resolve conflicts

Author: kamilmysliwiec

integration/hello-world/e2e/middleware-execute-order.spec.ts

@@ -0,0 +1,60 @@
+import { INestApplication, MiddlewareConsumer, Module } from '@nestjs/common';
+import { Test } from '@nestjs/testing';
+import * as request from 'supertest';
+
+const RETURN_VALUE_A = 'test_A';
+const RETURN_VALUE_B = 'test_B';
+
+@Module({
+  imports: [],
+})
+class TestAModule {
+  configure(consumer: MiddlewareConsumer) {
+    consumer
+      .apply((req, res, next) => {
+        res.send(RETURN_VALUE_A);
+      })
+      .forRoutes('hello');
+  }
+}
+
+@Module({
+  imports: [TestAModule],
+})
+class TestBModule {
+  configure(consumer: MiddlewareConsumer) {
+    consumer
+      .apply((req, res, next) => {
+        res.send(RETURN_VALUE_B);
+      })
+      .forRoutes('hello');
+  }
+}
+
+@Module({
+  imports: [TestBModule],
+})
+class TestModule {
+}
+
+describe('Middleware Execute Order', () => {
+  let app: INestApplication;
+
+  beforeEach(async () => {
+    app = (await Test.createTestingModule({
+      imports: [TestModule],
+    }).compile()).createNestApplication();
+
+    await app.init();
+  });
+
+  it(`Execute middleware of dependent modules first `, () => {
+    return request(app.getHttpServer())
+      .get('/hello')
+      .expect(200, RETURN_VALUE_A);
+  });
+
+  afterEach(async () => {
+    await app.close();
+  });
+});

packages/core/injector/module.ts

@@ -44,6 +44,7 @@ export class Module {
     InstanceWrapper<Controller>
   >();
   private readonly _exports = new Set<string | symbol>();
+  private _distance: number = 0;
 
   constructor(
     private readonly _metatype: Type<any>,
@@ -115,6 +116,17 @@ export class Module {
     return this._metatype;
   }
 
+  get distance(): number {
+    return this._distance;
+  }
+
+  set distance(distance: number) {
+    this._distance = distance;
+    Array.from(this._imports)
+      .filter(module => module && !module.imports.has(this))
+      .forEach(module => (module.distance = distance + 1));
+  }
+
   public addCoreProviders(container: NestContainer) {
     this.addModuleAsProvider();
     this.addModuleRef();
@@ -399,8 +411,12 @@ export class Module {
     );
   }
 
-  public addRelatedModule(module: any) {
+  public addRelatedModule(module: Module) {
     this._imports.add(module);
+    module.distance =
+      this._distance + 1 > module._distance
+        ? this._distance + 1
+        : module._distance;
   }
 
   public replace(toReplace: string | symbol | Type<any>, options: any) {

packages/core/middleware/middleware-module.ts

@@ -114,11 +114,18 @@ export class MiddlewareModule {
         );
       });
 
-    const configEntries = [...configs.entries()];
+    const entriesSortedByDistance = [...configs.entries()].sort(
+      ([moduleA], [moduleB]) => {
+        return (
+          this.container.getModuleByKey(moduleB).distance -
+          this.container.getModuleByKey(moduleA).distance
+        );
+      },
+    );
     const registerModuleConfigs = async ([module, moduleConfigs]) => {
       await Promise.all(registerAllConfigs(module, [...moduleConfigs]));
     };
-    await Promise.all(configEntries.map(registerModuleConfigs));
+    await Promise.all(entriesSortedByDistance.map(registerModuleConfigs));
   }
 
   public async registerMiddlewareConfig(

packages/core/test/injector/module.spec.ts

@@ -481,4 +481,39 @@ describe('Module', () => {
       });
     });
   });
+
+  describe('getter "distance"', () => {
+    @ModuleDecorator({})
+    class ModuleA {}
+
+    @ModuleDecorator({})
+    class ModuleB {}
+
+    @ModuleDecorator({})
+    class ModuleC {}
+
+    let moduleA, moduleB, moduleC;
+    beforeEach(() => {
+      moduleA = new Module(ModuleA as any, [], container);
+      moduleB = new Module(ModuleB as any, [], container);
+      moduleC = new Module(ModuleC as any, [], container);
+    });
+
+    it('should get "distance" correct', () => {
+      moduleA.addRelatedModule(moduleB);
+      moduleC.addRelatedModule(moduleB);
+      moduleA.addRelatedModule(moduleC);
+
+      expect(moduleA.distance).to.be.equal(0);
+      expect(moduleB.distance).to.be.equal(2);
+      expect(moduleC.distance).to.be.equal(1);
+    });
+
+    it('should don`t throw exception when circular dependency', () => {
+      expect(() => {
+        moduleA.addRelatedModule(moduleB);
+        moduleB.addRelatedModule(moduleA);
+      }).to.not.throw;
+    });
+  });
 });