@chidchanun/bcp 0.1.4 → 0.1.6

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

@@ -6,12 +6,98 @@ export const DEV_EVENTS_PATH =
 const ENV_RESTART_COOKIE =
     "__bcp_env_restart";
 
+const INTERNAL_API_PATHS =
+    new Set([
+        "/api/bcp-styles",
+    ]);
+
+const HTTP_REQUEST_LOG_PATTERN =
+    /^(?:\[bcp\]\s+)?(?:GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)\s+(\S+)\s+\d{3}\s+\d+(?:\.\d+)?ms$/i;
+
+let requestLogFilterInstalled =
+    false;
+
+export function shouldLogDevApiPath(
+    pathname: string
+): boolean {
+    const normalized =
+        pathname.split(
+            "?",
+            1
+        )[0];
+
+    return (
+        (
+            normalized === "/api" ||
+            normalized.startsWith(
+                "/api/"
+            )
+        ) &&
+        !INTERNAL_API_PATHS.has(
+            normalized
+        )
+    );
+}
+
+export function shouldWriteDevConsoleLine(
+    line: string
+): boolean {
+    const match =
+        HTTP_REQUEST_LOG_PATTERN.exec(
+            line.trim()
+        );
+
+    if (!match) {
+        return true;
+    }
+
+    return shouldLogDevApiPath(
+        match[1]
+    );
+}
+
+function installRequestLogFilter(): void {
+    if (requestLogFilterInstalled) {
+        return;
+    }
+
+    requestLogFilterInstalled =
+        true;
+
+    const originalLog =
+        console.log.bind(
+            console
+        );
+
+    console.log = (
+        ...args: unknown[]
+    ) => {
+        if (
+            args.length === 1 &&
+            typeof args[0] === "string" &&
+            !shouldWriteDevConsoleLine(
+                args[0]
+            )
+        ) {
+            return;
+        }
+
+        originalLog(
+            ...args
+        );
+    };
+}
+
 export class DevHmrServer {
     private readonly clients =
         new Set<
             http.ServerResponse
         >();
 
+    constructor() {
+        installRequestLogFilter();
+    }
+
     connect(
         req: http.IncomingMessage,
         res: http.ServerResponse

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

@@ -5,6 +5,10 @@ import type {
     DevServerOptions,
 } from "./index.js";
 
+import {
+    createCriticalCssProxy,
+} from "./critical-css-proxy.js";
+
 import {
     loadProjectMiddleware,
 } from "./middleware-loader.js";
@@ -56,6 +60,12 @@ export function createMiddlewareDevServer(
         > | null =
         null;
 
+    let criticalCssGateway:
+        ReturnType<
+            typeof createCriticalCssProxy
+        > | null =
+        null;
+
     let started =
         false;
 
@@ -68,6 +78,8 @@ export function createMiddlewareDevServer(
             await findFreePort();
         const middlewarePort =
             await findFreePort();
+        const securityPort =
+            await findFreePort();
 
         internalServer =
             createStaticDevServer({
@@ -111,8 +123,10 @@ export function createMiddlewareDevServer(
 
         securityGateway =
             createSecurityProxy({
-                port,
-                hostname,
+                port:
+                    securityPort,
+                hostname:
+                    "127.0.0.1",
                 upstreamPort:
                     middlewarePort,
                 upstreamHostname:
@@ -133,12 +147,48 @@ export function createMiddlewareDevServer(
             throw error;
         }
 
+        criticalCssGateway =
+            createCriticalCssProxy({
+                port,
+                hostname,
+                upstreamPort:
+                    securityPort,
+                upstreamHostname:
+                    "127.0.0.1",
+                cssFile:
+                    path.join(
+                        rootDirectory,
+                        "public",
+                        "bcp.css"
+                    ),
+            });
+
+        try {
+            await criticalCssGateway.start();
+        } catch (error) {
+            await securityGateway.stop();
+            await middlewareGateway.stop();
+            await internalServer.stop();
+            internalServer =
+                null;
+            middlewareGateway =
+                null;
+            securityGateway =
+                null;
+            criticalCssGateway =
+                null;
+            throw error;
+        }
+
         started =
             true;
 
         console.log(
             `[BCP Security] Dev gateway: http://${hostname}:${port}`
         );
+        console.log(
+            `[BCP CSS] Inline /bcp.css when <= 8 KiB and allowed by CSP.`
+        );
         console.log(
             `[BCP Middleware] File: ${path.join(rootDirectory, "middleware.ts")} (optional; .tsx/.js/.jsx also supported)`
         );
@@ -146,6 +196,12 @@ export function createMiddlewareDevServer(
     }
 
     async function stop(): Promise<void> {
+        if (criticalCssGateway) {
+            await criticalCssGateway.stop();
+            criticalCssGateway =
+                null;
+        }
+
         if (securityGateway) {
             await securityGateway.stop();
             securityGateway =
@@ -257,4 +313,4 @@ async function findFreePort(): Promise<number> {
             );
         }
     }
-}
+}

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";