genbox 1.0.2 → 1.0.4

package/dist/scanner/compose-parser.js

@@ -0,0 +1,441 @@
+"use strict";
+/**
+ * Docker Compose Parser
+ *
+ * Parses docker-compose files to extract:
+ * - Services (applications, databases, infrastructure)
+ * - Port mappings
+ * - Environment variables
+ * - Dependencies between services
+ */
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComposeParser = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const yaml = __importStar(require("js-yaml"));
+// Known database images
+const DATABASE_PATTERNS = [
+    /^mongo(db)?/i,
+    /^postgres/i,
+    /^mysql/i,
+    /^mariadb/i,
+    /^cockroach/i,
+    /^cassandra/i,
+    /^dynamodb/i,
+    /^couchdb/i,
+    /^neo4j/i,
+    /^arangodb/i,
+];
+// Known cache images
+const CACHE_PATTERNS = [
+    /^redis/i,
+    /^memcache/i,
+    /^hazelcast/i,
+    /^keydb/i,
+];
+// Known queue/message broker images
+const QUEUE_PATTERNS = [
+    /^rabbitmq/i,
+    /^kafka/i,
+    /^nats/i,
+    /^pulsar/i,
+    /^activemq/i,
+    /^zeromq/i,
+];
+// Known infrastructure images
+const INFRA_PATTERNS = [
+    /^nginx/i,
+    /^traefik/i,
+    /^caddy/i,
+    /^haproxy/i,
+    /^envoy/i,
+    /^mailhog/i,
+    /^localstack/i,
+    /^minio/i,
+    /^elasticsearch/i,
+    /^kibana/i,
+    /^grafana/i,
+    /^prometheus/i,
+    /^jaeger/i,
+    /^zipkin/i,
+    /^vault/i,
+    /^consul/i,
+];
+class ComposeParser {
+    /**
+     * Parse docker-compose files in the project
+     */
+    async parse(root) {
+        const composeFiles = this.findComposeFiles(root);
+        if (composeFiles.length === 0) {
+            return null;
+        }
+        const allServices = [];
+        for (const file of composeFiles) {
+            try {
+                const content = yaml.load(fs.readFileSync(file, 'utf8'));
+                if (content && content.services) {
+                    for (const [name, config] of Object.entries(content.services)) {
+                        const service = this.normalizeService(name, config, root);
+                        allServices.push(service);
+                    }
+                }
+            }
+            catch (err) {
+                console.warn(`Warning: Could not parse ${file}:`, err);
+            }
+        }
+        // Categorize services
+        const categorized = this.categorizeServices(allServices);
+        // Build port map
+        const portMap = new Map();
+        for (const service of allServices) {
+            for (const port of service.ports) {
+                portMap.set(port.host, service.name);
+            }
+        }
+        // Build dependency graph
+        const dependencyGraph = new Map();
+        for (const service of allServices) {
+            dependencyGraph.set(service.name, service.dependsOn);
+        }
+        return {
+            files: composeFiles,
+            ...categorized,
+            portMap,
+            dependencyGraph,
+        };
+    }
+    findComposeFiles(root) {
+        const files = [];
+        const patterns = [
+            'docker-compose.yml',
+            'docker-compose.yaml',
+            'docker-compose.dev.yml',
+            'docker-compose.dev.yaml',
+            'docker-compose.local.yml',
+            'docker-compose.local.yaml',
+            'docker-compose.override.yml',
+            'docker-compose.override.yaml',
+            'docker-compose.secure.yml',
+            'docker-compose.secure.yaml',
+            'compose.yml',
+            'compose.yaml',
+        ];
+        for (const pattern of patterns) {
+            const filePath = path.join(root, pattern);
+            if (fs.existsSync(filePath)) {
+                files.push(filePath);
+            }
+        }
+        return files;
+    }
+    normalizeService(name, config, root) {
+        return {
+            name,
+            image: config.image,
+            build: this.normalizeBuild(config.build, root),
+            ports: this.normalizePorts(config.ports),
+            environment: this.normalizeEnvironment(config.environment),
+            envFile: this.normalizeEnvFile(config.env_file),
+            dependsOn: this.normalizeDependsOn(config.depends_on),
+            volumes: this.normalizeVolumes(config.volumes),
+            healthcheck: this.normalizeHealthcheck(config.healthcheck),
+            command: this.normalizeCommand(config.command),
+            labels: this.normalizeLabels(config.labels),
+        };
+    }
+    normalizeBuild(build, root) {
+        if (!build)
+            return undefined;
+        if (typeof build === 'string') {
+            return {
+                context: path.resolve(root, build),
+            };
+        }
+        if (typeof build === 'object') {
+            const b = build;
+            return {
+                context: path.resolve(root, b.context || '.'),
+                dockerfile: b.dockerfile,
+                target: b.target,
+            };
+        }
+        return undefined;
+    }
+    normalizePorts(ports) {
+        if (!ports || !Array.isArray(ports))
+            return [];
+        const mappings = [];
+        for (const port of ports) {
+            if (typeof port === 'string') {
+                // Parse "3000:3000" or "3000:3000/tcp" or "3000"
+                const match = port.match(/^(\d+)(?::(\d+))?(?:\/(\w+))?$/);
+                if (match) {
+                    const host = parseInt(match[1], 10);
+                    const container = match[2] ? parseInt(match[2], 10) : host;
+                    mappings.push({
+                        host,
+                        container,
+                        protocol: match[3] || 'tcp',
+                    });
+                }
+            }
+            else if (typeof port === 'object') {
+                const p = port;
+                if (p.published && p.target) {
+                    mappings.push({
+                        host: p.published,
+                        container: p.target,
+                        protocol: p.protocol || 'tcp',
+                    });
+                }
+            }
+            else if (typeof port === 'number') {
+                mappings.push({ host: port, container: port });
+            }
+        }
+        return mappings;
+    }
+    normalizeEnvironment(env) {
+        if (!env)
+            return {};
+        if (Array.isArray(env)) {
+            // ["KEY=value", "KEY2=value2"]
+            const result = {};
+            for (const item of env) {
+                if (typeof item === 'string') {
+                    const [key, ...valueParts] = item.split('=');
+                    result[key] = valueParts.join('=');
+                }
+            }
+            return result;
+        }
+        if (typeof env === 'object') {
+            // { KEY: "value" }
+            return env;
+        }
+        return {};
+    }
+    normalizeEnvFile(envFile) {
+        if (!envFile)
+            return undefined;
+        if (typeof envFile === 'string') {
+            return [envFile];
+        }
+        if (Array.isArray(envFile)) {
+            return envFile.filter(f => typeof f === 'string');
+        }
+        return undefined;
+    }
+    normalizeDependsOn(dependsOn) {
+        if (!dependsOn)
+            return [];
+        if (Array.isArray(dependsOn)) {
+            return dependsOn.filter(d => typeof d === 'string');
+        }
+        if (typeof dependsOn === 'object') {
+            // { service_name: { condition: "service_healthy" } }
+            return Object.keys(dependsOn);
+        }
+        return [];
+    }
+    normalizeVolumes(volumes) {
+        if (!volumes || !Array.isArray(volumes))
+            return [];
+        const mappings = [];
+        for (const vol of volumes) {
+            if (typeof vol === 'string') {
+                // Parse "./data:/data:ro" or "./data:/data"
+                const parts = vol.split(':');
+                if (parts.length >= 2) {
+                    mappings.push({
+                        source: parts[0],
+                        target: parts[1],
+                        readOnly: parts[2] === 'ro',
+                    });
+                }
+            }
+            else if (typeof vol === 'object') {
+                const v = vol;
+                if (v.source && v.target) {
+                    mappings.push({
+                        source: v.source,
+                        target: v.target,
+                        readOnly: v.read_only,
+                    });
+                }
+            }
+        }
+        return mappings;
+    }
+    normalizeHealthcheck(healthcheck) {
+        if (!healthcheck || typeof healthcheck !== 'object')
+            return undefined;
+        const hc = healthcheck;
+        let test = '';
+        if (Array.isArray(hc.test)) {
+            test = hc.test.join(' ');
+        }
+        else if (typeof hc.test === 'string') {
+            test = hc.test;
+        }
+        return {
+            test,
+            interval: hc.interval,
+            timeout: hc.timeout,
+            retries: hc.retries,
+        };
+    }
+    normalizeCommand(command) {
+        if (!command)
+            return undefined;
+        if (typeof command === 'string') {
+            return command;
+        }
+        if (Array.isArray(command)) {
+            return command.join(' ');
+        }
+        return undefined;
+    }
+    normalizeLabels(labels) {
+        if (!labels)
+            return undefined;
+        if (Array.isArray(labels)) {
+            // ["key=value"]
+            const result = {};
+            for (const item of labels) {
+                if (typeof item === 'string') {
+                    const [key, ...valueParts] = item.split('=');
+                    result[key] = valueParts.join('=');
+                }
+            }
+            return result;
+        }
+        if (typeof labels === 'object') {
+            return labels;
+        }
+        return undefined;
+    }
+    categorizeServices(services) {
+        const applications = [];
+        const databases = [];
+        const caches = [];
+        const queues = [];
+        const infrastructure = [];
+        for (const service of services) {
+            const category = this.categorizeService(service);
+            switch (category) {
+                case 'application':
+                    applications.push(service);
+                    break;
+                case 'database':
+                    databases.push(service);
+                    break;
+                case 'cache':
+                    caches.push(service);
+                    break;
+                case 'queue':
+                    queues.push(service);
+                    break;
+                case 'infra':
+                    infrastructure.push(service);
+                    break;
+            }
+        }
+        return { applications, databases, caches, queues, infrastructure };
+    }
+    categorizeService(service) {
+        // Check labels first (explicit declaration)
+        if (service.labels?.['genbox.type']) {
+            return service.labels['genbox.type'];
+        }
+        const image = service.image?.toLowerCase() || '';
+        // Check against known patterns
+        if (DATABASE_PATTERNS.some(p => p.test(image))) {
+            return 'database';
+        }
+        if (CACHE_PATTERNS.some(p => p.test(image))) {
+            return 'cache';
+        }
+        if (QUEUE_PATTERNS.some(p => p.test(image))) {
+            return 'queue';
+        }
+        if (INFRA_PATTERNS.some(p => p.test(image))) {
+            return 'infra';
+        }
+        // If it has a build context, it's likely an application
+        if (service.build) {
+            return 'application';
+        }
+        // Default to infrastructure for other pre-built images
+        if (service.image) {
+            return 'infra';
+        }
+        return 'application';
+    }
+    /**
+     * Get suggested genbox service name from compose service
+     */
+    getGenboxServiceName(service) {
+        // Use label if available
+        if (service.labels?.['genbox.name']) {
+            return service.labels['genbox.name'];
+        }
+        // Clean up the name
+        return service.name
+            .replace(/[-_]service$/i, '')
+            .replace(/[-_]app$/i, '')
+            .replace(/[-_]api$/i, '-api')
+            .toLowerCase();
+    }
+    /**
+     * Get the primary port for a service
+     */
+    getPrimaryPort(service) {
+        if (service.ports.length === 0)
+            return undefined;
+        // Prefer certain ports based on service category
+        const category = this.categorizeService(service);
+        // For applications, prefer the first exposed port
+        if (category === 'application') {
+            return service.ports[0].host;
+        }
+        // For databases/caches, use the container port
+        return service.ports[0].container;
+    }
+}
+exports.ComposeParser = ComposeParser;