@kumori/aurora-backend-handler 1.0.0

package/helpers/revision-helper.ts

@@ -0,0 +1,899 @@
+
+import { Account, Container, Environment, Instance, Resource, Service, Usage } from "@hestekumori/aurora-interfaces";
+import { convertToGigabytes, getTimestamp } from "../utils/utils";
+
+interface Role {
+  name: string;
+  instances: Instance[];
+  logo?: string;
+  category?: string;
+  version?: string;
+  description?: string;
+  resource?: any[];
+  parameters?: { [key: string]: string }[];
+  registry?: string;
+  imageTag?: string;
+  entrypoint?: string;
+  cmd?: string;
+  scalling?: {
+    cpu: { up: string; down: string };
+    memory: { up: string; down: string };
+    instances: { max: number; min: number };
+    histeresys: string;
+  };
+  hsize?: number;
+}
+
+interface Revision {
+  service: string;
+  revision: string;
+  usage: Usage;
+  status: {
+    code: string;
+    message: string;
+    timestamp: string;
+    args: string[];
+  };
+  errorCode?: string;
+  errorMsg?: string;
+  createdAt?: string;
+}
+
+interface HandleRevisionEventParams {
+  entityId: string;
+  eventData: any;
+  parentParts: { [entity: string]: string };
+  servicesMap: Map<string, Service>;
+  revisionsMap: Map<string, Revision>;
+  roleMap: Map<string, Role[]>;
+  environmentsMap: Map<string, Environment>;
+  accountsMap: Map<string, Account>;
+}
+
+interface HandleRevisionEventResult {
+  revision: Revision;
+  revisionKey: string;
+  serviceId: string;
+  roles: Role[];
+  updatedService: Service | null;
+  updatedEnvironment: Environment | null;
+  updatedAccount: Account | null;
+  pendingRevisionError: { service: string; revision: Revision } | null;
+  shouldFetchChannels: boolean;
+  channelsFetchInfo: { serviceId: string; tenantId: string } | null;
+  serviceDeployedEvent: Service | null;
+  serviceDeploymentErrorEvent: Service | null;
+}
+
+const MAX_HISTORY = 100;
+
+/**
+ * Process role and instance data from revision event
+ */
+const processRolesAndInstances = (
+  eventData: any,
+  serviceId: string,
+  roleMap: Map<string, Role[]>
+): { roles: Role[]; instances: Instance[]; usedCpu: number; usedMemory: number } => {
+  const roles: Role[] = [];
+  const instances: Instance[] = [];
+  let usedCpu = 0;
+  let usedMemory = 0;
+
+  const roleEntries = eventData.status.runtime
+    ? Object.entries(eventData.status.runtime.roles)
+    : [];
+
+  for (const [roleName, roleData] of roleEntries) {
+    const instanceEntries = Object.entries(
+      (roleData as { instances: Record<string, any> }).instances
+    );
+    const roleInstances: Instance[] = [];
+    const existingRoles = roleMap.get(serviceId) || [];
+    const existingRole = existingRoles.find((r) => r.name === roleName);
+
+    for (const [instanceId, instanceData] of instanceEntries) {
+      const containers: Container[] = [];
+
+      const containerEntries = Object.entries(instanceData.containers || {});
+      for (const [containerName, containerData] of containerEntries) {
+        const container: Container = {
+          name: containerName,
+          ready: (containerData as any).status.ready,
+          reestartCount: (containerData as any).status.restarts,
+          metrics: {
+            cpu: (containerData as any).status.metrics.cpu,
+            memory: (containerData as any).status.metrics.memory,
+          },
+          states: (containerData as any).status.status,
+        };
+        containers.push(container);
+      }
+
+      usedCpu += Number(instanceData.status.metrics.cpu);
+      usedMemory += Number(instanceData.status.metrics.memory);
+
+      const instance: Instance = {
+        id: instanceId,
+        name: `${roleName}::${instanceId}`,
+        status: instanceData.status.status,
+        usage: {
+          current: {
+            cpu: instanceData.status.metrics.cpu,
+            memory: instanceData.status.metrics.memory,
+            storage: 0,
+            volatileStorage: 0,
+            nonReplicatedStorage: 0,
+            persistentStorage: 0,
+          },
+          limit: {
+            cpu: {
+              max: (eventData.spec.roles[roleName]?.cpu || 0) / 1000,
+              min: 0,
+            },
+            memory: {
+              max: (eventData.spec.roles[roleName]?.memory || 0) / 1000,
+              min: 0,
+            },
+            storage: { max: 0, min: 0 },
+            volatileStorage: { max: 0, min: 0 },
+            nonReplicatedStorage: { max: 0, min: 0 },
+            persistentStorage: { max: 0, min: 0 },
+          },
+          cost: 0,
+        },
+        logs: [],
+        containers: containers,
+      };
+
+      roleInstances.push(instance);
+      instances.push(instance);
+    }
+
+    const role: Role = {
+      name: roleName,
+      instances: roleInstances,
+      hsize: (roleData as any).status?.scale || 0,
+      ...(existingRole?.scalling && { scalling: existingRole.scalling }),
+      ...(existingRole?.category && { category: existingRole.category }),
+    };
+
+    roles.push(role);
+  }
+
+  return { roles, instances, usedCpu, usedMemory };
+};
+
+/**
+ * Create a new revision object from event data
+ */
+const createRevision = (
+  entityId: string,
+  parentParts: { [entity: string]: string },
+  eventData: any,
+  usedCpu: number,
+  usedMemory: number
+): Revision => {
+  return {
+    service: parentParts.service,
+    revision: entityId,
+    usage: {
+      current: {
+        cpu: usedCpu,
+        memory: usedMemory,
+        storage: 0,
+        volatileStorage: 0,
+        nonReplicatedStorage: 0,
+        persistentStorage: 0,
+      },
+      limit: {
+        cpu: {
+          max: eventData.spec.intensives?.vcpu / 1000 || 0,
+          min: 0,
+        },
+        memory: {
+          max: eventData.spec.intensives?.ram / 1000 || 0,
+          min: 0,
+        },
+        storage: {
+          max: eventData.spec.intensives?.shared_disk / 1000 || 0,
+          min: 0,
+        },
+        volatileStorage: {
+          max: eventData.spec.intensives?.volatile_disk / 1000 || 0,
+          min: 0,
+        },
+        nonReplicatedStorage: {
+          max: eventData.spec.intensives?.nrpersistent_disk / 1000 || 0,
+          min: 0,
+        },
+        persistentStorage: {
+          max: eventData.spec.intensives?.persistent_disk / 1000 || 0,
+          min: 0,
+        },
+      },
+      cost: 0,
+    },
+    status: eventData.status.state,
+    errorCode:
+      eventData.status && eventData.status.error
+        ? eventData.status.error.code
+        : "",
+    errorMsg:
+      eventData.status && eventData.status.error
+        ? eventData.status.error.message
+        : "",
+    createdAt:
+      (eventData.status && eventData.status.runtime?.status?.createdAt) || "",
+  };
+};
+
+/**
+ * Update service with new revision data
+ */
+const updateServiceWithRevision = (
+  existingService: Service,
+  entityId: string,
+  eventData: any,
+  newRevision: Revision,
+  roles: Role[]
+): { updatedService: Service; deploymentErrorEvent: Service | null } => {
+  const existingRevisionIndex = existingService.revisions.findIndex(
+    (rev) => rev === entityId
+  );
+  const shouldIncludeInList =
+    newRevision.errorCode !== "COMPUTE_ERROR" &&
+    eventData.status?.error?.code !== "COMPUTE_ERROR";
+
+  let updatedRevisions;
+  if (shouldIncludeInList) {
+    updatedRevisions =
+      existingRevisionIndex === -1
+        ? [...existingService.revisions, entityId]
+        : existingService.revisions;
+  } else {
+    updatedRevisions = existingService.revisions.filter(
+      (rev) => rev !== entityId
+    );
+  }
+
+  const updatedService: Service = {
+    ...existingService,
+    revisions: updatedRevisions,
+    role: roles.length > 0 ? roles : existingService.role,
+    usage: newRevision.usage,
+    startedAt: newRevision.createdAt || existingService.startedAt,
+  };
+
+  let deploymentErrorEvent: Service | null = null;
+
+  const incomingStatus = eventData.status.state;
+  const incomingTs = getTimestamp(incomingStatus.timestamp);
+  const currentTs = getTimestamp(existingService.status?.timestamp);
+
+  if (incomingTs > currentTs) {
+    updatedService.status = incomingStatus;
+
+    if (eventData.status.error) {
+      updatedService.error = {
+        code: eventData.status.error.code,
+        message: eventData.status.error.message,
+        timestamp: eventData.status.error.timestamp || incomingStatus.timestamp,
+      };
+      deploymentErrorEvent = updatedService;
+    } else {
+      updatedService.error = undefined;
+    }
+  } else if (eventData.status.error) {
+    const incomingErrorTs = getTimestamp(eventData.status.error.timestamp);
+    const currentErrorTs = getTimestamp(existingService.error?.timestamp);
+
+    if (incomingErrorTs > currentErrorTs) {
+      updatedService.error = {
+        code: eventData.status.error.code,
+        message: eventData.status.error.message,
+        timestamp: eventData.status.error.timestamp,
+      };
+      deploymentErrorEvent = updatedService;
+    }
+  }
+
+  return { updatedService, deploymentErrorEvent };
+};
+
+/**
+ * Update environment consumption history
+ */
+const updateEnvironmentConsumption = (
+  environment: Environment,
+  servicesMap: Map<string, Service>,
+  revisionsMap: Map<string, Revision>,
+  serviceEnvironmentId: string
+): Environment => {
+  let totalEnvCpu = 0;
+  let totalEnvMemory = 0;
+
+  servicesMap.forEach((service, svcId) => {
+    if (service.environment === serviceEnvironmentId) {
+      const currentRevisionKey = `${svcId}-${service.currentRevision}`;
+      const currentRevision = revisionsMap.get(currentRevisionKey);
+      if (currentRevision) {
+        totalEnvCpu += currentRevision.usage.limit.cpu.max || 0;
+        totalEnvMemory += currentRevision.usage.limit.memory.max || 0;
+      }
+    }
+  });
+
+  if (!environment.usage.current.cpuConsuption) {
+    environment.usage.current.cpuConsuption = [];
+  }
+  if (!environment.usage.current.memoryConsuption) {
+    environment.usage.current.memoryConsuption = [];
+  }
+
+  environment.usage.current.cpuConsuption.push(totalEnvCpu);
+  environment.usage.current.memoryConsuption.push(totalEnvMemory);
+
+  if (environment.usage.current.cpuConsuption.length > MAX_HISTORY) {
+    environment.usage.current.cpuConsuption =
+      environment.usage.current.cpuConsuption.slice(-MAX_HISTORY);
+  }
+  if (environment.usage.current.memoryConsuption.length > MAX_HISTORY) {
+    environment.usage.current.memoryConsuption =
+      environment.usage.current.memoryConsuption.slice(-MAX_HISTORY);
+  }
+
+  return environment;
+};
+
+/**
+ * Update account consumption history
+ */
+const updateAccountConsumption = (
+  account: Account,
+  servicesMap: Map<string, Service>,
+  revisionsMap: Map<string, Revision>,
+  serviceAccountId: string
+): Account => {
+  let totalAccountCpu = 0;
+  let totalAccountMemory = 0;
+
+  servicesMap.forEach((service, svcId) => {
+    if (service.account === serviceAccountId) {
+      const currentRevisionKey = `${svcId}-${service.currentRevision}`;
+      const currentRevision = revisionsMap.get(currentRevisionKey);
+      if (currentRevision) {
+        totalAccountCpu += currentRevision.usage.limit.cpu.max || 0;
+        totalAccountMemory += currentRevision.usage.limit.memory.max || 0;
+      }
+    }
+  });
+
+  if (!account.usage.current.cpuConsuption) {
+    account.usage.current.cpuConsuption = [];
+  }
+  if (!account.usage.current.memoryConsuption) {
+    account.usage.current.memoryConsuption = [];
+  }
+
+  account.usage.current.cpuConsuption.push(totalAccountCpu);
+  account.usage.current.memoryConsuption.push(totalAccountMemory);
+
+  if (account.usage.current.cpuConsuption.length > MAX_HISTORY) {
+    account.usage.current.cpuConsuption =
+      account.usage.current.cpuConsuption.slice(-MAX_HISTORY);
+  }
+  if (account.usage.current.memoryConsuption.length > MAX_HISTORY) {
+    account.usage.current.memoryConsuption =
+      account.usage.current.memoryConsuption.slice(-MAX_HISTORY);
+  }
+
+  return account;
+};
+
+// ============================================
+// MAIN HANDLER FUNCTION
+// ============================================
+
+/**
+ * Handles the "revision" event from WebSocket messages
+ * Processes revision data, updates services, environments, and accounts
+ */
+export const handleRevisionEvent = ({
+  entityId,
+  eventData,
+  parentParts,
+  servicesMap,
+  revisionsMap,
+  roleMap,
+  environmentsMap,
+  accountsMap,
+}: HandleRevisionEventParams): HandleRevisionEventResult => {
+  const serviceId = `${parentParts.tenant}/${parentParts.service}`;
+  const revisionKey = `${serviceId}-${entityId}`;
+
+  // Process roles and instances
+  const { roles, instances, usedCpu, usedMemory } = processRolesAndInstances(
+    eventData,
+    serviceId,
+    roleMap
+  );
+
+  // Create new revision
+  const newRevision = createRevision(
+    entityId,
+    parentParts,
+    eventData,
+    usedCpu,
+    usedMemory
+  );
+
+  // Initialize result
+  let updatedService: Service | null = null;
+  let updatedEnvironment: Environment | null = null;
+  let updatedAccount: Account | null = null;
+  let pendingRevisionError: { service: string; revision: Revision } | null = null;
+  let serviceDeployedEvent: Service | null = null;
+  let serviceDeploymentErrorEvent: Service | null = null;
+  let shouldFetchChannels = false;
+  let channelsFetchInfo: { serviceId: string; tenantId: string } | null = null;
+
+  const existingService = servicesMap.get(serviceId);
+
+  if (existingService) {
+    const serviceUpdateResult = updateServiceWithRevision(
+      existingService,
+      entityId,
+      eventData,
+      newRevision,
+      roles
+    );
+
+    updatedService = serviceUpdateResult.updatedService;
+    serviceDeploymentErrorEvent = serviceUpdateResult.deploymentErrorEvent;
+    const serviceEnvironmentId = updatedService.environment;
+    if (serviceEnvironmentId) {
+      const environment = environmentsMap.get(serviceEnvironmentId);
+      if (environment) {
+        const tempServicesMap = new Map(servicesMap);
+        tempServicesMap.set(serviceId, updatedService);
+        const tempRevisionsMap = new Map(revisionsMap);
+        tempRevisionsMap.set(revisionKey, newRevision);
+
+        updatedEnvironment = updateEnvironmentConsumption(
+          { ...environment },
+          tempServicesMap,
+          tempRevisionsMap,
+          serviceEnvironmentId
+        );
+      }
+    }
+    const serviceAccountId = updatedService.account;
+    if (serviceAccountId) {
+      const account = accountsMap.get(serviceAccountId);
+      if (account) {
+        const tempServicesMap = new Map(servicesMap);
+        tempServicesMap.set(serviceId, updatedService);
+        
+        const tempRevisionsMap = new Map(revisionsMap);
+        tempRevisionsMap.set(revisionKey, newRevision);
+
+        updatedAccount = updateAccountConsumption(
+          { ...account },
+          tempServicesMap,
+          tempRevisionsMap,
+          serviceAccountId
+        );
+      }
+    }
+  } else if (eventData.status && eventData.status.error) {
+    newRevision.errorCode = eventData.status.error.code;
+    newRevision.errorMsg = eventData.status.error.message;
+    pendingRevisionError = {
+      service: serviceId,
+      revision: newRevision,
+    };
+  }
+  if (!eventData.meta.deleted && eventData.status && eventData.status.deployed) {
+    shouldFetchChannels = true;
+    channelsFetchInfo = {
+      serviceId: parentParts.service,
+      tenantId: parentParts.tenant,
+    };
+  }
+
+  return {
+    revision: newRevision,
+    revisionKey,
+    serviceId,
+    roles,
+    updatedService,
+    updatedEnvironment,
+    updatedAccount,
+    pendingRevisionError,
+    shouldFetchChannels,
+    channelsFetchInfo,
+    serviceDeployedEvent,
+    serviceDeploymentErrorEvent,
+  };
+};
+export const processRevisionData = (service: Service, revisionData: any): Service => {
+  const { solution } = revisionData;
+  const deploymentName = solution.top || service.name;
+  const deployment = solution.deployments[deploymentName];
+
+  if (!deployment) {
+    console.warn(
+      `No deployment found with name ${deploymentName} in solution. Available deployments:`,
+      Object.keys(solution.deployments),
+    );
+    const firstDeploymentKey = Object.keys(solution.deployments)[0];
+    if (firstDeploymentKey) {
+      console.warn(`Using first available deployment: ${firstDeploymentKey}`);
+      return processDeployment(
+        service,
+        solution.deployments[firstDeploymentKey],
+        revisionData,
+      );
+    }
+    return service;
+  }
+
+  return processDeployment(service, deployment, revisionData);
+};
+export const processDeployment = (
+  service: Service,
+  deployment: any,
+  revisionData: any,
+): Service => {
+  const artifact = deployment.artifact;
+  const deploymentConfig = deployment.config || {};
+  const serviceResources = extractResources(deploymentConfig.resource || {});
+  const allServiceParameters = extractParametersFromConfig(
+    deploymentConfig.parameter || {},
+  );
+
+  const rolesDefinition = artifact.description?.role || {};
+  const hasRoles = Object.keys(rolesDefinition).length > 0;
+  let updatedRoles: Role[] = [];
+
+  if (hasRoles) {
+    Object.entries(rolesDefinition).forEach(
+      ([roleName, roleData]: [string, any]) => {
+        const roleResources = extractResources(roleData.config?.resource || {});
+        const existingRole = service.role.find((r) => r.name === roleName);
+        let hsize = 1;
+        if (roleData.config?.scale?.hsize !== undefined) {
+          hsize = roleData.config.scale.hsize;
+        }
+        if (deploymentConfig.scale?.detail?.[roleName]?.hsize !== undefined) {
+          hsize = deploymentConfig.scale.detail[roleName].hsize;
+        }
+        const hasDuplex =
+          roleData.artifact?.description?.srv?.duplex?.length > 0;
+        const hasVolumeResource = Object.values(
+          roleData.artifact?.description?.config?.resource || {},
+        ).some((resourceData: any) => resourceData.volume);
+        const role: Role = {
+          name: roleName,
+          instances: existingRole?.instances || [],
+          logo: service.logo,
+          description:
+            roleData.artifact?.ref?.module || roleData.ref?.module || "",
+          resource: roleResources,
+          parameters: allServiceParameters,
+          hsize: hsize,
+          category: hasDuplex || hasVolumeResource ? "stateful" : "",
+        };
+        if (
+          deployment.meta?.scaling &&
+          Object.keys(deployment.meta.scaling.simple || {}).length > 0
+        ) {
+          role.scalling = processScalingConfig(deployment.meta);
+        }
+
+        updatedRoles.push(role);
+      },
+    );
+  } else {
+    let hsize = 1;
+
+    if (deploymentConfig.scale?.hsize !== undefined) {
+      hsize = deploymentConfig.scale.hsize;
+    }
+
+    if (deploymentConfig.scale?.detail?.[""]?.hsize !== undefined) {
+      hsize = deploymentConfig.scale.detail[""].hsize;
+    }
+    updatedRoles = [
+      {
+        name: service.name,
+        instances: [],
+        logo: service.logo,
+        description:
+          artifact.ref?.module ||
+          (artifact.description?.builtin ? "Builtin Service" : ""),
+        resource: serviceResources,
+        parameters: allServiceParameters,
+        hsize: hsize,
+        ...(deployment.meta?.scaling &&
+          Object.keys(deployment.meta.scaling.simple || {}).length > 0 && {
+            scalling: processScalingConfig(deployment.meta),
+          }),
+      },
+    ];
+  }
+
+  return {
+    ...service,
+    resources: serviceResources,
+    parameters: allServiceParameters,
+    role: updatedRoles,
+  };
+};
+export const extractParametersFromConfig = (
+  parameterConfig: any,
+): { [key: string]: string }[] => {
+  const parameters: { [key: string]: string }[] = [];
+
+  if (!parameterConfig || typeof parameterConfig !== "object") {
+    return parameters;
+  }
+
+  Object.entries(parameterConfig).forEach(
+    ([paramName, paramValue]: [string, any]) => {
+      let value: string;
+      let description: string | undefined;
+
+      if (typeof paramValue === "object" && paramValue !== null) {
+        if (paramValue.value !== undefined) {
+          value = String(paramValue.value);
+        } else if (paramValue.default !== undefined) {
+          value = String(paramValue.default);
+        } else {
+          value = JSON.stringify(paramValue);
+        }
+
+        if (paramValue.description) {
+          description = paramValue.description;
+        }
+      } else {
+        value = String(paramValue);
+      }
+
+      const parameter: { [key: string]: string } = {
+        name: paramName,
+        value: value,
+        type: typeof paramValue,
+        configKey: paramName,
+      };
+
+      if (description) {
+        parameter.description = description;
+      }
+
+      parameters.push(parameter);
+    },
+  );
+
+  return parameters;
+};
+export const extractResources = (resourceConfig: any): Resource[] => {
+  const resources: Resource[] = [];
+
+  Object.entries(resourceConfig).forEach(
+    ([resourceName, resourceData]: [string, any]) => {
+      let resource: Resource;
+      if (resourceData.volume) {
+        const volumeData = resourceData.volume;
+        const sizeInGB = convertToGigabytes(volumeData.size, volumeData.unit);
+        resource = {
+          type: "volume",
+          name: resourceName,
+          value: sizeInGB ? sizeInGB.toString() : "1",
+          kind: volumeData.type || "storage",
+          status: "available",
+          tenant: "",
+        };
+      } else if (resourceData.port) {
+        resource = {
+          type: "port",
+          name: resourceName,
+          value: extractResourceName(resourceData.port),
+          status: "available",
+          tenant: "",
+        };
+      } else if (resourceData.domain) {
+        resource = {
+          type: "domain",
+          name: resourceName,
+          value: extractResourceName(resourceData.domain),
+          status: "available",
+          tenant: "",
+        };
+      } else if (resourceData.secret) {
+        resource = {
+          type: "secret",
+          name: resourceName,
+          value: extractResourceName(resourceData.secret),
+          status: "available",
+          tenant: "",
+        };
+      } else if (resourceData.certificate) {
+        resource = {
+          type: "certificate",
+          name: resourceName,
+          value: extractResourceName(
+            resourceData.certificate.cert || resourceData.certificate,
+          ),
+          key: resourceData.key,
+          domain: resourceData.domain,
+          status: "available",
+          tenant: "",
+        };
+      } else if (resourceData.ca) {
+        resource = {
+          type: "ca",
+          name: resourceName,
+          value: extractResourceName(resourceData.ca),
+          status: "available",
+          tenant: "",
+        };
+      } else {
+        resource = {
+          type: resourceData.type || "unknown",
+          name: resourceName,
+          value: extractResourceName(
+            resourceData.value || resourceData.size || "",
+          ),
+          status: "available",
+          tenant: "",
+        };
+
+        if (resourceData.kind) resource.kind = resourceData.kind;
+        if (resourceData.domain) resource.domain = resourceData.domain;
+        if (resourceData.key) resource.key = resourceData.key;
+        if (resourceData.maxItems) resource.maxItems = resourceData.maxItems;
+      }
+
+      resources.push(resource);
+    },
+  );
+
+  return resources;
+};
+const processScalingConfig = (meta: any): any => {
+  if (!meta?.scaling?.simple || Object.keys(meta.scaling.simple).length === 0) {
+    return {
+      cpu: { up: "80%", down: "20%" },
+      memory: { up: "80%", down: "20%" },
+      instances: { max: 1, min: 1 },
+      histeresys: "5",
+    };
+  }
+
+  const roleNames = Object.keys(meta.scaling.simple);
+  const firstRoleName = roleNames[0];
+  const roleScaling = meta.scaling.simple[firstRoleName];
+
+  if (!roleScaling) {
+    return {
+      cpu: { up: "80%", down: "20%" },
+      memory: { up: "80%", down: "20%" },
+      instances: { max: 1, min: 1 },
+      histeresys: "5",
+    };
+  }
+
+  return {
+    cpu: {
+      up: `${roleScaling.scale_up?.cpu || 80}%`,
+      down: `${roleScaling.scale_down?.cpu || 20}%`,
+    },
+    memory: {
+      up: `${roleScaling.scale_up?.memory || 80}%`,
+      down: `${roleScaling.scale_down?.memory || 20}%`,
+    },
+    instances: {
+      max: roleScaling.max_replicas || 1,
+      min: roleScaling.min_replicas || 1,
+    },
+    histeresys: `${roleScaling.hysteresis || 5}`,
+  };
+};
+const extractResourceName = (resourcePath: string): string => {
+  if (!resourcePath) return "";
+
+  const parts = resourcePath.split("/");
+
+  if (parts.length === 2) {
+    if (parts[0] === "cluster.core") {
+      return resourcePath;
+    }
+    return parts[1];
+  }
+  return resourcePath;
+};
+//UNUSED KEEPING IT JUST IN CASE:
+const extractParameters = (
+  parameterConfig: any,
+  roleData?: any,
+  roleName?: string,
+): { [key: string]: string }[] => {
+  const parameters: { [key: string]: string }[] = [];
+
+  if (roleData?.artifact?.description?.code) {
+    const codeEntries = Object.entries(roleData.artifact.description.code);
+
+    for (const [codeName, codeData] of codeEntries) {
+      const mapping = (codeData as any)?.mapping?.env;
+
+      if (mapping && typeof mapping === "object") {
+        Object.entries(mapping).forEach(([envName, envData]: [string, any]) => {
+          const envValue = envData.value || "";
+          let configKey = envName;
+          const matchedParam = Object.entries(parameterConfig).find(
+            ([configParamName, paramData]: [string, any]) => {
+              const configValue =
+                typeof paramData === "object"
+                  ? paramData.value || paramData.default || ""
+                  : String(paramData);
+              const envLower = envName.toLowerCase();
+              const configLower = configParamName.toLowerCase();
+
+              if (
+                envLower.includes(configLower) ||
+                configLower.includes(envLower)
+              ) {
+                return configValue === envValue;
+              }
+
+              return false;
+            },
+          );
+
+          if (matchedParam) {
+            configKey = matchedParam[0];
+          }
+
+          const parameter: { [key: string]: string } = {
+            name: envName,
+            value: envValue,
+            type: configKey,
+            configKey: configKey,
+            ...(roleName && { fromRole: roleName }),
+          };
+
+          parameters.push(parameter);
+        });
+      }
+    }
+  }
+
+  if (parameters.length === 0 && parameterConfig) {
+    Object.entries(parameterConfig).forEach(
+      ([paramName, paramData]: [string, any]) => {
+        const paramValue =
+          typeof paramData === "object"
+            ? paramData.value || paramData.default || ""
+            : String(paramData);
+
+        const parameter: { [key: string]: string } = {
+          name: paramName,
+          value: paramValue,
+          type: paramName,
+          configKey: paramName,
+          ...(roleName && { fromRole: roleName }),
+        };
+
+        if (typeof paramData === "object" && paramData.description) {
+          parameter.description = paramData.description;
+        }
+
+        parameters.push(parameter);
+      },
+    );
+  }
+
+  return parameters;
+};