zod-codegen 1.0.3 → 1.1.1

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

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

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

@@ -0,0 +1,110 @@
+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.js

@@ -1,30 +1,100 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
+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 = {
-            info: vi.fn(),
+            log: vi.fn(),
             error: vi.fn(),
-            warn: vi.fn(),
-            success: vi.fn(),
         };
-        generator = new Generator('test-app', '1.0.0', mockReporter, './test-input.json', './test-output');
+    });
+    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 have the run method defined', () => {
-            expect(generator).toHaveProperty('run');
+        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');
         });
     });
 });

package/eslint.config.mjs

@@ -10,6 +10,7 @@ export default defineConfig([
       'node_modules/**/*',
       '**/*.test*.ts',
       '**/coverage/*',
+      'examples/**/*.ts',
     ],
   },
   eslint.configs.recommended,

package/examples/.gitkeep

@@ -0,0 +1,3 @@
+# This file ensures the examples directory is tracked by git
+# Generated type.ts files are ignored via .gitignore
+

package/examples/README.md

@@ -0,0 +1,74 @@
+# Examples
+
+This directory contains example implementations demonstrating how to use `zod-codegen` with real-world OpenAPI specifications.
+
+## Available Examples
+
+### 🐾 [Petstore API](./petstore/)
+
+The Swagger Petstore API is a well-known example API that demonstrates various OpenAPI features. This example shows:
+
+- Basic client usage
+- Authentication with API keys
+- Extending the client for custom headers
+- Working with pets, orders, and users
+
+**Generate the client:**
+
+```bash
+zod-codegen --input ./samples/swagger-petstore.yaml --output ./examples/petstore
+```
+
+**Run examples:**
+
+```bash
+npx ts-node examples/petstore/basic-usage.ts
+npx ts-node examples/petstore/authenticated-usage.ts
+```
+
+### ⚡ [PokéAPI](./pokeapi/)
+
+PokéAPI is a public RESTful API that provides data about Pokémon. This example demonstrates:
+
+- Working with a real-world public API
+- Fetching Pokémon data
+- Custom client configuration
+
+**Generate the client:**
+
+```bash
+zod-codegen --input https://pokeapi.co/api/v2/openapi.json --output ./examples/pokeapi
+```
+
+## Structure
+
+Each example directory contains:
+
+- `type.ts` - Generated client and schemas (created by zod-codegen)
+- `README.md` - Example-specific documentation
+- `basic-usage.ts` - Basic usage examples
+- `authenticated-usage.ts` - Authentication examples (if applicable)
+
+## Getting Started
+
+1. **Choose an example** that matches your use case
+2. **Generate the client** using the command shown in the example's README
+3. **Review the generated code** in `type.ts`
+4. **Run the example scripts** to see it in action
+5. **Extend the client** using patterns from [EXAMPLES.md](../EXAMPLES.md)
+
+## Learning Path
+
+1. Start with **Petstore** to understand basic concepts
+2. Try **PokéAPI** to see a real-world public API
+3. Read [EXAMPLES.md](../EXAMPLES.md) for advanced patterns
+4. Create your own example with your API!
+
+## Contributing Examples
+
+If you'd like to add an example:
+
+1. Create a new directory under `examples/`
+2. Add a `README.md` explaining the example
+3. Include example TypeScript files
+4. Update this README to list your example