genbox 1.0.12 → 1.0.13

package/dist/commands/validate.js

@@ -0,0 +1,529 @@
+"use strict";
+/**
+ * Validate Command
+ *
+ * Validates configuration files and checks for issues:
+ * 1. Schema validation (required fields, correct types)
+ * 2. Reference validation (apps exist, profiles reference valid apps)
+ * 3. Dependency validation (connected services exist)
+ * 4. Detection warnings (implicit values that should be explicit)
+ *
+ * Usage:
+ *   genbox validate                  # Validate genbox.yaml
+ *   genbox validate --resolved       # Validate resolved.yaml
+ *   genbox validate --strict         # Fail on warnings
+ */
+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.validateCommand = void 0;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const yaml = __importStar(require("js-yaml"));
+const config_loader_1 = require("../config-loader");
+const config_explainer_1 = require("../config-explainer");
+const strict_mode_1 = require("../strict-mode");
+exports.validateCommand = new commander_1.Command('validate')
+    .description('Validate configuration files for errors and warnings')
+    .option('--resolved', 'Validate resolved.yaml instead of genbox.yaml')
+    .option('--strict', 'Treat warnings as errors')
+    .option('--json', 'Output as JSON')
+    .option('-q, --quiet', 'Only output errors')
+    .action(async (options) => {
+    const cwd = process.cwd();
+    if (!options.quiet) {
+        console.log(chalk_1.default.cyan('\n🔍 Validating configuration...\n'));
+    }
+    try {
+        const result = options.resolved
+            ? await validateResolvedConfig(cwd)
+            : await validateGenboxConfig(cwd);
+        // Add detection warnings
+        if (!options.resolved) {
+            const detectionWarnings = await getDetectionWarnings(cwd);
+            result.warnings.push(...detectionWarnings);
+            // Add strict mode violations
+            const configLoader = new config_loader_1.ConfigLoader();
+            const loadResult = await configLoader.load(cwd);
+            if (loadResult.config) {
+                const strictSettings = (0, strict_mode_1.getStrictModeSettings)(loadResult.config);
+                const strictResult = (0, strict_mode_1.validateStrictMode)(loadResult.config, {
+                    ...strictSettings,
+                    // CLI --strict flag overrides config
+                    warnings_as_errors: options.strict || strictSettings.warnings_as_errors,
+                });
+                // Convert strict violations to validation issues
+                for (const violation of strictResult.violations) {
+                    const issue = {
+                        path: violation.path,
+                        message: `[Strict] ${violation.message}`,
+                        severity: violation.severity,
+                        suggestion: violation.suggestion,
+                    };
+                    if (violation.severity === 'error') {
+                        result.errors.push(issue);
+                    }
+                    else {
+                        result.warnings.push(issue);
+                    }
+                }
+                // Show strict mode summary if violations exist
+                if (!options.quiet && strictResult.violations.length > 0) {
+                    console.log(chalk_1.default.bold('Strict Mode Analysis:'));
+                    console.log(`  Explicit values: ${strictResult.summary.explicit_values}`);
+                    console.log(`  $detect markers: ${strictResult.summary.detect_markers}`);
+                    console.log(`  Inferred values: ${chalk_1.default.yellow(String(strictResult.summary.inferred_values))}`);
+                    console.log();
+                }
+            }
+        }
+        // In strict mode, warnings become errors
+        if (options.strict) {
+            result.errors.push(...result.warnings.map(w => ({ ...w, severity: 'error' })));
+            result.warnings = [];
+            result.valid = result.errors.length === 0;
+        }
+        // Output
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            displayValidationResult(result, options.quiet);
+        }
+        if (!result.valid) {
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        if (options.json) {
+            console.log(JSON.stringify({
+                valid: false,
+                errors: [{ path: '', message: String(error), severity: 'error' }],
+                warnings: [],
+            }, null, 2));
+        }
+        else {
+            console.error(chalk_1.default.red('Validation failed:'), error);
+        }
+        process.exit(1);
+    }
+});
+async function validateGenboxConfig(cwd) {
+    const errors = [];
+    const warnings = [];
+    // Load configuration
+    const configLoader = new config_loader_1.ConfigLoader();
+    const loadResult = await configLoader.load(cwd);
+    if (!loadResult.found || !loadResult.config) {
+        errors.push({
+            path: 'genbox.yaml',
+            message: 'No genbox.yaml found. Run "genbox init" first.',
+            severity: 'error',
+        });
+        return { valid: false, errors, warnings };
+    }
+    const config = loadResult.config;
+    // Schema validation
+    validateSchema(config, errors, warnings);
+    // Reference validation
+    validateReferences(config, errors, warnings);
+    // Profile validation
+    validateProfiles(config, errors, warnings);
+    // Dependency validation
+    validateDependencies(config, errors, warnings);
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}
+async function validateResolvedConfig(cwd) {
+    const errors = [];
+    const warnings = [];
+    const resolvedPath = path.join(cwd, '.genbox', 'resolved.yaml');
+    if (!fs.existsSync(resolvedPath)) {
+        errors.push({
+            path: '.genbox/resolved.yaml',
+            message: 'No resolved.yaml found. Run "genbox resolve" first.',
+            severity: 'error',
+        });
+        return { valid: false, errors, warnings };
+    }
+    try {
+        const content = fs.readFileSync(resolvedPath, 'utf8');
+        const resolved = yaml.load(content);
+        // Check for unresolved $detect markers
+        checkUnresolvedDetectMarkers(resolved, '', errors);
+        // Validate resolved structure
+        if (!resolved.name) {
+            errors.push({
+                path: 'name',
+                message: 'Resolved config missing required field: name',
+                severity: 'error',
+            });
+        }
+        if (!resolved.apps || !Array.isArray(resolved.apps)) {
+            errors.push({
+                path: 'apps',
+                message: 'Resolved config missing apps array',
+                severity: 'error',
+            });
+        }
+        // Check each app has required fields
+        if (Array.isArray(resolved.apps)) {
+            for (const app of resolved.apps) {
+                if (!app.name) {
+                    errors.push({
+                        path: 'apps[?]',
+                        message: 'App missing required field: name',
+                        severity: 'error',
+                    });
+                }
+                if (!app.type) {
+                    warnings.push({
+                        path: `apps.${app.name || '?'}.type`,
+                        message: 'App has no type specified',
+                        severity: 'warning',
+                        suggestion: 'Add explicit type: frontend | backend | worker | gateway',
+                    });
+                }
+            }
+        }
+    }
+    catch (err) {
+        errors.push({
+            path: '.genbox/resolved.yaml',
+            message: `Failed to parse resolved.yaml: ${err}`,
+            severity: 'error',
+        });
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}
+function validateSchema(config, errors, warnings) {
+    // Required fields
+    if (!config.version) {
+        errors.push({
+            path: 'version',
+            message: 'Missing required field: version',
+            severity: 'error',
+            suggestion: 'Add "version: 3" at the top of genbox.yaml',
+        });
+    }
+    else if (config.version !== '3.0' && config.version !== 3 && config.version !== 4) {
+        warnings.push({
+            path: 'version',
+            message: `Version ${config.version} may not be fully supported`,
+            severity: 'warning',
+            suggestion: 'Consider upgrading to version 3 or 4',
+        });
+    }
+    if (!config.project?.name) {
+        errors.push({
+            path: 'project.name',
+            message: 'Missing required field: project.name',
+            severity: 'error',
+        });
+    }
+    // Apps validation
+    if (!config.apps || Object.keys(config.apps).length === 0) {
+        warnings.push({
+            path: 'apps',
+            message: 'No apps defined in configuration',
+            severity: 'warning',
+            suggestion: 'Define at least one app in the apps section',
+        });
+    }
+    // Validate each app
+    for (const [appName, appConfig] of Object.entries(config.apps || {})) {
+        if (!appConfig.path) {
+            errors.push({
+                path: `apps.${appName}.path`,
+                message: `App '${appName}' missing required field: path`,
+                severity: 'error',
+            });
+        }
+        // Check for $detect markers
+        if (appConfig.type === '$detect') {
+            warnings.push({
+                path: `apps.${appName}.type`,
+                message: `App '${appName}' uses $detect for type - run "genbox resolve" to compute actual value`,
+                severity: 'warning',
+            });
+        }
+        if (appConfig.port === '$detect') {
+            warnings.push({
+                path: `apps.${appName}.port`,
+                message: `App '${appName}' uses $detect for port - run "genbox resolve" to compute actual value`,
+                severity: 'warning',
+            });
+        }
+    }
+}
+function validateReferences(config, errors, _warnings) {
+    const appNames = new Set(Object.keys(config.apps || {}));
+    // Validate profile app references
+    for (const [profileName, profile] of Object.entries(config.profiles || {})) {
+        if (profile.apps) {
+            for (const appName of profile.apps) {
+                if (!appNames.has(appName)) {
+                    errors.push({
+                        path: `profiles.${profileName}.apps`,
+                        message: `Profile '${profileName}' references non-existent app: ${appName}`,
+                        severity: 'error',
+                        suggestion: `Available apps: ${Array.from(appNames).join(', ')}`,
+                    });
+                }
+            }
+        }
+        // Validate connect_to references
+        if (profile.connect_to) {
+            for (const [appName, connections] of Object.entries(profile.connect_to)) {
+                if (!appNames.has(appName)) {
+                    errors.push({
+                        path: `profiles.${profileName}.connect_to.${appName}`,
+                        message: `Profile '${profileName}' connect_to references non-existent app: ${appName}`,
+                        severity: 'error',
+                    });
+                }
+                // Validate connection targets
+                for (const [targetName] of Object.entries(connections || {})) {
+                    // Infrastructure names are in the infrastructure section (it's a Record, not array)
+                    const infraNames = new Set(Object.keys(config.infrastructure || {}));
+                    if (!appNames.has(targetName) && !infraNames.has(targetName)) {
+                        errors.push({
+                            path: `profiles.${profileName}.connect_to.${appName}.${targetName}`,
+                            message: `Connection target '${targetName}' not found in apps or infrastructure`,
+                            severity: 'error',
+                        });
+                    }
+                }
+            }
+        }
+    }
+    // Validate repos references (repos is a Record, not array)
+    for (const [repoName, repo] of Object.entries(config.repos || {})) {
+        // RepoConfig doesn't have apps field - skip this validation for now
+        // The apps are defined in the apps section with repo references
+    }
+}
+function validateProfiles(config, errors, warnings) {
+    const profiles = config.profiles || {};
+    // Check for recommended profiles
+    if (!profiles['quick'] && !profiles['minimal']) {
+        warnings.push({
+            path: 'profiles',
+            message: 'No quick/minimal profile defined for fast iteration',
+            severity: 'warning',
+            suggestion: 'Add a "quick" profile with minimal services for fast local development',
+        });
+    }
+    // Validate profile sizes
+    const validSizes = ['small', 'medium', 'large', 'xlarge'];
+    for (const [profileName, profile] of Object.entries(profiles)) {
+        if (profile.size && !validSizes.includes(profile.size)) {
+            errors.push({
+                path: `profiles.${profileName}.size`,
+                message: `Invalid size '${profile.size}' in profile '${profileName}'`,
+                severity: 'error',
+                suggestion: `Valid sizes: ${validSizes.join(', ')}`,
+            });
+        }
+    }
+}
+function validateDependencies(config, errors, warnings) {
+    const appNames = new Set(Object.keys(config.apps || {}));
+    const infraNames = new Set(Object.keys(config.infrastructure || {}));
+    // Check app dependencies
+    for (const [appName, appConfig] of Object.entries(config.apps || {})) {
+        if (appConfig.dependencies) {
+            for (const depName of Object.keys(appConfig.dependencies)) {
+                if (!infraNames.has(depName) && !appNames.has(depName)) {
+                    errors.push({
+                        path: `apps.${appName}.dependencies.${depName}`,
+                        message: `Dependency '${depName}' not found in infrastructure or apps`,
+                        severity: 'error',
+                        suggestion: `Define '${depName}' in the infrastructure section or check the name`,
+                    });
+                }
+            }
+        }
+    }
+    // Check for circular dependencies
+    const appDeps = new Map();
+    for (const [appName, appConfig] of Object.entries(config.apps || {})) {
+        const deps = Object.keys(appConfig.dependencies || {}).filter(d => appNames.has(d));
+        appDeps.set(appName, deps);
+    }
+    for (const appName of appNames) {
+        const cycle = findCycle(appName, appDeps);
+        if (cycle) {
+            errors.push({
+                path: `apps.${appName}.dependencies`,
+                message: `Circular dependency detected: ${cycle.join(' → ')}`,
+                severity: 'error',
+            });
+            break; // Only report once
+        }
+    }
+    // Warn about apps with no dependencies defined
+    for (const [appName, appConfig] of Object.entries(config.apps || {})) {
+        if (!appConfig.dependencies || Object.keys(appConfig.dependencies).length === 0) {
+            if (appConfig.type === 'backend' || appConfig.type === 'worker') {
+                warnings.push({
+                    path: `apps.${appName}.dependencies`,
+                    message: `Backend app '${appName}' has no dependencies defined`,
+                    severity: 'warning',
+                    suggestion: 'Consider defining database or cache dependencies',
+                });
+            }
+        }
+    }
+}
+function findCycle(start, deps, visited = new Set(), path = []) {
+    if (visited.has(start)) {
+        const cycleStart = path.indexOf(start);
+        if (cycleStart !== -1) {
+            return [...path.slice(cycleStart), start];
+        }
+        return null;
+    }
+    visited.add(start);
+    path.push(start);
+    for (const dep of deps.get(start) || []) {
+        const cycle = findCycle(dep, deps, visited, path);
+        if (cycle)
+            return cycle;
+    }
+    path.pop();
+    return null;
+}
+function checkUnresolvedDetectMarkers(obj, currentPath, errors) {
+    if (obj === '$detect') {
+        errors.push({
+            path: currentPath,
+            message: `Unresolved $detect marker at ${currentPath}`,
+            severity: 'error',
+            suggestion: 'Run "genbox scan" then "genbox resolve" to compute this value',
+        });
+        return;
+    }
+    if (obj && typeof obj === 'object') {
+        if (Array.isArray(obj)) {
+            obj.forEach((item, index) => {
+                checkUnresolvedDetectMarkers(item, `${currentPath}[${index}]`, errors);
+            });
+        }
+        else {
+            for (const [key, value] of Object.entries(obj)) {
+                const newPath = currentPath ? `${currentPath}.${key}` : key;
+                checkUnresolvedDetectMarkers(value, newPath, errors);
+            }
+        }
+    }
+}
+async function getDetectionWarnings(cwd) {
+    const warnings = [];
+    try {
+        const configLoader = new config_loader_1.ConfigLoader();
+        const loadResult = await configLoader.load(cwd);
+        if (!loadResult.found || !loadResult.config) {
+            return warnings;
+        }
+        const explainer = new config_explainer_1.ConfigExplainer(loadResult);
+        const detectionWarnings = explainer.getDetectionWarnings();
+        for (const warning of detectionWarnings) {
+            warnings.push({
+                path: 'detection',
+                message: warning,
+                severity: 'warning',
+                suggestion: 'Make this value explicit in genbox.yaml',
+            });
+        }
+    }
+    catch {
+        // Ignore errors in detection warnings
+    }
+    return warnings;
+}
+function displayValidationResult(result, quiet) {
+    const { errors, warnings, valid } = result;
+    // Display errors
+    if (errors.length > 0) {
+        console.log(chalk_1.default.red.bold(`\n❌ ${errors.length} Error(s):\n`));
+        for (const error of errors) {
+            console.log(chalk_1.default.red(`  • ${error.path}: ${error.message}`));
+            if (error.suggestion) {
+                console.log(chalk_1.default.dim(`    → ${error.suggestion}`));
+            }
+        }
+    }
+    // Display warnings (unless quiet)
+    if (!quiet && warnings.length > 0) {
+        console.log(chalk_1.default.yellow.bold(`\n⚠️  ${warnings.length} Warning(s):\n`));
+        for (const warning of warnings) {
+            console.log(chalk_1.default.yellow(`  • ${warning.path}: ${warning.message}`));
+            if (warning.suggestion) {
+                console.log(chalk_1.default.dim(`    → ${warning.suggestion}`));
+            }
+        }
+    }
+    // Summary
+    console.log();
+    if (valid) {
+        console.log(chalk_1.default.green.bold('✓ Configuration is valid'));
+        if (warnings.length > 0) {
+            console.log(chalk_1.default.yellow(`  (${warnings.length} warning(s) - consider addressing them)`));
+        }
+    }
+    else {
+        console.log(chalk_1.default.red.bold('✗ Configuration has errors'));
+        console.log(chalk_1.default.dim('  Fix the errors above and run validate again'));
+    }
+    // Next steps
+    if (valid) {
+        console.log(chalk_1.default.bold('\n📝 Next steps:\n'));
+        console.log('  1. Run ' + chalk_1.default.cyan('genbox resolve') + ' to compute final configuration');
+        console.log('  2. Run ' + chalk_1.default.cyan('genbox create <name>') + ' to provision');
+        console.log();
+    }
+}