@testsmith/api-spector 0.2.2 → 0.2.4

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;

package/out/main/contract.js

@@ -0,0 +1,210 @@
+#!/usr/bin/env node
+"use strict";
+const promises = require("fs/promises");
+const path = require("path");
+const snapshots = require("./chunks/snapshots-C7YbGHM7.js");
+const os = require("os");
+const crypto = require("crypto");
+require("undici");
+require("js-yaml");
+require("ajv");
+require("./chunks/auth-builder-B7-LgcGr.js");
+require("dayjs");
+require("vm");
+function parseArgs(argv) {
+  const args = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      const next = argv[i + 1];
+      if (!next || next.startsWith("--")) {
+        args[key] = true;
+      } else {
+        args[key] = next;
+        i++;
+      }
+    }
+  }
+  return args;
+}
+async function resolveWorkspacePath(wsPath) {
+  const s = await promises.stat(wsPath);
+  if (!s.isDirectory()) return wsPath;
+  const entries = await promises.readdir(wsPath);
+  const spector = entries.find((e) => e.endsWith(".spector"));
+  if (!spector) throw new Error(`No .spector workspace file found in directory: ${wsPath}`);
+  return path.join(wsPath, spector);
+}
+async function loadWorkspace(wsPath) {
+  const resolved = await resolveWorkspacePath(wsPath);
+  const raw = await promises.readFile(resolved, "utf8");
+  return { workspace: JSON.parse(raw), dir: path.dirname(path.resolve(resolved)) };
+}
+async function loadCollections(ws, dir, filterName) {
+  const cols = [];
+  for (const relPath of ws.collections) {
+    try {
+      const raw = await promises.readFile(path.join(dir, relPath), "utf8");
+      const col = JSON.parse(raw);
+      if (!filterName || col.name === filterName) cols.push(col);
+    } catch {
+    }
+  }
+  return cols;
+}
+async function loadEnvironments(ws, dir) {
+  const envs = [];
+  for (const relPath of ws.environments) {
+    try {
+      envs.push(JSON.parse(await promises.readFile(path.join(dir, relPath), "utf8")));
+    } catch {
+    }
+  }
+  return envs;
+}
+async function cmdList(args) {
+  const wsArg = args["workspace"];
+  if (typeof wsArg !== "string") {
+    console.error("  [error] --workspace <path> is required");
+    process.exit(2);
+  }
+  const { workspace, dir } = await loadWorkspace(wsArg);
+  const snapshots$1 = await snapshots.listSnapshots(dir, workspace.contracts ?? []);
+  if (snapshots$1.length === 0) {
+    console.log("  No contract snapshots. Capture one from the app or via:");
+    console.log("    api-spector contract run --workspace <path> --spec-url <url> --pin");
+    return;
+  }
+  console.log("");
+  console.log("  ID       Name                                Version     Captured");
+  console.log("  ──────── ─────────────────────────────────── ─────────── ──────────────────");
+  for (const { snapshot } of snapshots$1) {
+    const id = snapshot.id.slice(0, 8);
+    const name = snapshot.name.slice(0, 35).padEnd(35);
+    const version = (snapshot.specVersion ?? "—").slice(0, 11).padEnd(11);
+    const when = snapshot.capturedAt.slice(0, 19).replace("T", " ");
+    console.log(`  ${id} ${name} ${version} ${when}`);
+  }
+  console.log("");
+  console.log("  Run against a snapshot:");
+  console.log("    api-spector contract run --workspace <path> --mode provider --snapshot <id>");
+}
+async function resolveSnapshot(ws, dir, needle) {
+  const all = await snapshots.listSnapshots(dir, ws.contracts ?? []);
+  const matches = all.filter(
+    ({ snapshot }) => snapshot.id === needle || snapshot.id.startsWith(needle) || snapshot.name === needle
+  );
+  if (matches.length === 0) throw new Error(`No snapshot matches "${needle}". Run \`api-spector contract list --workspace <path>\` to see available snapshots.`);
+  if (matches.length > 1) {
+    const ids = matches.map((m) => m.snapshot.id.slice(0, 8)).join(", ");
+    throw new Error(`Ambiguous snapshot "${needle}" matches multiple (${ids}). Use a longer id prefix.`);
+  }
+  return matches[0];
+}
+async function cmdRun(args) {
+  const wsArg = args["workspace"];
+  const mode = args["mode"];
+  if (typeof wsArg !== "string") {
+    console.error("  [error] --workspace <path> is required");
+    process.exit(2);
+  }
+  if (mode !== "consumer" && mode !== "provider" && mode !== "bidirectional") {
+    console.error("  [error] --mode must be one of: consumer, provider, bidirectional");
+    process.exit(2);
+  }
+  const { workspace, dir } = await loadWorkspace(wsArg);
+  const collectionName = typeof args["collection"] === "string" ? args["collection"] : void 0;
+  const collections = await loadCollections(workspace, dir, collectionName);
+  const envs = await loadEnvironments(workspace, dir);
+  const envName = typeof args["environment"] === "string" ? args["environment"] : void 0;
+  const activeEnv = envName ? envs.find((e) => e.name === envName) : envs[0];
+  const envVars = {};
+  for (const v of activeEnv?.variables ?? []) if (v.enabled) envVars[v.key] = v.value;
+  const collectionVars = {};
+  for (const c of collections) Object.assign(collectionVars, c.collectionVariables ?? {});
+  const allRequests = collections.flatMap((c) => Object.values(c.requests));
+  const contractRequests = allRequests.filter(
+    (r) => r.contract && (r.contract.statusCode !== void 0 || r.contract.bodySchema || r.contract.headers?.length)
+  );
+  let specUrl = typeof args["spec-url"] === "string" ? args["spec-url"] : void 0;
+  let specPath = typeof args["spec-path"] === "string" ? args["spec-path"] : void 0;
+  let snapshotLabel;
+  if (typeof args["snapshot"] === "string") {
+    const { snapshot } = await resolveSnapshot(workspace, dir, args["snapshot"]);
+    const tmp = path.join(os.tmpdir(), `api-spector-${crypto.randomUUID()}.${snapshot.format === "yaml" ? "yaml" : "json"}`);
+    await promises.writeFile(tmp, snapshot.spec, "utf8");
+    specPath = tmp;
+    specUrl = void 0;
+    snapshotLabel = `${snapshot.name}${snapshot.specVersion ? ` (${snapshot.specVersion})` : ""}`;
+  }
+  const requestBaseUrl = typeof args["request-base-url"] === "string" ? args["request-base-url"] : void 0;
+  if (mode !== "consumer" && !specUrl && !specPath) {
+    console.error("  [error] Provider / bidirectional mode requires --snapshot, --spec-url, or --spec-path");
+    process.exit(2);
+  }
+  console.log(`  Running ${mode} contracts…`);
+  if (snapshotLabel) console.log(`  Spec: snapshot "${snapshotLabel}"`);
+  else if (specUrl) console.log(`  Spec: ${specUrl} (live)`);
+  else if (specPath) console.log(`  Spec: ${specPath}`);
+  let report;
+  const modeValue = mode;
+  switch (modeValue) {
+    case "consumer":
+      report = await snapshots.runConsumerContracts(contractRequests, envVars, collectionVars);
+      break;
+    case "provider":
+      report = await snapshots.runProviderVerification(allRequests, envVars, specUrl, specPath, requestBaseUrl);
+      break;
+    case "bidirectional":
+      report = await snapshots.runBidirectional(contractRequests, envVars, collectionVars, specUrl, specPath, requestBaseUrl);
+      break;
+  }
+  console.log("");
+  if (report.failed === 0) {
+    console.log(`  ✓ All ${report.passed}/${report.total} passed in ${report.durationMs}ms`);
+  } else {
+    console.log(`  ✗ ${report.failed}/${report.total} failed (${report.passed} passed) in ${report.durationMs}ms`);
+    console.log("");
+    for (const r of report.results.filter((r2) => !r2.passed)) {
+      console.log(`    ${r.method} ${r.requestName}`);
+      for (const v of r.violations) {
+        console.log(`      · ${v.type}: ${v.message}`);
+      }
+    }
+  }
+  if (typeof args["output"] === "string") {
+    await promises.writeFile(args["output"], JSON.stringify(report, null, 2), "utf8");
+    console.log(`
+  Report written to ${args["output"]}`);
+  }
+  process.exit(report.failed === 0 ? 0 : 1);
+}
+async function main() {
+  const [, , sub, ...rest] = process.argv;
+  const args = parseArgs(rest);
+  if (sub === "list") return cmdList(args);
+  if (sub === "run") return cmdRun(args);
+  if (args["help"] || !sub) {
+    console.log(`
+  api-spector contract list  --workspace <path>
+  api-spector contract run   --workspace <path> --mode <consumer|provider|bidirectional> [options]
+
+  Run options:
+    --snapshot <id|name>      Pinned snapshot (run list to see IDs)
+    --spec-url <url>          Live URL (fetched once for this run)
+    --spec-path <path>        Local spec file
+    --collection <name>       Filter to one collection
+    --environment <name>      Environment for {{var}} resolution
+    --request-base-url <url>  Strip this host before matching spec paths
+    --output <path>           Write ContractReport JSON here
+`);
+    return;
+  }
+  console.error(`  [error] Unknown subcommand "${sub}"`);
+  process.exit(2);
+}
+main().catch((e) => {
+  console.error(`  [error] ${e instanceof Error ? e.message : String(e)}`);
+  process.exit(1);
+});