@navios/di 0.3.0 → 0.4.0

package/src/__tests__/registry.spec.mts

@@ -0,0 +1,335 @@
+import { beforeEach, describe, expect, it } from 'vitest'
+
+import { InjectableScope, InjectableType } from '../enums/index.mjs'
+import { InjectionToken } from '../injection-token.mjs'
+import { globalRegistry, Registry } from '../registry.mjs'
+
+class TestService {}
+class AnotherService {}
+
+describe('Registry', () => {
+  let registry: Registry
+  let token1: InjectionToken<TestService, undefined>
+  let token2: InjectionToken<AnotherService, undefined>
+
+  beforeEach(() => {
+    registry = new Registry()
+    token1 = new InjectionToken<TestService, undefined>(
+      'TestService',
+      undefined,
+    )
+    token2 = new InjectionToken<AnotherService, undefined>(
+      'AnotherService',
+      undefined,
+    )
+  })
+
+  describe('constructor', () => {
+    it('should create registry without parent', () => {
+      const reg = new Registry()
+      expect(reg).toBeDefined()
+    })
+
+    it('should create registry with parent', () => {
+      const parentRegistry = new Registry()
+      const childRegistry = new Registry(parentRegistry)
+      expect(childRegistry).toBeDefined()
+    })
+  })
+
+  describe('set', () => {
+    it('should set factory record for token', () => {
+      registry.set(
+        token1,
+        InjectableScope.Singleton,
+        TestService,
+        InjectableType.Class,
+      )
+
+      expect(registry.has(token1)).toBe(true)
+    })
+
+    it('should set multiple factory records', () => {
+      registry.set(
+        token1,
+        InjectableScope.Singleton,
+        TestService,
+        InjectableType.Class,
+      )
+      registry.set(
+        token2,
+        InjectableScope.Transient,
+        AnotherService,
+        InjectableType.Factory,
+      )
+
+      expect(registry.has(token1)).toBe(true)
+      expect(registry.has(token2)).toBe(true)
+    })
+
+    it('should overwrite existing factory record', () => {
+      registry.set(
+        token1,
+        InjectableScope.Singleton,
+        TestService,
+        InjectableType.Class,
+      )
+      registry.set(
+        token1,
+        InjectableScope.Transient,
+        TestService,
+        InjectableType.Factory,
+      )
+
+      const record = registry.get(token1)
+      expect(record.scope).toBe(InjectableScope.Transient)
+      expect(record.type).toBe(InjectableType.Factory)
+    })
+  })
+
+  describe('has', () => {
+    it('should return false for non-existent token', () => {
+      expect(registry.has(token1)).toBe(false)
+    })
+
+    it('should return true for existing token', () => {
+      registry.set(
+        token1,
+        InjectableScope.Singleton,
+        TestService,
+        InjectableType.Class,
+      )
+      expect(registry.has(token1)).toBe(true)
+    })
+
+    it('should check parent registry when token not found locally', () => {
+      const parentRegistry = new Registry()
+      const childRegistry = new Registry(parentRegistry)
+
+      parentRegistry.set(
+        token1,
+        InjectableScope.Singleton,
+        TestService,
+        InjectableType.Class,
+      )
+
+      expect(childRegistry.has(token1)).toBe(true)
+    })
+
+    it('should return false when token not found in parent chain', () => {
+      const parentRegistry = new Registry()
+      const childRegistry = new Registry(parentRegistry)
+
+      expect(childRegistry.has(token1)).toBe(false)
+    })
+
+    it('should prioritize local registry over parent', () => {
+      const parentRegistry = new Registry()
+      const childRegistry = new Registry(parentRegistry)
+
+      parentRegistry.set(
+        token1,
+        InjectableScope.Singleton,
+        TestService,
+        InjectableType.Class,
+      )
+      childRegistry.set(
+        token1,
+        InjectableScope.Transient,
+        TestService,
+        InjectableType.Factory,
+      )
+
+      expect(childRegistry.has(token1)).toBe(true)
+      const record = childRegistry.get(token1)
+      expect(record.scope).toBe(InjectableScope.Transient) // From child registry
+    })
+  })
+
+  describe('get', () => {
+    it('should return factory record for existing token', () => {
+      registry.set(
+        token1,
+        InjectableScope.Singleton,
+        TestService,
+        InjectableType.Class,
+      )
+
+      const record = registry.get(token1)
+      expect(record.scope).toBe(InjectableScope.Singleton)
+      expect(record.target).toBe(TestService)
+      expect(record.type).toBe(InjectableType.Class)
+      expect(record.originalToken).toBe(token1)
+    })
+
+    it('should throw error for non-existent token', () => {
+      expect(() => {
+        registry.get(token1)
+      }).toThrow(`[Registry] No factory found for ${token1.toString()}`)
+    })
+
+    it('should get from parent registry when not found locally', () => {
+      const parentRegistry = new Registry()
+      const childRegistry = new Registry(parentRegistry)
+
+      parentRegistry.set(
+        token1,
+        InjectableScope.Singleton,
+        TestService,
+        InjectableType.Class,
+      )
+
+      const record = childRegistry.get(token1)
+      expect(record.scope).toBe(InjectableScope.Singleton)
+      expect(record.target).toBe(TestService)
+    })
+
+    it('should throw error when token not found in parent chain', () => {
+      const parentRegistry = new Registry()
+      const childRegistry = new Registry(parentRegistry)
+
+      expect(() => {
+        childRegistry.get(token1)
+      }).toThrow(`[Registry] No factory found for ${token1.toString()}`)
+    })
+
+    it('should prioritize local registry over parent', () => {
+      const parentRegistry = new Registry()
+      const childRegistry = new Registry(parentRegistry)
+
+      parentRegistry.set(
+        token1,
+        InjectableScope.Singleton,
+        TestService,
+        InjectableType.Class,
+      )
+      childRegistry.set(
+        token1,
+        InjectableScope.Transient,
+        AnotherService,
+        InjectableType.Factory,
+      )
+
+      const record = childRegistry.get(token1)
+      expect(record.scope).toBe(InjectableScope.Transient)
+      expect(record.target).toBe(AnotherService)
+      expect(record.type).toBe(InjectableType.Factory)
+    })
+  })
+
+  describe('delete', () => {
+    it('should delete existing token', () => {
+      registry.set(
+        token1,
+        InjectableScope.Singleton,
+        TestService,
+        InjectableType.Class,
+      )
+      expect(registry.has(token1)).toBe(true)
+
+      registry.delete(token1)
+      expect(registry.has(token1)).toBe(false)
+    })
+
+    it('should not affect parent registry when deleting from child', () => {
+      const parentRegistry = new Registry()
+      const childRegistry = new Registry(parentRegistry)
+
+      parentRegistry.set(
+        token1,
+        InjectableScope.Singleton,
+        TestService,
+        InjectableType.Class,
+      )
+      childRegistry.set(
+        token1,
+        InjectableScope.Transient,
+        AnotherService,
+        InjectableType.Factory,
+      )
+
+      childRegistry.delete(token1)
+
+      // Child should no longer have it
+      expect(childRegistry.has(token1)).toBe(true) // Still true because it exists in parent
+      // But getting it should return parent's version
+      const record = childRegistry.get(token1)
+      expect(record.scope).toBe(InjectableScope.Singleton) // From parent
+    })
+
+    it('should handle delete for non-existent token gracefully', () => {
+      expect(() => {
+        registry.delete(token1)
+      }).not.toThrow()
+    })
+  })
+
+  describe('complex parent-child scenarios', () => {
+    it('should handle deep hierarchy', () => {
+      const grandParent = new Registry()
+      const parent = new Registry(grandParent)
+      const child = new Registry(parent)
+
+      grandParent.set(
+        token1,
+        InjectableScope.Singleton,
+        TestService,
+        InjectableType.Class,
+      )
+
+      expect(child.has(token1)).toBe(true)
+      const record = child.get(token1)
+      expect(record.scope).toBe(InjectableScope.Singleton)
+    })
+
+    it('should handle overriding at different levels', () => {
+      const grandParent = new Registry()
+      const parent = new Registry(grandParent)
+      const child = new Registry(parent)
+
+      grandParent.set(
+        token1,
+        InjectableScope.Singleton,
+        TestService,
+        InjectableType.Class,
+      )
+      parent.set(
+        token1,
+        InjectableScope.Transient,
+        AnotherService,
+        InjectableType.Factory,
+      )
+
+      const record = child.get(token1)
+      expect(record.scope).toBe(InjectableScope.Transient) // From parent, not grandparent
+      expect(record.target).toBe(AnotherService)
+    })
+  })
+})
+
+describe('globalRegistry', () => {
+  it('should be a Registry instance', () => {
+    expect(globalRegistry).toBeInstanceOf(Registry)
+  })
+
+  it('should be able to store and retrieve tokens', () => {
+    const token = new InjectionToken<TestService, undefined>(
+      'GlobalTest',
+      undefined,
+    )
+
+    globalRegistry.set(
+      token,
+      InjectableScope.Singleton,
+      TestService,
+      InjectableType.Class,
+    )
+    expect(globalRegistry.has(token)).toBe(true)
+
+    const record = globalRegistry.get(token)
+    expect(record.target).toBe(TestService)
+
+    // Clean up
+    globalRegistry.delete(token)
+  })
+})

package/src/__tests__/request-scope.spec.mts

@@ -4,6 +4,7 @@ import { Container } from '../container.mjs'
 import { Injectable } from '../decorators/injectable.decorator.mjs'
 import { InjectableScope } from '../enums/index.mjs'
 import { inject } from '../index.mjs'
+import { InjectionToken } from '../injection-token.mjs'
 import { Registry } from '../registry.mjs'
 import { createRequestContextHolder } from '../request-context-holder.mjs'
 
@@ -237,13 +238,12 @@ describe('Request Scope', () => {
 
       holder.addInstance('test-instance', mockInstance, mockHolder)
 
-      expect(holder.hasInstance('test-instance')).toBe(true)
-      expect(holder.getInstance('test-instance')).toBe(mockInstance)
-      expect(holder.getHolder('test-instance')).toBe(mockHolder)
+      expect(holder.has('test-instance')).toBe(true)
+      expect(holder.get('test-instance')).toBe(mockHolder)
 
       // Clear instances
       holder.clear()
-      expect(holder.hasInstance('test-instance')).toBe(false)
+      expect(holder.has('test-instance')).toBe(false)
     })
 
     it('should handle metadata correctly', () => {
@@ -259,5 +259,168 @@ describe('Request Scope', () => {
       holder.clear()
       expect(holder.getMetadata('key1')).toBeUndefined()
     })
+
+    it('should store instances by InjectionToken', () => {
+      const holder = createRequestContextHolder('test-request')
+      const token = InjectionToken.create<string>('TestService')
+      const instance = { id: 'test-instance', data: 'test-data' }
+
+      // Store instance by InjectionToken
+      holder.addInstance(token, instance)
+
+      // Verify instance is stored and retrievable
+      expect(holder.has(token.toString())).toBe(true)
+      expect(holder.get(token.toString())?.instance).toBe(instance)
+
+      // Verify holder is created with correct properties
+      const holderInfo = holder.get(token.toString())
+      expect(holderInfo).toBeDefined()
+      expect(holderInfo?.instance).toBe(instance)
+      expect(holderInfo?.name).toBe(token.toString())
+    })
+
+    it('should store multiple instances by different InjectionTokens', () => {
+      const holder = createRequestContextHolder('test-request')
+
+      const token1 = InjectionToken.create<string>('Service1')
+      const token2 = InjectionToken.create<number>('Service2')
+      const token3 = InjectionToken.create<boolean>('Service3')
+
+      const instance1 = { id: 'instance1', type: 'string' }
+      const instance2 = { id: 'instance2', type: 'number' }
+      const instance3 = { id: 'instance3', type: 'boolean' }
+
+      // Store multiple instances
+      holder.addInstance(token1, instance1)
+      holder.addInstance(token2, instance2)
+      holder.addInstance(token3, instance3)
+
+      // Verify all instances are stored correctly
+      expect(holder.has(token1.toString())).toBe(true)
+      expect(holder.has(token2.toString())).toBe(true)
+      expect(holder.has(token3.toString())).toBe(true)
+
+      expect(holder.get(token1.toString())?.instance).toBe(instance1)
+      expect(holder.get(token2.toString())?.instance).toBe(instance2)
+      expect(holder.get(token3.toString())?.instance).toBe(instance3)
+
+      // Verify each has its own holder
+      const holder1 = holder.get(token1.toString())
+      const holder2 = holder.get(token2.toString())
+      const holder3 = holder.get(token3.toString())
+
+      expect(holder1?.instance).toBe(instance1)
+      expect(holder2?.instance).toBe(instance2)
+      expect(holder3?.instance).toBe(instance3)
+    })
+
+    it('should override instances stored by InjectionToken', () => {
+      const holder = createRequestContextHolder('test-request')
+      const token = InjectionToken.create<string>('TestService')
+
+      const originalInstance = { id: 'original', data: 'original-data' }
+      const newInstance = { id: 'new', data: 'new-data' }
+
+      // Store original instance
+      holder.addInstance(token, originalInstance)
+      expect(holder.get(token.toString())?.instance).toBe(originalInstance)
+
+      // Override with new instance
+      holder.addInstance(token, newInstance)
+      expect(holder.get(token.toString())?.instance).toBe(newInstance)
+      expect(holder.get(token.toString())?.instance).not.toBe(originalInstance)
+
+      // Verify holder is updated
+      const holderInfo = holder.get(token.toString())
+      expect(holderInfo?.instance).toBe(newInstance)
+    })
+
+    it('should handle InjectionToken with different name types', () => {
+      const holder = createRequestContextHolder('test-request')
+
+      // Test with string name
+      const stringToken = InjectionToken.create<string>('StringService')
+      const stringInstance = { type: 'string' }
+
+      // Test with symbol name
+      const symbolToken = InjectionToken.create<number>(Symbol('SymbolService'))
+      const symbolInstance = { type: 'symbol' }
+
+      // Test with class name
+      class TestClass {}
+      const classToken = InjectionToken.create(TestClass)
+      const classInstance = { type: 'class' }
+
+      holder.addInstance(stringToken, stringInstance)
+      holder.addInstance(symbolToken, symbolInstance)
+      holder.addInstance(classToken, classInstance)
+
+      expect(holder.get(stringToken.toString())?.instance).toBe(stringInstance)
+      expect(holder.get(symbolToken.toString())?.instance).toBe(symbolInstance)
+      expect(holder.get(classToken.toString())?.instance).toBe(classInstance)
+    })
+
+    it('should clear instances stored by InjectionToken', () => {
+      const holder = createRequestContextHolder('test-request')
+      const token1 = InjectionToken.create<string>('Service1')
+      const token2 = InjectionToken.create<number>('Service2')
+
+      const instance1 = { id: 'instance1' }
+      const instance2 = { id: 'instance2' }
+
+      holder.addInstance(token1, instance1)
+      holder.addInstance(token2, instance2)
+
+      expect(holder.has(token1.toString())).toBe(true)
+      expect(holder.has(token2.toString())).toBe(true)
+
+      // Clear all instances
+      holder.clear()
+
+      expect(holder.has(token1.toString())).toBe(false)
+      expect(holder.has(token2.toString())).toBe(false)
+      expect(holder.get(token1.toString())?.instance).toBeUndefined()
+      expect(holder.get(token2.toString())?.instance).toBeUndefined()
+    })
+
+    it('should handle mixed storage by InjectionToken and string name', () => {
+      const holder = createRequestContextHolder('test-request')
+
+      const token = InjectionToken.create<string>('TokenService')
+      const tokenInstance = { id: 'token-instance' }
+
+      const stringName = 'string-service'
+      const stringInstance = { id: 'string-instance' }
+
+      // Store by InjectionToken
+      holder.addInstance(token, tokenInstance)
+
+      // Store by string name (requires holder)
+      const mockHolder = {
+        status: 'Created' as any,
+        name: stringName,
+        instance: stringInstance,
+        creationPromise: null,
+        destroyPromise: null,
+        type: 'Class' as any,
+        scope: 'Singleton' as any,
+        deps: new Set<string>(),
+        destroyListeners: [],
+        createdAt: Date.now(),
+        ttl: Infinity,
+      }
+      holder.addInstance(stringName, stringInstance, mockHolder)
+
+      // Verify both are stored correctly
+      expect(holder.has(token.toString())).toBe(true)
+      expect(holder.has(stringName)).toBe(true)
+
+      expect(holder.get(token.toString())?.instance).toBe(tokenInstance)
+      expect(holder.get(stringName)?.instance).toBe(stringInstance)
+
+      // Verify holders
+      expect(holder.get(token.toString())?.instance).toBe(tokenInstance)
+      expect(holder.get(stringName)?.instance).toBe(stringInstance)
+    })
   })
 })