@kirrosh/zond 0.22.0 → 0.23.0

package/src/web/data/collection-state.ts

@@ -1,362 +0,0 @@
-/**
- * Unified collection state builder for Web UI.
- * Aggregates spec endpoints, disk suites, coverage, run results, warnings, env diagnostics.
- */
-
-import type { CollectionRecord, RunRecord, StoredStepResult } from "../../db/queries.ts";
-import { listRunsByCollection, getResultsByRunId, getRunById } from "../../db/queries.ts";
-import type { EndpointWarning } from "../../core/generator/endpoint-warnings.ts";
-import { envHint, statusHint, classifyFailure, computeSharedEnvIssue } from "../../core/diagnostics/failure-hints.ts";
-import { join, basename } from "node:path";
-
-// ── Types ──
-
-export interface CoveringStep {
-  suiteName: string;
-  file: string;            // relative filename (e.g. "auth-login.yaml")
-  stepName: string;
-  status: "pass" | "fail" | "error" | "skip" | null; // null = not run
-  responseStatus?: number;
-  durationMs?: number;
-  hint?: string;           // failure hint
-  assertions?: { field: string; rule: string; passed: boolean; actual?: unknown; expected?: unknown }[];
-}
-
-export interface EndpointViewState {
-  method: string;
-  path: string;
-  summary?: string;
-  deprecated: boolean;
-  hasCoverage: boolean;
-  runStatus: "passing" | "api_error" | "test_failed" | "not_run" | "no_tests";
-  warnings: string[];
-  coveringFiles: string[];
-  coveringSteps: CoveringStep[];
-}
-
-export interface StepViewState {
-  name: string;
-  status: "pass" | "fail" | "error" | "skip";
-  durationMs?: number;
-  requestMethod?: string;
-  requestUrl?: string;
-  requestBody?: string;
-  responseStatus?: number;
-  responseBody?: string;
-  assertions?: { field: string; rule: string; passed: boolean; actual?: unknown; expected?: unknown }[];
-  captures?: Record<string, unknown>;
-  hint?: string;
-  errorMessage?: string;
-}
-
-export interface SuiteViewState {
-  name: string;
-  description?: string;
-  tags: string[];
-  stepCount: number;
-  filePath: string;
-  status: "passed" | "failed" | "not_run" | "parse_error";
-  runResult?: { passed: number; failed: number; skipped: number };
-  parseError?: string;
-  steps: StepViewState[];
-}
-
-export interface CollectionState {
-  collection: CollectionRecord;
-  endpoints: EndpointViewState[];
-  totalEndpoints: number;
-  coveragePct: number;
-  coveredCount: number;
-  suites: SuiteViewState[];
-  latestRun: RunRecord | null;
-  latestRunResults: StoredStepResult[];
-  envAlert: string | null;
-  warnings: EndpointWarning[];
-  // Run stats
-  runPassed: number;
-  runFailed: number;
-  runSkipped: number;
-  runTotal: number;
-  runDurationMs: number | null;
-}
-
-// ── Cache ──
-
-interface CacheEntry {
-  state: CollectionState;
-  timestamp: number;
-}
-
-const cache = new Map<number, CacheEntry>();
-const CACHE_TTL_MS = 30_000;
-
-export function invalidateCollectionCache(collectionId: number): void {
-  cache.delete(collectionId);
-}
-
-// ── Builder ──
-
-export async function buildCollectionState(collection: CollectionRecord): Promise<CollectionState> {
-  const cached = cache.get(collection.id);
-  if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) {
-    return cached.state;
-  }
-
-  // Load spec endpoints
-  let specEndpoints: import("../../core/generator/types.ts").EndpointInfo[] = [];
-  let warnings: EndpointWarning[] = [];
-  if (collection.openapi_spec) {
-    try {
-      const { readOpenApiSpec, extractEndpoints } = await import("../../core/generator/openapi-reader.ts");
-      const { analyzeEndpoints } = await import("../../core/generator/endpoint-warnings.ts");
-      const doc = await readOpenApiSpec(collection.openapi_spec);
-      specEndpoints = extractEndpoints(doc);
-      warnings = analyzeEndpoints(specEndpoints);
-    } catch { /* spec unavailable */ }
-  }
-
-  // Scan coverage from disk
-  const { scanCoveredEndpoints } = await import("../../core/generator/coverage-scanner.ts");
-  const { specPathToRegex, normalizePath } = await import("../../core/generator/coverage-scanner.ts");
-  let coveredEndpoints: import("../../core/generator/coverage-scanner.ts").CoveredEndpoint[] = [];
-  try {
-    coveredEndpoints = await scanCoveredEndpoints(collection.test_path);
-  } catch { /* no tests on disk */ }
-
-  // Parse suites from disk
-  const { parseDirectorySafe } = await import("../../core/parser/yaml-parser.ts");
-  let diskSuites: import("../../core/parser/yaml-parser.ts").ParseDirectoryResult = { suites: [], errors: [] };
-  try {
-    diskSuites = await parseDirectorySafe(collection.test_path);
-  } catch { /* test dir missing */ }
-
-  // Get latest run
-  const runs = listRunsByCollection(collection.id, 1, 0);
-  const latestRun = runs.length > 0 ? (getRunById(runs[0]!.id) ?? null) : null;
-  const latestRunResults = latestRun ? getResultsByRunId(latestRun.id) : [];
-
-  // Build result maps: suite_name -> step statuses
-  const suiteResultMap = new Map<string, StoredStepResult[]>();
-  for (const r of latestRunResults) {
-    const list = suiteResultMap.get(r.suite_name) ?? [];
-    list.push(r);
-    suiteResultMap.set(r.suite_name, list);
-  }
-
-  // Build endpoint -> run status map
-  // key: "METHOD /path" from results
-  const endpointRunStatusMap = new Map<string, "passing" | "api_error" | "test_failed">();
-  for (const r of latestRunResults) {
-    if (r.request_method && r.request_url) {
-      // Extract path from URL
-      let urlPath: string;
-      try {
-        const u = new URL(r.request_url);
-        urlPath = u.pathname;
-      } catch {
-        urlPath = r.request_url;
-      }
-      const key = `${r.request_method} ${normalizePath(urlPath)}`;
-      const current = endpointRunStatusMap.get(key);
-      if (r.status === "fail" || r.status === "error") {
-        const ft = classifyFailure(r.status, r.response_status);
-        endpointRunStatusMap.set(key, ft === "api_error" ? "api_error" : "test_failed");
-      } else if (r.status === "pass" && current !== "test_failed" && current !== "api_error") {
-        endpointRunStatusMap.set(key, "passing");
-      }
-    }
-  }
-
-  // Build endpoint view states
-  const warningsMap = new Map<string, string[]>();
-  for (const w of warnings) {
-    warningsMap.set(`${w.method} ${w.path}`, w.warnings);
-  }
-
-  // Build map: normalized "METHOD /path" -> list of StoredStepResult
-  const resultsByEndpoint = new Map<string, StoredStepResult[]>();
-  for (const r of latestRunResults) {
-    if (r.request_method && r.request_url) {
-      let urlPath: string;
-      try { urlPath = new URL(r.request_url).pathname; } catch { urlPath = r.request_url; }
-      const key = `${r.request_method} ${normalizePath(urlPath)}`;
-      const list = resultsByEndpoint.get(key) ?? [];
-      list.push(r);
-      resultsByEndpoint.set(key, list);
-    }
-  }
-
-  // Map suite name -> file basename for display
-  const suiteNameToFile = new Map<string, string>();
-  for (const s of diskSuites.suites) {
-    suiteNameToFile.set(s.name, basename(s.filePath ?? s.name));
-  }
-
-  // Env file path for hints
-  const envFilePath = collection.base_dir
-    ? join(collection.base_dir, ".env.yaml").replace(/\\/g, "/")
-    : undefined;
-
-  const endpoints: EndpointViewState[] = specEndpoints.map(ep => {
-    const specRegex = specPathToRegex(ep.path);
-    const covering = coveredEndpoints.filter(
-      c => c.method === ep.method && specRegex.test(normalizePath(c.path)),
-    );
-    const hasCoverage = covering.length > 0;
-
-    // Determine run status
-    let runStatus: EndpointViewState["runStatus"] = "no_tests";
-    if (hasCoverage) {
-      runStatus = "not_run";
-      for (const [key, status] of endpointRunStatusMap) {
-        const [method, path] = [key.split(" ")[0], key.split(" ").slice(1).join(" ")];
-        if (method === ep.method && specRegex.test(path!)) {
-          runStatus = status;
-          break;
-        }
-      }
-    }
-
-    // Build covering steps from run results
-    const coveringSteps: CoveringStep[] = [];
-    for (const [key, results] of resultsByEndpoint) {
-      const [method, path] = [key.split(" ")[0], key.split(" ").slice(1).join(" ")];
-      if (method === ep.method && specRegex.test(path!)) {
-        for (const r of results) {
-          const hint = (r.status === "fail" || r.status === "error")
-            ? (envHint(r.request_url, r.error_message, envFilePath) ?? statusHint(r.response_status) ?? undefined)
-            : undefined;
-          coveringSteps.push({
-            suiteName: r.suite_name,
-            file: suiteNameToFile.get(r.suite_name) ?? r.suite_name,
-            stepName: r.test_name,
-            status: r.status as CoveringStep["status"],
-            responseStatus: r.response_status ?? undefined,
-            durationMs: r.duration_ms ?? undefined,
-            hint,
-            assertions: Array.isArray(r.assertions) ? r.assertions : undefined,
-          });
-        }
-      }
-    }
-
-    return {
-      method: ep.method,
-      path: ep.path,
-      summary: ep.summary,
-      deprecated: ep.deprecated ?? false,
-      hasCoverage,
-      runStatus,
-      warnings: warningsMap.get(`${ep.method} ${ep.path}`) ?? [],
-      coveringFiles: covering.map(c => c.file),
-      coveringSteps,
-    };
-  });
-
-  // Coverage stats
-  const totalEndpoints = endpoints.length;
-  const coveredCount = endpoints.filter(e => e.hasCoverage).length;
-  const coveragePct = totalEndpoints > 0 ? Math.round((coveredCount / totalEndpoints) * 100) : 0;
-
-  // Build suite view states
-  const suites: SuiteViewState[] = diskSuites.suites.map(s => {
-    const results = suiteResultMap.get(s.name);
-    let status: SuiteViewState["status"] = "not_run";
-    let runResult: SuiteViewState["runResult"] | undefined;
-    const steps: StepViewState[] = [];
-
-    if (results) {
-      const passed = results.filter(r => r.status === "pass").length;
-      const failed = results.filter(r => r.status === "fail" || r.status === "error").length;
-      const skipped = results.filter(r => r.status === "skip").length;
-      runResult = { passed, failed, skipped };
-      status = failed > 0 ? "failed" : "passed";
-
-      for (const r of results) {
-        const hint = (r.status === "fail" || r.status === "error")
-          ? (envHint(r.request_url, r.error_message, envFilePath) ?? statusHint(r.response_status) ?? undefined)
-          : undefined;
-        steps.push({
-          name: r.test_name,
-          status: r.status as StepViewState["status"],
-          durationMs: r.duration_ms ?? undefined,
-          requestMethod: r.request_method ?? undefined,
-          requestUrl: r.request_url ?? undefined,
-          requestBody: r.request_body ?? undefined,
-          responseStatus: r.response_status ?? undefined,
-          responseBody: r.response_body ?? undefined,
-          assertions: Array.isArray(r.assertions) ? r.assertions : undefined,
-          captures: r.captures && typeof r.captures === "object" ? r.captures as Record<string, unknown> : undefined,
-          hint,
-          errorMessage: r.error_message ?? undefined,
-        });
-      }
-    }
-
-    return {
-      name: s.name,
-      description: s.description,
-      tags: s.tags ?? [],
-      stepCount: s.tests.length,
-      filePath: s.filePath ?? "",
-      status,
-      runResult,
-      steps,
-    };
-  });
-
-  // Add parse errors as suites
-  for (const err of diskSuites.errors) {
-    suites.push({
-      name: err.file,
-      tags: [],
-      stepCount: 0,
-      filePath: err.file,
-      status: "parse_error",
-      parseError: err.error,
-      steps: [],
-    });
-  }
-
-  // Env diagnostics
-  let envAlert: string | null = null;
-  const failedResults = latestRunResults.filter(r => r.status === "fail" || r.status === "error");
-  if (failedResults.length > 0) {
-    const envFilePath = collection.base_dir
-      ? join(collection.base_dir, ".env.yaml").replace(/\\/g, "/")
-      : undefined;
-
-    const failuresWithHints = failedResults.map(r => ({
-      hint: envHint(r.request_url, r.error_message, envFilePath) ?? undefined,
-    }));
-    envAlert = computeSharedEnvIssue(failuresWithHints, envFilePath);
-  }
-
-  // Run stats
-  const runPassed = latestRun?.passed ?? 0;
-  const runFailed = latestRun?.failed ?? 0;
-  const runSkipped = latestRun?.skipped ?? 0;
-  const runTotal = latestRun?.total ?? 0;
-  const runDurationMs = latestRun?.duration_ms ?? null;
-
-  const state: CollectionState = {
-    collection,
-    endpoints,
-    totalEndpoints,
-    coveragePct,
-    coveredCount,
-    suites,
-    latestRun,
-    latestRunResults,
-    envAlert,
-    warnings,
-    runPassed,
-    runFailed,
-    runSkipped,
-    runTotal,
-    runDurationMs,
-  };
-
-  cache.set(collection.id, { state, timestamp: Date.now() });
-  return state;
-}

package/src/web/routes/api.ts

@@ -1,314 +0,0 @@
-import { OpenAPIHono, createRoute } from "@hono/zod-openapi";
-import { getRunById, getResultsByRunId } from "../../db/queries.ts";
-import { generateJunitXml } from "../../core/reporter/junit.ts";
-import { executeRun } from "../../core/runner/execute-run.ts";
-import { statusBadge, renderSuiteResults, failedFilterToggle, autoExpandFailedScript } from "../views/results.ts";
-import { formatDuration } from "../../core/reporter/console.ts";
-import type { TestRunResult, StepResult } from "../../core/runner/types.ts";
-import {
-  ErrorSchema,
-  RunRequestSchema,
-  RunResponseSchema,
-  RunDetailSchema,
-  RunIdParam,
-} from "../schemas.ts";
-import { renderProxyResponse, renderProxyError } from "../views/explorer-tab.ts";
-
-const api = new OpenAPIHono();
-
-// ──────────────────────────────────────────────
-// POST /run — form-data handler for HTMX
-// ──────────────────────────────────────────────
-
-api.post("/run", async (c) => {
-  try {
-    const form = await c.req.parseBody();
-    const testPath = form["path"] as string;
-    const envName = (form["env"] as string) || undefined;
-
-    if (!testPath) {
-      return c.json({ error: "Missing 'path' field" }, 400);
-    }
-
-    const { runId } = await executeRun({ testPath, envName, trigger: "webui" });
-
-    // If targeted at the results panel (dashboard), return inline HTML
-    const hxTarget = c.req.header("HX-Target");
-    if (hxTarget === "results-panel") {
-      const run = getRunById(runId);
-      if (!run) {
-        c.header("HX-Redirect", `/runs/${runId}`);
-        return c.json({ runId });
-      }
-      const results = getResultsByRunId(runId);
-      const passed = run.passed;
-      const failed = run.failed;
-      const skipped = run.skipped;
-      const total = run.total;
-      const duration = run.duration_ms != null ? formatDuration(run.duration_ms) : "-";
-
-      const header = `
-        <div style="display:flex;align-items:center;gap:0.75rem;flex-wrap:wrap;margin-bottom:0.5rem;padding-bottom:0.5rem;border-bottom:1px solid var(--border);">
-          <strong>Run #${run.id}</strong>
-          <span style="color:var(--text-dim);font-size:0.85rem;">just now</span>
-          <span style="font-size:0.9rem;">${passed}&#10003; ${failed}&#10007; ${skipped}&#9675;</span>
-          <span style="color:var(--text-dim);font-size:0.85rem;">${duration}</span>
-          ${statusBadge(total, passed, failed)}
-          <span style="flex:1;"></span>
-          <a href="/api/export/${run.id}/junit" download class="btn btn-sm btn-outline">Export JUnit</a>
-          <a href="/api/export/${run.id}/json" download class="btn btn-sm btn-outline">Export JSON</a>
-          ${failedFilterToggle()}
-        </div>`;
-
-      const suitesHtml = renderSuiteResults(results, runId);
-      return c.html(header + suitesHtml + autoExpandFailedScript());
-    }
-
-    // Default: redirect to run detail page
-    c.header("HX-Redirect", `/runs/${runId}`);
-    return c.json({ runId });
-  } catch (err) {
-    const hxTarget = c.req.header("HX-Target");
-    if (hxTarget === "results-panel") {
-      return c.html(`<div style="color:var(--fail);padding:1rem;border:1px solid var(--fail);border-radius:6px;">Error: ${(err as Error).message}</div>`, 500);
-    }
-    return c.json({ error: (err as Error).message }, 500);
-  }
-});
-
-const runRoute = createRoute({
-  method: "post",
-  path: "/api/run",
-  tags: ["Runs"],
-  summary: "Run tests",
-  request: {
-    body: {
-      content: { "application/json": { schema: RunRequestSchema } },
-      required: true,
-    },
-  },
-  responses: {
-    200: {
-      content: { "application/json": { schema: RunResponseSchema } },
-      description: "Run created",
-    },
-    400: {
-      content: { "application/json": { schema: ErrorSchema } },
-      description: "Validation error",
-    },
-    500: {
-      content: { "application/json": { schema: ErrorSchema } },
-      description: "Server error",
-    },
-  },
-});
-
-api.openapi(runRoute, async (c) => {
-  try {
-    const { path: testPath, env: envName } = c.req.valid("json");
-    const { runId } = await executeRun({ testPath, envName, trigger: "webui" });
-
-    c.header("HX-Redirect", `/runs/${runId}`);
-    return c.json({ runId }, 200);
-  } catch (err) {
-    return c.json({ error: (err as Error).message }, 500);
-  }
-});
-
-// ──────────────────────────────────────────────
-// POST /api/proxy — Explorer proxy for HTTP requests
-// ──────────────────────────────────────────────
-
-api.post("/api/proxy", async (c) => {
-  const form = await c.req.parseBody();
-  const baseUrl = (form["base_url"] as string) ?? "";
-  const method = ((form["method"] as string) ?? "GET").toUpperCase();
-  let path = (form["path"] as string) ?? "/";
-  const body = (form["body"] as string) || undefined;
-  const contentType = (form["content_type"] as string) || undefined;
-
-  if (!baseUrl) {
-    return c.html(renderProxyError("Base URL is required", 0));
-  }
-
-  // Substitute path parameters
-  for (const [key, value] of Object.entries(form)) {
-    if (typeof key === "string" && key.startsWith("param_path_") && value) {
-      const paramName = key.slice("param_path_".length);
-      path = path.replace(`{${paramName}}`, encodeURIComponent(value as string));
-    }
-  }
-
-  // Build query string
-  const queryParams = new URLSearchParams();
-  for (const [key, value] of Object.entries(form)) {
-    if (typeof key === "string" && key.startsWith("param_query_") && value) {
-      queryParams.set(key.slice("param_query_".length), value as string);
-    }
-  }
-
-  // Build headers
-  const headers: Record<string, string> = {};
-  for (const [key, value] of Object.entries(form)) {
-    if (typeof key === "string" && key.startsWith("param_header_") && value) {
-      headers[key.slice("param_header_".length)] = value as string;
-    }
-  }
-  // Custom headers
-  for (let i = 0; i < 50; i++) {
-    const k = form[`custom_header_key_${i}`] as string | undefined;
-    const v = form[`custom_header_value_${i}`] as string | undefined;
-    if (!k && !v) break;
-    if (k && v) headers[k] = v;
-  }
-
-  if (contentType && body) {
-    headers["Content-Type"] = contentType;
-  }
-
-  // Build URL
-  let url: URL;
-  try {
-    url = new URL(path, baseUrl.endsWith("/") ? baseUrl : baseUrl + "/");
-    queryParams.forEach((v, k) => url.searchParams.set(k, v));
-  } catch (err) {
-    return c.html(renderProxyError(`Invalid URL: ${baseUrl}${path} — ${(err as Error).message}`, 0));
-  }
-
-  const startTime = performance.now();
-  try {
-    const resp = await fetch(url.toString(), {
-      method,
-      headers,
-      body: ["GET", "HEAD"].includes(method) ? undefined : (body || undefined),
-    });
-    const elapsed = Math.round(performance.now() - startTime);
-    const respBody = await resp.text();
-    const respHeaders: Record<string, string> = {};
-    resp.headers.forEach((v, k) => { respHeaders[k] = v; });
-
-    return c.html(renderProxyResponse(resp.status, respHeaders, respBody, elapsed));
-  } catch (err) {
-    const elapsed = Math.round(performance.now() - startTime);
-    return c.html(renderProxyError((err as Error).message, elapsed));
-  }
-});
-
-// ──────────────────────────────────────────────
-// Export helpers
-// ──────────────────────────────────────────────
-
-function reconstructResults(runId: number): TestRunResult[] | null {
-  const run = getRunById(runId);
-  if (!run) return null;
-
-  const rows = getResultsByRunId(runId);
-  const suiteMap = new Map<string, StepResult[]>();
-
-  for (const row of rows) {
-    const steps = suiteMap.get(row.suite_name) ?? [];
-    steps.push({
-      name: row.test_name,
-      status: row.status as StepResult["status"],
-      duration_ms: row.duration_ms,
-      request: {
-        method: row.request_method ?? "GET",
-        url: row.request_url ?? "",
-        headers: {},
-      },
-      response: row.response_status != null
-        ? { status: row.response_status, headers: {}, body: "", duration_ms: row.duration_ms }
-        : undefined,
-      assertions: row.assertions,
-      captures: row.captures as Record<string, unknown>,
-      error: row.error_message ?? undefined,
-    });
-    suiteMap.set(row.suite_name, steps);
-  }
-
-  const results: TestRunResult[] = [];
-  for (const [suiteName, steps] of suiteMap) {
-    const total = steps.length;
-    const passed = steps.filter((s) => s.status === "pass").length;
-    const failed = steps.filter((s) => s.status === "fail").length;
-    const skipped = steps.filter((s) => s.status === "skip").length;
-    results.push({
-      suite_name: suiteName,
-      started_at: run.started_at,
-      finished_at: run.finished_at ?? run.started_at,
-      total,
-      passed,
-      failed,
-      skipped,
-      steps,
-    });
-  }
-  return results;
-}
-
-// ──────────────────────────────────────────────
-// Export routes (OpenAPI-documented)
-// ──────────────────────────────────────────────
-
-const exportJsonRoute = createRoute({
-  method: "get",
-  path: "/api/export/{runId}/json",
-  tags: ["Export"],
-  summary: "Export run results as JSON",
-  request: { params: RunIdParam },
-  responses: {
-    200: {
-      content: { "application/json": { schema: RunDetailSchema } },
-      description: "Run results",
-    },
-    400: {
-      content: { "application/json": { schema: ErrorSchema } },
-      description: "Invalid run ID",
-    },
-    404: {
-      content: { "application/json": { schema: ErrorSchema } },
-      description: "Run not found",
-    },
-  },
-});
-
-api.openapi(exportJsonRoute, (c) => {
-  const { runId } = c.req.valid("param");
-  const results = reconstructResults(runId);
-  if (!results) return c.json({ error: "Run not found" }, 404);
-
-  c.header("Content-Disposition", `attachment; filename="run-${runId}-results.json"`);
-  return c.json(results as any, 200);
-});
-
-const exportJunitRoute = createRoute({
-  method: "get",
-  path: "/api/export/{runId}/junit",
-  tags: ["Export"],
-  summary: "Export run results as JUnit XML",
-  request: { params: RunIdParam },
-  responses: {
-    200: { description: "JUnit XML file" },
-    400: {
-      content: { "application/json": { schema: ErrorSchema } },
-      description: "Invalid run ID",
-    },
-    404: {
-      content: { "application/json": { schema: ErrorSchema } },
-      description: "Run not found",
-    },
-  },
-});
-
-api.openapi(exportJunitRoute, (c) => {
-  const { runId } = c.req.valid("param");
-  const results = reconstructResults(runId);
-  if (!results) return c.json({ error: "Run not found" }, 404);
-
-  const xml = generateJunitXml(results);
-  c.header("Content-Disposition", `attachment; filename="run-${runId}-junit.xml"`);
-  c.header("Content-Type", "application/xml");
-  return c.body(xml);
-});
-
-export default api;