@expressots/cli 3.0.0 → 4.0.0-preview.2

package/bin/migrate/form.js

@@ -0,0 +1,347 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeMigration = exports.listMigrations = exports.generateMigration = exports.initMigration = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const platform_detector_1 = require("./analyzers/platform-detector");
+const generators_1 = require("./generators");
+const SUPPORTED_MIGRATIONS = [
+    {
+        from: "heroku",
+        to: "railway",
+        description: "Heroku to Railway",
+        complexity: "low",
+    },
+    {
+        from: "heroku",
+        to: "render",
+        description: "Heroku to Render",
+        complexity: "low",
+    },
+    {
+        from: "heroku",
+        to: "fly",
+        description: "Heroku to Fly.io",
+        complexity: "medium",
+    },
+    {
+        from: "heroku",
+        to: "kubernetes",
+        description: "Heroku to Kubernetes",
+        complexity: "high",
+    },
+    {
+        from: "docker-compose",
+        to: "kubernetes",
+        description: "Docker Compose to Kubernetes",
+        complexity: "medium",
+    },
+    {
+        from: "docker-compose",
+        to: "railway",
+        description: "Docker Compose to Railway",
+        complexity: "low",
+    },
+    {
+        from: "docker-compose",
+        to: "render",
+        description: "Docker Compose to Render",
+        complexity: "low",
+    },
+    {
+        from: "docker-compose",
+        to: "fly",
+        description: "Docker Compose to Fly.io",
+        complexity: "medium",
+    },
+    {
+        from: "vercel",
+        to: "railway",
+        description: "Vercel to Railway",
+        complexity: "low",
+    },
+    {
+        from: "vercel",
+        to: "render",
+        description: "Vercel to Render",
+        complexity: "low",
+    },
+    {
+        from: "aws-ecs",
+        to: "gcp-cloudrun",
+        description: "AWS ECS to GCP Cloud Run",
+        complexity: "high",
+    },
+    {
+        from: "aws-ecs",
+        to: "kubernetes",
+        description: "AWS ECS to Kubernetes",
+        complexity: "medium",
+    },
+    {
+        from: "gcp-cloudrun",
+        to: "aws-ecs",
+        description: "GCP Cloud Run to AWS ECS",
+        complexity: "high",
+    },
+];
+/**
+ * Interactive migration setup wizard
+ */
+async function initMigration(options) {
+    console.log(chalk_1.default.cyan("\n🚀 ExpressoTS Migration Wizard\n"));
+    // Detect current platform
+    const detected = await (0, platform_detector_1.detectCurrentPlatform)();
+    if (detected) {
+        console.log(chalk_1.default.green(`✓ Detected current platform: ${detected}`));
+    }
+    // Interactive prompts
+    const answers = await inquirer_1.default.prompt([
+        {
+            type: "list",
+            name: "from",
+            message: "Select source platform:",
+            choices: [
+                { name: "Heroku", value: "heroku" },
+                { name: "Docker Compose", value: "docker-compose" },
+                { name: "Vercel", value: "vercel" },
+                { name: "AWS ECS", value: "aws-ecs" },
+                { name: "GCP Cloud Run", value: "gcp-cloudrun" },
+                { name: "Azure Container Apps", value: "azure-container" },
+            ],
+            default: detected || "heroku",
+        },
+        {
+            type: "list",
+            name: "to",
+            message: "Select target platform:",
+            choices: (prev) => {
+                const migrations = SUPPORTED_MIGRATIONS.filter((m) => m.from === prev.from);
+                if (migrations.length === 0) {
+                    // Show all targets if no specific migrations defined
+                    return [
+                        { name: "Railway", value: "railway" },
+                        { name: "Render", value: "render" },
+                        { name: "Fly.io", value: "fly" },
+                        { name: "Kubernetes", value: "kubernetes" },
+                        { name: "AWS ECS", value: "aws-ecs" },
+                        { name: "GCP Cloud Run", value: "gcp-cloudrun" },
+                    ];
+                }
+                return migrations.map((m) => ({
+                    name: `${m.to.charAt(0).toUpperCase() + m.to.slice(1)} (${m.complexity} complexity)`,
+                    value: m.to,
+                }));
+            },
+        },
+        {
+            type: "confirm",
+            name: "includeSecrets",
+            message: "Include environment variable migration?",
+            default: true,
+        },
+        {
+            type: "confirm",
+            name: "includeData",
+            message: "Include data migration scripts?",
+            default: false,
+        },
+        {
+            type: "input",
+            name: "outputDir",
+            message: "Output directory for migration files:",
+            default: "./migration",
+        },
+    ]);
+    const migrationOptions = {
+        ...options,
+        from: answers.from,
+        to: answers.to,
+        includeSecrets: answers.includeSecrets,
+        includeData: answers.includeData,
+        outputDir: answers.outputDir,
+    };
+    await generateMigration(migrationOptions);
+}
+exports.initMigration = initMigration;
+/**
+ * Generate migration scripts
+ */
+async function generateMigration(options) {
+    if (!options.from || !options.to) {
+        console.log(chalk_1.default.red("Error: Please specify both --from and --to platforms."));
+        console.log(chalk_1.default.gray("Use 'expressots migrate list' to see available migrations."));
+        return;
+    }
+    console.log(chalk_1.default.cyan(`\n📦 Generating migration: ${options.from} → ${options.to}\n`));
+    // Create output directory
+    const outputDir = path_1.default.resolve(options.outputDir);
+    if (!options.dryRun) {
+        fs_1.default.mkdirSync(outputDir, { recursive: true });
+    }
+    // Find migration path
+    const migration = SUPPORTED_MIGRATIONS.find((m) => m.from === options.from && m.to === options.to);
+    if (options.dryRun) {
+        console.log(chalk_1.default.yellow("🔍 Dry run mode - showing migration steps:\n"));
+        printMigrationSteps(options, migration);
+        return;
+    }
+    // Generate migration files based on source/target
+    try {
+        await generateMigrationFiles(options, outputDir, migration);
+        console.log(chalk_1.default.green(`\n✅ Migration files generated in ${outputDir}\n`));
+        printNextSteps(options);
+    }
+    catch (error) {
+        console.log(chalk_1.default.red(`Error generating migration: ${error}`));
+    }
+}
+exports.generateMigration = generateMigration;
+/**
+ * List available migrations
+ */
+async function listMigrations() {
+    console.log(chalk_1.default.cyan("\n📋 Available Migration Paths\n"));
+    // Group by source
+    const bySource = SUPPORTED_MIGRATIONS.reduce((acc, m) => {
+        if (!acc[m.from])
+            acc[m.from] = [];
+        acc[m.from].push(m);
+        return acc;
+    }, {});
+    for (const [source, migrations] of Object.entries(bySource)) {
+        console.log(chalk_1.default.bold(`\nFrom ${source}:`));
+        for (const m of migrations) {
+            const complexityColor = m.complexity === "low"
+                ? chalk_1.default.green
+                : m.complexity === "medium"
+                    ? chalk_1.default.yellow
+                    : chalk_1.default.red;
+            console.log(`  → ${m.to.padEnd(20)} ${complexityColor(`[${m.complexity}]`)}`);
+        }
+    }
+    console.log(chalk_1.default.gray("\n\nUsage: expressots migrate generate --from <source> --to <target>"));
+    console.log(chalk_1.default.gray("       expressots migrate init (interactive wizard)\n"));
+}
+exports.listMigrations = listMigrations;
+/**
+ * Analyze migration complexity
+ */
+async function analyzeMigration(options) {
+    console.log(chalk_1.default.cyan("\n🔍 Migration Analysis\n"));
+    const detected = await (0, platform_detector_1.detectCurrentPlatform)();
+    const cwd = process.cwd();
+    console.log(chalk_1.default.bold("Current Setup:"));
+    console.log(`  Platform: ${detected || "Unknown"}`);
+    // Analyze project files
+    const hasDockerfile = fs_1.default.existsSync(path_1.default.join(cwd, "Dockerfile"));
+    const hasDockerCompose = fs_1.default.existsSync(path_1.default.join(cwd, "docker-compose.yml"));
+    const hasK8s = fs_1.default.existsSync(path_1.default.join(cwd, "k8s"));
+    const hasProcfile = fs_1.default.existsSync(path_1.default.join(cwd, "Procfile"));
+    const hasVercelConfig = fs_1.default.existsSync(path_1.default.join(cwd, "vercel.json"));
+    const hasRailwayConfig = fs_1.default.existsSync(path_1.default.join(cwd, "railway.json"));
+    console.log(`  Dockerfile: ${hasDockerfile ? chalk_1.default.green("✓") : chalk_1.default.gray("✗")}`);
+    console.log(`  Docker Compose: ${hasDockerCompose ? chalk_1.default.green("✓") : chalk_1.default.gray("✗")}`);
+    console.log(`  Kubernetes: ${hasK8s ? chalk_1.default.green("✓") : chalk_1.default.gray("✗")}`);
+    console.log(`  Procfile (Heroku): ${hasProcfile ? chalk_1.default.green("✓") : chalk_1.default.gray("✗")}`);
+    console.log(`  Vercel Config: ${hasVercelConfig ? chalk_1.default.green("✓") : chalk_1.default.gray("✗")}`);
+    console.log(`  Railway Config: ${hasRailwayConfig ? chalk_1.default.green("✓") : chalk_1.default.gray("✗")}`);
+    // Check for environment variables
+    const hasEnvFile = fs_1.default.existsSync(path_1.default.join(cwd, ".env"));
+    const hasEnvExample = fs_1.default.existsSync(path_1.default.join(cwd, ".env.example"));
+    console.log(chalk_1.default.bold("\nEnvironment:"));
+    console.log(`  .env file: ${hasEnvFile ? chalk_1.default.green("✓") : chalk_1.default.gray("✗")}`);
+    console.log(`  .env.example: ${hasEnvExample ? chalk_1.default.green("✓") : chalk_1.default.gray("✗")}`);
+    // Analyze package.json for dependencies
+    const packageJsonPath = path_1.default.join(cwd, "package.json");
+    if (fs_1.default.existsSync(packageJsonPath)) {
+        const pkg = JSON.parse(fs_1.default.readFileSync(packageJsonPath, "utf-8"));
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        console.log(chalk_1.default.bold("\nDependencies:"));
+        if (deps.pg || deps.postgres)
+            console.log("  Database: PostgreSQL");
+        if (deps.mysql || deps.mysql2)
+            console.log("  Database: MySQL");
+        if (deps.mongodb)
+            console.log("  Database: MongoDB");
+        if (deps.redis || deps.ioredis)
+            console.log("  Cache: Redis");
+    }
+    if (options.to) {
+        const migration = SUPPORTED_MIGRATIONS.find((m) => m.from === (detected || options.from) && m.to === options.to);
+        if (migration) {
+            console.log(chalk_1.default.bold(`\nMigration to ${options.to}:`));
+            console.log(`  Complexity: ${migration.complexity}`);
+            console.log(`  Description: ${migration.description}`);
+        }
+    }
+    console.log();
+}
+exports.analyzeMigration = analyzeMigration;
+/**
+ * Generate migration files based on source/target
+ */
+async function generateMigrationFiles(options, outputDir, migration) {
+    const { from, to } = options;
+    // Generate based on migration path
+    if (from === "heroku" && to === "railway") {
+        await (0, generators_1.generateHerokuToRailway)(outputDir, options);
+    }
+    else if (from === "heroku" && to === "render") {
+        await (0, generators_1.generateHerokuToRender)(outputDir, options);
+    }
+    else if (from === "heroku" && to === "fly") {
+        await (0, generators_1.generateHerokuToFly)(outputDir, options);
+    }
+    else if (from === "docker-compose" && to === "kubernetes") {
+        await (0, generators_1.generateComposeToK8s)(outputDir, options);
+    }
+    else if (from === "docker-compose" && to === "railway") {
+        await (0, generators_1.generateComposeToRailway)(outputDir, options);
+    }
+    else if (from === "docker-compose" && to === "render") {
+        await (0, generators_1.generateComposeToRender)(outputDir, options);
+    }
+    else {
+        // Generic migration
+        await (0, generators_1.generateGenericMigration)(outputDir, options, migration);
+    }
+}
+/**
+ * Print migration steps for dry run
+ */
+function printMigrationSteps(options, migration) {
+    console.log(chalk_1.default.bold(`Migration: ${options.from} → ${options.to}`));
+    console.log(`Complexity: ${migration?.complexity || "unknown"}`);
+    console.log();
+    console.log(chalk_1.default.bold("Steps:"));
+    console.log("  1. Generate target platform configuration");
+    console.log("  2. Create environment variable mapping");
+    if (options.includeSecrets) {
+        console.log("  3. Generate secrets migration script");
+    }
+    if (options.includeData) {
+        console.log("  4. Generate data migration scripts");
+    }
+    console.log("  5. Create migration checklist (README.md)");
+    console.log();
+}
+/**
+ * Print next steps after migration
+ */
+function printNextSteps(options) {
+    console.log(chalk_1.default.bold("📖 Next Steps:"));
+    console.log(`  1. Review the migration files in ${options.outputDir}`);
+    console.log("  2. Check the MIGRATION_CHECKLIST.md for step-by-step instructions");
+    console.log("  3. Set up environment variables on the target platform");
+    if (options.includeData) {
+        console.log("  4. Review and run data migration scripts carefully");
+    }
+    console.log("  5. Test the deployment in a staging environment first");
+    console.log();
+}

package/bin/migrate/generators/compose-to-k8s.d.ts

@@ -0,0 +1,2 @@
+import type { MigrationOptions } from "../form";
+export declare function generateComposeToK8s(outputDir: string, options: MigrationOptions): Promise<void>;

package/bin/migrate/generators/compose-to-k8s.js

@@ -0,0 +1,324 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateComposeToK8s = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const template_loader_1 = require("./template-loader");
+async function generateComposeToK8s(outputDir, options) {
+    console.log(chalk_1.default.yellow("  Generating Docker Compose → Kubernetes migration..."));
+    const vars = (0, template_loader_1.buildMigrationVars)(options);
+    const k8sDir = path_1.default.join(outputDir, "k8s");
+    fs_1.default.mkdirSync(k8sDir, { recursive: true });
+    // Generate deployment.yaml
+    const deployment = generateDeployment();
+    fs_1.default.writeFileSync(path_1.default.join(k8sDir, "deployment.yaml"), deployment, "utf-8");
+    console.log(chalk_1.default.green("    ✓ Created k8s/deployment.yaml"));
+    // Generate service.yaml
+    const service = generateService();
+    fs_1.default.writeFileSync(path_1.default.join(k8sDir, "service.yaml"), service, "utf-8");
+    console.log(chalk_1.default.green("    ✓ Created k8s/service.yaml"));
+    // Generate configmap.yaml
+    const configMap = generateConfigMap();
+    fs_1.default.writeFileSync(path_1.default.join(k8sDir, "configmap.yaml"), configMap, "utf-8");
+    console.log(chalk_1.default.green("    ✓ Created k8s/configmap.yaml"));
+    // Generate secrets.yaml template
+    const secrets = generateSecrets();
+    fs_1.default.writeFileSync(path_1.default.join(k8sDir, "secrets.yaml"), secrets, "utf-8");
+    console.log(chalk_1.default.green("    ✓ Created k8s/secrets.yaml"));
+    // Generate ingress.yaml
+    const ingress = generateIngress();
+    fs_1.default.writeFileSync(path_1.default.join(k8sDir, "ingress.yaml"), ingress, "utf-8");
+    console.log(chalk_1.default.green("    ✓ Created k8s/ingress.yaml"));
+    // Generate kustomization.yaml
+    const kustomization = generateKustomization();
+    fs_1.default.writeFileSync(path_1.default.join(k8sDir, "kustomization.yaml"), kustomization, "utf-8");
+    console.log(chalk_1.default.green("    ✓ Created k8s/kustomization.yaml"));
+    // Generate migration checklist
+    const checklist = generateK8sChecklist();
+    fs_1.default.writeFileSync(path_1.default.join(outputDir, "MIGRATION_CHECKLIST.md"), checklist, "utf-8");
+    console.log(chalk_1.default.green("    ✓ Created MIGRATION_CHECKLIST.md"));
+    // Generate kompose command reference
+    const komposeRef = generateKomposeReference();
+    fs_1.default.writeFileSync(path_1.default.join(outputDir, "kompose-reference.md"), komposeRef, "utf-8");
+    console.log(chalk_1.default.green("    ✓ Created kompose-reference.md"));
+}
+exports.generateComposeToK8s = generateComposeToK8s;
+function generateDeployment() {
+    return `# Kubernetes Deployment
+# Generated by ExpressoTS CLI
+# Migrated from Docker Compose
+
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: expressots-app
+  labels:
+    app: expressots-app
+spec:
+  replicas: 2
+  selector:
+    matchLabels:
+      app: expressots-app
+  template:
+    metadata:
+      labels:
+        app: expressots-app
+    spec:
+      containers:
+        - name: app
+          image: your-registry/expressots-app:latest
+          ports:
+            - containerPort: 3000
+          envFrom:
+            - configMapRef:
+                name: expressots-config
+            - secretRef:
+                name: expressots-secrets
+          resources:
+            requests:
+              memory: "128Mi"
+              cpu: "100m"
+            limits:
+              memory: "512Mi"
+              cpu: "500m"
+          livenessProbe:
+            httpGet:
+              path: /health
+              port: 3000
+            initialDelaySeconds: 30
+            periodSeconds: 10
+          readinessProbe:
+            httpGet:
+              path: /health
+              port: 3000
+            initialDelaySeconds: 5
+            periodSeconds: 5
+      imagePullSecrets:
+        - name: registry-credentials
+`;
+}
+function generateService() {
+    return `# Kubernetes Service
+# Generated by ExpressoTS CLI
+
+apiVersion: v1
+kind: Service
+metadata:
+  name: expressots-app-service
+  labels:
+    app: expressots-app
+spec:
+  type: ClusterIP
+  ports:
+    - port: 80
+      targetPort: 3000
+      protocol: TCP
+      name: http
+  selector:
+    app: expressots-app
+`;
+}
+function generateConfigMap() {
+    return `# Kubernetes ConfigMap
+# Generated by ExpressoTS CLI
+# Non-sensitive configuration values
+
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: expressots-config
+data:
+  NODE_ENV: "production"
+  PORT: "3000"
+  # Add your non-sensitive config values here
+`;
+}
+function generateSecrets() {
+    return `# Kubernetes Secrets
+# Generated by ExpressoTS CLI
+# ⚠️ DO NOT commit this file with real values!
+# Use: kubectl create secret generic expressots-secrets --from-env-file=.env
+
+apiVersion: v1
+kind: Secret
+metadata:
+  name: expressots-secrets
+type: Opaque
+stringData:
+  DATABASE_URL: "postgresql://user:pass@host:5432/db"
+  API_KEY: "your-api-key"
+  # Add your sensitive values here
+  # In production, use sealed-secrets or external-secrets
+`;
+}
+function generateIngress() {
+    return `# Kubernetes Ingress
+# Generated by ExpressoTS CLI
+
+apiVersion: networking.k8s.io/v1
+kind: Ingress
+metadata:
+  name: expressots-ingress
+  annotations:
+    kubernetes.io/ingress.class: nginx
+    cert-manager.io/cluster-issuer: letsencrypt-prod
+spec:
+  tls:
+    - hosts:
+        - your-domain.com
+      secretName: expressots-tls
+  rules:
+    - host: your-domain.com
+      http:
+        paths:
+          - path: /
+            pathType: Prefix
+            backend:
+              service:
+                name: expressots-app-service
+                port:
+                  number: 80
+`;
+}
+function generateKustomization() {
+    return `# Kustomization
+# Generated by ExpressoTS CLI
+
+apiVersion: kustomize.config.k8s.io/v1beta1
+kind: Kustomization
+
+resources:
+  - deployment.yaml
+  - service.yaml
+  - configmap.yaml
+  - secrets.yaml
+  - ingress.yaml
+
+commonLabels:
+  app.kubernetes.io/name: expressots-app
+  app.kubernetes.io/managed-by: kustomize
+`;
+}
+function generateK8sChecklist() {
+    return `# Migration Checklist: Docker Compose → Kubernetes
+
+## Pre-Migration
+
+- [ ] Ensure kubectl is installed and configured
+- [ ] Have access to a Kubernetes cluster
+- [ ] Push Docker image to container registry
+
+## Automatic Conversion (Optional)
+
+Use Kompose for automatic conversion:
+\`\`\`bash
+kompose convert -f docker-compose.yml -o k8s/
+\`\`\`
+
+## Manual Migration Steps
+
+1. **Deployment**
+   - [ ] Update image name in deployment.yaml
+   - [ ] Adjust replica count
+   - [ ] Configure resource limits
+
+2. **Configuration**
+   - [ ] Add non-sensitive values to configmap.yaml
+   - [ ] Add sensitive values to secrets.yaml
+   - [ ] Never commit secrets with real values!
+
+3. **Networking**
+   - [ ] Configure Service (ClusterIP, LoadBalancer, NodePort)
+   - [ ] Set up Ingress for external access
+   - [ ] Configure TLS/SSL certificates
+
+4. **Storage (if needed)**
+   - [ ] Create PersistentVolumeClaims for data
+   - [ ] Mount volumes in deployment
+
+## Deployment
+
+\`\`\`bash
+# Apply all resources
+kubectl apply -k k8s/
+
+# Or apply individually
+kubectl apply -f k8s/configmap.yaml
+kubectl apply -f k8s/secrets.yaml
+kubectl apply -f k8s/deployment.yaml
+kubectl apply -f k8s/service.yaml
+kubectl apply -f k8s/ingress.yaml
+\`\`\`
+
+## Verification
+
+\`\`\`bash
+kubectl get pods
+kubectl get services
+kubectl get ingress
+kubectl logs -f deployment/expressots-app
+\`\`\`
+
+## Database Migration
+
+If migrating database:
+- [ ] Create PersistentVolumeClaim for database
+- [ ] Deploy database as StatefulSet
+- [ ] Or use managed database service (RDS, Cloud SQL)
+`;
+}
+function generateKomposeReference() {
+    return `# Kompose Reference
+
+Kompose is a tool to convert Docker Compose files to Kubernetes resources.
+
+## Installation
+
+\`\`\`bash
+# macOS
+brew install kompose
+
+# Linux
+curl -L https://github.com/kubernetes/kompose/releases/download/v1.31.2/kompose-linux-amd64 -o kompose
+chmod +x kompose
+sudo mv kompose /usr/local/bin/
+
+# Windows
+choco install kubernetes-kompose
+\`\`\`
+
+## Basic Conversion
+
+\`\`\`bash
+# Convert docker-compose.yml
+kompose convert
+
+# Output to specific directory
+kompose convert -o k8s/
+
+# Generate Helm chart
+kompose convert -c
+\`\`\`
+
+## Supported Features
+
+| Docker Compose | Kubernetes |
+|---------------|------------|
+| services | Deployment + Service |
+| volumes | PersistentVolumeClaim |
+| environment | ConfigMap/Secret |
+| ports | Service ports |
+| depends_on | (manual ordering) |
+| networks | (default pod networking) |
+
+## Limitations
+
+- \`build\` context is not supported (pre-build images)
+- \`links\` deprecated, use service DNS
+- Some volume types not supported
+`;
+}

package/bin/migrate/generators/compose-to-railway.d.ts

@@ -0,0 +1,2 @@
+import type { MigrationOptions } from "../form";
+export declare function generateComposeToRailway(outputDir: string, options: MigrationOptions): Promise<void>;