zod-codegen 1.3.0 → 1.4.1

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

@@ -0,0 +1,263 @@
+import {describe, expect, it} from 'vitest';
+import {transformNamingConvention, type NamingConvention} from '../../src/utils/naming-convention.js';
+
+describe('transformNamingConvention', () => {
+  describe('transform', () => {
+    const testCases: Array<{
+      input: string;
+      convention: NamingConvention;
+      expected: string;
+      description: string;
+    }> = [
+      // camelCase
+      {
+        input: 'get_user_by_id',
+        convention: 'camelCase',
+        expected: 'getUserById',
+        description: 'should convert snake_case to camelCase',
+      },
+      {
+        input: 'GetUserById',
+        convention: 'camelCase',
+        expected: 'getUserById',
+        description: 'should convert PascalCase to camelCase',
+      },
+      {
+        input: 'get-user-by-id',
+        convention: 'camelCase',
+        expected: 'getUserById',
+        description: 'should convert kebab-case to camelCase',
+      },
+      {
+        input: 'getUserById',
+        convention: 'camelCase',
+        expected: 'getUserById',
+        description: 'should keep camelCase as camelCase',
+      },
+
+      // PascalCase
+      {
+        input: 'get_user_by_id',
+        convention: 'PascalCase',
+        expected: 'GetUserById',
+        description: 'should convert snake_case to PascalCase',
+      },
+      {
+        input: 'get-user-by-id',
+        convention: 'PascalCase',
+        expected: 'GetUserById',
+        description: 'should convert kebab-case to PascalCase',
+      },
+      {
+        input: 'getUserById',
+        convention: 'PascalCase',
+        expected: 'GetUserById',
+        description: 'should convert camelCase to PascalCase',
+      },
+
+      // snake_case
+      {
+        input: 'getUserById',
+        convention: 'snake_case',
+        expected: 'get_user_by_id',
+        description: 'should convert camelCase to snake_case',
+      },
+      {
+        input: 'GetUserById',
+        convention: 'snake_case',
+        expected: 'get_user_by_id',
+        description: 'should convert PascalCase to snake_case',
+      },
+      {
+        input: 'get-user-by-id',
+        convention: 'snake_case',
+        expected: 'get_user_by_id',
+        description: 'should convert kebab-case to snake_case',
+      },
+
+      // kebab-case
+      {
+        input: 'getUserById',
+        convention: 'kebab-case',
+        expected: 'get-user-by-id',
+        description: 'should convert camelCase to kebab-case',
+      },
+      {
+        input: 'GetUserById',
+        convention: 'kebab-case',
+        expected: 'get-user-by-id',
+        description: 'should convert PascalCase to kebab-case',
+      },
+      {
+        input: 'get_user_by_id',
+        convention: 'kebab-case',
+        expected: 'get-user-by-id',
+        description: 'should convert snake_case to kebab-case',
+      },
+
+      // SCREAMING_SNAKE_CASE
+      {
+        input: 'getUserById',
+        convention: 'SCREAMING_SNAKE_CASE',
+        expected: 'GET_USER_BY_ID',
+        description: 'should convert camelCase to SCREAMING_SNAKE_CASE',
+      },
+      {
+        input: 'get-user-by-id',
+        convention: 'SCREAMING_SNAKE_CASE',
+        expected: 'GET_USER_BY_ID',
+        description: 'should convert kebab-case to SCREAMING_SNAKE_CASE',
+      },
+
+      // SCREAMING-KEBAB-CASE
+      {
+        input: 'getUserById',
+        convention: 'SCREAMING-KEBAB-CASE',
+        expected: 'GET-USER-BY-ID',
+        description: 'should convert camelCase to SCREAMING-KEBAB-CASE',
+      },
+      {
+        input: 'get_user_by_id',
+        convention: 'SCREAMING-KEBAB-CASE',
+        expected: 'GET-USER-BY-ID',
+        description: 'should convert snake_case to SCREAMING-KEBAB-CASE',
+      },
+
+      // Edge cases
+      {
+        input: '',
+        convention: 'camelCase',
+        expected: '',
+        description: 'should handle empty string',
+      },
+      {
+        input: 'a',
+        convention: 'camelCase',
+        expected: 'a',
+        description: 'should handle single character',
+      },
+      {
+        input: 'API',
+        convention: 'camelCase',
+        expected: 'aPI',
+        description: 'should handle all uppercase (splits at uppercase boundaries)',
+      },
+      {
+        input: 'getUser123ById',
+        convention: 'snake_case',
+        expected: 'get_user_123_by_id',
+        description: 'should handle numbers in identifiers (splits at digit boundaries)',
+      },
+    ];
+
+    testCases.forEach(({input, convention, expected, description}) => {
+      it(description, () => {
+        const result = transformNamingConvention(input, convention);
+        expect(result).toBe(expected);
+      });
+    });
+  });
+
+  describe('edge cases', () => {
+    describe('consecutive delimiters', () => {
+      it('should handle consecutive underscores', () => {
+        expect(transformNamingConvention('get__user__by__id', 'camelCase')).toBe('getUserById');
+      });
+
+      it('should handle consecutive hyphens', () => {
+        expect(transformNamingConvention('get--user--by--id', 'snake_case')).toBe('get_user_by_id');
+      });
+
+      it('should handle mixed consecutive delimiters', () => {
+        expect(transformNamingConvention('get__user--by_id', 'kebab-case')).toBe('get-user-by-id');
+      });
+    });
+
+    describe('mixed delimiters', () => {
+      it('should handle snake_case and kebab-case mixed', () => {
+        // Note: Delimiters split the string, so 'byId' becomes 'by' and 'id' (normalized to lowercase)
+        expect(transformNamingConvention('get_user-byId', 'camelCase')).toBe('getUserByid');
+      });
+
+      it('should handle camelCase with underscores', () => {
+        // Note: Underscore delimiter splits, so 'byId' becomes 'by' and 'id'
+        expect(transformNamingConvention('getUser_byId', 'PascalCase')).toBe('GetuserByid');
+      });
+
+      it('should handle dots as delimiters', () => {
+        expect(transformNamingConvention('get.user.by.id', 'snake_case')).toBe('get_user_by_id');
+      });
+
+      it('should handle spaces as delimiters', () => {
+        expect(transformNamingConvention('get user by id', 'kebab-case')).toBe('get-user-by-id');
+      });
+    });
+
+    describe('unicode and special characters', () => {
+      it('should handle accented characters', () => {
+        expect(transformNamingConvention('getRésumé', 'snake_case')).toBe('get_résumé');
+      });
+
+      it('should handle numbers at start', () => {
+        expect(transformNamingConvention('123getUser', 'camelCase')).toBe('123getUser');
+      });
+
+      it('should handle single uppercase letter', () => {
+        expect(transformNamingConvention('getX', 'snake_case')).toBe('get_x');
+      });
+
+      it('should handle all numbers', () => {
+        expect(transformNamingConvention('123456', 'camelCase')).toBe('123456');
+      });
+    });
+
+    describe('acronyms and abbreviations', () => {
+      it('should handle acronyms in camelCase (splits on uppercase boundaries)', () => {
+        // Note: Algorithm splits on uppercase boundaries, so 'XML' becomes 'X', 'M', 'L'
+        // This is correct behavior - detecting acronyms would require a dictionary
+        expect(transformNamingConvention('getXMLData', 'snake_case')).toBe('get_x_m_l_data');
+      });
+
+      it('should handle multiple acronyms (splits on uppercase boundaries)', () => {
+        // Note: 'JSON' and 'XML' are split into individual letters
+        // 'parseJSONToXML' → ['parse', 'j', 's', 'o', 'n', 'to', 'x', 'm', 'l']
+        expect(transformNamingConvention('parseJSONToXML', 'kebab-case')).toBe('parse-j-s-o-n-to-x-m-l');
+      });
+
+      it('should handle ID abbreviation (splits on uppercase boundaries)', () => {
+        // Note: 'ID' is split into 'I' and 'D' because the algorithm splits on uppercase boundaries
+        // This is correct behavior - detecting acronyms would require a dictionary
+        expect(transformNamingConvention('getUserID', 'snake_case')).toBe('get_user_i_d');
+      });
+    });
+
+    describe('already transformed names', () => {
+      it('should be idempotent for camelCase', () => {
+        const input = 'getUserById';
+        const result = transformNamingConvention(input, 'camelCase');
+        expect(transformNamingConvention(result, 'camelCase')).toBe(result);
+      });
+
+      it('should be idempotent for snake_case', () => {
+        const input = 'get_user_by_id';
+        const result = transformNamingConvention(input, 'snake_case');
+        expect(transformNamingConvention(result, 'snake_case')).toBe(result);
+      });
+    });
+
+    describe('special patterns', () => {
+      it('should handle single word', () => {
+        expect(transformNamingConvention('user', 'PascalCase')).toBe('User');
+      });
+
+      it('should handle two words', () => {
+        expect(transformNamingConvention('getUser', 'snake_case')).toBe('get_user');
+      });
+
+      it('should handle very long names', () => {
+        const longName = 'getVeryLongOperationNameWithManyWords';
+        expect(transformNamingConvention(longName, 'kebab-case')).toBe('get-very-long-operation-name-with-many-words');
+      });
+    });
+  });
+});

package/tsconfig.json

@@ -13,6 +13,8 @@
     "lib": ["ES2022", "DOM"],
     "module": "ESNext",
     "moduleResolution": "Bundler",
+    "declaration": true,
+    "declarationMap": true,
     "noEmit": false,
     "noFallthroughCasesInSwitch": true,
     "noImplicitAny": true,
@@ -39,6 +41,6 @@
     "useUnknownInCatchVariables": true,
     "verbatimModuleSyntax": true
   },
-  "exclude": ["node_modules", "dist", "build", "examples/**/*.ts"],
+  "exclude": ["node_modules", "dist", "build", "examples/**/*.ts", "tests/**/*.ts", "scripts/**/*.ts"],
   "include": ["src/**/*.ts", "scripts/**/*.ts", "tests/**/*.ts", "vitest.config.ts"]
 }

package/.claude/settings.local.json

@@ -1,43 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(npm install:*)",
-      "Bash(npm uninstall:*)",
-      "Bash(npm run type-check:*)",
-      "Bash(npm run build:*)",
-      "Bash(./dist/src/cli.js --help)",
-      "Bash(./dist/src/cli.js --version)",
-      "Bash(npm run dev:*)",
-      "Bash(node:*)",
-      "Bash(npm run lint)",
-      "Bash(npx husky init:*)",
-      "Bash(chmod:*)",
-      "Bash(npm run validate:*)",
-      "Bash(npm run format:*)",
-      "Bash(npm run test:*)",
-      "Bash(npm test)",
-      "Bash(npm audit:*)",
-      "Bash(npx depcheck:*)",
-      "Bash(npm outdated)",
-      "Bash(npm update:*)",
-      "WebSearch",
-      "Bash(find:*)",
-      "Bash(npx zod-codegen:*)",
-      "Bash(DEBUG=1 node ./dist/src/cli.js --input ./samples/openapi.json --output ./test-generated)",
-      "Bash(rm:*)",
-      "Bash(npm outdated:*)",
-      "Bash(npm view:*)",
-      "Bash(git tag:*)",
-      "Bash(npm run release:*)",
-      "Bash(git log:*)",
-      "Bash(npx commitlint:*)",
-      "Bash(git rev-list:*)",
-      "Bash(./fix-commit-messages.sh:*)",
-      "Bash(git add:*)",
-      "Bash(git commit:*)",
-      "Bash(FILTER_BRANCH_SQUELCH_WARNING=1 ./fix-commit-messages.sh)"
-    ],
-    "deny": [],
-    "ask": []
-  }
-}

package/dist/scripts/update-manifest.js

@@ -1,31 +0,0 @@
-import { readFileSync, writeFileSync } from 'fs';
-import { resolve } from 'path';
-import { z } from 'zod';
-/**
- * Type guard for the package.json object
- *
- * @param input Unknown input
- * @returns true if the input is an event object
- */
-export function isPackageJson(input) {
-    const event = z
-        .object({
-        name: z.string(),
-        version: z.string(),
-        description: z.string(),
-    })
-        .strict()
-        .catchall(z.any())
-        .required();
-    const { success } = event.safeParse(input);
-    return success;
-}
-const sourcePath = resolve(__dirname, '..', 'package.json');
-const data = JSON.parse(readFileSync(sourcePath, 'utf8'));
-if (!isPackageJson(data)) {
-    process.exit(1);
-}
-const { name, version, description } = data;
-const targetPath = resolve(__dirname, '..', 'src', 'assets', 'manifest.json');
-writeFileSync(targetPath, JSON.stringify({ name, version, description }, null, 2));
-process.exit(0);

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

@@ -1,25 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { execSync } from 'node:child_process';
-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', {
-                encoding: 'utf-8',
-                cwd: resolve(__dirname, '../..'),
-            });
-            expect(result).toContain('Usage:');
-            expect(result).toContain('--input');
-            expect(result).toContain('--output');
-        });
-    });
-    describe('--version', () => {
-        it('should display version information', () => {
-            const result = execSync('yarn build && node ./dist/src/cli.js --version', {
-                encoding: 'utf-8',
-                cwd: resolve(__dirname, '../..'),
-            });
-            expect(result).toMatch(/\d+\.\d+\.\d+/);
-        });
-    });
-});

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

@@ -1,290 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { TypeScriptCodeGeneratorService } from '../../src/services/code-generator.service.js';
-describe('TypeScriptCodeGeneratorService', () => {
-    let generator;
-    beforeEach(() => {
-        generator = new TypeScriptCodeGeneratorService();
-    });
-    describe('generate', () => {
-        it('should generate code for a minimal OpenAPI spec', () => {
-            const spec = {
-                openapi: '3.0.0',
-                info: {
-                    title: 'Test API',
-                    version: '1.0.0',
-                },
-                paths: {},
-            };
-            const code = generator.generate(spec);
-            expect(code).toBeTruthy();
-            expect(typeof code).toBe('string');
-            expect(code).toMatch(/import\s*{\s*z\s*}\s*from\s*['"]zod['"]/);
-            expect(code).toContain('export class');
-        });
-        it('should generate schemas for component schemas', () => {
-            const spec = {
-                openapi: '3.0.0',
-                info: {
-                    title: 'Test API',
-                    version: '1.0.0',
-                },
-                paths: {},
-                components: {
-                    schemas: {
-                        User: {
-                            type: 'object',
-                            properties: {
-                                id: { type: 'integer' },
-                                name: { type: 'string' },
-                            },
-                            required: ['id', 'name'],
-                        },
-                    },
-                },
-            };
-            const code = generator.generate(spec);
-            expect(code).toContain('export const User');
-            expect(code).toContain('z.object');
-            expect(code).toContain('z.number().int()');
-            expect(code).toContain('z.string()');
-        });
-        it('should generate client methods for paths', () => {
-            const spec = {
-                openapi: '3.0.0',
-                info: {
-                    title: 'Test API',
-                    version: '1.0.0',
-                },
-                paths: {
-                    '/users': {
-                        get: {
-                            operationId: 'getUsers',
-                            responses: {
-                                '200': {
-                                    description: 'Success',
-                                    content: {
-                                        'application/json': {
-                                            schema: {
-                                                type: 'array',
-                                                items: { type: 'string' },
-                                            },
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-            };
-            const code = generator.generate(spec);
-            expect(code).toContain('async getUsers');
-            expect(code).toContain('#makeRequest');
-        });
-        it('should generate getBaseRequestOptions method', () => {
-            const spec = {
-                openapi: '3.0.0',
-                info: {
-                    title: 'Test API',
-                    version: '1.0.0',
-                },
-                paths: {},
-            };
-            const code = generator.generate(spec);
-            expect(code).toContain('protected getBaseRequestOptions');
-            expect(code).toContain('Partial<Omit<RequestInit');
-        });
-        it('should handle servers configuration', () => {
-            const spec = {
-                openapi: '3.0.0',
-                info: {
-                    title: 'Test API',
-                    version: '1.0.0',
-                },
-                servers: [{ url: 'https://api.example.com' }],
-                paths: {},
-            };
-            const code = generator.generate(spec);
-            expect(code).toContain('defaultBaseUrl');
-            expect(code).toContain('https://api.example.com');
-        });
-        it('should handle complex schemas with references', () => {
-            const spec = {
-                openapi: '3.0.0',
-                info: {
-                    title: 'Test API',
-                    version: '1.0.0',
-                },
-                paths: {},
-                components: {
-                    schemas: {
-                        User: {
-                            type: 'object',
-                            properties: {
-                                id: { type: 'integer' },
-                                profile: { $ref: '#/components/schemas/Profile' },
-                            },
-                            required: ['id'],
-                        },
-                        Profile: {
-                            type: 'object',
-                            properties: {
-                                name: { type: 'string' },
-                                email: { type: 'string', format: 'email' },
-                            },
-                            required: ['name', 'email'],
-                        },
-                    },
-                },
-            };
-            const code = generator.generate(spec);
-            expect(code).toContain('export const User');
-            expect(code).toContain('export const Profile');
-            // Profile should be defined before User (topological sort)
-            const profileIndex = code.indexOf('Profile');
-            const userIndex = code.indexOf('User');
-            expect(profileIndex).toBeLessThan(userIndex);
-        });
-        it('should handle enum types', () => {
-            const spec = {
-                openapi: '3.0.0',
-                info: {
-                    title: 'Test API',
-                    version: '1.0.0',
-                },
-                paths: {},
-                components: {
-                    schemas: {
-                        Status: {
-                            type: 'string',
-                            enum: ['active', 'inactive', 'pending'],
-                        },
-                    },
-                },
-            };
-            const code = generator.generate(spec);
-            expect(code).toContain('z.enum');
-            expect(code).toContain('active');
-            expect(code).toContain('inactive');
-            expect(code).toContain('pending');
-        });
-        it('should handle numeric enum types with z.union and z.literal', () => {
-            const spec = {
-                openapi: '3.0.0',
-                info: {
-                    title: 'Test API',
-                    version: '1.0.0',
-                },
-                paths: {},
-                components: {
-                    schemas: {
-                        Status: {
-                            type: 'integer',
-                            enum: [-99, 0, 1, 2],
-                        },
-                        ExecutionMode: {
-                            type: 'integer',
-                            enum: [1, 2],
-                        },
-                    },
-                },
-            };
-            const code = generator.generate(spec);
-            // Numeric enums should use z.union([z.literal(...), ...])
-            expect(code).toContain('z.union');
-            expect(code).toContain('z.literal');
-            expect(code).toContain('-99');
-            expect(code).toContain('0');
-            expect(code).toContain('1');
-            expect(code).toContain('2');
-            // Should not use z.enum for numeric enums
-            expect(code).not.toContain('Status: z.enum');
-            expect(code).not.toContain('ExecutionMode: z.enum');
-        });
-        it('should merge baseOptions with request-specific options in #makeRequest', () => {
-            const spec = {
-                openapi: '3.0.0',
-                info: {
-                    title: 'Test API',
-                    version: '1.0.0',
-                },
-                paths: {
-                    '/test': {
-                        get: {
-                            operationId: 'testEndpoint',
-                            responses: {
-                                '200': {
-                                    description: 'Success',
-                                    content: {
-                                        'application/json': {
-                                            schema: { type: 'string' },
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-            };
-            const code = generator.generate(spec);
-            // Should call getBaseRequestOptions()
-            expect(code).toContain('getBaseRequestOptions()');
-            // Should merge headers: baseHeaders + Content-Type + request headers
-            expect(code).toContain('Object.assign');
-            expect(code).toContain('baseHeaders');
-            expect(code).toContain('Content-Type');
-            // Should merge all options: baseOptions + {method, headers, body}
-            expect(code).toMatch(/Object\.assign\s*\(\s*\{\s*\}\s*,\s*baseOptions/);
-            expect(code).toContain('method');
-            expect(code).toContain('headers');
-            expect(code).toContain('body');
-        });
-        it('should handle array types', () => {
-            const spec = {
-                openapi: '3.0.0',
-                info: {
-                    title: 'Test API',
-                    version: '1.0.0',
-                },
-                paths: {},
-                components: {
-                    schemas: {
-                        Tags: {
-                            type: 'array',
-                            items: { type: 'string' },
-                        },
-                    },
-                },
-            };
-            const code = generator.generate(spec);
-            expect(code).toContain('z.array');
-            expect(code).toContain('z.string()');
-        });
-    });
-    describe('buildSchema', () => {
-        it('should build schema for string type', () => {
-            const schema = { type: 'string' };
-            const result = generator.buildSchema(schema, true);
-            expect(result).toBeDefined();
-        });
-        it('should build schema for number type', () => {
-            const schema = { type: 'number' };
-            const result = generator.buildSchema(schema, true);
-            expect(result).toBeDefined();
-        });
-        it('should build schema for boolean type', () => {
-            const schema = { type: 'boolean' };
-            const result = generator.buildSchema(schema, true);
-            expect(result).toBeDefined();
-        });
-        it('should handle optional fields', () => {
-            const schema = { type: 'string' };
-            const result = generator.buildSchema(schema, false);
-            expect(result).toBeDefined();
-        });
-        it('should handle string formats', () => {
-            const schema = { type: 'string', format: 'email' };
-            const result = generator.buildSchema(schema, true);
-            expect(result).toBeDefined();
-        });
-    });
-});