🔧

packages/example-fastify/src/AppContext.ts

@@ -12,7 +12,8 @@ export type AppContext = {
 export async function createContext() {
   const database = await createDatabase()
 
-  const context = Container.register("db", () => database)
+  const context = Container.new()
+    .register("db", () => database)
     .instance("tasksCreator", TasksCreator)
     .instance("tasks", SQLiteTaskStore)
     .context<AppContext>()

packages/example-fastify/src/SQLiteTaskStore.ts

@@ -1,8 +1,12 @@
 import { TaskStore } from "./TaskStore"
 import { Task } from "./Task"
-import { Service } from "./Service"
+import { Service } from "nwire"
+import { AppContext } from "./AppContext"
 
-export class SQLiteTaskStore extends Service implements TaskStore {
+export class SQLiteTaskStore
+  extends Service<AppContext>()
+  implements TaskStore
+{
   async get(id: number): Promise<Task | null> {
     return (await this.db.get(`SELECT * FROM tasks WHERE id = ?`, [id])) ?? null
   }

packages/example-fastify/src/TasksCreator.ts

@@ -1,7 +1,7 @@
+import { Service } from "nwire"
 import { AppContext } from "./AppContext"
-import { Service } from "./Service"
 
-export class TasksCreator extends Service {
+export class TasksCreator extends Service<AppContext>() {
   async createBasicTasks() {
     await this.tasks.save("My first test")
     await this.tasks.save("My second test")

packages/example-fastify/src/createServer.test.ts

@@ -17,8 +17,7 @@ describe("server", function () {
   beforeEach(async (context) => {
     const database = await createDatabase()
 
-    const container = Container
-      //
+    const container = Container.new()
       .register("db", () => database)
       .instance("tasks", SQLiteTaskStore)
       .instance("tasksCreator", TasksCreator)

packages/example-hello-world/src/index.ts

@@ -1,17 +1,19 @@
-import { Container, Injected } from "nwire"
+import { Singleton } from "nwire"
+import { Container, Service } from "nwire"
 
-type MyTypedContext = {
+type MyContext = {
   banner: string
   my: MyService
 }
 
-export class MyService extends Injected<MyTypedContext> {
+export class MyService extends Service<MyContext>(Singleton) {
   helloWorld() {
-    return this._context.banner
+    return this.banner
   }
 }
 
-const context = Container.register("banner", () => "Hello world!")
+const context = Container.new()
+  .register("banner", () => "Hello world!")
   .instance("my", MyService)
   .context()
 

packages/nwire/README.md

@@ -12,9 +12,9 @@ type MyTypedContext = {
   my: MyService
 }
 
-export class MyService extends Injected<MyTypedContext> {
+export class MyService extends WithContextProperties(Singleton) {
   helloWorld() {
-    return this._context.banner
+    return this.banner
   }
 }
 
@@ -395,7 +395,7 @@ const user = await context.users.find("123")
 the `UsersService` calls `users.findOne`, `nwire` will **lazily** return an instance of
 `UserRepository`.
 
-> ⚠️ `nwire` contexts are not normal objects. `nwire` use a proxy under the hood to evaluate your dependencies as needed. This is an intentional design decision to avoid having to instantiate the entire `Container` for tests.
+> ⚠️ `nwire` contexts are not normal objects. `nwire` uses a proxy under the hood to evaluate your dependencies as needed. This is an intentional design decision to avoid having to instantiate the entire `Container` for tests.
 
 ## License
 

packages/nwire/dist/Container.d.ts

@@ -19,6 +19,7 @@ export declare class Container<TContext extends Context = {}> {
     private _cache;
     private _transient;
     private _base;
+    private _context;
     private _rootContainer;
     private _parentContainer;
     constructor(rootContainer?: Container, _parentContainer?: Container);

packages/nwire/dist/Singleton.d.ts

@@ -2,7 +2,7 @@ import { Context } from "./Container";
 type PopulatedSingleton<T> = T & {
     [key in keyof T]: T[key];
 };
-export declare function WithContextProperties<T extends Context>(Base: any): new (context: T) => PopulatedSingleton<T>;
+export declare function Service<T extends Context>(Base?: any): new (context: T) => PopulatedSingleton<T>;
 export declare class Singleton<TContext extends Context> {
     protected _context: TContext;
     constructor(context: TContext);