@kumori/aurora-backend-handler 1.0.0

package/helpers/environment-helper.ts

@@ -0,0 +1,289 @@
+import { Account, Environment, Notification } from "@hestekumori/aurora-interfaces";
+
+
+
+interface HandleEnvironmentEventParams {
+  entityId: string;
+  eventData: any;
+  parentParts: { [entity: string]: string };
+  accountsMap: Map<string, Account>;
+  environmentsMap: Map<string, Environment>;
+  pendingCloudProviderUpdates: Array<{ environmentId: string; accountId: string }>;
+}
+
+interface HandleEnvironmentEventResult {
+  environment: Environment;
+  pendingCloudProviderUpdate: { environmentId: string; accountId: string } | null;
+  hasTenant: boolean;
+  tenantId: string;
+}
+interface HandleEnvironmentOperationSuccessParams {
+  action: string;
+  entityName: string;
+  originalData: Environment;
+}
+
+interface HandleEnvironmentOperationSuccessResult {
+  updatedEnvironment: Environment | null;
+  shouldDelete: boolean;
+  notification: Notification | null;
+  eventType: "created" | "updated" | "cleaned" | null;
+}
+interface HandleEnvironmentOperationErrorParams {
+  action: string;
+  entityName: string;
+  originalData: Environment;
+  error: any;
+}
+
+interface HandleEnvironmentOperationErrorResult {
+  updatedEnvironment: Environment;
+  notification: Notification;
+  eventType: "creationError" | "updateError" | "deletionError";
+}
+
+/**
+ * Handles the "environment" event from WebSocket messages
+ * Processes environment data updates and cloud provider associations
+ */
+export const handleEnvironmentEvent = ({
+  entityId,
+  eventData,
+  parentParts,
+  accountsMap,
+  environmentsMap,
+  pendingCloudProviderUpdates,
+}: HandleEnvironmentEventParams): HandleEnvironmentEventResult => {
+  const tenantId = parentParts.tenant;
+  const accountId = parentParts.account;
+  const relatedAccount = accountsMap.get(accountId);
+  let cloudProviderName = relatedAccount?.cloudProvider?.name || "";
+
+  let pendingCloudProviderUpdate: { environmentId: string; accountId: string } | null = null;
+
+  if (!relatedAccount) {
+    pendingCloudProviderUpdate = {
+      environmentId: entityId,
+      accountId: accountId,
+    };
+  }
+
+  const existingEnvironment = environmentsMap.get(entityId);
+
+  const newEnvironment: Environment = {
+    id: entityId,
+    name: entityId,
+    account: accountId,
+    tenant: tenantId,
+    logo: "",
+    services: [],
+    domains: [],
+    status: eventData.meta?.deleted
+      ? {
+          code: "DELETING",
+          message: `Environment ${entityId} is being deleted.`,
+          timestamp: new Date().toISOString(),
+        }
+      : {
+          code: eventData.status.state.code,
+          message: eventData.status.state.message,
+          timestamp: eventData.status.state.timestamp,
+        },
+    highAvaliable: eventData.spec.highlyAvailable || false,
+    usage: {
+      current: {
+        cpu: eventData.status.marks.vcpu.current / 1000,
+        memory: eventData.status.marks.memory.current / 1000,
+        storage: eventData.status.marks.storage.current / 1000,
+        volatileStorage: eventData.status.marks.vstorage.current / 1000,
+        nonReplicatedStorage: eventData.status.marks.nrstorage.current / 1000,
+        persistentStorage: eventData.status.marks.rstorage.current / 1000,
+        nodes: eventData.status.nodes.length || 0,
+        memoryConsuption: existingEnvironment?.usage.current.memoryConsuption || [],
+        cpuConsuption: existingEnvironment?.usage.current.cpuConsuption || [],
+      },
+      limit: {
+        cpu: {
+          max: eventData.spec.marks.vcpu.highmark / 1000,
+          min: eventData.spec.marks.vcpu.lowmark / 1000,
+        },
+        memory: {
+          max: eventData.spec.marks.memory.highmark / 1000,
+          min: eventData.spec.marks.memory.lowmark / 1000,
+        },
+        storage: {
+          max: eventData.spec.marks.storage.highmark / 1000,
+          min: eventData.spec.marks.storage.lowmark / 1000,
+        },
+        volatileStorage: {
+          max: eventData.spec.marks.vstorage.highmark / 1000,
+          min: eventData.spec.marks.vstorage.lowmark / 1000,
+        },
+        nonReplicatedStorage: {
+          max: eventData.spec.marks.nrstorage.highmark / 1000,
+          min: eventData.spec.marks.nrstorage.lowmark / 1000,
+        },
+        persistentStorage: {
+          max: eventData.spec.marks.rstorage.highmark / 1000,
+          min: eventData.spec.marks.rstorage.lowmark / 1000,
+        },
+      },
+      cost: eventData.status.marks.cost.current,
+    },
+    organization: "",
+    cloudProvider: cloudProviderName,
+    labels: Object.values(eventData.meta.labels),
+    nodes: {
+      max: eventData.spec.marks.nodes.highmark,
+      min: eventData.status.minimumRequiredNodes?.ingress?.replicas || 0,
+    },
+    type: eventData.spec.type || "primary",
+    cluster: { name: eventData.spec.cluster?.name || "" },
+    isIsolated: eventData.spec.isolated || false,
+  };
+
+  return {
+    environment: newEnvironment,
+    pendingCloudProviderUpdate,
+    hasTenant: false,
+    tenantId,
+  };
+};
+
+/**
+ * Handles successful environment operations (CREATE, UPDATE, DELETE, CLEAN)
+ */
+export const handleEnvironmentOperationSuccess = ({
+  action,
+  entityName,
+  originalData,
+}: HandleEnvironmentOperationSuccessParams): HandleEnvironmentOperationSuccessResult => {
+  const envData = originalData;
+
+  if (action === "DELETE") {
+    return {
+      updatedEnvironment: null,
+      shouldDelete: true,
+      notification: null,
+      eventType: null,
+    };
+  }
+
+  if (action === "CLEAN") {
+    const updatedEnvironment: Environment = {
+      ...envData,
+      status: {
+        code: "CLEANING_ENVIRONMENT",
+        message: `Environment ${envData.name} is being cleaned.`,
+        timestamp: new Date().toISOString(),
+      },
+    };
+
+    const envNotification: Notification = {
+      type: "success",
+      subtype: "environment-cleaned",
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        environment: envData.name,
+        account: envData.account,
+        tenant: envData.tenant,
+      },
+    };
+
+    return {
+      updatedEnvironment,
+      shouldDelete: false,
+      notification: envNotification,
+      eventType: "cleaned",
+    };
+  }
+  if (envData) {
+    const updatedEnvironment: Environment = {
+      ...envData,
+      status: {
+        code: "ENVIRONMENT_READY",
+        message: `Environment ${envData.name} is ready.`,
+        timestamp: new Date().toISOString(),
+      },
+    };
+
+    let eventType: "created" | "updated" | null = null;
+    if (action === "CREATE") {
+      eventType = "created";
+    } else if (action === "UPDATE") {
+      eventType = "updated";
+    }
+
+    return {
+      updatedEnvironment,
+      shouldDelete: false,
+      notification: null,
+      eventType,
+    };
+  }
+
+  return {
+    updatedEnvironment: null,
+    shouldDelete: false,
+    notification: null,
+    eventType: null,
+  };
+};
+/**
+ * Handles failed environment operations (CREATE, UPDATE, DELETE)
+ */
+export const handleEnvironmentOperationError = ({
+  action,
+  entityName,
+  originalData,
+  error,
+}: HandleEnvironmentOperationErrorParams): HandleEnvironmentOperationErrorResult => {
+  let subtype: string;
+  let eventType: "creationError" | "updateError" | "deletionError";
+
+  if (action === "CREATE") {
+    subtype = "environment-creation-error";
+    eventType = "creationError";
+  } else if (action === "UPDATE") {
+    subtype = "environment-update-error";
+    eventType = "updateError";
+  } else {
+    subtype = "environment-deletion-error";
+    eventType = "deletionError";
+  }
+
+  const envErrorNotification: Notification = {
+    type: "error",
+    subtype,
+    date: Date.now().toString(),
+    status: "unread",
+    info_content: {
+      code: error?.error?.code || "UNKNOWN_ERROR",
+      message: error?.error?.content || error?.error?.message || "Unknown error",
+      timestamp: error?.error?.timestamp || "",
+    },
+    callToAction: false,
+    data: {
+      environment: originalData.name,
+      account: originalData.account,
+      tenant: originalData.tenant,
+    },
+  };
+
+  const updatedEnvironment: Environment = {
+    ...originalData,
+    status: {
+      code: "ERROR",
+      message: error?.error?.content || error?.error?.message || "Operation failed",
+      timestamp: new Date().toISOString(),
+    },
+  };
+
+  return {
+    updatedEnvironment,
+    notification: envErrorNotification,
+    eventType,
+  };
+};

package/helpers/link-helper.ts

@@ -0,0 +1,114 @@
+import { Link, Service } from "@hestekumori/aurora-interfaces";
+
+
+interface HandleLinkEventParams {
+  eventData: any;
+  servicesMap: Map<string, Service>;
+}
+
+interface HandleLinkEventResult {
+  linkId: string;
+  clientToServerLink: Link;
+  serverToClientLink: Link;
+  linkServiceServer: string;
+  linkServiceClient: string;
+  updatedServerService: Service | null;
+  updatedClientService: Service | null;
+  serverServiceFound: boolean;
+  clientServiceFound: boolean;
+}
+/**
+ * Handles the "link" event from WebSocket messages
+ * Creates bidirectional links between services
+ */
+export const handleLinkEvent = ({
+  eventData,
+  servicesMap,
+}: HandleLinkEventParams): HandleLinkEventResult => {
+  const linkId = eventData.id.name;
+  const clientService = eventData.spec.client_service;
+  const clientChannel = eventData.spec.client_channel;
+  const serverService = eventData.spec.server_service;
+  const serverChannel = eventData.spec.server_channel;
+  const linkServiceServer = `${eventData.spec.server_tenant}/${serverService}`;
+  const linkServiceClient = `${eventData.spec.client_tenant}/${clientService}`;
+  const clientToServerLink: Link = {
+    name: linkId,
+    origin: clientService,
+    target: serverService,
+    originChannel: clientChannel,
+    targetChannel: serverChannel,
+    client: clientChannel,
+    server: serverChannel,
+  };
+
+  const serverToClientLink: Link = {
+    name: linkId,
+    origin: clientService,
+    target: serverService,
+    originChannel: clientChannel,
+    targetChannel: serverChannel,
+    client: clientChannel,
+    server: serverChannel,
+  };
+  let updatedServerService: Service | null = null;
+  let serverServiceFound = false;
+
+  const serverServiceObj = servicesMap.get(linkServiceServer);
+  if (serverServiceObj) {
+    serverServiceFound = true;
+    const existingLinkIndex = serverServiceObj.links.findIndex(
+      (link) =>
+        link.name === clientToServerLink.name &&
+        link.origin === clientToServerLink.origin &&
+        link.target === clientToServerLink.target
+    );
+
+    if (existingLinkIndex !== -1) {
+      serverServiceObj.links[existingLinkIndex] = clientToServerLink;
+    } else {
+      serverServiceObj.links.push(clientToServerLink);
+    }
+    updatedServerService = serverServiceObj;
+  } else {
+    console.warn(
+      `Client service ${linkServiceServer} not found when processing link event`
+    );
+  }
+  let updatedClientService: Service | null = null;
+  let clientServiceFound = false;
+
+  const clientServiceObj = servicesMap.get(linkServiceClient);
+  if (clientServiceObj) {
+    clientServiceFound = true;
+    const existingLinkIndex = clientServiceObj.links.findIndex(
+      (link) =>
+        link.name === serverToClientLink.name &&
+        link.origin === serverToClientLink.origin &&
+        link.target === serverToClientLink.target
+    );
+
+    if (existingLinkIndex !== -1) {
+      clientServiceObj.links[existingLinkIndex] = serverToClientLink;
+    } else {
+      clientServiceObj.links.push(serverToClientLink);
+    }
+    updatedClientService = clientServiceObj;
+  } else {
+    console.warn(
+      `Server service ${linkServiceClient} not found when processing link event`
+    );
+  }
+
+  return {
+    linkId,
+    clientToServerLink,
+    serverToClientLink,
+    linkServiceServer,
+    linkServiceClient,
+    updatedServerService,
+    updatedClientService,
+    serverServiceFound,
+    clientServiceFound,
+  };
+};

package/helpers/plan-helper.ts

@@ -0,0 +1,104 @@
+import { Plan, UserData } from "@hestekumori/aurora-interfaces";
+
+
+interface HandlePlanInstanceEventParams {
+  entityId: string;
+  eventData: any;
+  parentParts: { [entity: string]: string };
+}
+
+interface HandlePlanInstanceEventResult {
+  plan: Plan;
+  planKey: string;
+}
+interface UpdateUserPlansParams {
+  newPlan: Plan;
+  userData: UserData;
+  userId: string;
+}
+
+interface UpdateUserPlansResult {
+  shouldUpdate: boolean;
+  updatedPlans: Plan[];
+}
+
+/**
+ * Handles the "planinstance" event from WebSocket messages
+ * Processes plan data and builds the Plan object
+ */
+export const handlePlanInstanceEvent = ({
+  entityId,
+  eventData,
+  parentParts,
+}: HandlePlanInstanceEventParams): HandlePlanInstanceEventResult => {
+  const planProvider = parentParts.planprovider;
+  const planKey = `${planProvider}/${entityId}`;
+
+  const newPlan: Plan = {
+    name: entityId,
+    provider: planProvider,
+    alias: eventData.spec.alias || "",
+    lastCheck: eventData.spec.lastCheck
+      ? eventData.spec.lastCheck.toString()
+      : "",
+    tenants: eventData.status.tenants
+      ? Object.keys(eventData.status.tenants)
+      : [],
+    quarantine: eventData.spec.quarantine || false,
+    owner: eventData.spec.owner || "",
+    limits: eventData.spec.limits
+      ? {
+          cpu: eventData.spec.limits.vcpu || 0,
+          memory: eventData.spec.limits.memory || 0,
+          instances: eventData.spec.limits.instances || 0,
+          deployments: eventData.spec.limits.deployments || 0,
+          tenants: eventData.spec.limits.tenants || 0,
+          accounts: eventData.spec.limits.accounts || 0,
+          clusters: eventData.spec.limits.clusters || 0,
+          nrstorage: eventData.spec.limits.nrstorage || 0,
+          rstorage: eventData.spec.limits.rstorage || 0,
+          vstorage: eventData.spec.limits.vstorage || 0,
+          storage: eventData.spec.limits.storage || 0,
+        }
+      : undefined,
+    type: eventData.spec.type || "",
+  };
+
+  return {
+    plan: newPlan,
+    planKey,
+  };
+};
+
+/**
+ * Updates user plans after a plan event
+ * Only updates if the user is the owner of the plan
+ */
+export const updateUserPlansAfterPlanEvent = ({
+  newPlan,
+  userData,
+  userId,
+}: UpdateUserPlansParams): UpdateUserPlansResult => {
+  if (newPlan.owner !== userId) {
+    return {
+      shouldUpdate: false,
+      updatedPlans: userData.plans || [],
+    };
+  }
+
+  const updatedPlans = userData.plans || [];
+  const existingIndex = updatedPlans.findIndex(
+    (plan) => plan.name === newPlan.name && plan.provider === newPlan.provider
+  );
+
+  if (existingIndex !== -1) {
+    updatedPlans[existingIndex] = newPlan;
+  } else {
+    updatedPlans.push(newPlan);
+  }
+
+  return {
+    shouldUpdate: true,
+    updatedPlans,
+  };
+};

package/helpers/registry-helper.ts

@@ -0,0 +1,134 @@
+
+import { Registry, Tenant } from "@hestekumori/aurora-interfaces";
+import { decodeRegistryAuth } from "../utils/utils";
+
+
+interface HandleRegistryEventParams {
+  eventData: any;
+  parentParts: { [entity: string]: string };
+  tenantsMap: Map<string, Tenant>;
+  secretsMap: Map<string, any>;
+}
+
+interface HandleRegistryEventResult {
+  registry: Registry;
+  tenantId: string;
+  tenantFound: boolean;
+  updatedTenant: Tenant | null;
+  pendingRegistry: { tenant: string; registry: Registry } | null;
+}
+/**
+ * Extract registry credentials from secrets map
+ */
+const extractRegistryCredentials = (
+  tenantId: string,
+  secretName: string,
+  secretsMap: Map<string, any>
+): { username: string; password: string } => {
+  let username = "";
+  let password = "";
+
+  const secretKey = `${tenantId}/${secretName}`;
+  const credentialsKey = `${secretKey}_credentials`;
+  const savedCredentials = secretsMap.get(credentialsKey);
+  if (savedCredentials) {
+    username = savedCredentials.secretUsername;
+    password = savedCredentials.secretPassword;
+  } else {
+    const secretData = secretsMap.get(secretKey);
+    if (secretData) {
+      try {
+        const parsedSecret = JSON.parse(secretData);
+        if (parsedSecret.auths) {
+          const registryUrl = Object.keys(parsedSecret.auths)[0];
+          if (registryUrl && parsedSecret.auths[registryUrl].auth) {
+            const credentials = decodeRegistryAuth(
+              parsedSecret.auths[registryUrl].auth
+            );
+            username = credentials.username;
+            password = credentials.password;
+          }
+        }
+      } catch (error) {
+        console.error("Error parsing registry secret in dregistry:", error);
+      }
+    } else {
+      console.warn("Secret not found for registry:", {
+        registryName: secretName,
+        secretKey,
+        availableSecrets: Array.from(secretsMap.keys()),
+      });
+    }
+  }
+
+  return { username, password };
+};
+
+/**
+ * Handles the "dregistry" event from WebSocket messages
+ * Processes registry data and credentials
+ */
+export const handleRegistryEvent = ({
+  eventData,
+  parentParts,
+  tenantsMap,
+  secretsMap,
+}: HandleRegistryEventParams): HandleRegistryEventResult => {
+  const tenantId = parentParts.tenant;
+  const registryName = eventData.id?.name;
+  let username = "";
+  let password = "";
+
+  if (eventData.status?.secret?.name) {
+    const credentials = extractRegistryCredentials(
+      tenantId,
+      eventData.status.secret.name,
+      secretsMap
+    );
+    username = credentials.username;
+    password = credentials.password;
+  }
+  const newRegistry: Registry = {
+    name: registryName,
+    domain: eventData.spec.registry || "",
+    public: true,
+    credentials: username,
+    password: password,
+    description: `Registry for ${registryName}`,
+    extra: eventData.meta.labels.logo || "",
+  };
+  const tenant = tenantsMap.get(tenantId);
+  let tenantFound = false;
+  let updatedTenant: Tenant | null = null;
+  let pendingRegistry: { tenant: string; registry: Registry } | null = null;
+
+  if (tenant) {
+    tenantFound = true;
+    const existingIndex = tenant.registry.findIndex(
+      (reg) => reg.domain === registryName
+    );
+
+    if (existingIndex !== -1) {
+      tenant.registry[existingIndex] = newRegistry;
+    } else {
+      tenant.registry.push(newRegistry);
+    }
+    updatedTenant = tenant;
+  } else {
+    pendingRegistry = {
+      tenant: tenantId,
+      registry: newRegistry,
+    };
+    console.warn(
+      `Registry orphaned for tenant ${tenantId}, added to pending registries.`
+    );
+  }
+
+  return {
+    registry: newRegistry,
+    tenantId,
+    tenantFound,
+    updatedTenant,
+    pendingRegistry,
+  };
+};