@navios/di 0.5.1 → 0.6.1

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

@@ -3,13 +3,14 @@ import { z } from 'zod/v4'
 
 import type { OnServiceDestroy } from '../index.mjs'
 
+import { Container } from '../container/container.mjs'
 import { Injectable } from '../decorators/injectable.decorator.mjs'
 import { InjectableScope } from '../enums/index.mjs'
 import { getInjectableToken } from '../index.mjs'
-import { InjectionToken } from '../injection-token.mjs'
-import { asyncInject, inject } from '../injector.mjs'
-import { globalRegistry } 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 { globalRegistry } from '../token/registry.mjs'
 
 describe('ServiceLocator', () => {
   describe('getInstanceIdentifier', () => {
@@ -42,7 +43,7 @@ describe('ServiceLocator', () => {
   })
 
   describe('clearAll', () => {
-    let serviceLocator: ServiceLocator
+    let container: Container
     let mockLogger: Console
 
     beforeEach(() => {
@@ -54,10 +55,12 @@ describe('ServiceLocator', () => {
         trace: vi.fn(),
       } as any
 
-      serviceLocator = new ServiceLocator(globalRegistry, mockLogger)
+      container = new Container(globalRegistry, mockLogger)
     })
 
     it('should clear all services gracefully', async () => {
+      const serviceLocator = container.getServiceLocator()
+
       // Create Injectable services
       @Injectable({ scope: InjectableScope.Singleton })
       class ServiceA {
@@ -74,13 +77,13 @@ describe('ServiceLocator', () => {
         name = 'ServiceC'
       }
 
-      // Create instances
-      await serviceLocator.getInstance(ServiceA)
-      await serviceLocator.getInstance(ServiceB)
-      await serviceLocator.getInstance(ServiceC)
+      // Create instances using container
+      await container.get(ServiceA)
+      await container.get(ServiceB)
+      await container.get(ServiceC)
 
-      // Verify services exist
-      expect(serviceLocator.getManager().size()).toBe(3)
+      // Verify services exist (container also registers itself as +1)
+      expect(serviceLocator.getManager().size()).toBe(4)
 
       // Clear all services
       await serviceLocator.clearAll()
@@ -88,19 +91,22 @@ describe('ServiceLocator', () => {
       // Verify all services are cleared
       expect(serviceLocator.getManager().size()).toBe(0)
       expect(mockLogger.log).toHaveBeenCalledWith(
-        '[ServiceInvalidator] Graceful clearing completed',
+        '[Invalidator] Graceful clearing completed',
       )
     })
 
     it('should handle empty service locator', async () => {
+      const serviceLocator = new ServiceLocator(globalRegistry, mockLogger)
       await serviceLocator.clearAll()
 
       expect(mockLogger.log).toHaveBeenCalledWith(
-        '[ServiceInvalidator] No singleton services to clear',
+        '[Invalidator] No services to clear',
       )
     })
 
     it('should clear service from a request context', async () => {
+      const serviceLocator = container.getServiceLocator()
+
       @Injectable({ scope: InjectableScope.Singleton })
       class ServiceA {
         name = 'ServiceA'
@@ -113,20 +119,21 @@ describe('ServiceLocator', () => {
       }
 
       const requestId = 'test-request'
-      serviceLocator.beginRequest(requestId)
-      const [error, serviceB] = await serviceLocator.getInstance(ServiceB)
-      expect(error).toBeUndefined()
+      const scoped = container.beginRequest(requestId)
+      const serviceB = await scoped.get(ServiceB)
       expect(serviceB).toBeDefined()
 
-      await serviceLocator.invalidate(getInjectableToken(ServiceA).toString())
-      expect(serviceLocator.getManager().size()).toBe(0)
+      await scoped.invalidate(await container.get(ServiceA))
+      // Container itself remains
+      expect(serviceLocator.getManager().size()).toBe(1)
       await serviceLocator.clearAll()
+      await scoped.endRequest()
     })
 
-    it('should clear request contexts when requested', async () => {
+    it('should clear request contexts via ScopedContainer', async () => {
       // Create a request context
       const requestId = 'test-request'
-      serviceLocator.beginRequest(requestId)
+      const scoped = container.beginRequest(requestId)
 
       // Create Injectable service with request scope
       @Injectable({ scope: InjectableScope.Request })
@@ -134,31 +141,36 @@ describe('ServiceLocator', () => {
         name = 'TestService'
       }
 
-      await serviceLocator.getInstance(TestService)
+      await scoped.get(TestService)
 
-      // Verify request context exists before clearing
-      expect(serviceLocator.getCurrentRequestContext()).not.toBeNull()
+      // Verify request context exists
+      expect(container.hasActiveRequest(requestId)).toBe(true)
 
-      // Clear all services including request contexts
-      await serviceLocator.clearAll({ clearRequestContexts: true })
+      // End request to clean up
+      await scoped.endRequest()
 
       // Verify request context is cleared
-      expect(serviceLocator.getCurrentRequestContext()).toBeNull()
+      expect(container.hasActiveRequest(requestId)).toBe(false)
     })
 
-    it('should skip clearing request contexts when disabled', async () => {
+    it('should track active request contexts', async () => {
       // Create a request context
       const requestId = 'test-request'
-      serviceLocator.beginRequest(requestId)
+      const scoped = container.beginRequest(requestId)
 
-      // Clear all services but skip request contexts
-      await serviceLocator.clearAll({ clearRequestContexts: false })
+      // Verify request context exists
+      expect(container.hasActiveRequest(requestId)).toBe(true)
 
-      // Verify request context is still there
-      expect(serviceLocator.getCurrentRequestContext()).not.toBeNull()
+      // End request
+      await scoped.endRequest()
+
+      // Verify request context is gone
+      expect(container.hasActiveRequest(requestId)).toBe(false)
     })
 
     it('should handle services with dependencies correctly', async () => {
+      const serviceLocator = container.getServiceLocator()
+
       // Create Injectable services
       @Injectable({ scope: InjectableScope.Singleton })
       class ServiceA {
@@ -171,8 +183,8 @@ describe('ServiceLocator', () => {
         name = 'ServiceB'
       }
 
-      // Create instances
-      await serviceLocator.getInstance(ServiceB)
+      // Create instances using container
+      await container.get(ServiceB)
 
       // Clear all services
       await serviceLocator.clearAll()
@@ -182,13 +194,15 @@ describe('ServiceLocator', () => {
     })
 
     it('should respect maxRounds option', async () => {
+      const serviceLocator = container.getServiceLocator()
+
       // Create Injectable service
       @Injectable({ scope: InjectableScope.Singleton })
       class TestService {
         name = 'TestService'
       }
 
-      await serviceLocator.getInstance(TestService)
+      await container.get(TestService)
 
       // Clear with a very low maxRounds to test the limit
       await serviceLocator.clearAll({ maxRounds: 1 })
@@ -198,6 +212,8 @@ describe('ServiceLocator', () => {
     })
 
     it('should clear services with dependencies in correct order', async () => {
+      const serviceLocator = container.getServiceLocator()
+
       // Create services with dependencies
       @Injectable({ scope: InjectableScope.Singleton })
       class DatabaseService {
@@ -217,12 +233,12 @@ describe('ServiceLocator', () => {
       }
 
       // Create instances (this will establish dependencies)
-      await serviceLocator.getInstance(AuthService)
-      await serviceLocator.getInstance(UserService)
-      await serviceLocator.getInstance(DatabaseService)
+      await container.get(AuthService)
+      await container.get(UserService)
+      await container.get(DatabaseService)
 
-      // Verify services exist
-      expect(serviceLocator.getManager().size()).toBe(3)
+      // Verify services exist (container also registers itself as +1)
+      expect(serviceLocator.getManager().size()).toBe(4)
 
       // Clear all services - should clear in dependency order
       await serviceLocator.clearAll()
@@ -232,6 +248,8 @@ describe('ServiceLocator', () => {
     })
 
     it('should handle services with destroy listeners', async () => {
+      const serviceLocator = container.getServiceLocator()
+
       let destroyCalled = false
       @Injectable({ scope: InjectableScope.Singleton })
       class TestService implements OnServiceDestroy {
@@ -246,7 +264,7 @@ describe('ServiceLocator', () => {
         }
       }
 
-      await serviceLocator.getInstance(TestService)
+      await container.get(TestService)
 
       // Clear all services
       await serviceLocator.clearAll()
@@ -258,7 +276,7 @@ describe('ServiceLocator', () => {
   })
 
   describe('Mixed Scope Services', () => {
-    let serviceLocator: ServiceLocator
+    let container: Container
     let mockLogger: Console
 
     beforeEach(() => {
@@ -270,7 +288,7 @@ describe('ServiceLocator', () => {
         trace: vi.fn(),
       } as any
 
-      serviceLocator = new ServiceLocator(globalRegistry, mockLogger)
+      container = new Container(globalRegistry, mockLogger)
     })
 
     describe('Services with dependencies across different scopes', () => {
@@ -290,13 +308,9 @@ describe('ServiceLocator', () => {
         }
 
         // Get instances
-        const [error1, singleton1] =
-          await serviceLocator.getInstance(SingletonService)
-        const [error2, singleton2] =
-          await serviceLocator.getInstance(SingletonService)
+        const singleton1 = await container.get(SingletonService)
+        const singleton2 = await container.get(SingletonService)
 
-        expect(error1).toBeUndefined()
-        expect(error2).toBeUndefined()
         expect(singleton1).toBe(singleton2) // Same singleton instance
 
         // Get the actual transient service instances (asyncInject returns Promises)
@@ -324,32 +338,26 @@ describe('ServiceLocator', () => {
         }
 
         // Begin request context
-        const requestId = 'test-request-1'
-        serviceLocator.beginRequest(requestId)
+        const scoped1 = container.beginRequest('test-request-1')
 
         // Get instances within the same request
-        const [error1, request1] =
-          await serviceLocator.getInstance(RequestService)
-        const [error2, request2] =
-          await serviceLocator.getInstance(RequestService)
+        const request1 = await scoped1.get(RequestService)
+        const request2 = await scoped1.get(RequestService)
 
-        expect(error1).toBeUndefined()
-        expect(error2).toBeUndefined()
         expect(request1).toBe(request2) // Same request-scoped instance
         expect(request1.singletonService).toBe(request2.singletonService) // Same singleton instance
 
         // End request and start new one
-        await serviceLocator.endRequest(requestId)
-        const newRequestId = 'test-request-2'
-        serviceLocator.beginRequest(newRequestId)
+        await scoped1.endRequest()
+        const scoped2 = container.beginRequest('test-request-2')
 
         // Get instance in new request
-        const [error3, request3] =
-          await serviceLocator.getInstance(RequestService)
+        const request3 = await scoped2.get(RequestService)
 
-        expect(error3).toBeUndefined()
         expect(request1).not.toBe(request3) // Different request-scoped instances
         expect(request1.singletonService).toBe(request3.singletonService) // Same singleton instance
+
+        await scoped2.endRequest()
       })
 
       it('should handle Transient service depending on Request service', async () => {
@@ -368,23 +376,20 @@ describe('ServiceLocator', () => {
         }
 
         // Begin request context
-        const requestId = 'test-request'
-        serviceLocator.beginRequest(requestId)
+        const scoped = container.beginRequest('test-request')
 
         // Get multiple transient instances
-        const [error1, transient1] =
-          await serviceLocator.getInstance(TransientService)
-        const [error2, transient2] =
-          await serviceLocator.getInstance(TransientService)
+        const transient1 = await scoped.get(TransientService)
+        const transient2 = await scoped.get(TransientService)
 
-        expect(error1).toBeUndefined()
-        expect(error2).toBeUndefined()
         expect(transient1).not.toBe(transient2) // Different transient instances
 
-        // Get the actual request service instances (asyncInject returns Promises)
+        // Get the actual request service instances
         const requestService1 = transient1.requestService
         const requestService2 = transient2.requestService
         expect(requestService1).toBe(requestService2) // Same request-scoped instance
+
+        await scoped.endRequest()
       })
 
       it('should handle complex dependency chain across all scopes', async () => {
@@ -417,20 +422,12 @@ describe('ServiceLocator', () => {
         }
 
         // Begin request context
-        const requestId = 'complex-request'
-        serviceLocator.beginRequest(requestId)
+        const scoped = container.beginRequest('complex-request')
 
         // Get instances
-        const [error1, action1] =
-          await serviceLocator.getInstance(UserActionService)
-        const [error2, action2] =
-          await serviceLocator.getInstance(UserActionService)
-        const [error3, manager] =
-          await serviceLocator.getInstance(UserManagerService)
-
-        expect(error1).toBeUndefined()
-        expect(error2).toBeUndefined()
-        expect(error3).toBeUndefined()
+        const action1 = await scoped.get(UserActionService)
+        const action2 = await scoped.get(UserActionService)
+        const manager = await container.get(UserManagerService)
 
         // Verify instances are created
         expect(action1).toBeDefined()
@@ -440,7 +437,7 @@ describe('ServiceLocator', () => {
         // Verify scope behavior - check if dependencies are properly injected
         expect(action1).not.toBe(action2) // Different transient instances
 
-        // Get the actual dependency instances (asyncInject returns Promises)
+        // Get the actual dependency instances
         const action1Database = action1.database
         const action2Database = action2.database
         const action1Session = action1.session
@@ -454,18 +451,12 @@ describe('ServiceLocator', () => {
         expect(action1Session.database).toBe(action1Database) // Same singleton instance
 
         // End request and start new one
-        await serviceLocator.endRequest(requestId)
-        const newRequestId = 'complex-request-2'
-        serviceLocator.beginRequest(newRequestId)
+        await scoped.endRequest()
+        const scoped2 = container.beginRequest('complex-request-2')
 
         // Get instances in new request
-        const [error4, action3] =
-          await serviceLocator.getInstance(UserActionService)
-        const [error5, manager2] =
-          await serviceLocator.getInstance(UserManagerService)
-
-        expect(error4).toBeUndefined()
-        expect(error5).toBeUndefined()
+        const action3 = await scoped2.get(UserActionService)
+        const manager2 = await container.get(UserManagerService)
 
         // Verify scope behavior across requests
         expect(action1).not.toBe(action3) // Different transient instances
@@ -479,6 +470,8 @@ describe('ServiceLocator', () => {
 
         // Check if session dependency is properly injected in new request
         expect(action1Session).not.toBe(action3Session) // Different request-scoped instances
+
+        await scoped2.endRequest()
       })
     })
 
@@ -491,21 +484,15 @@ describe('ServiceLocator', () => {
         }
 
         // First request
-        const requestId1 = 'request-1'
-        serviceLocator.beginRequest(requestId1)
-        const [error1, service1] =
-          await serviceLocator.getInstance(RequestService)
-        await serviceLocator.endRequest(requestId1)
+        const scoped1 = container.beginRequest('request-1')
+        const service1 = await scoped1.get(RequestService)
+        await scoped1.endRequest()
 
         // Second request
-        const requestId2 = 'request-2'
-        serviceLocator.beginRequest(requestId2)
-        const [error2, service2] =
-          await serviceLocator.getInstance(RequestService)
-        await serviceLocator.endRequest(requestId2)
-
-        expect(error1).toBeUndefined()
-        expect(error2).toBeUndefined()
+        const scoped2 = container.beginRequest('request-2')
+        const service2 = await scoped2.get(RequestService)
+        await scoped2.endRequest()
+
         expect(service1).not.toBe(service2) // Different instances
         expect(service1.id).not.toBe(service2.id) // Different IDs
       })
@@ -518,21 +505,15 @@ describe('ServiceLocator', () => {
         }
 
         // First request
-        const requestId1 = 'request-1'
-        serviceLocator.beginRequest(requestId1)
-        const [error1, service1] =
-          await serviceLocator.getInstance(SingletonService)
-        await serviceLocator.endRequest(requestId1)
+        const scoped1 = container.beginRequest('request-1')
+        const service1 = await scoped1.get(SingletonService)
+        await scoped1.endRequest()
 
         // Second request
-        const requestId2 = 'request-2'
-        serviceLocator.beginRequest(requestId2)
-        const [error2, service2] =
-          await serviceLocator.getInstance(SingletonService)
-        await serviceLocator.endRequest(requestId2)
-
-        expect(error1).toBeUndefined()
-        expect(error2).toBeUndefined()
+        const scoped2 = container.beginRequest('request-2')
+        const service2 = await scoped2.get(SingletonService)
+        await scoped2.endRequest()
+
         expect(service1).toBe(service2) // Same instance
         expect(service1.id).toBe(service2.id) // Same ID
       })
@@ -544,19 +525,10 @@ describe('ServiceLocator', () => {
           name = 'TransientService'
         }
 
-        const requestId = 'request'
-        serviceLocator.beginRequest(requestId)
+        const service1 = await container.get(TransientService)
+        const service2 = await container.get(TransientService)
+        const service3 = await container.get(TransientService)
 
-        const [error1, service1] =
-          await serviceLocator.getInstance(TransientService)
-        const [error2, service2] =
-          await serviceLocator.getInstance(TransientService)
-        const [error3, service3] =
-          await serviceLocator.getInstance(TransientService)
-
-        expect(error1).toBeUndefined()
-        expect(error2).toBeUndefined()
-        expect(error3).toBeUndefined()
         expect(service1).not.toBe(service2) // Different instances
         expect(service1).not.toBe(service3) // Different instances
         expect(service2).not.toBe(service3) // Different instances
@@ -580,42 +552,32 @@ describe('ServiceLocator', () => {
           name = 'SingletonService'
         }
 
-        const requestId = 'cleanup-test'
-        serviceLocator.beginRequest(requestId)
+        const scoped = container.beginRequest('cleanup-test')
 
         // Create instances
-        const [error1, _requestService] =
-          await serviceLocator.getInstance(RequestService)
-        const [error2, singletonService] =
-          await serviceLocator.getInstance(SingletonService)
-
-        expect(error1).toBeUndefined()
-        expect(error2).toBeUndefined()
+        const _requestService = await scoped.get(RequestService)
+        const singletonService = await scoped.get(SingletonService)
 
         // Verify request context exists
-        expect(serviceLocator.getCurrentRequestContext()).not.toBeNull()
-        expect(serviceLocator.getCurrentRequestContext()?.requestId).toBe(
-          requestId,
-        )
+        expect(container.hasActiveRequest('cleanup-test')).toBe(true)
 
         // End request
-        await serviceLocator.endRequest(requestId)
+        await scoped.endRequest()
 
         // Verify request context is cleared
-        expect(serviceLocator.getCurrentRequestContext()).toBeNull()
+        expect(container.hasActiveRequest('cleanup-test')).toBe(false)
 
         // Singleton should still be available
-        const [error3, singletonService2] =
-          await serviceLocator.getInstance(SingletonService)
-        expect(error3).toBeUndefined()
+        const singletonService2 = await container.get(SingletonService)
         expect(singletonService).toBe(singletonService2) // Same singleton instance
 
         // Request service should not be available (no current request context)
-        const [error4] = await serviceLocator.getInstance(RequestService)
-        expect(error4).toBeDefined() // Should error because no request context
+        await expect(container.get(RequestService)).rejects.toThrow(
+          /Cannot resolve request-scoped service/,
+        )
       })
 
-      it('should handle nested request contexts with mixed scopes', async () => {
+      it('should handle parallel request contexts with mixed scopes', async () => {
         @Injectable({ scope: InjectableScope.Request })
         class RequestService {
           id = Math.random().toString(36).substr(2, 9)
@@ -629,43 +591,26 @@ describe('ServiceLocator', () => {
         }
 
         // First request
-        const requestId1 = 'outer-request'
-        serviceLocator.beginRequest(requestId1)
-        const [error1, requestService1] =
-          await serviceLocator.getInstance(RequestService)
-        const [error2, singletonService1] =
-          await serviceLocator.getInstance(SingletonService)
-
-        // Second request (nested)
-        const requestId2 = 'inner-request'
-        serviceLocator.beginRequest(requestId2)
-        const [error3, requestService2] =
-          await serviceLocator.getInstance(RequestService)
-        const [error4, singletonService2] =
-          await serviceLocator.getInstance(SingletonService)
-
-        expect(error1).toBeUndefined()
-        expect(error2).toBeUndefined()
-        expect(error3).toBeUndefined()
-        expect(error4).toBeUndefined()
+        const scoped1 = container.beginRequest('outer-request')
+        const requestService1 = await scoped1.get(RequestService)
+        const singletonService1 = await scoped1.get(SingletonService)
+
+        // Second request (parallel)
+        const scoped2 = container.beginRequest('inner-request')
+        const requestService2 = await scoped2.get(RequestService)
+        const singletonService2 = await scoped2.get(SingletonService)
 
         // Verify instances
         expect(requestService1).not.toBe(requestService2) // Different request instances
         expect(singletonService1).toBe(singletonService2) // Same singleton instance
 
-        // End inner request
-        await serviceLocator.endRequest(requestId2)
-
-        // Verify current context is back to outer request
-        expect(serviceLocator.getCurrentRequestContext()?.requestId).toBe(
-          requestId1,
-        )
+        // End both requests
+        await scoped2.endRequest()
+        await scoped1.endRequest()
 
-        // End outer request
-        await serviceLocator.endRequest(requestId1)
-
-        // Verify no current context
-        expect(serviceLocator.getCurrentRequestContext()).toBeNull()
+        // Verify no active contexts
+        expect(container.hasActiveRequest('outer-request')).toBe(false)
+        expect(container.hasActiveRequest('inner-request')).toBe(false)
       })
 
       it('should handle concurrent requests with mixed scopes', async () => {
@@ -681,17 +626,15 @@ describe('ServiceLocator', () => {
           name = 'SingletonService'
         }
 
-        // Start multiple requests sequentially to avoid race conditions
+        // Start multiple requests sequentially
         const requestIds = ['req-1', 'req-2', 'req-3']
         const results = []
 
         for (const requestId of requestIds) {
-          serviceLocator.beginRequest(requestId)
-          const [_error1, requestService] =
-            await serviceLocator.getInstance(RequestService)
-          const [_error2, singletonService] =
-            await serviceLocator.getInstance(SingletonService)
-          await serviceLocator.endRequest(requestId)
+          const scoped = container.beginRequest(requestId)
+          const requestService = await scoped.get(RequestService)
+          const singletonService = await scoped.get(SingletonService)
+          await scoped.endRequest()
           results.push({ requestService, singletonService, requestId })
         }
 
@@ -721,10 +664,9 @@ describe('ServiceLocator', () => {
         }
 
         // Try to get Request-scoped service without request context
-        const [error] = await serviceLocator.getInstance(RequestService)
-
-        expect(error).toBeDefined()
-        expect(error?.code).toBe('UnknownError')
+        await expect(container.get(RequestService)).rejects.toThrow(
+          /Cannot resolve request-scoped service/,
+        )
       })
 
       it('should handle service instantiation errors in mixed scope scenario', async () => {
@@ -742,23 +684,23 @@ describe('ServiceLocator', () => {
           name = 'RequestService'
         }
 
-        const requestId = 'error-test'
-        serviceLocator.beginRequest(requestId)
+        const scoped = container.beginRequest('error-test')
 
         // Try to get Request service that depends on failing Singleton
-        // The system should throw an error when the service cannot be instantiated
-        await expect(
-          serviceLocator.getInstance(RequestService),
-        ).rejects.toThrow('Singleton creation failed')
+        await expect(scoped.get(RequestService)).rejects.toThrow(
+          'Singleton creation failed',
+        )
+
+        await scoped.endRequest()
       })
     })
   })
 
   describe('Injectable with Schema', () => {
-    let serviceLocator: ServiceLocator
+    let container: Container
 
     beforeEach(() => {
-      serviceLocator = new ServiceLocator(globalRegistry)
+      container = new Container(globalRegistry)
     })
 
     it('should work with simple schema definition', async () => {
@@ -777,16 +719,17 @@ describe('ServiceLocator', () => {
       }
 
       const token = getInjectableToken(DatabaseConfig)
-      const [error, instance] = await serviceLocator.getInstance(
+      const instance = await container.get(
         InjectionToken.bound(token, {
           host: 'localhost',
           port: 5432,
         }),
       )
 
-      expect(error).toBeUndefined()
       expect(instance).toBeInstanceOf(DatabaseConfig)
+      // @ts-expect-error - instance is of type DatabaseConfig
       expect(instance.config).toEqual({ host: 'localhost', port: 5432 })
+      // @ts-expect-error - instance is of type DatabaseConfig
       expect(instance.getConnectionString()).toBe('localhost:5432')
     })
 
@@ -805,17 +748,15 @@ describe('ServiceLocator', () => {
         }
       }
 
-      const [error1, instance1] = await serviceLocator.getInstance(ApiClient, {
+      const instance1 = await container.get(ApiClient, {
         apiKey: 'secret-key',
         baseUrl: 'https://api.example.com',
       })
-      const [error2, instance2] = await serviceLocator.getInstance(ApiClient, {
+      const instance2 = await container.get(ApiClient, {
         apiKey: 'secret-key',
         baseUrl: 'https://api.example.com',
       })
 
-      expect(error1).toBeUndefined()
-      expect(error2).toBeUndefined()
       expect(instance1).toBe(instance2) // Same singleton instance
       expect(instance1.getApiKey()).toBe('secret-key')
     })
@@ -835,17 +776,15 @@ describe('ServiceLocator', () => {
         }
       }
 
-      const [error1, instance1] = await serviceLocator.getInstance(Logger, {
+      const instance1 = await container.get(Logger, {
         level: 'info' as const,
         prefix: 'APP',
       })
-      const [error2, instance2] = await serviceLocator.getInstance(Logger, {
+      const instance2 = await container.get(Logger, {
         level: 'info' as const,
         prefix: 'APP',
       })
 
-      expect(error1).toBeUndefined()
-      expect(error2).toBeUndefined()
       expect(instance1).not.toBe(instance2) // Different transient instances
       expect(instance1.log('test')).toBe('[APP] test')
       expect(instance2.log('test')).toBe('[APP] test')
@@ -872,11 +811,8 @@ describe('ServiceLocator', () => {
         }
       }
 
-      const [error, instance] =
-        await serviceLocator.getInstance(DatabaseService)
+      const instance = await container.get(DatabaseService)
 
-      expect(error).toBeUndefined()
-      if (!instance) throw new Error('Instance is undefined')
       expect(instance).toBeInstanceOf(DatabaseService)
       expect(instance.getConnectionString()).toBe(
         'postgres://localhost:5432/mydb',
@@ -909,10 +845,8 @@ describe('ServiceLocator', () => {
         }
       }
 
-      const [error, instance] = await serviceLocator.getInstance(CacheService)
+      const instance = await container.get(CacheService)
 
-      expect(error).toBeUndefined()
-      if (!instance) throw new Error('Instance is undefined')
       expect(instance).toBeInstanceOf(CacheService)
       const config = await instance.getConfig()
       expect(config).toEqual({ ttl: 3600, maxSize: 1000 })
@@ -930,27 +864,19 @@ describe('ServiceLocator', () => {
       }
 
       // Valid configuration
-      const [error1, instance1] = await serviceLocator.getInstance(
-        StrictService,
-        {
-          required: 'value',
-          optional: 42,
-        },
-      )
+      const instance1 = await container.get(StrictService, {
+        required: 'value',
+        optional: 42,
+      })
 
-      expect(error1).toBeUndefined()
       expect(instance1).toBeInstanceOf(StrictService)
       expect(instance1.config).toEqual({ required: 'value', optional: 42 })
 
       // Valid with optional field missing
-      const [error2, instance2] = await serviceLocator.getInstance(
-        StrictService,
-        {
-          required: 'another value',
-        },
-      )
+      const instance2 = await container.get(StrictService, {
+        required: 'another value',
+      })
 
-      expect(error2).toBeUndefined()
       expect(instance2).toBeInstanceOf(StrictService)
       expect(instance2.config).toEqual({ required: 'another value' })
     })
@@ -984,7 +910,7 @@ describe('ServiceLocator', () => {
         }
       }
 
-      const [error, instance] = await serviceLocator.getInstance(AppConfig, {
+      const instance = await container.get(AppConfig, {
         database: {
           host: 'db.example.com',
           port: 5432,
@@ -999,7 +925,6 @@ describe('ServiceLocator', () => {
         },
       })
 
-      expect(error).toBeUndefined()
       expect(instance).toBeInstanceOf(AppConfig)
       expect(instance.getDatabaseHost()).toBe('db.example.com')
       expect(instance.isCacheEnabled()).toBe(true)
@@ -1025,19 +950,17 @@ describe('ServiceLocator', () => {
         }
       }
 
-      const requestId = 'test-request'
-      serviceLocator.beginRequest(requestId)
+      const scoped = container.beginRequest('test-request')
 
-      const [error, instance] = await serviceLocator.getInstance(UserContext, {
+      const instance = await scoped.get(UserContext, {
         userId: 'user-123',
         sessionId: 'session-456',
       })
 
-      expect(error).toBeUndefined()
       expect(instance).toBeInstanceOf(UserContext)
       expect(instance.getUserId()).toBe('user-123')
 
-      await serviceLocator.endRequest(requestId)
+      await scoped.endRequest()
     })
   })
 })