@kumori/aurora-backend-handler 1.0.0

package/api/tenant-api-service.ts

@@ -0,0 +1,1260 @@
+import { Notification, Registry, Tenant, tenantRole } from "@hestekumori/aurora-interfaces";
+import { eventHelper } from "../backend-handler";
+import { environment } from "../environment";
+import {
+  initializeGlobalWebSocketClient,
+  getWebSocketStatus,
+  makeGlobalWebSocketRequest,
+} from "../websocket-manager";
+
+type Security = string;
+interface DregistryBody {
+  spec: {
+    labels?: { [key: string]: string };
+    docker_server: string;
+    docker_username: string;
+    docker_password: string;
+  };
+}
+/**
+ * Function to create a tenant using the global WebSocket connection
+ * @param tenant Tenant object with the data of the tenant
+ * @param security Authorization token
+ * @returns The response of the WebSocket API
+ */
+export const createTenant = async (tenant: Tenant, security: Security) => {
+  try {
+    await initializeGlobalWebSocketClient(security);
+
+    const tenantBody =
+      tenant.npmRegistry && tenant.npmRegistry.endpoint !== ""
+        ? {
+            tenant: tenant.name,
+            provider: tenant.plan?.provider || "",
+            plan: tenant.plan?.name || "",
+            spec: {
+              registry: {
+                kind: "git",
+                endpoint: tenant.npmRegistry.endpoint,
+                domain: tenant.npmRegistry.domain,
+                credentials: tenant.npmRegistry.credentials,
+                public: tenant.npmRegistry.public,
+              },
+            },
+          }
+        : {
+            tenant: tenant.name,
+            provider: tenant.plan?.provider || "",
+            plan: tenant.plan?.name || "",
+            spec: {
+              registry: undefined,
+            },
+          };
+
+    const response = await makeGlobalWebSocketRequest(
+      "tenant:create_tenant",
+      tenantBody,
+      30000,
+      "CREATE",
+      tenant.name
+    );
+    const updatedTenant = { ...tenant, status: "pending" };
+    eventHelper.tenant.publish.created(updatedTenant);
+    const tenantCreatedNotification: Notification = {
+      type: "success",
+      subtype: "tenant-created",
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        tenant: tenant.name,
+      },
+    };
+    eventHelper.notification.publish.creation(tenantCreatedNotification);
+    return response;
+  } catch (error) {
+    console.error("Error creating tenant:", {
+      error,
+      errorMessage: error instanceof Error ? error.message : "Unknown error",
+      tenant: tenant.name,
+      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 tenantCreationErrorNotification: Notification = {
+      type: "error",
+      subtype: "tenant-creation-error",
+      info_content: {
+        code: contentMessage,
+        message: errorContent,
+      },
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        tenant: tenant.name,
+      },
+    };
+    eventHelper.notification.publish.creation(tenantCreationErrorNotification);
+    throw error;
+  }
+};
+
+export const deleteTenant = async (tenant: Tenant, security: string) => {
+  try {
+    await initializeGlobalWebSocketClient(security);
+
+    const deleteBody = {
+      tenant: tenant.name,
+      force: true,
+    };
+
+    const response = await makeGlobalWebSocketRequest(
+      "tenant:delete_tenant",
+      deleteBody,
+      30000,
+      "DELETE",
+      tenant.name
+    );
+
+    // const updatedTenant = { ...tenant, status: "pending" };
+    // eventHelper.tenant.publish.deleted(updatedTenant);
+    // const tenantDeletedNotification: Notification = {
+    //   type: "success",
+    //   subtype: "tenant-deleted",
+    //   date: Date.now().toString(),
+    //   status: "unread",
+    //   callToAction: false,
+    // };
+    // eventHelper.notification.publish.creation(tenantDeletedNotification);
+    return response;
+  } catch (err) {
+    console.error("Error in tenant deletion WebSocket request:", err);
+    eventHelper.tenant.publish.deletionError(tenant);
+    let contentMessage = "Unknown error";
+    let errorContent = "Unknown error";
+
+    if (
+      typeof err === "object" &&
+      err !== null &&
+      "error" in err &&
+      typeof (err as any).error === "object" &&
+      (err as any).error !== null
+    ) {
+      if ("code" in (err as any).error) {
+        contentMessage = (err as any).error.code;
+      }
+      if ("content" in (err as any).error) {
+        errorContent = (err as any).error.content;
+      }
+    }
+    const tenantDeletionErrorNotification: Notification = {
+      type: "error",
+      subtype: "tenant-deletion-error",
+      info_content: {
+        code: contentMessage,
+        message: errorContent,
+      },
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        tenant: tenant.name,
+      },
+    };
+    eventHelper.notification.publish.creation(tenantDeletionErrorNotification);
+    throw err;
+  }
+};
+
+export const updateTenant = async (tenant: Tenant, security: string) => {
+  try {
+    await initializeGlobalWebSocketClient(security);
+
+    const hasNpmRegistry =
+      tenant.npmRegistry && tenant.npmRegistry.endpoint !== "";
+    const hasPlan = tenant.plan?.name;
+
+    const updateBody: Record<string, any> = {
+      tenant: tenant.name,
+      spec: {
+        registry: hasNpmRegistry
+          ? {
+              kind: "git",
+              endpoint: tenant.npmRegistry!.endpoint,
+              domain: tenant.npmRegistry!.domain,
+              credentials: tenant.npmRegistry!.credentials,
+              public: tenant.npmRegistry!.public,
+            }
+          : undefined,
+      },
+    };
+
+    if (hasPlan) {
+      updateBody.provider = tenant.plan!.provider || "";
+      updateBody.plan = tenant.plan!.name;
+    }
+
+    const response = await makeGlobalWebSocketRequest(
+      "tenant:update_tenant",
+      updateBody,
+      30000,
+      "UPDATE",
+      tenant.name
+    );
+
+    const updatedTenant = { ...tenant, status: "pending" };
+    eventHelper.tenant.publish.updated(updatedTenant);
+    const tenantCreatedNotification: Notification = {
+      type: "success",
+      subtype: "tenant-updated",
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        tenant: tenant.name,
+      },
+    };
+    eventHelper.notification.publish.creation(tenantCreatedNotification);
+    return response;
+  } catch (err) {
+    console.error("Error in tenant update WebSocket request:", err);
+    eventHelper.tenant.publish.updateError(tenant);
+    let contentMessage = "Unknown error";
+    let errorContent = "Unknown error";
+
+    if (
+      typeof err === "object" &&
+      err !== null &&
+      "error" in err &&
+      typeof (err as any).error === "object" &&
+      (err as any).error !== null
+    ) {
+      if ("code" in (err as any).error) {
+        contentMessage = (err as any).error.code;
+      }
+      if ("content" in (err as any).error) {
+        errorContent = (err as any).error.content;
+      }
+    }
+    const tenantUpdateErrorNotification: Notification = {
+      type: "error",
+      subtype: "tenant-update-error",
+      info_content: {
+        code: contentMessage,
+        message: errorContent,
+      },
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        tenant: tenant.name,
+      },
+    };
+    eventHelper.notification.publish.creation(tenantUpdateErrorNotification);
+    throw err;
+  }
+};
+
+/**
+ * Function to create a tenant
+ * @param tenant Tenant object with the data of the tenant
+ * @returns The response of the API.
+ */
+export const createTenantHTTP = async (tenant: Tenant) => {
+  const createTenantUrl = new URL(
+    `${environment.apiServer.baseUrl}/api/${environment.apiServer.apiVersion}/tenant/${tenant.name}`
+  );
+  if (tenant.plan && tenant.plan?.name !== "" && tenant.plan?.provider !== "") {
+    createTenantUrl.searchParams.append("plan", tenant.plan?.name || "");
+    createTenantUrl.searchParams.append(
+      "provider",
+      tenant.plan?.provider || ""
+    );
+  }
+  const tenantBody =
+    tenant.npmRegistry && tenant.npmRegistry.endpoint !== ""
+      ? {
+          tenant: tenant.name,
+          provider: tenant.plan?.provider || "",
+          plan: tenant.plan?.name || "",
+          spec: {
+            registry: {
+              kind: "git",
+              endpoint: tenant.npmRegistry.endpoint,
+              domain: tenant.npmRegistry.domain,
+              credentials: tenant.npmRegistry.credentials,
+              public: tenant.npmRegistry.public,
+            },
+          },
+        }
+      : {
+          tenant: tenant.name,
+          spec: {
+            registry: undefined,
+          },
+        };
+  const response = await fetch(createTenantUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify(tenantBody),
+  });
+  if (response.ok) {
+    const updatedTenant = { ...tenant, status: "pending" };
+    eventHelper.tenant.publish.created(updatedTenant);
+    const tenantCreatedNotification: Notification = {
+      type: "success",
+      subtype: "tenant-created",
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        tenant: tenant.name,
+      },
+    };
+    eventHelper.notification.publish.creation(tenantCreatedNotification);
+  } else {
+    eventHelper.tenant.publish.creationError(tenant);
+
+    let errorCode = "Unknown error";
+    let errorMessage = "Unknown error";
+
+    try {
+      const errorBody = await response.json();
+      if (errorBody?.code) {
+        errorCode = errorBody.code;
+      }
+      if (errorBody?.content) {
+        errorMessage = errorBody.content;
+      } else {
+        errorMessage = JSON.stringify(errorBody, null, 2);
+      }
+    } catch (e) {
+      const text = await response.text();
+      errorMessage = text || "Unknown error";
+    }
+
+    const tenantCreationErrorNotification: Notification = {
+      type: "error",
+      subtype: "tenant-creation-error",
+      info_content: {
+        code: errorCode,
+        message: errorMessage,
+      },
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        tenant: tenant.name,
+      },
+    };
+
+    eventHelper.notification.publish.creation(tenantCreationErrorNotification);
+  }
+};
+
+export const deleteTenantHTTP = async (tenant: Tenant) => {
+  const url = new URL(
+    `${environment.apiServer.baseUrl}/api/${environment.apiServer.apiVersion}/tenant/${tenant.name}`
+  );
+  url.searchParams.append("force", "true");
+
+  const response = await fetch(url.toString(), {
+    method: "DELETE",
+  });
+
+  if (response.ok) {
+    const tenantDeletedNotification: Notification = {
+      type: "success",
+      subtype: "tenant-deleting",
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        tenant: tenant.name,
+      },
+    };
+    eventHelper.notification.publish.creation(tenantDeletedNotification);
+  } else {
+    eventHelper.tenant.publish.deletionError(tenant);
+
+    let errorCode = "Unknown error";
+    let errorMessage = "Unknown error";
+    try {
+      const errorBody = await response.json();
+      if (errorBody?.code) {
+        errorCode = errorBody.code;
+      }
+      if (errorBody?.content) {
+        errorMessage = errorBody.content;
+      }
+    } catch (e) {
+      const text = await response.text();
+      errorMessage = text || "Unknown error";
+    }
+
+    const tenantDeletionErrorNotification: Notification = {
+      type: "error",
+      subtype: "tenant-deletion-error",
+      info_content: {
+        code: errorCode,
+        message: errorMessage,
+      },
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        tenant: tenant.name,
+      },
+    };
+    eventHelper.notification.publish.creation(tenantDeletionErrorNotification);
+  }
+};
+
+export const updateTenantHTTP = async (tenant: Tenant) => {
+  const updateTenantUrl = new URL(
+    `${environment.apiServer.baseUrl}/api/${environment.apiServer.apiVersion}/tenant/${tenant.name}`
+  );
+  if (tenant.plan && tenant.plan?.name !== "" && tenant.plan?.provider !== "") {
+    updateTenantUrl.searchParams.append("plan", tenant.plan?.name || "");
+    updateTenantUrl.searchParams.append(
+      "provider",
+      tenant.plan?.provider || ""
+    );
+  }
+  const tenantBody =
+    tenant.npmRegistry && tenant.npmRegistry.endpoint !== ""
+      ? {
+          tenant: tenant.name,
+          provider: tenant.plan?.provider || "",
+          plan: tenant.plan?.name || "",
+          spec: {
+            registry: {
+              kind: "git",
+              endpoint: tenant.npmRegistry.endpoint,
+              domain: tenant.npmRegistry.domain,
+              credentials: tenant.npmRegistry.credentials,
+              public: tenant.npmRegistry.public,
+            },
+          },
+        }
+      : {
+          tenant: tenant.name,
+          spec: {
+            registry: undefined,
+          },
+        };
+  const response = await fetch(updateTenantUrl, {
+    method: "PATCH",
+    headers: {
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify(tenantBody),
+  });
+
+  if (response.ok) {
+    const updatedTenant = { ...tenant, status: "pending" };
+    eventHelper.tenant.publish.updated(updatedTenant);
+    const tenantCreatedNotification: Notification = {
+      type: "success",
+      subtype: "tenant-updated",
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        tenant: tenant.name,
+      },
+    };
+    eventHelper.notification.publish.creation(tenantCreatedNotification);
+  } else {
+    eventHelper.tenant.publish.updateError(tenant);
+
+    let errorCode = "Unknown error";
+    let errorMessage = "Unknown error";
+    try {
+      const errorBody = await response.json();
+      if (errorBody?.code) {
+        errorCode = errorBody.code;
+      }
+      if (errorBody?.content) {
+        errorMessage = errorBody.content;
+      }
+    } catch (e) {
+      const text = await response.text();
+      errorMessage = text || "Unknown error";
+    }
+
+    const tenantUpdateErrorNotification: Notification = {
+      type: "error",
+      subtype: "tenant-update-error",
+      info_content: {
+        code: errorCode,
+        message: errorMessage,
+      },
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        tenant: tenant.name,
+      },
+    };
+    eventHelper.notification.publish.creation(tenantUpdateErrorNotification);
+  }
+};
+
+export const createRegistry = async (
+  tenant: Tenant,
+  security: Security,
+  registry: Registry
+) => {
+  try {
+    await initializeGlobalWebSocketClient(security);
+    const dregistryBody: DregistryBody = {
+      spec: {
+        labels: { logo: registry.extra },
+        docker_server: registry.domain,
+        docker_username: registry.credentials,
+        docker_password: registry.password || "",
+      },
+    };
+    const queryParams = {
+      tenant: tenant.name,
+      dregistry: registry.name,
+    };
+
+    const response = await makeGlobalWebSocketRequest(
+      "dregistry:create_dregistry",
+      {
+        ...dregistryBody,
+        ...queryParams,
+      },
+      30000,
+      "CREATE",
+      `${tenant.name}/${registry.domain}`
+    );
+
+    const dregistryCreatedNotification: Notification = {
+      type: "success",
+      subtype: "registry-created",
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        tenant: tenant.name,
+      },
+    };
+    eventHelper.notification.publish.creation(dregistryCreatedNotification);
+    return response;
+  } catch (error) {
+    console.error("Error creating dregistry:", {
+      error,
+      errorMessage: error instanceof Error ? error.message : "Unknown error",
+      tenant: tenant.name,
+      registry: registry.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 dregistryCreationErrorNotification: Notification = {
+      type: "error",
+      subtype: "registry-creation-error",
+      info_content: {
+        code: contentMessage,
+        message: errorContent,
+      },
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        tenant: tenant.name,
+      },
+    };
+    eventHelper.notification.publish.creation(
+      dregistryCreationErrorNotification
+    );
+    throw error;
+  }
+};
+
+/**
+ * Function to update a dregistry using the global WebSocket connection
+ * @param tenant Tenant object with registry information
+ * @param security Authorization token
+ * @param force Force update flag (default: false)
+ * @returns The response of the WebSocket API
+ */
+export const updateRegistry = async (
+  tenant: Tenant,
+  registry: Registry,
+  security: Security,
+  force: boolean = false
+) => {
+  try {
+    await initializeGlobalWebSocketClient(security);
+    const dregistryBody: DregistryBody = {
+      spec: {
+        labels: { logo: registry.extra },
+        docker_server: registry.domain,
+        docker_username: registry.credentials,
+        docker_password: registry.password || "",
+      },
+    };
+    const queryParams = {
+      tenant: tenant.name,
+      dregistry: registry.name,
+      force: force,
+    };
+
+    const response = await makeGlobalWebSocketRequest(
+      "dregistry:update_dregistry",
+      {
+        ...dregistryBody,
+        ...queryParams,
+      },
+      30000,
+      "UPDATE",
+      `${tenant.name}/${registry.domain}`
+    );
+    const dregistryUpdatedNotification: Notification = {
+      type: "success",
+      subtype: "registry-updated",
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        tenant: tenant.name,
+      },
+    };
+    eventHelper.notification.publish.creation(dregistryUpdatedNotification);
+
+    return response;
+  } catch (error) {
+    console.error("Error updating dregistry:", {
+      error,
+      errorMessage: error instanceof Error ? error.message : "Unknown error",
+      tenant: tenant.name,
+      registry: registry.domain,
+      force,
+      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 dregistryUpdateErrorNotification: Notification = {
+      type: "error",
+      subtype: "registry-update-error",
+      info_content: {
+        code: contentMessage,
+        message: errorContent,
+      },
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        tenant: tenant.name,
+      },
+    };
+    eventHelper.notification.publish.creation(dregistryUpdateErrorNotification);
+    throw error;
+  }
+};
+
+export const deleteRegistry = async (
+  tenant: Tenant,
+  registry: Registry,
+  security: Security,
+  force: boolean = false
+) => {
+  try {
+    await initializeGlobalWebSocketClient(security);
+
+    const queryParams = {
+      tenant: tenant.name,
+      dregistry: registry.name,
+      force: force,
+    };
+
+    const response = await makeGlobalWebSocketRequest(
+      "dregistry:delete_dregistry",
+      queryParams,
+      30000,
+      "DELETE",
+      `${tenant.name}/${registry.domain}`
+    );
+
+    const dregistryDeletedNotification: Notification = {
+      type: "success",
+      subtype: "registry-deleted",
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        tenant: tenant.name,
+      },
+    };
+    eventHelper.notification.publish.creation(dregistryDeletedNotification);
+    return response;
+  } catch (error) {
+    console.error("Error deleting dregistry:", {
+      error,
+      errorMessage: error instanceof Error ? error.message : "Unknown error",
+      tenant: tenant.name,
+      registry: registry.domain,
+      force,
+      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 dregistryDeletionErrorNotification: Notification = {
+      type: "error",
+      subtype: "registry-deletion-error",
+      info_content: {
+        code: contentMessage,
+        message: errorContent,
+      },
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        tenant: tenant.name,
+      },
+    };
+    eventHelper.notification.publish.creation(
+      dregistryDeletionErrorNotification
+    );
+    throw error;
+  }
+};
+
+export const inviteUser = async (
+  tenant: string,
+  email: string,
+  role: tenantRole,
+  security: string
+) => {
+  try {
+    await initializeGlobalWebSocketClient(security);
+
+    const queryParams = {
+      tenant: tenant,
+      user: email,
+      role: role,
+    };
+
+    const response = await makeGlobalWebSocketRequest(
+      "tenant:propose_user",
+      queryParams,
+      30000,
+      "CREATE",
+      `${tenant}/${email}`
+    );
+    const tenantInvitedNotification: Notification = {
+      type: "success",
+      subtype: "tenant-user-invited",
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        tenant: tenant,
+        email: email,
+        role,
+        tenantRole,
+      },
+    };
+    eventHelper.notification.publish.creation(tenantInvitedNotification);
+    return response;
+  } catch (error) {
+    console.error("Error inviting user:", {
+      error,
+      errorMessage: error instanceof Error ? error.message : "Unknown error",
+      tenant: tenant,
+      email: email,
+      role: role,
+      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 tenantInviteErrorNotification: Notification = {
+      type: "error",
+      subtype: "tenant-user-invite-error",
+      info_content: {
+        code: contentMessage,
+        message: errorContent,
+      },
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        tenant: tenant,
+        email: email,
+        role,
+        tenantRole,
+      },
+    };
+    eventHelper.notification.publish.creation(tenantInviteErrorNotification);
+    throw error;
+  }
+};
+
+export const removeUser = async (
+  tenant: string,
+  userId: string,
+  security: string
+) => {
+  try {
+    await initializeGlobalWebSocketClient(security);
+    const queryParams = {
+      tenant: tenant,
+      user: userId,
+    };
+    const response = await makeGlobalWebSocketRequest(
+      "tenant:exclude_user",
+      queryParams,
+      30000,
+      "DELETE",
+      `${tenant}/${userId}`
+    );
+    const tenantUserRemovedNotification: Notification = {
+      type: "success",
+      subtype: "tenant-user-removed",
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        tenant: tenant,
+        user: userId,
+      },
+    };
+    eventHelper.notification.publish.creation(tenantUserRemovedNotification);
+    return response;
+  } catch (error) {
+    console.error("Error removing user from tenant:", {
+      error,
+      errorMessage: error instanceof Error ? error.message : "Unknown error",
+      tenant: tenant,
+      userId: userId,
+      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 tenantUserRemovedErrorNotification: Notification = {
+      type: "error",
+      subtype: "tenant-user-removed-error",
+      info_content: {
+        code: contentMessage,
+        message: errorContent,
+      },
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        tenant: tenant,
+        user: userId,
+      },
+    };
+    eventHelper.notification.publish.creation(
+      tenantUserRemovedErrorNotification
+    );
+    throw error;
+  }
+};
+
+export const updateUserRole = async (
+  tenant: string,
+  userId: string,
+  role: tenantRole,
+  security: string
+) => {
+  try {
+    await initializeGlobalWebSocketClient(security);
+    const queryParams = {
+      tenant: tenant,
+      user: userId,
+      role: role,
+    };
+    const response = await makeGlobalWebSocketRequest(
+      "tenant:modify_user_role",
+      queryParams,
+      30000,
+      "PATCH",
+      `${tenant}/${userId}`
+    );
+    const tenantUserUpdatedNotification: Notification = {
+      type: "success",
+      subtype: "user-role-updated",
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        tenant: tenant,
+        user: userId,
+        role: role,
+      },
+    };
+    eventHelper.notification.publish.creation(tenantUserUpdatedNotification);
+    return response;
+  } catch (error) {
+    console.error("Error updating user in tenant:", {
+      error,
+      errorMessage: error instanceof Error ? error.message : "Unknown error",
+      tenant: tenant,
+      userId: userId,
+      role: role,
+      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 tenantUserUpdatedErrorNotification: Notification = {
+      type: "error",
+      subtype: "user-role-updated-error",
+      info_content: {
+        code: contentMessage,
+        message: errorContent,
+      },
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        tenant: tenant,
+        user: userId,
+        role: role,
+      },
+    };
+    eventHelper.notification.publish.creation(
+      tenantUserUpdatedErrorNotification
+    );
+    throw error;
+  }
+};
+
+export const acceptInvite = async (tenant: string, security: string) => {
+  try {
+    await initializeGlobalWebSocketClient(security);
+    const queryParams = { tenant: tenant };
+    const response = await makeGlobalWebSocketRequest(
+      "tenant:accept_proposal_user",
+      queryParams,
+      30000,
+      "PUT",
+      `${tenant}/accept`
+    );
+    const tenantInviteAcceptedNotification: Notification = {
+      type: "success",
+      subtype: "tenant-invite-accepted",
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        tenant: tenant,
+      },
+    };
+    eventHelper.notification.publish.creation(tenantInviteAcceptedNotification);
+    return response;
+  } catch (error) {
+    console.error("Error accepting tenant invite:", {
+      error,
+      errorMessage: error instanceof Error ? error.message : "Unknown error",
+      tenant: tenant,
+      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 tenantInviteAcceptedErrorNotification: Notification = {
+      type: "error",
+      subtype: "tenant-invite-accepted-error",
+      info_content: {
+        code: contentMessage,
+        message: errorContent,
+      },
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        tenant: tenant,
+      },
+    };
+    eventHelper.notification.publish.creation(
+      tenantInviteAcceptedErrorNotification
+    );
+    throw error;
+  }
+};
+
+export const rejectInvite = async (tenant: string, security: string) => {
+  try {
+    await initializeGlobalWebSocketClient(security);
+    const queryParams = { tenant: tenant };
+    const response = await makeGlobalWebSocketRequest(
+      "tenant:reject_proposal_user",
+      queryParams,
+      30000,
+      "DELETE",
+      `${tenant}/reject`
+    );
+    const tenantInviteRejectedNotification: Notification = {
+      type: "success",
+      subtype: "tenant-invite-rejected",
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        tenant: tenant,
+      },
+    };
+    eventHelper.notification.publish.creation(tenantInviteRejectedNotification);
+    return response;
+  } catch (error) {
+    console.error("Error rejecting tenant invite:", {
+      error,
+      errorMessage: error instanceof Error ? error.message : "Unknown error",
+      tenant: tenant,
+      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 tenantInviteRejectedErrorNotification: Notification = {
+      type: "error",
+      subtype: "tenant-invite-rejected-error",
+      info_content: {
+        code: contentMessage,
+        message: errorContent,
+      },
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        tenant: tenant,
+      },
+    };
+    eventHelper.notification.publish.creation(
+      tenantInviteRejectedErrorNotification
+    );
+    throw error;
+  }
+};
+export const createToken = async (
+  tenantName: string,
+  tokenDescription: string,
+  tokenExpiration: string,
+  security: string
+) => {
+  try {
+    await initializeGlobalWebSocketClient(security);
+    const createTokenBody = {
+      spec: {
+        scopes: {
+          tenant: { [tenantName]: { allow: ["*:*:*"] } },
+          planprovider: { "*": { allow: ["*:*:*"] } },
+          user: { "*": { allow: ["*:*:*"] } },
+          idprovider: { "*": { allow: ["*:*:*"] } },
+        },
+        expiration: tokenExpiration,
+        description: tokenDescription,
+        labels: {
+          tenant: tenantName,
+        },
+      },
+    };
+    const response = await makeGlobalWebSocketRequest(
+      "token:create_token",
+      createTokenBody,
+      30000,
+      "CREATE",
+      `${tenantName}/tokens`,
+      "token"
+    );
+
+    const tenantTokenCreatedNotification: Notification = {
+      type: "success",
+      subtype: "token-created",
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        tenant: tenantName,
+        tokenName: tokenDescription,
+      },
+    };
+    eventHelper.notification.publish.creation(tenantTokenCreatedNotification);
+
+    return response;
+  } catch (error) {
+    console.error("Error creating tenant token:", {
+      error,
+      errorMessage: error instanceof Error ? error.message : "Unknown error",
+      tenant: tenantName,
+      webSocketStatus: getWebSocketStatus(),
+    });
+    throw error;
+  }
+};
+export const deleteToken = async (
+  tenantName: string,
+  tokenID: string,
+  security: string
+) => {
+  try {
+    await initializeGlobalWebSocketClient(security);
+    const queryParams = {
+      token_jti: tokenID,
+    };
+    const response = await makeGlobalWebSocketRequest(
+      "token:revoke_token",
+      queryParams,
+      30000,
+      "DELETE",
+      `${tenantName}/tokens/${tokenID}`
+    );
+    return response;
+  } catch (error) {
+    console.error("Error deleting tenant token:", {
+      error,
+      errorMessage: error instanceof Error ? error.message : "Unknown error",
+      tenant: tenantName,
+      webSocketStatus: getWebSocketStatus(),
+    });
+    throw error;
+  }
+};