ts-ioc-container 55.0.0 → 55.2.0

package/README.md

@@ -2462,7 +2462,16 @@ Sometimes you need to invoke methods after construct or dispose of class. This i
 
 ```typescript
 import 'reflect-metadata';
-import { AddOnConstructHookModule, Container, type HookFn, inject, onConstruct, Registration as R } from 'ts-ioc-container';
+import {
+  AddOnConstructHookModule,
+  Container,
+  type ExecutionContext,
+  type HookFn,
+  type IContainer,
+  inject,
+  onConstruct,
+  Registration as R,
+} from 'ts-ioc-container';
 
 const execute: HookFn = (ctx) => {
   ctx.invokeMethod({ args: ctx.resolveArgs() });
@@ -2490,6 +2499,64 @@ describe('onConstruct', function () {
     expect(db.isConnected).toBe(true);
     expect(db.connectionString).toBe('postgres://localhost:5432');
   });
+
+  it('should forward hook exceptions to the onException handler with the execution context', function () {
+    const failure = new Error('boom');
+
+    class BrokenService {
+      @onConstruct(() => {
+        throw failure;
+      })
+      init() {}
+    }
+
+    let captured: { ex: unknown; context: ExecutionContext } | undefined;
+    const container = new Container().useModule(
+      new AddOnConstructHookModule((ex, context) => {
+        captured = { ex, context };
+      }),
+    );
+
+    expect(() => container.resolve(BrokenService)).not.toThrow();
+    expect(captured?.ex).toBe(failure);
+    expect(captured?.context.scope).toBe(container);
+  });
+
+  it('should rethrow hook exceptions when no onException handler is provided', function () {
+    const failure = new Error('boom');
+
+    class BrokenService {
+      @onConstruct(() => {
+        throw failure;
+      })
+      init() {}
+    }
+
+    const container = new Container().useModule(new AddOnConstructHookModule());
+
+    expect(() => container.resolve(BrokenService)).toThrow(failure);
+  });
+
+  it('should expose the resolving scope through the execution context', function () {
+    class BrokenService {
+      @onConstruct(() => {
+        throw new Error('boom');
+      })
+      init() {}
+    }
+
+    let scope: IContainer | undefined;
+    const container = new Container().useModule(
+      new AddOnConstructHookModule((_ex, context) => {
+        scope = context.scope;
+      }),
+    );
+    const child = container.createScope();
+
+    child.resolve(BrokenService);
+
+    expect(scope).toBe(child);
+  });
 });
 
 ```

package/cjm/ExecutionContext.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjm/hooks/HooksRunner.js

@@ -10,10 +10,10 @@ class HooksRunner {
     constructor(key) {
         this.key = key;
     }
-    execute(target, { scope, createContext = HookContext_1.createHookContext, predicate = () => true }) {
+    execute(target, { scope, createContext = HookContext_1.createHookContext, mapContext = (context) => context, predicate = () => true, }) {
         const hooks = Array.from((0, hook_1.getHooks)(target, this.key).entries()).filter(([methodName]) => predicate(methodName));
         const runMethodHooks = (methodName, executions) => {
-            const context = createContext(target, scope, methodName);
+            const context = mapContext(createContext(target, scope, methodName));
             for (const execute of executions) {
                 const result = execute(context);
                 if (result instanceof Promise) {
@@ -25,10 +25,10 @@ class HooksRunner {
             runMethodHooks(methodName, executions.map(hook_1.toHookFn));
         }
     }
-    async executeAsync(target, { scope, createContext = HookContext_1.createHookContext, predicate = () => true, }) {
+    async executeAsync(target, { scope, createContext = HookContext_1.createHookContext, mapContext = (context) => context, predicate = () => true, }) {
         const hooks = Array.from((0, hook_1.getHooks)(target, this.key).entries()).filter(([methodName]) => predicate(methodName));
         const runMethodHooks = async (methodName, executions) => {
-            const context = createContext(target, scope, methodName);
+            const context = mapContext(createContext(target, scope, methodName));
             for (const execute of executions) {
                 await (0, promise_1.promisify)(execute(context));
             }

package/cjm/hooks/onConstruct.js

@@ -7,9 +7,21 @@ exports.onConstructHooksRunner = new HooksRunner_1.HooksRunner('onConstruct');
 const onConstruct = (...fns) => (0, hook_1.hook)('onConstruct', ...fns);
 exports.onConstruct = onConstruct;
 class AddOnConstructHookModule {
+    onException;
+    constructor(onException) {
+        this.onException = onException;
+    }
     applyTo(container) {
         container.addOnConstructHook((instance, scope) => {
-            exports.onConstructHooksRunner.execute(instance, { scope });
+            try {
+                exports.onConstructHooksRunner.execute(instance, { scope });
+            }
+            catch (ex) {
+                if (!this.onException) {
+                    throw ex;
+                }
+                this.onException(ex, { scope });
+            }
         });
     }
 }

package/esm/ExecutionContext.js

@@ -0,0 +1 @@
+export {};

package/esm/hooks/HooksRunner.js

@@ -7,10 +7,10 @@ export class HooksRunner {
     constructor(key) {
         this.key = key;
     }
-    execute(target, { scope, createContext = createHookContext, predicate = () => true }) {
+    execute(target, { scope, createContext = createHookContext, mapContext = (context) => context, predicate = () => true, }) {
         const hooks = Array.from(getHooks(target, this.key).entries()).filter(([methodName]) => predicate(methodName));
         const runMethodHooks = (methodName, executions) => {
-            const context = createContext(target, scope, methodName);
+            const context = mapContext(createContext(target, scope, methodName));
             for (const execute of executions) {
                 const result = execute(context);
                 if (result instanceof Promise) {
@@ -22,10 +22,10 @@ export class HooksRunner {
             runMethodHooks(methodName, executions.map(toHookFn));
         }
     }
-    async executeAsync(target, { scope, createContext = createHookContext, predicate = () => true, }) {
+    async executeAsync(target, { scope, createContext = createHookContext, mapContext = (context) => context, predicate = () => true, }) {
         const hooks = Array.from(getHooks(target, this.key).entries()).filter(([methodName]) => predicate(methodName));
         const runMethodHooks = async (methodName, executions) => {
-            const context = createContext(target, scope, methodName);
+            const context = mapContext(createContext(target, scope, methodName));
             for (const execute of executions) {
                 await promisify(execute(context));
             }

package/esm/hooks/onConstruct.js

@@ -3,9 +3,21 @@ import { HooksRunner } from './HooksRunner';
 export const onConstructHooksRunner = new HooksRunner('onConstruct');
 export const onConstruct = (...fns) => hook('onConstruct', ...fns);
 export class AddOnConstructHookModule {
+    onException;
+    constructor(onException) {
+        this.onException = onException;
+    }
     applyTo(container) {
         container.addOnConstructHook((instance, scope) => {
-            onConstructHooksRunner.execute(instance, { scope });
+            try {
+                onConstructHooksRunner.execute(instance, { scope });
+            }
+            catch (ex) {
+                if (!this.onException) {
+                    throw ex;
+                }
+                this.onException(ex, { scope });
+            }
         });
     }
 }

package/esm/index.js

@@ -24,7 +24,7 @@ export { CannonSingletonApplyTwiceError } from './errors/CannonSingletonApplyTwi
 export { getHooks, hook, hasHooks } from './hooks/hook';
 export { HookContext, createHookContextFactory, createHookContext } from './hooks/HookContext';
 export { injectProp } from './hooks/injectProp';
-export { onConstructHooksRunner, onConstruct, AddOnConstructHookModule } from './hooks/onConstruct';
+export { onConstructHooksRunner, onConstruct, AddOnConstructHookModule, } from './hooks/onConstruct';
 export { onDisposeHooksRunner, onDispose, AddOnDisposeHookModule } from './hooks/onDispose';
 export { HooksRunner } from './hooks/HooksRunner';
 // Tokens

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-ioc-container",
-  "version": "55.0.0",
+  "version": "55.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"

package/typings/ExecutionContext.d.ts

@@ -0,0 +1,4 @@
+import type { IContainer } from './container/IContainer';
+export interface ExecutionContext {
+    scope: IContainer;
+}

package/typings/hooks/HooksRunner.d.ts

@@ -1,17 +1,15 @@
-import { createHookContext, type CreateHookContext } from './HookContext';
+import { type CreateHookContext, type IHookContext } from './HookContext';
 import type { IContainer } from '../container/IContainer';
+export type MapHookContext = (context: IHookContext) => IHookContext;
 export type HooksRunnerContext = {
     scope: IContainer;
     createContext?: CreateHookContext;
+    mapContext?: MapHookContext;
     predicate?: (methodName: string) => boolean;
 };
 export declare class HooksRunner {
     private readonly key;
     constructor(key: string | symbol);
-    execute(target: object, { scope, createContext, predicate }: HooksRunnerContext): void;
-    executeAsync(target: object, { scope, createContext, predicate, }: {
-        scope: IContainer;
-        createContext?: typeof createHookContext;
-        predicate?: (methodName: string) => boolean;
-    }): Promise<void[]>;
+    execute(target: object, { scope, createContext, mapContext, predicate, }: HooksRunnerContext): void;
+    executeAsync(target: object, { scope, createContext, mapContext, predicate, }: HooksRunnerContext): Promise<void[]>;
 }

package/typings/hooks/onConstruct.d.ts

@@ -2,9 +2,13 @@ import { HookClass, HookFn } from './hook';
 import type { IContainer, IContainerModule } from '../container/IContainer';
 import { constructor, Instance } from '../utils/basic';
 import { HooksRunner } from './HooksRunner';
+import type { ExecutionContext } from '../ExecutionContext';
 export declare const onConstructHooksRunner: HooksRunner;
 export declare const onConstruct: (...fns: (HookFn | constructor<HookClass>)[]) => (target: object, propertyKey: string | symbol) => void;
 export type OnConstructHook = (instance: Instance, scope: IContainer) => void;
+export type OnExceptionHandler = (ex: unknown, context: ExecutionContext) => void;
 export declare class AddOnConstructHookModule implements IContainerModule {
+    private readonly onException?;
+    constructor(onException?: OnExceptionHandler | undefined);
     applyTo(container: IContainer): void;
 }

package/typings/index.d.ts

@@ -20,9 +20,9 @@ export { CannonSingletonApplyTwiceError } from './errors/CannonSingletonApplyTwi
 export { getHooks, hook, hasHooks, type HookFn, type HookClass, type InjectFn, type HooksOfClass } from './hooks/hook';
 export { HookContext, createHookContextFactory, createHookContext, type IHookContext } from './hooks/HookContext';
 export { injectProp } from './hooks/injectProp';
-export { onConstructHooksRunner, onConstruct, AddOnConstructHookModule } from './hooks/onConstruct';
+export { onConstructHooksRunner, onConstruct, AddOnConstructHookModule, type OnExceptionHandler, } from './hooks/onConstruct';
 export { onDisposeHooksRunner, onDispose, AddOnDisposeHookModule } from './hooks/onDispose';
-export { HooksRunner, type HooksRunnerContext } from './hooks/HooksRunner';
+export { HooksRunner, type HooksRunnerContext, type MapHookContext } from './hooks/HooksRunner';
 export { InjectionToken } from './token/InjectionToken';
 export { GroupAliasToken, toGroupAlias } from './token/GroupAliasToken';
 export { SingleAliasToken, toSingleAlias } from './token/SingleAliasToken';
@@ -39,6 +39,7 @@ export { throttle } from './utils/throttle';
 export { debounce } from './utils/debounce';
 export { shallowCache } from './utils/shallowCache';
 export { once } from './utils/once';
+export { type ExecutionContext } from './ExecutionContext';
 export { select } from './select';
 export { pipe, type MapFn } from './utils/fp';
 export { type constructor, type Instance, Is, resolveConstructor } from './utils/basic';