@navios/di 0.2.1 → 0.3.1

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
@@ -21,8 +23,10 @@ export type InjectionTokenSchemaType =
   | OptionalInjectionTokenSchemaType
 
 export class InjectionToken<
+  // oxlint-disable-next-line no-unused-vars
   T,
   S extends InjectionTokenSchemaType | unknown = unknown,
+  // oxlint-disable-next-line no-unused-vars
   Required extends boolean = S extends ZodOptional<ZodObject>
     ? false
     : S extends ZodOptional<ZodRecord>
@@ -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 ? 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>) {

package/src/request-context-holder.mts

@@ -0,0 +1,174 @@
+import type { ServiceLocatorInstanceHolder } from './service-locator-instance-holder.mjs'
+
+import { InjectableScope, InjectableType } from './enums/index.mjs'
+import { InjectionToken } from './injection-token.mjs'
+import { ServiceLocatorInstanceHolderStatus } from './service-locator-instance-holder.mjs'
+
+/**
+ * Request context holder that manages pre-prepared instances for a specific request.
+ * This allows for efficient instantiation of request-scoped services.
+ */
+export interface RequestContextHolder {
+  /**
+   * Unique identifier for this request context.
+   */
+  readonly requestId: string
+
+  /**
+   * Pre-prepared instances for this request, keyed by instance name.
+   */
+  readonly instances: Map<string, any>
+
+  /**
+   * Instance holders for request-scoped services.
+   */
+  readonly holders: Map<string, ServiceLocatorInstanceHolder>
+
+  /**
+   * Priority for resolution in FactoryContext.inject method.
+   * Higher values take precedence.
+   */
+  readonly priority: number
+
+  /**
+   * Request-specific metadata that can be used during instantiation.
+   */
+  readonly metadata: Map<string, any>
+
+  /**
+   * Timestamp when this context was created.
+   */
+  readonly createdAt: number
+
+  /**
+   * Adds a pre-prepared instance to this context.
+   */
+  addInstance(
+    instanceName: string,
+    instance: any,
+    holder: ServiceLocatorInstanceHolder,
+  ): void
+
+  /**
+   * Adds a pre-prepared instance to this context.
+   */
+  addInstance(token: InjectionToken<any, undefined>, instance: any): void
+
+  /**
+   * Gets a pre-prepared instance from this context.
+   */
+  getInstance(instanceName: string): any | undefined
+
+  /**
+   * Gets an instance holder from this context.
+   */
+  getHolder(instanceName: string): ServiceLocatorInstanceHolder | undefined
+
+  /**
+   * Checks if this context has a pre-prepared instance.
+   */
+  hasInstance(instanceName: string): boolean
+
+  /**
+   * Clears all instances and holders from this context.
+   */
+  clear(): void
+
+  /**
+   * Gets metadata value by key.
+   */
+  getMetadata(key: string): any | undefined
+
+  /**
+   * Sets metadata value by key.
+   */
+  setMetadata(key: string, value: any): void
+}
+
+/**
+ * Default implementation of RequestContextHolder.
+ */
+export class DefaultRequestContextHolder implements RequestContextHolder {
+  public readonly instances = new Map<string, any>()
+  public readonly holders = new Map<string, ServiceLocatorInstanceHolder>()
+  public readonly metadata = new Map<string, any>()
+  public readonly createdAt = Date.now()
+
+  constructor(
+    public readonly requestId: string,
+    public readonly priority: number = 100,
+    initialMetadata?: Record<string, any>,
+  ) {
+    if (initialMetadata) {
+      Object.entries(initialMetadata).forEach(([key, value]) => {
+        this.metadata.set(key, value)
+      })
+    }
+  }
+
+  addInstance(
+    instanceName: string | InjectionToken<any, undefined>,
+    instance: any,
+    holder?: ServiceLocatorInstanceHolder,
+  ): void {
+    if (instanceName instanceof InjectionToken) {
+      this.instances.set(instanceName.toString(), instance)
+      this.holders.set(instanceName.toString(), {
+        instance,
+        status: ServiceLocatorInstanceHolderStatus.Created,
+        creationPromise: null,
+        destroyPromise: null,
+        destroyListeners: [],
+        deps: new Set(),
+        name: instanceName.toString(),
+        type: InjectableType.Class,
+        scope: InjectableScope.Singleton,
+        createdAt: Date.now(),
+        ttl: Infinity,
+      })
+    } else {
+      if (!holder) {
+        throw new Error('Holder is required when adding an instance by name')
+      }
+      this.instances.set(instanceName, instance)
+      this.holders.set(instanceName, holder)
+    }
+  }
+
+  getInstance(instanceName: string): any | undefined {
+    return this.instances.get(instanceName)
+  }
+
+  getHolder(instanceName: string): ServiceLocatorInstanceHolder | undefined {
+    return this.holders.get(instanceName)
+  }
+
+  hasInstance(instanceName: string): boolean {
+    return this.instances.has(instanceName)
+  }
+
+  clear(): void {
+    this.instances.clear()
+    this.holders.clear()
+    this.metadata.clear()
+  }
+
+  getMetadata(key: string): any | undefined {
+    return this.metadata.get(key)
+  }
+
+  setMetadata(key: string, value: any): void {
+    this.metadata.set(key, value)
+  }
+}
+
+/**
+ * Creates a new request context holder with the given parameters.
+ */
+export function createRequestContextHolder(
+  requestId: string,
+  priority: number = 100,
+  initialMetadata?: Record<string, any>,
+): RequestContextHolder {
+  return new DefaultRequestContextHolder(requestId, priority, initialMetadata)
+}