@elench/testkit 0.1.64 → 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/evidence.mjs

@@ -1,12 +1,14 @@
 import fs from "fs";
 import path from "path";
-import { extractHttpSuiteRequests, extractPlaywrightVisitedRoutes } from "./next-static-analysis.mjs";
+import { extractHttpRequests, extractPlaywrightVisitedRoutes } from "@elench/ts-analysis";
 import {
   apiRouteLookupKey,
+  DYNAMIC_SEGMENT_TOKEN,
   HTTP_METHODS,
   dedupeTargets,
   findMatchingApiRouteEntry,
   findMatchingRouteValue,
+  normalizeRoute,
   toApiRequestPath,
   toSelectionType,
 } from "./shared.mjs";
@@ -36,7 +38,13 @@ export function inferCoveredNodeIdsForTest(entry, context) {
 
   // Capability: Playwright page routes (content-first, path-fallback)
   if (entry.framework === "playwright") {
-    const gotoRoutes = content ? extractPlaywrightVisitedRoutes(content, entry.filePath) : [];
+    const gotoRoutes = content
+      ? extractPlaywrightVisitedRoutes(content, {
+          filePath: entry.filePath,
+          normalizeRoute,
+          dynamicSegmentToken: DYNAMIC_SEGMENT_TOKEN,
+        })
+      : [];
     const routes = gotoRoutes.length > 0
       ? gotoRoutes
       : (() => { const r = inferPageRouteFromTestFile(entry.filePath, context.nextAppRoot, context.serviceRoot); return r ? [r] : []; })();
@@ -56,7 +64,11 @@ export function inferCoveredNodeIdsForTest(entry, context) {
 
   // Capability: HTTP request extraction (any test type with rawReq/fetch/wrapper calls)
   if (content) {
-    const requests = extractHttpSuiteRequests(content, entry.filePath);
+    const requests = extractHttpRequests(content, {
+      filePath: entry.filePath,
+      normalizeRoute,
+      dynamicSegmentToken: DYNAMIC_SEGMENT_TOKEN,
+    });
     for (const request of requests) {
       if (!request.path.startsWith("/api/")) continue;
       const routeEntry = resolveApiRouteEntry(context, request.method, request.path);

package/lib/coverage/evidence.test.mjs

@@ -4,7 +4,7 @@ import {
   extractPlaywrightTargetsFromContent,
   inferDataCapabilitiesFromOwner,
 } from "./evidence.mjs";
-import { extractPlaywrightVisitedRoutes } from "./next-static-analysis.mjs";
+import { extractPlaywrightVisitedRoutes } from "@elench/ts-analysis";
 import { DYNAMIC_SEGMENT_TOKEN } from "./shared.mjs";
 
 describe("coverage evidence helpers", () => {
@@ -60,19 +60,28 @@ describe("extractPlaywrightVisitedRoutes", () => {
         await page.goto("https://external.com/path"); // external
         await page.goto("http://localhost:3000/events"); // same-origin absolute
       });
-    `, "nav.pw.testkit.ts")).toEqual(["/dashboard", "/settings/profile", "/events"]);
+    `, {
+      filePath: "nav.pw.testkit.ts",
+      dynamicSegmentToken: DYNAMIC_SEGMENT_TOKEN,
+    })).toEqual(["/dashboard", "/settings/profile", "/events"]);
   });
 
   it("handles property chain: foo.page.goto()", () => {
     expect(extractPlaywrightVisitedRoutes(`
       await this.page.goto("/projects");
-    `, "test.pw.testkit.ts")).toEqual(["/projects"]);
+    `, {
+      filePath: "test.pw.testkit.ts",
+      dynamicSegmentToken: DYNAMIC_SEGMENT_TOKEN,
+    })).toEqual(["/projects"]);
   });
 
   it("normalizes dynamic goto expressions into route patterns", () => {
     expect(extractPlaywrightVisitedRoutes(`
       await page.goto(\`/projects/\${id}\`);
       await page.goto(someVar);
-    `, "test.pw.testkit.ts")).toEqual([`/projects/${DYNAMIC_SEGMENT_TOKEN}`]);
+    `, {
+      filePath: "test.pw.testkit.ts",
+      dynamicSegmentToken: DYNAMIC_SEGMENT_TOKEN,
+    })).toEqual([`/projects/${DYNAMIC_SEGMENT_TOKEN}`]);
   });
 });

package/lib/coverage/graph-builder.mjs

@@ -1,7 +1,6 @@
 import { discoverDataCapabilities } from "./backend-discovery.mjs";
 import { buildEvidenceDetails, inferCoveredNodeIdsForTest } from "./evidence.mjs";
-import { findNextAppRoot, resolveImportToSourceFile, resolveServiceRoot } from "./fs-walk.mjs";
-import { discoverApiRoutes, discoverPageViews, discoverServerActions } from "./next-discovery.mjs";
+import { convertNextAnalysisToGraph } from "./next-ir-to-graph.mjs";
 import {
   appendGraph,
   createEmptyGraph,
@@ -11,6 +10,8 @@ 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 = [] }) {
   const graph = createEmptyGraph();
@@ -84,9 +85,7 @@ export function buildCoverageGraph({ productDir, repoDiscovery = {}, services =
 }
 
 export function buildServiceCoverageContext(productDir, serviceName, config, repoDiscovery = {}) {
-  const serviceRoot = resolveServiceRoot(productDir, config);
-  const nextAppRoot = findNextAppRoot(serviceRoot);
-  if (!nextAppRoot) return null;
+  const serviceRoot = resolveServiceCwd(productDir, config?.local?.cwd || ".");
   const serviceDiscovery = normalizeDiscoveryConfig(config?.discovery, { allowRoots: true });
   const exclude = [
     ...new Set([
@@ -95,42 +94,42 @@ 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 discoveryOptions = {
+  const pages = nextProject.discoverPages();
+  const apiRoutes = nextProject.discoverApiRoutes();
+  const serverActions = nextProject.discoverServerActions();
+  const routeTrees = pages.map((page) => nextProject.analyzeRouteTree(page.route)).filter(Boolean);
+  const converted = convertNextAnalysisToGraph({
     serviceName,
-    serviceRoot,
-    nextAppRoot,
-    exclude,
-    resolveImportToSourceFile,
-  };
-  const pages = discoverPageViews(discoveryOptions);
-  const apiRoutes = discoverApiRoutes(discoveryOptions);
-  const serverActions = discoverServerActions({
-    serviceName,
-    serviceRoot,
-    exclude,
-    resolveImportToSourceFile,
+    pages,
+    apiRoutes,
+    serverActions,
+    routeTrees,
   });
 
-  for (const node of [...pages.nodes, ...apiRoutes.nodes, ...serverActions.nodes]) graph.nodes.push(node);
-  for (const edge of [...pages.edges, ...apiRoutes.edges, ...serverActions.edges]) graph.edges.push(edge);
+  for (const node of converted.nodes) graph.nodes.push(node);
+  for (const edge of converted.edges) graph.edges.push(edge);
 
   const dataAugmentation = discoverDataCapabilities({ serviceName, serviceRoot, nodes: graph.nodes });
   for (const node of dataAugmentation.nodes) graph.nodes.push(node);
   for (const edge of dataAugmentation.edges) graph.edges.push(edge);
+  for (const diagnostic of nextProject.getDiagnostics()) graph.diagnostics.push(diagnostic);
 
-  const pageByRoute = new Map(pages.pageEntries.map((entry) => [entry.route, entry]));
+  const pageByRoute = new Map(converted.pageEntries.map((entry) => [entry.route, entry]));
   const apiRouteByKey = new Map(
-    apiRoutes.routeEntries.map((entry) => [`${entry.method}:${entry.requestPath}`, entry])
+    converted.routeEntries.map((entry) => [`${entry.method}:${entry.requestPath}`, entry])
   );
   const serverActionByExportKey = new Map(
-    serverActions.actionEntries.map((entry) => [`${entry.sourceFile}#${entry.exportName}`, entry])
+    converted.actionEntries.map((entry) => [`${entry.sourceFile}#${entry.exportName}`, entry])
   );
 
-  for (const pageEntry of pages.pageEntries) {
+  for (const pageEntry of converted.pageEntries) {
     for (const request of pageEntry.requests) {
-      const apiRoute = findMatchingApiRouteEntry(request.method, request.path, apiRoutes.routeEntries);
+      const apiRoute = findMatchingApiRouteEntry(request.method, request.path, converted.routeEntries);
       if (!apiRoute) continue;
       graph.edges.push({
         id: `handles:${request.node.id}:${apiRoute.node.id}`,
@@ -161,7 +160,7 @@ export function buildServiceCoverageContext(productDir, serviceName, config, rep
     graph,
     pageByRoute,
     apiRouteByKey,
-    apiRouteEntries: apiRoutes.routeEntries,
+    apiRouteEntries: converted.routeEntries,
     serverActionByExportKey,
     dataCapabilities: dataAugmentation.nodes,
   };