Promisify @grpc-js service client with typescript

promisified-grpc-client.ts

import { Client, ServiceError, Metadata, CallOptions, ClientUnaryCall } from '@grpc/grpc-js';
import { Message } from 'google-protobuf';

type OriginalCall<T, U> = (request: T, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError, res: U) => void) => ClientUnaryCall;

type PromisifiedCall<T, U> = ((request: T, metadata?: Metadata, options?: Partial<CallOptions>) => Promise<U>);

export type Promisified<C> = { $: C; } & {
  [prop in Exclude<keyof C, keyof Client>]: (C[prop] extends OriginalCall<infer T, infer U> ? PromisifiedCall<T, U> : never);
}

export function promisify<C extends Client>(client: C): Promisified<C> {
  return new Proxy(client, {
    get: (target, descriptor) => {
      let stack = '';

      // this step is required to get the correct stack trace
      // of course, this has some performance impact, but it's not that big in comparison with grpc calls
      try { throw new Error(); } catch (e) { stack = e.stack; }

      if (descriptor === '$') {
        return target;
      }

      return (...args: any[]) => new Promise((resolve, reject) => target[descriptor](...[...args, (err: ServiceError, res: Message) => {
        if (err) {
          err.stack += stack;
          reject(err);
        } else {
          resolve(res);
        }
      }]));
    },
  }) as unknown as Promisified<C>;
}

usage-example.ts

export class SearchService {

  private searchServiceClient: Promisified<SearchServiceClient>;

  constructor(private config: Config) {
    const { host, grpcPort } = this.config.services.shopCore;

    this.searchServiceClient = promisify(new SearchServiceClient(`${host}:${grpcPort}`, ChannelCredentials.createInsecure()));
  }

  async search(query: string, limit: number): Promise<SearchResult> {
    const request = new SearchRequest().setQuery(query);
    const response = await this.searchServiceClient.search(request);

    return {
      items: response.getResultsList().map(item => ({
        name: item.getName(),
        url: item.getUrl(),
      })),
    };
  }

}

I got a Element implicitly has an 'any' type because expression of type 'string | symbol' can't be used to index type 'Client'. No index signature with a parameter of type 'string' was found on type 'Client'. error on line 19, target[descriptor].

I don't know if I had a wrong typescript setting.

You should explicitly use generate_package_definition if you use https://www.npmjs.com/package/grpc_tools_node_protoc_ts . Example: grpc_tools_node_protoc --plugin=protoc-gen-ts=../../node_modules/.bin/protoc-gen-ts --ts_out=generate_package_definition:... ...

Fix strict mode (and better naming): timostamm/protobuf-ts#345 (comment)

This was a big help.

I needed to make a small change to Promisified<C> to make it work on clients that have both unary and streaming calls. I changed the : never at the end to : any.