zod-codegen 1.0.3 → 1.1.0

package/src/types/openapi.ts

@@ -61,7 +61,7 @@ const ServerVariable = z.object({
 });
 
 const Server = z.object({
-  url: z.url(),
+  url: z.string(), // Allow templated URLs with {variables}
   description: z.string().optional(),
   variables: z.record(z.string(), ServerVariable).optional(),
 });

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

@@ -0,0 +1,243 @@
+import {describe, expect, it} from 'vitest';
+import {TypeScriptCodeGeneratorService} from '../../src/services/code-generator.service.js';
+import type {OpenApiSpecType} from '../../src/types/openapi.js';
+
+describe('TypeScriptCodeGeneratorService', () => {
+  let generator: TypeScriptCodeGeneratorService;
+
+  beforeEach(() => {
+    generator = new TypeScriptCodeGeneratorService();
+  });
+
+  describe('generate', () => {
+    it('should generate code for a minimal OpenAPI spec', () => {
+      const spec: OpenApiSpecType = {
+        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: OpenApiSpecType = {
+        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: OpenApiSpecType = {
+        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: OpenApiSpecType = {
+        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: OpenApiSpecType = {
+        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: OpenApiSpecType = {
+        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: OpenApiSpecType = {
+        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 array types', () => {
+      const spec: OpenApiSpecType = {
+        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/tests/unit/file-reader.test.ts

@@ -0,0 +1,134 @@
+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: SyncFileReaderService;
+
+  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": {}}',
+      } as Response);
+
+      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',
+      } as Response);
+      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: OpenApiFileParserService;
+
+  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/tests/unit/generator.test.ts

@@ -1,36 +1,128 @@
-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: Generator;
   let mockReporter: Reporter;
 
   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(),
     } as unknown as Reporter;
+  });
 
-    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/tsconfig.examples.json

@@ -0,0 +1,17 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "noEmit": true,
+    "strict": false,
+    "noImplicitAny": false,
+    "noImplicitOverride": false,
+    "strictNullChecks": false,
+    "strictPropertyInitialization": false,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "exactOptionalPropertyTypes": false,
+    "verbatimModuleSyntax": false
+  },
+  "include": ["examples/**/*.ts"],
+  "exclude": []
+}

package/tsconfig.json

@@ -39,6 +39,6 @@
     "useUnknownInCatchVariables": true,
     "verbatimModuleSyntax": true
   },
-  "exclude": ["node_modules", "dist", "build"],
+  "exclude": ["node_modules", "dist", "build", "examples/**/*.ts"],
   "include": ["src/**/*.ts", "scripts/**/*.ts", "tests/**/*.ts", "vitest.config.ts"]
 }