@elench/testkit 0.1.65 → 0.1.66

package/lib/config/validation.mjs

@@ -1,5 +1,5 @@
-import { ensureExistingPath, resolveServiceCwd } from "./paths.mjs";
-import { parseModuleSpecifier } from "./runtime.mjs";
+import { ensureExistingPath } from "./paths.mjs";
+import { validateConfiguredCollection } from "../shared/configured-steps.mjs";
 
 export function validateConfigCoverage(configs) {
   const names = new Set(configs.map((config) => config.name));
@@ -60,65 +60,21 @@ export function validateServiceConfig({
   }
   for (const [stageName, steps] of Object.entries(database?.template || {})) {
     if (stageName === "inputs") continue;
-    for (const step of steps || []) {
-      if (step.cwd) {
-        ensureExistingPath(productDir, step.cwd, `Service "${name}" database.template.${stageName} step cwd`);
-      }
-      if (step.kind === "sql-file") {
-        ensureExistingPath(
-          resolveServiceCwd(productDir, step.cwd || "."),
-          step.path,
-          `Service "${name}" database.template.${stageName} sql file`
-        );
-      }
-      if (step.kind === "module") {
-        const { modulePath } = parseModuleSpecifier(step.specifier);
-        ensureExistingPath(
-          resolveServiceCwd(productDir, step.cwd || "."),
-          modulePath,
-          `Service "${name}" database.template.${stageName} module`
-        );
-      }
-      for (const input of step.inputs || []) {
-        ensureExistingPath(
-          resolveServiceCwd(productDir, step.cwd || "."),
-          input,
-          `Service "${name}" database.template.${stageName} step input`
-        );
-      }
-    }
-  }
-  for (const input of database?.template?.inputs || []) {
-    ensureExistingPath(productDir, input, `Service "${name}" database.template input`);
-  }
-  for (const step of runtime.prepare?.steps || []) {
-    if (step.cwd) {
-      ensureExistingPath(productDir, step.cwd, `Service "${name}" runtime.prepare step cwd`);
-    }
-    if (step.kind === "sql-file") {
-      ensureExistingPath(
-        resolveServiceCwd(productDir, step.cwd || "."),
-        step.path,
-        `Service "${name}" runtime.prepare sql file`
-      );
-    }
-    if (step.kind === "module") {
-      const { modulePath } = parseModuleSpecifier(step.specifier);
-      ensureExistingPath(
-        resolveServiceCwd(productDir, step.cwd || "."),
-        modulePath,
-        `Service "${name}" runtime.prepare module`
-      );
-    }
-    for (const input of step.inputs || []) {
-      ensureExistingPath(
-        resolveServiceCwd(productDir, step.cwd || "."),
-        input,
-        `Service "${name}" runtime.prepare step input`
-      );
-    }
-  }
-  for (const input of runtime.prepare?.inputs || []) {
-    ensureExistingPath(productDir, input, `Service "${name}" runtime.prepare input`);
+    validateConfiguredCollection({
+      productDir,
+      label: `Service "${name}" database.template.${stageName}`,
+      steps,
+    });
   }
+  validateConfiguredCollection({
+    productDir,
+    label: `Service "${name}" database.template`,
+    inputs: database?.template?.inputs || [],
+  });
+  validateConfiguredCollection({
+    productDir,
+    label: `Service "${name}" runtime.prepare`,
+    inputs: runtime.prepare?.inputs || [],
+    steps: runtime.prepare?.steps || [],
+  });
 }

package/lib/coverage/backend-discovery.mjs

@@ -1,13 +1,12 @@
 import fs from "fs";
 import path from "path";
 import {
+  collectImports,
+  createSourceFile,
   extractExportedFunctionBody,
-  extractExportedFunctions,
-  extractExportedMethodBodies,
+  resolveImportToSourceFile,
 } from "@elench/ts-analysis";
 import {
-  dedupeBackendImports,
-  dedupeDataImports,
   dedupeEdges,
   dedupeNodes,
   hasWord,
@@ -15,7 +14,6 @@ import {
   isDataSpecifier,
   modulePathKey,
 } from "./shared.mjs";
-import { resolveImportToSourceFile } from "./fs-walk.mjs";
 
 export function extractBackendImports({
   serviceName,
@@ -26,34 +24,15 @@ export function extractBackendImports({
   resolveImportToSourceFile: resolveImportAlias,
 }) {
   const resolveImportFn = resolveImportAlias || resolveImport;
-  const imports = [];
-  const importRegex = /import\s+\{([^}]+)\}\s+from\s+["'`]([^"'`]+)["'`]/gu;
-  for (const match of content.matchAll(importRegex)) {
-    const rawNames = match[1]
-      .split(",")
-      .map((entry) => entry.trim())
-      .map((entry) => entry.split(/\s+as\s+/u)[0]?.trim())
-      .filter(Boolean);
-    const specifier = match[2].trim();
-    if (!isBackendSpecifier(specifier)) continue;
-    const resolvedFilePath = resolveImportFn(serviceRoot, filePath, specifier);
-    for (const importName of rawNames) {
-      imports.push({
-        importName,
-        node: {
-          id: `server_capability:${modulePathKey(resolvedFilePath || filePath)}#${importName}`,
-          kind: "server_capability",
-          service: serviceName,
-          label: importName,
-          filePath: resolvedFilePath || null,
-          metadata: {
-            specifier,
-          },
-        },
-      });
-    }
-  }
-  return dedupeBackendImports(imports);
+  return collectCapabilityImports({
+    serviceName,
+    serviceRoot,
+    filePath,
+    content,
+    resolveImportFn,
+    matchesSpecifier: isBackendSpecifier,
+    kind: "server_capability",
+  });
 }
 
 export function discoverDataCapabilities({ serviceName, serviceRoot, nodes, readFile = defaultReadFile }) {
@@ -97,63 +76,67 @@ export function extractDataImports({
   resolveImportToSourceFile: resolveImportAlias,
 }) {
   const resolveImportFn = resolveImportAlias || resolveImport;
-  const imports = [];
-  const importRegex = /import\s+\{([^}]+)\}\s+from\s+["'`]([^"'`]+)["'`]/gu;
-  for (const match of content.matchAll(importRegex)) {
-    const rawNames = match[1]
-      .split(",")
-      .map((entry) => entry.trim())
-      .map((entry) => entry.split(/\s+as\s+/u)[0]?.trim())
-      .filter(Boolean);
-    const specifier = match[2].trim();
-    if (!isDataSpecifier(specifier)) continue;
-    const resolvedFilePath = resolveImportFn(serviceRoot, filePath, specifier);
-    for (const importName of rawNames) {
-      imports.push({
-        importName,
-        node: {
-          id: `data_capability:${modulePathKey(resolvedFilePath || filePath)}#${importName}`,
-          kind: "data_capability",
-          service: serviceName,
-          label: importName,
-          filePath: resolvedFilePath || null,
-          metadata: {
-            specifier,
-          },
-        },
-      });
-    }
-  }
-  return dedupeDataImports(imports);
+  return collectCapabilityImports({
+    serviceName,
+    serviceRoot,
+    filePath,
+    content,
+    resolveImportFn,
+    matchesSpecifier: isDataSpecifier,
+    kind: "data_capability",
+  });
 }
 
-export { extractExportedFunctionBody, extractExportedFunctions, extractExportedMethodBodies };
+function defaultReadFile(filePath) {
+  if (!fs.existsSync(filePath)) return null;
+  return fs.readFileSync(filePath, "utf8");
+}
 
-export function readBalancedBlock(content, startIndex) {
-  let depth = 0;
-  let inSingle = false;
-  let inDouble = false;
-  let inTemplate = false;
+function collectCapabilityImports({
+  serviceName,
+  serviceRoot,
+  filePath,
+  content,
+  resolveImportFn,
+  matchesSpecifier,
+  kind,
+}) {
+  const sourceFile = createSourceFile(filePath, content);
+  const imports = collectImports(sourceFile, {
+    resolveImportPath: (specifier) => resolveImportFn(serviceRoot, filePath, specifier),
+    readSourceFile: () => null,
+    isServerActionFile: () => false,
+  });
 
-  for (let index = startIndex; index < content.length; index += 1) {
-    const char = content[index];
-    const previous = content[index - 1];
-    if (char === "'" && !inDouble && !inTemplate && previous !== "\\") inSingle = !inSingle;
-    if (char === '"' && !inSingle && !inTemplate && previous !== "\\") inDouble = !inDouble;
-    if (char === "`" && !inSingle && !inDouble && previous !== "\\") inTemplate = !inTemplate;
-    if (inSingle || inDouble || inTemplate) continue;
-    if (char === "{") depth += 1;
-    if (char === "}") {
-      depth -= 1;
-      if (depth === 0) {
-        return content.slice(startIndex, index + 1);
-      }
-    }
+  const collected = [];
+  for (const [localName, imported] of imports.entries()) {
+    if (!matchesSpecifier(imported.specifier)) continue;
+    const exportName = imported.importedName === "default" ? localName : imported.importedName;
+    collected.push({
+      importName: localName,
+      node: {
+        id: `${kind}:${modulePathKey(imported.resolvedFilePath || filePath)}#${exportName}`,
+        kind,
+        service: serviceName,
+        label: exportName,
+        filePath: imported.resolvedFilePath || null,
+        metadata: {
+          specifier: imported.specifier,
+          localName,
+        },
+      },
+    });
   }
-  return null;
+
+  return dedupeCapabilityImports(collected);
 }
 
-function defaultReadFile(filePath) {
-  if (!fs.existsSync(filePath)) return null;
-  return fs.readFileSync(filePath, "utf8");
+function dedupeCapabilityImports(entries) {
+  const seen = new Set();
+  return entries.filter((entry) => {
+    const key = `${entry.importName}:${entry.node.id}:${entry.node.filePath || ""}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
 }

package/lib/coverage/backend-discovery.test.mjs

@@ -1,52 +1,61 @@
 import { describe, expect, it } from "vitest";
-import {
-  extractExportedFunctionBody,
-  extractExportedFunctions,
-  extractExportedMethodBodies,
-  readBalancedBlock,
-} from "./backend-discovery.mjs";
-
-describe("coverage backend discovery helpers", () => {
-  it("extracts exported HTTP method bodies without being confused by braces in strings", () => {
-    const content = `
-      export async function GET() {
-        const template = "{not a block}";
-        return template;
-      }
-
-      export async function POST() {
-        return { ok: true };
-      }
-    `;
-
-    expect(extractExportedMethodBodies(content, ["GET", "POST"])).toEqual([
-      ["GET", expect.stringContaining('"{not a block}"')],
-      ["POST", expect.stringContaining("{ ok: true }")],
+import { extractBackendImports, extractDataImports } from "./backend-discovery.mjs";
+
+describe("coverage backend discovery", () => {
+  it("tracks local import names while anchoring capabilities to exported names", () => {
+    const content = [
+      'import { saveSettings as persistSettings } from "@/backend/server/settings";',
+      'import { loadProjects as fetchProjects } from "@/backend/data/projects";',
+    ].join("\n");
+
+    expect(
+      extractBackendImports({
+        serviceName: "web",
+        serviceRoot: "/repo",
+        filePath: "src/app/settings/actions.ts",
+        content,
+        resolveImport: () => "src/backend/server/settings.ts",
+      })
+    ).toEqual([
+      {
+        importName: "persistSettings",
+        node: {
+          id: "server_capability:src/backend/server/settings#saveSettings",
+          kind: "server_capability",
+          service: "web",
+          label: "saveSettings",
+          filePath: "src/backend/server/settings.ts",
+          metadata: {
+            specifier: "@/backend/server/settings",
+            localName: "persistSettings",
+          },
+        },
+      },
     ]);
-  });
-
-  it("extracts named exported functions and their bodies", () => {
-    const content = `
-      export async function saveSettings() {
-        return updateSettings();
-      }
 
-      export function listSettings() {
-        return [];
-      }
-    `;
-
-    expect(extractExportedFunctions(content)).toEqual([
-      { name: "saveSettings", body: expect.stringContaining("updateSettings") },
-      { name: "listSettings", body: expect.stringContaining("return [];") },
+    expect(
+      extractDataImports({
+        serviceName: "web",
+        serviceRoot: "/repo",
+        filePath: "src/backend/server/settings.ts",
+        content,
+        resolveImport: () => "src/backend/data/projects.ts",
+      })
+    ).toEqual([
+      {
+        importName: "fetchProjects",
+        node: {
+          id: "data_capability:src/backend/data/projects#loadProjects",
+          kind: "data_capability",
+          service: "web",
+          label: "loadProjects",
+          filePath: "src/backend/data/projects.ts",
+          metadata: {
+            specifier: "@/backend/data/projects",
+            localName: "fetchProjects",
+          },
+        },
+      },
     ]);
-    expect(extractExportedFunctionBody(content, "saveSettings")).toContain("updateSettings");
-  });
-
-  it("reads a balanced block from a brace offset", () => {
-    const content = `before { const tpl = \`{nested}\`; return tpl; } after`;
-    const startIndex = content.indexOf("{");
-
-    expect(readBalancedBlock(content, startIndex)).toBe("{ const tpl = `{nested}`; return tpl; }");
   });
 });

package/lib/coverage/graph-builder.mjs

@@ -1,6 +1,5 @@
 import { discoverDataCapabilities } from "./backend-discovery.mjs";
 import { buildEvidenceDetails, inferCoveredNodeIdsForTest } from "./evidence.mjs";
-import { resolveServiceRoot } from "./fs-walk.mjs";
 import { convertNextAnalysisToGraph } from "./next-ir-to-graph.mjs";
 import {
   appendGraph,
@@ -11,6 +10,7 @@ import {
   toSelectionType,
 } from "./shared.mjs";
 import { DEFAULT_DISCOVERY_EXCLUDES, normalizeDiscoveryConfig } from "../discovery/path-policy.mjs";
+import { resolveServiceCwd } from "../config/paths.mjs";
 import { createNextAnalysisProject } from "@elench/next-analysis";
 
 export function buildCoverageGraph({ productDir, repoDiscovery = {}, services = {}, discoveryFiles = [] }) {
@@ -85,10 +85,7 @@ export function buildCoverageGraph({ productDir, repoDiscovery = {}, services =
 }
 
 export function buildServiceCoverageContext(productDir, serviceName, config, repoDiscovery = {}) {
-  const serviceRoot = resolveServiceRoot(productDir, config);
-  const nextProject = createNextAnalysisProject({ rootDir: serviceRoot });
-  const nextAppRoot = nextProject.findAppRoot();
-  if (!nextAppRoot) return null;
+  const serviceRoot = resolveServiceCwd(productDir, config?.local?.cwd || ".");
   const serviceDiscovery = normalizeDiscoveryConfig(config?.discovery, { allowRoots: true });
   const exclude = [
     ...new Set([
@@ -97,6 +94,9 @@ export function buildServiceCoverageContext(productDir, serviceName, config, rep
       ...((serviceDiscovery.exclude || []).map(normalizePath)),
     ]),
   ];
+  const nextProject = createNextAnalysisProject({ rootDir: serviceRoot, exclude });
+  const nextAppRoot = nextProject.findAppRoot();
+  if (!nextAppRoot) return null;
 
   const graph = createEmptyGraph();
   const pages = nextProject.discoverPages();

package/lib/coverage/next-ir-to-graph.mjs

@@ -1,5 +1,4 @@
 import {
-  normalizePath,
   pageLabelFromRoute,
 } from "@elench/next-analysis";
 import {

package/lib/coverage/routing.mjs

@@ -1,5 +1,6 @@
 import path from "path";
-import { normalizePath, normalizeRoute } from "./shared.mjs";
+import { normalizeRouteSegments, toApiRequestPath } from "@elench/next-analysis";
+import { normalizePath } from "./shared.mjs";
 
 export function inferPageRouteFromTestFile(filePath, nextAppRoot, serviceRoot) {
   const appRelativeSegments = extractRouteOwnerSegments(filePath, nextAppRoot, serviceRoot);
@@ -47,38 +48,10 @@ export function extractRouteOwnerSegments(filePath, nextAppRoot, serviceRoot) {
   return segments.slice(0, testkitIndex);
 }
 
-export function routeFromAppFile(nextAppRoot, filePath) {
-  const absolutePath = path.isAbsolute(filePath) ? filePath : path.resolve(nextAppRoot, filePath);
-  const relative = normalizePath(path.relative(nextAppRoot, absolutePath));
-  const segments = relative.split("/");
-  segments.pop();
-  return normalizeRouteSegments(segments);
-}
-
-export function routeFromApiFile(nextAppRoot, filePath) {
-  const appRelative = normalizePath(path.relative(nextAppRoot, path.dirname(filePath)));
-  const segments = appRelative.split("/").filter(Boolean);
-  if (segments[0] === "api") segments.shift();
-  return normalizeRouteSegments(segments);
-}
-
-export function normalizeRouteSegments(segments) {
-  const normalizedSegments = segments
-    .filter(Boolean)
-    .filter((segment) => !segment.startsWith("(") || !segment.endsWith(")"))
-    .filter((segment) => !segment.startsWith("@"))
-    .filter((segment) => segment !== "page" && segment !== "route");
-  return normalizeRoute(`/${normalizedSegments.join("/")}`);
-}
-
 export function apiRouteLookupKey(method, route) {
   return `${method}:${route}`;
 }
 
-export function toApiRequestPath(route) {
-  return normalizeRoute(`/api${route === "/" ? "" : route}`);
-}
-
 export function toSelectionType(type, framework) {
   if (framework === "playwright") return "pw";
   if (type === "integration") return "int";

package/lib/coverage/routing.test.mjs

@@ -4,19 +4,10 @@ import {
   inferApiRoutesFromTestFile,
   inferOwnerDirectoryFromTestFile,
   inferPageRouteFromTestFile,
-  normalizeRouteSegments,
   pathMatchesOwner,
-  routeFromApiFile,
-  routeFromAppFile,
 } from "./routing.mjs";
 
 describe("coverage routing helpers", () => {
-  it("normalizes route segments by stripping route groups and slots", () => {
-    expect(normalizeRouteSegments(["(marketing)", "@modal", "campaigns", "[campaignId]", "page"])).toBe(
-      "/campaigns/[campaignId]"
-    );
-  });
-
   it("infers page ownership routes from colocated __testkit__ files", () => {
     const serviceRoot = "/repo";
     const nextAppRoot = path.join(serviceRoot, "src", "app");
@@ -35,13 +26,6 @@ describe("coverage routing helpers", () => {
     ).toEqual(["/campaigns"]);
   });
 
-  it("derives page and API routes from Next app file paths", () => {
-    const nextAppRoot = "/repo/src/app";
-
-    expect(routeFromAppFile(nextAppRoot, "/repo/src/app/settings/page.tsx")).toBe("/settings");
-    expect(routeFromApiFile(nextAppRoot, "/repo/src/app/api/campaigns/route.ts")).toBe("/campaigns");
-  });
-
   it("matches nested ownership directories for DAL evidence", () => {
     expect(inferOwnerDirectoryFromTestFile("src/backend/data/campaigns/__testkit__/save.dal.testkit.ts")).toBe(
       "src/backend/data/campaigns"

package/lib/coverage/shared.mjs

@@ -1,7 +1,28 @@
 import path from "path";
 import { TESTKIT_COVERAGE_GRAPH_VERSION } from "@elench/testkit-protocol";
+import {
+  DYNAMIC_SEGMENT_TOKEN,
+  HTTP_METHODS,
+  isBackendSpecifier,
+  isDataSpecifier,
+  modulePathKey,
+  normalizePath,
+  normalizeRoute,
+  pageLabelFromRoute,
+  toApiRequestPath,
+} from "@elench/next-analysis";
+export {
+  DYNAMIC_SEGMENT_TOKEN,
+  HTTP_METHODS,
+  isBackendSpecifier,
+  isDataSpecifier,
+  modulePathKey,
+  normalizePath,
+  normalizeRoute,
+  pageLabelFromRoute,
+  toApiRequestPath,
+};
 
-export const HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE"];
 export const HTTP_WRAPPER_METHODS = {
   getJson: "GET",
   postJson: "POST",
@@ -9,7 +30,6 @@ export const HTTP_WRAPPER_METHODS = {
   patchJson: "PATCH",
   deleteJson: "DELETE",
 };
-export const DYNAMIC_SEGMENT_TOKEN = "__TESTKIT_DYNAMIC_SEGMENT__";
 
 export function createEmptyGraph() {
   return {
@@ -59,51 +79,12 @@ export function apiRouteLookupKey(method, route) {
   return `${method}:${route}`;
 }
 
-export function toApiRequestPath(route) {
-  return normalizeRoute(`/api${route === "/" ? "" : route}`);
-}
-
 export function toSelectionType(type, framework) {
   if (framework === "playwright") return "pw";
   if (type === "integration") return "int";
   return type;
 }
 
-export function pageLabelFromRoute(route) {
-  if (route === "/") return "Home";
-  return route
-    .split("/")
-    .filter(Boolean)
-    .map((segment) => {
-      if (segment.startsWith("[") && segment.endsWith("]")) {
-        return segment.slice(1, -1);
-      }
-      return segment;
-    })
-    .map((segment) => segment.replace(/[-_]+/gu, " "))
-    .map((segment) => segment.replace(/^\w/u, (char) => char.toUpperCase()))
-    .join(" ");
-}
-
-export function normalizeRoute(value) {
-  const trimmed = String(value || "/").trim();
-  if (!trimmed || trimmed === "/") return "/";
-  const withLeadingSlash = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
-  return withLeadingSlash.length > 1 ? withLeadingSlash.replace(/\/+$/u, "") : withLeadingSlash;
-}
-
-export function normalizePath(filePath) {
-  return filePath.split(path.sep).join("/");
-}
-
-export function modulePathKey(filePath) {
-  const normalized = normalizePath(filePath);
-  const ext = path.extname(normalized);
-  if (path.basename(normalized, ext) === "index") {
-    return normalizePath(path.dirname(normalized));
-  }
-  return normalized.slice(0, normalized.length - ext.length);
-}
 
 export function escapeRegExp(value) {
   return String(value).replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
@@ -114,27 +95,6 @@ export function isServerActionFile(content) {
   return trimmed.startsWith('"use server"') || trimmed.startsWith("'use server'");
 }
 
-export function isBackendSpecifier(specifier) {
-  return (
-    specifier.startsWith("@/backend/server/") ||
-    specifier.includes("/backend/server/") ||
-    specifier.startsWith("./backend/server/") ||
-    specifier.startsWith("../backend/server/")
-  );
-}
-
-export function isDataSpecifier(specifier) {
-  return (
-    specifier.startsWith("@/backend/data/") ||
-    specifier.startsWith("@/backend/dal/") ||
-    specifier.includes("/backend/data/") ||
-    specifier.includes("/backend/dal/") ||
-    specifier.includes("/db/") ||
-    specifier.includes("/repository/") ||
-    specifier.includes("/repositories/")
-  );
-}
-
 export function hasWord(content, word) {
   if (!content || !word) return false;
   return new RegExp(`\\b${escapeRegExp(word)}\\b`, "u").test(content);
@@ -178,26 +138,6 @@ export function dedupeTargets(targets) {
   });
 }
 
-export function dedupeBackendImports(entries) {
-  const seen = new Set();
-  return entries.filter((entry) => {
-    const key = `${entry.importName}:${entry.node.filePath || ""}:${entry.node.label}`;
-    if (seen.has(key)) return false;
-    seen.add(key);
-    return true;
-  });
-}
-
-export function dedupeDataImports(entries) {
-  const seen = new Set();
-  return entries.filter((entry) => {
-    const key = `${entry.importName}:${entry.node.filePath || ""}:${entry.node.label}`;
-    if (seen.has(key)) return false;
-    seen.add(key);
-    return true;
-  });
-}
-
 export function findMatchingApiRouteEntry(method, candidatePath, routeEntries = []) {
   const normalizedMethod = String(method || "").trim().toUpperCase();
   const normalizedCandidate = normalizeRequestPathCandidate(candidatePath);

package/lib/database/fingerprint.mjs

@@ -1,7 +1,7 @@
 import crypto from "crypto";
 import fs from "fs";
 import path from "path";
-import { resolveServiceCwd } from "../config/index.mjs";
+import { resolveServiceCwd } from "../config/paths.mjs";
 import { collectTemplateInputs } from "./template-steps.mjs";
 
 const LOCAL_IMAGE = "pgvector/pgvector:pg16";