@testsmith/api-spector 0.2.3 → 0.2.5

package/out/main/chunks/soap-handler-Cpj-JwyA.js

@@ -0,0 +1,326 @@
+"use strict";
+const https = require("https");
+const http = require("http");
+const xmldom = require("@xmldom/xmldom");
+function fetchUrl(url, headers = {}) {
+  return new Promise((resolveP, rejectP) => {
+    const lib = url.startsWith("https") ? https : http;
+    const req = lib.get(url, { headers }, (res) => {
+      const chunks = [];
+      res.on("data", (chunk) => chunks.push(chunk));
+      res.on("end", () => resolveP(Buffer.concat(chunks).toString("utf8")));
+      res.on("error", rejectP);
+    });
+    req.on("error", rejectP);
+    req.setTimeout(15e3, () => {
+      req.destroy();
+      rejectP(new Error("WSDL fetch timed out"));
+    });
+  });
+}
+const NS_SOAP = "http://schemas.xmlsoap.org/wsdl/soap/";
+const NS_SOAP12 = "http://schemas.xmlsoap.org/wsdl/soap12/";
+function isElement(node) {
+  return node.nodeType === 1;
+}
+function nodeListToArray(list) {
+  if (!list || typeof list.length !== "number") return [];
+  const out = [];
+  for (let i = 0; i < list.length; i++) out.push(list[i]);
+  return out;
+}
+function children(node) {
+  return nodeListToArray(node.childNodes).filter(isElement);
+}
+function childrenByLocalName(node, localName) {
+  return children(node).filter((c) => (c.localName ?? c.tagName) === localName);
+}
+function descendantsByLocalName(node, localName) {
+  const out = [];
+  const stack = [node];
+  while (stack.length) {
+    const cur = stack.pop();
+    for (const c of nodeListToArray(cur.childNodes)) {
+      if (isElement(c)) {
+        if ((c.localName ?? c.tagName) === localName) out.push(c);
+        stack.push(c);
+      }
+    }
+  }
+  return out;
+}
+function attr(node, name) {
+  const v = node.getAttribute?.(name);
+  return v == null || v === "" ? void 0 : v;
+}
+function localOfQName(q) {
+  const i = q.indexOf(":");
+  return i === -1 ? q : q.slice(i + 1);
+}
+function indexSchema(definitions) {
+  const idx = /* @__PURE__ */ new Map();
+  for (const types of childrenByLocalName(definitions, "types")) {
+    for (const schema of childrenByLocalName(types, "schema")) {
+      for (const el of childrenByLocalName(schema, "element")) {
+        const n = attr(el, "name");
+        if (n) idx.set(n, el);
+      }
+      for (const ct of childrenByLocalName(schema, "complexType")) {
+        const n = attr(ct, "name");
+        if (n) idx.set("__type__:" + n, ct);
+      }
+    }
+  }
+  return idx;
+}
+function resolveComplexType(el, schemaIdx) {
+  const inlineCt = childrenByLocalName(el, "complexType")[0];
+  if (inlineCt) return inlineCt;
+  const typeAttr = attr(el, "type");
+  if (typeAttr) {
+    const local = localOfQName(typeAttr);
+    const named = schemaIdx.get("__type__:" + local);
+    if (named) return named;
+    return null;
+  }
+  return null;
+}
+function buildParams(complexType, schemaIdx, depth = 0) {
+  if (depth > 5) return [];
+  const params = [];
+  const containers = ["sequence", "all", "choice"].flatMap((n) => childrenByLocalName(complexType, n));
+  for (const container of containers) {
+    for (const childEl of childrenByLocalName(container, "element")) {
+      const name = attr(childEl, "name") ?? attr(childEl, "ref");
+      if (!name) continue;
+      const local = localOfQName(name);
+      const typeAttr = attr(childEl, "type");
+      let typeHint = "string";
+      if (typeAttr) typeHint = localOfQName(typeAttr);
+      const nested = resolveComplexType(childEl, schemaIdx);
+      if (nested) {
+        params.push({ name: local, typeHint: "complex", children: buildParams(nested, schemaIdx, depth + 1) });
+      } else {
+        params.push({ name: local, typeHint });
+      }
+    }
+  }
+  return params;
+}
+function indent(level) {
+  return "  ".repeat(level);
+}
+function renderParams(params, level) {
+  return params.map((p) => {
+    if (p.children && p.children.length) {
+      return `${indent(level)}<tns:${p.name}>
+${renderParams(p.children, level + 1)}
+${indent(level)}</tns:${p.name}>`;
+    }
+    return `${indent(level)}<tns:${p.name}><!-- ${p.typeHint} --></tns:${p.name}>`;
+  }).join("\n");
+}
+function buildEnvelopeTemplate(operationName, namespace, params = [], soapVersion = "1.1") {
+  const envNs = soapVersion === "1.2" ? "http://www.w3.org/2003/05/soap-envelope" : "http://schemas.xmlsoap.org/soap/envelope/";
+  const body = params.length ? `
+${renderParams(params, 3)}
+    ` : `
+      <!-- Add parameters here -->
+    `;
+  return `<?xml version="1.0" encoding="utf-8"?>
+<soap:Envelope
+  xmlns:soap="${envNs}"
+  xmlns:tns="${namespace}">
+  <soap:Header/>
+  <soap:Body>
+    <tns:${operationName}>${body}</tns:${operationName}>
+  </soap:Body>
+</soap:Envelope>`;
+}
+function parseWsdl(wsdlText) {
+  let doc;
+  try {
+    doc = new xmldom.DOMParser().parseFromString(wsdlText, "text/xml");
+  } catch (err) {
+    throw new Error(`WSDL parse failed: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  const definitions = childrenByLocalName(doc, "definitions")[0] ?? descendantsByLocalName(doc, "definitions")[0];
+  if (!definitions) {
+    return { targetNamespace: "", endpoints: [], operations: [] };
+  }
+  const targetNamespace = attr(definitions, "targetNamespace") ?? "";
+  const schemaIdx = indexSchema(definitions);
+  const portTypeInputs = {};
+  for (const pt of childrenByLocalName(definitions, "portType")) {
+    for (const op of childrenByLocalName(pt, "operation")) {
+      const name = attr(op, "name");
+      if (!name) continue;
+      const inputEl = childrenByLocalName(op, "input")[0];
+      portTypeInputs[name] = inputEl ? attr(inputEl, "message") : void 0;
+    }
+  }
+  const messageElements = {};
+  for (const msg of childrenByLocalName(definitions, "message")) {
+    const name = attr(msg, "name");
+    if (!name) continue;
+    const part = childrenByLocalName(msg, "part")[0];
+    if (!part) continue;
+    messageElements[name] = attr(part, "element");
+  }
+  const bindings = [];
+  for (const binding of childrenByLocalName(definitions, "binding")) {
+    const bindingName = attr(binding, "name") ?? "";
+    let soapVersion = "1.1";
+    for (const c of children(binding)) {
+      if ((c.localName ?? c.tagName) === "binding") {
+        if (c.namespaceURI === NS_SOAP12) soapVersion = "1.2";
+        else if (c.namespaceURI === NS_SOAP) soapVersion = "1.1";
+      }
+    }
+    const ops = [];
+    for (const op of childrenByLocalName(binding, "operation")) {
+      const opName = attr(op, "name");
+      if (!opName) continue;
+      let soapAction;
+      for (const c of children(op)) {
+        if ((c.localName ?? c.tagName) === "operation" && (c.namespaceURI === NS_SOAP || c.namespaceURI === NS_SOAP12)) {
+          soapAction = attr(c, "soapAction");
+        }
+      }
+      ops.push({ name: opName, soapAction });
+    }
+    bindings.push({ name: bindingName, soapVersion, operations: ops });
+  }
+  const endpoints = [];
+  for (const svc of childrenByLocalName(definitions, "service")) {
+    for (const port of childrenByLocalName(svc, "port")) {
+      const bindingRef = attr(port, "binding");
+      if (!bindingRef) continue;
+      let address;
+      let addrVersion = "1.1";
+      for (const c of children(port)) {
+        if ((c.localName ?? c.tagName) === "address") {
+          address = attr(c, "location");
+          if (c.namespaceURI === NS_SOAP12) addrVersion = "1.2";
+        }
+      }
+      if (address) {
+        endpoints.push({ binding: localOfQName(bindingRef), address, soapVersion: addrVersion });
+      }
+    }
+  }
+  const operations = [];
+  const seenOpNames = /* @__PURE__ */ new Set();
+  for (const binding of bindings) {
+    const endpoint = endpoints.find((e) => e.binding === binding.name)?.address;
+    for (const op of binding.operations) {
+      if (seenOpNames.has(op.name + "@" + binding.name)) continue;
+      seenOpNames.add(op.name + "@" + binding.name);
+      const messageQName = portTypeInputs[op.name];
+      const messageLocal = messageQName ? localOfQName(messageQName) : void 0;
+      const elementQName = messageLocal ? messageElements[messageLocal] : void 0;
+      const elementLocal = elementQName ? localOfQName(elementQName) : op.name;
+      const schemaEl = schemaIdx.get(elementLocal);
+      let params = [];
+      if (schemaEl) {
+        const ct = resolveComplexType(schemaEl, schemaIdx);
+        if (ct) params = buildParams(ct, schemaIdx);
+      }
+      operations.push({
+        name: op.name,
+        binding: binding.name,
+        soapAction: op.soapAction,
+        soapVersion: binding.soapVersion,
+        endpoint,
+        inputTemplate: buildEnvelopeTemplate(elementLocal, targetNamespace, params, binding.soapVersion),
+        params
+      });
+    }
+  }
+  if (operations.length === 0) {
+    const regex = /<(?:wsdl:)?operation\s+name\s*=\s*["']([^"']+)["']/g;
+    const seen = /* @__PURE__ */ new Set();
+    let m;
+    while ((m = regex.exec(wsdlText)) !== null) seen.add(m[1]);
+    const soapActionByName = {};
+    const blockRx = /<(?:wsdl:)?operation\s+name\s*=\s*["']([^"']+)["'][^>]*>([\s\S]*?)<\/(?:wsdl:)?operation>/g;
+    while ((m = blockRx.exec(wsdlText)) !== null) {
+      const sa = m[2].match(/soapAction\s*=\s*["']([^"']*)["']/);
+      if (sa) soapActionByName[m[1]] = sa[1];
+    }
+    for (const name of seen) {
+      operations.push({
+        name,
+        soapAction: soapActionByName[name],
+        soapVersion: "1.1",
+        inputTemplate: buildEnvelopeTemplate(name, targetNamespace, [], "1.1"),
+        params: []
+      });
+    }
+  }
+  return { targetNamespace, endpoints, operations };
+}
+function buildResponseEnvelope(operationName, namespace, soapVersion = "1.1") {
+  const envNs = soapVersion === "1.2" ? "http://www.w3.org/2003/05/soap-envelope" : "http://schemas.xmlsoap.org/soap/envelope/";
+  return `<?xml version="1.0" encoding="utf-8"?>
+<soap:Envelope
+  xmlns:soap="${envNs}"
+  xmlns:tns="${namespace}">
+  <soap:Body>
+    <tns:${operationName}Response>
+      <tns:${operationName}Result><!-- replace with mock value --></tns:${operationName}Result>
+    </tns:${operationName}Response>
+  </soap:Body>
+</soap:Envelope>`;
+}
+function buildMockDispatchScript(_opMap) {
+  return `// Auto-generated by Import WSDL — dispatches per SOAP operation.
+// Envelopes come from route metadata.soapEnvelopes (set by the WSDL importer).
+const envelopes = (metadata && metadata.soapEnvelopes) || {};
+const ct = (metadata && metadata.soapVersion === '1.2')
+  ? 'application/soap+xml; charset=utf-8'
+  : 'text/xml; charset=utf-8';
+
+const headers = request.headers || {};
+const sa      = String(headers['soapaction'] || headers['SOAPAction'] || '').replace(/"/g, '');
+const body    = request.body || '';
+
+let opName = null;
+for (const k of Object.keys(envelopes)) {
+  if (sa && (sa === k || sa.endsWith('/' + k) || sa.endsWith(':' + k))) { opName = k; break; }
+  if (body.indexOf('<' + k + ' ') !== -1 || body.indexOf('<' + k + '>') !== -1
+      || body.indexOf(':' + k + ' ') !== -1 || body.indexOf(':' + k + '>') !== -1) {
+    opName = k; break;
+  }
+}
+
+response.headers['Content-Type'] = ct;
+if (opName) {
+  response.statusCode = 200;
+  response.body       = envelopes[opName];
+} else {
+  response.statusCode = 500;
+  response.body = '<?xml version="1.0"?><soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"><soap:Body><soap:Fault><faultstring>Unknown SOAP operation</faultstring></soap:Fault></soap:Body></soap:Envelope>';
+}
+`;
+}
+function registerSoapHandlers(ipc) {
+  ipc.handle("wsdl:fetch", async (_event, url, extraHeaders = {}) => {
+    const { validateWsdlFetchUrl } = await Promise.resolve().then(() => require("./ipc-validate-CscN4HfG.js"));
+    validateWsdlFetchUrl(url);
+    const wsdlText = await fetchUrl(url, extraHeaders);
+    return parseWsdl(wsdlText);
+  });
+  ipc.handle("wsdl:import", async (_event, opts) => {
+    const { validateWsdlImport } = await Promise.resolve().then(() => require("./ipc-validate-CscN4HfG.js"));
+    validateWsdlImport(opts);
+    const { importWsdl } = await Promise.resolve().then(() => require("./import-C9qdkBCH.js"));
+    const wsdlText = opts.xml ?? (opts.url ? await fetchUrl(opts.url) : "");
+    if (!wsdlText) throw new Error("wsdl:import requires either `url` or `xml`");
+    return importWsdl(wsdlText, { name: opts.name, existingMockPorts: opts.existingMockPorts });
+  });
+}
+exports.buildMockDispatchScript = buildMockDispatchScript;
+exports.buildResponseEnvelope = buildResponseEnvelope;
+exports.parseWsdl = parseWsdl;
+exports.registerSoapHandlers = registerSoapHandlers;