@oussema_mili/test-pkg-123 1.1.32

package/docker-actions/config-transformer.js

@@ -0,0 +1,380 @@
+/**
+ * Configuration Transformer
+ *
+ * Transforms platform-agnostic deployment configuration into platform-specific formats.
+ * Supports Docker Compose and Helm transformations.
+ */
+
+/**
+ * Transforms deployment config to Docker Compose format
+ * Splits environment variables by scope (container, host, secret)
+ *
+ * @param {Object} deploymentConfig - Universal deployment configuration
+ * @param {Array} deploymentConfig.environment - Environment variables with scopes
+ * @param {Object} deploymentConfig.resources - Resource limits (memory, cpu)
+ * @param {Object} deploymentConfig.scaling - Scaling config (replicas)
+ * @param {Object} deploymentConfig.volumes - Volume configurations
+ * @returns {Object} Docker Compose configuration with separated env vars
+ */
+export function toDockerComposeConfig(deploymentConfig) {
+  if (!deploymentConfig) {
+    return {
+      containerEnv: {},
+      hostEnv: {},
+      secretRefs: {},
+      resources: null,
+      replicas: 1,
+      volumes: null,
+    };
+  }
+
+  const result = {
+    containerEnv: {},
+    hostEnv: {},
+    secretRefs: {},
+    resources: null,
+    replicas: 1,
+    volumes: null,
+  };
+
+  // Process environment variables by scope
+  if (
+    deploymentConfig.environment &&
+    Array.isArray(deploymentConfig.environment)
+  ) {
+    for (const envVar of deploymentConfig.environment) {
+      const { name, value, scope } = envVar;
+
+      // Skip invalid entries
+      if (!name || !value) continue;
+
+      switch (scope) {
+        case "container":
+          result.containerEnv[name] = value;
+          break;
+
+        case "host":
+          result.hostEnv[name] = value;
+          break;
+
+        case "secret":
+          // Store secret references (e.g., "${SECRET_NAME}")
+          // These will be resolved from host environment at runtime
+          result.secretRefs[name] = value;
+          // Also add to container env so docker-compose can interpolate
+          result.containerEnv[name] = value;
+          break;
+
+        default:
+          // Default to container scope
+          result.containerEnv[name] = value;
+      }
+    }
+  }
+
+  // Process resource limits
+  if (deploymentConfig.resources) {
+    result.resources = {
+      memory: deploymentConfig.resources.memory || null,
+      cpu: deploymentConfig.resources.cpu || null,
+    };
+  }
+
+  // Process scaling
+  if (deploymentConfig.scaling && deploymentConfig.scaling.replicas) {
+    result.replicas = deploymentConfig.scaling.replicas;
+  }
+
+  // Process volumes
+  if (deploymentConfig.volumes) {
+    result.volumes = deploymentConfig.volumes;
+  }
+
+  return result;
+}
+
+/**
+ * Generates a bash script to export host environment variables
+ *
+ * @param {Object} hostEnv - Key-value pairs of host environment variables
+ * @returns {string} Bash script content
+ */
+export function generateHostEnvScript(hostEnv) {
+  if (!hostEnv || Object.keys(hostEnv).length === 0) {
+    return "#!/bin/bash\n# No host environment variables configured\n";
+  }
+
+  const lines = ["#!/bin/bash", "# Host environment variables", ""];
+
+  for (const [name, value] of Object.entries(hostEnv)) {
+    // Escape special characters in values
+    const escapedValue = value.replace(/"/g, '\\"').replace(/\$/g, "\\$");
+    lines.push(`export ${name}="${escapedValue}"`);
+  }
+
+  lines.push("");
+  return lines.join("\n");
+}
+
+/**
+ * Generates Docker Compose deploy section for resources and replicas
+ *
+ * @param {Object} resources - Resource limits {memory, cpu}
+ * @param {number} replicas - Number of replicas
+ * @returns {Object|null} Docker Compose deploy configuration
+ */
+export function generateComposeDeploy(resources, replicas) {
+  const deploy = {};
+
+  // Add replicas
+  if (replicas && replicas > 1) {
+    deploy.replicas = replicas;
+  }
+
+  // Add resource limits
+  if (resources && (resources.memory || resources.cpu)) {
+    deploy.resources = {
+      limits: {},
+      reservations: {},
+    };
+
+    if (resources.memory) {
+      deploy.resources.limits.memory = resources.memory;
+      // Set reservations to 50% of limits
+      deploy.resources.reservations.memory = resources.memory;
+    }
+
+    if (resources.cpu) {
+      deploy.resources.limits.cpus = resources.cpu;
+      // Set reservations to 50% of limits
+      const cpuValue = parseFloat(resources.cpu);
+      if (!isNaN(cpuValue)) {
+        deploy.resources.reservations.cpus = (cpuValue * 0.5).toString();
+      }
+    }
+  }
+
+  return Object.keys(deploy).length > 0 ? deploy : null;
+}
+
+/**
+ * Generates .env file content for Docker Compose
+ * Includes both container and secret reference variables
+ *
+ * @param {Object} containerEnv - Container environment variables
+ * @param {Object} secretRefs - Secret reference variables
+ * @returns {string} .env file content
+ */
+export function generateEnvFile(containerEnv, secretRefs) {
+  const lines = ["# Environment variables for Docker Compose", ""];
+
+  // Add container environment variables
+  if (containerEnv && Object.keys(containerEnv).length > 0) {
+    lines.push("# Container environment variables");
+    for (const [name, value] of Object.entries(containerEnv)) {
+      // Skip secret refs (they're added separately)
+      if (secretRefs && secretRefs[name]) continue;
+      lines.push(`${name}=${value}`);
+    }
+    lines.push("");
+  }
+
+  // Add secret references with comments
+  if (secretRefs && Object.keys(secretRefs).length > 0) {
+    lines.push("# Secret references (resolved from host environment)");
+    for (const [name, value] of Object.entries(secretRefs)) {
+      lines.push(`${name}=${value}`);
+    }
+    lines.push("");
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Validates deployment configuration
+ *
+ * @param {Object} deploymentConfig - Universal deployment configuration
+ * @returns {Object} Validation result {valid: boolean, errors: string[]}
+ */
+export function validateDeploymentConfig(deploymentConfig) {
+  const errors = [];
+
+  if (!deploymentConfig) {
+    return { valid: true, errors: [] }; // Config is optional
+  }
+
+  // Validate environment variables
+  if (deploymentConfig.environment) {
+    if (!Array.isArray(deploymentConfig.environment)) {
+      errors.push("environment must be an array");
+    } else {
+      deploymentConfig.environment.forEach((envVar, index) => {
+        if (!envVar.name) {
+          errors.push(`environment[${index}]: name is required`);
+        }
+        if (!envVar.value) {
+          errors.push(`environment[${index}]: value is required`);
+        }
+        if (
+          !envVar.scope ||
+          !["container", "host", "secret"].includes(envVar.scope)
+        ) {
+          errors.push(
+            `environment[${index}]: scope must be 'container', 'host', or 'secret'`
+          );
+        }
+      });
+    }
+  }
+
+  // Validate resources
+  if (deploymentConfig.resources) {
+    const { memory, cpu } = deploymentConfig.resources;
+
+    if (memory && typeof memory !== "string") {
+      errors.push('resources.memory must be a string (e.g., "512Mi", "1Gi")');
+    }
+
+    if (cpu && typeof cpu !== "string") {
+      errors.push('resources.cpu must be a string (e.g., "500m", "1")');
+    }
+  }
+
+  // Validate scaling
+  if (deploymentConfig.scaling) {
+    const { replicas } = deploymentConfig.scaling;
+
+    if (replicas !== undefined) {
+      if (typeof replicas !== "number" || replicas < 1) {
+        errors.push("scaling.replicas must be a number >= 1");
+      }
+    }
+  }
+
+  // Validate volumes
+  if (deploymentConfig.volumes) {
+    if (typeof deploymentConfig.volumes !== "object") {
+      errors.push("volumes must be an object");
+    }
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+  };
+}
+
+/**
+ * Transforms deployment config to Helm values format
+ * (For future Kubernetes deployments)
+ *
+ * @param {Object} deploymentConfig - Universal deployment configuration
+ * @returns {Object} Helm values object
+ */
+export function toHelmValues(deploymentConfig) {
+  if (!deploymentConfig) {
+    return {};
+  }
+
+  const helmValues = {};
+
+  // Process environment variables
+  if (
+    deploymentConfig.environment &&
+    Array.isArray(deploymentConfig.environment)
+  ) {
+    helmValues.env = [];
+
+    for (const envVar of deploymentConfig.environment) {
+      const { name, value, scope } = envVar;
+
+      if (!name || !value) continue;
+
+      switch (scope) {
+        case "container":
+          // Direct environment variable
+          helmValues.env.push({
+            name,
+            value,
+          });
+          break;
+
+        case "secret":
+          // Secret reference - extract secret name and key
+          // Expected format: ${SECRET_NAME} or ${SECRET_NAME:KEY}
+          const secretMatch = value.match(/\$\{([^:}]+)(?::([^}]+))?\}/);
+          if (secretMatch) {
+            const secretName = secretMatch[1];
+            const secretKey = secretMatch[2] || name.toLowerCase();
+
+            helmValues.env.push({
+              name,
+              valueFrom: {
+                secretKeyRef: {
+                  name: secretName,
+                  key: secretKey,
+                },
+              },
+            });
+          } else {
+            // Invalid secret reference, treat as regular value
+            helmValues.env.push({ name, value });
+          }
+          break;
+
+        case "host":
+          // Host env vars don't apply to Kubernetes - skip or warn
+          console.warn(
+            `Host environment variable ${name} will not be included in Helm values`
+          );
+          break;
+
+        default:
+          helmValues.env.push({ name, value });
+      }
+    }
+  }
+
+  // Process resource limits
+  if (deploymentConfig.resources) {
+    helmValues.resources = {
+      limits: {},
+      requests: {},
+    };
+
+    if (deploymentConfig.resources.memory) {
+      helmValues.resources.limits.memory = deploymentConfig.resources.memory;
+      helmValues.resources.requests.memory = deploymentConfig.resources.memory;
+    }
+
+    if (deploymentConfig.resources.cpu) {
+      helmValues.resources.limits.cpu = deploymentConfig.resources.cpu;
+      // Request 50% of CPU limit
+      const cpuValue = parseFloat(deploymentConfig.resources.cpu);
+      if (!isNaN(cpuValue)) {
+        helmValues.resources.requests.cpu = (cpuValue * 0.5).toString();
+      }
+    }
+  }
+
+  // Process scaling
+  if (deploymentConfig.scaling && deploymentConfig.scaling.replicas) {
+    helmValues.replicaCount = deploymentConfig.scaling.replicas;
+  }
+
+  // Process volumes
+  if (deploymentConfig.volumes) {
+    helmValues.persistence = {};
+
+    for (const [name, size] of Object.entries(deploymentConfig.volumes)) {
+      helmValues.persistence[name] = {
+        enabled: true,
+        size,
+        accessMode: "ReadWriteOnce",
+      };
+    }
+  }
+
+  return helmValues;
+}