@kumori/aurora-backend-handler 1.0.49 → 1.0.50

package/helpers/revision-helper.ts

@@ -8,7 +8,6 @@ import {
   Usage,
 } from "@kumori/aurora-interfaces";
 import { convertToGigabytes, getTimestamp } from "../utils/utils";
-import { Revision } from "@kumori/aurora-interfaces/interfaces/revision-interface";
 
 interface Role {
   name: string;
@@ -32,6 +31,21 @@ interface Role {
   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;
@@ -60,6 +74,9 @@ interface HandleRevisionEventResult {
 
 const MAX_HISTORY = 100;
 
+/**
+ * Process role and instance data from revision event
+ */
 const processRolesAndInstances = (
   eventData: any,
   serviceId: string,
@@ -138,7 +155,7 @@ const processRolesAndInstances = (
           cost: 0,
         },
         logs: [],
-        containers,
+        containers: containers,
       };
 
       roleInstances.push(instance);
@@ -159,15 +176,19 @@ const processRolesAndInstances = (
   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 {
-    id: entityId,
-    schema: {},
+    service: parentParts.service,
+    revision: entityId,
     usage: {
       current: {
         cpu: usedCpu,
@@ -178,8 +199,14 @@ const createRevision = (
         persistentStorage: 0,
       },
       limit: {
-        cpu: { max: eventData.spec.intensives?.vcpu / 1000 || 0, min: 0 },
-        memory: { max: eventData.spec.intensives?.ram / 1000 || 0, min: 0 },
+        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,
@@ -200,13 +227,22 @@ const createRevision = (
       cost: 0,
     },
     status: eventData.status.state,
-    errorCode: eventData.status?.error ? eventData.status.error.code : "",
-    errorMsg: eventData.status?.error ? eventData.status.error.message : "",
+    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,
@@ -215,19 +251,27 @@ const updateServiceWithRevision = (
   roles: Role[],
 ): { updatedService: Service; deploymentErrorEvent: Service | null } => {
   const existingRevisionIndex = existingService.revisions.findIndex(
-    (rev) => rev.id === entityId,
+    (rev) => rev === entityId,
   );
-  const updatedRevisions: Revision[] =
-    existingRevisionIndex === -1
-      ? [...existingService.revisions, newRevision]
-      : existingService.revisions.map((rev) =>
-          rev.id === entityId ? newRevision : rev,
-        );
+  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,
-    currentRevision: entityId,
     role: roles.length > 0 ? roles : existingService.role,
     usage: newRevision.usage,
     startedAt: newRevision.createdAt || existingService.startedAt,
@@ -241,6 +285,7 @@ const updateServiceWithRevision = (
 
   if (incomingTs > currentTs) {
     updatedService.status = incomingStatus;
+
     if (eventData.status.error) {
       updatedService.error = {
         code: eventData.status.error.code,
@@ -254,6 +299,7 @@ const updateServiceWithRevision = (
   } 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,
@@ -267,6 +313,9 @@ const updateServiceWithRevision = (
   return { updatedService, deploymentErrorEvent };
 };
 
+/**
+ * Update environment consumption history
+ */
 const updateEnvironmentConsumption = (
   environment: Environment,
   servicesMap: Map<string, Service>,
@@ -287,24 +336,31 @@ const updateEnvironmentConsumption = (
     }
   });
 
-  if (!environment.usage.current.cpuConsuption)
+  if (!environment.usage.current.cpuConsuption) {
     environment.usage.current.cpuConsuption = [];
-  if (!environment.usage.current.memoryConsuption)
+  }
+  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)
+  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)
+  }
+  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>,
@@ -325,24 +381,31 @@ const updateAccountConsumption = (
     }
   });
 
-  if (!account.usage.current.cpuConsuption)
+  if (!account.usage.current.cpuConsuption) {
     account.usage.current.cpuConsuption = [];
-  if (!account.usage.current.memoryConsuption)
+  }
+  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)
+  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)
+  }
+  if (account.usage.current.memoryConsuption.length > MAX_HISTORY) {
     account.usage.current.memoryConsuption =
       account.usage.current.memoryConsuption.slice(-MAX_HISTORY);
+  }
 
   return account;
 };
-
+/**
+ * Handles the "revision" event from WebSocket messages
+ * Processes revision data, updates services, environments, and accounts
+ */
 export const handleRevisionEvent = ({
   entityId,
   eventData,
@@ -360,15 +423,13 @@ export const handleRevisionEvent = ({
     serviceId,
     roleMap,
   );
-  const existingRevision = revisionsMap.get(revisionKey);
-  const newRevision = createRevision(entityId, eventData, usedCpu, usedMemory);
-  if (
-    existingRevision?.schema &&
-    Object.keys(existingRevision.schema).length > 0
-  ) {
-    newRevision.schema = existingRevision.schema;
-  }
-
+  const newRevision = createRevision(
+    entityId,
+    parentParts,
+    eventData,
+    usedCpu,
+    usedMemory,
+  );
   let updatedService: Service | null = null;
   let updatedEnvironment: Environment | null = null;
   let updatedAccount: Account | null = null;
@@ -389,9 +450,9 @@ export const handleRevisionEvent = ({
       newRevision,
       roles,
     );
+
     updatedService = serviceUpdateResult.updatedService;
     serviceDeploymentErrorEvent = serviceUpdateResult.deploymentErrorEvent;
-
     const serviceEnvironmentId = updatedService.environment;
     if (serviceEnvironmentId) {
       const environment = environmentsMap.get(serviceEnvironmentId);
@@ -400,6 +461,7 @@ export const handleRevisionEvent = ({
         tempServicesMap.set(serviceId, updatedService);
         const tempRevisionsMap = new Map(revisionsMap);
         tempRevisionsMap.set(revisionKey, newRevision);
+
         updatedEnvironment = updateEnvironmentConsumption(
           { ...environment },
           tempServicesMap,
@@ -408,15 +470,16 @@ export const handleRevisionEvent = ({
         );
       }
     }
-
     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,
@@ -428,9 +491,11 @@ export const handleRevisionEvent = ({
   } else if (eventData.status && eventData.status.error) {
     newRevision.errorCode = eventData.status.error.code;
     newRevision.errorMsg = eventData.status.error.message;
-    pendingRevisionError = { service: serviceId, revision: newRevision };
+    pendingRevisionError = {
+      service: serviceId,
+      revision: newRevision,
+    };
   }
-
   if (
     !eventData.meta.deleted &&
     eventData.status &&
@@ -458,276 +523,45 @@ export const handleRevisionEvent = ({
     serviceDeploymentErrorEvent,
   };
 };
-
-const collectNamedTypes = (schema: any): string[] => {
-  if (!schema || typeof schema !== "object") return [];
-  const names: string[] = [];
-  if (schema.$kdsl?.const?.NamedType?.Name)
-    names.push(schema.$kdsl.const.NamedType.Name as string);
-  if (Array.isArray(schema.oneOf)) {
-    for (const branch of schema.oneOf) names.push(...collectNamedTypes(branch));
-  }
-  return names;
-};
-
-const namedTypeToResourceKind = (
-  namedTypes: string[],
-): { type: string; kind?: string } | null => {
-  for (const name of namedTypes) {
-    switch (name) {
-      case "Secret":
-        return { type: "secret" };
-      case "Domain":
-        return { type: "domain" };
-      case "Port":
-        return { type: "port" };
-      case "Certificate":
-        return { type: "certificate" };
-      case "CA":
-        return { type: "ca" };
-      case "Volatile":
-      case "Ephemeral":
-        return { type: "volume", kind: "volatile" };
-      case "NonReplicated":
-        return { type: "volume", kind: "nonReplicated" };
-      case "Persisted":
-      case "Persistent":
-        return { type: "volume", kind: "persistent" };
-      case "Registered":
-        return { type: "volume" };
-    }
-  }
-  return null;
-};
-
-export const extractStructuredSchema = (
-  revisionData: any,
-):
-  | {
-      parameters: {
-        name: string;
-        type: string;
-        required: boolean;
-        defaultValue?: any;
-      }[];
-      resources: {
-        name: string;
-        type: string;
-        kind?: string;
-        required: boolean;
-      }[];
-    }
-  | {} => {
-  const configSchema = revisionData?.configSchema;
-  if (!configSchema) return {};
-
-  const deploymentName = revisionData?.solution?.top;
-  const deployment = deploymentName
-    ? revisionData?.solution?.deployments?.[deploymentName]
-    : Object.values(revisionData?.solution?.deployments ?? {})[0];
-
-  const parameterValues: Record<string, any> =
-    (deployment as any)?.config?.parameter ?? {};
-  const configResourceValues: Record<string, any> =
-    (deployment as any)?.config?.resource ?? {};
-
-  const requiredParams: string[] =
-    configSchema?.properties?.config?.required ?? [];
-  const requiredResources: string[] =
-    configSchema?.properties?.resource?.required ?? [];
-  const schemaConfigProps: Record<string, any> =
-    configSchema?.properties?.config?.properties ?? {};
-
-  const parameters = Object.entries(schemaConfigProps).map(
-    ([name, propSchema]) => {
-      const entry: {
-        name: string;
-        type: string;
-        required: boolean;
-        defaultValue?: any;
-      } = {
-        name,
-        type: propSchema?.type ?? "string",
-        required: requiredParams.includes(name),
-      };
-      const currentValue = parameterValues[name];
-      if (currentValue !== undefined) entry.defaultValue = currentValue;
-      else if (propSchema?.default !== undefined)
-        entry.defaultValue = propSchema.default;
-      return entry;
-    },
-  );
-
-  const resolveResourceType = (
-    configValue: any,
-  ): { type: string; kind?: string } | null => {
-    if (!configValue || typeof configValue !== "object") return null;
-    if ("secret" in configValue) return { type: "secret" };
-    if ("domain" in configValue) return { type: "domain" };
-    if ("port" in configValue) return { type: "port" };
-    if ("certificate" in configValue) return { type: "certificate" };
-    if ("ca" in configValue) return { type: "ca" };
-    if ("volume" in configValue) {
-      const volType = configValue.volume?.type;
-      if (volType === "persistent" || volType === "Persisted")
-        return { type: "volume", kind: "persistent" };
-      if (volType === "nonReplicated" || volType === "NonReplicated")
-        return { type: "volume", kind: "nonReplicated" };
-      if (
-        volType === "volatile" ||
-        volType === "Volatile" ||
-        volType === "ephemeral" ||
-        volType === "Ephemeral"
-      )
-        return { type: "volume", kind: "volatile" };
-      return { type: "volume" };
-    }
-    return null;
-  };
-
-  const allResourceNames = new Set<string>([
-    ...Object.keys(configResourceValues),
-    ...Object.keys(configSchema?.properties?.resource?.properties ?? {}),
-  ]);
-
-  const resources = Array.from(allResourceNames)
-    .map((name) => {
-      const configValue = configResourceValues[name];
-      const fromConfig = resolveResourceType(configValue);
-      const schemaProps =
-        configSchema?.properties?.resource?.properties?.[name];
-      const fromSchema = schemaProps
-        ? namedTypeToResourceKind(collectNamedTypes(schemaProps))
-        : null;
-      const resolved = fromConfig ?? fromSchema;
-      if (!resolved) return null;
-      const entry: {
-        name: string;
-        type: string;
-        kind?: string;
-        required: boolean;
-      } = {
-        name,
-        type: resolved.type,
-        required: requiredResources.includes(name),
-      };
-      if (resolved.kind) entry.kind = resolved.kind;
-      return entry;
-    })
-    .filter(Boolean) as {
-    name: string;
-    type: string;
-    kind?: string;
-    required: boolean;
-  }[];
-
-  return { parameters, resources };
-};
-
 export const processRevisionData = (
   service: Service,
   revisionData: any,
-  revisionsMap?: Map<string, Revision>,
-  serviceId?: string,
 ): Service => {
   const { solution } = revisionData;
 
   const config = revisionData?.config?.config || {};
-  const parameters = extractParametersFromConfig(config.parameter || {});
+  const parameters = extractParametersFromConfig(
+    config.parameter || {},
+  );
   const resources = extractResources(config.resource || {});
 
-  const schemaResult = revisionData.revision
-    ? extractStructuredSchema(revisionData)
-    : {};
-  const schema =
-    schemaResult && "parameters" in schemaResult ? schemaResult : {};
-
-  if (
-    revisionsMap &&
-    serviceId &&
-    revisionData.revision &&
-    "parameters" in schema
-  ) {
-    const revisionId: string = revisionData.revision;
-    const revisionKey = `${serviceId}-${revisionId}`;
-    const existing = revisionsMap.get(revisionKey);
-    if (existing) {
-      revisionsMap.set(revisionKey, { ...existing, schema });
-    } else {
-      revisionsMap.set(revisionKey, {
-        id: revisionId,
-        schema,
-        usage: {
-          current: {
-            cpu: 0,
-            memory: 0,
-            storage: 0,
-            volatileStorage: 0,
-            nonReplicatedStorage: 0,
-            persistentStorage: 0,
-          },
-          limit: {
-            cpu: { max: revisionData.intensives?.vcpu / 1000 || 0, min: 0 },
-            memory: { max: revisionData.intensives?.ram / 1000 || 0, min: 0 },
-            storage: {
-              max: revisionData.intensives?.shared_disk / 1000 || 0,
-              min: 0,
-            },
-            volatileStorage: {
-              max: revisionData.intensives?.volatile_disk / 1000 || 0,
-              min: 0,
-            },
-            nonReplicatedStorage: {
-              max: revisionData.intensives?.nrpersistent_disk / 1000 || 0,
-              min: 0,
-            },
-            persistentStorage: {
-              max: revisionData.intensives?.persistent_disk / 1000 || 0,
-              min: 0,
-            },
-          },
-          cost: 0,
-        },
-        status: { code: "", message: "", timestamp: "", args: [] },
-        errorCode: "",
-        errorMsg: "",
-        createdAt: "",
-      });
-    }
-  }
-
   const deploymentName = solution.top || service.name;
   const deployment = solution.deployments[deploymentName];
 
-  const applySchemaToService = (svc: Service): Service => {
-    if (!revisionData.revision || !("parameters" in schema)) return svc;
-    const revisionId: string = revisionData.revision;
-    return {
-      ...svc,
-      revisions: svc.revisions.map((rev) =>
-        rev.id === revisionId ? { ...rev, schema } : rev,
-      ),
-    };
-  };
-
   if (!deployment) {
     const firstDeploymentKey = Object.keys(solution.deployments)[0];
     if (firstDeploymentKey) {
-      return applySchemaToService(
-        processDeployment(
-          service,
-          solution.deployments[firstDeploymentKey],
-          revisionData,
-          parameters,
-          resources,
-        ),
+      return processDeployment(
+        service,
+        solution.deployments[firstDeploymentKey],
+        revisionData,
+        parameters,
+        resources,
       );
     }
-    return applySchemaToService({ ...service, parameters, resources });
+    return {
+      ...service,
+      parameters: parameters,
+      resources: resources,
+    };
   }
 
-  return applySchemaToService(
-    processDeployment(service, deployment, revisionData, parameters, resources),
+  return processDeployment(
+    service,
+    deployment,
+    revisionData,
+    parameters,
+    resources,
   );
 };
 
@@ -740,6 +574,7 @@ export const processDeployment = (
 ): Service => {
   const artifact = deployment.artifact;
   const deploymentConfig = deployment.config || {};
+
   const rolesDefinition = artifact.description?.role || {};
   const hasRoles = Object.keys(rolesDefinition).length > 0;
   let updatedRoles: Role[] = [];
@@ -749,10 +584,12 @@ export const processDeployment = (
       ([roleName, roleData]: [string, any]) => {
         const existingRole = service.role.find((r) => r.name === roleName);
         let hsize = 1;
-        if (roleData.config?.scale?.hsize !== undefined)
+        if (roleData.config?.scale?.hsize !== undefined) {
           hsize = roleData.config.scale.hsize;
-        if (deploymentConfig.scale?.detail?.[roleName]?.hsize !== undefined)
+        }
+        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(
@@ -765,24 +602,27 @@ export const processDeployment = (
           description:
             roleData.artifact?.ref?.module || roleData.ref?.module || "",
           resource: resources,
-          parameters,
-          hsize,
+          parameters: parameters,
+          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)
+    if (deploymentConfig.scale?.hsize !== undefined) {
       hsize = deploymentConfig.scale.hsize;
-    if (deploymentConfig.scale?.detail?.[""]?.hsize !== undefined)
+    }
+    if (deploymentConfig.scale?.detail?.[""]?.hsize !== undefined) {
       hsize = deploymentConfig.scale.detail[""].hsize;
+    }
     updatedRoles = [
       {
         name: service.name,
@@ -792,8 +632,8 @@ export const processDeployment = (
           artifact.ref?.module ||
           (artifact.description?.builtin ? "Builtin Service" : ""),
         resource: resources,
-        parameters,
-        hsize,
+        parameters: parameters,
+        hsize: hsize,
         ...(deployment.meta?.scaling &&
           Object.keys(deployment.meta.scaling.simple || {}).length > 0 && {
             scalling: processScalingConfig(deployment.meta),
@@ -802,43 +642,60 @@ export const processDeployment = (
     ];
   }
 
-  return { ...service, resources, parameters, role: updatedRoles };
+  return {
+    ...service,
+    resources: resources,
+    parameters: parameters,
+    role: updatedRoles,
+  };
 };
-
 export const extractParametersFromConfig = (
   parameterConfig: any,
 ): { [key: string]: string }[] => {
   const parameters: { [key: string]: string }[] = [];
-  if (!parameterConfig || typeof parameterConfig !== "object")
+
+  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 = paramValue.value;
-        else if (paramValue.default !== undefined)
+        if (paramValue.value !== undefined) {
+          value = paramValue.value;
+        } else if (paramValue.default !== undefined) {
           value = String(paramValue.default);
-        else value = JSON.stringify(paramValue);
-        if (paramValue.description) description = paramValue.description;
+        } else {
+          value = JSON.stringify(paramValue);
+        }
+
+        if (paramValue.description) {
+          description = paramValue.description;
+        }
       } else {
         value = String(paramValue);
       }
+
       const parameter: { [key: string]: string } = {
         name: paramName,
-        value,
+        value: value,
         type: typeof paramValue,
         configKey: paramName,
       };
-      if (description) parameter.description = description;
+
+      if (description) {
+        parameter.description = description;
+      }
+
       parameters.push(parameter);
     },
   );
 
   return parameters;
 };
-
 export const extractParametersFromFilesystem = (
   filesystem: any,
   currentParameters: { [key: string]: string }[],
@@ -855,13 +712,13 @@ export const extractParametersFromFilesystem = (
         value: value.data.value,
         type: "file",
       });
-      if (existingParam)
+      if (existingParam) {
         currentParameters.splice(currentParameters.indexOf(existingParam), 1);
+      }
     }
   });
   return parameters;
 };
-
 export const extractResourcesFromFilesystem = (
   filesystem: any,
   currentResources: Resource[],
@@ -885,15 +742,16 @@ export const extractResourcesFromFilesystem = (
         status: existingResource?.status || "available",
         tenant: "",
       });
-      if (existingResource)
+      if (existingResource) {
         currentResources.splice(currentResources.indexOf(existingResource), 1);
+      }
     }
   });
   return resources;
 };
-
 export const extractResources = (resourceConfig: any): Resource[] => {
   const resources: Resource[] = [];
+
   Object.entries(resourceConfig).forEach(
     ([resourceName, resourceData]: [string, any]) => {
       let resource: Resource;
@@ -962,34 +820,42 @@ export const extractResources = (resourceConfig: any): Resource[] => {
           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)
+  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 firstRoleName = Object.keys(meta.scaling.simple)[0];
+  }
+
+  const roleNames = Object.keys(meta.scaling.simple);
+  const firstRoleName = roleNames[0];
   const roleScaling = meta.scaling.simple[firstRoleName];
-  if (!roleScaling)
+
+  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}%`,
@@ -1006,13 +872,99 @@ const processScalingConfig = (meta: any): any => {
     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;
+    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;
+};