@navios/di 0.4.2 → 0.5.0

package/lib/testing/index.mjs

@@ -1,4 +1,4 @@
-import { Injectable, __decoratorStart, __decorateElement, __runInitializers, Container, globalRegistry, getInjectableToken } from '../chunk-3NLYPYBY.mjs';
+import { Injectable, __decoratorStart, __decorateElement, __runInitializers, Container, globalRegistry, getInjectableToken } from '../chunk-44F3LXW5.mjs';
 
 // src/testing/test-container.mts
 var TestBindingBuilder = class {

package/package.json

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

package/src/__tests__/container.spec.mts

@@ -1,3 +1,4 @@
+// oxlint-disable no-unused-vars
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 import { z } from 'zod/v4'
 
@@ -16,7 +17,6 @@ import { InjectionToken } from '../injection-token.mjs'
 import { asyncInject, inject } from '../injector.mjs'
 import { Registry } from '../registry.mjs'
 import { ServiceLocator } from '../service-locator.mjs'
-import { createDeferred } from '../utils/defer.mjs'
 
 describe('Container', () => {
   let container: Container
@@ -321,7 +321,6 @@ describe('Container', () => {
           }
         }
 
-        @Injectable({ registry })
         class TestService {
           constructor(
             public readonly name: string,
@@ -359,7 +358,6 @@ describe('Container', () => {
           }
         }
 
-        @Injectable({ registry })
         class TestService {
           constructor(
             public readonly name: string,
@@ -394,7 +392,6 @@ describe('Container', () => {
           }
         }
 
-        @Injectable({ registry })
         class TestService {
           constructor(public readonly type: string) {}
         }
@@ -450,7 +447,6 @@ describe('Container', () => {
           }
         }
 
-        @Injectable({ registry })
         class TestService {
           constructor(public readonly factory: string) {}
         }
@@ -751,7 +747,7 @@ describe('Container', () => {
 
   describe('Ready method and async operations', () => {
     it('should wait for all pending operations', async () => {
-      const deferred = createDeferred<string>()
+      const deferred = Promise.withResolvers<string>()
 
       @Factory({ registry })
       class AsyncFactory implements Factorable<TestService> {
@@ -761,7 +757,6 @@ describe('Container', () => {
         }
       }
 
-      @Injectable({ registry })
       class TestService {
         constructor(public readonly value: string) {}
       }
@@ -779,8 +774,8 @@ describe('Container', () => {
     })
 
     it('should handle multiple concurrent operations', async () => {
-      const deferred1 = createDeferred<string>()
-      const deferred2 = createDeferred<string>()
+      const deferred1 = Promise.withResolvers<string>()
+      const deferred2 = Promise.withResolvers<string>()
 
       @Factory({ registry })
       class AsyncFactory1 implements Factorable<TestService> {
@@ -798,7 +793,6 @@ describe('Container', () => {
         }
       }
 
-      @Injectable({ registry })
       class TestService {
         constructor(public readonly value: string) {}
       }
@@ -817,7 +811,7 @@ describe('Container', () => {
     })
 
     it.skip('should handle factory errors in ready state', async () => {
-      const deferred = createDeferred<string>()
+      const deferred = Promise.withResolvers<string>()
 
       @Factory({ registry })
       class ErrorFactory implements Factorable<TestService> {
@@ -826,13 +820,13 @@ describe('Container', () => {
           if (result === 'error') {
             throw new Error('Factory error')
           }
-          return new TestService(result)
+          return new TestService()
         }
       }
 
       @Injectable({ registry })
       class TestService {
-        constructor(public readonly value: string) {}
+        constructor() {}
       }
 
       const promise = container.get(ErrorFactory)
@@ -1135,6 +1129,46 @@ describe('Container', () => {
         expect(level1_1.id).not.toBe(level1_2.id)
       })
 
+      it('should invalidate services with nested inject dependencies in request context', async () => {
+        @Injectable({ registry, scope: InjectableScope.Request })
+        class Level1Service {
+          public id = Math.random()
+        }
+
+        @Injectable({ registry })
+        class Level2Service {
+          level1 = inject(Level1Service)
+          public id = Math.random()
+        }
+
+        @Injectable({ registry })
+        class RootService {
+          level2 = inject(Level2Service)
+        }
+
+        container.beginRequest('request-1')
+
+        const root1 = await container.get(RootService)
+        const level2_1 = root1.level2
+        const level1_1 = level2_1.level1
+
+        // Invalidate the root service
+        await container.invalidate(level1_1)
+
+        const root2 = await container.get(RootService)
+        const level2_2 = root2.level2
+        const level1_2 = level2_2.level1
+
+        // All should be new instances
+        expect(root1).not.toBe(root2)
+        expect(level2_1).not.toBe(level2_2)
+        expect(level1_1).not.toBe(level1_2)
+        expect(level2_1.id).not.toBe(level2_2.id)
+        expect(level1_1.id).not.toBe(level1_2.id)
+
+        await container.endRequest('request-1')
+      })
+
       it('should handle invalidation of services with mixed inject and asyncInject', async () => {
         @Injectable({ registry })
         class AsyncService {

package/src/__tests__/errors.spec.mts

@@ -1,61 +1,87 @@
 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', () => {
+import { DIError, DIErrorCode } from '../errors/index.mjs'
+
+describe('DIError', () => {
+  describe('factoryNotFound', () => {
     it('should create error with proper message and code', () => {
-      const error = new FactoryNotFound('TestFactory')
+      const error = DIError.factoryNotFound('TestFactory')
 
       expect(error.message).toBe('Factory TestFactory not found')
-      expect(error.code).toBe(ErrorsEnum.FactoryNotFound)
-      expect(error.name).toBe('TestFactory')
+      expect(error.code).toBe(DIErrorCode.FactoryNotFound)
+      expect(error.context?.name).toBe('TestFactory')
+      expect(error).toBeInstanceOf(DIError)
       expect(error).toBeInstanceOf(Error)
     })
 
     it('should be throwable', () => {
       expect(() => {
-        throw new FactoryNotFound('SomeFactory')
+        throw DIError.factoryNotFound('SomeFactory')
       }).toThrow('Factory SomeFactory not found')
     })
   })
 
-  describe('InstanceDestroying', () => {
+  describe('instanceDestroying', () => {
     it('should create error with proper message and code', () => {
-      const error = new InstanceDestroying('TestInstance')
+      const error = DIError.instanceDestroying('TestInstance')
 
       expect(error.message).toBe('Instance TestInstance destroying')
-      expect(error.code).toBe(ErrorsEnum.InstanceDestroying)
-      expect(error.name).toBe('TestInstance')
+      expect(error.code).toBe(DIErrorCode.InstanceDestroying)
+      expect(error.context?.name).toBe('TestInstance')
+      expect(error).toBeInstanceOf(DIError)
       expect(error).toBeInstanceOf(Error)
     })
 
     it('should be throwable', () => {
       expect(() => {
-        throw new InstanceDestroying('SomeInstance')
+        throw DIError.instanceDestroying('SomeInstance')
       }).toThrow('Instance SomeInstance destroying')
     })
   })
 
-  describe('InstanceExpired', () => {
+  describe('instanceNotFound', () => {
     it('should create error with proper message and code', () => {
-      const error = new InstanceExpired('TestInstance')
+      const error = DIError.instanceNotFound('TestInstance')
 
-      expect(error.message).toBe('Instance TestInstance expired')
-      expect(error.code).toBe(ErrorsEnum.InstanceExpired)
-      expect(error.name).toBe('TestInstance')
+      expect(error.message).toBe('Instance TestInstance not found')
+      expect(error.code).toBe(DIErrorCode.InstanceNotFound)
+      expect(error.context?.name).toBe('TestInstance')
+      expect(error).toBeInstanceOf(DIError)
       expect(error).toBeInstanceOf(Error)
     })
+  })
 
-    it('should be throwable', () => {
-      expect(() => {
-        throw new InstanceExpired('SomeInstance')
-      }).toThrow('Instance SomeInstance expired')
+  describe('factoryTokenNotResolved', () => {
+    it('should create error with proper message and code', () => {
+      const error = DIError.factoryTokenNotResolved('TestToken')
+
+      expect(error.message).toBe('Factory token not resolved: TestToken')
+      expect(error.code).toBe(DIErrorCode.FactoryTokenNotResolved)
+      expect(error.context?.token).toBe('TestToken')
+      expect(error).toBeInstanceOf(DIError)
+      expect(error).toBeInstanceOf(Error)
+    })
+  })
+
+  describe('unknown', () => {
+    it('should create error with string message', () => {
+      const error = DIError.unknown('Test error message')
+
+      expect(error.message).toBe('Test error message')
+      expect(error.code).toBe(DIErrorCode.UnknownError)
+      expect(error).toBeInstanceOf(DIError)
+      expect(error).toBeInstanceOf(Error)
+    })
+
+    it('should create error with Error object', () => {
+      const originalError = new Error('Original error')
+      const error = DIError.unknown(originalError)
+
+      expect(error.message).toBe('Original error')
+      expect(error.code).toBe(DIErrorCode.UnknownError)
+      expect(error.context?.parent).toBe(originalError)
+      expect(error).toBeInstanceOf(DIError)
+      expect(error).toBeInstanceOf(Error)
     })
   })
 })

package/src/__tests__/injectable.spec.mts

@@ -170,4 +170,77 @@ describe('Injectable decorator', () => {
     expect(value).toBeInstanceOf(TestOuter)
     expect(value.foo).toBeInstanceOf(TestInner)
   })
+
+  it('should work with inject and Transient services', async () => {
+    @Injectable({ scope: InjectableScope.Transient })
+    class TransientService {
+      value = Math.random()
+
+      getValue() {
+        return this.value
+      }
+    }
+
+    @Injectable()
+    class ConsumerService {
+      private readonly transientService = inject(TransientService)
+
+      async getTransientValue() {
+        // Service should be available in async methods after initialization
+        return this.transientService.getValue()
+      }
+
+      // Synchronous access should work after initialization
+      getTransientValueSync() {
+        return this.transientService.getValue()
+      }
+    }
+
+    const consumer1 = await container.get(ConsumerService)
+    expect(consumer1).toBeInstanceOf(ConsumerService)
+
+    const value1 = await consumer1.getTransientValue()
+    expect(typeof value1).toBe('number')
+
+    const value2 = consumer1.getTransientValueSync()
+    expect(value2).toBe(value1) // Should be the same instance
+
+    // Each consumer gets a new transient instance
+    const consumer2 = await container.get(ConsumerService)
+    expect(consumer2).toBe(consumer1) // Consumer is singleton
+
+    const value3 = await consumer2.getTransientValue()
+    expect(value3).toBe(value1) // Same transient instance for same consumer
+  })
+
+  it('should track async dependencies with inject for Transient services', async () => {
+    @Injectable({ scope: InjectableScope.Transient })
+    class AsyncTransientService {
+      private initialized = false
+
+      async onServiceInit() {
+        await new Promise((resolve) => setTimeout(resolve, 10))
+        this.initialized = true
+      }
+
+      isInitialized() {
+        return this.initialized
+      }
+    }
+
+    @Injectable()
+    class AsyncConsumerService {
+      private readonly transientService = inject(AsyncTransientService)
+
+      async checkInitialization() {
+        return this.transientService.isInitialized()
+      }
+    }
+
+    const consumer = await container.get(AsyncConsumerService)
+    expect(consumer).toBeInstanceOf(AsyncConsumerService)
+
+    const isInitialized = await consumer.checkInitialization()
+    expect(isInitialized).toBe(true) // Should be initialized after container.get()
+  })
 })

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

@@ -233,7 +233,6 @@ describe('Request Scope', () => {
         deps: new Set<string>(),
         destroyListeners: [],
         createdAt: Date.now(),
-        ttl: Infinity,
       }
 
       holder.addInstance('test-instance', mockInstance, mockHolder)
@@ -407,7 +406,6 @@ describe('Request Scope', () => {
         deps: new Set<string>(),
         destroyListeners: [],
         createdAt: Date.now(),
-        ttl: Infinity,
       }
       holder.addInstance(stringName, stringInstance, mockHolder)
 

package/src/__tests__/service-locator-manager.spec.mts

@@ -1,11 +1,7 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 import { InjectableScope, InjectableType } from '../enums/index.mjs'
-import {
-  InstanceDestroying,
-  InstanceExpired,
-  InstanceNotFound,
-} from '../errors/index.mjs'
+import { DIError } from '../errors/index.mjs'
 import { ServiceLocatorInstanceHolderStatus } from '../service-locator-instance-holder.mjs'
 import { ServiceLocatorManager } from '../service-locator-manager.mjs'
 
@@ -32,11 +28,11 @@ describe('ServiceLocatorManager', () => {
   })
 
   describe('get', () => {
-    it('should return InstanceNotFound for non-existent instance', () => {
+    it('should return DIError.instanceNotFound for non-existent instance', () => {
       const result = manager.get('non-existent')
 
       expect(result).toHaveLength(1)
-      expect(result[0]).toBeInstanceOf(InstanceNotFound)
+      expect(result[0]).toBeInstanceOf(DIError)
       expect(mockLogger.log).toHaveBeenCalledWith(
         '[ServiceLocatorManager]#getInstanceHolder() Instance non-existent not found',
       )
@@ -57,30 +53,7 @@ describe('ServiceLocatorManager', () => {
       expect(result[1]).toBe(holder)
     })
 
-    it('should return InstanceExpired for expired instance with TTL', () => {
-      const holder = manager.storeCreatedHolder(
-        'expired-instance',
-        { value: 'test' },
-        InjectableType.Class,
-        InjectableScope.Singleton,
-        new Set(),
-        100, // 100ms TTL
-      )
-
-      // Manually set creation time to past
-      holder.createdAt = Date.now() - 200
-
-      const result = manager.get('expired-instance')
-
-      expect(result).toHaveLength(2)
-      expect(result[0]).toBeInstanceOf(InstanceExpired)
-      expect(result[1]).toBe(holder)
-      expect(mockLogger.log).toHaveBeenCalledWith(
-        '[ServiceLocatorManager]#getInstanceHolder() TTL expired for expired-instance',
-      )
-    })
-
-    it('should return InstanceDestroying for destroying instance', () => {
+    it('should return DIError.instanceDestroying for destroying instance', () => {
       const holder = manager.storeCreatedHolder(
         'destroying-instance',
         { value: 'test' },
@@ -94,7 +67,7 @@ describe('ServiceLocatorManager', () => {
       const result = manager.get('destroying-instance')
 
       expect(result).toHaveLength(2)
-      expect(result[0]).toBeInstanceOf(InstanceDestroying)
+      expect(result[0]).toBeInstanceOf(DIError)
       expect(result[1]).toBe(holder)
       expect(mockLogger.log).toHaveBeenCalledWith(
         '[ServiceLocatorManager]#getInstanceHolder() Instance destroying-instance is destroying',
@@ -111,35 +84,18 @@ describe('ServiceLocatorManager', () => {
 
       // Manually set status to error with an error instance
       holder.status = ServiceLocatorInstanceHolderStatus.Error
-      const errorInstance = new InstanceNotFound('error-instance')
+      const errorInstance = DIError.instanceNotFound('error-instance')
       holder.instance = errorInstance
 
       const result = manager.get('error-instance')
 
       expect(result).toHaveLength(2)
-      expect(result[0]).toBeInstanceOf(InstanceNotFound)
+      expect(result[0]).toBeInstanceOf(DIError)
       expect(result[1]).toBe(holder)
       expect(mockLogger.log).toHaveBeenCalledWith(
         '[ServiceLocatorManager]#getInstanceHolder() Instance error-instance is in error state',
       )
     })
-
-    it('should handle instance with infinite TTL correctly', () => {
-      const holder = manager.storeCreatedHolder(
-        'infinite-ttl-instance',
-        { value: 'test' },
-        InjectableType.Class,
-        InjectableScope.Singleton,
-        new Set(),
-        Infinity,
-      )
-
-      const result = manager.get('infinite-ttl-instance')
-
-      expect(result).toHaveLength(2)
-      expect(result[0]).toBeUndefined()
-      expect(result[1]).toBe(holder)
-    })
   })
 
   describe('set', () => {
@@ -184,24 +140,6 @@ describe('ServiceLocatorManager', () => {
       expect(result[1]).toBe(true)
     })
 
-    it('should return error for expired instance', () => {
-      const holder = manager.storeCreatedHolder(
-        'expired-instance',
-        { value: 'test' },
-        InjectableType.Class,
-        InjectableScope.Singleton,
-        new Set(),
-        100,
-      )
-
-      holder.createdAt = Date.now() - 200
-
-      const result = manager.has('expired-instance')
-
-      expect(result).toHaveLength(1)
-      expect(result[0]).toBeInstanceOf(InstanceExpired)
-    })
-
     it('should return error for destroying instance', () => {
       const holder = manager.storeCreatedHolder(
         'destroying-instance',
@@ -215,7 +153,7 @@ describe('ServiceLocatorManager', () => {
       const result = manager.has('destroying-instance')
 
       expect(result).toHaveLength(1)
-      expect(result[0]).toBeInstanceOf(InstanceDestroying)
+      expect(result[0]).toBeInstanceOf(DIError)
     })
   })
 
@@ -233,7 +171,7 @@ describe('ServiceLocatorManager', () => {
 
       const getResult = manager.get('test-instance')
       expect(getResult).toHaveLength(1)
-      expect(getResult[0]).toBeInstanceOf(InstanceNotFound)
+      expect(getResult[0]).toBeInstanceOf(DIError)
     })
 
     it('should return false for non-existent instance', () => {
@@ -299,23 +237,19 @@ describe('ServiceLocatorManager', () => {
       expect(holder.type).toBe(InjectableType.Class)
       expect(holder.scope).toBe(InjectableScope.Singleton)
       expect(holder.deps).toEqual(new Set())
-      expect(holder.ttl).toBe(Infinity)
     })
 
-    it('should create holder with custom dependencies and TTL', () => {
+    it('should create holder with custom dependencies', () => {
       const deps = new Set(['dep1', 'dep2'])
-      const ttl = 5000
 
-      const [deferred, holder] = manager.createCreatingHolder(
+      const [, holder] = manager.createCreatingHolder(
         'test-instance',
         InjectableType.Factory,
         InjectableScope.Request,
         deps,
-        ttl,
       )
 
       expect(holder.deps).toBe(deps)
-      expect(holder.ttl).toBe(ttl)
       expect(holder.type).toBe(InjectableType.Factory)
       expect(holder.scope).toBe(InjectableScope.Request)
     })
@@ -338,7 +272,6 @@ describe('ServiceLocatorManager', () => {
       expect(holder.type).toBe(InjectableType.Class)
       expect(holder.scope).toBe(InjectableScope.Singleton)
       expect(holder.deps).toEqual(new Set())
-      expect(holder.ttl).toBe(Infinity)
 
       // Verify it's stored
       const getResult = manager.get('test-instance')
@@ -347,9 +280,8 @@ describe('ServiceLocatorManager', () => {
       expect(getResult[1]).toBe(holder)
     })
 
-    it('should create holder with custom dependencies and TTL', () => {
+    it('should create holder with custom dependencies', () => {
       const deps = new Set(['dep1', 'dep2'])
-      const ttl = 5000
       const instance = { value: 'test' }
 
       const holder = manager.storeCreatedHolder(
@@ -358,11 +290,9 @@ describe('ServiceLocatorManager', () => {
         InjectableType.Factory,
         InjectableScope.Request,
         deps,
-        ttl,
       )
 
       expect(holder.deps).toBe(deps)
-      expect(holder.ttl).toBe(ttl)
       expect(holder.type).toBe(InjectableType.Factory)
       expect(holder.scope).toBe(InjectableScope.Request)
     })