@build-astron-co/nimbus 0.2.0 → 0.4.0

package/dist/src/generator/kubernetes.js

@@ -0,0 +1,773 @@
+/**
+ * Kubernetes Manifest Generator
+ *
+ * Generates Kubernetes manifests from configuration
+ */
+import * as yaml from 'js-yaml';
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+// ==========================================
+// Generator Class
+// ==========================================
+export class KubernetesGenerator {
+    config;
+    constructor(config) {
+        this.config = {
+            namespace: 'default',
+            imageTag: 'latest',
+            replicas: 1,
+            containerPort: 8080,
+            serviceType: 'ClusterIP',
+            ...config,
+        };
+    }
+    /**
+     * Generate all manifests based on configuration
+     */
+    generate() {
+        const manifests = [];
+        // Namespace (if not default)
+        if (this.config.namespace && this.config.namespace !== 'default') {
+            manifests.push(this.generateNamespace());
+        }
+        // ServiceAccount
+        if (this.config.serviceAccount?.create) {
+            manifests.push(this.generateServiceAccount());
+        }
+        // ConfigMap
+        if (this.config.configMap) {
+            manifests.push(this.generateConfigMap());
+        }
+        // Secret
+        if (this.config.secret) {
+            manifests.push(this.generateSecret());
+        }
+        // Workload (Deployment, StatefulSet, etc.)
+        manifests.push(this.generateWorkload());
+        // Service
+        if (this.config.serviceType !== 'None') {
+            manifests.push(this.generateService());
+        }
+        // Ingress
+        if (this.config.ingressEnabled) {
+            manifests.push(this.generateIngress());
+        }
+        // HPA
+        if (this.config.hpa?.enabled) {
+            manifests.push(this.generateHPA());
+        }
+        // PDB
+        if (this.config.pdb?.enabled) {
+            manifests.push(this.generatePDB());
+        }
+        // RBAC
+        if (this.config.rbac?.enabled) {
+            manifests.push(this.generateRole());
+            manifests.push(this.generateRoleBinding());
+            if (this.config.rbac?.clusterWide) {
+                manifests.push(this.generateClusterRole());
+                manifests.push(this.generateClusterRoleBinding());
+            }
+        }
+        // NetworkPolicy
+        if (this.config.networkPolicy?.enabled) {
+            manifests.push(this.generateNetworkPolicy());
+        }
+        // PersistentVolumeClaim
+        if (this.config.persistence?.enabled) {
+            manifests.push(this.generatePersistentVolumeClaim());
+        }
+        return manifests;
+    }
+    /**
+     * Generate combined YAML file
+     */
+    generateCombined() {
+        const manifests = this.generate();
+        return manifests.map(m => m.content).join('\n---\n');
+    }
+    /**
+     * Write manifests to files
+     */
+    writeToFiles(outputDir) {
+        const manifests = this.generate();
+        const files = [];
+        if (!fs.existsSync(outputDir)) {
+            fs.mkdirSync(outputDir, { recursive: true });
+        }
+        for (const manifest of manifests) {
+            const filename = `${manifest.name}.yaml`;
+            const filepath = path.join(outputDir, filename);
+            fs.writeFileSync(filepath, manifest.content);
+            files.push(filepath);
+        }
+        // Write kustomization.yaml
+        const kustomization = this.generateKustomization(manifests);
+        const kustomizationPath = path.join(outputDir, 'kustomization.yaml');
+        fs.writeFileSync(kustomizationPath, kustomization);
+        files.push(kustomizationPath);
+        return files;
+    }
+    // ==========================================
+    // Private Generator Methods
+    // ==========================================
+    getLabels() {
+        return {
+            'app.kubernetes.io/name': this.config.appName,
+            'app.kubernetes.io/instance': this.config.appName,
+            'app.kubernetes.io/managed-by': 'nimbus',
+            ...this.config.labels,
+        };
+    }
+    getSelectorLabels() {
+        return {
+            'app.kubernetes.io/name': this.config.appName,
+            'app.kubernetes.io/instance': this.config.appName,
+        };
+    }
+    generateNamespace() {
+        const manifest = {
+            apiVersion: 'v1',
+            kind: 'Namespace',
+            metadata: {
+                name: this.config.namespace,
+                labels: this.getLabels(),
+            },
+        };
+        return {
+            name: 'namespace',
+            kind: 'Namespace',
+            content: yaml.dump(manifest),
+        };
+    }
+    generateServiceAccount() {
+        const manifest = {
+            apiVersion: 'v1',
+            kind: 'ServiceAccount',
+            metadata: {
+                name: this.config.serviceAccount?.name || this.config.appName,
+                namespace: this.config.namespace,
+                labels: this.getLabels(),
+                ...(this.config.serviceAccount?.annotations && {
+                    annotations: this.config.serviceAccount.annotations,
+                }),
+            },
+        };
+        return {
+            name: 'serviceaccount',
+            kind: 'ServiceAccount',
+            content: yaml.dump(manifest),
+        };
+    }
+    generateConfigMap() {
+        const manifest = {
+            apiVersion: 'v1',
+            kind: 'ConfigMap',
+            metadata: {
+                name: `${this.config.appName}-config`,
+                namespace: this.config.namespace,
+                labels: this.getLabels(),
+            },
+            data: this.config.configMap?.data || {},
+        };
+        return {
+            name: 'configmap',
+            kind: 'ConfigMap',
+            content: yaml.dump(manifest),
+        };
+    }
+    generateSecret() {
+        const data = {};
+        for (const [key, value] of Object.entries(this.config.secret?.data || {})) {
+            data[key] = Buffer.from(value).toString('base64');
+        }
+        const manifest = {
+            apiVersion: 'v1',
+            kind: 'Secret',
+            metadata: {
+                name: `${this.config.appName}-secret`,
+                namespace: this.config.namespace,
+                labels: this.getLabels(),
+            },
+            type: this.config.secret?.type || 'Opaque',
+            data,
+        };
+        return {
+            name: 'secret',
+            kind: 'Secret',
+            content: yaml.dump(manifest),
+        };
+    }
+    generateWorkload() {
+        const container = this.buildContainer();
+        const volumes = this.buildVolumes();
+        let manifest;
+        switch (this.config.workloadType) {
+            case 'deployment':
+                manifest = this.buildDeployment(container, volumes);
+                break;
+            case 'statefulset':
+                manifest = this.buildStatefulSet(container, volumes);
+                break;
+            case 'daemonset':
+                manifest = this.buildDaemonSet(container, volumes);
+                break;
+            case 'job':
+                manifest = this.buildJob(container, volumes);
+                break;
+            case 'cronjob':
+                manifest = this.buildCronJob(container, volumes);
+                break;
+            default:
+                manifest = this.buildDeployment(container, volumes);
+        }
+        return {
+            name: this.config.workloadType,
+            kind: manifest.kind,
+            content: yaml.dump(manifest),
+        };
+    }
+    buildContainer() {
+        const container = {
+            name: this.config.appName,
+            image: `${this.config.image}:${this.config.imageTag}`,
+            ports: [
+                {
+                    name: 'http',
+                    containerPort: this.config.containerPort,
+                    protocol: 'TCP',
+                },
+            ],
+        };
+        // Resources
+        if (this.config.resources) {
+            container.resources = this.config.resources;
+        }
+        // Environment variables
+        if (this.config.env && this.config.env.length > 0) {
+            container.env = this.config.env;
+        }
+        // Environment from ConfigMaps/Secrets
+        if (this.config.envFrom && this.config.envFrom.length > 0) {
+            container.envFrom = this.config.envFrom.map(ef => {
+                if (ef.configMapRef) {
+                    return { configMapRef: { name: ef.configMapRef } };
+                }
+                if (ef.secretRef) {
+                    return { secretRef: { name: ef.secretRef } };
+                }
+                return {};
+            });
+        }
+        // Volume mounts
+        if (this.config.volumes && this.config.volumes.length > 0) {
+            container.volumeMounts = this.config.volumes.map(v => ({
+                name: v.name,
+                mountPath: v.mountPath,
+                ...(v.subPath && { subPath: v.subPath }),
+            }));
+        }
+        // Health checks
+        if (this.config.healthChecks) {
+            if (this.config.healthChecks.livenessProbe) {
+                container.livenessProbe = this.config.healthChecks.livenessProbe;
+            }
+            if (this.config.healthChecks.readinessProbe) {
+                container.readinessProbe = this.config.healthChecks.readinessProbe;
+            }
+            if (this.config.healthChecks.startupProbe) {
+                container.startupProbe = this.config.healthChecks.startupProbe;
+            }
+        }
+        return container;
+    }
+    buildVolumes() {
+        if (!this.config.volumes || this.config.volumes.length === 0) {
+            return [];
+        }
+        return this.config.volumes.map(v => {
+            const volume = { name: v.name };
+            switch (v.type) {
+                case 'emptyDir':
+                    volume.emptyDir = {};
+                    break;
+                case 'configMap':
+                    volume.configMap = { name: v.configMapName };
+                    break;
+                case 'secret':
+                    volume.secret = { secretName: v.secretName };
+                    break;
+                case 'persistentVolumeClaim':
+                    volume.persistentVolumeClaim = { claimName: v.pvcName };
+                    break;
+                case 'hostPath':
+                    volume.hostPath = { path: v.hostPath };
+                    break;
+            }
+            return volume;
+        });
+    }
+    buildPodSpec(container, volumes) {
+        const spec = {
+            containers: [container],
+        };
+        if (this.config.serviceAccount?.create || this.config.serviceAccount?.name) {
+            spec.serviceAccountName = this.config.serviceAccount?.name || this.config.appName;
+        }
+        if (volumes.length > 0) {
+            spec.volumes = volumes;
+        }
+        if (this.config.nodeSelector) {
+            spec.nodeSelector = this.config.nodeSelector;
+        }
+        if (this.config.tolerations && this.config.tolerations.length > 0) {
+            spec.tolerations = this.config.tolerations;
+        }
+        if (this.config.affinity) {
+            spec.affinity = this.config.affinity;
+        }
+        return spec;
+    }
+    buildDeployment(container, volumes) {
+        return {
+            apiVersion: 'apps/v1',
+            kind: 'Deployment',
+            metadata: {
+                name: this.config.appName,
+                namespace: this.config.namespace,
+                labels: this.getLabels(),
+                ...(this.config.annotations && { annotations: this.config.annotations }),
+            },
+            spec: {
+                replicas: this.config.replicas,
+                selector: {
+                    matchLabels: this.getSelectorLabels(),
+                },
+                template: {
+                    metadata: {
+                        labels: this.getLabels(),
+                    },
+                    spec: this.buildPodSpec(container, volumes),
+                },
+            },
+        };
+    }
+    buildStatefulSet(container, volumes) {
+        return {
+            apiVersion: 'apps/v1',
+            kind: 'StatefulSet',
+            metadata: {
+                name: this.config.appName,
+                namespace: this.config.namespace,
+                labels: this.getLabels(),
+            },
+            spec: {
+                serviceName: this.config.appName,
+                replicas: this.config.replicas,
+                selector: {
+                    matchLabels: this.getSelectorLabels(),
+                },
+                template: {
+                    metadata: {
+                        labels: this.getLabels(),
+                    },
+                    spec: this.buildPodSpec(container, volumes),
+                },
+            },
+        };
+    }
+    buildDaemonSet(container, volumes) {
+        return {
+            apiVersion: 'apps/v1',
+            kind: 'DaemonSet',
+            metadata: {
+                name: this.config.appName,
+                namespace: this.config.namespace,
+                labels: this.getLabels(),
+            },
+            spec: {
+                selector: {
+                    matchLabels: this.getSelectorLabels(),
+                },
+                template: {
+                    metadata: {
+                        labels: this.getLabels(),
+                    },
+                    spec: this.buildPodSpec(container, volumes),
+                },
+            },
+        };
+    }
+    buildJob(container, volumes) {
+        return {
+            apiVersion: 'batch/v1',
+            kind: 'Job',
+            metadata: {
+                name: this.config.appName,
+                namespace: this.config.namespace,
+                labels: this.getLabels(),
+            },
+            spec: {
+                template: {
+                    metadata: {
+                        labels: this.getLabels(),
+                    },
+                    spec: {
+                        ...this.buildPodSpec(container, volumes),
+                        restartPolicy: 'OnFailure',
+                    },
+                },
+            },
+        };
+    }
+    buildCronJob(container, volumes) {
+        return {
+            apiVersion: 'batch/v1',
+            kind: 'CronJob',
+            metadata: {
+                name: this.config.appName,
+                namespace: this.config.namespace,
+                labels: this.getLabels(),
+            },
+            spec: {
+                schedule: '0 * * * *', // Default: every hour
+                jobTemplate: {
+                    spec: {
+                        template: {
+                            metadata: {
+                                labels: this.getLabels(),
+                            },
+                            spec: {
+                                ...this.buildPodSpec(container, volumes),
+                                restartPolicy: 'OnFailure',
+                            },
+                        },
+                    },
+                },
+            },
+        };
+    }
+    generateService() {
+        const manifest = {
+            apiVersion: 'v1',
+            kind: 'Service',
+            metadata: {
+                name: this.config.appName,
+                namespace: this.config.namespace,
+                labels: this.getLabels(),
+            },
+            spec: {
+                type: this.config.serviceType,
+                ports: [
+                    {
+                        port: this.config.containerPort,
+                        targetPort: 'http',
+                        protocol: 'TCP',
+                        name: 'http',
+                    },
+                ],
+                selector: this.getSelectorLabels(),
+            },
+        };
+        return {
+            name: 'service',
+            kind: 'Service',
+            content: yaml.dump(manifest),
+        };
+    }
+    generateIngress() {
+        const manifest = {
+            apiVersion: 'networking.k8s.io/v1',
+            kind: 'Ingress',
+            metadata: {
+                name: this.config.appName,
+                namespace: this.config.namespace,
+                labels: this.getLabels(),
+                annotations: {
+                    'kubernetes.io/ingress.class': 'nginx',
+                },
+            },
+            spec: {
+                rules: [
+                    {
+                        host: this.config.ingressHost || `${this.config.appName}.example.com`,
+                        http: {
+                            paths: [
+                                {
+                                    path: '/',
+                                    pathType: 'Prefix',
+                                    backend: {
+                                        service: {
+                                            name: this.config.appName,
+                                            port: {
+                                                number: this.config.containerPort,
+                                            },
+                                        },
+                                    },
+                                },
+                            ],
+                        },
+                    },
+                ],
+            },
+        };
+        return {
+            name: 'ingress',
+            kind: 'Ingress',
+            content: yaml.dump(manifest),
+        };
+    }
+    generateHPA() {
+        const manifest = {
+            apiVersion: 'autoscaling/v2',
+            kind: 'HorizontalPodAutoscaler',
+            metadata: {
+                name: this.config.appName,
+                namespace: this.config.namespace,
+                labels: this.getLabels(),
+            },
+            spec: {
+                scaleTargetRef: {
+                    apiVersion: 'apps/v1',
+                    kind: 'Deployment',
+                    name: this.config.appName,
+                },
+                minReplicas: this.config.hpa?.minReplicas || 1,
+                maxReplicas: this.config.hpa?.maxReplicas || 10,
+                metrics: [
+                    {
+                        type: 'Resource',
+                        resource: {
+                            name: 'cpu',
+                            target: {
+                                type: 'Utilization',
+                                averageUtilization: this.config.hpa?.targetCPUUtilization || 80,
+                            },
+                        },
+                    },
+                ],
+            },
+        };
+        return {
+            name: 'hpa',
+            kind: 'HorizontalPodAutoscaler',
+            content: yaml.dump(manifest),
+        };
+    }
+    generatePDB() {
+        const manifest = {
+            apiVersion: 'policy/v1',
+            kind: 'PodDisruptionBudget',
+            metadata: {
+                name: this.config.appName,
+                namespace: this.config.namespace,
+                labels: this.getLabels(),
+            },
+            spec: {
+                minAvailable: this.config.pdb?.minAvailable || 1,
+                selector: {
+                    matchLabels: this.getSelectorLabels(),
+                },
+            },
+        };
+        return {
+            name: 'pdb',
+            kind: 'PodDisruptionBudget',
+            content: yaml.dump(manifest),
+        };
+    }
+    generateRole() {
+        const rules = this.config.rbac?.rules || [
+            {
+                apiGroups: [''],
+                resources: ['pods', 'services', 'configmaps'],
+                verbs: ['get', 'list', 'watch'],
+            },
+        ];
+        const manifest = {
+            apiVersion: 'rbac.authorization.k8s.io/v1',
+            kind: 'Role',
+            metadata: {
+                name: `${this.config.appName}-role`,
+                namespace: this.config.namespace,
+                labels: this.getLabels(),
+            },
+            rules,
+        };
+        return {
+            name: 'role',
+            kind: 'Role',
+            content: yaml.dump(manifest),
+        };
+    }
+    generateRoleBinding() {
+        const manifest = {
+            apiVersion: 'rbac.authorization.k8s.io/v1',
+            kind: 'RoleBinding',
+            metadata: {
+                name: `${this.config.appName}-rolebinding`,
+                namespace: this.config.namespace,
+                labels: this.getLabels(),
+            },
+            subjects: [
+                {
+                    kind: 'ServiceAccount',
+                    name: this.config.serviceAccount?.name || this.config.appName,
+                    namespace: this.config.namespace,
+                },
+            ],
+            roleRef: {
+                kind: 'Role',
+                name: `${this.config.appName}-role`,
+                apiGroup: 'rbac.authorization.k8s.io',
+            },
+        };
+        return {
+            name: 'rolebinding',
+            kind: 'RoleBinding',
+            content: yaml.dump(manifest),
+        };
+    }
+    generateClusterRole() {
+        const rules = this.config.rbac?.rules || [
+            {
+                apiGroups: [''],
+                resources: ['pods', 'services', 'configmaps'],
+                verbs: ['get', 'list', 'watch'],
+            },
+        ];
+        const manifest = {
+            apiVersion: 'rbac.authorization.k8s.io/v1',
+            kind: 'ClusterRole',
+            metadata: {
+                name: `${this.config.appName}-clusterrole`,
+                labels: this.getLabels(),
+            },
+            rules,
+        };
+        return {
+            name: 'clusterrole',
+            kind: 'ClusterRole',
+            content: yaml.dump(manifest),
+        };
+    }
+    generateClusterRoleBinding() {
+        const manifest = {
+            apiVersion: 'rbac.authorization.k8s.io/v1',
+            kind: 'ClusterRoleBinding',
+            metadata: {
+                name: `${this.config.appName}-clusterrolebinding`,
+                labels: this.getLabels(),
+            },
+            subjects: [
+                {
+                    kind: 'ServiceAccount',
+                    name: this.config.serviceAccount?.name || this.config.appName,
+                    namespace: this.config.namespace,
+                },
+            ],
+            roleRef: {
+                kind: 'ClusterRole',
+                name: `${this.config.appName}-clusterrole`,
+                apiGroup: 'rbac.authorization.k8s.io',
+            },
+        };
+        return {
+            name: 'clusterrolebinding',
+            kind: 'ClusterRoleBinding',
+            content: yaml.dump(manifest),
+        };
+    }
+    generateNetworkPolicy() {
+        const spec = {
+            podSelector: {
+                matchLabels: this.getSelectorLabels(),
+            },
+            policyTypes: [],
+        };
+        if (this.config.networkPolicy?.ingressRules) {
+            spec.policyTypes.push('Ingress');
+            spec.ingress = this.config.networkPolicy.ingressRules;
+        }
+        else {
+            spec.policyTypes.push('Ingress');
+            spec.ingress = [
+                {
+                    from: [
+                        {
+                            podSelector: {
+                                matchLabels: this.getSelectorLabels(),
+                            },
+                        },
+                    ],
+                    ports: [
+                        {
+                            protocol: 'TCP',
+                            port: this.config.containerPort,
+                        },
+                    ],
+                },
+            ];
+        }
+        if (this.config.networkPolicy?.egressRules) {
+            spec.policyTypes.push('Egress');
+            spec.egress = this.config.networkPolicy.egressRules;
+        }
+        const manifest = {
+            apiVersion: 'networking.k8s.io/v1',
+            kind: 'NetworkPolicy',
+            metadata: {
+                name: `${this.config.appName}-netpol`,
+                namespace: this.config.namespace,
+                labels: this.getLabels(),
+            },
+            spec,
+        };
+        return {
+            name: 'networkpolicy',
+            kind: 'NetworkPolicy',
+            content: yaml.dump(manifest),
+        };
+    }
+    generatePersistentVolumeClaim() {
+        const manifest = {
+            apiVersion: 'v1',
+            kind: 'PersistentVolumeClaim',
+            metadata: {
+                name: `${this.config.appName}-pvc`,
+                namespace: this.config.namespace,
+                labels: this.getLabels(),
+            },
+            spec: {
+                accessModes: this.config.persistence?.accessModes || ['ReadWriteOnce'],
+                storageClassName: this.config.persistence?.storageClass || 'standard',
+                resources: {
+                    requests: {
+                        storage: this.config.persistence?.size || '10Gi',
+                    },
+                },
+            },
+        };
+        return {
+            name: 'pvc',
+            kind: 'PersistentVolumeClaim',
+            content: yaml.dump(manifest),
+        };
+    }
+    generateKustomization(manifests) {
+        const kustomization = {
+            apiVersion: 'kustomize.config.k8s.io/v1beta1',
+            kind: 'Kustomization',
+            namespace: this.config.namespace,
+            resources: manifests.map(m => `${m.name}.yaml`),
+            commonLabels: this.getSelectorLabels(),
+        };
+        return yaml.dump(kustomization);
+    }
+}
+/**
+ * Factory function for creating a Kubernetes generator
+ */
+export function createKubernetesGenerator(config) {
+    return new KubernetesGenerator(config);
+}