@chidchanun/bcp 0.1.4 → 0.1.6

package/packages/bundler/src/client-boundary.ts

@@ -0,0 +1,484 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import type {
+    Route,
+} from "../../router/src/index.js";
+
+import {
+    hasUseClientDirective,
+    resolveApplicationModuleAlias,
+    usesReactClientHooks,
+} from "./application-modules.js";
+
+const MODULE_EXTENSIONS = [
+    ".ts",
+    ".tsx",
+    ".mts",
+    ".cts",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+] as const;
+
+export function validateClientBoundaries(
+    routes: Route[],
+    rootDirectory: string
+): void {
+    const root =
+        path.resolve(
+            rootDirectory
+        );
+
+    const visited =
+        new Set<string>();
+
+    for (
+        const route
+        of routes
+    ) {
+        visitClientModule(
+            route.filePath,
+            route.pathname,
+            root,
+            visited
+        );
+
+        for (
+            const layoutFile
+            of route.layouts
+        ) {
+            visitClientModule(
+                layoutFile,
+                route.pathname,
+                root,
+                visited
+            );
+        }
+    }
+
+    for (
+        const islandFile
+        of findIslandFiles(
+            path.join(
+                root,
+                "app"
+            )
+        )
+    ) {
+        visitClientModule(
+            islandFile,
+            "client island",
+            root,
+            visited,
+            true
+        );
+    }
+}
+
+function visitClientModule(
+    filePath: string,
+    routeName: string,
+    rootDirectory: string,
+    visited: Set<string>,
+    islandRoot = false
+): void {
+    const normalized =
+        normalizePath(
+            filePath
+        );
+
+    if (
+        visited.has(
+            normalized
+        )
+    ) {
+        return;
+    }
+
+    visited.add(
+        normalized
+    );
+
+    const source =
+        fs.readFileSync(
+            filePath,
+            "utf8"
+        );
+
+    if (
+        !islandRoot &&
+        usesReactClientHooks(
+            source
+        ) &&
+        !hasUseClientDirective(
+            source
+        )
+    ) {
+        throw new Error(
+            `BCP Framework: ${formatApplicationPath(rootDirectory, filePath)} uses React client hooks on ${routeName} but is missing the "use client" directive. Add "use client" as the first directive in the module.`
+        );
+    }
+
+    for (
+        const specifier
+        of collectRuntimeImports(
+            source
+        )
+    ) {
+        if (
+            specifier ===
+            "bcp/server-only"
+        ) {
+            throw new Error(
+                `BCP Framework: ${formatApplicationPath(rootDirectory, filePath)} imports bcp/server-only but is reachable from the client bundle for ${routeName}. Move the server dependency behind an API route.`
+            );
+        }
+
+        const dependency =
+            resolveLocalDependency(
+                rootDirectory,
+                filePath,
+                specifier
+            );
+
+        if (!dependency) {
+            continue;
+        }
+
+        visitClientModule(
+            dependency,
+            routeName,
+            rootDirectory,
+            visited,
+            /\.island\.(?:ts|tsx)$/.test(
+                dependency
+            )
+        );
+    }
+}
+
+function collectRuntimeImports(
+    source: string
+): string[] {
+    const imports =
+        new Set<string>();
+
+    const staticImport =
+        /\bimport\s+(?!type\b)(?:[^;"']*?\s+from\s+)?["']([^"']+)["']/g;
+    const reExport =
+        /\bexport\s+(?!type\b)[^;"']*?\s+from\s+["']([^"']+)["']/g;
+    const dynamicImport =
+        /\bimport\s*\(\s*["']([^"']+)["']\s*\)/g;
+
+    for (
+        const pattern
+        of [
+            staticImport,
+            reExport,
+            dynamicImport,
+        ]
+    ) {
+        let match:
+            RegExpExecArray | null;
+
+        while (
+            (
+                match =
+                    pattern.exec(
+                        source
+                    )
+            )
+        ) {
+            imports.add(
+                match[1]
+            );
+        }
+    }
+
+    return Array.from(
+        imports
+    );
+}
+
+function resolveLocalDependency(
+    rootDirectory: string,
+    importer: string,
+    specifier: string
+): string | null {
+    if (
+        specifier.startsWith(
+            "@/"
+        )
+    ) {
+        return resolveApplicationModuleAlias(
+            rootDirectory,
+            specifier
+        );
+    }
+
+    if (
+        !specifier.startsWith(
+            "./"
+        ) &&
+        !specifier.startsWith(
+            "../"
+        )
+    ) {
+        return null;
+    }
+
+    const unresolved =
+        path.resolve(
+            path.dirname(
+                importer
+            ),
+            specifier
+        );
+
+    const resolved =
+        resolveExistingModulePath(
+            unresolved
+        );
+
+    if (!resolved) {
+        return null;
+    }
+
+    const root =
+        path.resolve(
+            rootDirectory
+        );
+
+    if (
+        !isPathInside(
+            root,
+            resolved
+        )
+    ) {
+        return null;
+    }
+
+    return resolved;
+}
+
+function resolveExistingModulePath(
+    unresolvedPath: string
+): string | null {
+    if (
+        isFile(
+            unresolvedPath
+        )
+    ) {
+        return unresolvedPath;
+    }
+
+    if (
+        path.extname(
+            unresolvedPath
+        ) === ""
+    ) {
+        for (
+            const extension
+            of MODULE_EXTENSIONS
+        ) {
+            const candidate =
+                `${unresolvedPath}${extension}`;
+
+            if (
+                isFile(
+                    candidate
+                )
+            ) {
+                return candidate;
+            }
+        }
+    }
+
+    if (
+        isDirectory(
+            unresolvedPath
+        )
+    ) {
+        for (
+            const extension
+            of MODULE_EXTENSIONS
+        ) {
+            const candidate =
+                path.join(
+                    unresolvedPath,
+                    `index${extension}`
+                );
+
+            if (
+                isFile(
+                    candidate
+                )
+            ) {
+                return candidate;
+            }
+        }
+    }
+
+    return null;
+}
+
+function findIslandFiles(
+    appDirectory: string
+): string[] {
+    if (
+        !fs.existsSync(
+            appDirectory
+        )
+    ) {
+        return [];
+    }
+
+    const result:
+        string[] = [];
+
+    walkDirectory(
+        appDirectory,
+        (filePath) => {
+            if (
+                /\.island\.(?:ts|tsx)$/.test(
+                    filePath
+                )
+            ) {
+                result.push(
+                    filePath
+                );
+            }
+        }
+    );
+
+    return result.sort();
+}
+
+function walkDirectory(
+    directory: string,
+    callback: (
+        filePath: string
+    ) => void
+): void {
+    for (
+        const entry
+        of fs.readdirSync(
+            directory,
+            {
+                withFileTypes: true,
+            }
+        )
+    ) {
+        const fullPath =
+            path.join(
+                directory,
+                entry.name
+            );
+
+        if (
+            entry.isDirectory()
+        ) {
+            walkDirectory(
+                fullPath,
+                callback
+            );
+            continue;
+        }
+
+        if (
+            entry.isFile()
+        ) {
+            callback(
+                fullPath
+            );
+        }
+    }
+}
+
+function formatApplicationPath(
+    rootDirectory: string,
+    filePath: string
+): string {
+    const relative =
+        path.relative(
+            rootDirectory,
+            filePath
+        )
+            .replace(
+                /\\/g,
+                "/"
+            );
+
+    return `"${relative || filePath}"`;
+}
+
+function isPathInside(
+    parent: string,
+    child: string
+): boolean {
+    const relative =
+        path.relative(
+            parent,
+            child
+        );
+
+    return (
+        relative === "" ||
+        (
+            relative !== ".." &&
+            !relative.startsWith(
+                `..${path.sep}`
+            ) &&
+            !path.isAbsolute(
+                relative
+            )
+        )
+    );
+}
+
+function isFile(
+    filePath: string
+): boolean {
+    try {
+        return fs.statSync(
+            filePath
+        ).isFile();
+    } catch {
+        return false;
+    }
+}
+
+function isDirectory(
+    filePath: string
+): boolean {
+    try {
+        return fs.statSync(
+            filePath
+        ).isDirectory();
+    } catch {
+        return false;
+    }
+}
+
+function normalizePath(
+    filePath: string
+): string {
+    let normalized =
+        path.normalize(
+            path.resolve(
+                filePath
+            )
+        );
+
+    if (
+        process.platform ===
+        "win32"
+    ) {
+        normalized =
+            normalized.toLowerCase();
+    }
+
+    return normalized;
+}

package/packages/cli/src/index.ts

@@ -4,6 +4,12 @@ import {
   pathToFileURL,
 } from "node:url";
 
+import {
+  installApplicationModuleAlias,
+} from "../../bundler/src/application-modules.js";
+import {
+  validateClientBoundaries,
+} from "../../bundler/src/client-boundary.js";
 import {
   readResolvedBcpConfig,
 } from "../../config/src/index.js";
@@ -72,6 +78,31 @@ async function runDev() {
   process.env.NODE_ENV =
     "development";
 
+  const rootDirectory =
+    resolveProjectRoot(
+      cliOptions.rootDirectory
+    );
+
+  installApplicationModuleAlias(
+    rootDirectory
+  );
+
+  const appDirectory =
+    path.join(
+      rootDirectory,
+      "app"
+    );
+
+  const pageRoutes =
+    scanRoutes(
+      appDirectory
+    );
+
+  validateClientBoundaries(
+    pageRoutes,
+    rootDirectory
+  );
+
   const {
     createMiddlewareDevServer,
   } =
@@ -79,11 +110,6 @@ async function runDev() {
       "../../server/src/middleware-dev-server.js"
     );
 
-  const rootDirectory =
-    resolveProjectRoot(
-      cliOptions.rootDirectory
-    );
-
   console.log(
     `[BCP CLI] Project: ${rootDirectory}`
   );
@@ -151,6 +177,11 @@ async function runBuild() {
     apiRoutes
   );
 
+  validateClientBoundaries(
+    pageRoutes,
+    rootDirectory
+  );
+
   console.log("");
   console.log(
     `[BCP Build] Project: ${rootDirectory}`

package/packages/client/src/server-only.browser.mjs

@@ -0,0 +1,7 @@
+import "node:fs";
+
+throw new Error(
+    "BCP Framework: bcp/server-only cannot be loaded in the browser."
+);
+
+export {};

package/packages/client/src/server-only.d.ts

@@ -0,0 +1 @@
+export {};

package/packages/client/src/server-only.mjs

@@ -0,0 +1 @@
+export {};