@kumori/aurora-backend-handler 1.0.49 → 1.0.50

package/helpers/service-helper.ts

@@ -1,5 +1,5 @@
+
 import { Channel, Service, Tenant, Usage } from "@kumori/aurora-interfaces";
-import { Revision } from "@kumori/aurora-interfaces/interfaces/revision-interface";
 import { getTimestamp } from "../utils/utils";
 
 interface Role {
@@ -24,6 +24,21 @@ interface Role {
   hsize?: number;
 }
 
+interface Revision {
+  service: string;
+  revision: string;
+  usage: Usage;
+  status: {
+    code: string;
+    message: string;
+    timestamp: string;
+    args: string[];
+  };
+  errorCode?: string;
+  errorMsg?: string;
+  createdAt?: string;
+}
+
 interface HandleServiceEventParams {
   entityId: string;
   eventData: any;
@@ -43,7 +58,6 @@ interface HandleServiceEventResult {
   pendingProject: { tenant: string; project: string } | null;
   updatedPendingRevisionErrors: Array<{ service: string; revision: Revision }>;
 }
-
 interface HandleServiceOperationSuccessParams {
   action: string;
   entityName: string;
@@ -83,6 +97,9 @@ interface HandleServiceOperationErrorResult {
   shouldResetRoles: boolean;
 }
 
+/**
+ * Parse key path to extract entity names
+ */
 const parseKeyPath = (key: string): { [entity: string]: string } => {
   if (!key) {
     return {};
@@ -92,12 +109,17 @@ const parseKeyPath = (key: string): { [entity: string]: string } => {
   const result: { [entity: string]: string } = {};
   for (let i = 0; i < parts.length; i += 2) {
     if (parts[i] && parts[i + 1]) {
-      result[parts[i]] = parts[i + 1];
+      const entityType = parts[i];
+      const entityName = parts[i + 1];
+      result[entityType] = entityName;
     }
   }
   return result;
 };
 
+/**
+ * Get default usage object
+ */
 const getDefaultUsage = (): Usage => ({
   current: {
     cpu: 0,
@@ -118,6 +140,25 @@ const getDefaultUsage = (): Usage => ({
   cost: 0,
 });
 
+/**
+ * Collect revisions for a service from revisionsMap
+ */
+const collectServiceRevisions = (
+  entityId: string,
+  revisionsMap: Map<string, Revision>,
+): string[] => {
+  const serviceRevisions: string[] = [];
+  revisionsMap.forEach((revision, key) => {
+    if (revision.service === entityId) {
+      serviceRevisions.push(revision.revision);
+    }
+  });
+  return serviceRevisions;
+};
+
+/**
+ * Determine final status and error based on timestamps
+ */
 const determineFinalStatusAndError = (
   existingService: Service | undefined,
   eventData: any,
@@ -138,13 +179,13 @@ const determineFinalStatusAndError = (
 
   if (isNewer) {
     finalStatus = incomingStatus;
+
     if (eventData.status.error) {
       finalError = eventData.status.error;
     } else {
       finalError = undefined;
     }
   }
-
   const pendingErrorIndex = pendingRevisionErrors.findIndex(
     (pending) => pending.service === entityId,
   );
@@ -166,7 +207,10 @@ const determineFinalStatusAndError = (
 
   return { finalStatus, finalError, pendingErrorIndex };
 };
-
+/**
+ * Handles the "service" event from WebSocket messages
+ * Processes service data updates and manages project labels
+ */
 export const handleServiceEvent = ({
   entityId,
   eventData,
@@ -186,14 +230,7 @@ export const handleServiceEvent = ({
   const projectLabel = eventData.meta?.labels?.project;
   const serviceRoles = roleMap.get(serviceFullKey) || [];
   const serviceUsage = currentRevision?.usage || getDefaultUsage();
-
-  const serviceRevisions: Revision[] = [];
-  revisionsMap.forEach((revision, key) => {
-    if (key.startsWith(`${serviceFullKey}-`)) {
-      serviceRevisions.push(revision);
-    }
-  });
-
+  const serviceRevisions = collectServiceRevisions(entityId, revisionsMap);
   const environmentPath = eventData.spec.environment;
   const pathParts = parseKeyPath(environmentPath);
   const existingService = servicesMap.get(serviceFullKey);
@@ -204,37 +241,30 @@ export const handleServiceEvent = ({
       pendingRevisionErrors,
       entityId,
     );
-
   const updatedPendingRevisionErrors = [...pendingRevisionErrors];
   if (pendingErrorIndex !== -1) {
     updatedPendingRevisionErrors.splice(pendingErrorIndex, 1);
   }
-
-  const currentRevisionId =
-    eventData.status.revision ||
-    (serviceRevisions.length > 0
-      ? Math.max(...serviceRevisions.map((r) => Number(r.id))).toString()
-      : "");
-
   const baseServiceData = {
     tenant: serviceTenantId,
     account: eventData.spec.metadata.targetAccount || pathParts.account,
     environment:
       eventData.spec.metadata.targetEnvironment || pathParts.environment,
     name: entityId,
-    revisions: [...serviceRevisions].sort(
-      (a, b) => Number(b.id) - Number(a.id),
-    ),
+    revisions: [...serviceRevisions].sort((a, b) => Number(b) - Number(a)),
     status: finalStatus || eventData.status.state,
     error: finalError,
     role: serviceRoles.length > 0 ? serviceRoles : existingService?.role || [],
     usage: serviceUsage,
     lastDeployed: eventData.spec.ctstamp,
     project: projectLabel || existingService?.project || "",
-    currentRevision: currentRevisionId,
+    currentRevision:
+      eventData.status.revision ||
+      (serviceRevisions.length > 0
+        ? Math.max(...serviceRevisions.map(Number)).toString()
+        : ""),
     startedAt: currentRevision?.createdAt || existingService?.startedAt || "",
   };
-
   let newService: Service;
 
   if (existingService) {
@@ -263,7 +293,6 @@ export const handleServiceEvent = ({
       ...baseServiceData,
     };
   }
-
   const oldStatusCode = existingService?.status?.code;
   const newStatusCode = newService.status.code;
 
@@ -272,7 +301,6 @@ export const handleServiceEvent = ({
     oldStatusCode !== "SERVICE_READY" &&
     newStatusCode === "SERVICE_READY" &&
     eventData.status.deployed === true;
-
   let pendingProject: { tenant: string; project: string } | null = null;
 
   if (projectLabel) {
@@ -301,6 +329,9 @@ export const handleServiceEvent = ({
   };
 };
 
+/**
+ * Handles successful service operations
+ */
 export const handleServiceOperationSuccess = ({
   action,
   entityName,
@@ -341,8 +372,12 @@ export const handleServiceOperationSuccess = ({
     }
 
     if (!revisionData?.solution) {
+      const resetService = {
+        ...service,
+        role: [],
+      };
       return {
-        updatedService: { ...service, role: [] },
+        updatedService: resetService,
         shouldDelete: false,
         eventType: null,
         processRevisionData: false,
@@ -350,7 +385,6 @@ export const handleServiceOperationSuccess = ({
         serviceId,
       };
     }
-
     return {
       updatedService: service,
       shouldDelete: false,
@@ -365,16 +399,17 @@ export const handleServiceOperationSuccess = ({
     const existingService = servicesMap.get(serviceId);
 
     if (existingService) {
-      return {
-        updatedService: {
-          ...existingService,
-          status: {
-            code: "REMOVING_SERVICE",
-            message: `Service ${entityName} is being removed`,
-            args: [],
-            timestamp: new Date().toISOString(),
-          },
+      const updatedService = {
+        ...existingService,
+        status: {
+          code: "REMOVING_SERVICE",
+          message: `Service ${entityName} is being removed`,
+          args: [],
+          timestamp: new Date().toISOString(),
         },
+      };
+      return {
+        updatedService,
         shouldDelete: false,
         eventType: "deleting",
         processRevisionData: false,
@@ -392,25 +427,28 @@ export const handleServiceOperationSuccess = ({
       serviceId,
     };
   }
-
   if (originalData) {
-    return {
-      updatedService: {
-        ...originalData,
-        status: {
-          code: "SERVICE_READY",
-          message: `Service (${entityName}) is ready.`,
-          args: [],
-          timestamp: new Date().toISOString(),
-        },
+    const updatedService = {
+      ...originalData,
+      status: {
+        code: "SERVICE_READY",
+        message: `Service (${entityName}) is ready.`,
+        args: [],
+        timestamp: new Date().toISOString(),
       },
+    };
+
+    let eventType: "deployed" | "updated" | null = null;
+    if (action === "CREATE") {
+      eventType = "deployed";
+    } else if (action === "UPDATE") {
+      eventType = "updated";
+    }
+
+    return {
+      updatedService,
       shouldDelete: false,
-      eventType:
-        action === "CREATE"
-          ? "deployed"
-          : action === "UPDATE"
-            ? "updated"
-            : null,
+      eventType,
       processRevisionData: false,
       revisionData: null,
       serviceId,
@@ -427,6 +465,9 @@ export const handleServiceOperationSuccess = ({
   };
 };
 
+/**
+ * Handles failed service operations
+ */
 export const handleServiceOperationError = ({
   action,
   entityName,
@@ -440,27 +481,46 @@ export const handleServiceOperationError = ({
     : entityName;
 
   if (action === "CREATE") {
-    return { eventType: "deploymentError", serviceId, shouldResetRoles: false };
+    return {
+      eventType: "deploymentError",
+      serviceId,
+      shouldResetRoles: false,
+    };
   }
 
   if (action === "UPDATE") {
-    return { eventType: "updateError", serviceId, shouldResetRoles: false };
+    return {
+      eventType: "updateError",
+      serviceId,
+      shouldResetRoles: false,
+    };
   }
 
   if (action === "DELETE") {
-    return { eventType: "deletionError", serviceId, shouldResetRoles: false };
+    return {
+      eventType: "deletionError",
+      serviceId,
+      shouldResetRoles: false,
+    };
   }
 
   if (action === "GET_REVISION") {
     const service = servicesMap.get(serviceId);
     if (service) {
-      return { eventType: "revisionError", serviceId, shouldResetRoles: true };
+      return {
+        eventType: "revisionError",
+        serviceId,
+        shouldResetRoles: true,
+      };
     }
   }
 
-  return { eventType: null, serviceId, shouldResetRoles: false };
+  return {
+    eventType: null,
+    serviceId,
+    shouldResetRoles: false,
+  };
 };
-
 export const mapChannelsFromApiData = (
   apiData: any,
   entityId: string,
@@ -476,28 +536,45 @@ export const mapChannelsFromApiData = (
 
   const publicChannelNames = new Set<string>();
 
-  const collectPublic = (section: any) => {
-    if (!section) return;
-    Object.keys(section).forEach((channelName) => {
+  if (apiData.server) {
+    Object.keys(apiData.server).forEach((channelName) => {
       if (channelName.endsWith(inboundSuffix)) {
         const baseName = channelName.slice(0, -inboundSuffix.length);
-        if (section[baseName]) {
+        if (apiData.server[baseName]) {
           publicChannelNames.add(baseName);
         }
       }
     });
-  };
+  }
 
-  collectPublic(apiData.server);
-  collectPublic(apiData.client);
-  collectPublic(apiData.duplex);
+  if (apiData.client) {
+    Object.keys(apiData.client).forEach((channelName) => {
+      if (channelName.endsWith(inboundSuffix)) {
+        const baseName = channelName.slice(0, -inboundSuffix.length);
+        if (apiData.client[baseName]) {
+          publicChannelNames.add(baseName);
+        }
+      }
+    });
+  }
 
-  const mapChannels = (section: any, target: Channel[]) => {
-    if (!section) return;
-    Object.entries(section).forEach(
+  if (apiData.duplex) {
+    Object.keys(apiData.duplex).forEach((channelName) => {
+      if (channelName.endsWith(inboundSuffix)) {
+        const baseName = channelName.slice(0, -inboundSuffix.length);
+        if (apiData.duplex[baseName]) {
+          publicChannelNames.add(baseName);
+        }
+      }
+    });
+  }
+  if (apiData.server) {
+    Object.entries(apiData.server).forEach(
       ([channelName, channelData]: [string, any]) => {
-        if (channelName.endsWith(inboundSuffix)) return;
-        target.push({
+        if (channelName.endsWith(inboundSuffix)) {
+          return;
+        }
+        serverChannels.push({
           name: channelName,
           from: entityId,
           to: "",
@@ -508,11 +585,43 @@ export const mapChannelsFromApiData = (
         });
       },
     );
-  };
-
-  mapChannels(apiData.server, serverChannels);
-  mapChannels(apiData.client, clientChannels);
-  mapChannels(apiData.duplex, duplexChannels);
+  }
+  if (apiData.client) {
+    Object.entries(apiData.client).forEach(
+      ([channelName, channelData]: [string, any]) => {
+        if (channelName.endsWith(inboundSuffix)) {
+          return;
+        }
+        clientChannels.push({
+          name: channelName,
+          from: entityId,
+          to: "",
+          protocol: channelData.protocol as "http" | "tcp" | "https",
+          port: channelData.port,
+          portNum: channelData.port,
+          isPublic: publicChannelNames.has(channelName),
+        });
+      },
+    );
+  }
+  if (apiData.duplex) {
+    Object.entries(apiData.duplex).forEach(
+      ([channelName, channelData]: [string, any]) => {
+        if (channelName.endsWith(inboundSuffix)) {
+          return;
+        }
+        duplexChannels.push({
+          name: channelName,
+          from: entityId,
+          to: "",
+          protocol: channelData.protocol as "http" | "tcp" | "https",
+          port: channelData.port,
+          portNum: channelData.port,
+          isPublic: publicChannelNames.has(channelName),
+        });
+      },
+    );
+  }
 
   return { serverChannels, clientChannels, duplexChannels };
-};
+};

package/package.json

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

package/websocket-manager.ts

@@ -74,7 +74,6 @@ import {
 } from "./helpers/token-helper";
 import { handleLinkEvent } from "./helpers/link-helper";
 import { eventHelper } from "./backend-handler";
-import { Revision } from "@kumori/aurora-interfaces/interfaces/revision-interface";
 
 let WebSocketClass: any;
 
@@ -89,9 +88,19 @@ interface WSMessage {
     content?: string;
   };
 }
-interface RevisionWs {
+interface Revision {
   service: string;
-  revision: Revision;
+  revision: string;
+  usage: Usage;
+  status: {
+    code: string;
+    message: string;
+    timestamp: string;
+    args: string[];
+  };
+  errorCode?: string;
+  errorMsg?: string;
+  createdAt?: string;
 }
 interface PendingOperation {
   resolve: Function;
@@ -1218,8 +1227,6 @@ const handleOperationSuccess = (operation: PendingOperation, response: any) => {
             const updatedService = processRevisionData(
               svcSuccessResult.updatedService!,
               svcSuccessResult.revisionData,
-              revisionsMap,
-              svcSuccessResult.serviceId,
             );
 
             if (svcSuccessResult.revisionData.revision_error) {