genbox 1.0.11 → 1.0.13

package/dist/migration.js

@@ -0,0 +1,334 @@
+"use strict";
+/**
+ * Configuration Migration Utilities
+ *
+ * Handles migration from v3 to v4 schema:
+ * - Converts `requires` to `connects_to`
+ * - Converts `infrastructure` to `provides`
+ * - Adds explicit types where inferred
+ * - Shows deprecation warnings
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkDeprecations = checkDeprecations;
+exports.migrateV3ToV4 = migrateV3ToV4;
+exports.needsMigration = needsMigration;
+exports.getMigrationSummary = getMigrationSummary;
+const schema_v4_1 = require("./schema-v4");
+/**
+ * Check a v3 config for deprecated patterns
+ */
+function checkDeprecations(config) {
+    const warnings = [];
+    // Check version (v3 version is '3.0' string, v4 is number 4)
+    if (config.version !== 4) {
+        warnings.push({
+            path: 'version',
+            message: `Config version ${config.version} is deprecated`,
+            suggestion: 'Run "genbox migrate" to upgrade to version 4',
+            severity: 'warning',
+            autoMigrate: true,
+        });
+    }
+    // Check for requires in apps
+    for (const [appName, appConfig] of Object.entries(config.apps || {})) {
+        if (appConfig.requires) {
+            warnings.push({
+                path: `apps.${appName}.requires`,
+                message: '"requires" is deprecated in v4',
+                suggestion: 'Use "connects_to" with explicit connection modes',
+                severity: 'warning',
+                autoMigrate: true,
+            });
+        }
+    }
+    // Check for infrastructure (should be provides)
+    if (config.infrastructure) {
+        warnings.push({
+            path: 'infrastructure',
+            message: '"infrastructure" is renamed to "provides" in v4',
+            suggestion: 'Rename to "provides" for clarity',
+            severity: 'warning',
+            autoMigrate: true,
+        });
+    }
+    // Check for profile connect_to
+    for (const [profileName, profile] of Object.entries(config.profiles || {})) {
+        if (profile.connect_to && typeof profile.connect_to === 'string') {
+            warnings.push({
+                path: `profiles.${profileName}.connect_to`,
+                message: 'Single string "connect_to" is deprecated in v4',
+                suggestion: 'Use "default_connection" or per-app "connections" overrides',
+                severity: 'warning',
+                autoMigrate: true,
+            });
+        }
+    }
+    // Check for implicit app types (inferred from names)
+    for (const [appName, appConfig] of Object.entries(config.apps || {})) {
+        if (!appConfig.type) {
+            warnings.push({
+                path: `apps.${appName}.type`,
+                message: `App "${appName}" has no explicit type`,
+                suggestion: 'Add explicit "type: frontend|backend|worker|gateway"',
+                severity: 'warning',
+                autoMigrate: false,
+            });
+        }
+    }
+    return warnings;
+}
+/**
+ * Migrate a v3 config to v4
+ */
+function migrateV3ToV4(v3Config) {
+    const changes = [];
+    const warnings = [];
+    // Start with base v4 structure
+    const v4Config = {
+        version: 4,
+        project: {
+            name: v3Config.project.name,
+            description: v3Config.project.description,
+            structure: v3Config.project.structure,
+        },
+        apps: {},
+    };
+    changes.push({
+        type: 'modify',
+        path: 'version',
+        description: 'Upgraded version from 3 to 4',
+        before: v3Config.version,
+        after: 4,
+    });
+    // Migrate infrastructure to provides
+    if (v3Config.infrastructure) {
+        v4Config.provides = {};
+        for (const [name, infra] of Object.entries(v3Config.infrastructure)) {
+            v4Config.provides[name] = migrateInfrastructure(name, infra);
+        }
+        changes.push({
+            type: 'rename',
+            path: 'infrastructure',
+            description: 'Renamed "infrastructure" to "provides"',
+        });
+    }
+    // Migrate apps
+    for (const [appName, appConfig] of Object.entries(v3Config.apps || {})) {
+        const migratedApp = migrateApp(appName, appConfig, v3Config, changes, warnings);
+        v4Config.apps[appName] = migratedApp;
+    }
+    // Migrate profiles
+    if (v3Config.profiles) {
+        v4Config.profiles = {};
+        for (const [profileName, profile] of Object.entries(v3Config.profiles)) {
+            v4Config.profiles[profileName] = migrateProfile(profileName, profile, changes);
+        }
+    }
+    // Copy over other sections
+    if (v3Config.environments) {
+        v4Config.environments = {};
+        for (const [envName, envConfig] of Object.entries(v3Config.environments)) {
+            v4Config.environments[envName] = {
+                description: envConfig.description,
+                urls: extractUrls(envConfig),
+                env: {},
+            };
+        }
+    }
+    if (v3Config.repos) {
+        v4Config.repos = {};
+        for (const [repoName, repoConfig] of Object.entries(v3Config.repos)) {
+            v4Config.repos[repoName] = {
+                url: repoConfig.url,
+                path: repoConfig.path,
+                branch: repoConfig.branch,
+                auth: repoConfig.auth,
+            };
+        }
+    }
+    if (v3Config.defaults) {
+        v4Config.defaults = {
+            size: v3Config.defaults.size,
+            database: v3Config.defaults.database,
+            branch: v3Config.defaults.branch,
+        };
+    }
+    if (v3Config.hooks) {
+        v4Config.hooks = v3Config.hooks;
+    }
+    if (v3Config.scripts) {
+        v4Config.scripts = v3Config.scripts.map(script => ({
+            name: script.name,
+            path: script.path,
+            stage: script.stage,
+            run_as: script.runAs,
+            depends_on: script.dependsOn,
+        }));
+    }
+    // Add strict mode (default for v4)
+    v4Config.strict = {
+        enabled: true,
+        allow_detect: true,
+        warnings_as_errors: false,
+    };
+    changes.push({
+        type: 'add',
+        path: 'strict',
+        description: 'Added strict mode configuration (default for v4)',
+        after: v4Config.strict,
+    });
+    return { config: v4Config, changes, warnings };
+}
+function migrateInfrastructure(name, infra) {
+    return {
+        type: infra.type,
+        image: infra.image,
+        port: infra.port,
+        data_dir: infra.data_dir,
+        description: `Migrated from infrastructure.${name}`,
+    };
+}
+function migrateApp(appName, appConfig, v3Config, changes, warnings) {
+    const v4App = {
+        path: appConfig.path,
+        type: appConfig.type || '$detect',
+    };
+    // Migrate framework
+    if (appConfig.framework) {
+        v4App.framework = appConfig.framework;
+    }
+    // Migrate port
+    if (appConfig.port) {
+        v4App.port = appConfig.port;
+    }
+    // Migrate requires to connects_to
+    if (appConfig.requires) {
+        v4App.connects_to = {};
+        for (const [depName, requirement] of Object.entries(appConfig.requires)) {
+            v4App.connects_to[depName] = {
+                mode: 'local', // Default to local
+                required: requirement === 'required',
+                description: `Migrated from requires.${depName}`,
+            };
+        }
+        changes.push({
+            type: 'rename',
+            path: `apps.${appName}.requires`,
+            description: `Converted "requires" to "connects_to" for app "${appName}"`,
+            before: appConfig.requires,
+            after: v4App.connects_to,
+        });
+    }
+    // Also handle dependencies if present
+    if (appConfig.dependencies) {
+        if (!v4App.connects_to)
+            v4App.connects_to = {};
+        for (const [depName, depConfig] of Object.entries(appConfig.dependencies)) {
+            if (!v4App.connects_to[depName]) {
+                v4App.connects_to[depName] = {
+                    mode: depConfig.mode,
+                    required: true,
+                };
+            }
+        }
+    }
+    // Migrate commands
+    if (appConfig.commands) {
+        v4App.commands = appConfig.commands;
+    }
+    // Copy other fields
+    if (appConfig.repo)
+        v4App.repo = appConfig.repo;
+    if (appConfig.description)
+        v4App.description = appConfig.description;
+    if (appConfig.env)
+        v4App.env = appConfig.env;
+    if (appConfig.compose_file) {
+        v4App.compose = { file: appConfig.compose_file };
+    }
+    // Warn about missing explicit type
+    if (!appConfig.type) {
+        warnings.push(`App "${appName}" has no explicit type. Using $detect marker. ` +
+            `Run "genbox scan" then "genbox resolve" to determine the type.`);
+    }
+    return v4App;
+}
+function migrateProfile(profileName, profile, changes) {
+    const v4Profile = {
+        description: profile.description,
+        extends: profile.extends,
+        size: profile.size,
+        apps: profile.apps,
+        database: profile.database,
+        env: profile.env,
+        branch: profile.branch,
+    };
+    // Convert connect_to to default_connection
+    if (profile.connect_to && typeof profile.connect_to === 'string') {
+        v4Profile.default_connection = profile.connect_to;
+        changes.push({
+            type: 'rename',
+            path: `profiles.${profileName}.connect_to`,
+            description: `Converted string "connect_to" to "default_connection" in profile "${profileName}"`,
+            before: profile.connect_to,
+            after: v4Profile.default_connection,
+        });
+    }
+    return v4Profile;
+}
+function extractUrls(envConfig) {
+    const urls = {};
+    if (envConfig.api?.url) {
+        urls['api'] = envConfig.api.url;
+    }
+    if (envConfig.api?.gateway) {
+        urls['gateway'] = envConfig.api.gateway;
+    }
+    if (envConfig.mongodb?.url) {
+        urls['mongodb'] = envConfig.mongodb.url;
+    }
+    if (envConfig.redis?.url) {
+        urls['redis'] = envConfig.redis.url;
+    }
+    if (envConfig.rabbitmq?.url) {
+        urls['rabbitmq'] = envConfig.rabbitmq.url;
+    }
+    return urls;
+}
+// ============================================
+// Migration Detection
+// ============================================
+/**
+ * Check if a config needs migration
+ */
+function needsMigration(config) {
+    const version = (0, schema_v4_1.getConfigVersion)(config);
+    return version === 3 || version === 'unknown';
+}
+/**
+ * Get migration summary
+ */
+function getMigrationSummary(v3Config) {
+    const deprecations = checkDeprecations(v3Config);
+    const estimatedChanges = [];
+    if (v3Config.infrastructure) {
+        estimatedChanges.push('Rename "infrastructure" to "provides"');
+    }
+    for (const appName of Object.keys(v3Config.apps || {})) {
+        const app = v3Config.apps[appName];
+        if (app.requires) {
+            estimatedChanges.push(`Convert "${appName}.requires" to "connects_to"`);
+        }
+    }
+    for (const profileName of Object.keys(v3Config.profiles || {})) {
+        const profile = v3Config.profiles[profileName];
+        if (profile.connect_to && typeof profile.connect_to === 'string') {
+            estimatedChanges.push(`Convert "${profileName}.connect_to" to "default_connection"`);
+        }
+    }
+    return {
+        fieldsToMigrate: estimatedChanges.length,
+        deprecatedPatterns: deprecations.length,
+        estimatedChanges,
+    };
+}

package/dist/profile-resolver.js

@@ -225,12 +225,17 @@ class ProfileResolver {
             }
             processedDeps.add(depName);
         }
+        // Handle $detect markers - if still present, they should be resolved by now
+        // For now, filter them out with a warning
+        const type = appConfig.type === '$detect' ? 'backend' : appConfig.type;
+        const framework = appConfig.framework === '$detect' ? undefined : appConfig.framework;
+        const port = appConfig.port === '$detect' ? undefined : appConfig.port;
         return {
             name: appName,
             path: appConfig.path,
-            type: appConfig.type,
-            framework: appConfig.framework,
-            port: appConfig.port,
+            type,
+            framework,
+            port,
             services: appConfig.services,
             commands: appConfig.commands,
             env: appConfig.env,

package/dist/schema-v3.js

@@ -10,3 +10,39 @@
  * - Dependency resolution
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DETECTABLE_APP_FIELDS = exports.DETECT_MARKER = void 0;
+exports.isDetectMarker = isDetectMarker;
+// ============================================
+// $detect Marker Support
+// ============================================
+/**
+ * Special marker indicating a value should be auto-detected.
+ * Used in genbox.yaml to opt-in to detection for specific fields.
+ *
+ * Example:
+ *   apps:
+ *     web:
+ *       path: ./web
+ *       type: $detect        # Auto-detect from dependencies
+ *       port: $detect        # Auto-detect from scripts
+ *       framework: $detect   # Auto-detect from dependencies
+ */
+exports.DETECT_MARKER = '$detect';
+/**
+ * List of fields that support $detect markers in AppConfig
+ */
+exports.DETECTABLE_APP_FIELDS = [
+    'type',
+    'framework',
+    'port',
+    'commands.install',
+    'commands.dev',
+    'commands.build',
+    'commands.start',
+];
+/**
+ * Check if a value is a $detect marker
+ */
+function isDetectMarker(value) {
+    return value === exports.DETECT_MARKER;
+}

package/dist/schema-v4.js

@@ -0,0 +1,54 @@
+"use strict";
+/**
+ * Genbox Configuration Schema v4
+ *
+ * Key changes from v3:
+ * - Explicit `connects_to` replacing implicit dependency resolution
+ * - `provides` section for infrastructure definitions
+ * - `$detect` markers for opt-in auto-detection
+ * - Strict mode by default (no implicit inference)
+ * - Better separation of concerns
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEPRECATED_V3_FIELDS = void 0;
+exports.isV4Config = isV4Config;
+exports.getConfigVersion = getConfigVersion;
+// ============================================
+// Migration Helpers
+// ============================================
+/**
+ * Check if a config is v4
+ */
+function isV4Config(config) {
+    return config.version === 4;
+}
+/**
+ * Get the version of a config
+ */
+function getConfigVersion(config) {
+    if (config.version === 4)
+        return 4;
+    if (config.version === 3 || config.version === '3.0')
+        return 3;
+    return 'unknown';
+}
+/**
+ * List of deprecated fields from v3
+ */
+exports.DEPRECATED_V3_FIELDS = [
+    {
+        path: 'apps.*.requires',
+        replacement: 'apps.*.connects_to',
+        message: 'Use connects_to with explicit connection modes',
+    },
+    {
+        path: 'infrastructure',
+        replacement: 'provides',
+        message: 'Renamed to provides for clarity',
+    },
+    {
+        path: 'profiles.*.connect_to',
+        replacement: 'profiles.*.default_connection',
+        message: 'Use default_connection or per-app connections override',
+    },
+];