@kumori/aurora-backend-handler 1.0.0

package/websocket-manager.ts

@@ -0,0 +1,1833 @@
+import { v7 as uuidv7 } from "uuid";
+import { environment } from "./environment";
+import { Account, Channel, ClusterToken, Environment, Instance, Link, MarketplaceService, Notification, Organization, Plan, PlanProvider, Platform, Registry, Resource, Service, Tenant, tenantRole, Token, Usage, User, UserData } from "@hestekumori/aurora-interfaces";
+import { loadMarketplaceItemsForTenant } from "./api/marketplace-api-service";
+import { getReporting } from "./api/reporting-api-service";
+import { parseKeyPath } from "./utils/utils";
+import {
+  handleTenantEvent,
+  handleTenantOperationSuccess,
+} from "./helpers/tenant-helper";
+import {
+  handleUserEvent,
+  handleUserOperationError,
+} from "./helpers/user-helper";
+import {
+  handleEnvironmentEvent,
+  handleEnvironmentOperationError,
+  handleEnvironmentOperationSuccess,
+} from "./helpers/environment-helper";
+import { handleRevisionEvent, processRevisionData } from "./helpers/revision-helper";
+import {
+  handleServiceEvent,
+  handleServiceOperationError,
+  handleServiceOperationSuccess,
+  mapChannelsFromApiData,
+} from "./helpers/service-helper";
+import {
+  handleAccountEvent,
+  handleAccountOperationError,
+  handleAccountOperationSuccess,
+} from "./helpers/account-helper";
+import {
+  handleCAEvent,
+  handleCertificateEvent,
+  handleDomainEvent,
+  handlePortEvent,
+  handleSecretEvent,
+  handleVolumeEvent,
+  processResourceResult,
+} from "./helpers/resource-helper";
+import {
+  handlePlanInstanceEvent,
+  updateUserPlansAfterPlanEvent,
+} from "./helpers/plan-helper";
+import { handleRegistryEvent } from "./helpers/registry-helper";
+import {
+  handleTokenEvent,
+  handleTokenOperationSuccess,
+} from "./helpers/token-helper";
+import { handleLinkEvent } from "./helpers/link-helper";
+import { eventHelper } from "./backend-handler";
+
+let WebSocketClass: any;
+
+interface WSMessage {
+  messageId: string;
+  payload: any;
+  topic: string;
+  type: "request" | "multipartrequest" | "success" | "error" | "event";
+  error?: {
+    code?: string;
+    message?: string;
+    content?: string;
+  };
+}
+interface Revision {
+  service: string;
+  revision: string;
+  usage: Usage;
+  status: {
+    code: string;
+    message: string;
+    timestamp: string;
+    args: string[];
+  };
+  errorCode?: string;
+  errorMsg?: string;
+  createdAt?: string;
+}
+interface PendingOperation {
+  resolve: Function;
+  reject: Function;
+  action: string;
+  entityType: string;
+  entityName: string;
+  originalData?: any;
+  responsePayload?: any;
+}
+if (typeof window === "undefined") {
+  WebSocketClass = require("ws");
+} else {
+  WebSocketClass = WebSocket;
+}
+interface Role {
+  name: string;
+  instances: Instance[];
+  logo?: string;
+  category?: string;
+  version?: string;
+  description?: string;
+  resource?: Resource[];
+  parameters?: { [key: string]: string }[];
+  registry?: string;
+  imageTag?: string;
+  entrypoint?: string;
+  cmd?: string;
+  scalling?: {
+    cpu: {
+      up: string;
+      down: string;
+    };
+    memory: {
+      up: string;
+      down: string;
+    };
+    instances: {
+      max: number;
+      min: number;
+    };
+    histeresys: string;
+  };
+  hsize?: number;
+}
+
+/**
+ * Global WebSocket client instance and pending requests
+ */
+let wsConnection: WebSocket | null = null;
+let pendingRequests = new Map<string, PendingOperation>();
+let currentToken: string | null = null;
+let connectionPromise: Promise<WebSocket> | null = null;
+let userData: UserData = {
+  id: "",
+  name: "",
+  surname: "",
+  provider: [],
+  notificationsEnabled: "",
+  organizations: [],
+  clusterTokens: [],
+  tokens: [],
+  tenants: [],
+  axebowPlan: "freemium",
+  companyName: "",
+  rol: "",
+};
+let user: User = new User(userData);
+let tenantsMap = new Map<string, Tenant>();
+let clusterTokensMap = new Map<string, ClusterToken>();
+let servicesMap = new Map<string, Service>();
+let organizationsMap = new Map<string, Organization>();
+let environmentsMap = new Map<string, Environment>();
+let accountsMap = new Map<string, Account>();
+let revisionsMap = new Map<string, Revision>();
+let roleMap = new Map<string, Role[]>();
+let tokenMap = new Map<string, Token>();
+let platformInfo: Platform | null = null;
+let isPlatformInfoLoading = false;
+let isPlatformInfoLoaded = false;
+const pendingDomains: Resource[] = [];
+let globalEntityName: string | null = null;
+let pendingEnvironments: Array<{ tenant: string; env: Environment }> = [];
+let pendingRevisionErrors: Array<{ service: string; revision: Revision }> = [];
+let pendingCloudProviderUpdates: Array<{
+  environmentId: string;
+  accountId: string;
+}> = [];
+let plansMap = new Map<string, Plan>();
+let pendingRegistries: Array<{ tenant: string; registry: Registry }> = [];
+let secretsMap = new Map<string, any>();
+let tempProviders: Record<string, string> = {};
+let pendingProjects: Array<{ tenant: string; project: string }> = [];
+let isLoadingReporting = false;
+const REPORTING_ITERATIONS = 5;
+const REPORTING_INTERVAL = 1000;
+let hasLoadedReportingOnce = false;
+
+/**
+ * Helper function to safely stringify error objects
+ */
+const safeStringifyError = (error: any): string => {
+  if (typeof error === "string") {
+    return error;
+  }
+
+  if (error && typeof error === "object") {
+    try {
+      if (error.message) return error.message;
+      if (error.error) {
+        if (typeof error.error === "string") return error.error;
+        if (error.error.message) return error.error.message;
+        if (error.error.content) return error.error.content;
+        if (error.error.description) return error.error.description;
+        return JSON.stringify(error.error);
+      }
+      if (error.content) return error.content;
+      if (error.description) return error.description;
+      return JSON.stringify(error);
+    } catch (stringifyError) {
+      return `Error object could not be stringified: ${error.toString()}`;
+    }
+  }
+
+  return String(error);
+};
+
+/**
+ * Initialize global WebSocket connection
+ * @param token Authorization token
+ * @returns Promise that resolves to WebSocket instance
+ */
+export const initializeGlobalWebSocketClient = async (
+  token: string,
+  type?: string,
+  name?: string,
+  previousData?: UserData,
+): Promise<WebSocket> => {
+  userData.notifications = previousData?.notifications;
+  globalEntityName = name || null;
+  if (
+    wsConnection &&
+    wsConnection.readyState === WebSocket.OPEN &&
+    currentToken === token
+  ) {
+    return wsConnection;
+  }
+
+  if (connectionPromise) {
+    try {
+      return await connectionPromise;
+    } catch (error) {
+      connectionPromise = null;
+    }
+  }
+
+  if (wsConnection && currentToken !== token) {
+    wsConnection.close();
+    wsConnection = null;
+    platformInfo = null;
+    isPlatformInfoLoaded = false;
+    isPlatformInfoLoading = false;
+  }
+  const baseUrl = environment.apiServer.baseUrl.replace("http", "ws");
+  const wsUrl = `${baseUrl}/api/${environment.apiServer.apiVersion}/ws`;
+
+  connectionPromise = new Promise((resolve, reject) => {
+    try {
+      if (typeof window === "undefined") {
+        wsConnection = new WebSocketClass(wsUrl, {
+          headers: {
+            authorization: `Bearer ${token}`,
+          },
+        });
+      } else {
+        wsConnection = new WebSocketClass(wsUrl);
+      }
+
+      wsConnection?.addEventListener("open", async () => {
+        currentToken = token;
+        connectionPromise = null;
+
+        resolve(wsConnection!);
+      });
+
+      wsConnection?.addEventListener("message", (event) => {
+        try {
+          const rawMessage = typeof window === "undefined" ? event : event.data;
+          const message: WSMessage = JSON.parse(rawMessage.toString());
+
+          if (message.type === "success" || message.type === "error") {
+            const pending = pendingRequests.get(message.messageId);
+            if (pending) {
+              pendingRequests.delete(message.messageId);
+              if (message.type === "success") {
+                handleOperationSuccess(
+                  {
+                    ...pending,
+                    action:
+                      message.messageId.split(":")[1].split("/")[0] ||
+                      pending.action,
+                    entityType:
+                      message.payload?.data?.id?.kind ||
+                      (Array.isArray(message.payload?.data) &&
+                        message.payload.data[0]?.id?.kind) ||
+                      pending.entityType,
+                    entityName:
+                      message.payload?.data?.id?.name ||
+                      globalEntityName ||
+                      pending.entityName,
+                    originalData: pending.originalData,
+                    responsePayload: message.payload,
+                  },
+                  message,
+                );
+                pending.resolve(message);
+              } else {
+                console.error("WebSocket error response:", {
+                  messageId: message.messageId,
+                  fullMessage: message,
+                });
+                handleOperationError(
+                  {
+                    ...pending,
+                    action:
+                      message.messageId.split("ACTION:")[1].split("/ON")[0] ||
+                      pending.action,
+                    entityType:
+                      message.payload?.data?.id?.kind ||
+                      pending.entityType ||
+                      "unknown",
+                    entityName:
+                      message.payload?.data?.id?.name ||
+                      pending.entityName ||
+                      globalEntityName ||
+                      "unknown",
+                    originalData: pending.originalData,
+                  },
+                  message,
+                );
+                pending.reject(message);
+              }
+            }
+          }
+
+          if (message.type === "event") {
+            handleEvent(message);
+          } else if (
+            message.type === "error" &&
+            message.error?.code === "_unknown_user_" &&
+            message.error?.content !== "Unknown proposed user."
+          ) {
+            userData.status = "unknown";
+            user = new User(userData);
+            eventHelper.user.publish.loaded(user);
+          }
+        } catch (error) {
+          console.error("Error parsing WebSocket message:", error, {
+            rawMessage: typeof window === "undefined" ? event : event.data,
+          });
+        }
+      });
+
+      wsConnection?.addEventListener("close", () => {
+        wsConnection = null;
+        currentToken = null;
+        connectionPromise = null;
+        platformInfo = null;
+        isPlatformInfoLoaded = false;
+        isPlatformInfoLoading = false;
+
+        pendingRequests.forEach((pending, messageId) => {
+          pending.reject(new Error("WebSocket connection closed"));
+          pendingRequests.delete(messageId);
+        });
+      });
+
+      wsConnection?.addEventListener("error", (error) => {
+        console.error("Global WebSocket error:", error);
+        connectionPromise = null;
+        reject(error);
+      });
+    } catch (error) {
+      connectionPromise = null;
+      reject(error);
+    }
+  });
+
+  return connectionPromise;
+};
+
+/**
+ * Function to make WebSocket requests using the global connection
+ * @param topic Request topic (group:method)
+ * @param payload Request payload
+ * @param timeout Request timeout in milliseconds
+ * @returns The response data
+ */
+export const makeGlobalWebSocketRequest = async (
+  topic: string,
+  payload: any = {},
+  timeout = 30000,
+  petitionAction: string = "",
+  petitionInfo: string = "",
+  entityType: string = "",
+  originalData?: any,
+): Promise<any> => {
+  if (!wsConnection || wsConnection.readyState !== WebSocket.OPEN) {
+    throw new Error(
+      "Global WebSocket connection not established. Call initializeGlobalWebSocketClient first.",
+    );
+  }
+
+  const requestId = uuidv7();
+  const messageId =
+    "ACTION:" +
+    petitionAction +
+    "/ON:/" +
+    petitionInfo +
+    "/" +
+    Date.now() +
+    "-" +
+    requestId;
+  const request = {
+    messageId: messageId,
+    type: "request",
+    topic,
+    payload,
+  };
+
+  return new Promise((resolve, reject) => {
+    const timeoutId = setTimeout(() => {
+      const pending = pendingRequests.get(messageId);
+      if (pending) {
+        pendingRequests.delete(messageId);
+        handleOperationError(
+          {
+            ...pending,
+            action: petitionAction,
+            entityType: entityType,
+            entityName: petitionInfo,
+          },
+          new Error(`Request timeout for ${topic}`),
+        );
+      }
+      reject(new Error(`Request timeout for ${topic}`));
+    }, timeout);
+
+    const operation: PendingOperation = {
+      resolve: (response: any) => {
+        clearTimeout(timeoutId);
+        resolve(response.payload || response);
+      },
+      reject: (error: any) => {
+        clearTimeout(timeoutId);
+        const errorMessage = safeStringifyError(error);
+        console.error(`WebSocket request failed for ${topic}:`, {
+          originalError: error,
+          errorMessage,
+          messageId,
+          topic,
+          payload,
+        });
+        reject(error);
+      },
+      action: petitionAction,
+      entityType: entityType,
+      entityName: petitionInfo,
+      originalData: {
+        ...originalData,
+        payload: payload,
+      },
+    };
+
+    pendingRequests.set(messageId, operation);
+    wsConnection!.send(JSON.stringify(request));
+  });
+};
+
+/**
+ * Helper function for WebSocket requests with retry logic using global connection
+ * @param topic Request topic
+ * @param payload Request payload
+ * @param maxRetries Maximum number of retries
+ * @param timeout Request timeout
+ * @returns The response data
+ */
+export const makeGlobalWebSocketRequestWithRetry = async (
+  topic: string,
+  payload: any = {},
+  maxRetries: number = 3,
+  timeout = 30000,
+  petitionAction: string = "",
+  petitionInfo: string = "",
+  entityType: string = "",
+  originalData?: any,
+): Promise<any> => {
+  let lastError: Error | null = null;
+
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      const result = await makeGlobalWebSocketRequest(
+        topic,
+        payload,
+        timeout,
+        petitionAction,
+        petitionInfo,
+        entityType,
+        originalData,
+      );
+      return result;
+    } catch (error) {
+      lastError = error as Error;
+      console.warn(`Attempt ${attempt} failed for ${topic}:`, {
+        error,
+        errorMessage:
+          error instanceof Error ? error.message : safeStringifyError(error),
+      });
+
+      if (attempt < maxRetries) {
+        const delay = Math.min(1000 * Math.pow(2, attempt - 1), 5000);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+  }
+
+  throw (
+    lastError || new Error(`Failed after ${maxRetries} attempts for ${topic}`)
+  );
+};
+
+/**
+ * Get the current WebSocket connection status
+ * @returns Connection status and token info
+ */
+export const getWebSocketStatus = () => {
+  return {
+    connected: wsConnection?.readyState === WebSocket.OPEN,
+    readyState: wsConnection?.readyState,
+    currentToken: currentToken ? "***" + currentToken.slice(-4) : null,
+    pendingRequests: pendingRequests.size,
+    platformInfoLoaded: isPlatformInfoLoaded,
+  };
+};
+
+/**
+ * Close the global WebSocket connection
+ */
+export const closeGlobalWebSocketConnection = () => {
+  if (wsConnection) {
+    wsConnection.close();
+    wsConnection = null;
+    currentToken = null;
+    connectionPromise = null;
+  }
+
+  platformInfo = null;
+  isPlatformInfoLoaded = false;
+  isPlatformInfoLoading = false;
+
+  pendingRequests.forEach((pending, messageId) => {
+    pending.reject(new Error("WebSocket connection manually closed"));
+    pendingRequests.delete(messageId);
+  });
+};
+
+const rebuildHierarchy = () => {
+  const preservedUserData = { ...userData };
+
+  tenantsMap.forEach((tenant) => {
+    tenant.accounts = Array.from(accountsMap.values()).filter((account) => {
+      account.environments = Array.from(environmentsMap.values())
+        .filter((env) => env.account === account.id)
+        .map((env) => env.name);
+      return account.tenant === tenant.id;
+    });
+
+    tenant.environments = Array.from(environmentsMap.values()).filter(
+      (env) => env.tenant === tenant.id,
+    );
+
+    tenant.services = Array.from(servicesMap.values()).filter(
+      (service) => service.tenant === tenant.id,
+    );
+
+    for (let i = pendingProjects.length - 1; i >= 0; i--) {
+      const { tenant: tenantId, project } = pendingProjects[i];
+      if (tenantId === tenant.id) {
+        if (!tenant.projects) {
+          tenant.projects = [];
+        }
+        if (!tenant.projects.includes(project)) {
+          tenant.projects.push(project);
+        }
+        pendingProjects.splice(i, 1);
+      }
+    }
+  });
+
+  userData = {
+    id: preservedUserData.id,
+    name: preservedUserData.name,
+    surname: preservedUserData.surname,
+    provider: preservedUserData.provider.map((p) => ({ ...p })),
+    notificationsEnabled: preservedUserData.notificationsEnabled,
+    organizations: Array.from(organizationsMap.values()),
+    clusterTokens: Array.from(clusterTokensMap.values()),
+    tokens: preservedUserData.tokens || [],
+    tenants: Array.from(tenantsMap.values()),
+    axebowPlan: preservedUserData.axebowPlan,
+    companyName: preservedUserData.companyName,
+    rol: preservedUserData.rol,
+    platform: preservedUserData.platform,
+    status: preservedUserData.status,
+    notifications: preservedUserData.notifications || [],
+    plans: preservedUserData.plans || [],
+  };
+};
+const handleEvent = async (message: WSMessage) => {
+  if (message.payload.deleted === true) {
+    await handleDeleteEvent(message);
+  } else {
+    const kind = message.payload.record.id.kind;
+    const eventData = message.payload.record;
+    const entityId = eventData.id.name;
+    const hasRequestingServices =
+      eventData.status?.requesting_services &&
+      Object.keys(eventData.status.requesting_services).length > 0;
+    const parentParts = eventData.id.parent
+      ? parseKeyPath(eventData.id.parent.name)
+      : {};
+    switch (kind) {
+      case "user":
+        const userEventResult = handleUserEvent({
+          eventData,
+          tenantsMap,
+          currentUserData: userData,
+          currentUserNotifications: user.notifications || [],
+          plansMap,
+          parseKeyPath,
+          eventHelper,
+        });
+        userData = userEventResult.userData;
+        tempProviders = userEventResult.tempProviders;
+        userEventResult.deletedTenantKeys.forEach((key) => {
+          tenantsMap.delete(key);
+        });
+        break;
+      case "environment":
+        const envEventResult = handleEnvironmentEvent({
+          entityId,
+          eventData,
+          parentParts,
+          accountsMap,
+          environmentsMap,
+          pendingCloudProviderUpdates,
+        });
+        if (envEventResult.pendingCloudProviderUpdate) {
+          pendingCloudProviderUpdates.push(
+            envEventResult.pendingCloudProviderUpdate,
+          );
+        }
+        environmentsMap.set(entityId, envEventResult.environment);
+        const envTenant = tenantsMap.get(envEventResult.tenantId);
+        if (!envTenant) {
+          pendingEnvironments.push({
+            tenant: envEventResult.tenantId,
+            env: envEventResult.environment,
+          });
+        }
+        break;
+      case "revision":
+        const revisionResult = handleRevisionEvent({
+          entityId,
+          eventData,
+          parentParts,
+          servicesMap,
+          revisionsMap,
+          roleMap,
+          environmentsMap,
+          accountsMap,
+        });
+        revisionsMap.set(revisionResult.revisionKey, revisionResult.revision);
+        if (revisionResult.roles.length > 0) {
+          roleMap.set(revisionResult.serviceId, revisionResult.roles);
+        }
+        if (revisionResult.updatedService) {
+          servicesMap.set(
+            revisionResult.serviceId,
+            revisionResult.updatedService,
+          );
+        }
+        if (revisionResult.updatedEnvironment) {
+          const envId = revisionResult.updatedService?.environment;
+          if (envId) {
+            environmentsMap.set(envId, revisionResult.updatedEnvironment);
+          }
+        }
+        if (revisionResult.updatedAccount) {
+          const accId = revisionResult.updatedService?.account;
+          if (accId) {
+            accountsMap.set(accId, revisionResult.updatedAccount);
+          }
+        }
+        if (revisionResult.pendingRevisionError) {
+          pendingRevisionErrors.push(revisionResult.pendingRevisionError);
+        }
+        if (revisionResult.serviceDeploymentErrorEvent) {
+          eventHelper.service.publish.deploymentError(
+            revisionResult.serviceDeploymentErrorEvent,
+          );
+        }
+        if (
+          revisionResult.shouldFetchChannels &&
+          revisionResult.channelsFetchInfo
+        ) {
+          getChannelsInfo(
+            revisionResult.channelsFetchInfo.serviceId,
+            revisionResult.channelsFetchInfo.tenantId,
+          )
+            .then((channelsInfo) => {})
+            .catch((error) => {
+              console.error("[ws] Error fetching channels info for revision", {
+                revisionServiceId: revisionResult.channelsFetchInfo?.serviceId,
+                error,
+              });
+            });
+        }
+        break;
+      case "service":
+        const serviceResult = handleServiceEvent({
+          entityId,
+          eventData,
+          parentParts,
+          servicesMap,
+          revisionsMap,
+          roleMap,
+          tenantsMap,
+          pendingRevisionErrors,
+          pendingProjects,
+        });
+        pendingRevisionErrors.length = 0;
+        pendingRevisionErrors.push(
+          ...serviceResult.updatedPendingRevisionErrors,
+        );
+        servicesMap.set(serviceResult.serviceFullKey, serviceResult.service);
+        const projectLabel = eventData.meta?.labels?.project;
+        if (projectLabel) {
+          const tenant = tenantsMap.get(parentParts.tenant);
+          if (tenant) {
+            if (!tenant.projects) {
+              tenant.projects = [];
+            }
+            if (!tenant.projects.includes(projectLabel)) {
+              tenant.projects.push(projectLabel);
+              tenantsMap.set(parentParts.tenant, tenant);
+            }
+          } else if (serviceResult.pendingProject) {
+            pendingProjects.push(serviceResult.pendingProject);
+          }
+        }
+        if (serviceResult.wasDeployed) {
+          eventHelper.service.publish.deployed(serviceResult.service);
+        }
+        break;
+      case "account":
+        const accountResult = handleAccountEvent({
+          entityId,
+          eventData,
+          parentParts,
+          accountsMap,
+        });
+
+        if (!message.payload.deleted) {
+          accountsMap.set(entityId, accountResult.account);
+          updateEnvironmentsCloudProvider(entityId, eventData.spec.api);
+        }
+        break;
+
+      case "tenant":
+        const newTenant: Tenant = handleTenantEvent(
+          entityId,
+          eventData,
+          userData,
+        );
+        tenantsMap.set(entityId, newTenant);
+        loadMarketplaceItemsForTenant(entityId, "") //TODO Move to helper
+          .then((items) => {
+            const tenant = tenantsMap.get(entityId);
+            if (tenant) {
+              tenant.marketplaceItems = items;
+              tenantsMap.set(entityId, tenant);
+            }
+          })
+          .catch((err) => {
+            console.error(
+              `Failed to load marketplace items for ${entityId}:`,
+              err,
+            );
+          });
+
+        for (let i = pendingEnvironments.length - 1; i >= 0; i--) {
+          const { tenant, env } = pendingEnvironments[i];
+          if (tenant === entityId) {
+            pendingEnvironments.splice(i, 1);
+          }
+        }
+        for (let i = pendingDomains.length - 1; i >= 0; i--) {
+          const pd = pendingDomains[i];
+          if (pd.tenant === newTenant.id) {
+            newTenant.resources.push(pd);
+            pendingDomains.splice(i, 1);
+          }
+        }
+        for (let i = pendingRegistries.length - 1; i >= 0; i--) {
+          const { tenant, registry } = pendingRegistries[i];
+          if (tenant === entityId) {
+            newTenant.registry.push(registry);
+            pendingRegistries.splice(i, 1);
+          }
+        }
+        break;
+
+      case "domain":
+        const domainResult = handleDomainEvent(
+          eventData,
+          parentParts,
+          tenantsMap,
+          hasRequestingServices,
+        );
+        processResourceResult(
+          domainResult,
+          tenantsMap,
+          pendingDomains,
+          eventHelper,
+        );
+        break;
+
+      case "port":
+        const portResult = handlePortEvent(
+          eventData,
+          parentParts,
+          tenantsMap,
+          hasRequestingServices,
+        );
+        processResourceResult(
+          portResult,
+          tenantsMap,
+          pendingDomains,
+          eventHelper,
+        );
+        break;
+
+      case "secret":
+        const secretResult = handleSecretEvent(
+          eventData,
+          parentParts,
+          tenantsMap,
+          secretsMap,
+        );
+        secretResult.secretsToStore.forEach(({ key, value }) =>
+          secretsMap.set(key, value),
+        );
+        processResourceResult(
+          secretResult,
+          tenantsMap,
+          pendingDomains,
+          eventHelper,
+        );
+        break;
+
+      case "certificate":
+        const certificateResult = handleCertificateEvent(
+          eventData,
+          parentParts,
+          tenantsMap,
+        );
+        processResourceResult(
+          certificateResult,
+          tenantsMap,
+          pendingDomains,
+          eventHelper,
+        );
+        break;
+
+      case "ca":
+        const caResult = handleCAEvent(eventData, parentParts, tenantsMap);
+        processResourceResult(
+          caResult,
+          tenantsMap,
+          pendingDomains,
+          eventHelper,
+        );
+        break;
+
+      case "volume":
+        const volumeResult = handleVolumeEvent(
+          eventData,
+          parentParts,
+          tenantsMap,
+        );
+        processResourceResult(
+          volumeResult,
+          tenantsMap,
+          pendingDomains,
+          eventHelper,
+        );
+        break;
+      case "provideruser":
+        const providerUserId = eventData.id.name;
+        const providerEmail = eventData.spec.claims?.email || "";
+        for (const [providerName, providerId] of Object.entries(
+          tempProviders,
+        )) {
+          if (providerId === providerUserId) {
+            const existingIndex = userData.provider.findIndex(
+              (p) => p.name === providerName,
+            );
+
+            if (existingIndex !== -1) {
+              userData.provider[existingIndex] = {
+                ...userData.provider[existingIndex],
+                email: providerEmail,
+              };
+            } else {
+              userData.provider.push({
+                name: providerName,
+                email: providerEmail,
+              });
+            }
+            user = new User(
+              userData,
+              Array.from(tenantsMap.values()),
+              Array.from(organizationsMap.values()),
+              platformInfo || undefined,
+            );
+            break;
+          }
+        }
+        break;
+      case "planinstance":
+        const planResult = handlePlanInstanceEvent({
+          entityId,
+          eventData,
+          parentParts,
+        });
+
+        plansMap.set(planResult.planKey, planResult.plan);
+        const userPlansResult = updateUserPlansAfterPlanEvent({
+          newPlan: planResult.plan,
+          userData,
+          userId: userData.id,
+        });
+
+        if (userPlansResult.shouldUpdate) {
+          userData.plans = userPlansResult.updatedPlans;
+          user = new User(
+            userData,
+            Array.from(tenantsMap.values()),
+            Array.from(organizationsMap.values()),
+            user.platform,
+          );
+          eventHelper.user.publish.loaded(user);
+        }
+        break;
+      case "dregistry":
+        const registryResult = handleRegistryEvent({
+          eventData,
+          parentParts,
+          tenantsMap,
+          secretsMap
+        });
+
+        if (registryResult.tenantFound && registryResult.updatedTenant) {
+          tenantsMap.set(registryResult.tenantId, registryResult.updatedTenant);
+        } else if (registryResult.pendingRegistry) {
+          pendingRegistries.push(registryResult.pendingRegistry);
+        }
+        break;
+      case "token":
+        const tokenResult = handleTokenEvent({
+          eventData,
+          tokenMap,
+          userData,
+        });
+
+        if (tokenResult.isUserToken) {
+          userData.tokens = tokenResult.updatedUserTokens;
+        } else if (tokenResult.isClusterToken && tokenResult.clusterToken) {
+          clusterTokensMap.clear();
+          clusterTokensMap.set(tokenResult.tokenId, tokenResult.clusterToken);
+        }
+        break;
+      case "cluster":
+        const clusterName = eventData.spec.cluster.name;
+        break;
+      case "link":
+        const linkResult = handleLinkEvent({
+          eventData,
+          servicesMap,
+        });
+
+        if (linkResult.updatedServerService) {
+          servicesMap.set(
+            linkResult.linkServiceServer,
+            linkResult.updatedServerService,
+          );
+        }
+
+        if (linkResult.updatedClientService) {
+          servicesMap.set(
+            linkResult.linkServiceClient,
+            linkResult.updatedClientService,
+          );
+        }
+        break;
+    }
+    setTimeout(async () => {
+      rebuildHierarchy();
+      await updateUserWithPlatformInfo();
+    }, 500);
+  }
+};
+const loadPlatformInfo = async (): Promise<Platform | null> => {
+  if (isPlatformInfoLoaded && platformInfo) {
+    return platformInfo;
+  }
+
+  if (isPlatformInfoLoading) {
+    let attempts = 0;
+    while (isPlatformInfoLoading && attempts < 100) {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      attempts++;
+    }
+    return platformInfo;
+  }
+
+  isPlatformInfoLoading = true;
+
+  try {
+    const platformResponse = await makeGlobalWebSocketRequest(
+      "misc:info",
+      {},
+      30000,
+      "GET",
+      "PLATFORM",
+    );
+
+    if (platformResponse) {
+      platformInfo = platformResponse as Platform;
+      isPlatformInfoLoaded = true;
+    }
+  } catch (err) {
+    console.error("Error loading platform info:", err);
+    platformInfo = null;
+  } finally {
+    isPlatformInfoLoading = false;
+  }
+
+  return platformInfo;
+};
+
+const updateUserWithPlatformInfo = async () => {
+  try {
+    const platform = await loadPlatformInfo();
+    const mapTenants = Array.from(tenantsMap.values());
+
+    const existingTenants = user.tenants;
+    const combinedTenantsMap = new Map<string, Tenant>();
+    existingTenants.forEach((tenant) => {
+      combinedTenantsMap.set(tenant.id, tenant);
+    });
+    mapTenants.forEach((tenant) => {
+      combinedTenantsMap.set(tenant.id, tenant);
+    });
+    user = new User(
+      userData,
+      Array.from(tenantsMap.values()),
+      Array.from(organizationsMap.values()),
+      platform || undefined,
+    );
+
+    eventHelper.user.publish.loaded(user);
+    if (
+      environmentsMap.size > 0 &&
+      !isLoadingReporting &&
+      !hasLoadedReportingOnce
+    ) {
+      setTimeout(() => {
+        if (!isLoadingReporting && !hasLoadedReportingOnce) {
+          loadAllEnvironmentsReporting().catch((err) => {
+            console.error("Error in background reporting loading:", err);
+          });
+        }
+      }, 2000);
+    }
+  } catch (err) {
+    console.error("Error updating user with platform info:", err);
+    user = new User(
+      userData,
+      Array.from(tenantsMap.values()),
+      Array.from(organizationsMap.values()),
+    );
+    eventHelper.user.publish.loaded(user);
+  }
+};
+export const getReferenceDomain = () => {
+  return user.platform?.referenceDomain.replace(/\./g, "-");
+};
+const handleOperationSuccess = (operation: PendingOperation, response: any) => {
+  const { action, entityType, entityName, originalData } = operation;
+  switch (entityType.toLowerCase()) {
+    case "tenant":
+      if (action === "DELETE") {
+        tenantsMap.delete(entityName);
+      } else {
+        if (originalData) {
+          if (action === "CREATE") {
+            const eventData = response.payload.data;
+            const newTenant: Tenant = handleTenantOperationSuccess(
+              entityName,
+              eventData,
+              userData,
+            );
+            tenantsMap.set(entityName, newTenant);
+            eventHelper.tenant.publish.created(newTenant);
+          } else if (action === "UPDATE") {
+            const updatedTenant = { ...originalData, status: "active" };
+            tenantsMap.set(entityName, updatedTenant);
+            eventHelper.tenant.publish.updated(updatedTenant);
+          }
+        }
+      }
+      break;
+
+    case "service":
+      const svcSuccessResult = handleServiceOperationSuccess({
+        action,
+        entityName,
+        originalData,
+        responsePayload: operation.responsePayload,
+        servicesMap,
+        revisionsMap,
+        roleMap,
+      });
+
+      if (action === "GET_CHANNELS") {
+        let serviceId: string;
+        let serviceName: string;
+
+        const payloadTenant = operation.originalData?.payload?.tenant;
+        const payloadService = operation.originalData?.payload?.service;
+
+        if (payloadTenant && payloadService) {
+          serviceId = `${payloadTenant}/${payloadService}`;
+          serviceName = payloadService;
+        } else {
+          const entityNameParts = operation.entityName.split("/");
+          if (entityNameParts.length === 2) {
+            serviceId = operation.entityName;
+            serviceName = entityNameParts[1];
+          } else {
+            console.warn(
+              `Cannot determine serviceId for GET_CHANNELS. EntityName: ${operation.entityName}`,
+            );
+            break;
+          }
+        }
+
+        const service = servicesMap.get(serviceId);
+        if (service) {
+          const channelsInfo = mapChannelsFromApiData(
+            response.payload.data,
+            serviceName,
+          );
+          service.serverChannels = channelsInfo.serverChannels;
+          service.clientChannels = channelsInfo.clientChannels;
+          service.duplexChannels = channelsInfo.duplexChannels;
+          servicesMap.set(serviceId, service);
+        } else {
+          console.warn(
+            `Service ${serviceId} not found when processing GET_CHANNELS response`,
+          );
+        }
+      } else if (action === "GET_REVISION") {
+        if (
+          svcSuccessResult.processRevisionData &&
+          svcSuccessResult.revisionData
+        ) {
+          try {
+            const updatedService = processRevisionData(
+              svcSuccessResult.updatedService!,
+              svcSuccessResult.revisionData,
+            );
+
+            if (svcSuccessResult.revisionData.revision_error) {
+              updatedService.status =
+                svcSuccessResult.revisionData.revision_error;
+              updatedService.error = {
+                code:
+                  svcSuccessResult.revisionData.revision_error.code ||
+                  "UNKNOWN_ERROR",
+                message:
+                  svcSuccessResult.revisionData.revision_error.message ||
+                  "Unknown error occurred",
+              };
+            }
+
+            servicesMap.set(svcSuccessResult.serviceId, updatedService);
+
+            if (updatedService.role && updatedService.role.length > 0) {
+              roleMap.set(svcSuccessResult.serviceId, updatedService.role);
+            }
+          } catch (error) {
+            console.error(
+              `Error processing revision data for ${svcSuccessResult.serviceId}:`,
+              error,
+            );
+            const service = servicesMap.get(svcSuccessResult.serviceId);
+            if (service) {
+              const resetService = { ...service, role: [] };
+              servicesMap.set(svcSuccessResult.serviceId, resetService);
+              roleMap.delete(svcSuccessResult.serviceId);
+            }
+          }
+        } else if (
+          svcSuccessResult.updatedService &&
+          !svcSuccessResult.processRevisionData
+        ) {
+          servicesMap.set(
+            svcSuccessResult.serviceId,
+            svcSuccessResult.updatedService,
+          );
+          roleMap.delete(svcSuccessResult.serviceId);
+          console.warn(
+            `GET_REVISION response without solution for ${svcSuccessResult.serviceId}, roles reset`,
+          );
+        }
+      } else if (svcSuccessResult.updatedService) {
+        servicesMap.set(
+          svcSuccessResult.serviceId,
+          svcSuccessResult.updatedService,
+        );
+        if (svcSuccessResult.eventType === "deployed") {
+          eventHelper.service.publish.deployed(svcSuccessResult.updatedService);
+        } else if (svcSuccessResult.eventType === "updated") {
+          eventHelper.service.publish.updated(svcSuccessResult.updatedService);
+        } else if (svcSuccessResult.eventType === "deleting") {
+          eventHelper.service.publish.updated(svcSuccessResult.updatedService);
+        }
+      }
+      break;
+    case "account":
+      const accSuccessResult = handleAccountOperationSuccess({
+        action,
+        entityName,
+        originalData: originalData as Account,
+      });
+
+      if (accSuccessResult.shouldDelete) {
+        const acc = accountsMap.get(entityName);
+        if (acc) {
+          accountsMap.delete(entityName);
+          eventHelper.notification.publish.creation(
+            accSuccessResult.notification,
+          );
+        }
+      } else if (accSuccessResult.updatedAccount) {
+        accountsMap.set(entityName, accSuccessResult.updatedAccount);
+        if (accSuccessResult.eventType === "created") {
+          eventHelper.account.publish.created(accSuccessResult.updatedAccount);
+        } else if (accSuccessResult.eventType === "updated") {
+          eventHelper.account.publish.updated(accSuccessResult.updatedAccount);
+        }
+        eventHelper.notification.publish.creation(
+          accSuccessResult.notification,
+        );
+      }
+      break;
+
+    case "environment":
+      const envSuccessResult = handleEnvironmentOperationSuccess({
+        action,
+        entityName,
+        originalData: originalData as Environment,
+      });
+
+      if (envSuccessResult.shouldDelete) {
+        environmentsMap.delete(entityName);
+      } else if (envSuccessResult.updatedEnvironment) {
+        environmentsMap.set(entityName, envSuccessResult.updatedEnvironment);
+        if (envSuccessResult.notification) {
+          eventHelper.notification.publish.creation(
+            envSuccessResult.notification,
+          );
+        }
+        if (envSuccessResult.eventType === "created") {
+          eventHelper.environment.publish.created(
+            envSuccessResult.updatedEnvironment,
+          );
+        } else if (envSuccessResult.eventType === "updated") {
+          eventHelper.environment.publish.updated(
+            envSuccessResult.updatedEnvironment,
+          );
+        }
+      }
+      break;
+    case "planprovider":
+      if (action === "GET") {
+        const providers: PlanProvider[] = response.payload.data.map(
+          (item: any) => ({
+            name: item.id.name,
+          }),
+        );
+        eventHelper.planProviders.publish.plansLoaded(providers);
+      }
+      break;
+    case "token":
+      const tokenSuccessResult = handleTokenOperationSuccess({
+        responsePayload: response.payload,
+      });
+      tokenMap.set(tokenSuccessResult.token.name, tokenSuccessResult.token);
+      break;
+    case "user":
+      if (action === "DELETE") {
+        userData = handleUserOperationError();
+        user = new User(userData);
+      }
+      break;
+  }
+
+  setTimeout(async () => {
+    rebuildHierarchy();
+    await updateUserWithPlatformInfo();
+  }, 100);
+};
+
+const handleOperationError = (operation: PendingOperation, error: any) => {
+  const { action, entityType, entityName, originalData } = operation;
+
+  console.error(
+    `Operation ${action} on ${entityType} '${entityName}' failed:`,
+    error,
+  );
+  switch (entityType.toLowerCase()) {
+    case "tenant":
+      if (action === "CREATE") {
+        eventHelper.tenant.publish.creationError(originalData);
+      } else if (action === "UPDATE") {
+        eventHelper.tenant.publish.updateError(originalData);
+      } else if (action === "DELETE") {
+        eventHelper.tenant.publish.deletionError(originalData);
+      }
+      break;
+
+    case "service":
+      const svcErrorResult = handleServiceOperationError({
+        action,
+        entityName,
+        originalData,
+        error,
+        servicesMap,
+        roleMap,
+      });
+      if (svcErrorResult.eventType === "deploymentError") {
+        eventHelper.service.publish.deploymentError(originalData);
+      } else if (svcErrorResult.eventType === "updateError") {
+        eventHelper.service.publish.updateError(originalData);
+      } else if (svcErrorResult.eventType === "deletionError") {
+        eventHelper.service.publish.deletionError(originalData);
+      }
+      if (svcErrorResult.shouldResetRoles) {
+        const service = servicesMap.get(svcErrorResult.serviceId);
+        if (service) {
+          const resetService = { ...service, role: [] };
+          servicesMap.set(svcErrorResult.serviceId, resetService);
+          roleMap.delete(svcErrorResult.serviceId);
+          console.warn(
+            `GET_REVISION failed for ${svcErrorResult.serviceId}, roles have been reset`,
+          );
+        }
+      }
+      break;
+    case "account":
+      const accErrorResult = handleAccountOperationError({
+        action,
+        entityName,
+        originalData: originalData as Account,
+        error,
+      });
+
+      if (accErrorResult.shouldDelete) {
+        accountsMap.delete(entityName);
+      } else if (accErrorResult.updatedAccount) {
+        accountsMap.set(entityName, accErrorResult.updatedAccount);
+      }
+      if (accErrorResult.eventType === "creationError") {
+        eventHelper.account.publish.creationError(originalData);
+      } else if (accErrorResult.eventType === "updateError") {
+        eventHelper.account.publish.updateError(originalData);
+      } else if (accErrorResult.eventType === "deletionError") {
+        eventHelper.account.publish.deletionError(originalData);
+      }
+      eventHelper.notification.publish.creation(accErrorResult.notification);
+      break;
+    case "environment":
+      const envErrorResult = handleEnvironmentOperationError({
+        action,
+        entityName,
+        originalData: originalData as Environment,
+        error,
+      });
+      if (envErrorResult.eventType === "creationError") {
+        eventHelper.environment.publish.creationError(originalData);
+      } else if (envErrorResult.eventType === "updateError") {
+        eventHelper.environment.publish.updateError(originalData);
+      } else if (envErrorResult.eventType === "deletionError") {
+        eventHelper.environment.publish.deletionError(originalData);
+      }
+      eventHelper.notification.publish.creation(envErrorResult.notification);
+      environmentsMap.set(entityName, envErrorResult.updatedEnvironment);
+      break;
+  }
+};
+const handleDeleteEvent = async (message: WSMessage) => {
+  const keyParts = parseKeyPath(message.payload.key);
+  const tenantName = keyParts.tenant;
+  if (keyParts.service && !keyParts.revision) {
+    const serviceName = `${keyParts.tenant}/${keyParts.service}`;
+    const deletedService = servicesMap.get(serviceName);
+    if (deletedService) {
+      servicesMap.delete(serviceName);
+      const revisionsToDelete: string[] = [];
+      revisionsMap.forEach((revision, key) => {
+        if (key.startsWith(serviceName)) {
+          revisionsToDelete.push(key);
+        }
+      });
+      revisionsToDelete.forEach((key) => revisionsMap.delete(key));
+      roleMap.delete(serviceName);
+      eventHelper.service.publish.deleted(deletedService);
+    } else {
+      console.warn(`Service ${serviceName} not found in map for deletion`);
+    }
+  }
+  if (keyParts.environment && !keyParts.service) {
+    const environmentName = keyParts.environment;
+    const deletedEnv = environmentsMap.get(environmentName)!;
+    eventHelper.environment.publish.deleted(deletedEnv);
+    const envNotification: Notification = {
+      type: "success",
+      subtype: "environment-deleted",
+      date: Date.now().toString(),
+      callToAction: false,
+      status: "unread",
+      data: {
+        environment: deletedEnv.name,
+        account: deletedEnv.account,
+        tenant: deletedEnv.tenant,
+      },
+    };
+    eventHelper.notification.publish.creation(envNotification);
+    environmentsMap.delete(environmentName);
+  }
+  if (keyParts.account && !keyParts.environment) {
+    const accountName = keyParts.account;
+    const deletedAccount = accountsMap.get(accountName)!;
+    eventHelper.account.publish.deleted(deletedAccount);
+    const accountNotification: Notification = {
+      type: "success",
+      subtype: "account-deleted",
+      date: Date.now().toString(),
+      callToAction: false,
+      status: "unread",
+      data: {
+        account: deletedAccount.name,
+        tenant: deletedAccount.tenant,
+      },
+    };
+    eventHelper.notification.publish.creation(accountNotification);
+    accountsMap.delete(accountName);
+  }
+  if (keyParts.domain) {
+    const domainName = keyParts.domain;
+    const domainTenant = tenantsMap.get(tenantName);
+    if (domainTenant) {
+      const existingIndex = domainTenant.resources.findIndex(
+        (res) => res.name === domainName && res.type === "domain",
+      );
+      if (existingIndex !== -1) {
+        eventHelper.resource.publish.deleted(
+          domainTenant.resources[existingIndex],
+        );
+        domainTenant.resources.splice(existingIndex, 1);
+        tenantsMap.set(tenantName, domainTenant);
+      } else {
+        console.warn(`Intento de eliminar recurso inexistente: ${domainName}`);
+      }
+    }
+  }
+  if (keyParts.port) {
+    const portName = keyParts.port;
+    const portTenant = tenantsMap.get(tenantName);
+    if (portTenant) {
+      const existingIndex = portTenant.resources.findIndex(
+        (res) => res.name === portName && res.type === "port",
+      );
+      if (existingIndex !== -1) {
+        eventHelper.resource.publish.deleted(
+          portTenant.resources[existingIndex],
+        );
+        portTenant.resources.splice(existingIndex, 1);
+        tenantsMap.set(tenantName, portTenant);
+      } else {
+        console.warn(`Intento de eliminar recurso inexistente: ${portTenant}`);
+      }
+    }
+  }
+  if (keyParts.secret) {
+    const secretName = keyParts.secret;
+    const secretTenant = tenantsMap.get(tenantName);
+    if (secretTenant) {
+      const existingIndex = secretTenant.resources.findIndex(
+        (res) => res.name === secretName && res.type === "secret",
+      );
+      if (existingIndex !== -1) {
+        eventHelper.resource.publish.deleted(
+          secretTenant.resources[existingIndex],
+        );
+        secretTenant.resources.splice(existingIndex, 1);
+        tenantsMap.set(tenantName, secretTenant);
+      } else {
+        console.warn(`Intento de eliminar recurso inexistente: ${secretName}`);
+      }
+    }
+  }
+  if (keyParts.volume) {
+    const volumeName = keyParts.volume;
+    const volumeTenant = tenantsMap.get(tenantName);
+    if (volumeTenant) {
+      const existingIndex = volumeTenant.resources.findIndex(
+        (res) => res.name === volumeName && res.type === "volume",
+      );
+      if (existingIndex !== -1) {
+        eventHelper.resource.publish.deleted(
+          volumeTenant.resources[existingIndex],
+        );
+        volumeTenant.resources.splice(existingIndex, 1);
+        tenantsMap.set(tenantName, volumeTenant);
+      } else {
+        console.warn(`Intento de eliminar recurso inexistente: ${volumeName}`);
+      }
+    }
+  }
+  if (keyParts.ca) {
+    const caName = keyParts.ca;
+    const caTenant = tenantsMap.get(tenantName);
+    if (caTenant) {
+      const existingIndex = caTenant.resources.findIndex(
+        (res) => res.name === caName && res.type === "ca",
+      );
+      if (existingIndex !== -1) {
+        eventHelper.resource.publish.deleted(caTenant.resources[existingIndex]);
+        caTenant.resources.splice(existingIndex, 1);
+        tenantsMap.set(tenantName, caTenant);
+      } else {
+        console.warn(`Intento de eliminar recurso inexistente: ${caName}`);
+      }
+    }
+  }
+  if (keyParts.certificate) {
+    const certName = keyParts.certificate;
+    const certTenant = tenantsMap.get(tenantName);
+    if (certTenant) {
+      const existingIndex = certTenant.resources.findIndex(
+        (res) => res.name === certName && res.type === "certificate",
+      );
+      if (existingIndex !== -1) {
+        eventHelper.resource.publish.deleted(
+          certTenant.resources[existingIndex],
+        );
+        certTenant.resources.splice(existingIndex, 1);
+        tenantsMap.set(tenantName, certTenant);
+      } else {
+        console.warn(`Intento de eliminar recurso inexistente: ${certName}`);
+      }
+    }
+  }
+  if (keyParts.dregistry) {
+    const registryName = keyParts.dregistry;
+    const registryTenant = tenantsMap.get(tenantName);
+
+    if (registryTenant) {
+      const existingIndex = registryTenant.registry.findIndex(
+        (reg) => reg.domain === registryName,
+      );
+
+      if (existingIndex !== -1) {
+        const deletedRegistry = registryTenant.registry[existingIndex];
+        const deleteRegistryBody = {
+          tenant: registryTenant,
+          registry: deletedRegistry,
+        };
+        eventHelper.tenant?.publish?.deleteRegistry(deleteRegistryBody);
+        registryTenant.registry.splice(existingIndex, 1);
+        tenantsMap.set(tenantName, registryTenant);
+        const registryNotification: Notification = {
+          type: "success",
+          subtype: "registry-deleted",
+          date: Date.now().toString(),
+          status: "unread",
+          callToAction: false,
+          data: {
+            registry: deletedRegistry,
+            tenant: registryTenant,
+          },
+        };
+        eventHelper.notification.publish.creation(registryNotification);
+      } else {
+        console.warn(
+          `Attempt to delete non-existent registry: ${registryName}`,
+        );
+      }
+    }
+  }
+  if (keyParts.link) {
+    const linkId = keyParts.link;
+    let deletedLinkInfo: {
+      origin: string;
+      target: string;
+      originChannel: string;
+      targetChannel: string;
+      tenant: string;
+    } = {
+      origin: "",
+      target: "",
+      originChannel: "",
+      targetChannel: "",
+      tenant: "",
+    };
+
+    servicesMap.forEach((service, serviceId) => {
+      const linkIndex = service.links.findIndex((link) => link.name === linkId);
+      if (linkIndex !== -1) {
+        const deletedLink = service.links[linkIndex];
+
+        if (!deletedLinkInfo) {
+          deletedLinkInfo = {
+            origin: deletedLink.origin,
+            target: deletedLink.target,
+            originChannel: deletedLink.originChannel || "",
+            targetChannel: deletedLink.targetChannel || "",
+            tenant: service.tenant,
+          };
+        }
+
+        service.links.splice(linkIndex, 1);
+        servicesMap.set(serviceId, service);
+      }
+    });
+
+    if (deletedLinkInfo) {
+      const unlinkNotification: Notification = {
+        type: "success",
+        subtype: "service-unlinked",
+        date: Date.now().toString(),
+        status: "unread",
+        callToAction: false,
+        data: {
+          originService: deletedLinkInfo.origin,
+          targetService: deletedLinkInfo.target,
+          originChannel: deletedLinkInfo.originChannel,
+          targetChannel: deletedLinkInfo.targetChannel,
+          tenant: deletedLinkInfo.tenant,
+        },
+      };
+      eventHelper.notification.publish.creation(unlinkNotification);
+    }
+  }
+  if (keyParts.token && keyParts.user) {
+    const tokenId = keyParts.token;
+    const tokenIndex = userData.tokens.findIndex((t) => t.name === tokenId);
+    if (tokenIndex !== -1) {
+      const deletedToken = userData.tokens[tokenIndex];
+      userData.tokens.splice(tokenIndex, 1);
+
+      const tokenNotification: Notification = {
+        type: "success",
+        subtype: "token-deleted",
+        date: Date.now().toString(),
+        status: "unread",
+        callToAction: false,
+        data: {
+          tokenName: deletedToken.name,
+          tenant: deletedToken.tenant,
+        },
+      };
+      eventHelper.notification.publish.creation(tokenNotification);
+    }
+  }
+  rebuildHierarchy();
+  await updateUserWithPlatformInfo();
+};
+const getChannelsInfo = async (
+  serviceId: string,
+  tenantId: string,
+): Promise<{
+  serverChannels: Channel[];
+  clientChannels: Channel[];
+  duplexChannels: Channel[];
+}> => {
+  try {
+    const service = servicesMap.get(`${tenantId}/${serviceId}`);
+    const response = await makeGlobalWebSocketRequest(
+      "service:report_channels_service",
+      {
+        tenant: tenantId,
+        service: serviceId,
+      },
+      30000,
+      "GET_CHANNELS",
+      `${tenantId}/${serviceId}`,
+      "service",
+      service,
+    );
+    return mapChannelsFromApiData(response.data, serviceId);
+  } catch (error) {
+    console.error(`Error getting channels for service ${serviceId}:`, error);
+    return {
+      serverChannels: [],
+      clientChannels: [],
+      duplexChannels: [],
+    };
+  }
+};
+
+const updateEnvironmentsCloudProvider = (
+  accountId: string,
+  cloudProviderName: string,
+) => {
+  environmentsMap.forEach((environment, envId) => {
+    if (environment.account === accountId) {
+      environment.cloudProvider = cloudProviderName;
+      environmentsMap.set(envId, environment);
+    }
+  });
+  pendingCloudProviderUpdates = pendingCloudProviderUpdates.filter(
+    (pending) => pending.accountId !== accountId,
+  );
+};
+
+const loadReportingForEnvironment = async (environment: Environment) => {
+  try {
+    const reportingData = await getReporting(environment);
+    if (
+      reportingData !== undefined &&
+      reportingData !== null &&
+      Array.isArray(reportingData)
+    ) {
+      const updatedEnvironment = environmentsMap.get(environment.id);
+
+      if (!updatedEnvironment) {
+        console.warn(`Environment ${environment.id} not found in map`);
+        return;
+      }
+
+      if (!updatedEnvironment.usage.current.cpuConsuption) {
+        updatedEnvironment.usage.current.cpuConsuption = [];
+      }
+      const cpuValues = reportingData.map((dataPoint: any) => {
+        const fromTime = Date.parse(dataPoint.From);
+        const toTime = Date.parse(dataPoint.To);
+        const durationMs = toTime - fromTime;
+        const milliCores =
+          durationMs > 0 ? dataPoint.VCPUMillisMs / durationMs : 0;
+        return milliCores;
+      });
+
+      updatedEnvironment.usage.current.cpuConsuption.push(...cpuValues);
+
+      if (
+        updatedEnvironment.usage.current.cpuConsuption.length >
+        REPORTING_ITERATIONS
+      ) {
+        updatedEnvironment.usage.current.cpuConsuption =
+          updatedEnvironment.usage.current.cpuConsuption.slice(
+            -REPORTING_ITERATIONS,
+          );
+      }
+
+      environmentsMap.set(environment.id, updatedEnvironment);
+    }
+  } catch (error) {
+    console.error(
+      `Error loading reporting for environment ${environment.name}:`,
+      error,
+    );
+  }
+};
+
+const loadAllEnvironmentsReporting = async () => {
+  if (isLoadingReporting || hasLoadedReportingOnce) {
+    return;
+  }
+  isLoadingReporting = true;
+  try {
+    const environments = Array.from(environmentsMap.values());
+    await Promise.all(
+      environments.map((env) => loadReportingForEnvironment(env)),
+    );
+    hasLoadedReportingOnce = true;
+  } catch (error) {
+    console.error("Error loading reporting for all environments:", error);
+    isLoadingReporting = false;
+  } finally {
+    isLoadingReporting = false;
+  }
+};
+export const updateUserComplete = (updatedUserData: UserData): User => {
+  try {
+    const preservedNotifications =
+      userData.notifications || updatedUserData.notifications || [];
+    userData = {
+      id: updatedUserData.id || userData.id,
+      name: updatedUserData.name || userData.name,
+      surname: updatedUserData.surname || userData.surname,
+      provider: updatedUserData.provider || userData.provider || [],
+      notificationsEnabled:
+        updatedUserData.notificationsEnabled ||
+        userData.notificationsEnabled ||
+        "",
+      organizations: updatedUserData.organizations || [],
+      clusterTokens: updatedUserData.clusterTokens || [],
+      tokens: updatedUserData.tokens || [],
+      tenants: updatedUserData.tenants || [],
+      axebowPlan:
+        updatedUserData.axebowPlan || userData.axebowPlan || "freemium",
+      companyName: updatedUserData.companyName || userData.companyName || "",
+      rol: updatedUserData.rol || userData.rol || "",
+      notifications: preservedNotifications,
+      plans: updatedUserData.plans,
+      status: updatedUserData.status,
+    };
+    user = new User(
+      userData,
+      Array.from(tenantsMap.values()),
+      Array.from(organizationsMap.values()),
+      platformInfo || undefined,
+    );
+    return user;
+  } catch (error) {
+    console.error("Error updating user in websocket-manager:", error);
+    return user;
+  }
+};