Merge branch 'krugi-feature/grpc-server-package-definition'

packages/microservices/client/client-grpc.ts

@@ -10,6 +10,7 @@ import { ClientGrpc, GrpcOptions } from '../interfaces';
 import { ClientProxy } from './client-proxy';
 import { GRPC_CANCELLED } from './constants';
 import { ChannelOptions } from '../external/grpc-options.interface';
+import { getGrpcPackageDefinition } from '../helpers';
 
 let grpcPackage: any = {};
 let grpcProtoLoaderPackage: any = {};
@@ -300,16 +301,11 @@ export class ClientGrpcProxy extends ClientProxy implements ClientGrpc {
 
   public loadProto(): any {
     try {
-      const file = this.getOptionsProp(this.options, 'protoPath');
-      const loader = this.getOptionsProp(this.options, 'loader');
-
-      const packageDefinition =
-        this.getOptionsProp(this.options, 'packageDefinition') ||
-        grpcProtoLoaderPackage.loadSync(file, loader);
-
-      const packageObject =
-        grpcPackage.loadPackageDefinition(packageDefinition);
-      return packageObject;
+      const packageDefinition = getGrpcPackageDefinition(
+        this.options,
+        grpcProtoLoaderPackage,
+      );
+      return grpcPackage.loadPackageDefinition(packageDefinition);
     } catch (err) {
       const invalidProtoError = new InvalidProtoDefinitionException(err.path);
       const message =

packages/microservices/errors/invalid-grpc-package-definition-missing-package-definition.exception.ts

@@ -0,0 +1,9 @@
+import { RuntimeException } from '@nestjs/core/errors/exceptions/runtime.exception';
+
+export class InvalidGrpcPackageDefinitionMissingPackageDefinitionException extends RuntimeException {
+  constructor() {
+    super(
+      `Invalid gRPC configuration. protoPath or packageDefinition must be defined.`,
+    );
+  }
+}

packages/microservices/errors/invalid-grpc-package-definition-mutex.exception.ts

@@ -0,0 +1,9 @@
+import { RuntimeException } from '@nestjs/core/errors/exceptions/runtime.exception';
+
+export class InvalidGrpcPackageDefinitionMutexException extends RuntimeException {
+  constructor() {
+    super(
+      `Invalid gRPC configuration. Both protoPath and packageDefinition cannot be defined at the same time.`,
+    );
+  }
+}

packages/microservices/helpers/grpc-helpers.ts

@@ -0,0 +1,23 @@
+import { InvalidGrpcPackageDefinitionMissingPackageDefinitionException } from '../errors/invalid-grpc-package-definition-missing-package-definition.exception';
+import { InvalidGrpcPackageDefinitionMutexException } from '../errors/invalid-grpc-package-definition-mutex.exception';
+import { GrpcOptions } from '../interfaces';
+
+export function getGrpcPackageDefinition(
+  options: GrpcOptions['options'],
+  grpcProtoLoaderPackage: any,
+) {
+  const file = options['protoPath'];
+  const packageDefinition = options['packageDefinition'];
+
+  if (file && packageDefinition) {
+    throw new InvalidGrpcPackageDefinitionMutexException();
+  }
+  if (!file && !packageDefinition) {
+    throw new InvalidGrpcPackageDefinitionMissingPackageDefinitionException();
+  }
+
+  return (
+    packageDefinition ||
+    grpcProtoLoaderPackage.loadSync(file, options['loader'])
+  );
+}

packages/microservices/helpers/index.ts

@@ -3,3 +3,4 @@ export * from './kafka-logger';
 export * from './kafka-parser';
 export * from './kafka-reply-partition-assigner';
 export * from './tcp-socket';
+export * from './grpc-helpers';

packages/microservices/interfaces/microservice-configuration.interface.ts

@@ -61,7 +61,7 @@ export interface GrpcOptions {
     };
     channelOptions?: ChannelOptions;
     credentials?: any;
-    protoPath: string | string[];
+    protoPath?: string | string[];
     package: string | string[];
     protoLoader?: string;
     packageDefinition?: any;

packages/microservices/server/server-grpc.ts

@@ -23,6 +23,7 @@ import { Transport } from '../enums';
 import { InvalidGrpcPackageException } from '../errors/invalid-grpc-package.exception';
 import { InvalidProtoDefinitionException } from '../errors/invalid-proto-definition.exception';
 import { ChannelOptions } from '../external/grpc-options.interface';
+import { getGrpcPackageDefinition } from '../helpers';
 import { CustomTransportStrategy, MessageHandler } from '../interfaces';
 import { GrpcOptions } from '../interfaces/microservice-configuration.interface';
 import { Server } from './server';
@@ -501,20 +502,18 @@ export class ServerGrpc extends Server implements CustomTransportStrategy {
 
   public loadProto(): any {
     try {
-      const file = this.getOptionsProp(this.options, 'protoPath');
-      const loader = this.getOptionsProp(this.options, 'loader');
-
-      const packageDefinition = grpcProtoLoaderPackage.loadSync(file, loader);
-      const packageObject =
-        grpcPackage.loadPackageDefinition(packageDefinition);
-      return packageObject;
+      const packageDefinition = getGrpcPackageDefinition(
+        this.options,
+        grpcProtoLoaderPackage,
+      );
+      return grpcPackage.loadPackageDefinition(packageDefinition);
     } catch (err) {
       const invalidProtoError = new InvalidProtoDefinitionException(err.path);
       const message =
         err && err.message ? err.message : invalidProtoError.message;
 
       this.logger.error(message, invalidProtoError.stack);
-      throw err;
+      throw invalidProtoError;
     }
   }
 

packages/microservices/test/client/client-grpc.spec.ts

@@ -3,10 +3,11 @@ import { expect } from 'chai';
 import { join } from 'path';
 import { Observable, Subject } from 'rxjs';
 import * as sinon from 'sinon';
-import { ClientGrpcProxy } from '../../client/client-grpc';
+import { ClientGrpcProxy } from '../../client';
 import { InvalidGrpcPackageException } from '../../errors/invalid-grpc-package.exception';
 import { InvalidGrpcServiceException } from '../../errors/invalid-grpc-service.exception';
 import { InvalidProtoDefinitionException } from '../../errors/invalid-proto-definition.exception';
+import * as grpcHelpers from '../../helpers/grpc-helpers';
 
 class NoopLogger extends Logger {
   log(message: any, context?: string): void {}
@@ -443,13 +444,18 @@ describe('ClientGrpcProxy', () => {
   describe('loadProto', () => {
     describe('when proto is invalid', () => {
       it('should throw InvalidProtoDefinitionException', () => {
-        sinon.stub(client, 'getOptionsProp' as any).callsFake(() => {
+        const getPackageDefinitionStub = sinon.stub(
+          grpcHelpers,
+          'getGrpcPackageDefinition' as any,
+        );
+        getPackageDefinitionStub.callsFake(() => {
           throw new Error();
         });
         (client as any).logger = new NoopLogger();
         expect(() => client.loadProto()).to.throws(
           InvalidProtoDefinitionException,
         );
+        getPackageDefinitionStub.restore();
       });
     });
   });

packages/microservices/test/helpers/grpc-helpers.spec.ts

@@ -0,0 +1,64 @@
+import { expect } from 'chai';
+import { InvalidGrpcPackageDefinitionMissingPackageDefinitionException } from '../../errors/invalid-grpc-package-definition-missing-package-definition.exception';
+import { InvalidGrpcPackageDefinitionMutexException } from '../../errors/invalid-grpc-package-definition-mutex.exception';
+import { getGrpcPackageDefinition } from '../../helpers/grpc-helpers';
+
+const grpcProtoLoaderPackage = { loadSync: (a, b) => 'withLoader' };
+
+describe('getGrpcPackageDefinition', () => {
+  describe('when missing both protoPath and packageDefinition', () => {
+    it('should throw InvalidGrpcPackageDefinitionMissingPackageDefinitionException', () => {
+      expect(() =>
+        getGrpcPackageDefinition(
+          {
+            package: 'somePackage',
+          },
+          grpcProtoLoaderPackage,
+        ),
+      ).to.throw(InvalidGrpcPackageDefinitionMissingPackageDefinitionException);
+    });
+  });
+
+  describe('when both protoPath and packageDefinition are defined', () => {
+    it('should throw InvalidGrpcPackageDefinitionMutexException', () => {
+      expect(() =>
+        getGrpcPackageDefinition(
+          {
+            package: 'somePackage',
+            protoPath: 'some/path',
+            packageDefinition: {},
+          },
+          grpcProtoLoaderPackage,
+        ),
+      ).to.throw(InvalidGrpcPackageDefinitionMutexException);
+    });
+  });
+
+  describe('when only protoPath is defined', () => {
+    it('should not throw any exception', () => {
+      expect(() =>
+        getGrpcPackageDefinition(
+          {
+            package: 'somePackage',
+            protoPath: 'some/path',
+          },
+          grpcProtoLoaderPackage,
+        ),
+      ).to.not.throw(Error);
+    });
+  });
+
+  describe('when only packageDefinition is defined', () => {
+    it('should not throw any exception', () => {
+      expect(() =>
+        getGrpcPackageDefinition(
+          {
+            package: 'somePackage',
+            packageDefinition: {},
+          },
+          grpcProtoLoaderPackage,
+        ),
+      ).to.not.throw(Error);
+    });
+  });
+});

packages/microservices/test/server/server-grpc.spec.ts

@@ -1,19 +1,14 @@
 import { Logger } from '@nestjs/common';
 import { expect } from 'chai';
 import { join } from 'path';
-import {
-  async,
-  Observable,
-  of,
-  ReplaySubject,
-  Subject,
-  throwError,
-} from 'rxjs';
+import { ReplaySubject, Subject, throwError } from 'rxjs';
 import * as sinon from 'sinon';
 import { CANCEL_EVENT } from '../../constants';
 import { InvalidGrpcPackageException } from '../../errors/invalid-grpc-package.exception';
+import { InvalidProtoDefinitionException } from '../../errors/invalid-proto-definition.exception';
+import * as grpcHelpers from '../../helpers/grpc-helpers';
 import { GrpcMethodStreamingType } from '../../index';
-import { ServerGrpc } from '../../server/server-grpc';
+import { ServerGrpc } from '../../server';
 
 class NoopLogger extends Logger {
   log(message: any, context?: string): void {}
@@ -777,6 +772,25 @@ describe('ServerGrpc', () => {
     });
   });
 
+  describe('loadProto', () => {
+    describe('when proto is invalid', () => {
+      it('should throw InvalidProtoDefinitionException', () => {
+        const getPackageDefinitionStub = sinon.stub(
+          grpcHelpers,
+          'getGrpcPackageDefinition' as any,
+        );
+        getPackageDefinitionStub.callsFake(() => {
+          throw new Error();
+        });
+        (server as any).logger = new NoopLogger();
+        expect(() => server.loadProto()).to.throws(
+          InvalidProtoDefinitionException,
+        );
+        getPackageDefinitionStub.restore();
+      });
+    });
+  });
+
   describe('close', () => {
     it('should call "forceShutdown" by default', async () => {
       const grpcClient = {