@navios/di 0.2.0 → 0.3.0

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'

package/src/decorators/injectable.decorator.mts

@@ -8,21 +8,17 @@ import type {
   ClassTypeWithInstanceAndArgument,
   ClassTypeWithInstanceAndOptionalArgument,
   ClassTypeWithOptionalArgument,
-  InjectionTokenSchemaType,
   OptionalInjectionTokenSchemaType,
 } from '../injection-token.mjs'
-import type { Factory, FactoryWithArgs } 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 { resolveService } from '../resolve-service.mjs'
 import { InjectableTokenMeta } from '../symbols/index.mjs'
 
 export interface InjectableOptions {
   scope?: InjectableScope
-  type?: InjectableType
   token?: InjectionToken<any, any>
   registry?: Registry
 }
@@ -32,23 +28,16 @@ export function Injectable(): <T extends ClassType>(
   context?: ClassDecoratorContext,
 ) => T
 export function Injectable(options: {
+  scope?: InjectableScope
   registry: Registry
 }): <T extends ClassType>(target: T, context?: ClassDecoratorContext) => T
-
-// #2 Factory without arguments
-export function Injectable<R>(options: {
-  scope?: InjectableScope
-  type: InjectableType.Factory
-  registry?: Registry
-}): <T extends ClassTypeWithInstance<Factory<R>>>(
-  target: T,
-  context?: ClassDecoratorContext,
-) => T
+export function Injectable(options: {
+  scope: InjectableScope
+}): <T extends ClassType>(target: T, context?: ClassDecoratorContext) => T
 
 // #3 Class with typeless token and schema
 export function Injectable<Type, Schema>(options: {
   scope?: InjectableScope
-  type?: InjectableType.Class
   token: InjectionToken<Type, Schema>
   registry?: Registry
 }): Schema extends BaseInjectionTokenSchemaType // #3.1 Check that schema is an object or a record
@@ -84,28 +73,8 @@ export function Injectable<Type, Schema>(options: {
         ) => R
       : never // #3.4 Cannot use a token without a type and schema
 
-// #4 Factory with typed token
-export function Injectable<R, S>(options: {
-  scope?: InjectableScope
-  type: InjectableType.Factory
-  token: InjectionToken<R, S>
-  registry?: Registry
-}): R extends undefined // #4.1 Check that token has a type
-  ? never // #4.1.1 Token must have a type
-  : S extends InjectionTokenSchemaType // #4.2 Check that schema is an object or a record
-    ? <T extends ClassTypeWithInstance<FactoryWithArgs<R, S>>>( // #4.2.1 Token have a schema
-        target: T,
-        context?: ClassDecoratorContext,
-      ) => T
-    : S extends undefined // #4.3 For a factory without schema
-      ? <T extends ClassTypeWithInstance<Factory<R>>>( // #4.3.1 Token without a schema
-          target: T,
-          context?: ClassDecoratorContext,
-        ) => T
-      : never // #4.4 Cannot use a token without a type and schema
 export function Injectable({
   scope = InjectableScope.Singleton,
-  type = InjectableType.Class,
   token,
   registry = globalRegistry,
 }: InjectableOptions = {}) {
@@ -123,27 +92,8 @@ export function Injectable({
     }
     let injectableToken: InjectionToken<any, any> =
       token ?? InjectionToken.create(target)
-    if (type === InjectableType.Class) {
-      registry.set(
-        injectableToken,
-        async (ctx, args: any) => resolveService(ctx, target, [args]),
-        scope,
-      )
-    } else if (type === InjectableType.Factory) {
-      registry.set(
-        injectableToken,
-        async (ctx, args: any) => {
-          const builder = await resolveService(ctx, target)
-          if (typeof builder.create !== 'function') {
-            throw new Error(
-              `[ServiceLocator] Factory ${target.name} does not implement the create method.`,
-            )
-          }
-          return builder.create(ctx, args)
-        },
-        scope,
-      )
-    }
+
+    registry.set(injectableToken, scope, target, InjectableType.Class)
 
     // @ts-expect-error
     target[InjectableTokenMeta] = injectableToken

package/src/enums/injectable-scope.enum.mts

@@ -6,5 +6,9 @@ export enum InjectableScope {
   /**
    * Instance scope: A new instance is created for each injection.
    */
-  Instance = 'Instance',
+  Transient = 'Transient',
+  /**
+   * Request scope: The instance is created once per request and shared within that request context.
+   */
+  Request = 'Request',
 }

package/src/event-emitter.mts

@@ -1,11 +1,17 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 /* eslint-disable @typescript-eslint/no-empty-object-type */
 /* eslint-disable @typescript-eslint/no-unsafe-function-type */
+
+import { Injectable, InjectableScope } from './index.mjs'
+
 /* eslint-disable @typescript-eslint/no-explicit-any */
 export type EventsConfig = {
   [event: string]: any[]
 }
-export type EventsNames<Events extends EventsConfig> = Exclude<keyof Events, symbol | number>
+export type EventsNames<Events extends EventsConfig> = Exclude<
+  keyof Events,
+  symbol | number
+>
 export type EventsArgs<
   Events extends EventsConfig,
   Name extends EventsNames<Events>,
@@ -16,7 +22,11 @@ export type ChannelEmitter<
   Ns extends string,
   E extends EventsNames<Events>,
 > = {
-  emit<Args extends EventsArgs<Events, E>>(ns: Ns, event: E, ...args: Args): Promise<any>
+  emit<Args extends EventsArgs<Events, E>>(
+    ns: Ns,
+    event: E,
+    ...args: Args
+  ): Promise<any>
 }
 
 export interface EventEmitterInterface<Events extends EventsConfig> {
@@ -28,17 +38,9 @@ export interface EventEmitterInterface<Events extends EventsConfig> {
     event: E,
     ...args: Args
   ): void
-  addChannel<
-    E extends EventsNames<Events>,
-    Ns extends string,
-    Emmiter extends ChannelEmitter<Events, Ns, E>,
-  >(
-    ns: Ns,
-    event: E,
-    target: Emmiter,
-  ): () => void
 }
 
+@Injectable({ scope: InjectableScope.Transient })
 export class EventEmitter<Events extends EventsConfig = {}>
   implements EventEmitterInterface<Events>
 {
@@ -94,14 +96,10 @@ export class EventEmitter<Events extends EventsConfig = {}>
       return
     }
 
-    return Promise.all(Array.from(this.listeners.get(event)!).map(listener => listener(...args)))
-  }
-
-  addChannel<
-    E extends EventsNames<Events>,
-    Ns extends string,
-    Emitter extends ChannelEmitter<Events, Ns, E>,
-  >(ns: Ns, event: E, target: Emitter) {
-    return this.on(event, (...args) => target.emit(ns, event, ...args))
+    return Promise.all(
+      Array.from(this.listeners.get(event)!).map((listener) =>
+        listener(...args),
+      ),
+    )
   }
 }

package/src/factory-context.mts

@@ -1,16 +1,8 @@
-/* eslint-disable @typescript-eslint/no-empty-object-type */
-import type { ServiceLocatorEventBus } from './service-locator-event-bus.mjs'
 import type { ServiceLocator } from './service-locator.mjs'
 import type { Injectors } from './utils/index.mjs'
 
 export interface FactoryContext {
-  inject: Injectors['inject']
-  on: ServiceLocatorEventBus['on']
-  getDependencies: () => string[]
-  invalidate: () => void
-  addEffect: (listener: () => void) => void
-  getDestroyListeners: () => (() => void)[]
-  setTtl: (ttl: number) => void
-  getTtl: () => number
+  inject: Injectors['asyncInject']
   locator: ServiceLocator
+  addDestroyListener: (listener: () => void) => void
 }

package/src/index.mts

@@ -7,11 +7,12 @@ export * from './event-emitter.mjs'
 export * from './factory-context.mjs'
 export * from './injection-token.mjs'
 export * from './injector.mjs'
-export * from './proxy-service-locator.mjs'
 export * from './registry.mjs'
-export * from './resolve-service.mjs'
+export * from './service-instantiator.mjs'
 export * from './service-locator.mjs'
 export * from './service-locator-event-bus.mjs'
 export * from './service-locator-instance-holder.mjs'
 export * from './service-locator-manager.mjs'
+export * from './request-context-holder.mjs'
 export * from './symbols/injectable-token.mjs'
+export * from './container.mjs'

package/src/injection-token.mts

@@ -1,5 +1,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 ClassTypeWithArgument<Arg> = new (arg: Arg) => any
 export type ClassTypeWithOptionalArgument<Arg> = new (arg?: Arg) => any
@@ -10,10 +12,10 @@ export type ClassTypeWithInstanceAndOptionalArgument<T, Arg> = new (
   arg?: Arg,
 ) => T
 
-export type BaseInjectionTokenSchemaType = ZodObject<any> | ZodRecord
+export type BaseInjectionTokenSchemaType = ZodObject | ZodRecord
 
 export type OptionalInjectionTokenSchemaType =
-  | ZodOptional<ZodObject<any>>
+  | ZodOptional<ZodObject>
   | ZodOptional<ZodRecord>
 
 export type InjectionTokenSchemaType =
@@ -21,13 +23,15 @@ export type InjectionTokenSchemaType =
   | OptionalInjectionTokenSchemaType
 
 export class InjectionToken<
+  // oxlint-disable-next-line no-unused-vars
   T,
   S extends InjectionTokenSchemaType | unknown = unknown,
-  Required extends boolean = S extends ZodOptional<ZodObject<any>>
+  // oxlint-disable-next-line no-unused-vars
+  Required extends boolean = S extends ZodOptional<ZodObject>
     ? false
     : S extends ZodOptional<ZodRecord>
       ? false
-      : S extends ZodObject<any>
+      : S extends ZodObject
         ? true
         : S extends ZodRecord
           ? true
@@ -38,7 +42,7 @@ export class InjectionToken<
 
   constructor(
     public readonly name: string | symbol | ClassType,
-    public readonly schema: ZodObject<any> | undefined,
+    public readonly schema: ZodObject | undefined,
   ) {}
 
   static create<T extends ClassType>(
@@ -69,7 +73,7 @@ export class InjectionToken<
 
   static factory<T, S extends InjectionTokenSchemaType>(
     token: InjectionToken<T, S>,
-    factory: () => Promise<z.input<S>>,
+    factory: (ctx: FactoryContext) => Promise<z.input<S>>,
   ): FactoryInjectionToken<T, S> {
     return new FactoryInjectionToken(token, factory)
   }
@@ -126,16 +130,16 @@ export class FactoryInjectionToken<T, S extends InjectionTokenSchemaType> {
 
   constructor(
     public readonly token: InjectionToken<T, S>,
-    public readonly factory: () => Promise<z.input<S>>,
+    public readonly factory: (ctx: FactoryContext) => Promise<z.input<S>>,
   ) {
     this.name = token.name
     this.id = token.id
     this.schema = token.schema as InjectionTokenSchemaType
   }
 
-  async resolve(): Promise<z.input<S>> {
+  async resolve(ctx: FactoryContext): Promise<z.input<S>> {
     if (!this.value) {
-      this.value = await this.factory()
+      this.value = await this.factory(ctx)
       this.resolved = true
     }
     return this.value
@@ -145,3 +149,14 @@ export class FactoryInjectionToken<T, S extends InjectionTokenSchemaType> {
     return this.token.toString()
   }
 }
+
+export type AnyInjectableType =
+  | ClassType
+  | InjectionToken<any, any>
+  | BoundInjectionToken<any, any>
+  | FactoryInjectionToken<any, any>
+
+export type InjectionTokenType =
+  | InjectionToken<any, any>
+  | BoundInjectionToken<any, any>
+  | FactoryInjectionToken<any, any>

package/src/injector.mts

@@ -1,28 +1,16 @@
 import type { Injectors } from './utils/index.mjs'
 
-import { globalRegistry } from './registry.mjs'
-import { ServiceLocator } from './service-locator.mjs'
 import { getInjectors } from './utils/index.mjs'
 
-const globalServiceLocator: ServiceLocator = new ServiceLocator(globalRegistry)
+export const defaultInjectors = getInjectors()
 
-export function getGlobalServiceLocator(): ServiceLocator {
-  if (!globalServiceLocator) {
-    throw new Error(
-      '[ServiceLocator] Service locator is not initialized. Please provide the service locator before using the @Injectable decorator.',
-    )
-  }
-  return globalServiceLocator
-}
-const values = getInjectors({
-  baseLocator: globalServiceLocator,
-})
+export const asyncInject: Injectors['asyncInject'] =
+  defaultInjectors.asyncInject
 
-export const inject: Injectors['inject'] = values.inject
+export const inject: Injectors['inject'] = defaultInjectors.inject
 
-export const syncInject: Injectors['syncInject'] = values.syncInject
+export const wrapSyncInit: Injectors['wrapSyncInit'] =
+  defaultInjectors.wrapSyncInit
 
-export const wrapSyncInit: Injectors['wrapSyncInit'] = values.wrapSyncInit
-
-export const provideServiceLocator: Injectors['provideServiceLocator'] =
-  values.provideServiceLocator
+export const provideFactoryContext: Injectors['provideFactoryContext'] =
+  defaultInjectors.provideFactoryContext

package/src/interfaces/factory.interface.mts

@@ -3,10 +3,10 @@ import { z } from 'zod/v4'
 import type { FactoryContext } from '../factory-context.mjs'
 import type { InjectionTokenSchemaType } from '../injection-token.mjs'
 
-export interface Factory<T> {
+export interface Factorable<T> {
   create(ctx?: FactoryContext): Promise<T> | T
 }
 
-export interface FactoryWithArgs<T, A extends InjectionTokenSchemaType> {
-  create(...args: [FactoryContext, z.output<A>]): Promise<T> | T
+export interface FactorableWithArgs<T, A extends InjectionTokenSchemaType> {
+  create(ctx?: FactoryContext, ...args: [z.output<A>]): Promise<T> | T
 }

package/src/interfaces/index.mts

@@ -1 +1,3 @@
 export * from './factory.interface.mjs'
+export * from './on-service-init.interface.mjs'
+export * from './on-service-destroy.interface.mjs'

package/src/interfaces/on-service-destroy.interface.mts

@@ -0,0 +1,3 @@
+export interface OnServiceDestroy {
+  onServiceDestroy(): Promise<void> | void
+}

package/src/interfaces/on-service-init.interface.mts

@@ -0,0 +1,3 @@
+export interface OnServiceInit {
+  onServiceInit(): Promise<void> | void
+}

package/src/registry.mts

@@ -1,22 +1,12 @@
-import type { z, ZodObject } from 'zod/v4'
+import type { ClassType, InjectionToken } from './injection-token.mjs'
 
-import type { FactoryContext } from './factory-context.mjs'
-import type { InjectionToken } from './injection-token.mjs'
-
-import { InjectableScope } from './enums/index.mjs'
-
-export type InjectionFactory<T = unknown, Args = unknown> = (
-  ctx: FactoryContext,
-  args: Args,
-) => Promise<T>
+import { InjectableScope, InjectableType } from './enums/index.mjs'
 
 export type FactoryRecord<Instance = any, Schema = any> = {
   scope: InjectableScope
   originalToken: InjectionToken<Instance, Schema>
-  factory: InjectionFactory<
-    Instance,
-    Schema extends ZodObject<any> ? z.input<Schema> : unknown
-  >
+  target: ClassType
+  type: InjectableType
 }
 
 export class Registry {
@@ -49,10 +39,11 @@ export class Registry {
 
   set<Instance, Schema>(
     token: InjectionToken<Instance, Schema>,
-    factory: InjectionFactory,
     scope: InjectableScope,
+    target: ClassType,
+    type: InjectableType,
   ) {
-    this.factories.set(token.id, { factory, scope, originalToken: token })
+    this.factories.set(token.id, { scope, originalToken: token, target, type })
   }
 
   delete(token: InjectionToken<any, any>) {