zod-codegen 1.6.2 → 1.7.0

package/src/services/file-reader.service.ts

@@ -1,8 +1,8 @@
-import {readFileSync} from 'node:fs';
-import {load} from 'js-yaml';
-import type {OpenApiFileParser, OpenApiFileReader} from '../interfaces/file-reader';
-import type {OpenApiSpecType} from '../types/openapi';
-import {OpenApiSpec} from '../types/openapi';
+import { load } from 'js-yaml';
+import { readFileSync } from 'node:fs';
+import type { OpenApiFileParser, OpenApiFileReader } from '../interfaces/file-reader';
+import type { OpenApiSpecType } from '../types/openapi';
+import { OpenApiSpec } from '../types/openapi';
 
 export class SyncFileReaderService implements OpenApiFileReader {
   async readFile(path: string): Promise<string> {
@@ -14,6 +14,7 @@ export class SyncFileReaderService implements OpenApiFileReader {
       if (!response.ok) {
         throw new Error(`Failed to fetch ${path}: ${String(response.status)} ${response.statusText}`);
       }
+
       return await response.text();
     } catch {
       // If URL parsing fails, treat it as a local file path

package/src/services/file-writer.service.ts

@@ -1,12 +1,12 @@
-import {existsSync, mkdirSync, writeFileSync} from 'node:fs';
-import {dirname, resolve} from 'node:path';
-import type {FileWriter} from '../interfaces/code-generator';
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import type { FileWriter } from '../interfaces/code-generator';
 
 export class SyncFileWriterService implements FileWriter {
   constructor(
     private readonly name: string,
     private readonly version: string,
-    private readonly inputPath: string,
+    private readonly inputPath: string
   ) {}
 
   writeFile(filePath: string, content: string): void {
@@ -18,19 +18,19 @@ export class SyncFileWriterService implements FileWriter {
       '/* eslint-disable */',
       '// @ts-nocheck',
       '',
-      content,
+      content
     ].join('\n');
 
     const dirPath = dirname(filePath);
 
     if (!existsSync(dirPath)) {
-      mkdirSync(dirPath, {recursive: true});
+      mkdirSync(dirPath, { recursive: true });
     }
 
     writeFileSync(filePath, generatedContent);
   }
 
-  resolveOutputPath(outputDir: string, fileName = 'type.ts'): string {
+  resolveOutputPath(outputDir: string, fileName = 'api.ts'): string {
     return resolve(outputDir, fileName);
   }
 }

package/src/services/import-builder.service.ts

@@ -1,13 +1,13 @@
 import * as ts from 'typescript';
-import {z} from 'zod';
-import type {ImportBuilder} from '../interfaces/code-generator';
+import { z } from 'zod';
+import type { ImportBuilder } from '../interfaces/code-generator';
 
 const IsTypeImport = z.boolean();
 const ImportedElement = z.record(z.string(), IsTypeImport);
 
 const ImportOptions = z.object({
   defaultImport: ImportedElement.optional(),
-  namedImports: ImportedElement.optional(),
+  namedImports: ImportedElement.optional()
 });
 
 type ImportOptionsType = z.infer<typeof ImportOptions>;
@@ -16,15 +16,15 @@ export class TypeScriptImportBuilderService implements ImportBuilder {
   buildImports(): ts.ImportDeclaration[] {
     return [
       this.createImport('zod', {
-        namedImports: {z: false},
-      }),
+        namedImports: { z: false }
+      })
     ];
   }
 
   createImport(target: string, options: ImportOptionsType): ts.ImportDeclaration {
     const safeOptions = ImportOptions.parse(options);
     const [defaultImport] = Object.entries(safeOptions.defaultImport ?? {})[0] ?? [undefined, false];
-    const {success: hasDefaultImport} = z.string().safeParse(defaultImport);
+    const { success: hasDefaultImport } = z.string().safeParse(defaultImport);
 
     const safeNameImports = ImportedElement.safeParse(safeOptions.namedImports);
     const namedImportList = safeNameImports.success ? Object.entries(safeNameImports.data) : [];
@@ -35,7 +35,7 @@ export class TypeScriptImportBuilderService implements ImportBuilder {
         ? ts.factory.createNamedImports(
             namedImportList.map(([name, isTypeImport]) => {
               return ts.factory.createImportSpecifier(isTypeImport, undefined, ts.factory.createIdentifier(name));
-            }),
+            })
           )
         : undefined;
 
@@ -48,14 +48,10 @@ export class TypeScriptImportBuilderService implements ImportBuilder {
       undefined,
       hasAnyImports
         ? // eslint-disable-next-line @typescript-eslint/no-deprecated
-          ts.factory.createImportClause(
-            false,
-            hasDefaultImport && defaultImport ? ts.factory.createIdentifier(defaultImport) : undefined,
-            namedImports ?? undefined,
-          )
+          ts.factory.createImportClause(false, hasDefaultImport && defaultImport ? ts.factory.createIdentifier(defaultImport) : undefined, namedImports ?? undefined)
         : undefined,
       ts.factory.createStringLiteral(target, true),
-      undefined,
+      undefined
     );
   }
 }

package/src/services/type-builder.service.ts

@@ -1,5 +1,5 @@
 import * as ts from 'typescript';
-import type {TypeBuilder} from '../interfaces/code-generator';
+import type { TypeBuilder } from '../interfaces/code-generator';
 
 export class TypeScriptTypeBuilderService implements TypeBuilder {
   buildType(type: string): ts.TypeNode {
@@ -18,16 +18,15 @@ export class TypeScriptTypeBuilderService implements TypeBuilder {
           const itemType = type.slice(0, -2);
           return ts.factory.createArrayTypeNode(this.buildType(itemType));
         }
+
         // Handle Record types
         if (type.startsWith('Record<')) {
           // For now, return unknown for complex Record types
           return ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword);
         }
+
         // Custom type name - create a type reference
-        return ts.factory.createTypeReferenceNode(
-          ts.factory.createIdentifier(this.sanitizeIdentifier(type)),
-          undefined,
-        );
+        return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(this.sanitizeIdentifier(type)), undefined);
     }
   }
 
@@ -39,33 +38,23 @@ export class TypeScriptTypeBuilderService implements TypeBuilder {
       ts.factory[createIdentifier](name),
       undefined,
       this.buildType(type),
-      undefined,
+      undefined
     );
   }
 
-  createParameter(
-    name: string,
-    type?: string | ts.TypeNode,
-    defaultValue?: ts.Expression,
-    isOptional = false,
-  ): ts.ParameterDeclaration {
+  createParameter(name: string, type?: string | ts.TypeNode, defaultValue?: ts.Expression, isOptional = false): ts.ParameterDeclaration {
     return ts.factory.createParameterDeclaration(
       undefined,
       undefined,
       ts.factory.createIdentifier(this.sanitizeIdentifier(name)),
       isOptional ? ts.factory.createToken(ts.SyntaxKind.QuestionToken) : undefined,
       typeof type === 'string' ? this.buildType(type) : type,
-      defaultValue,
+      defaultValue
     );
   }
 
   createGenericType(name: string): ts.TypeParameterDeclaration {
-    return ts.factory.createTypeParameterDeclaration(
-      undefined,
-      ts.factory.createIdentifier(name),
-      undefined,
-      undefined,
-    );
+    return ts.factory.createTypeParameterDeclaration(undefined, ts.factory.createIdentifier(name), undefined, undefined);
   }
 
   sanitizeIdentifier(name: string): string {

package/src/types/generator-options.ts

@@ -1,4 +1,4 @@
-import type {NamingConvention, OperationNameTransformer} from '../utils/naming-convention';
+import type { NamingConvention, OperationNameTransformer } from '../utils/naming-convention';
 
 /**
  * Configuration options for the Generator class.

package/src/types/openapi.ts

@@ -1,7 +1,7 @@
-import {z} from 'zod';
+import { z } from 'zod';
 
 export const Reference = z.object({
-  $ref: z.string().optional(),
+  $ref: z.string().optional()
 });
 
 const BaseSchemaProperties = z.object({
@@ -38,32 +38,32 @@ const BaseSchemaProperties = z.object({
   xml: z
     .object({
       name: z.string().optional(),
-      wrapped: z.boolean().optional(),
+      wrapped: z.boolean().optional()
     })
     .optional(),
   externalDocs: Reference.optional(),
   example: z.unknown().optional(),
-  deprecated: z.boolean().optional(),
+  deprecated: z.boolean().optional()
 });
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export const SchemaProperties: z.ZodLazy<z.ZodObject<any>> = z.lazy(() =>
   BaseSchemaProperties.extend({
     properties: z.record(z.string(), SchemaProperties).optional(),
-    items: SchemaProperties.optional(),
-  }),
+    items: SchemaProperties.optional()
+  })
 );
 
 const ServerVariable = z.object({
   default: z.string(),
   description: z.string().optional(),
-  enum: z.array(z.string()).optional(),
+  enum: z.array(z.string()).optional()
 });
 
 const Server = z.object({
   url: z.string(), // Allow templated URLs with {variables}
   description: z.string().optional(),
-  variables: z.record(z.string(), ServerVariable).optional(),
+  variables: z.record(z.string(), ServerVariable).optional()
 });
 
 export const Parameter = z.object({
@@ -77,7 +77,7 @@ export const Parameter = z.object({
   style: z.string().optional(),
   explode: z.boolean().optional(),
   allowReserved: z.boolean().optional(),
-  schema: SchemaProperties.optional(),
+  schema: SchemaProperties.optional()
 });
 
 const ResponseHeader = z.object({
@@ -89,25 +89,25 @@ const ResponseHeader = z.object({
   style: z.string().optional(),
   explode: z.boolean().optional(),
   allowReserved: z.boolean().optional(),
-  schema: Reference.optional(),
+  schema: Reference.optional()
 });
 
 const MediaType = z.object({
-  schema: z.unknown().optional(),
+  schema: z.unknown().optional()
 });
 
 export const Response = z.object({
   $ref: z.string().optional(),
   description: z.string(),
   headers: z.record(z.string(), ResponseHeader).optional(),
-  content: z.record(z.string(), MediaType).optional(),
+  content: z.record(z.string(), MediaType).optional()
 });
 
 export const RequestBody = z.object({
   $ref: z.string().optional(),
   description: z.string().optional(),
   required: z.boolean().optional(),
-  content: z.record(z.string(), MediaType).optional(),
+  content: z.record(z.string(), MediaType).optional()
 });
 
 export const MethodSchema = z.object({
@@ -118,7 +118,7 @@ export const MethodSchema = z.object({
   requestBody: RequestBody.optional(),
   responses: z.record(z.string(), Response).optional(),
   tags: z.array(z.string()).optional(),
-  deprecated: z.boolean().optional(),
+  deprecated: z.boolean().optional()
 });
 
 export const PathItem = z.object({
@@ -133,7 +133,7 @@ export const PathItem = z.object({
   head: MethodSchema.optional(),
   options: MethodSchema.optional(),
   trace: MethodSchema.optional(),
-  parameters: z.array(Parameter).optional(),
+  parameters: z.array(Parameter).optional()
 });
 
 const Info = z.object({
@@ -145,15 +145,15 @@ const Info = z.object({
     .object({
       name: z.string().optional(),
       email: z.email().optional(),
-      url: z.url().optional(),
+      url: z.url().optional()
     })
     .optional(),
   license: z
     .object({
       name: z.string().min(1),
-      url: z.url().optional(),
+      url: z.url().optional()
     })
-    .optional(),
+    .optional()
 });
 
 const SecurityRequirement = z.record(z.string(), z.array(z.string()));
@@ -161,12 +161,12 @@ const SecurityRequirement = z.record(z.string(), z.array(z.string()));
 const Tag = z.object({
   name: z.string().min(1),
   description: z.string().optional(),
-  externalDocs: Reference.optional(),
+  externalDocs: Reference.optional()
 });
 
 const ExternalDocumentation = z.object({
   description: z.string().optional(),
-  url: z.url(),
+  url: z.url()
 });
 
 const Components = z.object({
@@ -178,7 +178,7 @@ const Components = z.object({
   headers: z.record(z.string(), ResponseHeader).optional(),
   securitySchemes: z.record(z.string(), Reference).optional(),
   links: z.record(z.string(), Reference).optional(),
-  callbacks: z.record(z.string(), Reference).optional(),
+  callbacks: z.record(z.string(), Reference).optional()
 });
 
 export const OpenApiSpec = z.object({
@@ -189,7 +189,7 @@ export const OpenApiSpec = z.object({
   components: Components.optional(),
   security: z.array(SecurityRequirement).optional(),
   tags: z.array(Tag).optional(),
-  externalDocs: ExternalDocumentation.optional(),
+  externalDocs: ExternalDocumentation.optional()
 });
 
 export type OpenApiSpecType = z.infer<typeof OpenApiSpec>;

package/src/utils/error-handler.ts

@@ -1,5 +1,5 @@
-import {getExecutionTime} from './execution-time';
-import type {Reporter} from './reporter';
+import { getExecutionTime } from './execution-time';
+import type { Reporter } from './reporter';
 
 export const errorReceived = (process: NodeJS.Process, startTime: bigint, reporter: Reporter) => (): void => {
   reporter.log(`Done after ${String(getExecutionTime(startTime))}s`);

package/src/utils/naming-convention.ts

@@ -8,13 +8,7 @@
  * transformNamingConvention('getUserById', 'snake_case') // 'get_user_by_id'
  * ```
  */
-export type NamingConvention =
-  | 'camelCase'
-  | 'PascalCase'
-  | 'snake_case'
-  | 'kebab-case'
-  | 'SCREAMING_SNAKE_CASE'
-  | 'SCREAMING-KEBAB-CASE';
+export type NamingConvention = 'camelCase' | 'PascalCase' | 'snake_case' | 'kebab-case' | 'SCREAMING_SNAKE_CASE' | 'SCREAMING-KEBAB-CASE';
 
 /**
  * Operation details provided to custom transformers.
@@ -66,7 +60,10 @@ export type OperationNameTransformer = (details: OperationDetails) => string;
  * Capitalizes the first letter of a word
  */
 function capitalize(word: string): string {
-  if (word.length === 0) return word;
+  if (word.length === 0) {
+    return word;
+  }
+
   return word.charAt(0).toUpperCase() + word.slice(1);
 }
 
@@ -126,9 +123,15 @@ function normalizeToWords(input: string): string[] {
  * Converts words array to camelCase
  */
 function toCamelCase(words: string[]): string {
-  if (words.length === 0) return '';
+  if (words.length === 0) {
+    return '';
+  }
+
   const [first, ...rest] = words;
-  if (!first) return '';
+  if (!first) {
+    return '';
+  }
+
   return first + rest.map((w) => capitalize(w)).join('');
 }
 

package/src/utils/reporter.ts

@@ -1,9 +1,9 @@
-import {format} from 'node:util';
+import { format } from 'node:util';
 
 export class Reporter {
   constructor(
     private readonly stdout: NodeJS.WriteStream,
-    private readonly stderr: NodeJS.WriteStream = stdout,
+    private readonly stderr: NodeJS.WriteStream = stdout
   ) {
     this.log = this.log.bind(this);
     this.error = this.error.bind(this);

package/src/utils/signal-handler.ts

@@ -1,12 +1,11 @@
-import {getExecutionTime} from './execution-time';
-import type {Reporter} from './reporter';
+import { getExecutionTime } from './execution-time';
+import type { Reporter } from './reporter';
 
-export const signalReceived =
-  (process: NodeJS.Process, startTime: bigint, event: NodeJS.Signals, reporter: Reporter) => (): void => {
-    reporter.log(`Done after ${String(getExecutionTime(startTime))}s`);
-    process.kill(process.pid, event);
-    process.exit(1);
-  };
+export const signalReceived = (process: NodeJS.Process, startTime: bigint, event: NodeJS.Signals, reporter: Reporter) => (): void => {
+  reporter.log(`Done after ${String(getExecutionTime(startTime))}s`);
+  process.kill(process.pid, event);
+  process.exit(1);
+};
 
 export const handleSignals = (process: NodeJS.Process, startTime: bigint, reporter: Reporter): void => {
   const catchSignals: NodeJS.Signals[] = ['SIGTERM', 'SIGINT', 'SIGUSR2'];

package/tests/integration/cli-comprehensive.test.ts

@@ -1,7 +1,7 @@
-import {describe, expect, it} from 'vitest';
-import {execSync} from 'node:child_process';
-import {resolve} from 'node:path';
-import {existsSync, rmSync, readFileSync} from 'node:fs';
+import { execSync } from 'node:child_process';
+import { existsSync, readFileSync, rmSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { describe, expect, it } from 'vitest';
 
 describe('CLI Comprehensive Integration', () => {
   const cwd = resolve(__dirname, '../..');
@@ -9,13 +9,13 @@ describe('CLI Comprehensive Integration', () => {
 
   beforeEach(() => {
     if (existsSync(testOutputDir)) {
-      rmSync(testOutputDir, {recursive: true, force: true});
+      rmSync(testOutputDir, { recursive: true, force: true });
     }
   });
 
   afterEach(() => {
     if (existsSync(testOutputDir)) {
-      rmSync(testOutputDir, {recursive: true, force: true});
+      rmSync(testOutputDir, { recursive: true, force: true });
     }
   });
 
@@ -23,10 +23,10 @@ describe('CLI Comprehensive Integration', () => {
     it('should generate code with default output directory', () => {
       execSync('node ./dist/src/cli.js --input ./samples/swagger-petstore.yaml --output generated', {
         encoding: 'utf-8',
-        cwd,
+        cwd
       });
 
-      const outputFile = resolve(cwd, 'generated/type.ts');
+      const outputFile = resolve(cwd, 'generated/api.ts');
       expect(existsSync(outputFile)).toBe(true);
 
       const content = readFileSync(outputFile, 'utf-8');
@@ -36,23 +36,20 @@ describe('CLI Comprehensive Integration', () => {
     it('should generate code with custom output directory', () => {
       execSync(`node ./dist/src/cli.js --input ./samples/swagger-petstore.yaml --output ${testOutputDir}`, {
         encoding: 'utf-8',
-        cwd,
+        cwd
       });
 
-      const outputFile = resolve(testOutputDir, 'type.ts');
+      const outputFile = resolve(testOutputDir, 'api.ts');
       expect(existsSync(outputFile)).toBe(true);
     });
 
     it('should accept naming convention option', () => {
-      execSync(
-        `node ./dist/src/cli.js --input ./samples/swagger-petstore.yaml --output ${testOutputDir} --naming-convention camelCase`,
-        {
-          encoding: 'utf-8',
-          cwd,
-        },
-      );
+      execSync(`node ./dist/src/cli.js --input ./samples/swagger-petstore.yaml --output ${testOutputDir} --naming-convention camelCase`, {
+        encoding: 'utf-8',
+        cwd
+      });
 
-      const outputFile = resolve(testOutputDir, 'type.ts');
+      const outputFile = resolve(testOutputDir, 'api.ts');
       const content = readFileSync(outputFile, 'utf-8');
 
       // Verify camelCase is applied (operation IDs should be camelCase)
@@ -61,16 +58,25 @@ describe('CLI Comprehensive Integration', () => {
 
     it('should reject invalid naming convention', () => {
       expect(() => {
-        execSync(
-          `node ./dist/src/cli.js --input ./samples/swagger-petstore.yaml --output ${testOutputDir} --naming-convention invalid`,
-          {
-            encoding: 'utf-8',
-            cwd,
-            stdio: 'pipe',
-          },
-        );
+        execSync(`node ./dist/src/cli.js --input ./samples/swagger-petstore.yaml --output ${testOutputDir} --naming-convention invalid`, {
+          encoding: 'utf-8',
+          cwd,
+          stdio: 'pipe'
+        });
       }).toThrow();
     });
+
+    it('should write to custom file when output is a .ts path', () => {
+      const outputFile = resolve(testOutputDir, 'client.ts');
+      execSync(`node ./dist/src/cli.js --input ./samples/swagger-petstore.yaml --output "${outputFile}"`, {
+        encoding: 'utf-8',
+        cwd
+      });
+
+      expect(existsSync(outputFile)).toBe(true);
+      const content = readFileSync(outputFile, 'utf-8');
+      expect(content).toContain('SwaggerPetstoreOpenAPI30');
+    });
   });
 
   describe('CLI Error Handling', () => {
@@ -79,7 +85,7 @@ describe('CLI Comprehensive Integration', () => {
         execSync('node ./dist/src/cli.js --input ./nonexistent.yaml --output generated', {
           encoding: 'utf-8',
           cwd,
-          stdio: 'pipe',
+          stdio: 'pipe'
         });
         expect.fail('Should have thrown an error');
       } catch (error: unknown) {
@@ -93,7 +99,7 @@ describe('CLI Comprehensive Integration', () => {
         execSync('node ./dist/src/cli.js --output generated', {
           encoding: 'utf-8',
           cwd,
-          stdio: 'pipe',
+          stdio: 'pipe'
         });
       }).toThrow();
     });
@@ -103,20 +109,20 @@ describe('CLI Comprehensive Integration', () => {
     it('should handle JSON format', () => {
       execSync(`node ./dist/src/cli.js --input ./samples/pokeapi-openapi.json --output ${testOutputDir}`, {
         encoding: 'utf-8',
-        cwd,
+        cwd
       });
 
-      const outputFile = resolve(testOutputDir, 'type.ts');
+      const outputFile = resolve(testOutputDir, 'api.ts');
       expect(existsSync(outputFile)).toBe(true);
     });
 
     it('should handle YAML format', () => {
       execSync(`node ./dist/src/cli.js --input ./samples/swagger-petstore.yaml --output ${testOutputDir}`, {
         encoding: 'utf-8',
-        cwd,
+        cwd
       });
 
-      const outputFile = resolve(testOutputDir, 'type.ts');
+      const outputFile = resolve(testOutputDir, 'api.ts');
       expect(existsSync(outputFile)).toBe(true);
     });
   });

package/tests/integration/cli.test.ts

@@ -1,13 +1,13 @@
-import {describe, expect, it} from 'vitest';
-import {execSync} from 'node:child_process';
-import {resolve} from 'node:path';
+import { execSync } from 'node:child_process';
+import { resolve } from 'node:path';
+import { describe, expect, it } from 'vitest';
 
 describe('CLI Integration', () => {
   describe('--help', () => {
     it('should display help information', () => {
       const result = execSync('node ./dist/src/cli.js --help', {
         encoding: 'utf-8',
-        cwd: resolve(__dirname, '../..'),
+        cwd: resolve(__dirname, '../..')
       });
 
       expect(result).toContain('Usage:');
@@ -20,7 +20,7 @@ describe('CLI Integration', () => {
     it('should display version information', () => {
       const result = execSync('node ./dist/src/cli.js --version', {
         encoding: 'utf-8',
-        cwd: resolve(__dirname, '../..'),
+        cwd: resolve(__dirname, '../..')
       });
 
       expect(result).toMatch(/\d+\.\d+\.\d+/);