@chidchanun/bcp 0.1.0

package/packages/env/src/index.ts

@@ -0,0 +1,593 @@
+import fs from "node:fs";
+import path from "node:path";
+
+export type EnvironmentMode =
+    | "development"
+    | "production"
+    | "test"
+    | string;
+
+export interface EnvironmentLoadResult {
+    mode: EnvironmentMode;
+    files: string[];
+    values: Record<string, string>;
+    publicValues: Record<string, string>;
+}
+
+interface EnvironmentState {
+    externalValues: Record<string, string | undefined>;
+    managedKeys: Set<string>;
+}
+
+const PUBLIC_PREFIX =
+    "BCP_PUBLIC_";
+
+const environmentStates =
+    new Map<string, EnvironmentState>();
+
+export function loadEnvironment(
+    rootDirectory: string,
+    mode: EnvironmentMode
+): EnvironmentLoadResult {
+    const root =
+        path.resolve(
+            rootDirectory
+        );
+
+    const stateKey =
+        `${normalizeStatePath(root)}\0${mode}`;
+
+    let state =
+        environmentStates.get(
+            stateKey
+        );
+
+    if (!state) {
+        state = {
+            externalValues:
+                snapshotProcessEnvironment(),
+            managedKeys:
+                new Set<string>(),
+        };
+
+        environmentStates.set(
+            stateKey,
+            state
+        );
+    } else {
+        restoreExternalEnvironment(
+            state
+        );
+    }
+
+    const merged:
+        Record<string, string> = {};
+
+    const loadedFiles:
+        string[] = [];
+
+    for (
+        const fileName
+        of getEnvironmentFileNames(
+            mode
+        )
+    ) {
+        const filePath =
+            path.join(
+                root,
+                fileName
+            );
+
+        if (
+            !fs.existsSync(
+                filePath
+            )
+        ) {
+            continue;
+        }
+
+        const stat =
+            fs.statSync(
+                filePath
+            );
+
+        if (!stat.isFile()) {
+            continue;
+        }
+
+        const parsed =
+            parseEnvironmentFile(
+                fs.readFileSync(
+                    filePath,
+                    "utf8"
+                ),
+                {
+                    ...state.externalValues,
+                    ...merged,
+                }
+            );
+
+        Object.assign(
+            merged,
+            parsed
+        );
+
+        loadedFiles.push(
+            fileName
+        );
+    }
+
+    const nextManagedKeys =
+        new Set<string>();
+
+    for (
+        const [
+            key,
+            value,
+        ]
+        of Object.entries(
+            merged
+        )
+    ) {
+        if (
+            state.externalValues[
+                key
+            ] !== undefined
+        ) {
+            continue;
+        }
+
+        process.env[
+            key
+        ] =
+            value;
+
+        nextManagedKeys.add(
+            key
+        );
+    }
+
+    state.managedKeys =
+        nextManagedKeys;
+
+    const values =
+        collectEnvironmentValues();
+
+    return {
+        mode,
+        files:
+            loadedFiles,
+        values,
+        publicValues:
+            getPublicEnvironment(
+                values
+            ),
+    };
+}
+
+export function getPublicEnvironment(
+    source:
+        NodeJS.ProcessEnv |
+        Record<string, string> =
+            process.env
+): Record<string, string> {
+    const result:
+        Record<string, string> = {};
+
+    for (
+        const [
+            key,
+            value,
+        ]
+        of Object.entries(
+            source
+        )
+    ) {
+        if (
+            !key.startsWith(
+                PUBLIC_PREFIX
+            ) ||
+            value === undefined
+        ) {
+            continue;
+        }
+
+        result[
+            key
+        ] =
+            value;
+    }
+
+    return result;
+}
+
+export function createClientEnvironmentDefines(
+    mode: "development" | "production"
+): Record<string, string> {
+    const publicValues =
+        getPublicEnvironment();
+
+    const safeEnvironment = {
+        NODE_ENV:
+            mode,
+        ...publicValues,
+    };
+
+    const defines:
+        Record<string, string> = {
+        "process.env":
+            JSON.stringify(
+                safeEnvironment
+            ),
+        "process.env.NODE_ENV":
+            JSON.stringify(
+                mode
+            ),
+    };
+
+    for (
+        const [
+            key,
+            value,
+        ]
+        of Object.entries(
+            publicValues
+        )
+    ) {
+        defines[
+            `process.env.${key}`
+        ] =
+            JSON.stringify(
+                value
+            );
+    }
+
+    return defines;
+}
+
+export function createServerEnvironmentDefines(
+    mode: "development" | "production"
+): Record<string, string> {
+    const defines:
+        Record<string, string> = {
+        "process.env.NODE_ENV":
+            JSON.stringify(
+                mode
+            ),
+    };
+
+    for (
+        const [
+            key,
+            value,
+        ]
+        of Object.entries(
+            getPublicEnvironment()
+        )
+    ) {
+        defines[
+            `process.env.${key}`
+        ] =
+            JSON.stringify(
+                value
+            );
+    }
+
+    return defines;
+}
+
+export function getEnvironmentFileNames(
+    mode: EnvironmentMode
+): string[] {
+    return [
+        ".env",
+        ".env.local",
+        `.env.${mode}`,
+        `.env.${mode}.local`,
+    ];
+}
+
+export function parseEnvironmentFile(
+    source: string,
+    expansionSource:
+        NodeJS.ProcessEnv |
+        Record<string, string | undefined> =
+            process.env
+): Record<string, string> {
+    const result:
+        Record<string, string> = {};
+
+    const lines =
+        source
+            .replace(
+                /^\uFEFF/,
+                ""
+            )
+            .split(
+                /\r?\n/
+            );
+
+    for (
+        let index = 0;
+        index <
+            lines.length;
+        index++
+    ) {
+        const originalLine =
+            lines[
+                index
+            ];
+
+        const trimmed =
+            originalLine.trim();
+
+        if (
+            trimmed.length === 0 ||
+            trimmed.startsWith(
+                "#"
+            )
+        ) {
+            continue;
+        }
+
+        const normalized =
+            trimmed.startsWith(
+                "export "
+            )
+                ? trimmed.slice(
+                    "export ".length
+                ).trimStart()
+                : trimmed;
+
+        const separator =
+            normalized.indexOf(
+                "="
+            );
+
+        if (
+            separator <= 0
+        ) {
+            throw new Error(
+                `BCP Framework: invalid environment assignment on line ${index + 1}.`
+            );
+        }
+
+        const key =
+            normalized
+                .slice(
+                    0,
+                    separator
+                )
+                .trim();
+
+        if (
+            !/^[A-Za-z_][A-Za-z0-9_]*$/.test(
+                key
+            )
+        ) {
+            throw new Error(
+                `BCP Framework: invalid environment variable name "${key}" on line ${index + 1}.`
+            );
+        }
+
+        const rawValue =
+            normalized
+                .slice(
+                    separator + 1
+                )
+                .trim();
+
+        const value =
+            parseEnvironmentValue(
+                rawValue
+            );
+
+        result[
+            key
+        ] =
+            expandEnvironmentValue(
+                value,
+                {
+                    ...expansionSource,
+                    ...result,
+                }
+            );
+    }
+
+    return result;
+}
+
+function parseEnvironmentValue(
+    rawValue: string
+): string {
+    if (
+        rawValue.length === 0
+    ) {
+        return "";
+    }
+
+    if (
+        rawValue.startsWith(
+            "'"
+        )
+    ) {
+        if (
+            !rawValue.endsWith(
+                "'"
+            ) ||
+            rawValue.length < 2
+        ) {
+            throw new Error(
+                "BCP Framework: unterminated single-quoted environment value."
+            );
+        }
+
+        return rawValue.slice(
+            1,
+            -1
+        );
+    }
+
+    if (
+        rawValue.startsWith(
+            '"'
+        )
+    ) {
+        if (
+            !rawValue.endsWith(
+                '"'
+            ) ||
+            rawValue.length < 2
+        ) {
+            throw new Error(
+                "BCP Framework: unterminated double-quoted environment value."
+            );
+        }
+
+        return rawValue
+            .slice(
+                1,
+                -1
+            )
+            .replace(
+                /\\n/g,
+                "\n"
+            )
+            .replace(
+                /\\r/g,
+                "\r"
+            )
+            .replace(
+                /\\t/g,
+                "\t"
+            )
+            .replace(
+                /\\"/g,
+                '"'
+            )
+            .replace(
+                /\\\\/g,
+                "\\"
+            );
+    }
+
+    const commentMatch =
+        /\s+#/.exec(
+            rawValue
+        );
+
+    return (
+        commentMatch
+            ? rawValue.slice(
+                0,
+                commentMatch.index
+            )
+            : rawValue
+    ).trimEnd();
+}
+
+function expandEnvironmentValue(
+    value: string,
+    source:
+        NodeJS.ProcessEnv |
+        Record<string, string | undefined>
+): string {
+    return value.replace(
+        /(^|[^\\])\$(?:\{([A-Za-z_][A-Za-z0-9_]*)\}|([A-Za-z_][A-Za-z0-9_]*))/g,
+        (
+            _match,
+            prefix: string,
+            braced: string | undefined,
+            plain: string | undefined
+        ) => {
+            const key =
+                braced ??
+                plain ??
+                "";
+
+            return `${prefix}${
+                source[
+                    key
+                ] ??
+                ""
+            }`;
+        }
+    )
+        .replace(
+            /\\\$/g,
+            "$"
+        );
+}
+
+function snapshotProcessEnvironment(): Record<string, string | undefined> {
+    return {
+        ...process.env,
+    };
+}
+
+function restoreExternalEnvironment(
+    state: EnvironmentState
+): void {
+    for (
+        const key
+        of state.managedKeys
+    ) {
+        const externalValue =
+            state.externalValues[
+                key
+            ];
+
+        if (
+            externalValue === undefined
+        ) {
+            delete process.env[
+                key
+            ];
+        } else {
+            process.env[
+                key
+            ] =
+                externalValue;
+        }
+    }
+}
+
+function normalizeStatePath(
+    value: string
+): string {
+    const normalized =
+        path.normalize(
+            value
+        );
+
+    return process.platform ===
+        "win32"
+        ? normalized.toLowerCase()
+        : normalized;
+}
+
+function collectEnvironmentValues(): Record<string, string> {
+    const result:
+        Record<string, string> = {};
+
+    for (
+        const [
+            key,
+            value,
+        ]
+        of Object.entries(
+            process.env
+        )
+    ) {
+        if (
+            value !== undefined
+        ) {
+            result[
+                key
+            ] =
+                value;
+        }
+    }
+
+    return result;
+}