@elevasis/ui 2.73.0 → 2.75.0

package/dist/chunk-QFS2GZMV.js

@@ -0,0 +1,515 @@
+import { useNotificationAdapter } from './chunk-SB3IHM5Y.js';
+import { showApiErrorNotification } from './chunk-ICHDIVQO.js';
+import { OrganizationContext } from './chunk-DD3CCMCZ.js';
+import { STALE_TIME_DEFAULT, GC_TIME_MEDIUM, GC_TIME_SHORT, STALE_TIME_MONITORING } from './chunk-A2SB32YV.js';
+import { useElevasisServices } from './chunk-BI5VDO2K.js';
+import { useQuery, useQueryClient, useMutation } from '@tanstack/react-query';
+import { z } from 'zod';
+import { notifications } from '@mantine/notifications';
+import { useContext } from 'react';
+
+// ../core/src/auth/multi-tenancy/memberships/membership.ts
+function transformMembershipToTableRow(membership) {
+  return {
+    id: membership.id,
+    userId: membership.userId,
+    organizationId: membership.organizationId,
+    userEmail: membership.user?.email || "Unknown",
+    userFullName: membership.user?.firstName && membership.user?.lastName ? `${membership.user.firstName} ${membership.user.lastName}` : membership.user?.email || "Unknown User",
+    organizationName: membership.organization?.name || "Unknown Organization",
+    role: membership.role.slug,
+    status: membership.status,
+    statusBadge: membership.status,
+    joinedAt: new Date(membership.createdAt),
+    updatedAt: new Date(membership.updatedAt),
+    canEdit: membership.status === "active",
+    canRemove: true
+  };
+}
+var MEMBERSHIP_STATUS_COLORS = {
+  active: "green",
+  inactive: "gray"
+};
+var PROVISIONING_STATE_DISPLAY = {
+  pre_provisioned: {
+    label: "Invited",
+    color: "orange",
+    description: "Invited but signup is not complete. The membership exists here; no WorkOS account is linked to it yet."
+  },
+  accepted_unlinked: {
+    label: "Link missing",
+    color: "red",
+    description: "This person accepted their invitation and has a real account, but our record of the connection was never written. They have access; our database just cannot see the link."
+  },
+  workos_only: {
+    label: "Sync gap",
+    color: "red",
+    description: "WorkOS has this membership but our database has no row for it, so it is not included in the member count. Remove and re-add the member to restore the record."
+  }
+};
+var MembershipRoleSchema = z.string().min(1).max(64);
+var MembershipStatusSchema = z.enum(["active", "inactive"]);
+var MembershipIdParamSchema = z.object({
+  id: z.string().min(1)
+  // WorkOS membership IDs can be various formats
+}).strict();
+z.object({
+  orgId: z.string().uuid()
+}).strict();
+z.object({
+  permissions: z.array(z.string())
+});
+var CreateMembershipSchema = z.object({
+  userId: z.string().min(1),
+  organizationId: z.string().min(1),
+  roleSlug: MembershipRoleSchema.default("member")
+}).strict();
+var UpdateMembershipSchema = z.object({
+  roleSlug: MembershipRoleSchema
+}).strict();
+var ListMembershipsQuerySchema = z.object({
+  userId: z.string().optional(),
+  organizationId: z.string().optional(),
+  // A querystring repeats keys rather than nesting arrays, so a single value
+  // arrives as a bare string. Normalize both shapes to an array.
+  statuses: z.union([MembershipStatusSchema, z.array(MembershipStatusSchema)]).transform((value) => Array.isArray(value) ? value : [value]).optional(),
+  order: z.enum(["asc", "desc"]).optional(),
+  limit: z.coerce.number().int().min(1).max(100).optional(),
+  before: z.string().optional(),
+  // WorkOS pagination cursor
+  after: z.string().optional()
+  // WorkOS pagination cursor
+}).strict().refine((data) => data.userId || data.organizationId, {
+  message: "Either userId or organizationId must be provided"
+});
+
+// src/hooks/settings/roles/usePermissionCatalog.ts
+var STALE_TIME_CATALOG = 60 * 60 * 1e3;
+function usePermissionCatalog() {
+  const { apiRequest, isReady } = useElevasisServices();
+  return useQuery({
+    queryKey: ["permission-catalog"],
+    queryFn: () => apiRequest("/permissions/catalog"),
+    enabled: isReady,
+    staleTime: STALE_TIME_CATALOG
+  });
+}
+
+// src/hooks/settings/webhooks/webhookEndpointService.ts
+var WebhookEndpointService = class {
+  constructor(apiRequest) {
+    this.apiRequest = apiRequest;
+  }
+  /**
+   * List webhook endpoints for the current organization
+   */
+  async listEndpoints() {
+    const response = await this.apiRequest("/webhook-endpoints");
+    return response.data;
+  }
+  /**
+   * Create a new webhook endpoint
+   */
+  async createEndpoint(data) {
+    return this.apiRequest("/webhook-endpoints", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  /**
+   * Update an existing webhook endpoint (e.g., toggle status, rename)
+   */
+  async updateEndpoint(endpointId, data) {
+    return this.apiRequest(`/webhook-endpoints/${endpointId}`, {
+      method: "PATCH",
+      body: JSON.stringify(data)
+    });
+  }
+  /**
+   * Delete a webhook endpoint
+   */
+  async deleteEndpoint(endpointId) {
+    await this.apiRequest(`/webhook-endpoints/${endpointId}`, {
+      method: "DELETE"
+    });
+  }
+};
+function useDeleteWebhookEndpoint() {
+  const { apiRequest } = useElevasisServices();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (endpointId) => {
+      const service = new WebhookEndpointService(apiRequest);
+      return await service.deleteEndpoint(endpointId);
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["webhook-endpoints"] });
+      notifications.show({
+        title: "Success",
+        message: "Webhook endpoint deleted",
+        color: "teal"
+      });
+    },
+    onError: (error) => {
+      console.error("Failed to delete webhook endpoint:", error);
+      showApiErrorNotification(error);
+    }
+  });
+}
+function useUpdateWebhookEndpoint() {
+  const { apiRequest } = useElevasisServices();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async ({ endpointId, data }) => {
+      const service = new WebhookEndpointService(apiRequest);
+      return await service.updateEndpoint(endpointId, data);
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["webhook-endpoints"] });
+      notifications.show({
+        title: "Success",
+        message: "Webhook endpoint updated",
+        color: "teal"
+      });
+    },
+    onError: (error) => {
+      console.error("Failed to update webhook endpoint:", error);
+      showApiErrorNotification(error);
+    }
+  });
+}
+function useCreateWebhookEndpoint() {
+  const { apiRequest } = useElevasisServices();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (data) => {
+      const service = new WebhookEndpointService(apiRequest);
+      return await service.createEndpoint(data);
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["webhook-endpoints"] });
+    },
+    onError: (error) => {
+      console.error("Failed to create webhook endpoint:", error);
+      showApiErrorNotification(error);
+    }
+  });
+}
+function useListWebhookEndpoints() {
+  const { apiRequest, workOSOrganizationId, isReady } = useElevasisServices();
+  return useQuery({
+    queryKey: ["webhook-endpoints", workOSOrganizationId],
+    queryFn: async () => {
+      const service = new WebhookEndpointService(apiRequest);
+      return await service.listEndpoints();
+    },
+    enabled: isReady
+  });
+}
+function useOrgRoles(orgId) {
+  const { apiRequest, isReady } = useElevasisServices();
+  const organization = useContext(OrganizationContext);
+  const targetOrgId = orgId ?? organization?.currentSupabaseOrganizationId ?? void 0;
+  return useQuery({
+    queryKey: ["org-roles", targetOrgId],
+    queryFn: () => apiRequest(`/organizations/${targetOrgId}/roles`),
+    enabled: isReady && !!targetOrgId,
+    staleTime: STALE_TIME_DEFAULT
+  });
+}
+function useAssignRole() {
+  const { apiRequest } = useElevasisServices();
+  const organization = useContext(OrganizationContext);
+  const orgId = organization?.currentSupabaseOrganizationId ?? null;
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: ({ membershipId, roleId }) => apiRequest(`/memberships/${membershipId}/roles`, {
+      method: "POST",
+      body: JSON.stringify({ roleId })
+    }),
+    onSettled: (_data, _error, { membershipId }) => {
+      queryClient.invalidateQueries({ queryKey: ["member-roles", orgId, membershipId] });
+      queryClient.invalidateQueries({ queryKey: ["organization-permissions", orgId] });
+      queryClient.invalidateQueries({ queryKey: ["org-roles", orgId] });
+    }
+  });
+}
+function useRevokeRole() {
+  const { apiRequest } = useElevasisServices();
+  const organization = useContext(OrganizationContext);
+  const orgId = organization?.currentSupabaseOrganizationId ?? null;
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: ({ membershipId, roleId }) => apiRequest(`/memberships/${membershipId}/roles/${roleId}`, {
+      method: "DELETE"
+    }),
+    onSettled: (_data, _error, { membershipId }) => {
+      queryClient.invalidateQueries({ queryKey: ["member-roles", orgId, membershipId] });
+      queryClient.invalidateQueries({ queryKey: ["organization-permissions", orgId] });
+      queryClient.invalidateQueries({ queryKey: ["org-roles", orgId] });
+    }
+  });
+}
+
+// src/hooks/settings/organization/organizationMembershipService.ts
+var OrganizationMembershipService = class {
+  constructor(apiRequest) {
+    this.apiRequest = apiRequest;
+  }
+  /**
+   * Get user's organization memberships
+   */
+  async getUserMemberships(userId) {
+    const searchParams = new URLSearchParams();
+    searchParams.append("userId", userId);
+    const url = `/memberships?${searchParams.toString()}`;
+    const response = await this.apiRequest(url);
+    return response.data.map((membership) => ({
+      ...membership,
+      createdAt: membership.createdAt,
+      updatedAt: membership.updatedAt
+    }));
+  }
+  /**
+   * Get organization members
+   */
+  async getOrganizationMembers(organizationId) {
+    const searchParams = new URLSearchParams();
+    searchParams.append("organizationId", organizationId);
+    const url = `/memberships?${searchParams.toString()}`;
+    const response = await this.apiRequest(url);
+    return response.data.map((membership) => ({
+      ...membership,
+      createdAt: membership.createdAt,
+      updatedAt: membership.updatedAt
+    }));
+  }
+  /**
+   * List memberships with filtering
+   */
+  async listMemberships(params) {
+    if (params) {
+      ListMembershipsQuerySchema.parse(params);
+    }
+    const searchParams = new URLSearchParams();
+    if (params?.userId) {
+      searchParams.append("userId", params.userId);
+    }
+    if (params?.organizationId) {
+      searchParams.append("organizationId", params.organizationId);
+    }
+    if (params?.statuses) {
+      params.statuses.forEach((status) => searchParams.append("statuses", status));
+    }
+    if (params?.limit) {
+      searchParams.append("limit", params.limit.toString());
+    }
+    if (params?.before) {
+      searchParams.append("before", params.before);
+    }
+    if (params?.after) {
+      searchParams.append("after", params.after);
+    }
+    if (params?.order) {
+      searchParams.append("order", params.order);
+    }
+    const url = `/memberships${searchParams.toString() ? `?${searchParams.toString()}` : ""}`;
+    const response = await this.apiRequest(url);
+    return {
+      ...response,
+      data: response.data.map((membership) => ({
+        ...membership,
+        createdAt: membership.createdAt,
+        updatedAt: membership.updatedAt
+      }))
+    };
+  }
+  /**
+   * Get a single membership by ID
+   */
+  async getMembership(membershipId) {
+    MembershipIdParamSchema.parse({ id: membershipId });
+    const membership = await this.apiRequest(`/memberships/${membershipId}`);
+    return {
+      ...membership,
+      createdAt: membership.createdAt,
+      updatedAt: membership.updatedAt
+    };
+  }
+  /**
+   * Create a new organization membership
+   */
+  async createMembership(data) {
+    const validated = CreateMembershipSchema.parse(data);
+    const membership = await this.apiRequest("/memberships", {
+      method: "POST",
+      body: JSON.stringify(validated)
+    });
+    return {
+      ...membership,
+      createdAt: membership.createdAt,
+      updatedAt: membership.updatedAt
+    };
+  }
+  /**
+   * Update an existing membership
+   */
+  async updateMembership(membershipId, data) {
+    MembershipIdParamSchema.parse({ id: membershipId });
+    const validated = UpdateMembershipSchema.parse(data);
+    const membership = await this.apiRequest(`/memberships/${membershipId}`, {
+      method: "PUT",
+      body: JSON.stringify(validated)
+    });
+    return {
+      ...membership,
+      createdAt: membership.createdAt,
+      updatedAt: membership.updatedAt
+    };
+  }
+  /**
+   * Delete a membership
+   */
+  async deleteMembership(membershipId) {
+    MembershipIdParamSchema.parse({ id: membershipId });
+    await this.apiRequest(`/memberships/${membershipId}`, {
+      method: "DELETE"
+    });
+  }
+  /**
+   * Deactivate a membership (soft delete)
+   */
+  async deactivateMembership(membershipId) {
+    MembershipIdParamSchema.parse({ id: membershipId });
+    const membership = await this.apiRequest(`/memberships/${membershipId}/deactivate`, {
+      method: "POST"
+    });
+    return {
+      ...membership,
+      createdAt: membership.createdAt,
+      updatedAt: membership.updatedAt
+    };
+  }
+  /**
+   * Reactivate a membership
+   */
+  async reactivateMembership(membershipId) {
+    MembershipIdParamSchema.parse({ id: membershipId });
+    const membership = await this.apiRequest(`/memberships/${membershipId}/reactivate`, {
+      method: "POST"
+    });
+    return {
+      ...membership,
+      createdAt: membership.createdAt,
+      updatedAt: membership.updatedAt
+    };
+  }
+  /**
+   * Write the WorkOS membership link the acceptance path failed to record --
+   * the repair for a membership reported as `accepted_unlinked`.
+   *
+   * Idempotent on the server: an already-linked row returns unchanged. A row in
+   * any other state is refused with a 409 rather than guessed at.
+   */
+  async repairMembershipLink(membershipId) {
+    MembershipIdParamSchema.parse({ id: membershipId });
+    const membership = await this.apiRequest(`/memberships/${membershipId}/repair-link`, {
+      method: "POST"
+    });
+    return {
+      ...membership,
+      createdAt: membership.createdAt,
+      updatedAt: membership.updatedAt
+    };
+  }
+};
+function useUserMemberships(userId, params) {
+  const { apiRequest, isReady } = useElevasisServices();
+  return useQuery({
+    queryKey: ["memberships", "user", userId, params],
+    queryFn: async () => {
+      const membershipService = new OrganizationMembershipService(apiRequest);
+      return await membershipService.getUserMemberships(userId);
+    },
+    enabled: isReady && !!userId,
+    refetchOnWindowFocus: false,
+    staleTime: STALE_TIME_DEFAULT,
+    gcTime: GC_TIME_MEDIUM
+  });
+}
+function useDeactivateMembership() {
+  const { apiRequest } = useElevasisServices();
+  const adapter = useNotificationAdapter();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async ({ membershipId }) => {
+      const membershipService = new OrganizationMembershipService(apiRequest);
+      return await membershipService.deactivateMembership(membershipId);
+    },
+    onError: (error) => {
+      adapter.apiError(error);
+    },
+    // Fires on both success and failure. A prior `onSuccess` invalidated the
+    // same key redundantly.
+    onSettled: () => {
+      queryClient.invalidateQueries({ queryKey: ["memberships"] });
+    }
+  });
+}
+function useReactivateMembership() {
+  const { apiRequest } = useElevasisServices();
+  const adapter = useNotificationAdapter();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async ({ membershipId }) => {
+      const membershipService = new OrganizationMembershipService(apiRequest);
+      return await membershipService.reactivateMembership(membershipId);
+    },
+    onError: (error) => {
+      adapter.apiError(error);
+    },
+    onSettled: () => {
+      queryClient.invalidateQueries({ queryKey: ["memberships"] });
+    }
+  });
+}
+function useOrganizationMembers(organizationId, params) {
+  const { apiRequest, isReady } = useElevasisServices();
+  return useQuery({
+    queryKey: ["organization-members", organizationId, params],
+    queryFn: async () => {
+      const searchParams = new URLSearchParams();
+      searchParams.append("organizationId", organizationId);
+      if (params?.userId) {
+        searchParams.append("userId", params.userId);
+      }
+      for (const status of params?.statuses ?? []) {
+        searchParams.append("statuses", status);
+      }
+      if (params?.order) {
+        searchParams.append("order", params.order);
+      }
+      if (params?.limit !== void 0) {
+        searchParams.append("limit", String(params.limit));
+      }
+      if (params?.before) {
+        searchParams.append("before", params.before);
+      }
+      if (params?.after) {
+        searchParams.append("after", params.after);
+      }
+      const response = await apiRequest(`/memberships?${searchParams.toString()}`);
+      return response.data.map((membership) => ({
+        ...membership,
+        createdAt: membership.createdAt,
+        updatedAt: membership.updatedAt
+      }));
+    },
+    enabled: isReady && !!organizationId,
+    staleTime: STALE_TIME_MONITORING,
+    gcTime: GC_TIME_SHORT,
+    refetchOnWindowFocus: false
+  });
+}
+
+export { MEMBERSHIP_STATUS_COLORS, OrganizationMembershipService, PROVISIONING_STATE_DISPLAY, WebhookEndpointService, transformMembershipToTableRow, useAssignRole, useCreateWebhookEndpoint, useDeactivateMembership, useDeleteWebhookEndpoint, useListWebhookEndpoints, useOrgRoles, useOrganizationMembers, usePermissionCatalog, useReactivateMembership, useRevokeRole, useUpdateWebhookEndpoint, useUserMemberships };