feat: Consistent identifier names

Author: laurence79

example/generated/SwaggerPetstoreClient.generated.ts

@@ -289,21 +289,21 @@ export class SwaggerPetstoreClient {
   }
 
   public async deletePet(
-    args: { api_key?: string; petId: number },
+    args: { apiKey?: string; petId: number },
     options?: RequestInit
   ): Promise<
     ResponseWithData<400, undefined> | ResponseWithData<404, undefined>
   > {
-    const { api_key, petId } = args;
+    const { apiKey, petId } = args;
 
     const method = 'DELETE';
     const url = `${this.baseUrl}/pet/${petId}`;
 
     const response = await fetch(url, {
       method,
       headers: {
-        ...(typeof api_key !== 'undefined' && api_key !== null
-          ? { ['api_key']: api_key }
+        ...(typeof apiKey !== 'undefined' && apiKey !== null
+          ? { ['api_key']: apiKey }
           : {})
       },
       ...options

example/generated/SwaggerPetstoreStubs.generated.ts

@@ -27,7 +27,7 @@ export type UpdatePetWithFormRequestPath = { petId: number };
 
 export type UpdatePetWithFormRequestBody = { name?: string; status?: string };
 
-export type DeletePetRequestHeader = { api_key?: string };
+export type DeletePetRequestHeader = { apiKey?: string };
 
 export type DeletePetRequestPath = { petId: number };
 

src/generateCode.ts

@@ -6,7 +6,7 @@ import { assertNever } from './helpers/assertNever';
 import { initUpper } from './helpers/initUpper';
 import { load } from './helpers/load';
 import { writeFile } from './helpers/writeFile';
-import { serviceNameTemplate } from './templates';
+import { makeIdentifier } from './templates/makeIdentifier';
 import { GenerateCodeOptions } from './types/GenerateCodeOptions';
 import * as OpenApi from './types/OpenApi';
 
@@ -28,7 +28,7 @@ export const generateCode = async (
   )) as unknown) as OpenApi.Document;
 
   const serviceName =
-    inputOptions.serviceName ?? serviceNameTemplate(openApiDocument.info.title);
+    inputOptions.serviceName ?? makeIdentifier(openApiDocument.info.title);
 
   const filename = (() => {
     const outputTypeName = initUpper(

src/generators/stubs/index.ts

@@ -8,7 +8,10 @@ import { generateServerTypes } from './server-types';
 import { initLower } from '../../helpers/initLower';
 import { fromV2 } from './v2';
 import { fromV3 } from './v3';
-import { safeName } from '../../templates/safeName';
+import {
+  makeIdentifier,
+  IdentifierFormat
+} from '../../templates/makeIdentifier';
 
 export const generateStubs = ({
   logger,
@@ -126,7 +129,10 @@ export const generateStubs = ({
       ${data
         .map(
           ({ operationId, methodStubType }) =>
-            `readonly ${safeName(operationId)}: ${methodStubType};`
+            `readonly ${makeIdentifier(
+              operationId,
+              IdentifierFormat.camelCase
+            )}: ${methodStubType};`
         )
         .join('\n')}
     };
@@ -145,16 +151,23 @@ export const generateStubs = ({
       const reset = () => {
         methodStubs = {
           ${data
-            .map(({ operationId }) => `${safeName(operationId)}: methodStub()`)
+            .map(
+              ({ operationId }) =>
+                `${makeIdentifier(
+                  operationId,
+                  IdentifierFormat.camelCase
+                )}: methodStub()`
+            )
             .join(',\n')}
         };
 
         currentRouter = Router()
           ${data
             .map(
               ({ method, operationId, requestHandlerPath }) =>
-                `.${method}('${requestHandlerPath}', methodStubs.${safeName(
-                  operationId
+                `.${method}('${requestHandlerPath}', methodStubs.${makeIdentifier(
+                  operationId,
+                  IdentifierFormat.camelCase
                 )}.requestHandler)`
             )
             .join('\n')}

src/generators/stubs/server-types/jsonSchema.ts

@@ -1,8 +1,7 @@
 import { JSONSchema7 } from 'json-schema';
 import { LogFn, progress } from '../../../lib/cli-logging';
 import { typeDefForSchema } from '../../../helpers/json-schema';
-import { initUpper } from '../../../helpers/initUpper';
-import { safeName } from '../../../templates/safeName';
+import { makeIdentifier } from '../../../templates/makeIdentifier';
 
 export const fromJsonSchema = (
   jsonSchema: JSONSchema7,
@@ -22,7 +21,7 @@ export const fromJsonSchema = (
 
     log?.(progress(typeName));
 
-    return `export type ${initUpper(safeName(typeName))} = ${typeDefForSchema(
+    return `export type ${makeIdentifier(typeName)} = ${typeDefForSchema(
       definition,
       options
     )};`;

src/helpers/json-schema/typeDefForReference.ts

@@ -1,7 +1,6 @@
-import { safeName } from '../../templates/safeName';
-import { initUpper } from '../initUpper';
+import { makeIdentifier } from '../../templates/makeIdentifier';
 
 export const typeDefForReference = ($ref: string): string => {
   const name = $ref.substring($ref.lastIndexOf('/') + 1);
-  return initUpper(safeName(name));
+  return makeIdentifier(name);
 };

src/helpers/open-api/typeName.spec.ts

@@ -2,7 +2,7 @@ import * as OpenApiV2 from '../../../types/OpenApiV2';
 import { typeDefForObject } from './typeDefForObject';
 import { typeDefForReference } from './typeDefForReference';
 import { typeDefForEnum } from './typeDefForEnum';
-import { typeName } from '../typeName';
+import { makeIdentifier } from '../../../templates/makeIdentifier';
 import { TypeDefContext } from '../TypeDefContext';
 
 export const typeDefForSchema = (
@@ -31,7 +31,7 @@ export const typeDefForSchema = (
 
     const { enum: enumProp, allOf, title } = schema;
 
-    const type = title ? typeName(title) : undefined;
+    const type = title ? makeIdentifier(title) : undefined;
 
     if (type) {
       if (!context.shouldEmitType(type)) {

src/helpers/open-api/v2/typeDefForSchema.ts

@@ -3,7 +3,7 @@ import { typeDefForObject } from './typeDefForObject';
 import { typeDefForReference } from './typeDefForReference';
 import { typeDefForEnum } from './typeDefForEnum';
 import { isObjectSchema } from './isObjectSchema';
-import { typeName } from '../typeName';
+import { makeIdentifier } from '../../../templates/makeIdentifier';
 import { TypeDefContext } from '../TypeDefContext';
 
 export const typeDefForSchema = (
@@ -29,7 +29,7 @@ export const typeDefForSchema = (
 
   const { enum: enumProp, allOf, oneOf, anyOf, title } = schema;
 
-  const type = title ? typeName(title) : undefined;
+  const type = title ? makeIdentifier(title) : undefined;
 
   if (type) {
     if (!context.shouldEmitType(type)) {

src/helpers/open-api/v3/typeDefForSchema.ts

@@ -1,7 +1,7 @@
 /* eslint-disable no-template-curly-in-string */
 import { aliasIfReserved, aliasNameIfReserved } from './aliasIfReserved';
+import { IdentifierFormat, makeIdentifier } from './makeIdentifier';
 import { objectTemplate } from './objectTemplate';
-import { safeName } from './safeName';
 
 export type ClientMethodTemplateArgs = {
   httpMethod: string;
@@ -120,14 +120,19 @@ export const clientMethodTemplate = (
 
   const decomposeParameters = paramNames.any()
     ? `const {${paramNames
-        .map(safeName)
+        .map(name => makeIdentifier(name, IdentifierFormat.camelCase))
         .map(aliasIfReserved)
         .join(', ')}} = args;`
     : '';
 
   const composeQuery = queryParams.any()
     ? `const query = qs.stringify({ ${queryParams
-        .map(q => `["${q.name}"]: ${safeName(aliasIfReserved(q.name))}`)
+        .map(
+          q =>
+            `["${q.name}"]: ${aliasNameIfReserved(
+              makeIdentifier(q.name, IdentifierFormat.camelCase)
+            )}`
+        )
         .join(', ')} }${
         queryArrayFormat === 'comma' ? ", { arrayFormat: 'comma' }" : ''
       });`
@@ -152,17 +157,15 @@ export const clientMethodTemplate = (
 
   const headers = headerParams
     .map(h => {
+      const localVarName = aliasNameIfReserved(
+        makeIdentifier(h.name, IdentifierFormat.camelCase)
+      );
+
       if (h.required) {
-        return `["${h.name}"]: ${safeName(aliasIfReserved(h.name))}`;
+        return `["${h.name}"]: ${localVarName}`;
       }
 
-      return `...(typeof ${safeName(
-        aliasNameIfReserved(h.name)
-      )} !== 'undefined' && ${safeName(
-        aliasNameIfReserved(h.name)
-      )} !== null ? { ["${h.name}"]: ${safeName(
-        aliasIfReserved(h.name)
-      )} } : {})`;
+      return `...(typeof ${localVarName} !== 'undefined' && ${localVarName} !== null ? { ["${h.name}"]: ${localVarName} } : {})`;
     })
     .concat(
       body?.type === 'json' ? ["'Content-Type': 'application/json'"] : []