zod-codegen 1.6.3 → 1.7.1

package/dist/tests/integration/error-scenarios.test.js

@@ -0,0 +1,169 @@
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { Generator } from '../../src/generator';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const testOutputDir = join(__dirname, '../../test-output-errors');
+describe('Error Scenarios', () => {
+    let generator;
+    let mockReporter;
+    const logSpy = vi.fn();
+    const errorSpy = vi.fn();
+    beforeEach(() => {
+        if (existsSync(testOutputDir)) {
+            rmSync(testOutputDir, { recursive: true, force: true });
+        }
+        mkdirSync(testOutputDir, { recursive: true });
+        mockReporter = {
+            log: logSpy,
+            error: errorSpy
+        };
+        logSpy.mockClear();
+        errorSpy.mockClear();
+    });
+    afterEach(() => {
+        if (existsSync(testOutputDir)) {
+            rmSync(testOutputDir, { recursive: true, force: true });
+        }
+    });
+    describe('File Reading Errors', () => {
+        it('should handle non-existent local file', 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(errorSpy).toHaveBeenCalled();
+            expect(String(errorSpy.mock.calls[0]?.[0] ?? '')).toContain('Error');
+        });
+        it('should handle network errors when fetching URL', async () => {
+            const originalFetch = global.fetch;
+            const mockFetch = vi.fn().mockRejectedValue(new Error('Network error'));
+            global.fetch = mockFetch;
+            generator = new Generator('test-app', '1.0.0', mockReporter, 'https://example.com/nonexistent.json', testOutputDir);
+            const exitCode = await generator.run();
+            expect(exitCode).toBe(1);
+            expect(errorSpy).toHaveBeenCalled();
+            expect(mockFetch).toHaveBeenCalled();
+            global.fetch = originalFetch;
+        });
+        it('should handle HTTP errors when fetching URL', async () => {
+            const originalFetch = global.fetch;
+            const mockFetch = vi.fn().mockResolvedValue({
+                ok: false,
+                status: 500,
+                statusText: 'Internal Server Error',
+                text: async () => 'Error response'
+            });
+            global.fetch = mockFetch;
+            generator = new Generator('test-app', '1.0.0', mockReporter, 'https://example.com/error.json', testOutputDir);
+            const exitCode = await generator.run();
+            expect(exitCode).toBe(1);
+            expect(errorSpy).toHaveBeenCalled();
+            // Error should mention the HTTP error or parsing failure
+            const errorMessage = (errorSpy.mock.calls[0]?.[0] ?? '');
+            expect(errorMessage).toMatch(/500|Error|Failed/);
+            global.fetch = originalFetch;
+        });
+    });
+    describe('Parsing Errors', () => {
+        it('should handle invalid JSON', async () => {
+            const invalidFile = join(testOutputDir, 'invalid.json');
+            writeFileSync(invalidFile, '{ invalid json }');
+            generator = new Generator('test-app', '1.0.0', mockReporter, invalidFile, testOutputDir);
+            const exitCode = await generator.run();
+            expect(exitCode).toBe(1);
+            expect(errorSpy).toHaveBeenCalled();
+        });
+        it('should handle invalid YAML', async () => {
+            const invalidFile = join(testOutputDir, 'invalid.yaml');
+            writeFileSync(invalidFile, 'invalid: yaml: [unclosed');
+            generator = new Generator('test-app', '1.0.0', mockReporter, invalidFile, testOutputDir);
+            const exitCode = await generator.run();
+            expect(exitCode).toBe(1);
+            expect(errorSpy).toHaveBeenCalled();
+        });
+        it('should handle invalid OpenAPI version', async () => {
+            const invalidFile = join(testOutputDir, 'invalid-version.yaml');
+            writeFileSync(invalidFile, `
+openapi: 2.0.0
+info:
+  title: Test API
+  version: 1.0.0
+paths: {}
+`);
+            generator = new Generator('test-app', '1.0.0', mockReporter, invalidFile, testOutputDir);
+            const exitCode = await generator.run();
+            expect(exitCode).toBe(1);
+            expect(errorSpy).toHaveBeenCalled();
+        });
+        it('should handle missing required fields', async () => {
+            const invalidFile = join(testOutputDir, 'missing-fields.yaml');
+            writeFileSync(invalidFile, `
+openapi: 3.0.0
+paths: {}
+`);
+            generator = new Generator('test-app', '1.0.0', mockReporter, invalidFile, testOutputDir);
+            const exitCode = await generator.run();
+            expect(exitCode).toBe(1);
+            expect(errorSpy).toHaveBeenCalled();
+        });
+    });
+    describe('File Writing Errors', () => {
+        it('should handle write permission errors gracefully', async () => {
+            // Create a read-only directory (on Unix systems)
+            const readOnlyDir = join(testOutputDir, 'readonly');
+            mkdirSync(readOnlyDir, { recursive: true });
+            // Note: chmod doesn't work the same way on all systems, so this test
+            // might need to be adjusted based on the environment
+            generator = new Generator('test-app', '1.0.0', mockReporter, './samples/swagger-petstore.yaml', readOnlyDir);
+            const exitCode = await generator.run();
+            // Should either succeed or fail gracefully
+            expect([0, 1]).toContain(exitCode);
+        });
+    });
+    describe('Malformed OpenAPI Specs', () => {
+        it('should handle empty spec', async () => {
+            const emptyFile = join(testOutputDir, 'empty.yaml');
+            writeFileSync(emptyFile, '');
+            generator = new Generator('test-app', '1.0.0', mockReporter, emptyFile, testOutputDir);
+            const exitCode = await generator.run();
+            expect(exitCode).toBe(1);
+            expect(errorSpy).toHaveBeenCalled();
+        });
+        it('should handle spec with no paths', async () => {
+            const noPathsFile = join(testOutputDir, 'no-paths.yaml');
+            writeFileSync(noPathsFile, `
+openapi: 3.0.0
+info:
+  title: Test API
+  version: 1.0.0
+paths: {}
+`);
+            generator = new Generator('test-app', '1.0.0', mockReporter, noPathsFile, testOutputDir);
+            const exitCode = await generator.run();
+            // Should succeed even with no paths
+            expect(exitCode).toBe(0);
+            expect(logSpy).toHaveBeenCalled();
+        });
+        it('should handle spec with no components', async () => {
+            const noComponentsFile = join(testOutputDir, 'no-components.yaml');
+            writeFileSync(noComponentsFile, `
+openapi: 3.0.0
+info:
+  title: Test API
+  version: 1.0.0
+paths:
+  /test:
+    get:
+      operationId: test
+      responses:
+        '200':
+          description: Success
+`);
+            generator = new Generator('test-app', '1.0.0', mockReporter, noComponentsFile, testOutputDir);
+            const exitCode = await generator.run();
+            // Should succeed even with no components
+            expect(exitCode).toBe(0);
+        });
+    });
+});

package/dist/tests/integration/snapshots.test.d.ts

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

package/dist/tests/integration/snapshots.test.d.ts.map

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

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":""}