ts-ioc-container 55.1.0 → 55.3.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);
+  });
 });
 
 ```
@@ -2601,6 +2668,26 @@ describe('inject property', () => {
     expect(viewModel.greetingService).toBe('Hello');
     expect(viewModel.display()).toBe('Hello User');
   });
+
+  it('should read the applied instance property via getProperty', () => {
+    const onInitHookRunner = new HooksRunner('onInit');
+
+    let injectedValue: unknown;
+
+    class UserViewModel {
+      @hook('onInit', injectProp('GreetingService'), (context) => {
+        injectedValue = context.getProperty();
+      })
+      greetingService!: string;
+    }
+
+    const container = new Container().addRegistration(Registration.fromValue('Hello').bindToKey('GreetingService'));
+
+    const viewModel = container.resolve(UserViewModel);
+    onInitHookRunner.execute(viewModel, { scope: container });
+
+    expect(injectedValue).toBe('Hello');
+  });
 });
 
 ```

package/cjm/ExecutionContext.js

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

package/cjm/hooks/HookContext.js

@@ -26,6 +26,10 @@ class HookContext {
         // @ts-ignore
         this.instance[this.methodName] = fn.resolve(this.scope);
     }
+    getProperty() {
+        // @ts-ignore
+        return this.instance[this.methodName];
+    }
     setInitialArgs(...args) {
         this.initialArgs = args;
         return this;

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/HookContext.js

@@ -23,6 +23,10 @@ export class HookContext {
         // @ts-ignore
         this.instance[this.methodName] = fn.resolve(this.scope);
     }
+    getProperty() {
+        // @ts-ignore
+        return this.instance[this.methodName];
+    }
     setInitialArgs(...args) {
         this.initialArgs = args;
         return this;

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.1.0",
+  "version": "55.3.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/HookContext.d.ts

@@ -9,6 +9,7 @@ export interface IHookContext {
         args?: unknown[];
     }): unknown;
     setProperty(fn: InjectionToken): void;
+    getProperty(): unknown;
     setInitialArgs(...args: unknown[]): this;
 }
 export declare class HookContext implements IHookContext {
@@ -22,6 +23,7 @@ export declare class HookContext implements IHookContext {
         args?: unknown[];
     }): unknown;
     setProperty(fn: InjectionToken): void;
+    getProperty(): unknown;
     setInitialArgs(...args: unknown[]): this;
 }
 export type CreateHookContext = (Target: object, scope: IContainer, methodName?: string) => IHookContext;

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,7 +20,7 @@ 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, type MapHookContext } from './hooks/HooksRunner';
 export { InjectionToken } from './token/InjectionToken';
@@ -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';