ts-ioc-container 32.0.6 → 32.1.0

package/README.md

@@ -1149,12 +1149,13 @@ import {
   Registration as R,
   register,
 } from 'ts-ioc-container';
+import { InjectOptions } from '../lib/injector/IInjector.ts';
 
 class MyInjector implements IInjector {
   private injector = new MetadataInjector();
 
-  resolve<T>(container: IContainer, value: constructor<T>, ...deps: unknown[]): T {
-    const instance = this.injector.resolve(container, value, ...deps);
+  resolve<T>(container: IContainer, value: constructor<T>, options: InjectOptions): T {
+    const instance = this.injector.resolve(container, value, options);
     // eslint-disable-next-line @typescript-eslint/ban-types
     for (const [h] of getHooks(instance as object, 'onConstruct')) {
       // @ts-ignore
@@ -1206,7 +1207,6 @@ import {
   MetadataInjector,
   register,
 } from 'ts-ioc-container';
-import * as console from 'node:console';
 
 @register(key('logsRepo'))
 @provider(singleton())
@@ -1224,7 +1224,7 @@ class Logger {
 
   constructor(@inject(by.key('logsRepo')) private logsRepo: LogsRepo) {}
 
-  log(message: string): void {
+  log(@inject(by.key('logsRepo')) message: string): void {
     this.messages.push(message);
   }
 

package/cjm/autorun.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startAutorun = exports.getAutorunHooks = exports.autorun = exports.AutorunContext = void 0;
+const MetadataInjector_1 = require("./injector/MetadataInjector");
+const METADATA_KEY = 'autorun';
+class AutorunContext {
+    constructor(instance, methodName, scope) {
+        this.instance = instance;
+        this.methodName = methodName;
+        this.scope = scope;
+    }
+    resolveArgs(...args) {
+        return (0, MetadataInjector_1.resolveArgs)(this.instance.constructor, this.methodName)(this.scope, ...args);
+    }
+    invokeMethod({ args = this.resolveArgs() }) {
+        // @ts-ignore
+        return this.instance[this.methodName](...args);
+    }
+}
+exports.AutorunContext = AutorunContext;
+const createStore = () => new Map();
+const autorun = (execute) => (target, propertyKey) => {
+    const hooks = Reflect.hasMetadata(METADATA_KEY, target.constructor)
+        ? Reflect.getMetadata(METADATA_KEY, target.constructor)
+        : createStore();
+    hooks.set(propertyKey, execute);
+    Reflect.defineMetadata(METADATA_KEY, hooks, target.constructor);
+};
+exports.autorun = autorun;
+const getAutorunHooks = (target) => {
+    return Reflect.hasMetadata(METADATA_KEY, target.constructor)
+        ? Reflect.getMetadata(METADATA_KEY, target.constructor)
+        : new Map();
+};
+exports.getAutorunHooks = getAutorunHooks;
+const startAutorun = (target, scope, createContext = (c) => c) => {
+    for (const [methodName, execute] of (0, exports.getAutorunHooks)(target)) {
+        execute(createContext(new AutorunContext(target, methodName, scope)));
+    }
+};
+exports.startAutorun = startAutorun;

package/cjm/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getParameterMetadata = exports.getMethodMetadata = exports.setMethodMetadata = exports.setParameterMetadata = exports.getMetadata = exports.setMetadata = exports.byAliases = exports.byAlias = exports.IMemoKey = exports.by = exports.hasHooks = exports.hook = exports.getHooks = exports.ContainerDisposedError = exports.MethodNotImplementedError = exports.DependencyNotFoundError = exports.Registration = exports.register = exports.scope = exports.key = exports.decorate = exports.multiCache = exports.MultiCache = exports.SingletonProvider = exports.singleton = exports.Provider = exports.ProviderDecorator = exports.args = exports.argsFn = exports.alias = exports.visible = exports.provider = exports.ProxyInjector = exports.SimpleInjector = exports.inject = exports.MetadataInjector = exports.AutoMockedContainer = exports.EmptyContainer = exports.Container = exports.isDependencyKey = void 0;
+exports.getParameterMetadata = exports.getMethodMetadata = exports.setMethodMetadata = exports.setParameterMetadata = exports.getMetadata = exports.setMetadata = exports.AutorunContext = exports.startAutorun = exports.autorun = exports.byAliases = exports.byAlias = exports.IMemoKey = exports.by = exports.hasHooks = exports.hook = exports.getHooks = exports.ContainerDisposedError = exports.MethodNotImplementedError = exports.DependencyNotFoundError = exports.Registration = exports.register = exports.scope = exports.key = exports.decorate = exports.multiCache = exports.MultiCache = exports.SingletonProvider = exports.singleton = exports.Provider = exports.ProviderDecorator = exports.args = exports.argsFn = exports.alias = exports.visible = exports.provider = exports.ProxyInjector = exports.SimpleInjector = exports.getInjectFns = exports.resolveArgs = exports.inject = exports.MetadataInjector = exports.AutoMockedContainer = exports.EmptyContainer = exports.Container = exports.isDependencyKey = void 0;
 // Containers
 var IContainer_1 = require("./container/IContainer");
 Object.defineProperty(exports, "isDependencyKey", { enumerable: true, get: function () { return IContainer_1.isDependencyKey; } });
@@ -13,6 +13,8 @@ Object.defineProperty(exports, "AutoMockedContainer", { enumerable: true, get: f
 var MetadataInjector_1 = require("./injector/MetadataInjector");
 Object.defineProperty(exports, "MetadataInjector", { enumerable: true, get: function () { return MetadataInjector_1.MetadataInjector; } });
 Object.defineProperty(exports, "inject", { enumerable: true, get: function () { return MetadataInjector_1.inject; } });
+Object.defineProperty(exports, "resolveArgs", { enumerable: true, get: function () { return MetadataInjector_1.resolveArgs; } });
+Object.defineProperty(exports, "getInjectFns", { enumerable: true, get: function () { return MetadataInjector_1.getInjectFns; } });
 var SimpleInjector_1 = require("./injector/SimpleInjector");
 Object.defineProperty(exports, "SimpleInjector", { enumerable: true, get: function () { return SimpleInjector_1.SimpleInjector; } });
 var ProxyInjector_1 = require("./injector/ProxyInjector");
@@ -59,6 +61,10 @@ Object.defineProperty(exports, "by", { enumerable: true, get: function () { retu
 Object.defineProperty(exports, "IMemoKey", { enumerable: true, get: function () { return by_1.IMemoKey; } });
 Object.defineProperty(exports, "byAlias", { enumerable: true, get: function () { return by_1.byAlias; } });
 Object.defineProperty(exports, "byAliases", { enumerable: true, get: function () { return by_1.byAliases; } });
+var autorun_1 = require("./autorun");
+Object.defineProperty(exports, "autorun", { enumerable: true, get: function () { return autorun_1.autorun; } });
+Object.defineProperty(exports, "startAutorun", { enumerable: true, get: function () { return autorun_1.startAutorun; } });
+Object.defineProperty(exports, "AutorunContext", { enumerable: true, get: function () { return autorun_1.AutorunContext; } });
 var metadata_1 = require("./metadata");
 Object.defineProperty(exports, "setMetadata", { enumerable: true, get: function () { return metadata_1.setMetadata; } });
 Object.defineProperty(exports, "getMetadata", { enumerable: true, get: function () { return metadata_1.getMetadata; } });

package/cjm/injector/MetadataInjector.js

@@ -1,16 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MetadataInjector = exports.inject = void 0;
+exports.MetadataInjector = exports.resolveArgs = exports.inject = exports.getInjectFns = void 0;
 const utils_1 = require("../utils");
 const metadata_1 = require("../metadata");
 const METADATA_KEY = 'inject';
-const getInjectFns = (Target) => (0, metadata_1.getParameterMetadata)(METADATA_KEY, Target);
-const inject = (fn) => (0, metadata_1.setParameterMetadata)(METADATA_KEY, fn);
+const getInjectFns = (Target, methodName) => (0, metadata_1.getParameterMetadata)(metaKey(methodName), Target);
+exports.getInjectFns = getInjectFns;
+const metaKey = (methodName = 'constructor') => `${METADATA_KEY}:${methodName}`;
+const inject = (fn) => (target, propertyKey, parameterIndex) => (0, metadata_1.setParameterMetadata)(metaKey(propertyKey), fn)(target, propertyKey, parameterIndex);
 exports.inject = inject;
+const resolveArgs = (Target, methodName) => {
+    const argsFns = (0, exports.getInjectFns)(Target, methodName);
+    return (scope, ...deps) => (0, utils_1.fillEmptyIndexes)(argsFns, deps.map(utils_1.constant)).map((fn) => fn(scope));
+};
+exports.resolveArgs = resolveArgs;
 class MetadataInjector {
     resolve(container, Target, { args: deps }) {
-        const injectionFns = getInjectFns(Target);
-        const args = (0, utils_1.fillEmptyIndexes)(injectionFns, deps.map(utils_1.constant)).map((fn) => fn(container));
+        const args = (0, exports.resolveArgs)(Target)(container, ...deps);
         return new Target(...args);
     }
 }

package/cjm/registration/Registration.js

@@ -34,6 +34,10 @@ class Registration {
         this.mappers.push(...mappers);
         return this;
     }
+    when(isValidWhen) {
+        this.matchScope = isValidWhen;
+        return this;
+    }
     applyTo(container) {
         if (!this.matchScope(container)) {
             return;
@@ -43,9 +47,5 @@ class Registration {
         }
         container.register(this.key, this.createProvider().pipe(...this.mappers));
     }
-    when(isValidWhen) {
-        this.matchScope = isValidWhen;
-        return this;
-    }
 }
 exports.Registration = Registration;

package/esm/autorun.js

@@ -0,0 +1,34 @@
+import { resolveArgs } from './injector/MetadataInjector';
+const METADATA_KEY = 'autorun';
+export class AutorunContext {
+    constructor(instance, methodName, scope) {
+        this.instance = instance;
+        this.methodName = methodName;
+        this.scope = scope;
+    }
+    resolveArgs(...args) {
+        return resolveArgs(this.instance.constructor, this.methodName)(this.scope, ...args);
+    }
+    invokeMethod({ args = this.resolveArgs() }) {
+        // @ts-ignore
+        return this.instance[this.methodName](...args);
+    }
+}
+const createStore = () => new Map();
+export const autorun = (execute) => (target, propertyKey) => {
+    const hooks = Reflect.hasMetadata(METADATA_KEY, target.constructor)
+        ? Reflect.getMetadata(METADATA_KEY, target.constructor)
+        : createStore();
+    hooks.set(propertyKey, execute);
+    Reflect.defineMetadata(METADATA_KEY, hooks, target.constructor);
+};
+export const getAutorunHooks = (target) => {
+    return Reflect.hasMetadata(METADATA_KEY, target.constructor)
+        ? Reflect.getMetadata(METADATA_KEY, target.constructor)
+        : new Map();
+};
+export const startAutorun = (target, scope, createContext = (c) => c) => {
+    for (const [methodName, execute] of getAutorunHooks(target)) {
+        execute(createContext(new AutorunContext(target, methodName, scope)));
+    }
+};

package/esm/index.js

@@ -3,7 +3,7 @@ export { isDependencyKey, } from './container/IContainer';
 export { Container } from './container/Container';
 export { EmptyContainer } from './container/EmptyContainer';
 export { AutoMockedContainer } from './container/AutoMockedContainer';
-export { MetadataInjector, inject } from './injector/MetadataInjector';
+export { MetadataInjector, inject, resolveArgs, getInjectFns } from './injector/MetadataInjector';
 export { SimpleInjector } from './injector/SimpleInjector';
 export { ProxyInjector } from './injector/ProxyInjector';
 // Providers
@@ -22,4 +22,5 @@ export { ContainerDisposedError } from './errors/ContainerDisposedError';
 // Others
 export { getHooks, hook, hasHooks } from './hook';
 export { by, IMemoKey, byAlias, byAliases } from './by';
+export { autorun, startAutorun, AutorunContext } from './autorun';
 export { setMetadata, getMetadata, setParameterMetadata, setMethodMetadata, getMethodMetadata, getParameterMetadata, } from './metadata';

package/esm/injector/MetadataInjector.js

@@ -1,12 +1,16 @@
 import { constant, fillEmptyIndexes } from '../utils';
 import { setParameterMetadata, getParameterMetadata } from '../metadata';
 const METADATA_KEY = 'inject';
-const getInjectFns = (Target) => getParameterMetadata(METADATA_KEY, Target);
-export const inject = (fn) => setParameterMetadata(METADATA_KEY, fn);
+export const getInjectFns = (Target, methodName) => getParameterMetadata(metaKey(methodName), Target);
+const metaKey = (methodName = 'constructor') => `${METADATA_KEY}:${methodName}`;
+export const inject = (fn) => (target, propertyKey, parameterIndex) => setParameterMetadata(metaKey(propertyKey), fn)(target, propertyKey, parameterIndex);
+export const resolveArgs = (Target, methodName) => {
+    const argsFns = getInjectFns(Target, methodName);
+    return (scope, ...deps) => fillEmptyIndexes(argsFns, deps.map(constant)).map((fn) => fn(scope));
+};
 export class MetadataInjector {
     resolve(container, Target, { args: deps }) {
-        const injectionFns = getInjectFns(Target);
-        const args = fillEmptyIndexes(injectionFns, deps.map(constant)).map((fn) => fn(container));
+        const args = resolveArgs(Target)(container, ...deps);
         return new Target(...args);
     }
 }

package/esm/registration/Registration.js

@@ -31,6 +31,10 @@ export class Registration {
         this.mappers.push(...mappers);
         return this;
     }
+    when(isValidWhen) {
+        this.matchScope = isValidWhen;
+        return this;
+    }
     applyTo(container) {
         if (!this.matchScope(container)) {
             return;
@@ -40,8 +44,4 @@ export class Registration {
         }
         container.register(this.key, this.createProvider().pipe(...this.mappers));
     }
-    when(isValidWhen) {
-        this.matchScope = isValidWhen;
-        return this;
-    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-ioc-container",
-  "version": "32.0.6",
+  "version": "32.1.0",
   "description": "Typescript IoC container",
   "publishConfig": {
     "access": "public",
@@ -44,20 +44,20 @@
     "generate:docs": "ts-node scripts/generateReadme/generateReadme.ts && git add README.md",
     "build": "npm run build:cjm && npm run build:esm && npm run build:types",
     "coverage": "coveralls",
-    "watch": "nodemon --watch ./lib --exec npm run build",
-    "test": "jest --coverage"
+    "test": "jest --coverage",
+    "type-check": "tsc --noEmit",
+    "type-check:watch": "tsc --noEmit --watch"
   },
   "devDependencies": {
     "@types/jest": "27.0.2",
     "handlebars": "^4.7.7",
     "jest": "27.2.3",
     "moq.ts": "^7.3.4",
-    "nodemon": "^2.0.13",
     "reflect-metadata": "^0.2.2",
     "rimraf": "3.0.2",
     "ts-jest": "27.0.5",
     "ts-node": "^10.9.1",
     "typescript": "5.4.3"
   },
-  "gitHead": "a653a60236b043827d7f9d61b64b8380c4e3493e"
+  "gitHead": "79eba3d3a19747339a7b078592f719f00c869f59"
 }

package/typings/autorun.d.ts

@@ -0,0 +1,16 @@
+import { IContainer } from './container/IContainer';
+export declare class AutorunContext {
+    instance: object;
+    methodName: string;
+    private scope;
+    constructor(instance: object, methodName: string, scope: IContainer);
+    resolveArgs(...args: unknown[]): unknown[];
+    invokeMethod({ args }: {
+        args: unknown[];
+    }): unknown;
+}
+type AutorunHandler = <T extends AutorunContext>(context: T) => void;
+export declare const autorun: (execute: AutorunHandler) => MethodDecorator;
+export declare const getAutorunHooks: (target: object) => Map<string, AutorunHandler>;
+export declare const startAutorun: <Context extends AutorunContext>(target: object, scope: IContainer, createContext?: (c: AutorunContext) => Context) => void;
+export {};

package/typings/index.d.ts

@@ -3,7 +3,7 @@ export { Container } from './container/Container';
 export { EmptyContainer } from './container/EmptyContainer';
 export { AutoMockedContainer } from './container/AutoMockedContainer';
 export { IInjector } from './injector/IInjector';
-export { MetadataInjector, inject } from './injector/MetadataInjector';
+export { MetadataInjector, inject, resolveArgs, getInjectFns, InjectFn } from './injector/MetadataInjector';
 export { SimpleInjector } from './injector/SimpleInjector';
 export { ProxyInjector } from './injector/ProxyInjector';
 export { ResolveDependency, IProvider, provider, visible, alias, argsFn, args, ArgsFn, ProviderDecorator, InstantDependencyOptions, ProviderResolveOptions, } from './provider/IProvider';
@@ -20,4 +20,5 @@ export { ContainerDisposedError } from './errors/ContainerDisposedError';
 export { getHooks, hook, hasHooks } from './hook';
 export { by, InstancePredicate, IMemo, IMemoKey, byAlias, byAliases } from './by';
 export { constructor } from './utils';
+export { autorun, startAutorun, AutorunContext } from './autorun';
 export { setMetadata, getMetadata, setParameterMetadata, setMethodMetadata, getMethodMetadata, getParameterMetadata, } from './metadata';

package/typings/injector/MetadataInjector.d.ts

@@ -2,7 +2,9 @@ import { IInjector, InjectOptions } from './IInjector';
 import { IContainer } from '../container/IContainer';
 import { constructor } from '../utils';
 export type InjectFn<T = unknown> = (l: IContainer) => T;
+export declare const getInjectFns: (Target: constructor<unknown>, methodName?: string) => InjectFn<unknown>[];
 export declare const inject: (fn: InjectFn) => ParameterDecorator;
+export declare const resolveArgs: (Target: constructor<unknown>, methodName?: string) => (scope: IContainer, ...deps: unknown[]) => unknown[];
 export declare class MetadataInjector implements IInjector {
     resolve<T>(container: IContainer, Target: constructor<T>, { args: deps }: InjectOptions): T;
 }

package/typings/registration/Registration.d.ts

@@ -13,6 +13,6 @@ export declare class Registration<T = unknown> implements IRegistration<T> {
     constructor(createProvider: () => IProvider<T>, key?: DependencyKey | undefined, matchScope?: ScopePredicate);
     to(key: DependencyKey): this;
     pipe(...mappers: MapFn<IProvider<T>>[]): this;
-    applyTo(container: IContainer): void;
     when(isValidWhen: ScopePredicate): this;
+    applyTo(container: IContainer): void;
 }