@chidchanun/bcp 0.1.22 → 0.1.24

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

@@ -1,6 +1,12 @@
 import * as net from "node:net";
 import path from "node:path";
 
+import chokidar from "chokidar";
+
+import {
+    scanRoutes,
+} from "../../router/src/index.js";
+
 import type {
     DevServerOptions,
 } from "./index.js";
@@ -9,6 +15,10 @@ import {
     createCriticalCssProxy,
 } from "./critical-css-proxy.js";
 
+import {
+    hasDevClientRouteGraphChanged,
+} from "./dev-route-graph.js";
+
 import {
     createFormActionDevProxy,
 } from "./form-action-dev-proxy.js";
@@ -29,6 +39,9 @@ import {
     createStaticDevServer,
 } from "./static-dev-server.js";
 
+const ROUTE_GRAPH_DEBOUNCE_MS =
+    120;
+
 export function createMiddlewareDevServer(
     options: DevServerOptions = {}
 ) {
@@ -46,6 +59,15 @@ export function createMiddlewareDevServer(
             process.cwd()
         );
 
+    const appDirectory =
+        path.join(
+            rootDirectory,
+            "app"
+        );
+
+    let applicationPort =
+        0;
+
     let internalServer:
         ReturnType<
             typeof createStaticDevServer
@@ -76,6 +98,27 @@ export function createMiddlewareDevServer(
         > | null =
         null;
 
+    let routeWatcher:
+        ReturnType<
+            typeof chokidar.watch
+        > | null =
+        null;
+
+    let routeGraph =
+        scanRoutes(
+            appDirectory
+        );
+
+    let routeGraphTimer:
+        NodeJS.Timeout | null =
+        null;
+
+    let routeRestartRunning =
+        false;
+
+    let routeRestartQueued =
+        false;
+
     let started =
         false;
 
@@ -84,7 +127,7 @@ export function createMiddlewareDevServer(
             return;
         }
 
-        const applicationPort =
+        applicationPort =
             await findFreePort();
         const actionPort =
             await findFreePort();
@@ -93,15 +136,13 @@ export function createMiddlewareDevServer(
         const securityPort =
             await findFreePort();
 
+        routeGraph =
+            scanRoutes(
+                appDirectory
+            );
+
         internalServer =
-            createStaticDevServer({
-                ...options,
-                rootDirectory,
-                port:
-                    applicationPort,
-                hostname:
-                    "127.0.0.1",
-            });
+            createInternalServer();
 
         await internalServer.start();
 
@@ -225,6 +266,8 @@ export function createMiddlewareDevServer(
             throw error;
         }
 
+        startRouteGraphWatcher();
+
         started =
             true;
 
@@ -244,6 +287,20 @@ export function createMiddlewareDevServer(
     }
 
     async function stop(): Promise<void> {
+        if (routeGraphTimer) {
+            clearTimeout(
+                routeGraphTimer
+            );
+            routeGraphTimer =
+                null;
+        }
+
+        if (routeWatcher) {
+            await routeWatcher.close();
+            routeWatcher =
+                null;
+        }
+
         if (criticalCssGateway) {
             await criticalCssGateway.stop();
             criticalCssGateway =
@@ -278,6 +335,157 @@ export function createMiddlewareDevServer(
             false;
     }
 
+    function createInternalServer() {
+        return createStaticDevServer({
+            ...options,
+            rootDirectory,
+            port:
+                applicationPort,
+            hostname:
+                "127.0.0.1",
+        });
+    }
+
+    function startRouteGraphWatcher(): void {
+        routeWatcher =
+            chokidar.watch(
+                appDirectory,
+                {
+                    persistent: true,
+                    ignoreInitial: true,
+                    atomic: true,
+                    ignored: (
+                        watchedPath,
+                        stats
+                    ) => {
+                        if (
+                            stats?.isDirectory()
+                        ) {
+                            return false;
+                        }
+
+                        if (!stats) {
+                            return false;
+                        }
+
+                        return !/\.[jt]sx?$/.test(
+                            watchedPath
+                        );
+                    },
+                }
+            );
+
+        routeWatcher.on(
+            "all",
+            (
+                eventName
+            ) => {
+                if (
+                    eventName === "add" ||
+                    eventName === "change" ||
+                    eventName === "unlink"
+                ) {
+                    scheduleRouteGraphCheck();
+                }
+            }
+        );
+
+        routeWatcher.on(
+            "error",
+            (error) => {
+                console.error(
+                    "[BCP Dev] Route graph watcher error:",
+                    error
+                );
+            }
+        );
+    }
+
+    function scheduleRouteGraphCheck(): void {
+        if (routeGraphTimer) {
+            clearTimeout(
+                routeGraphTimer
+            );
+        }
+
+        routeGraphTimer =
+            setTimeout(
+                () => {
+                    routeGraphTimer =
+                        null;
+                    void refreshRouteGraph();
+                },
+                ROUTE_GRAPH_DEBOUNCE_MS
+            );
+    }
+
+    async function refreshRouteGraph(): Promise<void> {
+        if (routeRestartRunning) {
+            routeRestartQueued =
+                true;
+            return;
+        }
+
+        const nextRouteGraph =
+            scanRoutes(
+                appDirectory
+            );
+
+        if (
+            !hasDevClientRouteGraphChanged(
+                routeGraph,
+                nextRouteGraph
+            )
+        ) {
+            return;
+        }
+
+        routeRestartRunning =
+            true;
+
+        try {
+            console.log(
+                "[BCP Dev] Page route graph changed; refreshing client bundler state..."
+            );
+
+            if (internalServer) {
+                await internalServer.stop();
+                internalServer =
+                    null;
+            }
+
+            const nextServer =
+                createInternalServer();
+
+            await nextServer.start();
+
+            internalServer =
+                nextServer;
+            routeGraph =
+                nextRouteGraph;
+
+            console.log(
+                `[BCP Dev] Client bundle graph synchronized (${nextRouteGraph.length} route(s)).`
+            );
+        } catch (error) {
+            internalServer =
+                null;
+            console.error(
+                "[BCP Dev] Client bundle graph refresh failed:",
+                error
+            );
+        } finally {
+            routeRestartRunning =
+                false;
+
+            if (routeRestartQueued) {
+                routeRestartQueued =
+                    false;
+                scheduleRouteGraphCheck();
+            }
+        }
+    }
+
     return {
         start,
         stop,