@anaemia/bundler 0.4.0 → 0.5.0

package/src/index.ts

@@ -5,6 +5,7 @@ import fs from "node:fs";
 import type { AnaemiaConfig } from "@anaemia/core/config";
 import { createRequire } from "node:module";
 import { fileURLToPath } from "node:url";
+import pc from "picocolors";
 
 import clientServerFnTransform from "./plugins/babel-transform-server.js";
 import serverHashInjector from "./plugins/babel-hash-injector-server.js";
@@ -20,6 +21,8 @@ import { createStyleRules, createBabelRule, createAssetRules } from "./rules.js"
 import { getClientOptimization, getPerformanceProfile } from "./optimization.js";
 import loadEnvFiles from "./env-loader.js";
 
+import { analyzeApp } from "./analyzer/index.js";
+
 const require = createRequire(import.meta.url);
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -31,12 +34,43 @@ export async function getRspackConfig(
   const isDev = process.env.NODE_ENV !== "production";
   loadEnvFiles(appRoot, process.env.NODE_ENV || "development");
 
+  // run the analyzer to collect route metadata and other information about the app that we can use to optimize the build
+  const analysis = await analyzeApp(appRoot, {
+    mode: isDev ? "development" : "production",
+  });
+
+  // flush diagnostics to console
+  const tag = pc.dim("[anaemia-analyzer]");
+
+  for (const diagnostic of analysis.diagnostics) {
+    const prefix =
+      diagnostic.severity === "error"
+        ? pc.red("✖ [error]")
+        : diagnostic.severity === "warning"
+          ? pc.yellow("⚠ [warning]")
+          : pc.cyan("› [info]");
+
+    const loc = diagnostic.line ? pc.dim(`:${diagnostic.line}`) : "";
+    const file = pc.bold(diagnostic.filePath);
+    const msg =
+      diagnostic.severity === "error"
+        ? pc.red(diagnostic.message)
+        : diagnostic.severity === "warning"
+          ? pc.yellow(diagnostic.message)
+          : diagnostic.message;
+
+    // eslint-disable-next-line no-console
+    console.log(`${tag} ${prefix} ${file}${loc} - ${msg}`);
+    // eslint-disable-next-line no-console
+    if (diagnostic.help) console.log(`  ${pc.dim(`hint: ${diagnostic.help}`)}`);
+  }
+
   const coreRuntimeDir = path.dirname(require.resolve("@anaemia/core/package.json"));
   const runtimeDir = path.resolve(coreRuntimeDir, "./dist/runtime");
 
   const routes = await scanRoutes(appRoot);
   const serverRoutes = scanServerRoutes(appRoot);
-  writeManifest(appRoot, routes);
+  writeManifest(appRoot, routes, analysis.routeMetadata);
 
   const frameworkInternalDir = path.resolve(appRoot, "./.anaemia");
   if (!fs.existsSync(frameworkInternalDir)) {
@@ -251,3 +285,11 @@ export async function getRspackConfig(
 
 export { scanRoutes } from "./router/scan.js";
 export { writeManifest } from "./router/manifest.js";
+export { analyzeApp, collectAnalyzerFiles, parseAnalyzerFile, walkAst } from "./analyzer/index.js";
+export type {
+  AnalyzeAppOptions,
+  AnalyzerDiagnostic,
+  AnalyzerFileKind,
+  AnalyzerResult,
+  ParsedAnalyzerFile,
+} from "./analyzer/index.js";

package/src/router/manifest.ts

@@ -1,37 +1,28 @@
 import fs from "node:fs";
 import path from "node:path";
-import type { RouteManifestEntry } from "./scan.js";
+import type { RouteManifestEntry } from "../router/scan.js";
+import type { RouteMetadata } from "../analyzer/checks/route-metadata.js";
 
-interface BuildManifest {
-  routes: RouteManifestEntry[];
-  // filled in after rspack build - maps chunkName to hashed filename
-  chunks: Record<string, { js: string; css?: string }>;
-  errors: Record<string, string>;
-  buildTime: string;
-}
-
-export function writeManifest(appRoot: string, routes: RouteManifestEntry[]): void {
-  const errors: Record<string, string> = {};
-
-  for (const route of routes) {
-    if (route.filePath.endsWith("404.tsx")) {
-      errors["404"] = route.urlPattern;
-    }
-    if (route.filePath.endsWith("500.tsx")) {
-      errors["500"] = route.urlPattern;
-    }
-  }
+export function writeManifest(appRoot: string, routes: RouteManifestEntry[], routeMetadata: RouteMetadata[]) {
+  const metadataMap = new Map(routeMetadata.map((m) => [path.resolve(appRoot, m.filePath), m]));
 
-  const conventionalRoutes = routes.filter((r) => !r.filePath.endsWith("404.tsx") && !r.filePath.endsWith("500.tsx"));
-
-  const manifest: BuildManifest = {
-    routes: conventionalRoutes,
-    errors,
-    chunks: {}, // rspack fills this in via ManifestPlugin
-    buildTime: new Date().toISOString(),
+  const manifest = {
+    routes: routes.map((route) => {
+      const meta = metadataMap.get(route.filePath);
+      return {
+        ...route,
+        isStatic: meta?.isStatic ?? false,
+        hasLoader: meta?.hasLoader ?? false,
+        hasGuard: meta?.hasGuard ?? false,
+        serverFunctionIds: meta?.serverFunctionIds ?? [],
+      };
+    }),
+    chunks: {},
   };
 
-  const outDir = path.resolve(appRoot, "./dist");
-  fs.mkdirSync(outDir, { recursive: true });
-  fs.writeFileSync(path.resolve(outDir, "route-manifest.json"), JSON.stringify(manifest, null, 2));
+  const manifestPath = path.resolve(appRoot, "./dist/route-manifest.json");
+  const manifestDir = path.dirname(manifestPath);
+  if (!fs.existsSync(manifestDir)) fs.mkdirSync(manifestDir, { recursive: true });
+
+  fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
 }

package/test/analyzer.test.mjs

@@ -0,0 +1,308 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+import { analyzeApp, walkAst } from "../dist/analyzer/index.js";
+
+function createTmpProject() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "anaemia-analyzer-test-"));
+  fs.mkdirSync(path.join(dir, "src/routes/users/[id]"), { recursive: true });
+  fs.mkdirSync(path.join(dir, "src/features/auth/components"), { recursive: true });
+  fs.mkdirSync(path.join(dir, "src/shared/utils"), { recursive: true });
+
+  fs.writeFileSync(
+    path.join(dir, "anaemia.config.ts"),
+    `
+    import { defineConfig } from "@anaemia/core";
+    export default defineConfig({ port: 3005 });
+  `,
+  );
+
+  fs.writeFileSync(path.join(dir, "src/root.tsx"), `export default function Root(props) { return props.children; }`);
+
+  // route with PUBLIC_ env - valid
+  fs.writeFileSync(
+    path.join(dir, "src/routes/users/[id]/index.tsx"),
+    `export default function UserPage() { return <h1>{import.meta.env.PUBLIC_API_URL}</h1>; }`,
+  );
+
+  // route with non-PUBLIC_ env - should warn
+  fs.writeFileSync(
+    path.join(dir, "src/routes/index.tsx"),
+    `export default function Home() { return <div>{import.meta.env.SECRET_KEY}</div>; }`,
+  );
+
+  // route with process.env - should warn
+  fs.writeFileSync(
+    path.join(dir, "src/routes/about.tsx"),
+    `export default function About() { return <div>{process.env.API_KEY}</div>; }`,
+  );
+
+  // server route - env access should not warn
+  fs.writeFileSync(
+    path.join(dir, "src/routes/users/[id]/_route.ts"),
+    `export const GET = () => new Response(import.meta.env.SECRET_KEY);`,
+  );
+
+  // .server file - env access should not warn
+  fs.writeFileSync(
+    path.join(dir, "src/features/auth/components/auth.server.ts"),
+    `export const getToken = () => import.meta.env.SECRET_TOKEN;`,
+  );
+
+  // feature component with non-PUBLIC_ env - should warn
+  fs.writeFileSync(
+    path.join(dir, "src/features/auth/components/Login.tsx"),
+    `export function Login() { return <form action={import.meta.env.AUTH_URL} />; }`,
+  );
+
+  // server function definition
+  fs.writeFileSync(
+    path.join(dir, "src/features/auth/components/actions.server.ts"),
+    `
+    import { runOnServer } from "@anaemia/core";
+    export const getUser = runOnServer(async (id) => ({ id }), "getUser");
+    export const unusedFn = runOnServer(async () => {}, "unusedFn");
+  `,
+  );
+
+  // only imports getUser, not unusedFn
+  fs.writeFileSync(
+    path.join(dir, "src/routes/users/[id]/index.tsx"),
+    `
+    import { getUser } from "../../features/auth/components/actions.server";
+    export default function UserPage() { return <h1>{import.meta.env.PUBLIC_API_URL}</h1>; }
+  `,
+  );
+
+  return dir;
+}
+
+// file classification
+
+test("analyzeApp classifies file kinds correctly", async () => {
+  const dir = createTmpProject();
+  try {
+    const result = await analyzeApp(dir, { mode: "test" });
+    const kinds = new Map(result.files.map((f) => [f.relativePath, f.kind]));
+
+    assert.equal(kinds.get("anaemia.config.ts"), "config");
+    assert.equal(kinds.get("src/root.tsx"), "root");
+    assert.equal(kinds.get("src/routes/users/[id]/index.tsx"), "route");
+    assert.equal(kinds.get("src/routes/users/[id]/_route.ts"), "server-route");
+    assert.equal(result.build.mode, "test");
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+// defineConfig
+
+test("analyzeApp handles defineConfig in anaemia.config.ts without errors", async () => {
+  const dir = createTmpProject();
+  try {
+    const result = await analyzeApp(dir, { mode: "test" });
+    const configFile = result.files.find((f) => f.relativePath === "anaemia.config.ts");
+
+    assert.ok(configFile, "config file should be present");
+    assert.ok(configFile.program !== null, "config file should parse without error");
+
+    const configErrors = configFile.diagnostics.filter((d) => d.severity === "error");
+    assert.equal(configErrors.length, 0, "config file should have no parse errors");
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+// env access
+
+test("env check: PUBLIC_ prefix passes without warning", async () => {
+  const dir = createTmpProject();
+  try {
+    const result = await analyzeApp(dir, { mode: "test" });
+    const warnings = result.diagnostics.filter(
+      (d) => d.code === "ENV_NOT_PUBLIC" && d.file?.includes("users/[id]/index.tsx"),
+    );
+    assert.equal(warnings.length, 0);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("env check: non-PUBLIC_ prefix in route warns", async () => {
+  const dir = createTmpProject();
+  try {
+    const result = await analyzeApp(dir, { mode: "test" });
+    const warnings = result.diagnostics.filter(
+      (d) => d.code === "ENV_NOT_PUBLIC" && d.filePath?.includes("routes/index.tsx"),
+    );
+    assert.equal(warnings.length, 1);
+    assert.ok(warnings[0].message.includes("SECRET_KEY"));
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("env check: non-PUBLIC_ prefix in feature component warns", async () => {
+  const dir = createTmpProject();
+  try {
+    const result = await analyzeApp(dir, { mode: "test" });
+    const warnings = result.diagnostics.filter((d) => d.code === "ENV_NOT_PUBLIC" && d.filePath?.includes("Login.tsx"));
+    assert.equal(warnings.length, 1);
+    assert.ok(warnings[0].message.includes("AUTH_URL"));
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("env check: server route does not warn for non-PUBLIC_ env", async () => {
+  const dir = createTmpProject();
+  try {
+    const result = await analyzeApp(dir, { mode: "test" });
+    const warnings = result.diagnostics.filter((d) => d.code === "ENV_NOT_PUBLIC" && d.file?.includes("_route.ts"));
+    assert.equal(warnings.length, 0);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("env check: .server.ts file does not warn for non-PUBLIC_ env", async () => {
+  const dir = createTmpProject();
+  try {
+    const result = await analyzeApp(dir, { mode: "test" });
+    const warnings = result.diagnostics.filter(
+      (d) => d.code === "ENV_NOT_PUBLIC" && d.file?.includes("auth.server.ts"),
+    );
+    assert.equal(warnings.length, 0);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("env check: process.env usage warns", async () => {
+  const dir = createTmpProject();
+  try {
+    const result = await analyzeApp(dir, { mode: "test" });
+    const warnings = result.diagnostics.filter(
+      (d) => d.code === "PROCESS_ENV_ACCESS" && d.filePath?.includes("about.tsx"),
+    );
+    assert.equal(warnings.length, 1);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("env check: ALWAYS_SAFE keys do not warn", async () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "anaemia-analyzer-test-"));
+  try {
+    fs.mkdirSync(path.join(dir, "src/routes"), { recursive: true });
+    fs.writeFileSync(
+      path.join(dir, "src/routes/index.tsx"),
+      `
+      export default function Page() {
+        return <div>{import.meta.env.NODE_ENV}{import.meta.env.MODE}{import.meta.env.DEV}{import.meta.env.PROD}</div>;
+      }
+    `,
+    );
+    const result = await analyzeApp(dir, { mode: "test" });
+    const warnings = result.diagnostics.filter((d) => d.code === "ENV_NOT_PUBLIC");
+    assert.equal(warnings.length, 0);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+// unused server functions
+
+test("unused server functions: imported function does not warn", async () => {
+  const dir = createTmpProject();
+  try {
+    const result = await analyzeApp(dir, { mode: "test" });
+    const warnings = result.diagnostics.filter(
+      (d) => d.code === "UNUSED_SERVER_FUNCTION" && d.message?.includes("getUser"),
+    );
+    assert.equal(warnings.length, 0);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("unused server functions: unimported function warns", async () => {
+  const dir = createTmpProject();
+  try {
+    const result = await analyzeApp(dir, { mode: "test" });
+    const warnings = result.diagnostics.filter(
+      (d) => d.code === "UNUSED_SERVER_FUNCTION" && d.message?.includes("unusedFn"),
+    );
+    assert.equal(warnings.length, 1);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+// route metadata
+
+test("route metadata: static route detected correctly", async () => {
+  const dir = createTmpProject();
+  try {
+    const result = await analyzeApp(dir, { mode: "test" });
+    const aboutMeta = result.routeMetadata?.find((m) => m.filePath.includes("about.tsx"));
+    assert.ok(aboutMeta);
+    assert.equal(aboutMeta.isStatic, true);
+    assert.equal(aboutMeta.hasLoader, false);
+    assert.equal(aboutMeta.hasGuard, false);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("route metadata: route with server function import is not static", async () => {
+  const dir = createTmpProject();
+  try {
+    const result = await analyzeApp(dir, { mode: "test" });
+    const userMeta = result.routeMetadata?.find((m) => m.filePath.includes("users/[id]/index.tsx"));
+    assert.ok(userMeta);
+    assert.equal(userMeta.isStatic, false);
+    assert.equal(userMeta.hasServerFunctions, true);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("route metadata: params extracted from file path", async () => {
+  const dir = createTmpProject();
+  try {
+    const result = await analyzeApp(dir, { mode: "test" });
+    const userMeta = result.routeMetadata?.find((m) => m.filePath.includes("users/[id]"));
+    assert.ok(userMeta);
+    assert.ok(userMeta.params.includes("id"));
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+// walkAst
+
+test("walkAst visits all expected node types", async () => {
+  const dir = createTmpProject();
+  try {
+    const result = await analyzeApp(dir, { include: ["src/routes/**/*.tsx"] });
+    const routeFile = result.files.find((f) => f.relativePath === "src/routes/users/[id]/index.tsx");
+
+    assert.ok(routeFile);
+    const seen = new Set();
+    walkAst(routeFile.program, {
+      enter(node) {
+        seen.add(node.type);
+      },
+    });
+
+    assert.ok(seen.has("Program"));
+    assert.ok(seen.has("ImportDeclaration"));
+    assert.ok(seen.has("ExportDefaultDeclaration"));
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});