@testsmith/api-spector 0.4.6 → 0.4.7

package/out/main/chunks/{snapshots-BDe-B5iQ.js → snapshots-CtYxkSLz.js}

@@ -1,13 +1,13 @@
 "use strict";
-const undici = require("undici");
-const requestExec = require("./request-exec-CBi2kL6s.js");
 const promises = require("fs/promises");
 const path = require("path");
+const crypto = require("crypto");
+const undici = require("undici");
+const requestExec = require("./request-exec-BH-M3KqZ.js");
 const Ajv = require("ajv");
 const jsYaml = require("js-yaml");
-const crypto = require("crypto");
 const MATCH_KEY = "__match";
-function isMatcher(node) {
+function isMatcher$1(node) {
   return typeof node === "object" && node !== null && !Array.isArray(node) && typeof node[MATCH_KEY] === "string";
 }
 function compileMatcher(m) {
@@ -44,7 +44,7 @@ function compileMatcher(m) {
   }
 }
 function compileMatcherExample(node, exact = true) {
-  if (isMatcher(node)) return compileMatcher(node);
+  if (isMatcher$1(node)) return compileMatcher(node);
   if (node === null) return { type: "null" };
   const t = typeof node;
   if (t === "boolean") return exact ? { const: node } : { type: "boolean" };
@@ -68,6 +68,552 @@ function compileMatcherExample(node, exact = true) {
   }
   return {};
 }
+function parsePath(path2) {
+  const tokens = [];
+  const re = /\.([^.[\]]+)|\['([^']*)'\]|\[(\d+|\*)\]/g;
+  let m;
+  while ((m = re.exec(path2)) !== null) {
+    if (m[1] !== void 0) tokens.push({ key: m[1] });
+    else if (m[2] !== void 0) tokens.push({ key: m[2] });
+    else if (m[3] !== void 0) tokens.push({ index: m[3] === "*" ? "*" : Number(m[3]) });
+  }
+  return tokens;
+}
+function ruleToMatcher(value, rule) {
+  switch (rule.match) {
+    case "type":
+      if (Array.isArray(value)) {
+        return { [MATCH_KEY]: "eachLike", value: value[0] ?? {}, min: rule.min ?? 1 };
+      }
+      return { [MATCH_KEY]: "type", value };
+    case "regex":
+      return { [MATCH_KEY]: "regex", regex: rule.regex ?? ".*", value };
+    case "integer":
+      return { [MATCH_KEY]: "integer", value };
+    case "number":
+    case "decimal":
+      return { [MATCH_KEY]: "decimal", value };
+    case "boolean":
+      return { [MATCH_KEY]: "boolean", value };
+    case "null":
+      return { [MATCH_KEY]: "null", value: null };
+    case "datetime":
+    case "timestamp":
+      return { [MATCH_KEY]: "datetime", value, format: rule.format };
+    case "date":
+      return { [MATCH_KEY]: "date", value };
+    case "time":
+      return { [MATCH_KEY]: "time", value };
+    default:
+      return value;
+  }
+}
+function applyAtPath(root, tokens, transform) {
+  if (tokens.length === 0) return transform(root);
+  const [head, ...rest] = tokens;
+  if ("index" in head) {
+    if (!Array.isArray(root)) return root;
+    if (head.index === "*") {
+      return root.map((el) => applyAtPath(el, rest, transform));
+    }
+    const arr = [...root];
+    if (head.index < arr.length) arr[head.index] = applyAtPath(arr[head.index], rest, transform);
+    return arr;
+  }
+  if (typeof root !== "object" || root === null || Array.isArray(root)) return root;
+  const obj = { ...root };
+  if (head.key in obj) obj[head.key] = applyAtPath(obj[head.key], rest, transform);
+  return obj;
+}
+function bodyWithMatchers(body, matchingRules) {
+  const bodyRules = matchingRules?.["body"] ?? matchingRules?.["content"];
+  if (!bodyRules || body === void 0) return body;
+  const entries = Object.entries(bodyRules).sort((a, b) => parsePath(b[0]).length - parsePath(a[0]).length);
+  let result = body;
+  for (const [path2, def] of entries) {
+    const rule = def?.matchers?.[0];
+    if (!rule) continue;
+    const tokens = parsePath(path2);
+    result = applyAtPath(result, tokens, (v) => ruleToMatcher(v, rule));
+  }
+  return result;
+}
+function providerStatesOf(interaction) {
+  const v3 = interaction["providerStates"];
+  if (Array.isArray(v3)) return v3.map((s) => s?.name ?? "").filter(Boolean);
+  const v2 = interaction["providerState"] ?? interaction["provider_state"];
+  return typeof v2 === "string" && v2 ? [v2] : [];
+}
+function queryToParams(query) {
+  const params = [];
+  if (!query) return params;
+  if (typeof query === "string") {
+    for (const pair of query.split("&")) {
+      const [k, v = ""] = pair.split("=");
+      if (k) params.push({ key: decodeURIComponent(k), value: decodeURIComponent(v), enabled: true });
+    }
+  } else if (typeof query === "object") {
+    for (const [k, vals] of Object.entries(query)) {
+      const list = Array.isArray(vals) ? vals : [vals];
+      for (const v of list) params.push({ key: k, value: String(v ?? ""), enabled: true });
+    }
+  }
+  return params;
+}
+function headerEntries(headers) {
+  if (!headers || typeof headers !== "object") return [];
+  return Object.entries(headers).map(([key, value]) => ({
+    key,
+    value: Array.isArray(value) ? value.join(", ") : String(value ?? "")
+  }));
+}
+function headersToKv(headers) {
+  return headerEntries(headers).map((h) => ({ ...h, enabled: true }));
+}
+function headersToContract(headers) {
+  return headerEntries(headers).map((h) => ({ ...h, required: true }));
+}
+function importInteraction(interaction) {
+  const request = interaction["request"] ?? {};
+  const response = interaction["response"] ?? {};
+  const method = String(request["method"] ?? "GET").toUpperCase();
+  const path2 = String(request["path"] ?? "/");
+  const reqBody = request["body"];
+  const body = reqBody === void 0 ? { mode: "none" } : typeof reqBody === "string" ? { mode: "raw", raw: reqBody } : { mode: "json", json: JSON.stringify(reqBody, null, 2) };
+  const contract = {};
+  if (typeof response["status"] === "number") contract.statusCode = response["status"];
+  const respHeaders = headersToContract(response["headers"]);
+  if (respHeaders?.length) contract.headers = respHeaders;
+  if (response["body"] !== void 0) {
+    const example = bodyWithMatchers(response["body"], response["matchingRules"]);
+    contract.bodyMatcher = JSON.stringify(example, null, 2);
+  }
+  const states = providerStatesOf(interaction);
+  if (states.length) contract.providerStates = states;
+  return {
+    id: crypto.randomUUID(),
+    name: String(interaction["description"] ?? `${method} ${path2}`),
+    method,
+    url: `{{baseUrl}}${path2}`,
+    headers: headersToKv(request["headers"]),
+    params: queryToParams(request["query"]),
+    auth: { type: "none" },
+    body,
+    contract,
+    meta: { tags: ["pact"] }
+  };
+}
+function importPact(json) {
+  const pact = typeof json === "string" ? JSON.parse(json) : json;
+  const consumer = pact["consumer"]?.name ?? "consumer";
+  const provider = pact["provider"]?.name ?? "provider";
+  const metadata = pact["metadata"];
+  const specVersion = String(
+    metadata?.["pactSpecification"]?.version ?? metadata?.["pact-specification"]?.version ?? "3.0.0"
+  );
+  const interactions = pact["interactions"] ?? [];
+  const httpInteractions = interactions.filter((i) => {
+    const type = i["type"];
+    return type === void 0 || type === "Synchronous/HTTP" || type === "HTTP";
+  });
+  return {
+    consumer,
+    provider,
+    specVersion,
+    requests: httpInteractions.map(importInteraction)
+  };
+}
+function pactToCollection(result) {
+  const requests = {};
+  for (const r of result.requests) requests[r.id] = r;
+  return {
+    version: "1.0",
+    id: crypto.randomUUID(),
+    name: `${result.consumer} → ${result.provider}`,
+    description: `Imported from Pact (spec ${result.specVersion})`,
+    rootFolder: {
+      id: crypto.randomUUID(),
+      name: "root",
+      folders: [],
+      requestIds: result.requests.map((r) => r.id)
+    },
+    requests,
+    collectionVariables: { baseUrl: "" }
+  };
+}
+function isMatcher(node) {
+  return typeof node === "object" && node !== null && !Array.isArray(node) && typeof node[MATCH_KEY] === "string";
+}
+function exampleToPactBody(node) {
+  const rules = {};
+  function walk(n, path2) {
+    if (isMatcher(n)) {
+      const kind = n[MATCH_KEY];
+      switch (kind) {
+        case "type":
+          rules[path2] = { matchers: [{ match: "type" }] };
+          return walk(n.value, path2);
+        case "eachLike": {
+          rules[path2] = { matchers: [{ match: "type", min: n.min ?? 1 }] };
+          return [walk(n.value, `${path2}[*]`)];
+        }
+        case "regex":
+          rules[path2] = { matchers: [{ match: "regex", regex: n.regex ?? ".*" }] };
+          return n.value ?? "";
+        case "integer":
+          rules[path2] = { matchers: [{ match: "integer" }] };
+          return n.value ?? 0;
+        case "decimal":
+        case "number":
+          rules[path2] = { matchers: [{ match: "decimal" }] };
+          return n.value ?? 0;
+        case "boolean":
+          rules[path2] = { matchers: [{ match: "boolean" }] };
+          return n.value ?? false;
+        case "string":
+          rules[path2] = { matchers: [{ match: "type" }] };
+          return n.value ?? "";
+        case "null":
+          rules[path2] = { matchers: [{ match: "null" }] };
+          return null;
+        case "datetime":
+        case "timestamp":
+          rules[path2] = { matchers: [{ match: "datetime", format: n.format }] };
+          return n.value ?? "";
+        case "date":
+          rules[path2] = { matchers: [{ match: "date" }] };
+          return n.value ?? "";
+        case "time":
+          rules[path2] = { matchers: [{ match: "time" }] };
+          return n.value ?? "";
+        default:
+          return n.value;
+      }
+    }
+    if (Array.isArray(n)) return n.map((el, i) => walk(el, `${path2}[${i}]`));
+    if (typeof n === "object" && n !== null) {
+      const out = {};
+      for (const [k, v] of Object.entries(n)) out[k] = walk(v, `${path2}.${k}`);
+      return out;
+    }
+    return n;
+  }
+  const body = walk(node, "$");
+  return { body, rules };
+}
+function kvToHeaders$1(kv) {
+  if (!kv?.length) return void 0;
+  const out = {};
+  for (const h of kv) if (h.enabled !== false && h.key) out[h.key] = h.value;
+  return Object.keys(out).length ? out : void 0;
+}
+const V4_SYNC_HTTP = "Synchronous/HTTP";
+function interactionKey(identity) {
+  let h = 2166136261;
+  for (let i = 0; i < identity.length; i++) {
+    h ^= identity.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(16).padStart(8, "0");
+}
+function exportPact(consumer, provider, requests) {
+  const interactions = requests.filter((r) => r.contract).map((r) => {
+    const c = r.contract;
+    const path2 = r.url.replace(/^\{\{baseUrl\}\}/, "").replace(/^https?:\/\/[^/]+/, "") || "/";
+    const query = {};
+    for (const p of r.params ?? []) {
+      if (p.enabled === false || !p.key) continue;
+      (query[p.key] ??= []).push(p.value);
+    }
+    const response = {};
+    if (c.statusCode !== void 0) response["status"] = c.statusCode;
+    const respHeaders = kvToHeaders$1(c.headers);
+    if (respHeaders) response["headers"] = respHeaders;
+    if (c.bodyMatcher?.trim()) {
+      try {
+        const { body, rules } = exampleToPactBody(JSON.parse(c.bodyMatcher));
+        response["body"] = body;
+        if (Object.keys(rules).length) response["matchingRules"] = { body: rules };
+      } catch {
+      }
+    }
+    const request = { method: r.method, path: path2 };
+    if (Object.keys(query).length) request["query"] = query;
+    const reqHeaders = kvToHeaders$1(r.headers);
+    if (reqHeaders) request["headers"] = reqHeaders;
+    if (r.body?.mode === "json" && r.body.json) {
+      try {
+        request["body"] = JSON.parse(r.body.json);
+      } catch {
+      }
+    } else if (r.body?.mode === "raw" && r.body.raw) request["body"] = r.body.raw;
+    const interaction = {
+      type: V4_SYNC_HTTP,
+      key: interactionKey(`${r.method}|${path2}|${c.statusCode ?? ""}|${r.name}`),
+      description: r.name,
+      request,
+      response
+    };
+    if (c.providerStates?.length) interaction["providerStates"] = c.providerStates.map((name) => ({ name }));
+    return interaction;
+  });
+  return {
+    consumer: { name: consumer },
+    provider: { name: provider },
+    interactions,
+    metadata: {
+      pactSpecification: { version: "4.0" },
+      client: { name: "api-spector" }
+    }
+  };
+}
+function kvToHeaders(kv) {
+  const out = {};
+  for (const p of kv ?? []) {
+    if (p.enabled === false || !p.key) continue;
+    out[p.key] = p.value;
+  }
+  return Object.keys(out).length ? out : void 0;
+}
+function kvToQuery(kv) {
+  const out = {};
+  for (const p of kv ?? []) {
+    if (p.enabled === false || !p.key) continue;
+    (out[p.key] ??= []).push(p.value);
+  }
+  return Object.keys(out).length ? out : void 0;
+}
+function parseJson(s) {
+  if (!s || !s.trim()) return void 0;
+  try {
+    return JSON.parse(s);
+  } catch {
+    return void 0;
+  }
+}
+function typeMatchingRules(body) {
+  const rules = {};
+  const walk = (node, path2) => {
+    if (Array.isArray(node)) {
+      rules[path2] = { matchers: [{ match: "type", min: node.length > 0 ? 1 : 0 }] };
+      if (node.length > 0) walk(node[0], `${path2}[*]`);
+    } else if (node !== null && typeof node === "object") {
+      for (const [k, v] of Object.entries(node)) walk(v, `${path2}.${k}`);
+    } else {
+      rules[path2] = { matchers: [{ match: "type" }] };
+    }
+  };
+  walk(body, "$");
+  return rules;
+}
+function scalarFromName(name) {
+  switch (name.toLowerCase()) {
+    case "integer":
+    case "int":
+      return { kind: "scalar", type: "integer" };
+    case "number":
+    case "float":
+    case "double":
+    case "decimal":
+      return { kind: "scalar", type: "number" };
+    case "boolean":
+    case "bool":
+      return { kind: "scalar", type: "boolean" };
+    case "null":
+      return { kind: "scalar", type: "null" };
+    default:
+      return { kind: "scalar", type: "string" };
+  }
+}
+function tokenizeShape(src) {
+  const tokens = [];
+  const re = /\s*([{}[\]:,]|[A-Za-z0-9_$-]+|"[^"]*")\s*/y;
+  let i = 0;
+  while (i < src.length) {
+    re.lastIndex = i;
+    const m = re.exec(src);
+    if (!m || m.index !== i) return void 0;
+    tokens.push(m[1].startsWith('"') ? m[1].slice(1, -1) : m[1]);
+    i = re.lastIndex;
+  }
+  return tokens;
+}
+function parseShape(src) {
+  if (!src || !src.trim()) return void 0;
+  const tokens = tokenizeShape(src);
+  if (!tokens || tokens.length === 0) return void 0;
+  let pos = 0;
+  const peek = () => tokens[pos];
+  const structural = /* @__PURE__ */ new Set(["{", "}", "[", "]", ":", ","]);
+  const parseValue = () => {
+    const tok = peek();
+    if (tok === "{") return parseObject();
+    if (tok === "[") return parseArray();
+    if (tok === void 0 || structural.has(tok)) return void 0;
+    pos++;
+    return scalarFromName(tok);
+  };
+  const parseObject = () => {
+    pos++;
+    const fields = [];
+    while (peek() !== void 0 && peek() !== "}") {
+      const name = peek();
+      if (structural.has(name)) return void 0;
+      pos++;
+      let shape2;
+      if (peek() === ":") {
+        pos++;
+        const s = parseValue();
+        if (!s) return void 0;
+        shape2 = s;
+      } else {
+        shape2 = { kind: "scalar", type: "string" };
+      }
+      fields.push({ name, shape: shape2 });
+      if (peek() === ",") pos++;
+    }
+    if (peek() !== "}") return void 0;
+    pos++;
+    return { kind: "object", fields };
+  };
+  const parseArray = () => {
+    pos++;
+    let item;
+    if (peek() === "]") {
+      item = { kind: "scalar", type: "string" };
+    } else {
+      const s = parseValue();
+      if (!s) return void 0;
+      item = s;
+    }
+    if (peek() !== "]") return void 0;
+    pos++;
+    return { kind: "array", item };
+  };
+  const shape = parseValue();
+  if (!shape || pos !== tokens.length) return void 0;
+  return shape;
+}
+function compileShape(shape) {
+  const rules = {};
+  const build = (s, path2) => {
+    if (s.kind === "array") {
+      rules[path2] = { matchers: [{ match: "type", min: 1 }] };
+      return [build(s.item, `${path2}[*]`)];
+    }
+    if (s.kind === "object") {
+      const obj = {};
+      for (const f of s.fields) obj[f.name] = build(f.shape, `${path2}.${f.name}`);
+      return obj;
+    }
+    switch (s.type) {
+      case "integer":
+        rules[path2] = { matchers: [{ match: "integer" }] };
+        return 0;
+      case "number":
+        rules[path2] = { matchers: [{ match: "number" }] };
+        return 0;
+      case "boolean":
+        rules[path2] = { matchers: [{ match: "boolean" }] };
+        return false;
+      case "null":
+        rules[path2] = { matchers: [{ match: "null" }] };
+        return null;
+      default:
+        rules[path2] = { matchers: [{ match: "type" }] };
+        return "string";
+    }
+  };
+  const body = build(shape, "$");
+  return { body, rules };
+}
+function compileResponseBody(text, loose = true) {
+  if (!text || !text.trim()) return void 0;
+  try {
+    const json = JSON.parse(text);
+    const rules = loose ? typeMatchingRules(json) : {};
+    return { body: json, rules: Object.keys(rules).length ? rules : void 0 };
+  } catch {
+  }
+  const shape = parseShape(text);
+  if (shape) {
+    const { body, rules } = compileShape(shape);
+    return { body, rules: Object.keys(rules).length ? rules : void 0 };
+  }
+  return void 0;
+}
+function interactionToPact(it) {
+  const request = {
+    method: (it.request.method || "GET").toUpperCase(),
+    path: it.request.path || "/"
+  };
+  const query = kvToQuery(it.request.query);
+  if (query) request["query"] = query;
+  const reqHeaders = kvToHeaders(it.request.headers);
+  if (reqHeaders) request["headers"] = reqHeaders;
+  const reqBody = parseJson(it.request.body);
+  if (reqBody !== void 0) request["body"] = reqBody;
+  const response = { status: it.response.status };
+  const respHeaders = kvToHeaders(it.response.headers);
+  if (respHeaders) response["headers"] = respHeaders;
+  const respBody = compileResponseBody(it.response.body, it.looseMatch !== false);
+  if (respBody) {
+    response["body"] = respBody.body;
+    if (respBody.rules) response["matchingRules"] = { body: respBody.rules };
+  }
+  const interaction = {
+    type: V4_SYNC_HTTP,
+    key: interactionKey(`${(it.request.method || "GET").toUpperCase()}|${it.request.path || "/"}|${it.response.status}|${it.description ?? ""}`),
+    description: it.description || `${it.request.method} ${it.request.path}`,
+    request,
+    response
+  };
+  if (it.providerState?.trim()) interaction["providerStates"] = [{ name: it.providerState.trim() }];
+  return interaction;
+}
+function designContractToPact(cc) {
+  return {
+    consumer: { name: cc.consumer },
+    provider: { name: cc.provider },
+    interactions: cc.interactions.map(interactionToPact),
+    metadata: {
+      pactSpecification: { version: "4.0" },
+      client: { name: "api-spector", designFirst: true }
+    }
+  };
+}
+async function loadDesignContractRequests(workspace, dir) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (requests) => {
+    for (const r of requests) {
+      const key = `${r.method} ${r.url} ${r.name}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      out.push(r);
+    }
+  };
+  for (const cc of workspace.designContracts ?? []) {
+    try {
+      add(importPact(designContractToPact(cc)).requests);
+    } catch {
+    }
+  }
+  if (dir) {
+    let files = [];
+    try {
+      files = (await promises.readdir(path.join(dir, "pacts"))).filter((f) => f.endsWith(".json"));
+    } catch {
+    }
+    for (const f of files.sort()) {
+      try {
+        add(importPact(await promises.readFile(path.join(dir, "pacts", f), "utf8")).requests);
+      } catch {
+      }
+    }
+  }
+  return out;
+}
 const ajv$2 = new Ajv({ allErrors: true, strict: false });
 function hasContract(contract) {
   return !!contract && (contract.statusCode !== void 0 || !!contract.bodySchema || !!contract.bodyMatcher || !!contract.headers?.length);
@@ -1636,17 +2182,21 @@ async function deleteSnapshot(workspaceDir, relPath) {
   } catch {
   }
 }
-exports.MATCH_KEY = MATCH_KEY;
 exports.canIDeploy = canIDeploy;
 exports.captureSnapshot = captureSnapshot;
 exports.dashboardToHtml = dashboardToHtml;
 exports.deleteSnapshot = deleteSnapshot;
+exports.designContractToPact = designContractToPact;
+exports.exportPact = exportPact;
 exports.fuzzReportToHtml = fuzzReportToHtml;
 exports.hasContract = hasContract;
+exports.importPact = importPact;
 exports.listEnvironments = listEnvironments;
 exports.listResults = listResults;
 exports.listSnapshots = listSnapshots;
+exports.loadDesignContractRequests = loadDesignContractRequests;
 exports.loadSnapshot = loadSnapshot;
+exports.pactToCollection = pactToCollection;
 exports.recordDeployment = recordDeployment;
 exports.recordResult = recordResult;
 exports.relPathOf = relPathOf;

package/out/main/chunks/{soap-handler-CAyUjzxB.js → soap-handler-BXx842MN.js}

@@ -1,5 +1,5 @@
 "use strict";
-const handle = require("./handle-BGYDylL2.js");
+const handle = require("./handle-rimXXdJH.js");
 const https = require("https");
 const http = require("http");
 const xmldom = require("@xmldom/xmldom");
@@ -315,7 +315,7 @@ function registerSoapHandlers(ipc) {
   handle.handleIpc(ipc, handle.IPC.wsdl.import, async (_event, opts) => {
     const { validateWsdlImport } = await Promise.resolve().then(() => require("./ipc-validate-k6KI8adf.js"));
     validateWsdlImport(opts);
-    const { importWsdl } = await Promise.resolve().then(() => require("./import-CUcjlmSK.js"));
+    const { importWsdl } = await Promise.resolve().then(() => require("./import-DcenB5Q_.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 });