@chidchanun/bcp 0.1.0

package/packages/server/src/standalone-production-runtime-v3.ts

@@ -0,0 +1,250 @@
+import fs from "node:fs";
+import * as net from "node:net";
+import path from "node:path";
+import {
+    pathToFileURL,
+} from "node:url";
+
+import {
+    assertMiddlewareModule,
+} from "./middleware-loader.js";
+
+import {
+    createMiddlewareProxy,
+} from "./middleware-proxy.js";
+
+import {
+    createStandaloneProductionServer as createBaseStandaloneProductionServer,
+    type StandaloneApiRoute,
+    type StandalonePageRoute,
+    type StandaloneProductionServerOptions as BaseStandaloneProductionServerOptions,
+} from "./standalone-production-runtime-v2.js";
+
+import type {
+    MiddlewareModule,
+} from "./middleware.js";
+
+export type {
+    StandaloneApiRoute,
+    StandalonePageRoute,
+};
+
+export interface StandaloneProductionServerOptions
+    extends BaseStandaloneProductionServerOptions {}
+
+export function createStandaloneProductionServer(
+    options: StandaloneProductionServerOptions
+) {
+    let baseServer:
+        ReturnType<
+            typeof createBaseStandaloneProductionServer
+        > | null =
+        null;
+
+    let middlewareProxy:
+        ReturnType<
+            typeof createMiddlewareProxy
+        > | null =
+        null;
+
+    let started =
+        false;
+
+    async function start(): Promise<void> {
+        if (started) {
+            return;
+        }
+
+        const middlewareFile =
+            path.join(
+                options.buildDirectory,
+                "server",
+                "middleware.mjs"
+            );
+
+        if (
+            !fs.existsSync(
+                middlewareFile
+            )
+        ) {
+            baseServer =
+                createBaseStandaloneProductionServer(
+                    options
+                );
+            await baseServer.start();
+            started =
+                true;
+            return;
+        }
+
+        const module =
+            await import(
+                pathToFileURL(
+                    middlewareFile
+                ).href
+            ) as MiddlewareModule;
+
+        assertMiddlewareModule(
+            module,
+            middlewareFile
+        );
+
+        const internalPort =
+            await findFreePort();
+
+        baseServer =
+            createBaseStandaloneProductionServer({
+                ...options,
+                port:
+                    internalPort,
+                hostname:
+                    "127.0.0.1",
+            });
+
+        await baseServer.start();
+
+        middlewareProxy =
+            createMiddlewareProxy({
+                port:
+                    options.port,
+                hostname:
+                    options.hostname,
+                upstreamPort:
+                    internalPort,
+                upstreamHostname:
+                    "127.0.0.1",
+                getMiddleware:
+                    () =>
+                        module,
+            });
+
+        try {
+            await middlewareProxy.start();
+        } catch (error) {
+            await baseServer.stop();
+            baseServer =
+                null;
+            middlewareProxy =
+                null;
+            throw error;
+        }
+
+        started =
+            true;
+
+        console.log(
+            `[BCP Middleware] Production gateway: http://${options.hostname}:${options.port}`
+        );
+        console.log(
+            `[BCP Middleware] Standalone module: ${middlewareFile}`
+        );
+        console.log("");
+    }
+
+    async function stop(): Promise<void> {
+        if (middlewareProxy) {
+            await middlewareProxy.stop();
+            middlewareProxy =
+                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 middleware 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-runtime-v4.ts

@@ -0,0 +1,289 @@
+import fs from "node:fs";
+import * as net from "node:net";
+import path from "node:path";
+
+import {
+    createResponseCacheProxy,
+    type ResponseCacheManifest,
+} from "./response-cache-proxy.js";
+
+import {
+    createStandaloneProductionServer as createBaseStandaloneProductionServer,
+    type StandaloneApiRoute,
+    type StandalonePageRoute,
+    type StandaloneProductionServerOptions as BaseStandaloneProductionServerOptions,
+} from "./standalone-production-runtime-v3.js";
+
+export type {
+    StandaloneApiRoute,
+    StandalonePageRoute,
+};
+
+export interface StandaloneProductionServerOptions
+    extends BaseStandaloneProductionServerOptions {}
+
+export function createStandaloneProductionServer(
+    options: StandaloneProductionServerOptions
+) {
+    let baseServer:
+        ReturnType<
+            typeof createBaseStandaloneProductionServer
+        > | null =
+        null;
+
+    let cacheProxy:
+        ReturnType<
+            typeof createResponseCacheProxy
+        > | null =
+        null;
+
+    let started =
+        false;
+
+    async function start(): Promise<void> {
+        if (started) {
+            return;
+        }
+
+        const manifest =
+            readCacheManifest(
+                options.buildDirectory
+            );
+
+        const responseCacheEnabled =
+            process.env
+                .BCP_RESPONSE_CACHE !==
+            "0";
+
+        const hasCacheRoutes =
+            responseCacheEnabled &&
+            (
+                manifest.pages.length > 0 ||
+                manifest.apiRoutes.length > 0
+            );
+
+        if (!hasCacheRoutes) {
+            baseServer =
+                createBaseStandaloneProductionServer(
+                    options
+                );
+            await baseServer.start();
+            started =
+                true;
+
+            if (
+                !responseCacheEnabled
+            ) {
+                console.log(
+                    "[BCP Cache] Production response cache disabled by configuration."
+                );
+                console.log("");
+            }
+
+            return;
+        }
+
+        const internalPort =
+            await findFreePort();
+
+        baseServer =
+            createBaseStandaloneProductionServer({
+                ...options,
+                port:
+                    internalPort,
+                hostname:
+                    "127.0.0.1",
+            });
+
+        await baseServer.start();
+
+        cacheProxy =
+            createResponseCacheProxy({
+                port:
+                    options.port,
+                hostname:
+                    options.hostname,
+                upstreamPort:
+                    internalPort,
+                upstreamHostname:
+                    "127.0.0.1",
+                manifest,
+            });
+
+        try {
+            await cacheProxy.start();
+        } catch (error) {
+            await baseServer.stop();
+            baseServer =
+                null;
+            cacheProxy =
+                null;
+            throw error;
+        }
+
+        started =
+            true;
+
+        console.log(
+            `[BCP Cache] Production response cache: ${manifest.pages.length} page(s), ${manifest.apiRoutes.length} API route(s)`
+        );
+        console.log(
+            `[BCP Cache] Gateway: http://${options.hostname}:${options.port}`
+        );
+        console.log("");
+    }
+
+    async function stop(): Promise<void> {
+        if (cacheProxy) {
+            await cacheProxy.stop();
+            cacheProxy =
+                null;
+        }
+
+        if (baseServer) {
+            await baseServer.stop();
+            baseServer =
+                null;
+        }
+
+        started =
+            false;
+    }
+
+    return {
+        start,
+        stop,
+    };
+}
+
+function readCacheManifest(
+    buildDirectory: string
+): ResponseCacheManifest {
+    const filePath =
+        path.join(
+            buildDirectory,
+            "server",
+            "cache-manifest.json"
+        );
+
+    if (
+        !fs.existsSync(
+            filePath
+        )
+    ) {
+        return {
+            version: 1,
+            pages: [],
+            apiRoutes: [],
+        };
+    }
+
+    const parsed =
+        JSON.parse(
+            fs.readFileSync(
+                filePath,
+                "utf8"
+            )
+        ) as Partial<ResponseCacheManifest>;
+
+    if (
+        parsed.version !== 1 ||
+        !Array.isArray(
+            parsed.pages
+        ) ||
+        !Array.isArray(
+            parsed.apiRoutes
+        )
+    ) {
+        throw new Error(
+            `BCP Framework: invalid cache manifest at "${filePath}".`
+        );
+    }
+
+    return parsed as ResponseCacheManifest;
+}
+
+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 production cache port."
+            );
+        }
+
+        return address.port;
+    } finally {
+        if (
+            server.listening
+        ) {
+            await new Promise<void>(
+                (
+                    resolve,
+                    reject
+                ) => {
+                    server.close(
+                        (error) => {
+                            if (error) {
+                                reject(
+                                    error
+                                );
+                                return;
+                            }
+                            resolve();
+                        }
+                    );
+                }
+            );
+        }
+    }
+}