@pracht/cli 0.0.0 → 1.0.0

package/test/pracht-cli.test.js

@@ -0,0 +1,415 @@
+import { execFileSync, spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
+
+import { afterEach, describe, expect, it } from "vitest";
+
+const cliPath = fileURLToPath(new URL("../bin/pracht.js", import.meta.url));
+const tempDirs = [];
+
+afterEach(() => {
+  while (tempDirs.length > 0) {
+    rmSync(tempDirs.pop(), { force: true, recursive: true });
+  }
+});
+
+describe("@pracht/cli", () => {
+  it("scaffolds shell, middleware, route, and api modules for manifest apps", () => {
+    const appDir = createTempDir("pracht-cli-manifest-");
+    writeManifestApp(appDir);
+
+    runCli(["generate", "shell", "--name", "app"], { cwd: appDir });
+    runCli(["generate", "middleware", "--name", "auth"], { cwd: appDir });
+
+    const apiResult = runCli(
+      ["generate", "api", "--path", "/health", "--methods", "GET,POST", "--json"],
+      { cwd: appDir },
+    );
+    const apiJson = JSON.parse(apiResult.stdout);
+
+    runCli(
+      [
+        "generate",
+        "route",
+        "--path",
+        "/dashboard",
+        "--render",
+        "isg",
+        "--revalidate",
+        "120",
+        "--shell",
+        "app",
+        "--middleware",
+        "auth",
+        "--loader",
+        "--error-boundary",
+      ],
+      { cwd: appDir },
+    );
+
+    const manifest = readFileSync(join(appDir, "src/routes.ts"), "utf-8");
+    const shellSource = readFileSync(join(appDir, "src/shells/app.tsx"), "utf-8");
+    const middlewareSource = readFileSync(join(appDir, "src/middleware/auth.ts"), "utf-8");
+    const routeSource = readFileSync(join(appDir, "src/routes/dashboard.tsx"), "utf-8");
+    const apiSource = readFileSync(join(appDir, "src/api/health.ts"), "utf-8");
+
+    expect(apiJson).toMatchObject({
+      created: ["src/api/health.ts"],
+      kind: "api",
+      ok: true,
+      updated: [],
+    });
+    expect(shellSource).toContain("export function Shell({ children }: ShellProps)");
+    expect(middlewareSource).toContain("export const middleware: MiddlewareFn");
+    expect(routeSource).toContain("export async function loader(_args: LoaderArgs)");
+    expect(routeSource).toContain("export function ErrorBoundary({ error }: ErrorBoundaryProps)");
+    expect(apiSource).toContain("export function GET(_args: BaseRouteArgs)");
+    expect(apiSource).toContain("export async function POST({ request }: BaseRouteArgs)");
+    expect(manifest).toContain('import { defineApp, route, timeRevalidate } from "@pracht/core";');
+    expect(manifest).toContain('shells: {\n    app: "./shells/app.tsx",\n  },');
+    expect(manifest).toContain('middleware: {\n    auth: "./middleware/auth.ts",\n  },');
+    expect(manifest).toContain('route("/dashboard", "./routes/dashboard.tsx", {');
+    expect(manifest).toContain('shell: "app",');
+    expect(manifest).toContain('middleware: ["auth"],');
+    expect(manifest).toContain("revalidate: timeRevalidate(120)");
+  });
+
+  it("reports a healthy manifest app in doctor json output", () => {
+    const appDir = createTempDir("pracht-cli-doctor-ok-");
+    writeManifestApp(appDir, {
+      routesSource: `import { defineApp, route } from "@pracht/core";
+
+export const app = defineApp({
+  shells: {
+    app: "./shells/app.tsx",
+  },
+  middleware: {
+    auth: "./middleware/auth.ts",
+  },
+  routes: [route("/dashboard", "./routes/dashboard.tsx", { id: "dashboard", shell: "app", middleware: ["auth"], render: "ssr" })],
+});
+`,
+    });
+
+    writeProjectFile(
+      appDir,
+      "src/shells/app.tsx",
+      `import type { ShellProps } from "@pracht/core";
+
+export function Shell({ children }: ShellProps) {
+  return <main>{children}</main>;
+}
+`,
+    );
+    writeProjectFile(
+      appDir,
+      "src/middleware/auth.ts",
+      `import type { MiddlewareFn } from "@pracht/core";
+
+export const middleware: MiddlewareFn = async () => {
+  return;
+};
+`,
+    );
+    writeProjectFile(
+      appDir,
+      "src/routes/dashboard.tsx",
+      `export function Component() {
+  return <h1>Dashboard</h1>;
+}
+`,
+    );
+
+    const result = runCli(["doctor", "--json"], { cwd: appDir });
+    const report = JSON.parse(result.stdout);
+
+    expect(report.ok).toBe(true);
+    expect(report.mode).toBe("manifest");
+    expect(report.checks.some((check) => check.message.includes("app manifest"))).toBe(true);
+    expect(report.checks.some((check) => check.message.includes("adapter dependency"))).toBe(true);
+  });
+
+  it("reports blocking doctor failures for broken manifest references", () => {
+    const appDir = createTempDir("pracht-cli-doctor-bad-");
+    writeManifestApp(appDir, {
+      routesSource: `import { defineApp, route } from "@pracht/core";
+
+export const app = defineApp({
+  routes: [route("/broken", "./routes/missing.tsx", { id: "broken", render: "ssr" })],
+});
+`,
+    });
+
+    const result = runCliStatus(["doctor", "--json"], { cwd: appDir });
+    expect(result.status).toBe(1);
+
+    const report = JSON.parse(result.stdout);
+    expect(report.ok).toBe(false);
+    expect(report.checks.some((check) => check.message.includes("missing files"))).toBe(true);
+  });
+
+  it("reports a healthy manifest app in verify json output", () => {
+    const appDir = createTempDir("pracht-cli-verify-ok-");
+    writeManifestApp(appDir, {
+      routesSource: `import { defineApp, route } from "@pracht/core";
+
+export const app = defineApp({
+  routes: [route("/dashboard", "./routes/dashboard.tsx", { id: "dashboard", render: "ssr" })],
+});
+`,
+    });
+
+    writeProjectFile(
+      appDir,
+      "src/routes/dashboard.tsx",
+      `export function Component() {
+  return <h1>Dashboard</h1>;
+}
+`,
+    );
+    writeProjectFile(
+      appDir,
+      "src/api/health.ts",
+      `export function GET() {
+  return new Response("ok");
+}
+`,
+    );
+
+    const result = runCli(["verify", "--json"], { cwd: appDir });
+    const report = JSON.parse(result.stdout);
+
+    expect(report.ok).toBe(true);
+    expect(report.scope).toBe("full");
+    expect(report.checks.some((check) => check.message.includes("manifest module path"))).toBe(
+      true,
+    );
+    expect(report.checks.some((check) => check.message.includes("API route discovery"))).toBe(true);
+  });
+
+  it("reports duplicate API discovery failures in verify json output", () => {
+    const appDir = createTempDir("pracht-cli-verify-api-dupe-");
+    writeManifestApp(appDir);
+
+    writeProjectFile(
+      appDir,
+      "src/api/users.ts",
+      `export function GET() {
+  return new Response("users");
+}
+`,
+    );
+    writeProjectFile(
+      appDir,
+      "src/api/users/index.ts",
+      `export function GET() {
+  return new Response("users-index");
+}
+`,
+    );
+
+    const result = runCliStatus(["verify", "--json"], { cwd: appDir });
+    expect(result.status).toBe(1);
+
+    const report = JSON.parse(result.stdout);
+    expect(report.ok).toBe(false);
+    expect(report.checks.some((check) => check.message.includes("duplicate paths"))).toBe(true);
+  });
+
+  it("limits verify --changed to changed framework files", () => {
+    const appDir = createTempDir("pracht-cli-verify-changed-");
+    writeManifestApp(appDir, {
+      routesSource: `import { defineApp, route } from "@pracht/core";
+
+export const app = defineApp({
+  routes: [route("/dashboard", "./routes/dashboard.tsx", { id: "dashboard", render: "ssr" })],
+});
+`,
+    });
+
+    writeProjectFile(
+      appDir,
+      "src/routes/dashboard.tsx",
+      `export function Component() {
+  return <h1>Dashboard</h1>;
+}
+`,
+    );
+
+    initializeGitRepo(appDir);
+
+    writeProjectFile(
+      appDir,
+      "src/routes/dashboard.tsx",
+      `export function Component() {
+  return <h1>Updated dashboard</h1>;
+}
+`,
+    );
+    writeProjectFile(appDir, "notes.txt", "ignored");
+
+    const result = runCli(["verify", "--changed", "--json"], { cwd: appDir });
+    const report = JSON.parse(result.stdout);
+
+    expect(report.ok).toBe(true);
+    expect(report.scope).toBe("changed");
+    expect(report.frameworkFiles).toContain("src/routes/dashboard.tsx");
+    expect(report.frameworkFiles).not.toContain("notes.txt");
+    expect(
+      report.checks.some(
+        (check) =>
+          check.message.includes("Changed route module") &&
+          check.message.includes("src/routes/dashboard.tsx"),
+      ),
+    ).toBe(true);
+  });
+
+  it("scaffolds pages-router routes without touching a manifest", () => {
+    const appDir = createTempDir("pracht-cli-pages-");
+    writePagesApp(appDir);
+
+    runCli(["generate", "route", "--path", "/blog/:slug", "--render", "ssg", "--loader"], {
+      cwd: appDir,
+    });
+
+    const routePath = join(appDir, "src/pages/blog/[slug].tsx");
+    expect(existsSync(routePath)).toBe(true);
+
+    const routeSource = readFileSync(routePath, "utf-8");
+    expect(routeSource).toContain('export const RENDER_MODE = "ssg";');
+    expect(routeSource).toContain("export function getStaticPaths()");
+    expect(routeSource).toContain('slug: "example-slug"');
+  });
+});
+
+function createTempDir(prefix) {
+  const dir = mkdtempSync(join(tmpdir(), prefix));
+  tempDirs.push(dir);
+  return dir;
+}
+
+function runCli(args, { cwd }) {
+  return {
+    stdout: execFileSync(process.execPath, [cliPath, ...args], {
+      cwd,
+      encoding: "utf-8",
+      env: process.env,
+      stdio: ["ignore", "pipe", "pipe"],
+    }),
+  };
+}
+
+function runCliStatus(args, { cwd }) {
+  return spawnSync(process.execPath, [cliPath, ...args], {
+    cwd,
+    encoding: "utf-8",
+    env: process.env,
+  });
+}
+
+function initializeGitRepo(appDir) {
+  execFileSync("git", ["init"], {
+    cwd: appDir,
+    env: process.env,
+    stdio: "ignore",
+  });
+  execFileSync("git", ["config", "user.email", "test@example.com"], {
+    cwd: appDir,
+    env: process.env,
+    stdio: "ignore",
+  });
+  execFileSync("git", ["config", "user.name", "Pracht Tests"], {
+    cwd: appDir,
+    env: process.env,
+    stdio: "ignore",
+  });
+  execFileSync("git", ["add", "."], {
+    cwd: appDir,
+    env: process.env,
+    stdio: "ignore",
+  });
+  execFileSync("git", ["commit", "-m", "initial"], {
+    cwd: appDir,
+    env: process.env,
+    stdio: "ignore",
+  });
+}
+
+function writeManifestApp(appDir, { routesSource } = {}) {
+  writeProjectFile(
+    appDir,
+    "package.json",
+    JSON.stringify(
+      {
+        name: "fixture-app",
+        private: true,
+        dependencies: {
+          "@pracht/adapter-node": "workspace:*",
+          "@pracht/cli": "workspace:*",
+        },
+      },
+      null,
+      2,
+    ),
+  );
+  writeProjectFile(
+    appDir,
+    "vite.config.ts",
+    `import { defineConfig } from "vite";
+import { pracht } from "@pracht/vite-plugin";
+
+export default defineConfig(async () => ({
+  plugins: [await pracht()],
+}));
+`,
+  );
+  writeProjectFile(
+    appDir,
+    "src/routes.ts",
+    routesSource ??
+      `import { defineApp } from "@pracht/core";
+
+export const app = defineApp({
+  routes: [],
+});
+`,
+  );
+}
+
+function writePagesApp(appDir) {
+  writeProjectFile(
+    appDir,
+    "package.json",
+    JSON.stringify(
+      {
+        name: "fixture-pages-app",
+        private: true,
+        dependencies: {
+          "@pracht/adapter-node": "workspace:*",
+          "@pracht/cli": "workspace:*",
+        },
+      },
+      null,
+      2,
+    ),
+  );
+  writeProjectFile(
+    appDir,
+    "vite.config.ts",
+    `import { defineConfig } from "vite";
+import { pracht } from "@pracht/vite-plugin";
+
+export default defineConfig(async () => ({
+  plugins: [await pracht({ pagesDir: "/src/pages" })],
+}));
+`,
+  );
+}
+
+function writeProjectFile(appDir, relativePath, contents) {
+  const filePath = resolve(appDir, relativePath);
+  mkdirSync(dirname(filePath), { recursive: true });
+  writeFileSync(filePath, contents.endsWith("\n") ? contents : `${contents}\n`, "utf-8");
+}