@testsmith/api-spector 0.2.3 → 0.2.5

package/bin/cli.js

@@ -6,6 +6,23 @@ const { spawn } = require('child_process')
 
 const [, , cmd = 'ui', ...rest] = process.argv
 
+// ─── Command dispatch ────────────────────────────────────────────────────────
+//
+// Each entry maps a top-level command to the bundled JS file that handles it.
+// `entrypoint: null` is reserved for `ui`, which spawns electron itself rather
+// than a node script. Adding a new CLI surface is one line here + one entry in
+// electron.vite.config.ts.
+
+const COMMANDS = {
+  ui:       { entrypoint: null,        runner: 'electron' },
+  run:      { entrypoint: 'runner.js',  runner: 'node' },
+  mock:     { entrypoint: 'mock.js',    runner: 'node' },
+  record:   { entrypoint: 'record.js',  runner: 'node' },
+  agents:   { entrypoint: 'agents.js',  runner: 'node' },
+  contract: { entrypoint: 'contract.js',runner: 'node' },
+  wsdl:     { entrypoint: 'wsdl.js',    runner: 'node' },
+}
+
 function printHelp() {
   console.log('')
   console.log('  API Spector — local-first API testing tool')
@@ -16,6 +33,7 @@ function printHelp() {
   console.log('    api-spector mock     --workspace <path>   Start mock servers from CLI')
   console.log('    api-spector record   --upstream <url>     Record API traffic as mock stubs')
   console.log('    api-spector contract list|run             Manage & run pinned contract snapshots')
+  console.log('    api-spector wsdl     describe|import-*    Inspect a WSDL or import as collection/mock')
   console.log('')
   console.log('  Options:')
   console.log('    api-spector agents init <name>            Initialize AI agent files')
@@ -34,51 +52,34 @@ function printHelp() {
 if (cmd === '--help' || cmd === '-h') {
   printHelp()
   process.exit(0)
-} else if (cmd === 'ui') {
+}
+
+const command = COMMANDS[cmd]
+if (!command) {
+  console.error(`API Spector — unknown command: "${cmd}"`)
+  printHelp()
+  process.exit(1)
+}
+
+// ui: spawn electron with the app dir
+if (command.runner === 'electron') {
   const electron = require('electron')
   const appDir = path.join(__dirname, '..')
+  // Forward the user's cwd so the main process can decide whether to open a
+  // workspace in this folder, or fall through to the welcome screen. Without
+  // this, the app would always auto-load the previously-opened workspace
+  // even when launched from an empty/different directory.
   const proc = spawn(String(electron), [appDir, ...rest], {
     stdio: 'inherit',
-    env: process.env,
-  })
-  proc.on('close', code => process.exit(code ?? 0))
-} else if (cmd === 'run') {
-  const runnerPath = path.join(__dirname, '..', 'out', 'main', 'runner.js')
-  const proc = spawn(process.execPath, [runnerPath, ...rest], {
-    stdio: 'inherit',
-    env: process.env,
-  })
-  proc.on('close', code => process.exit(code ?? 0))
-} else if (cmd === 'mock') {
-  const mockPath = path.join(__dirname, '..', 'out', 'main', 'mock.js')
-  const proc = spawn(process.execPath, [mockPath, ...rest], {
-    stdio: 'inherit',
-    env: process.env,
-  })
-  proc.on('close', code => process.exit(code ?? 0))
-} else if (cmd === 'record') {
-  const recordPath = path.join(__dirname, '..', 'out', 'main', 'record.js')
-  const proc = spawn(process.execPath, [recordPath, ...rest], {
-    stdio: 'inherit',
-    env: process.env,
-  })
-  proc.on('close', code => process.exit(code ?? 0))
-} else if (cmd === 'agents') {
-  const agentsPath = path.join(__dirname, '..', 'out', 'main', 'agents.js')
-  const proc = spawn(process.execPath, [agentsPath, ...rest], {
-    stdio: 'inherit',
-    env: process.env,
+    env: { ...process.env, API_SPECTOR_LAUNCH_CWD: process.cwd() },
   })
   proc.on('close', code => process.exit(code ?? 0))
-} else if (cmd === 'contract') {
-  const contractPath = path.join(__dirname, '..', 'out', 'main', 'contract.js')
-  const proc = spawn(process.execPath, [contractPath, ...rest], {
+} else {
+  // node-runnable bundles in out/main/<entrypoint>
+  const target = path.join(__dirname, '..', 'out', 'main', command.entrypoint)
+  const proc = spawn(process.execPath, [target, ...rest], {
     stdio: 'inherit',
     env: process.env,
   })
   proc.on('close', code => process.exit(code ?? 0))
-} else {
-  console.error(`API Spector — unknown command: "${cmd}"`)
-  printHelp()
-  process.exit(1)
 }

package/out/main/chunks/import-C9qdkBCH.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const uuid = require("uuid");
+const soapHandler = require("./soap-handler-Cpj-JwyA.js");
+require("https");
+require("http");
+require("@xmldom/xmldom");
+const SOAP_11_CONTENT_TYPE = "text/xml; charset=utf-8";
+const SOAP_12_CONTENT_TYPE = "application/soap+xml; charset=utf-8";
+function contentTypeForSoap(version) {
+  return version === "1.2" ? SOAP_12_CONTENT_TYPE : SOAP_11_CONTENT_TYPE;
+}
+function withContentType(headers, value) {
+  const idx = headers.findIndex((h) => h.key.toLowerCase() === "content-type");
+  const next = { key: "Content-Type", value, enabled: true };
+  if (idx === -1) return [...headers, next];
+  return headers.map((h, i) => i === idx ? { ...h, value, enabled: true } : h);
+}
+function buildRequestsFromWsdl(parsed) {
+  const out = [];
+  const byName = /* @__PURE__ */ new Map();
+  for (const op of parsed.operations) {
+    const existing = byName.get(op.name);
+    if (!existing || existing.soapVersion === "1.2" && op.soapVersion === "1.1") byName.set(op.name, op);
+  }
+  for (const op of byName.values()) {
+    const ct = contentTypeForSoap(op.soapVersion);
+    const req = {
+      id: uuid.v4(),
+      name: op.name,
+      method: "POST",
+      url: op.endpoint ?? "",
+      headers: withContentType([], ct),
+      params: [],
+      auth: { type: "none" },
+      protocol: "soap",
+      body: {
+        mode: "soap",
+        soap: {
+          wsdlUrl: "",
+          operationName: op.name,
+          soapAction: op.soapAction ?? "",
+          envelope: op.inputTemplate
+        }
+      },
+      description: op.soapAction ? `SOAPAction: ${op.soapAction}` : void 0
+    };
+    out.push(req);
+  }
+  return out;
+}
+function buildCollectionFromWsdl(name, parsed) {
+  const requests = buildRequestsFromWsdl(parsed);
+  const requestMap = {};
+  for (const r of requests) requestMap[r.id] = r;
+  const collection = {
+    version: "1.0",
+    id: uuid.v4(),
+    name,
+    description: `Imported from WSDL — ${parsed.endpoints[0]?.address ?? parsed.targetNamespace}`,
+    rootFolder: {
+      id: uuid.v4(),
+      name: "root",
+      description: "",
+      folders: [],
+      requestIds: requests.map((r) => r.id)
+    },
+    requests: requestMap
+  };
+  return { collection, requestIds: requests.map((r) => r.id) };
+}
+function pathFromUrl(url) {
+  try {
+    return new URL(url).pathname || "/";
+  } catch {
+    return "/";
+  }
+}
+function pickFreePort(existing) {
+  let p = 3900;
+  while (existing.includes(p)) p++;
+  return p;
+}
+function buildMockFromWsdl(name, parsed, existingPorts = []) {
+  const opMap = {};
+  const seen = /* @__PURE__ */ new Set();
+  for (const op of parsed.operations) {
+    if (seen.has(op.name)) continue;
+    seen.add(op.name);
+    opMap[op.name] = soapHandler.buildResponseEnvelope(op.name, parsed.targetNamespace, op.soapVersion);
+  }
+  const pathsByVersion = /* @__PURE__ */ new Map();
+  for (const ep of parsed.endpoints) {
+    pathsByVersion.set(pathFromUrl(ep.address), ep.soapVersion);
+  }
+  if (pathsByVersion.size === 0) pathsByVersion.set("/", "1.1");
+  const routes = [];
+  for (const [routePath, version] of pathsByVersion.entries()) {
+    routes.push({
+      id: uuid.v4(),
+      method: "POST",
+      path: routePath,
+      statusCode: 200,
+      headers: { "Content-Type": contentTypeForSoap(version) },
+      body: "",
+      description: `SOAP ${version} — dispatched per operation`,
+      script: soapHandler.buildMockDispatchScript(),
+      // Externalized so workspace JSON stays compact: the dispatch script reads
+      // these via the script-runner's `metadata` context binding instead of
+      // baking each envelope as a JS string literal.
+      metadata: { soapEnvelopes: opMap, soapVersion: version }
+    });
+  }
+  return {
+    version: "1.0",
+    id: uuid.v4(),
+    name,
+    port: pickFreePort(existingPorts),
+    routes
+  };
+}
+function importWsdl(wsdlText, opts = {}) {
+  const parsed = soapHandler.parseWsdl(wsdlText);
+  const baseName = opts.name?.trim() || (() => {
+    try {
+      return new URL(parsed.endpoints[0]?.address ?? "").hostname || "WSDL service";
+    } catch {
+      return "WSDL service";
+    }
+  })();
+  const { collection } = buildCollectionFromWsdl(baseName, parsed);
+  const mock = buildMockFromWsdl(`${baseName} (mock)`, parsed, opts.existingMockPorts ?? []);
+  return { parsed, collection, mock };
+}
+function defaultCollectionRelPath(ws, collection) {
+  const safe = collection.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "wsdl";
+  let i = 0;
+  let candidate = `collections/${safe}.json`;
+  const existing = new Set(ws.collections);
+  while (existing.has(candidate)) {
+    i++;
+    candidate = `collections/${safe}-${i}.json`;
+  }
+  return candidate;
+}
+function defaultMockRelPath(mock) {
+  return `mocks/${mock.id}.mock.json`;
+}
+exports.buildCollectionFromWsdl = buildCollectionFromWsdl;
+exports.buildMockFromWsdl = buildMockFromWsdl;
+exports.buildRequestsFromWsdl = buildRequestsFromWsdl;
+exports.defaultCollectionRelPath = defaultCollectionRelPath;
+exports.defaultMockRelPath = defaultMockRelPath;
+exports.importWsdl = importWsdl;

package/out/main/chunks/ipc-validate-CscN4HfG.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Ajv = require("ajv");
+const ajv = new Ajv({
+  allErrors: true,
+  strict: false,
+  coerceTypes: false,
+  allowUnionTypes: true
+});
+function compile(schema) {
+  const fn = ajv.compile(schema);
+  return function validate(data) {
+    if (!fn(data)) {
+      const err = (fn.errors ?? []).map((e) => `${e.instancePath || "<root>"} ${e.message ?? "invalid"}`).join("; ");
+      throw new Error(`Invalid IPC payload: ${err || "unknown"}`);
+    }
+  };
+}
+const apiRequestSchema = {
+  type: "object",
+  properties: {
+    id: { type: "string" },
+    name: { type: "string" },
+    method: { type: "string" },
+    url: { type: "string" },
+    headers: { type: "array" },
+    params: { type: "array" },
+    auth: {
+      type: "object",
+      properties: { type: { type: "string" } },
+      required: ["type"],
+      additionalProperties: true
+    },
+    body: {
+      type: "object",
+      properties: { mode: { type: "string" } },
+      required: ["mode"],
+      additionalProperties: true
+    }
+  },
+  required: ["id", "name", "method", "url", "headers", "params"],
+  additionalProperties: true
+};
+const stringMap = {
+  type: "object",
+  additionalProperties: { type: "string" }
+};
+const validateSendRequestPayload = compile({
+  type: "object",
+  properties: {
+    request: apiRequestSchema,
+    collectionVars: stringMap,
+    globals: stringMap,
+    piiMaskPatterns: { type: "array", items: { type: "string" } }
+    // `environment`, `proxy`, `tls` are accepted as anything — they're
+    // covered by the IPC handler's own type-narrow + defaults.
+  },
+  required: ["request"],
+  additionalProperties: true
+});
+const validateContractRunPayload = compile({
+  type: "object",
+  properties: {
+    mode: { type: "string", enum: ["consumer", "provider", "bidirectional"] },
+    requests: { type: "array", items: apiRequestSchema },
+    envVars: stringMap,
+    collectionVars: stringMap,
+    specUrl: { type: "string" },
+    specPath: { type: "string" },
+    specSnapshotRelPath: { type: "string" },
+    requestBaseUrl: { type: "string" }
+  },
+  required: ["mode", "requests"],
+  additionalProperties: true
+});
+const validateWsdlFetchUrl = (url) => {
+  if (typeof url !== "string" || !url.trim()) throw new Error("Invalid IPC payload: url must be a non-empty string");
+  if (!/^https?:\/\//i.test(url)) throw new Error("Invalid IPC payload: url must start with http:// or https://");
+};
+const validateWsdlImport = compile({
+  type: "object",
+  properties: {
+    url: { type: "string" },
+    xml: { type: "string" },
+    name: { type: "string" },
+    extraHeaders: stringMap,
+    existingMockPorts: { type: "array", items: { type: "number" } }
+  },
+  additionalProperties: true
+});
+exports.validateContractRunPayload = validateContractRunPayload;
+exports.validateSendRequestPayload = validateSendRequestPayload;
+exports.validateWsdlFetchUrl = validateWsdlFetchUrl;
+exports.validateWsdlImport = validateWsdlImport;

package/out/main/chunks/{mock-server-Cx-xG4pJ.js → mock-server-DmdvwCgj.js}

@@ -169,6 +169,10 @@ async function handleRequest(serverId, req, res, reqStart) {
       vm__namespace.runInNewContext(route.script, {
         request: requestCtx,
         response: responseDraft,
+        // Free-form per-route data the importer/user can stash (e.g. SOAP
+        // envelopes by operation, lookup tables, fixtures). Frozen so a script
+        // can't mutate it across calls.
+        metadata: route.metadata ? Object.freeze({ ...route.metadata }) : {},
         faker: faker2,
         dayjs,
         console: { log: (...args) => console.log("[mock-script]", ...args) }

package/out/main/chunks/{request-collection-DMVlm0PA.js → request-collection-CElFJzre.js}

@@ -32,6 +32,7 @@ const jsonpathPlus = require("jsonpath-plus");
 const xmldom = require("@xmldom/xmldom");
 const path = require("path");
 const Ajv = require("ajv");
+const ipcValidate = require("./ipc-validate-CscN4HfG.js");
 function _interopNamespaceDefault(e) {
   const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
   if (e) {
@@ -253,13 +254,15 @@ class AssertionError extends Error {
   }
 }
 function buildAt(ctx, testResults, consoleOutput) {
-  const { envVars, collectionVars, globals: globals2, localVars } = ctx;
+  const { envVars, collectionVars, globals: globals2, localVars, piiMaskPatterns = [] } = ctx;
+  const isSensitiveKey = (key) => piiMaskPatterns.some((p) => key.toLowerCase().includes(p.toLowerCase()));
   function makeVarScope(store, scopeName) {
     return {
       get: (key) => store[key] ?? null,
       set: (key, value) => {
         store[key] = String(value);
-        consoleOutput.push(`[set] ${scopeName}.${key} = ${JSON.stringify(String(value))}`);
+        const display = isSensitiveKey(key) ? '"[REDACTED]"' : JSON.stringify(String(value));
+        consoleOutput.push(`[set] ${scopeName}.${key} = ${display}`);
       },
       clear: (key) => {
         delete store[key];
@@ -382,7 +385,8 @@ async function runScript(code, ctx, timeoutMs = 5e3) {
     collectionVars: collectionCopy,
     globals: globalsCopy,
     localVars: localVarsCopy,
-    response: ctx.response
+    response: ctx.response,
+    piiMaskPatterns: ctx.piiMaskPatterns
   };
   const sp = buildAt(scriptCtx, testResults, consoleOutput);
   const captureConsole = {
@@ -601,6 +605,40 @@ function buildSchemaTestResults(schemaText, body) {
     error: err.message ?? "Schema violation"
   }));
 }
+function buildProtocolFaultTests(bodyMode, body) {
+  if (!body) return [];
+  if (bodyMode === "soap") {
+    const isFault = /<(?:[\w-]+:)?Fault(?:\s|>)/i.test(body);
+    if (isFault) {
+      const reason = /<(?:[\w-]+:)?(?:faultstring|Text)[^>]*>([\s\S]*?)<\/(?:[\w-]+:)?(?:faultstring|Text)>/i.exec(body);
+      return [{
+        name: "[soap] response is not a Fault",
+        passed: false,
+        error: reason?.[1]?.trim() ?? "SOAP Fault returned"
+      }];
+    }
+    return [{ name: "[soap] response is not a Fault", passed: true }];
+  }
+  if (bodyMode === "graphql") {
+    let parsed;
+    try {
+      parsed = JSON.parse(body);
+    } catch {
+      return [];
+    }
+    const errors = parsed?.errors;
+    if (Array.isArray(errors) && errors.length > 0) {
+      const first = errors[0];
+      return [{
+        name: "[graphql] response has no errors",
+        passed: false,
+        error: first?.message ?? "GraphQL response contained an `errors` array"
+      }];
+    }
+    return [{ name: "[graphql] response has no errors", passed: true }];
+  }
+  return [];
+}
 async function buildDispatcher(proxy, tls) {
   const connectOpts = {};
   let hasTls = false;
@@ -642,6 +680,7 @@ async function buildDispatcher(proxy, tls) {
 }
 function registerRequestHandler(ipc) {
   ipc.handle("request:send", async (_e, payload) => {
+    ipcValidate.validateSendRequestPayload(payload);
     const {
       request: req,
       environment,
@@ -695,6 +734,7 @@ function registerRequestHandler(ipc) {
       vars = authBuilder.mergeVars(updatedEnvVars, updatedCollectionVars, updatedGlobals, localVars, dynamicVars);
     }
     let response;
+    let scriptResponse;
     let sentRequest = { method: req.method, url: "", headers: {} };
     const resolvedUrl = authBuilder.buildUrl(req.url, req.params, vars);
     const secretValues = /* @__PURE__ */ new Set();
@@ -838,6 +878,14 @@ function registerRequestHandler(ipc) {
         bodySize: Buffer.byteLength(responseBody, "utf8"),
         durationMs
       };
+      scriptResponse = {
+        status: fetchResp.status,
+        statusText: fetchResp.statusText,
+        headers: rawResponseHeaders,
+        body: responseBody,
+        bodySize: Buffer.byteLength(responseBody, "utf8"),
+        durationMs
+      };
     } catch (err) {
       const diagnostic = formatRequestError(err, {
         requestId: req.id,
@@ -856,8 +904,9 @@ function registerRequestHandler(ipc) {
         durationMs: Date.now() - start,
         error: diagnostic
       };
+      scriptResponse = response;
     }
-    const schemaTestResults = !response.error ? buildSchemaTestResults(req.schema, response.body) : [];
+    const schemaTestResults = !response.error ? buildSchemaTestResults(req.schema, scriptResponse.body) : [];
     let postTestResults = [];
     let postConsole = [];
     let postError;
@@ -867,7 +916,9 @@ function registerRequestHandler(ipc) {
         collectionVars: { ...updatedCollectionVars },
         globals: { ...updatedGlobals },
         localVars: { ...localVars },
-        response
+        // Pass the *unmasked* response so the script can extract real values
+        // (tokens, ids, …). The displayed `response` keeps the redacted copy.
+        response: scriptResponse
       });
       postTestResults = result.testResults;
       postConsole = result.consoleOutput;
@@ -914,22 +965,57 @@ function registerRequestHandler(ipc) {
     };
   });
 }
-function collectTagged(folder, requests, collectionVars, filterTags, parentPath = [], isRoot = true) {
-  const results = [];
-  const scopePath = isRoot ? parentPath : [...parentPath, folder.name];
-  for (const reqId of folder.requestIds) {
-    const req = requests[reqId];
-    if (!req || req.hookType || req.disabled) continue;
+function makeHook(req, collectionVars, hookType, scopeId, scopeAncestors, scopePath, mainRequestId) {
+  return { request: req, collectionVars, isHook: true, hookType, scopeId, scopeAncestors, scopePath, mainRequestId };
+}
+function buildFolderPlan(folder, requests, collectionVars, filterTags, scopeId, ancestorIds, parentPath, wrappers, isRoot) {
+  const result = [];
+  const scopePath = isRoot ? [] : [...parentPath, folder.name];
+  const folderReqs = folder.requestIds.map((id) => requests[id]).filter((r) => r && !r.disabled);
+  const beforeAllHooks = folderReqs.filter((r) => r.hookType === "beforeAll");
+  const beforeHooks = folderReqs.filter((r) => r.hookType === "before");
+  const afterHooks = folderReqs.filter((r) => r.hookType === "after");
+  const afterAllHooks = folderReqs.filter((r) => r.hookType === "afterAll");
+  const regularReqs = folderReqs.filter((r) => !r.hookType);
+  const myWrapper = { scopeId, ancestors: ancestorIds, scopePath, before: beforeHooks, after: afterHooks };
+  const allWrappers = [...wrappers, myWrapper];
+  for (const req of beforeAllHooks) {
+    result.push(makeHook(req, collectionVars, "beforeAll", scopeId, ancestorIds, scopePath));
+  }
+  for (const req of regularReqs) {
     const tags = req.meta?.tags ?? [];
     if (filterTags.length > 0 && !filterTags.some((t) => tags.includes(t))) continue;
-    results.push({ request: req, collectionVars, scopePath });
+    for (const w of allWrappers) {
+      for (const hookReq of w.before) {
+        result.push(makeHook(hookReq, collectionVars, "before", w.scopeId, w.ancestors, w.scopePath, req.id));
+      }
+    }
+    result.push({ request: req, collectionVars, scopeId, scopeAncestors: ancestorIds, scopePath });
+    for (const w of [...allWrappers].reverse()) {
+      for (const hookReq of w.after) {
+        result.push(makeHook(hookReq, collectionVars, "after", w.scopeId, w.ancestors, w.scopePath, req.id));
+      }
+    }
   }
   for (const sub of folder.folders) {
     const folderTags = sub.tags ?? [];
-    const effectiveTags = filterTags.length === 0 ? filterTags : folderTags.some((t) => filterTags.includes(t)) ? [] : filterTags;
-    results.push(...collectTagged(sub, requests, collectionVars, effectiveTags, scopePath, false));
+    const effectiveFilter = filterTags.length === 0 ? filterTags : folderTags.some((t) => filterTags.includes(t)) ? [] : filterTags;
+    result.push(...buildFolderPlan(
+      sub,
+      requests,
+      collectionVars,
+      effectiveFilter,
+      sub.id,
+      [...ancestorIds, scopeId],
+      scopePath,
+      allWrappers,
+      false
+    ));
   }
-  return results;
+  for (const req of afterAllHooks) {
+    result.push(makeHook(req, collectionVars, "afterAll", scopeId, ancestorIds, scopePath));
+  }
+  return result;
 }
 function folderPathTo(root, requestId) {
   if (root.requestIds.includes(requestId)) return [root];
@@ -977,9 +1063,26 @@ function resolveInheritedAuthAndHeaders(requestId, collection) {
   }
   return { auth: inheritedAuth, headers: inheritedHeaders };
 }
+function buildRunPlan(collection, folderId, filterTags) {
+  const collectionVars = collection.collectionVariables ?? {};
+  {
+    return buildFolderPlan(
+      collection.rootFolder,
+      collection.requests,
+      collectionVars,
+      filterTags,
+      collection.rootFolder.id,
+      [],
+      [],
+      [],
+      true
+    );
+  }
+}
 exports.buildDispatcher = buildDispatcher;
+exports.buildProtocolFaultTests = buildProtocolFaultTests;
+exports.buildRunPlan = buildRunPlan;
 exports.buildSchemaTestResults = buildSchemaTestResults;
-exports.collectTagged = collectTagged;
 exports.getAllApplicableHooks = getAllApplicableHooks;
 exports.getGlobals = getGlobals;
 exports.loadGlobals = loadGlobals;