@chidchanun/bcp 0.1.0

package/packages/cli/src/index.ts

@@ -0,0 +1,504 @@
+import fs from "node:fs";
+import path from "node:path";
+import {
+  pathToFileURL,
+} from "node:url";
+
+import {
+  readResolvedBcpConfig,
+} from "../../config/src/index.js";
+
+import {
+  assertNoPageApiConflicts,
+  scanApiRoutes,
+  scanRoutes,
+} from "../../router/src/index.js";
+
+import {
+  parseCliArgs,
+  resolveProjectRoot,
+} from "./args.js";
+
+import {
+  getFrameworkVersion,
+} from "./version.js";
+
+const FRAMEWORK_VERSION =
+  getFrameworkVersion();
+
+const cliOptions =
+  parseCliArgs(
+    process.argv.slice(2)
+  );
+
+const frameworkConfig =
+  readResolvedBcpConfig();
+
+switch (cliOptions.command) {
+  case "dev": {
+    await runDev();
+    break;
+  }
+
+  case "build": {
+    await runBuild();
+    break;
+  }
+
+  case "start": {
+    await runStart();
+    break;
+  }
+
+  case "routes": {
+    runRoutes();
+    break;
+  }
+
+  case "help": {
+    printHelp();
+    break;
+  }
+
+  case "version": {
+    console.log(
+      `BCP Framework v${FRAMEWORK_VERSION}`
+    );
+    break;
+  }
+}
+
+async function runDev() {
+  process.env.NODE_ENV =
+    "development";
+
+  const {
+    createMiddlewareDevServer,
+  } =
+    await import(
+      "../../server/src/middleware-dev-server.js"
+    );
+
+  const rootDirectory =
+    resolveProjectRoot(
+      cliOptions.rootDirectory
+    );
+
+  console.log(
+    `[BCP CLI] Project: ${rootDirectory}`
+  );
+
+  const server =
+    createMiddlewareDevServer({
+      port:
+        frameworkConfig.server.port,
+      hostname:
+        frameworkConfig.server.hostname,
+      rootDirectory,
+    });
+
+  installShutdownHandlers(
+    server
+  );
+
+  await server.start();
+}
+
+async function runBuild() {
+  process.env.NODE_ENV =
+    "production";
+
+  const [
+    {
+      buildProductionClient,
+    },
+    {
+      buildProductionServer,
+    },
+  ] =
+    await Promise.all([
+      import(
+        "../../bundler/src/partial-hydration.js"
+      ),
+      import(
+        "../../bundler/src/server-production-middleware.js"
+      ),
+    ]);
+
+  const rootDirectory =
+    resolveProjectRoot(
+      cliOptions.rootDirectory
+    );
+
+  const appDirectory =
+    path.join(
+      rootDirectory,
+      "app"
+    );
+
+  const pageRoutes =
+    scanRoutes(
+      appDirectory
+    );
+
+  const apiRoutes =
+    scanApiRoutes(
+      appDirectory
+    );
+
+  assertNoPageApiConflicts(
+    pageRoutes,
+    apiRoutes
+  );
+
+  console.log("");
+  console.log(
+    `[BCP Build] Project: ${rootDirectory}`
+  );
+  console.log(
+    `[BCP Build] Pages: ${pageRoutes.length} | API: ${apiRoutes.length}`
+  );
+  console.log(
+    `[BCP Build] Config: minify=${frameworkConfig.build.minify} sourceMaps=${frameworkConfig.build.sourceMaps} compression=${frameworkConfig.compression}`
+  );
+
+  const startedAt =
+    performance.now();
+
+  const manifest =
+    await buildProductionClient(
+      pageRoutes,
+      rootDirectory
+    );
+
+  const serverBuild =
+    await buildProductionServer(
+      pageRoutes,
+      apiRoutes,
+      rootDirectory,
+      manifest
+    );
+
+  const duration =
+    performance.now() -
+    startedAt;
+
+  console.log("");
+
+  for (
+    const [
+      pathname,
+      routeAsset,
+    ]
+    of Object.entries(
+      manifest.routes
+    )
+  ) {
+    console.log(
+      `  ${pathname} -> ${routeAsset.entry}`
+    );
+
+    console.log(
+      `    imports: ${routeAsset.imports.length} | raw ${formatBytes(routeAsset.size.raw)} | gzip ${formatBytes(routeAsset.size.gzip)} | br ${formatBytes(routeAsset.size.brotli)}`
+    );
+  }
+
+  const totalSize =
+    manifest.assets.reduce(
+      (
+        total,
+        asset
+      ) => ({
+        raw:
+          total.raw +
+          asset.size.raw,
+        gzip:
+          total.gzip +
+          asset.size.gzip,
+        brotli:
+          total.brotli +
+          asset.size.brotli,
+      }),
+      {
+        raw: 0,
+        gzip: 0,
+        brotli: 0,
+      }
+    );
+
+  console.log("");
+  console.log(
+    `[BCP Build] Client assets: raw ${formatBytes(totalSize.raw)} | gzip ${formatBytes(totalSize.gzip)} | br ${formatBytes(totalSize.brotli)}`
+  );
+  console.log(
+    `[BCP Build] Server bundle: ${formatBytes(serverBuild.size)}`
+  );
+  console.log(
+    `[BCP Build] Server: ${serverBuild.serverFile}`
+  );
+  console.log(
+    `[BCP Build] Build ID: ${manifest.buildId}`
+  );
+  console.log(
+    `[BCP Build] Assets: ${manifest.assets.length}`
+  );
+  console.log(
+    `[BCP Build] Completed in ${duration.toFixed(2)}ms`
+  );
+  console.log("");
+  console.log(
+    "[BCP Build] Standalone run:"
+  );
+  console.log(
+    `  node ${serverBuild.serverFile}`
+  );
+  console.log("");
+}
+
+async function runStart() {
+  process.env.NODE_ENV =
+    "production";
+
+  const rootDirectory =
+    resolveProjectRoot(
+      cliOptions.rootDirectory
+    );
+
+  const serverFile =
+    path.join(
+      rootDirectory,
+      ".bcp-framework",
+      "build",
+      "server",
+      "server.mjs"
+    );
+
+  if (
+    !fs.existsSync(
+      serverFile
+    )
+  ) {
+    throw new Error(
+      "BCP Framework: standalone production build was not found. Run `bcp build` before `bcp start`."
+    );
+  }
+
+  /*
+   * Keep build-time configuration frozen in server.mjs/config.json.
+   * Only explicit runtime environment values and CLI options should
+   * override the standalone artifact after it has been built.
+   */
+  if (
+    cliOptions.port !==
+    undefined
+  ) {
+    process.env.BCP_PORT =
+      String(
+        cliOptions.port
+      );
+  }
+
+  if (
+    cliOptions.hostname !==
+    undefined
+  ) {
+    process.env.BCP_HOSTNAME =
+      cliOptions.hostname;
+  }
+
+  console.log(
+    `[BCP CLI] Starting standalone build: ${serverFile}`
+  );
+
+  if (
+    cliOptions.hostname !== undefined ||
+    cliOptions.port !== undefined
+  ) {
+    console.log(
+      `[BCP CLI] Runtime server override: ${cliOptions.hostname ?? process.env.BCP_HOSTNAME ?? "(frozen hostname)"}:${cliOptions.port ?? process.env.BCP_PORT ?? "(frozen port)"}`
+    );
+  }
+
+  await import(
+    pathToFileURL(
+      serverFile
+    ).href
+  );
+}
+
+function installShutdownHandlers(
+  server: {
+    stop(): Promise<void>;
+  }
+) {
+  process.once(
+    "SIGINT",
+    async () => {
+      console.log("");
+      console.log(
+        "Stopping BCP Framework..."
+      );
+
+      await server.stop();
+
+      process.exit(0);
+    }
+  );
+
+  process.once(
+    "SIGTERM",
+    async () => {
+      await server.stop();
+
+      process.exit(0);
+    }
+  );
+}
+
+function runRoutes() {
+  const rootDirectory =
+    resolveProjectRoot(
+      cliOptions.rootDirectory
+    );
+
+  const appDirectory =
+    path.join(
+      rootDirectory,
+      "app"
+    );
+
+  const pageRoutes =
+    scanRoutes(
+      appDirectory
+    );
+
+  const apiRoutes =
+    scanApiRoutes(
+      appDirectory
+    );
+
+  assertNoPageApiConflicts(
+    pageRoutes,
+    apiRoutes
+  );
+
+  console.log("");
+  console.log(
+    `BCP Framework Routes: ${rootDirectory}`
+  );
+
+  console.log("");
+  console.log(
+    "Pages:"
+  );
+
+  if (
+    pageRoutes.length === 0
+  ) {
+    console.log(
+      "  (none)"
+    );
+  }
+
+  for (
+    const route of pageRoutes
+  ) {
+    console.log(
+      `  ${route.pathname}`
+    );
+
+    console.log(
+      `    ${route.filePath}`
+    );
+  }
+
+  console.log("");
+  console.log(
+    "API:"
+  );
+
+  if (
+    apiRoutes.length === 0
+  ) {
+    console.log(
+      "  (none)"
+    );
+  }
+
+  for (
+    const route of apiRoutes
+  ) {
+    console.log(
+      `  ${route.pathname}`
+    );
+
+    console.log(
+      `    ${route.filePath}`
+    );
+  }
+
+  console.log("");
+  console.log(
+    `Total: ${pageRoutes.length} page(s), ${apiRoutes.length} API route(s)`
+  );
+}
+
+function formatBytes(
+  value: number
+): string {
+  if (
+    value < 1024
+  ) {
+    return `${value} B`;
+  }
+
+  if (
+    value < 1024 * 1024
+  ) {
+    return `${(
+      value / 1024
+    ).toFixed(1)} KiB`;
+  }
+
+  return `${(
+    value /
+    (1024 * 1024)
+  ).toFixed(2)} MiB`;
+}
+
+function printHelp() {
+  console.log(`
+BCP Framework v${FRAMEWORK_VERSION}
+
+Usage:
+  bcp <command> [options]
+
+Commands:
+  dev       Start the development server
+  build     Create optimized client assets and standalone server.mjs
+  start     Start the standalone production build
+  routes    Print discovered page and API routes
+  help      Show this help message
+  version   Show framework version
+
+Options:
+  --root <path>         Project root directory
+  --port <number>       Override configured HTTP port
+  --hostname <host>     Override configured HTTP hostname
+  --host <host>         Alias for --hostname
+  -h, --help            Show help
+  -v, --version         Show version
+
+Config precedence:
+  dev/build: CLI > BCP_* environment > bcp.config.ts > defaults
+  start:     CLI > runtime BCP_* environment > frozen build config
+
+Examples:
+  bcp dev
+  bcp dev --port 4000
+  bcp build
+  bcp start
+  bcp start --port 4000
+  bcp routes
+`);
+}

package/packages/cli/src/version.ts

@@ -0,0 +1,45 @@
+import fs from "node:fs";
+import path from "node:path";
+import {
+    fileURLToPath,
+} from "node:url";
+
+export function getFrameworkVersion(): string {
+    const currentDirectory =
+        path.dirname(
+            fileURLToPath(
+                import.meta.url
+            )
+        );
+
+    const packageFile =
+        path.resolve(
+            currentDirectory,
+            "../../../package.json"
+        );
+
+    try {
+        const packageJson =
+            JSON.parse(
+                fs.readFileSync(
+                    packageFile,
+                    "utf8"
+                )
+            ) as {
+                version?: unknown;
+            };
+
+        if (
+            typeof packageJson.version ===
+                "string" &&
+            packageJson.version.trim() !==
+                ""
+        ) {
+            return packageJson.version;
+        }
+    } catch {
+        // Fall through to a non-release development marker.
+    }
+
+    return "0.0.0-dev";
+}

package/packages/client/src/cache.ts

@@ -0,0 +1,11 @@
+export {
+    cache,
+    clearCache,
+    dedupe,
+    getCacheStats,
+    revalidatePath,
+    revalidateTag,
+    type CacheOptions,
+    type CacheStats,
+    type RevalidateValue,
+} from "../../cache/src/index.js";

package/packages/client/src/config.ts

@@ -0,0 +1,18 @@
+export {
+    applyResolvedBcpConfig,
+    defaultBcpConfig,
+    defineConfig,
+    getConfigFileNames,
+    loadBcpConfig,
+    readResolvedBcpConfig,
+    resolveBcpConfig,
+    type BcpBuildConfig,
+    type BcpCacheConfig,
+    type BcpConfig,
+    type BcpExperimentalConfig,
+    type BcpSecurityConfig,
+    type BcpServerConfig,
+    type LoadedBcpConfig,
+    type ResolveBcpConfigOverrides,
+    type ResolvedBcpConfig,
+} from "../../config/src/index.js";

package/packages/client/src/error-boundary.tsx

@@ -0,0 +1,149 @@
+import {
+    Component,
+    createElement,
+    type ComponentType,
+    type ErrorInfo,
+    type ReactNode,
+} from "react";
+
+import {
+    isNotFoundError,
+} from "./not-found.js";
+
+export interface BcpErrorComponentProps {
+    error: Error;
+    reset: () => void;
+}
+
+export interface BcpRouteErrorBoundaryProps {
+    children: ReactNode;
+    ErrorComponent?:
+        ComponentType<
+            BcpErrorComponentProps
+        > | null;
+    NotFoundComponent?:
+        ComponentType | null;
+}
+
+interface BcpRouteErrorBoundaryState {
+    error: unknown | null;
+}
+
+export class BcpRouteErrorBoundary
+    extends Component<
+        BcpRouteErrorBoundaryProps,
+        BcpRouteErrorBoundaryState
+    > {
+    state:
+        BcpRouteErrorBoundaryState = {
+        error: null,
+    };
+
+    static getDerivedStateFromError(
+        error: unknown
+    ):
+        BcpRouteErrorBoundaryState {
+        return {
+            error,
+        };
+    }
+
+    componentDidCatch(
+        error: Error,
+        info: ErrorInfo
+    ): void {
+        console.error(
+            "[BCP Route Error]",
+            error,
+            info.componentStack
+        );
+    }
+
+    private reset = (): void => {
+        this.setState({
+            error: null,
+        });
+    };
+
+    render(): ReactNode {
+        const {
+            error,
+        } = this.state;
+
+        if (error === null) {
+            return this.props.children;
+        }
+
+        if (
+            isNotFoundError(
+                error
+            )
+        ) {
+            const NotFoundComponent =
+                this.props
+                    .NotFoundComponent;
+
+            if (NotFoundComponent) {
+                return createElement(
+                    NotFoundComponent
+                );
+            }
+
+            return createElement(
+                "main",
+                null,
+                createElement(
+                    "h1",
+                    null,
+                    "404"
+                ),
+                createElement(
+                    "p",
+                    null,
+                    "Page Not Found"
+                )
+            );
+        }
+
+        const ErrorComponent =
+            this.props.ErrorComponent;
+
+        const normalizedError =
+            error instanceof Error
+                ? error
+                : new Error(
+                    "An unexpected client error occurred."
+                );
+
+        if (ErrorComponent) {
+            return createElement(
+                ErrorComponent,
+                {
+                    error:
+                        normalizedError,
+                    reset:
+                        this.reset,
+                }
+            );
+        }
+
+        return createElement(
+            "main",
+            null,
+            createElement(
+                "h1",
+                null,
+                "Something went wrong"
+            ),
+            createElement(
+                "button",
+                {
+                    type: "button",
+                    onClick:
+                        this.reset,
+                },
+                "Try again"
+            )
+        );
+    }
+}

package/packages/client/src/hydration.ts

@@ -0,0 +1,3 @@
+export type HydrationMode =
+    | "full"
+    | "none";