@chidchanun/bcp 0.1.10 → 0.1.12

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

@@ -0,0 +1,523 @@
+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";
+
+import {
+    findPageActionFile,
+} from "../../server/src/form-action.js";
+
+export async function buildProductionActions(
+    pageRoutes: Route[],
+    rootDirectory: string,
+    serverDirectory: string
+): Promise<void> {
+    const outputFile =
+        path.join(
+            serverDirectory,
+            "actions.mjs"
+        );
+
+    fs.rmSync(
+        outputFile,
+        {
+            force: true,
+        }
+    );
+
+    const appDirectory =
+        path.join(
+            rootDirectory,
+            "app"
+        );
+    const actionRoutes =
+        pageRoutes
+            .map(
+                (route) => ({
+                    route,
+                    actionFile:
+                        findPageActionFile(
+                            route.filePath
+                        ),
+                    guardFiles:
+                        findPageGuardFiles(
+                            appDirectory,
+                            route.filePath
+                        ),
+                })
+            )
+            .filter(
+                (entry) =>
+                    entry.actionFile !==
+                    null
+            ) as Array<{
+                route: Route;
+                actionFile: string;
+                guardFiles: string[];
+            }>;
+
+    if (
+        actionRoutes.length ===
+        0
+    ) {
+        console.log(
+            "[BCP Build] Actions: none"
+        );
+        return;
+    }
+
+    const entryDirectory =
+        path.join(
+            rootDirectory,
+            ".bcp-framework",
+            "build",
+            ".action-entry"
+        );
+    const entryFile =
+        path.join(
+            entryDirectory,
+            "actions-entry.mjs"
+        );
+
+    fs.rmSync(
+        entryDirectory,
+        {
+            recursive: true,
+            force: true,
+        }
+    );
+    fs.mkdirSync(
+        entryDirectory,
+        {
+            recursive: true,
+        }
+    );
+
+    fs.writeFileSync(
+        entryFile,
+        createActionEntry(
+            actionRoutes,
+            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-action-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] Actions: ${actionRoutes.length} route(s) -> ${path.relative(rootDirectory, outputFile).replace(/\\/g, "/")}`
+    );
+}
+
+function createActionEntry(
+    actionRoutes: Array<{
+        route: Route;
+        actionFile: string;
+        guardFiles: string[];
+    }>,
+    rootDirectory: string,
+    entryDirectory: string
+): string {
+    const frameworkDirectory =
+        path.dirname(
+            fileURLToPath(
+                import.meta.url
+            )
+        );
+    const actionRuntime =
+        path.resolve(
+            frameworkDirectory,
+            "../../server/src/form-action.ts"
+        );
+    const actionTransportRuntime =
+        path.resolve(
+            frameworkDirectory,
+            "../../server/src/form-action-transport.ts"
+        );
+    const guardRuntime =
+        path.resolve(
+            frameworkDirectory,
+            "../../server/src/page-guard.ts"
+        );
+    const requestContextRuntime =
+        path.resolve(
+            frameworkDirectory,
+            "../../server/src/request-context.ts"
+        );
+    const cacheRuntime =
+        path.resolve(
+            frameworkDirectory,
+            "../../cache/src/index.ts"
+        );
+    const routerRuntime =
+        path.resolve(
+            frameworkDirectory,
+            "../../router/src/index.ts"
+        );
+
+    const imports: string[] = [
+        `import { assertPageActionName, executePageActionFunction, normalizePageActionMethod } from ${JSON.stringify(toImportSpecifier(entryDirectory, actionRuntime))};`,
+        `import { completePageActionExecution } from ${JSON.stringify(toImportSpecifier(entryDirectory, actionTransportRuntime))};`,
+        `import { executePageGuardFunctions } from ${JSON.stringify(toImportSpecifier(entryDirectory, guardRuntime))};`,
+        `import { runWithRequestContext } from ${JSON.stringify(toImportSpecifier(entryDirectory, requestContextRuntime))};`,
+        `import { runWithRequestCacheContext } from ${JSON.stringify(toImportSpecifier(entryDirectory, cacheRuntime))};`,
+        `import { matchRoute } from ${JSON.stringify(toImportSpecifier(entryDirectory, routerRuntime))};`,
+    ];
+    const guardNameByFile =
+        new Map<string, string>();
+    let guardIndex =
+        0;
+
+    actionRoutes.forEach(
+        (entry, index) => {
+            imports.push(
+                `import * as Actions${index} from ${JSON.stringify(toImportSpecifier(entryDirectory, entry.actionFile))};`
+            );
+
+            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 =
+        actionRoutes.map(
+            (entry, index) => {
+                const guards =
+                    entry.guardFiles.map(
+                        (guardFile) => {
+                            const guardName =
+                                guardNameByFile.get(
+                                    guardFile
+                                );
+
+                            if (!guardName) {
+                                throw new Error(
+                                    `BCP Framework: action guard import was not generated for "${guardFile}".`
+                                );
+                            }
+
+                            return `{
+        filePath: ${JSON.stringify(path.relative(rootDirectory, guardFile).replace(/\\/g, "/"))},
+        guard: ${guardName}
+      }`;
+                        }
+                    );
+
+                return `{
+    pathname: ${JSON.stringify(entry.route.pathname)},
+    segments: ${JSON.stringify(entry.route.segments)},
+    actions: Actions${index},
+    actionFile: ${JSON.stringify(path.relative(rootDirectory, entry.actionFile).replace(/\\/g, "/"))},
+    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 actionPathnames =
+  definitions.map(
+    (definition) =>
+      definition.pathname
+  );
+
+export async function evaluateRouteAction(input) {
+  assertPageActionName(
+    input.name
+  );
+
+  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 candidate =
+    definition.actions[
+      input.name
+    ];
+
+  if (
+    typeof candidate !==
+    "function"
+  ) {
+    return null;
+  }
+
+  const method =
+    normalizePageActionMethod(
+      input.method
+    );
+  const request =
+    new Request(
+      target,
+      {
+        method,
+        headers:
+          new Headers(
+            input.headers ||
+            []
+          )
+      }
+    );
+
+  return runWithRequestContext(
+    request,
+    () =>
+      runWithRequestCacheContext(
+        target.pathname,
+        async () => {
+          const guardExecution =
+            await executePageGuardFunctions(
+              definition.guards,
+              match.params,
+              target
+            );
+
+          if (guardExecution.response) {
+            return completePageActionExecution({
+              hasGuard:
+                guardExecution.hasGuard,
+              guardData:
+                guardExecution.data,
+              data:
+                null,
+              response:
+                guardExecution.response
+            });
+          }
+
+          const execution =
+            await executePageActionFunction(
+              candidate,
+              input.name,
+              method,
+              input.formData,
+              match.params,
+              target,
+              guardExecution.data,
+              guardExecution.hasGuard,
+              definition.actionFile
+            );
+
+          return completePageActionExecution(
+            execution
+          );
+        }
+      ),
+    {
+      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,6 +12,10 @@ import {
     createServerEnvironmentDefines,
 } from "../../env/src/index.js";
 
+import {
+    routeHasPageActions,
+} from "../../server/src/form-action.js";
+
 import {
     findProjectMiddlewareFile,
 } from "../../server/src/middleware-loader.js";
@@ -33,6 +37,10 @@ import type {
     PartialHydrationBuildManifest,
 } from "./partial-hydration.js";
 
+import {
+    buildProductionActions,
+} from "./server-production-actions.js";
+
 import {
     buildProductionGuards,
 } from "./server-production-guards.js";
@@ -96,6 +104,12 @@ export async function buildProductionServer(
         serverDirectory
     );
 
+    await buildProductionActions(
+        pageRoutes,
+        rootDirectory,
+        serverDirectory
+    );
+
     return {
         ...baseResult,
         size:
@@ -228,6 +242,9 @@ function writeCacheManifest(
                 !routeHasPageGuard(
                     appDirectory,
                     route.filePath
+                ) &&
+                !routeHasPageActions(
+                    route.filePath
                 )
         );