@navios/di 0.2.0 → 0.3.0

package/src/request-context-holder.mts

@@ -0,0 +1,145 @@
+import type { ServiceLocatorInstanceHolder } 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
+
+  /**
+   * 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,
+    instance: any,
+    holder: ServiceLocatorInstanceHolder,
+  ): void {
+    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)
+}

package/src/service-instantiator.mts

@@ -0,0 +1,158 @@
+import type { FactoryContext } from './factory-context.mjs'
+import type { FactoryRecord } from './registry.mjs'
+import type { Injectors } from './utils/get-injectors.mjs'
+
+import { InjectableType } from './enums/index.mjs'
+
+/**
+ * ServiceInstantiator handles the instantiation of services based on registry records.
+ * It replaces the hard-coded logic in Injectable and Factory decorators.
+ */
+export class ServiceInstantiator {
+  constructor(private readonly injectors: Injectors) {}
+
+  /**
+   * Instantiates a service based on its registry record.
+   * @param ctx The factory context for dependency injection
+   * @param record The factory record from the registry
+   * @param args Optional arguments for the service
+   * @returns Promise resolving to [undefined, instance] or [error]
+   */
+  async instantiateService<T>(
+    ctx: FactoryContext,
+    record: FactoryRecord<T, any>,
+    args: any = undefined,
+  ): Promise<[undefined, T] | [Error]> {
+    try {
+      switch (record.type) {
+        case InjectableType.Class:
+          return this.instantiateClass(ctx, record, args)
+        case InjectableType.Factory:
+          return this.instantiateFactory(ctx, record, args)
+        default:
+          throw new Error(
+            `[ServiceInstantiator] Unknown service type: ${record.type}`,
+          )
+      }
+    } catch (error) {
+      return [error instanceof Error ? error : new Error(String(error))]
+    }
+  }
+
+  /**
+   * Instantiates a class-based service (Injectable decorator).
+   * @param ctx The factory context for dependency injection
+   * @param record The factory record from the registry
+   * @param args Optional arguments for the service constructor
+   * @returns Promise resolving to [undefined, instance] or [error]
+   */
+  private async instantiateClass<T>(
+    ctx: FactoryContext,
+    record: FactoryRecord<T, any>,
+    args: any,
+  ): Promise<[undefined, T] | [Error]> {
+    try {
+      const tryLoad = this.injectors.wrapSyncInit(() => {
+        const original = this.injectors.provideFactoryContext(ctx)
+        let result = new record.target(...(args ? [args] : []))
+        this.injectors.provideFactoryContext(original)
+        return result
+      })
+
+      let [instance, promises, injectState] = tryLoad()
+      if (promises.length > 0) {
+        const results = await Promise.allSettled(promises)
+        if (results.some((result) => result.status === 'rejected')) {
+          throw new Error(
+            `[ServiceInstantiator] Service ${record.target.name} cannot be instantiated.`,
+          )
+        }
+        const newRes = tryLoad(injectState)
+        instance = newRes[0]
+        promises = newRes[1]
+      }
+
+      if (promises.length > 0) {
+        console.error(`[ServiceInstantiator] ${record.target.name} has problem with it's definition.
+
+       One or more of the dependencies are registered as a InjectableScope.Instance and are used with inject.
+
+       Please use inject asyncInject of inject to load those dependencies.`)
+        throw new Error(
+          `[ServiceInstantiator] Service ${record.target.name} cannot be instantiated.`,
+        )
+      }
+
+      // Handle lifecycle hooks
+      if ('onServiceInit' in instance) {
+        await (instance as any).onServiceInit()
+      }
+      if ('onServiceDestroy' in instance) {
+        ctx.addDestroyListener(async () => {
+          await (instance as any).onServiceDestroy()
+        })
+      }
+
+      return [undefined, instance]
+    } catch (error) {
+      return [error instanceof Error ? error : new Error(String(error))]
+    }
+  }
+
+  /**
+   * Instantiates a factory-based service (Factory decorator).
+   * @param ctx The factory context for dependency injection
+   * @param record The factory record from the registry
+   * @param args Optional arguments for the factory
+   * @returns Promise resolving to [undefined, instance] or [error]
+   */
+  private async instantiateFactory<T>(
+    ctx: FactoryContext,
+    record: FactoryRecord<T, any>,
+    args: any,
+  ): Promise<[undefined, T] | [Error]> {
+    try {
+      const tryLoad = this.injectors.wrapSyncInit(() => {
+        const original = this.injectors.provideFactoryContext(ctx)
+        let result = new record.target()
+        this.injectors.provideFactoryContext(original)
+        return result
+      })
+
+      let [builder, promises, injectState] = tryLoad()
+      if (promises.length > 0) {
+        const results = await Promise.allSettled(promises)
+        if (results.some((result) => result.status === 'rejected')) {
+          throw new Error(
+            `[ServiceInstantiator] Service ${record.target.name} cannot be instantiated.`,
+          )
+        }
+        const newRes = tryLoad(injectState)
+        builder = newRes[0]
+        promises = newRes[1]
+      }
+
+      if (promises.length > 0) {
+        console.error(`[ServiceInstantiator] ${record.target.name} has problem with it's definition.
+
+       One or more of the dependencies are registered as a InjectableScope.Instance and are used with inject.
+
+       Please use asyncInject instead of inject to load those dependencies.`)
+        throw new Error(
+          `[ServiceInstantiator] Service ${record.target.name} cannot be instantiated.`,
+        )
+      }
+
+      if (typeof builder.create !== 'function') {
+        throw new Error(
+          `[ServiceInstantiator] Factory ${record.target.name} does not implement the create method.`,
+        )
+      }
+
+      const instance = await builder.create(ctx, args)
+      return [undefined, instance]
+    } catch (error) {
+      return [error instanceof Error ? error : new Error(String(error))]
+    }
+  }
+}

package/src/service-locator-event-bus.mts

@@ -43,21 +43,6 @@ export class ServiceLocatorEventBus {
 
     const events = this.listeners.get(key)!
 
-    const preEvent = `pre:${event}`
-    const postEvent = `post:${event}`
-    this.logger?.debug(`[ServiceLocatorEventBus]#emit(): ${key}:${preEvent}`)
-    await Promise.allSettled(
-      [...(events.get(preEvent) ?? [])].map((listener) => listener(preEvent)),
-    ).then((results) => {
-      results
-        .filter((result) => result.status === 'rejected')
-        .forEach((result: PromiseRejectedResult) => {
-          this.logger?.warn(
-            `[ServiceLocatorEventBus]#emit(): ${key}:${preEvent} rejected with`,
-            result.reason,
-          )
-        })
-    })
     this.logger?.debug(`[ServiceLocatorEventBus]#emit(): ${key}:${event}`)
 
     const res = await Promise.allSettled(
@@ -78,19 +63,6 @@ export class ServiceLocatorEventBus {
       }
       return results
     })
-    this.logger?.debug(`[ServiceLocatorEventBus]#emit(): ${key}:${postEvent}`)
-    await Promise.allSettled(
-      [...(events.get(postEvent) ?? [])].map((listener) => listener(postEvent)),
-    ).then((results) => {
-      results
-        .filter((result) => result.status === 'rejected')
-        .forEach((result: PromiseRejectedResult) => {
-          this.logger?.warn(
-            `[ServiceLocatorEventBus]#emit(): ${key}:${postEvent} rejected with`,
-            result.reason,
-          )
-        })
-    })
     return res
   }
 }

package/src/service-locator-instance-holder.mts

@@ -1,15 +1,11 @@
-/* eslint-disable @typescript-eslint/no-empty-object-type */
-
-export enum ServiceLocatorInstanceHolderKind {
-  Instance = 'instance',
-  Factory = 'factory',
-  AbstractFactory = 'abstractFactory',
-}
+import type { InjectableScope, InjectableType } from './enums/index.mjs'
 
+/* eslint-disable @typescript-eslint/no-empty-object-type */
 export enum ServiceLocatorInstanceHolderStatus {
   Created = 'created',
   Creating = 'creating',
   Destroying = 'destroying',
+  Error = 'error',
 }
 
 export type ServiceLocatorInstanceEffect = () => void
@@ -21,9 +17,9 @@ export interface ServiceLocatorInstanceHolderCreating<Instance> {
   instance: null
   creationPromise: Promise<[undefined, Instance]> | null
   destroyPromise: null
-  kind: ServiceLocatorInstanceHolderKind
-  effects: ServiceLocatorInstanceEffect[]
-  deps: string[]
+  type: InjectableType
+  scope: InjectableScope
+  deps: Set<string>
   destroyListeners: ServiceLocatorInstanceDestroyListener[]
   createdAt: number
   ttl: number
@@ -35,9 +31,9 @@ export interface ServiceLocatorInstanceHolderCreated<Instance> {
   instance: Instance
   creationPromise: null
   destroyPromise: null
-  kind: ServiceLocatorInstanceHolderKind
-  effects: ServiceLocatorInstanceEffect[]
-  deps: string[]
+  type: InjectableType
+  scope: InjectableScope
+  deps: Set<string>
   destroyListeners: ServiceLocatorInstanceDestroyListener[]
   createdAt: number
   ttl: number
@@ -49,9 +45,23 @@ export interface ServiceLocatorInstanceHolderDestroying<Instance> {
   instance: Instance | null
   creationPromise: null
   destroyPromise: Promise<void>
-  kind: ServiceLocatorInstanceHolderKind
-  effects: ServiceLocatorInstanceEffect[]
-  deps: string[]
+  type: InjectableType
+  scope: InjectableScope
+  deps: Set<string>
+  destroyListeners: ServiceLocatorInstanceDestroyListener[]
+  createdAt: number
+  ttl: number
+}
+
+export interface ServiceLocatorInstanceHolderError {
+  status: ServiceLocatorInstanceHolderStatus.Error
+  name: string
+  instance: Error
+  creationPromise: null
+  destroyPromise: null
+  type: InjectableType
+  scope: InjectableScope
+  deps: Set<string>
   destroyListeners: ServiceLocatorInstanceDestroyListener[]
   createdAt: number
   ttl: number
@@ -61,3 +71,4 @@ export type ServiceLocatorInstanceHolder<Instance = unknown> =
   | ServiceLocatorInstanceHolderCreating<Instance>
   | ServiceLocatorInstanceHolderCreated<Instance>
   | ServiceLocatorInstanceHolderDestroying<Instance>
+  | ServiceLocatorInstanceHolderError

package/src/service-locator-manager.mts

@@ -1,6 +1,7 @@
 /* eslint-disable @typescript-eslint/no-empty-object-type */
 import type { ServiceLocatorInstanceHolder } from './service-locator-instance-holder.mjs'
 
+import { InjectableScope, InjectableType } from './enums/index.mjs'
 import {
   ErrorsEnum,
   InstanceDestroying,
@@ -8,6 +9,7 @@ import {
   InstanceNotFound,
 } from './errors/index.mjs'
 import { ServiceLocatorInstanceHolderStatus } from './service-locator-instance-holder.mjs'
+import { createDeferred } from './utils/defer.mjs'
 
 export class ServiceLocatorManager {
   private readonly instancesHolders: Map<string, ServiceLocatorInstanceHolder> =
@@ -38,6 +40,11 @@ export class ServiceLocatorManager {
           `[ServiceLocatorManager]#getInstanceHolder() Instance ${holder.name} is destroying`,
         )
         return [new InstanceDestroying(holder.name), holder]
+      } else if (holder.status === ServiceLocatorInstanceHolderStatus.Error) {
+        this.logger?.log(
+          `[ServiceLocatorManager]#getInstanceHolder() Instance ${holder.name} is in error state`,
+        )
+        return [holder.instance as InstanceNotFound, holder]
       }
 
       return [undefined, holder]
@@ -86,4 +93,81 @@ export class ServiceLocatorManager {
       ),
     )
   }
+
+  /**
+   * Creates a new holder with Creating status and a deferred creation promise.
+   * This is useful for creating placeholder holders that can be fulfilled later.
+   * @param name The name of the instance
+   * @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>(
+    name: string,
+    type: InjectableType,
+    scope: InjectableScope,
+    deps: Set<string> = new Set(),
+    ttl: number = Infinity,
+  ): [
+    ReturnType<typeof createDeferred<[undefined, Instance]>>,
+    ServiceLocatorInstanceHolder<Instance>,
+  ] {
+    const deferred = createDeferred<[undefined, Instance]>()
+
+    const holder: ServiceLocatorInstanceHolder<Instance> = {
+      status: ServiceLocatorInstanceHolderStatus.Creating,
+      name,
+      instance: null,
+      creationPromise: deferred.promise,
+      destroyPromise: null,
+      type,
+      scope,
+      deps,
+      destroyListeners: [],
+      createdAt: Date.now(),
+      ttl,
+    }
+
+    return [deferred, holder]
+  }
+
+  /**
+   * Creates a new holder with Created status and an actual instance.
+   * This is useful for creating holders that already have their instance ready.
+   * @param name The name of the instance
+   * @param instance The actual instance to store
+   * @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
+   */
+  storeCreatedHolder<Instance>(
+    name: string,
+    instance: Instance,
+    type: InjectableType,
+    scope: InjectableScope,
+    deps: Set<string> = new Set(),
+    ttl: number = Infinity,
+  ): ServiceLocatorInstanceHolder<Instance> {
+    const holder: ServiceLocatorInstanceHolder<Instance> = {
+      status: ServiceLocatorInstanceHolderStatus.Created,
+      name,
+      instance,
+      creationPromise: null,
+      destroyPromise: null,
+      type,
+      scope,
+      deps,
+      destroyListeners: [],
+      createdAt: Date.now(),
+      ttl,
+    }
+
+    this.instancesHolders.set(name, holder)
+
+    return holder
+  }
 }