@techspokes/typescript-wsdl-client 0.15.2 → 0.17.0

package/dist/compiler/schemaCompiler.js

@@ -153,7 +153,7 @@ function extractAnnotationDocumentation(node) {
  * 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.
  */
-export function compileCatalog(cat, options) {
+export function compileCatalog(cat, options, streamConfig) {
     // symbol tables discovered across all schemas
     const complexTypes = new Map();
     const simpleTypes = new Map();
@@ -190,6 +190,13 @@ export function compileCatalog(cat, options) {
     const attrType = {};
     const childType = {};
     const propMeta = {};
+    const diagnostics = {};
+    const addDiagnosticNote = (note) => {
+        diagnostics.notes ??= [];
+        if (!diagnostics.notes.includes(note)) {
+            diagnostics.notes.push(note);
+        }
+    };
     /** Compile a simpleType node to TS */
     function compileSimpleTypeNode(simpleNode, schemaNS, prefixes) {
         const rest = getFirstWithLocalName(simpleNode, "restriction");
@@ -346,6 +353,33 @@ export function compileCatalog(cat, options) {
             }
             return out;
         };
+        // Walks the same compositor structure as collectParticles and returns any
+        // xs:any wildcard particles found. Kept as a sibling to avoid reshaping
+        // collectParticles' return type at the three call sites below.
+        const collectWildcards = (node) => {
+            const out = [];
+            const recurse = (groupNode) => {
+                for (const a of getChildrenWithLocalName(groupNode, "any")) {
+                    const min = a["@_minOccurs"] ? Number(a["@_minOccurs"]) : 1;
+                    const maxAttr = a["@_maxOccurs"];
+                    const max = maxAttr === "unbounded" ? "unbounded" : maxAttr ? Number(maxAttr) : 1;
+                    const pc = a["@_processContents"];
+                    out.push({
+                        min,
+                        max,
+                        ...(a["@_namespace"] ? { namespace: a["@_namespace"] } : {}),
+                        ...(pc === "lax" || pc === "strict" || pc === "skip" ? { processContents: pc } : {}),
+                    });
+                }
+                for (const comp of ["sequence", "all", "choice"]) {
+                    for (const sub of getChildrenWithLocalName(groupNode, comp)) {
+                        recurse(sub);
+                    }
+                }
+            };
+            recurse(node);
+            return out;
+        };
         const collectParticles = (ownerTypeName, node) => {
             const out = [];
             // process a compositor or element container recursively
@@ -417,8 +451,12 @@ export function compileCatalog(cat, options) {
             // On duplicate definitions, merge new attributes and elements
             const newAttrs = collectAttributes(cnode);
             const newElems = collectParticles(outName, cnode);
+            const newWildcards = collectWildcards(cnode);
             mergeAttrs(present.attrs, newAttrs);
             mergeElems(present.elems, newElems);
+            if (newWildcards.length > 0) {
+                present.wildcards = [...(present.wildcards ?? []), ...newWildcards];
+            }
             if (!present.doc && typeDoc) {
                 present.doc = typeDoc;
             }
@@ -453,6 +491,7 @@ export function compileCatalog(cat, options) {
                 // collect local additions/overrides
                 const locals = collectAttributes(node);
                 const localElems = collectParticles(outName, node);
+                const localWildcards = collectWildcards(node);
                 attrs.push(...locals);
                 elems.push(...localElems);
                 const result = {
@@ -463,7 +502,8 @@ export function compileCatalog(cat, options) {
                     doc: typeDoc,
                     base: baseName,
                     localAttrs: locals,
-                    localElems
+                    localElems,
+                    ...(localWildcards.length > 0 ? { wildcards: localWildcards } : {}),
                 };
                 compiledMap.set(key, result);
                 inProgress.delete(key);
@@ -506,7 +546,15 @@ export function compileCatalog(cat, options) {
         // Attributes + particles
         mergeAttrs(attrs, collectAttributes(cnode));
         mergeElems(elems, collectParticles(outName, cnode));
-        const result = { name: outName, ns: schemaNS, attrs, elems, doc: typeDoc };
+        const wildcards = collectWildcards(cnode);
+        const result = {
+            name: outName,
+            ns: schemaNS,
+            attrs,
+            elems,
+            doc: typeDoc,
+            ...(wildcards.length > 0 ? { wildcards } : {}),
+        };
         compiledMap.set(key, result);
         inProgress.delete(rawKey);
         return result;
@@ -585,6 +633,19 @@ export function compileCatalog(cat, options) {
             const srec = simpleTypes.get(qkey(q));
             if (srec) {
                 const a = getOrCompileAlias(q.local, srec.node, srec.tns, srec.prefixes);
+                if (outName === a.name) {
+                    addDiagnosticNote(`Element {${schemaNS}}${name} reuses same-name simple type alias ${a.name} instead of emitting a wrapper interface.`);
+                    if (!a.doc && elementDoc) {
+                        a.doc = elementDoc;
+                    }
+                    return {
+                        name: a.name,
+                        ns: schemaNS,
+                        attrs: [],
+                        elems: [],
+                        doc: elementDoc,
+                    };
+                }
                 const t = {
                     name: outName,
                     ns: schemaNS,
@@ -812,7 +873,7 @@ export function compileCatalog(cat, options) {
         .filter((x) => x != null)
         .sort((a, b) => a.name.localeCompare(b.name));
     // build operations list
-    const ops = (pOps
+    const ops = pOps
         .map(po => {
         const name = po?.["@_name"];
         if (!name)
@@ -825,9 +886,18 @@ export function compileCatalog(cat, options) {
         // Derive TypeScript type names from element local names
         const inputTypeName = inputElement ? pascal(inputElement.local) : undefined;
         const outputTypeName = outputElement ? pascal(outputElement.local) : undefined;
-        return { name, soapAction: bOps.get(name) || "", inputElement, outputElement, inputTypeName, outputTypeName, doc };
+        const op = {
+            name,
+            soapAction: bOps.get(name) || "",
+            ...(inputElement ? { inputElement } : {}),
+            ...(outputElement ? { outputElement } : {}),
+            ...(inputTypeName ? { inputTypeName } : {}),
+            ...(outputTypeName ? { outputTypeName } : {}),
+            ...(doc ? { doc } : {}),
+        };
+        return op;
     })
-        .filter((x) => x != null));
+        .filter((x) => x != null);
     // --- WS-Policy: scan for security requirements (inline policies only) ---
     const bindingPolicies = getChildrenWithLocalName(soapBinding || {}, "Policy");
     const bindingSec = collectSecurityFromPolicyNodes(bindingPolicies);
@@ -838,6 +908,31 @@ export function compileCatalog(cat, options) {
         const secSet = new Set([...bindingSec, ...opSec]);
         op.security = Array.from(secSet);
     }
+    // --- Stream config application ---
+    // A stream-configured operation is matched by name against the WSDL's
+    // portType operations. Unknown operation names are fatal so that consumers
+    // find out about stale configs at generation time, not at runtime.
+    if (streamConfig) {
+        const opByName = new Map(ops.map((op) => [op.name, op]));
+        for (const [opName, meta] of Object.entries(streamConfig.operations)) {
+            const op = opByName.get(opName);
+            if (!op) {
+                throw new WsdlCompilationError(`Stream config references operation "${opName}" but the WSDL portType does not declare it.`, {
+                    element: opName,
+                    suggestion: `Remove the entry under "operations.${opName}" in the stream config, or correct the operation name to match one defined in the WSDL.`,
+                });
+            }
+            op.stream = {
+                mode: meta.mode,
+                format: meta.format,
+                mediaType: meta.mediaType,
+                recordPath: [...meta.recordPath],
+                recordTypeName: meta.recordTypeName,
+                ...(meta.shapeCatalogName ? { shapeCatalogName: meta.shapeCatalogName } : {}),
+                ...(op.outputTypeName ? { sourceOutputTypeName: op.outputTypeName } : {}),
+            };
+        }
+    }
     // --- Service discovery (for client naming) ---
     let serviceName;
     const soapBindingName = soapBinding?.["@_name"];
@@ -869,5 +964,6 @@ export function compileCatalog(cat, options) {
         serviceName,
         wsdlUri: cat.wsdlUri,
         ...(wsdlDocs ? { wsdlDocs } : {}),
+        ...(diagnostics.notes?.length ? { diagnostics } : {}),
     };
 }

package/dist/compiler/shapeResolver.d.ts

@@ -0,0 +1,18 @@
+import { type CompiledCatalog } from "./schemaCompiler.js";
+import type { StreamConfig } from "../util/streamConfig.js";
+export interface ApplyShapeCatalogsOptions {
+    /** Directory against which relative `catalogFile`/`wsdlSource` paths resolve. Defaults to process.cwd(). */
+    baseDir?: string;
+}
+/**
+ * Apply a parsed StreamConfig to a compiled catalog:
+ *   1. Verify every opted-in operation's record type is resolvable.
+ *   2. For each operation that names a shapeCatalog, load the companion
+ *      catalog (once, cached) and copy the reachable record-type graph.
+ *
+ * Mutates `compiled` in place. Safe to call with a StreamConfig that has
+ * zero shapeCatalogs — it will still validate record-type presence against
+ * the current catalog.
+ */
+export declare function applyShapeCatalogs(compiled: CompiledCatalog, streamConfig: StreamConfig, options?: ApplyShapeCatalogsOptions): Promise<void>;
+//# sourceMappingURL=shapeResolver.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shapeResolver.d.ts","sourceRoot":"","sources":["../../src/compiler/shapeResolver.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAqC,KAAK,eAAe,EAAoB,MAAM,qBAAqB,CAAC;AAGhH,OAAO,KAAK,EAAkB,YAAY,EAAC,MAAM,yBAAyB,CAAC;AAG3E,MAAM,WAAW,yBAAyB;IACxC,4GAA4G;IAC5G,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;GASG;AACH,wBAAsB,kBAAkB,CACtC,QAAQ,EAAE,eAAe,EACzB,YAAY,EAAE,YAAY,EAC1B,OAAO,GAAE,yBAA8B,GACtC,OAAO,CAAC,IAAI,CAAC,CAoDf"}

package/dist/compiler/shapeResolver.js

@@ -0,0 +1,280 @@
+/**
+ * Companion-catalog shape resolver (phase-2 of ADR-002).
+ *
+ * For stream operations whose record types live in a different WSDL (e.g.
+ * Escapia's main EVRN service provides the concrete UnitDescriptiveContentType
+ * while the content-service WSDL only exposes an xs:any-wrapped envelope),
+ * load the companion catalog and copy the reachable record-type graph into
+ * the current catalog.
+ *
+ * Invariants:
+ *   - A name collision against a type already in the current catalog is only
+ *     allowed when the two types are *structurally identical* — otherwise we
+ *     fail the build rather than silently rename public API types.
+ *   - Existing buffered generation stays byte-for-byte identical when no
+ *     streamConfig.shapeCatalogs entries are declared.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { compileCatalog } from "./schemaCompiler.js";
+import { loadWsdl } from "../loader/wsdlLoader.js";
+import { resolveCompilerOptions } from "../config.js";
+import { WsdlCompilationError } from "../util/errors.js";
+/**
+ * Apply a parsed StreamConfig to a compiled catalog:
+ *   1. Verify every opted-in operation's record type is resolvable.
+ *   2. For each operation that names a shapeCatalog, load the companion
+ *      catalog (once, cached) and copy the reachable record-type graph.
+ *
+ * Mutates `compiled` in place. Safe to call with a StreamConfig that has
+ * zero shapeCatalogs — it will still validate record-type presence against
+ * the current catalog.
+ */
+export async function applyShapeCatalogs(compiled, streamConfig, options = {}) {
+    const baseDir = options.baseDir ?? process.cwd();
+    // Load each declared shape catalog once, on-demand. Shape catalogs declared
+    // but never referenced are harmless — we only load the ones an operation
+    // actually uses.
+    const referencedCatalogs = new Set();
+    for (const meta of Object.values(streamConfig.operations)) {
+        if (meta.shapeCatalogName)
+            referencedCatalogs.add(meta.shapeCatalogName);
+    }
+    const companionByName = new Map();
+    for (const name of referencedCatalogs) {
+        const ref = streamConfig.shapeCatalogs[name];
+        if (!ref) {
+            throw new WsdlCompilationError(`Stream config references shape catalog "${name}" that is not declared under "shapeCatalogs".`, {
+                suggestion: `Add a "shapeCatalogs.${name}" entry pointing to a wsdlSource or catalogFile, or remove the reference.`,
+            });
+        }
+        companionByName.set(name, await loadCompanionCatalog(name, ref, baseDir, compiled));
+    }
+    for (const [opName, meta] of Object.entries(streamConfig.operations)) {
+        if (meta.shapeCatalogName) {
+            const companion = companionByName.get(meta.shapeCatalogName);
+            if (!companion) {
+                // Guarded by the loop above; this path is defensive.
+                throw new WsdlCompilationError(`Stream config for "${opName}" references shape catalog "${meta.shapeCatalogName}" which failed to load.`);
+            }
+            copyReachableGraph(compiled, companion, meta.recordTypeName, {
+                opName,
+                shapeCatalog: meta.shapeCatalogName,
+            });
+        }
+        else {
+            // No companion: the record type must already live in the main catalog.
+            if (!hasNamedType(compiled, meta.recordTypeName)) {
+                throw new WsdlCompilationError(`Stream config for operation "${opName}" references record type "${meta.recordTypeName}" which is not present in the compiled catalog.`, {
+                    element: meta.recordTypeName,
+                    suggestion: `Either declare a "shapeCatalogs.<name>" entry and set shapeCatalog on the operation, or correct the recordType to a type defined in the WSDL.`,
+                });
+            }
+        }
+    }
+}
+async function loadCompanionCatalog(name, ref, baseDir, compiled) {
+    if (ref.catalogFile) {
+        const abs = path.resolve(baseDir, ref.catalogFile);
+        let text;
+        try {
+            text = fs.readFileSync(abs, "utf-8");
+        }
+        catch (err) {
+            throw new WsdlCompilationError(`Failed to read companion catalog "${name}" at ${abs}: ${err.message}`, { suggestion: `Check that shapeCatalogs.${name}.catalogFile points to an existing catalog.json.` });
+        }
+        try {
+            return JSON.parse(text);
+        }
+        catch (err) {
+            throw new WsdlCompilationError(`Companion catalog "${name}" at ${abs} is not valid JSON: ${err.message}`);
+        }
+    }
+    if (ref.wsdlSource) {
+        // Relative paths resolve against baseDir; URLs pass through untouched.
+        const src = isLikelyUrl(ref.wsdlSource) ? ref.wsdlSource : path.resolve(baseDir, ref.wsdlSource);
+        const wsdlCatalog = await loadWsdl(src);
+        // Reuse the current catalog's compiler options so primitives / attrs keys
+        // / choice handling stay consistent with the main generation.
+        const companionOptions = resolveCompilerOptions({ ...compiled.options, catalog: false }, { wsdl: src, out: baseDir });
+        return compileCatalog(wsdlCatalog, companionOptions);
+    }
+    throw new WsdlCompilationError(`Shape catalog "${name}" declares neither wsdlSource nor catalogFile.`);
+}
+function isLikelyUrl(s) {
+    return /^[a-z][a-z0-9+.-]*:\/\//i.test(s);
+}
+function hasNamedType(cat, name) {
+    return cat.types.some((t) => t.name === name) || cat.aliases.some((a) => a.name === name);
+}
+/**
+ * Walk the reachable type graph from `rootTypeName` within the companion
+ * catalog and copy each reachable entry into `dst`. Types with the same name
+ * already present in `dst` are checked for structural equality; any divergence
+ * is fatal.
+ */
+function copyReachableGraph(dst, src, rootTypeName, context) {
+    const srcTypes = new Map(src.types.map((t) => [t.name, t]));
+    const srcAliases = new Map(src.aliases.map((a) => [a.name, a]));
+    if (!srcTypes.has(rootTypeName) && !srcAliases.has(rootTypeName)) {
+        throw new WsdlCompilationError(`Stream config for operation "${context.opName}" references record type "${rootTypeName}" but it is not present in shape catalog "${context.shapeCatalog}".`, {
+            element: rootTypeName,
+            suggestion: `Check the companion catalog or correct the recordType.`,
+        });
+    }
+    const known = new Set([...srcTypes.keys(), ...srcAliases.keys()]);
+    const queue = [rootTypeName];
+    const visited = new Set();
+    while (queue.length > 0) {
+        const typeName = queue.shift();
+        if (visited.has(typeName))
+            continue;
+        visited.add(typeName);
+        const srcType = srcTypes.get(typeName);
+        if (srcType) {
+            mergeType(dst, src, srcType, context);
+            // Enqueue referenced names from elems, attrs, base.
+            for (const e of srcType.elems ?? []) {
+                for (const ref of extractReferencedNames(e.tsType, known))
+                    queue.push(ref);
+            }
+            for (const a of srcType.attrs ?? []) {
+                for (const ref of extractReferencedNames(a.tsType, known))
+                    queue.push(ref);
+            }
+            if (srcType.base && known.has(srcType.base))
+                queue.push(srcType.base);
+            continue;
+        }
+        const srcAlias = srcAliases.get(typeName);
+        if (srcAlias) {
+            mergeAlias(dst, src, srcAlias, context);
+            for (const ref of extractReferencedNames(srcAlias.tsType, known))
+                queue.push(ref);
+        }
+        // Not in companion; silently skip — either a primitive or a type that
+        // the main catalog is expected to own.
+    }
+}
+function mergeType(dst, src, srcType, context) {
+    const existingIdx = dst.types.findIndex((t) => t.name === srcType.name);
+    if (existingIdx < 0) {
+        dst.types.push({ ...srcType });
+        copyTypeMeta(dst, src, srcType.name);
+        return;
+    }
+    const existing = dst.types[existingIdx];
+    if (!structurallyEqualType(existing, srcType)) {
+        throw new WsdlCompilationError(`Companion catalog "${context.shapeCatalog}" declares type "${srcType.name}" that conflicts structurally with the current catalog.`, {
+            element: srcType.name,
+            suggestion: `Rename one of the conflicting types in the source WSDL, or resolve the conflict before streaming. wsdl-tsc refuses to silently rename public API types.`,
+        });
+    }
+    // Structurally identical — keep the existing entry (and its meta) as-is.
+}
+function mergeAlias(dst, src, srcAlias, context) {
+    const existingIdx = dst.aliases.findIndex((a) => a.name === srcAlias.name);
+    if (existingIdx < 0) {
+        dst.aliases.push({ ...srcAlias });
+        // Aliases that point at a complex type get meta synonyms in compileCatalog;
+        // the main catalog already owns that path for its own types, so we only
+        // need to add meta if the companion aliases a complex type whose type we
+        // also just copied.
+        copyAliasSynonymMeta(dst, src, srcAlias.name);
+        return;
+    }
+    const existing = dst.aliases[existingIdx];
+    if (!structurallyEqualAlias(existing, srcAlias)) {
+        throw new WsdlCompilationError(`Companion catalog "${context.shapeCatalog}" declares alias "${srcAlias.name}" that conflicts structurally with the current catalog.`, {
+            element: srcAlias.name,
+            suggestion: `Resolve the conflicting type name before streaming. wsdl-tsc refuses to silently rename public API types.`,
+        });
+    }
+}
+function copyTypeMeta(dst, src, typeName) {
+    if (typeName in src.meta.attrSpec)
+        dst.meta.attrSpec[typeName] = [...src.meta.attrSpec[typeName]];
+    if (typeName in src.meta.attrType)
+        dst.meta.attrType[typeName] = { ...src.meta.attrType[typeName] };
+    if (typeName in src.meta.childType)
+        dst.meta.childType[typeName] = { ...src.meta.childType[typeName] };
+    if (typeName in src.meta.propMeta)
+        dst.meta.propMeta[typeName] = { ...src.meta.propMeta[typeName] };
+}
+function copyAliasSynonymMeta(dst, src, aliasName) {
+    // Phase-2 MVP: only copy meta for aliases whose name already keys into the
+    // source's meta maps. Aliases that are just simple-type renames don't need
+    // child/attr meta at all.
+    copyTypeMeta(dst, src, aliasName);
+}
+const TS_BUILTINS = new Set([
+    "string", "number", "boolean", "bigint", "null", "undefined", "void", "any", "unknown", "never",
+    "Date", "Array", "Record", "Map", "Set", "Promise", "Buffer", "Object", "Function",
+]);
+/**
+ * Extract PascalCase identifiers from a TypeScript type expression that are
+ * known to the companion catalog. Deliberately cheap — matches identifiers
+ * starting with an uppercase letter, skips TS built-ins and anything not
+ * present in the companion's known-names set.
+ */
+function extractReferencedNames(tsType, known) {
+    if (!tsType)
+        return [];
+    const out = [];
+    // Identifiers starting with an uppercase letter; bare word boundaries.
+    for (const m of tsType.matchAll(/\b[A-Z][A-Za-z0-9_]*\b/g)) {
+        const name = m[0];
+        if (TS_BUILTINS.has(name))
+            continue;
+        if (known.has(name))
+            out.push(name);
+    }
+    return out;
+}
+function structurallyEqualType(a, b) {
+    return canonicalizeType(a) === canonicalizeType(b);
+}
+function structurallyEqualAlias(a, b) {
+    return canonicalizeAlias(a) === canonicalizeAlias(b);
+}
+function canonicalizeType(t) {
+    // Drop fields that legitimately differ between catalogs (ns, docs) and
+    // stabilize ordering. Stream metadata is on operations, not on types.
+    return JSON.stringify({
+        name: t.name,
+        attrs: (t.attrs ?? []).map(canonicalizeAttr),
+        elems: (t.elems ?? []).map(canonicalizeElem),
+        base: t.base ?? null,
+        wildcards: (t.wildcards ?? []).map((w) => ({
+            min: w.min,
+            max: w.max,
+            namespace: w.namespace ?? null,
+            processContents: w.processContents ?? null,
+        })),
+    });
+}
+function canonicalizeAlias(a) {
+    return JSON.stringify({
+        name: a.name,
+        tsType: a.tsType,
+        declared: a.declared,
+    });
+}
+function canonicalizeAttr(a) {
+    return {
+        name: a.name,
+        tsType: a.tsType,
+        use: a.use ?? "optional",
+        declaredType: a.declaredType,
+    };
+}
+function canonicalizeElem(e) {
+    return {
+        name: e.name,
+        tsType: e.tsType,
+        min: e.min,
+        max: e.max,
+        nillable: !!e.nillable,
+        declaredType: e.declaredType,
+    };
+}

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

@@ -1 +1 @@
-{"version":3,"file":"generateGateway.d.ts","sourceRoot":"","sources":["../../src/gateway/generateGateway.ts"],"names":[],"mappings":"AA6CA;;;;;;;;;;;;;;;;;;GAkBG;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;IAE/B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,sBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC,CA6JjF"}
+{"version":3,"file":"generateGateway.d.ts","sourceRoot":"","sources":["../../src/gateway/generateGateway.ts"],"names":[],"mappings":"AA6CA;;;;;;;;;;;;;;;;;;GAkBG;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;IAE/B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,sBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC,CA8JjF"}

package/dist/gateway/generateGateway.js

@@ -183,7 +183,8 @@ export async function generateGateway(opts) {
     }
     // Step 6: Emit runtime.ts (if enabled)
     if (emitRuntime) {
-        emitRuntimeModule(outDir, versionSlug, serviceSlug, shouldUnwrap ? catalog : undefined);
+        const hasStreams = operations.some((o) => !!o.stream);
+        emitRuntimeModule(outDir, versionSlug, serviceSlug, shouldUnwrap ? catalog : undefined, { hasStreams });
     }
     // Step 7: Emit plugin.ts and type-check fixture (if enabled)
     if (emitPlugin) {

package/dist/gateway/generators.d.ts

@@ -40,6 +40,16 @@ export interface OperationMetadata {
     description?: string;
     /** When true, response schema is omitted from route registration to avoid fast-json-stringify stack overflow on deeply nested $ref graphs */
     skipResponseSchema?: boolean;
+    /**
+     * Stream metadata populated from the OpenAPI `x-wsdl-tsc-stream` extension.
+     * When present, the route handler pipes `result.records` through the NDJSON
+     * helper instead of envelope-wrapping a single response object.
+     */
+    stream?: {
+        mediaType: string;
+        format: "ndjson" | "json-array";
+        recordTypeName?: string;
+    };
 }
 /**
  * Emits Fastify-compatible operation schema files
@@ -107,7 +117,9 @@ export declare function emitSchemasModule(outDir: string, modelsDir: string, ver
  * @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;
-export declare function emitRuntimeModule(outDir: string, versionSlug: string, serviceSlug: string, catalog?: any): void;
+export declare function emitRuntimeModule(outDir: string, versionSlug: string, serviceSlug: string, catalog?: any, opts?: {
+    hasStreams?: boolean;
+}): void;
 /**
  * Emits plugin.ts module as the primary Fastify plugin wrapper
  *

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

@@ -1 +1 @@
-{"version":3,"file":"generators.d.ts","sourceRoot":"","sources":["../../src/gateway/generators.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"generators.d.ts","sourceRoot":"","sources":["../../src/gateway/generators.ts"],"names":[],"mappings":"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"}