@navios/di 0.2.1 → 0.3.0

package/src/__type-tests__/factory.spec-d.mts

@@ -0,0 +1,65 @@
+import { z } from 'zod/v4'
+
+import type { Factorable, FactorableWithArgs } from '../interfaces/index.mjs'
+
+import { Factory } from '../decorators/index.mjs'
+import { InjectableScope } from '../enums/index.mjs'
+import { InjectionToken } from '../injection-token.mjs'
+import { Registry } from '../registry.mjs'
+
+// Test factory without arguments
+@Factory()
+class TestFactory1 implements Factorable<string> {
+  create() {
+    return 'test'
+  }
+}
+
+// Test factory with scope
+@Factory({ scope: InjectableScope.Transient })
+class TestFactory2 implements Factorable<number> {
+  create() {
+    return 42
+  }
+}
+
+// Test factory with token
+const token = InjectionToken.create('TestToken')
+@Factory({ token })
+class TestFactory3 implements Factorable<boolean> {
+  create() {
+    return true
+  }
+}
+
+// Test factory with token and schema
+const schema = z.object({ name: z.string() })
+const tokenWithSchema = InjectionToken.create('TestTokenWithSchema', schema)
+@Factory({ token: tokenWithSchema })
+class TestFactory4
+  implements FactorableWithArgs<{ name: string }, typeof schema>
+{
+  create(ctx: any, args: z.output<typeof schema>) {
+    return args
+  }
+}
+
+// Test factory with custom registry
+const registry = new Registry()
+@Factory({ registry })
+class TestFactory5 implements Factorable<object> {
+  create() {
+    return {}
+  }
+}
+
+// Type tests
+const test1: string = new TestFactory1().create()
+const test2: number = new TestFactory2().create()
+const test3: boolean = new TestFactory3().create()
+const test4: { name: string } = new TestFactory4().create(undefined, {
+  name: 'test',
+})
+const test5: object = new TestFactory5().create()
+
+export { test1, test2, test3, test4, test5 }

package/src/__type-tests__/inject.spec-d.mts

@@ -2,9 +2,8 @@ import { assertType, describe, test } from 'vitest'
 import { z } from 'zod/v4'
 
 import { Injectable } from '../decorators/index.mjs'
-import { InjectableType } from '../enums/index.mjs'
 import { InjectionToken } from '../injection-token.mjs'
-import { inject } from '../injector.mjs'
+import { asyncInject } from '../injector.mjs'
 
 interface FooService {
   makeFoo(): string
@@ -18,8 +17,8 @@ const simpleOptionalObjectSchema = z
     foo: z.string(),
   })
   .optional()
-const simpleRecordSchema = z.record(z.string(), z.string())
-const simpleOptionalRecordSchema = z.record(z.string(), z.string()).optional()
+// const simpleRecordSchema = z.record(z.string(), z.string())
+// const simpleOptionalRecordSchema = z.record(z.string(), z.string()).optional()
 
 const typelessObjectToken = InjectionToken.create(
   Symbol.for('Typeless object token'),
@@ -29,14 +28,14 @@ const typelessOptionalObjectToken = InjectionToken.create(
   Symbol.for('Typeless optional object token'),
   simpleOptionalObjectSchema,
 )
-const typelessRecordToken = InjectionToken.create(
-  Symbol.for('Typeless record token'),
-  simpleRecordSchema,
-)
-const typelessOptionalRecordToken = InjectionToken.create(
-  Symbol.for('Typeless optional record token'),
-  simpleOptionalRecordSchema,
-)
+// const typelessRecordToken = InjectionToken.create(
+//   Symbol.for('Typeless record token'),
+//   simpleRecordSchema,
+// )
+// const typelessOptionalRecordToken = InjectionToken.create(
+//   Symbol.for('Typeless optional record token'),
+//   simpleOptionalRecordSchema,
+// )
 
 const typedObjectToken = InjectionToken.create<
   FooService,
@@ -46,14 +45,14 @@ const typedOptionalObjectToken = InjectionToken.create<
   FooService,
   typeof simpleOptionalObjectSchema
 >(Symbol.for('Typed optional object token'), simpleOptionalObjectSchema)
-const typedRecordToken = InjectionToken.create<
-  FooService,
-  typeof simpleRecordSchema
->(Symbol.for('Typed record token'), simpleRecordSchema)
-const typedOptionalRecordToken = InjectionToken.create<
-  FooService,
-  typeof simpleOptionalRecordSchema
->(Symbol.for('Typed optional record token'), simpleOptionalRecordSchema)
+// const typedRecordToken = InjectionToken.create<
+//   FooService,
+//   typeof simpleRecordSchema
+// >(Symbol.for('Typed record token'), simpleRecordSchema)
+// const typedOptionalRecordToken = InjectionToken.create<
+//   FooService,
+//   typeof simpleOptionalRecordSchema
+// >(Symbol.for('Typed optional record token'), simpleOptionalRecordSchema)
 
 const typedToken = InjectionToken.create<FooService>(Symbol.for('Typed token'))
 
@@ -66,34 +65,34 @@ describe('inject', () => {
       }
     }
 
-    assertType<Foo>(await inject(Foo))
+    assertType<Foo>(await asyncInject(Foo))
   })
   test('#2 Token with required Schema', async () => {
-    const result = await inject(typelessObjectToken, { foo: 'bar' })
+    const result = await asyncInject(typelessObjectToken, { foo: 'bar' })
     assertType<unknown>(result)
 
-    const result2 = await inject(typedObjectToken, { foo: 'bar' })
+    const result2 = await asyncInject(typedObjectToken, { foo: 'bar' })
     assertType<FooService>(result2)
 
     // @ts-expect-error We show error when we pass the wrong type
-    await inject(typedObjectToken, undefined)
+    await asyncInject(typedObjectToken, undefined)
   })
 
   test('#3 Token with optional Schema', async () => {
-    const result = await inject(typelessOptionalObjectToken)
+    const result = await asyncInject(typelessOptionalObjectToken)
     assertType<unknown>(result)
 
-    const result2 = await inject(typedOptionalObjectToken)
+    const result2 = await asyncInject(typedOptionalObjectToken)
     assertType<FooService>(result2)
 
-    const result3 = await inject(typedObjectToken)
+    const result3 = await asyncInject(typedObjectToken)
     // Special case when we pass the token without args
     // We can only return an error string
     assertType<'Error: Your token requires args: foo'>(result3)
   })
 
   test('#4 Token with no Schema', async () => {
-    const result = await inject(typedToken)
+    const result = await asyncInject(typedToken)
     assertType<FooService>(result)
   })
 })

package/src/__type-tests__/injectable.spec-d.mts

@@ -2,7 +2,6 @@ import { expectTypeOf, test } from 'vitest'
 import { z } from 'zod/v4'
 
 import { Injectable } from '../decorators/index.mjs'
-import { InjectableType } from '../enums/index.mjs'
 import { InjectionToken } from '../injection-token.mjs'
 
 interface FooService {
@@ -17,8 +16,8 @@ const simpleOptionalObjectSchema = z
     foo: z.string(),
   })
   .optional()
-const simpleRecordSchema = z.record(z.string(), z.string())
-const simpleOptionalRecordSchema = z.record(z.string(), z.string()).optional()
+// const simpleRecordSchema = z.record(z.string(), z.string())
+// const simpleOptionalRecordSchema = z.record(z.string(), z.string()).optional()
 
 const typelessObjectToken = InjectionToken.create(
   Symbol.for('Typeless object token'),
@@ -28,14 +27,14 @@ const typelessOptionalObjectToken = InjectionToken.create(
   Symbol.for('Typeless optional object token'),
   simpleOptionalObjectSchema,
 )
-const typelessRecordToken = InjectionToken.create(
-  Symbol.for('Typeless record token'),
-  simpleRecordSchema,
-)
-const typelessOptionalRecordToken = InjectionToken.create(
-  Symbol.for('Typeless optional record token'),
-  simpleOptionalRecordSchema,
-)
+// const typelessRecordToken = InjectionToken.create(
+//   Symbol.for('Typeless record token'),
+//   simpleRecordSchema,
+// )
+// const typelessOptionalRecordToken = InjectionToken.create(
+//   Symbol.for('Typeless optional record token'),
+//   simpleOptionalRecordSchema,
+// )
 
 const typedObjectToken = InjectionToken.create<
   FooService,
@@ -45,14 +44,14 @@ const typedOptionalObjectToken = InjectionToken.create<
   FooService,
   typeof simpleOptionalObjectSchema
 >(Symbol.for('Typed optional object token'), simpleOptionalObjectSchema)
-const typedRecordToken = InjectionToken.create<
-  FooService,
-  typeof simpleRecordSchema
->(Symbol.for('Typed record token'), simpleRecordSchema)
-const typedOptionalRecordToken = InjectionToken.create<
-  FooService,
-  typeof simpleOptionalRecordSchema
->(Symbol.for('Typed optional record token'), simpleOptionalRecordSchema)
+// const typedRecordToken = InjectionToken.create<
+//   FooService,
+//   typeof simpleRecordSchema
+// >(Symbol.for('Typed record token'), simpleRecordSchema)
+// const typedOptionalRecordToken = InjectionToken.create<
+//   FooService,
+//   typeof simpleOptionalRecordSchema
+// >(Symbol.for('Typed optional record token'), simpleOptionalRecordSchema)
 
 const typedToken = InjectionToken.create<FooService>(Symbol.for('Typed token'))
 
@@ -62,24 +61,8 @@ test('Injectable types', () => {
     @Injectable()
     class {},
   ).toBeConstructibleWith()
-  // #2
-  expectTypeOf(
-    @Injectable({
-      type: InjectableType.Factory,
-    })
-    class {
-      create() {}
-    },
-  ).toBeConstructibleWith()
-  expectTypeOf(
-    // @ts-expect-error should check that the class implements the factory
-    @Injectable({
-      type: InjectableType.Factory,
-    })
-    class {},
-  ).toBeConstructibleWith()
 
-  // #3 required argument
+  // #2 required argument
   expectTypeOf(
     @Injectable({
       token: typelessObjectToken,
@@ -90,7 +73,7 @@ test('Injectable types', () => {
   ).toBeConstructibleWith({
     foo: 'something',
   })
-  // #3 it's required in token but optional in class allowed
+  // #2 it's required in token but optional in class allowed
   expectTypeOf(
     @Injectable({
       token: typelessObjectToken,
@@ -101,7 +84,7 @@ test('Injectable types', () => {
   ).toBeConstructibleWith({
     foo: 'something',
   })
-  // #3 optional value but class accepts it
+  // #2 optional value but class accepts it
   expectTypeOf(
     @Injectable({
       token: typelessOptionalObjectToken,
@@ -112,7 +95,7 @@ test('Injectable types', () => {
   ).toBeConstructibleWith({
     foo: 'something',
   })
-  // #3 optional value and class accepts it
+  // #2 optional value and class accepts it
   expectTypeOf(
     @Injectable({
       token: typelessOptionalObjectToken,
@@ -121,7 +104,7 @@ test('Injectable types', () => {
       constructor(public arg: z.infer<typeof simpleOptionalObjectSchema>) {}
     },
   ).toBeConstructibleWith(undefined)
-  // #3 compatible schemas
+  // #2 compatible schemas
   expectTypeOf(
     @Injectable({
       token: typelessOptionalObjectToken,
@@ -130,7 +113,7 @@ test('Injectable types', () => {
       constructor(public arg?: z.infer<typeof simpleObjectSchema>) {}
     },
   ).toBeConstructibleWith(undefined)
-  // #3 compatible schemas
+  // #2 compatible schemas
   expectTypeOf(
     // @ts-expect-error token has optional schema, but Class has required, should fail
     @Injectable({
@@ -143,7 +126,7 @@ test('Injectable types', () => {
     foo: 'something',
   })
 
-  // #3 typed token and required argument
+  // #2 typed token and required argument
   expectTypeOf(
     @Injectable({
       token: typedObjectToken,
@@ -158,7 +141,7 @@ test('Injectable types', () => {
   ).toBeConstructibleWith({
     foo: 'something',
   })
-  // #3 typed token and required argument
+  // #2 typed token and required argument
   expectTypeOf(
     @Injectable({
       token: typedOptionalObjectToken,
@@ -173,7 +156,7 @@ test('Injectable types', () => {
   ).toBeConstructibleWith({
     foo: 'something',
   })
-  // #3 should fail if not compatible
+  // #2 should fail if not compatible
   expectTypeOf(
     // @ts-expect-error class doesn't implement the token type
     @Injectable({
@@ -185,7 +168,7 @@ test('Injectable types', () => {
   ).toBeConstructibleWith({
     foo: 'something',
   })
-  // #3 should fail if not compatible
+  // #2 should fail if not compatible
   expectTypeOf(
     // @ts-expect-error class doesn't implement the token type
     @Injectable({
@@ -201,7 +184,7 @@ test('Injectable types', () => {
   ).toBeConstructibleWith({
     foo: 'something',
   })
-  // #3 typed token without schema
+  // #2 typed token without schema
   expectTypeOf(
     @Injectable({
       token: typedToken,
@@ -213,7 +196,7 @@ test('Injectable types', () => {
       }
     },
   ).toBeConstructibleWith()
-  // #3 typed token without schema fail if not compatible
+  // #2 typed token without schema fail if not compatible
   expectTypeOf(
     // @ts-expect-error class doesn't implement the token type
     @Injectable({
@@ -224,69 +207,6 @@ test('Injectable types', () => {
     },
   ).toBeConstructibleWith()
 
-  // #4 factory with typed token
-  expectTypeOf(
-    @Injectable({
-      type: InjectableType.Factory,
-      token: typedToken,
-    })
-    class {
-      constructor() {}
-      create() {
-        return {
-          makeFoo: () => 'foo',
-        }
-      }
-    },
-  ).toBeConstructibleWith()
-  // #4 factory with typed token without schema should fail if not compatible
-  expectTypeOf(
-    // @ts-expect-error factory doesn't implement the token type
-    @Injectable({
-      type: InjectableType.Factory,
-      token: typedToken,
-    })
-    class {
-      constructor() {}
-      create(ctx: any, arg: z.infer<typeof simpleObjectSchema>) {
-        return {
-          makeFoo: () => 'foo',
-        }
-      }
-    },
-  ).toBeConstructibleWith()
-  // #4 factory with typed token fail if not compatible
-  expectTypeOf(
-    // @ts-expect-error class doesn't implement the token type
-    @Injectable({
-      type: InjectableType.Factory,
-      token: typedToken,
-    })
-    class {
-      constructor() {}
-      create() {
-        return {
-          // makeFoo: () => 'foo',
-        }
-      }
-    },
-  ).toBeConstructibleWith()
-  // #4 factory with typed token and schema
-  expectTypeOf(
-    @Injectable({
-      type: InjectableType.Factory,
-      token: typedObjectToken,
-    })
-    class {
-      constructor() {}
-      create(ctx: any, arg: z.infer<typeof simpleObjectSchema>) {
-        return {
-          makeFoo: () => 'foo',
-        }
-      }
-    },
-  )
-
   // #1 Injectable w/o decorators enabled in project
   expectTypeOf(
     Injectable({
@@ -300,25 +220,8 @@ test('Injectable types', () => {
       },
     ),
   ).toBeConstructibleWith()
-  expectTypeOf(
-    Injectable({
-      type: InjectableType.Factory,
-    })(
-      class {
-        create() {}
-      },
-    ),
-  ).toBeConstructibleWith()
-  expectTypeOf(
-    Injectable({
-      type: InjectableType.Factory,
-    })(
-      // @ts-expect-error should check that the class implements the factory
-      class {},
-    ),
-  ).toBeConstructibleWith()
 
-  // #3 required argument
+  // #2 required argument
   expectTypeOf(
     Injectable({
       token: typelessObjectToken,
@@ -330,7 +233,7 @@ test('Injectable types', () => {
   ).toBeConstructibleWith({
     foo: 'something',
   })
-  // #3 it's required in token but optional in class allowed
+  // #2 it's required in token but optional in class allowed
   expectTypeOf(
     Injectable({
       token: typelessObjectToken,
@@ -342,7 +245,7 @@ test('Injectable types', () => {
   ).toBeConstructibleWith({
     foo: 'something',
   })
-  // #3 optional value but class accepts it
+  // #2 optional value but class accepts it
   expectTypeOf(
     Injectable({
       token: typelessOptionalObjectToken,
@@ -354,7 +257,7 @@ test('Injectable types', () => {
   ).toBeConstructibleWith({
     foo: 'something',
   })
-  // #3 optional value and class accepts it
+  // #2 optional value and class accepts it
   expectTypeOf(
     Injectable({
       token: typelessOptionalObjectToken,
@@ -364,7 +267,7 @@ test('Injectable types', () => {
       },
     ),
   ).toBeConstructibleWith(undefined)
-  // #3 compatible schemas
+  // #2 compatible schemas
   expectTypeOf(
     Injectable({
       token: typelessOptionalObjectToken,
@@ -374,7 +277,7 @@ test('Injectable types', () => {
       },
     ),
   ).toBeConstructibleWith(undefined)
-  // #3 compatible schemas
+  // #2 compatible schemas
   expectTypeOf(
     Injectable({
       token: typelessOptionalObjectToken,
@@ -388,7 +291,7 @@ test('Injectable types', () => {
     foo: 'something',
   })
 
-  // #3 typed token and required argument
+  // #2 typed token and required argument
   expectTypeOf(
     Injectable({
       token: typedObjectToken,
@@ -404,7 +307,7 @@ test('Injectable types', () => {
   ).toBeConstructibleWith({
     foo: 'something',
   })
-  // #3 typed token and required argument
+  // #2 typed token and required argument
   expectTypeOf(
     Injectable({
       token: typedOptionalObjectToken,
@@ -420,7 +323,7 @@ test('Injectable types', () => {
   ).toBeConstructibleWith({
     foo: 'something',
   })
-  // #3 should fail if not compatible
+  // #2 should fail if not compatible
   expectTypeOf(
     Injectable({
       token: typedOptionalObjectToken,
@@ -433,7 +336,7 @@ test('Injectable types', () => {
   ).toBeConstructibleWith({
     foo: 'something',
   })
-  // #3 should fail if not compatible
+  // #2 should fail if not compatible
   expectTypeOf(
     Injectable({
       token: typedOptionalObjectToken,
@@ -450,7 +353,7 @@ test('Injectable types', () => {
   ).toBeConstructibleWith({
     foo: 'something',
   })
-  // #3 typed token without schema
+  // #2 typed token without schema
   expectTypeOf(
     Injectable({
       token: typedToken,
@@ -463,82 +366,15 @@ test('Injectable types', () => {
       },
     ),
   ).toBeConstructibleWith()
-  // #3 typed token without schema fail if not compatible
-  expectTypeOf(
-    Injectable({
-      token: typedToken,
-    })(
-      // @ts-expect-error class doesn't implement the token type
-      class {
-        constructor() {}
-      },
-    ),
-  ).toBeConstructibleWith()
-
-  // #4 factory with typed token
-  expectTypeOf(
-    Injectable({
-      type: InjectableType.Factory,
-      token: typedToken,
-    })(
-      class {
-        constructor() {}
-        create() {
-          return {
-            makeFoo: () => 'foo',
-          }
-        }
-      },
-    ),
-  ).toBeConstructibleWith()
-  // #4 factory with typed token without schema should fail if not compatible
+  // #2 typed token without schema fail if not compatible
   expectTypeOf(
     Injectable({
-      type: InjectableType.Factory,
-      token: typedToken,
-    })(
-      // @ts-expect-error factory doesn't implement the token type
-      class {
-        constructor() {}
-        create(ctx: any, arg: z.infer<typeof simpleObjectSchema>) {
-          return {
-            makeFoo: () => 'foo',
-          }
-        }
-      },
-    ),
-  ).toBeConstructibleWith()
-  // #4 factory with typed token fail if not compatible
-  expectTypeOf(
-    Injectable({
-      type: InjectableType.Factory,
       token: typedToken,
     })(
       // @ts-expect-error class doesn't implement the token type
       class {
         constructor() {}
-        create() {
-          return {
-            // makeFoo: () => 'foo',
-          }
-        }
       },
     ),
   ).toBeConstructibleWith()
-  // #4 factory with typed token and schema
-  expectTypeOf(
-    Injectable({
-      type: InjectableType.Factory,
-      token: typedObjectToken,
-    })(
-      class {
-        constructor() {}
-        create(ctx: any, arg: z.infer<typeof simpleObjectSchema>) {
-          return {
-            makeFoo: () => 'foo',
-          }
-        }
-      },
-    ),
-  )
 })