@kumori/aurora-backend-handler 1.0.100 → 1.0.111

package/helpers/service-helper.ts

@@ -1,4 +1,4 @@
-import { Channel, Service, Tenant, Usage } from "@kumori/aurora-interfaces";
+import { Channel, Resource, Service, Tenant, Usage } from "@kumori/aurora-interfaces";
 import { Revision } from "@kumori/aurora-interfaces/interfaces/revision-interface";
 import { getTimestamp } from "../utils/utils";
 
@@ -98,7 +98,7 @@ const parseKeyPath = (key: string): { [entity: string]: string } => {
   return result;
 };
 
-const getDefaultUsage = (): Usage => ({
+const getDefaultUsage = (eventData?: any): Usage => ({
   current: {
     cpu: 0,
     memory: 0,
@@ -108,12 +108,12 @@ const getDefaultUsage = (): Usage => ({
     persistentStorage: 0,
   },
   limit: {
-    cpu: { max: 0, min: 0 },
-    memory: { max: 0, min: 0 },
-    storage: { max: 0, min: 0 },
-    volatileStorage: { max: 0, min: 0 },
-    nonReplicatedStorage: { max: 0, min: 0 },
-    persistentStorage: { max: 0, min: 0 },
+    cpu: { max: eventData.vcpu || 0, min: eventData.vcpu || 0 },
+    memory: { max: eventData.ram || 0, min: eventData.ram || 0 },
+    storage: { max: (eventData.volatile_disk || 0) + (eventData.persistent_disk || 0) +  (eventData.persistent_disk || 0), min: (eventData.volatile_disk || 0) + (eventData.persistent_disk || 0) +  (eventData.persistent_disk || 0) },
+    volatileStorage: { max: eventData.volatile_disk || 0, min: eventData.volatile_disk || 0 },
+    nonReplicatedStorage: { max: eventData.persistent_disk || 0, min: eventData.persistent_disk || 0 },
+    persistentStorage: { max: eventData.persistent_disk || 0, min: eventData.persistent_disk || 0 },
   },
   cost: 0,
 });
@@ -123,6 +123,7 @@ const determineFinalStatusAndError = (
   eventData: any,
   pendingRevisionErrors: Array<{ service: string; revision: Revision }>,
   entityId: string,
+  currentRevision: Revision | undefined,
 ): {
   finalStatus: any;
   finalError: any;
@@ -131,37 +132,44 @@ const determineFinalStatusAndError = (
   const incomingStatus = eventData.status.state;
   const incomingTs = getTimestamp(incomingStatus.timestamp);
   const currentTs = getTimestamp(existingService?.status?.timestamp);
+  const revisionTs = currentRevision?.status ? getTimestamp(currentRevision.status.timestamp) : 0;
+
+  const bestCandidateTs = Math.max(incomingTs, revisionTs);
+  const isNewer = !existingService || bestCandidateTs > currentTs;
+
+  const removingStatus = {
+    code: "REMOVING_SERVICE",
+    message: `Service ${entityId} is being removed`,
+    args: [],
+    timestamp: new Date().toISOString(),
+  };
+
+  if (eventData.meta?.deleted || existingService?.status?.code === "REMOVING_SERVICE") {
+    return { finalStatus: removingStatus, finalError: undefined, pendingErrorIndex: -1 };
+  }
 
-  const isNewer = !existingService || incomingTs > currentTs;
   let finalStatus = existingService?.status;
   let finalError = existingService?.error;
 
   if (isNewer) {
-    finalStatus = incomingStatus;
-    if (eventData.status.error) {
-      finalError = eventData.status.error;
-    } else {
-      finalError = undefined;
-    }
+    const revisionHasError = !!currentRevision?.errorCode;
+    finalStatus = (revisionHasError || (currentRevision?.status && revisionTs >= incomingTs))
+      ? currentRevision!.status
+      : incomingStatus;
+    finalError = eventData.status.error ?? undefined;
   }
 
   const pendingErrorIndex = pendingRevisionErrors.findIndex(
     (pending) => pending.service === entityId,
   );
-
   if (pendingErrorIndex !== -1) {
     const pendingError = pendingRevisionErrors[pendingErrorIndex];
-    const pendingTs = getTimestamp(pendingError.revision.status.timestamp);
-    const currentDecisionTs = getTimestamp(finalStatus?.timestamp);
-
-    if (pendingTs > currentDecisionTs) {
-      finalStatus = pendingError.revision.status;
-      finalError = {
-        code: pendingError.revision.errorCode || "",
-        message: pendingError.revision.errorMsg || "",
-        timestamp: pendingError.revision.status.timestamp || "",
-      };
-    }
+    finalStatus = pendingError.revision.status;
+    finalError = {
+      code: pendingError.revision.errorCode || "",
+      message: pendingError.revision.errorMsg || "",
+      timestamp: pendingError.revision.status.timestamp || "",
+    };
   }
 
   return { finalStatus, finalError, pendingErrorIndex };
@@ -180,16 +188,17 @@ export const handleServiceEvent = ({
 }: HandleServiceEventParams): HandleServiceEventResult => {
   const serviceFullKey = `${parentParts.tenant}/${entityId}`;
   const serviceTenantId = parentParts.tenant;
-  const currentRevisionKey = `${serviceFullKey}-${eventData.status.revision}`;
+  const currentRevisionKey = `${eventData.id.parent.name}/service/${entityId}/revision/${eventData.spec.ctstamp || eventData.status.revision}`;
   const currentRevision = revisionsMap.get(currentRevisionKey);
 
   const projectLabel = eventData.meta?.labels?.project;
   const serviceRoles = roleMap.get(serviceFullKey) || [];
-  const serviceUsage = currentRevision?.usage || getDefaultUsage();
+  const serviceUsage = currentRevision?.usage || getDefaultUsage(eventData);
+
 
   const serviceRevisions: Revision[] = [];
   revisionsMap.forEach((revision, key) => {
-    if (key.startsWith(`${serviceFullKey}-`)) {
+    if (key.startsWith(`${eventData.id.parent.name}/service/${entityId}/revision/`)) {
       serviceRevisions.push(revision);
     }
   });
@@ -203,6 +212,7 @@ export const handleServiceEvent = ({
       eventData,
       pendingRevisionErrors,
       entityId,
+      currentRevision,
     );
 
   const updatedPendingRevisionErrors = [...pendingRevisionErrors];
@@ -458,6 +468,7 @@ export const handleServiceOperationError = ({
 export const mapChannelsFromApiData = (
   apiData: any,
   entityId: string,
+  existingResources?: Resource[],
 ): {
   serverChannels: Channel[];
   clientChannels: Channel[];
@@ -467,7 +478,6 @@ export const mapChannelsFromApiData = (
   const clientChannels: Channel[] = [];
   const duplexChannels: Channel[] = [];
   const inboundSuffix = "_inbound.inbound";
-
   const publicChannelNames = new Set<string>();
 
   const collectPublic = (section: any) => {
@@ -491,6 +501,12 @@ export const mapChannelsFromApiData = (
     Object.entries(section).forEach(
       ([channelName, channelData]: [string, any]) => {
         if (channelName.endsWith(inboundSuffix)) return;
+        const hasGatewayResource = existingResources?.some(
+          (r) =>
+            (r.type === "port" || r.type === "domain") &&
+            (r.name === `${channelName}_port` || r.name === `${channelName}_domain`),
+        ) ?? false;
+
         target.push({
           name: channelName,
           from: entityId,
@@ -498,7 +514,7 @@ export const mapChannelsFromApiData = (
           protocol: channelData.protocol as "http" | "tcp" | "https",
           port: channelData.port,
           portNum: channelData.port,
-          isPublic: publicChannelNames.has(channelName),
+          isPublic: publicChannelNames.has(channelName) || hasGatewayResource,
         });
       },
     );
@@ -509,4 +525,4 @@ export const mapChannelsFromApiData = (
   mapChannels(apiData.duplex, duplexChannels);
 
   return { serverChannels, clientChannels, duplexChannels };
-};
+};

package/helpers/tenant-helper.ts

@@ -1,4 +1,3 @@
-
 import { Tenant, tenantRole, User, UserData } from "@kumori/aurora-interfaces";
 import { parseKeyPath } from "../utils/utils";
 
@@ -98,10 +97,6 @@ export const handleTenantEvent: (
     ) {
       newTenant.npmRegistry.domain = Object.keys(eventData.spec.domains)[0];
     }
-  } else {
-    console.warn(
-      `No se encontró información de registry en eventData para el tenant ${newTenant.name}`,
-    );
   }
   return newTenant;
 };

package/helpers/token-helper.ts

@@ -1,10 +1,11 @@
-import { ClusterToken, Token, UserData } from "@kumori/aurora-interfaces";
+import { ClusterToken, errors, Notification, Token, UserData } from "@kumori/aurora-interfaces";
 
 
 interface HandleTokenEventParams {
   eventData: any;
   tokenMap: Map<string, Token>;
   userData: UserData;
+  deletedTokenIds: Set<string>;
 }
 
 interface HandleTokenEventResult {
@@ -24,10 +25,26 @@ export const handleTokenEvent = ({
   eventData,
   tokenMap,
   userData,
+  deletedTokenIds,
 }: HandleTokenEventParams): HandleTokenEventResult => {
   const tokenParentKind = eventData.id.parent?.kind;
   const tokenId = eventData.id.name;
 
+  if (tokenParentKind === "user" && deletedTokenIds.has(tokenId)) {
+    // A tombstoned token (already explicitly deleted by the user) must
+    // never be resurrected by a stale/out-of-order "token" event -
+    // e.g. one reflecting backend state that hasn't caught up with the
+    // deletion yet.
+    return {
+      isUserToken: false,
+      isClusterToken: false,
+      userToken: null,
+      clusterToken: null,
+      updatedUserTokens: userData.tokens,
+      tokenId,
+    };
+  }
+
   if (tokenParentKind === "user") {
     const tokenInMap = tokenMap.get(tokenId);
     
@@ -41,6 +58,10 @@ export const handleTokenEvent = ({
         : "",
       token: tokenInMap?.token || "",
     };
+    if (!tokenInMap) {
+      tokenMap.set(tokenId, newUserToken);
+    }
+
     const updatedUserTokens = [...userData.tokens];
     const existingTokenIndex = updatedUserTokens.findIndex(
       (t) => t.name === tokenId
@@ -76,7 +97,6 @@ export const handleTokenEvent = ({
     };
   }
 };
-
 interface HandleTokenOperationSuccessParams {
   responsePayload: any;
 }
@@ -104,4 +124,56 @@ export const handleTokenOperationSuccess = ({
   return {
     token: tokenWithData,
   };
+};
+interface HandleTokenDeletionParams {
+  tokenId: string;
+  tokenMap: Map<string, Token>;
+  userData: UserData;
+  deletedTokenIds: Set<string>;
+}
+
+interface HandleTokenDeletionResult {
+  removed: boolean;
+  updatedUserTokens: Token[];
+  notification: Notification | null;
+}
+
+export const handleTokenDeletion = ({
+  tokenId,
+  tokenMap,
+  userData,
+  deletedTokenIds,
+}: HandleTokenDeletionParams): HandleTokenDeletionResult => {
+  deletedTokenIds.add(tokenId);
+  const tokenIndex = userData.tokens.findIndex((t) => t.name === tokenId);
+  if (tokenIndex === -1) {
+    return {
+      removed: false,
+      updatedUserTokens: userData.tokens,
+      notification: null,
+    };
+  }
+
+  const deletedToken = userData.tokens[tokenIndex];
+  const updatedUserTokens = [...userData.tokens];
+  updatedUserTokens.splice(tokenIndex, 1);
+  tokenMap.delete(tokenId);
+
+  const notification: Notification = {
+    type: "success",
+    subtype: errors.user.tokenDeleted.subtype,
+    date: Date.now().toString(),
+    status: "unread",
+    callToAction: false,
+    data: {
+      tokenName: deletedToken.name,
+      tenant: deletedToken.tenant,
+    },
+  };
+
+  return {
+    removed: true,
+    updatedUserTokens,
+    notification,
+  };
 };

package/helpers/user-helper.ts

@@ -1,6 +1,12 @@
-import { Notification, Plan, Tenant, UserData } from "@kumori/aurora-interfaces";
-
-
+import {
+  errors,
+  Notification,
+  Plan,
+  Tenant,
+  UserData,
+  tenantRole,
+  UserStatus
+} from "@kumori/aurora-interfaces";
 
 interface HandleUserEventParams {
   eventData: any;
@@ -38,17 +44,49 @@ export const handleUserEvent = ({
     if (!userTenants.includes(key)) {
       const tenantToDelete = tenantsMap.get(key);
       if (tenantToDelete) {
-        const userRemovedNotification: Notification = {
-          type: "info",
-          subtype: "user-removed-from-tenant",
-          date: Date.now().toString(),
-          callToAction: false,
-          status: "unread",
-          data: {
-            tenant: tenantToDelete.name,
-          },
-        };
-        eventHelper.notification.publish.creation(userRemovedNotification);
+        const currentUserInTenant = tenantToDelete.users.find(
+          (u) => u.id === userId,
+        );
+        const isRejectedOrLeaving =
+          currentUserInTenant?.status === "rejected" ||
+          tenantToDelete.status === "leaving";
+
+        if (currentUserInTenant && !isRejectedOrLeaving) {
+          const onlyOneUser = tenantToDelete.users.length === 1;
+          const isSoloOwner =
+            onlyOneUser &&
+            currentUserInTenant.role === tenantRole.OWNER &&
+            currentUserInTenant.id === userId;
+
+          if (isSoloOwner) {
+            eventHelper.tenant.publish.deleted(tenantToDelete);
+            const tenantDeletedNotification: Notification = {
+              type: "success",
+              subtype: errors.tenant.deleted.subtype,
+              date: Date.now().toString(),
+              callToAction: false,
+              status: "unread",
+              data: {
+                tenant: tenantToDelete.name,
+              },
+            };
+            eventHelper.notification.publish.creation(
+              tenantDeletedNotification,
+            );
+          } else {
+            const userRemovedNotification: Notification = {
+              type: "info",
+              subtype: errors.tenant.accessRevoked.subtype,
+              date: Date.now().toString(),
+              callToAction: false,
+              status: "unread",
+              data: {
+                tenant: tenantToDelete.name,
+              },
+            };
+            eventHelper.notification.publish.creation(userRemovedNotification);
+          }
+        }
         deletedTenantKeys.push(key);
       }
     }
@@ -76,14 +114,14 @@ export const handleUserEvent = ({
           };
           userPlans.push(basicPlan);
         }
-      }
+      },
     );
   }
   const tempProviders: Record<string, string> = eventData.spec.providers || {};
   const providers: { name: string; email: string; password?: string }[] = [];
 
   const existingProvidersMap = new Map(
-    (currentUserData.provider || []).map((p) => [p.name, p])
+    (currentUserData.provider || []).map((p) => [p.name, p]),
   );
 
   for (const [providerName, providerId] of Object.entries(tempProviders)) {
@@ -100,6 +138,7 @@ export const handleUserEvent = ({
   }
   const userData: UserData = {
     id: userId,
+    created: eventData.meta?.created || currentUserData.created || "",
     name: eventData.spec.userinfo.name,
     surname: eventData.spec.userinfo.surname,
     provider: providers,
@@ -122,19 +161,21 @@ export const handleUserEvent = ({
     deletedTenantKeys,
   };
 };
-export const handleUserOperationError = (): UserData => {
-    return {
-        id: "",
-        name: "",
-        surname: "",
-        provider: [],
-        notificationsEnabled: "",
-        organizations: [],
-        clusterTokens: [],
-        tokens: [],
-        tenants: [],
-        axebowPlan: "freemium",
-        companyName: "",
-        rol: "",
-    };
+export const handleUserDelete = (): UserData => {
+  return {
+    id: "",
+    created: "",
+    name: "",
+    surname: "",
+    provider: [],
+    notificationsEnabled: "",
+    organizations: [],
+    clusterTokens: [],
+    tokens: [],
+    tenants: [],
+    axebowPlan: "freemium",
+    companyName: "",
+    rol: "",
+    status: UserStatus.NOT_LOGGED,
+  };
 };

package/jest.config.ts

@@ -19,6 +19,7 @@ const config: Config.InitialOptions = {
   moduleNameMapper: {
     '^(\\.{1,2}/.*)\\.js$': '$1',
   },
+  coverageProvider: 'v8',
   collectCoverage: true,
   collectCoverageFrom: [
     "**/backend-handler.ts",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kumori/aurora-backend-handler",
-  "version": "1.0.100",
+  "version": "1.0.111",
   "description": "backend handler",
   "main": "backend-handler.ts",
   "scripts": {
@@ -11,8 +11,8 @@
     "glob": "^11.0.0"
   },
   "dependencies": {
-    "@kumori/aurora-interfaces": "^1.0.12",
-    "@kumori/kumori-dsl-generator": "^1.0.4",
+    "@kumori/aurora-interfaces": "^1.0.30",
+    "@kumori/kumori-dsl-generator": "1.0.10",
     "@kumori/kumori-module-generator": "^1.1.6",
     "ts-node": "^10.9.2",
     "uuid": "^11.1.0",