fix: Consistently apply lowerCaseServiceMethods=true

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