@navios/di 0.3.1 → 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

@@ -238,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', () => {
@@ -270,11 +269,11 @@ describe('Request Scope', () => {
       holder.addInstance(token, instance)
 
       // Verify instance is stored and retrievable
-      expect(holder.hasInstance(token.toString())).toBe(true)
-      expect(holder.getInstance(token.toString())).toBe(instance)
+      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.getHolder(token.toString())
+      const holderInfo = holder.get(token.toString())
       expect(holderInfo).toBeDefined()
       expect(holderInfo?.instance).toBe(instance)
       expect(holderInfo?.name).toBe(token.toString())
@@ -297,18 +296,18 @@ describe('Request Scope', () => {
       holder.addInstance(token3, instance3)
 
       // Verify all instances are stored correctly
-      expect(holder.hasInstance(token1.toString())).toBe(true)
-      expect(holder.hasInstance(token2.toString())).toBe(true)
-      expect(holder.hasInstance(token3.toString())).toBe(true)
+      expect(holder.has(token1.toString())).toBe(true)
+      expect(holder.has(token2.toString())).toBe(true)
+      expect(holder.has(token3.toString())).toBe(true)
 
-      expect(holder.getInstance(token1.toString())).toBe(instance1)
-      expect(holder.getInstance(token2.toString())).toBe(instance2)
-      expect(holder.getInstance(token3.toString())).toBe(instance3)
+      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.getHolder(token1.toString())
-      const holder2 = holder.getHolder(token2.toString())
-      const holder3 = holder.getHolder(token3.toString())
+      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)
@@ -324,15 +323,15 @@ describe('Request Scope', () => {
 
       // Store original instance
       holder.addInstance(token, originalInstance)
-      expect(holder.getInstance(token.toString())).toBe(originalInstance)
+      expect(holder.get(token.toString())?.instance).toBe(originalInstance)
 
       // Override with new instance
       holder.addInstance(token, newInstance)
-      expect(holder.getInstance(token.toString())).toBe(newInstance)
-      expect(holder.getInstance(token.toString())).not.toBe(originalInstance)
+      expect(holder.get(token.toString())?.instance).toBe(newInstance)
+      expect(holder.get(token.toString())?.instance).not.toBe(originalInstance)
 
       // Verify holder is updated
-      const holderInfo = holder.getHolder(token.toString())
+      const holderInfo = holder.get(token.toString())
       expect(holderInfo?.instance).toBe(newInstance)
     })
 
@@ -356,9 +355,9 @@ describe('Request Scope', () => {
       holder.addInstance(symbolToken, symbolInstance)
       holder.addInstance(classToken, classInstance)
 
-      expect(holder.getInstance(stringToken.toString())).toBe(stringInstance)
-      expect(holder.getInstance(symbolToken.toString())).toBe(symbolInstance)
-      expect(holder.getInstance(classToken.toString())).toBe(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', () => {
@@ -372,16 +371,16 @@ describe('Request Scope', () => {
       holder.addInstance(token1, instance1)
       holder.addInstance(token2, instance2)
 
-      expect(holder.hasInstance(token1.toString())).toBe(true)
-      expect(holder.hasInstance(token2.toString())).toBe(true)
+      expect(holder.has(token1.toString())).toBe(true)
+      expect(holder.has(token2.toString())).toBe(true)
 
       // Clear all instances
       holder.clear()
 
-      expect(holder.hasInstance(token1.toString())).toBe(false)
-      expect(holder.hasInstance(token2.toString())).toBe(false)
-      expect(holder.getInstance(token1.toString())).toBeUndefined()
-      expect(holder.getInstance(token2.toString())).toBeUndefined()
+      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', () => {
@@ -413,15 +412,15 @@ describe('Request Scope', () => {
       holder.addInstance(stringName, stringInstance, mockHolder)
 
       // Verify both are stored correctly
-      expect(holder.hasInstance(token.toString())).toBe(true)
-      expect(holder.hasInstance(stringName)).toBe(true)
+      expect(holder.has(token.toString())).toBe(true)
+      expect(holder.has(stringName)).toBe(true)
 
-      expect(holder.getInstance(token.toString())).toBe(tokenInstance)
-      expect(holder.getInstance(stringName)).toBe(stringInstance)
+      expect(holder.get(token.toString())?.instance).toBe(tokenInstance)
+      expect(holder.get(stringName)?.instance).toBe(stringInstance)
 
       // Verify holders
-      expect(holder.getHolder(token.toString())?.instance).toBe(tokenInstance)
-      expect(holder.getHolder(stringName)?.instance).toBe(stringInstance)
+      expect(holder.get(token.toString())?.instance).toBe(tokenInstance)
+      expect(holder.get(stringName)?.instance).toBe(stringInstance)
     })
   })
 })