@kumori/aurora-backend-handler 1.0.0

package/helpers/service-helper.ts

@@ -0,0 +1,627 @@
+
+import { Channel, Service, Tenant, Usage } from "@hestekumori/aurora-interfaces";
+import { getTimestamp } from "../utils/utils";
+
+interface Role {
+  name: string;
+  instances: any[];
+  logo?: string;
+  category?: string;
+  version?: string;
+  description?: string;
+  resource?: any[];
+  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;
+}
+
+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;
+  parentParts: { [entity: string]: string };
+  servicesMap: Map<string, Service>;
+  revisionsMap: Map<string, Revision>;
+  roleMap: Map<string, Role[]>;
+  tenantsMap: Map<string, Tenant>;
+  pendingRevisionErrors: Array<{ service: string; revision: Revision }>;
+  pendingProjects: Array<{ tenant: string; project: string }>;
+}
+
+interface HandleServiceEventResult {
+  service: Service;
+  serviceFullKey: string;
+  wasDeployed: boolean;
+  pendingProject: { tenant: string; project: string } | null;
+  updatedPendingRevisionErrors: Array<{ service: string; revision: Revision }>;
+}
+interface HandleServiceOperationSuccessParams {
+  action: string;
+  entityName: string;
+  originalData: any;
+  responsePayload: any;
+  servicesMap: Map<string, Service>;
+  revisionsMap: Map<string, Revision>;
+  roleMap: Map<string, Role[]>;
+}
+
+interface HandleServiceOperationSuccessResult {
+  updatedService: Service | null;
+  shouldDelete: boolean;
+  eventType: "deployed" | "updated" | "deleting" | null;
+  processRevisionData: boolean;
+  revisionData: any;
+  serviceId: string;
+}
+
+interface HandleServiceOperationErrorParams {
+  action: string;
+  entityName: string;
+  originalData: any;
+  error: any;
+  servicesMap: Map<string, Service>;
+  roleMap: Map<string, Role[]>;
+}
+
+interface HandleServiceOperationErrorResult {
+  eventType:
+    | "deploymentError"
+    | "updateError"
+    | "deletionError"
+    | "revisionError"
+    | null;
+  serviceId: string;
+  shouldResetRoles: boolean;
+}
+
+/**
+ * Parse key path to extract entity names
+ */
+const parseKeyPath = (key: string): { [entity: string]: string } => {
+  if (!key) {
+    return {};
+  }
+  const cleanKey = key?.startsWith("/") ? key.slice(1) : key;
+  const parts = cleanKey.split("/");
+  const result: { [entity: string]: string } = {};
+  for (let i = 0; i < parts.length; i += 2) {
+    if (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,
+    memory: 0,
+    storage: 0,
+    volatileStorage: 0,
+    nonReplicatedStorage: 0,
+    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 },
+  },
+  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,
+  pendingRevisionErrors: Array<{ service: string; revision: Revision }>,
+  entityId: string,
+): {
+  finalStatus: any;
+  finalError: any;
+  pendingErrorIndex: number;
+} => {
+  const incomingStatus = eventData.status.state;
+  const incomingTs = getTimestamp(incomingStatus.timestamp);
+  const currentTs = getTimestamp(existingService?.status?.timestamp);
+
+  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 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 || "",
+      };
+    }
+  }
+
+  return { finalStatus, finalError, pendingErrorIndex };
+};
+/**
+ * Handles the "service" event from WebSocket messages
+ * Processes service data updates and manages project labels
+ */
+export const handleServiceEvent = ({
+  entityId,
+  eventData,
+  parentParts,
+  servicesMap,
+  revisionsMap,
+  roleMap,
+  tenantsMap,
+  pendingRevisionErrors,
+  pendingProjects,
+}: HandleServiceEventParams): HandleServiceEventResult => {
+  const serviceFullKey = `${parentParts.tenant}/${entityId}`;
+  const serviceTenantId = parentParts.tenant;
+  const currentRevisionKey = `${serviceFullKey}-${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 serviceRevisions = collectServiceRevisions(entityId, revisionsMap);
+  const environmentPath = eventData.spec.environment;
+  const pathParts = parseKeyPath(environmentPath);
+  const existingService = servicesMap.get(serviceFullKey);
+  const { finalStatus, finalError, pendingErrorIndex } =
+    determineFinalStatusAndError(
+      existingService,
+      eventData,
+      pendingRevisionErrors,
+      entityId,
+    );
+  const updatedPendingRevisionErrors = [...pendingRevisionErrors];
+  if (pendingErrorIndex !== -1) {
+    updatedPendingRevisionErrors.splice(pendingErrorIndex, 1);
+  }
+  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) - 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:
+      eventData.status.revision ||
+      (serviceRevisions.length > 0
+        ? Math.max(...serviceRevisions.map(Number)).toString()
+        : ""),
+    startedAt: currentRevision?.createdAt || existingService?.startedAt || "",
+  };
+  let newService: Service;
+
+  if (existingService) {
+    newService = {
+      ...existingService,
+      ...baseServiceData,
+    };
+  } else {
+    newService = {
+      id: serviceFullKey,
+      logo: "",
+      description: "",
+      links: [],
+      resources: [],
+      parameters: [],
+      minReplicas: 0,
+      maxReplicas: 0,
+      registry: "",
+      imageName: "",
+      entrypoint: "",
+      cmd: "",
+      serverChannels: [],
+      clientChannels: [],
+      duplexChannels: [],
+      cloudProvider: "",
+      ...baseServiceData,
+    };
+  }
+  const oldStatusCode = existingService?.status?.code;
+  const newStatusCode = newService.status.code;
+
+  const wasDeployed =
+    existingService !== undefined &&
+    oldStatusCode !== "SERVICE_READY" &&
+    newStatusCode === "SERVICE_READY" &&
+    eventData.status.deployed === true;
+  let pendingProject: { tenant: string; project: string } | null = null;
+
+  if (projectLabel) {
+    const tenant = tenantsMap.get(serviceTenantId);
+    if (!tenant) {
+      const existingPending = pendingProjects.find(
+        (pending) =>
+          pending.tenant === serviceTenantId &&
+          pending.project === projectLabel,
+      );
+      if (!existingPending) {
+        pendingProject = {
+          tenant: serviceTenantId,
+          project: projectLabel,
+        };
+      }
+    }
+  }
+
+  return {
+    service: newService,
+    serviceFullKey,
+    wasDeployed,
+    pendingProject,
+    updatedPendingRevisionErrors,
+  };
+};
+
+/**
+ * Handles successful service operations
+ */
+export const handleServiceOperationSuccess = ({
+  action,
+  entityName,
+  originalData,
+  responsePayload,
+  servicesMap,
+  revisionsMap,
+  roleMap,
+}: HandleServiceOperationSuccessParams): HandleServiceOperationSuccessResult => {
+  const serviceId = originalData
+    ? `${originalData.tenant}/${entityName}`
+    : entityName;
+
+  if (action === "GET_CHANNELS") {
+    return {
+      updatedService: null,
+      shouldDelete: false,
+      eventType: null,
+      processRevisionData: false,
+      revisionData: null,
+      serviceId,
+    };
+  }
+
+  if (action === "GET_REVISION") {
+    const revisionData = responsePayload?.data;
+    const service = servicesMap.get(serviceId);
+
+    if (!service) {
+      return {
+        updatedService: null,
+        shouldDelete: false,
+        eventType: null,
+        processRevisionData: false,
+        revisionData: null,
+        serviceId,
+      };
+    }
+
+    if (!revisionData?.solution) {
+      const resetService = {
+        ...service,
+        role: [],
+      };
+      return {
+        updatedService: resetService,
+        shouldDelete: false,
+        eventType: null,
+        processRevisionData: false,
+        revisionData: null,
+        serviceId,
+      };
+    }
+    return {
+      updatedService: service,
+      shouldDelete: false,
+      eventType: null,
+      processRevisionData: true,
+      revisionData,
+      serviceId,
+    };
+  }
+
+  if (action === "DELETE") {
+    const existingService = servicesMap.get(serviceId);
+
+    if (existingService) {
+      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,
+        revisionData: null,
+        serviceId,
+      };
+    }
+
+    return {
+      updatedService: null,
+      shouldDelete: false,
+      eventType: null,
+      processRevisionData: false,
+      revisionData: null,
+      serviceId,
+    };
+  }
+  if (originalData) {
+    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,
+      processRevisionData: false,
+      revisionData: null,
+      serviceId,
+    };
+  }
+
+  return {
+    updatedService: null,
+    shouldDelete: false,
+    eventType: null,
+    processRevisionData: false,
+    revisionData: null,
+    serviceId,
+  };
+};
+
+/**
+ * Handles failed service operations
+ */
+export const handleServiceOperationError = ({
+  action,
+  entityName,
+  originalData,
+  error,
+  servicesMap,
+  roleMap,
+}: HandleServiceOperationErrorParams): HandleServiceOperationErrorResult => {
+  const serviceId = originalData
+    ? `${originalData.tenant}/${entityName}`
+    : entityName;
+
+  if (action === "CREATE") {
+    return {
+      eventType: "deploymentError",
+      serviceId,
+      shouldResetRoles: false,
+    };
+  }
+
+  if (action === "UPDATE") {
+    return {
+      eventType: "updateError",
+      serviceId,
+      shouldResetRoles: false,
+    };
+  }
+
+  if (action === "DELETE") {
+    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: null,
+    serviceId,
+    shouldResetRoles: false,
+  };
+};
+export const mapChannelsFromApiData = (
+  apiData: any,
+  entityId: string,
+): {
+  serverChannels: Channel[];
+  clientChannels: Channel[];
+  duplexChannels: Channel[];
+} => {
+  const serverChannels: Channel[] = [];
+  const clientChannels: Channel[] = [];
+  const duplexChannels: Channel[] = [];
+  const inboundSuffix = "_inbound.inbound";
+
+  const publicChannelNames = new Set<string>();
+
+  if (apiData.server) {
+    Object.keys(apiData.server).forEach((channelName) => {
+      if (channelName.endsWith(inboundSuffix)) {
+        const baseName = channelName.slice(0, -inboundSuffix.length);
+        if (apiData.server[baseName]) {
+          publicChannelNames.add(baseName);
+        }
+      }
+    });
+  }
+
+  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);
+        }
+      }
+    });
+  }
+
+  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;
+        }
+        serverChannels.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.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 };
+};