@pracht/cli 1.1.5 → 1.2.1

package/{lib/build-shared.js → src/build-shared.ts}

@@ -1,27 +1,27 @@
 import { cpSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 
-import { DEFAULT_SECURITY_HEADERS, VERSION } from "./constants.js";
+import { VERSION } from "./constants.js";
 
 const ROUTE_STATE_REQUEST_HEADER = "x-pracht-route-state-request";
 
-export function setDefaultSecurityHeaders(res, headers = {}) {
-  for (const [key, value] of Object.entries({
-    ...DEFAULT_SECURITY_HEADERS,
-    ...headers,
-  })) {
-    res.setHeader(key, value);
-  }
+interface VercelBuildOutputOptions {
+  functionName?: string;
+  headersManifest?: Record<string, Record<string, string>>;
+  isgRoutes: string[];
+  regions?: string[];
+  root: string;
+  staticRoutes: string[];
 }
 
 export function writeVercelBuildOutput({
   functionName,
   headersManifest = {},
+  isgRoutes,
   regions,
   root,
   staticRoutes,
-  isgRoutes,
-}) {
+}: VercelBuildOutputOptions): string {
   const outputDir = join(root, ".vercel/output");
   const staticDir = join(outputDir, "static");
   const functionDir = join(outputDir, "functions", `${functionName || "render"}.func`);
@@ -49,9 +49,19 @@ export function writeVercelBuildOutput({
   return ".vercel/output";
 }
 
-function createVercelOutputConfig({ functionName, headersManifest, staticRoutes, isgRoutes }) {
+function createVercelOutputConfig({
+  functionName,
+  headersManifest,
+  staticRoutes,
+  isgRoutes,
+}: {
+  functionName?: string;
+  headersManifest: Record<string, Record<string, string>>;
+  isgRoutes: string[];
+  staticRoutes: string[];
+}): Record<string, unknown> {
   const target = `/${functionName || "render"}`;
-  const routes = [
+  const routes: Record<string, unknown>[] = [
     {
       dest: target,
       has: [{ type: "header", key: ROUTE_STATE_REQUEST_HEADER, value: "1" }],
@@ -76,7 +86,7 @@ function createVercelOutputConfig({ functionName, headersManifest, staticRoutes,
   routes.push({ handle: "filesystem" });
   routes.push({ dest: target, src: "/(.*)" });
 
-  const headers = [
+  const headers: Record<string, unknown>[] = [
     {
       headers: [
         {
@@ -111,8 +121,8 @@ function createVercelOutputConfig({ functionName, headersManifest, staticRoutes,
   };
 }
 
-function createVercelFunctionConfig({ regions }) {
-  const config = {
+function createVercelFunctionConfig({ regions }: { regions?: string[] }): Record<string, unknown> {
+  const config: Record<string, unknown> = {
     entrypoint: "server.js",
     runtime: "edge",
   };
@@ -124,11 +134,11 @@ function createVercelFunctionConfig({ regions }) {
   return config;
 }
 
-function sortStaticRoutes(routes) {
+function sortStaticRoutes(routes: string[]): string[] {
   return [...new Set(routes)].sort((left, right) => right.length - left.length);
 }
 
-function routeToRouteExpression(route) {
+function routeToRouteExpression(route: string): string {
   if (route === "/") {
     return "^/$";
   }
@@ -136,7 +146,7 @@ function routeToRouteExpression(route) {
   return `^${escapeRegex(route)}/?$`;
 }
 
-function routeToStaticHtmlPath(route) {
+function routeToStaticHtmlPath(route: string): string {
   if (route === "/") {
     return "/index.html";
   }
@@ -144,10 +154,10 @@ function routeToStaticHtmlPath(route) {
   return `${route}/index.html`;
 }
 
-function routeToHeaderSource(route) {
+function routeToHeaderSource(route: string): string {
   return route === "/" ? "/" : route;
 }
 
-function escapeRegex(value) {
+function escapeRegex(value: string): string {
   return value.replace(/[|\\{}()[\]^$+*?.-]/g, "\\$&");
 }

package/src/commands/build.ts

@@ -0,0 +1,137 @@
+import { cpSync, existsSync, mkdirSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+
+import { defineCommand } from "citty";
+import { build as viteBuild } from "vite";
+
+import { readClientBuildAssets } from "../build-metadata.js";
+import { writeVercelBuildOutput } from "../build-shared.js";
+
+export default defineCommand({
+  meta: {
+    name: "build",
+    description: "Production build (client + server)",
+  },
+  async run() {
+    const root = process.cwd();
+
+    console.log("\n  Building client...\n");
+    await viteBuild({
+      root,
+      build: {
+        outDir: "dist",
+        manifest: true,
+        rollupOptions: {
+          input: "virtual:pracht/client",
+        },
+      },
+    });
+
+    console.log("\n  Building server...\n");
+    await viteBuild({
+      root,
+      build: {
+        outDir: "dist/server",
+        ssr: "virtual:pracht/server",
+      },
+    });
+
+    const serverEntry = resolve(root, "dist/server/server.js");
+    let clientDir: string;
+    if (existsSync(resolve(root, "dist/client/.vite/manifest.json"))) {
+      clientDir = resolve(root, "dist/client");
+    } else {
+      clientDir = resolve(root, "dist/client");
+      const distRoot = resolve(root, "dist");
+      mkdirSync(clientDir, { recursive: true });
+      for (const entry of readdirSync(distRoot)) {
+        if (entry === "server" || entry === "client") continue;
+        const sourcePath = join(distRoot, entry);
+        const destinationPath = join(clientDir, entry);
+        cpSync(sourcePath, destinationPath, { recursive: true });
+        rmSync(sourcePath, { force: true, recursive: true });
+      }
+    }
+
+    const publicDir = resolve(root, "public");
+    if (existsSync(publicDir)) {
+      cpSync(publicDir, clientDir, { recursive: true });
+    }
+
+    if (existsSync(serverEntry)) {
+      const serverMod = await import(serverEntry);
+      const { prerenderApp } = serverMod;
+      const { clientEntryUrl, cssManifest, jsManifest } = readClientBuildAssets(root);
+
+      const { pages, isgManifest } = await prerenderApp({
+        app: serverMod.resolvedApp,
+        clientEntryUrl: clientEntryUrl ?? undefined,
+        cssManifest,
+        jsManifest,
+        registry: serverMod.registry,
+        withISGManifest: true,
+      });
+      const headersManifest: Record<string, Record<string, string>> = Object.fromEntries(
+        pages.map((page: { path: string; headers?: Record<string, string> }) => [
+          page.path,
+          page.headers ?? {},
+        ]),
+      );
+
+      if (pages.length > 0) {
+        console.log(`\n  Prerendering ${pages.length} SSG/ISG route(s)...\n`);
+        for (const page of pages) {
+          const filePath =
+            page.path === "/"
+              ? join(clientDir, "index.html")
+              : join(clientDir, page.path, "index.html");
+
+          mkdirSync(dirname(filePath), { recursive: true });
+          writeFileSync(filePath, page.html, "utf-8");
+          console.log(`    ${page.path} → ${filePath.replace(root + "/", "")}`);
+        }
+      }
+
+      if (Object.keys(headersManifest).length > 0) {
+        const headersManifestJson = `${JSON.stringify(headersManifest, null, 2)}\n`;
+        writeFileSync(
+          resolve(root, "dist/server/headers-manifest.json"),
+          headersManifestJson,
+          "utf-8",
+        );
+        mkdirSync(resolve(clientDir, "_pracht"), { recursive: true });
+        writeFileSync(resolve(clientDir, "_pracht/headers.json"), headersManifestJson, "utf-8");
+      }
+
+      if (Object.keys(isgManifest).length > 0) {
+        const isgManifestPath = resolve(root, "dist/server/isg-manifest.json");
+        writeFileSync(isgManifestPath, JSON.stringify(isgManifest, null, 2), "utf-8");
+        console.log(
+          `\n  ISG manifest → dist/server/isg-manifest.json (${Object.keys(isgManifest).length} route(s))\n`,
+        );
+      }
+
+      if (serverMod.buildTarget === "cloudflare") {
+        console.log("\n  Cloudflare worker → dist/server/server.js\n");
+        console.log("  Deploy with: wrangler deploy\n");
+      }
+
+      if (serverMod.buildTarget === "vercel") {
+        const outputPath = writeVercelBuildOutput({
+          functionName: serverMod.vercelFunctionName,
+          isgRoutes: Object.keys(isgManifest),
+          headersManifest,
+          regions: serverMod.vercelRegions,
+          root,
+          staticRoutes: pages
+            .map((page: { path: string }) => page.path)
+            .filter((path: string) => !(path in isgManifest)),
+        });
+
+        console.log(`\n  Vercel build output → ${outputPath}\n`);
+      }
+    }
+
+    console.log("\n  Build complete.\n");
+  },
+});

package/src/commands/dev.ts

@@ -0,0 +1,27 @@
+import { defineCommand } from "citty";
+import { createServer } from "vite";
+
+export default defineCommand({
+  meta: {
+    name: "dev",
+    description: "Start development server with HMR",
+  },
+  args: {
+    port: {
+      type: "positional",
+      description: "Port number",
+      required: false,
+    },
+  },
+  async run({ args }) {
+    const port = parseInt(process.env.PORT || args.port || "3000", 10);
+
+    const server = await createServer({
+      root: process.cwd(),
+      server: { port },
+    });
+
+    await server.listen();
+    server.printUrls();
+  },
+});

package/src/commands/doctor.ts

@@ -0,0 +1,33 @@
+import { defineCommand } from "citty";
+
+import { runDoctor } from "../verification.js";
+
+export default defineCommand({
+  meta: {
+    name: "doctor",
+    description: "Validate app wiring",
+  },
+  args: {
+    json: {
+      type: "boolean",
+      description: "Output as JSON",
+    },
+  },
+  async run({ args }) {
+    const report = runDoctor(process.cwd());
+
+    if (args.json) {
+      console.log(JSON.stringify(report, null, 2));
+    } else {
+      console.log(`Pracht doctor (${report.mode} mode)`);
+      for (const check of report.checks) {
+        console.log(`${check.status.toUpperCase().padEnd(5)} ${check.message}`);
+      }
+      console.log(report.ok ? "\nNo blocking issues found." : "\nBlocking issues found.");
+    }
+
+    if (!report.ok) {
+      process.exitCode = 1;
+    }
+  },
+});