Fix duplicate enum/type alias exports in types-plugin (#53)

* Fix duplicate type alias generation for enum declarations
* 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

@@ -19,18 +19,26 @@ export function typesPlugin(): Plugin {
 
             const ast = stringToAST(code) as ts.Node[];
 
+            // Collect names of all enum declarations to avoid generating duplicate type aliases
+            const existingEnums = new Set(
+                ast
+                    .filter(node => ts.isEnumDeclaration(node))
+                    .map(node => (node as ts.EnumDeclaration).name.text)
+            );
+
             const componentsDeclaration = ast.find(isComponentsInterfaceDeclaration);
 
             assert(componentsDeclaration, "Missing components declaration");
             const schema = componentsDeclaration.members.find(isComponentsSchema);
             assert(schema, "Missing components declaration");
             assert(schema.type && ts.isTypeLiteralNode(schema.type), "Invalid schema type");
-        
+
             const typeNodes = schema.type.members
                 .map(member => member.name)
                 .filter(name => name !== undefined)
                 .filter(name => ts.isStringLiteral(name) || ts.isIdentifier(name))
                 .map(name => name.text)
+                .filter(name => !existingEnums.has(toSafeName(name)))
                 .map(name => {
                     if (RESERVED_IDENTIFIERS.has(name)) {
                         throw new Error(`Invalid schema name: ${name}`);
@@ -68,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

@@ -1,5 +1,96 @@
 // Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
 
+exports[`e2e > enums.yaml / enum generation without duplicate type aliases 1`] = `
+"/** This file has been generated by @workleap/create-schemas (https://github.com/workleap/wl-openapi-typescript). Do not modify manually. */
+export interface paths {
+    "/test": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Success */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+}
+export type webhooks = Record<string, never>;
+export interface components {
+    schemas: {
+        /** @enum {string} */
+        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;
+        };
+    };
+    responses: never;
+    parameters: never;
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+export type $defs = Record<string, never>;
+export enum Status {
+    active = "active",
+    inactive = "inactive",
+    pending = "pending"
+}
+export enum Priority {
+    low = "low",
+    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"];
+export type Endpoints = keyof paths;
+"
+`;
+
 exports[`e2e > officevice.yaml / file URLs 1`] = `
 "/** This file has been generated by @workleap/create-schemas (https://github.com/workleap/wl-openapi-typescript). Do not modify manually. */
 export interface paths {

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

@@ -0,0 +1,51 @@
+openapi: 3.0.0
+info:
+  title: Enum Test API
+  version: 1.0.0
+paths:
+  /test:
+    get:
+      responses:
+        '200':
+          description: Success
+components:
+  schemas:
+    Status:
+      type: string
+      enum:
+        - active
+        - inactive
+        - pending
+    Priority:
+      type: string
+      enum:
+        - low
+        - medium
+        - high
+    user-status:
+      type: string
+      enum:
+        - online
+        - offline
+        - away
+    task.priority:
+      type: string
+      enum:
+        - urgent
+        - normal
+        - low-priority
+    Task:
+      type: object
+      properties:
+        id:
+          type: string
+        status:
+          $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

@@ -105,7 +105,7 @@ describe.concurrent("e2e", () => {
 
             const configFile = `
             import { experimental_openapiFetchPlugin } from "../../../src/plugins";
-            
+
             export default { plugins: [experimental_openapiFetchPlugin()] };
             `;
 
@@ -124,4 +124,52 @@ describe.concurrent("e2e", () => {
         },
         timeout
     );
+
+    test(
+        "enums.yaml / enum generation without duplicate type aliases",
+        async ({ expect, onTestFinished }) => {
+            const tempFolder = await createTemporaryFolder({ onTestFinished });
+
+            const configFile = `
+            export default {
+                openApiTsOptions: {
+                    enum: true
+                }
+            };
+            `;
+
+            await writeFile(join(tempFolder, "create-schemas.config.ts"), configFile);
+
+            const result = await runCompiledBin({
+                source: join(dataFolder, "enums.yaml"),
+                outdir: join(tempFolder, "dist"),
+                cwd: tempFolder
+            });
+
+            const typesFile = result.find(file => file.filename === openapiTypeScriptFilename);
+            assert(typesFile);
+
+            // 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"];');
+
+            expect(typesFile.code).toMatchSnapshot();
+        },
+        timeout
+    );
 });

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"]');
+});
 });