@navios/di 0.8.0 → 0.9.0

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

@@ -1,127 +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[] {
-    // Get dependents from request context (O(1) using reverse index)
-    const requestDependents = this.contextHolder.getDependents(instanceName)
-
-    // Also check singleton holders - a singleton may depend on this request-scoped service
-    const singletonDependents = this.holderManager.getDependents(instanceName)
-
-    // Combine both arrays (avoid allocations if one is empty)
-    if (requestDependents.length === 0) return singletonDependents
-    if (singletonDependents.length === 0) return requestDependents
-    return [...requestDependents, ...singletonDependents]
-  }
-}

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

@@ -1,92 +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 {
-    this.manager.forEachHolder((holder, name) => callback(name, holder))
-  }
-
-  findByInstance(instance: unknown): InstanceHolder | null {
-    return this.manager.findHolder((h) => h.instance === instance) ?? null
-  }
-
-  findDependents(instanceName: string): string[] {
-    return this.manager.getDependents(instanceName)
-  }
-}

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

package/src/testing/__tests__/test-container.spec.mts

@@ -1,173 +0,0 @@
-import { beforeEach, describe, expect, it } from 'vitest'
-
-import { Injectable } from '../../decorators/injectable.decorator.mjs'
-import { InjectionToken } from '../../token/injection-token.mjs'
-import { inject } from '../../injectors.mjs'
-import { TestContainer } from '../test-container.mjs'
-
-describe('TestContainer', () => {
-  let container: TestContainer
-
-  beforeEach(() => {
-    container = new TestContainer()
-  })
-
-  describe('clear method', () => {
-    it('should clear all instances from the container', () => {
-      // This test verifies that the clear method exists and can be called
-      expect(() => container.clear()).not.toThrow()
-    })
-  })
-
-  describe('bind method', () => {
-    it('should create a TestBindingBuilder', () => {
-      const token = InjectionToken.create<string>('test-token')
-      const builder = container.bind(token)
-      expect(builder).toBeDefined()
-      expect(builder).toHaveProperty('toValue')
-      expect(builder).toHaveProperty('toClass')
-    })
-
-    it('should allow chaining bind operations', () => {
-      const token = InjectionToken.create<string>('test-token')
-      const result = container.bind(token).toValue('test-value')
-      expect(result).toBe(container)
-    })
-
-    it('should bind value and retrieve it correctly', async () => {
-      const token = InjectionToken.create<string>('test-token')
-      const testValue = 'test-value'
-
-      container.bind(token).toValue(testValue)
-
-      const retrievedValue = await container.get(token)
-      expect(retrievedValue).toBe(testValue)
-    })
-
-    it('should bind class and retrieve instance correctly', async () => {
-      @Injectable()
-      class TestService {
-        getValue() {
-          return 'test-service-value'
-        }
-      }
-
-      const token = InjectionToken.create<TestService>('test-service')
-
-      container.bind(token).toClass(TestService)
-
-      const instance = await container.get(token)
-      expect(instance).toBeInstanceOf(TestService)
-      expect(instance.getValue()).toBe('test-service-value')
-    })
-  })
-
-  describe('bindValue method', () => {
-    it('should bind a value to a token', () => {
-      const token = InjectionToken.create<string>('test-token')
-      const result = container.bindValue(token, 'test-value')
-      expect(result).toBe(container)
-    })
-
-    it('should bind value and retrieve it correctly', async () => {
-      const token = InjectionToken.create<number>('number-token')
-      const testValue = 42
-
-      container.bindValue(token, testValue)
-
-      const retrievedValue = await container.get(token)
-      expect(retrievedValue).toBe(testValue)
-    })
-
-    it('should bind object value and retrieve it correctly', async () => {
-      interface TestConfig {
-        apiUrl: string
-        timeout: number
-      }
-
-      const token = InjectionToken.create<TestConfig>('config-token')
-      const testConfig: TestConfig = {
-        apiUrl: 'https://api.example.com',
-        timeout: 5000,
-      }
-
-      container.bindValue(token, testConfig)
-
-      const retrievedConfig = await container.get(token)
-      expect(retrievedConfig).toEqual(testConfig)
-      expect(retrievedConfig.apiUrl).toBe('https://api.example.com')
-      expect(retrievedConfig.timeout).toBe(5000)
-    })
-  })
-
-  describe('bindClass method', () => {
-    it('should bind a class to a token', () => {
-      class TestClass {}
-      const token = InjectionToken.create<TestClass>('test-token')
-      const result = container.bindClass(token, TestClass)
-      expect(result).toBe(container)
-    })
-
-    it('should bind class and retrieve instance correctly', async () => {
-      @Injectable()
-      class UserService {
-        private users: string[] = ['alice', 'bob']
-
-        getUsers() {
-          return this.users
-        }
-
-        addUser(user: string) {
-          this.users.push(user)
-        }
-      }
-
-      const token = InjectionToken.create<UserService>('user-service')
-
-      container.bindClass(token, UserService)
-
-      const instance = await container.get(token)
-      expect(instance).toBeInstanceOf(UserService)
-      expect(instance.getUsers()).toEqual(['alice', 'bob'])
-
-      instance.addUser('charlie')
-      expect(instance.getUsers()).toEqual(['alice', 'bob', 'charlie'])
-    })
-
-    it('should bind class with dependencies and retrieve instance correctly', async () => {
-      @Injectable()
-      class DatabaseService {
-        connect() {
-          return 'connected'
-        }
-      }
-
-      @Injectable()
-      class UserRepository {
-        db = inject(DatabaseService)
-
-        findUser(id: string) {
-          return `User ${id} from ${this.db.connect()}`
-        }
-      }
-
-      const dbToken = InjectionToken.create<DatabaseService>('db-service')
-      const userRepoToken = InjectionToken.create<UserRepository>('user-repo')
-
-      container.bindClass(dbToken, DatabaseService)
-      container.bindClass(userRepoToken, UserRepository)
-
-      const userRepo = await container.get(userRepoToken)
-      expect(userRepo).toBeInstanceOf(UserRepository)
-      expect(userRepo.findUser('123')).toBe('User 123 from connected')
-    })
-  })
-
-  describe('createChild method', () => {
-    it('should create a new TestContainer instance', () => {
-      const child = container.createChild()
-      expect(child).toBeInstanceOf(TestContainer)
-      expect(child).not.toBe(container)
-    })
-  })
-})