@navios/di 0.8.0 → 0.9.1

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()
+})

package/src/__type-tests__/scoped-container.spec-d.mts

@@ -0,0 +1,212 @@
+import { assertType, describe, test } from 'vitest'
+import { z } from 'zod/v4'
+
+import type { Factorable } from '../interfaces/index.mjs'
+
+import { Container } from '../container/container.mjs'
+import { Factory, Injectable } from '../decorators/index.mjs'
+import { 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()
+
+const typelessObjectToken = InjectionToken.create(
+  Symbol.for('Typeless object token'),
+  simpleObjectSchema,
+)
+const typelessOptionalObjectToken = InjectionToken.create(
+  Symbol.for('Typeless optional object token'),
+  simpleOptionalObjectSchema,
+)
+
+const typedObjectToken = InjectionToken.create<
+  FooService,
+  typeof simpleObjectSchema
+>(Symbol.for('Typed object token'), simpleObjectSchema)
+const typedOptionalObjectToken = InjectionToken.create<
+  FooService,
+  typeof simpleOptionalObjectSchema
+>(Symbol.for('Typed optional object token'), simpleOptionalObjectSchema)
+
+const typedToken = InjectionToken.create<FooService>(Symbol.for('Typed token'))
+
+describe('ScopedContainer.get', () => {
+  describe('#1 Classes', () => {
+    test('simple class', async () => {
+      @Injectable()
+      class Foo {
+        makeFoo() {
+          return 'foo'
+        }
+      }
+
+      const container = new Container()
+      const scopedContainer = container.beginRequest('req-1')
+      assertType<Foo>(await scopedContainer.get(Foo))
+    })
+
+    test('class with required argument', async () => {
+      @Injectable({
+        schema: simpleObjectSchema,
+      })
+      class Foo {
+        constructor(public arg: z.infer<typeof simpleObjectSchema>) {}
+      }
+
+      const container = new Container()
+      const scopedContainer = container.beginRequest('req-1')
+      assertType<Foo>(await scopedContainer.get(Foo, { foo: 'bar' }))
+    })
+
+    test('should fail if not compatible', async () => {
+      @Injectable({
+        schema: simpleObjectSchema,
+      })
+      class Foo {
+        constructor(public arg: z.infer<typeof simpleObjectSchema>) {}
+      }
+
+      const container = new Container()
+      const scopedContainer = container.beginRequest('req-1')
+      // @ts-expect-error Should fail if not compatible
+      await scopedContainer.get(Foo, { test: 'bar' })
+    })
+
+    test('factory class returns unwrapped type', async () => {
+      @Factory()
+      class FooFactory implements Factorable<string> {
+        create() {
+          return 'created'
+        }
+      }
+
+      const container = new Container()
+      const scopedContainer = container.beginRequest('req-1')
+      // When getting a Factorable class, we get the created type, not the factory
+      assertType<string>(await scopedContainer.get(FooFactory))
+    })
+  })
+
+  test('#2 Token with required Schema', async () => {
+    const container = new Container()
+    const scopedContainer = container.beginRequest('req-1')
+
+    const result = await scopedContainer.get(typelessObjectToken, {
+      foo: 'bar',
+    })
+    assertType<unknown>(result)
+
+    const result2 = await scopedContainer.get(typedObjectToken, { foo: 'bar' })
+    assertType<FooService>(result2)
+
+    // @ts-expect-error We show error when we pass the wrong type
+    await scopedContainer.get(typedObjectToken, undefined)
+  })
+
+  test('#3 Token with optional Schema', async () => {
+    const container = new Container()
+    const scopedContainer = container.beginRequest('req-1')
+
+    const result = await scopedContainer.get(typelessOptionalObjectToken)
+    assertType<unknown>(result)
+
+    const result2 = await scopedContainer.get(typedOptionalObjectToken)
+    assertType<FooService>(result2)
+
+    const result3 = await scopedContainer.get(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 container = new Container()
+    const scopedContainer = container.beginRequest('req-1')
+
+    const result = await scopedContainer.get(typedToken)
+    assertType<FooService>(result)
+  })
+
+  test('#5 BoundInjectionToken', async () => {
+    const container = new Container()
+    const scopedContainer = container.beginRequest('req-1')
+
+    const boundToken = InjectionToken.bound(typedObjectToken, { foo: 'bar' })
+    const result = await scopedContainer.get(boundToken)
+    assertType<FooService>(result)
+  })
+
+  test('#6 FactoryInjectionToken', async () => {
+    const container = new Container()
+    const scopedContainer = container.beginRequest('req-1')
+
+    const factoryToken = InjectionToken.factory(typedObjectToken, async () => ({
+      foo: 'bar',
+    }))
+    const result = await scopedContainer.get(factoryToken)
+    assertType<FooService>(result)
+  })
+})
+
+describe('ScopedContainer methods', () => {
+  test('getRequestId returns string', () => {
+    const container = new Container()
+    const scopedContainer = container.beginRequest('req-1')
+    assertType<string>(scopedContainer.getRequestId())
+  })
+
+  test('getParent returns Container', () => {
+    const container = new Container()
+    const scopedContainer = container.beginRequest('req-1')
+    assertType<Container>(scopedContainer.getParent())
+  })
+
+  test('getMetadata returns any', () => {
+    const container = new Container()
+    const scopedContainer = container.beginRequest('req-1', { userId: '123' })
+    // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+    assertType<any | undefined>(scopedContainer.getMetadata('userId'))
+  })
+
+  test('setMetadata accepts any value', () => {
+    const container = new Container()
+    const scopedContainer = container.beginRequest('req-1')
+    scopedContainer.setMetadata('userId', '123')
+    scopedContainer.setMetadata('count', 42)
+    scopedContainer.setMetadata('data', { nested: true })
+  })
+
+  test('dispose returns Promise<void>', async () => {
+    const container = new Container()
+    const scopedContainer = container.beginRequest('req-1')
+    assertType<Promise<void>>(scopedContainer.dispose())
+  })
+
+  test('endRequest returns Promise<void>', async () => {
+    const container = new Container()
+    const scopedContainer = container.beginRequest('req-1')
+    assertType<Promise<void>>(scopedContainer.endRequest())
+  })
+
+  test('invalidate returns Promise<void>', async () => {
+    const container = new Container()
+    const scopedContainer = container.beginRequest('req-1')
+    assertType<Promise<void>>(scopedContainer.invalidate({}))
+  })
+
+  test('requestId property is string', () => {
+    const container = new Container()
+    const scopedContainer = container.beginRequest('req-1')
+    assertType<string>(scopedContainer.requestId)
+  })
+})