kubetsx 0.1.0

package/dist/render.js

@@ -0,0 +1,746 @@
+/**
+ * 🎯 Kubetsx - YAML Render Engine
+ *
+ * Transforms JSX element tree into Kubernetes YAML manifests
+ */
+import { stringify } from 'yaml';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+// ============================================================================
+// Main Render Function
+// ============================================================================
+/**
+ * Render a Kubex JSX tree to Kubernetes YAML
+ */
+export function render(element, options = {}) {
+    const resources = processElement(element, {});
+    const yamls = resources.map(r => stringify(r, { indent: 2 }));
+    const output = yamls.join('---\n');
+    if (options.output && !options.dryRun) {
+        if (options.splitFiles) {
+            // Write each resource to a separate file
+            resources.forEach((resource, i) => {
+                const filename = `${resource.metadata.name}-${resource.kind.toLowerCase()}.yaml`;
+                const filepath = path.join(options.output, filename);
+                fs.mkdirSync(options.output, { recursive: true });
+                fs.writeFileSync(filepath, stringify(resource, { indent: 2 }));
+                console.log(`✅ Generated: ${filepath}`);
+            });
+        }
+        else {
+            // Write all resources to a single file
+            fs.mkdirSync(path.dirname(options.output), { recursive: true });
+            fs.writeFileSync(options.output, output);
+            console.log(`✅ Generated: ${options.output}`);
+        }
+    }
+    else if (!options.dryRun) {
+        console.log(output);
+    }
+    return output;
+}
+function processElement(node, ctx) {
+    if (!node || typeof node !== 'object' || !('type' in node)) {
+        return [];
+    }
+    const element = node;
+    // Handle function components
+    if (typeof element.type === 'function') {
+        const result = element.type({ ...element.props, children: element.children });
+        return result ? processElement(result, ctx) : [];
+    }
+    const type = element.type;
+    const props = element.props;
+    const children = element.children;
+    switch (type) {
+        case 'Fragment':
+        case 'Manifest':
+            return children.flatMap(child => processElement(child, ctx));
+        case 'Cluster':
+            return children.flatMap(child => processElement(child, ctx));
+        case 'Namespace':
+            return processNamespace(props, children, ctx);
+        case 'Deployment':
+            return processDeployment(props, children, ctx);
+        case 'Service':
+            return [processService(props, ctx)];
+        case 'Ingress':
+            return [processIngress(props, children, ctx)];
+        case 'ConfigMap':
+            return [processConfigMap(props, ctx)];
+        case 'Secret':
+            return [processSecret(props, ctx)];
+        case 'Pvc':
+            return [processPvc(props, ctx)];
+        case 'Hpa':
+            return [processHpa(props, ctx)];
+        case 'Job':
+            return processJob(props, children, ctx);
+        case 'CronJob':
+            return processCronJob(props, children, ctx);
+        case 'ServiceAccount':
+            return [processServiceAccount(props, ctx)];
+        case 'Role':
+            return [processRole(props, ctx)];
+        case 'ClusterRole':
+            return [processClusterRole(props, ctx)];
+        case 'RoleBinding':
+            return [processRoleBinding(props, ctx)];
+        case 'ClusterRoleBinding':
+            return [processClusterRoleBinding(props, ctx)];
+        default:
+            // Unknown element, process children
+            return children.flatMap(child => processElement(child, ctx));
+    }
+}
+// ============================================================================
+// Resource Processors
+// ============================================================================
+function processNamespace(props, children, ctx) {
+    const name = props.name;
+    const labels = props.labels;
+    const nsResource = {
+        apiVersion: 'v1',
+        kind: 'Namespace',
+        metadata: { name, labels },
+    };
+    const childResources = children.flatMap(child => processElement(child, { ...ctx, namespace: name }));
+    return [nsResource, ...childResources];
+}
+function processDeployment(props, children, ctx) {
+    const name = props.name;
+    const namespace = props.namespace || ctx.namespace;
+    const replicas = props.replicas ?? 1;
+    const labels = { app: name, ...props.labels };
+    const annotations = props.annotations;
+    const selector = props.selector || { app: name };
+    const strategy = props.strategy;
+    // Process children to extract containers, volumes, etc.
+    const containers = [];
+    const volumes = [];
+    for (const child of children) {
+        processDeploymentChild(child, containers, volumes, ctx);
+    }
+    const resource = {
+        apiVersion: 'apps/v1',
+        kind: 'Deployment',
+        metadata: {
+            name,
+            namespace,
+            labels,
+            annotations,
+        },
+        spec: {
+            replicas,
+            selector: { matchLabels: selector },
+            ...(strategy && { strategy: { type: strategy } }),
+            template: {
+                metadata: { labels },
+                spec: {
+                    containers,
+                    ...(volumes.length > 0 && { volumes }),
+                },
+            },
+        },
+    };
+    return [resource];
+}
+function processDeploymentChild(node, containers, volumes, ctx) {
+    if (!node || typeof node !== 'object' || !('type' in node))
+        return;
+    const element = node;
+    // Handle function components
+    if (typeof element.type === 'function') {
+        const result = element.type({ ...element.props, children: element.children });
+        if (result)
+            processDeploymentChild(result, containers, volumes, ctx);
+        return;
+    }
+    const type = element.type;
+    if (type === 'Fragment') {
+        for (const child of element.children) {
+            processDeploymentChild(child, containers, volumes, ctx);
+        }
+        return;
+    }
+    if (type === 'Container') {
+        containers.push(processContainer(element));
+        return;
+    }
+    if (type === 'Volume') {
+        volumes.push(processVolume(element));
+        return;
+    }
+}
+function processContainer(element) {
+    const props = element.props;
+    const children = element.children;
+    const container = {
+        name: props.name,
+        image: props.image,
+    };
+    if (props.imagePullPolicy)
+        container.imagePullPolicy = props.imagePullPolicy;
+    if (props.command)
+        container.command = props.command;
+    if (props.args)
+        container.args = props.args;
+    if (props.workingDir)
+        container.workingDir = props.workingDir;
+    // Process children
+    for (const child of children) {
+        processContainerChild(child, container);
+    }
+    return container;
+}
+function processContainerChild(node, container) {
+    if (!node || typeof node !== 'object' || !('type' in node))
+        return;
+    const element = node;
+    if (typeof element.type === 'function') {
+        const result = element.type({ ...element.props, children: element.children });
+        if (result)
+            processContainerChild(result, container);
+        return;
+    }
+    const type = element.type;
+    const props = element.props;
+    switch (type) {
+        case 'Fragment':
+            for (const child of element.children) {
+                processContainerChild(child, container);
+            }
+            break;
+        case 'Port':
+            container.ports = container.ports || [];
+            const portEntry = {
+                containerPort: props.container,
+            };
+            if (props.name)
+                portEntry.name = props.name;
+            if (props.protocol)
+                portEntry.protocol = props.protocol;
+            container.ports.push(portEntry);
+            break;
+        case 'Env':
+            container.env = container.env || [];
+            const envEntry = {
+                name: props.name,
+            };
+            if (props.value !== undefined) {
+                envEntry.value = props.value;
+            }
+            else if (element.children.length > 0) {
+                const valueFrom = processEnvChild(element.children[0]);
+                if (valueFrom)
+                    envEntry.valueFrom = valueFrom;
+            }
+            container.env.push(envEntry);
+            break;
+        case 'Resources':
+            const requests = {};
+            const limits = {};
+            if (props.requestMemory)
+                requests.memory = props.requestMemory;
+            if (props.requestCpu)
+                requests.cpu = props.requestCpu;
+            if (props.requestEphemeralStorage)
+                requests['ephemeral-storage'] = props.requestEphemeralStorage;
+            if (props.limitMemory)
+                limits.memory = props.limitMemory;
+            if (props.limitCpu)
+                limits.cpu = props.limitCpu;
+            if (props.limitEphemeralStorage)
+                limits['ephemeral-storage'] = props.limitEphemeralStorage;
+            container.resources = { requests, limits };
+            break;
+        case 'Probe':
+            const probeType = props.type;
+            const probe = processProbe(element);
+            if (probeType === 'liveness')
+                container.livenessProbe = probe;
+            else if (probeType === 'readiness')
+                container.readinessProbe = probe;
+            else if (probeType === 'startup')
+                container.startupProbe = probe;
+            break;
+        case 'VolumeMount':
+            container.volumeMounts = container.volumeMounts || [];
+            const volumeMount = {
+                name: props.name,
+                mountPath: props.mountPath,
+            };
+            if (props.subPath)
+                volumeMount.subPath = props.subPath;
+            if (props.readOnly)
+                volumeMount.readOnly = props.readOnly;
+            container.volumeMounts.push(volumeMount);
+            break;
+    }
+}
+function resolveElement(node) {
+    if (!node || typeof node !== 'object' || !('type' in node))
+        return null;
+    let element = node;
+    // If type is a function component, call it to get the actual element
+    while (typeof element.type === 'function') {
+        const result = element.type({ ...element.props, children: element.children });
+        if (!result || typeof result !== 'object' || !('type' in result))
+            return null;
+        element = result;
+    }
+    return element;
+}
+function processEnvChild(node) {
+    const element = resolveElement(node);
+    if (!element)
+        return null;
+    const type = element.type;
+    const props = element.props;
+    if (type === 'SecretRef') {
+        return {
+            secretKeyRef: {
+                name: props.name,
+                key: props.secretKey,
+            },
+        };
+    }
+    if (type === 'ConfigMapRef') {
+        return {
+            configMapKeyRef: {
+                name: props.name,
+                key: props.configKey,
+            },
+        };
+    }
+    return null;
+}
+function processProbe(element) {
+    const props = element.props;
+    const children = element.children;
+    const probe = {};
+    if (props.delay)
+        probe.initialDelaySeconds = props.delay;
+    if (props.period)
+        probe.periodSeconds = props.period;
+    if (props.timeout)
+        probe.timeoutSeconds = props.timeout;
+    if (props.successThreshold)
+        probe.successThreshold = props.successThreshold;
+    if (props.failureThreshold)
+        probe.failureThreshold = props.failureThreshold;
+    for (const child of children) {
+        const childEl = resolveElement(child);
+        if (!childEl)
+            continue;
+        const type = childEl.type;
+        const childProps = childEl.props;
+        if (type === 'HttpProbe') {
+            const httpGet = {
+                path: childProps.path,
+                port: childProps.port,
+            };
+            if (childProps.scheme)
+                httpGet.scheme = childProps.scheme;
+            probe.httpGet = httpGet;
+        }
+        else if (type === 'TcpProbe') {
+            probe.tcpSocket = { port: childProps.port };
+        }
+        else if (type === 'ExecProbe') {
+            probe.exec = { command: childProps.command };
+        }
+    }
+    return probe;
+}
+function processVolume(element) {
+    const name = element.props.name;
+    const volume = { name };
+    for (const child of element.children) {
+        const childEl = resolveElement(child);
+        if (!childEl)
+            continue;
+        const type = childEl.type;
+        const props = childEl.props;
+        if (type === 'EmptyDir') {
+            const emptyDir = {};
+            if (props.medium)
+                emptyDir.medium = props.medium;
+            if (props.sizeLimit)
+                emptyDir.sizeLimit = props.sizeLimit;
+            volume.emptyDir = emptyDir;
+        }
+        else if (type === 'PvcVolume') {
+            const pvc = {
+                claimName: props.claimName,
+            };
+            if (props.readOnly)
+                pvc.readOnly = props.readOnly;
+            volume.persistentVolumeClaim = pvc;
+        }
+        else if (type === 'ConfigMapVolume') {
+            const configMap = {
+                name: props.name,
+            };
+            if (props.items)
+                configMap.items = props.items;
+            volume.configMap = configMap;
+        }
+        else if (type === 'SecretVolume') {
+            const secret = {
+                secretName: props.secretName,
+            };
+            if (props.items)
+                secret.items = props.items;
+            volume.secret = secret;
+        }
+    }
+    return volume;
+}
+function processService(props, ctx) {
+    const name = props.name;
+    const namespace = props.namespace || ctx.namespace;
+    const type = props.type || 'ClusterIP';
+    const port = props.port;
+    const targetPort = props.targetPort || port;
+    const nodePort = props.nodePort;
+    const selector = props.selector || { app: name };
+    const labels = props.labels;
+    return {
+        apiVersion: 'v1',
+        kind: 'Service',
+        metadata: { name, namespace, labels },
+        spec: {
+            type,
+            selector,
+            ports: [
+                {
+                    port,
+                    targetPort,
+                    ...(nodePort && { nodePort }),
+                },
+            ],
+        },
+    };
+}
+function processIngress(props, children, ctx) {
+    const name = props.name;
+    const namespace = props.namespace || ctx.namespace;
+    const className = props.className;
+    const ssl = props.ssl;
+    const annotations = {
+        ...(ssl && { 'nginx.ingress.kubernetes.io/ssl-redirect': 'true' }),
+        ...props.annotations,
+    };
+    const rules = [];
+    const tls = [];
+    for (const child of children) {
+        const childEl = resolveElement(child);
+        if (!childEl)
+            continue;
+        const childType = childEl.type;
+        if (childType === 'IngressHost') {
+            const host = childEl.props.host;
+            const paths = [];
+            for (const routeChild of childEl.children) {
+                const routeEl = resolveElement(routeChild);
+                if (!routeEl)
+                    continue;
+                if (routeEl.type === 'Route') {
+                    paths.push({
+                        path: routeEl.props.path,
+                        pathType: routeEl.props.pathType || 'Prefix',
+                        backend: {
+                            service: {
+                                name: routeEl.props.service,
+                                port: { number: routeEl.props.port },
+                            },
+                        },
+                    });
+                }
+            }
+            rules.push({ host, http: { paths } });
+            if (ssl) {
+                tls.push({ hosts: [host], secretName: `${name}-tls` });
+            }
+        }
+        else if (childType === 'Route') {
+            // Direct route without host wrapper
+            const hostFromProps = props.host;
+            if (hostFromProps) {
+                const existingRule = rules.find((r) => r.host === hostFromProps);
+                if (existingRule) {
+                    existingRule.http.paths.push({
+                        path: childEl.props.path,
+                        pathType: childEl.props.pathType || 'Prefix',
+                        backend: {
+                            service: {
+                                name: childEl.props.service,
+                                port: { number: childEl.props.port },
+                            },
+                        },
+                    });
+                }
+                else {
+                    rules.push({
+                        host: hostFromProps,
+                        http: {
+                            paths: [{
+                                    path: childEl.props.path,
+                                    pathType: childEl.props.pathType || 'Prefix',
+                                    backend: {
+                                        service: {
+                                            name: childEl.props.service,
+                                            port: { number: childEl.props.port },
+                                        },
+                                    },
+                                }],
+                        },
+                    });
+                    if (ssl) {
+                        tls.push({ hosts: [hostFromProps], secretName: `${name}-tls` });
+                    }
+                }
+            }
+        }
+    }
+    return {
+        apiVersion: 'networking.k8s.io/v1',
+        kind: 'Ingress',
+        metadata: { name, namespace, annotations },
+        spec: {
+            ...(className && { ingressClassName: className }),
+            rules,
+            ...(tls.length > 0 && { tls }),
+        },
+    };
+}
+function processConfigMap(props, ctx) {
+    const name = props.name;
+    const namespace = props.namespace || ctx.namespace;
+    const data = props.data;
+    const labels = props.labels;
+    return {
+        apiVersion: 'v1',
+        kind: 'ConfigMap',
+        metadata: { name, namespace, labels },
+        data,
+    };
+}
+function processSecret(props, ctx) {
+    const name = props.name;
+    const namespace = props.namespace || ctx.namespace;
+    const type = props.type || 'Opaque';
+    const data = props.data;
+    const stringData = props.stringData;
+    const labels = props.labels;
+    return {
+        apiVersion: 'v1',
+        kind: 'Secret',
+        metadata: { name, namespace, labels },
+        ...(type && { type }),
+        ...(data && { data }),
+        ...(stringData && { stringData }),
+    };
+}
+function processPvc(props, ctx) {
+    const name = props.name;
+    const namespace = props.namespace || ctx.namespace;
+    const storage = props.storage;
+    const accessModes = props.accessModes || ['ReadWriteOnce'];
+    const storageClassName = props.storageClassName;
+    const labels = props.labels;
+    return {
+        apiVersion: 'v1',
+        kind: 'PersistentVolumeClaim',
+        metadata: { name, namespace, labels },
+        spec: {
+            accessModes,
+            resources: {
+                requests: { storage },
+            },
+            ...(storageClassName && { storageClassName }),
+        },
+    };
+}
+function processHpa(props, ctx) {
+    const name = props.name;
+    const namespace = props.namespace || ctx.namespace;
+    const target = props.target;
+    const minReplicas = props.minReplicas || 1;
+    const maxReplicas = props.maxReplicas;
+    const targetCpuUtilization = props.targetCpuUtilization;
+    const targetMemoryUtilization = props.targetMemoryUtilization;
+    const metrics = [];
+    if (targetCpuUtilization) {
+        metrics.push({
+            type: 'Resource',
+            resource: {
+                name: 'cpu',
+                target: { type: 'Utilization', averageUtilization: targetCpuUtilization },
+            },
+        });
+    }
+    if (targetMemoryUtilization) {
+        metrics.push({
+            type: 'Resource',
+            resource: {
+                name: 'memory',
+                target: { type: 'Utilization', averageUtilization: targetMemoryUtilization },
+            },
+        });
+    }
+    return {
+        apiVersion: 'autoscaling/v2',
+        kind: 'HorizontalPodAutoscaler',
+        metadata: { name, namespace },
+        spec: {
+            scaleTargetRef: {
+                apiVersion: 'apps/v1',
+                kind: 'Deployment',
+                name: target,
+            },
+            minReplicas,
+            maxReplicas,
+            ...(metrics.length > 0 && { metrics }),
+        },
+    };
+}
+function processJob(props, children, ctx) {
+    const name = props.name;
+    const namespace = props.namespace || ctx.namespace;
+    const backoffLimit = props.backoffLimit;
+    const ttlSecondsAfterFinished = props.ttlSecondsAfterFinished;
+    const labels = props.labels;
+    const containers = [];
+    const volumes = [];
+    for (const child of children) {
+        processDeploymentChild(child, containers, volumes, ctx);
+    }
+    return [{
+            apiVersion: 'batch/v1',
+            kind: 'Job',
+            metadata: { name, namespace, labels },
+            spec: {
+                ...(backoffLimit !== undefined && { backoffLimit }),
+                ...(ttlSecondsAfterFinished !== undefined && { ttlSecondsAfterFinished }),
+                template: {
+                    spec: {
+                        containers,
+                        restartPolicy: 'Never',
+                        ...(volumes.length > 0 && { volumes }),
+                    },
+                },
+            },
+        }];
+}
+function processCronJob(props, children, ctx) {
+    const name = props.name;
+    const namespace = props.namespace || ctx.namespace;
+    const schedule = props.schedule;
+    const concurrencyPolicy = props.concurrencyPolicy;
+    const suspend = props.suspend;
+    const labels = props.labels;
+    const containers = [];
+    const volumes = [];
+    for (const child of children) {
+        processDeploymentChild(child, containers, volumes, ctx);
+    }
+    return [{
+            apiVersion: 'batch/v1',
+            kind: 'CronJob',
+            metadata: { name, namespace, labels },
+            spec: {
+                schedule,
+                ...(concurrencyPolicy && { concurrencyPolicy }),
+                ...(suspend !== undefined && { suspend }),
+                jobTemplate: {
+                    spec: {
+                        template: {
+                            spec: {
+                                containers,
+                                restartPolicy: 'Never',
+                                ...(volumes.length > 0 && { volumes }),
+                            },
+                        },
+                    },
+                },
+            },
+        }];
+}
+function processServiceAccount(props, ctx) {
+    const name = props.name;
+    const namespace = props.namespace || ctx.namespace;
+    const labels = props.labels;
+    return {
+        apiVersion: 'v1',
+        kind: 'ServiceAccount',
+        metadata: { name, namespace, labels },
+    };
+}
+function processRole(props, ctx) {
+    const name = props.name;
+    const namespace = props.namespace || ctx.namespace;
+    const rules = props.rules;
+    const labels = props.labels;
+    return {
+        apiVersion: 'rbac.authorization.k8s.io/v1',
+        kind: 'Role',
+        metadata: { name, namespace, labels },
+        rules,
+    };
+}
+function processClusterRole(props, ctx) {
+    const name = props.name;
+    const rules = props.rules;
+    const labels = props.labels;
+    return {
+        apiVersion: 'rbac.authorization.k8s.io/v1',
+        kind: 'ClusterRole',
+        metadata: { name, labels },
+        rules,
+    };
+}
+function processRoleBinding(props, ctx) {
+    const name = props.name;
+    const namespace = props.namespace || ctx.namespace;
+    const roleRef = props.roleRef;
+    const subjects = props.subjects;
+    return {
+        apiVersion: 'rbac.authorization.k8s.io/v1',
+        kind: 'RoleBinding',
+        metadata: { name, namespace },
+        roleRef: {
+            apiGroup: 'rbac.authorization.k8s.io',
+            kind: roleRef.kind,
+            name: roleRef.name,
+        },
+        subjects: subjects.map(s => ({
+            kind: s.kind,
+            name: s.name,
+            ...(s.namespace && { namespace: s.namespace }),
+        })),
+    };
+}
+function processClusterRoleBinding(props, ctx) {
+    const name = props.name;
+    const roleRef = props.roleRef;
+    const subjects = props.subjects;
+    return {
+        apiVersion: 'rbac.authorization.k8s.io/v1',
+        kind: 'ClusterRoleBinding',
+        metadata: { name },
+        roleRef: {
+            apiGroup: 'rbac.authorization.k8s.io',
+            kind: roleRef.kind,
+            name: roleRef.name,
+        },
+        subjects: subjects.map(s => ({
+            kind: s.kind,
+            name: s.name,
+            ...(s.namespace && { namespace: s.namespace }),
+        })),
+    };
+}
+export default render;
+//# sourceMappingURL=render.js.map