@elevasis/ui 1.25.0 → 1.26.0

package/dist/{chunk-QDO6NF2I.js → chunk-ZVJKIJFG.js}

@@ -1,9 +1,8 @@
-import { useSupabase } from './chunk-NJJ3NQ7B.js';
 import { getTimeRangeDates, observabilityKeys } from './chunk-LXHZYSMQ.js';
 import { GRAPH_CONSTANTS } from './chunk-F6RBK7NJ.js';
 import { useNotificationAdapter } from './chunk-R7WLWGPO.js';
 import { HTTP_HEADERS } from './chunk-NVOCKXUQ.js';
-import { STALE_TIME_MONITORING, REFETCH_INTERVAL_DASHBOARD, REFETCH_INTERVAL_RUNNING, WS_MAX_RETRIES_BEFORE_ERROR, WS_RECONNECT_BASE_DELAY, WS_RECONNECT_MAX_DELAY, getErrorInfo, formatErrorMessage, getErrorTitle, STALE_TIME_DEFAULT, STALE_TIME_ADMIN } from './chunk-IOKL7BKE.js';
+import { STALE_TIME_MONITORING, REFETCH_INTERVAL_DASHBOARD, REFETCH_INTERVAL_RUNNING, WS_MAX_RETRIES_BEFORE_ERROR, WS_RECONNECT_BASE_DELAY, WS_RECONNECT_MAX_DELAY, getErrorInfo, formatErrorMessage, getErrorTitle, STALE_TIME_DEFAULT, STALE_TIME_ADMIN, APIClientError } from './chunk-IOKL7BKE.js';
 import { useStableAccessToken } from './chunk-ALA56RGZ.js';
 import { useOrganization } from './chunk-DD3CCMCZ.js';
 import { useElevasisServices } from './chunk-QEPXAWE2.js';
@@ -682,6 +681,9 @@ z.object({
   message: z.string().trim().min(1).max(1e3),
   actionUrl: z.string().url().optional()
 }).strict();
+z.object({
+  ids: z.array(UuidSchema).min(1).max(500)
+}).strict();
 
 // src/hooks/monitoring/useNotifications.ts
 function useNotifications({ limit = 20, offset = 0 } = {}) {
@@ -998,15 +1000,18 @@ function useWarningNotification() {
   const adapter = useNotificationAdapter();
   return useCallback((title, message) => adapter.warning(title, message), [adapter]);
 }
-function useBatchDelete(tableName, invalidateQueryKeys) {
-  const supabase = useSupabase();
+function useBatchDelete(invalidateQueryKeys) {
+  const { apiRequest } = useElevasisServices();
   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;
+      const body = { ids };
+      await apiRequest("/notifications/batch", {
+        method: "DELETE",
+        body: JSON.stringify(body)
+      });
     },
     onSuccess: () => {
       for (const key of invalidateQueryKeys) {
@@ -2670,6 +2675,114 @@ var calibrationKeys = {
   run: (org, runId) => [...calibrationKeys.all, "run", org, runId],
   runFull: (org, runId) => [...calibrationKeys.all, "run-full", org, runId]
 };
+function useAllCalibrationProjects() {
+  const { apiRequest, organizationId, isReady } = useElevasisServices();
+  return useQuery({
+    queryKey: calibrationKeys.projects(organizationId ?? "none"),
+    queryFn: async () => {
+      const response = await apiRequest("/calibration/projects");
+      return response.projects;
+    },
+    enabled: isReady && !!organizationId
+  });
+}
+function useCalibrationProjects(resourceId, resourceType) {
+  const { apiRequest, organizationId, isReady } = useElevasisServices();
+  return useQuery({
+    queryKey: calibrationKeys.projectsByResource(organizationId ?? "none", resourceId, resourceType),
+    queryFn: async () => {
+      const response = await apiRequest(
+        `/calibration/projects?resourceId=${resourceId}&resourceType=${resourceType}`
+      );
+      return response.projects;
+    },
+    enabled: isReady && !!resourceId && !!resourceType && !!organizationId
+  });
+}
+function useCalibrationProject(projectId) {
+  const { apiRequest, organizationId, isReady } = useElevasisServices();
+  return useQuery({
+    queryKey: calibrationKeys.project(organizationId ?? "none", projectId),
+    queryFn: async () => {
+      const response = await apiRequest(`/calibration/projects/${projectId}`);
+      return response.project;
+    },
+    enabled: isReady && !!projectId && !!organizationId
+  });
+}
+function useCreateProject() {
+  const { apiRequest, organizationId } = useElevasisServices();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (input) => {
+      const response = await apiRequest("/calibration/projects", {
+        method: "POST",
+        body: JSON.stringify(input)
+      });
+      return response.project;
+    },
+    onSuccess: (data) => {
+      queryClient.invalidateQueries({
+        queryKey: calibrationKeys.projects(organizationId ?? "none")
+      });
+      queryClient.invalidateQueries({
+        queryKey: calibrationKeys.projectsByResource(organizationId ?? "none", data.resourceId, data.resourceType)
+      });
+    },
+    onError: (error) => {
+      showApiErrorNotification(error);
+    }
+  });
+}
+function useUpdateProject() {
+  const { apiRequest, organizationId } = useElevasisServices();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async ({
+      id,
+      ...input
+    }) => {
+      const response = await apiRequest(`/calibration/projects/${id}`, {
+        method: "PATCH",
+        body: JSON.stringify(input)
+      });
+      return response.project;
+    },
+    onSuccess: (data) => {
+      queryClient.invalidateQueries({
+        queryKey: calibrationKeys.projects(organizationId ?? "none")
+      });
+      queryClient.invalidateQueries({
+        queryKey: calibrationKeys.projectsByResource(organizationId ?? "none", data.resourceId, data.resourceType)
+      });
+      queryClient.invalidateQueries({
+        queryKey: calibrationKeys.project(organizationId ?? "none", data.id)
+      });
+    },
+    onError: (error) => {
+      showApiErrorNotification(error);
+    }
+  });
+}
+function useDeleteProject() {
+  const { apiRequest } = useElevasisServices();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (id) => {
+      await apiRequest(`/calibration/projects/${id}`, {
+        method: "DELETE"
+      });
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: calibrationKeys.all
+      });
+    },
+    onError: (error) => {
+      showApiErrorNotification(error);
+    }
+  });
+}
 function useCalibrationRuns(projectId) {
   const { apiRequest, organizationId, isReady } = useElevasisServices();
   return useQuery({
@@ -2899,110 +3012,192 @@ function useCalibrationSSE({ runId, manager, apiUrl, enabled = true }) {
     reset
   };
 }
-
-// src/hooks/operations/calibration/useCalibrationProjects.ts
-function useAllCalibrationProjects() {
-  const { apiRequest, organizationId, isReady } = useElevasisServices();
+function useDealDetail(acqDealId) {
+  const { apiRequest, isReady, organizationId } = useElevasisServices();
   return useQuery({
-    queryKey: calibrationKeys.projects(organizationId ?? "none"),
+    queryKey: ["deal-detail", organizationId, acqDealId],
     queryFn: async () => {
-      const response = await apiRequest("/calibration/projects");
-      return response.projects;
+      if (!acqDealId) return null;
+      try {
+        return await apiRequest(`/deals/${acqDealId}`);
+      } catch (err) {
+        if (err instanceof APIClientError && err.statusCode === 404) return null;
+        throw err;
+      }
     },
-    enabled: isReady && !!organizationId
+    enabled: isReady && !!acqDealId
   });
 }
-function useCalibrationProjects(resourceId, resourceType) {
-  const { apiRequest, organizationId, isReady } = useElevasisServices();
+function useSyncDealStage() {
+  const { apiRequest, organizationId } = useElevasisServices();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async ({ dealId, stage }) => {
+      await apiRequest(`/deals/${dealId}/sync-stage`, {
+        method: "PATCH",
+        body: JSON.stringify({ stage })
+      });
+    },
+    onSuccess: (_, variables) => {
+      queryClient.invalidateQueries({ queryKey: ["deals", organizationId] });
+      queryClient.invalidateQueries({ queryKey: ["deal-detail", organizationId, variables.dealId] });
+    },
+    onError: (error) => {
+      queryClient.invalidateQueries({ queryKey: dealKeys.all });
+      showApiErrorNotification(error);
+    }
+  });
+}
+var dealNoteKeys = {
+  all: ["deal-notes"],
+  list: (organizationId, dealId) => ["deal-notes", organizationId, dealId]
+};
+function useDealNotes(dealId) {
+  const { apiRequest, isReady, organizationId } = useElevasisServices();
   return useQuery({
-    queryKey: calibrationKeys.projectsByResource(organizationId ?? "none", resourceId, resourceType),
+    queryKey: dealNoteKeys.list(organizationId, dealId),
     queryFn: async () => {
-      const response = await apiRequest(
-        `/calibration/projects?resourceId=${resourceId}&resourceType=${resourceType}`
-      );
-      return response.projects;
+      return apiRequest(`/deals/${dealId}/notes`);
     },
-    enabled: isReady && !!resourceId && !!resourceType && !!organizationId
+    enabled: isReady && !!dealId
   });
 }
-function useCalibrationProject(projectId) {
-  const { apiRequest, organizationId, isReady } = useElevasisServices();
+function useCreateDealNote() {
+  const { apiRequest, organizationId } = useElevasisServices();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async ({ dealId, body }) => {
+      return apiRequest(`/deals/${dealId}/notes`, {
+        method: "POST",
+        body: JSON.stringify({ body })
+      });
+    },
+    onSuccess: (_, variables) => {
+      queryClient.invalidateQueries({ queryKey: dealNoteKeys.list(organizationId, variables.dealId) });
+      queryClient.invalidateQueries({ queryKey: ["recent-crm-activity", organizationId] });
+      showSuccessNotification("Note added");
+    },
+    onError: (error) => {
+      showApiErrorNotification(error);
+    }
+  });
+}
+var dealTaskKeys = {
+  all: ["deal-tasks"],
+  list: (orgId, dealId) => ["deal-tasks", orgId, dealId],
+  due: (orgId, window, assigneeUserId) => ["deal-tasks-due", orgId, window, assigneeUserId]
+};
+function useDealTasks(dealId) {
+  const { apiRequest, isReady, organizationId } = useElevasisServices();
   return useQuery({
-    queryKey: calibrationKeys.project(organizationId ?? "none", projectId),
+    queryKey: dealTaskKeys.list(organizationId, dealId ?? ""),
     queryFn: async () => {
-      const response = await apiRequest(`/calibration/projects/${projectId}`);
-      return response.project;
+      return apiRequest(`/deals/${dealId}/tasks`);
     },
-    enabled: isReady && !!projectId && !!organizationId
+    enabled: isReady && !!dealId
   });
 }
-function useCreateProject() {
+function useDealTasksDue(opts) {
+  const { apiRequest, isReady, organizationId } = useElevasisServices();
+  const window = opts?.window ?? "today_and_overdue";
+  const assigneeUserId = opts?.assigneeUserId ?? null;
+  return useQuery({
+    queryKey: dealTaskKeys.due(organizationId, window, assigneeUserId),
+    queryFn: async () => {
+      const params = new URLSearchParams({ window });
+      if (assigneeUserId) params.set("assigneeUserId", assigneeUserId);
+      return apiRequest(`/deals/tasks/due?${params.toString()}`);
+    },
+    enabled: isReady
+  });
+}
+function useCreateDealTask() {
   const { apiRequest, organizationId } = useElevasisServices();
   const queryClient = useQueryClient();
   return useMutation({
-    mutationFn: async (input) => {
-      const response = await apiRequest("/calibration/projects", {
+    mutationFn: async (params) => {
+      const { dealId, ...body } = params;
+      return apiRequest(`/deals/${dealId}/tasks`, {
         method: "POST",
-        body: JSON.stringify(input)
+        body: JSON.stringify({
+          title: body.title,
+          description: body.description ?? null,
+          kind: body.kind ?? "other",
+          dueAt: body.dueAt ?? null,
+          assigneeUserId: body.assigneeUserId ?? null
+        })
       });
-      return response.project;
     },
-    onSuccess: (data) => {
-      queryClient.invalidateQueries({
-        queryKey: calibrationKeys.projects(organizationId ?? "none")
-      });
-      queryClient.invalidateQueries({
-        queryKey: calibrationKeys.projectsByResource(organizationId ?? "none", data.resourceId, data.resourceType)
-      });
+    onSuccess: (_, variables) => {
+      queryClient.invalidateQueries({ queryKey: dealTaskKeys.list(organizationId, variables.dealId) });
+      queryClient.invalidateQueries({ queryKey: ["deal-tasks-due", organizationId] });
+      showSuccessNotification("Task created");
     },
     onError: (error) => {
       showApiErrorNotification(error);
     }
   });
 }
-function useUpdateProject() {
+function useCompleteDealTask() {
   const { apiRequest, organizationId } = useElevasisServices();
   const queryClient = useQueryClient();
   return useMutation({
-    mutationFn: async ({
-      id,
-      ...input
-    }) => {
-      const response = await apiRequest(`/calibration/projects/${id}`, {
-        method: "PATCH",
-        body: JSON.stringify(input)
+    mutationFn: async ({ taskId, dealId }) => {
+      return apiRequest(`/deals/${dealId}/tasks/${taskId}/complete`, {
+        method: "PATCH"
       });
-      return response.project;
     },
-    onSuccess: (data) => {
-      queryClient.invalidateQueries({
-        queryKey: calibrationKeys.projects(organizationId ?? "none")
-      });
-      queryClient.invalidateQueries({
-        queryKey: calibrationKeys.projectsByResource(organizationId ?? "none", data.resourceId, data.resourceType)
-      });
-      queryClient.invalidateQueries({
-        queryKey: calibrationKeys.project(organizationId ?? "none", data.id)
-      });
+    onSuccess: (_, variables) => {
+      queryClient.invalidateQueries({ queryKey: dealTaskKeys.list(organizationId, variables.dealId) });
+      queryClient.invalidateQueries({ queryKey: ["deal-tasks-due", organizationId] });
+      showSuccessNotification("Task completed");
     },
     onError: (error) => {
       showApiErrorNotification(error);
     }
   });
 }
-function useDeleteProject() {
-  const { apiRequest } = useElevasisServices();
+function useBatchTelemetry() {
+  const { apiRequest, isReady, organizationId } = useElevasisServices();
+  return useQuery({
+    queryKey: ["acq-batch-telemetry", organizationId],
+    queryFn: () => apiRequest("/acquisition/batches/telemetry"),
+    enabled: isReady
+  });
+}
+
+// src/hooks/acquisition/useDeals.ts
+var dealKeys = {
+  all: ["deals"],
+  lists: () => [...dealKeys.all, "list"],
+  list: (orgId, filters) => [...dealKeys.all, "list", orgId, filters],
+  details: () => [...dealKeys.all, "detail"],
+  detail: (id) => [...dealKeys.all, "detail", id]
+};
+function useDeals(filters = {}) {
+  const { apiRequest, isReady, organizationId } = useElevasisServices();
+  return useQuery({
+    queryKey: dealKeys.list(organizationId, filters),
+    queryFn: async () => {
+      const params = new URLSearchParams();
+      if (filters.stage) params.set("stage", filters.stage);
+      if (filters.search) params.set("search", filters.search);
+      const qs = params.toString();
+      const data = await apiRequest(`/deals${qs ? `?${qs}` : ""}`);
+      return data;
+    },
+    enabled: isReady
+  });
+}
+function useDeleteDeal() {
+  const { apiRequest, organizationId } = useElevasisServices();
   const queryClient = useQueryClient();
   return useMutation({
-    mutationFn: async (id) => {
-      await apiRequest(`/calibration/projects/${id}`, {
-        method: "DELETE"
-      });
+    mutationFn: async (dealId) => {
+      await apiRequest(`/deals/${dealId}`, { method: "DELETE" });
     },
     onSuccess: () => {
-      queryClient.invalidateQueries({
-        queryKey: calibrationKeys.all
-      });
+      queryClient.invalidateQueries({ queryKey: ["deals", organizationId] });
     },
     onError: (error) => {
       showApiErrorNotification(error);
@@ -3010,4 +3205,4 @@ function useDeleteProject() {
   });
 }
 
-export { CredentialNameSchema, OperationsService, UuidSchema, calibrationKeys, createUseFeatureAccess, executionsKeys, isSessionCapable, operationsKeys, scheduleKeys, sessionsKeys, showApiErrorNotification, showErrorNotification, showInfoNotification, showSuccessNotification, showWarningNotification, sortData, useActivities, useActivityTrend, useAllCalibrationProjects, useArchiveSession, useArchivedLogs, useBatchDelete, useBatchedResourcesHealth, useBulkDeleteExecutions, useBusinessImpact, useCalibrationProject, useCalibrationProjects, useCalibrationRun, useCalibrationRunFull, useCalibrationRuns, useCalibrationSSE, useCancelExecution, useCancelSchedule, useCheckpointTasks, useCommandQueue, useCommandQueueTotals, useCommandViewData, useCommandViewLayout, useCommandViewStats, useCommandViewStore, useCostBreakdown, useCostByModel, useCostSummary, useCostTrends, useCreateProject, useCreateRun, useCreateSchedule, useCreateSession, useDashboardMetrics, useDeleteExecution, useDeleteProject, useDeleteRun, useDeleteSchedule, useDeleteSession, useDeleteTask, useDeploymentDocs, useErrorAnalysis, useErrorDetail, useErrorDetails, useErrorDistribution, useErrorNotification, useExecuteAsync, useExecuteRun, useExecuteWorkflow, useExecution, useExecutionHealth, useExecutionLogSSE, useExecutionLogs, useExecutionPanelState, useExecutions, useGetExecutionHistory, useGetSchedule, useGradeRun, useGraphStats, useListSchedules, useMarkAllAsRead, useMarkAsRead, useNotificationCount, useNotifications, usePaginationState, usePatchTask, usePauseSchedule, useRecentExecutionsByResource, useResolveAllErrors, useResolveError, useResolveErrorsByExecution, useResourceDefinition, useResourceErrors, useResourceExecutions, useResources, useResourcesHealth, useResumeSchedule, useRetryExecution, useSSEConnection, useScheduledTasks, useSession, useSessionExecution, useSessionExecutions, useSessionMessages, useSessionWebSocket, useSessions, useSortedData, useSubmitAction, useSuccessNotification, useTableSelection, useTableSort, useTestNotification, useTopFailingResources, useUnresolveError, useUnresolvedErrors, useUpdateAnchor, useUpdateProject, useUpdateSchedule, useWarningNotification };
+export { CredentialNameSchema, OperationsService, UuidSchema, calibrationKeys, createUseFeatureAccess, dealKeys, dealNoteKeys, dealTaskKeys, executionsKeys, isSessionCapable, operationsKeys, scheduleKeys, sessionsKeys, showApiErrorNotification, showErrorNotification, showInfoNotification, showSuccessNotification, showWarningNotification, sortData, useActivities, useActivityTrend, useAllCalibrationProjects, useArchiveSession, useArchivedLogs, useBatchDelete, useBatchTelemetry, useBatchedResourcesHealth, useBulkDeleteExecutions, useBusinessImpact, useCalibrationProject, useCalibrationProjects, useCalibrationRun, useCalibrationRunFull, useCalibrationRuns, useCalibrationSSE, useCancelExecution, useCancelSchedule, useCheckpointTasks, useCommandQueue, useCommandQueueTotals, useCommandViewData, useCommandViewLayout, useCommandViewStats, useCommandViewStore, useCompleteDealTask, useCostBreakdown, useCostByModel, useCostSummary, useCostTrends, useCreateDealNote, useCreateDealTask, useCreateProject, useCreateRun, useCreateSchedule, useCreateSession, useDashboardMetrics, useDealDetail, useDealNotes, useDealTasks, useDealTasksDue, useDeals, useDeleteDeal, useDeleteExecution, useDeleteProject, useDeleteRun, useDeleteSchedule, useDeleteSession, useDeleteTask, useDeploymentDocs, useErrorAnalysis, useErrorDetail, useErrorDetails, useErrorDistribution, useErrorNotification, useExecuteAsync, useExecuteRun, useExecuteWorkflow, useExecution, useExecutionHealth, useExecutionLogSSE, useExecutionLogs, useExecutionPanelState, useExecutions, useGetExecutionHistory, useGetSchedule, useGradeRun, useGraphStats, useListSchedules, useMarkAllAsRead, useMarkAsRead, useNotificationCount, useNotifications, usePaginationState, usePatchTask, usePauseSchedule, useRecentExecutionsByResource, useResolveAllErrors, useResolveError, useResolveErrorsByExecution, useResourceDefinition, useResourceErrors, useResourceExecutions, useResources, useResourcesHealth, useResumeSchedule, useRetryExecution, useSSEConnection, useScheduledTasks, useSession, useSessionExecution, useSessionExecutions, useSessionMessages, useSessionWebSocket, useSessions, useSortedData, useSubmitAction, useSuccessNotification, useSyncDealStage, useTableSelection, useTableSort, useTestNotification, useTopFailingResources, useUnresolveError, useUnresolvedErrors, useUpdateAnchor, useUpdateProject, useUpdateSchedule, useWarningNotification };

package/dist/components/index.d.ts

@@ -8365,26 +8365,26 @@ declare function useCrmQuickMetrics(): {
     error: unknown;
 };
 
-type CrmActivityKind = 'note' | 'stage_change' | 'deal_created';
-interface CrmActivityEntry {
-    id: string;
-    kind: CrmActivityKind;
-    dealId: string;
-    occurredAt: string;
-    description: string;
-    contactName?: string | null;
-    companyName?: string | null;
-    stage?: DealStage | null;
-}
+// ---------------------------------------------------------------------------
+// Response schemas (no .strict() — forward-compatible)
+// ---------------------------------------------------------------------------
+
+declare const GetRecentActivityResponseSchema = z.object({
+  entries: z.array(RecentActivityEntrySchema)
+})
+type GetRecentActivityResponse = z.infer<typeof GetRecentActivityResponseSchema>
+
 /**
- * Composite hook that surfaces the most recent activity across all deals.
- * Merges acq_deal_notes + activity_log entries from acq_deals, sorted newest-first.
- * Org-scoped: all queries include organization_id filter.
+ * Returns the most recent CRM activity entries (notes + stage changes + deal
+ * creations) for the current organization, aggregated server-side.
+ *
+ * Replaces the previous client-side aggregation that joined acq_deal_notes
+ * with useDeals(). Server now owns the join via GET /api/crm/recent-activity.
  */
 declare function useRecentCrmActivity(opts?: {
     limit?: number;
 }): {
-    data: CrmActivityEntry[];
+    data: GetRecentActivityResponse['entries'];
     isLoading: boolean;
     error: unknown;
 };