@navios/di 0.4.2 → 0.5.1

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

@@ -57,15 +57,38 @@ const typedOptionalObjectToken = InjectionToken.create<
 const typedToken = InjectionToken.create<FooService>(Symbol.for('Typed token'))
 
 describe('inject', () => {
-  test('#1 Classes', async () => {
-    @Injectable()
-    class Foo {
-      makeFoo() {
-        return 'foo'
+  describe('#1 Classes', () => {
+    test('simple class', async () => {
+      @Injectable()
+      class Foo {
+        makeFoo() {
+          return 'foo'
+        }
       }
-    }
 
-    assertType<Foo>(await asyncInject(Foo))
+      assertType<Foo>(await asyncInject(Foo))
+    })
+    test('class with required argument', async () => {
+      @Injectable({
+        schema: simpleObjectSchema,
+      })
+      class Foo {
+        constructor(public arg: z.infer<typeof simpleObjectSchema>) {}
+      }
+
+      assertType<Foo>(await asyncInject(Foo, { foo: 'bar' }))
+    })
+    test('should fail if not compatible', async () => {
+      @Injectable({
+        schema: simpleObjectSchema,
+      })
+      class Foo {
+        constructor(public arg: z.infer<typeof simpleObjectSchema>) {}
+      }
+
+      // @ts-expect-error Should fail if not compatible
+      await asyncInject(Foo, { test: 'bar' })
+    })
   })
   test('#2 Token with required Schema', async () => {
     const result = await asyncInject(typelessObjectToken, { foo: 'bar' })

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

@@ -1,3 +1,4 @@
+// oxlint-disable no-unused-vars
 import { expectTypeOf, test } from 'vitest'
 import { z } from 'zod/v4'
 
@@ -16,6 +17,14 @@ const simpleOptionalObjectSchema = z
     foo: z.string(),
   })
   .optional()
+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()
 
@@ -61,8 +70,52 @@ test('Injectable types', () => {
     @Injectable()
     class {},
   ).toBeConstructibleWith()
+  // #1 Injectable w/o decorators enabled in project
+  expectTypeOf(
+    Injectable({
+      token: typedObjectToken,
+    })(
+      class {
+        constructor() {}
+        makeFoo() {
+          return 'foo'
+        }
+      },
+    ),
+  ).toBeConstructibleWith()
 
   // #2 required argument
+  expectTypeOf(
+    @Injectable({
+      schema: simpleObjectSchema,
+    })
+    class {
+      constructor(public arg: z.infer<typeof simpleObjectSchema>) {}
+    },
+  ).toBeConstructibleWith({
+    foo: 'something',
+  })
+  // #2 it's required in schema but optional in class allowed
+  expectTypeOf(
+    @Injectable({
+      schema: simpleObjectSchema,
+    })
+    class {
+      constructor(public arg?: z.infer<typeof simpleObjectSchema>) {}
+    },
+  ).toBeConstructibleWith({
+    foo: 'something',
+  })
+  // #2 should fail if not compatible
+  // @ts-expect-error Should fail if not compatible
+  @Injectable({
+    schema: simpleObjectSchema,
+  })
+  class FailWithOtherSchema {
+    constructor(public arg: z.infer<typeof otherObjectSchema>) {}
+  }
+
+  // #3 required argument
   expectTypeOf(
     @Injectable({
       token: typelessObjectToken,
@@ -73,7 +126,7 @@ test('Injectable types', () => {
   ).toBeConstructibleWith({
     foo: 'something',
   })
-  // #2 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,
@@ -84,7 +137,7 @@ test('Injectable types', () => {
   ).toBeConstructibleWith({
     foo: 'something',
   })
-  // #2 optional value but class accepts it
+  // #3 optional value but class accepts it
   expectTypeOf(
     @Injectable({
       token: typelessOptionalObjectToken,
@@ -95,7 +148,7 @@ test('Injectable types', () => {
   ).toBeConstructibleWith({
     foo: 'something',
   })
-  // #2 optional value and class accepts it
+  // #3 optional value and class accepts it
   expectTypeOf(
     @Injectable({
       token: typelessOptionalObjectToken,
@@ -104,7 +157,7 @@ test('Injectable types', () => {
       constructor(public arg: z.infer<typeof simpleOptionalObjectSchema>) {}
     },
   ).toBeConstructibleWith(undefined)
-  // #2 compatible schemas
+  // #3 compatible schemas
   expectTypeOf(
     @Injectable({
       token: typelessOptionalObjectToken,
@@ -113,7 +166,7 @@ test('Injectable types', () => {
       constructor(public arg?: z.infer<typeof simpleObjectSchema>) {}
     },
   ).toBeConstructibleWith(undefined)
-  // #2 compatible schemas
+  // #3 compatible schemas
   expectTypeOf(
     // @ts-expect-error token has optional schema, but Class has required, should fail
     @Injectable({
@@ -126,7 +179,7 @@ test('Injectable types', () => {
     foo: 'something',
   })
 
-  // #2 typed token and required argument
+  // #3 typed token and required argument
   expectTypeOf(
     @Injectable({
       token: typedObjectToken,
@@ -141,7 +194,7 @@ test('Injectable types', () => {
   ).toBeConstructibleWith({
     foo: 'something',
   })
-  // #2 typed token and required argument
+  // #3 typed token and required argument
   expectTypeOf(
     @Injectable({
       token: typedOptionalObjectToken,
@@ -156,7 +209,7 @@ test('Injectable types', () => {
   ).toBeConstructibleWith({
     foo: 'something',
   })
-  // #2 should fail if not compatible
+  // #3 should fail if not compatible
   expectTypeOf(
     // @ts-expect-error class doesn't implement the token type
     @Injectable({
@@ -168,7 +221,7 @@ test('Injectable types', () => {
   ).toBeConstructibleWith({
     foo: 'something',
   })
-  // #2 should fail if not compatible
+  // #3 should fail if not compatible
   expectTypeOf(
     // @ts-expect-error class doesn't implement the token type
     @Injectable({
@@ -184,7 +237,7 @@ test('Injectable types', () => {
   ).toBeConstructibleWith({
     foo: 'something',
   })
-  // #2 typed token without schema
+  // #3 typed token without schema
   expectTypeOf(
     @Injectable({
       token: typedToken,
@@ -196,7 +249,7 @@ test('Injectable types', () => {
       }
     },
   ).toBeConstructibleWith()
-  // #2 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({
@@ -207,21 +260,7 @@ test('Injectable types', () => {
     },
   ).toBeConstructibleWith()
 
-  // #1 Injectable w/o decorators enabled in project
-  expectTypeOf(
-    Injectable({
-      token: typedObjectToken,
-    })(
-      class {
-        constructor() {}
-        makeFoo() {
-          return 'foo'
-        }
-      },
-    ),
-  ).toBeConstructibleWith()
-
-  // #2 required argument
+  // #3 required argument
   expectTypeOf(
     Injectable({
       token: typelessObjectToken,
@@ -233,7 +272,7 @@ test('Injectable types', () => {
   ).toBeConstructibleWith({
     foo: 'something',
   })
-  // #2 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,
@@ -245,7 +284,7 @@ test('Injectable types', () => {
   ).toBeConstructibleWith({
     foo: 'something',
   })
-  // #2 optional value but class accepts it
+  // #3 optional value but class accepts it
   expectTypeOf(
     Injectable({
       token: typelessOptionalObjectToken,
@@ -257,7 +296,7 @@ test('Injectable types', () => {
   ).toBeConstructibleWith({
     foo: 'something',
   })
-  // #2 optional value and class accepts it
+  // #3 optional value and class accepts it
   expectTypeOf(
     Injectable({
       token: typelessOptionalObjectToken,
@@ -267,7 +306,7 @@ test('Injectable types', () => {
       },
     ),
   ).toBeConstructibleWith(undefined)
-  // #2 compatible schemas
+  // #3 compatible schemas
   expectTypeOf(
     Injectable({
       token: typelessOptionalObjectToken,
@@ -277,7 +316,7 @@ test('Injectable types', () => {
       },
     ),
   ).toBeConstructibleWith(undefined)
-  // #2 compatible schemas
+  // #3 compatible schemas
   expectTypeOf(
     Injectable({
       token: typelessOptionalObjectToken,
@@ -291,7 +330,7 @@ test('Injectable types', () => {
     foo: 'something',
   })
 
-  // #2 typed token and required argument
+  // #3 typed token and required argument
   expectTypeOf(
     Injectable({
       token: typedObjectToken,
@@ -307,7 +346,7 @@ test('Injectable types', () => {
   ).toBeConstructibleWith({
     foo: 'something',
   })
-  // #2 typed token and required argument
+  // #3 typed token and required argument
   expectTypeOf(
     Injectable({
       token: typedOptionalObjectToken,
@@ -323,7 +362,7 @@ test('Injectable types', () => {
   ).toBeConstructibleWith({
     foo: 'something',
   })
-  // #2 should fail if not compatible
+  // #3 should fail if not compatible
   expectTypeOf(
     Injectable({
       token: typedOptionalObjectToken,
@@ -336,7 +375,7 @@ test('Injectable types', () => {
   ).toBeConstructibleWith({
     foo: 'something',
   })
-  // #2 should fail if not compatible
+  // #3 should fail if not compatible
   expectTypeOf(
     Injectable({
       token: typedOptionalObjectToken,
@@ -353,7 +392,7 @@ test('Injectable types', () => {
   ).toBeConstructibleWith({
     foo: 'something',
   })
-  // #2 typed token without schema
+  // #3 typed token without schema
   expectTypeOf(
     Injectable({
       token: typedToken,
@@ -366,7 +405,7 @@ test('Injectable types', () => {
       },
     ),
   ).toBeConstructibleWith()
-  // #2 typed token without schema fail if not compatible
+  // #3 typed token without schema fail if not compatible
   expectTypeOf(
     Injectable({
       token: typedToken,

package/src/base-instance-holder-manager.mts

@@ -2,7 +2,6 @@ import type { ServiceLocatorInstanceHolder } from './service-locator-instance-ho
 
 import { InjectableScope, InjectableType } from './enums/index.mjs'
 import { ServiceLocatorInstanceHolderStatus } from './service-locator-instance-holder.mjs'
-import { createDeferred } from './utils/defer.mjs'
 
 /**
  * Abstract base class that provides common functionality for managing ServiceLocatorInstanceHolder objects.
@@ -84,7 +83,6 @@ export abstract class BaseInstanceHolderManager {
    * @param type The injectable type
    * @param scope The injectable scope
    * @param deps Optional set of dependencies
-   * @param ttl Optional time-to-live in milliseconds (defaults to Infinity)
    * @returns A tuple containing the deferred promise and the holder
    */
   createCreatingHolder<Instance>(
@@ -92,12 +90,11 @@ export abstract class BaseInstanceHolderManager {
     type: InjectableType,
     scope: InjectableScope,
     deps: Set<string> = new Set(),
-    ttl: number = Infinity,
   ): [
-    ReturnType<typeof createDeferred<[undefined, Instance]>>,
+    ReturnType<typeof Promise.withResolvers<[undefined, Instance]>>,
     ServiceLocatorInstanceHolder<Instance>,
   ] {
-    const deferred = createDeferred<[undefined, Instance]>()
+    const deferred = Promise.withResolvers<[undefined, Instance]>()
 
     const holder: ServiceLocatorInstanceHolder<Instance> = {
       status: ServiceLocatorInstanceHolderStatus.Creating,
@@ -110,7 +107,6 @@ export abstract class BaseInstanceHolderManager {
       deps,
       destroyListeners: [],
       createdAt: Date.now(),
-      ttl,
     }
 
     return [deferred, holder]
@@ -124,7 +120,6 @@ export abstract class BaseInstanceHolderManager {
    * @param type The injectable type
    * @param scope The injectable scope
    * @param deps Optional set of dependencies
-   * @param ttl Optional time-to-live in milliseconds (defaults to Infinity)
    * @returns The created holder
    */
   protected createCreatedHolder<Instance>(
@@ -133,7 +128,6 @@ export abstract class BaseInstanceHolderManager {
     type: InjectableType,
     scope: InjectableScope,
     deps: Set<string> = new Set(),
-    ttl: number = Infinity,
   ): ServiceLocatorInstanceHolder<Instance> {
     const holder: ServiceLocatorInstanceHolder<Instance> = {
       status: ServiceLocatorInstanceHolderStatus.Created,
@@ -146,7 +140,6 @@ export abstract class BaseInstanceHolderManager {
       deps,
       destroyListeners: [],
       createdAt: Date.now(),
-      ttl,
     }
 
     return holder

package/src/container.mts

@@ -10,6 +10,7 @@ import type {
 import type { Factorable } from './interfaces/factory.interface.mjs'
 import type { Registry } from './registry.mjs'
 import type { RequestContextHolder } from './request-context-holder.mjs'
+import type { ServiceLocatorInstanceHolder } from './service-locator-instance-holder.mjs'
 import type { Injectors } from './utils/index.mjs'
 import type { Join, UnionToArray } from './utils/types.mjs'
 
@@ -103,16 +104,67 @@ export class Container {
    * Invalidates a service and its dependencies
    */
   async invalidate(service: unknown): Promise<void> {
-    const holderMap = this.serviceLocator
-      .getManager()
-      .filter((holder) => holder.instance === service)
-    if (holderMap.size === 0) {
-      return
-    }
-    const holder = holderMap.values().next().value
+    const holder = this.getHolderByInstance(service)
     if (holder) {
       await this.serviceLocator.invalidate(holder.name)
+    } else {
+      const requestHolder = this.getRequestHolderByInstance(service)
+      if (requestHolder) {
+        await this.serviceLocator.invalidate(requestHolder.name)
+      }
+    }
+  }
+
+  /**
+   * Gets a service holder by instance (reverse lookup)
+   */
+  private getHolderByInstance(
+    instance: unknown,
+  ): ServiceLocatorInstanceHolder | null {
+    const holderMap = Array.from(
+      this.serviceLocator
+        .getManager()
+        .filter((holder) => holder.instance === instance)
+        .values(),
+    )
+
+    return holderMap.length > 0 ? holderMap[0] : null
+  }
+
+  private getRequestHolderByInstance(
+    instance: unknown,
+  ): ServiceLocatorInstanceHolder | null {
+    const requestContexts = this.serviceLocator
+      .getRequestContextManager()
+      .getRequestContexts()
+    if (requestContexts) {
+      for (const requestContext of requestContexts.values()) {
+        for (const holder of requestContext.holders.values()) {
+          if (holder.instance === instance) {
+            return holder
+          }
+        }
+      }
     }
+    return null
+  }
+
+  /**
+   * Checks if a service is registered in the container
+   */
+  isRegistered(token: any): boolean {
+    try {
+      return this.serviceLocator.getInstanceIdentifier(token) !== null
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * Disposes the container and cleans up all resources
+   */
+  async dispose(): Promise<void> {
+    await this.serviceLocator.clearAll()
   }
 
   /**
@@ -169,7 +221,7 @@ export class Container {
    * Clears all instances and bindings from the container.
    * This is useful for testing or resetting the container state.
    */
-  clear(): void {
-    this.serviceLocator.getManager().clear()
+  clear(): Promise<void> {
+    return this.serviceLocator.clearAll()
   }
 }

package/src/decorators/injectable.decorator.mts

@@ -1,4 +1,4 @@
-import { z } from 'zod/v4'
+import { z, ZodObject } from 'zod/v4'
 
 import type {
   BaseInjectionTokenSchemaType,
@@ -8,6 +8,8 @@ import type {
   ClassTypeWithInstanceAndArgument,
   ClassTypeWithInstanceAndOptionalArgument,
   ClassTypeWithOptionalArgument,
+  ClassTypeWithoutArguments,
+  InjectionTokenSchemaType,
   OptionalInjectionTokenSchemaType,
 } from '../injection-token.mjs'
 import type { Registry } from '../registry.mjs'
@@ -20,20 +22,36 @@ import { InjectableTokenMeta } from '../symbols/index.mjs'
 export interface InjectableOptions {
   scope?: InjectableScope
   token?: InjectionToken<any, any>
+  schema?: InjectionTokenSchemaType
   registry?: Registry
 }
 // #1 Simple constructorless class
-export function Injectable(): <T extends ClassType>(
+export function Injectable(): <T extends ClassTypeWithoutArguments>(
   target: T,
   context?: ClassDecoratorContext,
 ) => T
 export function Injectable(options: {
   scope?: InjectableScope
   registry: Registry
-}): <T extends ClassType>(target: T, context?: ClassDecoratorContext) => T
+}): <T extends ClassTypeWithoutArguments>(
+  target: T,
+  context?: ClassDecoratorContext,
+) => T
 export function Injectable(options: {
   scope: InjectableScope
-}): <T extends ClassType>(target: T, context?: ClassDecoratorContext) => T
+}): <T extends ClassTypeWithoutArguments>(
+  target: T,
+  context?: ClassDecoratorContext,
+) => T
+// #2 Class with schema
+export function Injectable<Schema extends InjectionTokenSchemaType>(options: {
+  scope?: InjectableScope
+  schema: Schema
+  registry?: Registry
+}): <T extends ClassTypeWithArgument<z.output<Schema>>>(
+  target: T,
+  context?: ClassDecoratorContext,
+) => T
 
 // #3 Class with typeless token and schema
 export function Injectable<Type, Schema>(options: {
@@ -76,6 +94,7 @@ export function Injectable<Type, Schema>(options: {
 export function Injectable({
   scope = InjectableScope.Singleton,
   token,
+  schema,
   registry = globalRegistry,
 }: InjectableOptions = {}) {
   return <T extends ClassType>(
@@ -90,8 +109,13 @@ export function Injectable({
         '[ServiceLocator] @Injectable decorator can only be used on classes.',
       )
     }
+    if (schema && token) {
+      throw new Error(
+        '[ServiceLocator] @Injectable decorator cannot have both a token and a schema',
+      )
+    }
     let injectableToken: InjectionToken<any, any> =
-      token ?? InjectionToken.create(target)
+      token ?? InjectionToken.create(target, schema as InjectionTokenSchemaType)
 
     registry.set(injectableToken, scope, target, InjectableType.Class)
 

package/src/errors/di-error.mts

@@ -0,0 +1,69 @@
+export enum DIErrorCode {
+  FactoryNotFound = 'FactoryNotFound',
+  FactoryTokenNotResolved = 'FactoryTokenNotResolved',
+  InstanceNotFound = 'InstanceNotFound',
+  InstanceDestroying = 'InstanceDestroying',
+  UnknownError = 'UnknownError',
+}
+
+export class DIError extends Error {
+  public readonly code: DIErrorCode
+  public readonly context?: Record<string, unknown>
+
+  constructor(
+    code: DIErrorCode,
+    message: string,
+    context?: Record<string, unknown>,
+  ) {
+    super(message)
+    this.name = 'DIError'
+    this.code = code
+    this.context = context
+  }
+
+  // Static factory methods for common error types
+  static factoryNotFound(name: string): DIError {
+    return new DIError(
+      DIErrorCode.FactoryNotFound,
+      `Factory ${name} not found`,
+      { name },
+    )
+  }
+
+  static factoryTokenNotResolved(token: string | symbol | unknown): DIError {
+    return new DIError(
+      DIErrorCode.FactoryTokenNotResolved,
+      `Factory token not resolved: ${token?.toString() ?? 'unknown'}`,
+      { token },
+    )
+  }
+
+  static instanceNotFound(name: string): DIError {
+    return new DIError(
+      DIErrorCode.InstanceNotFound,
+      `Instance ${name} not found`,
+      { name },
+    )
+  }
+
+  static instanceDestroying(name: string): DIError {
+    return new DIError(
+      DIErrorCode.InstanceDestroying,
+      `Instance ${name} destroying`,
+      { name },
+    )
+  }
+
+  static unknown(
+    message: string | Error,
+    context?: Record<string, unknown>,
+  ): DIError {
+    if (message instanceof Error) {
+      return new DIError(DIErrorCode.UnknownError, message.message, {
+        ...context,
+        parent: message,
+      })
+    }
+    return new DIError(DIErrorCode.UnknownError, message, context)
+  }
+}

package/src/errors/index.mts

@@ -1,7 +1,9 @@
-export * from './errors.enum.mjs'
-export * from './factory-not-found.mjs'
-export * from './factory-token-not-resolved.mjs'
-export * from './instance-destroying.mjs'
-export * from './instance-expired.mjs'
-export * from './instance-not-found.mjs'
-export * from './unknown-error.mjs'
+export * from './di-error.mjs'
+
+// Legacy exports for backward compatibility (deprecated)
+export { DIError as FactoryNotFound } from './di-error.mjs'
+export { DIError as FactoryTokenNotResolved } from './di-error.mjs'
+export { DIError as InstanceDestroying } from './di-error.mjs'
+export { DIError as InstanceNotFound } from './di-error.mjs'
+export { DIError as UnknownError } from './di-error.mjs'
+export { DIErrorCode as ErrorsEnum } from './di-error.mjs'

package/src/injection-token.mts

@@ -3,6 +3,7 @@ import type { z, ZodObject, ZodOptional, ZodRecord } from 'zod/v4'
 import type { FactoryContext } from './factory-context.mjs'
 
 export type ClassType = new (...args: any[]) => any
+export type ClassTypeWithoutArguments = new () => any
 export type ClassTypeWithArgument<Arg> = new (arg: Arg) => any
 export type ClassTypeWithOptionalArgument<Arg> = new (arg?: Arg) => any
 

package/src/injector.mts

@@ -9,6 +9,8 @@ export const asyncInject: Injectors['asyncInject'] =
 
 export const inject: Injectors['inject'] = defaultInjectors.inject
 
+export const optional: Injectors['optional'] = defaultInjectors.optional
+
 export const wrapSyncInit: Injectors['wrapSyncInit'] =
   defaultInjectors.wrapSyncInit