@navios/di 0.3.1 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@navios/di",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "author": {
     "name": "Oleksandr Hanzha",
     "email": "alex@granted.name"

package/src/__tests__/defer.spec.mts

@@ -0,0 +1,166 @@
+import { describe, expect, it } from 'vitest'
+
+import { createDeferred, Deferred } from '../utils/defer.mjs'
+
+describe('Deferred', () => {
+  describe('constructor', () => {
+    it('should create a deferred promise', () => {
+      const deferred = new Deferred<string>()
+
+      expect(deferred.promise).toBeInstanceOf(Promise)
+      expect(deferred.isResolved).toBe(false)
+      expect(deferred.isRejected).toBe(false)
+      expect(deferred.isSettled).toBe(false)
+    })
+  })
+
+  describe('resolve', () => {
+    it('should resolve the promise with given value', async () => {
+      const deferred = new Deferred<string>()
+      const testValue = 'test value'
+
+      deferred.resolve(testValue)
+      const result = await deferred.promise
+
+      expect(result).toBe(testValue)
+      expect(deferred.isResolved).toBe(true)
+      expect(deferred.isRejected).toBe(false)
+      expect(deferred.isSettled).toBe(true)
+    })
+
+    it('should throw error if already resolved', () => {
+      const deferred = new Deferred<string>()
+
+      deferred.resolve('test')
+
+      expect(() => {
+        deferred.resolve('test2')
+      }).toThrow('Deferred promise has already been resolved or rejected')
+    })
+
+    it('should throw error if already rejected', async () => {
+      const deferred = new Deferred<string>()
+
+      deferred.reject(new Error('test error'))
+
+      // Catch the rejection to avoid unhandled promise rejection
+      try {
+        await deferred.promise
+      } catch (error) {
+        // Expected to fail
+      }
+
+      expect(() => {
+        deferred.resolve('test')
+      }).toThrow('Deferred promise has already been resolved or rejected')
+    })
+  })
+
+  describe('reject', () => {
+    it('should reject the promise with given reason', async () => {
+      const deferred = new Deferred<string>()
+      const testError = new Error('test error')
+
+      deferred.reject(testError)
+
+      await expect(deferred.promise).rejects.toThrow('test error')
+      expect(deferred.isResolved).toBe(false)
+      expect(deferred.isRejected).toBe(true)
+      expect(deferred.isSettled).toBe(true)
+    })
+
+    it('should reject with string reason', async () => {
+      const deferred = new Deferred<string>()
+
+      deferred.reject('string error')
+
+      try {
+        await deferred.promise
+        expect.fail('Should have rejected')
+      } catch (error) {
+        expect(error).toBe('string error')
+      }
+    })
+
+    it('should throw error if already resolved', () => {
+      const deferred = new Deferred<string>()
+
+      deferred.resolve('test')
+
+      expect(() => {
+        deferred.reject(new Error('test error'))
+      }).toThrow('Deferred promise has already been resolved or rejected')
+    })
+
+    it('should throw error if already rejected', async () => {
+      const deferred = new Deferred<string>()
+
+      deferred.reject(new Error('first error'))
+
+      // Catch the rejection to avoid unhandled promise rejection
+      try {
+        await deferred.promise
+      } catch (error) {
+        // Expected to fail
+      }
+
+      expect(() => {
+        deferred.reject(new Error('second error'))
+      }).toThrow('Deferred promise has already been resolved or rejected')
+    })
+  })
+
+  describe('status getters', () => {
+    it('should return correct status for unresolved promise', () => {
+      const deferred = new Deferred<string>()
+
+      expect(deferred.isResolved).toBe(false)
+      expect(deferred.isRejected).toBe(false)
+      expect(deferred.isSettled).toBe(false)
+    })
+
+    it('should return correct status after resolve', () => {
+      const deferred = new Deferred<string>()
+
+      deferred.resolve('test')
+
+      expect(deferred.isResolved).toBe(true)
+      expect(deferred.isRejected).toBe(false)
+      expect(deferred.isSettled).toBe(true)
+    })
+
+    it('should return correct status after reject', async () => {
+      const deferred = new Deferred<string>()
+
+      deferred.reject(new Error('test'))
+
+      // Catch the rejection to avoid unhandled promise rejection
+      try {
+        await deferred.promise
+      } catch (error) {
+        // Expected to fail
+      }
+
+      expect(deferred.isResolved).toBe(false)
+      expect(deferred.isRejected).toBe(true)
+      expect(deferred.isSettled).toBe(true)
+    })
+  })
+})
+
+describe('createDeferred', () => {
+  it('should create a new Deferred instance', () => {
+    const deferred = createDeferred<string>()
+
+    expect(deferred).toBeInstanceOf(Deferred)
+    expect(deferred.promise).toBeInstanceOf(Promise)
+  })
+
+  it('should create independent instances', () => {
+    const deferred1 = createDeferred<string>()
+    const deferred2 = createDeferred<string>()
+
+    expect(deferred1).not.toBe(deferred2)
+    expect(deferred1.promise).not.toBe(deferred2.promise)
+  })
+})

package/src/__tests__/errors.spec.mts

@@ -0,0 +1,61 @@
+import { describe, expect, it } from 'vitest'
+
+import { ErrorsEnum } from '../errors/errors.enum.mjs'
+import {
+  FactoryNotFound,
+  InstanceDestroying,
+  InstanceExpired,
+} from '../errors/index.mjs'
+
+describe('Error Classes', () => {
+  describe('FactoryNotFound', () => {
+    it('should create error with proper message and code', () => {
+      const error = new FactoryNotFound('TestFactory')
+
+      expect(error.message).toBe('Factory TestFactory not found')
+      expect(error.code).toBe(ErrorsEnum.FactoryNotFound)
+      expect(error.name).toBe('TestFactory')
+      expect(error).toBeInstanceOf(Error)
+    })
+
+    it('should be throwable', () => {
+      expect(() => {
+        throw new FactoryNotFound('SomeFactory')
+      }).toThrow('Factory SomeFactory not found')
+    })
+  })
+
+  describe('InstanceDestroying', () => {
+    it('should create error with proper message and code', () => {
+      const error = new InstanceDestroying('TestInstance')
+
+      expect(error.message).toBe('Instance TestInstance destroying')
+      expect(error.code).toBe(ErrorsEnum.InstanceDestroying)
+      expect(error.name).toBe('TestInstance')
+      expect(error).toBeInstanceOf(Error)
+    })
+
+    it('should be throwable', () => {
+      expect(() => {
+        throw new InstanceDestroying('SomeInstance')
+      }).toThrow('Instance SomeInstance destroying')
+    })
+  })
+
+  describe('InstanceExpired', () => {
+    it('should create error with proper message and code', () => {
+      const error = new InstanceExpired('TestInstance')
+
+      expect(error.message).toBe('Instance TestInstance expired')
+      expect(error.code).toBe(ErrorsEnum.InstanceExpired)
+      expect(error.name).toBe('TestInstance')
+      expect(error).toBeInstanceOf(Error)
+    })
+
+    it('should be throwable', () => {
+      expect(() => {
+        throw new InstanceExpired('SomeInstance')
+      }).toThrow('Instance SomeInstance expired')
+    })
+  })
+})

package/src/__tests__/event-emitter.spec.mts

@@ -0,0 +1,163 @@
+import { describe, expect, it, vi } from 'vitest'
+
+import { EventEmitter } from '../event-emitter.mjs'
+
+describe('EventEmitter', () => {
+  it('should create an instance', () => {
+    const emitter = new EventEmitter()
+    expect(emitter).toBeDefined()
+  })
+
+  it('should add and trigger event listeners', async () => {
+    const emitter = new EventEmitter<{ test: [string] }>()
+    const mockListener = vi.fn()
+
+    emitter.on('test', mockListener)
+    await emitter.emit('test', 'hello')
+
+    expect(mockListener).toHaveBeenCalledWith('hello')
+    expect(mockListener).toHaveBeenCalledTimes(1)
+    emitter.off('test', mockListener)
+  })
+
+  it('should support multiple listeners for the same event', async () => {
+    const emitter = new EventEmitter<{ test: [string] }>()
+    const mockListener1 = vi.fn()
+    const mockListener2 = vi.fn()
+
+    emitter.on('test', mockListener1)
+    emitter.on('test', mockListener2)
+    await emitter.emit('test', 'hello')
+
+    expect(mockListener1).toHaveBeenCalledWith('hello')
+    expect(mockListener2).toHaveBeenCalledWith('hello')
+  })
+
+  it('should return unsubscribe function from on()', async () => {
+    const emitter = new EventEmitter<{ test: [string] }>()
+    const mockListener = vi.fn()
+
+    const unsubscribe = emitter.on('test', mockListener)
+    await emitter.emit('test', 'hello1')
+
+    unsubscribe()
+    await emitter.emit('test', 'hello2')
+
+    expect(mockListener).toHaveBeenCalledTimes(1)
+    expect(mockListener).toHaveBeenCalledWith('hello1')
+  })
+
+  it('should support off() method to remove listeners', async () => {
+    const emitter = new EventEmitter<{ test: [string] }>()
+    const mockListener = vi.fn()
+
+    emitter.on('test', mockListener)
+    await emitter.emit('test', 'hello1')
+
+    emitter.off('test', mockListener)
+    await emitter.emit('test', 'hello2')
+
+    expect(mockListener).toHaveBeenCalledTimes(1)
+    expect(mockListener).toHaveBeenCalledWith('hello1')
+  })
+
+  it('should handle off() for non-existent event', () => {
+    const emitter = new EventEmitter<{ test: [string] }>()
+    const mockListener = vi.fn()
+
+    expect(() => {
+      emitter.off('test', mockListener)
+    }).not.toThrow()
+  })
+
+  it('should clean up empty listener sets after removing all listeners', async () => {
+    const emitter = new EventEmitter<{ test: [string] }>()
+    const mockListener1 = vi.fn()
+    const mockListener2 = vi.fn()
+
+    emitter.on('test', mockListener1)
+    emitter.on('test', mockListener2)
+
+    emitter.off('test', mockListener1)
+    emitter.off('test', mockListener2)
+
+    // After removing all listeners, emitting should not call anything
+    await emitter.emit('test', 'hello')
+
+    expect(mockListener1).not.toHaveBeenCalled()
+    expect(mockListener2).not.toHaveBeenCalled()
+  })
+
+  it('should support once() method for one-time listeners', async () => {
+    const emitter = new EventEmitter<{ test: [string] }>()
+    const mockListener = vi.fn()
+
+    emitter.once('test', mockListener)
+    await emitter.emit('test', 'hello1')
+    await emitter.emit('test', 'hello2')
+
+    expect(mockListener).toHaveBeenCalledTimes(1)
+    expect(mockListener).toHaveBeenCalledWith('hello1')
+  })
+
+  it('should return unsubscribe function from once()', async () => {
+    const emitter = new EventEmitter<{ test: [string] }>()
+    const mockListener = vi.fn()
+
+    const unsubscribe = emitter.once('test', mockListener)
+    unsubscribe() // Remove before emitting
+    await emitter.emit('test', 'hello')
+
+    expect(mockListener).not.toHaveBeenCalled()
+  })
+
+  it('should handle emit() for non-existent event', async () => {
+    const emitter = new EventEmitter<{ test: [string] }>()
+
+    const result = await emitter.emit('test', 'hello')
+    expect(result).toBeUndefined()
+  })
+
+  it('should handle multiple arguments in events', async () => {
+    const emitter = new EventEmitter<{ test: [string, number, boolean] }>()
+    const mockListener = vi.fn()
+
+    emitter.on('test', mockListener)
+    await emitter.emit('test', 'hello', 42, true)
+
+    expect(mockListener).toHaveBeenCalledWith('hello', 42, true)
+  })
+
+  it('should handle async listeners', async () => {
+    const emitter = new EventEmitter<{ test: [string] }>()
+    const mockAsyncListener = vi.fn().mockResolvedValue('async result')
+
+    emitter.on('test', mockAsyncListener)
+    const results = await emitter.emit('test', 'hello')
+
+    expect(mockAsyncListener).toHaveBeenCalledWith('hello')
+    expect(results).toEqual(['async result'])
+  })
+
+  it('should handle multiple async listeners and return all results', async () => {
+    const emitter = new EventEmitter<{ test: [string] }>()
+    const mockAsyncListener1 = vi.fn().mockResolvedValue('result1')
+    const mockAsyncListener2 = vi.fn().mockResolvedValue('result2')
+
+    emitter.on('test', mockAsyncListener1)
+    emitter.on('test', mockAsyncListener2)
+    const results = await emitter.emit('test', 'hello')
+
+    expect(results).toEqual(['result1', 'result2'])
+  })
+
+  it('should work with no-argument events', async () => {
+    const emitter = new EventEmitter<{ test: [] }>()
+    const mockListener = vi.fn()
+
+    emitter.on('test', mockListener)
+    await emitter.emit('test')
+
+    expect(mockListener).toHaveBeenCalledWith()
+  })
+})

package/src/__tests__/get-injectors.spec.mts

@@ -0,0 +1,70 @@
+import { describe, expect, it } from 'vitest'
+
+import { Injectable, InjectableScope, InjectionToken } from '../index.mjs'
+import { getInjectors } from '../utils/get-injectors.mjs'
+
+@Injectable({ scope: InjectableScope.Singleton })
+class TestService {
+  constructor() {}
+}
+
+describe('getInjectors', () => {
+  it('should return injectors object with correct methods', () => {
+    const injectors = getInjectors()
+
+    expect(injectors).toBeDefined()
+    expect(typeof injectors.inject).toBe('function')
+    expect(typeof injectors.asyncInject).toBe('function')
+    expect(typeof injectors.wrapSyncInit).toBe('function')
+    expect(typeof injectors.provideFactoryContext).toBe('function')
+  })
+
+  it('should handle wrapSyncInit with simple function', () => {
+    const injectors = getInjectors()
+
+    const testFn = () => 'test result'
+    const wrappedFn = injectors.wrapSyncInit(testFn)
+
+    const result = wrappedFn()
+    expect(result).toHaveLength(3) // [result, promises, injectState]
+    expect(result[0]).toBe('test result')
+    expect(result[1]).toEqual([]) // no promises
+  })
+
+  it('should handle inject method when called outside context', () => {
+    const injectors = getInjectors()
+
+    // This should throw when called outside of injection context
+    expect(() => injectors.inject(TestService)).toThrow()
+  })
+
+  it('should handle asyncInject method when called outside context', async () => {
+    const injectors = getInjectors()
+    const testToken = new InjectionToken<string>('TestToken', undefined)
+
+    // This should throw since we're calling outside of an injectable context
+    try {
+      await injectors.asyncInject(testToken)
+      expect.fail('Should have thrown an error')
+    } catch (error) {
+      expect(error).toBeInstanceOf(Error)
+      expect((error as Error).message).toBe(
+        '[Injector] Trying to access inject outside of a injectable context',
+      )
+    }
+  })
+
+  it('should handle provideFactoryContext without context', () => {
+    const injectors = getInjectors()
+
+    const mockContext = {
+      inject: injectors.asyncInject,
+      locator: {} as any,
+      addDestroyListener: () => {},
+    }
+
+    // This should work but not have much effect without a real context
+    const result = injectors.provideFactoryContext(mockContext)
+    expect(result).toBeNull()
+  })
+})