@navios/di 0.2.1 → 0.3.1

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',
-          }
-        }
-      },
-    ),
-  )
 })

package/src/container.mts

@@ -0,0 +1,167 @@
+import type { z, ZodType } from 'zod/v4'
+
+import type {
+  BoundInjectionToken,
+  ClassType,
+  FactoryInjectionToken,
+  InjectionToken,
+  InjectionTokenSchemaType,
+} from './injection-token.mjs'
+import type { Factorable } from './interfaces/factory.interface.mjs'
+import type { Registry } from './registry.mjs'
+import type { RequestContextHolder } from './request-context-holder.mjs'
+import type { Injectors } from './utils/index.mjs'
+import type { Join, UnionToArray } from './utils/types.mjs'
+
+import { Injectable } from './decorators/injectable.decorator.mjs'
+import { InjectableScope, InjectableType } from './enums/index.mjs'
+import { defaultInjectors } from './injector.mjs'
+import { globalRegistry } from './registry.mjs'
+import { ServiceLocator } from './service-locator.mjs'
+import { getInjectableToken } from './utils/get-injectable-token.mjs'
+
+/**
+ * Container class that provides a simplified public API for dependency injection.
+ * It wraps a ServiceLocator instance and provides convenient methods for getting instances.
+ */
+@Injectable()
+export class Container {
+  private readonly serviceLocator: ServiceLocator
+
+  constructor(
+    registry: Registry = globalRegistry,
+    logger: Console | null = null,
+    injectors: Injectors = defaultInjectors,
+  ) {
+    this.serviceLocator = new ServiceLocator(registry, logger, injectors)
+    this.registerSelf()
+  }
+
+  private registerSelf() {
+    const token = getInjectableToken(Container)
+    const instanceName = this.serviceLocator.getInstanceIdentifier(token)
+    this.serviceLocator
+      .getManager()
+      .storeCreatedHolder(
+        instanceName,
+        this,
+        InjectableType.Class,
+        InjectableScope.Singleton,
+      )
+  }
+
+  /**
+   * Gets an instance from the container.
+   * This method has the same type signature as the inject method from get-injectors.mts
+   */
+  // #1 Simple class
+  get<T extends ClassType>(
+    token: T,
+  ): InstanceType<T> extends Factorable<infer R>
+    ? Promise<R>
+    : Promise<InstanceType<T>>
+  // #2 Token with required Schema
+  get<T, S extends InjectionTokenSchemaType>(
+    token: InjectionToken<T, S>,
+    args: z.input<S>,
+  ): Promise<T>
+  // #3 Token with optional Schema
+  get<T, S extends InjectionTokenSchemaType, R extends boolean>(
+    token: InjectionToken<T, S, R>,
+  ): R extends false
+    ? Promise<T>
+    : S extends ZodType<infer Type>
+      ? `Error: Your token requires args: ${Join<
+          UnionToArray<keyof Type>,
+          ', '
+        >}`
+      : 'Error: Your token requires args'
+  // #4 Token with no Schema
+  get<T>(token: InjectionToken<T, undefined>): Promise<T>
+  get<T>(token: BoundInjectionToken<T, any>): Promise<T>
+  get<T>(token: FactoryInjectionToken<T, any>): Promise<T>
+
+  async get(
+    token:
+      | ClassType
+      | InjectionToken<any>
+      | BoundInjectionToken<any, any>
+      | FactoryInjectionToken<any, any>,
+    args?: unknown,
+  ) {
+    return this.serviceLocator.getOrThrowInstance(token, args as any)
+  }
+
+  /**
+   * Gets the underlying ServiceLocator instance for advanced usage
+   */
+  getServiceLocator(): ServiceLocator {
+    return this.serviceLocator
+  }
+
+  /**
+   * 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
+    if (holder) {
+      await this.serviceLocator.invalidate(holder.name)
+    }
+  }
+
+  /**
+   * Waits for all pending operations to complete
+   */
+  async ready(): Promise<void> {
+    await this.serviceLocator.ready()
+  }
+
+  // ============================================================================
+  // REQUEST CONTEXT MANAGEMENT
+  // ============================================================================
+
+  /**
+   * Begins a new request context with the given parameters.
+   * @param requestId Unique identifier for this request
+   * @param metadata Optional metadata for the request
+   * @param priority Priority for resolution (higher = more priority)
+   * @returns The created request context holder
+   */
+  beginRequest(
+    requestId: string,
+    metadata?: Record<string, any>,
+    priority: number = 100,
+  ): RequestContextHolder {
+    return this.serviceLocator.beginRequest(requestId, metadata, priority)
+  }
+
+  /**
+   * Ends a request context and cleans up all associated instances.
+   * @param requestId The request ID to end
+   */
+  async endRequest(requestId: string): Promise<void> {
+    await this.serviceLocator.endRequest(requestId)
+  }
+
+  /**
+   * Gets the current request context.
+   * @returns The current request context holder or null
+   */
+  getCurrentRequestContext(): RequestContextHolder | null {
+    return this.serviceLocator.getCurrentRequestContext()
+  }
+
+  /**
+   * Sets the current request context.
+   * @param requestId The request ID to set as current
+   */
+  setCurrentRequestContext(requestId: string): void {
+    this.serviceLocator.setCurrentRequestContext(requestId)
+  }
+}

package/src/decorators/factory.decorator.mts

@@ -0,0 +1,79 @@
+import type {
+  ClassTypeWithInstance,
+  InjectionTokenSchemaType,
+} from '../injection-token.mjs'
+import type { Factorable, FactorableWithArgs } from '../interfaces/index.mjs'
+import type { Registry } from '../registry.mjs'
+
+import { InjectableScope, InjectableType } from '../enums/index.mjs'
+import { InjectionToken } from '../injection-token.mjs'
+import { globalRegistry } from '../registry.mjs'
+import { InjectableTokenMeta } from '../symbols/index.mjs'
+
+export interface FactoryOptions {
+  scope?: InjectableScope
+  token?: InjectionToken<any, any>
+  registry?: Registry
+}
+
+// #1 Factory without arguments
+export function Factory<R>(options?: {
+  scope?: InjectableScope
+  registry?: Registry
+}): <T extends ClassTypeWithInstance<Factorable<R>>>(
+  target: T,
+  context?: ClassDecoratorContext,
+) => T
+
+// #2 Factory with typed token
+export function Factory<R, S>(options: {
+  scope?: InjectableScope
+  token: InjectionToken<R, S>
+  registry?: Registry
+}): R extends undefined // #2.1 Check that token has a type
+  ? never // #2.1.1 Token must have a type
+  : S extends InjectionTokenSchemaType // #2.2 Check that schema is an object or a record
+    ? <T extends ClassTypeWithInstance<FactorableWithArgs<R, S>>>( // #2.2.1 Token have a schema
+        target: T,
+        context?: ClassDecoratorContext,
+      ) => T
+    : S extends undefined // #2.3 For a factory without schema
+      ? <T extends ClassTypeWithInstance<Factorable<R>>>( // #2.3.1 Token without a schema
+          target: T,
+          context?: ClassDecoratorContext,
+        ) => T
+      : never // #2.4 Cannot use a token without a type and schema
+
+export function Factory({
+  scope = InjectableScope.Singleton,
+  token,
+  registry = globalRegistry,
+}: FactoryOptions = {}) {
+  return <
+    T extends ClassTypeWithInstance<
+      Factorable<any> | FactorableWithArgs<any, any>
+    >,
+  >(
+    target: T,
+    context?: ClassDecoratorContext,
+  ): T => {
+    if (
+      (context && context.kind !== 'class') ||
+      (target instanceof Function && !context)
+    ) {
+      throw new Error(
+        '[ServiceLocator] @Factory decorator can only be used on classes.',
+      )
+    }
+
+    let injectableToken: InjectionToken<any, any> =
+      token ?? InjectionToken.create(target)
+
+    registry.set(injectableToken, scope, target, InjectableType.Factory)
+
+    // @ts-expect-error
+    target[InjectableTokenMeta] = injectableToken
+
+    return target
+  }
+}

package/src/decorators/index.mts

@@ -1 +1,2 @@
+export * from './factory.decorator.mjs'
 export * from './injectable.decorator.mjs'