@chidchanun/bcp 0.1.22 → 0.1.24

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

@@ -1,5 +1,9 @@
 import type * as http from "node:http";
 
+import {
+    createLogger,
+} from "./logger.js";
+
 export const DEV_EVENTS_PATH =
     "/_bcp/dev-events";
 
@@ -12,11 +16,28 @@ const INTERNAL_API_PATHS =
     ]);
 
 const HTTP_REQUEST_LOG_PATTERN =
-    /^(?:\[bcp\]\s+)?(?:GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)\s+(\S+)\s+\d{3}\s+\d+(?:\.\d+)?ms$/i;
+    /^(?:\[bcp\]\s+)?(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)\s+(\S+)\s+(\d{3})\s+(\d+(?:\.\d+)?)ms$/i;
+
+const TIMING_LOG_PATTERN =
+    /^(Import|SSR):\s+(\d+(?:\.\d+)?)ms$/i;
 
 let requestLogFilterInstalled =
     false;
 
+export interface DevHttpRequestLog {
+    method: string;
+    path: string;
+    status: number;
+    durationMs: number;
+}
+
+export type DevTimingLog = {
+    event:
+        | "module.import"
+        | "ssr.render";
+    durationMs: number;
+};
+
 export function shouldLogDevApiPath(
     pathname: string
 ): boolean {
@@ -39,20 +60,73 @@ export function shouldLogDevApiPath(
     );
 }
 
-export function shouldWriteDevConsoleLine(
+export function parseDevHttpRequestLog(
     line: string
-): boolean {
+): DevHttpRequestLog | null {
     const match =
         HTTP_REQUEST_LOG_PATTERN.exec(
             line.trim()
         );
 
     if (!match) {
+        return null;
+    }
+
+    return {
+        method:
+            match[1].toUpperCase(),
+        path:
+            match[2],
+        status:
+            Number(
+                match[3]
+            ),
+        durationMs:
+            Number(
+                match[4]
+            ),
+    };
+}
+
+export function parseDevTimingLog(
+    line: string
+): DevTimingLog | null {
+    const match =
+        TIMING_LOG_PATTERN.exec(
+            line.trim()
+        );
+
+    if (!match) {
+        return null;
+    }
+
+    return {
+        event:
+            match[1].toLowerCase() ===
+            "ssr"
+                ? "ssr.render"
+                : "module.import",
+        durationMs:
+            Number(
+                match[2]
+            ),
+    };
+}
+
+export function shouldWriteDevConsoleLine(
+    line: string
+): boolean {
+    const request =
+        parseDevHttpRequestLog(
+            line
+        );
+
+    if (!request) {
         return true;
     }
 
     return shouldLogDevApiPath(
-        match[1]
+        request.path
     );
 }
 
@@ -68,18 +142,66 @@ function installRequestLogFilter(): void {
         console.log.bind(
             console
         );
+    const devLogger =
+        createLogger({
+            name:
+                "bcp-dev",
+            write(
+                line
+            ) {
+                originalLog(
+                    line
+                );
+            },
+        });
 
     console.log = (
         ...args: unknown[]
     ) => {
         if (
             args.length === 1 &&
-            typeof args[0] === "string" &&
-            !shouldWriteDevConsoleLine(
-                args[0]
-            )
+            typeof args[0] === "string"
         ) {
-            return;
+            const request =
+                parseDevHttpRequestLog(
+                    args[0]
+                );
+
+            if (request) {
+                if (
+                    shouldLogDevApiPath(
+                        request.path
+                    )
+                ) {
+                    devLogger.info(
+                        "HTTP request",
+                        {
+                            event:
+                                "http.request",
+                            ...request,
+                        }
+                    );
+                }
+
+                return;
+            }
+
+            const timing =
+                parseDevTimingLog(
+                    args[0]
+                );
+
+            if (timing) {
+                devLogger.debug(
+                    timing.event ===
+                        "ssr.render"
+                        ? "SSR render"
+                        : "Module import",
+                    timing
+                );
+
+                return;
+            }
         }
 
         originalLog(

package/packages/server/src/dev-route-graph.ts

@@ -0,0 +1,91 @@
+export interface DevRouteGraphEntry {
+    pathname: string;
+    filePath: string;
+    layouts: string[];
+}
+
+export function hasDevClientRouteGraphChanged(
+    currentRoutes: DevRouteGraphEntry[],
+    nextRoutes: DevRouteGraphEntry[]
+): boolean {
+    if (
+        currentRoutes.length !==
+        nextRoutes.length
+    ) {
+        return true;
+    }
+
+    const current =
+        normalizeRouteGraph(
+            currentRoutes
+        );
+    const next =
+        normalizeRouteGraph(
+            nextRoutes
+        );
+
+    for (
+        let index = 0;
+        index < current.length;
+        index++
+    ) {
+        const left =
+            current[index];
+        const right =
+            next[index];
+
+        if (
+            left.pathname !==
+                right.pathname ||
+            left.filePath !==
+                right.filePath ||
+            left.layouts.length !==
+                right.layouts.length
+        ) {
+            return true;
+        }
+
+        for (
+            let layoutIndex = 0;
+            layoutIndex <
+                left.layouts.length;
+            layoutIndex++
+        ) {
+            if (
+                left.layouts[
+                    layoutIndex
+                ] !==
+                right.layouts[
+                    layoutIndex
+                ]
+            ) {
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+function normalizeRouteGraph(
+    routes: DevRouteGraphEntry[]
+): DevRouteGraphEntry[] {
+    return routes
+        .map(
+            (route) => ({
+                pathname:
+                    route.pathname,
+                filePath:
+                    route.filePath,
+                layouts: [
+                    ...route.layouts,
+                ],
+            })
+        )
+        .sort(
+            (left, right) =>
+                left.pathname.localeCompare(
+                    right.pathname
+                )
+        );
+}