zod-codegen 1.5.1 → 1.6.2

package/generated/type.ts

@@ -0,0 +1,326 @@
+// THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+// Built with zod-codegen@1.6.2
+// Latest edit: Mon, 19 Jan 2026 15:14:43 GMT
+// Source file: ./samples/swagger-petstore.yaml
+/* eslint-disable */
+// @ts-nocheck
+
+
+// Imports
+;
+import { z } from 'zod';
+
+// Components schemas
+;
+export const Order = z.object({
+    id: z.number().int().optional(),
+    petId: z.number().int().optional(),
+    quantity: z.number().int().optional(),
+    shipDate: z.iso.datetime({
+        local: true
+    }).optional(),
+    status: z.enum(['placed', 'approved', 'delivered']).optional(),
+    complete: z.boolean().optional()
+});
+export const Address = z.object({
+    street: z.string().optional(),
+    city: z.string().optional(),
+    state: z.string().optional(),
+    zip: z.string().optional()
+});
+export const Customer = z.object({
+    id: z.number().int().optional(),
+    username: z.string().optional(),
+    address: z.array(Address).optional()
+});
+export const Category = z.object({
+    id: z.number().int().optional(),
+    name: z.string().optional()
+});
+export const User = z.object({
+    id: z.number().int().optional(),
+    username: z.string().optional(),
+    firstName: z.string().optional(),
+    lastName: z.string().optional(),
+    email: z.string().optional(),
+    password: z.string().optional(),
+    phone: z.string().optional(),
+    userStatus: z.number().int().optional()
+});
+export const Tag = z.object({
+    id: z.number().int().optional(),
+    name: z.string().optional()
+});
+export const Pet = z.object({
+    id: z.number().int().optional(),
+    name: z.string(),
+    category: Category.optional(),
+    photoUrls: z.array(z.string()),
+    tags: z.array(Tag).optional(),
+    status: z.enum(['available', 'pending', 'sold']).optional()
+});
+export const ApiResponse = z.object({
+    code: z.number().int().optional(),
+    type: z.string().optional(),
+    message: z.string().optional()
+});
+export type Order = z.infer<typeof Order>;
+export type Address = z.infer<typeof Address>;
+export type Customer = z.infer<typeof Customer>;
+export type Category = z.infer<typeof Category>;
+export type User = z.infer<typeof User>;
+export type Tag = z.infer<typeof Tag>;
+export type Pet = z.infer<typeof Pet>;
+export type ApiResponse = z.infer<typeof ApiResponse>;
+export const serverConfigurations = [{
+        url: 'https://petstore3.swagger.io/api/v3'
+    }];
+export const defaultBaseUrl = 'https://petstore3.swagger.io/api/v3';
+export type ClientOptions = {
+    baseUrl?: string;
+    serverIndex?: number;
+    serverVariables?: Record<string, string>;
+};
+function resolveServerUrl(serverIndex?: number | undefined, serverVariables?: Record<string, string> = {}): string {
+    const configs = [{
+            url: 'https://petstore3.swagger.io/api/v3'
+        }];
+    const idx = serverIndex ?? 0;
+    if (idx < configs.length) {
+        const config = configs[idx];
+        let url = config.url;
+        if (config.variables && serverVariables) {
+            for (const [key, value] of Object.entries(serverVariables)) {
+                url = url.replace(new RegExp("\\{" + key + "\\}", "g"), value);
+            }
+        }
+        return url;
+    }
+    return 'https://petstore3.swagger.io/api/v3';
+}
+
+// Client class
+;
+export default class SwaggerPetstoreOpenAPI30 {
+    readonly #baseUrl: string;
+    constructor(options: ClientOptions) {
+        const resolvedUrl = options.baseUrl !== null ? options.baseUrl : resolveServerUrl(options.serverIndex, options.serverVariables);
+        this.#baseUrl = resolvedUrl;
+    }
+    protected getBaseRequestOptions(): Partial<Omit<RequestInit, 'method' | 'body'>> {
+        return {};
+    }
+    protected async handleResponse<T>(response: Response, method: string, path: string, options: _params___Record_string__string___number___boolean___data___unknown__contentType___string__headers___Record_string__string__): Promise<Response> {
+        return response;
+    }
+    protected async makeRequest<T>(method: string, path: string, options: _params___Record_string__string___number___boolean___data___unknown__contentType___string__headers___Record_string__string__ = {}): Promise<T> {
+        const baseUrl = new URL(path, this.#baseUrl);
+        const url = options.params && Object.keys(options.params).length > 0 ? (() => {
+            Object.entries(options.params).filter(([, value]) => value !== undefined).forEach(([key, value]) => { baseUrl.searchParams.set(key, String(value)); });
+            return baseUrl.toString();
+        })() : baseUrl.toString();
+        const baseOptions = this.getBaseRequestOptions();
+        const contentType = options.contentType === 'application/x-www-form-urlencoded' ? 'application/x-www-form-urlencoded' : 'application/json';
+        const baseHeaders = baseOptions.headers !== undefined ? baseOptions.headers : {};
+        const headers = Object.assign({}, baseHeaders, { 'Content-Type': contentType }, options.headers !== undefined ? options.headers : {});
+        const body = options.data !== undefined ? options.contentType === 'application/x-www-form-urlencoded' ? (() => { const params = new URLSearchParams(); Object.entries(options.data).forEach(([key, value]) => { params.set(key, String(value)); }); return params.toString(); })() : JSON.stringify(options.data) : null;
+        const rawResponse = await fetch(url, Object.assign({}, baseOptions, { method, headers: headers, body: body }));
+        const response = await this.handleResponse<T>(rawResponse, method, path, options);
+        if (!response.ok)
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        return await response.json();
+    }
+    /**
+     * Add a new pet to the store
+     * @param body Create a new pet in the store
+     * @returns {Pet}
+     */
+    async addPet(body: Pet): Promise<Pet> {
+        return Pet.parse(await this.makeRequest('POST', '/pet', { data: body, contentType: 'application/x-www-form-urlencoded' }));
+    }
+    /**
+     * Update an existing pet
+     *
+     * Update an existing pet by Id
+     * @param body Update an existent pet in the store
+     * @returns {Pet}
+     */
+    async updatePet(body: Pet): Promise<Pet> {
+        return Pet.parse(await this.makeRequest('PUT', '/pet', { data: body, contentType: 'application/x-www-form-urlencoded' }));
+    }
+    /**
+     * Finds Pets by status
+     *
+     * Multiple status values can be provided with comma separated strings
+     *
+     * @param status Status values that need to be considered for filter
+     * @returns {Pet[]}
+     */
+    async findPetsByStatus(status?: string): Promise<Pet[]> {
+        return await this.makeRequest('GET', '/pet/findByStatus', { params: { 'status': status } });
+    }
+    /**
+     * Finds Pets by tags
+     *
+     * Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
+     *
+     * @param tags Tags to filter by
+     * @returns {Pet[]}
+     */
+    async findPetsByTags(tags?: string[]): Promise<Pet[]> {
+        return await this.makeRequest('GET', '/pet/findByTags', { params: { 'tags': tags } });
+    }
+    /**
+     * Find pet by ID
+     *
+     * Returns a single pet
+     *
+     * @param petId ID of pet to return
+     * @returns {Pet}
+     */
+    async getPetById(petId: number): Promise<Pet> {
+        return Pet.parse(await this.makeRequest('GET', `/pet/${petId}`, {}));
+    }
+    /**
+     * Updates a pet in the store with form data
+     *
+     * @param petId ID of pet that needs to be updated
+     * @param name Name of pet that needs to be updated
+     * @param status Status of pet that needs to be updated
+     * @returns {void}
+     */
+    async updatePetWithForm(petId: number, name?: string, status?: string): Promise<void> {
+        return await this.makeRequest('POST', `/pet/${petId}`, { params: { 'name': name, 'status': status } });
+    }
+    /**
+     * Deletes a pet
+     *
+     * delete a pet
+     *
+     * @param api_key
+     * @param petId Pet id to delete
+     * @returns {void}
+     */
+    async deletePet(petId: number): Promise<void> {
+        return await this.makeRequest('DELETE', `/pet/${petId}`, {});
+    }
+    /**
+     * uploads an image
+     *
+     * @param petId ID of pet to update
+     * @param additionalMetadata Additional Metadata
+     * @param body
+     * @returns {ApiResponse}
+     */
+    async uploadFile(petId: number, additionalMetadata?: string): Promise<ApiResponse> {
+        return ApiResponse.parse(await this.makeRequest('POST', `/pet/${petId}/uploadImage`, { params: { 'additionalMetadata': additionalMetadata } }));
+    }
+    /**
+     * Returns pet inventories by status
+     *
+     * Returns a map of status codes to quantities
+     * @returns {Record<string, unknown>}
+     */
+    async getInventory(): Promise<Record<string, unknown>> {
+        return await this.makeRequest('GET', '/store/inventory', {});
+    }
+    /**
+     * Place an order for a pet
+     *
+     * Place a new order in the store
+     * @param body
+     * @returns {Order}
+     */
+    async placeOrder(body?: Order): Promise<Order> {
+        return Order.parse(await this.makeRequest('POST', '/store/order', { data: body, contentType: 'application/x-www-form-urlencoded' }));
+    }
+    /**
+     * Find purchase order by ID
+     *
+     * For valid response try integer IDs with value <= 5 or > 10. Other values will generate exceptions.
+     *
+     * @param orderId ID of order that needs to be fetched
+     * @returns {Order}
+     */
+    async getOrderById(orderId: number): Promise<Order> {
+        return Order.parse(await this.makeRequest('GET', `/store/order/${orderId}`, {}));
+    }
+    /**
+     * Delete purchase order by ID
+     *
+     * For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors
+     *
+     * @param orderId ID of the order that needs to be deleted
+     * @returns {void}
+     */
+    async deleteOrder(orderId: number): Promise<void> {
+        return await this.makeRequest('DELETE', `/store/order/${orderId}`, {});
+    }
+    /**
+     * Create user
+     *
+     * This can only be done by the logged in user.
+     * @param body Created user object
+     * @returns {User}
+     */
+    async createUser(body?: User): Promise<User> {
+        return User.parse(await this.makeRequest('POST', '/user', { data: body, contentType: 'application/x-www-form-urlencoded' }));
+    }
+    /**
+     * Creates list of users with given input array
+     * @param body
+     * @returns {User}
+     */
+    async createUsersWithListInput(body?: User[]): Promise<User> {
+        return User.parse(await this.makeRequest('POST', '/user/createWithList', { data: body }));
+    }
+    /**
+     * Logs user into the system
+     *
+     * @param username The user name for login
+     * @param password The password for login in clear text
+     * @returns {string}
+     */
+    async loginUser(username?: string, password?: string): Promise<string> {
+        return await this.makeRequest('GET', '/user/login', { params: { 'username': username, 'password': password } });
+    }
+    /**
+     * Logs out current logged in user session
+     * @returns {void}
+     */
+    async logoutUser(): Promise<void> {
+        return await this.makeRequest('GET', '/user/logout', {});
+    }
+    /**
+     * Get user by user name
+     *
+     * @param username The name that needs to be fetched. Use user1 for testing.
+     * @returns {User}
+     */
+    async getUserByName(username: string): Promise<User> {
+        return User.parse(await this.makeRequest('GET', `/user/${username}`, {}));
+    }
+    /**
+     * Update user
+     *
+     * This can only be done by the logged in user.
+     *
+     * @param username name that need to be deleted
+     * @param body Update an existent user in the store
+     * @returns {void}
+     */
+    async updateUser(username: string, body?: User): Promise<void> {
+        return await this.makeRequest('PUT', `/user/${username}`, { data: body, contentType: 'application/x-www-form-urlencoded' });
+    }
+    /**
+     * Delete user
+     *
+     * This can only be done by the logged in user.
+     *
+     * @param username The name that needs to be deleted
+     * @returns {void}
+     */
+    async deleteUser(username: string): Promise<void> {
+        return await this.makeRequest('DELETE', `/user/${username}`, {});
+    }
+}

package/package.json

@@ -13,7 +13,7 @@
     "openapi-types": "^12.1.3",
     "openapi-typescript": "^7.10.1",
     "path-to-regexp": "^8.3.0",
-    "prettier": "^3.6.2",
+    "prettier": "^3.8.0",
     "typescript": "^5.9.3",
     "url-pattern": "^1.0.3",
     "yargs": "^18.0.0",
@@ -41,9 +41,9 @@
     "@types/jest": "^30.0.0",
     "@types/js-yaml": "^4.0.9",
     "@types/jsonpath": "^0.2.4",
-    "@types/node": "^25.0.3",
+    "@types/node": "^25.0.9",
     "@types/yargs": "^17.0.35",
-    "@vitest/coverage-v8": "^4.0.16",
+    "@vitest/coverage-v8": "^4.0.17",
     "cross-env": "^10.1.0",
     "eslint": "^9.39.2",
     "eslint-config-prettier": "^10.1.8",
@@ -51,13 +51,10 @@
     "lint-staged": "^16.2.7",
     "semantic-release": "^25.0.2",
     "ts-node": "^10.9.2",
-    "typescript-eslint": "^8.51.0",
-    "undici": "^7.16.0",
+    "typescript-eslint": "^8.53.0",
+    "undici": "^7.18.2",
     "vitest": "^4.0.14"
   },
-  "optionalDependencies": {
-    "undici": "^7.16.0"
-  },
   "homepage": "https://github.com/julienandreu/zod-codegen",
   "license": "Apache-2.0",
   "name": "zod-codegen",
@@ -75,21 +72,19 @@
     "url": "git+ssh://git@github.com/julienandreu/zod-codegen.git"
   },
   "engines": {
-    "node": ">=24.11.1"
+    "node": ">=18.0.0"
   },
   "overrides": {
-    "npm": {
-      "glob": "^11.1.0",
-      "tar": "^7.5.2"
-    },
-    "glob": "^11.1.0",
-    "tar": "^7.5.2",
-    "yargs": "^18.0.0"
+    "tar": "^7.5.3",
+    "diff": "^8.0.3",
+    "@actions/http-client": {
+      "undici": "^7.18.0"
+    }
   },
   "scripts": {
     "audit:fix": "npm audit fix",
-    "build": "NODE_OPTIONS='--no-deprecation' sh -c 'rm -rf dist && tsc --project tsconfig.json && cp -r src/assets dist/src/ && chmod +x ./dist/src/cli.js'",
-    "build:native": "rm -rf dist && NODE_OPTIONS='--no-deprecation' npx tsgo --project tsconfig.json && cp -r src/assets dist/src/ && chmod +x ./dist/src/cli.js",
+    "build": "NODE_OPTIONS='--no-deprecation' sh -c 'rm -rf dist && tsc --project tsconfig.json && ts-node scripts/add-js-extensions.ts && mkdir -p dist/src/assets && cp -r src/assets/. dist/src/assets/ && chmod +x ./dist/src/cli.js'",
+    "build:native": "rm -rf dist && NODE_OPTIONS='--no-deprecation' npx tsgo --project tsconfig.json && ts-node scripts/add-js-extensions.ts && cp -r src/assets dist/src/ && chmod +x ./dist/src/cli.js",
     "build:watch": "tsc --project tsconfig.json --watch",
     "dev": "npm run build && node ./dist/src/cli.js --input ./samples/swagger-petstore.yaml --output ./examples/petstore && npm run format && npm run lint",
     "lint": "eslint src --fix",
@@ -110,5 +105,5 @@
     "release": "semantic-release",
     "release:dry": "semantic-release --dry-run"
   },
-  "version": "1.5.1"
+  "version": "1.6.2"
 }

package/scripts/add-js-extensions.ts

@@ -0,0 +1,79 @@
+import {readdirSync, readFileSync, statSync, writeFileSync} from 'node:fs';
+import {extname, join} from 'node:path';
+
+/**
+ * Recursively finds all .js files in a directory
+ */
+function findJsFiles(dir: string): string[] {
+  const files: string[] = [];
+  const entries = readdirSync(dir);
+
+  for (const entry of entries) {
+    const fullPath = join(dir, entry);
+    const stat = statSync(fullPath);
+
+    if (stat.isDirectory()) {
+      files.push(...findJsFiles(fullPath));
+    } else if (extname(entry) === '.js') {
+      files.push(fullPath);
+    }
+  }
+
+  return files;
+}
+
+/**
+ * Adds .js extensions to relative imports in a JavaScript file
+ */
+function addJsExtensions(content: string): string {
+  // Match relative imports: './something' or '../something' but not './something.js' or node: imports
+  // Handles both single and double quotes
+  // Also handles type imports: import type { ... } from './something'
+  const importRegex = /from\s+(['"])(\.\.?\/[^'"]+?)(['"])/g;
+
+  return content.replace(importRegex, (match, quote: string, importPath: string, endQuote: string) => {
+    // Skip if already has an extension
+    if (importPath.endsWith('.js') || importPath.endsWith('.json')) {
+      return match;
+    }
+
+    // Add .js extension
+    return `from ${quote}${importPath}.js${endQuote}`;
+  });
+}
+
+/**
+ * Main function to process all JavaScript files in dist/src
+ */
+function main(): void {
+  const distDir = join(process.cwd(), 'dist', 'src');
+
+  try {
+    const jsFiles = findJsFiles(distDir);
+
+    if (jsFiles.length === 0) {
+      console.warn('No .js files found in dist/src');
+      process.exit(0);
+    }
+
+    let processedCount = 0;
+
+    for (const filePath of jsFiles) {
+      const content = readFileSync(filePath, 'utf-8');
+      const updatedContent = addJsExtensions(content);
+
+      if (content !== updatedContent) {
+        writeFileSync(filePath, updatedContent, 'utf-8');
+        processedCount++;
+      }
+    }
+
+    console.log(`✅ Added .js extensions to ${String(processedCount)} file(s)`);
+    process.exit(0);
+  } catch (error) {
+    console.error('❌ Error processing files:', error);
+    process.exit(1);
+  }
+}
+
+main();

package/scripts/update-manifest.ts

@@ -1,5 +1,6 @@
-import {readFileSync, writeFileSync} from 'fs';
-import {resolve} from 'path';
+import {readFileSync, writeFileSync} from 'node:fs';
+import {dirname, resolve} from 'node:path';
+import {fileURLToPath} from 'node:url';
 import {z} from 'zod';
 
 interface PackageJson {
@@ -30,6 +31,7 @@ export function isPackageJson(input: unknown): input is PackageJson {
   return success;
 }
 
+const __dirname = dirname(fileURLToPath(import.meta.url));
 const sourcePath = resolve(__dirname, '..', 'package.json');
 
 const data: unknown = JSON.parse(readFileSync(sourcePath, 'utf8'));

package/src/assets/manifest.json

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

package/src/cli.ts

@@ -2,16 +2,16 @@
 
 import yargs from 'yargs';
 import {hideBin} from 'yargs/helpers';
-import {Generator, type GeneratorOptions, type NamingConvention} from './generator.js';
+import {Generator, type GeneratorOptions, type NamingConvention} from './generator';
 import {readFileSync} from 'node:fs';
 import {fileURLToPath} from 'node:url';
 import {dirname, join} from 'node:path';
 
 import loudRejection from 'loud-rejection';
-import {handleErrors} from './utils/error-handler.js';
-import {handleSignals} from './utils/signal-handler.js';
+import {handleErrors} from './utils/error-handler';
+import {handleSignals} from './utils/signal-handler';
 import debug from 'debug';
-import {Reporter} from './utils/reporter.js';
+import {Reporter} from './utils/reporter';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 // Read package.json from the project root
@@ -47,14 +47,14 @@ const packageData = JSON.parse(readFileSync(packageJsonPath, 'utf-8')) as {
 };
 
 const {name, description, version} = packageData;
-const reporter = new Reporter(process.stdout);
+const reporter = new Reporter(process.stdout, process.stderr);
 const startTime = process.hrtime.bigint();
 
 debug(`${name}:${String(process.pid)}`);
 
 loudRejection();
-handleSignals(process, startTime);
-handleErrors(process, startTime);
+handleSignals(process, startTime, reporter);
+handleErrors(process, startTime, reporter);
 
 const argv = yargs(hideBin(process.argv))
   .scriptName(name)

package/src/generator.ts

@@ -1,14 +1,41 @@
-import type {Reporter} from './utils/reporter.js';
-import type {OpenApiSpecType} from './types/openapi.js';
-import type {GeneratorOptions} from './types/generator-options.js';
-import {OpenApiFileParserService, SyncFileReaderService} from './services/file-reader.service.js';
-import {TypeScriptCodeGeneratorService} from './services/code-generator.service.js';
-import {SyncFileWriterService} from './services/file-writer.service.js';
+import type {Reporter} from './utils/reporter';
+import type {OpenApiSpecType} from './types/openapi';
+import type {GeneratorOptions} from './types/generator-options';
+import {OpenApiFileParserService, SyncFileReaderService} from './services/file-reader.service';
+import {TypeScriptCodeGeneratorService} from './services/code-generator.service';
+import {SyncFileWriterService} from './services/file-writer.service';
 
 // Re-export types for library users
-export type {GeneratorOptions} from './types/generator-options.js';
-export type {NamingConvention, OperationDetails, OperationNameTransformer} from './utils/naming-convention.js';
+export type {GeneratorOptions} from './types/generator-options';
+export type {NamingConvention, OperationDetails, OperationNameTransformer} from './utils/naming-convention';
 
+/**
+ * Main generator class for creating TypeScript code from OpenAPI specifications.
+ *
+ * This class orchestrates the code generation process:
+ * 1. Reads the OpenAPI specification file (local or remote)
+ * 2. Parses and validates the specification
+ * 3. Generates TypeScript code with Zod schemas and type-safe API client
+ * 4. Writes the generated code to the output directory
+ *
+ * @example
+ * ```typescript
+ * import {Generator} from 'zod-codegen';
+ * import {Reporter} from './utils/reporter';
+ *
+ * const reporter = new Reporter(process.stdout, process.stderr);
+ * const generator = new Generator(
+ *   'my-app',
+ *   '1.0.0',
+ *   reporter,
+ *   './openapi.yaml',
+ *   './generated',
+ *   {namingConvention: 'camelCase'}
+ * );
+ *
+ * const exitCode = await generator.run();
+ * ```
+ */
 export class Generator {
   private readonly fileReader = new SyncFileReaderService();
   private readonly fileParser = new OpenApiFileParserService();
@@ -16,6 +43,16 @@ export class Generator {
   private readonly fileWriter: SyncFileWriterService;
   private readonly outputPath: string;
 
+  /**
+   * Creates a new Generator instance.
+   *
+   * @param _name - The name of the application/library (used in generated file headers)
+   * @param _version - The version of the application/library (used in generated file headers)
+   * @param reporter - Reporter instance for logging messages and errors
+   * @param inputPath - Path or URL to the OpenAPI specification file
+   * @param _outputDir - Directory where generated files will be written
+   * @param options - Optional configuration for code generation
+   */
   constructor(
     private readonly _name: string,
     private readonly _version: string,
@@ -29,6 +66,11 @@ export class Generator {
     this.codeGenerator = new TypeScriptCodeGeneratorService(options);
   }
 
+  /**
+   * Executes the code generation process.
+   *
+   * @returns Promise that resolves to an exit code (0 for success, 1 for failure)
+   */
   async run(): Promise<number> {
     try {
       const rawSource = await this.readFile();
@@ -46,7 +88,7 @@ export class Generator {
         this.reporter.error('❌ An unknown error occurred');
       }
 
-      return Promise.resolve(1);
+      return 1;
     }
   }
 

package/src/interfaces/code-generator.ts

@@ -1,4 +1,4 @@
-import type {OpenApiSpecType} from '../types/openapi.js';
+import type {OpenApiSpecType} from '../types/openapi';
 
 export interface CodeGenerator {
   generate(spec: OpenApiSpecType): string;