Keep casing for schema types exported to root (#2524)

* Keep DTO as suffix when creating pascalCase

* Add flag to specify to keep casing of the root exports

* Added changeset

Author: gunnarvelle

.changeset/few-moments-laugh.md

@@ -0,0 +1,5 @@
+---
+"openapi-typescript": minor
+---
+
+Added flag to keep casing for exported root types

docs/cli.md

@@ -122,6 +122,7 @@ The following flags are supported in the CLI:
 | `--path-params-as-types`           |       | `false`  | Allow dynamic string lookups on the `paths` object                                                                  |
 | `--root-types`                     |       | `false`  | Exports types from `components` as root level type aliases                                                          |
 | `--root-types-no-schema-prefix`    |       | `false`  | Do not add "Schema" prefix to types at the root level (should only be used with --root-types)                       |
+| `--root-types-keep-casing`         |       | `false`  | Do not convert root type names to pascal case                                                                        |
 | `--make-paths-enum`                |       | `false`  | Generate ApiPaths enum for all paths                                                                                |
 | `--generate-path-params`           |       | `false`  | Generate path parameters for all paths where they are undefined by schema                                           |
 

packages/openapi-typescript/bin/cli.js

@@ -34,6 +34,7 @@ Options
   --root-types (optional)    Export schemas types at root level
   --root-types-no-schema-prefix (optional)
                              Do not add "Schema" prefix to types at the root level (should only be used with --root-types)
+  --root-types-keep-casing   Keep casing of root types (should only be used with --root-types)
   --make-paths-enum          Generate ApiPaths enum for all paths
 `;
 
@@ -64,6 +65,10 @@ if (args.includes("--root-types-no-schema-prefix") && !args.includes("--root-typ
   // biome-ignore lint/suspicious/noConsole: this is a CLI
   console.warn("--root-types-no-schema-prefix has no effect without --root-types flag");
 }
+if (args.includes("--root-types-keep-casing") && !args.includes("--root-types")) {
+  // biome-ignore lint/suspicious/noConsole: this is a CLI
+  console.warn("--root-types-keep-casing has no effect without --root-types flag");
+}
 
 const flags = parser(args, {
   boolean: [
@@ -86,6 +91,7 @@ const flags = parser(args, {
     "pathParamsAsTypes",
     "rootTypes",
     "rootTypesNoSchemaPrefix",
+    "rootTypesKeepCasing",
     "makePathsEnum",
     "generatePathParams",
   ],
@@ -150,6 +156,7 @@ async function generateSchema(schema, { redocly, silent = false }) {
       pathParamsAsTypes: flags.pathParamsAsTypes,
       rootTypes: flags.rootTypes,
       rootTypesNoSchemaPrefix: flags.rootTypesNoSchemaPrefix,
+      rootTypesKeepCasing: flags.rootTypesKeepCasing,
       makePathsEnum: flags.makePathsEnum,
       generatePathParams: flags.generatePathParams,
       redocly,

packages/openapi-typescript/src/index.ts

@@ -82,6 +82,7 @@ export default async function openapiTS(
     immutable: options.immutable ?? false,
     rootTypes: options.rootTypes ?? false,
     rootTypesNoSchemaPrefix: options.rootTypesNoSchemaPrefix ?? false,
+    rootTypesKeepCasing: options.rootTypesKeepCasing ?? false,
     injectFooter: [],
     pathParamsAsTypes: options.pathParamsAsTypes ?? false,
     postTransform: typeof options.postTransform === "function" ? options.postTransform : undefined,

packages/openapi-typescript/src/transform/components-object.ts

@@ -101,14 +101,15 @@ export default function transformComponentsObject(componentsObject: ComponentsOb
 
           if (!shouldSkipEnumSchema) {
             const componentKey = changeCase.pascalCase(singularizeComponentKey(key));
-            let aliasName = `${componentKey}${changeCase.pascalCase(name)}`;
+            const componentName = ctx.rootTypesKeepCasing && key === "schemas" ? name : changeCase.pascalCase(name);
+            let aliasName = `${componentKey}${componentName}`;
 
             // Add counter suffix (e.g. "_2") if conflict in name
             let conflictCounter = 1;
 
             while (rootTypeAliases[aliasName] !== undefined) {
               conflictCounter++;
-              aliasName = `${componentKey}${changeCase.pascalCase(name)}_${conflictCounter}`;
+              aliasName = `${componentKey}${componentName}_${conflictCounter}`;
             }
             const ref = ts.factory.createTypeReferenceNode(`components['${key}']['${name}']`);
             if (ctx.rootTypesNoSchemaPrefix && key === "schemas") {

packages/openapi-typescript/src/types.ts

@@ -670,6 +670,8 @@ export interface OpenAPITSOptions {
   rootTypes?: boolean;
   /** (optional) Do not add Schema prefix to types at root level */
   rootTypesNoSchemaPrefix?: boolean;
+  /** (optional) Keep casing of root types */
+  rootTypesKeepCasing?: boolean;
   /**
    * Configure Redocly for validation, schema fetching, and bundling
    * @see https://redocly.com/docs/cli/configuration/
@@ -708,6 +710,7 @@ export interface GlobalContext {
   propertiesRequiredByDefault: boolean;
   rootTypes: boolean;
   rootTypesNoSchemaPrefix: boolean;
+  rootTypesKeepCasing: boolean;
   redoc: RedoclyConfig;
   silent: boolean;
   transform: OpenAPITSOptions["transform"];

packages/openapi-typescript/test/test-helpers.ts

@@ -26,6 +26,7 @@ export const DEFAULT_CTX: GlobalContext = {
   propertiesRequiredByDefault: false,
   rootTypes: false,
   rootTypesNoSchemaPrefix: false,
+  rootTypesKeepCasing: false,
   redoc: await createConfig({}, { extends: ["minimal"] }),
   resolve($ref) {
     return resolveRef({}, $ref, { silent: false });

packages/openapi-typescript/test/transform/components-object.test.ts

@@ -757,7 +757,49 @@ export type Item = components['schemas']['Item'];
 export type Document = components['schemas']['Document'];
 export type Error = components['schemas']['Error'];
 `,
-        options: { ...DEFAULT_OPTIONS, rootTypes: true, rootTypesNoSchemaPrefix: true },
+        options: {
+          ...DEFAULT_OPTIONS,
+          rootTypes: true,
+          rootTypesNoSchemaPrefix: true,
+        },
+      },
+    ],
+    [
+      "options > rootTypes: true but keep casing",
+      {
+        given: {
+          schemas: {
+            ItemDTO: {
+              type: "object",
+              required: ["name", "url"],
+              properties: {
+                name: { type: "string" },
+                url: { type: "string" },
+              },
+            },
+          },
+        },
+        want: `{
+    schemas: {
+        ItemDTO: {
+            name: string;
+            url: string;
+        };
+    };
+    responses: never;
+    parameters: never;
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+export type ItemDTO = components['schemas']['ItemDTO'];
+`,
+        options: {
+          ...DEFAULT_OPTIONS,
+          rootTypes: true,
+          rootTypesNoSchemaPrefix: true,
+          rootTypesKeepCasing: true,
+        },
       },
     ],
     [