Implement detection of available protocol and creation of gRPC client

Author: deve-sh

src/client.ts

@@ -1,10 +1,10 @@
-import {ChannelCredentials, Metadata, ServiceError} from '@postman/grpc-js';
-import {getDescriptorRootFromDescriptorSet} from './descriptor';
-import * as services from './reflection_grpc_pb';
 import {
-  ServerReflectionRequest,
-  ServerReflectionResponse,
-} from './reflection_pb';
+  ChannelCredentials,
+  Metadata,
+  ServiceError,
+  status as GrpcStatus,
+} from '@postman/grpc-js';
+import {getDescriptorRootFromDescriptorSet} from './descriptor';
 import {Root} from '@postman/protobufjs';
 import {
   FileDescriptorSet,
@@ -13,26 +13,147 @@ import {
 } from '@postman/protobufjs/ext/descriptor';
 import set from 'lodash.set';
 
+// Static type definitions with common structures across all reflection providers
+import type {ServerReflectionClient} from './reflection_providers/v1alpha/reflection_grpc_pb';
+import type {
+  ServerReflectionRequest,
+  ServerReflectionResponse,
+} from './reflection_providers/v1alpha/reflection_pb';
+
+const supportedReflectionProtocols = [
+  {
+    protocol: 'v1alpha',
+    serviceName: 'grpc.reflection.v1alpha.ServerReflection',
+    client: import('./reflection_providers/v1alpha/reflection_pb'),
+    service: import('./reflection_providers/v1alpha/reflection_grpc_pb'),
+  },
+  {
+    protocol: 'v1',
+    serviceName: 'grpc.reflection.v1.ServerReflection',
+    client: import('./reflection_providers/v1/reflection_pb'),
+    service: import('./reflection_providers/v1/reflection_grpc_pb'),
+  },
+];
+
 export class Client {
   metadata: Metadata;
-  grpcClient: services.IServerReflectionClient;
   private fileDescriptorCache: Map<string, IFileDescriptorProto> = new Map();
+  private url: string;
+  private credentials: ChannelCredentials;
+  private clientOptions: object | undefined;
+
+  grpcClient: ServerReflectionClient | undefined;
+  private reflectionResponseCache: ServerReflectionResponse | undefined;
+  private compatibleProtocol: string | undefined;
+  private CompatibleServerReflectionRequest:
+    | (new (
+        ...args: ConstructorParameters<typeof ServerReflectionRequest>
+      ) => ServerReflectionRequest)
+    | undefined;
+
   constructor(
     url: string,
     credentials: ChannelCredentials,
     options?: object,
     metadata?: Metadata
   ) {
+    this.url = url;
+    this.credentials = credentials;
+    this.clientOptions = options;
     this.fileDescriptorCache = new Map();
     this.metadata = metadata || new Metadata();
-    this.grpcClient = new services.ServerReflectionClient(
-      url,
-      credentials,
-      options
-    );
   }
 
-  listServices(): Promise<string[]> {
+  private async sendReflectionRequest(
+    request: ServerReflectionRequest | ServerReflectionRequest[],
+    client?: ServerReflectionClient
+  ): Promise<ServerReflectionResponse[]> {
+    return new Promise((resolve, reject) => {
+      const result: ServerReflectionResponse[] = [];
+
+      const grpcCall = (client || this.grpcClient!).serverReflectionInfo(
+        this.metadata
+      );
+
+      grpcCall.on('data', (response: ServerReflectionResponse) => {
+        result.push(response);
+      });
+
+      grpcCall.on('error', (error: ServiceError) => {
+        reject(error);
+      });
+
+      grpcCall.on('end', () => resolve(result));
+
+      if (Array.isArray(request)) {
+        request.forEach(req => grpcCall.write(req));
+      } else {
+        grpcCall.write(request);
+      }
+
+      grpcCall.end();
+    });
+  }
+
+  private async initializeReflectionClient() {
+    if (this.grpcClient || this.compatibleProtocol) {
+      return;
+    }
+
+    // Check protocol compatibility and initialize gRPC client based on that
+    for (const protocolConfig of supportedReflectionProtocols) {
+      const {
+        protocol,
+        service: servicePromise,
+        client: clientPromise,
+      } = protocolConfig;
+
+      const [protocolService, protocolClient] = await Promise.all([
+        servicePromise,
+        clientPromise,
+      ]);
+
+      const grpcClientForProtocol = new protocolService.ServerReflectionClient(
+        this.url,
+        this.credentials,
+        this.clientOptions
+      );
+
+      const request = new protocolClient.ServerReflectionRequest();
+
+      request.setListServices('*');
+
+      try {
+        const [reflectionResponse] = await this.sendReflectionRequest(
+          request,
+          grpcClientForProtocol
+        );
+
+        this.grpcClient = grpcClientForProtocol;
+        this.compatibleProtocol = protocol;
+        this.CompatibleServerReflectionRequest =
+          protocolClient.ServerReflectionRequest;
+        this.reflectionResponseCache = reflectionResponse;
+
+        break; // Exit loop on first successful protocol
+      } catch (error) {
+        if ((error as ServiceError).code !== GrpcStatus.UNIMPLEMENTED) {
+          // Something is wrong with the gRPC server itself
+          throw error;
+        }
+
+        continue; // Try next protocol
+      }
+    }
+
+    if (!this.grpcClient) {
+      throw new Error('No compatible reflection protocol found.');
+    }
+  }
+
+  async listServices(): Promise<string[]> {
+    await this.initializeReflectionClient();
+
     return new Promise((resolve, reject) => {
       function dataCallback(response: ServerReflectionResponse) {
         if (response.hasListServicesResponse()) {
@@ -52,14 +173,16 @@ export class Client {
         reject(e);
       }
 
-      const request = new ServerReflectionRequest();
+      if (this.reflectionResponseCache) {
+        return dataCallback(this.reflectionResponseCache);
+      }
+
+      const request = new this.CompatibleServerReflectionRequest!();
       request.setListServices('*');
 
-      const grpcCall = this.grpcClient.serverReflectionInfo(this.metadata);
-      grpcCall.on('data', dataCallback);
-      grpcCall.on('error', errorCallback);
-      grpcCall.write(request);
-      grpcCall.end();
+      this.sendReflectionRequest(request)
+        .then(([response]) => dataCallback(response))
+        .catch(errorCallback);
     });
   }
 
@@ -120,9 +243,11 @@ export class Client {
     return fileDescriptorMap;
   }
 
-  private getFileContainingSymbol(
+  private async getFileContainingSymbol(
     symbol: string
   ): Promise<Array<IFileDescriptorProto> | undefined> {
+    await this.initializeReflectionClient();
+
     const fileDescriptorCache = this.fileDescriptorCache;
     return new Promise((resolve, reject) => {
       function dataCallback(response: ServerReflectionResponse) {
@@ -154,20 +279,20 @@ export class Client {
         reject(e);
       }
 
-      const request = new ServerReflectionRequest();
+      const request = new this.CompatibleServerReflectionRequest!();
       request.setFileContainingSymbol(symbol);
 
-      const grpcCall = this.grpcClient.serverReflectionInfo(this.metadata);
-      grpcCall.on('data', dataCallback);
-      grpcCall.on('error', errorCallback);
-      grpcCall.write(request);
-      grpcCall.end();
+      this.sendReflectionRequest(request)
+        .then(([response]) => dataCallback(response))
+        .catch(errorCallback);
     });
   }
 
-  private getFilesByFilenames(
+  private async getFilesByFilenames(
     symbols: string[]
   ): Promise<Array<IFileDescriptorProto> | undefined> {
+    await this.initializeReflectionClient();
+
     const result: Array<IFileDescriptorProto> = [];
     const fileDescriptorCache = this.fileDescriptorCache;
     const symbolsToFetch = symbols.filter(symbol => {
@@ -203,6 +328,13 @@ export class Client {
                 result.push(fileDescriptorProto);
               }
             });
+        } else if (response.hasErrorResponse()) {
+          const err = response.getErrorResponse();
+          reject(
+            new Error(
+              `Error: ${err?.getErrorCode()}: ${err?.getErrorMessage()}`
+            )
+          );
         } else {
           reject(Error());
         }
@@ -212,19 +344,17 @@ export class Client {
         reject(e);
       }
 
-      const grpcCall = this.grpcClient.serverReflectionInfo(this.metadata);
-      grpcCall.on('data', dataCallback);
-      grpcCall.on('error', errorCallback);
-      grpcCall.on('end', () => {
-        resolve(result);
+      const requests = symbolsToFetch.map(symbol => {
+        const request = new this.CompatibleServerReflectionRequest!();
+        return request.setFileByFilename(symbol);
       });
 
-      symbolsToFetch.forEach(symbol => {
-        const request = new ServerReflectionRequest();
-        grpcCall.write(request.setFileByFilename(symbol));
-      });
-
-      grpcCall.end();
+      this.sendReflectionRequest(requests)
+        .then(responses => {
+          for (const dataBit of responses) dataCallback(dataBit);
+          resolve(result);
+        })
+        .catch(errorCallback);
     });
   }
 }

test/client.test.ts

@@ -8,7 +8,7 @@ import {
   ListServiceResponse,
   ServiceResponse,
   FileDescriptorResponse,
-} from '../src/reflection_pb';
+} from '../src/reflection_providers/v1/reflection_pb';
 
 // eslint-disable-next-line no-undef
 describe('listServices', () => {