feat(microservices): errors thrown during eachMessage execution should be passed to kafkajs

.gitignore

@@ -5,6 +5,7 @@ node_modules/
 /.idea
 /.awcache
 /.vscode
+/.devcontainer
 *.code-workspace
 
 # bundle

integration/docker-compose.yml

@@ -17,13 +17,15 @@ services:
     restart: always
   mqtt:
     container_name: test-mqtt
-    image: toke/mosquitto
+    image: eclipse-mosquitto
+    volumes:
+      - ./mosquitto.conf:/mosquitto/config/mosquitto.conf
     ports:
       - "1883:1883"
       - "9001:9001"
     restart: always
   mysql:
-    image: mysql:8.0.27
+    image: mysql:8.0.28
     environment:
       MYSQL_ROOT_PASSWORD: root
       MYSQL_DATABASE: test

integration/injector/e2e/injector.spec.ts

@@ -1,14 +1,24 @@
 import { RuntimeException } from '@nestjs/core/errors/exceptions/runtime.exception';
+import { UnknownDependenciesException } from '@nestjs/core/errors/exceptions/unknown-dependencies.exception';
 import { UnknownExportException } from '@nestjs/core/errors/exceptions/unknown-export.exception';
 import { Test } from '@nestjs/testing';
 import { expect } from 'chai';
+import * as chai from 'chai';
+import * as chaiAsPromised from 'chai-as-promised';
 import {
   DYNAMIC_TOKEN,
   DYNAMIC_VALUE,
   NestDynamicModule,
 } from '../src/dynamic/dynamic.module';
 import { ExportsModule } from '../src/exports/exports.module';
 import { InjectModule } from '../src/inject/inject.module';
+import { InjectSameNameModule } from '../src/inject/inject-same-name.module';
+import {
+  SelfInjectionProviderModule,
+  SelfInjectionProviderCustomTokenModule,
+  SelfInjectionForwardProviderModule,
+} from '../src/self-injection/self-injection-provider.module';
+chai.use(chaiAsPromised);
 
 describe('Injector', () => {
   describe('when "providers" and "exports" properties are inconsistent', () => {
@@ -24,6 +34,16 @@ describe('Injector', () => {
     });
   });
 
+  describe("When class injects a provider with the same as class's name", () => {
+    it('should compile with success', async () => {
+      const builder = Test.createTestingModule({
+        imports: [InjectSameNameModule],
+      });
+
+      await expect(builder.compile()).to.eventually.be.fulfilled;
+    });
+  });
+
   describe('when Nest cannot resolve dependencies', () => {
     it(`should fail with "RuntimeException"`, async () => {
       try {
@@ -35,6 +55,42 @@ describe('Injector', () => {
         expect(err).to.be.instanceof(RuntimeException);
       }
     });
+
+    describe('due to self-injection providers', () => {
+      it('should fail with "UnknownDependenciesException" due to self-injection via same class reference', async () => {
+        const builder = Test.createTestingModule({
+          imports: [SelfInjectionProviderModule],
+        });
+
+        await expect(
+          builder.compile(),
+        ).to.eventually.be.rejected.and.be.an.instanceOf(
+          UnknownDependenciesException,
+        );
+      });
+      it('should fail with "UnknownDependenciesException" due to self-injection via forwardRef to the same class reference', async () => {
+        const builder = Test.createTestingModule({
+          imports: [SelfInjectionForwardProviderModule],
+        });
+
+        await expect(
+          builder.compile(),
+        ).to.eventually.be.rejected.and.be.an.instanceOf(
+          UnknownDependenciesException,
+        );
+      });
+      it('should fail with "UnknownDependenciesException" due to self-injection via custom provider', async () => {
+        const builder = Test.createTestingModule({
+          imports: [SelfInjectionProviderCustomTokenModule],
+        });
+
+        await expect(
+          builder.compile(),
+        ).to.eventually.be.rejected.and.be.an.instanceOf(
+          UnknownDependenciesException,
+        );
+      });
+    });
   });
 
   describe('when dynamic module', () => {

integration/injector/e2e/optional-factory-provider-dep.spec.ts

@@ -0,0 +1,96 @@
+import { UnknownDependenciesException } from '@nestjs/core/errors/exceptions/unknown-dependencies.exception';
+import { Test } from '@nestjs/testing';
+import { expect } from 'chai';
+
+describe('Optional factory provider deps', () => {
+  describe('when dependency is optional', () => {
+    describe('and it is available', () => {
+      it('then it should be injected into the factory function', async () => {
+        const defaultValue = 'DEFAULT_VALUE';
+        const moduleRef = await Test.createTestingModule({
+          providers: [
+            {
+              provide: 'FACTORY',
+              useFactory: dep => dep ?? defaultValue,
+              inject: [{ token: 'MISSING_DEP', optional: true }],
+            },
+            { provide: 'MISSING_DEP', useValue: 'OPTIONAL_DEP_VALUE' },
+          ],
+        }).compile();
+
+        const factoryProvider = moduleRef.get('FACTORY');
+        expect(factoryProvider).to.equal('OPTIONAL_DEP_VALUE');
+      });
+    });
+    describe('otherwise', () => {
+      it('"undefined" should be injected into the factory function', async () => {
+        const defaultValue = 'DEFAULT_VALUE';
+        const moduleRef = await Test.createTestingModule({
+          providers: [
+            {
+              provide: 'FACTORY',
+              useFactory: dep => dep ?? defaultValue,
+              inject: [{ token: 'MISSING_DEP', optional: true }],
+            },
+          ],
+        }).compile();
+
+        const factoryProvider = moduleRef.get('FACTORY');
+        expect(factoryProvider).to.equal(defaultValue);
+      });
+    });
+  });
+  describe('otherwise', () => {
+    describe('and dependency is not registered', () => {
+      it('should error out', async () => {
+        try {
+          const builder = Test.createTestingModule({
+            providers: [
+              {
+                provide: 'FACTORY',
+                useFactory: () => 'RETURNED_VALUE',
+                inject: ['MISSING_DEP'],
+              },
+            ],
+          });
+          await builder.compile();
+        } catch (err) {
+          expect(err).to.be.instanceOf(UnknownDependenciesException);
+        }
+      });
+    });
+  });
+  describe('and dependency is registered but it cannot be instantiated', () => {
+    it('should error out', async () => {
+      try {
+        const builder = Test.createTestingModule({
+          providers: [
+            {
+              provide: 'POSSIBLY_MISSING_DEP',
+              useFactory: () => null,
+              inject: ['MISSING_DEP'],
+            },
+            {
+              provide: 'FACTORY',
+              useFactory: () => 'RETURNED_VALUE',
+              inject: [{ token: 'POSSIBLY_MISSING_DEP', optional: false }],
+            },
+          ],
+        });
+        await builder.compile();
+      } catch (err) {
+        expect(err).to.be.instanceOf(UnknownDependenciesException);
+        expect(err.message).to
+          .equal(`Nest can't resolve dependencies of the POSSIBLY_MISSING_DEP (?). Please make sure that the argument MISSING_DEP at index [0] is available in the RootTestModule context.
+
+Potential solutions:
+- If MISSING_DEP is a provider, is it part of the current RootTestModule?
+- If MISSING_DEP is exported from a separate @Module, is that module imported within RootTestModule?
+  @Module({
+    imports: [ /* the Module containing MISSING_DEP */ ]
+  })
+`);
+      }
+    });
+  });
+});

integration/injector/src/inject/inject-same-name.module.ts

@@ -0,0 +1,16 @@
+import { Module, Injectable, Inject } from '@nestjs/common';
+
+@Injectable()
+class CoreService {
+  constructor(@Inject(CoreService.name) private readonly coreService: any) {}
+}
+
+@Module({
+  providers: [
+    {
+      provide: CoreService.name,
+      useValue: 'anything',
+    },
+  ],
+})
+export class InjectSameNameModule {}

integration/injector/src/self-injection/self-injection-provider.module.ts

@@ -0,0 +1,40 @@
+import { Module, Injectable, Inject, forwardRef } from '@nestjs/common';
+
+@Injectable()
+class ServiceInjectingItself {
+  constructor(private readonly coreService: ServiceInjectingItself) {}
+}
+
+@Injectable()
+class ServiceInjectingItselfForwared {
+  constructor(
+    @Inject(forwardRef(() => ServiceInjectingItself))
+    private readonly coreService: ServiceInjectingItself,
+  ) {}
+}
+
+@Injectable()
+class ServiceInjectingItselfViaCustomToken {
+  constructor(@Inject('AnotherToken') private readonly coreService: any) {}
+}
+
+@Module({
+  providers: [ServiceInjectingItself],
+})
+export class SelfInjectionProviderModule {}
+
+@Module({
+  providers: [ServiceInjectingItselfForwared],
+})
+export class SelfInjectionForwardProviderModule {}
+
+@Module({
+  providers: [
+    ServiceInjectingItselfViaCustomToken,
+    {
+      provide: 'AnotherToken',
+      useClass: ServiceInjectingItselfViaCustomToken,
+    },
+  ],
+})
+export class SelfInjectionProviderCustomTokenModule {}