@chidchanun/bcp 0.1.8 → 0.1.9

package/packages/server/src/page-loader.ts

@@ -0,0 +1,346 @@
+import fs from "node:fs";
+import path from "node:path";
+import {
+    pathToFileURL,
+} from "node:url";
+
+export const LOADER_DATA_PARAM =
+    "__bcp_loader_data";
+
+export interface PageLoaderContext {
+    params: Record<string, any>;
+    searchParams: URLSearchParams;
+}
+
+export type PageLoader = (
+    context: PageLoaderContext
+) =>
+    | unknown
+    | Promise<unknown>;
+
+export interface PageLoaderExecution {
+    hasLoader: boolean;
+    data: unknown;
+    response: Response | null;
+}
+
+export function findPageLoaderFile(
+    pageFilePath: string
+): string | null {
+    const directory =
+        path.dirname(
+            pageFilePath
+        );
+    const tsFile =
+        path.join(
+            directory,
+            "loader.ts"
+        );
+    const tsxFile =
+        path.join(
+            directory,
+            "loader.tsx"
+        );
+    const hasTs =
+        fs.existsSync(
+            tsFile
+        );
+    const hasTsx =
+        fs.existsSync(
+            tsxFile
+        );
+
+    if (hasTs && hasTsx) {
+        throw new Error(
+            `BCP Framework: both loader.ts and loader.tsx exist in "${directory}".`
+        );
+    }
+
+    if (hasTs) {
+        return tsFile;
+    }
+
+    if (hasTsx) {
+        return tsxFile;
+    }
+
+    return null;
+}
+
+export function routeHasPageLoader(
+    pageFilePath: string
+): boolean {
+    return findPageLoaderFile(
+        pageFilePath
+    ) !== null;
+}
+
+export async function executePageLoader(
+    pageFilePath: string,
+    params: Record<string, any>,
+    requestUrl: URL,
+    moduleVersion = 0
+): Promise<PageLoaderExecution> {
+    const loaderFile =
+        findPageLoaderFile(
+            pageFilePath
+        );
+
+    if (!loaderFile) {
+        return {
+            hasLoader:
+                false,
+            data:
+                undefined,
+            response:
+                null,
+        };
+    }
+
+    const moduleUrl =
+        pathToFileURL(
+            loaderFile
+        );
+
+    moduleUrl.searchParams.set(
+        "bcp-loader",
+        String(
+            moduleVersion
+        )
+    );
+
+    const loaderModule =
+        await import(
+            moduleUrl.href
+        ) as {
+            loader?: unknown;
+        };
+
+    if (
+        typeof loaderModule.loader !==
+        "function"
+    ) {
+        throw new Error(
+            `BCP Framework: loader "${loaderFile}" must export a named loader() function.`
+        );
+    }
+
+    return executePageLoaderFunction(
+        loaderModule.loader as
+            PageLoader,
+        params,
+        requestUrl,
+        loaderFile
+    );
+}
+
+export async function executePageLoaderFunction(
+    loader: PageLoader,
+    params: Record<string, any>,
+    requestUrl: URL,
+    label = "loader"
+): Promise<PageLoaderExecution> {
+    const result =
+        await loader({
+            params: {
+                ...params,
+            },
+            searchParams:
+                new URLSearchParams(
+                    requestUrl.searchParams
+                ),
+        });
+
+    if (
+        result instanceof
+        Response
+    ) {
+        return {
+            hasLoader:
+                true,
+            data:
+                undefined,
+            response:
+                result,
+        };
+    }
+
+    assertLoaderData(
+        result,
+        label
+    );
+
+    return {
+        hasLoader:
+            true,
+        data:
+            result,
+        response:
+            null,
+    };
+}
+
+export function attachLoaderDataToParams(
+    params: Record<string, any>,
+    execution: PageLoaderExecution
+): Record<string, any> {
+    if (!execution.hasLoader) {
+        return {
+            ...params,
+        };
+    }
+
+    return {
+        ...params,
+        [LOADER_DATA_PARAM]:
+            execution.data,
+    };
+}
+
+function assertLoaderData(
+    value: unknown,
+    loaderLabel: string
+): void {
+    const seen =
+        new Set<object>();
+
+    validateJsonValue(
+        value,
+        "$",
+        seen,
+        loaderLabel
+    );
+}
+
+function validateJsonValue(
+    value: unknown,
+    location: string,
+    seen: Set<object>,
+    loaderLabel: string
+): void {
+    if (
+        value === null ||
+        typeof value ===
+            "string" ||
+        typeof value ===
+            "boolean"
+    ) {
+        return;
+    }
+
+    if (
+        typeof value ===
+        "number"
+    ) {
+        if (
+            Number.isFinite(
+                value
+            )
+        ) {
+            return;
+        }
+
+        throwInvalidLoaderData(
+            loaderLabel,
+            location,
+            "numbers must be finite"
+        );
+    }
+
+    if (
+        typeof value !==
+        "object"
+    ) {
+        throwInvalidLoaderData(
+            loaderLabel,
+            location,
+            `unsupported ${typeof value} value`
+        );
+    }
+
+    const objectValue =
+        value as object;
+
+    if (seen.has(objectValue)) {
+        throwInvalidLoaderData(
+            loaderLabel,
+            location,
+            "circular references are not supported"
+        );
+    }
+
+    seen.add(
+        objectValue
+    );
+
+    try {
+        if (Array.isArray(value)) {
+            value.forEach(
+                (
+                    item,
+                    index
+                ) => {
+                    validateJsonValue(
+                        item,
+                        `${location}[${index}]`,
+                        seen,
+                        loaderLabel
+                    );
+                }
+            );
+            return;
+        }
+
+        const prototype =
+            Object.getPrototypeOf(
+                value
+            );
+
+        if (
+            prototype !==
+                Object.prototype &&
+            prototype !==
+                null
+        ) {
+            throwInvalidLoaderData(
+                loaderLabel,
+                location,
+                "only plain objects and arrays are supported"
+            );
+        }
+
+        for (
+            const [
+                key,
+                item,
+            ]
+            of Object.entries(
+                value as Record<
+                    string,
+                    unknown
+                >
+            )
+        ) {
+            validateJsonValue(
+                item,
+                `${location}.${key}`,
+                seen,
+                loaderLabel
+            );
+        }
+    } finally {
+        seen.delete(
+            objectValue
+        );
+    }
+}
+
+function throwInvalidLoaderData(
+    loaderLabel: string,
+    location: string,
+    reason: string
+): never {
+    throw new Error(
+        `BCP Framework: loader "${loaderLabel}" returned non-serializable data at ${location}: ${reason}.`
+    );
+}