@chidchanun/bcp 0.1.28 → 0.2.0

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

@@ -19,6 +19,10 @@ import {
   scanApiRoutes,
   scanRoutes,
 } from "../../router/src/index.js";
+import {
+  collectProjectDiagnostics,
+  type ProjectDiagnostics,
+} from "./developer-tools-v2.js";
 
 export type DoctorStatus =
   | "pass"
@@ -56,6 +60,7 @@ export interface InspectReport {
     platform: NodeJS.Platform;
     arch: string;
   };
+  project: ProjectDiagnostics;
   environment: {
     mode: "development";
     files: string[];
@@ -264,6 +269,90 @@ export async function collectDoctorReport(
     }
   }
 
+  const diagnostics =
+    collectProjectDiagnostics(
+      rootDirectory
+    );
+
+  addCheck(
+    checks,
+    "project.lockfile",
+    diagnostics.lockfile
+      ? "pass"
+      : "warn",
+    "Dependency lockfile",
+    diagnostics.lockfile
+      ? `${diagnostics.lockfile} detected (${diagnostics.packageManager ?? "unknown package manager"}).`
+      : "No supported dependency lockfile was found. Reproducible installs are recommended for CI and Docker."
+  );
+
+  addCheck(
+    checks,
+    "dependencies.framework-declarations",
+    diagnostics.frameworkDeclarations.length <= 1
+      ? "pass"
+      : "fail",
+    "Framework dependency declarations",
+    diagnostics.frameworkDeclarations.length === 0
+      ? "No BCP dependency declaration detected yet."
+      : diagnostics.frameworkDeclarations.length === 1
+        ? `${diagnostics.frameworkDeclarations[0].name} is declared once in ${diagnostics.frameworkDeclarations[0].section}.`
+        : `Multiple BCP declarations detected: ${diagnostics.frameworkDeclarations.map((item) => `${item.name} (${item.section})`).join(", ")}. Keep only the application dependency key bcp.`
+  );
+
+  addCheck(
+    checks,
+    "runtime.production-hardening",
+    diagnostics.hardening.valid
+      ? "pass"
+      : "fail",
+    "Production hardening configuration",
+    diagnostics.hardening.message
+  );
+
+  addCheck(
+    checks,
+    "production.build",
+    diagnostics.productionBuild
+      ? "pass"
+      : "warn",
+    "Standalone production artifact",
+    diagnostics.productionBuild
+      ? ".bcp-framework/build/server/server.mjs is present."
+      : "No standalone production artifact is present. Run `bcp build` before production deployment."
+  );
+
+  if (
+    diagnostics.dockerfile
+  ) {
+    addCheck(
+      checks,
+      "production.docker-lockfile",
+      diagnostics.lockfile ===
+        "package-lock.json"
+        ? "pass"
+        : "warn",
+      "Docker reproducible install",
+      diagnostics.lockfile ===
+        "package-lock.json"
+        ? `${diagnostics.dockerfile} and package-lock.json are present for npm ci.`
+        : `${diagnostics.dockerfile} is present but package-lock.json was not detected. Ensure the Dockerfile uses the matching package-manager lockfile.`
+    );
+  }
+
+  if (
+    diagnostics.storage.provider !==
+    "none"
+  ) {
+    addCheck(
+      checks,
+      "storage.provider",
+      "pass",
+      "Storage provider",
+      `${diagnostics.storage.provider} detected from ${diagnostics.storage.file}.`
+    );
+  }
+
   const appDirectory =
     path.join(
       rootDirectory,
@@ -687,6 +776,10 @@ export async function collectInspectReport(
       arch:
         process.arch,
     },
+    project:
+      collectProjectDiagnostics(
+        rootDirectory
+      ),
     environment: {
       mode:
         "development",
@@ -832,6 +925,28 @@ function printInspectReport(
     `Runtime: Node.js ${report.runtime.node} | ${report.runtime.platform} ${report.runtime.arch}`
   );
   console.log("");
+  console.log(
+    "Project diagnostics:"
+  );
+  console.log(
+    `  package manager: ${report.project.packageManager ?? "unknown"}`
+  );
+  console.log(
+    `  lockfile: ${report.project.lockfile ?? "(none)"}`
+  );
+  console.log(
+    `  production build: ${report.project.productionBuild ? "present" : "missing"}`
+  );
+  console.log(
+    `  Dockerfile: ${report.project.dockerfile ?? "(none)"}`
+  );
+  console.log(
+    `  storage: ${report.project.storage.provider}${report.project.storage.file ? ` (${report.project.storage.file})` : ""}`
+  );
+  console.log(
+    `  hardening: ${report.project.hardening.valid ? "valid" : "invalid"} - ${report.project.hardening.message}`
+  );
+  console.log("");
   console.log(
     "Environment:"
   );

package/packages/cli/src/generate.ts

@@ -0,0 +1,475 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import {
+    runDatabaseMigrationCommand,
+} from "./database-migrations.js";
+
+export type GenerateKind =
+    | "page"
+    | "api"
+    | "middleware"
+    | "migration";
+
+export interface GenerateOptions {
+    rootDirectory: string;
+    kind: GenerateKind;
+    name?: string;
+    force?: boolean;
+}
+
+export interface GeneratedArtifact {
+    kind: GenerateKind;
+    file: string;
+    route?: string;
+}
+
+export async function runGenerate(
+    options: GenerateOptions
+): Promise<GeneratedArtifact> {
+    const rootDirectory =
+        path.resolve(
+            options.rootDirectory
+        );
+
+    switch (options.kind) {
+        case "page":
+            return generatePage(
+                rootDirectory,
+                requireGenerateName(
+                    options.kind,
+                    options.name
+                ),
+                options.force === true
+            );
+
+        case "api":
+            return generateApiRoute(
+                rootDirectory,
+                requireGenerateName(
+                    options.kind,
+                    options.name
+                ),
+                options.force === true
+            );
+
+        case "middleware":
+            return generateMiddleware(
+                rootDirectory,
+                options.force === true
+            );
+
+        case "migration": {
+            const name =
+                requireGenerateName(
+                    options.kind,
+                    options.name
+                );
+            const migrationDirectory =
+                path.join(
+                    rootDirectory,
+                    "migrations"
+                );
+            const before =
+                listFiles(
+                    migrationDirectory
+                );
+
+            await runDatabaseMigrationCommand({
+                rootDirectory,
+                action:
+                    "create",
+                name,
+            });
+
+            const after =
+                listFiles(
+                    migrationDirectory
+                );
+            let created:
+                string | undefined;
+
+            for (const file of after) {
+                if (
+                    !before.has(
+                        file
+                    )
+                ) {
+                    created =
+                        file;
+                    break;
+                }
+            }
+
+            if (!created) {
+                throw new Error(
+                    "BCP Generate: migration command completed without creating a migration file."
+                );
+            }
+
+            return {
+                kind:
+                    "migration",
+                file:
+                    path.join(
+                        migrationDirectory,
+                        created
+                    ),
+            };
+        }
+    }
+}
+
+export function normalizeGenerateRoute(
+    value: string
+): string {
+    const normalized =
+        value
+            .trim()
+            .replace(
+                /\\/g,
+                "/"
+            )
+            .replace(
+                /^\/+|\/+$/g,
+                ""
+            );
+
+    if (!normalized) {
+        throw new Error(
+            "BCP Generate: route must not be empty."
+        );
+    }
+
+    const segments =
+        normalized.split(
+            "/"
+        );
+
+    for (const segment of segments) {
+        if (
+            !segment ||
+            segment === "." ||
+            segment === ".." ||
+            segment.includes(
+                "\0"
+            )
+        ) {
+            throw new Error(
+                `BCP Generate: invalid route segment "${segment}".`
+            );
+        }
+
+        if (
+            !/^(?:\([A-Za-z0-9_-]+\)|\[\[\.\.\.[A-Za-z0-9_-]+\]\]|\[\.\.\.[A-Za-z0-9_-]+\]|\[[A-Za-z0-9_-]+\]|[A-Za-z0-9_-]+)$/.test(
+                segment
+            )
+        ) {
+            throw new Error(
+                `BCP Generate: invalid route segment "${segment}".`
+            );
+        }
+    }
+
+    return segments.join(
+        "/"
+    );
+}
+
+function generatePage(
+    rootDirectory: string,
+    routeValue: string,
+    force: boolean
+): GeneratedArtifact {
+    const route =
+        normalizeGenerateRoute(
+            routeValue
+        );
+    const file =
+        path.join(
+            rootDirectory,
+            "app",
+            ...route.split("/"),
+            "page.tsx"
+        );
+    const componentName =
+        `${routeToIdentifier(route)}Page`;
+    const title =
+        routeToTitle(
+            route
+        );
+
+    writeGeneratedFile(
+        file,
+        `export default function ${componentName}() {\n    return (\n        <main>\n            <h1>${escapeJsxText(title)}</h1>\n        </main>\n    );\n}\n`,
+        force
+    );
+
+    printGenerated(
+        rootDirectory,
+        "page",
+        file,
+        `/${route}`
+    );
+
+    return {
+        kind:
+            "page",
+        file,
+        route:
+            `/${route}`,
+    };
+}
+
+function generateApiRoute(
+    rootDirectory: string,
+    routeValue: string,
+    force: boolean
+): GeneratedArtifact {
+    const normalized =
+        normalizeGenerateRoute(
+            routeValue
+        );
+    const route =
+        normalized.startsWith(
+            "api/"
+        )
+            ? normalized.slice(
+                "api/".length
+            )
+            : normalized;
+
+    if (!route) {
+        throw new Error(
+            "BCP Generate: API route must include a path after api/."
+        );
+    }
+
+    const file =
+        path.join(
+            rootDirectory,
+            "app",
+            "api",
+            ...route.split("/"),
+            "route.ts"
+        );
+
+    writeGeneratedFile(
+        file,
+        `export async function GET() {\n    return Response.json({\n        ok: true,\n    });\n}\n`,
+        force
+    );
+
+    printGenerated(
+        rootDirectory,
+        "api",
+        file,
+        `/api/${route}`
+    );
+
+    return {
+        kind:
+            "api",
+        file,
+        route:
+            `/api/${route}`,
+    };
+}
+
+function generateMiddleware(
+    rootDirectory: string,
+    force: boolean
+): GeneratedArtifact {
+    const file =
+        path.join(
+            rootDirectory,
+            "middleware.ts"
+        );
+
+    writeGeneratedFile(
+        file,
+        `import type {\n    MiddlewarePipelineHandler,\n} from "bcp/middleware";\n\nexport const middleware:\n    MiddlewarePipelineHandler =\n    async (\n        _request,\n        next\n    ) => {\n        return next();\n    };\n`,
+        force
+    );
+
+    printGenerated(
+        rootDirectory,
+        "middleware",
+        file
+    );
+
+    return {
+        kind:
+            "middleware",
+        file,
+    };
+}
+
+function writeGeneratedFile(
+    file: string,
+    content: string,
+    force: boolean
+): void {
+    if (
+        fs.existsSync(
+            file
+        ) &&
+        !force
+    ) {
+        throw new Error(
+            `BCP Generate: ${file} already exists. Pass --force to replace it.`
+        );
+    }
+
+    fs.mkdirSync(
+        path.dirname(
+            file
+        ),
+        {
+            recursive: true,
+        }
+    );
+    fs.writeFileSync(
+        file,
+        content,
+        "utf8"
+    );
+}
+
+function requireGenerateName(
+    kind: GenerateKind,
+    value: string | undefined
+): string {
+    const normalized =
+        value?.trim();
+
+    if (!normalized) {
+        throw new Error(
+            `BCP Generate: ${kind} requires a name or route.`
+        );
+    }
+
+    return normalized;
+}
+
+function routeToIdentifier(
+    route: string
+): string {
+    const words =
+        route
+            .replace(
+                /[\[\]().]+/g,
+                " "
+            )
+            .split(
+                /[\/_-]+|\s+/g
+            )
+            .filter(Boolean)
+            .map(
+                capitalize
+            );
+
+    const value =
+        words.join("") ||
+        "Generated";
+
+    return /^\d/.test(
+        value
+    )
+        ? `Route${value}`
+        : value;
+}
+
+function routeToTitle(
+    route: string
+): string {
+    const segment =
+        route
+            .split("/")
+            .filter(
+                (value) =>
+                    !value.startsWith("(")
+            )
+            .at(-1) ??
+        route;
+    const cleaned =
+        segment
+            .replace(
+                /^\[+|\]+$/g,
+                ""
+            )
+            .replace(
+                /^\.\.\./,
+                ""
+            )
+            .replace(
+                /[-_]+/g,
+                " "
+            )
+            .trim();
+
+    return cleaned
+        .split(/\s+/)
+        .filter(Boolean)
+        .map(capitalize)
+        .join(" ") ||
+        "Generated Page";
+}
+
+function capitalize(
+    value: string
+): string {
+    return value.length === 0
+        ? value
+        : value[0].toUpperCase() +
+            value.slice(1);
+}
+
+function escapeJsxText(
+    value: string
+): string {
+    return value
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/{/g, "&#123;")
+        .replace(/}/g, "&#125;");
+}
+
+function listFiles(
+    directory: string
+): Set<string> {
+    if (
+        !fs.existsSync(
+            directory
+        )
+    ) {
+        return new Set();
+    }
+
+    return new Set(
+        fs.readdirSync(
+            directory
+        )
+    );
+}
+
+function printGenerated(
+    rootDirectory: string,
+    kind: GenerateKind,
+    file: string,
+    route?: string
+): void {
+    const relative =
+        path.relative(
+            rootDirectory,
+            file
+        ).replace(
+            /\\/g,
+            "/"
+        );
+
+    console.log(
+        `[BCP Generate] ${kind}: ${relative}${route ? ` -> ${route}` : ""}`
+    );
+}

package/packages/cli/src/index.ts

@@ -71,6 +71,11 @@ switch (cliOptions.command) {
     break;
   }
 
+  case "generate": {
+    await runGenerateCommand();
+    break;
+  }
+
   case "doctor": {
     await runDeveloperCommand(
       "doctor"
@@ -480,6 +485,39 @@ async function runDatabaseCommand() {
   }
 }
 
+async function runGenerateCommand(): Promise<void> {
+  const kind =
+    cliOptions.generateKind;
+
+  if (
+    kind === undefined ||
+    kind === "help"
+  ) {
+    printGenerateHelp();
+    return;
+  }
+
+  const rootDirectory =
+    resolveProjectRoot(
+      cliOptions.rootDirectory
+    );
+  const {
+    runGenerate,
+  } =
+    await import(
+      "./generate.js"
+    );
+
+  await runGenerate({
+    rootDirectory,
+    kind,
+    name:
+      cliOptions.generateName,
+    force:
+      cliOptions.force,
+  });
+}
+
 async function runDeveloperCommand(
   command:
     "doctor" |
@@ -695,6 +733,32 @@ Examples:
 `);
 }
 
+function printGenerateHelp() {
+  console.log(`
+BCP Project Generators
+
+Usage:
+  bcp generate <kind> [name-or-route] [--force]
+
+Generators:
+  page <route>         Create app/<route>/page.tsx
+  api <route>          Create app/api/<route>/route.ts
+  middleware           Create middleware.ts in the project root
+  migration <name>     Create a timestamped migration in migrations/
+
+Options:
+  --force              Replace an existing page/API/middleware scaffold
+  --root <path>        Project root directory
+
+Examples:
+  bcp generate page dashboard/users
+  bcp generate page users/[id]
+  bcp generate api users
+  bcp generate middleware
+  bcp generate migration create_users
+`);
+}
+
 function printHelp() {
   console.log(`
 BCP Framework v${FRAMEWORK_VERSION}
@@ -709,6 +773,7 @@ Commands:
   routes             Print discovered page and API routes
   update [target]    Update BCP Framework (default target: latest)
   db <command>       Manage database migrations
+  generate <kind>    Generate pages, API routes, middleware or migrations
   doctor             Run project/runtime health diagnostics
   inspect            Print resolved env, config, dependencies and routes
   help               Show this help message
@@ -722,6 +787,7 @@ Options:
   --check               Check for a BCP update without changing files
   --dry-run             Preview a BCP update without changing files
   --json                JSON output for doctor/inspect
+  --force               Replace existing generated scaffold files
   -h, --help            Show help
   -v, --version         Show version
 
@@ -734,6 +800,9 @@ Examples:
   bcp build
   bcp start
   bcp routes
+  bcp generate page dashboard/users
+  bcp generate api users
+  bcp generate middleware
   bcp doctor
   bcp doctor --json
   bcp inspect