ts-ioc-container 32.9.0 → 32.10.0

package/README.md

@@ -1289,11 +1289,13 @@ describe('inject property', () => {
 import { by, Container, executeHooks, hook, inject, invokeExecution, MetadataInjector, Registration } from 'ts-ioc-container';
 
 describe('inject method', () => {
-  it('should inject method', () => {
+  const sleep = (number: number) => new Promise((resolve) => setTimeout(resolve, number));
+
+  it('should inject method', async () => {
     class App {
       greeting!: string;
 
-      @hook('onInit', invokeExecution({ handleError: jest.fn(), handleResult: jest.fn() }))
+      @hook('onInit', invokeExecution({ handleResult: jest.fn() }))
       setGreeting(@inject(by.key('greeting')) greeting: string) {
         this.greeting = greeting;
       }
@@ -1302,10 +1304,30 @@ describe('inject method', () => {
 
     const container = new Container(new MetadataInjector()).add(Registration.fromValue(expected).to('greeting'));
     const app = container.resolve(App);
-    executeHooks(app, 'onInit', { scope: container });
+    await executeHooks(app, 'onInit', { scope: container, handleError: jest.fn() });
 
     expect(app.greeting).toBe(expected);
   });
+
+  it('should inject method asyncronically', async () => {
+    class App {
+      greeting!: string;
+
+      @hook('onInit', invokeExecution({ handleResult: jest.fn() }))
+      setGreeting(@inject(by.key('greeting')) greeting: string, @inject(by.key('person')) person: string) {
+        this.greeting = `${greeting}${person}`;
+      }
+    }
+
+    const container = new Container(new MetadataInjector())
+      .add(Registration.fromFn(() => sleep(50).then(() => 'Hello,')).to('greeting'))
+      .add(Registration.fromFn(() => sleep(25).then(() => 'world')).to('person'));
+
+    const app = container.resolve(App);
+    await executeHooks(app, 'onInit', { scope: container, handleError: jest.fn() });
+
+    expect(app.greeting).toBe('Hello,world');
+  });
 });
 
 ```

package/cjm/hooks/hook.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.invokeExecution = exports.injectProp = exports.executeHooks = exports.hasHooks = exports.getHooks = exports.hook = void 0;
 const ExecutionContext_1 = require("./ExecutionContext");
-const MetadataInjector_1 = require("../injector/MetadataInjector");
+const utils_1 = require("../utils");
 const hook = (key, ...fns) => (target, propertyKey) => {
     const hooks = Reflect.hasMetadata(key, target.constructor)
         ? Reflect.getMetadata(key, target.constructor)
@@ -19,24 +19,17 @@ function hasHooks(target, key) {
     return Reflect.hasMetadata(key, target.constructor);
 }
 exports.hasHooks = hasHooks;
-const executeHooks = (target, key, { scope, createContext = (c) => c, }) => {
-    for (const [methodName, executions] of getHooks(target, key)) {
-        for (const execute of executions) {
-            execute(createContext(new ExecutionContext_1.ExecutionContext(target, methodName, scope)));
-        }
-    }
+const executeHooks = (target, key, { scope, decorateContext = (c) => c, handleError, }) => {
+    const hooks = Array.from(getHooks(target, key).entries());
+    const createContext = (methodName) => decorateContext(new ExecutionContext_1.ExecutionContext(target, methodName, scope));
+    const runExecution = (execute, context) => (0, utils_1.promisify)(execute(context)).catch((e) => handleError(e, scope));
+    return Promise.all(hooks.flatMap(([methodName, executions]) => executions.map((execute) => runExecution(execute, createContext(methodName)))));
 };
 exports.executeHooks = executeHooks;
 const injectProp = (fn) => (context) => context.injectProperty(fn);
 exports.injectProp = injectProp;
-const invokeExecution = ({ handleError, handleResult, }) => (context) => {
-    const args = (0, MetadataInjector_1.resolveArgs)(context.instance.constructor, context.methodName)(context.scope);
-    try {
-        const result = context.invokeMethod({ args });
-        handleResult(result, context);
-    }
-    catch (e) {
-        handleError(e, context.scope);
-    }
+const invokeExecution = ({ handleResult }) => async (context) => {
+    const args = await Promise.all(context.resolveArgs().map(utils_1.promisify));
+    return handleResult(context.invokeMethod({ args }), context);
 };
 exports.invokeExecution = invokeExecution;

package/cjm/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.lazyProxy = exports.isConstructor = exports.constant = exports.fillEmptyIndexes = exports.pipe = void 0;
+exports.promisify = exports.lazyProxy = exports.isConstructor = exports.constant = exports.fillEmptyIndexes = exports.pipe = void 0;
 const pipe = (...mappers) => (value) => mappers.reduce((acc, current) => current(acc), value);
 exports.pipe = pipe;
 function fillEmptyIndexes(baseArr, insertArr) {
@@ -29,3 +29,5 @@ function lazyProxy(resolveInstance) {
     });
 }
 exports.lazyProxy = lazyProxy;
+const promisify = (arg) => (arg instanceof Promise ? arg : Promise.resolve(arg));
+exports.promisify = promisify;

package/esm/hooks/hook.js

@@ -1,5 +1,5 @@
 import { ExecutionContext } from './ExecutionContext';
-import { resolveArgs } from '../injector/MetadataInjector';
+import { promisify } from '../utils';
 export const hook = (key, ...fns) => (target, propertyKey) => {
     const hooks = Reflect.hasMetadata(key, target.constructor)
         ? Reflect.getMetadata(key, target.constructor)
@@ -13,21 +13,14 @@ export function getHooks(target, key) {
 export function hasHooks(target, key) {
     return Reflect.hasMetadata(key, target.constructor);
 }
-export const executeHooks = (target, key, { scope, createContext = (c) => c, }) => {
-    for (const [methodName, executions] of getHooks(target, key)) {
-        for (const execute of executions) {
-            execute(createContext(new ExecutionContext(target, methodName, scope)));
-        }
-    }
+export const executeHooks = (target, key, { scope, decorateContext = (c) => c, handleError, }) => {
+    const hooks = Array.from(getHooks(target, key).entries());
+    const createContext = (methodName) => decorateContext(new ExecutionContext(target, methodName, scope));
+    const runExecution = (execute, context) => promisify(execute(context)).catch((e) => handleError(e, scope));
+    return Promise.all(hooks.flatMap(([methodName, executions]) => executions.map((execute) => runExecution(execute, createContext(methodName)))));
 };
 export const injectProp = (fn) => (context) => context.injectProperty(fn);
-export const invokeExecution = ({ handleError, handleResult, }) => (context) => {
-    const args = resolveArgs(context.instance.constructor, context.methodName)(context.scope);
-    try {
-        const result = context.invokeMethod({ args });
-        handleResult(result, context);
-    }
-    catch (e) {
-        handleError(e, context.scope);
-    }
+export const invokeExecution = ({ handleResult }) => async (context) => {
+    const args = await Promise.all(context.resolveArgs().map(promisify));
+    return handleResult(context.invokeMethod({ args }), context);
 };

package/esm/utils.js

@@ -21,3 +21,4 @@ export function lazyProxy(resolveInstance) {
         },
     });
 }
+export const promisify = (arg) => (arg instanceof Promise ? arg : Promise.resolve(arg));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-ioc-container",
-  "version": "32.9.0",
+  "version": "32.10.0",
   "description": "Typescript IoC container",
   "publishConfig": {
     "access": "public",
@@ -59,5 +59,5 @@
     "ts-node": "^10.9.1",
     "typescript": "5.4.3"
   },
-  "gitHead": "17060847c051dbbdfd167675ec27af2ae78efbfe"
+  "gitHead": "1feb3be27939265fa91d93aabc3c08fd5c235c27"
 }

package/typings/hooks/hook.d.ts

@@ -1,16 +1,20 @@
 import { IContainer } from '../container/IContainer';
 import { ExecutionContext } from './ExecutionContext';
 import { InjectFn } from '../injector/MetadataInjector';
-export type Execution<T extends ExecutionContext = ExecutionContext> = (context: T) => void;
-export declare const hook: (key: string | symbol, ...fns: Execution[]) => (target: object, propertyKey: string | symbol) => void;
-export declare function getHooks(target: object, key: string | symbol): Map<string, Execution[]>;
+export type Execution<T extends ExecutionContext = ExecutionContext> = (context: T) => void | Promise<void>;
+type HookList = Execution[];
+type Hooks = Map<string, HookList>;
+export declare const hook: (key: string | symbol, ...fns: HookList) => (target: object, propertyKey: string | symbol) => void;
+export declare function getHooks(target: object, key: string | symbol): Hooks;
 export declare function hasHooks(target: object, key: string | symbol): boolean;
-export declare const executeHooks: <Context extends ExecutionContext>(target: object, key: string | symbol, { scope, createContext, }: {
+export declare const executeHooks: <Context extends ExecutionContext>(target: object, key: string | symbol, { scope, decorateContext, handleError, }: {
     scope: IContainer;
-    createContext?: ((c: ExecutionContext) => Context) | undefined;
-}) => void;
-export declare const injectProp: (fn: InjectFn) => Execution;
-export declare const invokeExecution: ({ handleError, handleResult, }: {
+    decorateContext?: ((c: ExecutionContext) => Context) | undefined;
     handleError: (e: Error, s: IContainer) => void;
-    handleResult: (result: unknown, context: ExecutionContext) => void;
+}) => Promise<any[]>;
+export declare const injectProp: (fn: InjectFn) => Execution;
+type HandleResult = (result: unknown, context: ExecutionContext) => void | Promise<void>;
+export declare const invokeExecution: ({ handleResult }: {
+    handleResult: HandleResult;
 }) => Execution;
+export {};

package/typings/utils.d.ts

@@ -5,3 +5,4 @@ export declare function fillEmptyIndexes<T>(baseArr: (T | undefined)[], insertAr
 export declare const constant: <T>(value: T) => () => T;
 export declare const isConstructor: (T: unknown) => T is constructor<unknown>;
 export declare function lazyProxy<T>(resolveInstance: () => T): T;
+export declare const promisify: (arg: unknown) => Promise<any>;