@chidchanun/bcp 0.1.9 → 0.1.10

package/packages/server/src/page-loader.ts

@@ -4,12 +4,29 @@ import {
     pathToFileURL,
 } from "node:url";
 
+import {
+    executePageGuards,
+    type PageGuardData,
+} from "./page-guard.js";
+
+import {
+    headers,
+} from "./request-context.js";
+
 export const LOADER_DATA_PARAM =
     "__bcp_loader_data";
+export const GUARD_DATA_PARAM =
+    "__bcp_guard_data";
+export const GUARD_DATA_HEADER =
+    "x-bcp-guard-data";
+
+const SERVER_DATA_MARKER =
+    "__bcp_server_data";
 
 export interface PageLoaderContext {
     params: Record<string, any>;
     searchParams: URLSearchParams;
+    guardData: Readonly<PageGuardData>;
 }
 
 export type PageLoader = (
@@ -18,9 +35,26 @@ export type PageLoader = (
     | unknown
     | Promise<unknown>;
 
+export interface PageServerDataEnvelope {
+    __bcp_server_data: true;
+    hasPageLoader: boolean;
+    hasGuard: boolean;
+    loaderData: unknown;
+    guardData: PageGuardData;
+}
+
 export interface PageLoaderExecution {
+    /*
+     * hasLoader remains the SSR-provider switch for backward compatibility.
+     * It is true when either loader or guard data must be made available to
+     * React during server rendering.
+     */
     hasLoader: boolean;
+    hasPageLoader?: boolean;
+    hasGuard?: boolean;
     data: unknown;
+    loaderData?: unknown;
+    guardData?: PageGuardData;
     response: Response | null;
 }
 
@@ -81,20 +115,54 @@ export async function executePageLoader(
     requestUrl: URL,
     moduleVersion = 0
 ): Promise<PageLoaderExecution> {
+    const appDirectory =
+        findAppDirectory(
+            pageFilePath
+        );
+    const guardExecution =
+        await executePageGuards(
+            appDirectory,
+            pageFilePath,
+            params,
+            requestUrl,
+            moduleVersion
+        );
+
+    if (
+        guardExecution.response
+    ) {
+        return createExecution({
+            hasPageLoader:
+                false,
+            hasGuard:
+                guardExecution.hasGuard,
+            loaderData:
+                undefined,
+            guardData:
+                guardExecution.data,
+            response:
+                guardExecution.response,
+        });
+    }
+
     const loaderFile =
         findPageLoaderFile(
             pageFilePath
         );
 
     if (!loaderFile) {
-        return {
-            hasLoader:
+        return createExecution({
+            hasPageLoader:
                 false,
-            data:
+            hasGuard:
+                guardExecution.hasGuard,
+            loaderData:
                 undefined,
+            guardData:
+                guardExecution.data,
             response:
                 null,
-        };
+        });
     }
 
     const moduleUrl =
@@ -130,7 +198,9 @@ export async function executePageLoader(
             PageLoader,
         params,
         requestUrl,
-        loaderFile
+        loaderFile,
+        guardExecution.data,
+        guardExecution.hasGuard
     );
 }
 
@@ -138,8 +208,24 @@ export async function executePageLoaderFunction(
     loader: PageLoader,
     params: Record<string, any>,
     requestUrl: URL,
-    label = "loader"
+    label = "loader",
+    explicitGuardData?: PageGuardData,
+    explicitHasGuard?: boolean
 ): Promise<PageLoaderExecution> {
+    const headerGuardData =
+        explicitGuardData ===
+            undefined
+            ? await readGuardDataHeader()
+            : null;
+    const guardData =
+        explicitGuardData ??
+        headerGuardData?.data ??
+        {};
+    const hasGuard =
+        explicitHasGuard ??
+        headerGuardData?.hasGuard ??
+        false;
+
     const result =
         await loader({
             params: {
@@ -149,20 +235,25 @@ export async function executePageLoaderFunction(
                 new URLSearchParams(
                     requestUrl.searchParams
                 ),
+            guardData: {
+                ...guardData,
+            },
         });
 
     if (
         result instanceof
         Response
     ) {
-        return {
-            hasLoader:
+        return createExecution({
+            hasPageLoader:
                 true,
-            data:
+            hasGuard,
+            loaderData:
                 undefined,
+            guardData,
             response:
                 result,
-        };
+        });
     }
 
     assertLoaderData(
@@ -170,33 +261,239 @@ export async function executePageLoaderFunction(
         label
     );
 
-    return {
-        hasLoader:
+    return createExecution({
+        hasPageLoader:
             true,
-        data:
+        hasGuard,
+        loaderData:
             result,
+        guardData,
         response:
             null,
-    };
+    });
 }
 
 export function attachLoaderDataToParams(
     params: Record<string, any>,
     execution: PageLoaderExecution
 ): Record<string, any> {
-    if (!execution.hasLoader) {
-        return {
-            ...params,
+    let result = {
+        ...params,
+    };
+    const hasGuard =
+        execution.hasGuard ===
+        true;
+    const guardData =
+        execution.guardData ??
+        {};
+    const hasPageLoader =
+        execution.hasPageLoader ??
+        execution.hasLoader;
+    const loaderData =
+        execution.hasPageLoader ===
+            undefined
+            ? execution.data
+            : execution.loaderData;
+
+    if (hasGuard) {
+        result = {
+            ...result,
+            [GUARD_DATA_PARAM]:
+                guardData,
         };
     }
 
+    if (hasPageLoader) {
+        result = {
+            ...result,
+            [LOADER_DATA_PARAM]:
+                loaderData,
+        };
+    }
+
+    return result;
+}
+
+export function isPageServerDataEnvelope(
+    value: unknown
+): value is PageServerDataEnvelope {
+    return (
+        value !== null &&
+        typeof value ===
+            "object" &&
+        (
+            value as
+            Record<string, unknown>
+        )[SERVER_DATA_MARKER] ===
+            true
+    );
+}
+
+function createExecution(
+    input: {
+        hasPageLoader: boolean;
+        hasGuard: boolean;
+        loaderData: unknown;
+        guardData: PageGuardData;
+        response: Response | null;
+    }
+): PageLoaderExecution {
+    const data:
+        PageServerDataEnvelope = {
+        __bcp_server_data:
+            true,
+        hasPageLoader:
+            input.hasPageLoader,
+        hasGuard:
+            input.hasGuard,
+        loaderData:
+            input.loaderData,
+        guardData: {
+            ...input.guardData,
+        },
+    };
+
     return {
-        ...params,
-        [LOADER_DATA_PARAM]:
-            execution.data,
+        hasLoader:
+            input.hasPageLoader ||
+            input.hasGuard,
+        hasPageLoader:
+            input.hasPageLoader,
+        hasGuard:
+            input.hasGuard,
+        data,
+        loaderData:
+            input.loaderData,
+        guardData:
+            data.guardData,
+        response:
+            input.response,
     };
 }
 
+async function readGuardDataHeader():
+Promise<{
+    hasGuard: true;
+    data: PageGuardData;
+} | null> {
+    let requestHeaders:
+        Headers;
+
+    try {
+        requestHeaders =
+            await headers();
+    } catch {
+        return null;
+    }
+
+    const encoded =
+        requestHeaders.get(
+            GUARD_DATA_HEADER
+        );
+
+    if (!encoded) {
+        return null;
+    }
+
+    let parsed:
+        unknown;
+
+    try {
+        parsed =
+            JSON.parse(
+                Buffer.from(
+                    encoded,
+                    "base64url"
+                ).toString(
+                    "utf8"
+                )
+            );
+    } catch {
+        throw new Error(
+            "BCP Framework: invalid internal guard data header."
+        );
+    }
+
+    assertGuardHeaderData(
+        parsed
+    );
+
+    return {
+        hasGuard:
+            true,
+        data:
+            parsed,
+    };
+}
+
+function assertGuardHeaderData(
+    value: unknown
+): asserts value is PageGuardData {
+    if (
+        value === null ||
+        Array.isArray(
+            value
+        ) ||
+        typeof value !==
+            "object"
+    ) {
+        throw new Error(
+            "BCP Framework: invalid internal guard data header."
+        );
+    }
+
+    const prototype =
+        Object.getPrototypeOf(
+            value
+        );
+
+    if (
+        prototype !==
+            Object.prototype &&
+        prototype !==
+            null
+    ) {
+        throw new Error(
+            "BCP Framework: invalid internal guard data header."
+        );
+    }
+}
+
+function findAppDirectory(
+    pageFilePath: string
+): string {
+    let current =
+        path.dirname(
+            path.resolve(
+                pageFilePath
+            )
+        );
+
+    while (true) {
+        if (
+            path.basename(
+                current
+            ) === "app"
+        ) {
+            return current;
+        }
+
+        const parent =
+            path.dirname(
+                current
+            );
+
+        if (parent === current) {
+            throw new Error(
+                `BCP Framework: could not resolve app directory for page "${pageFilePath}".`
+            );
+        }
+
+        current =
+            parent;
+    }
+}
+
 function assertLoaderData(
     value: unknown,
     loaderLabel: string