@kumori/aurora-backend-handler 1.1.57 → 1.1.59

package/helpers/account-helper.ts

@@ -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 = {
@@ -357,7 +361,6 @@ export const handleAccountOperationError = ({
   const notification: Notification = {
     type: "error",
     subtype: errEntry.subtype,
-    title: errEntry.title,
     date: Date.now().toString(),
     status: "unread",
     info_content: {

package/helpers/environment-helper.ts

@@ -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,
@@ -250,7 +252,6 @@ export const handleEnvironmentOperationError = ({
   const envErrorNotification: Notification = {
     type: "error",
     subtype: envErrEntry.subtype,
-    title: envErrEntry.title,
     date: Date.now().toString(),
     status: "unread",
     info_content: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kumori/aurora-backend-handler",
-  "version": "1.1.57",
+  "version": "1.1.59",
   "description": "backend handler",
   "main": "backend-handler.ts",
   "scripts": {

package/websocket-manager.ts

@@ -676,7 +676,8 @@ const handleEvent = async (message: WSMessage) => {
             envEventResult.pendingCloudProviderUpdate,
           );
         }
-        environmentsMap.set(entityId, envEventResult.environment);
+        const envSetKey = parentParts.tenant && parentParts.account ? `${parentParts.tenant}/${parentParts.account}/${entityId}` : entityId;
+        environmentsMap.set(envSetKey, envEventResult.environment);
         const envTenant = tenantsMap.get(envEventResult.tenantId);
         if (!envTenant) {
           pendingEnvironments.push({
@@ -710,12 +711,16 @@ const handleEvent = async (message: WSMessage) => {
         }
         if (revisionResult.updatedEnvironment) {
           const envId = revisionResult.updatedService?.environment;
-          if (envId)
-            environmentsMap.set(envId, revisionResult.updatedEnvironment);
+          const envRevTenant = revisionResult.updatedEnvironment.tenant;
+          const envRevAccount = revisionResult.updatedEnvironment.account;
+          const envRevKey = envRevTenant && envRevAccount && envId ? `${envRevTenant}/${envRevAccount}/${envId}` : envId;
+          if (envRevKey) environmentsMap.set(envRevKey, revisionResult.updatedEnvironment);
         }
         if (revisionResult.updatedAccount) {
           const accId = revisionResult.updatedService?.account;
-          if (accId) accountsMap.set(accId, revisionResult.updatedAccount);
+          const accRevTenant = revisionResult.updatedAccount.tenant;
+          const accRevKey = accRevTenant && accId ? `${accRevTenant}/${accId}` : accId;
+          if (accRevKey) accountsMap.set(accRevKey, revisionResult.updatedAccount);
         }
         if (revisionResult.pendingRevisionError) {
           pendingRevisionErrors.push(revisionResult.pendingRevisionError);
@@ -808,7 +813,8 @@ const handleEvent = async (message: WSMessage) => {
         });
 
         if (!message.payload.deleted) {
-          accountsMap.set(entityId, accountResult.account);
+          const accountKey = parentParts.tenant ? `${parentParts.tenant}/${entityId}` : entityId;
+          accountsMap.set(accountKey, accountResult.account);
           updateEnvironmentsCloudProvider(entityId, eventData.spec.api);
         }
         break;
@@ -1395,16 +1401,18 @@ const handleOperationSuccess = (operation: PendingOperation, response: any) => {
         originalData: originalData as Account,
       });
 
+      const accTenant = (originalData as Account)?.tenant;
+      const accSuccessKey = accTenant ? `${accTenant}/${entityName}` : entityName;
       if (accSuccessResult.shouldDelete) {
-        const acc = accountsMap.get(entityName);
+        const acc = accountsMap.get(accSuccessKey);
         if (acc) {
-          accountsMap.delete(entityName);
+          accountsMap.delete(accSuccessKey);
           eventHelper.notification.publish.creation(
             accSuccessResult.notification,
           );
         }
       } else if (accSuccessResult.updatedAccount) {
-        accountsMap.set(entityName, accSuccessResult.updatedAccount);
+        accountsMap.set(accSuccessKey, accSuccessResult.updatedAccount);
         if (accSuccessResult.eventType === "created") {
           eventHelper.account.publish.created(accSuccessResult.updatedAccount);
         } else if (accSuccessResult.eventType === "updated") {
@@ -1423,10 +1431,12 @@ const handleOperationSuccess = (operation: PendingOperation, response: any) => {
         originalData: originalData as Environment,
       });
 
+      const envOrigData = originalData as Environment;
+      const envSuccessKey = envOrigData?.tenant && envOrigData?.account ? `${envOrigData.tenant}/${envOrigData.account}/${entityName}` : entityName;
       if (envSuccessResult.shouldDelete) {
-        environmentsMap.delete(entityName);
+        environmentsMap.delete(envSuccessKey);
       } else if (envSuccessResult.updatedEnvironment) {
-        environmentsMap.set(entityName, envSuccessResult.updatedEnvironment);
+        environmentsMap.set(envSuccessKey, envSuccessResult.updatedEnvironment);
         if (envSuccessResult.notification) {
           eventHelper.notification.publish.creation(
             envSuccessResult.notification,
@@ -1527,10 +1537,12 @@ const handleOperationError = (operation: PendingOperation, error: any) => {
         error,
       });
 
+      const accErrorTenant = (originalData as Account)?.tenant;
+      const accErrorKey = accErrorTenant ? `${accErrorTenant}/${entityName}` : entityName;
       if (accErrorResult.shouldDelete) {
-        accountsMap.delete(entityName);
+        accountsMap.delete(accErrorKey);
       } else if (accErrorResult.updatedAccount) {
-        accountsMap.set(entityName, accErrorResult.updatedAccount);
+        accountsMap.set(accErrorKey, accErrorResult.updatedAccount);
       }
 
       if (accErrorResult.eventType === "creationError") {
@@ -1557,7 +1569,9 @@ const handleOperationError = (operation: PendingOperation, error: any) => {
         eventHelper.environment.publish.deletionError(originalData);
       }
       eventHelper.notification.publish.creation(envErrorResult.notification);
-      environmentsMap.set(entityName, envErrorResult.updatedEnvironment);
+      const envErrOrigData = originalData as Environment;
+      const envErrorKey = envErrOrigData?.tenant && envErrOrigData?.account ? `${envErrOrigData.tenant}/${envErrOrigData.account}/${entityName}` : entityName;
+      environmentsMap.set(envErrorKey, envErrorResult.updatedEnvironment);
       break;
   }
   setTimeout(async () => {
@@ -1588,7 +1602,8 @@ const handleDeleteEvent = async (message: WSMessage) => {
   }
   if (keyParts.environment && !keyParts.service) {
     const environmentName = keyParts.environment;
-    const deletedEnv = environmentsMap.get(environmentName)!;
+    const envDeleteKey = tenantName && keyParts.account ? `${tenantName}/${keyParts.account}/${environmentName}` : environmentName;
+    const deletedEnv = environmentsMap.get(envDeleteKey)!;
     eventHelper.environment.publish.deleted(deletedEnv);
     const envNotification: Notification = {
       type: "success",
@@ -1603,11 +1618,12 @@ const handleDeleteEvent = async (message: WSMessage) => {
       },
     };
     eventHelper.notification.publish.creation(envNotification);
-    environmentsMap.delete(environmentName);
+    environmentsMap.delete(envDeleteKey);
   }
   if (keyParts.account && !keyParts.environment) {
     const accountName = keyParts.account;
-    const deletedAccount = accountsMap.get(accountName)!;
+    const accountDeleteKey = tenantName ? `${tenantName}/${accountName}` : accountName;
+    const deletedAccount = accountsMap.get(accountDeleteKey)!;
     eventHelper.account.publish.deleted(deletedAccount);
     const accountNotification: Notification = {
       type: "success",
@@ -1621,7 +1637,7 @@ const handleDeleteEvent = async (message: WSMessage) => {
       },
     };
     eventHelper.notification.publish.creation(accountNotification);
-    accountsMap.delete(accountName);
+    accountsMap.delete(accountDeleteKey);
   }
   if (keyParts.domain) {
     const domainName = keyParts.domain;
@@ -1901,7 +1917,8 @@ const loadReportingForEnvironment = async (environment: Environment) => {
       reportingData !== null &&
       Array.isArray(reportingData)
     ) {
-      const updatedEnvironment = environmentsMap.get(environment.id);
+      const envReportKey = environment.tenant && environment.account ? `${environment.tenant}/${environment.account}/${environment.id}` : environment.id;
+      const updatedEnvironment = environmentsMap.get(envReportKey);
 
       if (!updatedEnvironment) {
         console.warn(`Environment ${environment.id} not found in map`);
@@ -1932,7 +1949,7 @@ const loadReportingForEnvironment = async (environment: Environment) => {
           );
       }
 
-      environmentsMap.set(environment.id, updatedEnvironment);
+      environmentsMap.set(envReportKey, updatedEnvironment);
     }
   } catch (error) {
     console.error(