@techspokes/typescript-wsdl-client 0.11.6 → 0.13.0

package/README.md

@@ -13,6 +13,7 @@ Generate type-safe TypeScript SOAP clients, OpenAPI 3.1 specs, and production-re
 - OpenAPI 3.1 specs that mirror your TypeScript types
 - REST gateway over SOAP with automatic request/response transformation
 - CI-friendly deterministic output for safe regeneration in version control
+- WSDL/XSD documentation propagated into generated comments and OpenAPI descriptions
 
 ## Quick Start
 
@@ -57,7 +58,7 @@ curl -X POST http://localhost:3000/get-weather-information \
 
 | Output | Files | Purpose |
 |--------|-------|---------|
-| TypeScript Client | client.ts, types.ts, utils.ts | Typed SOAP operations |
+| TypeScript Client | client.ts, types.ts, utils.ts, operations.ts | Typed SOAP operations and mockable operations interface |
 | OpenAPI 3.1 Spec | openapi.json or .yaml | REST API documentation |
 | Fastify Gateway | plugin.ts, routes/, schemas/ | Production REST handlers |
 | Catalog | catalog.json | Compiled WSDL (debuggable, cacheable) |

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

@@ -1 +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"}
+{"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,QA+WxE"}

package/dist/client/generateClient.js

@@ -34,6 +34,12 @@ import { error, warn } from "../util/cli.js";
  */
 export function generateClient(outFile, compiled) {
     const isValidIdent = (name) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name);
+    const normalizeDocLines = (text) => String(text)
+        .replace(/\r\n?/g, "\n")
+        .split("\n")
+        .map(line => line.trim())
+        .filter(Boolean)
+        .map(line => line.replace(/\*\//g, "*\\/"));
     const reserved = new Set([
         "break", "case", "catch", "class", "const", "continue", "debugger", "default", "delete",
         "do", "else", "enum", "export", "extends", "false", "finally", "for", "function", "if",
@@ -61,11 +67,13 @@ export function generateClient(outFile, compiled) {
         const inTs = inTypeName ? `T.${inTypeName}` : `any`;
         const outTs = outTypeName ? `T.${outTypeName}` : `any`;
         const secHints = Array.isArray(op.security) && op.security.length ? op.security : [];
+        const opDocLines = op.doc ? normalizeDocLines(op.doc) : [];
+        const opDocStr = opDocLines.length ? `\n   *\n${opDocLines.map(line => `   * ${line}`).join("\n")}` : "";
         const secHintsStr = secHints.length ? `\n   *\n   * Security (WSDL policy hint): ${secHints.join(", ")}` : "";
         const methodTemplate = `
 
   /**
-   * Calls the ${m} operation of the ${clientName}.${secHintsStr}
+   * Calls the ${m} operation of the ${clientName}.${opDocStr}${secHintsStr}
    *
    * @param args - The request arguments for the ${m} operation.
    * @returns A promise resolving to the operation response containing data, headers, response raw XML, and request raw XML.

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

@@ -1 +1 @@
-{"version":3,"file":"generateOperations.d.ts","sourceRoot":"","sources":["../../src/client/generateOperations.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAIrE;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,eAAe,GAAG,IAAI,CA0DnF"}
+{"version":3,"file":"generateOperations.d.ts","sourceRoot":"","sources":["../../src/client/generateOperations.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAIrE;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,eAAe,GAAG,IAAI,CAsEnF"}

package/dist/client/generateOperations.js

@@ -22,6 +22,12 @@ export function generateOperations(outFile, compiled) {
     const ext = compiled.options.imports ?? "bare";
     const suffix = ext === "bare" ? "" : `.${ext}`;
     const clientName = deriveClientName(compiled);
+    const normalizeDocLines = (text) => String(text)
+        .replace(/\r\n?/g, "\n")
+        .split("\n")
+        .map(line => line.trim())
+        .filter(Boolean)
+        .map(line => line.replace(/\*\//g, "*\\/"));
     // Collect type names used in method signatures for the import statement
     const importedTypes = new Set();
     const methods = [];
@@ -37,7 +43,11 @@ export function generateOperations(outFile, compiled) {
             importedTypes.add(inTypeName);
         if (outTypeName)
             importedTypes.add(outTypeName);
-        methods.push(`  ${op.name}(\n` +
+        const docLines = op.doc ? normalizeDocLines(op.doc) : [];
+        const docBlock = docLines.length > 0
+            ? `  /**\n${docLines.map(line => `   * ${line}`).join("\n")}\n   */\n`
+            : "";
+        methods.push(`${docBlock}  ${op.name}(\n` +
             `    args: ${inTs}\n` +
             `  ): Promise<{ response: ${outTs}; headers: unknown }>;\n`);
     }

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

@@ -1 +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"}
+{"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,QAyLvE"}

package/dist/client/generateTypes.js

@@ -35,6 +35,30 @@ import { error } from "../util/cli.js";
  */
 export function generateTypes(outFile, compiled) {
     const lines = [];
+    const normalizeDocLines = (text) => String(text)
+        .replace(/\r\n?/g, "\n")
+        .split("\n")
+        .map(line => line.trim())
+        .filter(Boolean)
+        .map(line => line.replace(/\*\//g, "*\\/"));
+    const emitDocBlock = (indent, docText, xsdTag) => {
+        if (!docText && !xsdTag) {
+            return;
+        }
+        lines.push(`${indent}/**`);
+        if (docText) {
+            for (const line of normalizeDocLines(docText)) {
+                lines.push(`${indent} * ${line}`);
+            }
+        }
+        if (xsdTag) {
+            if (docText) {
+                lines.push(`${indent} *`);
+            }
+            lines.push(`${indent} * @xsd ${xsdTag}`);
+        }
+        lines.push(`${indent} */`);
+    };
     // Convenience lookups
     const typeNames = new Set(compiled.types.map((t) => t.name));
     const isValidIdent = (name) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name);
@@ -45,8 +69,14 @@ export function generateTypes(outFile, compiled) {
     // sort aliases by name to ensure consistent order
     compiled.aliases.sort((a, b) => a.name.localeCompare(b.name));
     for (const a of compiled.aliases) {
-        const ann = a.jsdoc ? `/** @xsd ${a.jsdoc} */\n` : "";
-        lines.push(`${ann}export type ${a.name} = ${a.tsType};`);
+        if (a.doc) {
+            emitDocBlock("", a.doc, a.jsdoc);
+            lines.push(`export type ${a.name} = ${a.tsType};`);
+        }
+        else {
+            const ann = a.jsdoc ? `/** @xsd ${a.jsdoc} */\n` : "";
+            lines.push(`${ann}export type ${a.name} = ${a.tsType};`);
+        }
         lines.push("");
     }
     //
@@ -64,6 +94,9 @@ export function generateTypes(outFile, compiled) {
             typeNames.has(e.tsType));
         const isSimpleContentExtension = !complexBase && (t.elems?.length || 0) === 1 && valueElems.length === 1;
         const baseName = complexBase ?? (isSimpleContentExtension ? valueElems[0].tsType : undefined);
+        if (t.doc) {
+            emitDocBlock("", t.doc);
+        }
         // Header: extend base type if applicable
         if (baseName) {
             lines.push(`export interface ${t.name} extends ${baseName} {`);
@@ -108,9 +141,14 @@ export function generateTypes(outFile, compiled) {
                 type: a.declaredType,
                 use: a.use || "optional",
             };
-            const ann = `  /** @xsd ${JSON.stringify(annObj)} */`;
             lines.push("");
-            lines.push(ann);
+            if (a.doc) {
+                emitDocBlock("  ", a.doc, JSON.stringify(annObj));
+            }
+            else {
+                const ann = `  /** @xsd ${JSON.stringify(annObj)} */`;
+                lines.push(ann);
+            }
             lines.push(`  ${emitPropName(a.name)}${opt}: ${a.tsType};`);
         }
         //
@@ -153,9 +191,14 @@ export function generateTypes(outFile, compiled) {
             if ((e.name === "$value") && (1 < elementsToEmit.length)) {
                 lines.push("");
             }
-            const ann = `  /** @xsd ${JSON.stringify(annObj)} */`;
             lines.push("");
-            lines.push(ann);
+            if (e.doc) {
+                emitDocBlock("  ", e.doc, JSON.stringify(annObj));
+            }
+            else {
+                const ann = `  /** @xsd ${JSON.stringify(annObj)} */`;
+                lines.push(ann);
+            }
             lines.push(`  ${emitPropName(e.name)}${opt}: ${e.tsType}${arr};`);
         }
         lines.push("}");

package/dist/compiler/schemaCompiler.d.ts

@@ -43,6 +43,7 @@ export type CompiledType = {
         tsType: string;
         use?: "required" | "optional";
         declaredType: string;
+        doc?: string;
     }>;
     elems: Array<{
         name: string;
@@ -51,14 +52,17 @@ export type CompiledType = {
         max: number | "unbounded";
         nillable?: boolean;
         declaredType: string;
+        doc?: string;
     }>;
     jsdoc?: string;
+    doc?: string;
     base?: string;
     localAttrs?: Array<{
         name: string;
         tsType: string;
         use?: "required" | "optional";
         declaredType: string;
+        doc?: string;
     }>;
     localElems?: Array<{
         name: string;
@@ -67,6 +71,7 @@ export type CompiledType = {
         max: number | "unbounded";
         nillable?: boolean;
         declaredType: string;
+        doc?: string;
     }>;
 };
 /**
@@ -85,6 +90,7 @@ export type CompiledAlias = {
     tsType: string;
     declared: string;
     jsdoc?: string;
+    doc?: string;
 };
 /**
  * Complete compiled catalog with all types, aliases, operations and metadata
@@ -117,6 +123,7 @@ export type CompiledCatalog = {
         security?: string[];
         inputTypeName?: string;
         outputTypeName?: string;
+        doc?: string;
     }>;
     wsdlTargetNS: string;
     wsdlUri: string;

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

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

package/dist/compiler/schemaCompiler.js

@@ -92,6 +92,57 @@ function collectSecurityFromPolicyNodes(policyNodes) {
         visit(p);
     return Array.from(found);
 }
+function extractNodeText(node) {
+    if (node == null) {
+        return "";
+    }
+    if (typeof node === "string" || typeof node === "number" || typeof node === "boolean") {
+        return String(node);
+    }
+    if (Array.isArray(node)) {
+        return node.map(extractNodeText).join(" ");
+    }
+    if (typeof node === "object") {
+        const parts = [];
+        if (node["#text"] != null) {
+            parts.push(extractNodeText(node["#text"]));
+        }
+        for (const [k, v] of Object.entries(node)) {
+            if ("#text" === k || k.startsWith("@_")) {
+                continue;
+            }
+            parts.push(extractNodeText(v));
+        }
+        return parts.join(" ");
+    }
+    return "";
+}
+function normalizeDocText(text) {
+    const compact = text
+        .replace(/\r\n?/g, "\n")
+        .split("\n")
+        .map(line => line.trim())
+        .filter(Boolean)
+        .join(" ")
+        .replace(/\s+/g, " ")
+        .trim();
+    return compact || undefined;
+}
+function extractDirectDocumentation(node) {
+    const docs = getChildrenWithLocalName(node, "documentation");
+    const merged = docs
+        .map(extractNodeText)
+        .join(" ");
+    return normalizeDocText(merged);
+}
+function extractAnnotationDocumentation(node) {
+    const annotations = getChildrenWithLocalName(node, "annotation");
+    const docs = annotations.flatMap(a => getChildrenWithLocalName(a, "documentation"));
+    const merged = docs
+        .map(extractNodeText)
+        .join(" ");
+    return normalizeDocText(merged);
+}
 /**
  * Compile a WSDL catalog into an internal representation (CompiledCatalog).
  * Steps:
@@ -172,7 +223,14 @@ export function compileCatalog(cat, options) {
             return present;
         }
         const { tsType, declared, jsdoc } = compileSimpleTypeNode(sNode, schemaNS, prefixes);
-        const alias = { name: pascal(name), ns: schemaNS, tsType, declared, jsdoc };
+        const alias = {
+            name: pascal(name),
+            ns: schemaNS,
+            tsType,
+            declared,
+            jsdoc,
+            doc: extractAnnotationDocumentation(sNode),
+        };
         aliasMap.set(key, alias);
         return alias;
     }
@@ -221,6 +279,7 @@ export function compileCatalog(cat, options) {
         }
         inProgress.add(rawKey);
         const outName = pascal(name);
+        const typeDoc = extractAnnotationDocumentation(cnode);
         const key = `${schemaNS}|${outName}`;
         // hoisted helpers for merging and collecting
         const mergeAttrs = (into, list) => {
@@ -267,7 +326,8 @@ export function compileCatalog(cat, options) {
                         name: an,
                         tsType: r.tsType,
                         use: a["@_use"] === "required" ? "required" : "optional",
-                        declaredType: r.declared
+                        declaredType: r.declared,
+                        doc: extractAnnotationDocumentation(a),
                     });
                 }
                 else {
@@ -279,7 +339,8 @@ export function compileCatalog(cat, options) {
                         name: an,
                         tsType: r.tsType,
                         use: a["@_use"] === "required" ? "required" : "optional",
-                        declaredType: r.declared
+                        declaredType: r.declared,
+                        doc: extractAnnotationDocumentation(a),
                     });
                 }
             }
@@ -310,18 +371,35 @@ export function compileCatalog(cat, options) {
                             min,
                             max,
                             nillable,
-                            declaredType: `{${schemaNS}}${rec.name}`
+                            declaredType: `{${schemaNS}}${rec.name}`,
+                            doc: extractAnnotationDocumentation(e),
                         });
                     }
                     else if (inlineSimple) {
                         const r = compileSimpleTypeNode(inlineSimple, schemaNS, prefixes);
-                        out.push({ name: propName || nameOrRef, tsType: r.tsType, min, max, nillable, declaredType: r.declared });
+                        out.push({
+                            name: propName || nameOrRef,
+                            tsType: r.tsType,
+                            min,
+                            max,
+                            nillable,
+                            declaredType: r.declared,
+                            doc: extractAnnotationDocumentation(e),
+                        });
                     }
                     else {
                         const t = e["@_type"] || e["@_ref"];
                         const q = t ? resolveQName(t, schemaNS, prefixes) : { ns: XS, local: "string" };
                         const r = resolveTypeRef(q, schemaNS, prefixes);
-                        out.push({ name: propName || nameOrRef, tsType: r.tsType, min, max, nillable, declaredType: r.declared });
+                        out.push({
+                            name: propName || nameOrRef,
+                            tsType: r.tsType,
+                            min,
+                            max,
+                            nillable,
+                            declaredType: r.declared,
+                            doc: extractAnnotationDocumentation(e),
+                        });
                     }
                 }
                 // recurse into nested compositor groups
@@ -341,6 +419,9 @@ export function compileCatalog(cat, options) {
             const newElems = collectParticles(outName, cnode);
             mergeAttrs(present.attrs, newAttrs);
             mergeElems(present.elems, newElems);
+            if (!present.doc && typeDoc) {
+                present.doc = typeDoc;
+            }
             // Remove from inProgress since we're done with this cycle
             inProgress.delete(rawKey);
             return present;
@@ -379,6 +460,7 @@ export function compileCatalog(cat, options) {
                     ns: schemaNS,
                     attrs,
                     elems,
+                    doc: typeDoc,
                     base: baseName,
                     localAttrs: locals,
                     localElems
@@ -409,7 +491,7 @@ export function compileCatalog(cat, options) {
                         declaredType: r.declared,
                     }]);
                 mergeAttrs(attrs, collectAttributes(scNode));
-                const result = { name: outName, ns: schemaNS, attrs, elems };
+                const result = { name: outName, ns: schemaNS, attrs, elems, doc: typeDoc };
                 compiledMap.set(key, result);
                 inProgress.delete(rawKey);
                 return result;
@@ -424,7 +506,7 @@ export function compileCatalog(cat, options) {
         // Attributes + particles
         mergeAttrs(attrs, collectAttributes(cnode));
         mergeElems(elems, collectParticles(outName, cnode));
-        const result = { name: outName, ns: schemaNS, attrs, elems };
+        const result = { name: outName, ns: schemaNS, attrs, elems, doc: typeDoc };
         compiledMap.set(key, result);
         inProgress.delete(rawKey);
         return result;
@@ -432,6 +514,7 @@ export function compileCatalog(cat, options) {
     // Helper: compile a global element into a surface type (wrapper)
     function compileElementAsType(name, enode, schemaNS, prefixes) {
         const outName = pascal(name);
+        const elementDoc = extractAnnotationDocumentation(enode);
         const key = `${schemaNS}|${outName}`;
         const present = compiledMap.get(key);
         if (present)
@@ -448,6 +531,7 @@ export function compileCatalog(cat, options) {
                 ns: schemaNS,
                 attrs: [],
                 elems: [{ name: "$value", tsType: r.tsType, min: 0, max: 1, nillable: false, declaredType: r.declared }],
+                doc: elementDoc,
             };
             compiledMap.set(key, t);
             return t;
@@ -470,6 +554,7 @@ export function compileCatalog(cat, options) {
                             nillable: false,
                             declaredType: label
                         }],
+                    doc: elementDoc,
                 };
                 compiledMap.set(key, t);
                 return t;
@@ -485,10 +570,13 @@ export function compileCatalog(cat, options) {
                     const existingAlias = aliasMap.get(aliasKey);
                     const declared = `{${base.ns}}${base.name}`;
                     if (!existingAlias) {
-                        aliasMap.set(aliasKey, { name: outName, ns: schemaNS, tsType: base.name, declared });
+                        aliasMap.set(aliasKey, { name: outName, ns: schemaNS, tsType: base.name, declared, doc: elementDoc });
                     }
                     else {
                         // if an alias exists but points elsewhere, keep the first one (stable) and ignore
+                        if (!existingAlias.doc && elementDoc) {
+                            existingAlias.doc = elementDoc;
+                        }
                     }
                 }
                 // Return base so callers have a CompiledType, but do not duplicate in compiledMap for wrapper
@@ -509,13 +597,14 @@ export function compileCatalog(cat, options) {
                             nillable: false,
                             declaredType: `{${a.ns}}${q.local}`
                         }],
+                    doc: elementDoc,
                 };
                 compiledMap.set(key, t);
                 return t;
             }
         }
         // default empty wrapper
-        const t = { name: outName, ns: schemaNS, attrs: [], elems: [] };
+        const t = { name: outName, ns: schemaNS, attrs: [], elems: [], doc: elementDoc };
         compiledMap.set(key, t);
         return t;
     }
@@ -652,10 +741,11 @@ export function compileCatalog(cat, options) {
         const outMsg = findMessage(getFirstWithLocalName(po, "output")?.["@_message"]);
         const inputElement = elementOfMessage(inMsg);
         const outputElement = elementOfMessage(outMsg);
+        const doc = extractDirectDocumentation(po);
         // 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 };
+        return { name, soapAction: bOps.get(name) || "", inputElement, outputElement, inputTypeName, outputTypeName, doc };
     })
         .filter((x) => x != null));
     // --- WS-Policy: scan for security requirements (inline policies only) ---

package/dist/openapi/generatePaths.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generatePaths.d.ts","sourceRoot":"","sources":["../../src/openapi/generatePaths.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,+BAA+B,CAAC;AACnE,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,aAAa,CAAC;AAG3C;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,gBAAgB;IAC/B,CAAC,MAAM,EAAE,MAAM,GAAG;QAChB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,UAAU,CAAC,EAAE,OAAO,CAAC;QACrB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,WAAW,CAAC,EAAE,MAAM,CAAC;KACtB,CAAC;CACH;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,eAAe;IAE9B,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;CAC1B;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,SAAS,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,EAAE,eAAe,CAAC;IAC1B,SAAS,CAAC,EAAE,gBAAgB,CAAC;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,EAAE,GAAG,SAAS,CAAC,CAAC;IAC9C,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;CAC9C;AAED,wBAAgB,aAAa,CAAC,QAAQ,EAAE,eAAe,EAAE,IAAI,EAAE,oBAAoB,uBAyDlF"}
+{"version":3,"file":"generatePaths.d.ts","sourceRoot":"","sources":["../../src/openapi/generatePaths.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,+BAA+B,CAAC;AACnE,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,aAAa,CAAC;AAG3C;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,gBAAgB;IAC/B,CAAC,MAAM,EAAE,MAAM,GAAG;QAChB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,UAAU,CAAC,EAAE,OAAO,CAAC;QACrB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,WAAW,CAAC,EAAE,MAAM,CAAC;KACtB,CAAC;CACH;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,eAAe;IAE9B,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;CAC1B;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,SAAS,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,EAAE,eAAe,CAAC;IAC1B,SAAS,CAAC,EAAE,gBAAgB,CAAC;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,EAAE,GAAG,SAAS,CAAC,CAAC;IAC9C,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;CAC9C;AAED,wBAAgB,aAAa,CAAC,QAAQ,EAAE,eAAe,EAAE,IAAI,EAAE,oBAAoB,uBA6DlF"}

package/dist/openapi/generatePaths.js

@@ -42,8 +42,12 @@ export function generatePaths(compiled, opts) {
         };
         if (override.summary)
             operationObject.summary = override.summary;
-        if (override.description)
+        if (override.description) {
             operationObject.description = override.description;
+        }
+        else if (op.doc) {
+            operationObject.description = op.doc;
+        }
         if (override.deprecated)
             operationObject.deprecated = true;
         if (parameters.length)

package/dist/openapi/generateSchemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generateSchemas.d.ts","sourceRoot":"","sources":["../../src/openapi/generateSchemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,EAAgB,eAAe,EAAe,MAAM,+BAA+B,CAAC;AAEhG;;;;;;GAMG;AACH,MAAM,WAAW,sBAAsB;IACrC,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC;AAED,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AAwIpD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,eAAe,EAAE,IAAI,EAAE,sBAAsB,GAAG,iBAAiB,CA+C1G"}
+{"version":3,"file":"generateSchemas.d.ts","sourceRoot":"","sources":["../../src/openapi/generateSchemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,EAAgB,eAAe,EAAe,MAAM,+BAA+B,CAAC;AAEhG;;;;;;GAMG;AACH,MAAM,WAAW,sBAAsB;IACrC,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC;AAED,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AAgKpD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,eAAe,EAAE,IAAI,EAAE,sBAAsB,GAAG,iBAAiB,CA+C1G"}

package/dist/openapi/generateSchemas.js

@@ -28,14 +28,24 @@ function primitiveSchema(ts) {
 function buildAliasSchema(a) {
     const lit = isLiteralUnion(a.tsType);
     if (lit) {
-        return { type: "string", enum: lit };
+        return {
+            type: "string",
+            enum: lit,
+            ...(a.doc ? { description: a.doc } : {}),
+        };
     }
     // If alias wraps primitive
     if (["string", "number", "boolean", "any"].includes(a.tsType) || a.tsType.endsWith("[]")) {
-        return primitiveSchema(a.tsType);
+        return {
+            ...primitiveSchema(a.tsType),
+            ...(a.doc ? { description: a.doc } : {}),
+        };
     }
     // alias of another complex/alias type -> allOf wrapper preserves name
-    return { allOf: [{ $ref: `#/components/schemas/${a.tsType}` }] };
+    return {
+        allOf: [{ $ref: `#/components/schemas/${a.tsType}` }],
+        ...(a.doc ? { description: a.doc } : {}),
+    };
 }
 function isArrayWrapper(t) {
     if (t.attrs.length !== 0)
@@ -80,13 +90,21 @@ function buildComplexSchema(t, closed, knownTypeNames, aliasNames, flattenWrappe
     const arrayWrap = flattenWrappers ? isArrayWrapper(t) : null;
     if (arrayWrap) {
         const item = refOrPrimitive(String(arrayWrap.itemType));
-        return { type: "array", items: item };
+        return {
+            type: "array",
+            items: item,
+            ...(t.doc ? { description: t.doc } : {}),
+        };
     }
     const properties = {};
     const required = [];
     // attributes
     for (const a of t.attrs) {
-        properties[a.name] = refOrPrimitive(a.tsType);
+        const propSchema = refOrPrimitive(a.tsType);
+        if (a.doc) {
+            propSchema.description = a.doc;
+        }
+        properties[a.name] = propSchema;
         if (a.use === "required")
             required.push(a.name);
     }
@@ -100,6 +118,9 @@ function buildComplexSchema(t, closed, knownTypeNames, aliasNames, flattenWrappe
         if (e.nillable) {
             schema = { anyOf: [schema, { type: "null" }] };
         }
+        if (e.doc) {
+            schema.description = e.doc;
+        }
         properties[e.name] = schema;
         if (e.name === "$value") {
             // never required
@@ -130,6 +151,9 @@ function buildComplexSchema(t, closed, knownTypeNames, aliasNames, flattenWrappe
         if (!closed)
             delete obj.additionalProperties; // put closed only on leaf part
     }
+    if (t.doc) {
+        obj.description = t.doc;
+    }
     return obj;
 }
 /**

package/docs/architecture.md

@@ -83,6 +83,8 @@ CompiledCatalog {
 }
 ```
 
+`CompiledType`, type aliases, and operations may include optional `doc` fields populated from WSDL/XSD documentation nodes. Client emitters consume these values to generate comments in `types.ts`, `operations.ts`, and `client.ts`. OpenAPI emitters consume the same fields for schema, property, and operation `description` values.
+
 Data flow through the pipeline:
 
 1. schemaCompiler produces CompiledCatalog from WSDL XML

package/docs/concepts.md

@@ -67,6 +67,8 @@ cacheable, and reused across client, OpenAPI, and gateway generation.
 Inspect types, operations, and metadata as plain JSON. The catalog is
 automatically placed alongside generated output.
 
+The catalog stores optional human-readable `doc` fields extracted from WSDL/XSD documentation nodes. These fields are additive metadata used by TypeScript and OpenAPI emitters and do not change runtime behavior.
+
 ### Catalog Locations by Command
 
 | Command | Location |

package/docs/generated-code.md

@@ -73,6 +73,34 @@ result.GetCityWeatherByZIPResult.Temperature;
 
 Autocomplete and type checking work across all generated interfaces.
 
+## Documentation Comments
+
+Generated `types.ts`, `operations.ts`, and `client.ts` include source documentation when present in WSDL/XSD.
+
+`wsdl:documentation` on operations is emitted as method comments in `operations.ts` and `client.ts`. `xs:annotation/xs:documentation` on complex types, attributes, and elements is emitted as comments in `types.ts`.
+
+```typescript
+/**
+ * Thing payload.
+ */
+export interface Thing {
+  /**
+   * Display name.
+   *
+   * @xsd {"kind":"element","type":"xs:string","occurs":{"min":1,"max":1,"nillable":false}}
+   */
+  name: string;
+}
+```
+
+The existing `@xsd` metadata annotations are preserved for runtime marshaling and tooling.
+
+OpenAPI generation also propagates these docs into `description` fields:
+
+- Operation descriptions come from `wsdl:documentation` by default
+- `--openapi-ops-file` `description` overrides operation documentation when provided
+- Schema and property descriptions come from `xs:annotation/xs:documentation`
+
 ## Gateway Route Handlers
 
 When generating a Fastify gateway (`--gateway-dir`), each SOAP operation gets a fully typed route handler. The handler imports the request type from the client, uses Fastify's `Body: T` generic for type inference, and wraps the SOAP response in a standard envelope.
@@ -99,9 +127,9 @@ export async function registerRoute_v1_weather_getcityforecastbyzip(fastify: Fas
 
 Key features of the generated handlers:
 
-- **`Body: T` generic** — Fastify infers `request.body` type from the route generic, enabling IDE autocomplete and compile-time checks
-- **JSON Schema validation** — the `schema` import provides Fastify with request/response validation at runtime, before the handler runs
-- **Envelope wrapping** — `buildSuccessEnvelope()` wraps the raw SOAP response in the standard `{ status, message, data, error }` envelope
+- `Body: T` generic: Fastify infers `request.body` type from the route generic, enabling IDE autocomplete and compile-time checks
+- JSON Schema validation: the `schema` import provides Fastify with request/response validation at runtime, before the handler runs
+- Envelope wrapping: `buildSuccessEnvelope()` wraps the raw SOAP response in the standard `{ status, message, data, error }` envelope
 
 See [Gateway Guide](gateway-guide.md) for the full architecture and [CLI Reference](cli-reference.md) for generation flags.
 

package/docs/testing.md

@@ -8,9 +8,9 @@ See [README](../README.md) for quick start and [CONTRIBUTING](../CONTRIBUTING.md
 
 The project uses three layers of testing:
 
-1. **Unit tests** — Pure function tests for utilities, parsers, and type mapping
-2. **Snapshot tests** — Baseline comparisons for all generated pipeline output
-3. **Integration tests** — End-to-end gateway tests using Fastify's `inject()` with mock clients
+1. Unit tests: Pure function tests for utilities, parsers, and type mapping
+2. Snapshot tests: Baseline comparisons for all generated pipeline output
+3. Integration tests: End-to-end gateway tests using Fastify's `inject()` with mock clients
 
 All tests use [Vitest](https://vitest.dev/) and run in under 3 seconds.
 
@@ -34,12 +34,13 @@ npm run ci
 
 Unit tests cover pure functions with no I/O or side effects:
 
-- **`tools.test.ts`** — `pascal()`, `resolveQName()`, `explodePascal()`, `pascalToSnakeCase()`, `normalizeArray()`, `getChildrenWithLocalName()`, `getFirstWithLocalName()`
-- **`casing.test.ts`** — `toPathSegment()` with kebab, asis, and lower styles
-- **`primitives.test.ts`** — `xsdToTsPrimitive()` covering all XSD types (string-like, boolean, integers, decimals, floats, dates, any)
-- **`errors.test.ts`** — `WsdlCompilationError` construction and `toUserMessage()` formatting
-- **`schema-alignment.test.ts`** — Cross-validates TypeScript types, JSON schemas, and catalog.json for consistency
-- **`mock-data.test.ts`** — `generateMockPrimitive()`, `generateMockData()`, `generateAllOperationMocks()` with cycle detection and array wrapping
+- `tools.test.ts`: `pascal()`, `resolveQName()`, `explodePascal()`, `pascalToSnakeCase()`, `normalizeArray()`, `getChildrenWithLocalName()`, `getFirstWithLocalName()`
+- `casing.test.ts`: `toPathSegment()` with kebab, asis, and lower styles
+- `primitives.test.ts`: `xsdToTsPrimitive()` covering all XSD types (string-like, boolean, integers, decimals, floats, dates, any)
+- `errors.test.ts`: `WsdlCompilationError` construction and `toUserMessage()` formatting
+- `schema-alignment.test.ts`: Cross-validates TypeScript types, JSON schemas, and catalog.json for consistency
+- `mock-data.test.ts`: `generateMockPrimitive()`, `generateMockData()`, `generateAllOperationMocks()` with cycle detection and array wrapping
+- `wsdl-documentation.test.ts`: verifies doc flow to catalog, generated TS comments, and OpenAPI descriptions with override precedence
 
 ### Writing Unit Tests
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@techspokes/typescript-wsdl-client",
-  "version": "0.11.6",
+  "version": "0.13.0",
   "description": "Generate type-safe TypeScript SOAP clients, OpenAPI 3.1 specs, and production-ready Fastify REST gateways from WSDL/XSD definitions.",
   "keywords": [
     "wsdl",
@@ -76,20 +76,20 @@
   },
   "devDependencies": {
     "@types/js-yaml": "^4.0.9",
-    "@types/node": "^25.2.0",
+    "@types/node": "^25.3.3",
     "@types/yargs": "^17.0.35",
-    "fastify": "^5.7.0",
+    "fastify": "^5.7.4",
     "fastify-plugin": "^5.1.0",
-    "rimraf": "^6.1.0",
+    "rimraf": "^6.1.3",
     "tsx": "^4.21.0",
-    "typescript": "^5.9.0",
+    "typescript": "^5.9.3",
     "vitest": "^4.0.18"
   },
   "dependencies": {
     "@apidevtools/swagger-parser": "^12.1.0",
-    "fast-xml-parser": "^5.3.0",
+    "fast-xml-parser": "^5.4.2",
     "js-yaml": "^4.1.1",
-    "soap": "^1.6.0",
+    "soap": "^1.7.1",
     "yargs": "^18.0.0"
   },
   "funding": {