@navios/di 0.2.1 → 0.3.0

package/src/__tests__/injection-token.spec.mts

@@ -1,14 +1,17 @@
-import { describe, expect, it } from 'vitest'
+import { beforeEach, describe, expect, it } from 'vitest'
 import { z } from 'zod/v4'
 
-import type { Factory, FactoryWithArgs } from '../interfaces/index.mjs'
+import type { Factorable, FactorableWithArgs } from '../interfaces/index.mjs'
 
-import { Injectable } from '../decorators/index.mjs'
-import { InjectableType } from '../enums/index.mjs'
+import { Factory, Injectable } from '../decorators/index.mjs'
+import { Container } from '../index.mjs'
 import { InjectionToken } from '../injection-token.mjs'
-import { inject } from '../injector.mjs'
 
 describe('InjectToken', () => {
+  let container: Container
+  beforeEach(() => {
+    container = new Container()
+  })
   it('should work with class', async () => {
     const token = InjectionToken.create('Test')
     @Injectable({
@@ -16,7 +19,7 @@ describe('InjectToken', () => {
     })
     class Test {}
 
-    const value = await inject(Test)
+    const value = await container.get(Test)
     expect(value).toBeInstanceOf(Test)
   })
 
@@ -34,7 +37,7 @@ describe('InjectToken', () => {
         return 'foo'
       }
     }
-    const value = await inject(token, {
+    const value = await container.get(token, {
       test: 'test',
     })
 
@@ -43,17 +46,16 @@ describe('InjectToken', () => {
 
   it('should work with factory', async () => {
     const token = InjectionToken.create<string>('Test')
-    @Injectable({
+    @Factory({
       token,
-      type: InjectableType.Factory,
     })
-    class Test implements Factory<string> {
+    class Test implements Factorable<string> {
       async create() {
         return 'foo'
       }
     }
 
-    const value = await inject(Test)
+    const value = await container.get(Test)
     expect(value).toBe('foo')
   })
 
@@ -63,16 +65,16 @@ describe('InjectToken', () => {
     })
     const token = InjectionToken.create<string, typeof schema>('Test', schema)
 
-    @Injectable({
+    @Factory({
       token,
-      type: InjectableType.Factory,
     })
-    class Test implements FactoryWithArgs<string, typeof schema> {
+    // oxlint-disable-next-line no-unused-vars
+    class Test implements FactorableWithArgs<string, typeof schema> {
       async create(ctx: any, args: { test: string }) {
         return args.test
       }
     }
-    const value = await inject(token, {
+    const value = await container.get(token, {
       test: 'test',
     })
 
@@ -96,7 +98,7 @@ describe('InjectToken', () => {
         return 'foo'
       }
     }
-    const value = await inject(boundToken)
+    const value = await container.get(boundToken)
 
     expect(value).toBeInstanceOf(Test)
   })
@@ -120,8 +122,322 @@ describe('InjectToken', () => {
         return 'foo'
       }
     }
-    const value = await inject(factoryInjectionToken)
+    const value = await container.get(factoryInjectionToken)
 
     expect(value).toBeInstanceOf(Test)
   })
+
+  describe('Factory Token Resolution', () => {
+    it('should resolve factory token only once and cache the result', async () => {
+      let resolveCount = 0
+      const token = InjectionToken.create<Test>('Test')
+      const factoryInjectionToken = InjectionToken.factory(token, () => {
+        resolveCount++
+        return Promise.resolve({
+          value: 'cached-value',
+        })
+      })
+
+      @Injectable({
+        token,
+      })
+      class Test {
+        value = 'test-value'
+      }
+
+      // First resolution
+      const value1 = await container.get(factoryInjectionToken)
+      expect(value1).toBeInstanceOf(Test)
+      expect(resolveCount).toBe(1)
+
+      // Second resolution should use cached value
+      const value2 = await container.get(factoryInjectionToken)
+      expect(value2).toBeInstanceOf(Test)
+      expect(resolveCount).toBe(1) // Should not increment
+    })
+
+    it('should handle async factory functions', async () => {
+      const token = InjectionToken.create<AsyncTest>('AsyncTest')
+      const factoryInjectionToken = InjectionToken.factory(token, async () => {
+        await new Promise((resolve) => setTimeout(resolve, 10))
+        return {
+          value: 'async-value',
+        }
+      })
+
+      @Injectable({
+        token,
+      })
+      class AsyncTest {
+        value = 'async-test'
+      }
+
+      const value = await container.get(factoryInjectionToken)
+      expect(value).toBeInstanceOf(AsyncTest)
+    })
+
+    it('should handle factory functions that throw errors', async () => {
+      const token = InjectionToken.create<ErrorTest>('ErrorTest')
+      const factoryInjectionToken = InjectionToken.factory(token, () => {
+        throw new Error('Factory error')
+      })
+
+      @Injectable({
+        token,
+      })
+      class ErrorTest {
+        value = 'error-test'
+      }
+
+      await expect(container.get(factoryInjectionToken)).rejects.toThrow(
+        'Factory error',
+      )
+    })
+
+    it('should handle factory functions that return rejected promises', async () => {
+      const token = InjectionToken.create<RejectedTest>('RejectedTest')
+      const factoryInjectionToken = InjectionToken.factory(token, () => {
+        return Promise.reject(new Error('Promise rejection'))
+      })
+
+      @Injectable({
+        token,
+      })
+      class RejectedTest {
+        value = 'rejected-test'
+      }
+
+      await expect(container.get(factoryInjectionToken)).rejects.toThrow(
+        'Promise rejection',
+      )
+    })
+
+    it('should support inject in factory', async () => {
+      @Injectable()
+      class InjectTest2 {
+        value = 'inject-test'
+      }
+
+      const token = InjectionToken.create('InjectTest')
+      const factoryInjectionToken = InjectionToken.factory(
+        token,
+        async (ctx) => {
+          const injectTest = await ctx.inject(InjectTest2)
+          return { value: injectTest.value }
+        },
+      )
+
+      @Injectable({
+        token,
+      })
+      class InjectTest {
+        value = 'inject-test'
+      }
+
+      const value = await container.get(factoryInjectionToken)
+      expect(value).toBeInstanceOf(InjectTest)
+    })
+  })
+
+  describe('Factory Token with Different Schema Types', () => {
+    it('should work with optional schema', async () => {
+      const schema = z
+        .object({
+          optional: z.string().optional(),
+        })
+        .optional()
+      const token = InjectionToken.create('OptionalTest', schema)
+      const factoryInjectionToken = InjectionToken.factory(token, () =>
+        Promise.resolve(undefined),
+      )
+
+      @Injectable({
+        token,
+      })
+      class OptionalTest {
+        value = 'optional-test'
+      }
+
+      const value = await container.get(factoryInjectionToken)
+      expect(value).toBeInstanceOf(OptionalTest)
+    })
+
+    it('should work with record schema', async () => {
+      const schema = z.record(z.string(), z.number())
+      const token = InjectionToken.create('RecordTest', schema)
+      const factoryInjectionToken = InjectionToken.factory(token, () =>
+        Promise.resolve({ count: 42, score: 100 }),
+      )
+
+      @Injectable({
+        token,
+      })
+      class RecordTest {
+        value = 'record-test'
+      }
+
+      const value = await container.get(factoryInjectionToken)
+      expect(value).toBeInstanceOf(RecordTest)
+    })
+
+    it('should work with complex nested schema', async () => {
+      const schema = z.object({
+        user: z.object({
+          id: z.number(),
+          name: z.string(),
+          preferences: z.object({
+            theme: z.enum(['light', 'dark']),
+            notifications: z.boolean(),
+          }),
+        }),
+        metadata: z.array(z.string()),
+      })
+      const token = InjectionToken.create('ComplexTest', schema)
+      const factoryInjectionToken = InjectionToken.factory(token, () =>
+        Promise.resolve({
+          user: {
+            id: 1,
+            name: 'John Doe',
+            preferences: {
+              theme: 'dark' as const,
+              notifications: true,
+            },
+          },
+          metadata: ['tag1', 'tag2'],
+        }),
+      )
+
+      @Injectable({
+        token,
+      })
+      class ComplexTest {
+        value = 'complex-test'
+      }
+
+      const value = await container.get(factoryInjectionToken)
+      expect(value).toBeInstanceOf(ComplexTest)
+    })
+  })
+
+  describe('Factory Token with Multiple Instances', () => {
+    it('should create separate instances for different factory tokens', async () => {
+      const token1 = InjectionToken.create<Test1>('Test1')
+      const token2 = InjectionToken.create<Test2>('Test2')
+
+      const factoryToken1 = InjectionToken.factory(token1, () =>
+        Promise.resolve({
+          value: 'value1',
+        }),
+      )
+      const factoryToken2 = InjectionToken.factory(token2, () =>
+        Promise.resolve({
+          value: 'value2',
+        }),
+      )
+
+      @Injectable({
+        token: token1,
+      })
+      class Test1 {
+        value = 'test1'
+      }
+
+      @Injectable({
+        token: token2,
+      })
+      class Test2 {
+        value = 'test2'
+      }
+
+      const value1 = await container.get(factoryToken1)
+      const value2 = await container.get(factoryToken2)
+
+      expect(value1).toBeInstanceOf(Test1)
+      expect(value2).toBeInstanceOf(Test2)
+      expect(value1).not.toBe(value2)
+    })
+
+    it('should handle factory tokens with same underlying token but different factories', async () => {
+      const token = InjectionToken.create<SharedTest>('SharedTest')
+
+      const factoryToken1 = InjectionToken.factory(token, () =>
+        Promise.resolve({
+          value: 'factory1',
+        }),
+      )
+      const factoryToken2 = InjectionToken.factory(token, () =>
+        Promise.resolve({
+          value: 'factory2',
+        }),
+      )
+
+      @Injectable({
+        token,
+      })
+      class SharedTest {
+        value = 'shared-test'
+      }
+
+      const value1 = await container.get(factoryToken1)
+      const value2 = await container.get(factoryToken2)
+
+      expect(value1).toBeInstanceOf(SharedTest)
+      expect(value2).toBeInstanceOf(SharedTest)
+    })
+  })
+
+  describe('Factory Token Properties', () => {
+    it('should have correct properties', () => {
+      const token = InjectionToken.create('PropertyTest')
+      const factoryInjectionToken = InjectionToken.factory(token, () =>
+        Promise.resolve({
+          value: 'test',
+        }),
+      )
+
+      expect(factoryInjectionToken.id).toBe(token.id)
+      expect(factoryInjectionToken.name).toBe(token.name)
+      expect(factoryInjectionToken.schema).toBe(token.schema)
+      expect(factoryInjectionToken.resolved).toBe(false)
+      expect(factoryInjectionToken.value).toBeUndefined()
+    })
+
+    it('should update resolved property after resolution', async () => {
+      const token = InjectionToken.create('ResolvedTest')
+      const factoryInjectionToken = InjectionToken.factory(token, () =>
+        Promise.resolve({
+          value: 'resolved',
+        }),
+      )
+
+      expect(factoryInjectionToken.resolved).toBe(false)
+      expect(factoryInjectionToken.value).toBeUndefined()
+
+      // @ts-expect-error we are not using the context
+      await factoryInjectionToken.resolve()
+
+      expect(factoryInjectionToken.resolved).toBe(true)
+      expect(factoryInjectionToken.value).toMatchObject({ value: 'resolved' })
+    })
+
+    it('should return cached value on subsequent resolve calls', async () => {
+      let resolveCount = 0
+      const token = InjectionToken.create('CacheTest')
+      const factoryInjectionToken = InjectionToken.factory(token, () => {
+        resolveCount++
+        return Promise.resolve({
+          value: 'cached',
+        })
+      })
+
+      // @ts-expect-error we are not using the context
+      const result1 = await factoryInjectionToken.resolve()
+      // @ts-expect-error we are not using the context
+      const result2 = await factoryInjectionToken.resolve()
+
+      expect(result1).toMatchObject({ value: 'cached' })
+      expect(result2).toMatchObject({ value: 'cached' })
+      expect(resolveCount).toBe(1)
+    })
+  })
 })

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

@@ -0,0 +1,263 @@
+import { beforeEach, describe, expect, it } from 'vitest'
+
+import { Container } from '../container.mjs'
+import { Injectable } from '../decorators/injectable.decorator.mjs'
+import { InjectableScope } from '../enums/index.mjs'
+import { inject } from '../index.mjs'
+import { Registry } from '../registry.mjs'
+import { createRequestContextHolder } from '../request-context-holder.mjs'
+
+describe('Request Scope', () => {
+  let container: Container
+  let registry: Registry
+
+  beforeEach(() => {
+    registry = new Registry()
+    container = new Container(registry)
+  })
+
+  describe('Request-scoped services', () => {
+    it('should create different instances for different requests', async () => {
+      @Injectable({ registry, scope: InjectableScope.Request })
+      class RequestService {
+        public readonly requestId = Math.random().toString(36)
+        public readonly createdAt = new Date()
+      }
+
+      // Start first request
+      container.beginRequest('request-1')
+      const instance1a = await container.get(RequestService)
+      const instance1b = await container.get(RequestService)
+
+      // Start second request
+      container.beginRequest('request-2')
+      const instance2a = await container.get(RequestService)
+      const instance2b = await container.get(RequestService)
+
+      // Within same request, instances should be the same
+      expect(instance1a).toBe(instance1b)
+      expect(instance2a).toBe(instance2b)
+
+      // Between different requests, instances should be different
+      expect(instance1a).not.toBe(instance2a)
+      expect(instance1a.requestId).not.toBe(instance2a.requestId)
+
+      // Clean up
+      await container.endRequest('request-1')
+      await container.endRequest('request-2')
+    })
+
+    it('should handle request context lifecycle correctly', async () => {
+      @Injectable({ registry, scope: InjectableScope.Request })
+      class RequestService {
+        public readonly requestId = Math.random().toString(36)
+        public destroyed = false
+
+        async onServiceDestroy() {
+          this.destroyed = true
+        }
+      }
+
+      // Start request
+      const requestId = 'test-request'
+      container.beginRequest(requestId)
+
+      const instance = await container.get(RequestService)
+      expect(instance.destroyed).toBe(false)
+
+      // End request should trigger cleanup
+      await container.endRequest(requestId)
+      expect(instance.destroyed).toBe(true)
+    })
+
+    it('should support request metadata', async () => {
+      const requestId = 'test-request'
+      const metadata = { userId: 'user123', sessionId: 'session456' }
+
+      container.beginRequest(requestId, metadata)
+
+      // Note: In a real implementation, you might want to inject metadata
+      // For now, we'll just verify the context exists
+      const context = container.getCurrentRequestContext()
+      expect(context).not.toBeNull()
+      expect(context?.requestId).toBe(requestId)
+      expect(context?.getMetadata('userId')).toBe('user123')
+      expect(context?.getMetadata('sessionId')).toBe('session456')
+
+      await container.endRequest(requestId)
+    })
+
+    it('should handle pre-prepared instances', async () => {
+      @Injectable({ registry, scope: InjectableScope.Request })
+      class RequestService {
+        public readonly requestId = Math.random().toString(36)
+        public readonly prePrepared = true
+      }
+
+      const requestId = 'test-request'
+      container.beginRequest(requestId)
+
+      // Getting the instance should be fast (pre-prepared)
+      const instance = await container.get(RequestService)
+      expect(instance.prePrepared).toBe(true)
+
+      await container.endRequest(requestId)
+    })
+
+    it('should handle mixed scopes correctly', async () => {
+      @Injectable({ registry, scope: InjectableScope.Singleton })
+      class SingletonService {
+        public readonly id = Math.random().toString(36)
+      }
+
+      @Injectable({ registry, scope: InjectableScope.Request })
+      class RequestService {
+        public readonly id = Math.random().toString(36)
+        singleton: SingletonService = inject(SingletonService)
+      }
+
+      @Injectable({ registry, scope: InjectableScope.Transient })
+      class TransientService {
+        requestService = inject(RequestService)
+        public readonly id = Math.random().toString(36)
+      }
+
+      // Start request
+      container.beginRequest('test-request')
+
+      const requestService1 = await container.get(RequestService)
+      const requestService2 = await container.get(RequestService)
+      const singleton1 = await container.get(SingletonService)
+      const singleton2 = await container.get(SingletonService)
+      const transient1 = await container.get(TransientService)
+      const transient2 = await container.get(TransientService)
+
+      // Request-scoped: same instance within request
+      expect(requestService1).toBe(requestService2)
+      expect(requestService1.singleton).toBe(singleton1)
+
+      // Singleton: same instance always
+      expect(singleton1).toBe(singleton2)
+
+      // Transient: different instances always
+      expect(transient1).not.toBe(transient2)
+      expect(transient1.requestService).toBe(transient2.requestService)
+
+      await container.endRequest('test-request')
+    })
+
+    it('should handle nested request contexts', async () => {
+      @Injectable({ registry, scope: InjectableScope.Request })
+      class RequestService {
+        public readonly id = Math.random().toString(36)
+      }
+
+      // Start first request
+      container.beginRequest('request-1')
+      const instance1 = await container.get(RequestService)
+
+      // Start second request (nested)
+      container.beginRequest('request-2')
+      const instance2 = await container.get(RequestService)
+
+      // Should be different instances
+      expect(instance1).not.toBe(instance2)
+
+      // End second request
+      await container.endRequest('request-2')
+
+      // Get instance from first request again
+      const instance1Again = await container.get(RequestService)
+      expect(instance1).toBe(instance1Again)
+
+      // End first request
+      await container.endRequest('request-1')
+    })
+
+    it('should handle request context switching', async () => {
+      @Injectable({ registry, scope: InjectableScope.Request })
+      class RequestService {
+        public readonly id = Math.random().toString(36)
+      }
+
+      // Start multiple requests
+      container.beginRequest('request-1')
+      container.beginRequest('request-2')
+      container.beginRequest('request-3')
+
+      // Switch to request-1
+      container.setCurrentRequestContext('request-1')
+      const instance1 = await container.get(RequestService)
+
+      // Switch to request-2
+      container.setCurrentRequestContext('request-2')
+      const instance2 = await container.get(RequestService)
+
+      // Switch back to request-1
+      container.setCurrentRequestContext('request-1')
+      const instance1Again = await container.get(RequestService)
+
+      // Should get same instance for request-1
+      expect(instance1).toBe(instance1Again)
+      // Should get different instance for request-2
+      expect(instance1).not.toBe(instance2)
+
+      // Clean up all requests
+      await container.endRequest('request-1')
+      await container.endRequest('request-2')
+      await container.endRequest('request-3')
+    })
+  })
+
+  describe('RequestContextHolder', () => {
+    it('should manage instances correctly', () => {
+      const holder = createRequestContextHolder('test-request', 100, {
+        userId: 'user123',
+      })
+
+      expect(holder.requestId).toBe('test-request')
+      expect(holder.priority).toBe(100)
+      expect(holder.getMetadata('userId')).toBe('user123')
+
+      // Add instance
+      const mockInstance = { id: 'test-instance' }
+      const mockHolder = {
+        status: 'Created' as any,
+        name: 'test-instance',
+        instance: mockInstance,
+        creationPromise: null,
+        destroyPromise: null,
+        type: 'Class' as any,
+        scope: 'Request' as any,
+        deps: new Set<string>(),
+        destroyListeners: [],
+        createdAt: Date.now(),
+        ttl: Infinity,
+      }
+
+      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)
+
+      // Clear instances
+      holder.clear()
+      expect(holder.hasInstance('test-instance')).toBe(false)
+    })
+
+    it('should handle metadata correctly', () => {
+      const holder = createRequestContextHolder('test-request')
+
+      holder.setMetadata('key1', 'value1')
+      holder.setMetadata('key2', 'value2')
+
+      expect(holder.getMetadata('key1')).toBe('value1')
+      expect(holder.getMetadata('key2')).toBe('value2')
+      expect(holder.getMetadata('nonexistent')).toBeUndefined()
+
+      holder.clear()
+      expect(holder.getMetadata('key1')).toBeUndefined()
+    })
+  })
+})