ts-ioc-container 50.0.0 → 50.2.0

package/README.md

@@ -36,7 +36,7 @@ no global container objects.
 - [Setup](#setup)
 - [Quickstart](#quickstart)
 - [Cheatsheet](#cheatsheet)
-- [Spec-driven workflow](#spec-driven-workflow)
+- [Specs-driven workflow](#specs-driven-workflow)
   - [Product capability map](#product-capability-map)
   - [Acceptance specs](#acceptance-specs)
 - [tsyringe alternative](https://igorbabkin.github.io/ts-ioc-container/tsyringe-alternative)
@@ -56,7 +56,7 @@ no global container objects.
   - [Proxy](#proxy)
 - [Provider](#provider) `provider`
   - [Singleton](#singleton) `singleton`
-  - [Arguments](#arguments) `setArgs` `setArgsFn`
+  - [Arguments](#arguments) `appendArgs` `appendArgsFn`
   - [Visibility](#visibility) `visible`
   - [Alias](#alias) `asAlias`
   - [Decorator](#decorator) `decorate`
@@ -140,11 +140,11 @@ container.resolve(App).start();
 > For classes, prefer the `@register(bindTo('Key'))` decorator over the fluent
 > `R.fromClass(Class).bindToKey('Key')` chain. The decorator co-locates the binding
 > with the class and reads consistently with other registration pipes
-> (`scope`, `singleton`, `setArgsFn`, ...). Use the fluent `bindToKey` chain only
+> (`scope`, `singleton`, `appendArgsFn`, ...). Use the fluent `bindToKey` chain only
 > for `R.fromValue(...)` and `R.fromFn(...)` (which have no class to decorate)
 > or for third-party classes you don't own.
 
-## Spec-driven workflow
+## Specs-driven workflow
 
 Public behavior is described as product capabilities before it is implemented.
 The repository keeps the same chain visible in specs, tests, docs, and this
@@ -184,49 +184,203 @@ tests stay in the feature folders under `__tests__/`.
 
 ### Express/Next handler (per-request scope)
 
-```typescript
-const app = new Container({ tags: ['application'] }).addRegistration(R.fromClass(Logger).pipe(singleton()));
+import 'reflect-metadata';
+import { bindTo, Container, inject, register, Registration as R, singleton } from 'ts-ioc-container';
+
+/**
+ * Web Framework Integration - Per-Request Scope
+ *
+ * In Express/Next.js applications, each HTTP request typically gets its own
+ * scope. This ensures request-specific state (logger context, current user,
+ * correlation IDs) is isolated between concurrent requests.
+ *
+ * Scope hierarchy:
+ *   Application (singleton services — live for entire app lifetime)
+ *     └── Request (per-request services — created and disposed per request)
+ */
+
+@register(bindTo('ILogger'), singleton())
+class Logger {
+  readonly messages: string[] = [];
 
-function handleRequest() {
-  const requestScope = app.createScope({ tags: ['request'] });
-  const logger = requestScope.resolve<Logger>('Logger');
-  logger.log('req started');
+  log(message: string) {
+    this.messages.push(message);
+  }
 }
-```
+
+describe('Express/Next per-request scope', () => {
+  it('should give each request its own Logger instance', () => {
+    const app = new Container({ tags: ['application'] }).addRegistration(R.fromClass(Logger));
+
+    // Simulate two concurrent HTTP requests
+    const request1Scope = app.createScope({ tags: ['request'] });
+    const request2Scope = app.createScope({ tags: ['request'] });
+
+    const logger1 = request1Scope.resolve<Logger>('ILogger');
+    const logger2 = request2Scope.resolve<Logger>('ILogger');
+
+    logger1.log('req 1 started');
+    logger2.log('req 2 started');
+
+    // Each request has its own Logger — logs don't leak between requests
+    expect(logger1.messages).toEqual(['req 1 started']);
+    expect(logger2.messages).toEqual(['req 2 started']);
+    expect(logger1).not.toBe(logger2);
+  });
+
+  it('should resolve the same Logger within a single request', () => {
+    const app = new Container({ tags: ['application'] }).addRegistration(R.fromClass(Logger));
+
+    const requestScope = app.createScope({ tags: ['request'] });
+
+    const logger1 = requestScope.resolve<Logger>('ILogger');
+    const logger2 = requestScope.resolve<Logger>('ILogger');
+
+    // Within one request, singleton is maintained
+    expect(logger1).toBe(logger2);
+  });
+});
+
 
 ### Background worker (singleton client, transient jobs)
 
-```typescript
+import 'reflect-metadata';
+import { Container, inject, register, Registration as R, singleton } from 'ts-ioc-container';
+
+/**
+ * Background Worker - Singleton Client, Transient Jobs
+ *
+ * A queue worker typically needs:
+ * - A single shared QueueClient (expensive to create, holds connections)
+ * - A new JobHandler per job (stateful — holds job-specific data)
+ *
+ * singleton() on QueueClient ensures one shared connection pool.
+ * No singleton on JobHandler gives a fresh instance per resolve.
+ */
+
 @register(singleton())
-class QueueClient {}
+class QueueClient {
+  readonly connected = true;
+
+  dequeue(): string {
+    return 'job-payload';
+  }
+}
 
 class JobHandler {
-  constructor(@inject('QueueClient') private queue: QueueClient) {}
+  readonly result: string;
+
+  constructor(@inject('QueueClient') private queue: QueueClient) {
+    this.result = this.queue.dequeue();
+  }
 }
 
-const worker = new Container({ tags: ['worker'] })
-  .addRegistration(R.fromClass(QueueClient))
-  .addRegistration(R.fromClass(JobHandler));
-```
+describe('Background worker', () => {
+  function createWorker() {
+    return new Container({ tags: ['worker'] })
+      .addRegistration(R.fromClass(QueueClient))
+      .addRegistration(R.fromClass(JobHandler));
+  }
+
+  it('should share a single QueueClient across all job handlers', () => {
+    const worker = createWorker();
+
+    const handler1 = worker.resolve(JobHandler);
+    const handler2 = worker.resolve(JobHandler);
+
+    const client1 = worker.resolve<QueueClient>('QueueClient');
+    const client2 = worker.resolve<QueueClient>('QueueClient');
+
+    // QueueClient is a singleton — same connection shared everywhere
+    expect(client1).toBe(client2);
+    expect(client1.connected).toBe(true);
+
+    // JobHandler is transient — fresh instance per job
+    expect(handler1).not.toBe(handler2);
+  });
+
+  it('should inject the shared QueueClient into each JobHandler', () => {
+    const worker = createWorker();
+
+    const handler = worker.resolve(JobHandler);
+
+    expect(handler.result).toBe('job-payload');
+  });
+});
+
 
 ### Frontend widget/page scope with lazy dependency
 
-```typescript
+import 'reflect-metadata';
+import { bindTo, Container, inject, register, Registration as R, select, singleton } from 'ts-ioc-container';
+
+/**
+ * Frontend Widget - Page Scope with Lazy Dependency
+ *
+ * In frontend applications, feature flags are fetched once per page load
+ * (singleton per page scope) but a widget may not need them on every render.
+ * Lazy injection defers instantiation until the widget actually reads the flags,
+ * avoiding unnecessary work for widgets that never display flag-gated content.
+ *
+ * Scope hierarchy:
+ *   Application
+ *     └── Page (singleton flags fetched once)
+ *           └── Widget (lazy flag access)
+ */
+
 @register(bindTo('FeatureFlags'), singleton())
 class FeatureFlags {
-  load() {
-    /* fetch flags */
+  load(): Record<string, boolean> {
+    return { newDashboard: true };
   }
 }
 
 class Widget {
-  constructor(@inject(select.token('FeatureFlags').lazy()) private flags: FeatureFlags) {}
+  constructor(@inject(select.token('FeatureFlags').lazy()) public flags: FeatureFlags) {}
 }
 
-const page = new Container({ tags: ['page'] })
-  .addRegistration(R.fromClass(FeatureFlags))
-  .addRegistration(R.fromClass(Widget));
-```
+describe('Frontend widget/page scope with lazy dependency', () => {
+  function createPage() {
+    return new Container({ tags: ['page'] })
+      .addRegistration(R.fromClass(FeatureFlags))
+      .addRegistration(R.fromClass(Widget));
+  }
+
+  it('should not instantiate FeatureFlags until the widget actually accesses it', () => {
+    const page = createPage();
+
+    const widget = page.resolve(Widget);
+
+    // Widget is resolved, but FeatureFlags has not been instantiated yet
+    let instances = Array.from(page.getInstances()).filter((x) => x instanceof FeatureFlags);
+    expect(instances).toHaveLength(0);
+
+    // Accessing any property on the lazy proxy triggers instantiation
+    const _load = widget.flags.load;
+    expect(_load).toBeDefined();
+
+    instances = Array.from(page.getInstances()).filter((x) => x instanceof FeatureFlags);
+    expect(instances).toHaveLength(1);
+  });
+
+  it('should share the same FeatureFlags singleton across widgets on the same page', () => {
+    const page = createPage();
+
+    const widget1 = page.resolve(Widget);
+    const widget2 = page.resolve(Widget);
+
+    // Trigger instantiation through both widgets
+    const _load1 = widget1.flags.load;
+    const _load2 = widget2.flags.load;
+    expect(_load1).toBeDefined();
+    expect(_load2).toBeDefined();
+
+    // Only one FeatureFlags instance was created across the whole page scope
+    const instances = Array.from(page.getInstances()).filter((x) => x instanceof FeatureFlags);
+    expect(instances).toHaveLength(1);
+  });
+});
+
 
 ## Container
 
@@ -1288,7 +1442,7 @@ describe('lazy registerPipe', () => {
       const container = new Container().addRegistration(
         R.fromClass(ConfigService)
           .pipe(
-            (p) => p.setArgs(() => ['https://api.example.com', 5000]),
+            (p) => p.appendArgs('https://api.example.com', 5000),
             (p) => p.lazy(),
           )
           .pipe(singleton()),
@@ -1586,8 +1740,8 @@ Provider is dependency factory which creates dependency.
 ```typescript
 import {
   args,
-  setArgs,
-  setArgsFn,
+  appendArgs,
+  appendArgsFn,
   bindTo,
   Container,
   inject,
@@ -1669,7 +1823,7 @@ describe('Provider', () => {
 
     const container = new Container().register(
       'FileService',
-      Provider.fromClass(FileService).pipe(setArgs('/var/data')),
+      Provider.fromClass(FileService).pipe(appendArgs('/var/data')),
     );
 
     const service = container.resolve<FileService>('FileService');
@@ -1685,7 +1839,7 @@ describe('Provider', () => {
       'Database',
       Provider.fromClass(Database).pipe(
         // Dynamically resolve connection string at creation time
-        setArgsFn((scope) => [`postgres://${scope.resolve('DbPath')}`]),
+        appendArgsFn((scope) => [`postgres://${scope.resolve('DbPath')}`]),
       ),
     );
 
@@ -1826,11 +1980,11 @@ describe('Singleton', function () {
 
 ### Arguments
 
-Sometimes you want to bind some arguments to provider. This is what `ArgsProvider` is for.
+Sometimes you want to bind some arguments to provider.
 
-- `provider(setArgs('someArgument'))`
-- `provider(setArgsFn((container) => [container.resolve(Logger), 'someValue']))`
-- `Provider.fromClass(Logger).pipe(setArgs('someArgument'))`
+- `provider(appendArgs('someArgument'))`
+- `provider(appendArgsFn((container) => [container.resolve(Logger), 'someValue']))`
+- `Provider.fromClass(Logger).pipe(appendArgs('someArgument'))`
 
 ### Token as argument
 
@@ -1863,13 +2017,13 @@ const userToken = ApiToken.args('https://users.api.com', 1000);
 ```typescript
 import {
   args,
+  appendArgs,
+  appendArgsFn,
   bindTo,
   Container,
   inject,
   register,
   Registration as R,
-  setArgs,
-  setArgsFn,
   SingleToken,
   singleton,
 } from 'ts-ioc-container';
@@ -1884,7 +2038,7 @@ import {
  * - Generic classes (like Repositories) that need to know what they are managing
  */
 
-describe('ArgsProvider', function () {
+describe('IProvider', function () {
   function createContainer() {
     return new Container();
   }
@@ -1892,7 +2046,7 @@ describe('ArgsProvider', function () {
   describe('Static Arguments', () => {
     it('can pass static arguments to constructor', function () {
       // Pre-configure the logger with a filename
-      @register(setArgs('/var/log/app.log'))
+      @register(appendArgs('/var/log/app.log'))
       class FileLogger {
         constructor(@inject(args(0)) public filename: string) {}
       }
@@ -1904,19 +2058,21 @@ describe('ArgsProvider', function () {
       expect(logger.filename).toBe('/var/log/app.log');
     });
 
-    it('prioritizes provided args over resolve args', function () {
-      // 'FixedContext' wins over any runtime args
-      @register(setArgs('FixedContext'))
+    it('appends configured args after resolve args', function () {
+      @register(appendArgs('ConfiguredContext'))
       class Logger {
-        constructor(@inject(args(0)) public context: string) {}
+        constructor(
+          @inject(args(0)) public runtimeContext: string,
+          @inject(args(1)) public configuredContext: string,
+        ) {}
       }
 
       const root = createContainer().addRegistration(R.fromClass(Logger));
 
-      // Even if we ask for 'RuntimeContext', we get 'FixedContext'
       const logger = root.resolve<Logger>('Logger', { args: ['RuntimeContext'] });
 
-      expect(logger.context).toBe('FixedContext');
+      expect(logger.runtimeContext).toBe('RuntimeContext');
+      expect(logger.configuredContext).toBe('ConfiguredContext');
     });
   });
 
@@ -1927,7 +2083,7 @@ describe('ArgsProvider', function () {
       }
 
       // Extract 'env' from Config service dynamically
-      @register(setArgsFn((scope) => [scope.resolve<Config>('Config').env]))
+      @register(appendArgsFn((scope) => [scope.resolve<Config>('Config').env]))
       class Service {
         constructor(@inject(args(0)) public env: string) {}
       }
@@ -1941,6 +2097,46 @@ describe('ArgsProvider', function () {
     });
   });
 
+  describe('Appending Arguments', () => {
+    it('can append static arguments after existing resolve arguments', function () {
+      @register(appendArgs('configured'))
+      class Service {
+        constructor(
+          @inject(args(0)) public runtime: string,
+          @inject(args(1)) public configured: string,
+        ) {}
+      }
+
+      const root = createContainer().addRegistration(R.fromClass(Service));
+
+      const service = root.resolve<Service>('Service', { args: ['runtime'] });
+      expect(service.runtime).toBe('runtime');
+      expect(service.configured).toBe('configured');
+    });
+
+    it('can append dynamic arguments after runtime args', function () {
+      class Config {
+        tenant = 'tenant-a';
+      }
+
+      @register(appendArgs('fixed'), appendArgsFn((scope) => [scope.resolve<Config>('Config').tenant]))
+      class Service {
+        constructor(
+          @inject(args(0)) public runtime: string,
+          @inject(args(1)) public fixed: string,
+          @inject(args(2)) public tenant: string,
+        ) {}
+      }
+
+      const root = createContainer().addRegistration(R.fromClass(Config)).addRegistration(R.fromClass(Service));
+
+      const service = root.resolve<Service>('Service', { args: ['runtime'] });
+      expect(service.runtime).toBe('runtime');
+      expect(service.fixed).toBe('fixed');
+      expect(service.tenant).toBe('tenant-a');
+    });
+  });
+
   describe('Generic Repositories (Advanced Pattern)', () => {
     // This example demonstrates how to implement the Generic Repository pattern
     // where a generic EntityManager needs to know WHICH repository to use.

package/cjm/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SingleToken = exports.ClassToken = exports.toSingleAlias = exports.SingleAliasToken = exports.toGroupAlias = exports.GroupAliasToken = exports.InjectionToken = exports.HooksRunner = exports.AddOnDisposeHookModule = exports.onDispose = exports.onDisposeHooksRunner = exports.AddOnConstructHookModule = exports.onConstruct = exports.onConstructHooksRunner = exports.injectProp = exports.createHookContext = exports.createHookContextFactory = exports.HookContext = exports.hasHooks = exports.hook = exports.getHooks = exports.UnexpectedHookResultError = exports.ContainerDisposedError = exports.MethodNotImplementedError = exports.DependencyMissingKeyError = exports.DependencyNotFoundError = exports.Registration = exports.bindTo = exports.register = exports.scope = exports.decorate = exports.SingletonProvider = exports.singleton = exports.Provider = exports.ProviderDecorator = exports.setArgs = exports.setArgsFn = exports.lazy = exports.scopeAccess = exports.ProxyInjector = exports.SimpleInjector = exports.MetadataInjector = exports.Injector = exports.argsFn = exports.args = exports.resolveArgs = exports.inject = exports.EmptyContainer = exports.Container = exports.isDependencyKey = void 0;
+exports.SingleToken = exports.ClassToken = exports.toSingleAlias = exports.SingleAliasToken = exports.toGroupAlias = exports.GroupAliasToken = exports.InjectionToken = exports.HooksRunner = exports.AddOnDisposeHookModule = exports.onDispose = exports.onDisposeHooksRunner = exports.AddOnConstructHookModule = exports.onConstruct = exports.onConstructHooksRunner = exports.injectProp = exports.createHookContext = exports.createHookContextFactory = exports.HookContext = exports.hasHooks = exports.hook = exports.getHooks = exports.UnexpectedHookResultError = exports.ContainerDisposedError = exports.MethodNotImplementedError = exports.DependencyMissingKeyError = exports.DependencyNotFoundError = exports.Registration = exports.bindTo = exports.register = exports.scope = exports.decorate = exports.SingletonProvider = exports.singleton = exports.Provider = exports.ProviderDecorator = exports.appendArgsFn = exports.appendArgs = exports.lazy = exports.scopeAccess = exports.ProxyInjector = exports.SimpleInjector = exports.MetadataInjector = exports.Injector = exports.argsFn = exports.args = exports.resolveArgs = exports.inject = exports.EmptyContainer = exports.Container = exports.isDependencyKey = void 0;
 exports.resolveConstructor = exports.Is = exports.pipe = exports.select = exports.once = exports.shallowCache = exports.debounce = exports.throttle = exports.handleAsyncError = exports.handleError = exports.getMethodTags = exports.methodTag = exports.getMethodLabels = exports.methodLabel = exports.getMethodMeta = exports.methodMeta = exports.getParamTags = exports.paramTag = exports.getParamLabels = exports.paramLabel = exports.getParamMeta = exports.paramMeta = exports.getClassTags = exports.classTag = exports.getClassLabels = exports.classLabel = exports.getClassMeta = exports.classMeta = exports.GroupInstanceToken = exports.ConstantToken = exports.FunctionToken = void 0;
 // Containers
 var IContainer_1 = require("./container/IContainer");
@@ -27,8 +27,8 @@ Object.defineProperty(exports, "ProxyInjector", { enumerable: true, get: functio
 var IProvider_1 = require("./provider/IProvider");
 Object.defineProperty(exports, "scopeAccess", { enumerable: true, get: function () { return IProvider_1.scopeAccess; } });
 Object.defineProperty(exports, "lazy", { enumerable: true, get: function () { return IProvider_1.lazy; } });
-Object.defineProperty(exports, "setArgsFn", { enumerable: true, get: function () { return IProvider_1.setArgsFn; } });
-Object.defineProperty(exports, "setArgs", { enumerable: true, get: function () { return IProvider_1.setArgs; } });
+Object.defineProperty(exports, "appendArgs", { enumerable: true, get: function () { return IProvider_1.appendArgs; } });
+Object.defineProperty(exports, "appendArgsFn", { enumerable: true, get: function () { return IProvider_1.appendArgsFn; } });
 Object.defineProperty(exports, "ProviderDecorator", { enumerable: true, get: function () { return IProvider_1.ProviderDecorator; } });
 var Provider_1 = require("./provider/Provider");
 Object.defineProperty(exports, "Provider", { enumerable: true, get: function () { return Provider_1.Provider; } });

package/cjm/provider/IProvider.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProviderDecorator = exports.lazy = exports.scopeAccess = exports.setArgsFn = exports.setArgs = void 0;
+exports.ProviderDecorator = exports.lazy = exports.scopeAccess = exports.appendArgsFn = exports.appendArgs = void 0;
 const ProviderPipe_1 = require("./ProviderPipe");
-const setArgs = (...extraArgs) => (0, ProviderPipe_1.registerPipe)((p) => p.setArgs(() => extraArgs));
-exports.setArgs = setArgs;
-const setArgsFn = (fn) => (0, ProviderPipe_1.registerPipe)((p) => p.setArgs(fn));
-exports.setArgsFn = setArgsFn;
+const appendArgs = (...extraArgs) => (0, ProviderPipe_1.registerPipe)((p) => p.appendArgs(...extraArgs));
+exports.appendArgs = appendArgs;
+const appendArgsFn = (fn) => (0, ProviderPipe_1.registerPipe)((p) => p.appendArgsFn(fn));
+exports.appendArgsFn = appendArgsFn;
 const scopeAccess = (rule) => (0, ProviderPipe_1.registerPipe)((p) => p.setAccessRule(rule));
 exports.scopeAccess = scopeAccess;
 const lazy = () => (0, ProviderPipe_1.registerPipe)((p) => p.lazy());
@@ -35,8 +35,12 @@ class ProviderDecorator {
         this.decorated = this.decorated.pipe(...fns);
         return this;
     }
-    setArgs(argsFn) {
-        this.decorated.setArgs(argsFn);
+    appendArgs(...extraArgs) {
+        this.decorated.appendArgs(...extraArgs);
+        return this;
+    }
+    appendArgsFn(argsFn) {
+        this.decorated.appendArgsFn(argsFn);
         return this;
     }
     lazy() {

package/cjm/provider/Provider.js

@@ -38,8 +38,14 @@ class Provider {
         this.isLazy = true;
         return this;
     }
-    setArgs(argsFn) {
-        this.argsFn = argsFn;
+    appendArgs(...extraArgs) {
+        const parentFn = this.argsFn;
+        this.argsFn = (container, options) => [...parentFn(container, options), ...extraArgs];
+        return this;
+    }
+    appendArgsFn(argsFn) {
+        const parentFn = this.argsFn;
+        this.argsFn = (container, options) => [...parentFn(container, options), ...argsFn(container, options)];
         return this;
     }
     hasAccess(options) {

package/cjm/token/InjectionToken.js

@@ -1,13 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setArgs = exports.InjectionToken = void 0;
+exports.InjectionToken = void 0;
 exports.isInjectionToken = isInjectionToken;
 const basic_1 = require("../utils/basic");
 class InjectionToken {
 }
 exports.InjectionToken = InjectionToken;
-const setArgs = (...args) => (s) => args;
-exports.setArgs = setArgs;
 function isInjectionToken(target) {
     return basic_1.Is.object(target) && 'resolve' in target && 'args' in target && 'argsFn' in target && 'lazy' in target;
 }

package/esm/index.js

@@ -9,7 +9,7 @@ export { MetadataInjector } from './injector/MetadataInjector';
 export { SimpleInjector } from './injector/SimpleInjector';
 export { ProxyInjector } from './injector/ProxyInjector';
 // Providers
-export { scopeAccess, lazy, setArgsFn, setArgs, ProviderDecorator, } from './provider/IProvider';
+export { scopeAccess, lazy, appendArgs, appendArgsFn, ProviderDecorator, } from './provider/IProvider';
 export { Provider } from './provider/Provider';
 export { singleton, SingletonProvider } from './provider/SingletonProvider';
 export { decorate } from './provider/DecoratorProvider';

package/esm/provider/IProvider.js

@@ -1,6 +1,6 @@
 import { isProviderPipe, registerPipe } from './ProviderPipe';
-export const setArgs = (...extraArgs) => registerPipe((p) => p.setArgs(() => extraArgs));
-export const setArgsFn = (fn) => registerPipe((p) => p.setArgs(fn));
+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 lazy = () => registerPipe((p) => p.lazy());
 export class ProviderDecorator {
@@ -28,8 +28,12 @@ export class ProviderDecorator {
         this.decorated = this.decorated.pipe(...fns);
         return this;
     }
-    setArgs(argsFn) {
-        this.decorated.setArgs(argsFn);
+    appendArgs(...extraArgs) {
+        this.decorated.appendArgs(...extraArgs);
+        return this;
+    }
+    appendArgsFn(argsFn) {
+        this.decorated.appendArgsFn(argsFn);
         return this;
     }
     lazy() {

package/esm/provider/Provider.js

@@ -35,8 +35,14 @@ export class Provider {
         this.isLazy = true;
         return this;
     }
-    setArgs(argsFn) {
-        this.argsFn = argsFn;
+    appendArgs(...extraArgs) {
+        const parentFn = this.argsFn;
+        this.argsFn = (container, options) => [...parentFn(container, options), ...extraArgs];
+        return this;
+    }
+    appendArgsFn(argsFn) {
+        const parentFn = this.argsFn;
+        this.argsFn = (container, options) => [...parentFn(container, options), ...argsFn(container, options)];
         return this;
     }
     hasAccess(options) {

package/esm/token/InjectionToken.js

@@ -1,7 +1,6 @@
 import { Is } from '../utils/basic';
 export class InjectionToken {
 }
-export const setArgs = (...args) => (s) => args;
 export function isInjectionToken(target) {
     return Is.object(target) && 'resolve' in target && 'args' in target && 'argsFn' in target && 'lazy' in target;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-ioc-container",
-  "version": "50.0.0",
+  "version": "50.2.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"
@@ -90,11 +90,11 @@
     "@swc/core": "^1.15.24",
     "@types/node": "^25.5.2",
     "@typescript-eslint/eslint-plugin": "8.32.1",
-    "@typescript-eslint/parser": "8.29.1",
+    "@typescript-eslint/parser": "8.58.2",
     "@vitest/coverage-v8": "^4.1.2",
     "cz-conventional-changelog": "^3.3.0",
     "eslint": "9.24.0",
-    "eslint-config-prettier": "10.1.1",
+    "eslint-config-prettier": "10.1.8",
     "eslint-plugin-prettier": "5.2.6",
     "handlebars": "^4.7.8",
     "husky": "^9.1.7",

package/typings/index.d.ts

@@ -6,7 +6,7 @@ export { type IInjector, type InjectOptions, type IInjectFnResolver, Injector }
 export { MetadataInjector } from './injector/MetadataInjector';
 export { SimpleInjector } from './injector/SimpleInjector';
 export { ProxyInjector } from './injector/ProxyInjector';
-export { type ResolveDependency, type IProvider, scopeAccess, lazy, setArgsFn, setArgs, type ArgsFn, ProviderDecorator, type IMapper, type ProviderOptions, } from './provider/IProvider';
+export { type ResolveDependency, type IProvider, scopeAccess, lazy, appendArgs, appendArgsFn, type ArgsFn, ProviderDecorator, type IMapper, type ProviderOptions, } from './provider/IProvider';
 export { Provider } from './provider/Provider';
 export { singleton, SingletonProvider } from './provider/SingletonProvider';
 export { decorate, type DecorateFn } from './provider/DecoratorProvider';

package/typings/provider/IProvider.d.ts

@@ -21,11 +21,12 @@ export interface IProvider<T = any> {
     hasAccess(options: ScopeAccessOptions): boolean;
     pipe(...mappers: (MapFn<IProvider<T>> | ProviderPipe<T>)[]): IProvider<T>;
     setAccessRule(hasAccessWhen: ScopeAccessRule): this;
-    setArgs(argsFn: ArgsFn): this;
+    appendArgs(...extraArgs: unknown[]): this;
+    appendArgsFn(argsFn: ArgsFn): this;
     lazy(): this;
 }
-export declare const setArgs: <T>(...extraArgs: unknown[]) => ProviderPipe<T>;
-export declare const setArgsFn: <T>(fn: ArgsFn) => ProviderPipe<T>;
+export declare const appendArgs: <T>(...extraArgs: unknown[]) => ProviderPipe<T>;
+export declare const appendArgsFn: <T>(fn: ArgsFn) => ProviderPipe<T>;
 export declare const scopeAccess: <T>(rule: ScopeAccessRule) => ProviderPipe<T>;
 export declare const lazy: <T>() => ProviderPipe<T>;
 export declare abstract class ProviderDecorator<T> implements IProvider<T> {
@@ -35,6 +36,7 @@ export declare abstract class ProviderDecorator<T> implements IProvider<T> {
     hasAccess(options: ScopeAccessOptions): boolean;
     resolve(container: IContainer, options: ProviderOptions): T;
     pipe(...mappers: (MapFn<IProvider<T>> | ProviderPipe<T>)[]): IProvider<T>;
-    setArgs(argsFn: ArgsFn): this;
+    appendArgs(...extraArgs: unknown[]): this;
+    appendArgsFn(argsFn: ArgsFn): this;
     lazy(): this;
 }

package/typings/provider/Provider.d.ts

@@ -16,6 +16,7 @@ export declare class Provider<T = any> implements IProvider<T> {
     resolve(container: IContainer, { args, lazy }?: ProviderOptions): T;
     setAccessRule(predicate: ScopeAccessRule): this;
     lazy(): this;
-    setArgs(argsFn: ArgsFn): this;
+    appendArgs(...extraArgs: unknown[]): this;
+    appendArgsFn(argsFn: ArgsFn): this;
     hasAccess(options: ScopeAccessOptions): boolean;
 }

package/typings/token/InjectionToken.d.ts

@@ -1,10 +1,9 @@
 import { type IContainer } from '../container/IContainer';
-import { ArgsFn, ProviderOptions } from '../provider/IProvider';
+import { ProviderOptions } from '../provider/IProvider';
 export declare abstract class InjectionToken<T = any> {
     abstract resolve(s: IContainer, options?: ProviderOptions): T;
     abstract args(...deps: unknown[]): InjectionToken<T>;
     abstract argsFn(getArgsFn: (s: IContainer) => unknown[]): InjectionToken<T>;
     abstract lazy(): InjectionToken<T>;
 }
-export declare const setArgs: (...args: unknown[]) => ArgsFn;
 export declare function isInjectionToken(target: unknown): target is InjectionToken;