CR + Fix doc

Author: jgclement91

docs/src/configuration.md

@@ -66,4 +66,4 @@ Array of plugins to use. See [Using Plugins](./using-plugins) for more details.
 Options passed to OpenAPI TypeScript for type generation. You normally should
 not have to change them.
 
-[!ref target="blank" text="See OpenAPI TypeScript options"](https://openapi-ts.pages.dev/cli#flags)
+[!ref target="blank" text="See OpenAPI TypeScript options"](https://openapi-ts.dev/cli#flags)

packages/create-schemas/src/plugins/types-plugin.ts

@@ -76,33 +76,51 @@ export function isComponentsSchema(node: ts.Node): node is ts.PropertySignature
  * OpenAPI field names must match `^[a-zA-Z0-9\.\-_]+$` which allows names that
  * are not valid JavaScript/TypeScript identifiers. This function converts an
  * unsafe name into a safe name that can be used as a JavaScript/TypeScript
- * identifier.
+ * identifier using PascalCase transformation to match openapi-typescript's enum naming.
  */
 export function toSafeName(unsafeName: string): string {
     let safeName = "";
+    let capitalizeNext = true;
+
     for (const char of unsafeName) {
         const charCode = char.charCodeAt(0);
 
+        // Special characters that should trigger capitalization of next char
+        if (char === "-" || char === "." || char === " ") {
+            capitalizeNext = true;
+            continue;
+        }
+
         // A-Z
         if (charCode >= 65 && charCode <= 90) {
             safeName += char;
+            capitalizeNext = false;
+            continue;
         }
 
         // a-z
         if (charCode >= 97 && charCode <= 122) {
-            safeName += char;
+            safeName += capitalizeNext ? char.toUpperCase() : char;
+            capitalizeNext = false;
+            continue;
         }
 
-        if (char === "_" || char === "$") {
+        // 0-9
+        if (safeName.length > 0 && charCode >= 48 && charCode <= 57) {
             safeName += char;
+            capitalizeNext = false;
+            continue;
         }
 
-        // 0-9
-        if (safeName.length > 0 && charCode >= 48 && charCode <= 57) {
+        // _ and $ are valid identifier characters
+        if (char === "_" || char === "$") {
             safeName += char;
+            capitalizeNext = false;
+            continue;
         }
 
-        continue;
+        // Any other character triggers capitalization of next char but is not included
+        capitalizeNext = true;
     }
 
     return safeName;

packages/create-schemas/tests/__snapshots__/e2e.test.ts.snap

@@ -44,10 +44,16 @@ export interface components {
         Status: Status;
         /** @enum {string} */
         Priority: Priority;
+        /** @enum {string} */
+        "user-status": UserStatus;
+        /** @enum {string} */
+        "task.priority": TaskPriority;
         Task: {
             id?: string;
             status?: components["schemas"]["Status"];
             priority?: components["schemas"]["Priority"];
+            userStatus?: components["schemas"]["user-status"];
+            taskPriority?: components["schemas"]["task.priority"];
             name?: string;
         };
     };
@@ -68,6 +74,16 @@ export enum Priority {
     medium = "medium",
     high = "high"
 }
+export enum UserStatus {
+    online = "online",
+    offline = "offline",
+    away = "away"
+}
+export enum TaskPriority {
+    urgent = "urgent",
+    normal = "normal",
+    low_priority = "low-priority"
+}
 export type operations = Record<string, never>;
 
 export type Task = components["schemas"]["Task"];

packages/create-schemas/tests/data/enums.yaml

@@ -22,6 +22,18 @@ components:
         - low
         - medium
         - high
+    user-status:
+      type: string
+      enum:
+        - online
+        - offline
+        - away
+    task.priority:
+      type: string
+      enum:
+        - urgent
+        - normal
+        - low-priority
     Task:
       type: object
       properties:
@@ -31,5 +43,9 @@ components:
           $ref: '#/components/schemas/Status'
         priority:
           $ref: '#/components/schemas/Priority'
+        userStatus:
+          $ref: '#/components/schemas/user-status'
+        taskPriority:
+          $ref: '#/components/schemas/task.priority'
         name:
           type: string

packages/create-schemas/tests/e2e.test.ts

@@ -149,15 +149,21 @@ describe.concurrent("e2e", () => {
             const typesFile = result.find(file => file.filename === openapiTypeScriptFilename);
             assert(typesFile);
 
-            // Verify enums are generated
+            // Verify enums are generated (including those with special characters)
             expect(typesFile.code).toContain("export enum Status");
             expect(typesFile.code).toContain("export enum Priority");
+            expect(typesFile.code).toContain("export enum UserStatus");
+            expect(typesFile.code).toContain("export enum TaskPriority");
 
             // Verify NO duplicate type aliases for enums
             const statusTypeAliasRegex = /export type Status = components\["schemas"\]\["Status"\];/;
             const priorityTypeAliasRegex = /export type Priority = components\["schemas"\]\["Priority"\];/;
+            const userStatusTypeAliasRegex = /export type UserStatus = components\["schemas"\]\["user-status"\];/;
+            const taskPriorityTypeAliasRegex = /export type TaskPriority = components\["schemas"\]\["task\.priority"\];/;
             expect(typesFile.code).not.toMatch(statusTypeAliasRegex);
             expect(typesFile.code).not.toMatch(priorityTypeAliasRegex);
+            expect(typesFile.code).not.toMatch(userStatusTypeAliasRegex);
+            expect(typesFile.code).not.toMatch(taskPriorityTypeAliasRegex);
 
             // Verify non-enum types still get type aliases
             expect(typesFile.code).toContain('export type Task = components["schemas"]["Task"];');

packages/create-schemas/tests/generate.test.ts

@@ -19,8 +19,8 @@ describe.concurrent("generate", () => {
         expect(typesFile.code).toMatch("export type User");
         expect(typesFile.code).toMatch("export type User_1");
         expect(typesFile.code).toMatch("export type User_Name");
-        expect(typesFile.code).toMatch("export type username");
-        expect(typesFile.code).toMatch("export type myorgUser");
+        expect(typesFile.code).toMatch("export type UserName");
+        expect(typesFile.code).toMatch("export type MyOrgUser");
     });
 
     test("reject ambiguous names", async ({ expect }) => {

packages/create-schemas/tests/plugins.test.ts

@@ -65,8 +65,8 @@ describe.concurrent("plugins", () => {
           export type User = components["schemas"]["User"];
           export type User_1 = components["schemas"]["User_1"];
           export type User_Name = components["schemas"]["User_Name"];
-          export type username = components["schemas"]["user-name"];
-          export type myorgUser = components["schemas"]["my.org.User"];
+          export type UserName = components["schemas"]["user-name"];
+          export type MyOrgUser = components["schemas"]["my.org.User"];
           export type Endpoints = keyof paths;
           "
         `);
@@ -149,4 +149,31 @@ describe.concurrent("plugins", () => {
 
         expect(emittedFile).toBeUndefined();
     });
+
+    test("typesPlugin with enums", async ({ expect }) => {
+      const plugin = typesPlugin();
+      assert(plugin.transform);
+
+      const result = await plugin.transform({
+          config: await resolveConfig({ input: "openapi.json" }),
+          id: openapiTypeScriptId,
+          code: `export interface components {
+            schemas: {
+              Status: string;
+              Task: { name: string };
+            }
+          }
+          export enum Status {
+            Active = "active",
+            Inactive = "inactive"
+          }`,
+          filename: openapiTypeScriptFilename,
+          emitFile: () => void 0
+      });
+
+      assert(result);
+      
+      expect(result.code).toContain('export type Task = components["schemas"]["Task"]');
+      expect(result.code).not.toContain('export type Status = components["schemas"]["Status"]');
+});
 });