feat(grpc): GRPCClients.createClient() supports multi services in one .proto file and returns void insted of T

packages/grpc/src/comsumer/clients.ts

@@ -1,3 +1,4 @@
+import * as assert from 'assert';
 import {
   Config,
   Init,
@@ -40,23 +41,33 @@ export class GRPCClients extends Map {
     }
   }
 
-  async createClient<T>(options: IGRPCClientServiceOptions): Promise<T> {
+  async createClient<T>(options: IGRPCClientServiceOptions): Promise<void> {
     const packageDefinition = await loadProto({
       loaderOptions: options.loaderOptions,
       protoPath: options.protoPath,
     });
     const allProto = loadPackageDefinition(packageDefinition);
     const packageProto: any = finePackageProto(allProto, options.package);
+
     for (const definition in packageDefinition) {
       if (!packageDefinition[definition]['format']) {
         const serviceName = definition.replace(`${options.package}.`, '');
-        const connectionService = new packageProto[serviceName](
+        const connectionService: T = new packageProto[serviceName](
           options.url,
           credentials.createInsecure(),
           options.clientOptions
         );
+
         for (const methodName of Object.keys(packageDefinition[definition])) {
           const originMethod = connectionService[methodName];
+          const msg: string[] = [
+            `No method found in proto file, path: ${options.protoPath}`,
+            `method: ${methodName}`,
+            `definition: ${definition}`,
+            `serviceName: ${serviceName}`,
+          ];
+          assert(originMethod, msg.join(', '));
+
           connectionService[methodName] = (
             clientOptions: IClientOptions = {}
           ) => {
@@ -70,7 +81,6 @@ export class GRPCClients extends Map {
             connectionService[methodName];
         }
         this.set(definition, connectionService);
-        return connectionService;
       }
     }
   }
@@ -130,5 +140,12 @@ export const createGRPCConsumer = async <T>(
   };
 
   await clients.initService();
+  if (typeof options.service === 'string' && options.service) {
+    const pkg = clients.grpcConfig.services[0].package;
+    const name = options.service.startsWith(`${pkg}.`)
+      ? options.service
+      : `${pkg}.${options.service}`;
+    return clients.getService(name);
+  }
   return Array.from(clients.values())[0];
 };

packages/grpc/src/interface.ts

@@ -65,6 +65,10 @@ export interface IGRPCClientServiceOptions extends IGRPCServiceOptions {
    * Client options. Optional.
    */
   clientOptions?: ClientOptions;
+  /**
+   * Service name. Optional.
+   */
+  service?: string;
 }
 
 export interface IMidwayGRPFrameworkOptions extends IConfigurationOptions {

packages/grpc/test/fixtures/base-app-multiple-service/src/interface.ts

@@ -15,6 +15,13 @@ export namespace hero {
     id?: number;
     name?: string;
   }
+
+  export interface HeroService2 {
+    findOne2(data: HeroById, metadata?: Metadata): Promise<Hero>;
+  }
+  export interface HeroService2Client {
+    findOne2(options?: IClientOptions): IClientUnaryService<HeroById, Hero>;
+  }
 }
 
 export namespace helloworld {

packages/grpc/test/fixtures/base-app-multiple-service/src/provider/hero2.ts

@@ -0,0 +1,29 @@
+import { GrpcMethod, MSProviderType, Provider, Provide, Inject, Init } from '@midwayjs/core';
+import { helloworld, hero } from '../interface';
+import { Clients } from '../../../../../src';
+
+@Provide()
+@Provider(MSProviderType.GRPC, { package: 'hero' })
+export class HeroService2 implements hero.HeroService2 {
+
+  @Inject()
+  grpcClients: Clients;
+
+  greeterService: helloworld.GreeterClient;
+
+  @Init()
+  async init() {
+    this.greeterService = this.grpcClients.getService<helloworld.GreeterClient>('helloworld.Greeter');
+  }
+
+  @GrpcMethod()
+  async findOne2(data) {
+    const result = await this.greeterService.sayHello().sendMessage({
+      name: 'harry'
+    });
+    return {
+      id: 1,
+      name: 'bbbb-' + result.message,
+    };
+  }
+}

packages/grpc/test/fixtures/proto/hero.proto

@@ -6,6 +6,10 @@ service HeroService {
   rpc FindOne (HeroById) returns (Hero) {}
 }
 
+service HeroService2 {
+  rpc FindOne2 (HeroById) returns (Hero) {}
+}
+
 message HeroById {
   int32 id = 1;
 }

packages/grpc/test/index.test.ts

@@ -23,6 +23,9 @@ export namespace hero {
     id?: number;
     name?: string;
   }
+  export interface HeroService2Client {
+    findOne2(options?: IClientOptions): IClientUnaryService<HeroById, Hero>;
+  }
 }
 
 export namespace helloworld {
@@ -61,7 +64,6 @@ export namespace math {
   }
 }
 
-
 describe('/test/index.test.ts', function () {
 
   it('run with empty config', async () => {
@@ -108,18 +110,23 @@ describe('/test/index.test.ts', function () {
 
   it('should create multiple grpc service in one server', async () => {
     const app = await createServer('base-app-multiple-service');
-
-    const service = await createGRPCConsumer<hero.HeroServiceClient>({
+    const opts = {
       package: 'hero',
       protoPath: join(__dirname, 'fixtures/proto/hero.proto'),
       url: 'localhost:6565'
-    });
-
-    const result = await service.findOne().sendMessage({
-      id: 123
-    });
+    }
 
+    const service = await createGRPCConsumer<hero.HeroServiceClient>({ ...opts, });
+    const result = await service.findOne().sendMessage({ id: 123 });
     expect(result).toEqual({ id: 1, name: 'bbbb-Hello harry' })
+
+    const service2 = await createGRPCConsumer<hero.HeroService2Client>({ service: 'HeroService2', ...opts, });
+    const result2 = await service2.findOne2().sendMessage({ id: 123 });
+    expect(result2).toEqual({ id: 1, name: 'bbbb-Hello harry' })
+
+    const service3 = await createGRPCConsumer<hero.HeroService2Client>({ ...opts, service: 'hero.HeroService2' });
+    const result3 = await service3.findOne2().sendMessage({ id: 123 });
+    expect(result3).toEqual({ id: 1, name: 'bbbb-Hello harry' })
     await closeApp(app);
   });