zod-codegen 1.0.0

package/samples/test-logical.yaml

@@ -0,0 +1,50 @@
+openapi: 3.0.0
+info:
+  title: Test Logical Operators
+  version: 1.0.0
+paths: {}
+components:
+  schemas:
+    TestAnyOf:
+      anyOf:
+        - type: string
+        - type: number
+        - type: boolean
+    
+    TestOneOf:
+      oneOf:
+        - type: string
+        - type: number
+    
+    TestAllOf:
+      allOf:
+        - type: object
+          properties:
+            name:
+              type: string
+        - type: object
+          properties:
+            age:
+              type: number
+    
+    TestNot:
+      not:
+        type: string
+    
+    TestComplex:
+      type: object
+      properties:
+        unionField:
+          anyOf:
+            - type: string
+            - type: number
+        intersectionField:
+          allOf:
+            - type: object
+              properties:
+                id:
+                  type: string
+            - type: object
+              properties:
+                timestamp:
+                  type: number

package/scripts/update-manifest.js

@@ -0,0 +1,31 @@
+import {readFileSync, writeFileSync} from 'fs';
+import {resolve} from 'path';
+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 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/scripts/update-manifest.ts

@@ -0,0 +1,47 @@
+import {readFileSync, writeFileSync} from 'fs';
+import {resolve} from 'path';
+import {z} from 'zod';
+
+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 function isPackageJson(input: unknown): input is PackageJson {
+  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 sourcePath = resolve(__dirname, '..', 'package.json');
+
+const data: unknown = 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/src/assets/manifest.json

@@ -0,0 +1,5 @@
+{
+  "name": "zod-codegen",
+  "version": "0.1.0-alpha.1",
+  "description": "Zod code generator"
+}

package/src/cli.ts

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+
+import yargs from 'yargs';
+import {hideBin} from 'yargs/helpers';
+import {Generator} from './generator.js';
+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 debug from 'debug';
+import {isManifest} from './utils/manifest.js';
+import {Reporter} from './utils/reporter.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const manifestData: unknown = JSON.parse(readFileSync(join(__dirname, 'assets', 'manifest.json'), 'utf-8'));
+
+if (!isManifest(manifestData)) {
+  process.exit(1);
+}
+
+const {name, description, version} = manifestData;
+const reporter = new Reporter(process.stdout);
+const startTime = process.hrtime.bigint();
+
+debug(`${name}:${String(process.pid)}`);
+
+loudRejection();
+handleSignals(process, startTime);
+handleErrors(process, startTime);
+
+const argv = yargs(hideBin(process.argv))
+  .scriptName(name)
+  .usage(`${description}\n\nUsage: $0 [options]`)
+  .version(version)
+  .option('input', {
+    alias: 'i',
+    type: 'string',
+    description: 'Path or URL to OpenAPI file',
+    demandOption: true,
+  })
+  .option('output', {
+    alias: 'o',
+    type: 'string',
+    description: 'Directory to output the generated files',
+    default: 'generated',
+  })
+  .help()
+  .parseSync();
+
+const {input, output} = argv;
+
+void (async () => {
+  try {
+    const generator = new Generator(name, version, reporter, input, output);
+    const exitCode = await generator.run();
+    process.exit(exitCode);
+  } catch (error) {
+    if (error instanceof Error) {
+      reporter.error(`Fatal error: ${error.message}`);
+    } else {
+      reporter.error('An unknown fatal error occurred');
+    }
+    process.exit(1);
+  }
+})();

package/src/generator.ts

@@ -0,0 +1,61 @@
+import type {Reporter} from './utils/reporter.js';
+import type {OpenApiSpecType} from './types/openapi.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';
+
+export class Generator {
+  private readonly fileReader = new SyncFileReaderService();
+  private readonly fileParser = new OpenApiFileParserService();
+  private readonly codeGenerator = new TypeScriptCodeGeneratorService();
+  private readonly fileWriter: SyncFileWriterService;
+  private readonly outputPath: string;
+
+  constructor(
+    private readonly _name: string,
+    private readonly _version: string,
+    private readonly reporter: Reporter,
+    private readonly inputPath: string,
+    private readonly _outputDir: string,
+  ) {
+    this.fileWriter = new SyncFileWriterService(this._name, this._version, inputPath);
+    this.outputPath = this.fileWriter.resolveOutputPath(this._outputDir);
+  }
+
+  async run(): Promise<number> {
+    try {
+      const rawSource = this.readFile();
+      const openApiSpec = this.parseFile(rawSource);
+      const generatedCode = this.generateCode(openApiSpec);
+
+      this.writeFile(generatedCode);
+      this.reporter.log(`✅ Generated types successfully at: ${this.outputPath}`);
+
+      return 0;
+    } catch (error) {
+      if (error instanceof Error) {
+        this.reporter.error(`❌ Error: ${error.message}`);
+      } else {
+        this.reporter.error('❌ An unknown error occurred');
+      }
+
+      return Promise.resolve(1);
+    }
+  }
+
+  private readFile(): string {
+    return this.fileReader.readFile(this.inputPath);
+  }
+
+  private parseFile(source: string): OpenApiSpecType {
+    return this.fileParser.parse(source);
+  }
+
+  private generateCode(spec: OpenApiSpecType): string {
+    return this.codeGenerator.generate(spec);
+  }
+
+  private writeFile(content: string): void {
+    this.fileWriter.writeFile(this.outputPath, content);
+  }
+}

package/src/http/fetch-client.ts

@@ -0,0 +1,181 @@
+import {HttpClient, HttpError, HttpRequestConfig, HttpResponse} from '../types/http.js';
+
+declare const globalThis: typeof global & {
+  fetch?: typeof fetch;
+  Headers?: typeof Headers;
+  Request?: typeof Request;
+  Response?: typeof Response;
+};
+
+type FetchFunction = (input: string | Request, init?: RequestInit) => Promise<Response>;
+
+type HeadersConstructor = new (init?: HeadersInit) => Headers;
+
+export class FetchHttpClient implements HttpClient {
+  private readonly fetch: FetchFunction;
+  private readonly Headers: HeadersConstructor;
+
+  constructor(
+    private readonly baseUrl = '',
+    private readonly defaultHeaders: Record<string, string> = {},
+  ) {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (typeof globalThis.fetch === 'function' && globalThis.Headers) {
+      this.fetch = globalThis.fetch.bind(globalThis);
+      this.Headers = globalThis.Headers;
+      return;
+    }
+
+    if (typeof window !== 'undefined' && typeof window.fetch === 'function') {
+      this.fetch = window.fetch.bind(window);
+      this.Headers = window.Headers;
+      return;
+    }
+
+    throw new Error(
+      "Fetch API is not available. Please ensure you're running in a compatible environment or polyfill fetch.",
+    );
+  }
+
+  async request<TResponse = unknown, TRequest = unknown>(
+    config: HttpRequestConfig<TRequest>,
+  ): Promise<HttpResponse<TResponse>> {
+    const url = this.buildUrl(config.url, config.params);
+    const headers = this.buildHeaders(config.headers);
+    const body = this.buildBody(config.data, headers);
+
+    const controller = new AbortController();
+    const timeoutId = config.timeout
+      ? setTimeout(() => {
+          controller.abort();
+        }, config.timeout)
+      : undefined;
+
+    try {
+      const response = await this.fetch(url, {
+        method: config.method,
+        headers,
+        body,
+        signal: controller.signal,
+      });
+
+      const responseHeaders = this.extractHeaders(response.headers);
+      const data = await this.parseResponse<TResponse>(response);
+
+      if (!response.ok) {
+        throw new HttpError(`HTTP ${String(response.status)}: ${response.statusText}`, response.status, {
+          data,
+          status: response.status,
+          statusText: response.statusText,
+          headers: responseHeaders,
+          url: response.url,
+        });
+      }
+
+      return {
+        data,
+        status: response.status,
+        statusText: response.statusText,
+        headers: responseHeaders,
+        url: response.url,
+      };
+    } catch (error) {
+      if (error instanceof HttpError) {
+        throw error;
+      }
+
+      if (error instanceof Error) {
+        if (error.name === 'AbortError') {
+          throw new HttpError('Request timeout', 408);
+        }
+        throw new HttpError(`Network error: ${error.message}`, 0);
+      }
+
+      throw new HttpError('Unknown network error', 0);
+    } finally {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+    }
+  }
+
+  private buildUrl(path: string, params?: Record<string, string | number | boolean>): string {
+    const url = new URL(path, this.baseUrl || 'http://localhost');
+
+    if (params) {
+      Object.entries(params).forEach(([key, value]) => {
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (value !== undefined && value !== null) {
+          url.searchParams.set(key, String(value));
+        }
+      });
+    }
+
+    return url.toString();
+  }
+
+  private buildHeaders(customHeaders?: Record<string, string>): Headers {
+    const headers = new this.Headers();
+
+    Object.entries(this.defaultHeaders).forEach(([key, value]) => {
+      headers.set(key, value);
+    });
+
+    if (customHeaders) {
+      Object.entries(customHeaders).forEach(([key, value]) => {
+        headers.set(key, value);
+      });
+    }
+
+    return headers;
+  }
+
+  private buildBody(data?: unknown, headers?: Headers): string | null {
+    if (!data) {
+      return null;
+    }
+
+    const contentType = headers?.get('content-type') ?? 'application/json';
+
+    if (contentType.includes('application/json')) {
+      if (!headers?.has('content-type')) {
+        headers?.set('content-type', 'application/json');
+      }
+      return JSON.stringify(data);
+    }
+
+    if (typeof data === 'string') {
+      return data;
+    }
+
+    return JSON.stringify(data);
+  }
+
+  private extractHeaders(headers: Headers): Record<string, string> {
+    const result: Record<string, string> = {};
+    headers.forEach((value, key) => {
+      result[key.toLowerCase()] = value;
+    });
+    return result;
+  }
+
+  private async parseResponse<TResponse>(response: Response): Promise<TResponse> {
+    const contentType = response.headers.get('content-type') ?? '';
+
+    if (contentType.includes('application/json')) {
+      return (await response.json()) as TResponse;
+    }
+
+    if (contentType.includes('text/')) {
+      return (await response.text()) as unknown as TResponse;
+    }
+
+    try {
+      const text = await response.text();
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+      return text ? JSON.parse(text) : ({} as TResponse);
+    } catch {
+      return {} as TResponse;
+    }
+  }
+}

package/src/interfaces/code-generator.ts

@@ -0,0 +1,25 @@
+import type {OpenApiSpecType} from '../types/openapi.js';
+
+export interface CodeGenerator {
+  generate(spec: OpenApiSpecType): string;
+}
+
+export interface SchemaBuilder {
+  buildSchema(schema: unknown, required?: boolean): unknown;
+}
+
+export interface TypeBuilder {
+  buildType(type: string): unknown;
+}
+
+export interface ImportBuilder {
+  buildImports(): unknown[];
+}
+
+export interface ClassBuilder {
+  buildClass(spec: OpenApiSpecType): unknown;
+}
+
+export interface FileWriter {
+  writeFile(filePath: string, content: string): Promise<void> | void;
+}

package/src/interfaces/file-reader.ts

@@ -0,0 +1,15 @@
+export interface FileReader {
+  readFile(path: string): Promise<string> | string;
+}
+
+export interface FileParser<TInput, TOutput> {
+  parse(input: TInput): TOutput;
+}
+
+export interface OpenApiFileReader extends FileReader {
+  readFile(path: string): Promise<string> | string;
+}
+
+export interface OpenApiFileParser<TOutput> extends FileParser<unknown, TOutput> {
+  parse(input: unknown): TOutput;
+}

package/src/polyfills/fetch.ts

@@ -0,0 +1,26 @@
+export interface FetchPolyfillOptions {
+  enableNodejsPolyfill?: boolean;
+}
+
+export async function setupFetchPolyfill(options: FetchPolyfillOptions = {}): Promise<void> {
+  if (typeof fetch === 'function') {
+    return;
+  }
+
+  if (typeof window !== 'undefined' && typeof window.fetch === 'function') {
+    return;
+  }
+
+  if (options.enableNodejsPolyfill && typeof process !== 'undefined' && process.versions.node) {
+    try {
+      await import('undici');
+      return;
+    } catch {
+      // Fall through to error
+    }
+  }
+
+  throw new Error(
+    'Fetch API is not available. ' + 'For Node.js environments, please install undici: npm install undici',
+  );
+}