ts-ioc-container 46.6.2 → 46.7.0

package/README.md

@@ -28,6 +28,7 @@
 - [Container](#container)
     - [Basic usage](#basic-usage)
     - [Scope](#scope) `tags`
+    - [Dynamic Tag Management](#dynamic-tag-management) `addTags`
     - [Instances](#instances)
     - [Dispose](#dispose)
     - [Lazy](#lazy) `lazy`
@@ -279,7 +280,6 @@ import {
  */
 
 // SessionService is only available in request scope - not at application level
-// This prevents accidental access to request-specific data from singletons
 @register(bindTo('ISessionService'), scope((s) => s.hasTag('request')), singleton())
 class SessionService {
   private userId: string | null = null;
@@ -342,6 +342,113 @@ describe('Scopes', function () {
 
 ```
 
+### Dynamic Tag Management
+You can dynamically add tags to a container after it's been created using the `addTags()` method. This is useful for environment-based configuration, feature flags, and progressive container setup.
+
+- Tags can be added one at a time or multiple at once
+- Tags must be added **before** registrations are applied - scope matching happens at registration time
+- Useful for conditional configuration based on `NODE_ENV` or runtime flags
+- Container can be configured incrementally as the application initializes
+
+```typescript
+import { bindTo, Container, register, Registration as R, scope } from 'ts-ioc-container';
+
+describe('addTags', () => {
+  it('should dynamically add tags to enable environment-based registration', () => {
+    @register(bindTo('logger'), scope((s) => s.hasTag('development')))
+    class ConsoleLogger {
+      log(message: string) {
+        console.log(`[DEV] ${message}`);
+      }
+    }
+
+    @register(bindTo('logger'), scope((s) => s.hasTag('production')))
+    class FileLogger {
+      log(message: string) {
+        console.log(`[PROD] ${message}`);
+      }
+    }
+
+    // Create container and configure for environment
+    const container = new Container();
+    const environment = 'development';
+    container.addTags(environment); // Add tag dynamically based on environment
+
+    // Register services after tag is set
+    container.addRegistration(R.fromClass(ConsoleLogger)).addRegistration(R.fromClass(FileLogger));
+
+    // Resolve logger - gets ConsoleLogger because 'development' tag was added
+    const logger = container.resolve<ConsoleLogger>('logger');
+    expect(logger).toBeInstanceOf(ConsoleLogger);
+  });
+
+  it('should add multiple tags for feature-based configuration', () => {
+    @register(bindTo('premiumFeature'), scope((s) => s.hasTag('premium')))
+    class PremiumFeature {}
+
+    @register(bindTo('betaFeature'), scope((s) => s.hasTag('beta')))
+    class BetaFeature {}
+
+    const container = new Container();
+
+    // Add multiple tags at once
+    container.addTags('premium', 'beta', 'experimental');
+
+    // Verify all tags are present
+    expect(container.hasTag('premium')).toBe(true);
+    expect(container.hasTag('beta')).toBe(true);
+    expect(container.hasTag('experimental')).toBe(true);
+
+    // Register features after tags are added
+    container.addRegistration(R.fromClass(PremiumFeature)).addRegistration(R.fromClass(BetaFeature));
+
+    // Both features are available because container has both tags
+    expect(container.resolve('premiumFeature')).toBeInstanceOf(PremiumFeature);
+    expect(container.resolve('betaFeature')).toBeInstanceOf(BetaFeature);
+  });
+
+  it('should affect child scope creation', () => {
+    @register(bindTo('service'), scope((s) => s.hasTag('api')))
+    class ApiService {
+      handleRequest() {
+        return 'API response';
+      }
+    }
+
+    const appContainer = new Container();
+
+    // Add tag to parent
+    appContainer.addTags('api');
+    appContainer.addRegistration(R.fromClass(ApiService));
+
+    // Create child scopes - they inherit parent's registrations
+    const requestScope1 = appContainer.createScope({ tags: ['request'] });
+    const requestScope2 = appContainer.createScope({ tags: ['request'] });
+
+    // Both scopes can access the ApiService from parent
+    expect(requestScope1.resolve<ApiService>('service').handleRequest()).toBe('API response');
+    expect(requestScope2.resolve<ApiService>('service').handleRequest()).toBe('API response');
+  });
+
+  it('should enable incremental tag addition', () => {
+    const container = new Container();
+
+    // Start with basic tags
+    container.addTags('application');
+    expect(container.hasTag('application')).toBe(true);
+
+    // Add more tags as needed
+    container.addTags('monitoring', 'logging');
+    expect(container.hasTag('monitoring')).toBe(true);
+    expect(container.hasTag('logging')).toBe(true);
+
+    // All tags are retained
+    expect(container.hasTag('application')).toBe(true);
+  });
+});
+
+```
+
 ### Instances
 Sometimes you want to get all instances from container and its scopes. For example, when you want to dispose all instances of container.
 

package/cjm/container/Container.js

@@ -144,6 +144,11 @@ class Container {
     hasTag(tag) {
         return this.tags.has(tag);
     }
+    addTags(...tags) {
+        for (const tag of tags) {
+            this.tags.add(tag);
+        }
+    }
     validateContainer() {
         if (this.isDisposed) {
             throw new ContainerDisposedError_1.ContainerDisposedError('Container is already disposed');

package/cjm/container/EmptyContainer.js

@@ -29,6 +29,9 @@ class EmptyContainer {
     hasTag(tag) {
         throw new MethodNotImplementedError_1.MethodNotImplementedError();
     }
+    addTags(...tags) {
+        throw new MethodNotImplementedError_1.MethodNotImplementedError();
+    }
     getRegistrations() {
         return [];
     }

package/esm/container/Container.js

@@ -141,6 +141,11 @@ export class Container {
     hasTag(tag) {
         return this.tags.has(tag);
     }
+    addTags(...tags) {
+        for (const tag of tags) {
+            this.tags.add(tag);
+        }
+    }
     validateContainer() {
         if (this.isDisposed) {
             throw new ContainerDisposedError('Container is already disposed');

package/esm/container/EmptyContainer.js

@@ -26,6 +26,9 @@ export class EmptyContainer {
     hasTag(tag) {
         throw new MethodNotImplementedError();
     }
+    addTags(...tags) {
+        throw new MethodNotImplementedError();
+    }
     getRegistrations() {
         return [];
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-ioc-container",
-  "version": "46.6.2",
+  "version": "46.7.0",
   "description": "Typescript IoC container",
   "workspaces": [
     "docs"

package/typings/container/Container.d.ts

@@ -39,6 +39,7 @@ export declare class Container implements IContainer {
     getParent(): IContainer;
     getInstances(cascade?: boolean): Instance<unknown>[];
     hasTag(tag: Tag): boolean;
+    addTags(...tags: Tag[]): void;
     private validateContainer;
     private findProviderByKeyOrFail;
 }

package/typings/container/EmptyContainer.d.ts

@@ -14,6 +14,7 @@ export declare class EmptyContainer implements IContainer {
     dispose(): void;
     register(key: DependencyKey, value: IProvider): this;
     hasTag(tag: Tag): boolean;
+    addTags(...tags: Tag[]): void;
     getRegistrations(): never[];
     removeScope(): void;
     useModule(module: IContainerModule): this;

package/typings/container/IContainer.d.ts

@@ -17,6 +17,7 @@ type WithExcludedKeys = {
 };
 export interface Tagged {
     hasTag(tag: Tag): boolean;
+    addTags(...tags: Tag[]): void;
 }
 export type ResolveOneOptions = ProviderOptions & Partial<WithChild>;
 export type ResolveManyOptions = ResolveOneOptions & Partial<WithExcludedKeys>;