@navios/di 0.5.1 → 0.6.0

package/src/__tests__/container.spec.mts

@@ -2,21 +2,21 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 import { z } from 'zod/v4'
 
-import type { FactoryContext } from '../factory-context.mjs'
 import type {
   Factorable,
   FactorableWithArgs,
 } from '../interfaces/factory.interface.mjs'
+import type { FactoryContext } from '../internal/context/factory-context.mjs'
 
-import { Container } from '../container.mjs'
+import { Container } from '../container/container.mjs'
 import { Factory } from '../decorators/factory.decorator.mjs'
 import { Injectable } from '../decorators/injectable.decorator.mjs'
 import { InjectableScope } from '../enums/injectable-scope.enum.mjs'
 import { getInjectors } from '../index.mjs'
-import { InjectionToken } from '../injection-token.mjs'
-import { asyncInject, inject } from '../injector.mjs'
-import { Registry } from '../registry.mjs'
-import { ServiceLocator } from '../service-locator.mjs'
+import { asyncInject, inject } from '../injectors.mjs'
+import { ServiceLocator } from '../internal/core/service-locator.mjs'
+import { InjectionToken } from '../token/injection-token.mjs'
+import { Registry } from '../token/registry.mjs'
 
 describe('Container', () => {
   let container: Container
@@ -313,9 +313,10 @@ describe('Container', () => {
 
         @Factory({ token, registry })
         // oxlint-disable-next-line no-unused-vars
-        class ArgFactory
-          implements FactorableWithArgs<TestService, typeof schema>
-        {
+        class ArgFactory implements FactorableWithArgs<
+          TestService,
+          typeof schema
+        > {
           async create(ctx: any, args: z.output<typeof schema>) {
             return new TestService(args.name, args.value)
           }
@@ -350,9 +351,10 @@ describe('Container', () => {
 
         @Factory({ token, registry })
         // oxlint-disable-next-line no-unused-vars
-        class OptionalArgFactory
-          implements FactorableWithArgs<TestService, typeof schema>
-        {
+        class OptionalArgFactory implements FactorableWithArgs<
+          TestService,
+          typeof schema
+        > {
           async create(ctx: any, args: z.output<typeof schema>) {
             return new TestService(args?.name || 'default', args?.optional)
           }
@@ -439,9 +441,10 @@ describe('Container', () => {
 
         @Factory({ token, registry })
         // oxlint-disable-next-line no-unused-vars
-        class FactoryService
-          implements FactorableWithArgs<TestService, typeof schema>
-        {
+        class FactoryService implements FactorableWithArgs<
+          TestService,
+          typeof schema
+        > {
           async create(ctx: any, args: z.output<typeof schema>) {
             return new TestService(args.factory)
           }
@@ -526,7 +529,7 @@ describe('Container', () => {
 
       @Injectable({ registry })
       class ServiceB {
-        serviceA = asyncInject(ServiceA)
+        serviceA = asyncInject(ServiceA).catch(() => null)
       }
 
       // This should not throw but handle the circular dependency
@@ -535,6 +538,8 @@ describe('Container', () => {
       expect(serviceA.serviceB).toBeInstanceOf(Promise)
       const serviceB = await serviceA.serviceB
       expect(serviceB).toBeInstanceOf(ServiceB)
+      const serviceA2 = await serviceB.serviceA
+      expect(serviceA2).toBeInstanceOf(ServiceA)
     })
 
     it('should handle deep dependency chains', async () => {
@@ -626,7 +631,7 @@ describe('Container', () => {
       await expect(container.get(token, { invalid: 'arg' })).rejects.toThrow()
     })
 
-    it.skip('should handle factory errors', async () => {
+    it('should handle factory errors', async () => {
       @Factory({ registry })
       class ErrorFactory implements Factorable<TestService> {
         async create() {
@@ -640,7 +645,7 @@ describe('Container', () => {
       await expect(container.get(ErrorFactory)).rejects.toThrow('Factory error')
     })
 
-    it.skip('should handle async factory errors', async () => {
+    it('should handle async factory errors', async () => {
       @Factory({ registry })
       class AsyncErrorFactory implements Factorable<TestService> {
         async create() {
@@ -1135,27 +1140,27 @@ describe('Container', () => {
           public id = Math.random()
         }
 
-        @Injectable({ registry })
+        @Injectable({ registry, scope: InjectableScope.Request })
         class Level2Service {
           level1 = inject(Level1Service)
           public id = Math.random()
         }
 
-        @Injectable({ registry })
+        @Injectable({ registry, scope: InjectableScope.Request })
         class RootService {
           level2 = inject(Level2Service)
         }
 
-        container.beginRequest('request-1')
+        const scoped = container.beginRequest('request-1')
 
-        const root1 = await container.get(RootService)
+        const root1 = await scoped.get(RootService)
         const level2_1 = root1.level2
         const level1_1 = level2_1.level1
 
         // Invalidate the root service
-        await container.invalidate(level1_1)
+        await scoped.invalidate(level1_1)
 
-        const root2 = await container.get(RootService)
+        const root2 = await scoped.get(RootService)
         const level2_2 = root2.level2
         const level1_2 = level2_2.level1
 
@@ -1166,7 +1171,7 @@ describe('Container', () => {
         expect(level2_1.id).not.toBe(level2_2.id)
         expect(level1_1.id).not.toBe(level1_2.id)
 
-        await container.endRequest('request-1')
+        await scoped.endRequest()
       })
 
       it('should handle invalidation of services with mixed inject and asyncInject', async () => {