@testsmith/api-spector 0.2.3 → 0.2.4

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-DIsjTggj.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) {
@@ -642,6 +643,7 @@ async function buildDispatcher(proxy, tls) {
 }
 function registerRequestHandler(ipc) {
   ipc.handle("request:send", async (_e, payload) => {
+    ipcValidate.validateSendRequestPayload(payload);
     const {
       request: req,
       environment,