@elench/testkit 0.1.64 → 0.1.65

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" }),
+      ])
+    );
+  });
+});