genoc 0.2.0 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genoc",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Generate typed HTTP clients from OpenAPI 3.0 / 3.1 specifications",
   "keywords": [
     "client",
@@ -22,13 +22,7 @@
     "dist"
   ],
   "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
   "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
-    },
     "./runtime": {
       "import": "./dist/runtime/index.js",
       "types": "./dist/runtime/index.d.ts"
@@ -48,7 +42,10 @@
   },
   "dependencies": {
     "@stricli/core": "^1.2.6",
-    "yaml": "^2.8.4"
+    "lilconfig": "^3.1.3",
+    "undici": "^6.13.0",
+    "yaml": "^2.2.2",
+    "zod": "^4.0.0"
   },
   "devDependencies": {
     "@changesets/cli": "^2.31.0",

package/dist/generator/error-types.d.ts

@@ -1,13 +0,0 @@
-import type { AnalyzedOperation } from '../analyzer/path-analyzer.js';
-/**
- * Generate error types for a set of analyzed operations.
- *
- * Produces:
- * 1. `ApiError<TStatus, TData>` class
- * 2. `UnspecifiedApiError` class (extends ApiError, for status codes not in spec)
- * 3. Per-operation error union types (e.g. `GetApiV1ProductsErrors`)
- * 4. Per-operation per-status error type aliases (e.g. `GetApiV1ProductsError400`)
- * 5. `DefaultErrorBody` type for `default` responses
- * 6. Catch-all `UnspecifiedApiError` in error unions for unexpected status codes
- */
-export declare function generateErrorTypes(operations: AnalyzedOperation[]): string;

package/dist/generator/error-types.js

@@ -1,67 +0,0 @@
-/**
- * Generate error types for a set of analyzed operations.
- *
- * Produces:
- * 1. `ApiError<TStatus, TData>` class
- * 2. `UnspecifiedApiError` class (extends ApiError, for status codes not in spec)
- * 3. Per-operation error union types (e.g. `GetApiV1ProductsErrors`)
- * 4. Per-operation per-status error type aliases (e.g. `GetApiV1ProductsError400`)
- * 5. `DefaultErrorBody` type for `default` responses
- * 6. Catch-all `UnspecifiedApiError` in error unions for unexpected status codes
- */
-export function generateErrorTypes(operations) {
-    const lines = [];
-    lines.push(`export class ApiError<TStatus extends number, TData> extends Error {
-  constructor(
-    public readonly status: TStatus,
-    public readonly data: TData,
-    message: string,
-  ) {
-    super(message);
-    this.name = "ApiError";
-  }
-}`);
-    lines.push('');
-    lines.push(`export class UnspecifiedApiError extends ApiError<number, unknown> {
-  constructor(
-    status: number,
-    data: unknown,
-    message: string,
-  ) {
-    super(status, data, message);
-    this.name = "UnspecifiedApiError";
-  }
-}`);
-    lines.push('');
-    let needsDefaultErrorBody = false;
-    for (const op of operations) {
-        const errorResponses = op.responses.filter((r) => !r.isSuccess && r.statusCode !== 'default');
-        const defaultResponse = op.responses.find((r) => !r.isSuccess && r.statusCode === 'default');
-        if (errorResponses.length === 0 && !defaultResponse) {
-            continue;
-        }
-        const methodName = op.methodName;
-        const errorTypeName = (status) => `${methodName}Error${status}`;
-        lines.push('');
-        for (const err of errorResponses) {
-            const tsType = err.tsType || 'unknown';
-            lines.push(`export type ${errorTypeName(err.statusCode)} = ${tsType};`);
-        }
-        const unionParts = [];
-        for (const err of errorResponses) {
-            const status = Number(err.statusCode);
-            unionParts.push(`ApiError<${status}, ${errorTypeName(err.statusCode)}>`);
-        }
-        if (defaultResponse) {
-            needsDefaultErrorBody = true;
-            unionParts.push(`ApiError<number, DefaultErrorBody>`);
-        }
-        unionParts.push(`UnspecifiedApiError`);
-        lines.push(`export type ${methodName}Errors = ${unionParts.join('\n  | ')};`);
-    }
-    if (needsDefaultErrorBody) {
-        lines.push('');
-        lines.push('export type DefaultErrorBody = unknown;');
-    }
-    return lines.join('\n');
-}

package/dist/index.d.ts

@@ -1,8 +0,0 @@
-import { type ApiClient } from './generator/client-generator.js';
-import type { GeneratorConfig } from './types/client.js';
-export declare function generateClient(config: GeneratorConfig): Promise<void>;
-export { ApiError, UnspecifiedApiError, DefaultApiError, RequesterFailError, StreamResponse, ErrorResponse, decorateWithErrors, isDefinedError, } from './runtime/index.js';
-export type { Requester } from './runtime/index.js';
-export type { GeneratorConfig, ApiClient };
-export type { GenerationOptions } from './generator/client-generator.js';
-export { load as loadSpec } from './parser/spec-reader.js';

package/dist/index.js

@@ -1,8 +0,0 @@
-import { generateFullOutput } from './generator/client-generator.js';
-import { load } from './parser/spec-reader.js';
-export async function generateClient(config) {
-    const doc = await load(config.input);
-    await generateFullOutput(doc, config);
-}
-export { ApiError, UnspecifiedApiError, DefaultApiError, RequesterFailError, StreamResponse, ErrorResponse, decorateWithErrors, isDefinedError, } from './runtime/index.js';
-export { load as loadSpec } from './parser/spec-reader.js';

package/dist/parser/validators.d.ts

@@ -1,7 +0,0 @@
-import type { VersionStrategy } from './version/version-strategy.js';
-export interface ValidationResult {
-    valid: boolean;
-    errors: string[];
-}
-export declare function validateOpenAPIVersion(version: string): boolean;
-export declare function validateSpec(doc: unknown, strategy?: VersionStrategy): ValidationResult;

package/dist/parser/validators.js

@@ -1,79 +0,0 @@
-export function validateOpenAPIVersion(version) {
-    return typeof version === 'string' && version.startsWith('3.1');
-}
-export function validateSpec(doc, strategy) {
-    if (strategy) {
-        try {
-            const normalized = strategy.normalizeSpec(doc);
-            return strategy.validateSpec(normalized);
-        }
-        catch (error) {
-            // normalizeSpec may throw for structurally invalid specs;
-            // but re-throw "not yet supported" errors
-            if (typeof error === 'object' && error !== null && 'message' in error) {
-                const errorMessage = error.message;
-                if (errorMessage.includes('not yet supported')) {
-                    throw error;
-                }
-            }
-            // fall through to default 3.1-only validation below
-        }
-    }
-    const errors = [];
-    if (!doc || typeof doc !== 'object' || Array.isArray(doc)) {
-        errors.push('Document must be an object');
-        return { valid: false, errors };
-    }
-    const spec = doc;
-    // Check openapi field
-    if (!spec.openapi || typeof spec.openapi !== 'string') {
-        errors.push("OpenAPI specification must have an 'openapi' field with string value");
-    }
-    else if (!validateOpenAPIVersion(spec.openapi)) {
-        errors.push(`OpenAPI version must start with '3.1', got: ${spec.openapi}`);
-    }
-    // Check info field
-    if (!spec.info || typeof spec.info !== 'object' || Array.isArray(spec.info)) {
-        errors.push("OpenAPI specification must have an 'info' field with object value");
-    }
-    else {
-        const info = spec.info;
-        if (!info.title || typeof info.title !== 'string') {
-            errors.push("Info object must have a 'title' field with string value");
-        }
-        if (!info.version || typeof info.version !== 'string') {
-            errors.push("Info object must have a 'version' field with string value");
-        }
-    }
-    // Check at least one of paths, components, webhooks exists
-    if (!spec.paths && !spec.components && !spec.webhooks) {
-        errors.push("OpenAPI specification must have at least one of 'paths', 'components', or 'webhooks'");
-    }
-    // Validate paths if it exists
-    if (spec.paths) {
-        if (Array.isArray(spec.paths) || typeof spec.paths !== 'object') {
-            errors.push("'paths' field must be an object");
-        }
-    }
-    // Validate components.schemas if it exists
-    if (spec.components && typeof spec.components === 'object' && !Array.isArray(spec.components)) {
-        const components = spec.components;
-        if (components.schemas) {
-            if (Array.isArray(components.schemas) || typeof components.schemas !== 'object') {
-                errors.push("'components.schemas' must be an object");
-            }
-            else {
-                const schemas = components.schemas;
-                for (const [key, schema] of Object.entries(schemas)) {
-                    if (typeof schema !== 'object' || Array.isArray(schema)) {
-                        errors.push(`Schema '${key}' must be an object`);
-                    }
-                }
-            }
-        }
-    }
-    return {
-        valid: errors.length === 0,
-        errors,
-    };
-}

package/dist/parser/version/normalized-spec.d.ts

@@ -1,199 +0,0 @@
-/**
- * Normalized schema with consistent types across OpenAPI versions
- */
-export interface NormalizedSchema {
-    /** Normalized types - always an array, even for single types */
-    types: string[];
-    /** Format information */
-    format?: string;
-    /** Properties object */
-    properties?: Record<string, NormalizedSchema>;
-    /** Required properties array */
-    required?: string[];
-    /** Array items schema */
-    items?: NormalizedSchema;
-    /** Additional properties flag or schema */
-    additionalProperties?: boolean | NormalizedSchema;
-    /** Reference pointer */
-    $ref?: string;
-    /** AllOf composition */
-    allOf?: NormalizedSchema[];
-    /** OneOf composition */
-    oneOf?: NormalizedSchema[];
-    /** AnyOf composition */
-    anyOf?: NormalizedSchema[];
-    /** Enum values */
-    enum?: unknown[];
-    /** Const value */
-    const?: unknown;
-    /** Default value */
-    default?: unknown;
-    /** Description */
-    description?: string;
-    /** Whether nullable */
-    nullable: boolean;
-    /** Examples - always normalized to array */
-    examples: unknown[];
-    /** File upload information */
-    fileUpload?: {
-        binary: boolean;
-        base64: boolean;
-    };
-    /** Exclusive minimum (always number) */
-    exclusiveMinimum?: number;
-    /** Exclusive maximum (always number) */
-    exclusiveMaximum?: number;
-    /** Minimum value */
-    minimum?: number;
-    /** Maximum value */
-    maximum?: number;
-    /** Read only */
-    readOnly?: boolean;
-    /** Write only */
-    writeOnly?: boolean;
-    /** Deprecated */
-    deprecated?: boolean;
-    /** Discriminator information */
-    discriminator?: {
-        propertyName: string;
-        mapping?: Record<string, string>;
-    };
-}
-/**
- * Normalized OpenAPI specification with consistent structure
- */
-export interface NormalizedSpec {
-    /** Original OpenAPI version string */
-    openapi: string;
-    /** Info object */
-    info: {
-        title: string;
-        version: string;
-        description?: string;
-        termsOfService?: string;
-        contact?: {
-            name?: string;
-            url?: string;
-            email?: string;
-        };
-        license?: {
-            name: string;
-            url?: string;
-            identifier?: string;
-        };
-    };
-    /** Servers array */
-    servers?: Array<{
-        url: string;
-        description?: string;
-        variables?: Record<string, {
-            default: string;
-            description?: string;
-            enum?: string[];
-        }>;
-    }>;
-    /** Paths object - simplified version */
-    paths?: Record<string, {
-        $ref?: string;
-        summary?: string;
-        description?: string;
-        get?: NormalizedOperation;
-        put?: NormalizedOperation;
-        post?: NormalizedOperation;
-        delete?: NormalizedOperation;
-        options?: NormalizedOperation;
-        head?: NormalizedOperation;
-        patch?: NormalizedOperation;
-        trace?: NormalizedOperation;
-        parameters?: Array<NormalizedParameter>;
-        servers?: unknown[];
-    }>;
-    /** Components object */
-    components?: {
-        schemas?: Record<string, NormalizedSchema>;
-        responses?: Record<string, unknown>;
-        parameters?: Record<string, unknown>;
-        requestBodies?: Record<string, unknown>;
-        headers?: Record<string, unknown>;
-        securitySchemes?: Record<string, unknown>;
-        links?: Record<string, unknown>;
-        callbacks?: Record<string, unknown>;
-        examples?: Record<string, unknown>;
-    };
-    /** Security requirements */
-    security?: unknown[];
-    /** Tags */
-    tags?: unknown[];
-    /** External documentation */
-    externalDocs?: {
-        description?: string;
-        url: string;
-    };
-    /** Webhooks */
-    webhooks?: Record<string, {
-        $ref?: string;
-        summary?: string;
-        description?: string;
-        get?: NormalizedOperation;
-        put?: NormalizedOperation;
-        post?: NormalizedOperation;
-        delete?: NormalizedOperation;
-        options?: NormalizedOperation;
-        head?: NormalizedOperation;
-        patch?: NormalizedOperation;
-        trace?: NormalizedOperation;
-        parameters?: Array<NormalizedParameter>;
-        servers?: unknown[];
-    }>;
-}
-/**
- * Normalized operation object
- */
-interface NormalizedOperation {
-    tags?: string[];
-    summary?: string;
-    description?: string;
-    operationId?: string;
-    parameters?: Array<NormalizedParameter>;
-    requestBody?: {
-        description?: string;
-        content: Record<string, {
-            schema?: NormalizedSchema;
-            examples?: Record<string, unknown>;
-            example?: unknown;
-            encoding?: Record<string, unknown>;
-        }>;
-        required?: boolean;
-    };
-    responses: Record<string, {
-        description: string;
-        headers?: Record<string, unknown>;
-        content?: Record<string, {
-            schema?: NormalizedSchema;
-            examples?: Record<string, unknown>;
-            example?: unknown;
-            encoding?: Record<string, unknown>;
-        }>;
-        links?: Record<string, unknown>;
-    }>;
-    deprecated?: boolean;
-    security?: unknown[];
-    servers?: unknown[];
-}
-/**
- * Normalized parameter object
- */
-interface NormalizedParameter {
-    name: string;
-    in: 'query' | 'path' | 'header' | 'cookie';
-    description?: string;
-    required?: boolean;
-    deprecated?: boolean;
-    schema?: NormalizedSchema;
-    style?: string;
-    explode?: boolean;
-    allowEmptyValue?: boolean;
-    example?: unknown;
-    examples?: Record<string, unknown>;
-}
-export {};

package/dist/parser/version/registry.d.ts

@@ -1,28 +0,0 @@
-import type { VersionStrategy } from './version-strategy.js';
-/**
- * Registry for managing version strategies
- */
-export declare class VersionStrategyRegistry {
-    private strategies;
-    /**
-     * Register a version strategy for a specific OpenAPI version
-     */
-    register(strategy: VersionStrategy): void;
-    /**
-     * Get a version strategy by version string
-     * @throws Error if strategy is not registered
-     */
-    get(version: string): VersionStrategy;
-    /**
-     * Detect the version from a raw OpenAPI specification and return the corresponding strategy
-     */
-    detectAndResolve(rawSpec: unknown): VersionStrategy;
-    /**
-     * Get list of supported version strings
-     */
-    listSupported(): string[];
-    /**
-     * Check if a version is supported
-     */
-    isSupported(version: string): boolean;
-}

package/dist/parser/version/registry.js

@@ -1,44 +0,0 @@
-import { detectSpecVersion } from './version-detector.js';
-/**
- * Registry for managing version strategies
- */
-export class VersionStrategyRegistry {
-    strategies = new Map();
-    /**
-     * Register a version strategy for a specific OpenAPI version
-     */
-    register(strategy) {
-        const version = strategy.version();
-        this.strategies.set(version, strategy);
-    }
-    /**
-     * Get a version strategy by version string
-     * @throws Error if strategy is not registered
-     */
-    get(version) {
-        const strategy = this.strategies.get(version);
-        if (!strategy) {
-            throw new Error(`No strategy registered for version: ${version}`);
-        }
-        return strategy;
-    }
-    /**
-     * Detect the version from a raw OpenAPI specification and return the corresponding strategy
-     */
-    detectAndResolve(rawSpec) {
-        const version = detectSpecVersion(rawSpec);
-        return this.get(version);
-    }
-    /**
-     * Get list of supported version strings
-     */
-    listSupported() {
-        return Array.from(this.strategies.keys());
-    }
-    /**
-     * Check if a version is supported
-     */
-    isSupported(version) {
-        return this.strategies.has(version);
-    }
-}

package/dist/parser/version/v3.0/index.d.ts

@@ -1,3 +0,0 @@
-export { V3_0_VersionStrategy } from './strategy.js';
-export { normalizeSpec30 } from './normalizer.js';
-export { validateSpec30 } from './validator.js';

package/dist/parser/version/v3.0/index.js

@@ -1,3 +0,0 @@
-export { V3_0_VersionStrategy } from './strategy.js';
-export { normalizeSpec30 } from './normalizer.js';
-export { validateSpec30 } from './validator.js';

package/dist/parser/version/v3.0/normalizer.d.ts

@@ -1,15 +0,0 @@
-import type { NormalizedSpec } from '../normalized-spec.js';
-/**
- * Normalize a raw OpenAPI 3.0.x specification to a consistent format.
- *
- * 3.0-specific transformations applied during normalization:
- * - `nullable: true` → `nullable: true` on the NormalizedSchema
- * - `exclusiveMinimum: true` + `minimum: 5` → `exclusiveMinimum: 5`
- * - `exclusiveMinimum: false` → removed (not included in output)
- * - `example: value` → `examples: [value]`
- * - `format: "binary"` → `fileUpload: { binary: true, base64: false }`
- * - `format: "byte"` → `fileUpload: { binary: false, base64: true }`
- * - `$ref` siblings are stripped (3.0 compliant behavior)
- * - Error if `items` is an array (3.1-only tuple syntax)
- */
-export declare function normalizeSpec30(rawSpec: unknown): NormalizedSpec;