@kumori/aurora-backend-handler 1.0.99 → 1.0.111

package/event-helper.ts

@@ -1,3 +1,4 @@
+import { loadUser } from './api/user-api-service';
 import { Account, Environment, Link, MarketplaceItem, MarketplaceService, Organization, PlanProvider, Registry, Tenant, tenantRole, User, Service, Notification, Resource } from "@kumori/aurora-interfaces";
 import { EventNames } from "./event-names";
 export interface RegistryUpdatePayload {
@@ -63,7 +64,7 @@ export class EventHelper {
         updateInvite: this.createEvent<{ tenant: string; user: string; role: tenantRole; }>(EventNames.UpdateInvite).publish,
         inviteUpdated: this.createEvent<{ tenant: string; user: string; role: tenantRole; }>(EventNames.InviteUpdated).publish,
         inviteUpdateError: this.createEvent<{ tenant: string; user: string;  role: tenantRole; }>(EventNames.InviteUpdateError).publish,
-        rejectInvite: this.createEvent<{ tenant: string; }>(EventNames.RejectInvite).publish,
+        rejectInvite: this.createEvent<{ tenant: string; leave: boolean }>(EventNames.RejectInvite).publish,
         inviteRejected: this.createEvent<{ user: string; tenant: string; }>(EventNames.InviteRejected).publish,
         inviteRejectError: this.createEvent<{ tenant: string; }>(EventNames.InviteRejectError).publish,
         createToken: this.createEvent<{ tenant: string; expiration: string; description: string }>(EventNames.CreateToken).publish,
@@ -104,7 +105,7 @@ export class EventHelper {
         updateInvite: this.createEvent<{ tenant: string; user: string; role: tenantRole; }>(EventNames.UpdateInvite).subscribe,
         inviteUpdated: this.createEvent<{ tenant: string; user: string; role: tenantRole; }>(EventNames.InviteUpdated).subscribe,
         inviteUpdateError: this.createEvent<{ tenant: string; user: string;  role: tenantRole; }>(EventNames.InviteUpdateError).subscribe,
-        rejectInvite: this.createEvent<{ tenant: string; }>(EventNames.RejectInvite).subscribe,
+        rejectInvite: this.createEvent<{ tenant: string; leave: boolean }>(EventNames.RejectInvite).subscribe,
         inviteRejected: this.createEvent<{ user: string; tenant: string; }>(EventNames.InviteRejected).subscribe,
         inviteRejectError: this.createEvent<{ tenant: string; }>(EventNames.InviteRejectError).subscribe,
         createToken: this.createEvent<{ tenant: string; expiration: string; description: string }>(EventNames.CreateToken).subscribe,
@@ -145,7 +146,7 @@ export class EventHelper {
         updateInvite: this.createEvent<{ tenant: string; user: string; role: tenantRole; }>(EventNames.UpdateInvite).unsubscribe,
         inviteUpdated: this.createEvent<{ tenant: string; user: string; role: tenantRole; }>(EventNames.InviteUpdated).unsubscribe,
         inviteUpdateError: this.createEvent<{ tenant: string; user: string;  role: tenantRole; }>(EventNames.InviteUpdateError).unsubscribe,
-        rejectInvite: this.createEvent<{ tenant: string; }>(EventNames.RejectInvite).unsubscribe,
+        rejectInvite: this.createEvent<{ tenant: string; leave: boolean }>(EventNames.RejectInvite).unsubscribe,
         inviteRejected: this.createEvent<{ user: string; tenant: string; }>(EventNames.InviteRejected).unsubscribe,
         inviteRejectError: this.createEvent<{ tenant: string; }>(EventNames.InviteRejectError).unsubscribe,
         createToken: this.createEvent<{ tenant: string; expiration: string; description: string }>(EventNames.CreateToken).unsubscribe,
@@ -405,6 +406,9 @@ export class EventHelper {
         deletionError: this.createEvent<Service>(EventNames.MarketplaceItemDeletionError).publish,
         loadItems: this.createEvent<string[]>(EventNames.LoadMarketplaceItems).publish,
         itemsLoaded: this.createEvent<MarketplaceItem[]>(EventNames.MarketplaceItemsLoaded).publish,
+        loadSchema: this.createEvent<string>(EventNames.LoadMarketplaceSchema).publish,
+        schemaLoaded: this.createEvent<MarketplaceItem>(EventNames.MarketplaceSchemaLoaded).publish,
+        schemaLoadError: this.createEvent<string>(EventNames.MarketplaceSchemaLoadError).publish,
       },
       subscribe: {
         deployItem: this.createEvent<MarketplaceService>(EventNames.DeployMarketplaceItem).subscribe,
@@ -418,6 +422,9 @@ export class EventHelper {
         deletionError: this.createEvent<Service>(EventNames.MarketplaceItemDeletionError).subscribe,
         loadItems: this.createEvent<string[]>(EventNames.LoadMarketplaceItems).subscribe,
         itemsLoaded: this.createEvent<MarketplaceItem[]>(EventNames.MarketplaceItemsLoaded).subscribe,
+        loadSchema: this.createEvent<string>(EventNames.LoadMarketplaceSchema).subscribe,
+        schemaLoaded: this.createEvent<MarketplaceItem>(EventNames.MarketplaceSchemaLoaded).subscribe,
+        schemaLoadError: this.createEvent<string>(EventNames.MarketplaceSchemaLoadError).subscribe,
       },
       unsubscribe: {
         deployItem: this.createEvent<MarketplaceService>(EventNames.DeployMarketplaceItem).unsubscribe,
@@ -431,6 +438,9 @@ export class EventHelper {
         deletionError: this.createEvent<Service>(EventNames.MarketplaceItemDeletionError).unsubscribe,
         loadItems: this.createEvent<string[]>(EventNames.LoadMarketplaceItems).unsubscribe,
         itemsLoaded: this.createEvent<MarketplaceItem[]>(EventNames.MarketplaceItemsLoaded).unsubscribe,
+        loadSchema: this.createEvent<string>(EventNames.LoadMarketplaceSchema).unsubscribe,
+        schemaLoaded: this.createEvent<MarketplaceItem>(EventNames.MarketplaceSchemaLoaded).unsubscribe,
+        schemaLoadError: this.createEvent<string>(EventNames.MarketplaceSchemaLoadError).unsubscribe,
       },
     };
   }

package/event-names.ts

@@ -117,6 +117,9 @@ export enum EventNames {
 	MarketplaceItemDeletionError = "marketplaceItemDeletionError",
 	LoadMarketplaceItems = "loadMarketplaceItems",
 	MarketplaceItemsLoaded = "marketplaceItemsLoaded",
+	LoadMarketplaceSchema = "loadMarketplaceSchema",
+	MarketplaceSchemaLoaded = "marketplaceSchemaLoaded",
+	MarketplaceSchemaLoadError = "marketplaceSchemaLoadError",
 	// * Resource
 	CreateResource = "createResource",
 	ResourceCreated = "resourceCreated",

package/helpers/account-helper.ts

@@ -1,4 +1,4 @@
-import { Account, Notification } from "@kumori/aurora-interfaces";
+import { Account, errors, Notification } from "@kumori/aurora-interfaces";
 const CREDENTIAL_ERROR_CODES = new Set([
   "_error_retrieving_credentials_",
   "_invalid_account_credentials_",
@@ -169,11 +169,14 @@ export const syncAccountStatusFromNotifications = (
     const accountName: string = notification.data?.account;
     if (!accountName) continue;
 
-    const account = accountsMap.get(accountName);
+    const accountTenant: string = notification.data?.tenant ?? "";
+    const accountKey = accountTenant ? `${accountTenant}/${accountName}` : accountName;
+
+    const account = accountsMap.get(accountKey);
     if (!account || ACCOUNT_ERROR_STATUSES.has(account.status)) continue;
 
     const code: string = notification.info_content?.code ?? "";
-    accountsMap.set(accountName, {
+    accountsMap.set(accountKey, {
       ...account,
       status: resolveErrorStatus(code),
     });
@@ -194,7 +197,8 @@ export const handleAccountEvent = ({
     extractCloudProviderCredentials(eventData);
   const accountLabels: Record<string, string> = eventData.meta.labels;
   const hasCredentials = "__axebow::managedCredentials" in accountLabels;
-  const existingAccount = accountsMap.get(entityId);
+  const accountKey = accountTenantId ? `${accountTenantId}/${entityId}` : entityId;
+  const existingAccount = accountsMap.get(accountKey);
   const accountStatus = determineAccountStatus(eventData, existingAccount);
 
   const newAccount: Account = {
@@ -285,7 +289,7 @@ export const handleAccountOperationSuccess = ({
       shouldDelete: true,
       notification: {
         type: "success",
-        subtype: "account-deleted",
+        subtype: errors.account.deleted.subtype,
         date: Date.now().toString(),
         status: "unread",
         callToAction: false,
@@ -304,7 +308,7 @@ export const handleAccountOperationSuccess = ({
       shouldDelete: false,
       notification: {
         type: "success",
-        subtype: isCreate ? "account-created" : "account-updated",
+        subtype: isCreate ? errors.account.created.subtype : errors.account.updated.subtype,
         date: Date.now().toString(),
         status: "unread",
         callToAction: false,
@@ -345,12 +349,6 @@ export const handleAccountOperationError = ({
   const isCreate = action === "CREATE";
   const isUpdate = action === "UPDATE";
 
-  const subtype = isCreate
-    ? "account-creation-error"
-    : isUpdate
-      ? "account-update-error"
-      : "account-deletion-error";
-
   const eventType: "creationError" | "updateError" | "deletionError" = isCreate
     ? "creationError"
     : isUpdate
@@ -359,9 +357,10 @@ export const handleAccountOperationError = ({
   const errorCode: string = error?.error?.code ?? error?.code ?? "";
   const errorStatus = resolveErrorStatus(errorCode);
 
+  const errEntry = isCreate ? errors.account.creationError : isUpdate ? errors.account.updateError : errors.account.deletionError;
   const notification: Notification = {
     type: "error",
-    subtype,
+    subtype: errEntry.subtype,
     date: Date.now().toString(),
     status: "unread",
     info_content: {

package/helpers/environment-helper.ts

@@ -1,4 +1,4 @@
-import { Account, Environment, Notification } from "@kumori/aurora-interfaces";
+import { Account, Environment, errors, Notification } from "@kumori/aurora-interfaces";
 
 
 
@@ -56,7 +56,8 @@ export const handleEnvironmentEvent = ({
 }: HandleEnvironmentEventParams): HandleEnvironmentEventResult => {
   const tenantId = parentParts.tenant;
   const accountId = parentParts.account;
-  const relatedAccount = accountsMap.get(accountId);
+  const accountKey = tenantId ? `${tenantId}/${accountId}` : accountId;
+  const relatedAccount = accountsMap.get(accountKey);
   let cloudProviderName = relatedAccount?.cloudProvider?.name || "";
 
   let pendingCloudProviderUpdate: { environmentId: string; accountId: string } | null = null;
@@ -68,7 +69,8 @@ export const handleEnvironmentEvent = ({
     };
   }
 
-  const existingEnvironment = environmentsMap.get(entityId);
+  const envKey = tenantId && accountId ? `${tenantId}/${accountId}/${entityId}` : entityId;
+  const existingEnvironment = environmentsMap.get(envKey);
 
   const newEnvironment: Environment = {
     id: entityId,
@@ -78,17 +80,18 @@ export const handleEnvironmentEvent = ({
     logo: "",
     services: [],
     domains: [],
-    status: eventData.meta?.deleted
-      ? {
-          code: "DELETING",
-          message: `Environment ${entityId} is being deleted.`,
-          timestamp: new Date().toISOString(),
-        }
-      : {
-          code: eventData.status.state.code,
-          message: eventData.status.state.message,
-          timestamp: eventData.status.state.timestamp,
-        },
+    status: (() => {
+      const existingCode = existingEnvironment?.status?.code;
+      const isPurging = existingCode === "PURGING" || existingCode === "CLEANING_ENVIRONMENT";
+      const eventCode = eventData.meta?.deleted ? "DELETING" : eventData.status?.state?.code;
+      if (isPurging && typeof eventCode === "string" && eventCode.startsWith("DELETING")) {
+        return { code: "PURGING", message: `Environment ${entityId} is being purged.`, timestamp: new Date().toISOString() };
+      }
+      if (eventData.meta?.deleted) {
+        return { code: "DELETING", message: `Environment ${entityId} is being deleted.`, timestamp: new Date().toISOString() };
+      }
+      return { code: eventData.status.state.code, message: eventData.status.state.message, timestamp: eventData.status.state.timestamp };
+    })(),
     highAvaliable: eventData.spec.highlyAvailable || false,
     usage: {
       current: {
@@ -181,7 +184,7 @@ export const handleEnvironmentOperationSuccess = ({
 
     const envNotification: Notification = {
       type: "success",
-      subtype: "environment-cleaned",
+      subtype: errors.environment.purged.subtype,
       date: Date.now().toString(),
       status: "unread",
       callToAction: false,
@@ -240,23 +243,16 @@ export const handleEnvironmentOperationError = ({
   originalData,
   error,
 }: HandleEnvironmentOperationErrorParams): HandleEnvironmentOperationErrorResult => {
-  let subtype: string;
-  let eventType: "creationError" | "updateError" | "deletionError";
-
-  if (action === "CREATE") {
-    subtype = "environment-creation-error";
-    eventType = "creationError";
-  } else if (action === "UPDATE") {
-    subtype = "environment-update-error";
-    eventType = "updateError";
-  } else {
-    subtype = "environment-deletion-error";
-    eventType = "deletionError";
-  }
+  const eventType: "creationError" | "updateError" | "deletionError" = action === "CREATE"
+    ? "creationError"
+    : action === "UPDATE"
+      ? "updateError"
+      : "deletionError";
 
+  const envErrEntry = action === "CREATE" ? errors.environment.creationError : action === "UPDATE" ? errors.environment.updateError : errors.environment.deletionError;
   const envErrorNotification: Notification = {
     type: "error",
-    subtype,
+    subtype: envErrEntry.subtype,
     date: Date.now().toString(),
     status: "unread",
     info_content: {

package/helpers/marketplace-helper.ts

@@ -0,0 +1,109 @@
+export const processMarketplaceSchemaResponse = (rawEntry: any, nameKey: string) => {
+  const roles: string[] = rawEntry.roles || [];
+  const roleName = roles.join(", ");
+  const schemas = rawEntry.schemas || [];
+
+  const processSchema = (schema: any) => {
+    const parameters: any[] = [];
+    const resources: any[] = [];
+    const channels: any[] = [];
+
+    const configProps = schema.properties?.config?.properties;
+    if (configProps) {
+      Object.entries(configProps).forEach(([key, value]: [string, any]) => {
+        parameters.push({
+          name: key,
+          type: value.type || "string",
+          required: schema.properties?.config?.required?.includes(key) || false,
+          defaultValue: value.default ?? value.enum?.[0] ?? value.const ?? undefined,
+        });
+      });
+    }
+
+    const volumeTypes = ["Registered", "NonReplicated", "Persisted", "Volatile", "Ephemeral", "Persistent"];
+    const isVolumeResource = (v: any): boolean => {
+      if (!v.oneOf) return false;
+      return v.oneOf.some((o: any) => {
+        if (o.oneOf) return o.oneOf.some((n: any) => volumeTypes.includes(n?.properties?.$kdsl?.const?.NamedType?.Name));
+        return volumeTypes.includes(o?.properties?.$kdsl?.const?.NamedType?.Name);
+      });
+    };
+
+    const resourceProps = schema.properties?.resource;
+    if (resourceProps?.properties) {
+      Object.entries(resourceProps.properties).forEach(([key, value]: [string, any]) => {
+        if (isVolumeResource(value)) {
+          resources.push({
+            name: key,
+            type: "volume",
+            required: resourceProps.required?.includes(key) || false,
+          });
+        } else {
+          const typeName = value.properties?.["$kdsl"]?.const?.NamedType?.Name;
+          const resourceType = typeName ? typeName.toLowerCase() : Object.keys(value.properties || {})[0];
+          const inner = value.properties?.[resourceType] || value.properties?.inner;
+          const defaultValue =
+            inner?.default !== undefined
+              ? String(inner.default)
+              : inner?.enum?.[0]
+                ? String(inner.enum[0])
+                : undefined;
+          resources.push({
+            name: key,
+            type: resourceType || "string",
+            required: resourceProps.required?.includes(key) || false,
+            defaultValue,
+          });
+        }
+      });
+    }
+
+    const srvProps = schema.properties?.srv?.properties;
+    if (srvProps) {
+      (["client", "server", "duplex"] as const).forEach((channelType) => {
+        if (srvProps[channelType]?.properties) {
+          Object.entries(srvProps[channelType].properties).forEach(([channelName, channelData]: [string, any]) => {
+            const port = channelData.properties?.port?.const || channelData.properties?.port?.enum?.[0];
+            const protocol = channelData.properties?.protocol?.const || channelData.properties?.protocol?.enum?.[0];
+            channels.push({
+              name: channelName,
+              type: channelType,
+              resource: port && protocol ? { type: "port", value: `${protocol}:${port}` } : undefined,
+            });
+          });
+        }
+      });
+    }
+
+    return { parameters, resources, channels };
+  };
+
+  if (schemas.length > 0 && schemas[0].oneOf) {
+    const processedVariants: any[] = [];
+    for (const schemaRef of schemas[0].oneOf) {
+      const refKey = schemaRef.$ref?.replace("#/$defs/", "");
+      const actualSchema = schemas[0].$defs?.[refKey];
+      if (actualSchema) {
+        const result = processSchema(actualSchema);
+        processedVariants.push({ name: nameKey, roleName, roles, variant: refKey, ...result });
+      }
+    }
+    return {
+      parameters: processedVariants[0]?.parameters || [],
+      resources: processedVariants[0]?.resources || [],
+      channels: processedVariants[0]?.channels || [],
+      name: nameKey,
+      roleName,
+      roles,
+      hasVariants: true,
+      variants: processedVariants,
+    };
+  }
+
+  if (schemas[0]) {
+    const result = processSchema(schemas[0]);
+    return { ...result, name: nameKey, roleName, roles, hasVariants: false };
+  }
+
+  return { parameters: [], resources: [], channels: [], name: nameKey, roleName, roles, hasVariants: false };
+};

package/helpers/resource-helper.ts

@@ -239,7 +239,9 @@ export const handleResourceEvent = ({
     if (existingIndex !== -1) {
       existingResource = tenant.resources[existingIndex];
       publishUpdate = true;
-      tenant.resources[existingIndex] = resource;
+      tenant.resources[existingIndex] = existingResource.deleting
+        ? { ...resource, deleting: true }
+        : resource;
     } else {
       tenant.resources.push(resource);
     }
@@ -376,6 +378,22 @@ export const handleVolumeEvent = (
     hasRequestingServices: false
   });
 };
+export const setResourceDeleting = (
+  tenantsMap: Map<string, any>,
+  tenantName: string,
+  resourceName: string,
+  resourceType: string,
+) => {
+  const tenant = tenantsMap.get(tenantName);
+  if (!tenant) return;
+  const index = tenant.resources.findIndex(
+    (res: Resource) => res.name === resourceName && res.type === resourceType,
+  );
+  if (index === -1) return;
+  tenant.resources[index] = { ...tenant.resources[index], deleting: true };
+  tenantsMap.set(tenantName, tenant);
+};
+
 export const processResourceResult = (
   result: any,
   tenantsMap: Map<string, any>,

package/helpers/revision-helper.ts

@@ -159,12 +159,55 @@ const processRolesAndInstances = (
   return { roles, instances, usedCpu, usedMemory };
 };
 
+const getContainerError = (
+  revisionStatus: any,
+): { code: string; message: string; timestamp: string } | null => {
+  for (const roleData of Object.values<any>(revisionStatus?.runtime?.roles ?? {})) {
+    for (const instanceData of Object.values<any>(roleData.instances ?? {})) {
+      for (const container of Object.values<any>(instanceData.containers ?? {})) {
+        if (!container.status.ready) {
+          return {
+            code: container.status.status.waiting?.reason ?? "ContainerNotReady",
+            message: container.status.status.waiting?.message ?? "One or more containers are not ready for unknown reasons.",
+            timestamp: Date.now().toString(),
+          };
+        }
+      }
+    }
+  }
+  return null;
+};
+
+const handleRevisionStatus = (revisionStatus: any) => {
+  if (!revisionStatus?.runtime) {
+    return revisionStatus?.state;
+  }
+
+  for (const roleData of Object.values<any>(revisionStatus.runtime.roles)) {
+    for (const instanceData of Object.values<any>(roleData.instances)) {
+      for (const container of Object.values<any>(instanceData.containers ?? {})) {
+        if (!container.status.ready) {
+          return {
+            code: container.status.status.waiting?.reason ?? "ContainerNotReady",
+            message: container.status.status.waiting?.message ?? "One or more containers are not ready for unknown reasons.",
+            timestamp: Date.now().toString(),
+          };
+        }
+      }
+    }
+  }
+
+  return revisionStatus?.state;
+};
+
 const createRevision = (
   entityId: string,
   eventData: any,
   usedCpu: number,
   usedMemory: number,
 ): Revision => {
+  const containerError = eventData.status?.error ? null : getContainerError(eventData.status);
+
   return {
     id: entityId,
     schema: {},
@@ -181,7 +224,7 @@ const createRevision = (
         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,
+          max: (eventData.spec.intensives?.volatile_disk / 1000 || 0) + (eventData.spec.intensives?.nrpersistent_disk / 1000 || 0) + (eventData.spec.intensives?.persistent_disk / 1000 || 0),
           min: 0,
         },
         volatileStorage: {
@@ -199,14 +242,13 @@ const createRevision = (
       },
       cost: 0,
     },
-    status: eventData.status.state,
-    errorCode: eventData.status?.error ? eventData.status.error.code : "",
-    errorMsg: eventData.status?.error ? eventData.status.error.message : "",
+    status: handleRevisionStatus(eventData.status),
+    errorCode: eventData.status?.error ? eventData.status.error.code : containerError?.code === "CrashLoopBackOff" ? containerError.code : "",
+    errorMsg: eventData.status?.error ? eventData.status.error.message : containerError?.code === "CrashLoopBackOff" ? containerError.message : "",
     createdAt:
       (eventData.status && eventData.status.runtime?.status?.createdAt) || "",
   };
 };
-
 const updateServiceWithRevision = (
   existingService: Service,
   entityId: string,
@@ -239,13 +281,21 @@ const updateServiceWithRevision = (
           String(rev.id) === String(entityId) ? newRevision : rev,
         );
 
-  const updatedService: Service = {
-    ...existingService,
-    revisions: updatedRevisions,
-    role: roles.length > 0 ? roles : existingService.role,
-    usage: newRevision.usage,
-    startedAt: newRevision.createdAt || existingService.startedAt,
-  };
+  const isCurrentRevision =
+    String(existingService.currentRevision) === String(entityId);
+
+  const updatedService: Service = isCurrentRevision
+    ? {
+        ...existingService,
+        revisions: updatedRevisions,
+        role: roles.length > 0 ? roles : existingService.role,
+        usage: newRevision.usage,
+        startedAt: newRevision.createdAt || existingService.startedAt,
+      }
+    : {
+        ...existingService,
+        revisions: updatedRevisions,
+      };
 
   const deploymentErrorEvent = eventData.status?.error ? updatedService : null;
 
@@ -262,7 +312,7 @@ const updateEnvironmentConsumption = (
 
   servicesMap.forEach((service, svcId) => {
     if (service.environment === serviceEnvironmentId) {
-      const currentRevisionKey = `${svcId}-${service.currentRevision}`;
+      const currentRevisionKey = `/tenant/${svcId.split('/')[0]}/service/${svcId.split('/')[1]}/revision/${service.currentRevision}`;
       const currentRevision = revisionsMap.get(currentRevisionKey);
       if (currentRevision) {
         totalEnvCpu += currentRevision.usage.limit.cpu.max || 0;
@@ -300,7 +350,7 @@ const updateAccountConsumption = (
 
   servicesMap.forEach((service, svcId) => {
     if (service.account === serviceAccountId) {
-      const currentRevisionKey = `${svcId}-${service.currentRevision}`;
+      const currentRevisionKey = `/tenant/${svcId.split('/')[0]}/service/${svcId.split('/')[1]}/revision/${service.currentRevision}`;
       const currentRevision = revisionsMap.get(currentRevisionKey);
       if (currentRevision) {
         totalAccountCpu += currentRevision.usage.limit.cpu.max || 0;
@@ -338,7 +388,7 @@ export const handleRevisionEvent = ({
   accountsMap,
 }: HandleRevisionEventParams): HandleRevisionEventResult => {
   const serviceId = `${parentParts.tenant}/${parentParts.service}`;
-  const revisionKey = `${serviceId}-${entityId}`;
+  const revisionKey = `${eventData.id.parent.name}/revision/${entityId}`;
   const { roles, instances, usedCpu, usedMemory } = processRolesAndInstances(
     eventData,
     serviceId,
@@ -646,7 +696,6 @@ export const processRevisionData = (
     : {};
   const schema =
     schemaResult && "parameters" in schemaResult ? schemaResult : {};
-
   if (
     revisionsMap &&
     serviceId &&
@@ -654,7 +703,8 @@ export const processRevisionData = (
     "parameters" in schema
   ) {
     const revisionId: string = revisionData.revision;
-    const revisionKey = `${serviceId}-${revisionId}`;
+    const [tenantId, serviceName] = serviceId.split('/');
+    const revisionKey = `/tenant/${tenantId}/service/${serviceName}/revision/${revisionId}`;
     const existing = revisionsMap.get(revisionKey);
     if (existing) {
       revisionsMap.set(revisionKey, { ...existing, schema });
@@ -675,7 +725,7 @@ export const processRevisionData = (
             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,
+              max: (revisionData.intensives?.volatile_disk / 1000 || 0) + (revisionData.intensives?.nrpersistent_disk / 1000 || 0) + (revisionData.intensives?.persistent_disk / 1000 || 0),
               min: 0,
             },
             volatileStorage: {