zod-codegen 1.3.0 → 1.4.0

package/dist/src/types/openapi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openapi.d.ts","sourceRoot":"","sources":["../../../src/types/openapi.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAEtB,eAAO,MAAM,SAAS;;iBAEpB,CAAC;AA6CH,eAAO,MAAM,gBAAgB,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,CAKxD,CAAC;AAcF,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;iBAYpB,CAAC;AAkBH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;iBAKnB,CAAC;AAEH,eAAO,MAAM,WAAW;;;;;;;iBAKtB,CAAC;AAEH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBASvB,CAAC;AAEH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAanB,CAAC;AA+CH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAStB,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAC1D,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AACpE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC;AACtD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAC;AACpD,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAC1D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAC5D,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAC;AACpD,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC"}

package/dist/src/utils/error-handler.d.ts

@@ -0,0 +1,3 @@
+export declare const errorReceived: (process: NodeJS.Process, startTime: bigint) => () => void;
+export declare const handleErrors: (process: NodeJS.Process, startTime: bigint) => void;
+//# sourceMappingURL=error-handler.d.ts.map

package/dist/src/utils/error-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-handler.d.ts","sourceRoot":"","sources":["../../../src/utils/error-handler.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa,GAAI,SAAS,MAAM,CAAC,OAAO,EAAE,WAAW,MAAM,WAAS,IAGhF,CAAC;AAEF,eAAO,MAAM,YAAY,GAAI,SAAS,MAAM,CAAC,OAAO,EAAE,WAAW,MAAM,KAAG,IAKzE,CAAC"}

package/dist/src/utils/error-handler.js

@@ -5,7 +5,7 @@ export const errorReceived = (process, startTime) => () => {
 };
 export const handleErrors = (process, startTime) => {
     const catchErrors = ['unhandledRejection', 'uncaughtException'];
-    catchErrors.map((event) => {
-        return process.on(event, errorReceived(process, startTime));
+    catchErrors.forEach((event) => {
+        process.on(event, errorReceived(process, startTime));
     });
 };

package/dist/src/utils/execution-time.d.ts

@@ -0,0 +1,2 @@
+export declare function getExecutionTime(startTime: bigint): number;
+//# sourceMappingURL=execution-time.d.ts.map

package/dist/src/utils/execution-time.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execution-time.d.ts","sourceRoot":"","sources":["../../../src/utils/execution-time.ts"],"names":[],"mappings":"AAAA,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE1D"}

package/dist/src/utils/manifest.d.ts

@@ -0,0 +1,8 @@
+interface Manifest {
+    readonly name: string;
+    readonly version: string;
+    readonly description: string;
+}
+export declare function isManifest(input: unknown): input is Manifest;
+export {};
+//# sourceMappingURL=manifest.d.ts.map

package/dist/src/utils/manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../../src/utils/manifest.ts"],"names":[],"mappings":"AAEA,UAAU,QAAQ;IAChB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAQD,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CAE5D"}

package/dist/src/utils/naming-convention.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Supported naming conventions for operation IDs.
+ * These conventions transform operation IDs to match common programming language styles.
+ *
+ * @example
+ * ```typescript
+ * transformNamingConvention('get_user_by_id', 'camelCase') // 'getUserById'
+ * transformNamingConvention('getUserById', 'snake_case') // 'get_user_by_id'
+ * ```
+ */
+export type NamingConvention = 'camelCase' | 'PascalCase' | 'snake_case' | 'kebab-case' | 'SCREAMING_SNAKE_CASE' | 'SCREAMING-KEBAB-CASE';
+/**
+ * Operation details provided to custom transformers.
+ * Contains all available information about an OpenAPI operation.
+ *
+ * @example
+ * ```typescript
+ * const transformer: OperationNameTransformer = (details) => {
+ *   return `${details.method.toUpperCase()}_${details.operationId}`;
+ * };
+ * ```
+ */
+export interface OperationDetails {
+    /** Original operationId from OpenAPI spec */
+    operationId: string;
+    /** HTTP method (get, post, put, patch, delete, head, options) */
+    method: string;
+    /** API path (e.g., /users/{id}) */
+    path: string;
+    /** Tags associated with the operation */
+    tags?: string[];
+    /** Summary of the operation */
+    summary?: string;
+    /** Description of the operation */
+    description?: string;
+}
+/**
+ * Custom transformer function for operation names.
+ * Receives operation details and returns the transformed name.
+ *
+ * **Note:** The returned name will be sanitized to ensure it's a valid TypeScript identifier.
+ * Invalid characters will be replaced with underscores, and names starting with digits will be prefixed.
+ *
+ * @param details - Complete operation details from OpenAPI spec
+ * @returns The transformed operation name
+ *
+ * @example
+ * ```typescript
+ * const transformer: OperationNameTransformer = (details) => {
+ *   const tag = details.tags?.[0] || 'default';
+ *   return `${details.method}_${tag}_${details.operationId}`;
+ * };
+ * ```
+ */
+export type OperationNameTransformer = (details: OperationDetails) => string;
+/**
+ * Transforms a string to the specified naming convention.
+ *
+ * Handles various input formats including camelCase, PascalCase, snake_case, kebab-case,
+ * and mixed delimiters. The function normalizes the input by splitting on common delimiters
+ * (underscores, hyphens, spaces, dots) and then applies the target convention.
+ *
+ * **Note:** This function does not sanitize the output. The caller should ensure the result
+ * is a valid identifier for the target language (e.g., using `sanitizeIdentifier`).
+ *
+ * @param input - The input string to transform (can be in any naming convention)
+ * @param convention - The target naming convention to apply
+ * @returns The transformed string in the target convention
+ *
+ * @example
+ * ```typescript
+ * transformNamingConvention('get_user_by_id', 'camelCase') // 'getUserById'
+ * transformNamingConvention('getUserById', 'snake_case') // 'get_user_by_id'
+ * transformNamingConvention('get-user-by-id', 'PascalCase') // 'GetUserById'
+ * ```
+ *
+ * @throws Will return empty string if input is empty (preserves empty input)
+ */
+export declare function transformNamingConvention(input: string, convention: NamingConvention): string;
+//# sourceMappingURL=naming-convention.d.ts.map

package/dist/src/utils/naming-convention.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"naming-convention.d.ts","sourceRoot":"","sources":["../../../src/utils/naming-convention.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,MAAM,gBAAgB,GACxB,WAAW,GACX,YAAY,GACZ,YAAY,GACZ,YAAY,GACZ,sBAAsB,GACtB,sBAAsB,CAAC;AAE3B;;;;;;;;;;GAUG;AACH,MAAM,WAAW,gBAAgB;IAC/B,6CAA6C;IAC7C,WAAW,EAAE,MAAM,CAAC;IACpB,iEAAiE;IACjE,MAAM,EAAE,MAAM,CAAC;IACf,mCAAmC;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,yCAAyC;IACzC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,+BAA+B;IAC/B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,mCAAmC;IACnC,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,wBAAwB,GAAG,CAAC,OAAO,EAAE,gBAAgB,KAAK,MAAM,CAAC;AA0G7E;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,gBAAgB,GAAG,MAAM,CAsB7F"}

package/dist/src/utils/naming-convention.js

@@ -0,0 +1,135 @@
+/**
+ * Capitalizes the first letter of a word
+ */
+function capitalize(word) {
+    if (word.length === 0)
+        return word;
+    return word.charAt(0).toUpperCase() + word.slice(1);
+}
+/**
+ * Splits camelCase or PascalCase strings into words
+ */
+function splitCamelCase(input) {
+    const words = [];
+    let currentWord = '';
+    for (const char of input) {
+        const isUpperCase = char === char.toUpperCase() && char !== char.toLowerCase();
+        const isDigit = /\d/.test(char);
+        const lastChar = currentWord[currentWord.length - 1];
+        // Start a new word if:
+        // 1. Current char is uppercase and we have a previous word
+        // 2. Current char is a digit and previous was not
+        if (currentWord.length > 0 && (isUpperCase || (isDigit && lastChar && !/\d/.test(lastChar)))) {
+            words.push(currentWord);
+            currentWord = '';
+        }
+        currentWord += char;
+    }
+    if (currentWord.length > 0) {
+        words.push(currentWord);
+    }
+    return words.length > 0 ? words : [input];
+}
+/**
+ * Normalizes input string into an array of words
+ * Handles camelCase, PascalCase, snake_case, kebab-case, SCREAMING_SNAKE_CASE, etc.
+ */
+function normalizeToWords(input) {
+    // Handle empty or single character
+    if (input.length <= 1) {
+        return [input.toLowerCase()];
+    }
+    // Split by common delimiters: underscore, hyphen, space, dot
+    let words = input.split(/[-_\s.]+/).filter((w) => w.length > 0);
+    // If no delimiters found, try to split camelCase/PascalCase
+    if (words.length === 1) {
+        words = splitCamelCase(input);
+    }
+    // Normalize all words to lowercase
+    return words.map((w) => w.toLowerCase());
+}
+/**
+ * Converts words array to camelCase
+ */
+function toCamelCase(words) {
+    if (words.length === 0)
+        return '';
+    const [first, ...rest] = words;
+    if (!first)
+        return '';
+    return first + rest.map((w) => capitalize(w)).join('');
+}
+/**
+ * Converts words array to PascalCase
+ */
+function toPascalCase(words) {
+    return words.map((w) => capitalize(w)).join('');
+}
+/**
+ * Converts words array to snake_case
+ */
+function toSnakeCase(words) {
+    return words.join('_');
+}
+/**
+ * Converts words array to kebab-case
+ */
+function toKebabCase(words) {
+    return words.join('-');
+}
+/**
+ * Converts words array to SCREAMING_SNAKE_CASE
+ */
+function toScreamingSnakeCase(words) {
+    return words.map((w) => w.toUpperCase()).join('_');
+}
+/**
+ * Converts words array to SCREAMING-KEBAB-CASE
+ */
+function toScreamingKebabCase(words) {
+    return words.map((w) => w.toUpperCase()).join('-');
+}
+/**
+ * Transforms a string to the specified naming convention.
+ *
+ * Handles various input formats including camelCase, PascalCase, snake_case, kebab-case,
+ * and mixed delimiters. The function normalizes the input by splitting on common delimiters
+ * (underscores, hyphens, spaces, dots) and then applies the target convention.
+ *
+ * **Note:** This function does not sanitize the output. The caller should ensure the result
+ * is a valid identifier for the target language (e.g., using `sanitizeIdentifier`).
+ *
+ * @param input - The input string to transform (can be in any naming convention)
+ * @param convention - The target naming convention to apply
+ * @returns The transformed string in the target convention
+ *
+ * @example
+ * ```typescript
+ * transformNamingConvention('get_user_by_id', 'camelCase') // 'getUserById'
+ * transformNamingConvention('getUserById', 'snake_case') // 'get_user_by_id'
+ * transformNamingConvention('get-user-by-id', 'PascalCase') // 'GetUserById'
+ * ```
+ *
+ * @throws Will return empty string if input is empty (preserves empty input)
+ */
+export function transformNamingConvention(input, convention) {
+    if (!input || input.length === 0) {
+        return input;
+    }
+    // Normalize input: split by common delimiters and convert to words
+    const words = normalizeToWords(input);
+    switch (convention) {
+        case 'camelCase':
+            return toCamelCase(words);
+        case 'PascalCase':
+            return toPascalCase(words);
+        case 'snake_case':
+            return toSnakeCase(words);
+        case 'kebab-case':
+            return toKebabCase(words);
+        case 'SCREAMING_SNAKE_CASE':
+            return toScreamingSnakeCase(words);
+        case 'SCREAMING-KEBAB-CASE':
+            return toScreamingKebabCase(words);
+    }
+}

package/dist/src/utils/reporter.d.ts

@@ -0,0 +1,7 @@
+export declare class Reporter {
+    private readonly _stdout;
+    constructor(_stdout: NodeJS.WriteStream);
+    log(...args: readonly unknown[]): void;
+    error(...args: readonly unknown[]): void;
+}
+//# sourceMappingURL=reporter.d.ts.map

package/dist/src/utils/reporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reporter.d.ts","sourceRoot":"","sources":["../../../src/utils/reporter.ts"],"names":[],"mappings":"AAEA,qBAAa,QAAQ;IACP,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,EAAE,MAAM,CAAC,WAAW;IAKxD,GAAG,CAAC,GAAG,IAAI,EAAE,SAAS,OAAO,EAAE,GAAG,IAAI;IAItC,KAAK,CAAC,GAAG,IAAI,EAAE,SAAS,OAAO,EAAE,GAAG,IAAI;CAGzC"}

package/dist/src/utils/signal-handler.d.ts

@@ -0,0 +1,3 @@
+export declare const signalReceived: (process: NodeJS.Process, startTime: bigint, event: NodeJS.Signals) => () => void;
+export declare const handleSignals: (process: NodeJS.Process, startTime: bigint) => void;
+//# sourceMappingURL=signal-handler.d.ts.map

package/dist/src/utils/signal-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signal-handler.d.ts","sourceRoot":"","sources":["../../../src/utils/signal-handler.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,cAAc,GAAI,SAAS,MAAM,CAAC,OAAO,EAAE,WAAW,MAAM,EAAE,OAAO,MAAM,CAAC,OAAO,WAAS,IAIxG,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,SAAS,MAAM,CAAC,OAAO,EAAE,WAAW,MAAM,KAAG,IAK1E,CAAC"}

package/dist/src/utils/signal-handler.js

@@ -6,7 +6,7 @@ export const signalReceived = (process, startTime, event) => () => {
 };
 export const handleSignals = (process, startTime) => {
     const catchSignals = ['SIGTERM', 'SIGINT', 'SIGUSR2'];
-    catchSignals.map((event) => {
-        return process.once(event, signalReceived(process, startTime, event));
+    catchSignals.forEach((event) => {
+        process.once(event, signalReceived(process, startTime, event));
     });
 };

package/dist/src/utils/tty.d.ts

@@ -0,0 +1,2 @@
+export declare function isTTY(process: NodeJS.Process): boolean;
+//# sourceMappingURL=tty.d.ts.map

package/dist/src/utils/tty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tty.d.ts","sourceRoot":"","sources":["../../../src/utils/tty.ts"],"names":[],"mappings":"AAAA,wBAAgB,KAAK,CAAC,OAAO,EAAE,MAAM,CAAC,OAAO,GAAG,OAAO,CAEtD"}

package/dist/tests/integration/cli.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=cli.test.d.ts.map

package/dist/tests/integration/cli.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.test.d.ts","sourceRoot":"","sources":["../../../tests/integration/cli.test.ts"],"names":[],"mappings":""}

package/dist/tests/integration/cli.test.js

@@ -4,7 +4,7 @@ import { resolve } from 'node:path';
 describe('CLI Integration', () => {
     describe('--help', () => {
         it('should display help information', () => {
-            const result = execSync('yarn build && node ./dist/src/cli.js --help', {
+            const result = execSync('npm run build && node ./dist/src/cli.js --help', {
                 encoding: 'utf-8',
                 cwd: resolve(__dirname, '../..'),
             });
@@ -15,7 +15,7 @@ describe('CLI Integration', () => {
     });
     describe('--version', () => {
         it('should display version information', () => {
-            const result = execSync('yarn build && node ./dist/src/cli.js --version', {
+            const result = execSync('npm run build && node ./dist/src/cli.js --version', {
                 encoding: 'utf-8',
                 cwd: resolve(__dirname, '../..'),
             });

package/dist/tests/unit/code-generator.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=code-generator.test.d.ts.map

package/dist/tests/unit/code-generator.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-generator.test.d.ts","sourceRoot":"","sources":["../../../tests/unit/code-generator.test.ts"],"names":[],"mappings":""}

package/dist/tests/unit/code-generator.test.js

@@ -1,10 +1,179 @@
-import { describe, expect, it } from 'vitest';
+import { beforeEach, describe, expect, it } from 'vitest';
 import { TypeScriptCodeGeneratorService } from '../../src/services/code-generator.service.js';
 describe('TypeScriptCodeGeneratorService', () => {
     let generator;
     beforeEach(() => {
         generator = new TypeScriptCodeGeneratorService();
     });
+    describe('naming conventions', () => {
+        it('should apply camelCase naming convention', () => {
+            const spec = {
+                openapi: '3.0.0',
+                info: {
+                    title: 'Test API',
+                    version: '1.0.0',
+                },
+                paths: {
+                    '/users': {
+                        get: {
+                            operationId: 'get_user_by_id',
+                            responses: {
+                                '200': {
+                                    description: 'Success',
+                                    content: {
+                                        'application/json': {
+                                            schema: { type: 'string' },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            };
+            const generatorWithConvention = new TypeScriptCodeGeneratorService({
+                namingConvention: 'camelCase',
+            });
+            const code = generatorWithConvention.generate(spec);
+            expect(code).toContain('async getUserById');
+            expect(code).not.toContain('async get_user_by_id');
+        });
+        it('should apply PascalCase naming convention', () => {
+            const spec = {
+                openapi: '3.0.0',
+                info: {
+                    title: 'Test API',
+                    version: '1.0.0',
+                },
+                paths: {
+                    '/users': {
+                        get: {
+                            operationId: 'get_user_by_id',
+                            responses: {
+                                '200': {
+                                    description: 'Success',
+                                    content: {
+                                        'application/json': {
+                                            schema: { type: 'string' },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            };
+            const generatorWithConvention = new TypeScriptCodeGeneratorService({
+                namingConvention: 'PascalCase',
+            });
+            const code = generatorWithConvention.generate(spec);
+            expect(code).toContain('async GetUserById');
+            expect(code).not.toContain('async get_user_by_id');
+        });
+        it('should apply snake_case naming convention', () => {
+            const spec = {
+                openapi: '3.0.0',
+                info: {
+                    title: 'Test API',
+                    version: '1.0.0',
+                },
+                paths: {
+                    '/users': {
+                        get: {
+                            operationId: 'getUserById',
+                            responses: {
+                                '200': {
+                                    description: 'Success',
+                                    content: {
+                                        'application/json': {
+                                            schema: { type: 'string' },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            };
+            const generatorWithConvention = new TypeScriptCodeGeneratorService({
+                namingConvention: 'snake_case',
+            });
+            const code = generatorWithConvention.generate(spec);
+            expect(code).toContain('async get_user_by_id');
+            expect(code).not.toContain('async getUserById');
+        });
+        it('should use custom transformer when provided', () => {
+            const spec = {
+                openapi: '3.0.0',
+                info: {
+                    title: 'Test API',
+                    version: '1.0.0',
+                },
+                paths: {
+                    '/users/{id}': {
+                        get: {
+                            operationId: 'getUserById',
+                            tags: ['users'],
+                            summary: 'Get user',
+                            responses: {
+                                '200': {
+                                    description: 'Success',
+                                    content: {
+                                        'application/json': {
+                                            schema: { type: 'string' },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            };
+            const customTransformer = (details) => {
+                return `${details.method.toUpperCase()}_${details.tags?.[0] || 'default'}_${details.operationId}`;
+            };
+            const generatorWithTransformer = new TypeScriptCodeGeneratorService({
+                operationNameTransformer: customTransformer,
+            });
+            const code = generatorWithTransformer.generate(spec);
+            expect(code).toContain('async GET_users_getUserById');
+        });
+        it('should prioritize custom transformer over naming convention', () => {
+            const spec = {
+                openapi: '3.0.0',
+                info: {
+                    title: 'Test API',
+                    version: '1.0.0',
+                },
+                paths: {
+                    '/users': {
+                        get: {
+                            operationId: 'get_user_by_id',
+                            responses: {
+                                '200': {
+                                    description: 'Success',
+                                    content: {
+                                        'application/json': {
+                                            schema: { type: 'string' },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            };
+            const customTransformer = () => 'customName';
+            const generatorWithBoth = new TypeScriptCodeGeneratorService({
+                namingConvention: 'PascalCase',
+                operationNameTransformer: customTransformer,
+            });
+            const code = generatorWithBoth.generate(spec);
+            expect(code).toContain('async customName');
+            expect(code).not.toContain('GetUserById');
+            expect(code).not.toContain('get_user_by_id');
+        });
+    });
     describe('generate', () => {
         it('should generate code for a minimal OpenAPI spec', () => {
             const spec = {

package/dist/tests/unit/file-reader.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=file-reader.test.d.ts.map

package/dist/tests/unit/file-reader.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-reader.test.d.ts","sourceRoot":"","sources":["../../../tests/unit/file-reader.test.ts"],"names":[],"mappings":""}

package/dist/tests/unit/generator.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=generator.test.d.ts.map

package/dist/tests/unit/generator.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator.test.d.ts","sourceRoot":"","sources":["../../../tests/unit/generator.test.ts"],"names":[],"mappings":""}

package/dist/tests/unit/naming-convention.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=naming-convention.test.d.ts.map

package/dist/tests/unit/naming-convention.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"naming-convention.test.d.ts","sourceRoot":"","sources":["../../../tests/unit/naming-convention.test.ts"],"names":[],"mappings":""}