genbox 1.0.3 → 1.0.4

package/dist/profile-resolver.js

@@ -0,0 +1,547 @@
+"use strict";
+/**
+ * Profile Resolver
+ *
+ * Handles:
+ * - Profile resolution with inheritance
+ * - CLI flag merging
+ * - Dependency resolution with prompts
+ * - Interactive app selection
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProfileResolver = void 0;
+const prompts = __importStar(require("@inquirer/prompts"));
+const chalk_1 = __importDefault(require("chalk"));
+const config_loader_1 = require("./config-loader");
+class ProfileResolver {
+    configLoader;
+    constructor(configLoader) {
+        this.configLoader = configLoader || new config_loader_1.ConfigLoader();
+    }
+    /**
+     * Resolve configuration from options (CLI flags, profile, interactive)
+     */
+    async resolve(config, options) {
+        const warnings = [];
+        // Step 1: Get base profile (if specified)
+        let profile = {};
+        if (options.profile) {
+            const foundProfile = this.configLoader.getProfile(config, options.profile);
+            if (foundProfile) {
+                profile = foundProfile;
+            }
+            else {
+                warnings.push(`Profile '${options.profile}' not found, using defaults`);
+            }
+        }
+        // Step 2: Determine apps to include
+        let selectedApps;
+        if (options.apps) {
+            // CLI --apps flag takes precedence
+            selectedApps = options.apps;
+        }
+        else if (profile.apps && profile.apps.length > 0) {
+            // Use profile apps
+            selectedApps = profile.apps;
+            // Add additional apps if --add-apps specified
+            if (options.addApps) {
+                selectedApps = [...new Set([...selectedApps, ...options.addApps])];
+            }
+        }
+        else if (!options.yes) {
+            // Interactive mode
+            selectedApps = await this.selectAppsInteractive(config);
+        }
+        else {
+            // Default: all non-library apps
+            selectedApps = Object.entries(config.apps)
+                .filter(([_, app]) => app.type !== 'library')
+                .map(([name]) => name);
+        }
+        // Step 3: Resolve dependencies
+        const { apps, infrastructure, dependencyWarnings } = await this.resolveDependencies(config, selectedApps, options, profile);
+        warnings.push(...dependencyWarnings);
+        // Step 4: Determine database mode
+        const database = await this.resolveDatabaseMode(config, options, profile);
+        // Step 5: Determine size
+        const size = options.size || profile.size || this.inferSize(apps, infrastructure);
+        // Step 6: Build resolved config
+        const resolved = {
+            name: options.name,
+            size,
+            project: {
+                name: config.project.name,
+                structure: config.project.structure,
+            },
+            apps,
+            infrastructure,
+            database,
+            repos: this.resolveRepos(config, apps),
+            env: this.resolveEnvVars(config, apps, infrastructure, database),
+            hooks: config.hooks || {},
+            profile: options.profile,
+            warnings,
+        };
+        return resolved;
+    }
+    /**
+     * Interactive app selection
+     */
+    async selectAppsInteractive(config) {
+        const appChoices = Object.entries(config.apps)
+            .filter(([_, app]) => app.type !== 'library')
+            .map(([name, app]) => ({
+            name: `${name} - ${app.description || app.type} (${app.framework || 'custom'})`,
+            value: name,
+            checked: app.type === 'frontend', // Pre-select frontends
+        }));
+        if (appChoices.length === 0) {
+            console.log(chalk_1.default.yellow('No apps defined in configuration'));
+            return [];
+        }
+        console.log(chalk_1.default.cyan('\n📦 Available Apps:\n'));
+        const selected = await prompts.checkbox({
+            message: 'Select apps to include in your genbox:',
+            choices: appChoices,
+        });
+        return selected;
+    }
+    /**
+     * Resolve dependencies for selected apps
+     */
+    async resolveDependencies(config, selectedApps, options, profile) {
+        const resolvedApps = [];
+        const resolvedInfra = [];
+        const warnings = [];
+        const processedDeps = new Set();
+        // Default environment for dependencies
+        const defaultEnv = profile.connect_to || options.api;
+        for (const appName of selectedApps) {
+            const appConfig = config.apps[appName];
+            if (!appConfig) {
+                warnings.push(`App '${appName}' not found in configuration`);
+                continue;
+            }
+            const resolvedApp = await this.resolveApp(config, appName, appConfig, selectedApps, defaultEnv, options, processedDeps);
+            resolvedApps.push(resolvedApp);
+        }
+        // Collect infrastructure needs
+        for (const app of resolvedApps) {
+            for (const [depName, depConfig] of Object.entries(app.dependencies)) {
+                if (processedDeps.has(depName))
+                    continue;
+                const infraConfig = config.infrastructure?.[depName];
+                if (infraConfig) {
+                    resolvedInfra.push({
+                        name: depName,
+                        type: infraConfig.type,
+                        mode: depConfig.mode,
+                        image: depConfig.mode === 'local' ? infraConfig.image : undefined,
+                        port: depConfig.mode === 'local' ? infraConfig.port : undefined,
+                        environment: depConfig.environment,
+                        url: depConfig.url,
+                    });
+                    processedDeps.add(depName);
+                }
+            }
+        }
+        return { apps: resolvedApps, infrastructure: resolvedInfra, dependencyWarnings: warnings };
+    }
+    /**
+     * Resolve a single app with its dependencies
+     */
+    async resolveApp(config, appName, appConfig, selectedApps, defaultEnv, options, processedDeps) {
+        const dependencies = {};
+        // Process each dependency
+        for (const [depName, requirement] of Object.entries(appConfig.requires || {})) {
+            if (requirement === 'none')
+                continue;
+            // Check if dependency is already in selected apps
+            const isLocalApp = selectedApps.includes(depName);
+            // Check if it's infrastructure
+            const isInfra = config.infrastructure?.[depName];
+            if (isLocalApp) {
+                // Dependency is included locally
+                dependencies[depName] = { mode: 'local' };
+            }
+            else if (defaultEnv && config.environments?.[defaultEnv]) {
+                // Use default environment
+                const envConfig = config.environments[defaultEnv];
+                const url = this.getUrlForDependency(depName, envConfig);
+                dependencies[depName] = {
+                    mode: 'remote',
+                    environment: defaultEnv,
+                    url,
+                };
+            }
+            else if (requirement === 'required' && !options.yes) {
+                // Prompt user for resolution
+                const resolution = await this.promptDependencyResolution(config, appName, depName, isInfra ? 'infrastructure' : 'app');
+                dependencies[depName] = resolution;
+            }
+            else if (requirement === 'optional') {
+                // Skip optional dependencies if not explicitly included
+                continue;
+            }
+            else {
+                // Default to local if no other option
+                dependencies[depName] = { mode: 'local' };
+            }
+            processedDeps.add(depName);
+        }
+        return {
+            name: appName,
+            path: appConfig.path,
+            type: appConfig.type,
+            framework: appConfig.framework,
+            port: appConfig.port,
+            services: appConfig.services,
+            commands: appConfig.commands,
+            env: appConfig.env,
+            dependencies,
+        };
+    }
+    /**
+     * Prompt user for dependency resolution
+     */
+    async promptDependencyResolution(config, appName, depName, depType) {
+        console.log(chalk_1.default.yellow(`\n⚠ '${appName}' requires '${depName}'`));
+        const choices = [];
+        // Local option
+        if (depType === 'app') {
+            choices.push({
+                name: `Include '${depName}' locally`,
+                value: 'local',
+            });
+        }
+        else {
+            choices.push({
+                name: `Run '${depName}' locally (Docker)`,
+                value: 'local',
+            });
+        }
+        // Environment options
+        for (const [envName, envConfig] of Object.entries(config.environments || {})) {
+            choices.push({
+                name: `Connect to ${envName} ${envConfig.description ? `(${envConfig.description})` : ''}`,
+                value: envName,
+            });
+        }
+        // Skip option
+        choices.push({
+            name: 'Skip (app may not work correctly)',
+            value: 'skip',
+        });
+        const answer = await prompts.select({
+            message: `How should we handle '${depName}'?`,
+            choices,
+        });
+        if (answer === 'local') {
+            return { mode: 'local' };
+        }
+        else if (answer === 'skip') {
+            return { mode: 'remote' }; // Effectively skipped
+        }
+        else {
+            const envConfig = config.environments?.[answer];
+            return {
+                mode: 'remote',
+                environment: answer,
+                url: envConfig ? this.getUrlForDependency(depName, envConfig) : undefined,
+            };
+        }
+    }
+    /**
+     * Get URL for a dependency from environment config
+     */
+    getUrlForDependency(depName, envConfig) {
+        // Check if it's an API dependency
+        if (depName === 'api' && envConfig.api) {
+            return envConfig.api.url || envConfig.api.gateway;
+        }
+        // Check infrastructure
+        const infraConfig = envConfig[depName];
+        return infraConfig?.url;
+    }
+    /**
+     * Resolve database mode
+     */
+    async resolveDatabaseMode(config, options, profile) {
+        // CLI flag takes precedence
+        if (options.db) {
+            return {
+                mode: options.db,
+                source: options.dbSource || profile.database?.source || 'staging',
+            };
+        }
+        // Profile setting
+        if (profile.database) {
+            return {
+                mode: profile.database.mode,
+                source: profile.database.source,
+            };
+        }
+        // If connect_to is set, use remote
+        if (profile.connect_to) {
+            const envConfig = config.environments?.[profile.connect_to];
+            return {
+                mode: 'remote',
+                source: profile.connect_to,
+                url: envConfig?.mongodb?.url,
+            };
+        }
+        // Interactive mode
+        if (!options.yes) {
+            return await this.selectDatabaseModeInteractive(config);
+        }
+        // Default
+        return {
+            mode: config.defaults?.database?.mode || 'local',
+            source: config.defaults?.database?.source,
+        };
+    }
+    /**
+     * Interactive database mode selection
+     */
+    async selectDatabaseModeInteractive(config) {
+        console.log(chalk_1.default.cyan('\n🗄️ Database Configuration:\n'));
+        const modeChoices = [
+            { name: 'None (no database)', value: 'none' },
+            { name: 'Local empty database', value: 'local' },
+            { name: 'Copy from staging (snapshot)', value: 'copy-staging' },
+        ];
+        // Add production copy if available
+        if (config.environments?.production) {
+            modeChoices.push({
+                name: 'Copy from production (snapshot)',
+                value: 'copy-production',
+            });
+        }
+        // Add remote options
+        if (config.environments?.staging) {
+            modeChoices.push({
+                name: 'Connect to staging (remote)',
+                value: 'remote-staging',
+            });
+        }
+        const answer = await prompts.select({
+            message: 'Database mode:',
+            choices: modeChoices,
+        });
+        if (answer === 'none') {
+            return { mode: 'none' };
+        }
+        else if (answer === 'local') {
+            return { mode: 'local' };
+        }
+        else if (answer.startsWith('copy-')) {
+            const source = answer.replace('copy-', '');
+            return { mode: 'copy', source };
+        }
+        else if (answer.startsWith('remote-')) {
+            const source = answer.replace('remote-', '');
+            const envConfig = config.environments?.[source];
+            return {
+                mode: 'remote',
+                source,
+                url: envConfig?.mongodb?.url,
+            };
+        }
+        return { mode: 'local' };
+    }
+    /**
+     * Infer server size based on selected apps and infrastructure
+     */
+    inferSize(apps, infrastructure) {
+        const localApps = apps.length;
+        const localInfra = infrastructure.filter(i => i.mode === 'local').length;
+        const total = localApps + localInfra;
+        // Check for heavy services
+        const hasHeavyService = apps.some(a => a.services && Object.keys(a.services).length > 3);
+        if (total > 8 || hasHeavyService)
+            return 'xl';
+        if (total > 5)
+            return 'large';
+        if (total > 2)
+            return 'medium';
+        return 'small';
+    }
+    /**
+     * Resolve repositories to clone
+     */
+    resolveRepos(config, apps) {
+        const repos = [];
+        const seen = new Set();
+        for (const app of apps) {
+            const appConfig = config.apps[app.name];
+            // Check if app has specific repo
+            if (appConfig?.repo && config.repos?.[appConfig.repo]) {
+                const repoConfig = config.repos[appConfig.repo];
+                if (!seen.has(repoConfig.url)) {
+                    repos.push({
+                        name: appConfig.repo,
+                        url: repoConfig.url,
+                        path: repoConfig.path,
+                        branch: repoConfig.branch,
+                    });
+                    seen.add(repoConfig.url);
+                }
+            }
+        }
+        // If no specific repos, use main project repo
+        if (repos.length === 0 && config.repos) {
+            const mainRepo = Object.entries(config.repos)[0];
+            if (mainRepo) {
+                repos.push({
+                    name: mainRepo[0],
+                    url: mainRepo[1].url,
+                    path: mainRepo[1].path,
+                    branch: mainRepo[1].branch,
+                });
+            }
+        }
+        return repos;
+    }
+    /**
+     * Resolve environment variables
+     */
+    resolveEnvVars(config, apps, infrastructure, database) {
+        const env = {};
+        // Add API URL based on resolution
+        for (const app of apps) {
+            const apiDep = app.dependencies['api'];
+            if (apiDep) {
+                if (apiDep.mode === 'local') {
+                    env['API_URL'] = 'http://localhost:3050';
+                    env['VITE_API_URL'] = 'http://localhost:3050';
+                    env['NEXT_PUBLIC_API_URL'] = 'http://localhost:3050';
+                }
+                else if (apiDep.url) {
+                    env['API_URL'] = apiDep.url;
+                    env['VITE_API_URL'] = apiDep.url;
+                    env['NEXT_PUBLIC_API_URL'] = apiDep.url;
+                }
+            }
+        }
+        // Add database URL
+        if (database.mode === 'local') {
+            env['MONGODB_URI'] = `mongodb://localhost:27017/${config.project.name}`;
+        }
+        else if (database.url) {
+            env['MONGODB_URI'] = database.url;
+        }
+        // Add infrastructure URLs
+        for (const infra of infrastructure) {
+            if (infra.mode === 'local') {
+                switch (infra.type) {
+                    case 'cache':
+                        env['REDIS_URL'] = `redis://localhost:${infra.port || 6379}`;
+                        break;
+                    case 'queue':
+                        env['RABBITMQ_URL'] = `amqp://localhost:${infra.port || 5672}`;
+                        break;
+                }
+            }
+            else if (infra.url) {
+                switch (infra.type) {
+                    case 'cache':
+                        env['REDIS_URL'] = infra.url;
+                        break;
+                    case 'queue':
+                        env['RABBITMQ_URL'] = infra.url;
+                        break;
+                }
+            }
+        }
+        return env;
+    }
+    /**
+     * Interactive size selection
+     */
+    async selectSizeInteractive() {
+        console.log(chalk_1.default.cyan('\n📊 Server Size:\n'));
+        const answer = await prompts.select({
+            message: 'Select server size:',
+            choices: [
+                { name: 'Small  - 2 CPU, 4GB RAM  (UI only)', value: 'small' },
+                { name: 'Medium - 4 CPU, 8GB RAM  (1-2 services)', value: 'medium' },
+                { name: 'Large  - 8 CPU, 16GB RAM (full stack)', value: 'large' },
+                { name: 'XL     - 16 CPU, 32GB RAM (heavy workloads)', value: 'xl' },
+            ],
+        });
+        return answer;
+    }
+    /**
+     * Ask if user wants to save as profile
+     */
+    async askSaveProfile(config, resolved) {
+        const save = await prompts.confirm({
+            message: 'Save this configuration as a reusable profile?',
+            default: false,
+        });
+        if (!save)
+            return null;
+        const name = await prompts.input({
+            message: 'Profile name:',
+            validate: (value) => {
+                if (!value.trim())
+                    return 'Profile name is required';
+                if (config.profiles?.[value])
+                    return 'Profile already exists';
+                if (!/^[a-z0-9-]+$/.test(value))
+                    return 'Use lowercase letters, numbers, and hyphens';
+                return true;
+            },
+        });
+        // Build profile
+        const profile = {
+            description: `Created for ${resolved.name}`,
+            size: resolved.size,
+            apps: resolved.apps.map(a => a.name),
+            database: {
+                mode: resolved.database.mode,
+                source: resolved.database.source,
+            },
+        };
+        // Save to user profiles
+        this.configLoader.saveUserProfile(name, profile);
+        return name;
+    }
+}
+exports.ProfileResolver = ProfileResolver;