@elench/testkit 0.1.63 → 0.1.65

package/node_modules/@elench/next-analysis/src/pages.mjs

@@ -0,0 +1,68 @@
+import fs from "fs";
+import path from "path";
+import { routeFromAppFile } from "./routes.mjs";
+import { compareByRoute, isPageFile, normalizePath, pageLabelFromRoute } from "./shared.mjs";
+
+export function discoverPages({ rootDir, appRoot }) {
+  const pageFiles = walkFiles(appRoot).filter(isPageFile);
+  return pageFiles
+    .map((absolutePath) => {
+      const filePath = normalizePath(path.relative(rootDir, absolutePath));
+      const route = routeFromAppFile(appRoot, absolutePath);
+      const layoutFiles = collectLayoutFiles(rootDir, appRoot, absolutePath);
+      const rootFiles = [...layoutFiles, filePath];
+      return {
+        id: `page:${route}`,
+        kind: "page",
+        route,
+        label: pageLabelFromRoute(route),
+        filePath,
+        layoutFiles,
+        rootFiles,
+      };
+    })
+    .sort(compareByRoute);
+}
+
+function collectLayoutFiles(rootDir, appRoot, pageAbsolutePath) {
+  const rootFiles = [];
+  let currentDir = path.dirname(pageAbsolutePath);
+  const absoluteAppRoot = path.resolve(appRoot);
+
+  while (currentDir.startsWith(absoluteAppRoot)) {
+    const layoutFile = resolveRouteCompanion(currentDir, "layout");
+    if (layoutFile) rootFiles.push(normalizePath(path.relative(rootDir, layoutFile)));
+    if (currentDir === absoluteAppRoot) break;
+    currentDir = path.dirname(currentDir);
+  }
+
+  return [...new Set(rootFiles.reverse())];
+}
+
+function resolveRouteCompanion(directoryPath, baseName) {
+  const candidates = [
+    path.join(directoryPath, `${baseName}.tsx`),
+    path.join(directoryPath, `${baseName}.ts`),
+    path.join(directoryPath, `${baseName}.jsx`),
+    path.join(directoryPath, `${baseName}.js`),
+  ];
+  return candidates.find((candidate) => fs.existsSync(candidate)) || null;
+}
+
+function walkFiles(rootDir) {
+  const results = [];
+  const queue = [rootDir];
+  while (queue.length > 0) {
+    const current = queue.pop();
+    for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+      if (entry.isSymbolicLink()) continue;
+      const absolutePath = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        queue.push(absolutePath);
+      } else if (entry.isFile()) {
+        results.push(absolutePath);
+      }
+    }
+  }
+  return results.sort((left, right) => left.localeCompare(right));
+}

package/node_modules/@elench/next-analysis/src/project.mjs

@@ -0,0 +1,94 @@
+import fs from "fs";
+import path from "path";
+import nextRouting from "@next/routing";
+import { findNextAppRoot } from "./app-root.mjs";
+import { discoverApiRoutes } from "./api-routes.mjs";
+import { discoverPages } from "./pages.mjs";
+import { analyzeRouteTree } from "./route-tree.mjs";
+import { discoverServerActions } from "./server-actions.mjs";
+import { compareByPath, compareByRoute, createDiagnostic, normalizePath, readFileIfExists } from "./shared.mjs";
+
+export function createNextAnalysisProject({ rootDir, buildDir = null, nextConfigPath = null } = {}) {
+  const { resolveRoutes } = nextRouting;
+  const absoluteRoot = path.resolve(rootDir || process.cwd());
+  const diagnostics = [];
+  const moduleCache = new Map();
+  const routeTreeCache = new Map();
+  const appRoot = findNextAppRoot(absoluteRoot);
+
+  const project = {
+    rootDir: absoluteRoot,
+    buildDir: buildDir ? path.resolve(absoluteRoot, buildDir) : null,
+    nextConfigPath: nextConfigPath ? path.resolve(absoluteRoot, nextConfigPath) : null,
+    findAppRoot() {
+      return appRoot;
+    },
+    readSourceFile(relativeFilePath) {
+      const absolutePath = path.join(absoluteRoot, relativeFilePath);
+      return readFileIfExists(absolutePath);
+    },
+    getDiagnostics() {
+      return [...diagnostics];
+    },
+    loadModule(relativeFilePath) {
+      return moduleCache.get(relativeFilePath) || null;
+    },
+    setModule(relativeFilePath, moduleInfo) {
+      moduleCache.set(relativeFilePath, moduleInfo);
+    },
+    discoverPages() {
+      if (!appRoot) {
+        diagnostics.push(createDiagnostic({
+          level: "warn",
+          code: "missing-app-root",
+          message: `No Next app root found under "${absoluteRoot}".`,
+        }));
+        return [];
+      }
+      return discoverPages({ rootDir: absoluteRoot, appRoot }).sort(compareByRoute);
+    },
+    discoverApiRoutes() {
+      if (!appRoot) return [];
+      return discoverApiRoutes({ rootDir: absoluteRoot, appRoot }).sort((left, right) => {
+        return left.requestPath.localeCompare(right.requestPath) || left.method.localeCompare(right.method);
+      });
+    },
+    discoverServerActions() {
+      if (!appRoot) return [];
+      return discoverServerActions({ rootDir: absoluteRoot, appRoot }).sort(compareByPath);
+    },
+    analyzeRouteTree(routeOrPageFile) {
+      if (!appRoot) return null;
+      const key = normalizePath(routeOrPageFile);
+      if (routeTreeCache.has(key)) return routeTreeCache.get(key);
+      const result = analyzeRouteTree({ project, routeOrPageFile, diagnostics });
+      routeTreeCache.set(key, result);
+      return result;
+    },
+    async loadBuildRouting() {
+      if (!project.buildDir || !fs.existsSync(project.buildDir)) return null;
+      return {
+        async resolve(url, pathnames = []) {
+          return resolveRoutes({
+            url: new URL(url),
+            basePath: "",
+            requestBody: null,
+            headers: new Headers(),
+            pathnames,
+            routes: {
+              beforeMiddleware: [],
+              beforeFiles: [],
+              afterFiles: [],
+              dynamicRoutes: [],
+              onMatch: [],
+              fallback: [],
+            },
+            invokeMiddleware: async () => ({}),
+          });
+        },
+      };
+    },
+  };
+
+  return project;
+}

package/node_modules/@elench/next-analysis/src/project.test.mjs

@@ -0,0 +1,35 @@
+import path from "path";
+import { describe, expect, it } from "vitest";
+import { createNextAnalysisProject } from "./index.mjs";
+
+const fixtureRoot = path.resolve(
+  "/home/georgedlr/workspace/elench/testkit/test/fixtures/integration/next-route-tree-product"
+);
+
+describe("@elench/next-analysis project", () => {
+  it("discovers pages, api routes, and route trees from a Next fixture", () => {
+    const project = createNextAnalysisProject({ rootDir: fixtureRoot });
+
+    expect(project.findAppRoot()).toMatch(/src\/app$/u);
+    expect(project.discoverPages().map((page) => page.route)).toEqual(["/events", "/projects"]);
+    expect(project.discoverApiRoutes().map((route) => `${route.method} ${route.requestPath}`)).toEqual([
+      "GET /api/projects",
+      "POST /api/projects",
+      "GET /api/projects/[projectId]/events",
+    ]);
+
+    const routeTree = project.analyzeRouteTree("/projects");
+    expect(routeTree.reachableModules).toEqual(
+      expect.arrayContaining([
+        "src/app/(dashboard)/projects/page.tsx",
+        "src/components/project-context.tsx",
+      ])
+    );
+    expect(routeTree.requests).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ ownerKind: "page", method: "GET", path: "/api/projects" }),
+        expect.objectContaining({ ownerKind: "action", method: "POST", path: "/api/projects" }),
+      ])
+    );
+  });
+});