@tachybase/di 1.3.51 → 1.3.53

package/src/__tests__/decorators.test.ts

@@ -0,0 +1,178 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import { CannotInjectValueError, Container, Inject, InjectMany, Service, Token } from '../index';
+
+describe('Decorators', () => {
+  beforeEach(() => {
+    Container.reset({ strategy: 'resetServices' });
+  });
+
+  afterEach(() => {
+    Container.reset({ strategy: 'resetServices' });
+  });
+
+  describe('@Service Decorator', () => {
+    it('should register service with default options', () => {
+      @Service()
+      class TestService {
+        public name = 'test';
+      }
+
+      expect(Container.has(TestService)).toBe(true);
+      const instance = Container.get(TestService);
+      expect(instance).toBeInstanceOf(TestService);
+      expect(instance.name).toBe('test');
+    });
+
+    it('should register service with custom id', () => {
+      @Service({ id: 'custom-service' })
+      class TestService {
+        public name = 'test';
+      }
+
+      expect(Container.has('custom-service')).toBe(true);
+      const instance = Container.get('custom-service');
+      expect(instance).toBeInstanceOf(TestService);
+    });
+
+    it('should register service with singleton scope', () => {
+      @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 register service with transient scope', () => {
+      @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 register service with multiple flag', () => {
+      @Service({ multiple: true })
+      class TestService {
+        public name = 'test';
+      }
+
+      expect(Container.has(TestService)).toBe(true);
+      const services = Container.getMany(TestService);
+      expect(services).toHaveLength(1);
+    });
+
+    it('should register service with eager flag', () => {
+      let instantiated = false;
+
+      @Service({ eager: true })
+      class TestService {
+        constructor() {
+          instantiated = true;
+        }
+      }
+
+      expect(instantiated).toBe(true);
+    });
+
+    it('should register service with factory', () => {
+      const factory = () => ({ name: 'factory-created' });
+
+      @Service({ factory })
+      class TestService {}
+
+      const instance = Container.get(TestService);
+      expect(instance).toEqual({ name: 'factory-created' });
+    });
+  });
+
+  describe('@Inject Decorator', () => {
+    it('should inject service by string identifier', () => {
+      @Service({ id: 'dep-service' })
+      class DependencyService {
+        public name = 'dependency';
+      }
+
+      @Service()
+      class TestService {
+        @Inject('dep-service')
+        public dependency!: DependencyService;
+      }
+
+      const instance = Container.get(TestService);
+      expect(instance.dependency).toBeInstanceOf(DependencyService);
+    });
+
+    it('should inject service by token', () => {
+      const token = new Token<DependencyService>('dep-token');
+
+      @Service({ id: token })
+      class DependencyService {
+        public name = 'dependency';
+      }
+
+      @Service()
+      class TestService {
+        @Inject(token)
+        public dependency!: DependencyService;
+      }
+
+      const instance = Container.get(TestService);
+      expect(instance.dependency).toBeInstanceOf(DependencyService);
+    });
+  });
+
+  describe('@InjectMany Decorator', () => {
+    it('should inject multiple services by string identifier', () => {
+      @Service({ id: 'dep-service', multiple: true })
+      class DependencyService {
+        public name = 'dependency';
+      }
+
+      @Service({ id: 'dep-service', multiple: true })
+      class AnotherDependencyService {
+        public name = 'another-dependency';
+      }
+
+      @Service()
+      class TestService {
+        @InjectMany('dep-service')
+        public dependencies!: DependencyService[];
+      }
+
+      const instance = Container.get(TestService);
+      expect(instance.dependencies).toHaveLength(2);
+    });
+
+    it('should inject multiple services by token', () => {
+      const token = new Token<DependencyService>('dep-token');
+
+      @Service({ id: token, multiple: true })
+      class DependencyService {
+        public name = 'dependency';
+      }
+
+      @Service({ id: token, multiple: true })
+      class AnotherDependencyService {
+        public name = 'another-dependency';
+      }
+
+      @Service()
+      class TestService {
+        @InjectMany(token)
+        public dependencies!: DependencyService[];
+      }
+
+      const instance = Container.get(TestService);
+      expect(instance.dependencies).toHaveLength(2);
+    });
+  });
+});

package/src/__tests__/errors.test.ts

@@ -0,0 +1,359 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import {
+  CannotInjectValueError,
+  CannotInstantiateValueError,
+  Container,
+  ContainerInstance,
+  ServiceNotFoundError,
+  Token,
+} from '../index';
+
+describe('Error Handling', () => {
+  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('ServiceNotFoundError', () => {
+    it('should throw ServiceNotFoundError for non-existent string service', () => {
+      expect(() => container.get('non-existent-service')).toThrow(ServiceNotFoundError);
+    });
+
+    it('should throw ServiceNotFoundError for non-existent class service', () => {
+      class NonExistentService {}
+
+      expect(() => container.get(NonExistentService)).toThrow(ServiceNotFoundError);
+    });
+
+    it('should throw ServiceNotFoundError for non-existent token service', () => {
+      const token = new Token('non-existent-token');
+
+      expect(() => container.get(token)).toThrow(ServiceNotFoundError);
+    });
+
+    it('should have correct error message for string identifier', () => {
+      try {
+        container.get('test-service');
+      } catch (error) {
+        expect(error).toBeInstanceOf(ServiceNotFoundError);
+        expect(error.message).toContain('Service with "test-service" identifier was not found');
+        expect(error.message).toContain('Register it before usage');
+      }
+    });
+
+    it('should have correct error message for class identifier', () => {
+      class TestService {}
+
+      try {
+        container.get(TestService);
+      } catch (error) {
+        expect(error).toBeInstanceOf(ServiceNotFoundError);
+        expect(error.message).toContain('MaybeConstructable<TestService>');
+        expect(error.message).toContain('Register it before usage');
+      }
+    });
+
+    it('should have correct error message for token identifier', () => {
+      const token = new Token('test-token');
+
+      try {
+        container.get(token);
+      } catch (error) {
+        expect(error).toBeInstanceOf(ServiceNotFoundError);
+        expect(error.message).toContain('Token<test-token>');
+        expect(error.message).toContain('Register it before usage');
+      }
+    });
+
+    it('should have correct error message for token without name', () => {
+      const token = new Token();
+
+      try {
+        container.get(token);
+      } catch (error) {
+        expect(error).toBeInstanceOf(ServiceNotFoundError);
+        expect(error.message).toContain('Token<UNSET_NAME>');
+        expect(error.message).toContain('Register it before usage');
+      }
+    });
+
+    it('should throw ServiceNotFoundError for getMany with non-existent service', () => {
+      expect(() => container.getMany('non-existent-service')).toThrow(ServiceNotFoundError);
+    });
+  });
+
+  describe('CannotInstantiateValueError', () => {
+    it('should throw CannotInstantiateValueError when no type or factory provided', () => {
+      container.set({ id: 'invalid-service' });
+
+      expect(() => container.get('invalid-service')).toThrow(CannotInstantiateValueError);
+    });
+
+    it('should have correct error message', () => {
+      container.set({ id: 'invalid-service' });
+
+      try {
+        container.get('invalid-service');
+      } catch (error) {
+        expect(error).toBeInstanceOf(CannotInstantiateValueError);
+        expect(error.message).toContain('Cannot instantiate the requested value for the "invalid-service" identifier');
+        expect(error.message).toContain("doesn't contain a factory or a type to instantiate");
+      }
+    });
+
+    it('should throw error for class identifier', () => {
+      class TestService {}
+      container.set({ id: TestService });
+
+      expect(() => container.get(TestService)).toThrow(CannotInstantiateValueError);
+    });
+
+    it('should throw error for token identifier', () => {
+      const token = new Token('test-token');
+      container.set({ id: token });
+
+      expect(() => container.get(token)).toThrow(CannotInstantiateValueError);
+    });
+
+    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();
+    });
+  });
+
+  describe('CannotInjectValueError', () => {
+    it('should throw CannotInjectValueError when injecting unknown type', () => {
+      expect(() => {
+        // This would be caught during decoration, but we can't test it directly
+        // since the decorator runs at class definition time
+        class TestService {
+          // @Inject() // This would throw CannotInjectValueError
+          public unknown!: any;
+        }
+      }).not.toThrow(); // The error would be thrown during decoration, not here
+    });
+
+    it('should have correct error message format', () => {
+      class TestService {}
+      const propertyName = 'testProperty';
+
+      const error = new CannotInjectValueError(TestService, propertyName);
+
+      expect(error.message).toContain('Cannot inject value into "TestService.testProperty"');
+      expect(error.message).toContain('setup reflect-metadata properly');
+      expect(error.message).toContain('interfaces without service tokens');
+    });
+  });
+
+  describe('Container Disposal Errors', () => {
+    it('should throw error when using disposed container', async () => {
+      const testContainer = new ContainerInstance(`dispose-test-${Math.random()}`);
+      await testContainer.dispose();
+
+      expect(() => testContainer.get('test')).toThrow('Cannot use container after it has been disposed.');
+    });
+
+    it('should throw error when setting service in disposed container', async () => {
+      const testContainer = new ContainerInstance(`dispose-test-${Math.random()}`);
+      await testContainer.dispose();
+
+      expect(() => testContainer.set({ id: 'test', value: 'test' })).toThrow(
+        'Cannot use container after it has been disposed.',
+      );
+    });
+
+    it('should throw error when checking service in disposed container', async () => {
+      const testContainer = new ContainerInstance(`dispose-test-${Math.random()}`);
+      await testContainer.dispose();
+
+      expect(() => testContainer.has('test')).toThrow('Cannot use container after it has been disposed.');
+    });
+
+    it('should throw error when removing service in disposed container', async () => {
+      const testContainer = new ContainerInstance(`dispose-test-${Math.random()}`);
+      await testContainer.dispose();
+
+      expect(() => testContainer.remove('test')).toThrow('Cannot use container after it has been disposed.');
+    });
+
+    it('should throw error when resetting disposed container', async () => {
+      const testContainer = new ContainerInstance(`dispose-test-${Math.random()}`);
+      await testContainer.dispose();
+
+      expect(() => testContainer.reset()).toThrow('Cannot use container after it has been disposed.');
+    });
+  });
+
+  describe('Factory Errors', () => {
+    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 class not found in container', () => {
+      class Factory {
+        create() {
+          return 'created';
+        }
+      }
+
+      container.set({ id: 'factory-service', factory: [Factory, 'create'] });
+
+      // Should create factory instance directly since it's not in container
+      const result = container.get('factory-service');
+      expect(result).toBe('created');
+    });
+
+    it('should handle factory class found in container', () => {
+      class Factory {
+        create() {
+          return 'created-from-container';
+        }
+      }
+
+      container.set({ type: Factory });
+      container.set({ id: 'factory-service', factory: [Factory, 'create'] });
+
+      const result = container.get('factory-service');
+      expect(result).toBe('created-from-container');
+    });
+  });
+
+  describe('Multiple Service Errors', () => {
+    it('should throw error when getting single service with multiple flag', () => {
+      class TestService {
+        public name = 'test';
+      }
+
+      container.set({ id: 'test-services', type: TestService, multiple: true });
+
+      expect(() => container.get('test-services')).toThrow(
+        'Service with "test-services" identifier was not found in the container',
+      );
+    });
+
+    it('should throw error when getting single service with multiple flag using class', () => {
+      class TestService {
+        public name = 'test';
+      }
+
+      container.set({ type: TestService, multiple: true });
+
+      expect(() => container.get(TestService)).toThrow(
+        'Service with "MaybeConstructable<TestService>" identifier was not found in the container',
+      );
+    });
+  });
+
+  describe('Circular Dependency Errors', () => {
+    it('should handle circular dependencies gracefully', () => {
+      class ServiceA {
+        public serviceB: ServiceB;
+        constructor() {
+          this.serviceB = container.get(ServiceB);
+        }
+      }
+
+      class ServiceB {
+        public serviceA: ServiceA;
+        constructor() {
+          this.serviceA = container.get(ServiceA);
+        }
+      }
+
+      container.set({ type: ServiceA });
+      container.set({ type: ServiceB });
+
+      // Circular dependencies will cause stack overflow
+      expect(() => container.get(ServiceA)).toThrow('Maximum call stack size exceeded');
+    });
+  });
+
+  describe('Invalid Reset Strategy', () => {
+    it('should throw error for invalid reset strategy', () => {
+      expect(() => container.reset({ strategy: 'invalid' as any })).toThrow('Received invalid reset strategy.');
+    });
+  });
+
+  describe('Service Disposal Errors', () => {
+    it('should handle disposal errors gracefully', () => {
+      class TestService {
+        dispose() {
+          throw new Error('Disposal error');
+        }
+      }
+
+      container.set({ type: TestService });
+      const instance = container.get(TestService);
+
+      // Should not throw error even if disposal fails
+      expect(() => container.remove(TestService)).not.toThrow();
+    });
+
+    it('should handle disposal of service without dispose method', () => {
+      class TestService {
+        public name = 'test';
+      }
+
+      container.set({ type: TestService });
+      const instance = container.get(TestService);
+
+      // Should not throw error
+      expect(() => container.remove(TestService)).not.toThrow();
+    });
+  });
+
+  describe('Edge Cases', () => {
+    it('should handle undefined service identifier', () => {
+      expect(() => container.get(undefined as any)).toThrow();
+    });
+
+    it('should handle null service identifier', () => {
+      expect(() => container.get(null as any)).toThrow();
+    });
+
+    it('should handle empty string service identifier', () => {
+      expect(() => container.get('')).toThrow(ServiceNotFoundError);
+    });
+
+    it('should handle service with empty value', () => {
+      container.set({ id: 'empty-service', value: null });
+
+      const result = container.get('empty-service');
+      expect(result).toBeNull();
+    });
+
+    it('should handle service with undefined value', () => {
+      container.set({ id: 'undefined-service', value: undefined });
+
+      const result = container.get('undefined-service');
+      expect(result).toBeUndefined();
+    });
+  });
+});

package/src/__tests__/integration.test.ts

@@ -0,0 +1,123 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import { Container, ContainerInstance, Inject, InjectMany, Service, Token } from '../index';
+
+describe('Integration Tests', () => {
+  let container: ContainerInstance;
+
+  beforeEach(() => {
+    container = new ContainerInstance(`integration-test-${Math.random()}`);
+    Container.reset({ strategy: 'resetServices' });
+  });
+
+  afterEach(() => {
+    container.reset({ strategy: 'resetServices' });
+    Container.reset({ strategy: 'resetServices' });
+  });
+
+  describe('Real-world Application Scenarios', () => {
+    it('should handle plugin system with multiple implementations', () => {
+      // Plugin interface
+      const PluginToken = new Token<Plugin>('plugin');
+
+      interface Plugin {
+        name: string;
+        execute(): string;
+      }
+
+      // Plugin implementations
+      @Service({ id: PluginToken, multiple: true })
+      class LoggingPlugin implements Plugin {
+        public name = 'logging';
+
+        execute() {
+          return 'logging executed';
+        }
+      }
+
+      @Service({ id: PluginToken, multiple: true })
+      class CachingPlugin implements Plugin {
+        public name = 'caching';
+
+        execute() {
+          return 'caching executed';
+        }
+      }
+
+      // Plugin manager
+      @Service()
+      class PluginManager {
+        @InjectMany(PluginToken)
+        public plugins!: Plugin[];
+
+        public executeAll() {
+          return this.plugins.map((plugin) => plugin.execute());
+        }
+      }
+
+      const manager = Container.get(PluginManager);
+      const results = manager.executeAll();
+
+      expect(results).toHaveLength(2);
+      expect(results).toContain('logging executed');
+      expect(results).toContain('caching executed');
+    });
+  });
+
+  describe('Performance and Memory', () => {
+    it('should handle large number of services efficiently', () => {
+      const services: any[] = [];
+
+      // Create many services
+      for (let i = 0; i < 100; i++) {
+        class TestService {
+          public id = i;
+        }
+
+        container.set({ id: `service-${i}`, type: TestService });
+        services.push(container.get(`service-${i}`));
+      }
+
+      // Verify all services are accessible
+      for (let i = 0; i < 100; i++) {
+        expect(container.has(`service-${i}`)).toBe(true);
+        const service = container.get(`service-${i}`);
+        expect(service.id).toBe(i);
+      }
+    });
+
+    it('should handle rapid service creation and destruction', () => {
+      class TestService {
+        public id = Math.random();
+      }
+
+      // Rapidly create and destroy services
+      for (let i = 0; i < 50; i++) {
+        container.set({ id: `temp-service-${i}`, type: TestService });
+        const service = container.get(`temp-service-${i}`);
+        expect(service).toBeInstanceOf(TestService);
+        container.remove(`temp-service-${i}`);
+        expect(container.has(`temp-service-${i}`)).toBe(false);
+      }
+    });
+  });
+
+  describe('Cross-Container Scenarios', () => {
+    it('should handle singleton services across containers', () => {
+      const container1 = new ContainerInstance('container1');
+      const container2 = new ContainerInstance('container2');
+
+      @Service({ scope: 'singleton' })
+      class SingletonService {
+        public id = Math.random();
+      }
+
+      const service1 = container1.get(SingletonService);
+      const service2 = container2.get(SingletonService);
+
+      // Singleton should be shared across containers
+      expect(service1).toBe(service2);
+      expect(service1.id).toBe(service2.id);
+    });
+  });
+});