@navios/di 0.7.1 → 0.9.0

package/src/__tests__/unified-api.spec.mts

@@ -1,130 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { InjectableScope, InjectableType } from '../enums/index.mjs'
-import { DefaultRequestContext } from '../internal/context/request-context.mjs'
-import { HolderManager } from '../internal/holder/holder-manager.mjs'
-
-describe('Unified API', () => {
-  describe('Common methods between HolderManager and RequestContext', () => {
-    it('should have the same basic API surface', () => {
-      const holderManager = new HolderManager()
-      const requestContext = new DefaultRequestContext(
-        'test-request',
-        100,
-      )
-
-      // Both should have the same common methods
-      expect(typeof holderManager.size).toBe('function')
-      expect(typeof requestContext.size).toBe('function')
-
-      expect(typeof holderManager.isEmpty).toBe('function')
-      expect(typeof requestContext.isEmpty).toBe('function')
-
-      expect(typeof holderManager.filter).toBe('function')
-      expect(typeof requestContext.filter).toBe('function')
-
-      expect(typeof holderManager.clear).toBe('function')
-      expect(typeof requestContext.clear).toBe('function')
-
-      expect(typeof holderManager.delete).toBe('function')
-      expect(typeof requestContext.delete).toBe('function')
-
-      expect(typeof holderManager.getAllNames).toBe('function')
-      expect(typeof requestContext.getAllNames).toBe('function')
-
-      expect(typeof holderManager.getAllHolders).toBe('function')
-      expect(typeof requestContext.getAllHolders).toBe('function')
-
-      expect(typeof holderManager.createCreatingHolder).toBe('function')
-      expect(typeof requestContext.createCreatingHolder).toBe('function')
-    })
-
-    it('should work with the same holder creation patterns', () => {
-      const holderManager = new HolderManager()
-      const requestContext = new DefaultRequestContext(
-        'test-request',
-        100,
-      )
-
-      // Both should be able to create holders the same way
-      const [deferred1, holder1] = holderManager.createCreatingHolder(
-        'Service1',
-        InjectableType.Class,
-        InjectableScope.Singleton,
-      )
-
-      const [deferred2, holder2] = requestContext.createCreatingHolder(
-        'Service2',
-        InjectableType.Class,
-        InjectableScope.Request,
-      )
-
-      expect(holder1.name).toBe('Service1')
-      expect(holder1.scope).toBe(InjectableScope.Singleton)
-      expect(holder2.name).toBe('Service2')
-      expect(holder2.scope).toBe(InjectableScope.Request)
-
-      // Both should be able to store holders
-      holderManager.set('Service1', holder1)
-      requestContext.set('Service2', holder2)
-
-      expect(holderManager.size()).toBe(1)
-      expect(requestContext.size()).toBe(1)
-    })
-
-    it('should support the same filtering patterns', () => {
-      const holderManager = new HolderManager()
-      const requestContext = new DefaultRequestContext(
-        'test-request',
-        100,
-      )
-
-      // Create and store different types of holders
-      const singletonHolder = holderManager.storeCreatedHolder(
-        'Singleton',
-        {},
-        InjectableType.Class,
-        InjectableScope.Singleton,
-      )
-
-      // Create a holder first, then add it to the request context
-      const [, transientHolderTemp] = requestContext.createCreatingHolder(
-        'Transient',
-        InjectableType.Class,
-        InjectableScope.Transient,
-      )
-      requestContext.set('Transient', transientHolderTemp)
-      const transientHolder = transientHolderTemp
-
-      // Both should support the same filtering API
-      const singletons = holderManager.filter(
-        (holder) => holder.scope === InjectableScope.Singleton,
-      )
-      const transients = requestContext.filter(
-        (holder) => holder.scope === InjectableScope.Transient,
-      )
-
-      expect(singletons.size).toBe(1)
-      expect(transients.size).toBe(1)
-      expect(singletons.get('Singleton')).toBe(singletonHolder)
-      expect(transients.get('Transient')).toBe(transientHolder)
-    })
-
-    it('should maintain their specific behaviors while sharing common API', () => {
-      const holderManager = new HolderManager()
-      const requestContext = new DefaultRequestContext(
-        'test-request',
-        100,
-      )
-
-      // HolderManager has specific error handling
-      const [notFound] = holderManager.get('NonExistent')
-      expect(notFound).toBeDefined()
-
-      // RequestContext has specific request features
-      expect(requestContext.requestId).toBe('test-request')
-      expect(requestContext.priority).toBe(100)
-      expect(requestContext.metadata).toBeInstanceOf(Map)
-    })
-  })
-})

package/src/browser.mts

@@ -1,11 +0,0 @@
-/**
- * Browser-specific entry point for @navios/di.
- *
- * This entry point is automatically selected by bundlers that respect
- * the "browser" condition in package.json exports.
- *
- * The browser build uses SyncLocalStorage instead of Node's AsyncLocalStorage,
- * which is sufficient for synchronous DI resolution in browser environments.
- */
-
-export * from './index.mjs'

package/src/injectors.mts

@@ -1,18 +0,0 @@
-import type { Injectors } from './utils/index.mjs'
-
-import { getInjectors } from './utils/index.mjs'
-
-export const defaultInjectors = getInjectors()
-
-export const asyncInject: Injectors['asyncInject'] =
-  defaultInjectors.asyncInject
-
-export const inject: Injectors['inject'] = defaultInjectors.inject
-
-export const optional: Injectors['optional'] = defaultInjectors.optional
-
-export const wrapSyncInit: Injectors['wrapSyncInit'] =
-  defaultInjectors.wrapSyncInit
-
-export const provideFactoryContext: Injectors['provideFactoryContext'] =
-  defaultInjectors.provideFactoryContext

package/src/internal/context/request-context.mts

@@ -1,214 +0,0 @@
-import type { InstanceHolder } from '../holder/instance-holder.mjs'
-
-import { BaseHolderManager } from '../holder/base-holder-manager.mjs'
-import { InjectableScope, InjectableType } from '../../enums/index.mjs'
-import { InjectionToken } from '../../token/injection-token.mjs'
-
-/**
- * Interface for request context that manages pre-prepared instances for a specific request.
- *
- * Provides isolated storage for request-scoped services, enabling efficient
- * instantiation and cleanup within the lifecycle of a single request.
- */
-export interface RequestContext {
-  /**
-   * Unique identifier for this request context.
-   */
-  readonly requestId: string
-
-  /**
-   * Instance holders for request-scoped services.
-   */
-  readonly holders: Map<string, InstanceHolder>
-
-  /**
-   * 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: InstanceHolder,
-  ): void
-
-  /**
-   * Adds a pre-prepared instance to this context.
-   */
-  addInstance(token: InjectionToken<any, undefined>, instance: any): void
-
-  /**
-   * Gets an instance holder from this context.
-   */
-  get(instanceName: string): InstanceHolder | undefined
-
-  /**
-   * Sets an instance holder by name.
-   */
-  set(instanceName: string, holder: InstanceHolder): void
-
-  /**
-   * Checks if this context has a pre-prepared instance.
-   */
-  has(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
-
-  // Methods inherited from BaseHolderManager
-  /**
-   * Filters holders based on a predicate function.
-   */
-  filter(
-    predicate: (
-      value: InstanceHolder<any>,
-      key: string,
-    ) => boolean,
-  ): Map<string, InstanceHolder>
-
-  /**
-   * 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
-}
-
-/** @deprecated Use RequestContext instead */
-export type RequestContextHolder = RequestContext
-
-/**
- * Default implementation of RequestContext.
- *
- * Extends BaseHolderManager to provide holder management functionality
- * with request-specific metadata and lifecycle support.
- */
-export class DefaultRequestContext
-  extends BaseHolderManager
-  implements RequestContext
-{
-  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>,
-  ) {
-    super(null) // RequestContext doesn't need logging
-    if (initialMetadata) {
-      Object.entries(initialMetadata).forEach(([key, value]) => {
-        this.metadata.set(key, value)
-      })
-    }
-  }
-
-  /**
-   * Public getter for holders to maintain interface compatibility.
-   */
-  get holders(): Map<string, InstanceHolder> {
-    return this._holders
-  }
-
-  /**
-   * Gets a holder by name. For RequestContext, this is a simple lookup.
-   */
-  get(name: string): InstanceHolder | undefined {
-    return this._holders.get(name)
-  }
-
-  /**
-   * Sets a holder by name.
-   */
-  set(name: string, holder: InstanceHolder): 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?: InstanceHolder,
-  ): void {
-    if (instanceName instanceof InjectionToken) {
-      const name = instanceName.toString()
-      const createdHolder = this.createCreatedHolder(
-        name,
-        instance,
-        InjectableType.Class,
-        InjectableScope.Singleton,
-        new Set(),
-      )
-      this._holders.set(name, createdHolder)
-    } else {
-      if (!holder) {
-        throw new Error('Holder is required when adding an instance by name')
-      }
-      this._holders.set(instanceName, holder)
-    }
-  }
-
-  clear(): void {
-    super.clear() // Use the base class clear method for holders
-    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 with the given parameters.
- */
-export function createRequestContext(
-  requestId: string,
-  priority: number = 100,
-  initialMetadata?: Record<string, any>,
-): RequestContext {
-  return new DefaultRequestContext(requestId, priority, initialMetadata)
-}