zod-codegen 1.4.0 → 1.4.1

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

@@ -1,459 +0,0 @@
-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 = {
-                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();
-        });
-    });
-});

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

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

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

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

package/dist/tests/unit/file-reader.test.js

@@ -1,110 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from 'vitest';
-import { SyncFileReaderService, OpenApiFileParserService } from '../../src/services/file-reader.service.js';
-import { join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { dirname } from 'node:path';
-const __dirname = dirname(fileURLToPath(import.meta.url));
-describe('SyncFileReaderService', () => {
-    let reader;
-    beforeEach(() => {
-        reader = new SyncFileReaderService();
-    });
-    describe('readFile', () => {
-        it('should read local JSON files', async () => {
-            const content = await reader.readFile(join(__dirname, '../../samples/openapi.json'));
-            expect(content).toBeTruthy();
-            expect(typeof content).toBe('string');
-        });
-        it('should read local YAML files', async () => {
-            const content = await reader.readFile(join(__dirname, '../../samples/swagger-petstore.yaml'));
-            expect(content).toBeTruthy();
-            expect(typeof content).toBe('string');
-            expect(content).toContain('openapi:');
-        });
-        it('should handle non-existent files', async () => {
-            await expect(reader.readFile('./non-existent-file.json')).rejects.toThrow();
-        });
-        it('should handle URLs', async () => {
-            // Mock fetch for URL test
-            const originalFetch = global.fetch;
-            global.fetch = vi.fn().mockResolvedValue({
-                ok: true,
-                text: async () => '{"openapi": "3.0.0", "info": {"title": "Test", "version": "1.0.0"}, "paths": {}}',
-            });
-            const content = await reader.readFile('https://example.com/openapi.json');
-            expect(content).toBeTruthy();
-            global.fetch = originalFetch;
-        });
-        it('should handle URL fetch errors with non-ok responses', async () => {
-            const originalFetch = global.fetch;
-            const mockFetch = vi.fn().mockResolvedValue({
-                ok: false,
-                status: 404,
-                statusText: 'Not Found',
-            });
-            global.fetch = mockFetch;
-            await expect(reader.readFile('https://example.com/not-found.json')).rejects.toThrow();
-            // Verify fetch was called
-            expect(mockFetch).toHaveBeenCalledWith('https://example.com/not-found.json');
-            global.fetch = originalFetch;
-        });
-    });
-});
-describe('OpenApiFileParserService', () => {
-    let parser;
-    beforeEach(() => {
-        parser = new OpenApiFileParserService();
-    });
-    describe('parse', () => {
-        it('should parse valid JSON OpenAPI spec', () => {
-            const jsonSpec = JSON.stringify({
-                openapi: '3.0.0',
-                info: { title: 'Test API', version: '1.0.0' },
-                paths: {},
-            });
-            const result = parser.parse(jsonSpec);
-            expect(result).toBeDefined();
-            expect(result.openapi).toBe('3.0.0');
-            expect(result.info.title).toBe('Test API');
-        });
-        it('should parse valid YAML OpenAPI spec', () => {
-            const yamlSpec = `
-openapi: 3.0.0
-info:
-  title: Test API
-  version: 1.0.0
-paths: {}
-`;
-            const result = parser.parse(yamlSpec);
-            expect(result).toBeDefined();
-            expect(result.openapi).toBe('3.0.0');
-            expect(result.info.title).toBe('Test API');
-        });
-        it('should parse already parsed objects', () => {
-            const spec = {
-                openapi: '3.0.0',
-                info: { title: 'Test API', version: '1.0.0' },
-                paths: {},
-            };
-            const result = parser.parse(spec);
-            expect(result).toBeDefined();
-            expect(result.openapi).toBe('3.0.0');
-        });
-        it('should validate OpenAPI structure', () => {
-            const invalidSpec = {
-                openapi: '2.0.0', // Wrong version format
-                info: { title: 'Test API', version: '1.0.0' },
-                paths: {},
-            };
-            expect(() => parser.parse(invalidSpec)).toThrow();
-        });
-        it('should handle missing required fields', () => {
-            const invalidSpec = {
-                openapi: '3.0.0',
-                // Missing info
-                paths: {},
-            };
-            expect(() => parser.parse(invalidSpec)).toThrow();
-        });
-    });
-});

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

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

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

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

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

@@ -1,100 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { Generator } from '../../src/generator.js';
-import { Reporter } from '../../src/utils/reporter.js';
-import { readFileSync, existsSync, mkdirSync, rmSync } from 'node:fs';
-import { join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { dirname } from 'node:path';
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const testOutputDir = join(__dirname, '../../test-output');
-describe('Generator', () => {
-    let generator;
-    let mockReporter;
-    beforeEach(() => {
-        // Clean up test output directory
-        if (existsSync(testOutputDir)) {
-            rmSync(testOutputDir, { recursive: true, force: true });
-        }
-        mkdirSync(testOutputDir, { recursive: true });
-        // Create a mock reporter
-        mockReporter = {
-            log: vi.fn(),
-            error: vi.fn(),
-        };
-    });
-    afterEach(() => {
-        // Clean up test output directory
-        if (existsSync(testOutputDir)) {
-            rmSync(testOutputDir, { recursive: true, force: true });
-        }
-    });
-    describe('constructor', () => {
-        it('should create a new Generator instance', () => {
-            generator = new Generator('test-app', '1.0.0', mockReporter, './samples/swagger-petstore.yaml', testOutputDir);
-            expect(generator).toBeInstanceOf(Generator);
-        });
-        it('should initialize with correct parameters', () => {
-            generator = new Generator('test-app', '1.0.0', mockReporter, './samples/swagger-petstore.yaml', testOutputDir);
-            expect(generator).toBeDefined();
-        });
-    });
-    describe('run', () => {
-        it('should be a function', () => {
-            generator = new Generator('test-app', '1.0.0', mockReporter, './samples/swagger-petstore.yaml', testOutputDir);
-            expect(typeof generator.run).toBe('function');
-        });
-        it('should generate code from a valid OpenAPI file', async () => {
-            generator = new Generator('test-app', '1.0.0', mockReporter, './samples/swagger-petstore.yaml', testOutputDir);
-            const exitCode = await generator.run();
-            expect(exitCode).toBe(0);
-            expect(mockReporter.log).toHaveBeenCalled();
-            expect(mockReporter.error).not.toHaveBeenCalled();
-            // Verify output file was created
-            const outputFile = join(testOutputDir, 'type.ts');
-            expect(existsSync(outputFile)).toBe(true);
-            // Verify file contains expected content
-            const content = readFileSync(outputFile, 'utf-8');
-            expect(content).toMatch(/import\s*{\s*z\s*}\s*from\s*['"]zod['"]/);
-            expect(content).toContain('export class');
-            expect(content).toContain('getBaseRequestOptions');
-        });
-        it('should handle invalid file paths gracefully', async () => {
-            generator = new Generator('test-app', '1.0.0', mockReporter, './non-existent-file.yaml', testOutputDir);
-            const exitCode = await generator.run();
-            expect(exitCode).toBe(1);
-            expect(mockReporter.error).toHaveBeenCalled();
-        });
-        it('should handle invalid OpenAPI specifications', async () => {
-            // Create a temporary invalid OpenAPI file
-            const invalidFile = join(testOutputDir, 'invalid.yaml');
-            mkdirSync(testOutputDir, { recursive: true });
-            readFileSync; // Ensure we can write
-            const { writeFileSync } = await import('node:fs');
-            writeFileSync(invalidFile, 'invalid: yaml: content: [unclosed');
-            generator = new Generator('test-app', '1.0.0', mockReporter, invalidFile, testOutputDir);
-            const exitCode = await generator.run();
-            expect(exitCode).toBe(1);
-            expect(mockReporter.error).toHaveBeenCalled();
-        });
-        it('should generate code with correct structure', async () => {
-            generator = new Generator('test-app', '1.0.0', mockReporter, './samples/swagger-petstore.yaml', testOutputDir);
-            await generator.run();
-            const outputFile = join(testOutputDir, 'type.ts');
-            const content = readFileSync(outputFile, 'utf-8');
-            // Check for key components
-            expect(content).toMatch(/import\s*{\s*z\s*}\s*from\s*['"]zod['"]/);
-            expect(content).toContain('export const');
-            expect(content).toContain('protected getBaseRequestOptions');
-            expect(content).toContain('async #makeRequest');
-        });
-        it('should include header comments in generated file', async () => {
-            generator = new Generator('test-app', '1.0.0', mockReporter, './samples/swagger-petstore.yaml', testOutputDir);
-            await generator.run();
-            const outputFile = join(testOutputDir, 'type.ts');
-            const content = readFileSync(outputFile, 'utf-8');
-            expect(content).toContain('AUTOGENERATED');
-            expect(content).toContain('test-app@1.0.0');
-            expect(content).toContain('eslint-disable');
-        });
-    });
-});