@elevasis/ui 1.0.0

package/dist/chunk-J3FALDQE.js

@@ -0,0 +1,176 @@
+import { useElevasisServices } from './chunk-KA7LO7U5.js';
+import { showApiErrorNotification } from './chunk-7AI5ZYJ4.js';
+import { useQuery, useQueryClient, useMutation } from '@tanstack/react-query';
+import { notifications } from '@mantine/notifications';
+
+function useCommandQueue({
+  status,
+  limit,
+  offset,
+  humanCheckpoint,
+  timeRange,
+  priorityMin,
+  priorityMax
+} = {}) {
+  const { apiRequest, isReady, organizationId } = useElevasisServices();
+  return useQuery({
+    queryKey: ["command-queue", "list", organizationId, status, humanCheckpoint, timeRange, priorityMin, priorityMax, limit, offset],
+    queryFn: async () => {
+      const params = new URLSearchParams();
+      if (status) params.set("status", status);
+      if (humanCheckpoint) params.set("humanCheckpoint", humanCheckpoint);
+      if (timeRange) params.set("timeRange", timeRange);
+      if (priorityMin !== void 0) params.set("priorityMin", String(priorityMin));
+      if (priorityMax !== void 0) params.set("priorityMax", String(priorityMax));
+      if (limit !== void 0) params.set("limit", String(limit));
+      if (offset !== void 0) params.set("offset", String(offset));
+      const response = await apiRequest(
+        `/command-queue?${params.toString()}`
+      );
+      return response.tasks.map((task) => ({
+        ...task,
+        createdAt: new Date(task.createdAt),
+        completedAt: task.completedAt ? new Date(task.completedAt) : void 0,
+        expiresAt: task.expiresAt ? new Date(task.expiresAt) : void 0
+      }));
+    },
+    enabled: isReady
+  });
+}
+function useSubmitAction() {
+  const { apiRequest } = useElevasisServices();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async ({ taskId, actionId, payload, notes }) => {
+      const response = await apiRequest(`/command-queue/${taskId}/action`, {
+        method: "POST",
+        body: JSON.stringify({
+          actionId,
+          payload,
+          notes
+        })
+      });
+      return response;
+    },
+    onMutate: async ({ taskId }) => {
+      await queryClient.cancelQueries({ queryKey: ["command-queue", "list"] });
+      const previousData = /* @__PURE__ */ new Map();
+      const queries = queryClient.getQueriesData({ queryKey: ["command-queue", "list"] });
+      for (const [queryKey, data] of queries) {
+        previousData.set(queryKey, data);
+        if (data) {
+          queryClient.setQueryData(
+            queryKey,
+            (old) => old?.map((task) => task.id === taskId ? { ...task, status: "processing" } : task)
+          );
+        }
+      }
+      return { previousData };
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["command-queue"] });
+    },
+    onError: (_error, _variables, context) => {
+      if (context?.previousData) {
+        for (const [queryKey, data] of context.previousData) {
+          queryClient.setQueryData(queryKey, data);
+        }
+      }
+    }
+  });
+}
+function useDeleteTask() {
+  const { apiRequest } = useElevasisServices();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (taskId) => {
+      await apiRequest(`/command-queue/${taskId}`, {
+        method: "DELETE"
+      });
+    },
+    onMutate: async (taskId) => {
+      await queryClient.cancelQueries({ queryKey: ["command-queue", "list"] });
+      const previousData = /* @__PURE__ */ new Map();
+      const queries = queryClient.getQueriesData({ queryKey: ["command-queue", "list"] });
+      for (const [queryKey, data] of queries) {
+        previousData.set(queryKey, data);
+        if (data) {
+          queryClient.setQueryData(
+            queryKey,
+            (old) => old?.filter((task) => task.id !== taskId)
+          );
+        }
+      }
+      return { previousData };
+    },
+    onSuccess: () => {
+      notifications.show({
+        title: "Task Deleted",
+        message: "Task has been removed",
+        color: "green"
+      });
+      queryClient.invalidateQueries({ queryKey: ["command-queue"] });
+    },
+    onError: (error, _taskId, context) => {
+      if (context?.previousData) {
+        for (const [queryKey, data] of context.previousData) {
+          queryClient.setQueryData(queryKey, data);
+        }
+      }
+      showApiErrorNotification(error);
+    }
+  });
+}
+function useCommandQueueTotals({
+  timeRange = "24h",
+  priorityMin,
+  priorityMax,
+  status
+} = {}) {
+  const { apiRequest, isReady, organizationId } = useElevasisServices();
+  return useQuery({
+    queryKey: ["command-queue", "checkpoints", organizationId, timeRange, priorityMin, priorityMax, status],
+    queryFn: async () => {
+      const params = new URLSearchParams();
+      params.set("timeRange", timeRange);
+      if (priorityMin !== void 0) params.set("priorityMin", String(priorityMin));
+      if (priorityMax !== void 0) params.set("priorityMax", String(priorityMax));
+      if (status) params.set("status", status);
+      return apiRequest(`/command-queue/checkpoints?${params.toString()}`);
+    },
+    enabled: isReady,
+    staleTime: 3e4
+    // 30s monitoring stale time
+  });
+}
+function usePatchTask() {
+  const { apiRequest } = useElevasisServices();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async ({ taskId, params }) => {
+      const response = await apiRequest(`/command-queue/${taskId}`, {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(params)
+      });
+      return response.task;
+    },
+    onSuccess: (updatedTask) => {
+      const deserialized = {
+        ...updatedTask,
+        createdAt: new Date(updatedTask.createdAt),
+        completedAt: updatedTask.completedAt ? new Date(updatedTask.completedAt) : void 0,
+        expiresAt: updatedTask.expiresAt ? new Date(updatedTask.expiresAt) : void 0
+      };
+      queryClient.setQueriesData(
+        { queryKey: ["command-queue", "list"] },
+        (old) => old?.map((t) => t.id === deserialized.id ? { ...t, ...deserialized } : t)
+      );
+    },
+    onError: (error) => {
+      showApiErrorNotification(error);
+    }
+  });
+}
+
+export { useCommandQueue, useCommandQueueTotals, useDeleteTask, usePatchTask, useSubmitAction };

package/dist/chunk-JKERRYVS.js

@@ -0,0 +1,109 @@
+import { useElevasisServices } from './chunk-KA7LO7U5.js';
+import { showApiErrorNotification } from './chunk-7AI5ZYJ4.js';
+import { useQueryClient, useMutation, useQuery } from '@tanstack/react-query';
+import { z } from 'zod';
+
+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()
+});
+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/notifications/useMarkAsRead.ts
+function useMarkAsRead() {
+  const queryClient = useQueryClient();
+  const { apiRequest } = useElevasisServices();
+  return useMutation({
+    mutationFn: async (notificationId) => {
+      MarkAsReadParamsSchema.parse({ id: notificationId });
+      await apiRequest(`/notifications/${notificationId}/read`, {
+        method: "PATCH"
+      });
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["notifications"] });
+    },
+    onError: (error) => {
+      showApiErrorNotification(error);
+    }
+  });
+}
+function useMarkAllAsRead() {
+  const queryClient = useQueryClient();
+  const { apiRequest } = useElevasisServices();
+  return useMutation({
+    mutationFn: async () => {
+      await apiRequest("/notifications/mark-all-read", {
+        method: "PATCH"
+      });
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["notifications"] });
+    },
+    onError: (error) => {
+      showApiErrorNotification(error);
+    }
+  });
+}
+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
+  });
+}
+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
+  });
+}
+
+export { NonEmptyStringSchema, OriginResourceTypeSchema, ResourceTypeSchema, UuidSchema, useMarkAllAsRead, useMarkAsRead, useNotificationCount, useNotifications };

package/dist/chunk-KA7LO7U5.js

@@ -0,0 +1,28 @@
+import { createContext, useContext, useMemo } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+// src/provider/ElevasisServiceContext.tsx
+var ElevasisServiceContext = createContext(null);
+function useElevasisServices() {
+  const ctx = useContext(ElevasisServiceContext);
+  if (!ctx) {
+    throw new Error(
+      "useElevasisServices must be used within an ElevasisServiceProvider or an ElevasisProvider with apiUrl configured."
+    );
+  }
+  return ctx;
+}
+function ElevasisServiceProvider({
+  apiRequest,
+  organizationId,
+  isReady,
+  children
+}) {
+  const value = useMemo(
+    () => ({ apiRequest, organizationId, isReady }),
+    [apiRequest, organizationId, isReady]
+  );
+  return /* @__PURE__ */ jsx(ElevasisServiceContext.Provider, { value, children });
+}
+
+export { ElevasisServiceProvider, useElevasisServices };

package/dist/chunk-LHQTTUL2.js

@@ -0,0 +1,27 @@
+import { RouterProvider } from './chunk-Q7DJKLEN.js';
+import { useLocation, useRouter, Link } from '@tanstack/react-router';
+import { useCallback, useMemo, forwardRef } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+function TanStackRouterBridge({ children }) {
+  const location = useLocation();
+  const router = useRouter();
+  const navigate = useCallback((to) => router.navigate({ to }), [router]);
+  const Link$1 = useMemo(
+    () => forwardRef(function AdapterLink(props, ref) {
+      return /* @__PURE__ */ jsx(Link, { ref, ...props });
+    }),
+    []
+  );
+  const value = useMemo(
+    () => ({
+      currentPath: location.pathname,
+      navigate,
+      Link: Link$1
+    }),
+    [location.pathname, navigate, Link$1]
+  );
+  return /* @__PURE__ */ jsx(RouterProvider, { value, children });
+}
+
+export { TanStackRouterBridge };