@chidchanun/bcp 0.1.7 → 0.1.9

package/packages/server/src/standalone-production-runtime-v2.ts

@@ -20,6 +20,10 @@ import type {
     ProductionRouteAsset,
 } from "../../bundler/src/production.js";
 
+import {
+    BcpLoaderDataProvider,
+} from "../../client/src/loader-data.js";
+
 import {
     createMetadataHeadEntries,
     type ResolvedMetadata,
@@ -49,6 +53,13 @@ import {
     type MetadataSource,
 } from "./metadata.js";
 
+import {
+    attachLoaderDataToParams,
+    executePageLoaderFunction,
+    type PageLoader,
+    type PageLoaderExecution,
+} from "./page-loader.js";
+
 import {
     applyResponseCookies,
     runWithRequestContext,
@@ -69,6 +80,7 @@ export interface StandalonePageRoute {
     error: ComponentType<any> | null;
     notFound: ComponentType<any> | null;
     metadataSources: MetadataSource[];
+    loader: PageLoader | null;
     client: ProductionRouteAsset;
 }
 
@@ -345,6 +357,7 @@ export function createStandaloneProductionServer(
                     await sendPage(
                         req,
                         res,
+                        requestUrl,
                         definition,
                         match.params,
                         options
@@ -453,29 +466,99 @@ export function createStandaloneProductionServer(
 async function sendPage(
     req: http.IncomingMessage,
     res: http.ServerResponse,
+    requestUrl: URL,
     definition: StandalonePageRoute,
     params: Record<string, string>,
     options: StandaloneProductionServerOptions
 ): Promise<void> {
     try {
-        const metadata =
-            await resolveRouteMetadata(
-                definition.metadataSources,
-                params
+        const request =
+            await createWebRequest(
+                req,
+                requestUrl
             );
 
-        const html =
-            renderPageDocument(
-                definition,
-                params,
-                metadata
+        const response =
+            await runWithRequestContext(
+                request,
+                async () => {
+                    const loaderExecution:
+                        PageLoaderExecution =
+                        definition.loader
+                            ? await executePageLoaderFunction(
+                                definition.loader,
+                                params,
+                                requestUrl,
+                                definition.pathname
+                            )
+                            : {
+                                hasLoader:
+                                    false,
+                                data:
+                                    undefined,
+                                response:
+                                    null,
+                            };
+
+                    if (
+                        loaderExecution.response
+                    ) {
+                        return applyResponseCookies(
+                            loaderExecution.response
+                        );
+                    }
+
+                    const metadata =
+                        await resolveRouteMetadata(
+                            definition.metadataSources,
+                            params
+                        );
+
+                    const frameworkParams =
+                        attachLoaderDataToParams(
+                            params,
+                            loaderExecution
+                        );
+
+                    const html =
+                        renderPageDocument(
+                            definition,
+                            frameworkParams,
+                            metadata,
+                            loaderExecution
+                        );
+
+                    return applyResponseCookies(
+                        new Response(
+                            html,
+                            {
+                                status:
+                                    200,
+                                headers: {
+                                    "Content-Type":
+                                        "text/html; charset=utf-8",
+                                    "Cache-Control":
+                                        "no-store",
+                                },
+                            }
+                        )
+                    );
+                },
+                {
+                    remoteAddress:
+                        req.socket
+                            .remoteAddress ??
+                        null,
+                }
             );
 
-        sendHtml(
+        await sendWebResponse(
             req,
             res,
-            200,
-            html
+            response,
+            normalizeHttpMethod(
+                req.method
+            ) === "HEAD"
         );
     } catch (error) {
         if (isNotFoundError(error)) {
@@ -561,10 +644,11 @@ function sendGlobalNotFound(
 
 function renderPageDocument(
     definition: StandalonePageRoute,
-    params: Record<string, string>,
-    metadata: ResolvedMetadata
+    params: Record<string, any>,
+    metadata: ResolvedMetadata,
+    loaderExecution: PageLoaderExecution
 ): string {
-    const element =
+    let element =
         wrapWithLayouts(
             createElement(
                 definition.page,
@@ -576,6 +660,20 @@ function renderPageDocument(
             params
         );
 
+    if (
+        loaderExecution.hasLoader
+    ) {
+        element =
+            createElement(
+                BcpLoaderDataProvider,
+                {
+                    data:
+                        loaderExecution.data,
+                },
+                element
+            );
+    }
+
     const content =
         renderToString(
             element
@@ -595,7 +693,7 @@ function renderPageDocument(
 function renderFallbackDocument(
     Component: ComponentType<any> | null,
     layouts: ComponentType<any>[],
-    params: Record<string, string>,
+    params: Record<string, any>,
     fallback:
         | {
             kind: "not-found";
@@ -700,7 +798,7 @@ function renderFallbackDocument(
 function wrapWithLayouts(
     child: ReactElement,
     layouts: ComponentType<any>[],
-    params: Record<string, string>
+    params: Record<string, any>
 ): ReactElement {
     let element =
         child;
@@ -728,7 +826,7 @@ function renderDocument(
     input: {
         content: string;
         route: string | null;
-        params: Record<string, string> | null;
+        params: Record<string, any> | null;
         client: ProductionRouteAsset | null;
         metadata: ResolvedMetadata;
     }
@@ -1029,6 +1127,19 @@ async function handleNavigation(
         return;
     }
 
+    if (definition.loader) {
+        sendJson(
+            req,
+            res,
+            409,
+            {
+                error:
+                    "Loader routes require document navigation.",
+            }
+        );
+        return;
+    }
+
     let metadata:
         ResolvedMetadata;
 
@@ -1699,7 +1810,8 @@ async function sendWebResponse(
 
     if (
         cookies &&
-        cookies.length > 0
+        cookies.length >
+        0
     ) {
         res.setHeader(
             "Set-Cookie",

package/packages/server/src/standalone-production-runtime-v3.ts

@@ -18,7 +18,7 @@ import {
     type StandaloneApiRoute,
     type StandalonePageRoute,
     type StandaloneProductionServerOptions as BaseStandaloneProductionServerOptions,
-} from "./standalone-production-runtime-v2.js";
+} from "./standalone-production-runtime-v2-navigation.js";
 
 import type {
     MiddlewareModule,

package/packages/server/src/standalone-production-runtime-v4.ts

@@ -46,8 +46,11 @@ export function createStandaloneProductionServer(
         }
 
         const manifest =
-            readCacheManifest(
-                options.buildDirectory
+            excludeLoaderPagesFromCache(
+                readCacheManifest(
+                    options.buildDirectory
+                ),
+                options.routes
             );
 
         const responseCacheEnabled =
@@ -156,6 +159,43 @@ export function createStandaloneProductionServer(
     };
 }
 
+function excludeLoaderPagesFromCache(
+    manifest: ResponseCacheManifest,
+    routes: StandalonePageRoute[]
+): ResponseCacheManifest {
+    const loaderRoutes =
+        new Set(
+            routes
+                .filter(
+                    (route) =>
+                        route.loader !==
+                        null
+                )
+                .map(
+                    (route) =>
+                        route.pathname
+                )
+        );
+
+    if (
+        loaderRoutes.size ===
+        0
+    ) {
+        return manifest;
+    }
+
+    return {
+        ...manifest,
+        pages:
+            manifest.pages.filter(
+                (route) =>
+                    !loaderRoutes.has(
+                        route.pathname
+                    )
+            ),
+    };
+}
+
 function readCacheManifest(
     buildDirectory: string
 ): ResponseCacheManifest {

package/packages/server/src/static-dev-server.ts

@@ -11,12 +11,19 @@ import {
     applyDevDocumentMetadata,
 } from "./dev-document-metadata.js";
 
+import {
+    createDevNavigationTargetResponse,
+} from "./dev-navigation-target.js";
+
 import {
     resolveNavigationPayload,
     sendNavigationError,
-    sendNavigationPayload,
 } from "./navigation-payload.js";
 
+import {
+    sendNavigationWebResponse,
+} from "./navigation-response.js";
+
 import {
     readPublicAsset,
     type StaticAsset,
@@ -405,7 +412,11 @@ async function sendHtmlWithMetadata(
         const payload =
             await resolveNavigationPayload(
                 rootDirectory,
-                pathname
+                pathname,
+                {
+                    allowLoaderRoute:
+                        true,
+                }
             );
 
         const html =
@@ -595,34 +606,27 @@ async function handleNavigationRequest(
         return;
     }
 
-    const payload =
-        await resolveNavigationPayload(
+    const response =
+        await createDevNavigationTargetResponse(
+            req,
             rootDirectory,
-            target.pathname
+            target
         );
 
-    if (!payload) {
+    if (!response) {
         sendNavigationError(
             res,
             404,
             "Route not found."
         );
-
-        logRequest(
+    } else {
+        await sendNavigationWebResponse(
             req,
-            requestUrl.pathname,
             res,
-            startedAt
+            response
         );
-
-        return;
     }
 
-    sendNavigationPayload(
-        res,
-        payload
-    );
-
     logRequest(
         req,
         requestUrl.pathname,