@tachybase/di 1.3.51 → 1.3.53

package/lib/index.d.ts

@@ -10,6 +10,7 @@ export type { ServiceMetadata } from './interfaces/service-metadata.interface';
 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;
 export * from './decorators';

package/lib/index.js

@@ -20,6 +20,7 @@ var index_exports = {};
 __export(index_exports, {
   Container: () => import_container_instance2.Container,
   ContainerInstance: () => import_container_instance2.ContainerInstance,
+  ContainerRegistry: () => import_container_registry.ContainerRegistry,
   Token: () => import_token.Token,
   default: () => index_default
 });
@@ -32,6 +33,7 @@ __reExport(index_exports, require("./error/cannot-inject-value.error"), module.e
 __reExport(index_exports, require("./error/cannot-instantiate-value.error"), module.exports);
 __reExport(index_exports, require("./error/service-not-found.error"), module.exports);
 var import_container_instance2 = require("./container-instance.class");
+var import_container_registry = require("./container-registry.class");
 var import_token = require("./token.class");
 __reExport(index_exports, require("./decorators"), module.exports);
 var index_default = import_container_instance.Container;
@@ -39,6 +41,7 @@ var index_default = import_container_instance.Container;
 0 && (module.exports = {
   Container,
   ContainerInstance,
+  ContainerRegistry,
   Token,
   ...require("./decorators/inject-many.decorator"),
   ...require("./decorators/inject.decorator"),

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@tachybase/di",
-  "version": "1.3.51",
+  "version": "1.3.53",
   "description": "",
   "license": "Apache-2.0",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "dependencies": {
-    "@tachybase/utils": "^1.3.42"
+    "@tachybase/utils": "^1.3.52"
   }
 }

package/src/__tests__/container-instance.test.ts

@@ -0,0 +1,324 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import { CannotInstantiateValueError, Container, ContainerInstance, ServiceNotFoundError, Token } from '../index';
+
+describe('ContainerInstance', () => {
+  let container: ContainerInstance;
+
+  beforeEach(() => {
+    container = new ContainerInstance(`test-container-${Math.random()}`);
+  });
+
+  afterEach(() => {
+    container.reset({ strategy: 'resetServices' });
+  });
+
+  describe('Basic Operations', () => {
+    it('should create a new container instance with given id', () => {
+      const newContainer = new ContainerInstance('my-container');
+      expect(newContainer.id).toBe('my-container');
+    });
+
+    it('should have default container', () => {
+      expect(ContainerInstance.default).toBeDefined();
+      expect(ContainerInstance.default.id).toBe('default');
+    });
+
+    it('should check if service exists', () => {
+      class TestService {}
+
+      expect(container.has(TestService)).toBe(false);
+      container.set({ type: TestService });
+      expect(container.has(TestService)).toBe(true);
+    });
+
+    it('should register and retrieve service by class', () => {
+      class TestService {
+        public name = 'test';
+      }
+
+      container.set({ type: TestService });
+      const instance = container.get(TestService) as TestService;
+
+      expect(instance).toBeInstanceOf(TestService);
+      expect(instance.name).toBe('test');
+    });
+
+    it('should register and retrieve service by string identifier', () => {
+      class TestService {
+        public name = 'test';
+      }
+
+      container.set({ id: 'test-service', type: TestService });
+      const instance = container.get('test-service') as TestService;
+
+      expect(instance).toBeInstanceOf(TestService);
+      expect(instance.name).toBe('test');
+    });
+
+    it('should register and retrieve service by token', () => {
+      const token = new Token<TestService>('test-token');
+
+      class TestService {
+        public name = 'test';
+      }
+
+      container.set({ id: token, type: TestService });
+      const instance = container.get(token);
+
+      expect(instance).toBeInstanceOf(TestService);
+      expect(instance.name).toBe('test');
+    });
+
+    it('should register and retrieve service with value', () => {
+      const value = { name: 'test-value' };
+
+      container.set({ id: 'test-value', value });
+      const instance = container.get('test-value');
+
+      expect(instance).toBe(value);
+    });
+
+    it('should register and retrieve service with factory', () => {
+      const factory = () => ({ name: 'factory-created' });
+
+      container.set({ id: 'test-factory', factory });
+      const instance = container.get('test-factory');
+
+      expect(instance).toEqual({ name: 'factory-created' });
+    });
+
+    it('should register and retrieve service with factory class', () => {
+      class Factory {
+        create() {
+          return { name: 'factory-class-created' };
+        }
+      }
+
+      container.set({ id: 'test-factory-class', factory: [Factory, 'create'] });
+      const instance = container.get('test-factory-class');
+
+      expect(instance).toEqual({ name: 'factory-class-created' });
+    });
+  });
+
+  describe('Service Scopes', () => {
+    it('should create new instance for transient scope', () => {
+      class TestService {
+        public id = Math.random();
+      }
+
+      container.set({ type: TestService, scope: 'transient' });
+
+      const instance1 = container.get(TestService);
+      const instance2 = container.get(TestService);
+
+      expect(instance1).not.toBe(instance2);
+      expect(instance1.id).not.toBe(instance2.id);
+    });
+
+    it('should reuse instance for container scope', () => {
+      class TestService {
+        public id = Math.random();
+      }
+
+      container.set({ type: TestService, scope: 'container' });
+
+      const instance1 = container.get(TestService);
+      const instance2 = container.get(TestService);
+
+      expect(instance1).toBe(instance2);
+      expect(instance1.id).toBe(instance2.id);
+    });
+
+    it('should reuse instance for singleton scope', () => {
+      class TestService {
+        public id = Math.random();
+      }
+
+      container.set({ type: TestService, scope: 'singleton' });
+
+      const instance1 = container.get(TestService);
+      const instance2 = container.get(TestService);
+
+      expect(instance1).toBe(instance2);
+      expect(instance1.id).toBe(instance2.id);
+    });
+  });
+
+  describe('Multiple Services', () => {
+    it('should register and retrieve multiple services', () => {
+      class TestService1 {
+        public name = 'service1';
+      }
+
+      class TestService2 {
+        public name = 'service2';
+      }
+
+      container.set({ id: 'test-services', type: TestService1, multiple: true });
+      container.set({ id: 'test-services', type: TestService2, multiple: true });
+
+      const services = container.getMany('test-services');
+
+      expect(services).toHaveLength(2);
+      expect(services[0]).toBeInstanceOf(TestService1);
+      expect(services[1]).toBeInstanceOf(TestService2);
+    });
+
+    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',
+      );
+    });
+  });
+
+  describe('Eager Services', () => {
+    it('should instantiate eager service immediately', () => {
+      let instantiated = false;
+
+      class TestService {
+        constructor() {
+          instantiated = true;
+        }
+      }
+
+      container.set({ type: TestService, eager: true });
+
+      expect(instantiated).toBe(true);
+    });
+
+    it('should not instantiate eager transient service', () => {
+      let instantiated = false;
+
+      class TestService {
+        constructor() {
+          instantiated = true;
+        }
+      }
+
+      container.set({ type: TestService, eager: true, scope: 'transient' });
+
+      expect(instantiated).toBe(false);
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should throw ServiceNotFoundError when service not found', () => {
+      expect(() => container.get('non-existent-service')).toThrow(ServiceNotFoundError);
+    });
+
+    it('should throw CannotInstantiateValueError when no type or factory', () => {
+      container.set({ id: 'invalid-service' });
+
+      expect(() => container.get('invalid-service')).toThrow(CannotInstantiateValueError);
+    });
+
+    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.');
+    });
+  });
+
+  describe('Service Removal', () => {
+    it('should remove single service', () => {
+      class TestService {
+        public name = 'test';
+      }
+
+      container.set({ type: TestService });
+      expect(container.has(TestService)).toBe(true);
+
+      container.remove(TestService);
+      expect(container.has(TestService)).toBe(false);
+    });
+
+    it('should remove multiple services', () => {
+      class TestService1 {
+        public name = 'test1';
+      }
+
+      class TestService2 {
+        public name = 'test2';
+      }
+
+      container.set({ type: TestService1 });
+      container.set({ type: TestService2 });
+
+      container.remove([TestService1, TestService2]);
+
+      expect(container.has(TestService1)).toBe(false);
+      expect(container.has(TestService2)).toBe(false);
+    });
+  });
+
+  describe('Container Reset', () => {
+    it('should reset values but keep services', () => {
+      class TestService {
+        public id = Math.random();
+      }
+
+      container.set({ type: TestService });
+      const instance1 = container.get(TestService);
+
+      container.reset({ strategy: 'resetValue' });
+      const instance2 = container.get(TestService);
+
+      expect(container.has(TestService)).toBe(true);
+      expect(instance1).not.toBe(instance2);
+    });
+
+    it('should reset services completely', () => {
+      class TestService {
+        public name = 'test';
+      }
+
+      container.set({ type: TestService });
+      expect(container.has(TestService)).toBe(true);
+
+      container.reset({ strategy: 'resetServices' });
+      expect(container.has(TestService)).toBe(false);
+    });
+  });
+
+  describe('Service Disposal', () => {
+    it('should call dispose method on service when removing', () => {
+      let disposed = false;
+
+      class TestService {
+        dispose() {
+          disposed = true;
+        }
+      }
+
+      container.set({ type: TestService });
+      const instance = container.get(TestService);
+
+      container.remove(TestService);
+
+      expect(disposed).toBe(true);
+    });
+
+    it('should handle disposal errors gracefully', () => {
+      class TestService {
+        dispose() {
+          throw new Error('Disposal error');
+        }
+      }
+
+      container.set({ type: TestService });
+      container.get(TestService);
+
+      // Should not throw error
+      expect(() => container.remove(TestService)).not.toThrow();
+    });
+  });
+});

package/src/__tests__/container-registry.test.ts

@@ -0,0 +1,279 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import { ContainerInstance, ContainerRegistry } from '../index';
+
+describe('ContainerRegistry', () => {
+  let container1: ContainerInstance;
+  let container2: ContainerInstance;
+
+  beforeEach(() => {
+    // Clean up any existing containers
+    ContainerInstance.default.reset({ strategy: 'resetServices' });
+  });
+
+  afterEach(async () => {
+    // Clean up containers
+    try {
+      if (container1 && !container1['disposed']) {
+        await container1.dispose();
+      }
+    } catch (error) {
+      // Ignore errors during cleanup
+    }
+
+    try {
+      if (container2 && !container2['disposed']) {
+        await container2.dispose();
+      }
+    } catch (error) {
+      // Ignore errors during cleanup
+    }
+
+    ContainerInstance.default.reset({ strategy: 'resetServices' });
+  });
+
+  describe('Container Registration', () => {
+    it('should register container automatically when created', () => {
+      container1 = new ContainerInstance('test-container-1');
+
+      expect(ContainerRegistry.hasContainer('test-container-1')).toBe(true);
+    });
+
+    it('should register default container', () => {
+      expect(ContainerRegistry.hasContainer('default')).toBe(true);
+    });
+
+    it('should throw error when registering non-ContainerInstance', () => {
+      expect(() => {
+        ContainerRegistry.registerContainer({} as any);
+      }).toThrow('Only ContainerInstance instances can be registered.');
+    });
+
+    it('should throw error when registering container with same ID', () => {
+      container1 = new ContainerInstance('duplicate-id');
+
+      expect(() => {
+        container2 = new ContainerInstance('duplicate-id');
+      }).toThrow('Cannot register container with same ID.');
+    });
+  });
+
+  describe('Container Retrieval', () => {
+    it('should retrieve registered container', () => {
+      container1 = new ContainerInstance('retrieve-test');
+
+      const retrieved = ContainerRegistry.getContainer('retrieve-test');
+      expect(retrieved).toBe(container1);
+      expect(retrieved.id).toBe('retrieve-test');
+    });
+
+    it('should throw error when retrieving non-existent container', () => {
+      expect(() => {
+        ContainerRegistry.getContainer('non-existent');
+      }).toThrow('No container is registered with the given ID.');
+    });
+
+    it('should check if container exists', () => {
+      expect(ContainerRegistry.hasContainer('non-existent')).toBe(false);
+
+      container1 = new ContainerInstance('exists-test');
+      expect(ContainerRegistry.hasContainer('exists-test')).toBe(true);
+    });
+  });
+
+  describe('Container Removal', () => {
+    it('should remove container from registry', async () => {
+      container1 = new ContainerInstance('remove-test');
+
+      expect(ContainerRegistry.hasContainer('remove-test')).toBe(true);
+
+      await ContainerRegistry.removeContainer(container1);
+
+      expect(ContainerRegistry.hasContainer('remove-test')).toBe(false);
+    });
+
+    it('should throw error when removing non-existent container', async () => {
+      container1 = new ContainerInstance('remove-test');
+      await ContainerRegistry.removeContainer(container1);
+
+      expect(async () => {
+        await ContainerRegistry.removeContainer(container1);
+      }).rejects.toThrow('No container is registered with the given ID.');
+    });
+
+    it('should dispose container when removing', async () => {
+      let disposed = false;
+
+      container1 = new ContainerInstance('dispose-test');
+      container1['disposed'] = false;
+
+      // Override dispose method to track calls
+      const originalDispose = container1.dispose.bind(container1);
+      container1.dispose = async () => {
+        disposed = true;
+        return originalDispose();
+      };
+
+      await ContainerRegistry.removeContainer(container1);
+
+      expect(disposed).toBe(true);
+    });
+  });
+
+  describe('Multiple Containers', () => {
+    it('should handle multiple containers independently', () => {
+      container1 = new ContainerInstance('multi-1');
+      container2 = new ContainerInstance('multi-2');
+
+      expect(ContainerRegistry.hasContainer('multi-1')).toBe(true);
+      expect(ContainerRegistry.hasContainer('multi-2')).toBe(true);
+
+      const retrieved1 = ContainerRegistry.getContainer('multi-1');
+      const retrieved2 = ContainerRegistry.getContainer('multi-2');
+
+      expect(retrieved1).toBe(container1);
+      expect(retrieved2).toBe(container2);
+      expect(retrieved1).not.toBe(retrieved2);
+    });
+
+    it('should isolate services between containers', () => {
+      class TestService {
+        public name = 'test';
+      }
+
+      container1 = new ContainerInstance('isolate-1');
+      container2 = new ContainerInstance('isolate-2');
+
+      container1.set({ type: TestService });
+      container2.set({ type: TestService });
+
+      const instance1 = container1.get(TestService);
+      const instance2 = container2.get(TestService);
+
+      expect(instance1).not.toBe(instance2);
+    });
+  });
+
+  describe('Container Inheritance', () => {
+    it('should inherit handlers from default container', () => {
+      container1 = new ContainerInstance('inherit-test');
+
+      // Default container should have handlers array
+      expect(Array.isArray(ContainerInstance.default['handlers'])).toBe(true);
+
+      // Child container should inherit handlers
+      expect(Array.isArray(container1['handlers'])).toBe(true);
+    });
+
+    it('should not inherit handlers when creating default container', () => {
+      // Default container should not inherit from itself
+      expect(Array.isArray(ContainerInstance.default['handlers'])).toBe(true);
+    });
+  });
+
+  describe('Container.of() Method', () => {
+    it('should return default container when id is default', () => {
+      const container = ContainerInstance.default.of('default');
+      expect(container).toBe(ContainerInstance.default);
+    });
+
+    it('should return existing container when it exists', () => {
+      container1 = new ContainerInstance('of-test');
+
+      const retrieved = ContainerInstance.default.of('of-test');
+      expect(retrieved).toBe(container1);
+    });
+
+    it('should create new container when it does not exist', () => {
+      const newContainer = ContainerInstance.default.of('new-container');
+
+      expect(newContainer).toBeInstanceOf(ContainerInstance);
+      expect(newContainer.id).toBe('new-container');
+      expect(ContainerRegistry.hasContainer('new-container')).toBe(true);
+    });
+
+    it('should throw error when using disposed container', async () => {
+      container1 = new ContainerInstance('disposed-test');
+      await container1.dispose();
+
+      expect(() => container1.of('test')).toThrow('Cannot use container after it has been disposed.');
+    });
+  });
+
+  describe('Container Lifecycle', () => {
+    it('should handle container creation and disposal cycle', async () => {
+      container1 = new ContainerInstance('lifecycle-test');
+
+      // Register a service
+      class TestService {
+        public name = 'test';
+      }
+
+      container1.set({ type: TestService });
+      expect(container1.has(TestService)).toBe(true);
+
+      // Remove container
+      await ContainerRegistry.removeContainer(container1);
+
+      expect(ContainerRegistry.hasContainer('lifecycle-test')).toBe(false);
+    });
+
+    it('should handle multiple containers with same service types', () => {
+      class TestService {
+        public id = Math.random();
+      }
+
+      container1 = new ContainerInstance('same-service-1');
+      container2 = new ContainerInstance('same-service-2');
+
+      container1.set({ type: TestService });
+      container2.set({ type: TestService });
+
+      const instance1 = container1.get(TestService);
+      const instance2 = container2.get(TestService);
+
+      expect(instance1).not.toBe(instance2);
+      expect(instance1.id).not.toBe(instance2.id);
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle container disposal errors gracefully', async () => {
+      container1 = new ContainerInstance('error-test');
+
+      // Override dispose to throw error
+      const originalDispose = container1.dispose.bind(container1);
+      container1.dispose = async () => {
+        throw new Error('Disposal error');
+      };
+
+      // Should still remove from registry even if disposal fails
+      await expect(ContainerRegistry.removeContainer(container1)).rejects.toThrow('Disposal error');
+    });
+
+    it('should handle invalid container IDs', () => {
+      expect(() => {
+        ContainerRegistry.getContainer('' as any);
+      }).toThrow('No container is registered with the given ID.');
+    });
+  });
+
+  describe('Default Container', () => {
+    it('should have default container available', () => {
+      expect(ContainerInstance.default).toBeDefined();
+      expect(ContainerInstance.default.id).toBe('default');
+    });
+
+    it('should return same default container instance', () => {
+      const default1 = ContainerInstance.default;
+      const default2 = ContainerInstance.default;
+
+      expect(default1).toBe(default2);
+    });
+
+    it('should register default container in registry', () => {
+      // Default container should be registered when first accessed
+      expect(ContainerInstance.default).toBeDefined();
+    });
+  });
+});