fix: Consistently apply lowerCaseServiceMethods=true (#332)

* ts-proto-descriptors export js only

* Add FormattedMethodDescriptor class

* Replace all method descriptors with formatted method descriptors

* Change gen-svcs to use native method name

* Use FormattedMethodDescriptor

* Removed original property from formattedmethoddesc

* Invert FormattedMethodDescriptor

* Run prettier

* Remove allmethod from main

* Remove formatting from methods before returning from main

* Add lowerCaseServiceMethods tests

* Add parameters to lower case svc methods tests

integration/lower-case-svc-methods/lower-case-svc-methods-test.ts

@@ -0,0 +1,33 @@
+import { MathServiceClientImpl } from './math';
+
+function getRpc() {
+  return {
+    request: jest.fn<any, any>(() => ({then: () => null}))
+  };
+}
+
+function getContext() {
+  const dataLoaderReturnValue = {load: jest.fn()};
+  return {
+    dataLoaderReturnValue,
+    getDataLoader: jest.fn<any, any>(() => dataLoaderReturnValue)
+  }
+}
+
+describe('lower-case-svc-methods', () => {
+  it('lower-caseifies normal functions', () => {
+    const rpc = getRpc(), ctx = getContext();
+    const client = new MathServiceClientImpl(rpc);
+    client.absoluteValue(ctx, {num: -1});
+
+    expect(rpc.request).toBeCalledWith(ctx, 'MathService', 'AbsoluteValue', expect.any(Buffer));
+  });
+  it('lower-caseifies batch functions', () => {
+    const rpc = getRpc(), ctx = getContext();
+    const client = new MathServiceClientImpl(rpc);
+    client.getDouble(ctx, -1);
+
+    expect(ctx.getDataLoader).toBeCalledWith('MathService.BatchDouble', expect.any(Function));
+    expect(ctx.dataLoaderReturnValue.load).toBeCalledWith(-1);
+  });
+});

integration/lower-case-svc-methods/math.proto

@@ -0,0 +1,20 @@
+syntax = "proto3";
+
+message NumPair {
+    double num1 = 1;
+    double num2 = 2;
+}
+
+message NumSingle {
+    double num = 1;
+}
+
+message Numbers {
+    repeated double num = 1;
+}
+
+service MathService {
+    rpc Add(NumPair) returns (NumSingle);
+    rpc AbsoluteValue(NumSingle) returns (NumSingle);
+    rpc BatchDouble(Numbers) returns (Numbers);
+}

integration/lower-case-svc-methods/math.ts

@@ -0,0 +1,296 @@
+/* eslint-disable */
+import { util, configure, Reader, Writer } from 'protobufjs/minimal';
+import * as Long from 'long';
+import * as DataLoader from 'dataloader';
+import * as hash from 'object-hash';
+
+export const protobufPackage = '';
+
+export interface NumPair {
+  num1: number;
+  num2: number;
+}
+
+export interface NumSingle {
+  num: number;
+}
+
+export interface Numbers {
+  num: number[];
+}
+
+const baseNumPair: object = { num1: 0, num2: 0 };
+
+export const NumPair = {
+  encode(message: NumPair, writer: Writer = Writer.create()): Writer {
+    if (message.num1 !== 0) {
+      writer.uint32(9).double(message.num1);
+    }
+    if (message.num2 !== 0) {
+      writer.uint32(17).double(message.num2);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): NumPair {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = { ...baseNumPair } as NumPair;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.num1 = reader.double();
+          break;
+        case 2:
+          message.num2 = reader.double();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): NumPair {
+    const message = { ...baseNumPair } as NumPair;
+    if (object.num1 !== undefined && object.num1 !== null) {
+      message.num1 = Number(object.num1);
+    } else {
+      message.num1 = 0;
+    }
+    if (object.num2 !== undefined && object.num2 !== null) {
+      message.num2 = Number(object.num2);
+    } else {
+      message.num2 = 0;
+    }
+    return message;
+  },
+
+  toJSON(message: NumPair): unknown {
+    const obj: any = {};
+    message.num1 !== undefined && (obj.num1 = message.num1);
+    message.num2 !== undefined && (obj.num2 = message.num2);
+    return obj;
+  },
+
+  fromPartial(object: DeepPartial<NumPair>): NumPair {
+    const message = { ...baseNumPair } as NumPair;
+    if (object.num1 !== undefined && object.num1 !== null) {
+      message.num1 = object.num1;
+    } else {
+      message.num1 = 0;
+    }
+    if (object.num2 !== undefined && object.num2 !== null) {
+      message.num2 = object.num2;
+    } else {
+      message.num2 = 0;
+    }
+    return message;
+  },
+};
+
+const baseNumSingle: object = { num: 0 };
+
+export const NumSingle = {
+  encode(message: NumSingle, writer: Writer = Writer.create()): Writer {
+    if (message.num !== 0) {
+      writer.uint32(9).double(message.num);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): NumSingle {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = { ...baseNumSingle } as NumSingle;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.num = reader.double();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): NumSingle {
+    const message = { ...baseNumSingle } as NumSingle;
+    if (object.num !== undefined && object.num !== null) {
+      message.num = Number(object.num);
+    } else {
+      message.num = 0;
+    }
+    return message;
+  },
+
+  toJSON(message: NumSingle): unknown {
+    const obj: any = {};
+    message.num !== undefined && (obj.num = message.num);
+    return obj;
+  },
+
+  fromPartial(object: DeepPartial<NumSingle>): NumSingle {
+    const message = { ...baseNumSingle } as NumSingle;
+    if (object.num !== undefined && object.num !== null) {
+      message.num = object.num;
+    } else {
+      message.num = 0;
+    }
+    return message;
+  },
+};
+
+const baseNumbers: object = { num: 0 };
+
+export const Numbers = {
+  encode(message: Numbers, writer: Writer = Writer.create()): Writer {
+    writer.uint32(10).fork();
+    for (const v of message.num) {
+      writer.double(v);
+    }
+    writer.ldelim();
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): Numbers {
+    const reader = input instanceof Reader ? input : new Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = { ...baseNumbers } as Numbers;
+    message.num = [];
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if ((tag & 7) === 2) {
+            const end2 = reader.uint32() + reader.pos;
+            while (reader.pos < end2) {
+              message.num.push(reader.double());
+            }
+          } else {
+            message.num.push(reader.double());
+          }
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): Numbers {
+    const message = { ...baseNumbers } as Numbers;
+    message.num = [];
+    if (object.num !== undefined && object.num !== null) {
+      for (const e of object.num) {
+        message.num.push(Number(e));
+      }
+    }
+    return message;
+  },
+
+  toJSON(message: Numbers): unknown {
+    const obj: any = {};
+    if (message.num) {
+      obj.num = message.num.map((e) => e);
+    } else {
+      obj.num = [];
+    }
+    return obj;
+  },
+
+  fromPartial(object: DeepPartial<Numbers>): Numbers {
+    const message = { ...baseNumbers } as Numbers;
+    message.num = [];
+    if (object.num !== undefined && object.num !== null) {
+      for (const e of object.num) {
+        message.num.push(e);
+      }
+    }
+    return message;
+  },
+};
+
+export interface MathService<Context extends DataLoaders> {
+  add(ctx: Context, request: NumPair): Promise<NumSingle>;
+  absoluteValue(ctx: Context, request: NumSingle): Promise<NumSingle>;
+  batchDouble(ctx: Context, request: Numbers): Promise<Numbers>;
+  getDouble(ctx: Context, nu: number): Promise<number>;
+}
+
+export class MathServiceClientImpl<Context extends DataLoaders> implements MathService<Context> {
+  private readonly rpc: Rpc<Context>;
+  constructor(rpc: Rpc<Context>) {
+    this.rpc = rpc;
+    this.add = this.add.bind(this);
+    this.absoluteValue = this.absoluteValue.bind(this);
+    this.batchDouble = this.batchDouble.bind(this);
+  }
+  add(ctx: Context, request: NumPair): Promise<NumSingle> {
+    const data = NumPair.encode(request).finish();
+    const promise = this.rpc.request(ctx, 'MathService', 'Add', data);
+    return promise.then((data) => NumSingle.decode(new Reader(data)));
+  }
+
+  absoluteValue(ctx: Context, request: NumSingle): Promise<NumSingle> {
+    const data = NumSingle.encode(request).finish();
+    const promise = this.rpc.request(ctx, 'MathService', 'AbsoluteValue', data);
+    return promise.then((data) => NumSingle.decode(new Reader(data)));
+  }
+
+  getDouble(ctx: Context, nu: number): Promise<number> {
+    const dl = ctx.getDataLoader('MathService.BatchDouble', () => {
+      return new DataLoader<number, number>(
+        (num) => {
+          const request = { num };
+          return this.batchDouble(ctx, request).then((res) => res.num);
+        },
+        { cacheKeyFn: hash, ...ctx.rpcDataLoaderOptions }
+      );
+    });
+    return dl.load(nu);
+  }
+
+  batchDouble(ctx: Context, request: Numbers): Promise<Numbers> {
+    const data = Numbers.encode(request).finish();
+    const promise = this.rpc.request(ctx, 'MathService', 'BatchDouble', data);
+    return promise.then((data) => Numbers.decode(new Reader(data)));
+  }
+}
+
+interface Rpc<Context> {
+  request(ctx: Context, service: string, method: string, data: Uint8Array): Promise<Uint8Array>;
+}
+
+export interface DataLoaderOptions {
+  cache?: boolean;
+}
+
+export interface DataLoaders {
+  rpcDataLoaderOptions?: DataLoaderOptions;
+  getDataLoader<T>(identifier: string, constructorFn: () => T): T;
+}
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin
+  ? T
+  : T extends Array<infer U>
+  ? Array<DeepPartial<U>>
+  : T extends ReadonlyArray<infer U>
+  ? ReadonlyArray<DeepPartial<U>>
+  : T extends {}
+  ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+// If you get a compile-error about 'Constructor<Long> and ... have no overlap',
+// add '--ts_proto_opt=esModuleInterop=true' as a flag when calling 'protoc'.
+if (util.Long !== Long) {
+  util.Long = Long as any;
+  configure();
+}

integration/lower-case-svc-methods/parameters.txt

@@ -0,0 +1 @@
+lowerCaseServiceMethods=true,context=true