@expressots/cli 3.0.0 → 4.0.0-preview.3

package/bin/containerize/analyzers/project-analyzer.js

@@ -0,0 +1,150 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeProject = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const compiler_1 = __importDefault(require("../../utils/compiler"));
+const bootstrap_analyzer_1 = require("./bootstrap-analyzer");
+async function analyzeProject() {
+    const cwd = process.cwd();
+    const packageJsonPath = path_1.default.join(cwd, "package.json");
+    if (!fs_1.default.existsSync(packageJsonPath)) {
+        throw new Error("package.json not found in current directory");
+    }
+    const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, "utf-8"));
+    // Detect Node version
+    const nodeVersion = packageJson.engines?.node || process.version.replace("v", "");
+    // Detect package manager
+    const packageManager = detectPackageManager(cwd);
+    // Get dependencies
+    const dependencies = Object.keys(packageJson.dependencies || {});
+    const devDependencies = Object.keys(packageJson.devDependencies || {});
+    // Detect local file dependencies
+    const allDeps = {
+        ...packageJson.dependencies,
+        ...packageJson.devDependencies,
+    };
+    const localDependencyPaths = [];
+    let hasLocalDependencies = false;
+    for (const [name, version] of Object.entries(allDeps)) {
+        if (typeof version === "string" && version.startsWith("file:")) {
+            hasLocalDependencies = true;
+            const relativePath = version.replace("file:", "");
+            localDependencyPaths.push(relativePath);
+        }
+    }
+    // Detect database
+    const hasDatabase = dependencies.some((dep) => dep.includes("pg") ||
+        dep.includes("mysql") ||
+        dep.includes("mongodb") ||
+        dep.includes("prisma") ||
+        dep.includes("typeorm"));
+    // Detect Redis
+    const hasRedis = dependencies.some((dep) => dep.includes("redis") || dep.includes("ioredis"));
+    // Detect CORS
+    const hasCors = dependencies.some((dep) => dep.includes("cors"));
+    // Find controllers
+    const controllers = await findControllers(cwd);
+    // Detect health check paths
+    const healthCheckPaths = await detectHealthCheckPaths(cwd);
+    // Estimate resources
+    const estimatedMemory = estimateMemoryUsage(dependencies);
+    const estimatedCpu = "250m"; // Default conservative estimate
+    // Detect port
+    const port = await detectPort(cwd);
+    // Analyze bootstrap configuration
+    const bootstrapConfig = await (0, bootstrap_analyzer_1.analyzeBootstrapConfig)();
+    return {
+        nodeVersion,
+        packageManager,
+        dependencies,
+        devDependencies,
+        controllers,
+        hasDatabase,
+        hasRedis,
+        hasCors,
+        estimatedMemory,
+        estimatedCpu,
+        healthCheckPaths,
+        port,
+        hasLocalDependencies,
+        localDependencyPaths,
+        bootstrapConfig,
+    };
+}
+exports.analyzeProject = analyzeProject;
+function detectPackageManager(cwd) {
+    if (fs_1.default.existsSync(path_1.default.join(cwd, "pnpm-lock.yaml")))
+        return "pnpm";
+    if (fs_1.default.existsSync(path_1.default.join(cwd, "yarn.lock")))
+        return "yarn";
+    if (fs_1.default.existsSync(path_1.default.join(cwd, "bun.lockb")))
+        return "bun";
+    return "npm";
+}
+async function findControllers(cwd) {
+    const controllers = [];
+    const srcDir = path_1.default.join(cwd, "src");
+    if (!fs_1.default.existsSync(srcDir)) {
+        return controllers;
+    }
+    const findControllersRecursive = (dir) => {
+        const files = fs_1.default.readdirSync(dir);
+        for (const file of files) {
+            const fullPath = path_1.default.join(dir, file);
+            const stat = fs_1.default.statSync(fullPath);
+            if (stat.isDirectory()) {
+                findControllersRecursive(fullPath);
+            }
+            else if (file.endsWith(".controller.ts")) {
+                controllers.push(fullPath);
+            }
+        }
+    };
+    findControllersRecursive(srcDir);
+    return controllers;
+}
+async function detectHealthCheckPaths(cwd) {
+    const paths = [];
+    const controllers = await findControllers(cwd);
+    for (const controller of controllers) {
+        const content = fs_1.default.readFileSync(controller, "utf-8");
+        // Look for common health check patterns
+        if (content.includes("/health") || content.includes("health")) {
+            paths.push("/health");
+        }
+        if (content.includes("/ready") || content.includes("readiness")) {
+            paths.push("/ready");
+        }
+        if (content.includes("/live") || content.includes("liveness")) {
+            paths.push("/live");
+        }
+    }
+    // Remove duplicates
+    return [...new Set(paths)];
+}
+async function detectPort(cwd) {
+    try {
+        const config = await compiler_1.default.loadConfig();
+        // Check for port in config
+        // Default to 3000
+        return 3000;
+    }
+    catch {
+        return 3000;
+    }
+}
+function estimateMemoryUsage(dependencies) {
+    // Basic estimation based on dependency count
+    const depCount = dependencies.length;
+    if (depCount < 10)
+        return "128Mi";
+    if (depCount < 30)
+        return "256Mi";
+    if (depCount < 50)
+        return "512Mi";
+    return "1Gi";
+}

package/bin/containerize/cli.d.ts

@@ -0,0 +1,4 @@
+import { CommandModule } from "yargs";
+type CommandModuleArgs = Record<string, never>;
+declare const containerize: () => CommandModule<CommandModuleArgs, any>;
+export { containerize };

package/bin/containerize/cli.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.containerize = void 0;
+const form_1 = require("./form");
+const containerize = () => {
+    return {
+        command: "containerize [target] [environment]",
+        describe: "Generate container configurations for your ExpressoTS application.",
+        aliases: ["ctr"],
+        builder: (yargs) => {
+            yargs.positional("target", {
+                choices: ["docker", "kubernetes", "k8s", "compose"],
+                describe: "Target platform for containerization",
+                type: "string",
+                default: "docker",
+            });
+            yargs.positional("environment", {
+                choices: [
+                    "development",
+                    "staging",
+                    "production",
+                    "all",
+                ],
+                describe: "Target environment",
+                type: "string",
+                alias: "env",
+                default: "production",
+            });
+            yargs.option("preset", {
+                choices: [
+                    "minimal",
+                    "secure",
+                    "fast-startup",
+                    "dev",
+                    "multi-arch",
+                    "standard",
+                ],
+                describe: "Container preset to use",
+                type: "string",
+                default: "standard",
+            });
+            yargs.option("analyze", {
+                describe: "Analyze project before generating",
+                type: "boolean",
+                default: true,
+            });
+            yargs.option("skip-compose", {
+                describe: "Skip docker-compose.yml generation",
+                type: "boolean",
+                default: false,
+            });
+            yargs.option("include-ci", {
+                describe: "Include CI/CD pipeline configuration",
+                type: "boolean",
+                default: false,
+            });
+            yargs.option("ci-platform", {
+                choices: [
+                    "github",
+                    "gitlab",
+                    "circleci",
+                    "jenkins",
+                    "bitbucket",
+                    "azure",
+                    "all",
+                ],
+                describe: "CI/CD platform to generate configuration for",
+                type: "string",
+                default: "github",
+            });
+            yargs.option("ci-strategy", {
+                choices: [
+                    "basic",
+                    "comprehensive",
+                    "security-focused",
+                ],
+                describe: "CI/CD pipeline strategy",
+                type: "string",
+                default: "comprehensive",
+            });
+            yargs.option("include-security-scans", {
+                describe: "Include security scanning (Trivy, Snyk)",
+                type: "boolean",
+                default: true,
+            });
+            yargs.option("include-e2e", {
+                describe: "Include end-to-end tests in CI pipeline",
+                type: "boolean",
+                default: false,
+            });
+            // `--deployment-strategy` was previously exposed here but
+            // the value was never read by the K8s generator. The dead
+            // flag was removed; re-introduce it together with a real
+            // implementation in `kubernetes-generator.ts`.
+            return yargs;
+        },
+        handler: async ({ target, environment, preset, analyze, skipCompose, includeCi, ciPlatform, ciStrategy, includeSecurityScans, includeE2e, }) => {
+            await (0, form_1.containerizeProject)({
+                target,
+                environment,
+                preset,
+                analyze,
+                skipCompose,
+                includeCi,
+                ciPlatform,
+                ciStrategy,
+                includeSecurityScans,
+                includeE2E: includeE2e,
+            });
+        },
+    };
+};
+exports.containerize = containerize;

package/bin/containerize/form.d.ts

@@ -0,0 +1,15 @@
+import { type CIPlatform, type CIStrategy } from "./generators/ci-generator";
+type ContainerizeOptions = {
+    target: string;
+    environment: string;
+    preset: string;
+    analyze: boolean;
+    skipCompose: boolean;
+    includeCi: boolean;
+    ciPlatform?: CIPlatform;
+    ciStrategy?: CIStrategy;
+    includeSecurityScans?: boolean;
+    includeE2E?: boolean;
+};
+export declare const containerizeProject: (options: ContainerizeOptions) => Promise<void>;
+export {};

package/bin/containerize/form.js

@@ -0,0 +1,152 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.containerizeProject = void 0;
+const process_1 = require("process");
+const chalk_1 = __importDefault(require("chalk"));
+const cli_ui_1 = require("../utils/cli-ui");
+const project_analyzer_1 = require("./analyzers/project-analyzer");
+const dockerfile_generator_1 = require("./generators/dockerfile-generator");
+const kubernetes_generator_1 = require("./generators/kubernetes-generator");
+const docker_compose_generator_1 = require("./generators/docker-compose-generator");
+const ci_generator_1 = require("./generators/ci-generator");
+const bootstrap_analyzer_1 = require("./analyzers/bootstrap-analyzer");
+const containerizeProject = async (options) => {
+    try {
+        (0, cli_ui_1.printSection)("🐳 ExpressoTS Containerization");
+        // Step 1: Analyze project (if enabled)
+        let analysis;
+        if (options.analyze) {
+            (0, cli_ui_1.printSection)("📊 Project Analysis");
+            analysis = await (0, project_analyzer_1.analyzeProject)();
+            (0, cli_ui_1.printKeyValue)("Node version", analysis.nodeVersion);
+            (0, cli_ui_1.printKeyValue)("Package manager", analysis.packageManager);
+            (0, cli_ui_1.printKeyValue)("Dependencies", String(analysis.dependencies.length));
+            (0, cli_ui_1.printKeyValue)("Controllers", String(analysis.controllers.length));
+            if (analysis.hasLocalDependencies) {
+                process_1.stdout.write("\n");
+                (0, cli_ui_1.printWarning)(`Detected ${analysis.localDependencyPaths.length} local file dependencies`, "containerize");
+                (0, cli_ui_1.printBullet)(chalk_1.default.gray("These will be copied into the Docker image. For production,"));
+                (0, cli_ui_1.printBullet)(chalk_1.default.gray("consider publishing to npm registry instead."));
+            }
+            printBootstrapAnalysis(analysis);
+        }
+        // Step 2: Generate based on target
+        switch (options.target) {
+            case "docker":
+                await (0, dockerfile_generator_1.generateDockerfiles)(options, analysis);
+                if (!options.skipCompose) {
+                    await (0, docker_compose_generator_1.generateDockerCompose)(options, analysis);
+                }
+                break;
+            case "kubernetes":
+            case "k8s":
+                await (0, dockerfile_generator_1.generateDockerfiles)(options, analysis);
+                await (0, kubernetes_generator_1.generateKubernetesConfigs)(options, analysis);
+                break;
+            case "compose":
+                // Compose `build:` blocks reference Dockerfiles by
+                // path (Dockerfile or Dockerfile.development), so the
+                // compose-only target must also emit them — otherwise
+                // `docker compose up --build` fails with "no such file
+                // or directory".
+                await (0, dockerfile_generator_1.generateDockerfiles)(options, analysis);
+                await (0, docker_compose_generator_1.generateDockerCompose)(options, analysis);
+                break;
+            default:
+                await (0, dockerfile_generator_1.generateDockerfiles)(options, analysis);
+                break;
+        }
+        // Step 3: Generate CI/CD config (if requested)
+        if (options.includeCi) {
+            await (0, ci_generator_1.generateCIConfig)(options, analysis);
+        }
+        // Step 4: Success message
+        process_1.stdout.write("\n");
+        (0, cli_ui_1.printSuccess)("Container configuration generated successfully", "containerize");
+        (0, cli_ui_1.printSection)("📋 Summary");
+        (0, cli_ui_1.printBullet)("Generated files are fully customizable");
+        (0, cli_ui_1.printBullet)("Edit them to fit your specific needs");
+        (0, cli_ui_1.printBullet)(`Run ${chalk_1.default.cyan("expressots container profile")} to optimize`);
+        (0, cli_ui_1.printSection)("📖 Next steps");
+        if (analysis?.hasLocalDependencies) {
+            const pm = analysis.packageManager;
+            (0, cli_ui_1.printBullet)(`Review generated files`);
+            (0, cli_ui_1.printBullet)(`Run setup: ${chalk_1.default.cyan(`${pm} run docker:setup`)}`);
+            (0, cli_ui_1.printBullet)(`Build: ${chalk_1.default.cyan("docker build -t myapp .")}`);
+            (0, cli_ui_1.printBullet)(`Run: ${chalk_1.default.cyan("docker compose up")}`);
+            process_1.stdout.write("\n");
+            (0, cli_ui_1.printWarning)("docker-setup.js copies local dependencies to .docker-deps/ for the Docker build context.", "containerize");
+        }
+        else {
+            (0, cli_ui_1.printBullet)("Review generated files");
+            (0, cli_ui_1.printBullet)("Customize as needed");
+            (0, cli_ui_1.printBullet)(`Build: ${chalk_1.default.cyan("docker build -t myapp .")}`);
+            (0, cli_ui_1.printBullet)(`Run: ${chalk_1.default.cyan("docker compose up")}`);
+        }
+        process_1.stdout.write("\n");
+    }
+    catch (error) {
+        (0, cli_ui_1.printError)(`Containerization failed: ${error instanceof Error ? error.message : String(error)}`, "containerize");
+        throw error;
+    }
+};
+exports.containerizeProject = containerizeProject;
+/**
+ * Print bootstrap configuration analysis and recommendations
+ */
+function printBootstrapAnalysis(analysis) {
+    const bootstrapConfig = analysis.bootstrapConfig;
+    if (!bootstrapConfig.hasEnvFileConfig) {
+        return; // No env file config, nothing to warn about
+    }
+    (0, cli_ui_1.printSection)("📋 Bootstrap Configuration");
+    // Show detected env file config
+    if (bootstrapConfig.skipFileLoading || bootstrapConfig.ciMode) {
+        (0, cli_ui_1.printSuccess)("Container-ready configuration detected", "bootstrap");
+        (0, cli_ui_1.printBullet)(chalk_1.default.gray(`Using ${bootstrapConfig.skipFileLoading ? "skipFileLoading" : "ciMode"} mode`));
+        return;
+    }
+    // Check if env files are needed
+    const copyEnvFiles = (0, bootstrap_analyzer_1.shouldCopyEnvFiles)(bootstrapConfig);
+    if (copyEnvFiles) {
+        (0, cli_ui_1.printWarning)("Environment file configuration detected", "bootstrap");
+        if (bootstrapConfig.existingEnvFiles.length > 0) {
+            (0, cli_ui_1.printBullet)(chalk_1.default.bold("Existing env files:"));
+            bootstrapConfig.existingEnvFiles.forEach((file) => {
+                (0, cli_ui_1.printBullet)(chalk_1.default.green(`  ✓ ${file}`));
+            });
+        }
+        if (bootstrapConfig.missingEnvFiles.length > 0) {
+            (0, cli_ui_1.printBullet)(chalk_1.default.bold("Missing env files:"));
+            bootstrapConfig.missingEnvFiles.forEach((file) => {
+                (0, cli_ui_1.printBullet)(chalk_1.default.red(`  ✗ ${file}`));
+            });
+        }
+        if (bootstrapConfig.requiredVariables.length > 0) {
+            (0, cli_ui_1.printBullet)(chalk_1.default.bold("Required variables:"));
+            bootstrapConfig.requiredVariables.forEach((varName) => {
+                (0, cli_ui_1.printBullet)(chalk_1.default.yellow(`  • ${varName}`));
+            });
+        }
+    }
+    // Show recommendations
+    if (bootstrapConfig.recommendations.length > 0) {
+        (0, cli_ui_1.printSection)("💡 Recommendations");
+        bootstrapConfig.recommendations.forEach((rec) => {
+            (0, cli_ui_1.printBullet)(rec);
+        });
+    }
+    // Special warning for missing required env files
+    if (!bootstrapConfig.isContainerReady) {
+        process_1.stdout.write("\n");
+        (0, cli_ui_1.printError)("Container may fail to start!", "bootstrap");
+        (0, cli_ui_1.printBullet)(chalk_1.default.gray("The bootstrap configuration requires env files that are missing."));
+        (0, cli_ui_1.printBullet)(chalk_1.default.gray("Options:"));
+        (0, cli_ui_1.printBullet)(chalk_1.default.gray("  1. Create the missing env files before building"));
+        (0, cli_ui_1.printBullet)(chalk_1.default.gray("  2. Update bootstrap to use skipFileLoading: true"));
+        (0, cli_ui_1.printBullet)(chalk_1.default.gray("  3. Set environment variables in docker-compose.yml"));
+    }
+}

package/bin/containerize/generators/ci-generator.d.ts

@@ -0,0 +1,31 @@
+import type { ProjectAnalysis } from "../analyzers/project-analyzer";
+export type CIPlatform = "github" | "gitlab" | "circleci" | "jenkins" | "bitbucket" | "azure" | "all";
+export type CIStrategy = "basic" | "comprehensive" | "security-focused";
+/**
+ * Note on naming and scope (see CLI Deployment Hardening Plan §6):
+ *
+ * This generator is the **CD half** of ExpressoTS' pipeline tooling.
+ * It is invoked by `expressots containerize --include-ci` and emits
+ * a Docker-centric workflow (build → push → deploy).
+ *
+ * The **CI half** is `expressots cicd init`, which writes a
+ * lint/test/coverage workflow at `.github/workflows/ci.yml` (and
+ * the canonical config files for other platforms).
+ *
+ * On GitHub Actions both files coexist (`ci.yml` + `cd-docker.yml`).
+ * Other platforms (GitLab, CircleCI, Jenkins, Bitbucket, Azure)
+ * only support a single canonical config file, so running both
+ * generators against those platforms would overwrite each other —
+ * we print a warning when that happens.
+ */
+type GeneratorOptions = {
+    environment: string;
+    preset: string;
+    ciPlatform?: CIPlatform;
+    ciStrategy?: CIStrategy;
+    includeSecurityScans?: boolean;
+    includeE2E?: boolean;
+    [key: string]: any;
+};
+export declare function generateCIConfig(options: GeneratorOptions, analysis?: ProjectAnalysis): Promise<void>;
+export {};