@techspokes/typescript-wsdl-client 0.7.15 → 0.8.15

package/dist/{emit/clientEmitter.d.ts → client/generateClient.d.ts}

@@ -16,5 +16,5 @@ import type { CompiledCatalog } from "../compiler/schemaCompiler.js";
  * @param {string} outFile - Path to the output TypeScript file
  * @param {CompiledCatalog} compiled - The compiled WSDL catalog
  */
-export declare function emitClient(outFile: string, compiled: CompiledCatalog): void;
-//# sourceMappingURL=clientEmitter.d.ts.map
+export declare function generateClient(outFile: string, compiled: CompiledCatalog): void;
+//# sourceMappingURL=generateClient.d.ts.map

package/dist/client/generateClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateClient.d.ts","sourceRoot":"","sources":["../../src/client/generateClient.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,+BAA+B,CAAC;AAInE;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,eAAe,QAsWxE"}

package/dist/{emit/clientEmitter.js → client/generateClient.js}

@@ -1,5 +1,5 @@
 /**
- * TypeScript SOAP Client Emitter
+ * TypeScript SOAP Client Generator
  *
  * This module generates a strongly-typed TypeScript SOAP client class from the compiled WSDL catalog.
  * The generated client wraps the node-soap library with type-safe operation methods and proper
@@ -14,6 +14,7 @@
  */
 import fs from "node:fs";
 import { deriveClientName, pascal, pascalToSnakeCase } from "../util/tools.js";
+import { error, warn } from "../util/cli.js";
 /**
  * Generates a TypeScript SOAP client class from a compiled WSDL catalog
  *
@@ -31,7 +32,7 @@ import { deriveClientName, pascal, pascalToSnakeCase } from "../util/tools.js";
  * @param {string} outFile - Path to the output TypeScript file
  * @param {CompiledCatalog} compiled - The compiled WSDL catalog
  */
-export function emitClient(outFile, compiled) {
+export function generateClient(outFile, compiled) {
     const isValidIdent = (name) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name);
     const reserved = new Set([
         "break", "case", "catch", "class", "const", "continue", "debugger", "default", "delete",
@@ -54,7 +55,7 @@ export function emitClient(outFile, compiled) {
         const inTypeName = op.inputElement ? pascal(op.inputElement.local) : undefined;
         const outTypeName = op.outputElement ? pascal(op.outputElement.local) : undefined;
         if (!inTypeName && !outTypeName) {
-            console.warn(`Operation ${op.name} has no input or output type defined. Skipping method generation.`);
+            warn(`Operation ${op.name} has no input or output type defined. Skipping method generation.`);
             continue;
         }
         const inTs = inTypeName ? `T.${inTypeName}` : `any`;
@@ -382,9 +383,8 @@ ${methodsBody}
 `;
     try {
         fs.writeFileSync(outFile, classTemplate.replace(`// noinspection JSAnnotator\n\n`, ''), "utf8");
-        console.log(`Client class written to ${outFile}`);
     }
     catch (e) {
-        console.log(`Failed to write catalog to ${outFile}`);
+        error(`Failed to write client to ${outFile}`);
     }
 }

package/dist/{emit/typesEmitter.d.ts → client/generateTypes.d.ts}

@@ -1,13 +1,13 @@
 import type { CompiledCatalog } from "../compiler/schemaCompiler.js";
 /**
- * Emits TypeScript interfaces and type aliases from a compiled WSDL catalog
+ * Generates TypeScript interfaces and type aliases from a compiled WSDL catalog
  *
  * This function generates a TypeScript file containing all the types required to
  * work with the SOAP service, including:
  *
  * - Type aliases for simple types (enums, restrictions, etc.)
  * - Interfaces for complex types with proper inheritance
- * - JSDoc annotations with XML metadata for runtime marshalling
+ * - JSDoc annotations with XML metadata for runtime marshaling
  *
  * Key design decisions:
  * - Text node is modeled as "$value" (not "value") to avoid collisions with real elements
@@ -18,5 +18,5 @@ import type { CompiledCatalog } from "../compiler/schemaCompiler.js";
  * @param {string} outFile - Path to the output TypeScript file
  * @param {CompiledCatalog} compiled - The compiled WSDL catalog
  */
-export declare function emitTypes(outFile: string, compiled: CompiledCatalog): void;
-//# sourceMappingURL=typesEmitter.d.ts.map
+export declare function generateTypes(outFile: string, compiled: CompiledCatalog): void;
+//# sourceMappingURL=generateTypes.d.ts.map

package/dist/client/generateTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateTypes.d.ts","sourceRoot":"","sources":["../../src/client/generateTypes.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAC,eAAe,EAAe,MAAM,+BAA+B,CAAC;AAGjF;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,eAAe,QA+IvE"}

package/dist/{emit/typesEmitter.js → client/generateTypes.js}

@@ -1,5 +1,5 @@
 /**
- * TypeScript Types Emitter
+ * TypeScript Types Generator
  *
  * This module is responsible for transforming the compiled WSDL catalog into TypeScript
  * type definitions. It generates interfaces for complex types and type aliases for
@@ -13,15 +13,16 @@
  * - Optional/required markers based on XML schema requirements
  */
 import fs from "node:fs";
+import { error } from "../util/cli.js";
 /**
- * Emits TypeScript interfaces and type aliases from a compiled WSDL catalog
+ * Generates TypeScript interfaces and type aliases from a compiled WSDL catalog
  *
  * This function generates a TypeScript file containing all the types required to
  * work with the SOAP service, including:
  *
  * - Type aliases for simple types (enums, restrictions, etc.)
  * - Interfaces for complex types with proper inheritance
- * - JSDoc annotations with XML metadata for runtime marshalling
+ * - JSDoc annotations with XML metadata for runtime marshaling
  *
  * Key design decisions:
  * - Text node is modeled as "$value" (not "value") to avoid collisions with real elements
@@ -32,7 +33,7 @@ import fs from "node:fs";
  * @param {string} outFile - Path to the output TypeScript file
  * @param {CompiledCatalog} compiled - The compiled WSDL catalog
  */
-export function emitTypes(outFile, compiled) {
+export function generateTypes(outFile, compiled) {
     const lines = [];
     // Convenience lookups
     const typeNames = new Set(compiled.types.map((t) => t.name));
@@ -162,9 +163,8 @@ export function emitTypes(outFile, compiled) {
     }
     try {
         fs.writeFileSync(outFile, lines.join("\n"), "utf8");
-        console.log(`Types written to ${outFile}`);
     }
     catch (e) {
-        console.error(`Failed to write types to ${outFile}:`, e);
+        error(`Failed to write types to ${outFile}: ${e instanceof Error ? e.message : String(e)}`);
     }
 }

package/dist/{emit/utilsEmitter.d.ts → client/generateUtils.d.ts}

@@ -1,6 +1,6 @@
 import type { CompiledCatalog } from "../compiler/schemaCompiler.js";
 /**
- * Emits utility types and constants for XML serialization/deserialization
+ * Generates utility types and constants for XML serialization/deserialization
  *
  * This function generates a TypeScript file containing metadata mappings that help
  * the SOAP client distinguish between XML attributes and child elements during
@@ -9,7 +9,7 @@ import type { CompiledCatalog } from "../compiler/schemaCompiler.js";
  * 1. A DataTypes interface defining the structure of the metadata
  * 2. A constant containing the actual mappings extracted from the compiled catalog
  *
- * The metadata is critical for proper XML marshalling and unmarshalling, as it enables
+ * The metadata is critical for proper XML marshaling and unmarshalling, as it enables
  * the client to correctly handle XML attributes vs. child elements, maintain type information
  * during recursive processing, and ensure that the XML structure matches the WSDL specification.
  *
@@ -17,5 +17,5 @@ import type { CompiledCatalog } from "../compiler/schemaCompiler.js";
  * @param {CompiledCatalog} compiled - The compiled WSDL catalog containing metadata
  * @throws {Error} If metadata is missing or has an invalid structure
  */
-export declare function emitUtils(outFile: string, compiled: CompiledCatalog): void;
-//# sourceMappingURL=utilsEmitter.d.ts.map
+export declare function generateUtils(outFile: string, compiled: CompiledCatalog): void;
+//# sourceMappingURL=generateUtils.d.ts.map

package/dist/client/generateUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateUtils.d.ts","sourceRoot":"","sources":["../../src/client/generateUtils.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,+BAA+B,CAAC;AAInE;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,eAAe,QAgCvE"}

package/dist/{emit/utilsEmitter.js → client/generateUtils.js}

@@ -1,5 +1,5 @@
 /**
- * TypeScript SOAP Client Utilities Emitter
+ * TypeScript SOAP Client Utilities Generator
  *
  * This module generates utility types and constants needed for the TypeScript SOAP client
  * to properly handle XML serialization and deserialization. It creates metadata mappings
@@ -12,8 +12,9 @@
  */
 import fs from "node:fs";
 import { deriveClientName, pascalToSnakeCase } from "../util/tools.js";
+import { error } from "../util/cli.js";
 /**
- * Emits utility types and constants for XML serialization/deserialization
+ * Generates utility types and constants for XML serialization/deserialization
  *
  * This function generates a TypeScript file containing metadata mappings that help
  * the SOAP client distinguish between XML attributes and child elements during
@@ -22,7 +23,7 @@ import { deriveClientName, pascalToSnakeCase } from "../util/tools.js";
  * 1. A DataTypes interface defining the structure of the metadata
  * 2. A constant containing the actual mappings extracted from the compiled catalog
  *
- * The metadata is critical for proper XML marshalling and unmarshalling, as it enables
+ * The metadata is critical for proper XML marshaling and unmarshalling, as it enables
  * the client to correctly handle XML attributes vs. child elements, maintain type information
  * during recursive processing, and ensure that the XML structure matches the WSDL specification.
  *
@@ -30,12 +31,12 @@ import { deriveClientName, pascalToSnakeCase } from "../util/tools.js";
  * @param {CompiledCatalog} compiled - The compiled WSDL catalog containing metadata
  * @throws {Error} If metadata is missing or has an invalid structure
  */
-export function emitUtils(outFile, compiled) {
+export function generateUtils(outFile, compiled) {
     const clientName = deriveClientName(compiled);
     const clientConstant = pascalToSnakeCase(clientName).toUpperCase();
     const { attrSpec, childType } = compiled.meta;
     if (!attrSpec || !childType) {
-        throw new Error("Metadata not found in compiled catalog. Ensure schemaCompiler runs before metaEmitter.");
+        throw new Error("Metadata not found in compiled catalog. Ensure schemaCompiler runs before generator.");
     }
     if (typeof attrSpec !== "object" || typeof childType !== "object") {
         throw new Error("Invalid metadata structure. Expected objects for Attributes and ChildrenTypes.");
@@ -55,9 +56,8 @@ export interface ${clientName}DataTypes {
 export const ${clientConstant}_DATA_TYPES: ${clientName}DataTypes = ${metas} as const;\n`;
     try {
         fs.writeFileSync(outFile, dataTypes, "utf8");
-        console.log(`Utils written to ${outFile}`);
     }
     catch (e) {
-        console.error(`Failed to write utils to ${outFile}:`, e);
+        error(`Failed to write utils to ${outFile}: ${e instanceof Error ? e.message : String(e)}`);
     }
 }

package/dist/{emit/catalogEmitter.d.ts → compiler/generateCatalog.d.ts}

@@ -1,6 +1,6 @@
-import type { CompiledCatalog } from "../compiler/schemaCompiler.js";
+import type { CompiledCatalog } from "./schemaCompiler.js";
 /**
- * Emits the compiled catalog as a JSON file
+ * Generates the compiled catalog as a JSON file
  *
  * This function writes the complete compiled catalog to a JSON file, preserving all
  * type definitions, operation information, and metadata in a structured format.
@@ -17,5 +17,5 @@ import type { CompiledCatalog } from "../compiler/schemaCompiler.js";
  * @param {string} outFile - Path to the output JSON file
  * @param {CompiledCatalog} compiled - The compiled WSDL catalog to write
  */
-export declare function emitCatalog(outFile: string, compiled: CompiledCatalog): void;
-//# sourceMappingURL=catalogEmitter.d.ts.map
+export declare function generateCatalog(outFile: string, compiled: CompiledCatalog): void;
+//# sourceMappingURL=generateCatalog.d.ts.map

package/dist/compiler/generateCatalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateCatalog.d.ts","sourceRoot":"","sources":["../../src/compiler/generateCatalog.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,qBAAqB,CAAC;AAGzD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,eAAe,QAMzE"}

package/dist/{emit/catalogEmitter.js → compiler/generateCatalog.js}

@@ -1,5 +1,5 @@
 /**
- * Catalog Emitter for TypeScript WSDL Client Generator
+ * Catalog Generator for TypeScript WSDL Client Generator
  *
  * This module is responsible for writing the complete compiled catalog to a JSON file,
  * which serves as a structured representation of the WSDL for introspection and further
@@ -12,8 +12,9 @@
  * - Enabling incremental compilation workflows
  */
 import fs from "node:fs";
+import { error } from "../util/cli.js";
 /**
- * Emits the compiled catalog as a JSON file
+ * Generates the compiled catalog as a JSON file
  *
  * This function writes the complete compiled catalog to a JSON file, preserving all
  * type definitions, operation information, and metadata in a structured format.
@@ -30,12 +31,11 @@ import fs from "node:fs";
  * @param {string} outFile - Path to the output JSON file
  * @param {CompiledCatalog} compiled - The compiled WSDL catalog to write
  */
-export function emitCatalog(outFile, compiled) {
+export function generateCatalog(outFile, compiled) {
     try {
         fs.writeFileSync(outFile, JSON.stringify(compiled, null, 2), "utf8");
-        console.log(`Catalog written to ${outFile}`);
     }
     catch (err) {
-        console.error(`Failed to write catalog to ${outFile}:`, err);
+        error(`Failed to write catalog to ${outFile}: ${err instanceof Error ? err.message : String(err)}`);
     }
 }

package/dist/compiler/schemaCompiler.d.ts

@@ -125,7 +125,7 @@ export type CompiledCatalog = {
  * 1. Collect and index complexType, simpleType, and element definitions across all schemas.
  * 2. Recursively compile each named type to a TS interface or alias, handling inheritance,
  *    inline definitions, and XSD primitives.
- * 3. Build metadata maps for runtime marshalling (attributes, children, nillable, occurrence).
+ * 3. Build metadata maps for runtime marshaling (attributes, children, nillable, occurrence).
  * 4. Extract WSDL operations: pick the appropriate SOAP binding (v1.1 or v1.2), resolve its
  *    portType reference, then enumerate operations and their soapAction URIs.
  */

package/dist/compiler/schemaCompiler.js

@@ -97,7 +97,7 @@ function collectSecurityFromPolicyNodes(policyNodes) {
  * 1. Collect and index complexType, simpleType, and element definitions across all schemas.
  * 2. Recursively compile each named type to a TS interface or alias, handling inheritance,
  *    inline definitions, and XSD primitives.
- * 3. Build metadata maps for runtime marshalling (attributes, children, nillable, occurrence).
+ * 3. Build metadata maps for runtime marshaling (attributes, children, nillable, occurrence).
  * 4. Extract WSDL operations: pick the appropriate SOAP binding (v1.1 or v1.2), resolve its
  *    portType reference, then enumerate operations and their soapAction URIs.
  */

package/dist/config.d.ts

@@ -51,4 +51,17 @@ export type CompilerOptions = {
  * Default compiler options. Users may override selectively.
  */
 export declare const TYPESCRIPT_WSDL_CLIENT_DEFAULT_COMPLIER_OPTIONS: CompilerOptions;
+/**
+ * Resolve full compiler options from partial input
+ *
+ * Merges defaults with user-provided options and required overrides.
+ *
+ * @param input - Partial compiler options from CLI or API
+ * @param required - Required overrides (wsdl, out)
+ * @returns Complete compiler options
+ */
+export declare function resolveCompilerOptions(input: Partial<CompilerOptions>, required: {
+    wsdl: string;
+    out: string;
+}): CompilerOptions;
 //# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,qBAAqB,CAAC;AAE1D;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,gDAAgD;IAChD,IAAI,EAAE,MAAM,CAAC;IACb,oCAAoC;IACpC,GAAG,EAAE,MAAM,CAAC;IACZ,6CAA6C;IAC7C,OAAO,EAAE,IAAI,GAAG,IAAI,GAAG,MAAM,CAAC;IAC9B,0DAA0D;IAC1D,OAAO,EAAE,OAAO,CAAC;IACjB,+EAA+E;IAC/E,SAAS,EAAE,gBAAgB,CAAC;IAC5B,8FAA8F;IAC9F,MAAM,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC;IAClC,gFAAgF;IAChF,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,wEAAwE;IACxE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,qEAAqE;IACrE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,8DAA8D;IAC9D,kBAAkB,CAAC,EAAE,OAAO,CAAA;CAC7B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,+CAA+C,EAAE,eAgB7D,CAAC"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,qBAAqB,CAAC;AAE1D;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,gDAAgD;IAChD,IAAI,EAAE,MAAM,CAAC;IACb,oCAAoC;IACpC,GAAG,EAAE,MAAM,CAAC;IACZ,6CAA6C;IAC7C,OAAO,EAAE,IAAI,GAAG,IAAI,GAAG,MAAM,CAAC;IAC9B,0DAA0D;IAC1D,OAAO,EAAE,OAAO,CAAC;IACjB,+EAA+E;IAC/E,SAAS,EAAE,gBAAgB,CAAC;IAC5B,8FAA8F;IAC9F,MAAM,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC;IAClC,gFAAgF;IAChF,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,wEAAwE;IACxE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,qEAAqE;IACrE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,8DAA8D;IAC9D,kBAAkB,CAAC,EAAE,OAAO,CAAA;CAC7B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,+CAA+C,EAAE,eAgB7D,CAAC;AAEF;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,OAAO,CAAC,eAAe,CAAC,EAC/B,QAAQ,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GACtC,eAAe,CAOjB"}

package/dist/config.js

@@ -18,3 +18,20 @@ export const TYPESCRIPT_WSDL_CLIENT_DEFAULT_COMPLIER_OPTIONS = {
     clientName: undefined, // no default
     nillableAsOptional: false, // CLI default
 };
+/**
+ * Resolve full compiler options from partial input
+ *
+ * Merges defaults with user-provided options and required overrides.
+ *
+ * @param input - Partial compiler options from CLI or API
+ * @param required - Required overrides (wsdl, out)
+ * @returns Complete compiler options
+ */
+export function resolveCompilerOptions(input, required) {
+    return {
+        ...TYPESCRIPT_WSDL_CLIENT_DEFAULT_COMPLIER_OPTIONS,
+        ...input,
+        wsdl: required.wsdl,
+        out: required.out,
+    };
+}

package/dist/gateway/generateGateway.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Options for gateway code generation
+ *
+ * @interface GenerateGatewayOptions
+ * @property {string} [openapiFile] - Path to OpenAPI 3.1 JSON or YAML file (exclusive with openapiDocument)
+ * @property {any} [openapiDocument] - Pre-loaded OpenAPI document object (exclusive with openapiFile)
+ * @property {string} outDir - Output directory for generated gateway code
+ * @property {string} [clientDir] - Path to client directory (where client.ts is located) for importing client code
+ * @property {string} versionSlug - Version identifier for URN generation (required)
+ * @property {string} serviceSlug - Service identifier for URN generation (required)
+ * @property {number[]} [defaultResponseStatusCodes] - Status codes to backfill with default response
+ * @property {"js"|"ts"|"bare"} [imports] - Import-extension mode for generated TypeScript modules (mirrors global --imports)
+ */
+export interface GenerateGatewayOptions {
+    openapiFile?: string;
+    openapiDocument?: any;
+    outDir: string;
+    clientDir?: string;
+    versionSlug: string;
+    serviceSlug: string;
+    defaultResponseStatusCodes?: number[];
+    imports?: "js" | "ts" | "bare";
+}
+/**
+ * Generates Fastify gateway code from an OpenAPI 3.1 specification
+ *
+ * This function orchestrates the complete gateway generation process:
+ * 1. Loads/validates the OpenAPI document
+ * 2. Validates version and service slugs are provided
+ * 3. Generates model schemas with URN IDs
+ * 4. Generates operation schemas with Fastify structure
+ * 5. Emits schema registration module
+ * 6. Emits route files and aggregator module
+ *
+ * Contract assumptions (strict validation):
+ * - All request/response bodies use $ref to components.schemas (no inline schemas)
+ * - Every operation has a default response with application/json content
+ * - All schemas referenced by operations exist in components.schemas
+ *
+ * @param {GenerateGatewayOptions} opts - Generation options
+ * @returns {Promise<void>}
+ * @throws {Error} If OpenAPI validation fails or contract assumptions are violated
+ *
+ * @example
+ * // From JSON file
+ * await generateGateway({
+ *   openapiFile: "openapi.json",
+ *   outDir: "gateway",
+ *   versionSlug: "v1",
+ *   serviceSlug: "weather"
+ * });
+ *
+ * @example
+ * // From YAML file
+ * await generateGateway({
+ *   openapiFile: "openapi.yaml",
+ *   outDir: "gateway",
+ *   versionSlug: "v1",
+ *   serviceSlug: "weather"
+ * });
+ *
+ * @example
+ * // From in-memory document
+ * await generateGateway({
+ *   openapiDocument: openapiDoc,
+ *   outDir: "gateway",
+ *   versionSlug: "v1",
+ *   serviceSlug: "weather",
+ *   defaultResponseStatusCodes: [200, 400, 500]
+ * });
+ */
+export declare function generateGateway(opts: GenerateGatewayOptions): Promise<void>;
+//# sourceMappingURL=generateGateway.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"generateGateway.d.ts","sourceRoot":"","sources":["../../src/gateway/generateGateway.ts"],"names":[],"mappings":"AAiCA;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,sBAAsB;IACrC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,GAAG,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,0BAA0B,CAAC,EAAE,MAAM,EAAE,CAAC;IACtC,OAAO,CAAC,EAAE,IAAI,GAAG,IAAI,GAAG,MAAM,CAAC;CAChC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,sBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC,CAqFjF"}

package/dist/gateway/generateGateway.js

@@ -0,0 +1,135 @@
+/**
+ * Fastify Gateway Generator from OpenAPI 3.1
+ *
+ * This module generates production-ready Fastify gateway code from OpenAPI 3.1 specifications.
+ * It creates a complete "slice" (schemas + routes) for a single SOAP service and version,
+ * bridging the gap between OpenAPI specs and running Fastify applications.
+ *
+ * Core capabilities:
+ * - Generates JSON Schema files with URN-based IDs for all components
+ * - Creates Fastify-compatible operation schemas (body, params, querystring, headers, response)
+ * - Emits route registration code with handler stubs
+ * - Enforces strict contract validation (no inline schemas, proper $refs)
+ *
+ * Output structure:
+ *   {outDir}/
+ *     schemas/
+ *       models/      - JSON Schema components (re-ID'd with URNs)
+ *       operations/  - Fastify operation schemas
+ *     routes/        - Individual route registration files
+ *     schemas.ts     - Schema registration module
+ *     routes.ts      - Route registration module
+ */
+import fs from "node:fs";
+import path from "node:path";
+import * as yaml from "js-yaml";
+import { buildParamSchemasForOperation, getJsonSchemaRefName, isNumericStatus, } from "./helpers.js";
+import { emitModelSchemas, emitOperationSchemas, emitRouteFiles, emitSchemasModule, } from "./generators.js";
+/**
+ * Generates Fastify gateway code from an OpenAPI 3.1 specification
+ *
+ * This function orchestrates the complete gateway generation process:
+ * 1. Loads/validates the OpenAPI document
+ * 2. Validates version and service slugs are provided
+ * 3. Generates model schemas with URN IDs
+ * 4. Generates operation schemas with Fastify structure
+ * 5. Emits schema registration module
+ * 6. Emits route files and aggregator module
+ *
+ * Contract assumptions (strict validation):
+ * - All request/response bodies use $ref to components.schemas (no inline schemas)
+ * - Every operation has a default response with application/json content
+ * - All schemas referenced by operations exist in components.schemas
+ *
+ * @param {GenerateGatewayOptions} opts - Generation options
+ * @returns {Promise<void>}
+ * @throws {Error} If OpenAPI validation fails or contract assumptions are violated
+ *
+ * @example
+ * // From JSON file
+ * await generateGateway({
+ *   openapiFile: "openapi.json",
+ *   outDir: "gateway",
+ *   versionSlug: "v1",
+ *   serviceSlug: "weather"
+ * });
+ *
+ * @example
+ * // From YAML file
+ * await generateGateway({
+ *   openapiFile: "openapi.yaml",
+ *   outDir: "gateway",
+ *   versionSlug: "v1",
+ *   serviceSlug: "weather"
+ * });
+ *
+ * @example
+ * // From in-memory document
+ * await generateGateway({
+ *   openapiDocument: openapiDoc,
+ *   outDir: "gateway",
+ *   versionSlug: "v1",
+ *   serviceSlug: "weather",
+ *   defaultResponseStatusCodes: [200, 400, 500]
+ * });
+ */
+export async function generateGateway(opts) {
+    // Validate input sources
+    if (!opts.openapiDocument && !opts.openapiFile) {
+        throw new Error("Provide one of: openapiDocument or openapiFile");
+    }
+    if (opts.openapiDocument && opts.openapiFile) {
+        throw new Error("Provide only one source: openapiDocument OR openapiFile");
+    }
+    // Load OpenAPI document
+    let doc;
+    if (opts.openapiFile) {
+        const raw = fs.readFileSync(opts.openapiFile, "utf8");
+        const ext = path.extname(opts.openapiFile).toLowerCase();
+        // Parse based on file extension
+        if (ext === ".yaml" || ext === ".yml") {
+            doc = yaml.load(raw);
+        }
+        else if (ext === ".json") {
+            doc = JSON.parse(raw);
+        }
+        else {
+            throw new Error(`Unsupported OpenAPI file extension: ${ext}. Expected .json, .yaml, or .yml`);
+        }
+    }
+    else {
+        doc = opts.openapiDocument;
+    }
+    // Validate OpenAPI document structure
+    if (!doc || typeof doc !== "object" || typeof doc.paths !== "object") {
+        throw new Error("Invalid OpenAPI document: missing 'paths'");
+    }
+    if (!doc.components || !doc.components.schemas) {
+        throw new Error("Invalid OpenAPI document: missing 'components.schemas'");
+    }
+    // Validate that version and service slugs are provided
+    if (!opts.versionSlug || !opts.serviceSlug) {
+        throw new Error("Both versionSlug and serviceSlug are required for gateway generation");
+    }
+    const versionSlug = opts.versionSlug;
+    const serviceSlug = opts.serviceSlug;
+    // Set default response status codes if not provided
+    const defaultResponseStatusCodes = opts.defaultResponseStatusCodes || [
+        200, 400, 401, 403, 404, 409, 422, 429, 500, 502, 503, 504,
+    ];
+    // Determine import-extension mode (defaults to "js" like the client/compiler)
+    const importsMode = opts.imports ?? "js";
+    // Prepare output directories
+    const outDir = opts.outDir;
+    const modelsDir = path.join(outDir, "schemas", "models");
+    const opsDir = path.join(outDir, "schemas", "operations");
+    const routesDir = path.join(outDir, "routes");
+    // Step 1: Generate model schemas and build URN mapping
+    const schemaIdByName = emitModelSchemas(doc.components.schemas, modelsDir, versionSlug, serviceSlug);
+    // Step 2: Generate operation schemas
+    const operations = emitOperationSchemas(doc, opsDir, versionSlug, serviceSlug, schemaIdByName, defaultResponseStatusCodes, buildParamSchemasForOperation, getJsonSchemaRefName, isNumericStatus);
+    // Step 3: Emit schemas.ts module
+    emitSchemasModule(outDir, modelsDir, versionSlug, serviceSlug);
+    // Step 4: Emit route files and routes.ts module
+    emitRouteFiles(outDir, routesDir, versionSlug, serviceSlug, operations, importsMode);
+}

package/dist/gateway/generators.d.ts

@@ -0,0 +1,90 @@
+import { type OpenAPIDocument } 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 declare function emitModelSchemas(schemas: Record<string, any>, modelsDir: string, versionSlug: string, serviceSlug: string): Record<string, string>;
+/**
+ * Operation metadata for route generation
+ */
+export interface OperationMetadata {
+    operationSlug: string;
+    method: string;
+    path: string;
+}
+/**
+ * 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 declare function emitOperationSchemas(doc: OpenAPIDocument, opsDir: string, versionSlug: string, serviceSlug: string, schemaIdByName: Record<string, string>, defaultResponseStatusCodes: number[], buildParamSchemas: (pathItem: any, operation: any, doc: OpenAPIDocument, schemaIdByName: Record<string, string>) => any, getRefName: (schema: any) => string, isNumeric: (code: string) => boolean): OperationMetadata[];
+/**
+ * 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 declare function emitSchemasModule(outDir: string, modelsDir: string, versionSlug: string, serviceSlug: string): void;
+/**
+ * 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 declare function emitRouteFiles(outDir: string, routesDir: string, versionSlug: string, serviceSlug: string, operations: OperationMetadata[], importsMode: "js" | "ts" | "bare"): void;
+//# sourceMappingURL=generators.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"generators.d.ts","sourceRoot":"","sources":["../../src/gateway/generators.ts"],"names":[],"mappings":"AAcA,OAAO,EAAC,KAAK,eAAe,EAA+B,MAAM,cAAc,CAAC;AAEhF;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC5B,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,GAClB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CA0BxB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,eAAe,EACpB,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,EACnB,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EACtC,0BAA0B,EAAE,MAAM,EAAE,EACpC,iBAAiB,EAAE,CAAC,QAAQ,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,EAAE,GAAG,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,GAAG,EACvH,UAAU,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,MAAM,EACnC,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,GACnC,iBAAiB,EAAE,CA2HrB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,GAClB,IAAI,CAsBN;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,iBAAiB,EAAE,EAC/B,WAAW,EAAE,IAAI,GAAG,IAAI,GAAG,MAAM,GAChC,IAAI,CA0CN"}