@kumori/aurora-backend-handler 1.0.0

package/event-names.ts

@@ -0,0 +1,152 @@
+export enum EventNames {
+	// * Tenant
+	CreateTenant = "createTenant",
+	TenantCreated = "tenantCreated",
+	TenantCreationError = "tenantCreationError",
+	UpdateTenant = "updateTenant",
+	TenantUpdated = "tenantUpdated",
+	TenantUpdateError = "tenantUpdateError",
+	DeleteTenant = "deleteTenant",
+	TenantDeleted = "tenantDeleted",
+	TenantDeletionError = "tenantDeletionError",
+	CreateRegistry = "createRegistry",
+	RegistryCreated = "registryCreated",
+	RegistryCreationError = "registryCreationError",
+	UpdateRegistry = "updateRegistry",
+	RegistryUpdated = "registryUpdated",
+	RegistryUpdateError = "registryUpdateError",
+	DeleteRegistry = "deleteRegistry",
+	RegistryDeleted = "registryDeleted",
+	RegistryDeletionError = "registryDeletionError",
+	InviteUser = "inviteUser",
+	UserInvited = "tenantInvited",
+	UserInviteError = "tenantInviteError",
+	RemoveUserFromTenant = "removeUserFromTenant",
+	UserRemovedFromTenant = "userRemovedFromTenant",
+	UserRemovalFromTenantError = "userRemovalFromTenantError",
+	AcceptInvite = "acceptInvite",
+	InviteAccepted = "inviteAccepted",
+	InviteAcceptError = "inviteAcceptError",
+	UpdateInvite = "updateInvite",
+	InviteUpdated = "inviteUpdated",
+	InviteUpdateError = "inviteUpdateError",
+	RejectInvite = "rejectInvite",
+	InviteRejected = "inviteRejected",
+	InviteRejectError = "inviteRejectError",
+	CreateToken = "createToken",
+	TokenCreated = "tokenCreated",
+	TokenCreationError = "tokenCreationError",
+	DeleteToken = "deleteToken",
+	TokenDeleted = "tokenDeleted",
+	TokenDeletionError = "tokenDeletionError",
+
+	// * User
+	CreateUser = "createUser",
+	UserCreated = "userCreated",
+	UserCreationError = "userCreationError",
+	UpdateUser = "updateUser",
+	UserUpdated = "userUpdated",
+	UserUpdateError = "userUpdateError",
+	LoadUser = "loadUser",
+	UserLoaded = "userLoaded",
+	UserLoadError = "userLoadError",
+	DeleteUser = "deleteUser",
+	UserDeleted = "userDeleted",
+	UserDeletionError = "userDeletionError",
+	AuthError = "authError",
+	// * Account
+	CreateAccount = "createAccount",
+	AccountCreated = "accountCreated",
+	AccountCreationError = "accountCreationError",
+	UpdateAccount = "updateAccount",
+	AccountUpdated = "accountUpdated",
+	AccountUpdateError = "accountUpdateError",
+	DeleteAccount = "deleteAccount",
+	AccountDeleted = "accountDeleted",
+	AccountDeletionError = "accountDeletionError",
+	CleanAccount = "cleanAccount",
+	AccountCleaned = "accountCleaned",
+	AccountCleanError = "accountCleanError",
+	// * Environment
+	CreateEnvironment = "createEnvironment",
+	EnvironmentCreated = "environmentCreated",
+	EnvironmentCreationError = "environmentCreationError",
+	UpdateEnvironment = "updateEnvironment",
+	EnvironmentUpdated = "environmentUpdated",
+	EnvironmentUpdateError = "environmentUpdateError",
+	DeleteEnvironment = "deleteEnvironment",
+	EnvironmentDeleted = "environmentDeleted",
+	EvironmentDeletionError = "environmentDeletionError",
+	CleanEnvironment = "cleanEnvironment",
+	EnvironmentCleaned = "environmentCleaned",
+	EnvironmentCleanError = "environmentCleanError",
+	ScaleEnvironment = "scaleEnvironmet",
+	EnvironmentScaled = "environmentScaled",
+	EnvironmentScaleError = "environmentScaleError",
+	// * Service
+	DeployService = "deployService",
+	ServiceDeployed = "serviceDeployed",
+	ServiceDeploymentError = "deploymentError",
+	UpdateService = "updateService",
+	ServiceUpdated = "serviceUpdated",
+	ServiceUpdateError = "serviceUpdateError",
+	DeleteService = "deleteService",
+	ServiceDeleted = "serviceDeleted",
+	ServiceDeletionError = "serviceDeletionError",
+	RequestLogs = "requestLogs",
+	RestartService = "restartService",
+	ServiceRestarted = "serviceRestarted",
+	ServiceRestartError = "serviceRestartError",
+	RequestRevisionData = "requestRevisionData",
+	updateServiceLinks = "updateServiceLinks",
+	ChangeRevision = "changeRevision",
+	RevisionChanged = "revisionChanged",
+	RevisionChangeError = "revisionChangeError",
+	// * Marketplace
+	DeployMarketplaceItem = "deployMarketplaceItem",
+	MarketplaceItemDeployed = "marketplaceItemDeployed",
+	MarketplaceItemDeploymentError = "marketplaceItemDeploymentError",
+	UpdateMarketplaceItem = "updateMarketplaceItem",
+	MarketplaceItemUpdated = "marketplaceItemUpdated",
+	MarketplaceItemUpdateError = "marketplaceItemUpdateError",
+	DeleteMarketplaceItem = "deleteMarketplaceItem",
+	MarketplaceItemDeleted = "marketplaceItemDeleted",
+	MarketplaceItemDeletionError = "marketplaceItemDeletionError",
+	LoadMarketplaceItems = "loadMarketplaceItems",
+	MarketplaceItemsLoaded = "marketplaceItemsLoaded",
+	// * Resource
+	CreateResource = "createResource",
+	ResourceCreated = "resourceCreated",
+	ResourceCreationError = "resourceCreationError",
+	UpdateResource = "updateResource",
+	ResourceUpdated = "resourceUpdated",
+	ResourceUpdateError = "resourceUpdateError",
+	DeleteResource = "deleteResource",
+	ResourceDeleted = "resourceDeleted",
+	ResourceDeletionError = "resourceDeletionError",
+	// * Plan
+	UpdatePlan = "updatePlan",
+	PlanUpdated = "planUpdated",
+	PlanUpdateError = "planUpdateError",
+	DowngradePlan = "downgradePlan",
+	PlanDowngraded = "planDowngraded",
+	PlanDowngradeError = "planDowngradeError",
+	// * Organizations
+	CreateOrganization = "createOrganization",
+	OrganizationCreated = "organizationCreated",
+	OrganizationCreationError = "organizationCreationError",
+	UpdateOrganization = "updateOrganization",
+	OrganizationUpdated = "organizationUpdated",
+	OrganizationUpdateError = "organizationUpdateError",
+	DeleteOrganization = "deleteOrganization",
+	OrganizationDeleted = "organizationDeleted",
+	OrganizationDeletionError = "organizationDeletionError",
+	// * Notificaitons
+	CreateNotification = "createNotification",
+	DeleteNotification = "deleteNotification",
+	NotificationRead = "notificationRead",
+	// * Plan providers
+	LoadPlanProviders = "loadPlanProviders",
+	PlanProvidersLoaded = "planProvidersLoaded",
+	PlanProvidersLoadError = "planProvidersLoadError"
+}

package/helpers/account-helper.ts

@@ -0,0 +1,331 @@
+import { Account, Notification } from "@hestekumori/aurora-interfaces";
+
+
+interface HandleAccountEventParams {
+  entityId: string;
+  eventData: any;
+  parentParts: { [entity: string]: string };
+  accountsMap: Map<string, Account>;
+}
+
+interface HandleAccountEventResult {
+  account: Account;
+  isDeleted: boolean;
+}
+interface HandleAccountOperationSuccessParams {
+  action: string;
+  entityName: string;
+  originalData: Account;
+}
+
+interface HandleAccountOperationSuccessResult {
+  updatedAccount: Account | null;
+  shouldDelete: boolean;
+  notification: Notification;
+  eventType: "created" | "updated" | "deleted" | null;
+}
+
+interface HandleAccountOperationErrorParams {
+  action: string;
+  entityName: string;
+  originalData: any;
+  error: any;
+}
+
+interface HandleAccountOperationErrorResult {
+  updatedAccount: Account | null;
+  shouldDelete: boolean;
+  notification: Notification;
+  eventType: "creationError" | "updateError" | "deletionError";
+}
+/**
+ * Extract cloud provider credentials from event data
+ */
+const extractCloudProviderCredentials = (
+  eventData: any
+): { providerType: string; credentials: any } => {
+  let providerType = "";
+  let credentials = {};
+
+  if (eventData.spec.credentials.openstack) {
+    providerType = "ovh";
+    credentials = {
+      region: eventData.spec.credentials.openstack?.region_name || "",
+      interface: eventData.spec.credentials.openstack?.interface || "",
+      apiVersion: eventData.spec.credentials.openstack?.identity_api_version || "",
+      authType: eventData.spec.credentials.openstack?.auth_type || "",
+      authUrl: eventData.spec.credentials.openstack?.auth?.auth_url || "",
+      credentialId:
+        eventData.spec.credentials.openstack?.auth?.application_credential_id || "",
+      credentialSecret:
+        eventData.spec.credentials.openstack?.auth?.application_credential_secret || "",
+    };
+  } else if (eventData.spec.credentials.aws) {
+    providerType = "aws";
+    credentials = {
+      region: eventData.spec.credentials.aws?.region || "",
+      credentialId: eventData.spec.credentials.aws?.aws_access_key_id || "",
+      credentialSecret: eventData.spec.credentials.aws?.aws_secret_access_key || "",
+    };
+  } else if (eventData.spec.credentials.azure) {
+    providerType = "azure";
+    credentials = {
+      region: eventData.spec.credentials.azure?.region || "",
+      subscriptionId: eventData.spec.credentials.azure?.subscription_id || "",
+      tenantId: eventData.spec.credentials.azure?.tenant_id || "",
+      clientId: eventData.spec.credentials.azure?.client_id || "",
+      clientSecret: eventData.spec.credentials.azure?.client_secret || "",
+    };
+  }
+
+  return { providerType, credentials };
+};
+
+/**
+ * Determine account status from event data
+ */
+const determineAccountStatus = (
+  eventData: any,
+  existingAccount: Account | undefined
+): string => {
+  if (eventData.meta?.deleted) {
+    return "deleting";
+  }
+  if (eventData.status.validCredentials?.status) {
+    return eventData.status.validCredentials.status;
+  }
+  if (existingAccount?.status) {
+    return existingAccount.status;
+  }
+  return "pending";
+};
+
+
+/**
+ * Handles the "account" event from WebSocket messages
+ * Processes account data updates and cloud provider credentials
+ */
+export const handleAccountEvent = ({
+  entityId,
+  eventData,
+  parentParts,
+  accountsMap,
+}: HandleAccountEventParams): HandleAccountEventResult => {
+  const accountTenantId = parentParts.tenant;
+  const { providerType, credentials } = extractCloudProviderCredentials(eventData);
+  const accountLabels: Record<string, string> = eventData.meta.labels;
+  const hasCredentials = "__axebow::managedCredentials" in accountLabels;
+  const existingAccount = accountsMap.get(entityId);
+  const accountStatus = determineAccountStatus(eventData, existingAccount);
+  const newAccount: Account = {
+    id: entityId,
+    name: entityId,
+    tenant: accountTenantId,
+    cloudProvider: {
+      name: eventData.spec.api,
+      ...credentials,
+    },
+    logo: "",
+    environments: [],
+    services: [],
+    domains: [],
+    status: accountStatus,
+    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,
+        cpuConsuption: existingAccount?.usage.current.cpuConsuption || [],
+        memoryConsuption: existingAccount?.usage.current.memoryConsuption || [],
+      },
+      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: 0,
+    },
+    flavors: {
+      small: [eventData.spec.iaasconfig.smallVMFlavor || ""],
+      medium: [eventData.spec.iaasconfig.mediumVMFlavor || ""],
+      large: [eventData.spec.iaasconfig.largeVMFlavor || ""],
+      volatile: [eventData.spec.iaasconfig.volatile || ""],
+      nonReplicated: [eventData.spec.iaasconfig.nonreplicated || ""],
+      persistent: [eventData.spec.iaasconfig.persistent || ""],
+    },
+    organization: "",
+    nodes: {
+      max: eventData.spec.marks.nodes.highmark,
+      min: 0,
+    },
+    credentials: hasCredentials,
+  };
+
+  return {
+    account: newAccount,
+    isDeleted: false,
+  };
+};
+
+
+/**
+ * Handles successful account operations (CREATE, UPDATE, DELETE)
+ */
+export const handleAccountOperationSuccess = ({
+  action,
+  entityName,
+  originalData,
+}: HandleAccountOperationSuccessParams): HandleAccountOperationSuccessResult => {
+  if (action === "DELETE") {
+    const accountNotification: Notification = {
+      type: "success",
+      subtype: "account-deleted",
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        account: originalData.name,
+        tenant: originalData.tenant,
+      },
+    };
+
+    return {
+      updatedAccount: null,
+      shouldDelete: true,
+      notification: accountNotification,
+      eventType: "deleted",
+    };
+  }
+
+  if (originalData) {
+    const updatedAccount = { ...originalData, status: "active" };
+
+    let subtype: string;
+    let eventType: "created" | "updated" | null = null;
+
+    if (action === "CREATE") {
+      subtype = "account-created";
+      eventType = "created";
+    } else {
+      subtype = "account-updated";
+      eventType = "updated";
+    }
+
+    const accountNotification: Notification = {
+      type: "success",
+      subtype,
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        account: updatedAccount.name,
+        tenant: updatedAccount.tenant,
+      },
+    };
+
+    return {
+      updatedAccount,
+      shouldDelete: false,
+      notification: accountNotification,
+      eventType,
+    };
+  }
+
+  return {
+    updatedAccount: null,
+    shouldDelete: false,
+    notification: {
+      type: "success",
+      subtype: "account-unknown",
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {},
+    },
+    eventType: null,
+  };
+};
+
+
+/**
+ * Handles failed account operations (CREATE, UPDATE, DELETE)
+ */
+export const handleAccountOperationError = ({
+  action,
+  entityName,
+  originalData,
+  error,
+}: HandleAccountOperationErrorParams): HandleAccountOperationErrorResult => {
+  let subtype: string;
+  let eventType: "creationError" | "updateError" | "deletionError";
+  let shouldDelete = false;
+
+  if (action === "CREATE") {
+    subtype = "account-creation-error";
+    eventType = "creationError";
+    shouldDelete = true;
+  } else if (action === "UPDATE") {
+    subtype = "account-update-error";
+    eventType = "updateError";
+  } else {
+    subtype = "account-deletion-error";
+    eventType = "deletionError";
+  }
+
+  const accountErrorNotification: 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 || Date.now().toString(),
+    },
+    callToAction: false,
+    data: {
+      account: entityName || originalData?.name || originalData?.account || "unknown",
+      tenant: originalData?.tenant || "unknown",
+    },
+  };
+
+  let updatedAccount: Account | null = null;
+
+  if (!shouldDelete && originalData) {
+    updatedAccount = {
+      ...originalData,
+      status: "error",
+    };
+  }
+
+  return {
+    updatedAccount,
+    shouldDelete,
+    notification: accountErrorNotification,
+    eventType,
+  };
+};