@kirrosh/zond 0.26.1 → 0.27.1

package/src/core/runner/assertions.ts

@@ -1,383 +0,0 @@
-import type { TestStepExpect, AssertionRule } from "../parser/types.ts";
-import type { HttpResponse, AssertionResult } from "./types.ts";
-import { getByPath } from "../utils.ts";
-
-function checkType(value: unknown, expectedType: string): boolean {
-  switch (expectedType) {
-    case "string": return typeof value === "string";
-    case "integer": return typeof value === "number" && Number.isInteger(value);
-    case "number": return typeof value === "number";
-    case "boolean": return typeof value === "boolean";
-    case "array": return Array.isArray(value);
-    case "object": return typeof value === "object" && value !== null && !Array.isArray(value);
-    case "null": return value === null;
-    default: return false;
-  }
-}
-
-function describeType(value: unknown): string {
-  if (value === null) return "null";
-  if (value === undefined) return "undefined";
-  if (Array.isArray(value)) return "array";
-  if (typeof value === "number" && Number.isInteger(value)) return "integer";
-  return typeof value;
-}
-
-function deepEquals(a: unknown, b: unknown): boolean {
-  if (a === b) return true;
-  // Loose numeric comparison: "123" == 123
-  if (typeof a === "number" && typeof b === "string") return a === Number(b);
-  if (typeof a === "string" && typeof b === "number") return Number(a) === b;
-  if (typeof a !== typeof b) return false;
-  if (typeof a !== "object" || a === null || b === null) return false;
-  return Bun.deepEquals(a, b);
-}
-
-function checkRule(path: string, rule: AssertionRule, actual: unknown): AssertionResult[] {
-  const results: AssertionResult[] = [];
-  const field = `body.${path}`;
-
-  if (rule.exists !== undefined) {
-    // Key-presence semantics: null counts as "exists" (key present in response).
-    // Use `not_equals: null` or `type: "null"` to assert non-null specifically.
-    const doesExist = actual !== undefined;
-    results.push({
-      field, rule: `exists ${rule.exists}`,
-      passed: doesExist === rule.exists, actual: doesExist, expected: rule.exists,
-    });
-  }
-
-  if (rule.type !== undefined) {
-    results.push({
-      field, rule: `type ${rule.type}`,
-      passed: checkType(actual, rule.type), actual: describeType(actual), expected: rule.type,
-    });
-  }
-
-  if (rule.equals !== undefined) {
-    results.push({
-      field, rule: `equals ${JSON.stringify(rule.equals)}`,
-      passed: deepEquals(actual, rule.equals), actual, expected: rule.equals,
-    });
-  }
-
-  if (rule.contains !== undefined) {
-    const passed = typeof actual === "string" && actual.includes(rule.contains);
-    results.push({
-      field, rule: `contains "${rule.contains}"`,
-      passed, actual, expected: rule.contains,
-    });
-  }
-
-  if (rule.matches !== undefined) {
-    const passed = typeof actual === "string" && new RegExp(rule.matches).test(actual);
-    results.push({
-      field, rule: `matches ${rule.matches}`,
-      passed, actual, expected: rule.matches,
-    });
-  }
-
-  if (rule.gt !== undefined) {
-    const passed = typeof actual === "number" && actual > rule.gt;
-    results.push({
-      field, rule: `gt ${rule.gt}`,
-      passed, actual, expected: rule.gt,
-    });
-  }
-
-  if (rule.lt !== undefined) {
-    const passed = typeof actual === "number" && actual < rule.lt;
-    results.push({
-      field, rule: `lt ${rule.lt}`,
-      passed, actual, expected: rule.lt,
-    });
-  }
-
-  if (rule.not_equals !== undefined) {
-    results.push({
-      field, rule: `not_equals ${JSON.stringify(rule.not_equals)}`,
-      passed: !deepEquals(actual, rule.not_equals), actual, expected: rule.not_equals,
-    });
-  }
-
-  if (rule.not_contains !== undefined) {
-    const passed = typeof actual === "string" && !actual.includes(rule.not_contains);
-    results.push({
-      field, rule: `not_contains "${rule.not_contains}"`,
-      passed, actual, expected: rule.not_contains,
-    });
-  }
-
-  if (rule.gte !== undefined) {
-    const passed = typeof actual === "number" && actual >= rule.gte;
-    results.push({
-      field, rule: `gte ${rule.gte}`,
-      passed, actual, expected: rule.gte,
-    });
-  }
-
-  if (rule.lte !== undefined) {
-    const passed = typeof actual === "number" && actual <= rule.lte;
-    results.push({
-      field, rule: `lte ${rule.lte}`,
-      passed, actual, expected: rule.lte,
-    });
-  }
-
-  if (rule.length !== undefined) {
-    const hasLength = (Array.isArray(actual) || typeof actual === "string");
-    const passed = hasLength && (actual as string | unknown[]).length === rule.length;
-    results.push({
-      field, rule: `length ${rule.length}`,
-      passed, actual: hasLength ? (actual as string | unknown[]).length : describeType(actual), expected: rule.length,
-    });
-  }
-
-  if (rule.length_gt !== undefined) {
-    const hasLength = (Array.isArray(actual) || typeof actual === "string");
-    const passed = hasLength && (actual as string | unknown[]).length > rule.length_gt;
-    results.push({
-      field, rule: `length_gt ${rule.length_gt}`,
-      passed, actual: hasLength ? (actual as string | unknown[]).length : describeType(actual), expected: rule.length_gt,
-    });
-  }
-
-  if (rule.length_gte !== undefined) {
-    const hasLength = (Array.isArray(actual) || typeof actual === "string");
-    const passed = hasLength && (actual as string | unknown[]).length >= rule.length_gte;
-    results.push({
-      field, rule: `length_gte ${rule.length_gte}`,
-      passed, actual: hasLength ? (actual as string | unknown[]).length : describeType(actual), expected: rule.length_gte,
-    });
-  }
-
-  if (rule.length_lt !== undefined) {
-    const hasLength = (Array.isArray(actual) || typeof actual === "string");
-    const passed = hasLength && (actual as string | unknown[]).length < rule.length_lt;
-    results.push({
-      field, rule: `length_lt ${rule.length_lt}`,
-      passed, actual: hasLength ? (actual as string | unknown[]).length : describeType(actual), expected: rule.length_lt,
-    });
-  }
-
-  if (rule.length_lte !== undefined) {
-    const hasLength = (Array.isArray(actual) || typeof actual === "string");
-    const passed = hasLength && (actual as string | unknown[]).length <= rule.length_lte;
-    results.push({
-      field, rule: `length_lte ${rule.length_lte}`,
-      passed, actual: hasLength ? (actual as string | unknown[]).length : describeType(actual), expected: rule.length_lte,
-    });
-  }
-
-  if (rule.each !== undefined) {
-    if (!Array.isArray(actual)) {
-      results.push({ field, rule: "each", passed: false, actual: describeType(actual), expected: "array" });
-    } else {
-      for (let i = 0; i < actual.length; i++) {
-        for (const [subPath, subRule] of Object.entries(rule.each)) {
-          const subActual = getByPath(actual[i], subPath);
-          const subResults = checkRule(`${path}[${i}].${subPath}`, subRule, subActual);
-          results.push(...subResults);
-        }
-      }
-    }
-  }
-
-  if (rule.contains_item !== undefined) {
-    if (!Array.isArray(actual)) {
-      results.push({ field, rule: "contains_item", passed: false, actual: describeType(actual), expected: "array" });
-    } else {
-      const found = actual.some((item) => {
-        for (const [subPath, subRule] of Object.entries(rule.contains_item!)) {
-          const subActual = getByPath(item, subPath);
-          const subResults = checkRule("", subRule, subActual);
-          if (subResults.some(r => !r.passed)) return false;
-        }
-        return true;
-      });
-      results.push({
-        field, rule: "contains_item",
-        passed: found, actual: `array(${actual.length})`, expected: "at least one matching item",
-      });
-    }
-  }
-
-  if (rule.set_equals !== undefined) {
-    if (!Array.isArray(actual) || !Array.isArray(rule.set_equals)) {
-      results.push({
-        field, rule: "set_equals",
-        passed: false, actual: describeType(actual), expected: "both must be arrays",
-      });
-    } else {
-      const actualSet = new Set(actual.map(v => JSON.stringify(v)));
-      const expectedSet = new Set((rule.set_equals as unknown[]).map(v => JSON.stringify(v)));
-      const passed = actualSet.size === expectedSet.size && [...actualSet].every(v => expectedSet.has(v));
-      results.push({
-        field, rule: "set_equals",
-        passed, actual, expected: rule.set_equals,
-      });
-    }
-  }
-
-  return results;
-}
-
-export function checkAssertions(expect: TestStepExpect, response: HttpResponse): AssertionResult[] {
-  const results: AssertionResult[] = [];
-
-  if (expect.status !== undefined) {
-    const allowed = Array.isArray(expect.status) ? expect.status : [expect.status];
-    results.push({
-      field: "status",
-      rule: allowed.length === 1 ? `equals ${allowed[0]}` : `one of [${allowed.join(", ")}]`,
-      passed: allowed.includes(response.status),
-      actual: response.status,
-      expected: expect.status,
-      kind: "primary",
-    });
-  }
-
-  if (expect.duration !== undefined) {
-    results.push({
-      field: "duration",
-      rule: `lte ${expect.duration}ms`,
-      passed: response.duration_ms <= expect.duration,
-      actual: response.duration_ms,
-      expected: expect.duration,
-      kind: "auxiliary",
-    });
-  }
-
-  if (expect.headers) {
-    for (const [key, rule] of Object.entries(expect.headers)) {
-      const actual = response.headers[key.toLowerCase()];
-      if (typeof rule === "string") {
-        results.push({
-          field: `headers.${key}`,
-          rule: `equals "${rule}"`,
-          passed: actual === rule,
-          actual,
-          expected: rule,
-          kind: "auxiliary",
-        });
-      } else {
-        // AssertionRule in header — supports capture and other checks
-        const ruleResults = checkRule(key, rule, actual).map(r => ({
-          ...r,
-          field: r.field.replace(/^body\./, "headers."),
-          kind: "auxiliary" as const,
-        }));
-        results.push(...ruleResults);
-      }
-    }
-  }
-
-  if (expect.body && response.body_parsed !== undefined) {
-    for (const [path, rule] of Object.entries(expect.body)) {
-      let actual: unknown;
-      if (path === "_body") {
-        actual = response.body_parsed;
-      } else if (path.startsWith("_body.")) {
-        actual = getByPath(response.body_parsed, path.slice(6));
-      } else {
-        actual = getByPath(response.body_parsed, path);
-      }
-      const bodyResults = checkRule(path, rule, actual).map((r) => ({
-        ...r,
-        kind: "primary" as const,
-      }));
-      results.push(...bodyResults);
-    }
-  }
-
-  return results;
-}
-
-export function extractCaptures(
-  bodyRules: Record<string, AssertionRule> | undefined,
-  responseBody: unknown,
-  headerRules?: Record<string, string | AssertionRule>,
-  responseHeaders?: Record<string, string>,
-): Record<string, unknown> {
-  const captures: Record<string, unknown> = {};
-
-  if (bodyRules && responseBody !== undefined) {
-    for (const [path, rule] of Object.entries(bodyRules)) {
-      if (rule.capture) {
-        let value: unknown;
-        if (path === "_body") {
-          value = responseBody;
-        } else if (path.startsWith("_body.")) {
-          value = getByPath(responseBody, path.slice(6));
-        } else {
-          value = getByPath(responseBody, path);
-        }
-        if (value !== undefined) {
-          captures[rule.capture] = value;
-        }
-      }
-    }
-  }
-
-  if (headerRules && responseHeaders) {
-    for (const [key, rule] of Object.entries(headerRules)) {
-      if (typeof rule !== "string" && rule.capture) {
-        const value = responseHeaders[key.toLowerCase()];
-        if (value !== undefined) {
-          captures[rule.capture] = value;
-        }
-      }
-    }
-  }
-
-  return captures;
-}
-
-/**
- * Find capture rules whose path didn't resolve in the response, returning
- * `{ var, source, path }` per miss. Surfaced as auxiliary assertion failures
- * so the user sees "captures: {}" with a reason instead of silent emptiness —
- * the empty-captures pitfall is the #1 footgun in CRUD chains because the
- * downstream step is silently skipped or runs with `undefined`. TASK-256.
- */
-export function findMissedCaptures(
-  bodyRules: Record<string, AssertionRule> | undefined,
-  responseBody: unknown,
-  headerRules?: Record<string, string | AssertionRule>,
-  responseHeaders?: Record<string, string>,
-): Array<{ var: string; source: "body" | "header"; path: string }> {
-  const misses: Array<{ var: string; source: "body" | "header"; path: string }> = [];
-
-  if (bodyRules) {
-    for (const [path, rule] of Object.entries(bodyRules)) {
-      if (!rule.capture) continue;
-      if (responseBody === undefined) {
-        misses.push({ var: rule.capture, source: "body", path });
-        continue;
-      }
-      let value: unknown;
-      if (path === "_body") {
-        value = responseBody;
-      } else if (path.startsWith("_body.")) {
-        value = getByPath(responseBody, path.slice(6));
-      } else {
-        value = getByPath(responseBody, path);
-      }
-      if (value === undefined) {
-        misses.push({ var: rule.capture, source: "body", path });
-      }
-    }
-  }
-
-  if (headerRules) {
-    for (const [key, rule] of Object.entries(headerRules)) {
-      if (typeof rule === "string" || !rule.capture) continue;
-      const value = responseHeaders ? responseHeaders[key.toLowerCase()] : undefined;
-      if (value === undefined) {
-        misses.push({ var: rule.capture, source: "header", path: key });
-      }
-    }
-  }
-
-  return misses;
-}

package/src/core/runner/async-pool.ts

@@ -1,108 +0,0 @@
-/**
- * ARV-8 (m-15): bounded async-pool for `zond checks run --workers N`.
- *
- * Cooperative concurrency on a single Bun event loop — no threading,
- * no Workers, just N coroutines that pull from a shared cursor. The
- * design choice is deliberate:
- *
- *   * Threads/Workers would need request-context plumbing (auth headers,
- *     rate-limiter state, per-run schema validators are not transferable
- *     without serialization), and Bun's HTTP client is already
- *     non-blocking — so cooperative concurrency is faster *and* simpler.
- *   * `Promise.all(items.map(fn))` would saturate at items.length, which
- *     defeats the rate-limiter and tends to drown small mock servers.
- *
- * `runPool` preserves input order in the result array — callers (the
- * checks runner, mainly) want to merge per-op findings deterministically
- * regardless of which worker finished first.
- */
-import os from "node:os";
-
-const WORKERS_MIN = 1;
-const WORKERS_MAX = 64;
-/** `--workers auto` ceiling — beyond ~8 the gains on a typical mock
- *  server are dominated by network/IO contention, not parallelism. */
-const WORKERS_AUTO_CEILING = 8;
-
-/**
- * Run `fn` over `items` with at most `workers` in-flight at once.
- *
- * Results are returned in input order, *not* completion order — keep
- * call-sites that compose findings/snapshots deterministic.
- *
- * Errors propagate: the first rejection cancels remaining workers'
- * dispatch (they finish their in-flight task and exit). Caller should
- * `try/catch` if it wants partial results — none of zond's callers do
- * today (a runner crash is fatal anyway).
- */
-export async function runPool<T, R>(
-  items: readonly T[],
-  workers: number,
-  fn: (item: T, index: number) => Promise<R>,
-): Promise<R[]> {
-  if (items.length === 0) return [];
-  // Effective worker count is clamped both ways: never more than items
-  // (idle workers waste a closure), never below 1 (else nothing runs).
-  const effective = Math.max(1, Math.min(workers, items.length));
-  // Sequential fast-path — preserves the *exact* old behaviour
-  // (microtask ordering, error timing) for AC #4 backward-compat.
-  if (effective === 1) {
-    const out: R[] = new Array(items.length);
-    for (let i = 0; i < items.length; i++) {
-      out[i] = await fn(items[i]!, i);
-    }
-    return out;
-  }
-  const out: R[] = new Array(items.length);
-  let cursor = 0;
-  let aborted: unknown = null;
-  async function worker(): Promise<void> {
-    while (true) {
-      if (aborted !== null) return;
-      const i = cursor++;
-      if (i >= items.length) return;
-      try {
-        out[i] = await fn(items[i]!, i);
-      } catch (err) {
-        // First rejection wins — store it, drain in-flight tasks, then
-        // re-throw at the join point.
-        if (aborted === null) aborted = err;
-        return;
-      }
-    }
-  }
-  const swarm: Promise<void>[] = [];
-  for (let w = 0; w < effective; w++) swarm.push(worker());
-  await Promise.all(swarm);
-  if (aborted !== null) throw aborted;
-  return out;
-}
-
-/**
- * Parse a `--workers` flag value:
- *
- *   undefined      → 1 (backward-compat default — AC #4)
- *   "auto" / "AUTO"→ min(cpus, WORKERS_AUTO_CEILING) (AC #5)
- *   numeric        → clamp [1, 64] (AC #5)
- *   anything else  → throws (caller maps to a friendly CLI error)
- */
-export function parseWorkers(value: string | number | undefined): number {
-  if (value === undefined || value === null || value === "") return 1;
-  if (typeof value === "string") {
-    const trimmed = value.trim().toLowerCase();
-    if (trimmed === "auto") {
-      return Math.max(WORKERS_MIN, Math.min(os.cpus().length, WORKERS_AUTO_CEILING));
-    }
-    const n = Number.parseInt(trimmed, 10);
-    if (!Number.isFinite(n)) throw new Error(`Invalid --workers value: "${value}"`);
-    return Math.max(WORKERS_MIN, Math.min(n, WORKERS_MAX));
-  }
-  if (!Number.isFinite(value)) throw new Error(`Invalid --workers value: ${value}`);
-  return Math.max(WORKERS_MIN, Math.min(Math.trunc(value), WORKERS_MAX));
-}
-
-export const WORKERS_LIMITS = {
-  min: WORKERS_MIN,
-  max: WORKERS_MAX,
-  autoCeiling: WORKERS_AUTO_CEILING,
-} as const;

package/src/core/runner/auth-path.ts

@@ -1,8 +0,0 @@
-/**
- * Heuristic for "auth-shaped" endpoint paths used by `--safe` mode and
- * the env-symptom diagnostics in `db-analysis.ts`. Anything matching is
- * treated as a login/refresh route — `--safe` whitelists it for live
- * runs, and the diagnostics flag concentrated POST failures here as
- * `auth_required` rather than per-endpoint bugs.
- */
-export const AUTH_PATH_RE = /\/(auth|login|signin|token|oauth)\b/i;

package/src/core/runner/ci-context.ts

@@ -1,72 +0,0 @@
-/**
- * TASK-116: detect CI context (commit sha, branch, trigger) from common
- * environment variables. Returns `null` for fields when nothing is present
- * — caller decides whether to default `trigger` to `"manual"`.
- *
- * Supported providers (autodetected — no opt-in required):
- *   GitHub Actions  GITHUB_ACTIONS=true, GITHUB_SHA, GITHUB_REF_NAME
- *   GitLab CI       GITLAB_CI=true, CI_COMMIT_SHA, CI_COMMIT_REF_NAME
- *   CircleCI        CIRCLECI=true, CIRCLE_SHA1, CIRCLE_BRANCH
- *   Buildkite       BUILDKITE=true, BUILDKITE_COMMIT, BUILDKITE_BRANCH
- *   Jenkins         JENKINS_URL set, GIT_COMMIT, BRANCH_NAME / GIT_BRANCH
- *   Generic         CI=true triggers `trigger=ci` even when no provider
- *                   matches — caller can still pass nullable commit/branch.
- *
- * Manual override is via the explicit `--commit-sha` / `--branch` /
- * `--trigger` flags or the env vars `ZOND_COMMIT_SHA` / `ZOND_BRANCH` /
- * `ZOND_TRIGGER`. These win over autodetection.
- */
-export interface CiContext {
-  trigger: "ci" | "manual";
-  commit_sha: string | null;
-  branch: string | null;
-  /** Provider tag (github-actions / gitlab-ci / circleci / …) for diagnostics. */
-  provider: string | null;
-}
-
-export function detectCiContext(env: NodeJS.ProcessEnv = process.env): CiContext {
-  const overrideCommit = env.ZOND_COMMIT_SHA?.trim() || null;
-  const overrideBranch = env.ZOND_BRANCH?.trim() || null;
-  const overrideTrigger = env.ZOND_TRIGGER?.trim() || null;
-
-  let provider: string | null = null;
-  let commit: string | null = null;
-  let branch: string | null = null;
-
-  if (env.GITHUB_ACTIONS === "true") {
-    provider = "github-actions";
-    commit = env.GITHUB_SHA?.trim() || null;
-    branch = env.GITHUB_REF_NAME?.trim() || env.GITHUB_HEAD_REF?.trim() || null;
-  } else if (env.GITLAB_CI === "true") {
-    provider = "gitlab-ci";
-    commit = env.CI_COMMIT_SHA?.trim() || null;
-    branch = env.CI_COMMIT_REF_NAME?.trim() || null;
-  } else if (env.CIRCLECI === "true") {
-    provider = "circleci";
-    commit = env.CIRCLE_SHA1?.trim() || null;
-    branch = env.CIRCLE_BRANCH?.trim() || null;
-  } else if (env.BUILDKITE === "true") {
-    provider = "buildkite";
-    commit = env.BUILDKITE_COMMIT?.trim() || null;
-    branch = env.BUILDKITE_BRANCH?.trim() || null;
-  } else if (env.JENKINS_URL) {
-    provider = "jenkins";
-    commit = env.GIT_COMMIT?.trim() || null;
-    branch = env.BRANCH_NAME?.trim() || env.GIT_BRANCH?.trim() || null;
-  }
-
-  const inferredCi = !!provider || env.CI === "true" || env.CI === "1";
-  const trigger: "ci" | "manual" =
-    overrideTrigger === "ci" || overrideTrigger === "manual"
-      ? overrideTrigger
-      : inferredCi
-        ? "ci"
-        : "manual";
-
-  return {
-    trigger,
-    commit_sha: overrideCommit ?? commit,
-    branch: overrideBranch ?? branch,
-    provider: provider ?? (inferredCi ? "generic" : null),
-  };
-}