@chidchanun/bcp 0.1.9 → 0.1.11

package/packages/bundler/src/server-production-guards.ts

@@ -0,0 +1,497 @@
+import fs from "node:fs";
+import path from "node:path";
+import {
+    fileURLToPath,
+} from "node:url";
+
+import {
+    build,
+} from "esbuild";
+
+import {
+    createServerEnvironmentDefines,
+} from "../../env/src/index.js";
+
+import type {
+    Route,
+} from "../../router/src/index.js";
+
+import {
+    findPageGuardFiles,
+} from "../../server/src/page-guard.js";
+
+export async function buildProductionGuards(
+    pageRoutes: Route[],
+    rootDirectory: string,
+    serverDirectory: string
+): Promise<void> {
+    const outputFile =
+        path.join(
+            serverDirectory,
+            "guards.mjs"
+        );
+
+    fs.rmSync(
+        outputFile,
+        {
+            force: true,
+        }
+    );
+
+    const appDirectory =
+        path.join(
+            rootDirectory,
+            "app"
+        );
+    const guardedRoutes =
+        pageRoutes
+            .map(
+                (route) => ({
+                    route,
+                    guardFiles:
+                        findPageGuardFiles(
+                            appDirectory,
+                            route.filePath
+                        ),
+                })
+            )
+            .filter(
+                (entry) =>
+                    entry.guardFiles.length > 0
+            );
+
+    if (
+        guardedRoutes.length ===
+        0
+    ) {
+        console.log(
+            "[BCP Build] Guards: none"
+        );
+        return;
+    }
+
+    const entryDirectory =
+        path.join(
+            rootDirectory,
+            ".bcp-framework",
+            "build",
+            ".guard-entry"
+        );
+    const entryFile =
+        path.join(
+            entryDirectory,
+            "guards-entry.mjs"
+        );
+
+    fs.rmSync(
+        entryDirectory,
+        {
+            recursive: true,
+            force: true,
+        }
+    );
+    fs.mkdirSync(
+        entryDirectory,
+        {
+            recursive: true,
+        }
+    );
+
+    fs.writeFileSync(
+        entryFile,
+        createGuardEntry(
+            guardedRoutes,
+            rootDirectory,
+            entryDirectory
+        ),
+        "utf8"
+    );
+
+    const frameworkDirectory =
+        path.dirname(
+            fileURLToPath(
+                import.meta.url
+            )
+        );
+    const frameworkServerEntry =
+        path.resolve(
+            frameworkDirectory,
+            "../../client/src/server.ts"
+        );
+    const frameworkServerOnlyEntry =
+        path.resolve(
+            frameworkDirectory,
+            "../../client/src/server-only.mjs"
+        );
+    const frameworkCacheEntry =
+        path.resolve(
+            frameworkDirectory,
+            "../../cache/src/index.ts"
+        );
+
+    try {
+        await build({
+            absWorkingDir:
+                rootDirectory,
+            entryPoints: [
+                entryFile,
+            ],
+            outfile:
+                outputFile,
+            bundle:
+                true,
+            platform:
+                "node",
+            format:
+                "esm",
+            target: [
+                "node24",
+            ],
+            minify:
+                process.env
+                    .BCP_BUILD_MINIFY !==
+                "0",
+            sourcemap:
+                process.env
+                    .BCP_BUILD_SOURCE_MAPS ===
+                "1",
+            treeShaking:
+                true,
+            packages:
+                "external",
+            plugins: [
+                {
+                    name:
+                        "bcp-guard-runtime",
+                    setup(buildApi) {
+                        buildApi.onResolve(
+                            {
+                                filter:
+                                    /^bcp\/server$/,
+                            },
+                            () => ({
+                                path:
+                                    frameworkServerEntry,
+                            })
+                        );
+                        buildApi.onResolve(
+                            {
+                                filter:
+                                    /^bcp\/server-only$/,
+                            },
+                            () => ({
+                                path:
+                                    frameworkServerOnlyEntry,
+                            })
+                        );
+                        buildApi.onResolve(
+                            {
+                                filter:
+                                    /^bcp\/cache$/,
+                            },
+                            () => ({
+                                path:
+                                    frameworkCacheEntry,
+                            })
+                        );
+                    },
+                },
+            ],
+            define:
+                createServerEnvironmentDefines(
+                    "production"
+                ),
+            legalComments:
+                "none",
+            logLevel:
+                "silent",
+        });
+    } finally {
+        fs.rmSync(
+            entryDirectory,
+            {
+                recursive: true,
+                force: true,
+            }
+        );
+    }
+
+    console.log(
+        `[BCP Build] Guards: ${guardedRoutes.length} protected route(s) -> ${path.relative(rootDirectory, outputFile).replace(/\\/g, "/")}`
+    );
+}
+
+function createGuardEntry(
+    guardedRoutes: Array<{
+        route: Route;
+        guardFiles: string[];
+    }>,
+    rootDirectory: string,
+    entryDirectory: string
+): string {
+    const frameworkDirectory =
+        path.dirname(
+            fileURLToPath(
+                import.meta.url
+            )
+        );
+    const pageGuardRuntime =
+        path.resolve(
+            frameworkDirectory,
+            "../../server/src/page-guard.ts"
+        );
+    const requestContextRuntime =
+        path.resolve(
+            frameworkDirectory,
+            "../../server/src/request-context.ts"
+        );
+    const routerRuntime =
+        path.resolve(
+            frameworkDirectory,
+            "../../router/src/index.ts"
+        );
+
+    const imports: string[] = [
+        `import { executePageGuardFunctions } from ${JSON.stringify(
+            toImportSpecifier(
+                entryDirectory,
+                pageGuardRuntime
+            )
+        )};`,
+        `import { applyResponseCookies, runWithRequestContext } from ${JSON.stringify(
+            toImportSpecifier(
+                entryDirectory,
+                requestContextRuntime
+            )
+        )};`,
+        `import { matchRoute } from ${JSON.stringify(
+            toImportSpecifier(
+                entryDirectory,
+                routerRuntime
+            )
+        )};`,
+    ];
+    const guardNameByFile =
+        new Map<string, string>();
+    let guardIndex =
+        0;
+
+    for (const entry of guardedRoutes) {
+        for (const guardFile of entry.guardFiles) {
+            if (
+                guardNameByFile.has(
+                    guardFile
+                )
+            ) {
+                continue;
+            }
+
+            const guardName =
+                `Guard${guardIndex++}`;
+            guardNameByFile.set(
+                guardFile,
+                guardName
+            );
+            imports.push(
+                `import { guard as ${guardName} } from ${JSON.stringify(
+                    toImportSpecifier(
+                        entryDirectory,
+                        guardFile
+                    )
+                )};`
+            );
+        }
+    }
+
+    const definitions =
+        guardedRoutes.map(
+            ({
+                route,
+                guardFiles,
+            }) => {
+                const guards =
+                    guardFiles.map(
+                        (guardFile) => {
+                            const guardName =
+                                guardNameByFile.get(
+                                    guardFile
+                                );
+
+                            if (!guardName) {
+                                throw new Error(
+                                    `BCP Framework: guard import was not generated for "${guardFile}".`
+                                );
+                            }
+
+                            const label =
+                                path.relative(
+                                    rootDirectory,
+                                    guardFile
+                                )
+                                    .replace(
+                                        /\\/g,
+                                        "/"
+                                    );
+
+                            return `{
+        filePath: ${JSON.stringify(label)},
+        guard: ${guardName}
+      }`;
+                        }
+                    );
+
+                return `{
+    pathname: ${JSON.stringify(route.pathname)},
+    segments: ${JSON.stringify(route.segments)},
+    guards: [${guards.join(", ")}]
+  }`;
+            }
+        );
+
+    return `${imports.join("\n")}
+
+const definitions = [
+  ${definitions.join(",\n  ")}
+];
+
+const routePatterns =
+  definitions.map(
+    (definition) => ({
+      pathname:
+        definition.pathname,
+      segments:
+        definition.segments,
+      filePath:
+        definition.pathname,
+      layouts: []
+    })
+  );
+
+const definitionByPathname =
+  new Map(
+    definitions.map(
+      (definition) => [
+        definition.pathname,
+        definition
+      ]
+    )
+  );
+
+export const guardedPathnames =
+  definitions.map(
+    (definition) =>
+      definition.pathname
+  );
+
+export async function evaluateRouteGuards(input) {
+  const target =
+    new URL(
+      input.url
+    );
+  const match =
+    matchRoute(
+      routePatterns,
+      target.pathname
+    );
+
+  if (!match) {
+    return null;
+  }
+
+  const definition =
+    definitionByPathname.get(
+      match.route.pathname
+    );
+
+  if (!definition) {
+    return null;
+  }
+
+  const request =
+    new Request(
+      target,
+      {
+        method:
+          input.method ||
+          "GET",
+        headers:
+          new Headers(
+            input.headers ||
+            []
+          )
+      }
+    );
+
+  return runWithRequestContext(
+    request,
+    async () => {
+      const execution =
+        await executePageGuardFunctions(
+          definition.guards,
+          match.params,
+          target
+        );
+
+      if (execution.response) {
+        return {
+          kind:
+            "response",
+          response:
+            applyResponseCookies(
+              execution.response
+            )
+        };
+      }
+
+      const cookieCarrier =
+        applyResponseCookies(
+          new Response(
+            null,
+            {
+              status: 204
+            }
+          )
+        );
+
+      return {
+        kind:
+          "allow",
+        data:
+          execution.data,
+        setCookies:
+          cookieCarrier.headers.getSetCookie()
+      };
+    },
+    {
+      remoteAddress:
+        input.remoteAddress ||
+        null
+    }
+  );
+}
+`;
+}
+
+function toImportSpecifier(
+    fromDirectory: string,
+    filePath: string
+): string {
+    let relative =
+        path.relative(
+            fromDirectory,
+            filePath
+        )
+            .replace(
+                /\\/g,
+                "/"
+            );
+
+    if (
+        !relative.startsWith(".")
+    ) {
+        relative =
+            `./${relative}`;
+    }
+
+    return relative;
+}

package/packages/bundler/src/server-production-middleware.ts

@@ -12,10 +12,18 @@ import {
     createServerEnvironmentDefines,
 } from "../../env/src/index.js";
 
+import {
+    routeHasPageActions,
+} from "../../server/src/form-action.js";
+
 import {
     findProjectMiddlewareFile,
 } from "../../server/src/middleware-loader.js";
 
+import {
+    routeHasPageGuard,
+} from "../../server/src/page-guard.js";
+
 import type {
     ApiRoute,
     Route,
@@ -29,6 +37,14 @@ import type {
     PartialHydrationBuildManifest,
 } from "./partial-hydration.js";
 
+import {
+    buildProductionActions,
+} from "./server-production-actions.js";
+
+import {
+    buildProductionGuards,
+} from "./server-production-guards.js";
+
 import {
     buildProductionServer as buildBaseProductionServer,
     type ProductionServerBuildResult,
@@ -73,7 +89,8 @@ export async function buildProductionServer(
     writeCacheManifest(
         pageRoutes,
         apiRoutes,
-        serverDirectory
+        serverDirectory,
+        rootDirectory
     );
 
     await buildProductionMiddleware(
@@ -81,6 +98,18 @@ export async function buildProductionServer(
         serverDirectory
     );
 
+    await buildProductionGuards(
+        pageRoutes,
+        rootDirectory,
+        serverDirectory
+    );
+
+    await buildProductionActions(
+        pageRoutes,
+        rootDirectory,
+        serverDirectory
+    );
+
     return {
         ...baseResult,
         size:
@@ -174,11 +203,6 @@ async function bundleServerCacheRuntime(
             serverFile
         );
 
-        /*
-         * The base server build may have emitted an external map. The final
-         * cache-runtime rebundle uses an inline map so a stale server.mjs.map
-         * must not be shipped next to the rewritten bundle.
-         */
         fs.rmSync(
             `${serverFile}.map`,
             {
@@ -204,14 +228,32 @@ async function bundleServerCacheRuntime(
 function writeCacheManifest(
     pageRoutes: Route[],
     apiRoutes: ApiRoute[],
-    serverDirectory: string
+    serverDirectory: string,
+    rootDirectory: string
 ): void {
+    const appDirectory =
+        path.join(
+            rootDirectory,
+            "app"
+        );
+    const cacheablePages =
+        pageRoutes.filter(
+            (route) =>
+                !routeHasPageGuard(
+                    appDirectory,
+                    route.filePath
+                ) &&
+                !routeHasPageActions(
+                    route.filePath
+                )
+        );
+
     const manifest:
         CacheManifest = {
         version: 1,
         pages:
             collectCacheRoutes(
-                pageRoutes
+                cacheablePages
             ),
         apiRoutes:
             collectCacheRoutes(

package/packages/cli/src/args.ts

@@ -6,6 +6,7 @@ export type CliCommand =
   | "build"
   | "start"
   | "routes"
+  | "update"
   | "help"
   | "version";
 
@@ -17,6 +18,12 @@ export interface CliOptions {
   port?: number;
 
   hostname?: string;
+
+  updateTarget?: string;
+
+  updateCheck?: boolean;
+
+  updateDryRun?: boolean;
 }
 
 export function parseCliArgs(
@@ -33,6 +40,15 @@ export function parseCliArgs(
   let hostname:
     string | undefined;
 
+  let updateTarget:
+    string | undefined;
+
+  let updateCheck =
+    false;
+
+  let updateDryRun =
+    false;
+
   let commandSet = false;
 
   for (
@@ -152,6 +168,22 @@ export function parseCliArgs(
       continue;
     }
 
+    if (
+      argument === "--check"
+    ) {
+      updateCheck =
+        true;
+      continue;
+    }
+
+    if (
+      argument === "--dry-run"
+    ) {
+      updateDryRun =
+        true;
+      continue;
+    }
+
     if (
       argument.startsWith("-")
     ) {
@@ -179,6 +211,16 @@ export function parseCliArgs(
       continue;
     }
 
+    if (
+      commandSet &&
+      command === "update" &&
+      updateTarget === undefined
+    ) {
+      updateTarget =
+        argument;
+      continue;
+    }
+
     if (commandSet) {
       throw new Error(
         `Unexpected argument: ${argument}`
@@ -190,6 +232,7 @@ export function parseCliArgs(
       argument === "build" ||
       argument === "start" ||
       argument === "routes" ||
+      argument === "update" ||
       argument === "help" ||
       argument === "version"
     ) {
@@ -203,11 +246,26 @@ export function parseCliArgs(
     );
   }
 
+  if (
+    command !== "update" &&
+    (
+      updateCheck ||
+      updateDryRun
+    )
+  ) {
+    throw new Error(
+      "Options --check and --dry-run are only valid with `bcp update`."
+    );
+  }
+
   return {
     command,
     rootDirectory,
     port,
     hostname,
+    updateTarget,
+    updateCheck,
+    updateDryRun,
   };
 }