zod-codegen 1.2.2 → 1.4.0

package/src/types/generator-options.ts

@@ -0,0 +1,60 @@
+import type {NamingConvention, OperationNameTransformer} from '../utils/naming-convention.js';
+
+/**
+ * Configuration options for the Generator class.
+ *
+ * These options control how operation IDs are transformed during code generation.
+ * You can either use a predefined naming convention or provide a custom transformer function.
+ *
+ * @example
+ * ```typescript
+ * // Using a naming convention
+ * const generator = new Generator(..., {
+ *   namingConvention: 'camelCase'
+ * });
+ *
+ * // Using a custom transformer
+ * const generator = new Generator(..., {
+ *   operationNameTransformer: (details) => {
+ *     return `${details.method}_${details.operationId}`;
+ *   }
+ * });
+ * ```
+ */
+export interface GeneratorOptions {
+  /**
+   * Naming convention to apply to operation IDs.
+   *
+   * If provided, all operation IDs will be transformed according to the specified convention.
+   * This is useful when OpenAPI specs have inconsistent or poorly named operation IDs.
+   *
+   * **Note:** If `operationNameTransformer` is also provided, it takes precedence.
+   *
+   * @example
+   * ```typescript
+   * { namingConvention: 'camelCase' } // Transforms 'get_user_by_id' → 'getUserById'
+   * ```
+   */
+  namingConvention?: NamingConvention;
+
+  /**
+   * Custom transformer function for operation names.
+   *
+   * If provided, this function will be called for each operation with full operation details.
+   * This allows for advanced customization based on HTTP method, path, tags, etc.
+   *
+   * **Note:** This takes precedence over `namingConvention` if both are provided.
+   * The returned name will be sanitized to ensure it's a valid TypeScript identifier.
+   *
+   * @example
+   * ```typescript
+   * {
+   *   operationNameTransformer: (details) => {
+   *     const tag = details.tags?.[0] || 'default';
+   *     return `${details.method.toUpperCase()}_${tag}_${details.operationId}`;
+   *   }
+   * }
+   * ```
+   */
+  operationNameTransformer?: OperationNameTransformer;
+}

package/src/utils/error-handler.ts

@@ -7,7 +7,7 @@ export const errorReceived = (process: NodeJS.Process, startTime: bigint) => ():
 
 export const handleErrors = (process: NodeJS.Process, startTime: bigint): void => {
   const catchErrors: string[] = ['unhandledRejection', 'uncaughtException'];
-  catchErrors.map((event): NodeJS.EventEmitter => {
-    return process.on(event, errorReceived(process, startTime));
+  catchErrors.forEach((event) => {
+    process.on(event, errorReceived(process, startTime));
   });
 };

package/src/utils/naming-convention.ts

@@ -0,0 +1,214 @@
+/**
+ * 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;
+
+/**
+ * Capitalizes the first letter of a word
+ */
+function capitalize(word: string): string {
+  if (word.length === 0) return word;
+  return word.charAt(0).toUpperCase() + word.slice(1);
+}
+
+/**
+ * Splits camelCase or PascalCase strings into words
+ */
+function splitCamelCase(input: string): string[] {
+  const words: string[] = [];
+  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: string): string[] {
+  // 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: string[]): string {
+  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: string[]): string {
+  return words.map((w) => capitalize(w)).join('');
+}
+
+/**
+ * Converts words array to snake_case
+ */
+function toSnakeCase(words: string[]): string {
+  return words.join('_');
+}
+
+/**
+ * Converts words array to kebab-case
+ */
+function toKebabCase(words: string[]): string {
+  return words.join('-');
+}
+
+/**
+ * Converts words array to SCREAMING_SNAKE_CASE
+ */
+function toScreamingSnakeCase(words: string[]): string {
+  return words.map((w) => w.toUpperCase()).join('_');
+}
+
+/**
+ * Converts words array to SCREAMING-KEBAB-CASE
+ */
+function toScreamingKebabCase(words: string[]): string {
+  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: string, convention: NamingConvention): string {
+  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/src/utils/signal-handler.ts

@@ -8,7 +8,7 @@ export const signalReceived = (process: NodeJS.Process, startTime: bigint, event
 
 export const handleSignals = (process: NodeJS.Process, startTime: bigint): void => {
   const catchSignals: NodeJS.Signals[] = ['SIGTERM', 'SIGINT', 'SIGUSR2'];
-  catchSignals.map((event): NodeJS.EventEmitter => {
-    return process.once(event, signalReceived(process, startTime, event));
+  catchSignals.forEach((event) => {
+    process.once(event, signalReceived(process, startTime, event));
   });
 };

package/tests/integration/cli.test.ts

@@ -5,7 +5,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, '../..'),
       });
@@ -18,7 +18,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/tests/unit/code-generator.test.ts

@@ -1,4 +1,4 @@
-import {describe, expect, it} from 'vitest';
+import {beforeEach, describe, expect, it} from 'vitest';
 import {TypeScriptCodeGeneratorService} from '../../src/services/code-generator.service.js';
 import type {OpenApiSpecType} from '../../src/types/openapi.js';
 
@@ -9,6 +9,194 @@ describe('TypeScriptCodeGeneratorService', () => {
     generator = new TypeScriptCodeGeneratorService();
   });
 
+  describe('naming conventions', () => {
+    it('should apply camelCase naming convention', () => {
+      const spec: OpenApiSpecType = {
+        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: OpenApiSpecType = {
+        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: OpenApiSpecType = {
+        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: OpenApiSpecType = {
+        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: {
+        operationId: string;
+        method: string;
+        path: string;
+        tags?: string[];
+        summary?: string;
+        description?: string;
+      }) => {
+        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: OpenApiSpecType = {
+        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: OpenApiSpecType = {