ts-ioc-container 46.7.1 → 46.8.1

package/README.md

@@ -534,6 +534,107 @@ describe('Instances', function () {
 
 ```
 
+### Check Registration
+Sometimes you want to check if a registration with a specific key exists in the container. This is useful for conditional registration logic, validation, and debugging.
+
+- `hasRegistration(key)` checks if a registration exists in the current container or parent containers
+- Checks both the current container's registrations and parent container registrations
+- Works with string keys, symbol keys, and token keys
+- Returns false after container disposal
+
+```typescript
+import { Container, Registration as R, bindTo, register, SingleToken } from 'ts-ioc-container';
+
+/**
+ * Container Registration Checking - hasRegistration
+ *
+ * The `hasRegistration` method allows you to check if a registration with a specific key
+ * exists in the current container. This is useful for conditional registration logic,
+ * validation, and debugging.
+ *
+ * Key points:
+ * - Checks only the current container's registrations (not parent containers)
+ * - Works with string keys, symbol keys, and token keys
+ * - Returns false after container disposal
+ * - Useful for conditional registration patterns
+ */
+describe('hasRegistration', function () {
+  const createAppContainer = () => new Container({ tags: ['application'] });
+
+  it('should return true when registration exists with string key', function () {
+    const container = createAppContainer();
+    container.addRegistration(R.fromValue('production').bindToKey('Environment'));
+
+    expect(container.hasRegistration('Environment')).toBe(true);
+  });
+
+  it('should return false when registration does not exist', function () {
+    const container = createAppContainer();
+
+    expect(container.hasRegistration('NonExistentService')).toBe(false);
+  });
+
+  it('should work with symbol keys', function () {
+    const container = createAppContainer();
+    const serviceKey = Symbol('IService');
+    container.addRegistration(R.fromValue({ name: 'Service' }).bindToKey(serviceKey));
+
+    expect(container.hasRegistration(serviceKey)).toBe(true);
+  });
+
+  it('should work with token keys', function () {
+    const container = createAppContainer();
+    const loggerToken = new SingleToken<{ log: (msg: string) => void }>('ILogger');
+    container.addRegistration(R.fromValue({ log: () => {} }).bindTo(loggerToken));
+
+    expect(container.hasRegistration(loggerToken.token)).toBe(true);
+  });
+
+  it('should check current container and parent registrations', function () {
+    // Parent container has a registration
+    const parent = createAppContainer();
+    parent.addRegistration(R.fromValue('parent-config').bindToKey('Config'));
+
+    // Child scope does not have the registration
+    const child = parent.createScope();
+    child.addRegistration(R.fromValue('child-service').bindToKey('Service'));
+
+    // Child should see parent's registration (checks parent as well)
+    expect(child.hasRegistration('Config')).toBe(true);
+    // Child should see its own registration
+    expect(child.hasRegistration('Service')).toBe(true);
+    // Parent should see its own registration
+    expect(parent.hasRegistration('Config')).toBe(true);
+  });
+
+  it('should work with class-based registrations', function () {
+    @register(bindTo('ILogger'))
+    class Logger {}
+
+    const container = createAppContainer();
+    container.addRegistration(R.fromClass(Logger));
+
+    expect(container.hasRegistration('ILogger')).toBe(true);
+  });
+
+  it('should be useful for conditional registration patterns', function () {
+    const container = createAppContainer();
+
+    // Register a base service
+    container.addRegistration(R.fromValue('base-service').bindToKey('BaseService'));
+
+    // Conditionally register an extension only if base exists
+    if (container.hasRegistration('BaseService')) {
+      container.addRegistration(R.fromValue('extension-service').bindToKey('ExtensionService'));
+    }
+
+    expect(container.hasRegistration('BaseService')).toBe(true);
+    expect(container.hasRegistration('ExtensionService')).toBe(true);
+  });
+});
+
+```
+
 ### Dispose
 Sometimes you want to dispose container and all its scopes. For example, when you want to prevent memory leaks. Or you want to ensure that nobody can use container after it was disposed.
 
@@ -1157,7 +1258,7 @@ describe('lazy registerPipe', () => {
 
     @register(bindTo('PremiumFeature'), lazy(), singleton())
     class PremiumFeature {
-      constructor(@inject('FeatureFlagService') private flags: FeatureFlagService) {
+      constructor() {
         initLog.push('PremiumFeature initialized - expensive operation');
       }
 

package/cjm/container/Container.js

@@ -63,7 +63,7 @@ class Container {
     }
     resolveOneByAlias(alias, { args, child = this, lazy } = {}) {
         this.validateContainer();
-        const [key, ..._] = this.aliases.getKeysByAlias(alias);
+        const key = this.aliases.getKeysByAlias(alias)[0];
         const provider = key ? this.findProviderByKeyOrFail(key) : undefined;
         return provider?.hasAccess({ invocationScope: child, providerScope: this })
             ? provider.resolve(this, { args, lazy })
@@ -107,6 +107,9 @@ class Container {
     getRegistrations() {
         return [...this.parent.getRegistrations(), ...this.registrations];
     }
+    hasRegistration(key) {
+        return this.registrations.some((r) => r.getKeyOrFail() === key) || this.parent.hasRegistration(key);
+    }
     addOnConstructHook(...hooks) {
         this.onConstructHookList.push(...hooks);
         return this;

package/cjm/container/EmptyContainer.js

@@ -35,6 +35,9 @@ class EmptyContainer {
     getRegistrations() {
         return [];
     }
+    hasRegistration(key) {
+        return false;
+    }
     removeScope() { }
     useModule(module) {
         throw new MethodNotImplementedError_1.MethodNotImplementedError();

package/cjm/registration/Registration.js

@@ -79,5 +79,11 @@ class Registration {
         const provider = this.createProvider();
         container.register(this.key, provider.pipe(...this.mappers), { aliases: [...this.aliases] });
     }
+    getKeyOrFail() {
+        if (!this.key) {
+            throw new DependencyMissingKeyError_1.DependencyMissingKeyError('No key provided for registration');
+        }
+        return this.key;
+    }
 }
 exports.Registration = Registration;

package/esm/container/Container.js

@@ -60,7 +60,7 @@ export class Container {
     }
     resolveOneByAlias(alias, { args, child = this, lazy } = {}) {
         this.validateContainer();
-        const [key, ..._] = this.aliases.getKeysByAlias(alias);
+        const key = this.aliases.getKeysByAlias(alias)[0];
         const provider = key ? this.findProviderByKeyOrFail(key) : undefined;
         return provider?.hasAccess({ invocationScope: child, providerScope: this })
             ? provider.resolve(this, { args, lazy })
@@ -104,6 +104,9 @@ export class Container {
     getRegistrations() {
         return [...this.parent.getRegistrations(), ...this.registrations];
     }
+    hasRegistration(key) {
+        return this.registrations.some((r) => r.getKeyOrFail() === key) || this.parent.hasRegistration(key);
+    }
     addOnConstructHook(...hooks) {
         this.onConstructHookList.push(...hooks);
         return this;

package/esm/container/EmptyContainer.js

@@ -32,6 +32,9 @@ export class EmptyContainer {
     getRegistrations() {
         return [];
     }
+    hasRegistration(key) {
+        return false;
+    }
     removeScope() { }
     useModule(module) {
         throw new MethodNotImplementedError();

package/esm/registration/Registration.js

@@ -76,4 +76,10 @@ export class Registration {
         const provider = this.createProvider();
         container.register(this.key, provider.pipe(...this.mappers), { aliases: [...this.aliases] });
     }
+    getKeyOrFail() {
+        if (!this.key) {
+            throw new DependencyMissingKeyError('No key provided for registration');
+        }
+        return this.key;
+    }
 }

package/package.json

@@ -1,10 +1,7 @@
 {
   "name": "ts-ioc-container",
-  "version": "46.7.1",
+  "version": "46.8.1",
   "description": "Typescript IoC container",
-  "workspaces": [
-    "docs"
-  ],
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"
@@ -38,72 +35,39 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/IgorBabkin/ts-ioc-container"
+    "url": "git+https://github.com/IgorBabkin/ts-ioc-container",
+    "directory": "packages/ts-ioc-container"
   },
   "scripts": {
     "build:cjm": "rimraf cjm && tsc -p tsconfig.production.json --outDir cjm --module CommonJS",
     "build:esm": "rimraf esm && tsc -p tsconfig.production.json --outDir esm",
     "build:types": "rimraf typings && tsc -p tsconfig.production.json --outDir typings --emitDeclarationOnly --declaration",
-    "generate:docs": "scripts/generate-readme/generate-readme.ts && git add README.md",
-    "build": "npm run build:cjm && npm run build:esm && npm run build:types",
-    "test": "jest",
-    "test:coverage": "jest --coverage --coverageReporters=lcov --coverageReporters=text-summary",
+    "build": "pnpm run build:cjm && pnpm run build:esm && pnpm run build:types",
+    "test": "jest --maxWorkers=2",
+    "test:coverage": "jest --maxWorkers=2 --coverage --coverageReporters=lcov --coverageReporters=text-summary",
     "type-check": "tsc --noEmit",
     "type-check:watch": "tsc --noEmit --watch",
-    "commit": "cz",
+    "lint": "eslint lib/**/*.ts __tests__/**/*.ts scripts/**/*.ts",
+    "lint:fix": "pnpm run lint -- --fix",
     "format": "prettier --write \"**/*.ts\"",
-    "lint": "eslint lib/**/*.ts  __tests__/**/*.ts scripts/**/*.ts",
-    "lint:fix": "npm run lint --fix",
-    "audit": "npm audit",
-    "prepare": "husky",
-    "release": "npm run build && npm test && npm publish",
-    "docs:dev": "pnpm --filter ts-ioc-container-docs run dev",
-    "docs:serve": "pnpm --filter ts-ioc-container-docs run dev",
-    "docs:build": "pnpm --filter ts-ioc-container-docs run build",
-    "docs:preview": "pnpm --filter ts-ioc-container-docs run preview"
+    "generate:docs": "scripts/generate-readme/generate-readme.ts",
+    "release": "pnpm run build && pnpm run test && pnpm publish"
   },
   "devDependencies": {
-    "@semantic-release/changelog": "^6.0.3",
-    "@semantic-release/git": "^10.0.1",
-    "@semantic-release/github": "^12.0.2",
-    "@semantic-release/npm": "^13.1.2",
     "@types/jest": "29.5.14",
+    "@types/node": "^25.1.0",
     "@typescript-eslint/eslint-plugin": "8.29.1",
     "@typescript-eslint/parser": "8.29.1",
-    "cz-conventional-changelog": "^3.3.0",
     "eslint": "9.24.0",
     "eslint-config-prettier": "10.1.1",
     "eslint-plugin-prettier": "5.2.6",
     "handlebars": "^4.7.8",
-    "husky": "^9.1.7",
     "jest": "29.7.0",
-    "lint-staged": "^15.5.0",
     "moq.ts": "^7.4.1",
     "prettier": "3.5.3",
-    "prettier-plugin-astro": "^0.14.1",
     "reflect-metadata": "^0.2.2",
     "rimraf": "6.0.1",
-    "semantic-release": "^25.0.2",
     "ts-jest": "29.3.1",
     "typescript": "5.8.3"
-  },
-  "lint-staged": {
-    "*.{js,ts,tsx}": [
-      "eslint --fix",
-      "prettier --write"
-    ],
-    "docs/**/*.{js,ts,tsx,mjs,astro}": [
-      "prettier --write"
-    ],
-    "docs/**/*.astro": [
-      "eslint --fix"
-    ]
-  },
-  "gitHead": "ae10f302c7e0f55196b42669040735112479a854",
-  "config": {
-    "commitizen": {
-      "path": "./node_modules/cz-conventional-changelog"
-    }
-  },
-  "packageManager": "pnpm@10.20.0+sha512.cf9998222162dd85864d0a8102e7892e7ba4ceadebbf5a31f9c2fce48dfce317a9c53b9f6464d1ef9042cba2e02ae02a9f7c143a2b438cd93c91840f0192b9dd"
+  }
 }

package/typings/container/Container.d.ts

@@ -30,6 +30,7 @@ export declare class Container implements IContainer {
     dispose(): void;
     addRegistration(registration: IRegistration): this;
     getRegistrations(): IRegistration[];
+    hasRegistration(key: DependencyKey): boolean;
     addOnConstructHook(...hooks: OnConstructHook[]): this;
     addOnDisposeHook(...hooks: OnDisposeHook[]): this;
     addInstance(instance: Instance): void;

package/typings/container/EmptyContainer.d.ts

@@ -16,6 +16,7 @@ export declare class EmptyContainer implements IContainer {
     hasTag(tag: Tag): boolean;
     addTags(...tags: Tag[]): void;
     getRegistrations(): never[];
+    hasRegistration(key: DependencyKey): boolean;
     removeScope(): void;
     useModule(module: IContainerModule): this;
     addRegistration(registration: IRegistration): this;

package/typings/container/IContainer.d.ts

@@ -38,6 +38,7 @@ export interface IContainer extends Tagged {
     register(key: DependencyKey, value: IProvider, options?: RegisterOptions): this;
     addRegistration(registration: IRegistration): this;
     getRegistrations(): IRegistration[];
+    hasRegistration(key: DependencyKey): boolean;
     resolve<T>(target: constructor<T> | DependencyKey, options?: ResolveOneOptions): T;
     resolveByAlias<T>(alias: DependencyKey, options?: ResolveManyOptions): T[];
     resolveOneByAlias<T>(alias: DependencyKey, options?: ResolveOneOptions): T;

package/typings/registration/IRegistration.d.ts

@@ -6,6 +6,7 @@ import { MapFn } from '../utils/fp';
 import { type constructor } from '../utils/basic';
 export type ScopeMatchRule = (s: IContainer, prev?: boolean) => boolean;
 export interface IRegistration<T = any> extends IContainerModule {
+    getKeyOrFail(): DependencyKey;
     when(...predicates: ScopeMatchRule[]): this;
     bindToKey(key: DependencyKey): this;
     bindTo(key: DependencyKey | BindToken): this;

package/typings/registration/Registration.d.ts

@@ -7,7 +7,7 @@ import { type MapFn } from '../utils/fp';
 import { type constructor } from '../utils/basic';
 export declare class Registration<T = any> implements IRegistration<T> {
     private createProvider;
-    private key?;
+    key?: DependencyKey | undefined;
     private scopeRules;
     static fromClass<T>(Target: constructor<T>): IRegistration<any>;
     static fromValue<T>(value: T): IRegistration<any> | Registration<T>;
@@ -23,4 +23,5 @@ export declare class Registration<T = any> implements IRegistration<T> {
     bindTo(key: DependencyKey | BindToken): this;
     private matchScope;
     applyTo(container: IContainer): void;
+    getKeyOrFail(): DependencyKey;
 }