feat(di): allow Factory of Custom provider to have hooks

docs/docs/custom-providers.md

@@ -37,6 +37,10 @@ In order to inject a custom provider, we use the @@Inject@@ decorator. This deco
 
 <<< @/docs/snippets/providers/custom-provider-use-value-usage.ts
 
+::: tip
+Since v6.110.0, factory and custom provider can register his own [hooks](/docs/hooks.md)!
+:::
+
 ## Use Async Factory
 
 The `useAsyncFactory` is a way of creating asynchronous providers dynamically.

docs/docs/hooks.md

@@ -40,3 +40,28 @@ export class MyModule implements BeforeInit {
 ::: tip Note
 Database connection can be performed with Asynchronous Provider since v5.26. See [custom providers](/docs/custom-providers.md)
 :::
+
+Since v6.110.0, it's also possible to register hooks on custom provider:
+
+```typescript
+import {Configuration, registerProvider} from "@tsed/di";
+import {DatabaseConnection} from "connection-lib";
+
+export const CONNECTION = Symbol.for("CONNECTION");
+
+registerProvider<DatabaseConnection>({
+  provide: CONNECTION,
+  deps: [Configuration],
+  useFactory(configuration: Configuration) {
+    const options = configuration.get<any>("myOptions");
+
+    return new DatabaseConnection(options);
+  },
+  hooks: {
+    $onDestroy(connection) {
+      // called when provider instance is destroyed
+      return connection.close();
+    }
+  }
+});
+```

docs/docs/snippets/providers/custom-provider-use-factory-declaration.ts

@@ -3,12 +3,17 @@ import {DatabaseConnection} from "connection-lib";
 
 export const CONNECTION = Symbol.for("CONNECTION");
 
-registerProvider({
+registerProvider<DatabaseConnection>({
   provide: CONNECTION,
   deps: [Configuration],
   useFactory(configuration: Configuration) {
     const options = configuration.get<any>("myOptions");
 
     return new DatabaseConnection(options);
+  },
+  hooks: {
+    $onDestroy(connection) {
+      return connection.close();
+    }
   }
 });

docs/docs/snippets/providers/custom-provider-use-value-declaration.ts

@@ -5,5 +5,10 @@ export const CONNECTION = Symbol.for("CONNECTION");
 
 registerProvider({
   provide: CONNECTION,
-  useValue: connection
+  useValue: connection,
+  hooks: {
+    $onDestroy(connection: any) {
+      return connection.close();
+    }
+  }
 });

packages/core/src/utils/objects/methodsOf.ts

@@ -1,12 +1,13 @@
 import {classOf} from "./classOf";
 import {ancestorsOf} from "./ancestorsOf";
 import {prototypeOf} from "./prototypeOf";
+import {Type} from "../../domain/Type";
 
 /**
  * Return all methods for a given class.
  * @param target
  */
-export function methodsOf(target: any) {
+export function methodsOf(target: any): {target: Type; propertyKey: string}[] {
   const methods = new Map();
   target = classOf(target);
 

packages/di/src/domain/Provider.ts

@@ -15,6 +15,7 @@ export class Provider<T = any> implements ProviderOpts<T> {
   public useFactory: Function;
   public useAsyncFactory: Function;
   public useValue: any;
+  public hooks?: Record<string, (instance: T, ...args: any[]) => Promise<void> | void>;
   private _useClass: Type<T>;
   private _provide: TokenProvider;
   private _store: Store;

packages/di/src/interfaces/ProviderOpts.ts

@@ -46,6 +46,10 @@ export interface ProviderOpts<T = any> {
    */
   resolvers?: DIResolver[];
 
+  /**
+   * hooks to intercept custom events
+   */
+  hooks?: Record<string, (instance: T, ...args: any[]) => Promise<void> | void>;
   /**
    *
    */

packages/di/src/registries/ProviderRegistry.ts

@@ -13,7 +13,7 @@ GlobalProviders.createRegistry(ProviderType.CONTROLLER, Provider);
  * Register a provider configuration.
  * @param {ProviderOpts<any>} provider
  */
-export function registerProvider(provider: Partial<ProviderOpts>): void {
+export function registerProvider<Type = any>(provider: Partial<ProviderOpts<Type>>): void {
   if (!provider.provide) {
     throw new Error("Provider.provide is required");
   }

packages/di/src/services/InjectorService.ts

@@ -646,6 +646,12 @@ export class InjectorService extends Container {
       this.bindInjectableProperties(instance, locals, options);
     }
 
+    if (instance && provider.hooks) {
+      Object.entries(provider.hooks).forEach(([key, cb]) => {
+        instance[key] = (...args: any[]) => cb(instance, ...args);
+      });
+    }
+
     return instance;
   }
 

packages/di/test/integration/async-factory.spec.ts

@@ -9,7 +9,15 @@ describe("DI", () => {
     registerProvider({
       provide: ASYNC_FACTORY,
       useAsyncFactory() {
-        return Promise.resolve({connection: true});
+        return Promise.resolve({
+          connection: true,
+          close() {}
+        });
+      },
+      hooks: {
+        $onDestroy(instance: any) {
+          return instance.close();
+        }
       }
     });
 
@@ -38,7 +46,7 @@ describe("DI", () => {
       await injector.load(container);
 
       expect(isPromise(server.asyncFactory)).to.eq(false);
-      expect(server.asyncFactory).to.deep.eq({connection: true});
+      expect(server.asyncFactory.connection).to.deep.eq(true);
     });
   });
 });