@chidchanun/bcp 0.1.5 → 0.1.7

package/packages/server/src/server-response.ts

@@ -0,0 +1,82 @@
+import {
+    requestUrl,
+} from "./request-context.js";
+
+export type RedirectStatus =
+    | 301
+    | 302
+    | 303
+    | 307
+    | 308;
+
+export function json<T>(
+    data: T,
+    init?: ResponseInit
+): Response {
+    return Response.json(
+        data,
+        init
+    );
+}
+
+export async function redirect(
+    destination:
+        string |
+        URL,
+    status:
+        RedirectStatus =
+        307
+): Promise<Response> {
+    assertRedirectStatus(
+        status
+    );
+
+    const base =
+        await requestUrl();
+
+    const target =
+        destination instanceof URL
+            ? new URL(
+                destination.href
+            )
+            : new URL(
+                destination,
+                base
+            );
+
+    if (
+        target.protocol !== "http:" &&
+        target.protocol !== "https:"
+    ) {
+        throw new Error(
+            `BCP Framework: redirect only supports http and https URLs, received "${target.protocol}".`
+        );
+    }
+
+    return new Response(
+        null,
+        {
+            status,
+            headers: {
+                Location:
+                    target.href,
+            },
+        }
+    );
+}
+
+function assertRedirectStatus(
+    status: number
+): asserts status is RedirectStatus {
+    if (
+        status !== 301 &&
+        status !== 302 &&
+        status !== 303 &&
+        status !== 307 &&
+        status !== 308
+    ) {
+        throw new Error(
+            `BCP Framework: invalid redirect status ${status}. Use 301, 302, 303, 307 or 308.`
+        );
+    }
+}

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

@@ -49,6 +49,11 @@ import {
     type MetadataSource,
 } from "./metadata.js";
 
+import {
+    applyResponseCookies,
+    runWithRequestContext,
+} from "./request-context.ts";
+
 import {
     getContentType,
     readPublicAsset,
@@ -1405,7 +1410,8 @@ async function handleApiRoute(
 
     if (
         !handler &&
-        method === "HEAD"
+        method ===
+        "HEAD"
     ) {
         handler =
             getApiHandler(
@@ -1434,23 +1440,48 @@ async function handleApiRoute(
         return;
     }
 
+    const request =
+        await createWebRequest(
+            req,
+            requestUrl
+        );
+
     const response =
-        await handler(
-            await createWebRequest(
-                req,
-                requestUrl
-            ),
+        await runWithRequestContext(
+            request,
+
+            async () => {
+                const result =
+                    await handler(
+                        request,
+                        {
+                            params,
+                        }
+                    );
+
+                if (
+                    !(
+                        result instanceof
+                        Response
+                    )
+                ) {
+                    throw new Error(
+                        `API handler "${method} ${definition.pathname}" must return a Response object.`
+                    );
+                }
+
+                return applyResponseCookies(
+                    result
+                );
+            },
             {
-                params,
+                remoteAddress:
+                    req.socket
+                        .remoteAddress ??
+                    null,
             }
         );
 
-    if (!(response instanceof Response)) {
-        throw new Error(
-            `API handler "${method} ${definition.pathname}" must return a Response object.`
-        );
-    }
-
     await sendWebResponse(
         req,
         res,

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

@@ -0,0 +1,205 @@
+import * as net from "node:net";
+import path from "node:path";
+
+import {
+    createCriticalCssProxy,
+} from "./critical-css-proxy.js";
+
+import {
+    createStandaloneProductionServer as createBaseStandaloneProductionServer,
+    type StandaloneApiRoute,
+    type StandalonePageRoute,
+    type StandaloneProductionServerOptions as BaseStandaloneProductionServerOptions,
+} from "./standalone-production-runtime-v5.js";
+
+export type {
+    StandaloneApiRoute,
+    StandalonePageRoute,
+};
+
+export interface StandaloneProductionServerOptions
+    extends BaseStandaloneProductionServerOptions {}
+
+export function createStandaloneProductionServer(
+    options: StandaloneProductionServerOptions
+) {
+    let baseServer:
+        ReturnType<
+            typeof createBaseStandaloneProductionServer
+        > | null =
+        null;
+
+    let criticalCssProxy:
+        ReturnType<
+            typeof createCriticalCssProxy
+        > | null =
+        null;
+
+    let started =
+        false;
+
+    async function start(): Promise<void> {
+        if (started) {
+            return;
+        }
+
+        const internalPort =
+            await findFreePort();
+
+        baseServer =
+            createBaseStandaloneProductionServer({
+                ...options,
+                port:
+                    internalPort,
+                hostname:
+                    "127.0.0.1",
+            });
+
+        await baseServer.start();
+
+        criticalCssProxy =
+            createCriticalCssProxy({
+                port:
+                    options.port,
+                hostname:
+                    options.hostname,
+                upstreamPort:
+                    internalPort,
+                upstreamHostname:
+                    "127.0.0.1",
+                cssFile:
+                    path.join(
+                        options.buildDirectory,
+                        "public",
+                        "bcp.css"
+                    ),
+            });
+
+        try {
+            await criticalCssProxy.start();
+        } catch (error) {
+            await baseServer.stop();
+            baseServer =
+                null;
+            criticalCssProxy =
+                null;
+            throw error;
+        }
+
+        started =
+            true;
+
+        console.log(
+            `[BCP CSS] Inline /bcp.css when <= 8 KiB.`
+        );
+        console.log("");
+    }
+
+    async function stop(): Promise<void> {
+        if (criticalCssProxy) {
+            await criticalCssProxy.stop();
+            criticalCssProxy =
+                null;
+        }
+
+        if (baseServer) {
+            await baseServer.stop();
+            baseServer =
+                null;
+        }
+
+        started =
+            false;
+    }
+
+    return {
+        start,
+        stop,
+    };
+}
+
+async function findFreePort(): Promise<number> {
+    const server =
+        net.createServer();
+
+    try {
+        await new Promise<void>(
+            (
+                resolve,
+                reject
+            ) => {
+                const onError =
+                    (error: Error) => {
+                        server.off(
+                            "listening",
+                            onListening
+                        );
+                        reject(
+                            error
+                        );
+                    };
+
+                const onListening =
+                    () => {
+                        server.off(
+                            "error",
+                            onError
+                        );
+                        resolve();
+                    };
+
+                server.once(
+                    "error",
+                    onError
+                );
+                server.once(
+                    "listening",
+                    onListening
+                );
+                server.listen(
+                    0,
+                    "127.0.0.1"
+                );
+            }
+        );
+
+        const address =
+            server.address();
+
+        if (
+            !address ||
+            typeof address ===
+                "string"
+        ) {
+            throw new Error(
+                "BCP Framework: could not allocate critical CSS production port."
+            );
+        }
+
+        return address.port;
+    } finally {
+        if (
+            server.listening
+        ) {
+            await new Promise<void>(
+                (
+                    resolve,
+                    reject
+                ) => {
+                    server.close(
+                        (error) => {
+                            if (error) {
+                                reject(
+                                    error
+                                );
+                                return;
+                            }
+
+                            resolve();
+                        }
+                    );
+                }
+            );
+        }
+    }
+}

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

@@ -3,4 +3,4 @@ export {
     type StandaloneApiRoute,
     type StandalonePageRoute,
     type StandaloneProductionServerOptions,
-} from "./standalone-production-runtime-v5.js";
+} from "./standalone-production-runtime-v6.js";