@navios/di 0.3.1 → 0.4.0

package/src/request-context-holder.mts

@@ -1,5 +1,6 @@
 import type { ServiceLocatorInstanceHolder } from './service-locator-instance-holder.mjs'
 
+import { BaseInstanceHolderManager } from './base-instance-holder-manager.mjs'
 import { InjectableScope, InjectableType } from './enums/index.mjs'
 import { InjectionToken } from './injection-token.mjs'
 import { ServiceLocatorInstanceHolderStatus } from './service-locator-instance-holder.mjs'
@@ -14,11 +15,6 @@ export interface RequestContextHolder {
    */
   readonly requestId: string
 
-  /**
-   * Pre-prepared instances for this request, keyed by instance name.
-   */
-  readonly instances: Map<string, any>
-
   /**
    * Instance holders for request-scoped services.
    */
@@ -54,20 +50,15 @@ export interface RequestContextHolder {
    */
   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
+  get(instanceName: string): ServiceLocatorInstanceHolder | undefined
 
   /**
    * Checks if this context has a pre-prepared instance.
    */
-  hasInstance(instanceName: string): boolean
+  has(instanceName: string): boolean
 
   /**
    * Clears all instances and holders from this context.
@@ -83,14 +74,41 @@ export interface RequestContextHolder {
    * Sets metadata value by key.
    */
   setMetadata(key: string, value: any): void
+
+  // Methods inherited from BaseInstanceHolderManager
+  /**
+   * Filters holders based on a predicate function.
+   */
+  filter(
+    predicate: (
+      value: ServiceLocatorInstanceHolder<any>,
+      key: string,
+    ) => boolean,
+  ): Map<string, ServiceLocatorInstanceHolder>
+
+  /**
+   * Deletes a holder by name.
+   */
+  delete(name: string): boolean
+
+  /**
+   * Gets the number of holders currently managed.
+   */
+  size(): number
+
+  /**
+   * Checks if this manager has any holders.
+   */
+  isEmpty(): boolean
 }
 
 /**
  * Default implementation of RequestContextHolder.
  */
-export class DefaultRequestContextHolder implements RequestContextHolder {
-  public readonly instances = new Map<string, any>()
-  public readonly holders = new Map<string, ServiceLocatorInstanceHolder>()
+export class DefaultRequestContextHolder
+  extends BaseInstanceHolderManager
+  implements RequestContextHolder
+{
   public readonly metadata = new Map<string, any>()
   public readonly createdAt = Date.now()
 
@@ -99,6 +117,7 @@ export class DefaultRequestContextHolder implements RequestContextHolder {
     public readonly priority: number = 100,
     initialMetadata?: Record<string, any>,
   ) {
+    super(null) // RequestContextHolder doesn't need logging
     if (initialMetadata) {
       Object.entries(initialMetadata).forEach(([key, value]) => {
         this.metadata.set(key, value)
@@ -106,50 +125,60 @@ export class DefaultRequestContextHolder implements RequestContextHolder {
     }
   }
 
+  /**
+   * Public getter for holders to maintain interface compatibility.
+   */
+  get holders(): Map<string, ServiceLocatorInstanceHolder> {
+    return this._holders
+  }
+
+  /**
+   * Gets a holder by name. For RequestContextHolder, this is a simple lookup.
+   */
+  get(name: string): ServiceLocatorInstanceHolder | undefined {
+    return this._holders.get(name)
+  }
+
+  /**
+   * Sets a holder by name.
+   */
+  set(name: string, holder: ServiceLocatorInstanceHolder): void {
+    this._holders.set(name, holder)
+  }
+
+  /**
+   * Checks if a holder exists by name.
+   */
+  has(name: string): boolean {
+    return this._holders.has(name)
+  }
+
   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(), {
+      const name = instanceName.toString()
+      const createdHolder = this.createCreatedHolder(
+        name,
         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,
-      })
+        InjectableType.Class,
+        InjectableScope.Singleton,
+        new Set(),
+        Infinity,
+      )
+      this._holders.set(name, createdHolder)
     } 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)
+      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()
+    super.clear() // Use the base class clear method for holders
     this.metadata.clear()
   }
 

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 { BaseInstanceHolderManager } from './base-instance-holder-manager.mjs'
 import { InjectableScope, InjectableType } from './enums/index.mjs'
 import {
   ErrorsEnum,
@@ -9,13 +10,11 @@ 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> =
-    new Map()
-
-  constructor(private readonly logger: Console | null = null) {}
+export class ServiceLocatorManager extends BaseInstanceHolderManager {
+  constructor(logger: Console | null = null) {
+    super(logger)
+  }
 
   get(
     name: string,
@@ -23,7 +22,7 @@ export class ServiceLocatorManager {
     | [InstanceExpired | InstanceDestroying, ServiceLocatorInstanceHolder]
     | [InstanceNotFound]
     | [undefined, ServiceLocatorInstanceHolder] {
-    const holder = this.instancesHolders.get(name)
+    const holder = this._holders.get(name)
     if (holder) {
       if (holder.ttl !== Infinity) {
         const now = Date.now()
@@ -57,7 +56,7 @@ export class ServiceLocatorManager {
   }
 
   set(name: string, holder: ServiceLocatorInstanceHolder): void {
-    this.instancesHolders.set(name, holder)
+    this._holders.set(name, holder)
   }
 
   has(
@@ -77,61 +76,9 @@ export class ServiceLocatorManager {
     return [undefined, !!holder]
   }
 
-  delete(name: string): boolean {
-    return this.instancesHolders.delete(name)
-  }
+  // delete and filter methods are inherited from BaseInstanceHolderManager
 
-  filter(
-    predicate: (
-      value: ServiceLocatorInstanceHolder<any>,
-      key: string,
-    ) => boolean,
-  ): Map<string, ServiceLocatorInstanceHolder> {
-    return new Map(
-      [...this.instancesHolders].filter(([key, value]) =>
-        predicate(value, key),
-      ),
-    )
-  }
-
-  /**
-   * 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]
-  }
+  // createCreatingHolder method is inherited from BaseInstanceHolderManager
 
   /**
    * Creates a new holder with Created status and an actual instance.
@@ -152,21 +99,16 @@ export class ServiceLocatorManager {
     deps: Set<string> = new Set(),
     ttl: number = Infinity,
   ): ServiceLocatorInstanceHolder<Instance> {
-    const holder: ServiceLocatorInstanceHolder<Instance> = {
-      status: ServiceLocatorInstanceHolderStatus.Created,
+    const holder = this.createCreatedHolder(
       name,
       instance,
-      creationPromise: null,
-      destroyPromise: null,
       type,
       scope,
       deps,
-      destroyListeners: [],
-      createdAt: Date.now(),
       ttl,
-    }
+    )
 
-    this.instancesHolders.set(name, holder)
+    this._holders.set(name, holder)
 
     return holder
   }