@techspokes/typescript-wsdl-client 0.7.15 → 0.8.15

package/dist/gateway/generators.js

@@ -0,0 +1,270 @@
+/**
+ * Gateway Code Generators
+ *
+ * This module contains functions for generating various gateway code artifacts:
+ * - Model JSON Schema files with URN IDs
+ * - Operation schema files with Fastify-compatible structure
+ * - schemas.ts module for registering all model schemas
+ * - Individual route files with handler stubs
+ * - routes.ts module for registering all routes
+ *
+ * All emitters follow deterministic generation rules for diff-friendly output.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { rewriteSchemaRefs, slugName, } from "./helpers.js";
+/**
+ * Emits individual JSON Schema files for each OpenAPI component schema
+ *
+ * Process:
+ * 1. Creates schemas/models/ directory
+ * 2. For each component schema:
+ *    - Generates URN $id: urn:services:{service}:{version}:schemas:models:{slug}
+ *    - Rewrites all internal $refs to URN format
+ *    - Writes to {slug}.json
+ *
+ * @param {Record<string, any>} schemas - OpenAPI components.schemas object
+ * @param {string} modelsDir - Output directory for model schema files
+ * @param {string} versionSlug - Version slug for URN generation
+ * @param {string} serviceSlug - Service slug for URN generation
+ * @returns {Record<string, string>} - Map from original schema name to URN ID
+ */
+export function emitModelSchemas(schemas, modelsDir, versionSlug, serviceSlug) {
+    fs.mkdirSync(modelsDir, { recursive: true });
+    const schemaIdByName = {};
+    const modelSlugByName = {};
+    // First pass: generate all URN IDs
+    for (const name of Object.keys(schemas)) {
+        const slug = slugName(name);
+        if (modelSlugByName[name]) {
+            throw new Error(`Duplicate schema name '${name}'`);
+        }
+        modelSlugByName[name] = slug;
+        schemaIdByName[name] = `urn:services:${serviceSlug}:${versionSlug}:schemas:models:${slug}`;
+    }
+    // Second pass: rewrite refs and emit files
+    for (const [name, schema] of Object.entries(schemas)) {
+        const slug = modelSlugByName[name];
+        const cloned = rewriteSchemaRefs(schema, schemaIdByName);
+        cloned.$id = schemaIdByName[name];
+        const outPath = path.join(modelsDir, `${slug}.json`);
+        fs.writeFileSync(outPath, JSON.stringify(cloned, null, 2), "utf8");
+    }
+    return schemaIdByName;
+}
+/**
+ * Emits Fastify-compatible operation schema files
+ *
+ * Schema structure:
+ * {
+ *   "$id": "urn:services:{service}:{version}:schemas:operations:{slug}",
+ *   "body": { $ref: "..." },           // optional
+ *   "params": { type: object, ... },   // optional
+ *   "querystring": { type: object, ... }, // optional
+ *   "headers": { type: object, ... },  // optional
+ *   "response": {
+ *     "200": { $ref: "..." },
+ *     "400": { $ref: "..." },
+ *     ...
+ *   }
+ * }
+ *
+ * @param {OpenAPIDocument} doc - OpenAPI document
+ * @param {string} opsDir - Output directory for operation schema files
+ * @param {string} versionSlug - Version slug for URN generation
+ * @param {string} serviceSlug - Service slug for URN generation
+ * @param {Record<string, string>} schemaIdByName - Schema name to URN ID mapping
+ * @param {number[]} defaultResponseStatusCodes - Status codes to backfill with default response
+ * @param {Function} buildParamSchemas - Function to build param schemas
+ * @param {Function} getRefName - Function to extract $ref name
+ * @param {Function} isNumeric - Function to check if status code is numeric
+ * @returns {OperationMetadata[]} - Array of operation metadata for route generation
+ */
+export function emitOperationSchemas(doc, opsDir, versionSlug, serviceSlug, schemaIdByName, defaultResponseStatusCodes, buildParamSchemas, getRefName, isNumeric) {
+    fs.mkdirSync(opsDir, { recursive: true });
+    const operations = [];
+    const seenOperationSlugs = new Set();
+    for (const [p, pathItem] of Object.entries(doc.paths)) {
+        if (!pathItem || typeof pathItem !== "object")
+            continue;
+        const pathLevel = pathItem;
+        for (const [method, opVal] of Object.entries(pathItem)) {
+            const lowerMethod = method.toLowerCase();
+            if (!["get", "post", "put", "patch", "delete", "options", "head"].includes(lowerMethod)) {
+                continue;
+            }
+            const operation = opVal;
+            if (!operation || typeof operation !== "object")
+                continue;
+            let operationId = operation.operationId;
+            if (!operationId) {
+                operationId = `${lowerMethod}_${p}`;
+            }
+            const operationSlug = slugName(operationId);
+            if (seenOperationSlugs.has(operationSlug)) {
+                throw new Error(`Duplicate operation slug '${operationSlug}' derived from operationId '${operationId}'`);
+            }
+            seenOperationSlugs.add(operationSlug);
+            // Build request body schema
+            let bodySchema;
+            const rbSchema = operation.requestBody?.content?.["application/json"]?.schema;
+            if (rbSchema) {
+                const name = getRefName(rbSchema);
+                const id = schemaIdByName[name];
+                if (!id) {
+                    throw new Error(`Unknown request body schema component '${name}'`);
+                }
+                bodySchema = { $ref: id + "#" };
+            }
+            // Build parameter schemas
+            const { paramsSchema, querySchema, headersSchema } = buildParamSchemas(pathLevel, operation, doc, schemaIdByName);
+            // Build response schemas
+            const responses = operation.responses || {};
+            const responseObj = {};
+            const explicitCodes = Object.keys(responses).filter(isNumeric);
+            for (const code of explicitCodes) {
+                const r = responses[code];
+                if (!r || typeof r !== "object")
+                    continue;
+                const rSchema = r.content?.["application/json"]?.schema;
+                if (!rSchema) {
+                    throw new Error(`Response ${code} for operation '${operationId}' is missing application/json schema`);
+                }
+                const name = getRefName(rSchema);
+                const id = schemaIdByName[name];
+                if (!id) {
+                    throw new Error(`Unknown response schema component '${name}' for code ${code}`);
+                }
+                responseObj[code] = { $ref: id + "#" };
+            }
+            // Validate and get default response
+            const defaultResp = responses.default;
+            if (!defaultResp || typeof defaultResp !== "object") {
+                throw new Error(`Operation '${operationId}' is missing default response; required by gateway codegen`);
+            }
+            const defaultSchema = defaultResp.content?.["application/json"]?.schema;
+            if (!defaultSchema) {
+                throw new Error(`Operation '${operationId}' default response is missing application/json schema`);
+            }
+            const defaultName = getRefName(defaultSchema);
+            const defaultId = schemaIdByName[defaultName];
+            if (!defaultId) {
+                throw new Error(`Unknown default response schema component '${defaultName}' for operation '${operationId}'`);
+            }
+            // Backfill default response codes
+            for (const code of defaultResponseStatusCodes) {
+                const codeStr = String(code);
+                if (!responseObj[codeStr]) {
+                    responseObj[codeStr] = { $ref: defaultId + "#" };
+                }
+            }
+            // Build operation schema object
+            const opSchema = {
+                $id: `urn:services:${serviceSlug}:${versionSlug}:schemas:operations:${operationSlug}`,
+                response: responseObj,
+            };
+            if (bodySchema)
+                opSchema.body = bodySchema;
+            if (paramsSchema)
+                opSchema.params = paramsSchema;
+            if (querySchema)
+                opSchema.querystring = querySchema;
+            if (headersSchema)
+                opSchema.headers = headersSchema;
+            const opOutPath = path.join(opsDir, `${operationSlug}.json`);
+            fs.writeFileSync(opOutPath, JSON.stringify(opSchema, null, 2), "utf8");
+            operations.push({
+                operationSlug,
+                method: lowerMethod,
+                path: p,
+            });
+        }
+    }
+    return operations;
+}
+/**
+ * Emits schemas.ts module that registers all model schemas with Fastify
+ *
+ * Generated code:
+ * - Imports all JSON files from schemas/models/
+ * - Exports registerSchemas_{version}_{service}(fastify) function
+ * - Calls fastify.addSchema for each model schema
+ *
+ * @param {string} outDir - Root output directory
+ * @param {string} modelsDir - Directory containing model schema files
+ * @param {string} versionSlug - Version slug for function naming
+ * @param {string} serviceSlug - Service slug for function naming
+ */
+export function emitSchemasModule(outDir, modelsDir, versionSlug, serviceSlug) {
+    const modelFiles = fs.readdirSync(modelsDir).filter((f) => f.endsWith(".json"));
+    modelFiles.sort();
+    let schemasTs = "";
+    schemasTs += `import type { FastifyInstance } from "fastify";\n`;
+    modelFiles.forEach((file, idx) => {
+        const varName = `m${idx}`;
+        schemasTs += `import ${varName} from "./schemas/models/${file}" with { type: "json" };\n`;
+    });
+    schemasTs += `\nexport async function registerSchemas_${slugName(versionSlug)}_${slugName(serviceSlug)}(fastify: FastifyInstance) {\n`;
+    schemasTs += `  const schemas = [${modelFiles
+        .map((_, idx) => `m${idx}`)
+        .join(", ")}];\n`;
+    schemasTs += `  for (const s of schemas) {\n`;
+    schemasTs += `    fastify.addSchema(s as any);\n`;
+    schemasTs += `  }\n`;
+    schemasTs += `}\n`;
+    fs.writeFileSync(path.join(outDir, "schemas.ts"), schemasTs, "utf8");
+}
+/**
+ * Emits individual route files and routes.ts aggregator module
+ *
+ * For each operation:
+ * - Creates routes/{slug}.ts with registerRoute_{slug} function
+ * - Imports operation schema from schemas/operations/{slug}.json
+ * - Defines fastify.route() with method, url, schema, and stub handler
+ *
+ * Then creates routes.ts:
+ * - Imports all route registration functions
+ * - Exports registerRoutes_{version}_{service}(fastify) function
+ *
+ * @param {string} outDir - Root output directory
+ * @param {string} routesDir - Directory for individual route files
+ * @param {string} versionSlug - Version slug for function naming
+ * @param {string} serviceSlug - Service slug for function naming
+ * @param {OperationMetadata[]} operations - Array of operation metadata
+ * @param {"js"|"ts"|"bare"} importsMode - Import-extension mode for generated TypeScript modules
+ */
+export function emitRouteFiles(outDir, routesDir, versionSlug, serviceSlug, operations, importsMode) {
+    fs.mkdirSync(routesDir, { recursive: true });
+    // Sort operations for deterministic output
+    operations.sort((a, b) => a.operationSlug.localeCompare(b.operationSlug));
+    const suffix = importsMode === "bare" ? "" : `.${importsMode}`;
+    let routesTs = `import type { FastifyInstance } from "fastify";\n`;
+    operations.forEach((op) => {
+        const fnName = `registerRoute_${slugName(versionSlug)}_${slugName(serviceSlug)}_${op.operationSlug.replace(/[^a-zA-Z0-9_]/g, "_")}`;
+        const routeFileBase = op.operationSlug;
+        routesTs += `import { ${fnName} } from "./routes/${routeFileBase}${suffix}";\n`;
+        // Generate individual route file
+        let routeTs = "";
+        routeTs += `import type { FastifyInstance } from "fastify";\n`;
+        routeTs += `import schema from "../schemas/operations/${op.operationSlug}.json" with { type: "json" };\n\n`;
+        routeTs += `export async function ${fnName}(fastify: FastifyInstance) {\n`;
+        routeTs += `  fastify.route({\n`;
+        routeTs += `    method: "${op.method.toUpperCase()}",\n`;
+        routeTs += `    url: "${op.path}",\n`;
+        routeTs += `    schema: schema as any,\n`;
+        routeTs += `    handler: async (request, reply) => {\n`;
+        routeTs += `      throw new Error("Not implemented");\n`;
+        routeTs += `    }\n`;
+        routeTs += `  });\n`;
+        routeTs += `}\n`;
+        fs.writeFileSync(path.join(routesDir, `${routeFileBase}.ts`), routeTs, "utf8");
+    });
+    const routeFnName = `registerRoutes_${slugName(versionSlug)}_${slugName(serviceSlug)}`;
+    routesTs += `\nexport async function ${routeFnName}(fastify: FastifyInstance) {\n`;
+    operations.forEach((op) => {
+        const fnName = `registerRoute_${slugName(versionSlug)}_${slugName(serviceSlug)}_${op.operationSlug.replace(/[^a-zA-Z0-9_]/g, "_")}`;
+        routesTs += `  await ${fnName}(fastify);\n`;
+    });
+    routesTs += `}\n`;
+    fs.writeFileSync(path.join(outDir, "routes.ts"), routesTs, "utf8");
+}

package/dist/gateway/helpers.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Gateway Generation Helpers
+ *
+ * This module provides utility functions for generating Fastify gateway code from OpenAPI 3.1 specifications.
+ * It handles slug generation, schema reference rewriting, parameter resolution, and version/service detection.
+ *
+ * Key capabilities:
+ * - Deterministic slug generation from OpenAPI component names
+ * - Schema $ref rewriting from OpenAPI references to URN-style IDs
+ * - Parameter resolution with path-level and operation-level override support
+ * - Automatic version/service detection from OpenAPI paths
+ */
+/**
+ * OpenAPI document structure (minimal type for internal use)
+ */
+export interface OpenAPIDocument {
+    openapi: string;
+    info?: any;
+    paths: Record<string, any>;
+    components?: {
+        schemas?: Record<string, any>;
+        parameters?: Record<string, any>;
+    };
+}
+/**
+ * Converts a name to a deterministic slug for use in file names and URN IDs
+ *
+ * Rules:
+ * - Lowercase all characters
+ * - Replace non-alphanumeric sequences with single underscores
+ * - Strip leading/trailing underscores
+ * - Collapse multiple underscores to single underscore
+ *
+ * @param {string} name - Original name to convert
+ * @returns {string} - Slugified name
+ *
+ * @example
+ * slugName("GetUserDetails") // "getuserdetails"
+ * slugName("User-Profile_Data") // "user_profile_data"
+ */
+export declare function slugName(name: string): string;
+/**
+ * Checks if a status code string is numeric
+ *
+ * @param {string} code - Status code to check
+ * @returns {boolean} - True if the code is numeric
+ */
+export declare function isNumericStatus(code: string): boolean;
+/**
+ * Recursively rewrites all $ref properties in a schema object from OpenAPI component references
+ * to URN-style schema IDs
+ *
+ * Contract enforcement:
+ * - All $ref values must start with "#/components/schemas/"
+ * - The referenced schema name must exist in schemaIdByName map
+ * - Throws if unknown schema is referenced
+ *
+ * @param {any} node - Schema object or primitive value to process
+ * @param {Record<string, string>} schemaIdByName - Map from OpenAPI component name to URN ID
+ * @returns {any} - Deep clone with rewritten $ref properties
+ * @throws {Error} If unknown schema reference is encountered
+ */
+export declare function rewriteSchemaRefs(node: any, schemaIdByName: Record<string, string>): any;
+/**
+ * Extracts the component schema name from a $ref object
+ *
+ * Contract enforcement (strict validation):
+ * - Schema must be an object with a $ref property
+ * - $ref must start with "#/components/schemas/"
+ * - Throws if inline schema or invalid $ref format
+ *
+ * @param {any} schema - Schema object expected to contain a $ref
+ * @returns {string} - Extracted schema component name
+ * @throws {Error} If schema is not a proper $ref or uses unsupported format
+ */
+export declare function getJsonSchemaRefName(schema: any): string;
+/**
+ * Resolves a parameter object or $ref to a component parameter
+ *
+ * Supports:
+ * - Inline parameter objects (returned as-is)
+ * - $ref to "#/components/parameters/Name" (resolved from document)
+ *
+ * @param {any} paramOrRef - Parameter object or reference
+ * @param {OpenAPIDocument} doc - OpenAPI document containing components
+ * @returns {any} - Resolved parameter object
+ * @throws {Error} If $ref format is invalid or referenced parameter not found
+ */
+export declare function resolveParameter(paramOrRef: any, doc: OpenAPIDocument): any;
+/**
+ * Result of building Fastify-compatible param schemas from OpenAPI parameters
+ */
+export interface ParamSchemaBuildResult {
+    paramsSchema?: any;
+    querySchema?: any;
+    headersSchema?: any;
+}
+/**
+ * Builds Fastify-compatible params/querystring/headers schemas from OpenAPI parameters
+ *
+ * Logic:
+ * 1. Merges path-level and operation-level parameters (operation overrides path)
+ * 2. Partitions by "in" field: path -> params, query -> querystring, header -> headers
+ * 3. Builds inline object schemas with properties/required arrays
+ * 4. Lowercases header names (Fastify convention)
+ * 5. Rewrites any schema $refs to URN format
+ *
+ * @param {any} pathItem - Path-level object (may have parameters array)
+ * @param {any} operation - Operation object (may have parameters array)
+ * @param {OpenAPIDocument} doc - OpenAPI document for resolving parameter refs
+ * @param {Record<string, string>} schemaIdByName - Schema name to URN ID mapping
+ * @returns {ParamSchemaBuildResult} - Object with optional params/querystring/headers schemas
+ */
+export declare function buildParamSchemasForOperation(pathItem: any, operation: any, doc: OpenAPIDocument, schemaIdByName: Record<string, string>): ParamSchemaBuildResult;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/gateway/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/gateway/helpers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,GAAG,CAAC;IACX,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC3B,UAAU,CAAC,EAAE;QACX,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAC9B,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;KAClC,CAAC;CACH;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAI7C;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAErD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,GAAG,EAAE,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,GAAG,CAqBxF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,GAAG,GAAG,MAAM,CAcxD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,GAAG,EAAE,GAAG,EAAE,eAAe,GAAG,GAAG,CAiB3E;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,YAAY,CAAC,EAAE,GAAG,CAAC;IACnB,WAAW,CAAC,EAAE,GAAG,CAAC;IAClB,aAAa,CAAC,EAAE,GAAG,CAAC;CACrB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,GAAG,EACb,SAAS,EAAE,GAAG,EACd,GAAG,EAAE,eAAe,EACpB,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GACrC,sBAAsB,CAmFxB"}

package/dist/gateway/helpers.js

@@ -0,0 +1,224 @@
+/**
+ * Gateway Generation Helpers
+ *
+ * This module provides utility functions for generating Fastify gateway code from OpenAPI 3.1 specifications.
+ * It handles slug generation, schema reference rewriting, parameter resolution, and version/service detection.
+ *
+ * Key capabilities:
+ * - Deterministic slug generation from OpenAPI component names
+ * - Schema $ref rewriting from OpenAPI references to URN-style IDs
+ * - Parameter resolution with path-level and operation-level override support
+ * - Automatic version/service detection from OpenAPI paths
+ */
+/**
+ * Converts a name to a deterministic slug for use in file names and URN IDs
+ *
+ * Rules:
+ * - Lowercase all characters
+ * - Replace non-alphanumeric sequences with single underscores
+ * - Strip leading/trailing underscores
+ * - Collapse multiple underscores to single underscore
+ *
+ * @param {string} name - Original name to convert
+ * @returns {string} - Slugified name
+ *
+ * @example
+ * slugName("GetUserDetails") // "getuserdetails"
+ * slugName("User-Profile_Data") // "user_profile_data"
+ */
+export function slugName(name) {
+    const lower = String(name ?? "").toLowerCase();
+    const collapsed = lower.replace(/[^a-z0-9]+/g, "_");
+    return collapsed.replace(/^_+|_+$/g, "");
+}
+/**
+ * Checks if a status code string is numeric
+ *
+ * @param {string} code - Status code to check
+ * @returns {boolean} - True if the code is numeric
+ */
+export function isNumericStatus(code) {
+    return /^\d+$/.test(code);
+}
+/**
+ * Recursively rewrites all $ref properties in a schema object from OpenAPI component references
+ * to URN-style schema IDs
+ *
+ * Contract enforcement:
+ * - All $ref values must start with "#/components/schemas/"
+ * - The referenced schema name must exist in schemaIdByName map
+ * - Throws if unknown schema is referenced
+ *
+ * @param {any} node - Schema object or primitive value to process
+ * @param {Record<string, string>} schemaIdByName - Map from OpenAPI component name to URN ID
+ * @returns {any} - Deep clone with rewritten $ref properties
+ * @throws {Error} If unknown schema reference is encountered
+ */
+export function rewriteSchemaRefs(node, schemaIdByName) {
+    if (Array.isArray(node)) {
+        return node.map((v) => rewriteSchemaRefs(v, schemaIdByName));
+    }
+    if (node && typeof node === "object") {
+        const out = {};
+        for (const [k, v] of Object.entries(node)) {
+            if (k === "$ref" && typeof v === "string" && v.startsWith("#/components/schemas/")) {
+                const name = v.slice("#/components/schemas/".length);
+                const id = schemaIdByName[name];
+                if (!id) {
+                    throw new Error(`Unknown schema reference '${name}' in $ref '${v}'`);
+                }
+                out["$ref"] = id + "#";
+            }
+            else {
+                out[k] = rewriteSchemaRefs(v, schemaIdByName);
+            }
+        }
+        return out;
+    }
+    return node;
+}
+/**
+ * Extracts the component schema name from a $ref object
+ *
+ * Contract enforcement (strict validation):
+ * - Schema must be an object with a $ref property
+ * - $ref must start with "#/components/schemas/"
+ * - Throws if inline schema or invalid $ref format
+ *
+ * @param {any} schema - Schema object expected to contain a $ref
+ * @returns {string} - Extracted schema component name
+ * @throws {Error} If schema is not a proper $ref or uses unsupported format
+ */
+export function getJsonSchemaRefName(schema) {
+    if (!schema || typeof schema !== "object" || typeof schema.$ref !== "string") {
+        throw new Error("Expected schema with $ref to '#/components/schemas/Name', but got inline or missing $ref");
+    }
+    const ref = schema.$ref;
+    const prefix = "#/components/schemas/";
+    if (!ref.startsWith(prefix)) {
+        throw new Error(`Unsupported $ref '${ref}'. Expected to start with '${prefix}'.`);
+    }
+    return ref.slice(prefix.length);
+}
+/**
+ * Resolves a parameter object or $ref to a component parameter
+ *
+ * Supports:
+ * - Inline parameter objects (returned as-is)
+ * - $ref to "#/components/parameters/Name" (resolved from document)
+ *
+ * @param {any} paramOrRef - Parameter object or reference
+ * @param {OpenAPIDocument} doc - OpenAPI document containing components
+ * @returns {any} - Resolved parameter object
+ * @throws {Error} If $ref format is invalid or referenced parameter not found
+ */
+export function resolveParameter(paramOrRef, doc) {
+    if (paramOrRef && typeof paramOrRef === "object" && typeof paramOrRef.$ref === "string") {
+        const ref = paramOrRef.$ref;
+        const prefix = "#/components/parameters/";
+        if (!ref.startsWith(prefix)) {
+            throw new Error(`Unsupported parameter $ref '${ref}'. Expected to start with '${prefix}'.`);
+        }
+        const name = ref.slice(prefix.length);
+        const p = doc.components?.parameters?.[name];
+        if (!p) {
+            throw new Error(`Parameter '${name}' not found in components.parameters`);
+        }
+        return p;
+    }
+    return paramOrRef;
+}
+/**
+ * Builds Fastify-compatible params/querystring/headers schemas from OpenAPI parameters
+ *
+ * Logic:
+ * 1. Merges path-level and operation-level parameters (operation overrides path)
+ * 2. Partitions by "in" field: path -> params, query -> querystring, header -> headers
+ * 3. Builds inline object schemas with properties/required arrays
+ * 4. Lowercases header names (Fastify convention)
+ * 5. Rewrites any schema $refs to URN format
+ *
+ * @param {any} pathItem - Path-level object (may have parameters array)
+ * @param {any} operation - Operation object (may have parameters array)
+ * @param {OpenAPIDocument} doc - OpenAPI document for resolving parameter refs
+ * @param {Record<string, string>} schemaIdByName - Schema name to URN ID mapping
+ * @returns {ParamSchemaBuildResult} - Object with optional params/querystring/headers schemas
+ */
+export function buildParamSchemasForOperation(pathItem, operation, doc, schemaIdByName) {
+    const all = [];
+    if (Array.isArray(pathItem?.parameters)) {
+        all.push(...pathItem.parameters);
+    }
+    if (Array.isArray(operation?.parameters)) {
+        all.push(...operation.parameters);
+    }
+    // Map by (in + ":" + name), last one wins (operation-level override)
+    const byKey = {};
+    for (const p of all) {
+        const resolved = resolveParameter(p, doc);
+        if (!resolved || typeof resolved !== "object")
+            continue;
+        const loc = resolved.in;
+        const name = resolved.name;
+        if (!loc || !name)
+            continue;
+        const key = `${loc}:${name}`;
+        byKey[key] = resolved;
+    }
+    const pathParams = [];
+    const queryParams = [];
+    const headerParams = [];
+    for (const param of Object.values(byKey)) {
+        switch (param.in) {
+            case "path":
+                pathParams.push(param);
+                break;
+            case "query":
+                queryParams.push(param);
+                break;
+            case "header":
+                headerParams.push(param);
+                break;
+            default:
+                // ignore cookie or other locations for now
+                break;
+        }
+    }
+    function buildObjectFromParams(params, header) {
+        if (params.length === 0)
+            return undefined;
+        const properties = {};
+        const required = [];
+        for (const p of params) {
+            let name = p.name;
+            if (header) {
+                name = name.toLowerCase();
+            }
+            let propSchema = {};
+            if (p.schema) {
+                propSchema = rewriteSchemaRefs(p.schema, schemaIdByName);
+            }
+            properties[name] = propSchema;
+            if (p.required) {
+                required.push(name);
+            }
+        }
+        const obj = {
+            type: "object",
+            properties,
+            additionalProperties: false,
+        };
+        if (required.length > 0) {
+            obj.required = required;
+        }
+        return obj;
+    }
+    const paramsSchema = buildObjectFromParams(pathParams, false);
+    const querySchema = buildObjectFromParams(queryParams, false);
+    const headersSchema = buildObjectFromParams(headerParams, true);
+    return {
+        paramsSchema,
+        querySchema,
+        headersSchema,
+    };
+}

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import type { CompilerOptions } from "./config.js";
 export { generateOpenAPI } from "./openapi/generateOpenAPI.js";
+export { generateGateway } from "./gateway/generateGateway.js";
 export { runGenerationPipeline } from "./pipeline.js";
 /**
  * Compiles a WSDL file to TypeScript client code

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,aAAa,CAAC;AASjD,OAAO,EAAC,eAAe,EAAC,MAAM,8BAA8B,CAAC;AAC7D,OAAO,EAAC,qBAAqB,EAAC,MAAM,eAAe,CAAC;AAGpD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,oBAAoB,CACxC,KAAK,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,eAAe,CAAA;CAAE,GACjE,OAAO,CAAC,IAAI,CAAC,CAqDf"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,aAAa,CAAC;AAUjD,OAAO,EAAC,eAAe,EAAC,MAAM,8BAA8B,CAAC;AAC7D,OAAO,EAAC,eAAe,EAAC,MAAM,8BAA8B,CAAC;AAC7D,OAAO,EAAC,qBAAqB,EAAC,MAAM,eAAe,CAAC;AAGpD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,oBAAoB,CACxC,KAAK,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,eAAe,CAAA;CAAE,GACjE,OAAO,CAAC,IAAI,CAAC,CAsDf"}