@testsmith/api-spector 0.2.2 → 0.2.3

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);
+});