kubetsx 0.1.2 → 0.1.3

package/src/render.ts

@@ -1,863 +0,0 @@
-/**
- * 🎯 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';
-import type { 
-  KubexElement, 
-  KubexNode, 
-  K8sResource, 
-  RenderOptions,
-  ParsedContainer,
-  ParsedVolume 
-} from './types.js';
-
-// ============================================================================
-// Main Render Function
-// ============================================================================
-
-/**
- * Render a Kubex JSX tree to Kubernetes YAML
- */
-export function render(element: KubexElement, options: RenderOptions = {}): string {
-  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 }));
-        process.stderr.write(`✅ Generated: ${filepath}\n`);
-      });
-    } else {
-      // Write all resources to a single file
-      fs.mkdirSync(path.dirname(options.output), { recursive: true });
-      fs.writeFileSync(options.output, output);
-      process.stderr.write(`✅ Generated: ${options.output}\n`);
-    }
-  } else if (!options.dryRun) {
-    // Write YAML to stdout (clean output for piping)
-    process.stdout.write(output + '\n');
-  }
-
-  return output;
-}
-
-// ============================================================================
-// Element Processing
-// ============================================================================
-
-interface ProcessContext {
-  namespace?: string;
-  labels?: Record<string, string>;
-  currentDeployment?: Partial<K8sResource>;
-  containers?: ParsedContainer[];
-  volumes?: ParsedVolume[];
-}
-
-function processElement(node: KubexNode, ctx: ProcessContext): K8sResource[] {
-  if (!node || typeof node !== 'object' || !('type' in node)) {
-    return [];
-  }
-
-  const element = node as KubexElement;
-  
-  // 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 as string;
-  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: Record<string, unknown>,
-  children: KubexNode[],
-  ctx: ProcessContext
-): K8sResource[] {
-  const name = props.name as string;
-  const labels = props.labels as Record<string, string> | undefined;
-
-  const nsResource: K8sResource = {
-    apiVersion: 'v1',
-    kind: 'Namespace',
-    metadata: { name, labels },
-  };
-
-  const childResources = children.flatMap(child => 
-    processElement(child, { ...ctx, namespace: name })
-  );
-
-  return [nsResource, ...childResources];
-}
-
-function processDeployment(
-  props: Record<string, unknown>,
-  children: KubexNode[],
-  ctx: ProcessContext
-): K8sResource[] {
-  const name = props.name as string;
-  const namespace = (props.namespace as string) || ctx.namespace;
-  const replicas = (props.replicas as number) ?? 1;
-  const labels = { app: name, ...(props.labels as Record<string, string>) };
-  const annotations = props.annotations as Record<string, string> | undefined;
-  const selector = (props.selector as Record<string, string>) || { app: name };
-  const strategy = props.strategy as string | undefined;
-
-  // Process children to extract containers, volumes, etc.
-  const containers: ParsedContainer[] = [];
-  const volumes: ParsedVolume[] = [];
-
-  for (const child of children) {
-    processDeploymentChild(child, containers, volumes, ctx);
-  }
-
-  const resource: K8sResource = {
-    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: KubexNode,
-  containers: ParsedContainer[],
-  volumes: ParsedVolume[],
-  ctx: ProcessContext
-): void {
-  if (!node || typeof node !== 'object' || !('type' in node)) return;
-
-  const element = node as KubexElement;
-
-  // 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 as string;
-
-  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: KubexElement): ParsedContainer {
-  const props = element.props;
-  const children = element.children;
-
-  const container: ParsedContainer = {
-    name: props.name as string,
-    image: props.image as string,
-  };
-
-  if (props.imagePullPolicy) container.imagePullPolicy = props.imagePullPolicy as string;
-  if (props.command) container.command = props.command as string[];
-  if (props.args) container.args = props.args as string[];
-  if (props.workingDir) container.workingDir = props.workingDir as string;
-
-  // Process children
-  for (const child of children) {
-    processContainerChild(child, container);
-  }
-
-  return container;
-}
-
-function processContainerChild(node: KubexNode, container: ParsedContainer): void {
-  if (!node || typeof node !== 'object' || !('type' in node)) return;
-
-  const element = node as KubexElement;
-
-  if (typeof element.type === 'function') {
-    const result = element.type({ ...element.props, children: element.children });
-    if (result) processContainerChild(result, container);
-    return;
-  }
-
-  const type = element.type as string;
-  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: number; name?: string; protocol?: string } = {
-        containerPort: props.container as number,
-      };
-      if (props.name) portEntry.name = props.name as string;
-      if (props.protocol) portEntry.protocol = props.protocol as string;
-      container.ports.push(portEntry);
-      break;
-
-    case 'Env':
-      container.env = container.env || [];
-      const envEntry: { name: string; value?: string; valueFrom?: unknown } = {
-        name: props.name as string,
-      };
-      if (props.value !== undefined) {
-        envEntry.value = props.value as string;
-      } 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: Record<string, string> = {};
-      const limits: Record<string, string> = {};
-      if (props.requestMemory) requests.memory = props.requestMemory as string;
-      if (props.requestCpu) requests.cpu = props.requestCpu as string;
-      if (props.requestEphemeralStorage) requests['ephemeral-storage'] = props.requestEphemeralStorage as string;
-      if (props.limitMemory) limits.memory = props.limitMemory as string;
-      if (props.limitCpu) limits.cpu = props.limitCpu as string;
-      if (props.limitEphemeralStorage) limits['ephemeral-storage'] = props.limitEphemeralStorage as string;
-      container.resources = { requests, limits };
-      break;
-
-    case 'Probe':
-      const probeType = props.type as string;
-      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: string; mountPath: string; subPath?: string; readOnly?: boolean } = {
-        name: props.name as string,
-        mountPath: props.mountPath as string,
-      };
-      if (props.subPath) volumeMount.subPath = props.subPath as string;
-      if (props.readOnly) volumeMount.readOnly = props.readOnly as boolean;
-      container.volumeMounts.push(volumeMount);
-      break;
-  }
-}
-
-function resolveElement(node: KubexNode): KubexElement | null {
-  if (!node || typeof node !== 'object' || !('type' in node)) return null;
-  
-  let element = node as KubexElement;
-  
-  // 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: KubexNode): unknown {
-  const element = resolveElement(node);
-  if (!element) return null;
-
-  const type = element.type as string;
-  const props = element.props;
-
-  if (type === 'SecretRef') {
-    return {
-      secretKeyRef: {
-        name: props.name as string,
-        key: props.secretKey as string,
-      },
-    };
-  }
-
-  if (type === 'ConfigMapRef') {
-    return {
-      configMapKeyRef: {
-        name: props.name as string,
-        key: props.configKey as string,
-      },
-    };
-  }
-
-  return null;
-}
-
-function processProbe(element: KubexElement): unknown {
-  const props = element.props;
-  const children = element.children;
-
-  const probe: Record<string, unknown> = {};
-
-  if (props.delay) probe.initialDelaySeconds = props.delay as number;
-  if (props.period) probe.periodSeconds = props.period as number;
-  if (props.timeout) probe.timeoutSeconds = props.timeout as number;
-  if (props.successThreshold) probe.successThreshold = props.successThreshold as number;
-  if (props.failureThreshold) probe.failureThreshold = props.failureThreshold as number;
-
-  for (const child of children) {
-    const childEl = resolveElement(child);
-    if (!childEl) continue;
-    
-    const type = childEl.type as string;
-    const childProps = childEl.props;
-
-    if (type === 'HttpProbe') {
-      const httpGet: { path: string; port: number; scheme?: string } = {
-        path: childProps.path as string,
-        port: childProps.port as number,
-      };
-      if (childProps.scheme) httpGet.scheme = childProps.scheme as string;
-      probe.httpGet = httpGet;
-    } else if (type === 'TcpProbe') {
-      probe.tcpSocket = { port: childProps.port as number };
-    } else if (type === 'ExecProbe') {
-      probe.exec = { command: childProps.command as string[] };
-    }
-  }
-
-  return probe;
-}
-
-function processVolume(element: KubexElement): ParsedVolume {
-  const name = element.props.name as string;
-  const volume: ParsedVolume = { name };
-
-  for (const child of element.children) {
-    const childEl = resolveElement(child);
-    if (!childEl) continue;
-    
-    const type = childEl.type as string;
-    const props = childEl.props;
-
-    if (type === 'EmptyDir') {
-      const emptyDir: { medium?: string; sizeLimit?: string } = {};
-      if (props.medium) emptyDir.medium = props.medium as string;
-      if (props.sizeLimit) emptyDir.sizeLimit = props.sizeLimit as string;
-      volume.emptyDir = emptyDir;
-    } else if (type === 'PvcVolume') {
-      const pvc: { claimName: string; readOnly?: boolean } = {
-        claimName: props.claimName as string,
-      };
-      if (props.readOnly) pvc.readOnly = props.readOnly as boolean;
-      volume.persistentVolumeClaim = pvc;
-    } else if (type === 'ConfigMapVolume') {
-      const configMap: { name: string; items?: { key: string; path: string }[] } = {
-        name: props.name as string,
-      };
-      if (props.items) configMap.items = props.items as { key: string; path: string }[];
-      volume.configMap = configMap;
-    } else if (type === 'SecretVolume') {
-      const secret: { secretName: string; items?: { key: string; path: string }[] } = {
-        secretName: props.secretName as string,
-      };
-      if (props.items) secret.items = props.items as { key: string; path: string }[];
-      volume.secret = secret;
-    }
-  }
-
-  return volume;
-}
-
-function processService(props: Record<string, unknown>, ctx: ProcessContext): K8sResource {
-  const name = props.name as string;
-  const namespace = (props.namespace as string) || ctx.namespace;
-  const type = (props.type as string) || 'ClusterIP';
-  const port = props.port as number;
-  const targetPort = (props.targetPort as number) || port;
-  const nodePort = props.nodePort as number | undefined;
-  const selector = (props.selector as Record<string, string>) || { app: name };
-  const labels = props.labels as Record<string, string> | undefined;
-
-  return {
-    apiVersion: 'v1',
-    kind: 'Service',
-    metadata: { name, namespace, labels },
-    spec: {
-      type,
-      selector,
-      ports: [
-        {
-          port,
-          targetPort,
-          ...(nodePort && { nodePort }),
-        },
-      ],
-    },
-  };
-}
-
-function processIngress(
-  props: Record<string, unknown>,
-  children: KubexNode[],
-  ctx: ProcessContext
-): K8sResource {
-  const name = props.name as string;
-  const namespace = (props.namespace as string) || ctx.namespace;
-  const className = props.className as string | undefined;
-  const ssl = props.ssl as boolean | undefined;
-  const annotations = {
-    ...(ssl && { 'nginx.ingress.kubernetes.io/ssl-redirect': 'true' }),
-    ...(props.annotations as Record<string, string>),
-  };
-
-  const rules: unknown[] = [];
-  const tls: unknown[] = [];
-
-  for (const child of children) {
-    const childEl = resolveElement(child);
-    if (!childEl) continue;
-    
-    const childType = childEl.type as string;
-
-    if (childType === 'IngressHost') {
-      const host = childEl.props.host as string;
-      const paths: unknown[] = [];
-
-      for (const routeChild of childEl.children) {
-        const routeEl = resolveElement(routeChild);
-        if (!routeEl) continue;
-        
-        if (routeEl.type === 'Route') {
-          paths.push({
-            path: routeEl.props.path as string,
-            pathType: (routeEl.props.pathType as string) || 'Prefix',
-            backend: {
-              service: {
-                name: routeEl.props.service as string,
-                port: { number: routeEl.props.port as number },
-              },
-            },
-          });
-        }
-      }
-
-      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 as string | undefined;
-      if (hostFromProps) {
-        const existingRule = rules.find((r: any) => r.host === hostFromProps);
-        if (existingRule) {
-          (existingRule as any).http.paths.push({
-            path: childEl.props.path as string,
-            pathType: (childEl.props.pathType as string) || 'Prefix',
-            backend: {
-              service: {
-                name: childEl.props.service as string,
-                port: { number: childEl.props.port as number },
-              },
-            },
-          });
-        } else {
-          rules.push({
-            host: hostFromProps,
-            http: {
-              paths: [{
-                path: childEl.props.path as string,
-                pathType: (childEl.props.pathType as string) || 'Prefix',
-                backend: {
-                  service: {
-                    name: childEl.props.service as string,
-                    port: { number: childEl.props.port as number },
-                  },
-                },
-              }],
-            },
-          });
-          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: Record<string, unknown>, ctx: ProcessContext): K8sResource {
-  const name = props.name as string;
-  const namespace = (props.namespace as string) || ctx.namespace;
-  const data = props.data as Record<string, string> | undefined;
-  const labels = props.labels as Record<string, string> | undefined;
-
-  return {
-    apiVersion: 'v1',
-    kind: 'ConfigMap',
-    metadata: { name, namespace, labels },
-    data,
-  };
-}
-
-function processSecret(props: Record<string, unknown>, ctx: ProcessContext): K8sResource {
-  const name = props.name as string;
-  const namespace = (props.namespace as string) || ctx.namespace;
-  const type = (props.type as string) || 'Opaque';
-  const data = props.data as Record<string, string> | undefined;
-  const stringData = props.stringData as Record<string, string> | undefined;
-  const labels = props.labels as Record<string, string> | undefined;
-
-  return {
-    apiVersion: 'v1',
-    kind: 'Secret',
-    metadata: { name, namespace, labels },
-    ...(type && { type }),
-    ...(data && { data }),
-    ...(stringData && { stringData }),
-  };
-}
-
-function processPvc(props: Record<string, unknown>, ctx: ProcessContext): K8sResource {
-  const name = props.name as string;
-  const namespace = (props.namespace as string) || ctx.namespace;
-  const storage = props.storage as string;
-  const accessModes = (props.accessModes as string[]) || ['ReadWriteOnce'];
-  const storageClassName = props.storageClassName as string | undefined;
-  const labels = props.labels as Record<string, string> | undefined;
-
-  return {
-    apiVersion: 'v1',
-    kind: 'PersistentVolumeClaim',
-    metadata: { name, namespace, labels },
-    spec: {
-      accessModes,
-      resources: {
-        requests: { storage },
-      },
-      ...(storageClassName && { storageClassName }),
-    },
-  };
-}
-
-function processHpa(props: Record<string, unknown>, ctx: ProcessContext): K8sResource {
-  const name = props.name as string;
-  const namespace = (props.namespace as string) || ctx.namespace;
-  const target = props.target as string;
-  const minReplicas = (props.minReplicas as number) || 1;
-  const maxReplicas = props.maxReplicas as number;
-  const targetCpuUtilization = props.targetCpuUtilization as number | undefined;
-  const targetMemoryUtilization = props.targetMemoryUtilization as number | undefined;
-
-  const metrics: unknown[] = [];
-  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: Record<string, unknown>,
-  children: KubexNode[],
-  ctx: ProcessContext
-): K8sResource[] {
-  const name = props.name as string;
-  const namespace = (props.namespace as string) || ctx.namespace;
-  const backoffLimit = props.backoffLimit as number | undefined;
-  const ttlSecondsAfterFinished = props.ttlSecondsAfterFinished as number | undefined;
-  const labels = props.labels as Record<string, string> | undefined;
-
-  const containers: ParsedContainer[] = [];
-  const volumes: ParsedVolume[] = [];
-
-  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: Record<string, unknown>,
-  children: KubexNode[],
-  ctx: ProcessContext
-): K8sResource[] {
-  const name = props.name as string;
-  const namespace = (props.namespace as string) || ctx.namespace;
-  const schedule = props.schedule as string;
-  const concurrencyPolicy = props.concurrencyPolicy as string | undefined;
-  const suspend = props.suspend as boolean | undefined;
-  const labels = props.labels as Record<string, string> | undefined;
-
-  const containers: ParsedContainer[] = [];
-  const volumes: ParsedVolume[] = [];
-
-  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: Record<string, unknown>, ctx: ProcessContext): K8sResource {
-  const name = props.name as string;
-  const namespace = (props.namespace as string) || ctx.namespace;
-  const labels = props.labels as Record<string, string> | undefined;
-
-  return {
-    apiVersion: 'v1',
-    kind: 'ServiceAccount',
-    metadata: { name, namespace, labels },
-  };
-}
-
-function processRole(props: Record<string, unknown>, ctx: ProcessContext): K8sResource {
-  const name = props.name as string;
-  const namespace = (props.namespace as string) || ctx.namespace;
-  const rules = props.rules as { apiGroups: string[]; resources: string[]; verbs: string[] }[];
-  const labels = props.labels as Record<string, string> | undefined;
-
-  return {
-    apiVersion: 'rbac.authorization.k8s.io/v1',
-    kind: 'Role',
-    metadata: { name, namespace, labels },
-    rules,
-  };
-}
-
-function processClusterRole(props: Record<string, unknown>, ctx: ProcessContext): K8sResource {
-  const name = props.name as string;
-  const rules = props.rules as { apiGroups: string[]; resources: string[]; verbs: string[] }[];
-  const labels = props.labels as Record<string, string> | undefined;
-
-  return {
-    apiVersion: 'rbac.authorization.k8s.io/v1',
-    kind: 'ClusterRole',
-    metadata: { name, labels },
-    rules,
-  };
-}
-
-function processRoleBinding(props: Record<string, unknown>, ctx: ProcessContext): K8sResource {
-  const name = props.name as string;
-  const namespace = (props.namespace as string) || ctx.namespace;
-  const roleRef = props.roleRef as { kind: string; name: string };
-  const subjects = props.subjects as { kind: string; name: string; namespace?: string }[];
-
-  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: Record<string, unknown>, ctx: ProcessContext): K8sResource {
-  const name = props.name as string;
-  const roleRef = props.roleRef as { kind: string; name: string };
-  const subjects = props.subjects as { kind: string; name: string; namespace?: string }[];
-
-  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;
-