@chidchanun/bcp 0.1.28 → 0.2.0

package/packages/cli/src/developer-tools-v2.ts

@@ -0,0 +1,629 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import {
+    getProductionHardeningConfig,
+} from "../../server/src/production-hardening.js";
+
+export interface ProjectPresetMetadata {
+    tailwind: boolean | null;
+    database: string | null;
+    auth: string | null;
+    storage: string | null;
+}
+
+export interface ProjectDiagnostics {
+    packageManager:
+        | "npm"
+        | "pnpm"
+        | "yarn"
+        | "bun"
+        | null;
+    lockfile: string | null;
+    metadataFile: string | null;
+    presets: ProjectPresetMetadata | null;
+    productionBuild: boolean;
+    dockerfile: string | null;
+    frameworkDeclarations: Array<{
+        name:
+            "bcp" |
+            "@chidchanun/bcp";
+        range: string;
+        section:
+            "dependencies" |
+            "devDependencies";
+    }>;
+    storage: {
+        provider:
+            | "none"
+            | "local"
+            | "amazon-s3"
+            | "cloudflare-r2"
+            | "s3-compatible"
+            | "custom";
+        file: string | null;
+    };
+    hardening: {
+        valid: boolean;
+        message: string;
+    };
+}
+
+interface ProjectPackageJson {
+    packageManager?: unknown;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+}
+
+interface BcpProjectManifest {
+    schemaVersion?: unknown;
+    packageManager?: unknown;
+    presets?: {
+        tailwind?: unknown;
+        database?: unknown;
+        auth?: unknown;
+        storage?: unknown;
+    };
+}
+
+export function collectProjectDiagnostics(
+    rootDirectory: string
+): ProjectDiagnostics {
+    const root =
+        path.resolve(
+            rootDirectory
+        );
+    const lockfile =
+        detectLockfile(
+            root
+        );
+    const packageFile =
+        path.join(
+            root,
+            "package.json"
+        );
+    const projectPackage =
+        readProjectPackage(
+            packageFile
+        );
+    const projectMetadata =
+        readProjectMetadata(
+            root
+        );
+    const storage =
+        detectStorageProvider(
+            root,
+            projectMetadata.manifest
+        );
+
+    let hardening:
+        ProjectDiagnostics[
+            "hardening"
+        ];
+
+    try {
+        const config =
+            getProductionHardeningConfig();
+
+        hardening = {
+            valid:
+                true,
+            message:
+                `request=${config.requestTimeoutMs}ms headers=${config.headersTimeoutMs}ms keepAlive=${config.keepAliveTimeoutMs}ms shutdown=${config.shutdownTimeoutMs}ms trustProxy=${config.trustProxy ? "on" : "off"}`,
+        };
+    } catch (error) {
+        hardening = {
+            valid:
+                false,
+            message:
+                error instanceof Error
+                    ? error.message
+                    : String(
+                        error
+                    ),
+        };
+    }
+
+    return {
+        packageManager:
+            detectPackageManager(
+                projectPackage,
+                projectMetadata.manifest,
+                lockfile
+            ),
+        lockfile,
+        metadataFile:
+            projectMetadata.file,
+        presets:
+            normalizePresetMetadata(
+                projectMetadata.manifest
+            ),
+        productionBuild:
+            fs.existsSync(
+                path.join(
+                    root,
+                    ".bcp-framework",
+                    "build",
+                    "server",
+                    "server.mjs"
+                )
+            ),
+        dockerfile:
+            detectDockerfile(
+                root
+            ),
+        frameworkDeclarations:
+            collectFrameworkDeclarations(
+                projectPackage
+            ),
+        storage,
+        hardening,
+    };
+}
+
+function detectLockfile(
+    rootDirectory: string
+): string | null {
+    for (
+        const file
+        of [
+            "package-lock.json",
+            "pnpm-lock.yaml",
+            "yarn.lock",
+            "bun.lock",
+            "bun.lockb",
+        ]
+    ) {
+        if (
+            fs.existsSync(
+                path.join(
+                    rootDirectory,
+                    file
+                )
+            )
+        ) {
+            return file;
+        }
+    }
+
+    return null;
+}
+
+function detectPackageManager(
+    projectPackage:
+        ProjectPackageJson | null,
+    projectMetadata:
+        BcpProjectManifest | null,
+    lockfile: string | null
+): ProjectDiagnostics[
+    "packageManager"
+] {
+    const metadataManager =
+        normalizePackageManager(
+            projectMetadata?.packageManager
+        );
+
+    if (metadataManager) {
+        return metadataManager;
+    }
+
+    if (
+        typeof projectPackage
+            ?.packageManager ===
+        "string"
+    ) {
+        const name =
+            projectPackage
+                .packageManager
+                .split("@", 1)[0];
+        const normalized =
+            normalizePackageManager(
+                name
+            );
+
+        if (normalized) {
+            return normalized;
+        }
+    }
+
+    if (
+        lockfile ===
+        "package-lock.json"
+    ) {
+        return "npm";
+    }
+
+    if (
+        lockfile ===
+        "pnpm-lock.yaml"
+    ) {
+        return "pnpm";
+    }
+
+    if (
+        lockfile ===
+        "yarn.lock"
+    ) {
+        return "yarn";
+    }
+
+    if (
+        lockfile === "bun.lock" ||
+        lockfile === "bun.lockb"
+    ) {
+        return "bun";
+    }
+
+    return null;
+}
+
+function normalizePackageManager(
+    value: unknown
+): ProjectDiagnostics[
+    "packageManager"
+] {
+    if (
+        typeof value !==
+        "string"
+    ) {
+        return null;
+    }
+
+    const name =
+        value
+            .trim()
+            .split("@", 1)[0];
+
+    return (
+        name === "npm" ||
+        name === "pnpm" ||
+        name === "yarn" ||
+        name === "bun"
+    )
+        ? name
+        : null;
+}
+
+function detectDockerfile(
+    rootDirectory: string
+): string | null {
+    for (
+        const file
+        of [
+            "Dockerfile",
+            "dockerfile",
+        ]
+    ) {
+        if (
+            fs.existsSync(
+                path.join(
+                    rootDirectory,
+                    file
+                )
+            )
+        ) {
+            return file;
+        }
+    }
+
+    return null;
+}
+
+function collectFrameworkDeclarations(
+    projectPackage:
+        ProjectPackageJson | null
+): ProjectDiagnostics[
+    "frameworkDeclarations"
+] {
+    if (!projectPackage) {
+        return [];
+    }
+
+    const result:
+        ProjectDiagnostics[
+            "frameworkDeclarations"
+        ] = [];
+
+    for (
+        const [
+            section,
+            dependencies,
+        ]
+        of [
+            [
+                "dependencies",
+                projectPackage.dependencies,
+            ],
+            [
+                "devDependencies",
+                projectPackage.devDependencies,
+            ],
+        ] as const
+    ) {
+        if (!dependencies) {
+            continue;
+        }
+
+        for (
+            const name
+            of [
+                "bcp",
+                "@chidchanun/bcp",
+            ] as const
+        ) {
+            const range =
+                dependencies[name];
+
+            if (range) {
+                result.push({
+                    name,
+                    range,
+                    section,
+                });
+            }
+        }
+    }
+
+    return result;
+}
+
+function detectStorageProvider(
+    rootDirectory: string,
+    projectMetadata:
+        BcpProjectManifest | null
+): ProjectDiagnostics[
+    "storage"
+] {
+    const metadataStorage =
+        projectMetadata
+            ?.presets
+            ?.storage;
+
+    if (
+        metadataStorage === "none"
+    ) {
+        return {
+            provider:
+                "none",
+            file:
+                null,
+        };
+    }
+
+    if (
+        metadataStorage === "local" ||
+        metadataStorage === "amazon-s3" ||
+        metadataStorage === "cloudflare-r2"
+    ) {
+        return {
+            provider:
+                metadataStorage,
+            file:
+                "lib/storage.ts",
+        };
+    }
+
+    const relativeFile =
+        path.join(
+            "lib",
+            "storage.ts"
+        );
+    const file =
+        path.join(
+            rootDirectory,
+            relativeFile
+        );
+
+    if (
+        !fs.existsSync(
+            file
+        )
+    ) {
+        return {
+            provider:
+                "none",
+            file:
+                null,
+        };
+    }
+
+    const source =
+        fs.readFileSync(
+            file,
+            "utf8"
+        );
+
+    if (
+        /createLocalStorage\s*\(/.test(
+            source
+        )
+    ) {
+        return {
+            provider:
+                "local",
+            file:
+                "lib/storage.ts",
+        };
+    }
+
+    if (
+        /r2\.cloudflarestorage\.com/.test(
+            source
+        )
+    ) {
+        return {
+            provider:
+                "cloudflare-r2",
+            file:
+                "lib/storage.ts",
+        };
+    }
+
+    if (
+        /createS3Storage\s*\(/.test(
+            source
+        )
+    ) {
+        if (
+            /AWS_S3_BUCKET|AWS_REGION/.test(
+                source
+            )
+        ) {
+            return {
+                provider:
+                    "amazon-s3",
+                file:
+                    "lib/storage.ts",
+            };
+        }
+
+        return {
+            provider:
+                "s3-compatible",
+            file:
+                "lib/storage.ts",
+        };
+    }
+
+    return {
+        provider:
+            "custom",
+        file:
+            "lib/storage.ts",
+    };
+}
+
+function readProjectMetadata(
+    rootDirectory: string
+): {
+    file: string | null;
+    manifest: BcpProjectManifest | null;
+} {
+    const fileName =
+        "bcp.project.json";
+    const file =
+        path.join(
+            rootDirectory,
+            fileName
+        );
+
+    if (
+        !fs.existsSync(
+            file
+        )
+    ) {
+        return {
+            file:
+                null,
+            manifest:
+                null,
+        };
+    }
+
+    try {
+        const value =
+            JSON.parse(
+                fs.readFileSync(
+                    file,
+                    "utf8"
+                )
+            ) as BcpProjectManifest;
+
+        return {
+            file:
+                fileName,
+            manifest:
+                value &&
+                typeof value === "object"
+                    ? value
+                    : null,
+        };
+    } catch {
+        return {
+            file:
+                fileName,
+            manifest:
+                null,
+        };
+    }
+}
+
+function normalizePresetMetadata(
+    manifest:
+        BcpProjectManifest | null
+): ProjectPresetMetadata | null {
+    if (
+        manifest?.schemaVersion !== 1 ||
+        !manifest.presets ||
+        typeof manifest.presets !==
+            "object"
+    ) {
+        return null;
+    }
+
+    return {
+        tailwind:
+            typeof manifest.presets
+                .tailwind ===
+            "boolean"
+                ? manifest.presets
+                    .tailwind
+                : null,
+        database:
+            typeof manifest.presets
+                .database ===
+            "string"
+                ? manifest.presets
+                    .database
+                : null,
+        auth:
+            typeof manifest.presets
+                .auth ===
+            "string"
+                ? manifest.presets
+                    .auth
+                : null,
+        storage:
+            typeof manifest.presets
+                .storage ===
+            "string"
+                ? manifest.presets
+                    .storage
+                : null,
+    };
+}
+
+function readProjectPackage(
+    packageFile: string
+): ProjectPackageJson | null {
+    if (
+        !fs.existsSync(
+            packageFile
+        )
+    ) {
+        return null;
+    }
+
+    try {
+        const value =
+            JSON.parse(
+                fs.readFileSync(
+                    packageFile,
+                    "utf8"
+                )
+            );
+
+        return (
+            value &&
+            typeof value === "object" &&
+            !Array.isArray(
+                value
+            )
+        )
+            ? value as
+                ProjectPackageJson
+            : null;
+    } catch {
+        return null;
+    }
+}