@elevasis/ui 1.3.0 → 1.3.2

package/dist/{chunk-BZTA7IIL.js → chunk-6IX5JZEH.js}

@@ -1,7 +1,10 @@
-import { UuidSchema, ResourceTypeSchema, NonEmptyStringSchema, OriginResourceTypeSchema } from './chunk-BLO4SISK.js';
+import { useSupabase } from './chunk-JGJSZ3UE.js';
+import { useNotificationAdapter } from './chunk-TIRMFDM4.js';
+import { useStableAccessToken } from './chunk-FWZJH3TL.js';
 import { useElevasisServices } from './chunk-KA7LO7U5.js';
 import { useQuery, useQueryClient, useMutation } from '@tanstack/react-query';
 import { z } from 'zod';
+import { useCallback, useState, useEffect, useMemo, useId, useRef } from 'react';
 
 // src/hooks/executions/queryKeys.ts
 var executionsKeys = {
@@ -150,10 +153,35 @@ function useBulkDeleteExecutions() {
     }
   });
 }
+var UuidSchema = z.string().uuid();
+var NonEmptyStringSchema = z.string().trim().min(1).max(1e3);
+var ResourceTypeSchema = z.enum(["agent", "workflow"]);
+var OriginResourceTypeSchema = z.enum(["agent", "workflow", "scheduler", "api"]);
+z.string().trim().toLowerCase().min(1, "Credential name required").max(100, "Credential name too long (max 100 chars)").regex(
+  /^[a-z0-9]+(-[a-z0-9]+)+$/,
+  "Credential name must be lowercase letters, numbers, and hyphens in format: service-environment (e.g., gmail-prod, attio-dev)"
+);
+z.enum(["google-sheets", "dropbox"]);
+z.string().min(10, "Authorization code too short").max(1e3, "Authorization code too long");
+z.string().min(10, "State parameter too short").max(2048, "State parameter too long");
+z.string().trim().transform((str) => str.replace(/[<>'"]/g, ""));
+z.string().email();
+z.string().url();
+z.object({
+  limit: z.coerce.number().int().min(1).max(100).default(20),
+  offset: z.coerce.number().int().min(0).default(0)
+});
+z.string().datetime();
+z.object({
+  startDate: z.string().datetime(),
+  endDate: z.string().datetime()
+});
+
+// ../core/src/operations/sessions/api-schemas.ts
 var SessionIdParamSchema = z.object({
   sessionId: UuidSchema
 }).strict();
-z.object({
+var ExecutionIdParamsSchema = z.object({
   sessionId: UuidSchema,
   executionId: UuidSchema
 }).strict();
@@ -184,7 +212,7 @@ z.object({
   resourceId: z.string().optional(),
   limit: z.coerce.number().int().min(1).max(100).default(20)
 }).strict();
-z.object({
+var WebSocketSessionTurnSchema = z.object({
   type: z.literal("session:turn"),
   input: z.unknown().refine(
     (val) => {
@@ -413,6 +441,38 @@ function useExecutionLogs(params = {}) {
     // Real-time data - always refetch on mount/org switch
   });
 }
+var NotificationCategorySchema = z.enum(["info", "queue", "alert", "error", "system"]);
+var GetNotificationsQuerySchema = z.object({
+  limit: z.coerce.number().int().min(1).max(100).default(50),
+  offset: z.coerce.number().int().min(0).default(0)
+});
+var MarkAsReadParamsSchema = z.object({
+  id: UuidSchema
+});
+z.object({
+  userId: UuidSchema,
+  organizationId: UuidSchema,
+  category: NotificationCategorySchema,
+  title: z.string().trim().min(1).max(200),
+  message: z.string().trim().min(1).max(1e3),
+  actionUrl: z.string().url().optional()
+}).strict();
+
+// src/hooks/monitoring/useNotifications.ts
+function useNotifications({ limit = 20, offset = 0 } = {}) {
+  const { apiRequest, isReady, organizationId } = useElevasisServices();
+  return useQuery({
+    queryKey: ["notifications", organizationId, { limit, offset }],
+    queryFn: async () => {
+      const params = GetNotificationsQuerySchema.parse({ limit, offset });
+      const response = await apiRequest(
+        `/notifications?limit=${params.limit}&offset=${params.offset}`
+      );
+      return response;
+    },
+    enabled: isReady
+  });
+}
 var RelativeScheduleItemSchema = z.object({
   offset: z.string().regex(/^[+-]\d+[dhm]$/, "Invalid offset format. Use +3d, -2h, +30m, etc."),
   payload: z.record(z.string(), z.unknown()),
@@ -658,6 +718,92 @@ function useExecutionHealth({ timeRange }) {
     // 30s monitoring stale time
   });
 }
+function useMarkAsRead() {
+  const queryClient = useQueryClient();
+  const { apiRequest } = useElevasisServices();
+  const notify = useNotificationAdapter();
+  return useMutation({
+    mutationFn: async (notificationId) => {
+      MarkAsReadParamsSchema.parse({ id: notificationId });
+      await apiRequest(`/notifications/${notificationId}/read`, {
+        method: "PATCH"
+      });
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["notifications"] });
+    },
+    onError: (error) => {
+      notify.apiError(error);
+    }
+  });
+}
+function useMarkAllAsRead() {
+  const queryClient = useQueryClient();
+  const { apiRequest } = useElevasisServices();
+  const notify = useNotificationAdapter();
+  return useMutation({
+    mutationFn: async () => {
+      await apiRequest("/notifications/mark-all-read", {
+        method: "PATCH"
+      });
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["notifications"] });
+    },
+    onError: (error) => {
+      notify.apiError(error);
+    }
+  });
+}
+function useNotificationCount() {
+  const { apiRequest, isReady, organizationId } = useElevasisServices();
+  return useQuery({
+    queryKey: ["notifications", "unread-count", organizationId],
+    queryFn: async () => {
+      const response = await apiRequest("/notifications/unread-count");
+      return response.count;
+    },
+    enabled: isReady,
+    staleTime: 3e4
+  });
+}
+function useErrorNotification() {
+  const adapter = useNotificationAdapter();
+  return useCallback(
+    (error) => {
+      adapter.apiError(error);
+    },
+    [adapter]
+  );
+}
+function useSuccessNotification() {
+  const adapter = useNotificationAdapter();
+  return useCallback((title, message) => adapter.success(title, message), [adapter]);
+}
+function useWarningNotification() {
+  const adapter = useNotificationAdapter();
+  return useCallback((title, message) => adapter.warning(title, message), [adapter]);
+}
+function useBatchDelete(tableName, invalidateQueryKeys) {
+  const supabase = useSupabase();
+  const queryClient = useQueryClient();
+  const adapter = useNotificationAdapter();
+  return useMutation({
+    mutationFn: async (ids) => {
+      if (ids.length === 0) return;
+      const { error } = await supabase.from(tableName).delete().in("id", ids);
+      if (error) throw error;
+    },
+    onSuccess: () => {
+      for (const key of invalidateQueryKeys) {
+        queryClient.invalidateQueries({ queryKey: key });
+      }
+    },
+    onError: (err) => {
+      adapter.apiError(err);
+    }
+  });
+}
 
 // src/hooks/observability/queryKeys.ts
 var observabilityKeys = {
@@ -1063,5 +1209,213 @@ function useDeleteSchedule() {
     }
   });
 }
+function usePaginationState(pageSize, resetDeps, total) {
+  const [page, setPage] = useState(1);
+  useEffect(() => {
+    if (resetDeps) {
+      setPage(1);
+    }
+  }, resetDeps ?? []);
+  useEffect(() => {
+    if (total === void 0) return;
+    const lastPage = Math.max(1, Math.ceil(total / pageSize));
+    if (page > lastPage) {
+      setPage(lastPage);
+    }
+  }, [total, pageSize]);
+  return useMemo(
+    () => ({
+      page,
+      setPage,
+      offset: (page - 1) * pageSize,
+      totalPages: (total2) => Math.ceil(total2 / pageSize)
+    }),
+    [page, pageSize]
+  );
+}
+function useTableSelection(items, allItems) {
+  const [selectedIds, setSelectedIds] = useState(/* @__PURE__ */ new Set());
+  const pageIds = useMemo(() => new Set(items.map((i) => i.id)), [items]);
+  useEffect(() => {
+    setSelectedIds((prev) => {
+      const validIds = allItems ? new Set(allItems.map((i) => i.id)) : pageIds;
+      const next = new Set([...prev].filter((id) => validIds.has(id)));
+      return next.size === prev.size ? prev : next;
+    });
+  }, [allItems, pageIds]);
+  const toggle = useCallback((id) => {
+    setSelectedIds((prev) => {
+      const next = new Set(prev);
+      if (next.has(id)) next.delete(id);
+      else next.add(id);
+      return next;
+    });
+  }, []);
+  const togglePage = useCallback(() => {
+    setSelectedIds((prev) => {
+      const allPageSelected = items.every((i) => prev.has(i.id));
+      const next = new Set(prev);
+      if (allPageSelected) {
+        for (const item of items) next.delete(item.id);
+      } else {
+        for (const item of items) next.add(item.id);
+      }
+      return next;
+    });
+  }, [items]);
+  const clear = useCallback(() => setSelectedIds(/* @__PURE__ */ new Set()), []);
+  const isPageAllSelected = items.length > 0 && items.every((i) => selectedIds.has(i.id));
+  const isPagePartiallySelected = !isPageAllSelected && items.some((i) => selectedIds.has(i.id));
+  return {
+    selectedIds,
+    toggle,
+    togglePage,
+    clear,
+    isPageAllSelected,
+    isPagePartiallySelected,
+    selectedCount: selectedIds.size,
+    isSelected: (id) => selectedIds.has(id)
+  };
+}
+function useTableSort(defaultColumn, defaultDirection = "desc") {
+  const [sort, setSort] = useState({ column: defaultColumn, direction: defaultDirection });
+  const toggleSort = useCallback((column) => {
+    setSort((prev) => {
+      if (prev.column === column) {
+        return { column, direction: prev.direction === "asc" ? "desc" : "asc" };
+      }
+      return { column, direction: "desc" };
+    });
+  }, []);
+  return { sort, toggleSort };
+}
+function sortData(data, sort, accessors) {
+  const accessor = accessors[sort.column];
+  if (!accessor) return data;
+  return [...data].sort((a, b) => {
+    const aVal = accessor(a);
+    const bVal = accessor(b);
+    if (aVal == null && bVal == null) return 0;
+    if (aVal == null) return 1;
+    if (bVal == null) return -1;
+    let comparison = 0;
+    if (typeof aVal === "string" && typeof bVal === "string") {
+      comparison = aVal.localeCompare(bVal);
+    } else if (typeof aVal === "number" && typeof bVal === "number") {
+      comparison = aVal - bVal;
+    } else {
+      comparison = String(aVal).localeCompare(String(bVal));
+    }
+    return sort.direction === "asc" ? comparison : -comparison;
+  });
+}
+function useSortedData(data, defaultColumn, accessors, defaultDirection = "desc") {
+  const { sort, toggleSort } = useTableSort(defaultColumn, defaultDirection);
+  const sorted = useMemo(() => sortData(data, sort, accessors), [data, sort, accessors]);
+  return { sorted, sort, toggleSort };
+}
+function createUseFeatureAccess({
+  useInitialization,
+  useOrganization,
+  optInFeatures = []
+}) {
+  return function useFeatureAccess() {
+    const { profile, organizationReady } = useInitialization();
+    const { currentMembership } = useOrganization();
+    const { orgConfig, membershipConfig } = useMemo(() => {
+      const organizationConfig = currentMembership?.organization?.config;
+      const memberConfig = currentMembership?.config;
+      return { orgConfig: organizationConfig, membershipConfig: memberConfig };
+    }, [currentMembership]);
+    const userConfig = profile?.config;
+    const checkFeature = useCallback(
+      (featureKey) => {
+        const key = featureKey;
+        const orgValue = orgConfig?.features?.[key];
+        if (!profile?.is_platform_admin) {
+          const membershipValue = membershipConfig?.features?.[key];
+          if (membershipValue === false) return { allowed: false, restrictedBy: "membership" };
+          if (membershipValue === true) return { allowed: true, restrictedBy: null };
+        }
+        if (optInFeatures.includes(featureKey)) {
+          return orgValue === true ? { allowed: true, restrictedBy: null } : { allowed: false, restrictedBy: "org" };
+        }
+        return orgValue === false ? { allowed: false, restrictedBy: "org" } : { allowed: true, restrictedBy: null };
+      },
+      [profile?.is_platform_admin, membershipConfig, orgConfig]
+    );
+    const hasFeature = useCallback((featureKey) => checkFeature(featureKey).allowed, [checkFeature]);
+    return {
+      orgConfig,
+      membershipConfig,
+      userConfig,
+      hasFeature,
+      checkFeature,
+      isReady: organizationReady
+    };
+  };
+}
+function useSSEConnection({
+  manager,
+  connectionKey,
+  url,
+  enabled = true,
+  headers,
+  onmessage,
+  onopen,
+  onerror,
+  onclose
+}) {
+  const [connected, setConnected] = useState(false);
+  const [error, setError] = useState(null);
+  const getAccessToken = useStableAccessToken();
+  const subscriberId = useId();
+  const onmessageRef = useRef(onmessage);
+  const onopenRef = useRef(onopen);
+  const onerrorRef = useRef(onerror);
+  const oncloseRef = useRef(onclose);
+  const headersRef = useRef(headers);
+  onmessageRef.current = onmessage;
+  onopenRef.current = onopen;
+  onerrorRef.current = onerror;
+  oncloseRef.current = onclose;
+  headersRef.current = headers;
+  useEffect(() => {
+    if (!enabled) return;
+    const unsubscribe = manager.subscribe(connectionKey, subscriberId, {
+      url,
+      getToken: getAccessToken,
+      headers: headersRef.current ?? {},
+      onopen(response) {
+        if (response.ok) {
+          setConnected(true);
+          setError(null);
+        }
+        const customError = onopenRef.current?.(response);
+        if (customError) setError(customError);
+      },
+      onmessage(event) {
+        if (!event.data || event.data.trim() === "") return;
+        onmessageRef.current(event.data);
+      },
+      onerror(err) {
+        const msg = err instanceof Error ? err.message : "Unknown error";
+        setConnected(false);
+        setError(msg);
+        onerrorRef.current?.(err instanceof Error ? err : new Error(msg));
+      },
+      onclose() {
+        setConnected(false);
+        oncloseRef.current?.();
+      }
+    });
+    return () => {
+      unsubscribe();
+      setConnected(false);
+      setError(null);
+    };
+  }, [enabled, connectionKey, url, subscriberId, getAccessToken, manager]);
+  return { connected, error };
+}
 
-export { OperationsService, executionsKeys, observabilityKeys, scheduleKeys, useActivities, useActivityTrend, useBulkDeleteExecutions, useBusinessImpact, useCancelExecution, useCancelSchedule, useCostBreakdown, useCostByModel, useCostSummary, useCostTrends, useCreateSchedule, useDashboardMetrics, useDeleteExecution, useDeleteSchedule, useErrorAnalysis, useErrorDetail, useErrorDetails, useErrorDistribution, useErrorTrends, useExecuteAsync, useExecution, useExecutionHealth, useExecutionLogs, useExecutions, useGetExecutionHistory, useGetSchedule, useListSchedules, usePauseSchedule, useResolveAllErrors, useResolveError, useResolveErrorsByExecution, useResourceDefinition, useResources, useResumeSchedule, useRetryExecution, useTopFailingResources, useUnresolveError, useUpdateAnchor, useUpdateSchedule };
+export { ExecutionIdParamsSchema, OperationsService, SessionIdParamSchema, WebSocketSessionTurnSchema, createUseFeatureAccess, executionsKeys, observabilityKeys, scheduleKeys, sortData, useActivities, useActivityTrend, useBatchDelete, useBulkDeleteExecutions, useBusinessImpact, useCancelExecution, useCancelSchedule, useCostBreakdown, useCostByModel, useCostSummary, useCostTrends, useCreateSchedule, useDashboardMetrics, useDeleteExecution, useDeleteSchedule, useErrorAnalysis, useErrorDetail, useErrorDetails, useErrorDistribution, useErrorNotification, useErrorTrends, useExecuteAsync, useExecution, useExecutionHealth, useExecutionLogs, useExecutions, useGetExecutionHistory, useGetSchedule, useListSchedules, useMarkAllAsRead, useMarkAsRead, useNotificationCount, useNotifications, usePaginationState, usePauseSchedule, useResolveAllErrors, useResolveError, useResolveErrorsByExecution, useResourceDefinition, useResources, useResumeSchedule, useRetryExecution, useSSEConnection, useSortedData, useSuccessNotification, useTableSelection, useTableSort, useTopFailingResources, useUnresolveError, useUpdateAnchor, useUpdateSchedule, useWarningNotification };

package/dist/chunk-FWZJH3TL.js

@@ -0,0 +1,13 @@
+import { useAuthContext } from './chunk-7PLEQFHO.js';
+import { useRef, useCallback } from 'react';
+
+function useStableAccessToken() {
+  const { getAccessToken } = useAuthContext();
+  const getAccessTokenRef = useRef(getAccessToken);
+  getAccessTokenRef.current = getAccessToken;
+  return useCallback(() => {
+    return getAccessTokenRef.current();
+  }, []);
+}
+
+export { useStableAccessToken };