@navios/di 0.5.1 → 0.6.0

package/src/instance-resolver.mts

@@ -1,559 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable @typescript-eslint/no-empty-object-type */
-import type { z, ZodObject, ZodOptional } from 'zod/v4'
-
-import type { FactoryContext } from './factory-context.mjs'
-import type {
-  AnyInjectableType,
-  BaseInjectionTokenSchemaType,
-  InjectionTokenSchemaType,
-  InjectionTokenType,
-  OptionalInjectionTokenSchemaType,
-} from './injection-token.mjs'
-import type { Registry } from './registry.mjs'
-import type { RequestContextHolder } from './request-context-holder.mjs'
-import type { ServiceInstantiator } from './service-instantiator.mjs'
-import type { ServiceLocatorInstanceHolder } from './service-locator-instance-holder.mjs'
-import type { ServiceLocatorManager } from './service-locator-manager.mjs'
-import type { ServiceLocator } from './service-locator.mjs'
-import type { TokenProcessor } from './token-processor.mjs'
-
-import { InjectableScope } from './enums/index.mjs'
-import { DIError, DIErrorCode } from './errors/index.mjs'
-import {
-  BoundInjectionToken,
-  FactoryInjectionToken,
-  InjectionToken,
-} from './injection-token.mjs'
-import { ServiceLocatorInstanceHolderStatus } from './service-locator-instance-holder.mjs'
-
-/**
- * InstanceResolver handles instance resolution, creation, and lifecycle management.
- * Extracted from ServiceLocator to improve separation of concerns.
- */
-export class InstanceResolver {
-  constructor(
-    private readonly registry: Registry,
-    private readonly manager: ServiceLocatorManager,
-    private readonly serviceInstantiator: ServiceInstantiator,
-    private readonly tokenProcessor: TokenProcessor,
-    private readonly logger: Console | null = null,
-    private readonly serviceLocator: ServiceLocator,
-  ) {}
-
-  /**
-   * Resolves an instance for the given token and arguments.
-   */
-  async resolveInstance(
-    token: AnyInjectableType,
-    args?: any,
-    requestContext?: RequestContextHolder,
-  ): Promise<[undefined, any] | [DIError]> {
-    const [err, data] = await this.resolveTokenAndPrepareInstanceName(
-      token,
-      args,
-    )
-    if (err) {
-      return [err]
-    }
-
-    const {
-      instanceName,
-      validatedArgs,
-      actualToken: _actualToken,
-      realToken,
-    } = data
-
-    const [error, holder] = await this.retrieveOrCreateInstanceByInstanceName(
-      instanceName,
-      realToken,
-      validatedArgs,
-      requestContext,
-    )
-    if (error) {
-      return [error]
-    }
-    return [undefined, holder.instance]
-  }
-
-  /**
-   * Gets a synchronous instance (for sync operations).
-   */
-  getSyncInstance<
-    Instance,
-    Schema extends InjectionTokenSchemaType | undefined,
-  >(
-    token: AnyInjectableType,
-    args: Schema extends ZodObject
-      ? z.input<Schema>
-      : Schema extends ZodOptional<ZodObject>
-        ? z.input<Schema> | undefined
-        : undefined,
-    currentRequestContext: RequestContextHolder | null,
-  ): Instance | null {
-    const [err, { actualToken, validatedArgs }] =
-      this.tokenProcessor.validateAndResolveTokenArgs(token, args)
-    if (err) {
-      return null
-    }
-    const instanceName = this.tokenProcessor.generateInstanceName(
-      actualToken,
-      validatedArgs,
-    )
-
-    // Try request context first
-    if (currentRequestContext) {
-      const requestHolder = currentRequestContext.get(instanceName)
-      if (requestHolder) {
-        return requestHolder.instance as Instance
-      }
-    }
-
-    // Try singleton manager
-    const [error, holder] = this.manager.get(instanceName)
-    if (error) {
-      return null
-    }
-    return holder.instance as Instance
-  }
-
-  /**
-   * Internal method to resolve token args and create instance name.
-   * Handles factory token resolution and validation.
-   */
-  private async resolveTokenAndPrepareInstanceName(
-    token: AnyInjectableType,
-    args?: any,
-  ): Promise<
-    | [
-        undefined,
-        {
-          instanceName: string
-          validatedArgs: any
-          actualToken: InjectionTokenType
-          realToken: InjectionToken<any, any>
-        },
-      ]
-    | [DIError]
-  > {
-    const [err, { actualToken, validatedArgs }] =
-      this.tokenProcessor.validateAndResolveTokenArgs(token, args)
-    if (err instanceof DIError && err.code === DIErrorCode.UnknownError) {
-      return [err]
-    } else if (
-      err instanceof DIError &&
-      err.code === DIErrorCode.FactoryTokenNotResolved &&
-      actualToken instanceof FactoryInjectionToken
-    ) {
-      this.logger?.log(
-        `[InstanceResolver]#resolveTokenAndPrepareInstanceName() Factory token not resolved, resolving it`,
-      )
-      await actualToken.resolve(this.createFactoryContext())
-      return this.resolveTokenAndPrepareInstanceName(token)
-    }
-    const instanceName = this.tokenProcessor.generateInstanceName(
-      actualToken,
-      validatedArgs,
-    )
-    // Determine the real token (the actual InjectionToken that will be used for resolution)
-    const realToken =
-      actualToken instanceof BoundInjectionToken ||
-      actualToken instanceof FactoryInjectionToken
-        ? actualToken.token
-        : actualToken
-    return [undefined, { instanceName, validatedArgs, actualToken, realToken }]
-  }
-
-  /**
-   * Gets an instance by its instance name, handling all the logic after instance name creation.
-   */
-  private async retrieveOrCreateInstanceByInstanceName(
-    instanceName: string,
-    realToken: InjectionToken<any, any>,
-    realArgs: any,
-    requestContext?: RequestContextHolder,
-  ): Promise<[undefined, ServiceLocatorInstanceHolder<any>] | [DIError]> {
-    // Try to get existing instance (handles both request-scoped and singleton)
-    const existingHolder = await this.tryGetExistingInstance(
-      instanceName,
-      realToken,
-      requestContext,
-    )
-    if (existingHolder) {
-      return existingHolder
-    }
-
-    // No existing instance found, create a new one
-    const result = await this.createNewInstance(
-      instanceName,
-      realToken,
-      realArgs,
-      requestContext,
-    )
-    if (result[0]) {
-      return [result[0]]
-    }
-
-    const [, holder] = result
-    return this.waitForInstanceReady(holder)
-  }
-
-  /**
-   * Attempts to retrieve an existing instance, handling request-scoped and singleton instances.
-   * Returns null if no instance exists and a new one should be created.
-   */
-  private async tryGetExistingInstance(
-    instanceName: string,
-    realToken: InjectionToken<any, any>,
-    requestContext?: RequestContextHolder,
-  ): Promise<
-    [undefined, ServiceLocatorInstanceHolder<any>] | [DIError] | null
-  > {
-    // Check request-scoped instances first
-    const requestResult = await this.tryGetRequestScopedInstance(
-      instanceName,
-      realToken,
-      requestContext,
-    )
-    if (requestResult) {
-      return requestResult
-    }
-
-    // Check singleton instances
-    return this.tryGetSingletonInstance(instanceName)
-  }
-
-  /**
-   * Attempts to get a request-scoped instance if applicable.
-   */
-  private async tryGetRequestScopedInstance(
-    instanceName: string,
-    realToken: InjectionToken<any, any>,
-    requestContext?: RequestContextHolder,
-  ): Promise<
-    [undefined, ServiceLocatorInstanceHolder<any>] | [DIError] | null
-  > {
-    if (!this.registry.has(realToken)) {
-      return null
-    }
-
-    const record = this.registry.get(realToken)
-    if (record.scope !== InjectableScope.Request) {
-      return null
-    }
-
-    if (!requestContext) {
-      this.logger?.log(
-        `[InstanceResolver] No current request context available for request-scoped service ${instanceName}`,
-      )
-      return [
-        DIError.unknown(
-          `No current request context available for request-scoped service ${instanceName}`,
-        ),
-      ]
-    }
-
-    const requestHolder = requestContext.get(instanceName)
-    if (!requestHolder) {
-      return null
-    }
-
-    return this.waitForInstanceReady(requestHolder)
-  }
-
-  /**
-   * Attempts to get a singleton instance from the manager.
-   */
-  private async tryGetSingletonInstance(
-    instanceName: string,
-  ): Promise<
-    [undefined, ServiceLocatorInstanceHolder<any>] | [DIError] | null
-  > {
-    const [error, holder] = this.manager.get(instanceName)
-
-    if (!error) {
-      return this.waitForInstanceReady(holder)
-    }
-
-    // Handle recovery scenarios
-    switch (error.code) {
-      case DIErrorCode.InstanceDestroying:
-        this.logger?.log(
-          `[InstanceResolver] Instance ${instanceName} is being destroyed, waiting...`,
-        )
-        await holder?.destroyPromise
-        // Retry after destruction is complete
-        return this.tryGetSingletonInstance(instanceName)
-
-      case DIErrorCode.InstanceNotFound:
-        return null // Instance doesn't exist, should create new one
-
-      default:
-        return [error]
-    }
-  }
-
-  /**
-   * Waits for an instance holder to be ready and returns the appropriate result.
-   */
-  private async waitForInstanceReady<T>(
-    holder: ServiceLocatorInstanceHolder<T>,
-  ): Promise<[undefined, ServiceLocatorInstanceHolder<T>] | [DIError]> {
-    switch (holder.status) {
-      case ServiceLocatorInstanceHolderStatus.Creating:
-        await holder.creationPromise
-        return this.waitForInstanceReady(holder)
-
-      case ServiceLocatorInstanceHolderStatus.Destroying:
-        return [DIError.instanceDestroying(holder.name)]
-
-      case ServiceLocatorInstanceHolderStatus.Error:
-        return [holder.instance as DIError]
-
-      case ServiceLocatorInstanceHolderStatus.Created:
-        return [undefined, holder]
-
-      default:
-        return [DIError.instanceNotFound('unknown')]
-    }
-  }
-
-  /**
-   * Creates a new instance for the given token and arguments.
-   */
-  private async createNewInstance<
-    Instance,
-    Schema extends InjectionTokenSchemaType | undefined,
-  >(
-    instanceName: string,
-    realToken: InjectionToken<Instance, Schema>,
-    args: Schema extends ZodObject
-      ? z.output<Schema>
-      : Schema extends ZodOptional<ZodObject>
-        ? z.output<Schema> | undefined
-        : undefined,
-    requestContext?: RequestContextHolder,
-  ): Promise<[undefined, ServiceLocatorInstanceHolder<Instance>] | [DIError]> {
-    this.logger?.log(
-      `[InstanceResolver]#createNewInstance() Creating instance for ${instanceName}`,
-    )
-    if (this.registry.has(realToken)) {
-      return this.instantiateServiceFromRegistry<Instance, Schema, any>(
-        instanceName,
-        realToken,
-        args,
-        requestContext,
-      )
-    } else {
-      return [DIError.factoryNotFound(realToken.name.toString())]
-    }
-  }
-
-  /**
-   * Instantiates a service from the registry using the service instantiator.
-   */
-  private instantiateServiceFromRegistry<
-    Instance,
-    Schema extends InjectionTokenSchemaType | undefined,
-    Args extends Schema extends BaseInjectionTokenSchemaType
-      ? z.output<Schema>
-      : Schema extends OptionalInjectionTokenSchemaType
-        ? z.output<Schema> | undefined
-        : undefined,
-  >(
-    instanceName: string,
-    token: InjectionToken<Instance, Schema>,
-    args: Args,
-    requestContext?: RequestContextHolder,
-  ): Promise<[undefined, ServiceLocatorInstanceHolder<Instance>]> {
-    this.logger?.log(
-      `[InstanceResolver]#instantiateServiceFromRegistry(): Creating instance for ${instanceName} from abstract factory`,
-    )
-    const ctx = this.createFactoryContext()
-    let record = this.registry.get<Instance, Schema>(token)
-    let { scope, type } = record
-
-    // Use createCreatingHolder from manager
-    const [deferred, holder] = this.manager.createCreatingHolder<Instance>(
-      instanceName,
-      type,
-      scope,
-      ctx.deps,
-    )
-
-    // Start the instantiation process
-    this.serviceInstantiator
-      .instantiateService(ctx, record, args)
-      .then(async ([error, instance]) => {
-        await this.handleInstantiationResult(
-          instanceName,
-          holder,
-          ctx,
-          deferred,
-          scope,
-          error,
-          instance,
-          requestContext,
-        )
-      })
-      .catch(async (error) => {
-        await this.handleInstantiationError(
-          instanceName,
-          holder,
-          deferred,
-          scope,
-          error,
-        )
-      })
-
-    this.storeInstanceByScope(scope, instanceName, holder, requestContext)
-    // @ts-expect-error TS2322 This is correct type
-    return [undefined, holder]
-  }
-
-  /**
-   * Handles the result of service instantiation.
-   */
-  private async handleInstantiationResult(
-    instanceName: string,
-    holder: ServiceLocatorInstanceHolder<any>,
-    ctx: FactoryContext & {
-      deps: Set<string>
-      getDestroyListeners: () => (() => void)[]
-    },
-    deferred: any,
-    scope: InjectableScope,
-    error: any,
-    instance: any,
-    _requestContext?: RequestContextHolder,
-  ): Promise<void> {
-    holder.destroyListeners = ctx.getDestroyListeners()
-    holder.creationPromise = null
-
-    if (error) {
-      await this.handleInstantiationError(
-        instanceName,
-        holder,
-        deferred,
-        scope,
-        error,
-      )
-    } else {
-      await this.handleInstantiationSuccess(
-        instanceName,
-        holder,
-        ctx,
-        deferred,
-        instance,
-      )
-    }
-  }
-
-  /**
-   * Handles successful service instantiation.
-   */
-  private async handleInstantiationSuccess(
-    instanceName: string,
-    holder: ServiceLocatorInstanceHolder<any>,
-    ctx: FactoryContext & {
-      deps: Set<string>
-      getDestroyListeners: () => (() => void)[]
-    },
-    deferred: any,
-    instance: any,
-  ): Promise<void> {
-    holder.instance = instance
-    holder.status = ServiceLocatorInstanceHolderStatus.Created
-
-    // Set up dependency invalidation listeners
-    if (ctx.deps.size > 0) {
-      ctx.deps.forEach((dependency: string) => {
-        holder.destroyListeners.push(
-          this.serviceLocator.getEventBus().on(dependency, 'destroy', () => {
-            this.logger?.log(
-              `[InstanceResolver] Dependency ${dependency} destroyed, invalidating ${instanceName}`,
-            )
-            this.serviceLocator.getServiceInvalidator().invalidate(instanceName)
-          }),
-        )
-      })
-    }
-
-    // Note: Event emission would need access to the event bus
-    this.logger?.log(
-      `[InstanceResolver] Instance ${instanceName} created successfully`,
-    )
-    deferred.resolve([undefined, instance])
-  }
-
-  /**
-   * Handles service instantiation errors.
-   */
-  private async handleInstantiationError(
-    instanceName: string,
-    holder: ServiceLocatorInstanceHolder<any>,
-    deferred: any,
-    scope: InjectableScope,
-    error: any,
-  ): Promise<void> {
-    this.logger?.error(
-      `[InstanceResolver] Error creating instance for ${instanceName}`,
-      error,
-    )
-
-    holder.status = ServiceLocatorInstanceHolderStatus.Error
-    holder.instance = error
-    holder.creationPromise = null
-
-    if (scope === InjectableScope.Singleton) {
-      this.logger?.log(
-        `[InstanceResolver] Singleton ${instanceName} failed, will be invalidated`,
-      )
-      this.serviceLocator.getServiceInvalidator().invalidate(instanceName)
-    }
-
-    deferred.reject(error)
-  }
-
-  /**
-   * Stores an instance holder based on its scope.
-   */
-  private storeInstanceByScope(
-    scope: InjectableScope,
-    instanceName: string,
-    holder: ServiceLocatorInstanceHolder<any>,
-    requestContext?: RequestContextHolder,
-  ): void {
-    switch (scope) {
-      case InjectableScope.Singleton:
-        this.logger?.debug(
-          `[InstanceResolver] Setting singleton instance for ${instanceName}`,
-        )
-        this.manager.set(instanceName, holder)
-        break
-
-      case InjectableScope.Request:
-        if (requestContext) {
-          this.logger?.debug(
-            `[InstanceResolver] Setting request-scoped instance for ${instanceName}`,
-          )
-          requestContext.addInstance(instanceName, holder.instance, holder)
-        }
-        break
-
-      case InjectableScope.Transient:
-        // Transient instances are not stored anywhere
-        break
-    }
-  }
-
-  /**
-   * Creates a factory context for dependency injection during service instantiation.
-   */
-  private createFactoryContext(): FactoryContext & {
-    getDestroyListeners: () => (() => void)[]
-    deps: Set<string>
-  } {
-    return this.tokenProcessor.createFactoryContext(this.serviceLocator)
-  }
-}

package/src/request-context-manager.mts

@@ -1,149 +0,0 @@
-import type { RequestContextHolder } from './request-context-holder.mjs'
-
-import { DefaultRequestContextHolder } from './request-context-holder.mjs'
-
-/**
- * RequestContextManager handles request context lifecycle management.
- * Extracted from ServiceLocator to improve separation of concerns.
- */
-export class RequestContextManager {
-  private readonly requestContexts = new Map<string, RequestContextHolder>()
-  private currentRequestContext: RequestContextHolder | null = null
-
-  constructor(private readonly logger: Console | null = null) {}
-
-  /**
-   * 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 {
-    if (this.requestContexts.has(requestId)) {
-      throw new Error(
-        `[RequestContextManager] Request context ${requestId} already exists`,
-      )
-    }
-
-    const contextHolder = new DefaultRequestContextHolder(
-      requestId,
-      priority,
-      metadata,
-    )
-    this.requestContexts.set(requestId, contextHolder)
-    this.currentRequestContext = contextHolder
-
-    this.logger?.log(
-      `[RequestContextManager] Started request context: ${requestId}`,
-    )
-    return contextHolder
-  }
-
-  /**
-   * Ends a request context and cleans up all associated instances.
-   * @param requestId The request ID to end
-   */
-  async endRequest(requestId: string): Promise<void> {
-    const contextHolder = this.requestContexts.get(requestId)
-    if (!contextHolder) {
-      this.logger?.warn(
-        `[RequestContextManager] Request context ${requestId} not found`,
-      )
-      return
-    }
-
-    this.logger?.log(
-      `[RequestContextManager] Ending request context: ${requestId}`,
-    )
-
-    // Clean up all request-scoped instances
-    const cleanupPromises: Promise<any>[] = []
-    for (const [, holder] of contextHolder.holders) {
-      if (holder.destroyListeners.length > 0) {
-        cleanupPromises.push(
-          Promise.all(holder.destroyListeners.map((listener) => listener())),
-        )
-      }
-    }
-
-    await Promise.all(cleanupPromises)
-
-    // Clear the context
-    contextHolder.clear()
-    this.requestContexts.delete(requestId)
-
-    // Reset current context if it was the one being ended
-    if (this.currentRequestContext === contextHolder) {
-      this.currentRequestContext =
-        Array.from(this.requestContexts.values()).at(-1) ?? null
-    }
-
-    this.logger?.log(
-      `[RequestContextManager] Request context ${requestId} ended`,
-    )
-  }
-
-  /**
-   * Gets the current request context.
-   * @returns The current request context holder or null
-   */
-  getCurrentRequestContext(): RequestContextHolder | null {
-    return this.currentRequestContext
-  }
-
-  /**
-   * Sets the current request context.
-   * @param requestId The request ID to set as current
-   */
-  setCurrentRequestContext(requestId: string): void {
-    const contextHolder = this.requestContexts.get(requestId)
-    if (!contextHolder) {
-      throw new Error(
-        `[RequestContextManager] Request context ${requestId} not found`,
-      )
-    }
-    this.currentRequestContext = contextHolder
-  }
-
-  /**
-   * Gets all request contexts.
-   * @returns Map of request contexts
-   */
-  getRequestContexts(): Map<string, RequestContextHolder> {
-    return this.requestContexts
-  }
-
-  /**
-   * Clears all request contexts.
-   */
-  async clearAllRequestContexts(): Promise<void> {
-    const requestIds = Array.from(this.requestContexts.keys())
-
-    if (requestIds.length === 0) {
-      this.logger?.log('[RequestContextManager] No request contexts to clear')
-      return
-    }
-
-    this.logger?.log(
-      `[RequestContextManager] Clearing ${requestIds.length} request contexts: ${requestIds.join(', ')}`,
-    )
-
-    // Clear request contexts sequentially to avoid race conditions
-    for (const requestId of requestIds) {
-      try {
-        await this.endRequest(requestId)
-      } catch (error) {
-        this.logger?.error(
-          `[RequestContextManager] Error clearing request context ${requestId}:`,
-          error,
-        )
-        // Continue with other request contexts even if one fails
-      }
-    }
-  }
-}