chore: Rename camelCase to uncapitalize. (#817)

Because that is what it does. Not sure how it got this way.

src/case.ts

@@ -31,16 +31,15 @@ export function capitalize(s: string): string {
   return s.substring(0, 1).toUpperCase() + s.substring(1);
 }
 
-export function camelCase(s: string): string {
+export function uncapitalize(s: string): string {
   return s.substring(0, 1).toLowerCase() + s.substring(1);
 }
 
+/* This function uses the exact same semantics found inside the grpc
+ * nodejs library. Camel case splitting must be done by word i.e
+ * GetAPIValue must become getApiValue (notice the API becomes Api).
+ * This needs to be followed otherwise it will not succeed in the grpc nodejs module.
+ */
 export function camelCaseGrpc(s: string): string {
-  /* This function uses the exact same semantics found inside the grpc
-   * nodejs library. Camel case splitting must be done by word i.e
-   * GetAPIValue must become getApiValue (notice the API becomes Api).
-   * This needs to be followed otherwise it will not succeed in the grpc nodejs module.
-   */
-
   return camelCaseAnything(s);
 }

src/enums.ts

@@ -1,7 +1,7 @@
 import { code, def, Code, joinCode } from "ts-poet";
 import { EnumDescriptorProto, EnumValueDescriptorProto } from "ts-proto-descriptors";
 import { maybeAddComment } from "./utils";
-import { camelCase, camelToSnake } from "./case";
+import { uncapitalize, camelToSnake } from "./case";
 import SourceInfo, { Fields } from "./sourceInfo";
 import { Context } from "./context";
 
@@ -73,7 +73,7 @@ export function generateEnumFromJson(ctx: Context, fullName: string, enumDesc: E
   const { options, utils } = ctx;
   const chunks: Code[] = [];
 
-  const functionName = camelCase(fullName) + "FromJSON";
+  const functionName = uncapitalize(fullName) + "FromJSON";
   chunks.push(code`export function ${def(functionName)}(object: any): ${fullName} {`);
   chunks.push(code`switch (object) {`);
 
@@ -113,7 +113,7 @@ export function generateEnumToJson(ctx: Context, fullName: string, enumDesc: Enu
 
   const chunks: Code[] = [];
 
-  const functionName = camelCase(fullName) + "ToJSON";
+  const functionName = uncapitalize(fullName) + "ToJSON";
   chunks.push(
     code`export function ${def(functionName)}(object: ${fullName}): ${
       ctx.options.useNumericEnumForJson ? "number" : "string"
@@ -166,7 +166,7 @@ export function generateEnumToNumber(ctx: Context, fullName: string, enumDesc: E
 
   const chunks: Code[] = [];
 
-  const functionName = camelCase(fullName) + "ToNumber";
+  const functionName = uncapitalize(fullName) + "ToNumber";
   chunks.push(code`export function ${def(functionName)}(object: ${fullName}): number {`);
   chunks.push(code`switch (object) {`);
   for (const valueDesc of enumDesc.value) {

src/generate-generic-service-definition.ts

@@ -6,7 +6,7 @@ import {
   MethodOptions_IdempotencyLevel,
   ServiceDescriptorProto,
 } from "ts-proto-descriptors";
-import { camelCase } from "./case";
+import { uncapitalize } from "./case";
 import { Context } from "./context";
 import SourceInfo, { Fields } from "./sourceInfo";
 import { messageToTypeName } from "./types";
@@ -48,7 +48,7 @@ export function generateGenericServiceDefinition(
     maybeAddComment(info, chunks, methodDesc.options?.deprecated);
 
     chunks.push(code`
-      ${camelCase(methodDesc.name)}: ${generateMethodDefinition(ctx, methodDesc)},
+      ${uncapitalize(methodDesc.name)}: ${generateMethodDefinition(ctx, methodDesc)},
     `);
   }
 

src/generate-nestjs.ts

@@ -11,7 +11,7 @@ import {
 import SourceInfo, { Fields } from "./sourceInfo";
 import { contextTypeVar } from "./main";
 import { assertInstanceOf, FormattedMethodDescriptor, maybeAddComment, singular } from "./utils";
-import { camelCase } from "./case";
+import { uncapitalize } from "./case";
 import { Context } from "./context";
 import { ServiceOption } from "./options";
 

src/generate-nice-grpc.ts

@@ -1,6 +1,6 @@
 import { Code, code, def, imp, joinCode } from "ts-poet";
 import { FileDescriptorProto, ServiceDescriptorProto } from "ts-proto-descriptors";
-import { camelCase } from "./case";
+import { uncapitalize } from "./case";
 import { Context } from "./context";
 import SourceInfo, { Fields } from "./sourceInfo";
 import { messageToTypeName } from "./types";
@@ -50,15 +50,15 @@ function generateServerStub(ctx: Context, sourceInfo: SourceInfo, serviceDesc: S
       if (methodDesc.serverStreaming) {
         // bidi streaming
         chunks.push(code`
-          ${camelCase(methodDesc.name)}(
+          ${uncapitalize(methodDesc.name)}(
             request: AsyncIterable<${inputType}>,
             context: ${CallContext} & CallContextExt,
           ): ${ServerStreamingMethodResult}<${outputType}>;
         `);
       } else {
         // client streaming
         chunks.push(code`
-          ${camelCase(methodDesc.name)}(
+          ${uncapitalize(methodDesc.name)}(
             request: AsyncIterable<${inputType}>,
             context: ${CallContext} & CallContextExt,
           ): Promise<${outputType}>;
@@ -68,15 +68,15 @@ function generateServerStub(ctx: Context, sourceInfo: SourceInfo, serviceDesc: S
       if (methodDesc.serverStreaming) {
         // server streaming
         chunks.push(code`
-          ${camelCase(methodDesc.name)}(
+          ${uncapitalize(methodDesc.name)}(
             request: ${inputType},
             context: ${CallContext} & CallContextExt,
           ): ${ServerStreamingMethodResult}<${outputType}>;
         `);
       } else {
         // unary
         chunks.push(code`
-          ${camelCase(methodDesc.name)}(
+          ${uncapitalize(methodDesc.name)}(
             request: ${inputType},
             context: ${CallContext} & CallContextExt,
           ): Promise<${outputType}>;
@@ -113,15 +113,15 @@ function generateClientStub(ctx: Context, sourceInfo: SourceInfo, serviceDesc: S
       if (methodDesc.serverStreaming) {
         // bidi streaming
         chunks.push(code`
-          ${camelCase(methodDesc.name)}(
+          ${uncapitalize(methodDesc.name)}(
             request: AsyncIterable<${inputType}>,
             options?: ${CallOptions} & CallOptionsExt,
           ): AsyncIterable<${outputType}>;
         `);
       } else {
         // client streaming
         chunks.push(code`
-          ${camelCase(methodDesc.name)}(
+          ${uncapitalize(methodDesc.name)}(
             request: AsyncIterable<${inputType}>,
             options?: ${CallOptions} & CallOptionsExt,
           ): Promise<${outputType}>;
@@ -131,15 +131,15 @@ function generateClientStub(ctx: Context, sourceInfo: SourceInfo, serviceDesc: S
       if (methodDesc.serverStreaming) {
         // server streaming
         chunks.push(code`
-          ${camelCase(methodDesc.name)}(
+          ${uncapitalize(methodDesc.name)}(
             request: ${inputType},
             options?: ${CallOptions} & CallOptionsExt,
           ): AsyncIterable<${outputType}>;
         `);
       } else {
         // unary
         chunks.push(code`
-          ${camelCase(methodDesc.name)}(
+          ${uncapitalize(methodDesc.name)}(
             request: ${inputType},
             options?: ${CallOptions} & CallOptionsExt,
           ): Promise<${outputType}>;

src/types.ts

@@ -15,7 +15,7 @@ import { DateOption, EnvOption, LongOption, OneofOption, Options } from "./optio
 import { visit } from "./visit";
 import { fail, FormattedMethodDescriptor, impProto, maybePrefixPackage } from "./utils";
 import SourceInfo from "./sourceInfo";
-import { camelCase } from "./case";
+import { uncapitalize } from "./case";
 import { Context } from "./context";
 
 /** Based on https://github.com/dcodeIO/protobuf.js/blob/master/src/types.js#L37. */
@@ -601,7 +601,7 @@ function toModuleAndType(typeMap: TypeMap, protoType: string): [string, string,
 
 export function getEnumMethod(ctx: Context, enumProtoType: string, methodSuffix: string): Import {
   const [module, type] = toModuleAndType(ctx.typeMap, enumProtoType);
-  return impProto(ctx.options, module, `${camelCase(type)}${methodSuffix}`);
+  return impProto(ctx.options, module, `${uncapitalize(type)}${methodSuffix}`);
 }
 
 /** Return the TypeName for any field (primitive/message/etc.) as exposed in the interface. */

src/utils.ts

@@ -167,7 +167,7 @@ export class FormattedMethodDescriptor implements MethodDescriptorProto {
     let result = methodName;
 
     if (options.lowerCaseServiceMethods || options.outputServices.includes(ServiceOption.GRPC)) {
-      result = camelCaseGrpc(result);
+      if (options.snakeToCamel) result = camelCaseGrpc(result);
     }
 
     return result;