@kumori/aurora-backend-handler 1.0.0

package/api/resources-api-service.ts

@@ -0,0 +1,821 @@
+import { Notification, Resource } from "@hestekumori/aurora-interfaces";
+import { eventHelper } from "../backend-handler";
+
+import {
+  initializeGlobalWebSocketClient,
+  getWebSocketStatus,
+  makeGlobalWebSocketRequest,
+} from "../websocket-manager";
+
+const createResourceBody = (
+  tenant: string,
+  resource: Resource,
+  kind: string,
+  data: any
+) => ({
+  tenant,
+  resource: resource.name,
+  kind,
+  spec: {
+    kind,
+    data,
+  },
+});
+
+export const createDomain = async (
+  tenant: string,
+  domain: Resource,
+  security: string
+) => {
+  try {
+    await initializeGlobalWebSocketClient(security);
+    const status = getWebSocketStatus();
+
+    const domainBody = createResourceBody(tenant, domain, "domain", {
+      domain: domain.value,
+    });
+
+    const response = await makeGlobalWebSocketRequest(
+      "resource:create_resource",
+      domainBody,
+      30000,
+      "CREATE",
+      domain.name
+    );
+
+    // eventHelper.resource.publish.created(domain);
+    const resourceNotification: Notification = {
+      type: "success",
+      subtype: "resource-created",
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        resource: domain.name,
+        tenant: tenant
+      }
+    };
+    eventHelper.notification.publish.creation(resourceNotification);
+    return response;
+  } catch (error) {
+    console.error("Error creating domain:", {
+      error,
+      tenant,
+      domain,
+      webSocketStatus: getWebSocketStatus(),
+    });
+    let contentMessage = "Unknown error";
+    let errorContent = "Unknown error";
+
+    if (
+      typeof error === "object" &&
+      error !== null &&
+      "error" in error &&
+      typeof (error as any).error === "object" &&
+      (error as any).error !== null
+    ) {
+      if ("code" in (error as any).error) {
+        contentMessage = (error as any).error.code;
+      }
+      if ("content" in (error as any).error) {
+        errorContent = (error as any).error.content;
+      }
+    }
+    const resourceErrorNotification: Notification = {
+      type: "error",
+      subtype: "resource-creation-error",
+      info_content: {
+        code: contentMessage,
+        message: errorContent,
+      },
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        resource: domain.name,
+        tenant: tenant
+      }
+    };
+    eventHelper.notification.publish.creation(resourceErrorNotification);
+    throw error;
+  }
+};
+
+export const createPort = async (
+  tenant: string,
+  port: Resource,
+  security: string
+) => {
+  try {
+    await initializeGlobalWebSocketClient(security);
+    const status = getWebSocketStatus();
+
+    const portBody = createResourceBody(tenant, port, "port", {
+      port: Number(port.value),
+    });
+
+    const response = await makeGlobalWebSocketRequest(
+      "resource:create_resource",
+      portBody,
+      30000,
+      "CREATE",
+      port.name
+    );
+
+    eventHelper.resource.publish.created(port);
+    const resourceNotification: Notification = {
+      type: "success",
+      subtype: "resource-created",
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        resource: port.name,
+        tenant: tenant
+      }
+    };
+    eventHelper.notification.publish.creation(resourceNotification);
+    return response;
+  } catch (error) {
+    console.error("Error creating port:", {
+      error,
+      tenant,
+      port,
+      webSocketStatus: getWebSocketStatus(),
+    });
+    let contentMessage = "Unknown error";
+    let errorContent = "Unknown error";
+
+    if (
+      typeof error === "object" &&
+      error !== null &&
+      "error" in error &&
+      typeof (error as any).error === "object" &&
+      (error as any).error !== null
+    ) {
+      if ("code" in (error as any).error) {
+        contentMessage = (error as any).error.code;
+      }
+      if ("content" in (error as any).error) {
+        errorContent = (error as any).error.content;
+      }
+    }
+    const resourceErrorNotification: Notification = {
+      type: "error",
+      subtype: "resource-creation-error",
+      info_content: {
+        code: contentMessage,
+        message: errorContent,
+      },
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        resource: port.name,
+        tenant: tenant
+      }
+    };
+    eventHelper.notification.publish.creation(resourceErrorNotification);
+    throw error;
+  }
+};
+
+export const createCA = async (
+  tenant: string,
+  ca: Resource,
+  security: string
+) => {
+  try {
+    await initializeGlobalWebSocketClient(security);
+    const status = getWebSocketStatus();
+
+    const caBody = createResourceBody(tenant, ca, "ca", {
+      ca: ca.value,
+    });
+
+    const response = await makeGlobalWebSocketRequest(
+      "resource:create_resource",
+      caBody,
+      30000,
+      "CREATE",
+      ca.name
+    );
+
+    eventHelper.resource.publish.created(ca);
+    const resourceNotification: Notification = {
+      type: "success",
+      subtype: "resource-created",
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        resource: ca.name,
+        tenant: tenant
+      }
+    };
+    eventHelper.notification.publish.creation(resourceNotification);
+    return response;
+  } catch (error) {
+    console.error("Error creating CA:", {
+      error,
+      tenant,
+      ca,
+      webSocketStatus: getWebSocketStatus(),
+    });
+    let contentMessage = "Unknown error";
+    let errorContent = "Unknown error";
+
+    if (
+      typeof error === "object" &&
+      error !== null &&
+      "error" in error &&
+      typeof (error as any).error === "object" &&
+      (error as any).error !== null
+    ) {
+      if ("code" in (error as any).error) {
+        contentMessage = (error as any).error.code;
+      }
+      if ("content" in (error as any).error) {
+        errorContent = (error as any).error.content;
+      }
+    }
+    const resourceErrorNotification: Notification = {
+      type: "error",
+      subtype: "resource-creation-error",
+      info_content: {
+        code: contentMessage,
+        message: errorContent,
+      },
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        resource: ca.name,
+        tenant: tenant
+      }
+    };
+    eventHelper.notification.publish.creation(resourceErrorNotification);
+    throw error;
+  }
+};
+
+export const createCertificate = async (
+  tenant: string,
+  certificate: Resource,
+  security: string
+) => {
+  try {
+    await initializeGlobalWebSocketClient(security);
+    const status = getWebSocketStatus();
+
+    if (!certificate.key || !certificate.domain) {
+      throw new Error("Certificate requires both key and domain properties");
+    }
+
+    const certificateBody = createResourceBody(
+      tenant,
+      certificate,
+      "certificate",
+      {
+        certificate: {
+          cert: certificate.value,
+          key: certificate.key,
+          domain: certificate.domain,
+        },
+      }
+    );
+
+    const response = await makeGlobalWebSocketRequest(
+      "resource:create_resource",
+      certificateBody,
+      30000,
+      "CREATE",
+      certificate.name
+    );
+
+    eventHelper.resource.publish.created(certificate);
+    const resourceNotification: Notification = {
+      type: "success",
+      subtype: "resource-created",
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        resource: certificate.name,
+        tenant: tenant
+      }
+    };
+    eventHelper.notification.publish.creation(resourceNotification);
+    return response;
+  } catch (error) {
+    console.error("Error creating certificate:", {
+      error,
+      tenant,
+      certificate,
+      webSocketStatus: getWebSocketStatus(),
+    });
+    let contentMessage = "Unknown error";
+    let errorContent = "Unknown error";
+
+    if (
+      typeof error === "object" &&
+      error !== null &&
+      "error" in error &&
+      typeof (error as any).error === "object" &&
+      (error as any).error !== null
+    ) {
+      if ("code" in (error as any).error) {
+        contentMessage = (error as any).error.code;
+      }
+      if ("content" in (error as any).error) {
+        errorContent = (error as any).error.content;
+      }
+    }
+    const resourceErrorNotification: Notification = {
+      type: "error",
+      subtype: "resource-creation-error",
+      info_content: {
+        code: contentMessage,
+        message: errorContent,
+      },
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        resource: certificate.name,
+        tenant: tenant
+      }
+    };
+    eventHelper.notification.publish.creation(resourceErrorNotification);
+    throw error;
+  }
+};
+
+export const createSecret = async (
+  tenant: string,
+  secret: Resource,
+  security: string
+) => {
+  try {
+    await initializeGlobalWebSocketClient(security);
+    const status = getWebSocketStatus();
+
+    const secretBody = createResourceBody(tenant, secret, "secret", {
+      secret: secret.value,
+    });
+
+    const response = await makeGlobalWebSocketRequest(
+      "resource:create_resource",
+      secretBody,
+      30000,
+      "CREATE",
+      secret.name
+    );
+
+    eventHelper.resource.publish.created(secret);
+    const resourceNotification: Notification = {
+      type: "success",
+      subtype: "resource-created",
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        resource: secret.name,
+        tenant: tenant
+      }
+    };
+    eventHelper.notification.publish.creation(resourceNotification);
+    return response;
+  } catch (error) {
+    console.error("Error creating secret:", {
+      error,
+      tenant,
+      secret,
+      webSocketStatus: getWebSocketStatus(),
+    });
+    let contentMessage = "Unknown error";
+    let errorContent = "Unknown error";
+
+    if (
+      typeof error === "object" &&
+      error !== null &&
+      "error" in error &&
+      typeof (error as any).error === "object" &&
+      (error as any).error !== null
+    ) {
+      if ("code" in (error as any).error) {
+        contentMessage = (error as any).error.code;
+      }
+      if ("content" in (error as any).error) {
+        errorContent = (error as any).error.content;
+      }
+    }
+    const resourceErrorNotification: Notification = {
+      type: "error",
+      subtype: "resource-creation-error",
+      info_content: {
+        code: contentMessage,
+        message: errorContent,
+      },
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        resource: secret.name,
+        tenant: tenant
+      }
+    };
+    eventHelper.notification.publish.creation(resourceErrorNotification);
+    throw error;
+  }
+};
+
+export const createVolume = async (
+  tenant: string,
+  volume: Resource,
+  security: string
+) => {
+  try {
+    await initializeGlobalWebSocketClient(security);
+    const status = getWebSocketStatus();
+
+    let volumeKind: "persistent" | "nonreplicated" | "shared" = "persistent";
+    if (volume.kind === "nonReplicated") {
+      volumeKind = "nonreplicated";
+    } else if (volume.kind === "volatile") {
+      volumeKind = "persistent";
+    }
+
+    const volumeData: any = {
+      volume: {
+        kind: volumeKind,
+        size: Number(volume.value),
+      },
+    };
+
+    if (volume.maxItems !== undefined) {
+      volumeData.volume.maxitems = volume.maxItems;
+    }
+
+    // if (volumeKind === "persistent") {
+    //   volumeData.volume.options = {};
+    // }
+
+    const volumeBody = createResourceBody(tenant, volume, "volume", volumeData);
+
+    const response = await makeGlobalWebSocketRequest(
+      "resource:create_resource",
+      volumeBody,
+      30000,
+      "CREATE",
+      volume.name
+    );
+
+    eventHelper.resource.publish.created(volume);
+    const resourceNotification: Notification = {
+      type: "success",
+      subtype: "resource-created",
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        resource: volume.name,
+        tenant: tenant
+      }
+    };
+    eventHelper.notification.publish.creation(resourceNotification);
+    return response;
+  } catch (error) {
+    console.error("Error creating volume:", {
+      error,
+      tenant,
+      volume,
+      webSocketStatus: getWebSocketStatus(),
+    });
+    let contentMessage = "Unknown error";
+    let errorContent = "Unknown error";
+
+    if (
+      typeof error === "object" &&
+      error !== null &&
+      "error" in error &&
+      typeof (error as any).error === "object" &&
+      (error as any).error !== null
+    ) {
+      if ("code" in (error as any).error) {
+        contentMessage = (error as any).error.code;
+      }
+      if ("content" in (error as any).error) {
+        errorContent = (error as any).error.content;
+      }
+    }
+    const resourceErrorNotification: Notification = {
+      type: "error",
+      subtype: "resource-creation-error",
+      info_content: {
+        code: contentMessage,
+        message: errorContent,
+      },
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        resource: volume.name,
+        tenant: tenant
+      }
+    };
+    eventHelper.notification.publish.creation(resourceErrorNotification);
+    throw error;
+  }
+};
+
+export const createResource = async (
+  tenant: string,
+  resource: Resource,
+  security: string
+) => {
+  switch (resource.type) {
+    case "domain":
+      return createDomain(tenant, resource, security);
+    case "port":
+      return createPort(tenant, resource, security);
+    case "ca":
+      return createCA(tenant, resource, security);
+    case "certificate":
+      return createCertificate(tenant, resource, security);
+    case "secret":
+      return createSecret(tenant, resource, security);
+    case "volume":
+      return createVolume(tenant, resource, security);
+    default:
+      throw new Error(`Unsupported resource type: ${resource.type}`);
+  }
+};
+
+const deleteResourceBody = (
+  tenant: string,
+  resource: Resource,
+  kind: string
+) => ({
+  tenant,
+  resource: resource.name,
+  kind,
+});
+
+const deleteResourceBase = async (
+  tenant: string,
+  resource: Resource,
+  kind: string,
+  security: string
+) => {
+  try {
+    await initializeGlobalWebSocketClient(security);
+    const body = deleteResourceBody(tenant, resource, kind);
+
+    const response = await makeGlobalWebSocketRequest(
+      "resource:delete_resource",
+      body,
+      30000,
+      "DELETE",
+      resource.name
+    );
+
+    //eventHelper.resource.publish.deleted(resource);
+    const resourceNotification: Notification = {
+      type: "success",
+      subtype: "resource-deleted",
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        resource: resource.name,
+        type: resource.type,
+        tenant: tenant
+      }
+    };
+    eventHelper.notification.publish.creation(resourceNotification);
+    return response;
+  } catch (error) {
+    console.error(`Error deleting ${kind}:`, { error, tenant, resource });
+    let contentMessage = "Unknown error";
+    let errorContent = "Unknown error";
+
+    if (
+      typeof error === "object" &&
+      error !== null &&
+      "error" in error &&
+      typeof (error as any).error === "object" &&
+      (error as any).error !== null
+    ) {
+      if ("code" in (error as any).error) {
+        contentMessage = (error as any).error.code;
+      }
+      if ("content" in (error as any).error) {
+        errorContent = (error as any).error.content;
+      }
+    }
+    const resourceErrorNotification: Notification = {
+      type: "error",
+      subtype: "resource-deletion-error",
+      info_content: {
+        code: contentMessage,
+        message: errorContent,
+      },
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        resource: resource.name,
+        type: resource.type,
+        tenant: tenant
+      }
+    };
+    eventHelper.notification.publish.creation(resourceErrorNotification);
+    throw error;
+  }
+};
+
+export const deleteResource = async (
+  tenant: string,
+  resource: Resource,
+  security: string
+) => {
+  const supportedKinds = [
+    "domain",
+    "port",
+    "ca",
+    "certificate",
+    "secret",
+    "volume",
+  ];
+  if (!supportedKinds.includes(resource.type)) {
+    throw new Error(`Unsupported resource type: ${resource.type}`);
+  }
+
+  return deleteResourceBase(tenant, resource, resource.type, security);
+};
+
+const updateResourceBase = async (
+  tenant: string,
+  resource: Resource,
+  kind: string,
+  data: any,
+  security: string
+) => {
+  try {
+    await initializeGlobalWebSocketClient(security);
+    const body = createResourceBody(tenant, resource, kind, data);
+
+    const response = await makeGlobalWebSocketRequest(
+      "resource:update_resource",
+      body,
+      30000,
+      "UPDATE",
+      resource.name
+    );
+
+    // eventHelper.resource.publish.updated(resource);
+    const resourceNotification: Notification = {
+      type: "success",
+      subtype: "resource-updated",
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        resource: resource.name,
+        type: resource.type,
+        tenant: tenant
+      }
+    };
+    eventHelper.notification.publish.creation(resourceNotification);
+    return response;
+  } catch (error) {
+    console.error(`Error updating ${kind}:`, { error, tenant, resource });
+    let contentMessage = "Unknown error";
+    let errorContent = "Unknown error";
+
+    if (
+      typeof error === "object" &&
+      error !== null &&
+      "error" in error &&
+      typeof (error as any).error === "object" &&
+      (error as any).error !== null
+    ) {
+      if ("code" in (error as any).error) {
+        contentMessage = (error as any).error.code;
+      }
+      if ("content" in (error as any).error) {
+        errorContent = (error as any).error.content;
+      }
+    }
+    const resourceErrorNotification: Notification = {
+      type: "error",
+      subtype: "resource-update-error",
+      info_content: {
+        code: contentMessage,
+        message: errorContent,
+      },
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        resource: resource.name,
+        type: resource.type,
+        tenant: tenant
+      }
+    };
+    eventHelper.notification.publish.creation(resourceErrorNotification);
+    throw error;
+  }
+};
+
+export const updateResource = async (
+  tenant: string,
+  resource: Resource,
+  security: string
+) => {
+  switch (resource.type) {
+    case "domain":
+      return updateResourceBase(
+        tenant,
+        resource,
+        "domain",
+        { domain: resource.value },
+        security
+      );
+    case "port":
+      return updateResourceBase(
+        tenant,
+        resource,
+        "port",
+        { port: Number(resource.value) },
+        security
+      );
+    case "ca":
+      return updateResourceBase(
+        tenant,
+        resource,
+        "ca",
+        { ca: resource.value },
+        security
+      );
+    case "certificate":
+      if (!resource.key || !resource.domain) {
+        throw new Error("Certificate requires both key and domain");
+      }
+      return updateResourceBase(
+        tenant,
+        resource,
+        "certificate",
+        {
+          certificate: {
+            cert: resource.value,
+            key: resource.key,
+            domain: resource.domain,
+          },
+        },
+        security
+      );
+    case "secret":
+      return updateResourceBase(
+        tenant,
+        resource,
+        "secret",
+        { secret: resource.value },
+        security
+      );
+    case "volume":
+      let volumeKind: "persistent" | "nonreplicated" | "shared" = "persistent";
+      if (resource.kind === "nonReplicated") {
+        volumeKind = "nonreplicated";
+      } else if (resource.kind === "volatile") {
+        volumeKind = "shared";
+      }
+
+      const volumeData: any = {
+        volume: {
+          kind: volumeKind,
+          size: Number(resource.value),
+        },
+      };
+
+      if (resource.maxItems !== undefined) {
+        volumeData.volume.maxitems = resource.maxItems;
+      }
+
+      if (volumeKind === "shared") {
+        volumeData.volume.options = {};
+      }
+
+      return updateResourceBase(
+        tenant,
+        resource,
+        "volume",
+        volumeData,
+        security
+      );
+
+    default:
+      throw new Error(`Unsupported resource type: ${resource.type}`);
+  }
+};