@kumori/aurora-backend-handler 1.0.48 → 1.0.50

package/api/account-api-service.ts

@@ -222,7 +222,6 @@ export const createAccount = async (account: Account, security: Security) => {
                   username: account.cloudProvider.username || "",
                   password: account.cloudProvider.password || "",
                   region: account.cloudProvider?.region || "",
-                  project_id: account.cloudProvider?.project_id || "",
                 }
               : {
                   method: providerName,
@@ -334,7 +333,6 @@ export const createAccount = async (account: Account, security: Security) => {
                   password: account.cloudProvider.password || "",
                   region: account.cloudProvider?.region || "",
                   domain: account.cloudProvider?.domain || "",
-                  project_id: account.cloudProvider?.project_id || "",
                 }
               : {
                   method: providerName,
@@ -613,7 +611,6 @@ export const deleteAccount = async (account: Account, security: Security) => {
           credentials: {
             username: account.cloudProvider.username,
             password: account.cloudProvider.password,
-            project_id: account.cloudProvider?.project_id || "",
           },
         },
       };
@@ -628,7 +625,6 @@ export const deleteAccount = async (account: Account, security: Security) => {
             username: account.cloudProvider.username,
             password: account.cloudProvider.password,
             domain: account.cloudProvider.domain,
-            project_id: account.cloudProvider?.project_id || "",
           },
         },
       };
@@ -994,7 +990,6 @@ export const updateAccount = async (account: Account, security: Security) => {
                 username: account.cloudProvider.username || "",
                 password: account.cloudProvider.password || "",
                 region: account.cloudProvider?.region || "",
-                project_id: account.cloudProvider?.project_id || "",
               }
             : {
                 method: providerName,
@@ -1104,7 +1099,6 @@ export const updateAccount = async (account: Account, security: Security) => {
                 password: account.cloudProvider.password || "",
                 region: account.cloudProvider?.region || "",
                 domain: account.cloudProvider?.domain || "",
-                project_id: account.cloudProvider?.project_id || "",
               }
             : {
                 method: providerName,

package/api/service-api-service.ts

@@ -208,6 +208,9 @@ export const restartService = async (data: Service, security: string) => {
   }
 };
 const generateLinkBody = (data: Service, link: Link) => {
+  console.log("[Backend Handler] generateLinkBody - Link:", link);
+  console.log("[Backend Handler] generateLinkBody - Service:", data);
+
   const originInClient = data.clientChannels.find(
     (channel) =>
       channel.name === link.originChannel ||
@@ -238,7 +241,30 @@ const generateLinkBody = (data: Service, link: Link) => {
       channel.name === link.targetChannel ||
       channel.from === link.targetChannel,
   );
-
+  console.log(
+    "[Backend Handler] generateLinkBody - Origin in client:",
+    originInClient,
+  );
+  console.log(
+    "[Backend Handler] generateLinkBody - Origin in server:",
+    originInServer,
+  );
+  console.log(
+    "[Backend Handler] generateLinkBody - Origin in duplex:",
+    originInDuplex,
+  );
+  console.log(
+    "[Backend Handler] generateLinkBody - Target in client:",
+    targetInClient,
+  );
+  console.log(
+    "[Backend Handler] generateLinkBody - Target in server:",
+    targetInServer,
+  );
+  console.log(
+    "[Backend Handler] generateLinkBody - Target in duplex:",
+    targetInDuplex,
+  );
   let linkBody;
   if (originInClient) {
     linkBody = {
@@ -307,6 +333,8 @@ const generateLinkBody = (data: Service, link: Link) => {
       server_channel: link.targetChannel,
     };
   }
+
+  console.log("[Backend Handler] generateLinkBody - Link body:", linkBody);
   return linkBody;
 };
 export const linkPendingServices = async (service: Service, token: string) => {
@@ -407,177 +435,137 @@ export const updateService = async (
     //   pendingLinks.set(data.name, newLinksToCreate);
     //   await linkPendingServices(serviceWithNewLinks, token);
     // }
-    const url = new URL(
-      `${environment.apiServer.baseUrl}/api/${environment.apiServer.apiVersion}/tenant/${data.tenant}/service/${data.name}/revision/${data.currentRevision}`,
-    );
-    if (data.dsl) {
-      url.searchParams.append("dsl", "true");
-    }
-    if (data.serviceData) {
-      const formData = new FormData();
-      formData.append("type", "update-bundle");
-      formData.append("bundle", data.serviceData);
-      formData.append(
-        "meta",
-        JSON.stringify({
-          targetAccount: data.account,
-          targetEnvironment: data.environment,
-        }),
-      );
-      formData.append("labels", JSON.stringify({ project: data.project }));
-      formData.append("comment", " ");
-      const response = await fetch(url.toString(), {
-        method: "POST",
-        body: formData,
+
+    const parameterObject: Record<string, any> = {};
+    if (data.parameters && data.parameters.length > 0) {
+      data.parameters.forEach((param) => {
+        const key = param.configKey || param.name;
+        const paramType = param.type?.toLowerCase();
+        if (paramType === "number" || paramType === "integer") {
+          parameterObject[key] = Number(param.value) || 0;
+        } else if (paramType === "boolean") {
+          parameterObject[key] = param.value === "true";
+        } else {
+          parameterObject[key] = param.value;
+        }
       });
-      if (!response.ok) {
-        throw new Error(`HTTP error! status: ${response.status}`);
-      }
+    }
 
-      const jsonResponse = await response.json();
-      const isTimeout = jsonResponse?.events?.some(
-        (event: any) => event.content === "_timeout_",
-      );
+    const resourceObject: Record<string, any> = {};
+    if (data.resources && data.resources.length > 0) {
+      data.resources.forEach((resource) => {
+        if (resource.type === "volume") {
+          resourceObject[resource.name] = {
+            volume: {
+              kind: "storage",
+              size: parseInt(resource.value) || 1,
+              unit: "G",
+              type: resource.kind,
+            },
+          };
+        } else if (resource.type === "secret") {
+          resourceObject[resource.name] = {
+            secret: `${data.tenant}/${resource.value}`,
+          };
+        } else if (resource.type === "domain") {
+          resourceObject[resource.name] = {
+            domain: `${data.tenant}/${resource.value}`,
+          };
+        } else if (resource.type === "ca") {
+          resourceObject[resource.name] = {
+            ca: `${data.tenant}/${resource.value}`,
+          };
+        } else if (resource.type === "certificate") {
+          resourceObject[resource.name] = {
+            certificate: `${data.tenant}/${resource.value}`,
+          };
+        } else if (resource.type === "port") {
+          resourceObject[resource.name] = {
+            port: `${data.tenant}/${resource.value}`,
+          };
+        }
+      });
+    }
 
-      if (isTimeout) {
-        console.error("Timeout en la petición:", {
-          isOk: false,
-          code: "TIMEOUT",
-          error: "_timeout_",
-        });
+    let previousRevision = 1;
+    if (data.currentRevision) {
+      previousRevision = parseInt(data.currentRevision.toString(), 10);
+      if (isNaN(previousRevision)) {
+        console.warn("currentRevision is not a valid number, using 1");
+        previousRevision = 1;
       }
     } else {
-      const parameterObject: Record<string, any> = {};
-      if (data.parameters && data.parameters.length > 0) {
-        data.parameters.forEach((param) => {
-          const key = param.configKey || param.name;
-          const paramType = param.type?.toLowerCase();
-          if (paramType === "number" || paramType === "integer") {
-            parameterObject[key] = Number(param.value) || 0;
-          } else if (paramType === "boolean") {
-            parameterObject[key] = param.value === "true";
-          } else {
-            parameterObject[key] = param.value;
-          }
-        });
-      }
-
-      const resourceObject: Record<string, any> = {};
-      if (data.resources && data.resources.length > 0) {
-        data.resources.forEach((resource) => {
-          if (resource.type === "volume") {
-            resourceObject[resource.name] = {
-              volume: {
-                kind: "storage",
-                size: parseInt(resource.value) || 1,
-                unit: "G",
-                type: resource.kind,
-              },
-            };
-          } else if (resource.type === "secret") {
-            resourceObject[resource.name] = {
-              secret: `${data.tenant}/${resource.value}`,
-            };
-          } else if (resource.type === "domain") {
-            resourceObject[resource.name] = {
-              domain: `${data.tenant}/${resource.value}`,
-            };
-          } else if (resource.type === "ca") {
-            resourceObject[resource.name] = {
-              ca: `${data.tenant}/${resource.value}`,
-            };
-          } else if (resource.type === "certificate") {
-            resourceObject[resource.name] = {
-              certificate: `${data.tenant}/${resource.value}`,
-            };
-          } else if (resource.type === "port") {
-            resourceObject[resource.name] = {
-              port: `${data.tenant}/${resource.value}`,
-            };
-          }
-        });
-      }
-
-      let previousRevision = 1;
-      if (data.currentRevision) {
-        previousRevision = parseInt(data.currentRevision.toString(), 10);
-        if (isNaN(previousRevision)) {
-          console.warn("currentRevision is not a valid number, using 1");
-          previousRevision = 1;
-        }
-      } else {
-        previousRevision = getLatestRevision(data.revisions) || 1;
-      }
+      previousRevision = getLatestRevision(data.revisions) || 1;
+    }
 
-      const scaleConfig: any = {};
-      if (data.role && data.role.length > 0) {
-        scaleConfig.detail = {};
-        data.role.forEach((role) => {
-          scaleConfig.detail[role.name] = {
-            hsize: role.hsize || scale || data.minReplicas || 1,
-          };
-        });
-      } else {
-        scaleConfig.hsize = scale || data.minReplicas || 1;
-      }
-      const meta = {
-        scaling: {
-          simple:
-            data.role?.reduce(
-              (acc, role) => {
-                if (role.scalling && role.name) {
-                  acc[role.name] = {
-                    scale_up: {
-                      cpu: Math.min(parseInt(role.scalling.cpu.up) || 0, 100),
-                      memory: Math.min(
-                        parseInt(role.scalling.memory.up) || 0,
-                        100,
-                      ),
-                    },
-                    scale_down: {
-                      cpu: Math.min(parseInt(role.scalling.cpu.down) || 0, 100),
-                      memory: Math.min(
-                        parseInt(role.scalling.memory.down) || 0,
-                        100,
-                      ),
-                    },
-                    hysteresis: parseInt(role.scalling.histeresys) || 0,
-                    min_replicas: role.scalling.instances.min || 0,
-                    max_replicas: role.scalling.instances.max || 0,
-                  };
-                }
-                return acc;
-              },
-              {} as Record<string, any>,
-            ) || {},
-        },
-      };
+    const scaleConfig: any = {};
+    if (data.role && data.role.length > 0) {
+      scaleConfig.detail = {};
+      data.role.forEach((role) => {
+        scaleConfig.detail[role.name] = {
+          hsize: role.hsize || scale || data.minReplicas || 1,
+        };
+      });
+    } else {
+      scaleConfig.hsize = scale || data.minReplicas || 1;
+    }
+    const meta = {
+      scaling: {
+        simple:
+          data.role?.reduce(
+            (acc, role) => {
+              if (role.scalling && role.name) {
+                acc[role.name] = {
+                  scale_up: {
+                    cpu: Math.min(parseInt(role.scalling.cpu.up) || 0, 100),
+                    memory: Math.min(
+                      parseInt(role.scalling.memory.up) || 0,
+                      100,
+                    ),
+                  },
+                  scale_down: {
+                    cpu: Math.min(parseInt(role.scalling.cpu.down) || 0, 100),
+                    memory: Math.min(
+                      parseInt(role.scalling.memory.down) || 0,
+                      100,
+                    ),
+                  },
+                  hysteresis: parseInt(role.scalling.histeresys) || 0,
+                  min_replicas: role.scalling.instances.min || 0,
+                  max_replicas: role.scalling.instances.max || 0,
+                };
+              }
+              return acc;
+            },
+            {} as Record<string, any>,
+          ) || {},
+      },
+    };
 
-      const updateBody = {
-        spec: {
-          type: "update-config",
-          comment: "Service configuration update",
-          config: {
-            parameter: parameterObject,
-            resource: resourceObject,
-            resilience: 0,
-            scale: scaleConfig,
-          },
-          meta: meta,
+    const updateBody = {
+      spec: {
+        type: "update-config",
+        comment: "Service configuration update",
+        config: {
+          parameter: parameterObject,
+          resource: resourceObject,
+          resilience: 0,
+          scale: scaleConfig,
         },
-        tenant: data.tenant,
-        service: data.name,
-        previous: previousRevision,
-      };
+        meta: meta,
+      },
+      tenant: data.tenant,
+      service: data.name,
+      previous: previousRevision,
+    };
 
-      const response = await makeGlobalWebSocketRequest(
-        "revision:update_revision",
-        updateBody,
-        30000,
-        "UPDATE_CONFIG",
-        data.name,
-      );
-    }
+    const response = await makeGlobalWebSocketRequest(
+      "revision:update_revision",
+      updateBody,
+      30000,
+      "UPDATE_CONFIG",
+      data.name,
+    );
 
     const updatedService: Service = {
       ...data,

package/helpers/account-helper.ts

@@ -57,7 +57,6 @@ const extractCloudProviderCredentials = (
       authUrl: eventData.spec.credentials.openstack?.auth?.auth_url || "",
       credentialId: eventData.spec.credentials.openstack?.auth?.application_credential_id || "",
       credentialSecret: eventData.spec.credentials.openstack?.auth?.application_credential_secret || "",
-      project_id: eventData.spec.credentials.openstack?.auth?.project_id || "",
     };
   } else if (eventData.spec.credentials.aws) {
     providerType = "aws";

package/helpers/link-helper.ts

@@ -32,6 +32,7 @@ export const handleLinkEvent = ({
   const serverChannel = eventData.spec.server_channel;
   const linkServiceServer = `${eventData.spec.server_tenant}/${serverService}`;
   const linkServiceClient = `${eventData.spec.client_tenant}/${clientService}`;
+  const isBeeingDeleted : boolean = !!eventData.meta.deleted;
   const clientToServerLink: Link = {
     name: linkId,
     origin: clientService,
@@ -40,6 +41,7 @@ export const handleLinkEvent = ({
     targetChannel: serverChannel,
     client: clientChannel,
     server: serverChannel,
+    delete: isBeeingDeleted,
   };
 
   const serverToClientLink: Link = {
@@ -50,6 +52,7 @@ export const handleLinkEvent = ({
     targetChannel: serverChannel,
     client: clientChannel,
     server: serverChannel,
+    delete: isBeeingDeleted,
   };
   let updatedServerService: Service | null = null;
   let serverServiceFound = false;

package/helpers/revision-helper.ts

@@ -253,21 +253,25 @@ const updateServiceWithRevision = (
   const existingRevisionIndex = existingService.revisions.findIndex(
     (rev) => rev === entityId,
   );
-  const updatedRevisions =
-    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;
+  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: updatedCurrentRevision,
     role: roles.length > 0 ? roles : existingService.role,
     usage: newRevision.usage,
     startedAt: newRevision.createdAt || existingService.startedAt,
@@ -524,39 +528,52 @@ export const processRevisionData = (
   revisionData: any,
 ): Service => {
   const { solution } = revisionData;
+
+  const config = revisionData?.config?.config || {};
+  const parameters = extractParametersFromConfig(
+    config.parameter || {},
+  );
+  const resources = extractResources(config.resource || {});
+
   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,
+        parameters,
+        resources,
       );
     }
-    return service;
+    return {
+      ...service,
+      parameters: parameters,
+      resources: resources,
+    };
   }
 
-  return processDeployment(service, deployment, revisionData);
+  return 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;
@@ -565,19 +582,6 @@ 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) {
@@ -597,8 +601,8 @@ export const processDeployment = (
           logo: service.logo,
           description:
             roleData.artifact?.ref?.module || roleData.ref?.module || "",
-          resource: roleResources,
-          parameters: allServiceParameters,
+          resource: resources,
+          parameters: parameters,
           hsize: hsize,
           category: hasDuplex || hasVolumeResource ? "stateful" : "",
         };
@@ -608,17 +612,14 @@ export const processDeployment = (
         ) {
           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;
     }
@@ -630,8 +631,8 @@ export const processDeployment = (
         description:
           artifact.ref?.module ||
           (artifact.description?.builtin ? "Builtin Service" : ""),
-        resource: serviceResources,
-        parameters: allServiceParameters,
+        resource: resources,
+        parameters: parameters,
         hsize: hsize,
         ...(deployment.meta?.scaling &&
           Object.keys(deployment.meta.scaling.simple || {}).length > 0 && {
@@ -643,8 +644,8 @@ export const processDeployment = (
 
   return {
     ...service,
-    resources: serviceResources,
-    parameters: allServiceParameters,
+    resources: resources,
+    parameters: parameters,
     role: updatedRoles,
   };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kumori/aurora-backend-handler",
-  "version": "1.0.48",
+  "version": "1.0.50",
   "description": "backend handler",
   "main": "backend-handler.ts",
   "scripts": {
@@ -11,7 +11,7 @@
     "glob": "^11.0.0"
   },
   "dependencies": {
-    "@kumori/aurora-interfaces": "^1.0.6",
+    "@kumori/aurora-interfaces": "^1.0.4",
     "@kumori/kumori-dsl-generator": "^1.0.3",
     "@kumori/kumori-module-generator": "^1.1.6",
     "ts-node": "^10.9.2",

package/websocket-manager.ts

@@ -784,11 +784,36 @@ const handleEvent = async (message: WSMessage) => {
         break;
 
       case "tenant":
+        const existingTenant = tenantsMap.get(entityId);
         const newTenant: Tenant = handleTenantEvent(
           entityId,
           eventData,
           userData,
         );
+        if (existingTenant) {
+          if (
+            !newTenant.resources?.length &&
+            existingTenant.resources?.length
+          ) {
+            newTenant.resources = existingTenant.resources;
+          }
+          if (!newTenant.registry?.length && existingTenant.registry?.length) {
+            newTenant.registry = existingTenant.registry;
+          }
+          if (!newTenant.services?.length && existingTenant.services?.length) {
+            newTenant.services = existingTenant.services;
+          }
+          if (
+            !newTenant.environments?.length &&
+            existingTenant.environments?.length
+          ) {
+            newTenant.environments = existingTenant.environments;
+          }
+          if (!newTenant.projects?.length && existingTenant.projects?.length) {
+            newTenant.projects = existingTenant.projects;
+          }
+        }
+
         tenantsMap.set(entityId, newTenant);
         loadMarketplaceItemsForTenant(entityId, "") //TODO Move to helper
           .then((items) => {
@@ -1131,7 +1156,12 @@ const handleOperationSuccess = (operation: PendingOperation, response: any) => {
             tenantsMap.set(entityName, newTenant);
             eventHelper.tenant.publish.created(newTenant);
           } else if (action === "UPDATE") {
-            const updatedTenant = { ...originalData, status: "active" };
+            const existingTenant = tenantsMap.get(entityName);
+            const updatedTenant = {
+              ...existingTenant,
+              ...originalData,
+              status: "active",
+            };
             tenantsMap.set(entityName, updatedTenant);
             eventHelper.tenant.publish.updated(updatedTenant);
           }