@kumori/aurora-backend-handler 1.0.45 → 1.0.47

package/helpers/revision-helper.ts

@@ -8,6 +8,7 @@ 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;
@@ -31,21 +32,6 @@ 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;
@@ -74,9 +60,6 @@ interface HandleRevisionEventResult {
 
 const MAX_HISTORY = 100;
 
-/**
- * Process role and instance data from revision event
- */
 const processRolesAndInstances = (
   eventData: any,
   serviceId: string,
@@ -155,7 +138,7 @@ const processRolesAndInstances = (
           cost: 0,
         },
         logs: [],
-        containers: containers,
+        containers,
       };
 
       roleInstances.push(instance);
@@ -176,19 +159,15 @@ 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 {
-    service: parentParts.service,
-    revision: entityId,
+    id: entityId,
+    schema: {},
     usage: {
       current: {
         cpu: usedCpu,
@@ -199,14 +178,8 @@ 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,
@@ -227,22 +200,13 @@ const createRevision = (
       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
-        : "",
+    errorCode: eventData.status?.error ? eventData.status.error.code : "",
+    errorMsg: 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,
@@ -251,23 +215,19 @@ const updateServiceWithRevision = (
   roles: Role[],
 ): { updatedService: Service; deploymentErrorEvent: Service | null } => {
   const existingRevisionIndex = existingService.revisions.findIndex(
-    (rev) => rev === entityId,
+    (rev) => rev.id === entityId,
   );
-  const updatedRevisions =
+  const updatedRevisions: Revision[] =
     existingRevisionIndex === -1
-      ? [...existingService.revisions, entityId]
-      : existingService.revisions;
-  const currentRevisionTimestamp = Number(existingService.currentRevision) || 0;
-  const incomingRevisionTimestamp = Number(entityId) || 0;
-  const updatedCurrentRevision =
-    incomingRevisionTimestamp > currentRevisionTimestamp
-      ? entityId
-      : existingService.currentRevision;
+      ? [...existingService.revisions, newRevision]
+      : existingService.revisions.map((rev) =>
+          rev.id === entityId ? newRevision : rev,
+        );
 
   const updatedService: Service = {
     ...existingService,
     revisions: updatedRevisions,
-    currentRevision: updatedCurrentRevision,
+    currentRevision: entityId,
     role: roles.length > 0 ? roles : existingService.role,
     usage: newRevision.usage,
     startedAt: newRevision.createdAt || existingService.startedAt,
@@ -281,7 +241,6 @@ const updateServiceWithRevision = (
 
   if (incomingTs > currentTs) {
     updatedService.status = incomingStatus;
-
     if (eventData.status.error) {
       updatedService.error = {
         code: eventData.status.error.code,
@@ -295,7 +254,6 @@ 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,
@@ -309,9 +267,6 @@ const updateServiceWithRevision = (
   return { updatedService, deploymentErrorEvent };
 };
 
-/**
- * Update environment consumption history
- */
 const updateEnvironmentConsumption = (
   environment: Environment,
   servicesMap: Map<string, Service>,
@@ -332,31 +287,24 @@ 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>,
@@ -377,31 +325,24 @@ 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,
@@ -419,13 +360,15 @@ export const handleRevisionEvent = ({
     serviceId,
     roleMap,
   );
-  const newRevision = createRevision(
-    entityId,
-    parentParts,
-    eventData,
-    usedCpu,
-    usedMemory,
-  );
+  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;
+  }
+
   let updatedService: Service | null = null;
   let updatedEnvironment: Environment | null = null;
   let updatedAccount: Account | null = null;
@@ -446,9 +389,9 @@ export const handleRevisionEvent = ({
       newRevision,
       roles,
     );
-
     updatedService = serviceUpdateResult.updatedService;
     serviceDeploymentErrorEvent = serviceUpdateResult.deploymentErrorEvent;
+
     const serviceEnvironmentId = updatedService.environment;
     if (serviceEnvironmentId) {
       const environment = environmentsMap.get(serviceEnvironmentId);
@@ -457,7 +400,6 @@ export const handleRevisionEvent = ({
         tempServicesMap.set(serviceId, updatedService);
         const tempRevisionsMap = new Map(revisionsMap);
         tempRevisionsMap.set(revisionKey, newRevision);
-
         updatedEnvironment = updateEnvironmentConsumption(
           { ...environment },
           tempServicesMap,
@@ -466,16 +408,15 @@ 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,
@@ -487,11 +428,9 @@ 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 &&
@@ -519,45 +458,288 @@ 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 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) {
-    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 applySchemaToService(
+        processDeployment(
+          service,
+          solution.deployments[firstDeploymentKey],
+          revisionData,
+          parameters,
+          resources,
+        ),
       );
     }
-    return service;
+    return applySchemaToService({ ...service, parameters, resources });
   }
 
-  return processDeployment(service, deployment, revisionData);
+  return applySchemaToService(
+    processDeployment(service, deployment, revisionData, parameters, resources),
+  );
 };
+
 export const processDeployment = (
   service: Service,
   deployment: any,
   revisionData: any,
+  parameters: { [key: string]: string }[],
+  resources: Resource[],
 ): 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[] = [];
@@ -565,27 +747,12 @@ export const processDeployment = (
   if (hasRoles) {
     Object.entries(rolesDefinition).forEach(
       ([roleName, roleData]: [string, any]) => {
-        const fileSystemParameters = extractParametersFromFilesystem(
-          roleData.artifact.description?.code?.[roleName]?.mapping
-            ?.filesystem || [],
-          allServiceParameters,
-        );
-        allServiceParameters.push(...fileSystemParameters);
-        const fileSystemResources = extractResourcesFromFilesystem(
-          roleData.artifact.description?.code?.[roleName]?.mapping
-            ?.filesystem || [],
-          serviceResources,
-        );
-        serviceResources.push(...fileSystemResources);
-        const roleResources = extractResources(roleData.config?.resource || {});
         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(
@@ -597,31 +764,25 @@ export const processDeployment = (
           logo: service.logo,
           description:
             roleData.artifact?.ref?.module || roleData.ref?.module || "",
-          resource: roleResources,
-          parameters: allServiceParameters,
-          hsize: hsize,
+          resource: resources,
+          parameters,
+          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,
@@ -630,9 +791,9 @@ export const processDeployment = (
         description:
           artifact.ref?.module ||
           (artifact.description?.builtin ? "Builtin Service" : ""),
-        resource: serviceResources,
-        parameters: allServiceParameters,
-        hsize: hsize,
+        resource: resources,
+        parameters,
+        hsize,
         ...(deployment.meta?.scaling &&
           Object.keys(deployment.meta.scaling.simple || {}).length > 0 && {
             scalling: processScalingConfig(deployment.meta),
@@ -641,60 +802,43 @@ export const processDeployment = (
     ];
   }
 
-  return {
-    ...service,
-    resources: serviceResources,
-    parameters: allServiceParameters,
-    role: updatedRoles,
-  };
+  return { ...service, resources, 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 }[],
@@ -711,13 +855,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[],
@@ -741,16 +885,15 @@ 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;
@@ -819,42 +962,34 @@ 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 roleNames = Object.keys(meta.scaling.simple);
-  const firstRoleName = roleNames[0];
+  const firstRoleName = Object.keys(meta.scaling.simple)[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}%`,
@@ -871,99 +1006,13 @@ 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;
-};