zod-codegen 1.6.3 → 1.7.1

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

@@ -1,8 +1,7 @@
-import {describe, expect, it, vi, beforeEach} from 'vitest';
-import {SyncFileReaderService, OpenApiFileParserService} from '../../src/services/file-reader.service';
-import {join} from 'node:path';
-import {fileURLToPath} from 'node:url';
-import {dirname} from 'node:path';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { OpenApiFileParserService, SyncFileReaderService } from '../../src/services/file-reader.service';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -32,15 +31,15 @@ describe('SyncFileReaderService', () => {
     });
 
     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": {}}',
+        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();
+      expect(global.fetch).toHaveBeenCalledWith('https://example.com/openapi.json', { headers: {} });
 
       global.fetch = originalFetch;
     });
@@ -50,16 +49,57 @@ describe('SyncFileReaderService', () => {
       const mockFetch = vi.fn().mockResolvedValue({
         ok: false,
         status: 404,
-        statusText: 'Not Found',
+        statusText: 'Not Found'
       } as Response);
       global.fetch = mockFetch;
 
-      await expect(reader.readFile('https://example.com/not-found.json')).rejects.toThrow();
+      await expect(reader.readFile('https://example.com/not-found.json')).rejects.toThrow('Failed to fetch');
 
-      // Verify fetch was called
-      expect(mockFetch).toHaveBeenCalledWith('https://example.com/not-found.json');
       global.fetch = originalFetch;
     });
+
+    it('should propagate network errors for URLs instead of falling back to readFileSync', async () => {
+      const originalFetch = global.fetch;
+      global.fetch = vi.fn().mockRejectedValue(new TypeError('fetch failed'));
+
+      await expect(reader.readFile('https://example.com/openapi.json')).rejects.toThrow('fetch failed');
+
+      global.fetch = originalFetch;
+    });
+
+    it('should extract basic auth credentials from URL into Authorization header', async () => {
+      const originalFetch = global.fetch;
+      const mockFetch = vi.fn().mockResolvedValue({
+        ok: true,
+        text: async () => '{}'
+      } as Response);
+      global.fetch = mockFetch;
+
+      await reader.readFile('https://user:pass@example.com/openapi.json');
+
+      expect(mockFetch).toHaveBeenCalledWith('https://example.com/openapi.json', { headers: { Authorization: `Basic ${btoa('user:pass')}` } });
+
+      global.fetch = originalFetch;
+    });
+
+    it('should decode percent-encoded credentials from URL', async () => {
+      const originalFetch = global.fetch;
+      const mockFetch = vi.fn().mockResolvedValue({
+        ok: true,
+        text: async () => '{}'
+      } as Response);
+      global.fetch = mockFetch;
+
+      await reader.readFile('https://julien%2Bstaging%40saris.ai:qwerty123@api.staging.saris.ai/api/openapi.json');
+
+      expect(mockFetch).toHaveBeenCalledWith('https://api.staging.saris.ai/api/openapi.json', { headers: { Authorization: `Basic ${btoa('julien+staging@saris.ai:qwerty123')}` } });
+
+      global.fetch = originalFetch;
+    });
+
+    it('should not treat non-http schemes as URLs', async () => {
+      await expect(reader.readFile('file:///etc/passwd')).rejects.toThrow();
+    });
   });
 });
 
@@ -74,8 +114,8 @@ describe('OpenApiFileParserService', () => {
     it('should parse valid JSON OpenAPI spec', () => {
       const jsonSpec = JSON.stringify({
         openapi: '3.0.0',
-        info: {title: 'Test API', version: '1.0.0'},
-        paths: {},
+        info: { title: 'Test API', version: '1.0.0' },
+        paths: {}
       });
 
       const result = parser.parse(jsonSpec);
@@ -102,8 +142,8 @@ paths: {}
     it('should parse already parsed objects', () => {
       const spec = {
         openapi: '3.0.0',
-        info: {title: 'Test API', version: '1.0.0'},
-        paths: {},
+        info: { title: 'Test API', version: '1.0.0' },
+        paths: {}
       };
 
       const result = parser.parse(spec);
@@ -114,8 +154,8 @@ paths: {}
     it('should validate OpenAPI structure', () => {
       const invalidSpec = {
         openapi: '2.0.0', // Wrong version format
-        info: {title: 'Test API', version: '1.0.0'},
-        paths: {},
+        info: { title: 'Test API', version: '1.0.0' },
+        paths: {}
       };
 
       expect(() => parser.parse(invalidSpec)).toThrow();
@@ -125,7 +165,7 @@ paths: {}
       const invalidSpec = {
         openapi: '3.0.0',
         // Missing info
-        paths: {},
+        paths: {}
       };
 
       expect(() => parser.parse(invalidSpec)).toThrow();

package/tests/unit/generator.test.ts

@@ -1,10 +1,9 @@
-import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest';
-import {Generator} from '../../src/generator';
-import {Reporter} from '../../src/utils/reporter';
-import {readFileSync, existsSync, mkdirSync, rmSync} from 'node:fs';
-import {join} from 'node:path';
-import {fileURLToPath} from 'node:url';
-import {dirname} from 'node:path';
+import { existsSync, mkdirSync, readFileSync, rmSync } 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';
+import { Reporter } from '../../src/utils/reporter';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const testOutputDir = join(__dirname, '../../test-output');
@@ -16,21 +15,22 @@ describe('Generator', () => {
   beforeEach(() => {
     // Clean up test output directory
     if (existsSync(testOutputDir)) {
-      rmSync(testOutputDir, {recursive: true, force: true});
+      rmSync(testOutputDir, { recursive: true, force: true });
     }
-    mkdirSync(testOutputDir, {recursive: true});
+
+    mkdirSync(testOutputDir, { recursive: true });
 
     // Create a mock reporter
     mockReporter = {
       log: vi.fn(),
-      error: vi.fn(),
+      error: vi.fn()
     } as unknown as Reporter;
   });
 
   afterEach(() => {
     // Clean up test output directory
     if (existsSync(testOutputDir)) {
-      rmSync(testOutputDir, {recursive: true, force: true});
+      rmSync(testOutputDir, { recursive: true, force: true });
     }
   });
 
@@ -62,7 +62,7 @@ describe('Generator', () => {
       expect(mockReporter.error).not.toHaveBeenCalled();
 
       // Verify output file was created
-      const outputFile = join(testOutputDir, 'type.ts');
+      const outputFile = join(testOutputDir, 'api.ts');
       expect(existsSync(outputFile)).toBe(true);
 
       // Verify file contains expected content
@@ -84,9 +84,8 @@ describe('Generator', () => {
     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');
+      mkdirSync(testOutputDir, { recursive: true });
+      const { writeFileSync } = await import('node:fs');
       writeFileSync(invalidFile, 'invalid: yaml: content: [unclosed');
 
       generator = new Generator('test-app', '1.0.0', mockReporter, invalidFile, testOutputDir);
@@ -102,7 +101,7 @@ describe('Generator', () => {
 
       await generator.run();
 
-      const outputFile = join(testOutputDir, 'type.ts');
+      const outputFile = join(testOutputDir, 'api.ts');
       const content = readFileSync(outputFile, 'utf-8');
 
       // Check for key components
@@ -117,7 +116,7 @@ describe('Generator', () => {
 
       await generator.run();
 
-      const outputFile = join(testOutputDir, 'type.ts');
+      const outputFile = join(testOutputDir, 'api.ts');
       const content = readFileSync(outputFile, 'utf-8');
 
       expect(content).toContain('AUTOGENERATED');
@@ -125,11 +124,24 @@ describe('Generator', () => {
       expect(content).toContain('eslint-disable');
     });
 
+    it('should write to custom file path when output is a .ts path', async () => {
+      const customPath = join(testOutputDir, 'custom.ts');
+      generator = new Generator('test-app', '1.0.0', mockReporter, './samples/swagger-petstore.yaml', customPath);
+
+      const exitCode = await generator.run();
+
+      expect(exitCode).toBe(0);
+      expect(existsSync(customPath)).toBe(true);
+      expect(existsSync(join(testOutputDir, 'api.ts'))).toBe(false);
+      const content = readFileSync(customPath, 'utf-8');
+      expect(content).toMatch(/import\s*{\s*z\s*}\s*from\s*['"]zod['"]/);
+    });
+
     it('should handle unknown error type (not Error instance)', async () => {
       generator = new Generator('test-app', '1.0.0', mockReporter, './samples/swagger-petstore.yaml', testOutputDir);
 
       // Mock the fileReader to throw a non-Error object
-      const {SyncFileReaderService} = await import('../../src/services/file-reader.service');
+      const { SyncFileReaderService } = await import('../../src/services/file-reader.service');
       const originalReadFile = SyncFileReaderService.prototype.readFile;
       SyncFileReaderService.prototype.readFile = vi.fn().mockRejectedValue('string error');
 

package/tests/unit/naming-convention.test.ts

@@ -1,38 +1,38 @@
-import {describe, expect, it} from 'vitest';
-import {transformNamingConvention, type NamingConvention} from '../../src/utils/naming-convention';
+import { describe, expect, it } from 'vitest';
+import { type NamingConvention, transformNamingConvention } from '../../src/utils/naming-convention';
 
 describe('transformNamingConvention', () => {
   describe('transform', () => {
-    const testCases: Array<{
+    const testCases: {
       input: string;
       convention: NamingConvention;
       expected: string;
       description: string;
-    }> = [
+    }[] = [
       // camelCase
       {
         input: 'get_user_by_id',
         convention: 'camelCase',
         expected: 'getUserById',
-        description: 'should convert snake_case to camelCase',
+        description: 'should convert snake_case to camelCase'
       },
       {
         input: 'GetUserById',
         convention: 'camelCase',
         expected: 'getUserById',
-        description: 'should convert PascalCase to camelCase',
+        description: 'should convert PascalCase to camelCase'
       },
       {
         input: 'get-user-by-id',
         convention: 'camelCase',
         expected: 'getUserById',
-        description: 'should convert kebab-case to camelCase',
+        description: 'should convert kebab-case to camelCase'
       },
       {
         input: 'getUserById',
         convention: 'camelCase',
         expected: 'getUserById',
-        description: 'should keep camelCase as camelCase',
+        description: 'should keep camelCase as camelCase'
       },
 
       // PascalCase
@@ -40,19 +40,19 @@ describe('transformNamingConvention', () => {
         input: 'get_user_by_id',
         convention: 'PascalCase',
         expected: 'GetUserById',
-        description: 'should convert snake_case to PascalCase',
+        description: 'should convert snake_case to PascalCase'
       },
       {
         input: 'get-user-by-id',
         convention: 'PascalCase',
         expected: 'GetUserById',
-        description: 'should convert kebab-case to PascalCase',
+        description: 'should convert kebab-case to PascalCase'
       },
       {
         input: 'getUserById',
         convention: 'PascalCase',
         expected: 'GetUserById',
-        description: 'should convert camelCase to PascalCase',
+        description: 'should convert camelCase to PascalCase'
       },
 
       // snake_case
@@ -60,19 +60,19 @@ describe('transformNamingConvention', () => {
         input: 'getUserById',
         convention: 'snake_case',
         expected: 'get_user_by_id',
-        description: 'should convert camelCase to snake_case',
+        description: 'should convert camelCase to snake_case'
       },
       {
         input: 'GetUserById',
         convention: 'snake_case',
         expected: 'get_user_by_id',
-        description: 'should convert PascalCase to snake_case',
+        description: 'should convert PascalCase to snake_case'
       },
       {
         input: 'get-user-by-id',
         convention: 'snake_case',
         expected: 'get_user_by_id',
-        description: 'should convert kebab-case to snake_case',
+        description: 'should convert kebab-case to snake_case'
       },
 
       // kebab-case
@@ -80,19 +80,19 @@ describe('transformNamingConvention', () => {
         input: 'getUserById',
         convention: 'kebab-case',
         expected: 'get-user-by-id',
-        description: 'should convert camelCase to kebab-case',
+        description: 'should convert camelCase to kebab-case'
       },
       {
         input: 'GetUserById',
         convention: 'kebab-case',
         expected: 'get-user-by-id',
-        description: 'should convert PascalCase to kebab-case',
+        description: 'should convert PascalCase to kebab-case'
       },
       {
         input: 'get_user_by_id',
         convention: 'kebab-case',
         expected: 'get-user-by-id',
-        description: 'should convert snake_case to kebab-case',
+        description: 'should convert snake_case to kebab-case'
       },
 
       // SCREAMING_SNAKE_CASE
@@ -100,13 +100,13 @@ describe('transformNamingConvention', () => {
         input: 'getUserById',
         convention: 'SCREAMING_SNAKE_CASE',
         expected: 'GET_USER_BY_ID',
-        description: 'should convert camelCase to SCREAMING_SNAKE_CASE',
+        description: 'should convert camelCase to SCREAMING_SNAKE_CASE'
       },
       {
         input: 'get-user-by-id',
         convention: 'SCREAMING_SNAKE_CASE',
         expected: 'GET_USER_BY_ID',
-        description: 'should convert kebab-case to SCREAMING_SNAKE_CASE',
+        description: 'should convert kebab-case to SCREAMING_SNAKE_CASE'
       },
 
       // SCREAMING-KEBAB-CASE
@@ -114,13 +114,13 @@ describe('transformNamingConvention', () => {
         input: 'getUserById',
         convention: 'SCREAMING-KEBAB-CASE',
         expected: 'GET-USER-BY-ID',
-        description: 'should convert camelCase to SCREAMING-KEBAB-CASE',
+        description: 'should convert camelCase to SCREAMING-KEBAB-CASE'
       },
       {
         input: 'get_user_by_id',
         convention: 'SCREAMING-KEBAB-CASE',
         expected: 'GET-USER-BY-ID',
-        description: 'should convert snake_case to SCREAMING-KEBAB-CASE',
+        description: 'should convert snake_case to SCREAMING-KEBAB-CASE'
       },
 
       // Edge cases
@@ -128,29 +128,29 @@ describe('transformNamingConvention', () => {
         input: '',
         convention: 'camelCase',
         expected: '',
-        description: 'should handle empty string',
+        description: 'should handle empty string'
       },
       {
         input: 'a',
         convention: 'camelCase',
         expected: 'a',
-        description: 'should handle single character',
+        description: 'should handle single character'
       },
       {
         input: 'API',
         convention: 'camelCase',
         expected: 'aPI',
-        description: 'should handle all uppercase (splits at uppercase boundaries)',
+        description: 'should handle all uppercase (splits at uppercase boundaries)'
       },
       {
         input: 'getUser123ById',
         convention: 'snake_case',
         expected: 'get_user_123_by_id',
-        description: 'should handle numbers in identifiers (splits at digit boundaries)',
-      },
+        description: 'should handle numbers in identifiers (splits at digit boundaries)'
+      }
     ];
 
-    testCases.forEach(({input, convention, expected, description}) => {
+    testCases.forEach(({ input, convention, expected, description }) => {
       it(description, () => {
         const result = transformNamingConvention(input, convention);
         expect(result).toBe(expected);

package/tests/unit/type-builder.test.ts

@@ -1,5 +1,5 @@
-import {describe, expect, it, beforeEach} from 'vitest';
-import {TypeScriptTypeBuilderService} from '../../src/services/type-builder.service';
+import { beforeEach, describe, expect, it } from 'vitest';
+import { TypeScriptTypeBuilderService } from '../../src/services/type-builder.service';
 import * as ts from 'typescript';
 
 describe('TypeScriptTypeBuilderService', () => {

package/tsconfig.json

@@ -4,17 +4,19 @@
     "alwaysStrict": true,
     "baseUrl": ".",
     "checkJs": false,
+    "declaration": true,
+    "declarationMap": true,
     "downlevelIteration": true,
+    "emitDecoratorMetadata": true,
     "esModuleInterop": true,
     "exactOptionalPropertyTypes": true,
+    "experimentalDecorators": true,
     "forceConsistentCasingInFileNames": true,
     "incremental": true,
     "isolatedModules": true,
     "lib": ["ES2022", "DOM"],
     "module": "ESNext",
     "moduleResolution": "bundler",
-    "declaration": true,
-    "declarationMap": true,
     "noEmit": false,
     "noFallthroughCasesInSwitch": true,
     "noImplicitAny": true,
@@ -41,6 +43,6 @@
     "useUnknownInCatchVariables": true,
     "verbatimModuleSyntax": false
   },
-  "exclude": ["node_modules", "dist", "build", "examples/**/*.ts", "tests/**/*.ts"],
+  "exclude": ["node_modules", "dist", "build", "examples"],
   "include": ["src/**/*.ts", "scripts/**/*.ts", "tests/**/*.ts", "vitest.config.ts"]
 }

package/vitest.config.ts

@@ -1,39 +1,29 @@
-import {defineConfig} from 'vitest/config';
-import {resolve} from 'node:path';
+import { resolve } from 'node:path';
+import { defineConfig } from 'vitest/config';
 
 export default defineConfig({
   test: {
     globals: true,
     environment: 'node',
-    include: ['**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
+    include: ['**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts}'],
     exclude: ['node_modules', 'dist', 'coverage'],
     coverage: {
       provider: 'v8',
       reporter: ['text', 'json', 'html', 'lcov'],
-      exclude: [
-        'coverage/**',
-        'dist/**',
-        'node_modules/**',
-        '**/*.d.ts',
-        '**/*.config.*',
-        '**/*.test.*',
-        '**/*.spec.*',
-        'scripts/**',
-        'samples/**',
-      ],
+      exclude: ['coverage/**', 'dist/**', 'node_modules/**', '**/*.d.ts', '**/*.config.*', '**/*.test.*', '**/*.spec.*', 'scripts/**', 'samples/**'],
       thresholds: {
         global: {
           branches: 80,
           functions: 80,
           lines: 80,
-          statements: 80,
-        },
-      },
-    },
+          statements: 80
+        }
+      }
+    }
   },
   resolve: {
     alias: {
-      '@': resolve(__dirname, 'src'),
-    },
-  },
+      '@': resolve(__dirname, 'src')
+    }
+  }
 });

package/dist/scripts/update-manifest.d.ts

@@ -1,14 +0,0 @@
-interface PackageJson {
-    name: string;
-    version: string;
-    description: string;
-}
-/**
- * Type guard for the package.json object
- *
- * @param input Unknown input
- * @returns true if the input is an event object
- */
-export declare function isPackageJson(input: unknown): input is PackageJson;
-export {};
-//# sourceMappingURL=update-manifest.d.ts.map

package/dist/scripts/update-manifest.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"update-manifest.d.ts","sourceRoot":"","sources":["../../scripts/update-manifest.ts"],"names":[],"mappings":"AAKA,UAAU,WAAW;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,WAAW,CAclE"}

package/dist/scripts/update-manifest.js

@@ -1,33 +0,0 @@
-import { readFileSync, writeFileSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { z } from 'zod';
-/**
- * Type guard for the package.json object
- *
- * @param input Unknown input
- * @returns true if the input is an event object
- */
-export function isPackageJson(input) {
-    const event = z
-        .object({
-        name: z.string(),
-        version: z.string(),
-        description: z.string(),
-    })
-        .strict()
-        .catchall(z.any())
-        .required();
-    const { success } = event.safeParse(input);
-    return success;
-}
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const sourcePath = resolve(__dirname, '..', 'package.json');
-const data = JSON.parse(readFileSync(sourcePath, 'utf8'));
-if (!isPackageJson(data)) {
-    process.exit(1);
-}
-const { name, version, description } = data;
-const targetPath = resolve(__dirname, '..', 'src', 'assets', 'manifest.json');
-writeFileSync(targetPath, JSON.stringify({ name, version, description }, null, 2));
-process.exit(0);

package/dist/src/assets/manifest.json

@@ -1,5 +0,0 @@
-{
-  "name": "zod-codegen",
-  "version": "1.5.0",
-  "description": "A powerful TypeScript code generator that creates Zod schemas and type-safe clients from OpenAPI specifications"
-}