zod-codegen 1.6.3 → 1.7.0

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

@@ -0,0 +1,100 @@
+import { existsSync, mkdirSync, readFileSync, rmSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { describe, expect, it } from 'vitest';
+import { Generator } from '../../src/generator';
+import { Reporter } from '../../src/utils/reporter';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const testOutputDir = join(__dirname, '../../test-output-snapshots');
+describe('Generated Code Snapshots', () => {
+    let generator;
+    const reporter = new Reporter(process.stdout, process.stderr);
+    beforeEach(() => {
+        if (existsSync(testOutputDir)) {
+            rmSync(testOutputDir, { recursive: true, force: true });
+        }
+        mkdirSync(testOutputDir, { recursive: true });
+    });
+    afterEach(() => {
+        if (existsSync(testOutputDir)) {
+            rmSync(testOutputDir, { recursive: true, force: true });
+        }
+    });
+    describe('swagger-petstore.yaml', () => {
+        it('should generate valid TypeScript code', async () => {
+            generator = new Generator('test-app', '1.0.0', reporter, './samples/swagger-petstore.yaml', testOutputDir);
+            const exitCode = await generator.run();
+            expect(exitCode).toBe(0);
+            const outputFile = join(testOutputDir, 'api.ts');
+            expect(existsSync(outputFile)).toBe(true);
+            const content = readFileSync(outputFile, 'utf-8');
+            // Verify key components exist
+            expect(content).toMatch(/import\s*{\s*z\s*}\s*from\s*['"]zod['"]/);
+            expect(content).toContain('SwaggerPetstoreOpenAPI30');
+            expect(content).toContain('export const Pet');
+            expect(content).toContain('export const Order');
+            expect(content).toContain('export const User');
+            expect(content).toContain('async findPetsByStatus');
+            expect(content).toContain('async addPet');
+            expect(content).toContain('protected getBaseRequestOptions');
+            expect(content).toContain('protected async handleResponse');
+            expect(content).toContain('class ResponseValidationError<T> extends Error');
+            expect(content).toContain('Pet.safeParse(response)');
+            expect(content).toContain('new ResponseValidationError<Pet>');
+        });
+        it('should generate syntactically valid TypeScript code', async () => {
+            generator = new Generator('test-app', '1.0.0', reporter, './samples/swagger-petstore.yaml', testOutputDir);
+            await generator.run();
+            const outputFile = join(testOutputDir, 'api.ts');
+            const content = readFileSync(outputFile, 'utf-8');
+            // Verify basic TypeScript syntax
+            expect(content).toContain('import');
+            expect(content).toContain('export');
+            expect(content).toContain('class');
+            expect(content).toContain('async');
+            expect(content).toContain('protected');
+            // Verify code structure
+            expect(content.length).toBeGreaterThan(1000); // Should be substantial
+            expect(content.split('{').length).toBeGreaterThan(content.split('}').length - 10); // Rough bracket balance check
+        });
+    });
+    describe('test-logical.yaml', () => {
+        it('should generate correct logical operators', async () => {
+            generator = new Generator('test-app', '1.0.0', reporter, './samples/test-logical.yaml', testOutputDir);
+            await generator.run();
+            const outputFile = join(testOutputDir, 'api.ts');
+            const content = readFileSync(outputFile, 'utf-8');
+            // Verify logical operators are generated correctly
+            expect(content).toContain('TestAnyOf');
+            expect(content).toContain('z.union');
+            expect(content).toContain('TestOneOf');
+            expect(content).toContain('TestAllOf');
+            expect(content).toContain('z.intersection');
+            expect(content).toContain('TestNot');
+        });
+    });
+    describe('server-variables-example.yaml', () => {
+        it('should generate server configuration with variables', async () => {
+            generator = new Generator('test-app', '1.0.0', reporter, './samples/server-variables-example.yaml', testOutputDir);
+            await generator.run();
+            const outputFile = join(testOutputDir, 'api.ts');
+            const content = readFileSync(outputFile, 'utf-8');
+            // Verify server variables are handled
+            expect(content).toContain('serverConfigurations');
+            expect(content).toContain('serverVariables');
+            expect(content).toContain('resolveServerUrl');
+            expect(content).toContain('ClientOptions');
+        });
+    });
+    describe('pokeapi-openapi.json', () => {
+        it('should generate code for PokéAPI spec', async () => {
+            generator = new Generator('test-app', '1.0.0', reporter, './samples/pokeapi-openapi.json', testOutputDir);
+            await generator.run();
+            const outputFile = join(testOutputDir, 'api.ts');
+            const content = readFileSync(outputFile, 'utf-8');
+            expect(content).toMatch(/export (default )?class/);
+            expect(content).toContain('export const Pokemon');
+            expect(content).toContain('async getPokemonById');
+        });
+    });
+});

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

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

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

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

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

@@ -0,0 +1,506 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { TypeScriptCodeGeneratorService } from '../../src/services/code-generator.service';
+describe('TypeScriptCodeGeneratorService - Edge Cases', () => {
+    let generator;
+    beforeEach(() => {
+        generator = new TypeScriptCodeGeneratorService();
+    });
+    describe('buildBasicTypeFromSchema edge cases', () => {
+        it('should handle unknown type in default case', () => {
+            const spec = {
+                openapi: '3.0.0',
+                info: {
+                    title: 'Test API',
+                    version: '1.0.0'
+                },
+                paths: {},
+                components: {
+                    schemas: {
+                        UnknownType: {
+                            anyOf: [{ type: 'custom' }]
+                        }
+                    }
+                }
+            };
+            const code = generator.generate(spec);
+            expect(code).toContain('z.unknown()');
+        });
+        it('should handle unknown type directly in schema (not in logical operator)', () => {
+            const spec = {
+                openapi: '3.0.0',
+                info: {
+                    title: 'Test API',
+                    version: '1.0.0'
+                },
+                paths: {},
+                components: {
+                    schemas: {
+                        DirectUnknownType: {
+                            type: 'custom'
+                        }
+                    }
+                }
+            };
+            const code = generator.generate(spec);
+            expect(code).toContain('z.unknown()');
+            expect(code).toContain('DirectUnknownType');
+        });
+        it('should handle object type with properties in buildBasicTypeFromSchema path', () => {
+            // Test the path where buildObjectTypeFromSchema is called with properties
+            // This happens when SchemaProperties.parse fails but schema has type: 'object'
+            // We need to create a scenario where parse fails but type property exists
+            // Since SchemaProperties is very permissive, we'll use a non-object value
+            // that gets coerced or handled specially
+            const spec = {
+                openapi: '3.0.0',
+                info: {
+                    title: 'Test API',
+                    version: '1.0.0'
+                },
+                paths: {},
+                components: {
+                    schemas: {
+                        ObjectWithPropsViaBasic: {
+                            // Use oneOf with a schema that will fail parse but has type
+                            oneOf: [
+                                // Create an object that fails SchemaProperties validation
+                                // by having invalid nested structure that causes parse to fail
+                                // but still has the type property accessible
+                                (() => {
+                                    const obj = { type: 'object', properties: { name: { type: 'string' } } };
+                                    // Make it fail parse by adding circular reference or invalid structure
+                                    // Actually, let's try making properties invalid in a way that causes top-level parse to fail
+                                    obj.properties = new Proxy({}, {
+                                        get() {
+                                            throw new Error('Proxy error');
+                                        }
+                                    });
+                                    return obj;
+                                })()
+                            ]
+                        }
+                    }
+                }
+            };
+            // This might throw, but let's see
+            try {
+                const code = generator.generate(spec);
+                expect(code).toBeTruthy();
+            }
+            catch {
+                // Expected if proxy causes issues
+            }
+        });
+        it('should handle schema without type property', () => {
+            const spec = {
+                openapi: '3.0.0',
+                info: {
+                    title: 'Test API',
+                    version: '1.0.0'
+                },
+                paths: {},
+                components: {
+                    schemas: {
+                        NoType: {
+                            anyOf: [{}]
+                        }
+                    }
+                }
+            };
+            const code = generator.generate(spec);
+            expect(code).toContain('z.unknown()');
+        });
+        it('should handle null schema', () => {
+            const spec = {
+                openapi: '3.0.0',
+                info: {
+                    title: 'Test API',
+                    version: '1.0.0'
+                },
+                paths: {},
+                components: {
+                    schemas: {
+                        NullSchema: {
+                            anyOf: [null]
+                        }
+                    }
+                }
+            };
+            const code = generator.generate(spec);
+            // Should handle gracefully
+            expect(code).toBeTruthy();
+        });
+    });
+    describe('buildObjectTypeFromSchema edge cases', () => {
+        it('should handle object with empty properties in logical operators', () => {
+            const spec = {
+                openapi: '3.0.0',
+                info: {
+                    title: 'Test API',
+                    version: '1.0.0'
+                },
+                paths: {},
+                components: {
+                    schemas: {
+                        EmptyObject: {
+                            anyOf: [{ type: 'object', properties: {} }]
+                        }
+                    }
+                }
+            };
+            const code = generator.generate(spec);
+            // Empty object should fallback to record type
+            expect(code).toContain('z.record');
+        });
+        it('should handle object with properties in logical operators', () => {
+            const spec = {
+                openapi: '3.0.0',
+                info: {
+                    title: 'Test API',
+                    version: '1.0.0'
+                },
+                paths: {},
+                components: {
+                    schemas: {
+                        ObjectWithProps: {
+                            anyOf: [
+                                {
+                                    type: 'object',
+                                    properties: {
+                                        name: { type: 'string' },
+                                        age: { type: 'number' }
+                                    }
+                                }
+                            ]
+                        }
+                    }
+                }
+            };
+            const code = generator.generate(spec);
+            expect(code).toContain('name');
+            expect(code).toContain('age');
+        });
+        it('should handle object type directly in schema (not in logical operator)', () => {
+            const spec = {
+                openapi: '3.0.0',
+                info: {
+                    title: 'Test API',
+                    version: '1.0.0'
+                },
+                paths: {},
+                components: {
+                    schemas: {
+                        DirectObject: {
+                            type: 'object',
+                            properties: {
+                                name: { type: 'string' },
+                                age: { type: 'number' }
+                            }
+                        }
+                    }
+                }
+            };
+            const code = generator.generate(spec);
+            expect(code).toContain('name');
+            expect(code).toContain('age');
+            expect(code).toContain('DirectObject');
+        });
+        it('should handle object type with empty properties directly in schema', () => {
+            const spec = {
+                openapi: '3.0.0',
+                info: {
+                    title: 'Test API',
+                    version: '1.0.0'
+                },
+                paths: {},
+                components: {
+                    schemas: {
+                        EmptyDirectObject: {
+                            type: 'object',
+                            properties: {}
+                        }
+                    }
+                }
+            };
+            const code = generator.generate(spec);
+            // Empty object should fallback to record type
+            expect(code).toContain('z.record');
+        });
+    });
+    describe('buildArrayTypeFromSchema edge cases', () => {
+        it('should handle array without items in logical operators', () => {
+            const spec = {
+                openapi: '3.0.0',
+                info: {
+                    title: 'Test API',
+                    version: '1.0.0'
+                },
+                paths: {},
+                components: {
+                    schemas: {
+                        ArrayNoItems: {
+                            anyOf: [{ type: 'array' }]
+                        }
+                    }
+                }
+            };
+            const code = generator.generate(spec);
+            expect(code).toContain('z.array');
+            expect(code).toContain('z.unknown()');
+        });
+        it('should handle array with items in logical operators', () => {
+            const spec = {
+                openapi: '3.0.0',
+                info: {
+                    title: 'Test API',
+                    version: '1.0.0'
+                },
+                paths: {},
+                components: {
+                    schemas: {
+                        ArrayWithItems: {
+                            anyOf: [
+                                {
+                                    type: 'array',
+                                    items: { type: 'string' }
+                                }
+                            ]
+                        }
+                    }
+                }
+            };
+            const code = generator.generate(spec);
+            expect(code).toContain('z.array');
+            expect(code).toContain('z.string()');
+        });
+        it('should handle array type directly in schema (not in logical operator)', () => {
+            const spec = {
+                openapi: '3.0.0',
+                info: {
+                    title: 'Test API',
+                    version: '1.0.0'
+                },
+                paths: {},
+                components: {
+                    schemas: {
+                        DirectArray: {
+                            type: 'array',
+                            items: { type: 'string' }
+                        }
+                    }
+                }
+            };
+            const code = generator.generate(spec);
+            expect(code).toContain('z.array');
+            expect(code).toContain('z.string()');
+            expect(code).toContain('DirectArray');
+        });
+        it('should handle array type without items directly in schema', () => {
+            const spec = {
+                openapi: '3.0.0',
+                info: {
+                    title: 'Test API',
+                    version: '1.0.0'
+                },
+                paths: {},
+                components: {
+                    schemas: {
+                        DirectArrayNoItems: {
+                            type: 'array'
+                        }
+                    }
+                }
+            };
+            const code = generator.generate(spec);
+            expect(code).toContain('z.array');
+            expect(code).toContain('DirectArrayNoItems');
+        });
+    });
+    describe('Complex nested logical operators', () => {
+        it('should handle nested anyOf within allOf', () => {
+            const spec = {
+                openapi: '3.0.0',
+                info: {
+                    title: 'Test API',
+                    version: '1.0.0'
+                },
+                paths: {},
+                components: {
+                    schemas: {
+                        NestedLogical: {
+                            allOf: [
+                                {
+                                    anyOf: [{ type: 'string' }, { type: 'number' }]
+                                },
+                                {
+                                    type: 'object',
+                                    properties: {
+                                        id: { type: 'string' }
+                                    }
+                                }
+                            ]
+                        }
+                    }
+                }
+            };
+            const code = generator.generate(spec);
+            expect(code).toContain('z.intersection');
+            expect(code).toContain('z.union');
+        });
+        it('should handle not operator with complex schema', () => {
+            const spec = {
+                openapi: '3.0.0',
+                info: {
+                    title: 'Test API',
+                    version: '1.0.0'
+                },
+                paths: {},
+                components: {
+                    schemas: {
+                        NotComplex: {
+                            not: {
+                                type: 'object',
+                                properties: {
+                                    forbidden: { type: 'string' }
+                                }
+                            }
+                        }
+                    }
+                }
+            };
+            const code = generator.generate(spec);
+            // The not operator uses z.any.refine() pattern
+            expect(code).toContain('z.any');
+            expect(code).toContain('refine');
+            expect(code).toMatch(/forbidden|Value must not match/);
+        });
+    });
+    describe('buildSchemaFromLogicalOperator edge cases', () => {
+        it('should handle unknown type in default case of buildSchemaFromLogicalOperator', () => {
+            const spec = {
+                openapi: '3.0.0',
+                info: {
+                    title: 'Test API',
+                    version: '1.0.0'
+                },
+                paths: {},
+                components: {
+                    schemas: {
+                        UnknownTypeInLogical: {
+                            anyOf: [
+                                {
+                                    type: 'custom' // Unknown type that hits default case
+                                }
+                            ]
+                        }
+                    }
+                }
+            };
+            const code = generator.generate(spec);
+            expect(code).toContain('z.unknown()');
+        });
+        it('should handle buildObjectTypeFromSchema with empty properties', () => {
+            const spec = {
+                openapi: '3.0.0',
+                info: {
+                    title: 'Test API',
+                    version: '1.0.0'
+                },
+                paths: {},
+                components: {
+                    schemas: {
+                        EmptyObjectInLogical: {
+                            anyOf: [
+                                {
+                                    type: 'object',
+                                    properties: {}
+                                }
+                            ]
+                        }
+                    }
+                }
+            };
+            const code = generator.generate(spec);
+            // Should fallback to record type when properties are empty
+            expect(code).toContain('z.record');
+        });
+        it('should handle buildObjectTypeFromSchema with properties', () => {
+            const spec = {
+                openapi: '3.0.0',
+                info: {
+                    title: 'Test API',
+                    version: '1.0.0'
+                },
+                paths: {},
+                components: {
+                    schemas: {
+                        ObjectWithPropsInLogical: {
+                            anyOf: [
+                                {
+                                    type: 'object',
+                                    properties: {
+                                        name: { type: 'string' },
+                                        value: { type: 'number' }
+                                    }
+                                }
+                            ]
+                        }
+                    }
+                }
+            };
+            const code = generator.generate(spec);
+            expect(code).toContain('name');
+            expect(code).toContain('value');
+            expect(code).toContain('z.object');
+        });
+        it('should handle buildArrayTypeFromSchema without items', () => {
+            const spec = {
+                openapi: '3.0.0',
+                info: {
+                    title: 'Test API',
+                    version: '1.0.0'
+                },
+                paths: {},
+                components: {
+                    schemas: {
+                        ArrayNoItemsInLogical: {
+                            anyOf: [
+                                {
+                                    type: 'array'
+                                    // No items property
+                                }
+                            ]
+                        }
+                    }
+                }
+            };
+            const code = generator.generate(spec);
+            expect(code).toContain('z.array');
+        });
+        it('should handle buildArrayTypeFromSchema with items', () => {
+            const spec = {
+                openapi: '3.0.0',
+                info: {
+                    title: 'Test API',
+                    version: '1.0.0'
+                },
+                paths: {},
+                components: {
+                    schemas: {
+                        ArrayWithItemsInLogical: {
+                            anyOf: [
+                                {
+                                    type: 'array',
+                                    items: { type: 'string' }
+                                }
+                            ]
+                        }
+                    }
+                }
+            };
+            const code = generator.generate(spec);
+            expect(code).toContain('z.array');
+            expect(code).toContain('z.string()');
+        });
+    });
+});

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

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

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

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