@chidchanun/bcp 0.1.0

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

@@ -0,0 +1,289 @@
+import fs from "node:fs";
+import * as net from "node:net";
+import path from "node:path";
+
+import {
+    createSecurityProxy,
+} from "./security-proxy.js";
+
+import {
+    createStandaloneProductionServer as createBaseStandaloneProductionServer,
+    type StandaloneApiRoute,
+    type StandalonePageRoute,
+    type StandaloneProductionServerOptions as BaseStandaloneProductionServerOptions,
+} from "./standalone-production-runtime-v4.js";
+
+export type {
+    StandaloneApiRoute,
+    StandalonePageRoute,
+};
+
+export interface StandaloneProductionServerOptions
+    extends BaseStandaloneProductionServerOptions {}
+
+export function createStandaloneProductionServer(
+    options: StandaloneProductionServerOptions
+) {
+    let baseServer:
+        ReturnType<
+            typeof createBaseStandaloneProductionServer
+        > | null =
+        null;
+
+    let securityProxy:
+        ReturnType<
+            typeof createSecurityProxy
+        > | null =
+        null;
+
+    let started =
+        false;
+
+    async function start(): Promise<void> {
+        if (started) {
+            return;
+        }
+
+        applyFrozenSecurityConfig(
+            options.buildDirectory
+        );
+
+        const internalPort =
+            await findFreePort();
+
+        baseServer =
+            createBaseStandaloneProductionServer({
+                ...options,
+                port:
+                    internalPort,
+                hostname:
+                    "127.0.0.1",
+            });
+
+        await baseServer.start();
+
+        securityProxy =
+            createSecurityProxy({
+                port:
+                    options.port,
+                hostname:
+                    options.hostname,
+                upstreamPort:
+                    internalPort,
+                upstreamHostname:
+                    "127.0.0.1",
+            });
+
+        try {
+            await securityProxy.start();
+        } catch (error) {
+            await baseServer.stop();
+            baseServer =
+                null;
+            securityProxy =
+                null;
+            throw error;
+        }
+
+        started =
+            true;
+
+        console.log(
+            `[BCP Security] Gateway: http://${options.hostname}:${options.port}`
+        );
+        console.log("");
+    }
+
+    async function stop(): Promise<void> {
+        if (securityProxy) {
+            await securityProxy.stop();
+            securityProxy =
+                null;
+        }
+
+        if (baseServer) {
+            await baseServer.stop();
+            baseServer =
+                null;
+        }
+
+        started =
+            false;
+    }
+
+    return {
+        start,
+        stop,
+    };
+}
+
+function applyFrozenSecurityConfig(
+    buildDirectory: string
+): void {
+    const configFile =
+        path.join(
+            buildDirectory,
+            "server",
+            "config.json"
+        );
+
+    if (
+        !fs.existsSync(
+            configFile
+        )
+    ) {
+        return;
+    }
+
+    try {
+        const parsed =
+            JSON.parse(
+                fs.readFileSync(
+                    configFile,
+                    "utf8"
+                )
+            ) as {
+                server?: {
+                    bodyLimit?: number;
+                };
+                security?: {
+                    poweredByHeader?: boolean;
+                    contentSecurityPolicy?: string | false;
+                    frameOptions?: "DENY" | "SAMEORIGIN" | false;
+                    referrerPolicy?: string;
+                    permissionsPolicy?: string | false;
+                };
+            };
+
+        if (
+            process.env.BCP_BODY_LIMIT === undefined &&
+            Number.isInteger(
+                parsed.server?.bodyLimit
+            )
+        ) {
+            process.env.BCP_BODY_LIMIT =
+                String(
+                    parsed.server?.bodyLimit
+                );
+        }
+
+        const security =
+            parsed.security;
+
+        if (!security) {
+            return;
+        }
+
+        process.env.BCP_POWERED_BY_HEADER ??=
+            security.poweredByHeader
+                ? "1"
+                : "0";
+        process.env.BCP_SECURITY_CSP ??=
+            security.contentSecurityPolicy === false ||
+            security.contentSecurityPolicy === undefined
+                ? "0"
+                : security.contentSecurityPolicy;
+        process.env.BCP_SECURITY_FRAME_OPTIONS ??=
+            security.frameOptions === false ||
+            security.frameOptions === undefined
+                ? "0"
+                : security.frameOptions;
+        process.env.BCP_SECURITY_REFERRER_POLICY ??=
+            security.referrerPolicy ??
+            "strict-origin-when-cross-origin";
+        process.env.BCP_SECURITY_PERMISSIONS_POLICY ??=
+            security.permissionsPolicy === false ||
+            security.permissionsPolicy === undefined
+                ? "0"
+                : security.permissionsPolicy;
+    } catch (error) {
+        throw new Error(
+            `BCP Framework: invalid standalone security config at "${configFile}". ${error instanceof Error ? error.message : String(error)}`
+        );
+    }
+}
+
+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 security gateway port."
+            );
+        }
+
+        return address.port;
+    } finally {
+        if (
+            server.listening
+        ) {
+            await new Promise<void>(
+                (
+                    resolve,
+                    reject
+                ) => {
+                    server.close(
+                        (error) => {
+                            if (error) {
+                                reject(
+                                    error
+                                );
+                                return;
+                            }
+                            resolve();
+                        }
+                    );
+                }
+            );
+        }
+    }
+}