ts-ioc-container 50.2.5 → 51.0.0

package/README.md

@@ -47,7 +47,7 @@ provider pipelines, aliases, and custom injector strategies.
   - [Alias](#alias) `asAlias`
   - [Decorator](#decorator) `decorate`
 - [Registration](#registration) `@register`
-  - [Key](#key) `bindTo`
+  - [Token](#token) `bindTo`
   - [Scope](#scope) `scope`
 - [Module](#module)
 - [Hook](#hook) `@hook`
@@ -992,7 +992,7 @@ describe('lazy registerPipe', () => {
       const container = new Container().addRegistration(
         R.fromClass(ConfigService)
           .pipe(
-            (p) => p.appendArgs('https://api.example.com', 5000),
+            (p) => p.addArgs('https://api.example.com', 5000),
             (p) => p.lazy(),
           )
           .pipe(singleton()),
@@ -1403,7 +1403,7 @@ describe('Provider', () => {
 
     const appContainer = new Container({ tags: ['application'] }).register(
       'AdminService',
-      Provider.fromClass(AdminService).pipe(scopeAccess(({ invocationScope }) => invocationScope.hasTag('admin'))),
+      Provider.fromClass(AdminService).pipe(scopeAccess((_prev, { invocationScope }) => invocationScope.hasTag('admin'))),
     );
 
     const adminScope = appContainer.createScope({ tags: ['admin'] });
@@ -1778,8 +1778,10 @@ Sometimes you want to hide dependency if somebody wants to resolve it from certa
 > [!IMPORTANT]
 > Use `scope()` to decide where a provider is registered. Use `scopeAccess()` to decide which invocation scopes can see an already registered provider.
 
-- `provider(scopeAccess(({ invocationScope, providerScope }) => invocationScope === providerScope))` - dependency will be accessible only from the scope where it's registered
-- `Provider.fromClass(Logger).pipe(scopeAccess(({ invocationScope, providerScope }) => invocationScope === providerScope))`
+- `provider(scopeAccess((_prev, { invocationScope, providerScope }) => invocationScope === providerScope))` - dependency will be accessible only from the scope where it's registered
+- `Provider.fromClass(Logger).pipe(scopeAccess((_prev, { invocationScope, providerScope }) => invocationScope === providerScope))`
+
+Rules compose as a left-fold starting from `true` — each rule receives the accumulated result of all previous rules, enabling AND/OR logic across multiple `scopeAccess` calls.
 
 ```typescript
 import 'reflect-metadata';
@@ -1818,7 +1820,7 @@ describe('Visibility', function () {
       scope((s) => s.hasTag('application')), // Registered at app level
       singleton(),
       // Only accessible from admin scope, not regular request scope
-      scopeAccess(({ invocationScope }) => invocationScope.hasTag('admin')),
+      scopeAccess((_prev, { invocationScope }) => invocationScope.hasTag('admin')),
     )
     class UserManagementService {
       deleteUser(userId: string): string {
@@ -1850,7 +1852,7 @@ describe('Visibility', function () {
       scope((s) => s.hasTag('application')),
       singleton(),
       // Only accessible from the scope where it was registered
-      scopeAccess(({ invocationScope, providerScope }) => invocationScope === providerScope),
+      scopeAccess((_prev, { invocationScope, providerScope }) => invocationScope === providerScope),
     )
     class AuditLogger {
       log(message: string): string {
@@ -2146,12 +2148,9 @@ Registration is provider factory which registers provider in container.
 - `Registration.fromValue(Logger)`
 - `Registration.fromFn((container, options) => container.resolve(Logger, options))`
 
-### Key
-
-Sometimes you want to register provider with certain key. This is what `key` is for.
+### Token
 
-- by default, key is class name
-- you can assign the same key to different registrations
+Use `bindTo(key)` to register a provider under a specific key. By default the key is the class name. Multiple registrations can share the same key.
 
 > [!TIP]
 > Prefer `SingleToken<T>` over plain string literals as registration keys. Tokens are type-safe, rename-friendly, and prevent typos that only surface at runtime.

package/cjm/provider/IProvider.js

@@ -2,11 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProviderDecorator = exports.lazy = exports.scopeAccess = exports.appendArgsFn = exports.appendArgs = void 0;
 const ProviderPipe_1 = require("./ProviderPipe");
-const appendArgs = (...extraArgs) => (0, ProviderPipe_1.registerPipe)((p) => p.appendArgs(...extraArgs));
+const appendArgs = (...extraArgs) => (0, ProviderPipe_1.registerPipe)((p) => p.addArgs(...extraArgs));
 exports.appendArgs = appendArgs;
-const appendArgsFn = (fn) => (0, ProviderPipe_1.registerPipe)((p) => p.appendArgsFn(fn));
+const appendArgsFn = (fn) => (0, ProviderPipe_1.registerPipe)((p) => p.addArgsFn(fn));
 exports.appendArgsFn = appendArgsFn;
-const scopeAccess = (rule) => (0, ProviderPipe_1.registerPipe)((p) => p.setAccessRule(rule));
+const scopeAccess = (rule) => (0, ProviderPipe_1.registerPipe)((p) => p.addAccessRule(rule));
 exports.scopeAccess = scopeAccess;
 const lazy = () => (0, ProviderPipe_1.registerPipe)((p) => p.lazy());
 exports.lazy = lazy;
@@ -15,8 +15,8 @@ class ProviderDecorator {
     constructor(decorated) {
         this.decorated = decorated;
     }
-    setAccessRule(rule) {
-        this.decorated.setAccessRule(rule);
+    addAccessRule(rule) {
+        this.decorated.addAccessRule(rule);
         return this;
     }
     hasAccess(options) {
@@ -35,12 +35,12 @@ class ProviderDecorator {
         this.decorated = this.decorated.pipe(...fns);
         return this;
     }
-    appendArgs(...extraArgs) {
-        this.decorated.appendArgs(...extraArgs);
+    addArgs(...extraArgs) {
+        this.decorated.addArgs(...extraArgs);
         return this;
     }
-    appendArgsFn(argsFn) {
-        this.decorated.appendArgsFn(argsFn);
+    addArgsFn(argsFn) {
+        this.decorated.addArgsFn(argsFn);
         return this;
     }
     lazy() {

package/cjm/provider/Provider.js

@@ -15,7 +15,7 @@ class Provider {
         return new Provider((c) => c.resolve(key));
     }
     argsFn = (s, { args = [] } = {}) => args;
-    checkAccess = () => true;
+    accessRules = [];
     isLazy = false;
     constructor(resolveDependency) {
         this.resolveDependency = resolveDependency;
@@ -30,26 +30,26 @@ class Provider {
             lazy: lazy ?? this.isLazy,
         });
     }
-    setAccessRule(predicate) {
-        this.checkAccess = predicate;
+    addAccessRule(rule) {
+        this.accessRules.push(rule);
         return this;
     }
     lazy() {
         this.isLazy = true;
         return this;
     }
-    appendArgs(...extraArgs) {
+    addArgs(...extraArgs) {
         const parentFn = this.argsFn;
         this.argsFn = (container, options) => [...parentFn(container, options), ...extraArgs];
         return this;
     }
-    appendArgsFn(argsFn) {
+    addArgsFn(argsFn) {
         const parentFn = this.argsFn;
         this.argsFn = (container, options) => [...parentFn(container, options), ...argsFn(container, options)];
         return this;
     }
     hasAccess(options) {
-        return this.checkAccess(options);
+        return this.accessRules.reduce((acc, rule) => rule(acc, options), true);
     }
 }
 exports.Provider = Provider;

package/esm/provider/IProvider.js

@@ -1,15 +1,15 @@
 import { isProviderPipe, registerPipe } from './ProviderPipe';
-export const appendArgs = (...extraArgs) => registerPipe((p) => p.appendArgs(...extraArgs));
-export const appendArgsFn = (fn) => registerPipe((p) => p.appendArgsFn(fn));
-export const scopeAccess = (rule) => registerPipe((p) => p.setAccessRule(rule));
+export const appendArgs = (...extraArgs) => registerPipe((p) => p.addArgs(...extraArgs));
+export const appendArgsFn = (fn) => registerPipe((p) => p.addArgsFn(fn));
+export const scopeAccess = (rule) => registerPipe((p) => p.addAccessRule(rule));
 export const lazy = () => registerPipe((p) => p.lazy());
 export class ProviderDecorator {
     decorated;
     constructor(decorated) {
         this.decorated = decorated;
     }
-    setAccessRule(rule) {
-        this.decorated.setAccessRule(rule);
+    addAccessRule(rule) {
+        this.decorated.addAccessRule(rule);
         return this;
     }
     hasAccess(options) {
@@ -28,12 +28,12 @@ export class ProviderDecorator {
         this.decorated = this.decorated.pipe(...fns);
         return this;
     }
-    appendArgs(...extraArgs) {
-        this.decorated.appendArgs(...extraArgs);
+    addArgs(...extraArgs) {
+        this.decorated.addArgs(...extraArgs);
         return this;
     }
-    appendArgsFn(argsFn) {
-        this.decorated.appendArgsFn(argsFn);
+    addArgsFn(argsFn) {
+        this.decorated.addArgsFn(argsFn);
         return this;
     }
     lazy() {

package/esm/provider/Provider.js

@@ -12,7 +12,7 @@ export class Provider {
         return new Provider((c) => c.resolve(key));
     }
     argsFn = (s, { args = [] } = {}) => args;
-    checkAccess = () => true;
+    accessRules = [];
     isLazy = false;
     constructor(resolveDependency) {
         this.resolveDependency = resolveDependency;
@@ -27,25 +27,25 @@ export class Provider {
             lazy: lazy ?? this.isLazy,
         });
     }
-    setAccessRule(predicate) {
-        this.checkAccess = predicate;
+    addAccessRule(rule) {
+        this.accessRules.push(rule);
         return this;
     }
     lazy() {
         this.isLazy = true;
         return this;
     }
-    appendArgs(...extraArgs) {
+    addArgs(...extraArgs) {
         const parentFn = this.argsFn;
         this.argsFn = (container, options) => [...parentFn(container, options), ...extraArgs];
         return this;
     }
-    appendArgsFn(argsFn) {
+    addArgsFn(argsFn) {
         const parentFn = this.argsFn;
         this.argsFn = (container, options) => [...parentFn(container, options), ...argsFn(container, options)];
         return this;
     }
     hasAccess(options) {
-        return this.checkAccess(options);
+        return this.accessRules.reduce((acc, rule) => rule(acc, options), true);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-ioc-container",
-  "version": "50.2.5",
+  "version": "51.0.0",
   "description": "Fast, lightweight TypeScript dependency injection container with a clean API, scoped lifecycles, decorators, tokens, hooks, lazy injection, customizable providers, and no global container objects.",
   "workspaces": [
     "docs"

package/typings/provider/IProvider.d.ts

@@ -11,7 +11,7 @@ export type ScopeAccessOptions = {
     invocationScope: Tagged;
     providerScope: Tagged;
 };
-export type ScopeAccessRule = (options: ScopeAccessOptions) => boolean;
+export type ScopeAccessRule = (prev: boolean, options: ScopeAccessOptions) => boolean;
 export type ArgsFn = (l: IContainer, options?: InjectOptions) => unknown[];
 export interface IMapper {
     mapItem<T>(target: IProvider<T>): IProvider<T>;
@@ -20,9 +20,9 @@ export interface IProvider<T = any> {
     resolve(container: IContainer, options: ProviderOptions): T;
     hasAccess(options: ScopeAccessOptions): boolean;
     pipe(...mappers: (MapFn<IProvider<T>> | ProviderPipe<T>)[]): IProvider<T>;
-    setAccessRule(hasAccessWhen: ScopeAccessRule): this;
-    appendArgs(...extraArgs: unknown[]): this;
-    appendArgsFn(argsFn: ArgsFn): this;
+    addAccessRule(rule: ScopeAccessRule): this;
+    addArgs(...extraArgs: unknown[]): this;
+    addArgsFn(argsFn: ArgsFn): this;
     lazy(): this;
 }
 export declare const appendArgs: <T>(...extraArgs: unknown[]) => ProviderPipe<T>;
@@ -32,11 +32,11 @@ export declare const lazy: <T>() => ProviderPipe<T>;
 export declare abstract class ProviderDecorator<T> implements IProvider<T> {
     private decorated;
     protected constructor(decorated: IProvider<T>);
-    setAccessRule(rule: ScopeAccessRule): this;
+    addAccessRule(rule: ScopeAccessRule): this;
     hasAccess(options: ScopeAccessOptions): boolean;
     resolve(container: IContainer, options: ProviderOptions): T;
     pipe(...mappers: (MapFn<IProvider<T>> | ProviderPipe<T>)[]): IProvider<T>;
-    appendArgs(...extraArgs: unknown[]): this;
-    appendArgsFn(argsFn: ArgsFn): this;
+    addArgs(...extraArgs: unknown[]): this;
+    addArgsFn(argsFn: ArgsFn): this;
     lazy(): this;
 }

package/typings/provider/Provider.d.ts

@@ -9,14 +9,14 @@ export declare class Provider<T = any> implements IProvider<T> {
     static fromValue<T>(value: T): IProvider<T>;
     static fromKey<T>(key: DependencyKey): Provider<T>;
     private argsFn;
-    private checkAccess;
+    private readonly accessRules;
     private isLazy;
     constructor(resolveDependency: ResolveDependency<T>);
     pipe(...mappers: (MapFn<IProvider<T>> | ProviderPipe<T>)[]): IProvider<T>;
     resolve(container: IContainer, { args, lazy }?: ProviderOptions): T;
-    setAccessRule(predicate: ScopeAccessRule): this;
+    addAccessRule(rule: ScopeAccessRule): this;
     lazy(): this;
-    appendArgs(...extraArgs: unknown[]): this;
-    appendArgsFn(argsFn: ArgsFn): this;
+    addArgs(...extraArgs: unknown[]): this;
+    addArgsFn(argsFn: ArgsFn): this;
     hasAccess(options: ScopeAccessOptions): boolean;
 }