@chidchanun/bcp 0.1.0

package/packages/server/src/metadata.ts

@@ -0,0 +1,478 @@
+import type {
+    GenerateMetadata,
+    Metadata,
+    MetadataIcons,
+    MetadataOpenGraph,
+    MetadataRobots,
+    ResolvedMetadata,
+} from "../../client/src/metadata.js";
+
+export interface MetadataSource {
+    label: string;
+    metadata?: Metadata;
+    generateMetadata?: GenerateMetadata;
+}
+
+export async function resolveRouteMetadata(
+    sources: MetadataSource[],
+    params: Record<string, string>,
+    fallbackTitle = "BCP Framework"
+): Promise<ResolvedMetadata> {
+    let merged: Metadata = {};
+
+    for (const source of sources) {
+        const hasStatic =
+            source.metadata !== undefined;
+        const hasGenerated =
+            source.generateMetadata !== undefined;
+
+        if (hasStatic && hasGenerated) {
+            throw new Error(
+                `BCP Framework: ${source.label} cannot export both metadata and generateMetadata.`
+            );
+        }
+
+        let next: Metadata | undefined;
+
+        if (hasGenerated) {
+            if (
+                typeof source.generateMetadata !==
+                "function"
+            ) {
+                throw new Error(
+                    `BCP Framework: generateMetadata in ${source.label} must be a function.`
+                );
+            }
+
+            next =
+                await source.generateMetadata({
+                    params,
+                    parent:
+                        resolveMetadata(
+                            merged,
+                            fallbackTitle
+                        ),
+                });
+        } else if (hasStatic) {
+            next =
+                source.metadata;
+        }
+
+        if (next === undefined) {
+            continue;
+        }
+
+        assertMetadata(
+            next,
+            source.label
+        );
+
+        merged =
+            mergeMetadata(
+                merged,
+                next
+            );
+    }
+
+    return resolveMetadata(
+        merged,
+        fallbackTitle
+    );
+}
+
+function mergeMetadata(
+    base: Metadata,
+    next: Metadata
+): Metadata {
+    return {
+        ...base,
+        ...next,
+        alternates:
+            next.alternates
+                ? {
+                    ...base.alternates,
+                    ...next.alternates,
+                }
+                : base.alternates,
+        openGraph:
+            next.openGraph
+                ? {
+                    ...base.openGraph,
+                    ...next.openGraph,
+                }
+                : base.openGraph,
+        robots:
+            mergeRobots(
+                base.robots,
+                next.robots
+            ),
+        icons:
+            mergeIcons(
+                base.icons,
+                next.icons
+            ),
+    };
+}
+
+function mergeRobots(
+    base: Metadata["robots"],
+    next: Metadata["robots"]
+): Metadata["robots"] {
+    if (next === undefined) {
+        return base;
+    }
+
+    if (
+        typeof next === "string" ||
+        typeof base === "string" ||
+        base === undefined
+    ) {
+        return next;
+    }
+
+    return {
+        ...base,
+        ...next,
+    };
+}
+
+function mergeIcons(
+    base: Metadata["icons"],
+    next: Metadata["icons"]
+): Metadata["icons"] {
+    if (next === undefined) {
+        return base;
+    }
+
+    const normalizedNext =
+        normalizeIcons(
+            next
+        );
+
+    const normalizedBase =
+        base === undefined
+            ? undefined
+            : normalizeIcons(
+                base
+            );
+
+    return {
+        ...normalizedBase,
+        ...normalizedNext,
+    };
+}
+
+function resolveMetadata(
+    metadata: Metadata,
+    fallbackTitle: string
+): ResolvedMetadata {
+    const title =
+        metadata.title ??
+        fallbackTitle;
+
+    const description =
+        metadata.description ??
+        null;
+
+    const openGraph =
+        metadata.openGraph
+            ? resolveOpenGraph(
+                metadata.openGraph,
+                title,
+                description
+            )
+            : null;
+
+    const icons =
+        normalizeIcons(
+            metadata.icons
+        );
+
+    return {
+        title,
+        description,
+        robots:
+            resolveRobots(
+                metadata.robots
+            ),
+        canonical:
+            metadata.alternates
+                ?.canonical ??
+            null,
+        openGraph,
+        icons: {
+            icon:
+                icons.icon ??
+                null,
+            shortcut:
+                icons.shortcut ??
+                null,
+            apple:
+                icons.apple ??
+                null,
+        },
+    };
+}
+
+function resolveOpenGraph(
+    value: MetadataOpenGraph,
+    title: string,
+    description: string | null
+): ResolvedMetadata["openGraph"] {
+    const images =
+        value.images === undefined
+            ? []
+            : Array.isArray(
+                value.images
+            )
+                ? value.images
+                : [
+                    value.images,
+                ];
+
+    return {
+        title:
+            value.title ??
+            title,
+        description:
+            value.description ??
+            description,
+        url:
+            value.url ??
+            null,
+        type:
+            value.type ??
+            null,
+        siteName:
+            value.siteName ??
+            null,
+        images,
+    };
+}
+
+function resolveRobots(
+    value: Metadata["robots"]
+): string | null {
+    if (value === undefined) {
+        return null;
+    }
+
+    if (typeof value === "string") {
+        return value;
+    }
+
+    const directives:
+        string[] = [];
+
+    pushBooleanDirective(
+        directives,
+        value.index,
+        "index",
+        "noindex"
+    );
+    pushBooleanDirective(
+        directives,
+        value.follow,
+        "follow",
+        "nofollow"
+    );
+
+    if (value.noarchive) {
+        directives.push(
+            "noarchive"
+        );
+    }
+
+    if (value.nosnippet) {
+        directives.push(
+            "nosnippet"
+        );
+    }
+
+    if (value.noimageindex) {
+        directives.push(
+            "noimageindex"
+        );
+    }
+
+    return directives.length > 0
+        ? directives.join(", ")
+        : null;
+}
+
+function pushBooleanDirective(
+    directives: string[],
+    value: boolean | undefined,
+    positive: string,
+    negative: string
+): void {
+    if (value === undefined) {
+        return;
+    }
+
+    directives.push(
+        value
+            ? positive
+            : negative
+    );
+}
+
+function normalizeIcons(
+    value: Metadata["icons"]
+): MetadataIcons {
+    if (value === undefined) {
+        return {};
+    }
+
+    if (typeof value === "string") {
+        return {
+            icon: value,
+        };
+    }
+
+    return value;
+}
+
+function assertMetadata(
+    value: Metadata,
+    label: string
+): void {
+    if (
+        typeof value !== "object" ||
+        value === null ||
+        Array.isArray(value)
+    ) {
+        throw new Error(
+            `BCP Framework: metadata in ${label} must be an object.`
+        );
+    }
+
+    assertOptionalString(
+        value.title,
+        "title",
+        label
+    );
+    assertOptionalString(
+        value.description,
+        "description",
+        label
+    );
+
+    if (
+        value.robots !== undefined &&
+        typeof value.robots !== "string"
+    ) {
+        assertRobots(
+            value.robots,
+            label
+        );
+    }
+
+    if (value.alternates) {
+        assertOptionalString(
+            value.alternates.canonical,
+            "alternates.canonical",
+            label
+        );
+    }
+
+    if (value.openGraph) {
+        for (
+            const [name, item]
+            of Object.entries({
+                title:
+                    value.openGraph.title,
+                description:
+                    value.openGraph.description,
+                url:
+                    value.openGraph.url,
+                type:
+                    value.openGraph.type,
+                siteName:
+                    value.openGraph.siteName,
+            })
+        ) {
+            assertOptionalString(
+                item,
+                `openGraph.${name}`,
+                label
+            );
+        }
+
+        const images =
+            value.openGraph.images;
+
+        if (
+            images !== undefined &&
+            !(
+                typeof images === "string" ||
+                (
+                    Array.isArray(images) &&
+                    images.every(
+                        (image) =>
+                            typeof image ===
+                            "string"
+                    )
+                )
+            )
+        ) {
+            throw new Error(
+                `BCP Framework: metadata.openGraph.images in ${label} must be a string or string array.`
+            );
+        }
+    }
+
+    if (
+        value.icons !== undefined &&
+        typeof value.icons !== "string"
+    ) {
+        for (
+            const [name, item]
+            of Object.entries(
+                value.icons
+            )
+        ) {
+            assertOptionalString(
+                item,
+                `icons.${name}`,
+                label
+            );
+        }
+    }
+}
+
+function assertRobots(
+    value: MetadataRobots,
+    label: string
+): void {
+    for (
+        const [name, item]
+        of Object.entries(
+            value
+        )
+    ) {
+        if (
+            item !== undefined &&
+            typeof item !== "boolean"
+        ) {
+            throw new Error(
+                `BCP Framework: metadata.robots.${name} in ${label} must be a boolean.`
+            );
+        }
+    }
+}
+
+function assertOptionalString(
+    value: unknown,
+    field: string,
+    label: string
+): void {
+    if (
+        value !== undefined &&
+        typeof value !== "string"
+    ) {
+        throw new Error(
+            `BCP Framework: metadata.${field} in ${label} must be a string.`
+        );
+    }
+}

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

@@ -0,0 +1,260 @@
+import * as net from "node:net";
+import path from "node:path";
+
+import type {
+    DevServerOptions,
+} from "./index.js";
+
+import {
+    loadProjectMiddleware,
+} from "./middleware-loader.js";
+
+import {
+    createMiddlewareProxy,
+} from "./middleware-proxy.js";
+
+import {
+    createSecurityProxy,
+} from "./security-proxy.js";
+
+import {
+    createStaticDevServer,
+} from "./static-dev-server.js";
+
+export function createMiddlewareDevServer(
+    options: DevServerOptions = {}
+) {
+    const port =
+        options.port ??
+        3000;
+
+    const hostname =
+        options.hostname ??
+        "localhost";
+
+    const rootDirectory =
+        path.resolve(
+            options.rootDirectory ??
+            process.cwd()
+        );
+
+    let internalServer:
+        ReturnType<
+            typeof createStaticDevServer
+        > | null =
+        null;
+
+    let middlewareGateway:
+        ReturnType<
+            typeof createMiddlewareProxy
+        > | null =
+        null;
+
+    let securityGateway:
+        ReturnType<
+            typeof createSecurityProxy
+        > | null =
+        null;
+
+    let started =
+        false;
+
+    async function start(): Promise<void> {
+        if (started) {
+            return;
+        }
+
+        const applicationPort =
+            await findFreePort();
+        const middlewarePort =
+            await findFreePort();
+
+        internalServer =
+            createStaticDevServer({
+                ...options,
+                rootDirectory,
+                port:
+                    applicationPort,
+                hostname:
+                    "127.0.0.1",
+            });
+
+        await internalServer.start();
+
+        middlewareGateway =
+            createMiddlewareProxy({
+                port:
+                    middlewarePort,
+                hostname:
+                    "127.0.0.1",
+                upstreamPort:
+                    applicationPort,
+                upstreamHostname:
+                    "127.0.0.1",
+                getMiddleware:
+                    () =>
+                        loadProjectMiddleware(
+                            rootDirectory
+                        ),
+            });
+
+        try {
+            await middlewareGateway.start();
+        } catch (error) {
+            await internalServer.stop();
+            internalServer =
+                null;
+            middlewareGateway =
+                null;
+            throw error;
+        }
+
+        securityGateway =
+            createSecurityProxy({
+                port,
+                hostname,
+                upstreamPort:
+                    middlewarePort,
+                upstreamHostname:
+                    "127.0.0.1",
+            });
+
+        try {
+            await securityGateway.start();
+        } catch (error) {
+            await middlewareGateway.stop();
+            await internalServer.stop();
+            internalServer =
+                null;
+            middlewareGateway =
+                null;
+            securityGateway =
+                null;
+            throw error;
+        }
+
+        started =
+            true;
+
+        console.log(
+            `[BCP Security] Dev gateway: http://${hostname}:${port}`
+        );
+        console.log(
+            `[BCP Middleware] File: ${path.join(rootDirectory, "middleware.ts")} (optional; .tsx/.js/.jsx also supported)`
+        );
+        console.log("");
+    }
+
+    async function stop(): Promise<void> {
+        if (securityGateway) {
+            await securityGateway.stop();
+            securityGateway =
+                null;
+        }
+
+        if (middlewareGateway) {
+            await middlewareGateway.stop();
+            middlewareGateway =
+                null;
+        }
+
+        if (internalServer) {
+            await internalServer.stop();
+            internalServer =
+                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 dev port."
+            );
+        }
+
+        return address.port;
+    } finally {
+        if (
+            server.listening
+        ) {
+            await new Promise<void>(
+                (
+                    resolve,
+                    reject
+                ) => {
+                    server.close(
+                        (error) => {
+                            if (error) {
+                                reject(
+                                    error
+                                );
+                                return;
+                            }
+                            resolve();
+                        }
+                    );
+                }
+            );
+        }
+    }
+}