@navios/di 0.7.1 → 0.9.0

package/src/__tests__/service-instantiator.spec.mts

@@ -1,410 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-import type { FactoryContext } from '../internal/context/factory-context.mjs'
-import type { FactoryRecord } from '../token/registry.mjs'
-import type { Injectors } from '../utils/get-injectors.mjs'
-
-import { InjectableScope, InjectableType } from '../enums/index.mjs'
-import { DIError } from '../errors/index.mjs'
-import { Instantiator } from '../internal/core/instantiator.mjs'
-import { InjectionToken } from '../token/injection-token.mjs'
-
-// Mock classes for testing
-class TestService {
-  constructor(public name: string = 'default') {}
-}
-
-class TestServiceWithLifecycle {
-  public initCalled = false
-  public destroyCalled = false
-
-  async onServiceInit() {
-    this.initCalled = true
-  }
-
-  async onServiceDestroy() {
-    this.destroyCalled = true
-  }
-}
-
-class TestFactory {
-  async create(ctx: FactoryContext, args?: any) {
-    return { factoryResult: args?.value || 'default' }
-  }
-}
-
-class TestFactoryWithoutCreate {
-  // Missing create method
-}
-
-describe('Instantiator', () => {
-  let instantiator: Instantiator
-  let mockInjectors: Injectors
-  let mockContext: FactoryContext
-  let mockAddDestroyListener: ReturnType<typeof vi.fn>
-
-  beforeEach(() => {
-    mockAddDestroyListener = vi.fn()
-
-    mockInjectors = {
-      wrapSyncInit: vi.fn((fn) => {
-        // Simple mock implementation that just calls the function
-        return () => [fn(), [], null]
-      }),
-      provideFactoryContext: vi.fn((ctx) => ctx),
-    } as any
-
-    mockContext = {
-      inject: vi.fn(),
-      locator: {} as any,
-      // @ts-expect-error Test
-      addDestroyListener: mockAddDestroyListener,
-    }
-
-    instantiator = new Instantiator(mockInjectors)
-  })
-
-  function createFactoryRecord<T>(
-    target: any,
-    type: InjectableType,
-    scope: InjectableScope = InjectableScope.Singleton,
-  ): FactoryRecord<T, any> {
-    const token = new InjectionToken<T, any>('test-token', undefined)
-    return {
-      type,
-      target,
-      scope,
-      originalToken: token,
-    }
-  }
-
-  describe('instantiateService', () => {
-    it('should instantiate class-based service', async () => {
-      const record = createFactoryRecord<TestService>(
-        TestService,
-        InjectableType.Class,
-      )
-
-      const result = await instantiator.instantiateService(
-        mockContext,
-        record,
-        'test-name',
-      )
-
-      expect(result).toHaveLength(2)
-      expect(result[0]).toBeUndefined()
-      expect(result[1]).toBeInstanceOf(TestService)
-      expect((result[1] as TestService).name).toBe('test-name')
-    })
-
-    it('should instantiate factory-based service', async () => {
-      const record: FactoryRecord<any, any> = {
-        type: InjectableType.Factory,
-        target: TestFactory,
-        scope: InjectableScope.Singleton,
-        originalToken: 'test' as any,
-      }
-
-      const result = await instantiator.instantiateService(
-        mockContext,
-        record,
-        { value: 'test' },
-      )
-
-      expect(result).toHaveLength(2)
-      expect(result[0]).toBeUndefined()
-      expect(result[1]).toEqual({ factoryResult: 'test' })
-    })
-
-    it('should handle unknown service type', async () => {
-      const record: FactoryRecord<any, any> = {
-        type: 'Unknown' as any,
-        target: TestService,
-        scope: InjectableScope.Singleton,
-        originalToken: 'test' as any,
-      }
-
-      const result = await instantiator.instantiateService(mockContext, record)
-
-      expect(result).toHaveLength(1)
-      expect(result[0]).toBeInstanceOf(DIError)
-      expect(result[0]!.message).toContain('Unknown service type: Unknown')
-    })
-
-    it('should handle errors during instantiation', async () => {
-      const ThrowingService = class {
-        constructor() {
-          throw new Error('Constructor error')
-        }
-      }
-
-      const record: FactoryRecord<any, any> = {
-        type: InjectableType.Class,
-        target: ThrowingService,
-        scope: InjectableScope.Singleton,
-        originalToken: 'test' as any,
-      }
-
-      const result = await instantiator.instantiateService(mockContext, record)
-
-      expect(result).toHaveLength(1)
-      expect(result[0]).toBeInstanceOf(DIError)
-      expect(result[0]!.message).toBe('Error: Constructor error')
-    })
-  })
-
-  describe('instantiateClass', () => {
-    it('should handle class with no arguments', async () => {
-      const record: FactoryRecord<TestService, any> = {
-        type: InjectableType.Class,
-        target: TestService,
-        scope: InjectableScope.Singleton,
-        originalToken: 'test' as any,
-      }
-
-      const result = await instantiator.instantiateService(mockContext, record)
-
-      expect(result).toHaveLength(2)
-      expect(result[0]).toBeUndefined()
-      expect(result[1]).toBeInstanceOf(TestService)
-      expect((result[1] as TestService).name).toBe('default')
-    })
-
-    it('should handle class with lifecycle hooks', async () => {
-      const record: FactoryRecord<TestServiceWithLifecycle, any> = {
-        type: InjectableType.Class,
-        target: TestServiceWithLifecycle,
-        scope: InjectableScope.Singleton,
-        originalToken: 'test' as any,
-      }
-
-      const result = await instantiator.instantiateService(mockContext, record)
-
-      expect(result).toHaveLength(2)
-      expect(result[0]).toBeUndefined()
-
-      const instance = result[1] as TestServiceWithLifecycle
-      expect(instance.initCalled).toBe(true)
-      expect(mockAddDestroyListener).toHaveBeenCalled()
-
-      // Test destroy listener
-      const destroyListener = mockAddDestroyListener.mock.calls[0][0]
-      await destroyListener()
-      expect(instance.destroyCalled).toBe(true)
-    })
-
-    it('should handle wrapSyncInit with promises', async () => {
-      // Mock wrapSyncInit to simulate async dependencies
-      // @ts-expect-error Test
-      mockInjectors.wrapSyncInit = vi.fn((fn) => {
-        return (injectState?: any) => {
-          if (!injectState) {
-            // First call - return promises
-            return [fn(), [Promise.resolve('async-dep')], 'inject-state']
-          } else {
-            // Second call - no more promises
-            return [fn(), [], null]
-          }
-        }
-      })
-
-      const record: FactoryRecord<TestService, any> = {
-        type: InjectableType.Class,
-        target: TestService,
-        scope: InjectableScope.Singleton,
-        originalToken: 'test' as any,
-      }
-
-      const result = await instantiator.instantiateService(mockContext, record)
-
-      expect(result).toHaveLength(2)
-      expect(result[0]).toBeUndefined()
-      expect(result[1]).toBeInstanceOf(TestService)
-    })
-
-    it('should handle failed async dependencies', async () => {
-      // @ts-expect-error Test
-      mockInjectors.wrapSyncInit = vi.fn((fn) => {
-        return () => [fn(), [Promise.reject(new Error('Async error'))], null]
-      })
-
-      const record: FactoryRecord<TestService, any> = {
-        type: InjectableType.Class,
-        target: TestService,
-        scope: InjectableScope.Singleton,
-        originalToken: 'test' as any,
-      }
-
-      const result = await instantiator.instantiateService(mockContext, record)
-
-      expect(result).toHaveLength(1)
-      expect(result[0]).toBeInstanceOf(DIError)
-      expect(result[0]!.message).toContain('cannot be instantiated')
-    })
-
-    it('should handle persistent promises after retry', async () => {
-      let callCount = 0
-      // Always return promises to simulate problematic definition
-      // @ts-expect-error Test
-      mockInjectors.wrapSyncInit = vi.fn((fn) => {
-        return (injectState?: any) => {
-          callCount++
-          // Always return promises to simulate problematic definition
-          return [fn(), [Promise.resolve('persistent-promise')], 'state']
-        }
-      })
-
-      // Mock console.error to capture the warning
-      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
-
-      const record: FactoryRecord<TestService, any> = {
-        type: InjectableType.Class,
-        target: TestService,
-        scope: InjectableScope.Singleton,
-        originalToken: 'test' as any,
-      }
-
-      const result = await instantiator.instantiateService(mockContext, record)
-
-      expect(result).toHaveLength(1)
-      expect(result[0]).toBeInstanceOf(DIError)
-      expect(result[0]!.message).toContain('cannot be instantiated')
-      expect(consoleSpy).toHaveBeenCalledWith(
-        expect.stringContaining("has problem with it's definition"),
-      )
-
-      consoleSpy.mockRestore()
-    })
-  })
-
-  describe('instantiateFactory', () => {
-    it('should handle factory with no arguments', async () => {
-      const record: FactoryRecord<any, any> = {
-        type: InjectableType.Factory,
-        target: TestFactory,
-        scope: InjectableScope.Singleton,
-        originalToken: 'test' as any,
-      }
-
-      const result = await instantiator.instantiateService(mockContext, record)
-
-      expect(result).toHaveLength(2)
-      expect(result[0]).toBeUndefined()
-      expect(result[1]).toEqual({ factoryResult: 'default' })
-    })
-
-    it('should handle factory without create method', async () => {
-      const record: FactoryRecord<any, any> = {
-        type: InjectableType.Factory,
-        target: TestFactoryWithoutCreate,
-        scope: InjectableScope.Singleton,
-        originalToken: 'test' as any,
-      }
-
-      const result = await instantiator.instantiateService(mockContext, record)
-
-      expect(result).toHaveLength(1)
-      expect(result[0]).toBeInstanceOf(DIError)
-      expect(result[0]!.message).toContain(
-        'does not implement the create method',
-      )
-    })
-
-    it('should handle factory with promises', async () => {
-      // @ts-expect-error Test
-      mockInjectors.wrapSyncInit = vi.fn((fn) => {
-        return (injectState?: any) => {
-          if (!injectState) {
-            return [fn(), [Promise.resolve('async-dep')], 'inject-state']
-          } else {
-            return [fn(), [], null]
-          }
-        }
-      })
-
-      const record: FactoryRecord<any, any> = {
-        type: InjectableType.Factory,
-        target: TestFactory,
-        scope: InjectableScope.Singleton,
-        originalToken: 'test' as any,
-      }
-
-      const result = await instantiator.instantiateService(mockContext, record)
-
-      expect(result).toHaveLength(2)
-      expect(result[0]).toBeUndefined()
-      expect(result[1]).toEqual({ factoryResult: 'default' })
-    })
-
-    it('should handle failed async dependencies in factory', async () => {
-      // @ts-expect-error Test
-      mockInjectors.wrapSyncInit = vi.fn((fn) => {
-        return () => [
-          fn(),
-          [Promise.reject(new Error('Factory async error'))],
-          null,
-        ]
-      })
-
-      const record: FactoryRecord<any, any> = {
-        type: InjectableType.Factory,
-        target: TestFactory,
-        scope: InjectableScope.Singleton,
-        originalToken: 'test' as any,
-      }
-
-      const result = await instantiator.instantiateService(mockContext, record)
-
-      expect(result).toHaveLength(1)
-      expect(result[0]).toBeInstanceOf(DIError)
-      expect(result[0]!.message).toContain('cannot be instantiated')
-    })
-
-    it('should handle persistent promises in factory', async () => {
-      // @ts-expect-error
-      mockInjectors.wrapSyncInit = vi.fn((fn) => {
-        return () => [fn(), [Promise.resolve('persistent')], 'state']
-      })
-
-      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
-
-      const record: FactoryRecord<any, any> = {
-        type: InjectableType.Factory,
-        target: TestFactory,
-        scope: InjectableScope.Singleton,
-        originalToken: 'test' as any,
-      }
-
-      const result = await instantiator.instantiateService(mockContext, record)
-
-      expect(result).toHaveLength(1)
-      expect(result[0]).toBeInstanceOf(DIError)
-      expect(consoleSpy).toHaveBeenCalledWith(
-        expect.stringContaining('asyncInject instead of inject'),
-      )
-
-      consoleSpy.mockRestore()
-    })
-
-    it('should handle factory create method that throws', async () => {
-      class ThrowingFactory {
-        async create() {
-          throw new Error('Factory create error')
-        }
-      }
-
-      const record: FactoryRecord<any, any> = {
-        type: InjectableType.Factory,
-        target: ThrowingFactory,
-        scope: InjectableScope.Singleton,
-        originalToken: 'test' as any,
-      }
-
-      const result = await instantiator.instantiateService(mockContext, record)
-
-      expect(result).toHaveLength(1)
-      expect(result[0]).toBeInstanceOf(DIError)
-      expect(result[0]!.message).toBe('Error: Factory create error')
-    })
-  })
-})

package/src/__tests__/service-locator-event-bus.spec.mts

@@ -1,242 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-import { LifecycleEventBus } from '../internal/lifecycle/lifecycle-event-bus.mjs'
-
-describe('LifecycleEventBus', () => {
-  let eventBus: LifecycleEventBus
-  let mockLogger: Console
-
-  beforeEach(() => {
-    mockLogger = {
-      debug: vi.fn(),
-      warn: vi.fn(),
-    } as any as Console
-    eventBus = new LifecycleEventBus(mockLogger)
-  })
-
-  describe('constructor', () => {
-    it('should create event bus without logger', () => {
-      const eventBusWithoutLogger = new LifecycleEventBus()
-      expect(eventBusWithoutLogger).toBeDefined()
-    })
-
-    it('should create event bus with logger', () => {
-      expect(eventBus).toBeDefined()
-    })
-  })
-
-  describe('on', () => {
-    it('should register event listener', () => {
-      const listener = vi.fn()
-
-      eventBus.on('test-ns', 'create', listener)
-
-      expect(mockLogger.debug).toHaveBeenCalledWith(
-        '[LifecycleEventBus]#on(): ns:test-ns event:create',
-      )
-    })
-
-    it('should register multiple listeners for same namespace and event', () => {
-      const listener1 = vi.fn()
-      const listener2 = vi.fn()
-
-      eventBus.on('test-ns', 'create', listener1)
-      eventBus.on('test-ns', 'create', listener2)
-
-      expect(mockLogger.debug).toHaveBeenCalledTimes(2)
-    })
-
-    it('should register listeners for different events in same namespace', () => {
-      const listener1 = vi.fn()
-      const listener2 = vi.fn()
-
-      eventBus.on('test-ns', 'create', listener1)
-      eventBus.on('test-ns', 'destroy', listener2)
-
-      expect(mockLogger.debug).toHaveBeenCalledWith(
-        '[LifecycleEventBus]#on(): ns:test-ns event:create',
-      )
-      expect(mockLogger.debug).toHaveBeenCalledWith(
-        '[LifecycleEventBus]#on(): ns:test-ns event:destroy',
-      )
-    })
-
-    it('should return unsubscribe function', async () => {
-      const listener = vi.fn()
-
-      const unsubscribe = eventBus.on('test-ns', 'create', listener)
-      await eventBus.emit('test-ns', 'create')
-
-      expect(listener).toHaveBeenCalledWith('create')
-
-      unsubscribe()
-      await eventBus.emit('test-ns', 'create')
-
-      // Should only be called once (before unsubscribe)
-      expect(listener).toHaveBeenCalledTimes(1)
-    })
-  })
-
-  describe('emit', () => {
-    it('should emit event to registered listeners', async () => {
-      const listener = vi.fn()
-
-      eventBus.on('test-ns', 'create', listener)
-      await eventBus.emit('test-ns', 'create')
-
-      expect(listener).toHaveBeenCalledWith('create')
-      expect(mockLogger.debug).toHaveBeenCalledWith(
-        '[LifecycleEventBus]#emit(): test-ns:create',
-      )
-    })
-
-    it('should emit event to multiple listeners', async () => {
-      const listener1 = vi.fn()
-      const listener2 = vi.fn()
-
-      eventBus.on('test-ns', 'create', listener1)
-      eventBus.on('test-ns', 'create', listener2)
-      await eventBus.emit('test-ns', 'create')
-
-      expect(listener1).toHaveBeenCalledWith('create')
-      expect(listener2).toHaveBeenCalledWith('create')
-    })
-
-    it('should handle emit for non-existent namespace', async () => {
-      await expect(
-        eventBus.emit('non-existent-ns', 'create'),
-      ).resolves.not.toThrow()
-    })
-
-    it('should handle emit for non-existent event in existing namespace', async () => {
-      const listener = vi.fn()
-
-      eventBus.on('test-ns', 'create', listener)
-      await eventBus.emit('test-ns', 'destroy') // Different event
-
-      expect(listener).not.toHaveBeenCalled()
-    })
-
-    it('should handle async listeners', async () => {
-      const asyncListener = vi.fn().mockResolvedValue('async result')
-
-      eventBus.on('test-ns', 'create', asyncListener)
-      await eventBus.emit('test-ns', 'create')
-
-      expect(asyncListener).toHaveBeenCalledWith('create')
-    })
-
-    it('should handle listeners that throw errors and warn about them', async () => {
-      const throwingListener = vi.fn().mockImplementation(() => {
-        throw new Error('Listener error')
-      })
-      const goodListener = vi.fn()
-
-      eventBus.on('test-ns', 'create', throwingListener)
-      eventBus.on('test-ns', 'create', goodListener)
-
-      // Let's test what actually happens - the implementation appears to be buggy
-      // It should use Promise.allSettled to handle errors but seems to throw directly
-      await expect(eventBus.emit('test-ns', 'create')).rejects.toThrow(
-        'Listener error',
-      )
-
-      // Due to the synchronous error, the second listener may not be called
-      expect(throwingListener).toHaveBeenCalledWith('create')
-      // The good listener might not be called if error is thrown synchronously
-      // This seems to be a bug in the implementation
-    })
-
-    it('should handle promises from async listeners', async () => {
-      const asyncListener1 = vi.fn().mockResolvedValue('result1')
-      const asyncListener2 = vi.fn().mockResolvedValue('result2')
-
-      eventBus.on('test-ns', 'create', asyncListener1)
-      eventBus.on('test-ns', 'create', asyncListener2)
-
-      const results = await eventBus.emit('test-ns', 'create')
-
-      expect(asyncListener1).toHaveBeenCalledWith('create')
-      expect(asyncListener2).toHaveBeenCalledWith('create')
-      expect(results).toHaveLength(2)
-    })
-  })
-
-  describe('unsubscribe functionality', () => {
-    it('should remove specific listener when unsubscribe is called', async () => {
-      const listener1 = vi.fn()
-      const listener2 = vi.fn()
-
-      const unsubscribe1 = eventBus.on('test-ns', 'create', listener1)
-      eventBus.on('test-ns', 'create', listener2)
-
-      unsubscribe1()
-
-      await eventBus.emit('test-ns', 'create')
-
-      expect(listener1).not.toHaveBeenCalled()
-      expect(listener2).toHaveBeenCalledWith('create')
-    })
-
-    it('should clean up empty listener sets after removing all listeners', async () => {
-      const listener1 = vi.fn()
-      const listener2 = vi.fn()
-
-      const unsubscribe1 = eventBus.on('test-ns', 'create', listener1)
-      const unsubscribe2 = eventBus.on('test-ns', 'create', listener2)
-
-      unsubscribe1()
-      unsubscribe2()
-
-      // After removing all listeners, emitting should not call anything
-      await eventBus.emit('test-ns', 'create')
-
-      expect(listener1).not.toHaveBeenCalled()
-      expect(listener2).not.toHaveBeenCalled()
-    })
-  })
-
-  describe('complex scenarios', () => {
-    it('should handle multiple namespaces', async () => {
-      const listener1 = vi.fn()
-      const listener2 = vi.fn()
-
-      eventBus.on('ns1', 'create', listener1)
-      eventBus.on('ns2', 'create', listener2)
-
-      await eventBus.emit('ns1', 'create')
-      await eventBus.emit('ns2', 'create')
-
-      expect(listener1).toHaveBeenCalledWith('create')
-      expect(listener2).toHaveBeenCalledWith('create')
-    })
-
-    it('should handle multiple events in same namespace', async () => {
-      const createListener = vi.fn()
-      const destroyListener = vi.fn()
-
-      eventBus.on('test-ns', 'create', createListener)
-      eventBus.on('test-ns', 'destroy', destroyListener)
-
-      await eventBus.emit('test-ns', 'create')
-      await eventBus.emit('test-ns', 'destroy')
-
-      expect(createListener).toHaveBeenCalledWith('create')
-      expect(destroyListener).toHaveBeenCalledWith('destroy')
-    })
-
-    it('should handle prefixed events', async () => {
-      const preListener = vi.fn()
-      const postListener = vi.fn()
-
-      eventBus.on('test-ns', 'pre:action', preListener)
-      eventBus.on('test-ns', 'post:action', postListener)
-
-      await eventBus.emit('test-ns', 'pre:action')
-      await eventBus.emit('test-ns', 'post:action')
-
-      expect(preListener).toHaveBeenCalledWith('pre:action')
-      expect(postListener).toHaveBeenCalledWith('post:action')
-    })
-  })
-})