@navios/di 0.7.1 → 0.9.0

package/src/internal/holder/base-holder-manager.mts

@@ -1,238 +0,0 @@
-import type { InstanceHolder } from './instance-holder.mjs'
-
-import { InjectableScope, InjectableType } from '../../enums/index.mjs'
-import { DIError } from '../../errors/index.mjs'
-import { CircularDetector } from '../lifecycle/circular-detector.mjs'
-import { InstanceStatus } from './instance-holder.mjs'
-
-/**
- * Result type for waitForHolderReady.
- * Returns either [undefined, holder] on success or [error] on failure.
- */
-export type HolderReadyResult<T> = [undefined, InstanceHolder<T>] | [DIError]
-
-/**
- * Abstract base class providing common functionality for managing InstanceHolder objects.
- *
- * Provides shared patterns for holder storage, creation, and lifecycle management
- * used by both singleton (HolderManager) and request-scoped (RequestContext) managers.
- */
-export abstract class BaseHolderManager {
-  protected readonly _holders: Map<string, InstanceHolder>
-
-  constructor(protected readonly logger: Console | null = null) {
-    this._holders = new Map()
-  }
-
-  /**
-   * Protected getter for accessing the holders map from subclasses.
-   */
-  protected get holders(): Map<string, InstanceHolder> {
-    return this._holders
-  }
-
-  /**
-   * Abstract method to get a holder by name. Each implementation defines its own return type
-   * based on their specific error handling and validation needs.
-   */
-  abstract get(name: string): any
-
-  /**
-   * Abstract method to set a holder by name. Each implementation may have different validation logic.
-   */
-  abstract set(name: string, holder: InstanceHolder): void
-
-  /**
-   * Abstract method to check if a holder exists. Each implementation may have different validation logic.
-   */
-  abstract has(name: string): any
-
-  /**
-   * Deletes a holder by name.
-   * @param name The name of the holder to delete
-   * @returns true if the holder was deleted, false if it didn't exist
-   */
-  delete(name: string): boolean {
-    return this._holders.delete(name)
-  }
-
-  /**
-   * Filters holders based on a predicate function.
-   * @param predicate Function to test each holder
-   * @returns A new Map containing only the holders that match the predicate
-   */
-  filter(
-    predicate: (value: InstanceHolder<any>, key: string) => boolean,
-  ): Map<string, InstanceHolder> {
-    return new Map(
-      [...this._holders].filter(([key, value]) => predicate(value, key)),
-    )
-  }
-
-  /**
-   * Clears all holders from this manager.
-   */
-  clear(): void {
-    this._holders.clear()
-  }
-
-  /**
-   * Gets the number of holders currently managed.
-   */
-  size(): number {
-    return this._holders.size
-  }
-
-  /**
-   * 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
-   * @returns A tuple containing the deferred promise and the holder
-   */
-  createCreatingHolder<Instance>(
-    name: string,
-    type: InjectableType,
-    scope: InjectableScope,
-    deps: Set<string> = new Set(),
-  ): [
-    ReturnType<typeof Promise.withResolvers<[undefined, Instance]>>,
-    InstanceHolder<Instance>,
-  ] {
-    const deferred = Promise.withResolvers<[undefined, Instance]>()
-
-    const holder: InstanceHolder<Instance> = {
-      status: InstanceStatus.Creating,
-      name,
-      instance: null,
-      creationPromise: deferred.promise,
-      destroyPromise: null,
-      type,
-      scope,
-      deps,
-      destroyListeners: [],
-      createdAt: Date.now(),
-      waitingFor: new Set(),
-    }
-
-    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
-   * @returns The created holder
-   */
-  protected createCreatedHolder<Instance>(
-    name: string,
-    instance: Instance,
-    type: InjectableType,
-    scope: InjectableScope,
-    deps: Set<string> = new Set(),
-  ): InstanceHolder<Instance> {
-    const holder: InstanceHolder<Instance> = {
-      status: InstanceStatus.Created,
-      name,
-      instance,
-      creationPromise: null,
-      destroyPromise: null,
-      type,
-      scope,
-      deps,
-      destroyListeners: [],
-      createdAt: Date.now(),
-      waitingFor: new Set(),
-    }
-
-    return holder
-  }
-
-  /**
-   * Gets all holder names currently managed.
-   */
-  getAllNames(): string[] {
-    return Array.from(this._holders.keys())
-  }
-
-  /**
-   * Gets all holders currently managed.
-   */
-  getAllHolders(): InstanceHolder[] {
-    return Array.from(this._holders.values())
-  }
-
-  /**
-   * Checks if this manager has any holders.
-   */
-  isEmpty(): boolean {
-    return this._holders.size === 0
-  }
-
-  /**
-   * Waits for a holder to be ready and returns the appropriate result.
-   * This is a shared utility used by both singleton and request-scoped resolution.
-   *
-   * @param holder The holder to wait for
-   * @param waiterHolder Optional holder that is doing the waiting (for circular dependency detection)
-   * @param getHolder Optional function to retrieve holders by name (required if waiterHolder is provided)
-   * @returns A promise that resolves with [undefined, holder] on success or [DIError] on failure
-   */
-  static async waitForHolderReady<T>(
-    holder: InstanceHolder<T>,
-    waiterHolder?: InstanceHolder,
-    getHolder?: (name: string) => InstanceHolder | undefined,
-  ): Promise<HolderReadyResult<T>> {
-    switch (holder.status) {
-      case InstanceStatus.Creating: {
-        // Check for circular dependency before waiting
-        if (waiterHolder && getHolder) {
-          const cycle = CircularDetector.detectCycle(
-            waiterHolder.name,
-            holder.name,
-            getHolder,
-          )
-          if (cycle) {
-            return [DIError.circularDependency(cycle)]
-          }
-
-          // Track the waiting relationship
-          waiterHolder.waitingFor.add(holder.name)
-        }
-
-        try {
-          await holder.creationPromise
-        } finally {
-          // Clean up the waiting relationship
-          if (waiterHolder) {
-            waiterHolder.waitingFor.delete(holder.name)
-          }
-        }
-
-        return BaseHolderManager.waitForHolderReady(
-          holder,
-          waiterHolder,
-          getHolder,
-        )
-      }
-
-      case InstanceStatus.Destroying:
-        return [DIError.instanceDestroying(holder.name)]
-
-      case InstanceStatus.Error:
-        return [holder.instance as unknown as DIError]
-
-      case InstanceStatus.Created:
-        return [undefined, holder]
-
-      default:
-        return [DIError.instanceNotFound('unknown')]
-    }
-  }
-}

package/src/internal/holder/holder-manager.mts

@@ -1,85 +0,0 @@
-import type { InstanceHolder } from './instance-holder.mjs'
-
-import { InjectableScope, InjectableType } from '../../enums/index.mjs'
-import { DIError, DIErrorCode } from '../../errors/index.mjs'
-import { BaseHolderManager } from './base-holder-manager.mjs'
-import { InstanceStatus } from './instance-holder.mjs'
-
-/**
- * Manages the storage and retrieval of singleton instance holders.
- *
- * Provides CRUD operations and filtering for the holder map.
- * Handles holder state validation (destroying, error states) on retrieval.
- */
-export class HolderManager extends BaseHolderManager {
-  constructor(logger: Console | null = null) {
-    super(logger)
-  }
-
-  get(
-    name: string,
-  ): [DIError, InstanceHolder] | [DIError] | [undefined, InstanceHolder] {
-    const holder = this._holders.get(name)
-    if (holder) {
-      if (holder.status === InstanceStatus.Destroying) {
-        this.logger?.log(
-          `[HolderManager]#get() Instance ${holder.name} is destroying`,
-        )
-        return [DIError.instanceDestroying(holder.name), holder]
-      } else if (holder.status === InstanceStatus.Error) {
-        this.logger?.log(
-          `[HolderManager]#get() Instance ${holder.name} is in error state`,
-        )
-        return [holder.instance as unknown as DIError, holder]
-      }
-
-      return [undefined, holder]
-    } else {
-      this.logger?.log(`[HolderManager]#get() Instance ${name} not found`)
-      return [DIError.instanceNotFound(name)]
-    }
-  }
-
-  set(name: string, holder: InstanceHolder): void {
-    this._holders.set(name, holder)
-  }
-
-  has(name: string): [DIError] | [undefined, boolean] {
-    const [error, holder] = this.get(name)
-    if (!error) {
-      return [undefined, true]
-    }
-    if (error.code === DIErrorCode.InstanceDestroying) {
-      return [error]
-    }
-    return [undefined, !!holder]
-  }
-
-  // delete and filter methods are inherited from BaseHolderManager
-
-  // createCreatingHolder method is inherited from BaseHolderManager
-
-  /**
-   * Creates a new holder with Created status and stores it.
-   * 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
-   * @returns The created holder
-   */
-  storeCreatedHolder<Instance>(
-    name: string,
-    instance: Instance,
-    type: InjectableType,
-    scope: InjectableScope,
-    deps: Set<string> = new Set(),
-  ): InstanceHolder<Instance> {
-    const holder = this.createCreatedHolder(name, instance, type, scope, deps)
-
-    this._holders.set(name, holder)
-
-    return holder
-  }
-}

package/src/internal/holder/request-storage.mts

@@ -1,134 +0,0 @@
-import type { RequestContext } from '../context/request-context.mjs'
-import type { BaseHolderManager } from './base-holder-manager.mjs'
-import type {
-  HolderGetResult,
-  IHolderStorage,
-} from './holder-storage.interface.mjs'
-import type { InstanceHolder } from './instance-holder.mjs'
-
-import { InjectableScope, InjectableType } from '../../enums/index.mjs'
-import { DIError } from '../../errors/index.mjs'
-import { InstanceStatus } from './instance-holder.mjs'
-
-/**
- * Storage implementation for Request-scoped services.
- *
- * Wraps a RequestContext instance from a ScopedContainer and provides
- * the IHolderStorage interface. This allows the InstanceResolver to work
- * with request-scoped storage using the same interface as singleton storage.
- */
-export class RequestStorage implements IHolderStorage {
-  readonly scope = InjectableScope.Request
-
-  constructor(
-    private readonly contextHolder: RequestContext,
-    private readonly holderManager: BaseHolderManager,
-  ) {}
-
-  get<T = unknown>(instanceName: string): HolderGetResult<T> {
-    const holder = this.contextHolder.get(instanceName)
-
-    if (!holder) {
-      return null
-    }
-
-    // Check holder status for error states
-    switch (holder.status) {
-      case InstanceStatus.Destroying:
-        return [
-          DIError.instanceDestroying(instanceName),
-          holder as InstanceHolder<T>,
-        ]
-
-      case InstanceStatus.Error:
-        return [
-          holder.instance as unknown as DIError,
-          holder as InstanceHolder<T>,
-        ]
-
-      case InstanceStatus.Creating:
-      case InstanceStatus.Created:
-        return [undefined, holder as InstanceHolder<T>]
-
-      default:
-        return null
-    }
-  }
-
-  set(instanceName: string, holder: InstanceHolder): void {
-    this.contextHolder.set(instanceName, holder)
-  }
-
-  delete(instanceName: string): boolean {
-    return this.contextHolder.delete(instanceName)
-  }
-
-  createHolder<T>(
-    instanceName: string,
-    type: InjectableType,
-    deps: Set<string>,
-  ): [
-    ReturnType<typeof Promise.withResolvers<[undefined, T]>>,
-    InstanceHolder<T>,
-  ] {
-    // Use the holderManager's createCreatingHolder method
-    // which is inherited from BaseHolderManager
-    return this.holderManager.createCreatingHolder<T>(
-      instanceName,
-      type,
-      this.scope,
-      deps,
-    )
-  }
-
-  handles(scope: InjectableScope): boolean {
-    return scope === InjectableScope.Request
-  }
-
-  // ============================================================================
-  // ITERATION AND QUERY
-  // ============================================================================
-
-  getAllNames(): string[] {
-    const names: string[] = []
-    for (const [name] of this.contextHolder.holders) {
-      names.push(name)
-    }
-    return names
-  }
-
-  forEach(callback: (name: string, holder: InstanceHolder) => void): void {
-    for (const [name, holder] of this.contextHolder.holders) {
-      callback(name, holder)
-    }
-  }
-
-  findByInstance(instance: unknown): InstanceHolder | null {
-    for (const holder of this.contextHolder.holders.values()) {
-      if (holder.instance === instance) {
-        return holder
-      }
-    }
-    return null
-  }
-
-  findDependents(instanceName: string): string[] {
-    const dependents: string[] = []
-
-    // Check request-scoped holders
-    for (const [name, holder] of this.contextHolder.holders) {
-      if (holder.deps.has(instanceName)) {
-        dependents.push(name)
-      }
-    }
-
-    // Also check singleton holders - a singleton may depend on this request-scoped service
-    for (const [name, holder] of this.holderManager.filter(() => true)) {
-      if (holder.deps.has(instanceName)) {
-        dependents.push(name)
-      }
-    }
-
-    return dependents
-  }
-}

package/src/internal/holder/singleton-storage.mts

@@ -1,105 +0,0 @@
-import type { HolderManager } from './holder-manager.mjs'
-import type {
-  HolderGetResult,
-  IHolderStorage,
-} from './holder-storage.interface.mjs'
-import type { InstanceHolder } from './instance-holder.mjs'
-
-import { InjectableScope, InjectableType } from '../../enums/index.mjs'
-import { DIErrorCode } from '../../errors/index.mjs'
-
-/**
- * Storage implementation for Singleton-scoped services.
- *
- * Wraps a HolderManager instance and provides the IHolderStorage interface.
- * This allows the InstanceResolver to work with singleton storage
- * using the same interface as request-scoped storage.
- */
-export class SingletonStorage implements IHolderStorage {
-  readonly scope = InjectableScope.Singleton
-
-  constructor(private readonly manager: HolderManager) {}
-
-  get<T = unknown>(instanceName: string): HolderGetResult<T> {
-    const [error, holder] = this.manager.get(instanceName)
-
-    if (!error) {
-      return [undefined, holder as InstanceHolder<T>]
-    }
-
-    // Handle different error types
-    switch (error.code) {
-      case DIErrorCode.InstanceNotFound:
-        return null
-
-      case DIErrorCode.InstanceDestroying:
-        return [error, holder as InstanceHolder<T> | undefined]
-
-      default:
-        return [error]
-    }
-  }
-
-  set(instanceName: string, holder: InstanceHolder): void {
-    this.manager.set(instanceName, holder)
-  }
-
-  delete(instanceName: string): boolean {
-    return this.manager.delete(instanceName)
-  }
-
-  createHolder<T>(
-    instanceName: string,
-    type: InjectableType,
-    deps: Set<string>,
-  ): [
-    ReturnType<typeof Promise.withResolvers<[undefined, T]>>,
-    InstanceHolder<T>,
-  ] {
-    return this.manager.createCreatingHolder<T>(
-      instanceName,
-      type,
-      this.scope,
-      deps,
-    )
-  }
-
-  handles(scope: InjectableScope): boolean {
-    return scope === InjectableScope.Singleton
-  }
-
-  // ============================================================================
-  // ITERATION AND QUERY
-  // ============================================================================
-
-  getAllNames(): string[] {
-    return this.manager.getAllNames()
-  }
-
-  forEach(
-    callback: (name: string, holder: InstanceHolder) => void,
-  ): void {
-    for (const [name, holder] of this.manager.filter(() => true)) {
-      callback(name, holder)
-    }
-  }
-
-  findByInstance(instance: unknown): InstanceHolder | null {
-    for (const [, holder] of this.manager.filter(
-      (h) => h.instance === instance,
-    )) {
-      return holder
-    }
-    return null
-  }
-
-  findDependents(instanceName: string): string[] {
-    const dependents: string[] = []
-    for (const [name, holder] of this.manager.filter(() => true)) {
-      if (holder.deps.has(instanceName)) {
-        dependents.push(name)
-      }
-    }
-    return dependents
-  }
-}

package/src/testing/README.md

@@ -1,80 +0,0 @@
-# Testing Infrastructure
-
-The `@navios/di/testing` package provides a `TestContainer` class that extends the base `Container` with additional methods useful for testing.
-
-## Features
-
-- **TestContainer**: A specialized container for testing with simplified binding methods
-- **bind().toValue()**: Bind tokens to specific values (useful for mocks)
-- **bind().toClass()**: Bind tokens to class constructors
-- **clear()**: Clear all instances and bindings from the container
-- **Convenience methods**: `bindValue()`, `bindClass()`, `createChild()`
-
-## Usage
-
-```typescript
-import { Injectable, InjectionToken } from '@navios/di'
-import { TestContainer } from '@navios/di/testing'
-
-// Create a test container
-const container = new TestContainer()
-
-// Create injection tokens
-const API_URL_TOKEN = InjectionToken.create<string>('api-url')
-const HTTP_CLIENT_TOKEN = InjectionToken.create<HttpClient>('http-client')
-
-// Mock implementations
-class MockHttpClient implements HttpClient {
-  async get(url: string) {
-    return { data: 'mocked response' }
-  }
-}
-
-// Bind values for testing
-container.bindValue(API_URL_TOKEN, 'https://test-api.com')
-container.bindClass(HTTP_CLIENT_TOKEN, MockHttpClient)
-
-// Or use the fluent API
-container.bind(API_URL_TOKEN).toValue('https://test-api.com')
-
-container.bind(HTTP_CLIENT_TOKEN).toClass(MockHttpClient)
-
-// Bind a class to itself
-@Injectable()
-class UserService {
-  constructor(
-    @Inject(API_URL_TOKEN) private apiUrl: string,
-    @Inject(HTTP_CLIENT_TOKEN) private httpClient: HttpClient,
-  ) {}
-}
-
-container.bindSelf(UserService)
-
-// Clear the container between tests
-container.clear()
-
-// Create isolated child containers
-const childContainer = container.createChild()
-```
-
-## API Reference
-
-### TestContainer
-
-#### Methods
-
-- `bind<T>(token: InjectionToken<T, any>): TestBindingBuilder<T>` - Creates a binding builder
-- `bind<T>(token: ClassType): TestBindingBuilder<T>` - Creates a binding builder
-- `bindValue<T>(token: InjectionToken<T, any>, value: T): TestContainer` - Binds a value to a token
-- `bindValue<T>(token: ClassType, value: T): TestContainer` - Binds a value to a token
-- `bindClass<T>(token: InjectionToken<T, any>, target: ClassType): TestContainer` - Binds a class to a token
-- `bindClass<T>(token: ClassType, target: ClassType): TestContainer` - Binds a class to a token
-- `createChild(): TestContainer` - Creates a new isolated test container
-- `clear(): void` - Clears all instances and bindings
-
-### TestBindingBuilder
-
-#### Methods
-
-- `toValue(value: T): TestContainer` - Binds the token to a specific value
-- `toClass(target: ClassType): TestContainer` - Binds the token to a class constructor