feat(core): call hooks by components hierarchy level (order)

integration/hooks/e2e/before-app-shutdown.spec.ts

@@ -58,4 +58,48 @@ describe('BeforeApplicationShutdown', () => {
       bb.beforeApplicationShutdown,
     );
   });
+
+  it('should sort components within a single module by injection hierarchy - ASC order', async () => {
+    @Injectable()
+    class A implements BeforeApplicationShutdown {
+      beforeApplicationShutdown = Sinon.spy();
+    }
+
+    @Injectable()
+    class AHost implements BeforeApplicationShutdown {
+      constructor(private a: A) {}
+      beforeApplicationShutdown = Sinon.spy();
+    }
+
+    @Injectable()
+    class Composition implements BeforeApplicationShutdown {
+      constructor(
+        private a: A,
+        private host: AHost,
+      ) {}
+      beforeApplicationShutdown = Sinon.spy();
+    }
+
+    @Module({
+      providers: [AHost, A, Composition],
+    })
+    class AModule {}
+
+    const module = await Test.createTestingModule({
+      imports: [AModule],
+    }).compile();
+
+    const app = module.createNestApplication();
+    await app.init();
+    await app.close();
+
+    const child = module.get(A);
+    const parent = module.get(AHost);
+    const composition = module.get(Composition);
+    Sinon.assert.callOrder(
+      composition.beforeApplicationShutdown,
+      parent.beforeApplicationShutdown,
+      child.beforeApplicationShutdown,
+    );
+  });
 });

integration/hooks/e2e/on-app-boostrap.spec.ts

@@ -82,4 +82,48 @@ describe('OnApplicationBootstrap', () => {
     const instance = module.get(AA);
     expect(instance.field).to.equal('b-field_a-field');
   });
+
+  it('should sort components within a single module by injection hierarchy - DESC order', async () => {
+    @Injectable()
+    class A implements OnApplicationBootstrap {
+      onApplicationBootstrap = Sinon.spy();
+    }
+
+    @Injectable()
+    class AHost implements OnApplicationBootstrap {
+      constructor(private a: A) {}
+      onApplicationBootstrap = Sinon.spy();
+    }
+
+    @Injectable()
+    class Composition implements OnApplicationBootstrap {
+      constructor(
+        private a: A,
+        private host: AHost,
+      ) {}
+      onApplicationBootstrap = Sinon.spy();
+    }
+
+    @Module({
+      providers: [AHost, A, Composition],
+    })
+    class AModule {}
+
+    const module = await Test.createTestingModule({
+      imports: [AModule],
+    }).compile();
+
+    const app = module.createNestApplication();
+    await app.init();
+    await app.close();
+
+    const child = module.get(A);
+    const parent = module.get(AHost);
+    const composition = module.get(Composition);
+    Sinon.assert.callOrder(
+      child.onApplicationBootstrap,
+      parent.onApplicationBootstrap,
+      composition.onApplicationBootstrap,
+    );
+  });
 });

integration/hooks/e2e/on-app-shutdown.spec.ts

@@ -55,4 +55,48 @@ describe('OnApplicationShutdown', () => {
     const bb = module.get(BB);
     Sinon.assert.callOrder(aa.onApplicationShutdown, bb.onApplicationShutdown);
   });
+
+  it('should sort components within a single module by injection hierarchy - ASC order', async () => {
+    @Injectable()
+    class A implements OnApplicationShutdown {
+      onApplicationShutdown = Sinon.spy();
+    }
+
+    @Injectable()
+    class AHost implements OnApplicationShutdown {
+      constructor(private a: A) {}
+      onApplicationShutdown = Sinon.spy();
+    }
+
+    @Injectable()
+    class Composition implements OnApplicationShutdown {
+      constructor(
+        private a: A,
+        private host: AHost,
+      ) {}
+      onApplicationShutdown = Sinon.spy();
+    }
+
+    @Module({
+      providers: [AHost, A, Composition],
+    })
+    class AModule {}
+
+    const module = await Test.createTestingModule({
+      imports: [AModule],
+    }).compile();
+
+    const app = module.createNestApplication();
+    await app.init();
+    await app.close();
+
+    const child = module.get(A);
+    const parent = module.get(AHost);
+    const composition = module.get(Composition);
+    Sinon.assert.callOrder(
+      composition.onApplicationShutdown,
+      parent.onApplicationShutdown,
+      child.onApplicationShutdown,
+    );
+  });
 });

integration/hooks/e2e/on-module-destroy.spec.ts

@@ -76,4 +76,48 @@ describe('OnModuleDestroy', () => {
     const bb = module.get(BB);
     Sinon.assert.callOrder(aa.onModuleDestroy, bb.onModuleDestroy);
   });
+
+  it('should sort components within a single module by injection hierarchy - ASC order', async () => {
+    @Injectable()
+    class A implements OnModuleDestroy {
+      onModuleDestroy = Sinon.spy();
+    }
+
+    @Injectable()
+    class AHost implements OnModuleDestroy {
+      constructor(private a: A) {}
+      onModuleDestroy = Sinon.spy();
+    }
+
+    @Injectable()
+    class Composition implements OnModuleDestroy {
+      constructor(
+        private a: A,
+        private host: AHost,
+      ) {}
+      onModuleDestroy = Sinon.spy();
+    }
+
+    @Module({
+      providers: [AHost, A, Composition],
+    })
+    class AModule {}
+
+    const module = await Test.createTestingModule({
+      imports: [AModule],
+    }).compile();
+
+    const app = module.createNestApplication();
+    await app.init();
+    await app.close();
+
+    const child = module.get(A);
+    const parent = module.get(AHost);
+    const composition = module.get(Composition);
+    Sinon.assert.callOrder(
+      composition.onModuleDestroy,
+      parent.onModuleDestroy,
+      child.onModuleDestroy,
+    );
+  });
 });

integration/hooks/e2e/on-module-init.spec.ts

@@ -111,4 +111,48 @@ describe('OnModuleInit', () => {
     const instance = module.get(AA);
     expect(instance.field).to.equal('c-field_b-field_a-field');
   });
+
+  it('should sort components within a single module by injection hierarchy - DESC order', async () => {
+    @Injectable()
+    class A implements OnModuleInit {
+      onModuleInit = Sinon.spy();
+    }
+
+    @Injectable()
+    class AHost implements OnModuleInit {
+      constructor(private a: A) {}
+      onModuleInit = Sinon.spy();
+    }
+
+    @Injectable()
+    class Composition implements OnModuleInit {
+      constructor(
+        private a: A,
+        private host: AHost,
+      ) {}
+      onModuleInit = Sinon.spy();
+    }
+
+    @Module({
+      providers: [AHost, A, Composition],
+    })
+    class AModule {}
+
+    const module = await Test.createTestingModule({
+      imports: [AModule],
+    }).compile();
+
+    const app = module.createNestApplication();
+    await app.init();
+    await app.close();
+
+    const child = module.get(A);
+    const parent = module.get(AHost);
+    const composition = module.get(Composition);
+    Sinon.assert.callOrder(
+      child.onModuleInit,
+      parent.onModuleInit,
+      composition.onModuleInit,
+    );
+  });
 });

packages/core/hooks/before-app-shutdown.hook.ts

@@ -1,12 +1,9 @@
 import { BeforeApplicationShutdown } from '@nestjs/common';
 import { isFunction, isNil } from '@nestjs/common/utils/shared.utils';
 import { iterate } from 'iterare';
-import {
-  getNonTransientInstances,
-  getTransientInstances,
-} from '../injector/helpers/transient-instances';
-import { InstanceWrapper } from '../injector/instance-wrapper';
 import { Module } from '../injector/module';
+import { getInstancesGroupedByHierarchyLevel } from './utils/get-instances-grouped-by-hierarchy-level';
+import { getSortedHierarchyLevels } from './utils/get-sorted-hierarchy-levels';
 
 /**
  * Checks if the given instance has the `beforeApplicationShutdown` function
@@ -24,10 +21,7 @@ function hasBeforeApplicationShutdownHook(
 /**
  * Calls the given instances
  */
-function callOperator(
-  instances: InstanceWrapper[],
-  signal?: string,
-): Promise<any>[] {
+function callOperator(instances: unknown[], signal?: string): Promise<any>[] {
   return iterate(instances)
     .filter(instance => !isNil(instance))
     .filter(hasBeforeApplicationShutdownHook)
@@ -43,27 +37,26 @@ function callOperator(
  * Calls the `beforeApplicationShutdown` function on the module and its children
  * (providers / controllers).
  *
- * @param module The module which will be initialized
+ * @param moduleRef The module which will be initialized
  * @param signal The signal which caused the shutdown
  */
 export async function callBeforeAppShutdownHook(
-  module: Module,
+  moduleRef: Module,
   signal?: string,
 ): Promise<void> {
-  const providers = module.getNonAliasProviders();
+  const providers = moduleRef.getNonAliasProviders();
   const [_, moduleClassHost] = providers.shift()!;
-  const instances = [
-    ...module.controllers,
-    ...providers,
-    ...module.injectables,
-    ...module.middlewares,
-  ];
-
-  const nonTransientInstances = getNonTransientInstances(instances);
-  await Promise.all(callOperator(nonTransientInstances, signal));
-  const transientInstances = getTransientInstances(instances);
-  await Promise.all(callOperator(transientInstances, signal));
+  const groupedInstances = getInstancesGroupedByHierarchyLevel(
+    moduleRef.controllers,
+    moduleRef.injectables,
+    moduleRef.middlewares,
+    providers,
+  );
 
+  const levels = getSortedHierarchyLevels(groupedInstances, 'DESC');
+  for (const level of levels) {
+    await Promise.all(callOperator(groupedInstances.get(level)!, signal));
+  }
   const moduleClassInstance = moduleClassHost.instance;
   if (
     moduleClassInstance &&

packages/core/hooks/on-app-bootstrap.hook.ts

@@ -1,12 +1,9 @@
 import { OnApplicationBootstrap } from '@nestjs/common';
 import { isFunction, isNil } from '@nestjs/common/utils/shared.utils';
 import { iterate } from 'iterare';
-import {
-  getNonTransientInstances,
-  getTransientInstances,
-} from '../injector/helpers/transient-instances';
-import { InstanceWrapper } from '../injector/instance-wrapper';
 import { Module } from '../injector/module';
+import { getInstancesGroupedByHierarchyLevel } from './utils/get-instances-grouped-by-hierarchy-level';
+import { getSortedHierarchyLevels } from './utils/get-sorted-hierarchy-levels';
 
 /**
  * Checks if the given instance has the `onApplicationBootstrap` function
@@ -24,7 +21,7 @@ function hasOnAppBootstrapHook(
 /**
  * Calls the given instances
  */
-function callOperator(instances: InstanceWrapper[]): Promise<any>[] {
+function callOperator(instances: unknown[]): Promise<any>[] {
   return iterate(instances)
     .filter(instance => !isNil(instance))
     .filter(hasOnAppBootstrapHook)
@@ -38,24 +35,24 @@ function callOperator(instances: InstanceWrapper[]): Promise<any>[] {
  * Calls the `onApplicationBootstrap` function on the module and its children
  * (providers / controllers).
  *
- * @param module The module which will be initialized
+ * @param moduleRef The module which will be initialized
  */
-export async function callModuleBootstrapHook(module: Module): Promise<any> {
-  const providers = module.getNonAliasProviders();
+export async function callModuleBootstrapHook(moduleRef: Module): Promise<any> {
+  const providers = moduleRef.getNonAliasProviders();
   // Module (class) instance is the first element of the providers array
   // Lifecycle hook has to be called once all classes are properly initialized
   const [_, moduleClassHost] = providers.shift()!;
-  const instances = [
-    ...module.controllers,
-    ...providers,
-    ...module.injectables,
-    ...module.middlewares,
-  ];
+  const groupedInstances = getInstancesGroupedByHierarchyLevel(
+    moduleRef.controllers,
+    moduleRef.injectables,
+    moduleRef.middlewares,
+    providers,
+  );
 
-  const nonTransientInstances = getNonTransientInstances(instances);
-  await Promise.all(callOperator(nonTransientInstances));
-  const transientInstances = getTransientInstances(instances);
-  await Promise.all(callOperator(transientInstances));
+  const levels = getSortedHierarchyLevels(groupedInstances);
+  for (const level of levels) {
+    await Promise.all(callOperator(groupedInstances.get(level)!));
+  }
 
   // Call the instance itself
   const moduleClassInstance = moduleClassHost.instance;