@tachybase/di 1.3.52 → 1.3.53

package/src/__tests__/scopes.test.ts

@@ -0,0 +1,284 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import { Container, ContainerInstance, Inject, Service } from '../index';
+
+describe('Service Scopes', () => {
+  let container1: ContainerInstance;
+  let container2: ContainerInstance;
+
+  beforeEach(() => {
+    container1 = new ContainerInstance(`container1-${Math.random()}`);
+    container2 = new ContainerInstance(`container2-${Math.random()}`);
+    Container.reset({ strategy: 'resetServices' });
+  });
+
+  afterEach(() => {
+    container1.reset({ strategy: 'resetServices' });
+    container2.reset({ strategy: 'resetServices' });
+    Container.reset({ strategy: 'resetServices' });
+  });
+
+  describe('Container Scope', () => {
+    it('should create separate instances in different containers', () => {
+      class TestService {
+        public id = Math.random();
+      }
+
+      container1.set({ type: TestService, scope: 'container' });
+      container2.set({ type: TestService, scope: 'container' });
+
+      const instance1 = container1.get(TestService);
+      const instance2 = container2.get(TestService);
+
+      expect(instance1).not.toBe(instance2);
+      expect(instance1.id).not.toBe(instance2.id);
+    });
+
+    it('should reuse instance within same container', () => {
+      class TestService {
+        public id = Math.random();
+      }
+
+      container1.set({ type: TestService, scope: 'container' });
+
+      const instance1 = container1.get(TestService);
+      const instance2 = container1.get(TestService);
+
+      expect(instance1).toBe(instance2);
+      expect(instance1.id).toBe(instance2.id);
+    });
+
+    it('should work with decorators', () => {
+      @Service({ scope: 'container' })
+      class TestService {
+        public id = Math.random();
+      }
+
+      const instance1 = Container.get(TestService);
+      const instance2 = Container.get(TestService);
+
+      expect(instance1).toBe(instance2);
+    });
+  });
+
+  describe('Singleton Scope', () => {
+    it('should share instance across all containers', () => {
+      class TestService {
+        public id = Math.random();
+      }
+
+      container1.set({ type: TestService, scope: 'singleton' });
+      container2.set({ type: TestService, scope: 'singleton' });
+
+      const instance1 = container1.get(TestService);
+      const instance2 = container2.get(TestService);
+
+      expect(instance1).toBe(instance2);
+      expect(instance1.id).toBe(instance2.id);
+    });
+
+    it('should register in default container when set in child container', () => {
+      class TestService {
+        public id = Math.random();
+      }
+
+      container1.set({ type: TestService, scope: 'singleton' });
+
+      // Should be registered in default container
+      expect(Container.has(TestService)).toBe(true);
+      expect(container1.has(TestService)).toBe(false);
+
+      const instance1 = container1.get(TestService);
+      const instance2 = Container.get(TestService);
+
+      expect(instance1).toBe(instance2);
+    });
+
+    it('should work with decorators', () => {
+      @Service({ scope: 'singleton' })
+      class TestService {
+        public id = Math.random();
+      }
+
+      const instance1 = Container.get(TestService);
+      const instance2 = Container.get(TestService);
+
+      expect(instance1).toBe(instance2);
+    });
+
+    it('should handle multiple services with singleton scope', () => {
+      class TestService1 {
+        public name = 'service1';
+      }
+
+      class TestService2 {
+        public name = 'service2';
+      }
+
+      container1.set({ id: 'test-services', type: TestService1, multiple: true, scope: 'singleton' });
+      container2.set({ id: 'test-services', type: TestService2, multiple: true, scope: 'singleton' });
+
+      const services1 = container1.getMany('test-services');
+      const services2 = container2.getMany('test-services');
+
+      expect(services1).toHaveLength(2);
+      expect(services2).toHaveLength(2);
+      expect(services1[0]).toBe(services2[0]);
+      expect(services1[1]).toBe(services2[1]);
+    });
+  });
+
+  describe('Transient Scope', () => {
+    it('should create new instance every time', () => {
+      class TestService {
+        public id = Math.random();
+      }
+
+      container1.set({ type: TestService, scope: 'transient' });
+
+      const instance1 = container1.get(TestService);
+      const instance2 = container1.get(TestService);
+
+      expect(instance1).not.toBe(instance2);
+      expect(instance1.id).not.toBe(instance2.id);
+    });
+
+    it('should create new instances in different containers', () => {
+      class TestService {
+        public id = Math.random();
+      }
+
+      container1.set({ type: TestService, scope: 'transient' });
+      container2.set({ type: TestService, scope: 'transient' });
+
+      const instance1 = container1.get(TestService);
+      const instance2 = container2.get(TestService);
+
+      expect(instance1).not.toBe(instance2);
+      expect(instance1.id).not.toBe(instance2.id);
+    });
+
+    it('should work with decorators', () => {
+      @Service({ scope: 'transient' })
+      class TestService {
+        public id = Math.random();
+      }
+
+      const instance1 = Container.get(TestService);
+      const instance2 = Container.get(TestService);
+
+      expect(instance1).not.toBe(instance2);
+    });
+
+    it('should not store value for transient services', () => {
+      class TestService {
+        public id = Math.random();
+      }
+
+      container1.set({ type: TestService, scope: 'transient' });
+
+      const instance1 = container1.get(TestService);
+      const instance2 = container1.get(TestService);
+
+      // Both should be new instances
+      expect(instance1).not.toBe(instance2);
+    });
+  });
+
+  describe('Mixed Scopes', () => {
+    it('should handle inheritance with different scopes', () => {
+      @Service({ scope: 'singleton' })
+      class BaseService {
+        public id = Math.random();
+      }
+
+      @Service({ scope: 'transient' })
+      class ExtendedService extends BaseService {
+        public name = 'extended';
+      }
+
+      const instance1 = Container.get(ExtendedService);
+      const instance2 = Container.get(ExtendedService);
+
+      // Extended service should be transient
+      expect(instance1).not.toBe(instance2);
+
+      // Base service should also be transient since ExtendedService is transient
+      expect(instance1.id).not.toBe(instance2.id);
+    });
+  });
+
+  describe('Scope Edge Cases', () => {
+    it('should handle scope change after registration', () => {
+      class TestService {
+        public id = Math.random();
+      }
+
+      container1.set({ type: TestService, scope: 'container' });
+      const instance1 = container1.get(TestService);
+
+      // Change scope
+      container1.set({ type: TestService, scope: 'transient' });
+      const instance2 = container1.get(TestService);
+
+      // Should create new instance due to scope change
+      expect(instance1).not.toBe(instance2);
+    });
+
+    it('should handle eager services with different scopes', () => {
+      let singletonInstantiated = false;
+      let containerInstantiated = false;
+      let transientInstantiated = false;
+
+      @Service({ scope: 'singleton', eager: true })
+      class SingletonService {
+        constructor() {
+          singletonInstantiated = true;
+        }
+      }
+
+      @Service({ scope: 'container', eager: true })
+      class ContainerService {
+        constructor() {
+          containerInstantiated = true;
+        }
+      }
+
+      @Service({ scope: 'transient', eager: true })
+      class TransientService {
+        constructor() {
+          transientInstantiated = true;
+        }
+      }
+
+      expect(singletonInstantiated).toBe(true);
+      expect(containerInstantiated).toBe(true);
+      expect(transientInstantiated).toBe(false); // Transient eager services are ignored
+    });
+
+    it('should handle multiple services with different scopes', () => {
+      class Service1 {
+        public name = 'service1';
+      }
+
+      class Service2 {
+        public name = 'service2';
+      }
+
+      container1.set({ id: 'mixed-services', type: Service1, multiple: true, scope: 'singleton' });
+      container1.set({ id: 'mixed-services', type: Service2, multiple: true, scope: 'container' });
+
+      const services1 = container1.getMany('mixed-services');
+      const services2 = container1.getMany('mixed-services');
+
+      expect(services1).toHaveLength(1);
+      expect(services2).toHaveLength(1);
+
+      // First service is singleton, should be the same
+      expect(services1[0]).toBe(services2[0]);
+
+      // Second service is container scope, should be the same
+      expect(services1[1]).toBe(services2[1]);
+    });
+  });
+});

package/src/__tests__/token-factory.test.ts

@@ -0,0 +1,407 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import { Container, ContainerInstance, Inject, Service, Token } from '../index';
+
+describe('Token and Factory Patterns', () => {
+  let container: ContainerInstance;
+
+  beforeEach(() => {
+    container = new ContainerInstance(`test-container-${Math.random()}`);
+    Container.reset({ strategy: 'resetServices' });
+  });
+
+  afterEach(() => {
+    container.reset({ strategy: 'resetServices' });
+    Container.reset({ strategy: 'resetServices' });
+  });
+
+  describe('Token Class', () => {
+    it('should create token with name', () => {
+      const token = new Token('test-token');
+      expect(token.name).toBe('test-token');
+    });
+
+    it('should create token without name', () => {
+      const token = new Token();
+      expect(token.name).toBeUndefined();
+    });
+
+    it('should create token with empty string name', () => {
+      const token = new Token('');
+      expect(token.name).toBe('');
+    });
+
+    it('should be unique instances', () => {
+      const token1 = new Token('same-name');
+      const token2 = new Token('same-name');
+
+      expect(token1).not.toBe(token2);
+      expect(token1.name).toBe(token2.name);
+    });
+
+    it('should work as service identifier', () => {
+      const token = new Token('service-token');
+
+      class TestService {
+        public name = 'test';
+      }
+
+      container.set({ id: token, type: TestService });
+
+      expect(container.has(token)).toBe(true);
+      const instance = container.get(token);
+      expect(instance).toBeInstanceOf(TestService);
+    });
+
+    it('should work with decorators', () => {
+      const token = new Token('decorator-token');
+
+      @Service({ id: token })
+      class TestService {
+        public name = 'test';
+      }
+
+      @Service()
+      class ConsumerService {
+        @Inject(token)
+        public testService!: TestService;
+      }
+
+      const consumer = Container.get(ConsumerService);
+      expect(consumer.testService).toBeInstanceOf(TestService);
+    });
+
+    it('should work with multiple services', () => {
+      const token = new Token('multi-token');
+
+      class Service1 {
+        public name = 'service1';
+      }
+
+      class Service2 {
+        public name = 'service2';
+      }
+
+      container.set({ id: token, type: Service1, multiple: true });
+      container.set({ id: token, type: Service2, multiple: true });
+
+      const services = container.getMany(token);
+      expect(services).toHaveLength(2);
+      expect(services[0]).toBeInstanceOf(Service1);
+      expect(services[1]).toBeInstanceOf(Service2);
+    });
+  });
+
+  describe('Factory Functions', () => {
+    it('should use simple factory function', () => {
+      const factory = () => ({ name: 'factory-created', id: Math.random() });
+
+      container.set({ id: 'factory-service', factory });
+
+      const instance1 = container.get('factory-service');
+      const instance2 = container.get('factory-service');
+
+      expect(instance1.name).toBe('factory-created');
+      expect(instance2.name).toBe('factory-created');
+      expect(instance1).toBe(instance2); // Same instance due to container scope
+    });
+
+    it('should use factory with container parameter', () => {
+      const factory = (container: ContainerInstance, id: any) => {
+        return { name: 'factory-with-container', containerId: container.id, serviceId: id };
+      };
+
+      container.set({ id: 'container-factory', factory });
+
+      const instance = container.get('container-factory');
+      expect(instance.name).toBe('factory-with-container');
+      expect(instance.containerId).toMatch(/^test-container-/);
+      expect(instance.serviceId).toBe('container-factory');
+    });
+
+    it('should use factory with token parameter', () => {
+      const token = new Token('factory-token');
+      const factory = (container: ContainerInstance, id: any) => {
+        return { name: 'factory-with-token', tokenId: id };
+      };
+
+      container.set({ id: token, factory });
+
+      const instance = container.get(token);
+      expect(instance.name).toBe('factory-with-token');
+      expect(instance.tokenId).toBe(token);
+    });
+
+    it('should work with decorators', () => {
+      const factory = () => ({ name: 'decorator-factory' });
+
+      @Service({ id: 'decorator-factory-service', factory })
+      class TestService {}
+
+      @Service()
+      class ConsumerService {
+        @Inject('decorator-factory-service')
+        public testService!: any;
+      }
+
+      const consumer = Container.get(ConsumerService);
+      expect(consumer.testService.name).toBe('decorator-factory');
+    });
+  });
+
+  describe('Factory Classes', () => {
+    it('should use factory class with method', () => {
+      class TestFactory {
+        create(container: ContainerInstance, id: any) {
+          return { name: 'factory-class-created', id };
+        }
+      }
+
+      container.set({ id: 'factory-class', factory: [TestFactory, 'create'] });
+
+      const instance = container.get('factory-class');
+      expect(instance.name).toBe('factory-class-created');
+      expect(instance.id).toBe('factory-class');
+    });
+
+    it('should use factory class from container', () => {
+      class TestFactory {
+        create(container: ContainerInstance, id: any) {
+          return { name: 'factory-from-container', id };
+        }
+      }
+
+      // Register factory in container
+      container.set({ type: TestFactory });
+      container.set({ id: 'factory-from-container', factory: [TestFactory, 'create'] });
+
+      const instance = container.get('factory-from-container');
+      expect(instance.name).toBe('factory-from-container');
+    });
+
+    it('should handle factory class not in container', () => {
+      class TestFactory {
+        create(container: ContainerInstance, id: any) {
+          return { name: 'factory-not-in-container', id };
+        }
+      }
+
+      // Don't register factory in container
+      container.set({ id: 'factory-not-in-container', factory: [TestFactory, 'create'] });
+
+      const instance = container.get('factory-not-in-container');
+      expect(instance.name).toBe('factory-not-in-container');
+    });
+
+    it('should work with decorators', () => {
+      class TestFactory {
+        create() {
+          return { name: 'decorator-factory-class' };
+        }
+      }
+
+      @Service({ id: 'decorator-factory-class-service', factory: [TestFactory, 'create'] })
+      class TestService {}
+
+      @Service()
+      class ConsumerService {
+        @Inject('decorator-factory-class-service')
+        public testService!: any;
+      }
+
+      const consumer = Container.get(ConsumerService);
+      expect(consumer.testService.name).toBe('decorator-factory-class');
+    });
+  });
+
+  describe('Complex Factory Scenarios', () => {
+    it('should handle factory with dependencies', () => {
+      class DependencyService {
+        public name = 'dependency';
+      }
+
+      class TestFactory {
+        create(container: ContainerInstance, id: any) {
+          const dependency = container.get(DependencyService);
+          return { name: 'factory-with-dependency', dependency: dependency.name };
+        }
+      }
+
+      container.set({ type: DependencyService });
+      container.set({ id: 'factory-with-dependency', factory: [TestFactory, 'create'] });
+
+      const instance = container.get('factory-with-dependency');
+      expect(instance.name).toBe('factory-with-dependency');
+      expect(instance.dependency).toBe('dependency');
+    });
+
+    it('should handle factory with multiple dependencies', () => {
+      class Service1 {
+        public name = 'service1';
+      }
+
+      class Service2 {
+        public name = 'service2';
+      }
+
+      class TestFactory {
+        create(container: ContainerInstance, id: any) {
+          const service1 = container.get(Service1);
+          const service2 = container.get(Service2);
+          return {
+            name: 'factory-with-multiple-dependencies',
+            services: [service1.name, service2.name],
+          };
+        }
+      }
+
+      container.set({ type: Service1 });
+      container.set({ type: Service2 });
+      container.set({ id: 'factory-multiple-deps', factory: [TestFactory, 'create'] });
+
+      const instance = container.get('factory-multiple-deps');
+      expect(instance.name).toBe('factory-with-multiple-dependencies');
+      expect(instance.services).toEqual(['service1', 'service2']);
+    });
+
+    it('should handle factory with token dependencies', () => {
+      const token = new Token('token-dependency');
+
+      class TestFactory {
+        create(container: ContainerInstance, id: any) {
+          const dependency = container.get(token);
+          return { name: 'factory-with-token-dependency', dependency: dependency.name };
+        }
+      }
+
+      container.set({ id: token, value: { name: 'token-dependency-value' } });
+      container.set({ id: 'factory-token-deps', factory: [TestFactory, 'create'] });
+
+      const instance = container.get('factory-token-deps');
+      expect(instance.name).toBe('factory-with-token-dependency');
+      expect(instance.dependency).toBe('token-dependency-value');
+    });
+  });
+
+  describe('Factory with Different Scopes', () => {
+    it('should handle factory with transient scope', () => {
+      const factory = () => ({ id: Math.random() });
+
+      container.set({ id: 'transient-factory', factory, scope: 'transient' });
+
+      const instance1 = container.get('transient-factory');
+      const instance2 = container.get('transient-factory');
+
+      expect(instance1).not.toBe(instance2);
+      expect(instance1.id).not.toBe(instance2.id);
+    });
+
+    it('should handle factory with singleton scope', () => {
+      const factory = () => ({ id: Math.random() });
+
+      container.set({ id: 'singleton-factory', factory, scope: 'singleton' });
+
+      const instance1 = container.get('singleton-factory');
+      const instance2 = container.get('singleton-factory');
+
+      expect(instance1).toBe(instance2);
+      expect(instance1.id).toBe(instance2.id);
+    });
+
+    it('should handle factory with container scope', () => {
+      const factory = () => ({ id: Math.random() });
+
+      container.set({ id: 'container-factory', factory, scope: 'container' });
+
+      const instance1 = container.get('container-factory');
+      const instance2 = container.get('container-factory');
+
+      expect(instance1).toBe(instance2);
+      expect(instance1.id).toBe(instance2.id);
+    });
+  });
+
+  describe('Factory Error Handling', () => {
+    it('should propagate factory errors', () => {
+      const factory = () => {
+        throw new Error('Factory error');
+      };
+
+      container.set({ id: 'error-factory', factory });
+
+      expect(() => container.get('error-factory')).toThrow('Factory error');
+    });
+
+    it('should handle factory returning undefined', () => {
+      const factory = () => undefined;
+
+      container.set({ id: 'undefined-factory', factory });
+
+      // Factory returning undefined should not throw, but the value should be undefined
+      const result = container.get('undefined-factory');
+      expect(result).toBeUndefined();
+    });
+
+    it('should handle factory returning null', () => {
+      const factory = () => null;
+
+      container.set({ id: 'null-factory', factory });
+
+      // Factory returning null should not throw, but the value should be null
+      const result = container.get('null-factory');
+      expect(result).toBeNull();
+    });
+
+    it('should handle factory class method not found', () => {
+      class TestFactory {
+        // No create method
+      }
+
+      container.set({ id: 'missing-method-factory', factory: [TestFactory, 'create'] });
+
+      expect(() => container.get('missing-method-factory')).toThrow();
+    });
+  });
+
+  describe('Token and Factory Integration', () => {
+    it('should use token with factory', () => {
+      const token = new Token('token-factory');
+      const factory = () => ({ name: 'token-factory-created' });
+
+      container.set({ id: token, factory });
+
+      const instance = container.get(token);
+      expect(instance.name).toBe('token-factory-created');
+    });
+
+    it('should use token with factory class', () => {
+      const token = new Token('token-factory-class');
+
+      class TestFactory {
+        create() {
+          return { name: 'token-factory-class-created' };
+        }
+      }
+
+      container.set({ id: token, factory: [TestFactory, 'create'] });
+
+      const instance = container.get(token);
+      expect(instance.name).toBe('token-factory-class-created');
+    });
+
+    it('should use token with multiple services and factory', () => {
+      const token = new Token('token-multi-factory');
+
+      const factory1 = () => ({ name: 'factory1' });
+      const factory2 = () => ({ name: 'factory2' });
+
+      container.set({ id: token, factory: factory1, multiple: true });
+      container.set({ id: token, factory: factory2, multiple: true });
+
+      const services = container.getMany(token);
+      expect(services).toHaveLength(2);
+      expect(services[0].name).toBe('factory1');
+      expect(services[1].name).toBe('factory2');
+    });
+  });
+});

package/src/index.ts

@@ -14,6 +14,7 @@ export type { ServiceOptions } from './interfaces/service-options.interface';
 export type { ServiceIdentifier } from './types/service-identifier.type';
 
 export { ContainerInstance, Container } from './container-instance.class';
+export { ContainerRegistry } from './container-registry.class';
 export { Token } from './token.class';
 
 export default Container;