@navios/di 0.7.1 → 0.9.0

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

@@ -3,7 +3,7 @@ import { z } from 'zod/v4'
 
 import { Injectable } from '../decorators/index.mjs'
 import { InjectionToken } from '../token/injection-token.mjs'
-import { asyncInject } from '../injectors.mjs'
+import { asyncInject, inject, optional } from '../utils/default-injectors.mjs'
 
 interface FooService {
   makeFoo(): string
@@ -17,8 +17,6 @@ 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 typelessObjectToken = InjectionToken.create(
   Symbol.for('Typeless object token'),
@@ -28,14 +26,6 @@ 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 typedObjectToken = InjectionToken.create<
   FooService,
@@ -45,18 +35,10 @@ 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 typedToken = InjectionToken.create<FooService>(Symbol.for('Typed token'))
 
-describe('inject', () => {
+describe('asyncInject', () => {
   describe('#1 Classes', () => {
     test('simple class', async () => {
       @Injectable()
@@ -68,6 +50,7 @@ describe('inject', () => {
 
       assertType<Foo>(await asyncInject(Foo))
     })
+
     test('class with required argument', async () => {
       @Injectable({
         schema: simpleObjectSchema,
@@ -78,6 +61,7 @@ describe('inject', () => {
 
       assertType<Foo>(await asyncInject(Foo, { foo: 'bar' }))
     })
+
     test('should fail if not compatible', async () => {
       @Injectable({
         schema: simpleObjectSchema,
@@ -90,6 +74,7 @@ describe('inject', () => {
       await asyncInject(Foo, { test: 'bar' })
     })
   })
+
   test('#2 Token with required Schema', async () => {
     const result = await asyncInject(typelessObjectToken, { foo: 'bar' })
     assertType<unknown>(result)
@@ -119,3 +104,113 @@ describe('inject', () => {
     assertType<FooService>(result)
   })
 })
+
+describe('inject (synchronous)', () => {
+  describe('#1 Classes', () => {
+    test('simple class', () => {
+      @Injectable()
+      class Foo {
+        makeFoo() {
+          return 'foo'
+        }
+      }
+
+      assertType<Foo>(inject(Foo))
+    })
+
+    test('class with required argument', () => {
+      @Injectable({
+        schema: simpleObjectSchema,
+      })
+      class Foo {
+        constructor(public arg: z.infer<typeof simpleObjectSchema>) {}
+      }
+
+      assertType<Foo>(inject(Foo, { foo: 'bar' }))
+    })
+
+    test('should fail if not compatible', () => {
+      @Injectable({
+        schema: simpleObjectSchema,
+      })
+      class Foo {
+        constructor(public arg: z.infer<typeof simpleObjectSchema>) {}
+      }
+
+      // @ts-expect-error Should fail if not compatible
+      inject(Foo, { test: 'bar' })
+    })
+  })
+
+  test('#2 Token with required Schema', () => {
+    const result = inject(typelessObjectToken, { foo: 'bar' })
+    assertType<unknown>(result)
+
+    const result2 = inject(typedObjectToken, { foo: 'bar' })
+    assertType<FooService>(result2)
+
+    // @ts-expect-error We show error when we pass the wrong type
+    inject(typedObjectToken, undefined)
+  })
+
+  test('#3 Token with optional Schema', () => {
+    const result = inject(typelessOptionalObjectToken)
+    assertType<unknown>(result)
+
+    const result2 = inject(typedOptionalObjectToken)
+    assertType<FooService>(result2)
+
+    const result3 = inject(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', () => {
+    const result = inject(typedToken)
+    assertType<FooService>(result)
+  })
+})
+
+describe('optional', () => {
+  describe('#1 Classes', () => {
+    test('simple class returns nullable type', () => {
+      @Injectable()
+      class Foo {
+        makeFoo() {
+          return 'foo'
+        }
+      }
+
+      assertType<Foo | null>(optional(Foo))
+    })
+
+    // Note: optional() does not have a class + args overload
+    // Classes with required args should use tokens instead
+  })
+
+  test('#2 Token with required Schema', () => {
+    const result = optional(typelessObjectToken, { foo: 'bar' })
+    assertType<unknown>(result)
+
+    const result2 = optional(typedObjectToken, { foo: 'bar' })
+    assertType<FooService | null>(result2)
+  })
+
+  test('#3 Token with optional Schema', () => {
+    const result = optional(typelessOptionalObjectToken)
+    assertType<unknown>(result)
+
+    const result2 = optional(typedOptionalObjectToken)
+    assertType<FooService | null>(result2)
+
+    const result3 = optional(typedObjectToken)
+    // Special case when we pass the token without args
+    assertType<'Error: Your token requires args: foo'>(result3)
+  })
+
+  test('#4 Token with no Schema', () => {
+    const result = optional(typedToken)
+    assertType<FooService | null>(result)
+  })
+})

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

@@ -3,7 +3,9 @@ import { expectTypeOf, test } from 'vitest'
 import { z } from 'zod/v4'
 
 import { Injectable } from '../decorators/index.mjs'
+import { InjectableScope } from '../enums/index.mjs'
 import { InjectionToken } from '../token/injection-token.mjs'
+import { Registry } from '../token/registry.mjs'
 
 interface FooService {
   makeFoo(): string
@@ -20,13 +22,6 @@ const simpleOptionalObjectSchema = z
 const otherObjectSchema = z.object({
   bar: z.string(),
 })
-const otherOptionalObjectSchema = z
-  .object({
-    bar: 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'),
@@ -36,14 +31,6 @@ 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 typedObjectToken = InjectionToken.create<
   FooService,
@@ -53,23 +40,29 @@ 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 typedToken = InjectionToken.create<FooService>(Symbol.for('Typed token'))
 
 test('Injectable types', () => {
-  // #1
+  // #1 Simple class without arguments
   expectTypeOf(
     @Injectable()
     class {},
   ).toBeConstructibleWith()
+
+  // #1 Injectable with scope
+  expectTypeOf(
+    @Injectable({ scope: InjectableScope.Transient })
+    class {},
+  ).toBeConstructibleWith()
+
+  // #1 Injectable with registry
+  const registry = new Registry()
+  expectTypeOf(
+    @Injectable({ registry })
+    class {},
+  ).toBeConstructibleWith()
+
   // #1 Injectable w/o decorators enabled in project
   expectTypeOf(
     Injectable({
@@ -84,7 +77,7 @@ test('Injectable types', () => {
     ),
   ).toBeConstructibleWith()
 
-  // #2 required argument
+  // #2 Class with schema - required argument
   expectTypeOf(
     @Injectable({
       schema: simpleObjectSchema,
@@ -95,7 +88,8 @@ test('Injectable types', () => {
   ).toBeConstructibleWith({
     foo: 'something',
   })
-  // #2 it's required in schema but optional in class allowed
+
+  // #2 It's required in schema but optional in class allowed
   expectTypeOf(
     @Injectable({
       schema: simpleObjectSchema,
@@ -106,7 +100,8 @@ test('Injectable types', () => {
   ).toBeConstructibleWith({
     foo: 'something',
   })
-  // #2 should fail if not compatible
+
+  // #2 Should fail if not compatible
   // @ts-expect-error Should fail if not compatible
   @Injectable({
     schema: simpleObjectSchema,
@@ -115,7 +110,7 @@ test('Injectable types', () => {
     constructor(public arg: z.infer<typeof otherObjectSchema>) {}
   }
 
-  // #3 required argument
+  // #3 Typeless token with required schema - required argument
   expectTypeOf(
     @Injectable({
       token: typelessObjectToken,
@@ -126,7 +121,8 @@ test('Injectable types', () => {
   ).toBeConstructibleWith({
     foo: 'something',
   })
-  // #3 it's required in token but optional in class allowed
+
+  // #3 It's required in token but optional in class allowed
   expectTypeOf(
     @Injectable({
       token: typelessObjectToken,
@@ -137,7 +133,8 @@ test('Injectable types', () => {
   ).toBeConstructibleWith({
     foo: 'something',
   })
-  // #3 optional value but class accepts it
+
+  // #3 Optional value but class accepts it
   expectTypeOf(
     @Injectable({
       token: typelessOptionalObjectToken,
@@ -148,7 +145,8 @@ test('Injectable types', () => {
   ).toBeConstructibleWith({
     foo: 'something',
   })
-  // #3 optional value and class accepts it
+
+  // #3 Optional value and class accepts undefined
   expectTypeOf(
     @Injectable({
       token: typelessOptionalObjectToken,
@@ -157,7 +155,8 @@ test('Injectable types', () => {
       constructor(public arg: z.infer<typeof simpleOptionalObjectSchema>) {}
     },
   ).toBeConstructibleWith(undefined)
-  // #3 compatible schemas
+
+  // #3 Compatible schemas
   expectTypeOf(
     @Injectable({
       token: typelessOptionalObjectToken,
@@ -166,7 +165,8 @@ test('Injectable types', () => {
       constructor(public arg?: z.infer<typeof simpleObjectSchema>) {}
     },
   ).toBeConstructibleWith(undefined)
-  // #3 compatible schemas
+
+  // #3 Token has optional schema, but Class has required, should fail
   expectTypeOf(
     // @ts-expect-error token has optional schema, but Class has required, should fail
     @Injectable({
@@ -179,7 +179,7 @@ test('Injectable types', () => {
     foo: 'something',
   })
 
-  // #3 typed token and required argument
+  // #3 Typed token with required schema - required argument
   expectTypeOf(
     @Injectable({
       token: typedObjectToken,
@@ -194,7 +194,8 @@ test('Injectable types', () => {
   ).toBeConstructibleWith({
     foo: 'something',
   })
-  // #3 typed token and required argument
+
+  // #3 Typed token with optional schema
   expectTypeOf(
     @Injectable({
       token: typedOptionalObjectToken,
@@ -209,7 +210,8 @@ test('Injectable types', () => {
   ).toBeConstructibleWith({
     foo: 'something',
   })
-  // #3 should fail if not compatible
+
+  // #3 Should fail if class doesn't implement token type
   expectTypeOf(
     // @ts-expect-error class doesn't implement the token type
     @Injectable({
@@ -221,9 +223,10 @@ test('Injectable types', () => {
   ).toBeConstructibleWith({
     foo: 'something',
   })
-  // #3 should fail if not compatible
+
+  // #3 Should fail if return type doesn't match (returns undefined instead of string)
   expectTypeOf(
-    // @ts-expect-error class doesn't implement the token type
+    // @ts-expect-error class doesn't implement the token type (wrong return type)
     @Injectable({
       token: typedOptionalObjectToken,
     })
@@ -237,7 +240,8 @@ test('Injectable types', () => {
   ).toBeConstructibleWith({
     foo: 'something',
   })
-  // #3 typed token without schema
+
+  // #3 Typed token without schema
   expectTypeOf(
     @Injectable({
       token: typedToken,
@@ -249,7 +253,8 @@ test('Injectable types', () => {
       }
     },
   ).toBeConstructibleWith()
-  // #3 typed token without schema fail if not compatible
+
+  // #3 Typed token without schema - fail if not compatible
   expectTypeOf(
     // @ts-expect-error class doesn't implement the token type
     @Injectable({
@@ -260,7 +265,9 @@ test('Injectable types', () => {
     },
   ).toBeConstructibleWith()
 
-  // #3 required argument
+  // Function call syntax tests (without decorators)
+
+  // #3 Required argument
   expectTypeOf(
     Injectable({
       token: typelessObjectToken,
@@ -272,7 +279,8 @@ test('Injectable types', () => {
   ).toBeConstructibleWith({
     foo: 'something',
   })
-  // #3 it's required in token but optional in class allowed
+
+  // #3 It's required in token but optional in class allowed
   expectTypeOf(
     Injectable({
       token: typelessObjectToken,
@@ -284,7 +292,8 @@ test('Injectable types', () => {
   ).toBeConstructibleWith({
     foo: 'something',
   })
-  // #3 optional value but class accepts it
+
+  // #3 Optional value but class accepts it
   expectTypeOf(
     Injectable({
       token: typelessOptionalObjectToken,
@@ -296,7 +305,8 @@ test('Injectable types', () => {
   ).toBeConstructibleWith({
     foo: 'something',
   })
-  // #3 optional value and class accepts it
+
+  // #3 Optional value and class accepts undefined
   expectTypeOf(
     Injectable({
       token: typelessOptionalObjectToken,
@@ -306,7 +316,8 @@ test('Injectable types', () => {
       },
     ),
   ).toBeConstructibleWith(undefined)
-  // #3 compatible schemas
+
+  // #3 Compatible schemas
   expectTypeOf(
     Injectable({
       token: typelessOptionalObjectToken,
@@ -316,7 +327,8 @@ test('Injectable types', () => {
       },
     ),
   ).toBeConstructibleWith(undefined)
-  // #3 compatible schemas
+
+  // #3 Token has optional schema, but Class has required, should fail
   expectTypeOf(
     Injectable({
       token: typelessOptionalObjectToken,
@@ -330,7 +342,7 @@ test('Injectable types', () => {
     foo: 'something',
   })
 
-  // #3 typed token and required argument
+  // #3 Typed token with required schema - required argument
   expectTypeOf(
     Injectable({
       token: typedObjectToken,
@@ -346,7 +358,8 @@ test('Injectable types', () => {
   ).toBeConstructibleWith({
     foo: 'something',
   })
-  // #3 typed token and required argument
+
+  // #3 Typed token with optional schema
   expectTypeOf(
     Injectable({
       token: typedOptionalObjectToken,
@@ -362,7 +375,8 @@ test('Injectable types', () => {
   ).toBeConstructibleWith({
     foo: 'something',
   })
-  // #3 should fail if not compatible
+
+  // #3 Should fail if class doesn't implement token type
   expectTypeOf(
     Injectable({
       token: typedOptionalObjectToken,
@@ -375,7 +389,8 @@ test('Injectable types', () => {
   ).toBeConstructibleWith({
     foo: 'something',
   })
-  // #3 should fail if not compatible
+
+  // #3 Should fail if return type doesn't match
   expectTypeOf(
     Injectable({
       token: typedOptionalObjectToken,
@@ -392,7 +407,8 @@ test('Injectable types', () => {
   ).toBeConstructibleWith({
     foo: 'something',
   })
-  // #3 typed token without schema
+
+  // #3 Typed token without schema
   expectTypeOf(
     Injectable({
       token: typedToken,
@@ -405,7 +421,8 @@ test('Injectable types', () => {
       },
     ),
   ).toBeConstructibleWith()
-  // #3 typed token without schema fail if not compatible
+
+  // #3 Typed token without schema - fail if not compatible
   expectTypeOf(
     Injectable({
       token: typedToken,

package/src/__type-tests__/injection-token.spec-d.mts

@@ -0,0 +1,176 @@
+import { expectTypeOf, test } from 'vitest'
+import { z } from 'zod/v4'
+
+import {
+  BoundInjectionToken,
+  FactoryInjectionToken,
+  InjectionToken,
+} from '../token/injection-token.mjs'
+
+interface FooService {
+  makeFoo(): string
+}
+
+const simpleObjectSchema = z.object({
+  foo: z.string(),
+})
+const simpleOptionalObjectSchema = z
+  .object({
+    foo: z.string(),
+  })
+  .optional()
+
+test('InjectionToken.create with class', () => {
+  class MyService {
+    getValue() {
+      return 42
+    }
+  }
+
+  const token = InjectionToken.create(MyService)
+  expectTypeOf(token).toMatchTypeOf<InjectionToken<MyService, undefined>>()
+})
+
+test('InjectionToken.create with class and schema', () => {
+  class MyService {
+    constructor(public config: z.infer<typeof simpleObjectSchema>) {}
+    getValue() {
+      return 42
+    }
+  }
+
+  const token = InjectionToken.create(MyService, simpleObjectSchema)
+  expectTypeOf(token).toMatchTypeOf<
+    InjectionToken<MyService, typeof simpleObjectSchema, true>
+  >()
+})
+
+test('InjectionToken.create with class and optional schema', () => {
+  class MyService {
+    constructor(public config?: z.infer<typeof simpleOptionalObjectSchema>) {}
+    getValue() {
+      return 42
+    }
+  }
+
+  const token = InjectionToken.create(MyService, simpleOptionalObjectSchema)
+  expectTypeOf(token).toMatchTypeOf<
+    InjectionToken<MyService, typeof simpleOptionalObjectSchema, false>
+  >()
+})
+
+test('InjectionToken.create with string name', () => {
+  const token = InjectionToken.create<FooService>('FooService')
+  expectTypeOf(token).toMatchTypeOf<InjectionToken<FooService, undefined>>()
+})
+
+test('InjectionToken.create with symbol name', () => {
+  const token = InjectionToken.create<FooService>(Symbol.for('FooService'))
+  expectTypeOf(token).toMatchTypeOf<InjectionToken<FooService, undefined>>()
+})
+
+test('InjectionToken.create with string name and schema', () => {
+  const token = InjectionToken.create<FooService, typeof simpleObjectSchema>(
+    'FooService',
+    simpleObjectSchema,
+  )
+  expectTypeOf(token).toMatchTypeOf<
+    InjectionToken<FooService, typeof simpleObjectSchema>
+  >()
+})
+
+test('InjectionToken.bound creates BoundInjectionToken', () => {
+  const token = InjectionToken.create<FooService, typeof simpleObjectSchema>(
+    'FooService',
+    simpleObjectSchema,
+  )
+  const boundToken = InjectionToken.bound(token, { foo: 'bar' })
+  expectTypeOf(boundToken).toMatchTypeOf<
+    BoundInjectionToken<FooService, typeof simpleObjectSchema>
+  >()
+})
+
+test('InjectionToken.bound requires correct argument type', () => {
+  const token = InjectionToken.create<FooService, typeof simpleObjectSchema>(
+    'FooService',
+    simpleObjectSchema,
+  )
+
+  // @ts-expect-error Should fail with wrong argument type
+  InjectionToken.bound(token, { wrong: 'key' })
+
+  // @ts-expect-error Should fail with missing required property
+  InjectionToken.bound(token, {})
+})
+
+test('InjectionToken.factory creates FactoryInjectionToken', () => {
+  const token = InjectionToken.create<FooService, typeof simpleObjectSchema>(
+    'FooService',
+    simpleObjectSchema,
+  )
+  const factoryToken = InjectionToken.factory(token, async () => ({
+    foo: 'bar',
+  }))
+  expectTypeOf(factoryToken).toMatchTypeOf<
+    FactoryInjectionToken<FooService, typeof simpleObjectSchema>
+  >()
+})
+
+test('InjectionToken.factory requires correct return type', () => {
+  const token = InjectionToken.create<FooService, typeof simpleObjectSchema>(
+    'FooService',
+    simpleObjectSchema,
+  )
+
+  // @ts-expect-error Should fail with wrong return type
+  InjectionToken.factory(token, async () => ({ wrong: 'key' }))
+})
+
+test('InjectionToken.refineType changes BoundInjectionToken type', () => {
+  interface RefinedService {
+    doSomething(): void
+  }
+
+  const token = InjectionToken.create<unknown, typeof simpleObjectSchema>(
+    'Service',
+    simpleObjectSchema,
+  )
+  const boundToken = InjectionToken.bound(token, { foo: 'bar' })
+  const refinedToken = InjectionToken.refineType<RefinedService>(boundToken)
+  expectTypeOf(refinedToken).toMatchTypeOf<
+    BoundInjectionToken<RefinedService, any>
+  >()
+})
+
+test('BoundInjectionToken has value property with correct type', () => {
+  const token = InjectionToken.create<FooService, typeof simpleObjectSchema>(
+    'FooService',
+    simpleObjectSchema,
+  )
+  const boundToken = InjectionToken.bound(token, { foo: 'bar' })
+
+  expectTypeOf(boundToken.value).toMatchTypeOf<{ foo: string }>()
+})
+
+test('FactoryInjectionToken has factory property', () => {
+  const token = InjectionToken.create<FooService, typeof simpleObjectSchema>(
+    'FooService',
+    simpleObjectSchema,
+  )
+  const factoryToken = InjectionToken.factory(token, async () => ({
+    foo: 'bar',
+  }))
+
+  expectTypeOf(factoryToken.factory).toBeFunction()
+})
+
+test('InjectionToken properties', () => {
+  const token = InjectionToken.create<FooService, typeof simpleObjectSchema>(
+    'FooService',
+    simpleObjectSchema,
+  )
+
+  expectTypeOf(token.id).toBeString()
+  expectTypeOf(token.name).toMatchTypeOf<string | symbol | (new (...args: any[]) => any)>()
+  expectTypeOf(token.toString()).toBeString()
+})