@testsmith/api-spector 0.2.2 → 0.2.3

package/out/main/chunks/snapshots-C7YbGHM7.js

@@ -0,0 +1,588 @@
+"use strict";
+const promises = require("fs/promises");
+const undici = require("undici");
+const jsYaml = require("js-yaml");
+const Ajv = require("ajv");
+const authBuilder = require("./auth-builder-B7-LgcGr.js");
+const path = require("path");
+const crypto = require("crypto");
+const ajv$1 = new Ajv({ allErrors: true, strict: false });
+function validateConsumerResponse(contract, actualStatus, actualHeaders, bodyText) {
+  const violations = [];
+  if (contract.statusCode !== void 0 && actualStatus !== contract.statusCode) {
+    violations.push({
+      type: "status_mismatch",
+      message: `Expected status ${contract.statusCode}, got ${actualStatus}`,
+      expected: String(contract.statusCode),
+      actual: String(actualStatus)
+    });
+  }
+  for (const expected of contract.headers ?? []) {
+    if (!expected.required) continue;
+    const actual = actualHeaders[expected.key.toLowerCase()];
+    if (actual === void 0) {
+      violations.push({
+        type: "missing_header",
+        message: `Required header "${expected.key}" is absent`,
+        expected: expected.value || "(any)",
+        actual: "(absent)"
+      });
+    } else if (expected.value && actual.split(";")[0].trim().toLowerCase() !== expected.value.split(";")[0].trim().toLowerCase()) {
+      violations.push({
+        type: "missing_header",
+        message: `Header "${expected.key}" has unexpected value`,
+        expected: expected.value,
+        actual
+      });
+    }
+  }
+  if (contract.bodySchema?.trim()) {
+    let schema;
+    try {
+      schema = JSON.parse(contract.bodySchema);
+    } catch {
+      violations.push({
+        type: "schema_violation",
+        message: "Contract bodySchema is not valid JSON"
+      });
+      return violations;
+    }
+    let data;
+    try {
+      data = JSON.parse(bodyText);
+    } catch {
+      violations.push({
+        type: "schema_violation",
+        message: "Response body is not valid JSON — cannot validate against schema"
+      });
+      return violations;
+    }
+    try {
+      const validate = ajv$1.compile(schema);
+      if (!validate(data)) {
+        for (const err of validate.errors ?? []) {
+          violations.push({
+            type: "schema_violation",
+            message: err.message ?? "Schema violation",
+            path: err.instancePath || "/"
+          });
+        }
+      }
+    } catch (e) {
+      violations.push({
+        type: "schema_violation",
+        message: `Schema compile error: ${e instanceof Error ? e.message : String(e)}`
+      });
+    }
+  }
+  return violations;
+}
+async function executeContract(req, vars) {
+  const url = authBuilder.buildUrl(req.url, req.params, vars);
+  const start = Date.now();
+  try {
+    const headers = new undici.Headers();
+    for (const h of req.headers) {
+      if (h.enabled && h.key) headers.set(authBuilder.interpolate(h.key, vars), authBuilder.interpolate(h.value, vars));
+    }
+    const authHeaders = await authBuilder.buildAuthHeaders(req.auth, vars);
+    for (const [k, v] of Object.entries(authHeaders)) headers.set(k, v);
+    let body;
+    if (req.body.mode === "json" && req.body.json) {
+      body = authBuilder.interpolate(req.body.json, vars);
+      if (!headers.has("content-type")) headers.set("Content-Type", "application/json");
+    } else if (req.body.mode === "raw" && req.body.raw) {
+      body = authBuilder.interpolate(req.body.raw, vars);
+    }
+    const resp = await undici.fetch(url, {
+      method: req.method,
+      headers,
+      body: !["GET", "HEAD"].includes(req.method) ? body : void 0
+    });
+    const bodyText = await resp.text();
+    const rawHeaders = {};
+    resp.headers.forEach((v, k) => {
+      rawHeaders[k] = v;
+    });
+    const violations = validateConsumerResponse(req.contract, resp.status, rawHeaders, bodyText);
+    return {
+      requestId: req.id,
+      requestName: req.name,
+      method: req.method,
+      url,
+      passed: violations.length === 0,
+      violations,
+      durationMs: Date.now() - start,
+      actualStatus: resp.status
+    };
+  } catch (err) {
+    return {
+      requestId: req.id,
+      requestName: req.name,
+      method: req.method,
+      url,
+      passed: false,
+      violations: [{
+        type: "status_mismatch",
+        message: `Request failed: ${err instanceof Error ? err.message : String(err)}`
+      }],
+      durationMs: Date.now() - start
+    };
+  }
+}
+async function runConsumerContracts(requests, envVars, collectionVars = {}) {
+  const vars = { ...envVars, ...collectionVars };
+  const contractRequests = requests.filter(
+    (r) => !r.disabled && r.contract && (r.contract.statusCode !== void 0 || r.contract.bodySchema || r.contract.headers?.length)
+  );
+  const start = Date.now();
+  const results = await Promise.all(contractRequests.map((r) => executeContract(r, vars)));
+  const passed = results.filter((r) => r.passed).length;
+  return {
+    mode: "consumer",
+    total: results.length,
+    passed,
+    failed: results.length - passed,
+    results,
+    durationMs: Date.now() - start
+  };
+}
+const ajv = new Ajv({ allErrors: true, strict: false });
+async function loadSpec(specUrl, specPath) {
+  if (specUrl) {
+    const resp = await undici.fetch(specUrl);
+    if (!resp.ok) throw new Error(`HTTP ${resp.status} loading spec from ${specUrl}`);
+    const text = await resp.text();
+    const ct = resp.headers.get("content-type") ?? "";
+    return ct.includes("yaml") || specUrl.endsWith(".yaml") || specUrl.endsWith(".yml") ? jsYaml.load(text) : JSON.parse(text);
+  }
+  if (specPath) {
+    const raw = await promises.readFile(specPath, "utf8");
+    return specPath.endsWith(".yaml") || specPath.endsWith(".yml") ? jsYaml.load(raw) : JSON.parse(raw);
+  }
+  throw new Error("Either specUrl or specPath must be provided");
+}
+function resolveRef(spec, ref) {
+  const parts = ref.replace(/^#\//, "").split("/");
+  return parts.reduce((obj, key) => obj?.[key], spec);
+}
+function resolveSchema(spec, obj, seen = /* @__PURE__ */ new Set()) {
+  if (!obj || typeof obj !== "object") return obj;
+  if (seen.has(obj)) return {};
+  if (Array.isArray(obj)) {
+    seen.add(obj);
+    return obj.map((i) => resolveSchema(spec, i, seen));
+  }
+  const o = obj;
+  if ("$ref" in o) {
+    const target = resolveRef(spec, o["$ref"]);
+    return resolveSchema(spec, target, seen);
+  }
+  seen.add(obj);
+  return Object.fromEntries(Object.entries(o).map(([k, v]) => [k, resolveSchema(spec, v, seen)]));
+}
+function getServerBases(spec) {
+  const servers = spec["servers"] ?? [];
+  if (!servers.length) return [""];
+  return servers.map((s) => {
+    const raw = s.url ?? "";
+    try {
+      return new URL(raw).pathname.replace(/\/$/, "");
+    } catch {
+      return raw.replace(/\/$/, "");
+    }
+  });
+}
+function urlPathname(raw, baseUrl) {
+  try {
+    const pathname = new URL(raw).pathname;
+    if (baseUrl) {
+      try {
+        const basePath = new URL(baseUrl).pathname.replace(/\/$/, "");
+        if (basePath && pathname.startsWith(basePath)) return pathname.slice(basePath.length) || "/";
+      } catch {
+      }
+    }
+    return pathname;
+  } catch {
+    return raw.split("?")[0];
+  }
+}
+function pathTemplateToRegex(base, template) {
+  const combined = (base + template).replace(/\/+/g, "/");
+  const pattern = combined.replace(/\{[^}]+\}/g, "[^/]+");
+  return new RegExp("^" + pattern + "/?$");
+}
+function findOperation(spec, method, reqUrl, requestBaseUrl) {
+  const bases = getServerBases(spec);
+  const pathname = urlPathname(reqUrl, requestBaseUrl);
+  const paths = spec["paths"] ?? {};
+  for (const [template, pathItem] of Object.entries(paths)) {
+    const resolved = resolveSchema(spec, pathItem);
+    for (const base of bases) {
+      if (pathTemplateToRegex(base, template).test(pathname)) {
+        const op = resolved[method.toLowerCase()];
+        return op ? { pathTemplate: template, operation: op } : null;
+      }
+    }
+  }
+  return null;
+}
+function validateRequestAgainstSpec(spec, req, envVars, requestBaseUrl) {
+  const violations = [];
+  const vars = envVars;
+  const url = req.url.replace(/\{\{([^}]+)\}\}/g, (_, k) => vars[k] ?? `{{${k}}}`);
+  const match = findOperation(spec, req.method, url, requestBaseUrl);
+  if (!match) {
+    violations.push({
+      type: "unknown_path",
+      message: `No operation found in spec for ${req.method} ${url}`
+    });
+    return violations;
+  }
+  const { operation } = match;
+  if (req.body.mode === "json" && req.body.json?.trim()) {
+    const requestBody = resolveSchema(spec, operation["requestBody"]);
+    const content = requestBody?.["content"] ?? {};
+    const jsonContent = content["application/json"];
+    if (jsonContent?.["schema"]) {
+      try {
+        const data = JSON.parse(authBuilder.interpolate(req.body.json, vars));
+        const schema = resolveSchema(spec, jsonContent["schema"]);
+        const validate = ajv.compile(schema);
+        if (!validate(data)) {
+          for (const err of validate.errors ?? []) {
+            violations.push({
+              type: "request_body_invalid",
+              message: err.message ?? "Request body schema violation",
+              path: err.instancePath || "/"
+            });
+          }
+        }
+      } catch (e) {
+        violations.push({
+          type: "request_body_invalid",
+          message: `Could not validate request body: ${e instanceof Error ? e.message : String(e)}`
+        });
+      }
+    }
+  }
+  const parameters = resolveSchema(spec, operation["parameters"] ?? []);
+  for (const param of parameters) {
+    const p = param;
+    if (p["in"] === "query" && p["required"] === true) {
+      const name = p["name"];
+      if (!req.params.some((kv) => kv.enabled && kv.key === name)) {
+        violations.push({
+          type: "request_body_invalid",
+          message: `Required query parameter "${name}" is missing`,
+          path: `query.${name}`
+        });
+      }
+    }
+  }
+  return violations;
+}
+async function runProviderVerification(requests, envVars, specUrl, specPath, requestBaseUrl) {
+  const spec = await loadSpec(specUrl, specPath);
+  const start = Date.now();
+  const activeRequests = requests.filter((r) => !r.disabled);
+  const results = activeRequests.map((req) => {
+    const violations = validateRequestAgainstSpec(spec, req, envVars, requestBaseUrl);
+    const url = req.url.replace(/\{\{([^}]+)\}\}/g, (_, k) => envVars[k] ?? `{{${k}}}`);
+    return {
+      requestId: req.id,
+      requestName: req.name,
+      method: req.method,
+      url,
+      passed: violations.length === 0,
+      violations
+    };
+  });
+  const passed = results.filter((r) => r.passed).length;
+  return {
+    mode: "provider",
+    total: results.length,
+    passed,
+    failed: results.length - passed,
+    results,
+    durationMs: Date.now() - start
+  };
+}
+function checkSchemaCompatibility(consumerSchema, providerSchema, path2 = "") {
+  const violations = [];
+  if (!consumerSchema || !providerSchema) return violations;
+  const cType = consumerSchema["type"];
+  const pType = providerSchema["type"];
+  if (cType && pType && cType !== pType) {
+    const ok = cType === "integer" && pType === "number" || cType === "number" && pType === "integer";
+    if (!ok) {
+      violations.push({
+        type: "schema_incompatible",
+        message: `Type mismatch${path2 ? ` at "${path2}"` : ""}: consumer expects "${cType}", provider offers "${pType}"`,
+        path: path2 || "/",
+        expected: cType,
+        actual: pType
+      });
+      return violations;
+    }
+  }
+  if (cType === "array" || Array.isArray(consumerSchema["items"])) {
+    const cItems = consumerSchema["items"];
+    const pItems = providerSchema["items"];
+    if (cItems && pItems) {
+      violations.push(...checkSchemaCompatibility(cItems, pItems, path2 ? `${path2}[]` : "[]"));
+    }
+    return violations;
+  }
+  if (cType === "object" || consumerSchema["properties"]) {
+    const cProps = consumerSchema["properties"] ?? {};
+    const pProps = providerSchema["properties"] ?? {};
+    const cRequired = consumerSchema["required"] ?? [];
+    for (const field of cRequired) {
+      const fieldPath = path2 ? `${path2}.${field}` : field;
+      if (!(field in pProps)) {
+        violations.push({
+          type: "schema_incompatible",
+          message: `Consumer requires field "${fieldPath}" which is not defined in provider schema`,
+          path: fieldPath,
+          expected: "(defined)",
+          actual: "(absent)"
+        });
+      }
+    }
+    for (const [field, cPropSchema] of Object.entries(cProps)) {
+      if (field in pProps) {
+        const fieldPath = path2 ? `${path2}.${field}` : field;
+        violations.push(...checkSchemaCompatibility(
+          cPropSchema,
+          pProps[field],
+          fieldPath
+        ));
+      }
+    }
+  }
+  return violations;
+}
+function getProviderResponseSchema(spec, req, envVars, statusCode, requestBaseUrl) {
+  const url = req.url.replace(/\{\{([^}]+)\}\}/g, (_, k) => envVars[k] ?? `{{${k}}}`);
+  const match = findOperation(spec, req.method, url, requestBaseUrl);
+  if (!match) return null;
+  const responses = match.operation["responses"] ?? {};
+  const candidates = [String(statusCode), `${String(statusCode)[0]}xx`, "2XX", "2xx", "default"];
+  for (const candidate of candidates) {
+    const resp = responses[candidate];
+    if (resp) {
+      const resolved = resolveSchema(spec, resp);
+      const content = resolved["content"] ?? {};
+      const json = content["application/json"];
+      if (json?.["schema"]) {
+        return resolveSchema(spec, json["schema"]);
+      }
+    }
+  }
+  return null;
+}
+async function executeRequest(req, vars) {
+  const url = authBuilder.buildUrl(req.url, req.params, vars);
+  const start = Date.now();
+  try {
+    const headers = new undici.Headers();
+    for (const h of req.headers) {
+      if (h.enabled && h.key) headers.set(authBuilder.interpolate(h.key, vars), authBuilder.interpolate(h.value, vars));
+    }
+    const authHeaders = await authBuilder.buildAuthHeaders(req.auth, vars);
+    for (const [k, v] of Object.entries(authHeaders)) headers.set(k, v);
+    let body;
+    if (req.body.mode === "json" && req.body.json) {
+      body = authBuilder.interpolate(req.body.json, vars);
+      if (!headers.has("content-type")) headers.set("Content-Type", "application/json");
+    }
+    const resp = await undici.fetch(url, {
+      method: req.method,
+      headers,
+      body: !["GET", "HEAD"].includes(req.method) ? body : void 0
+    });
+    const bodyText = await resp.text();
+    const rawHdrs = {};
+    resp.headers.forEach((v, k) => {
+      rawHdrs[k] = v;
+    });
+    return { status: resp.status, headers: rawHdrs, body: bodyText, durationMs: Date.now() - start };
+  } catch (err) {
+    return err instanceof Error ? err : new Error(String(err));
+  }
+}
+async function runBidirectional(requests, envVars, collectionVars = {}, specUrl, specPath, requestBaseUrl) {
+  const spec = await loadSpec(specUrl, specPath);
+  const vars = { ...envVars, ...collectionVars };
+  const start = Date.now();
+  const contractRequests = requests.filter(
+    (r) => !r.disabled && r.contract && (r.contract.statusCode !== void 0 || r.contract.bodySchema || r.contract.headers?.length)
+  );
+  const results = await Promise.all(contractRequests.map(async (req) => {
+    const url = authBuilder.buildUrl(req.url, req.params, vars);
+    const violations = [];
+    const expectedStatus = req.contract.statusCode ?? 200;
+    const consumerSchema = req.contract.bodySchema ? (() => {
+      try {
+        return JSON.parse(req.contract.bodySchema);
+      } catch {
+        return null;
+      }
+    })() : null;
+    if (consumerSchema) {
+      const providerSchema = getProviderResponseSchema(spec, req, vars, expectedStatus, requestBaseUrl);
+      if (!providerSchema) {
+        violations.push({
+          type: "schema_incompatible",
+          message: `No response schema found in spec for ${req.method} ${url} → ${expectedStatus}`
+        });
+      } else {
+        violations.push(...checkSchemaCompatibility(consumerSchema, providerSchema));
+      }
+    }
+    const result = await executeRequest(req, vars);
+    if (result instanceof Error) {
+      violations.push({ type: "status_mismatch", message: `Request failed: ${result.message}` });
+      return { requestId: req.id, requestName: req.name, method: req.method, url, passed: false, violations };
+    }
+    const liveViolations = validateConsumerResponse(
+      req.contract,
+      result.status,
+      result.headers,
+      result.body
+    );
+    violations.push(...liveViolations);
+    return {
+      requestId: req.id,
+      requestName: req.name,
+      method: req.method,
+      url,
+      passed: violations.length === 0,
+      violations,
+      durationMs: result.durationMs,
+      actualStatus: result.status
+    };
+  }));
+  const passed = results.filter((r) => r.passed).length;
+  return {
+    mode: "bidirectional",
+    total: results.length,
+    passed,
+    failed: results.length - passed,
+    results,
+    durationMs: Date.now() - start
+  };
+}
+const SNAPSHOT_DIR = "contracts";
+function safeName(raw) {
+  return raw.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "spec";
+}
+function sha256(text) {
+  return crypto.createHash("sha256").update(text).digest("hex");
+}
+function detectFormat(source, contentType) {
+  const lc = source.toLowerCase();
+  if (lc.endsWith(".yaml") || lc.endsWith(".yml")) return "yaml";
+  if (lc.endsWith(".json")) return "json";
+  if (contentType.includes("yaml")) return "yaml";
+  return "json";
+}
+function tryExtractSpecVersion(specText, format) {
+  try {
+    const parsed = format === "yaml" ? jsYaml.load(specText) : JSON.parse(specText);
+    const info = parsed?.info;
+    if (info && typeof info.version === "string") return info.version;
+  } catch {
+  }
+  return void 0;
+}
+async function captureSnapshot(workspaceDir, opts) {
+  const { specUrl, specPath } = opts;
+  if (!specUrl && !specPath) throw new Error("captureSnapshot: specUrl or specPath is required");
+  let specText;
+  let format;
+  let source;
+  if (specUrl) {
+    const resp = await undici.fetch(specUrl);
+    if (!resp.ok) throw new Error(`HTTP ${resp.status} loading spec from ${specUrl}`);
+    specText = await resp.text();
+    format = detectFormat(specUrl, resp.headers.get("content-type") ?? "");
+    source = specUrl;
+  } else {
+    specText = await promises.readFile(specPath, "utf8");
+    format = detectFormat(specPath, "");
+    source = specPath;
+  }
+  const id = crypto.randomUUID();
+  const specVersion = tryExtractSpecVersion(specText, format);
+  let name = opts.name?.trim();
+  if (!name) {
+    try {
+      name = new URL(source).hostname;
+    } catch {
+      name = source.split(/[\\/]/).pop() ?? "spec";
+    }
+  }
+  if (specVersion && !name.includes(specVersion)) name = `${name} ${specVersion}`;
+  const snapshot = {
+    version: "1.0",
+    id,
+    name,
+    source,
+    capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    format,
+    specVersion,
+    spec: specText,
+    sha256: sha256(specText)
+  };
+  const relPath = path.join(SNAPSHOT_DIR, `${safeName(name)}-${id.slice(0, 8)}.contract.json`);
+  const absPath = path.resolve(workspaceDir, relPath);
+  await promises.mkdir(path.join(workspaceDir, SNAPSHOT_DIR), { recursive: true });
+  await promises.writeFile(absPath, JSON.stringify(snapshot, null, 2), "utf8");
+  Object.defineProperty(snapshot, "__relPath", { value: relPath, enumerable: false });
+  return snapshot;
+}
+function relPathOf(snapshot) {
+  const hidden = snapshot.__relPath;
+  return hidden;
+}
+async function loadSnapshot(workspaceDir, relPath) {
+  const raw = await promises.readFile(path.resolve(workspaceDir, relPath), "utf8");
+  return JSON.parse(raw);
+}
+async function listSnapshots(workspaceDir, registered = []) {
+  const seen = new Set(registered);
+  try {
+    const entries = await promises.readdir(path.join(workspaceDir, SNAPSHOT_DIR));
+    for (const f of entries) {
+      if (f.endsWith(".contract.json")) seen.add(path.join(SNAPSHOT_DIR, f));
+    }
+  } catch {
+  }
+  const out = [];
+  for (const relPath of seen) {
+    try {
+      const snapshot = await loadSnapshot(workspaceDir, relPath);
+      out.push({ relPath, snapshot });
+    } catch {
+    }
+  }
+  out.sort((a, b) => b.snapshot.capturedAt.localeCompare(a.snapshot.capturedAt));
+  return out;
+}
+async function deleteSnapshot(workspaceDir, relPath) {
+  try {
+    await promises.unlink(path.resolve(workspaceDir, relPath));
+  } catch {
+  }
+}
+exports.captureSnapshot = captureSnapshot;
+exports.deleteSnapshot = deleteSnapshot;
+exports.listSnapshots = listSnapshots;
+exports.loadSnapshot = loadSnapshot;
+exports.relPathOf = relPathOf;
+exports.runBidirectional = runBidirectional;
+exports.runConsumerContracts = runConsumerContracts;
+exports.runProviderVerification = runProviderVerification;