@elevasis/ui 2.73.0 → 2.75.0

package/dist/chunk-N6K2Q5BM.js

@@ -0,0 +1,393 @@
+import { REFETCH_INTERVAL_DASHBOARD } from './chunk-Y6I3IC45.js';
+import { useElevasisServices } from './chunk-BI5VDO2K.js';
+import { ResourceTypeSchema, NonEmptyStringSchema, OriginResourceTypeSchema, UuidSchema } from './chunk-TVTSASST.js';
+import { useQuery, useQueryClient, useMutation } from '@tanstack/react-query';
+import { z } from 'zod';
+
+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()),
+  label: z.string().optional()
+});
+var AbsoluteScheduleItemSchema = z.object({
+  runAt: z.string().datetime({ message: "Invalid datetime format" }),
+  payload: z.record(z.string(), z.unknown()),
+  label: z.string().optional()
+});
+var RecurringScheduleConfigSchema = z.object({
+  type: z.literal("recurring"),
+  cron: z.string().optional(),
+  interval: z.enum(["daily", "weekly", "monthly"]).optional(),
+  time: z.string().regex(/^\d{2}:\d{2}$/, "Time must be in HH:MM format").optional(),
+  timezone: z.string().min(1, "Timezone is required"),
+  payload: z.record(z.string(), z.unknown()),
+  endAt: z.string().datetime().nullable().optional(),
+  overduePolicy: z.enum(["skip", "execute"]).optional()
+}).refine((data) => data.cron || data.interval, { message: "Either cron or interval must be provided" });
+var RelativeScheduleConfigSchema = z.object({
+  type: z.literal("relative"),
+  anchorAt: z.string().datetime({ message: "Invalid anchor datetime" }),
+  anchorLabel: z.string().optional(),
+  items: z.array(RelativeScheduleItemSchema).min(1, "At least one item required"),
+  overduePolicy: z.enum(["skip", "execute"]).optional()
+});
+var AbsoluteScheduleConfigSchema = z.object({
+  type: z.literal("absolute"),
+  items: z.array(AbsoluteScheduleItemSchema).min(1, "At least one item required"),
+  overduePolicy: z.enum(["skip", "execute"]).optional()
+});
+var TaskScheduleConfigSchema = z.discriminatedUnion("type", [
+  RecurringScheduleConfigSchema,
+  RelativeScheduleConfigSchema,
+  AbsoluteScheduleConfigSchema
+]);
+var ScheduleTargetSchema = z.object({
+  resourceType: ResourceTypeSchema,
+  resourceId: NonEmptyStringSchema.max(255)
+});
+var OptionalOriginTrackingSchema = z.object({
+  originExecutionId: UuidSchema.optional(),
+  originResourceType: OriginResourceTypeSchema.optional(),
+  originResourceId: z.string().max(100).optional()
+});
+z.object({
+  organizationId: UuidSchema,
+  name: NonEmptyStringSchema.max(255),
+  description: z.string().max(1e3).optional(),
+  target: ScheduleTargetSchema,
+  scheduleConfig: TaskScheduleConfigSchema,
+  maxRetries: z.number().int().min(0).max(10).optional().default(3),
+  idempotencyKey: z.string().max(255).optional(),
+  metadata: z.record(z.string(), z.unknown()).optional()
+}).merge(OptionalOriginTrackingSchema);
+var CreateScheduleRequestSchema = z.object({
+  name: z.string().min(1, "Name is required").max(255),
+  description: z.string().max(1e3).optional(),
+  target: z.object({
+    resourceType: ResourceTypeSchema,
+    resourceId: z.string().min(1, "Resource ID is required").max(255)
+  }),
+  scheduleConfig: TaskScheduleConfigSchema,
+  maxRetries: z.number().int().min(0).max(10).optional(),
+  idempotencyKey: z.string().max(255).optional(),
+  // Origin tracking (optional)
+  originExecutionId: z.string().uuid().optional(),
+  originResourceType: OriginResourceTypeSchema.optional(),
+  originResourceId: z.string().max(255).optional()
+});
+z.object({
+  status: z.enum(["active", "paused", "completed", "cancelled"]).optional(),
+  targetResourceType: ResourceTypeSchema.optional(),
+  targetResourceId: z.string().optional(),
+  limit: z.coerce.number().int().min(1).max(100).optional().default(50),
+  offset: z.coerce.number().int().min(0).optional().default(0)
+});
+var GetScheduleParamsSchema = z.object({
+  id: z.string().uuid("Invalid schedule ID")
+});
+var UpdateAnchorRequestSchema = z.object({
+  anchorAt: z.string().datetime({ message: "Invalid anchor datetime format" })
+});
+var UpdateScheduleRequestSchema = z.object({
+  name: z.string().min(1, "Name cannot be empty").max(255).optional(),
+  description: z.string().max(1e3).nullable().optional(),
+  scheduleConfig: TaskScheduleConfigSchema.optional(),
+  maxRetries: z.number().int().min(0).max(10).optional()
+}).strict().refine(
+  (data) => data.name !== void 0 || data.description !== void 0 || data.scheduleConfig !== void 0 || data.maxRetries !== void 0,
+  { message: "At least one field (name, description, scheduleConfig, maxRetries) must be provided" }
+);
+z.object({
+  schedules: z.array(
+    z.object({
+      // Required identifiers
+      id: z.string().uuid(),
+      organization_id: z.string().uuid(),
+      name: z.string(),
+      // Target
+      target_resource_type: z.string(),
+      target_resource_id: z.string(),
+      // Schedule definition
+      schedule_config: z.record(z.string(), z.unknown()),
+      // JSONB from database
+      current_step: z.number().int(),
+      status: z.string(),
+      // Scheduling state
+      next_run_at: z.string().nullable(),
+      last_run_at: z.string().nullable(),
+      last_execution_id: z.string().uuid().nullable(),
+      // Config
+      max_retries: z.number().int(),
+      retry_count: z.number().int(),
+      idempotency_key: z.string().nullable(),
+      description: z.string().nullable(),
+      // Origin tracking
+      origin_execution_id: z.string().uuid().nullable(),
+      origin_resource_type: z.string().nullable(),
+      origin_resource_id: z.string().nullable(),
+      // Timestamps (PostgreSQL format with microseconds)
+      created_at: z.string(),
+      updated_at: z.string()
+    })
+  ).min(1).max(100)
+});
+z.object({
+  id: z.string().uuid("Invalid schedule ID")
+});
+z.object({
+  limit: z.coerce.number().int().min(1).max(100).optional().default(20),
+  offset: z.coerce.number().int().min(0).optional().default(0)
+});
+var ScheduleResponseSchema = z.object({
+  id: z.string().uuid(),
+  organizationId: z.string().uuid(),
+  name: z.string(),
+  description: z.string().nullable(),
+  target: z.object({
+    resourceType: ResourceTypeSchema,
+    resourceId: z.string()
+  }),
+  scheduleConfig: TaskScheduleConfigSchema,
+  nextRunAt: z.string().datetime().nullable(),
+  currentStep: z.number().int(),
+  status: z.enum(["active", "paused", "completed", "cancelled"]),
+  lastRunAt: z.string().datetime().nullable(),
+  lastExecutionId: z.string().uuid().nullable(),
+  maxRetries: z.number().int(),
+  idempotencyKey: z.string().nullable(),
+  createdAt: z.string().datetime(),
+  updatedAt: z.string().datetime()
+});
+z.object({
+  schedules: z.array(ScheduleResponseSchema),
+  total: z.number().int(),
+  limit: z.number().int(),
+  offset: z.number().int()
+});
+var ExecutionHistoryItemSchema = z.object({
+  id: z.string().uuid(),
+  createdAt: z.string().datetime(),
+  status: z.enum(["running", "completed", "failed", "cancelled"]),
+  step: z.number().int().nullable(),
+  itemLabel: z.string().nullable(),
+  duration: z.number().nullable(),
+  // milliseconds
+  error: z.string().nullable()
+});
+z.object({
+  executions: z.array(ExecutionHistoryItemSchema),
+  total: z.number().int(),
+  limit: z.number().int(),
+  offset: z.number().int()
+});
+z.object({
+  processed: z.number().int(),
+  succeeded: z.number().int(),
+  failed: z.number().int(),
+  errors: z.array(
+    z.object({
+      scheduleId: z.string().uuid(),
+      error: z.string()
+    })
+  ).optional()
+});
+
+// src/hooks/scheduling/useScheduledTasks.ts
+function useScheduledTasks(options = {}) {
+  const { apiRequest, workOSOrganizationId, isReady } = useElevasisServices();
+  return useQuery({
+    queryKey: ["schedules", "dashboard", workOSOrganizationId, options.status, options.targetResourceType],
+    queryFn: async () => {
+      const params = new URLSearchParams();
+      if (options.status) params.append("status", options.status);
+      if (options.targetResourceType) params.append("targetResourceType", options.targetResourceType);
+      const queryString = params.toString();
+      const response = await apiRequest(
+        `/task-scheduler/schedules${queryString ? `?${queryString}` : ""}`
+      );
+      return response.schedules;
+    },
+    enabled: isReady,
+    refetchInterval: REFETCH_INTERVAL_DASHBOARD
+  });
+}
+
+// src/hooks/scheduling/queryKeys.ts
+var scheduleKeys = {
+  all: (orgId) => ["schedules", orgId],
+  lists: (orgId) => [...scheduleKeys.all(orgId), "list"],
+  list: (orgId, filters) => [...scheduleKeys.lists(orgId), filters],
+  details: (orgId) => [...scheduleKeys.all(orgId), "detail"],
+  detail: (orgId, id) => [...scheduleKeys.details(orgId), id],
+  executions: (orgId, id) => [...scheduleKeys.detail(orgId, id), "executions"]
+};
+function useListSchedules(filters) {
+  const { apiRequest, workOSOrganizationId, isReady } = useElevasisServices();
+  return useQuery({
+    queryKey: scheduleKeys.list(workOSOrganizationId, filters),
+    queryFn: async () => {
+      const params = new URLSearchParams();
+      if (filters?.status) params.set("status", filters.status);
+      if (filters?.targetResourceType) params.set("targetResourceType", filters.targetResourceType);
+      if (filters?.targetResourceId) params.set("targetResourceId", filters.targetResourceId);
+      if (filters?.limit) params.set("limit", String(filters.limit));
+      if (filters?.offset) params.set("offset", String(filters.offset));
+      const queryString = params.toString();
+      const endpoint = `/task-scheduler/schedules${queryString ? `?${queryString}` : ""}`;
+      return apiRequest(endpoint);
+    },
+    enabled: isReady
+  });
+}
+function useGetSchedule(id) {
+  const { apiRequest, workOSOrganizationId, isReady } = useElevasisServices();
+  return useQuery({
+    queryKey: scheduleKeys.detail(workOSOrganizationId, id),
+    queryFn: async () => {
+      const data = await apiRequest(`/task-scheduler/schedules/${id}`);
+      return data.schedule;
+    },
+    enabled: isReady && !!id
+  });
+}
+function useGetExecutionHistory(scheduleId, options) {
+  const { apiRequest, workOSOrganizationId, isReady } = useElevasisServices();
+  return useQuery({
+    queryKey: [...scheduleKeys.executions(workOSOrganizationId, scheduleId), options?.limit, options?.offset],
+    queryFn: async () => {
+      const params = new URLSearchParams();
+      if (options?.limit) params.set("limit", String(options.limit));
+      if (options?.offset) params.set("offset", String(options.offset));
+      const queryString = params.toString();
+      const endpoint = `/task-scheduler/schedules/${scheduleId}/executions${queryString ? `?${queryString}` : ""}`;
+      return apiRequest(endpoint);
+    },
+    enabled: isReady && !!scheduleId
+  });
+}
+function useCreateSchedule() {
+  const queryClient = useQueryClient();
+  const { apiRequest, workOSOrganizationId } = useElevasisServices();
+  return useMutation({
+    mutationFn: async (input) => {
+      const validated = CreateScheduleRequestSchema.parse(input);
+      const data = await apiRequest("/task-scheduler/schedules", {
+        method: "POST",
+        body: JSON.stringify(validated)
+      });
+      return data.schedule;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: scheduleKeys.lists(workOSOrganizationId) });
+    }
+  });
+}
+function useUpdateSchedule() {
+  const queryClient = useQueryClient();
+  const { apiRequest, workOSOrganizationId } = useElevasisServices();
+  return useMutation({
+    mutationFn: async ({ id, ...fields }) => {
+      GetScheduleParamsSchema.parse({ id });
+      const validated = UpdateScheduleRequestSchema.parse(fields);
+      const data = await apiRequest(`/task-scheduler/schedules/${id}`, {
+        method: "PATCH",
+        body: JSON.stringify(validated)
+      });
+      return data.schedule;
+    },
+    onSuccess: (_, variables) => {
+      queryClient.invalidateQueries({
+        queryKey: scheduleKeys.detail(workOSOrganizationId, variables.id)
+      });
+      queryClient.invalidateQueries({ queryKey: scheduleKeys.lists(workOSOrganizationId) });
+    }
+  });
+}
+function useUpdateAnchor() {
+  const queryClient = useQueryClient();
+  const { apiRequest, workOSOrganizationId } = useElevasisServices();
+  return useMutation({
+    mutationFn: async ({ id, anchorAt }) => {
+      GetScheduleParamsSchema.parse({ id });
+      UpdateAnchorRequestSchema.parse({ anchorAt });
+      const data = await apiRequest(`/task-scheduler/schedules/${id}/anchor`, {
+        method: "PATCH",
+        body: JSON.stringify({ anchorAt })
+      });
+      return data.schedule;
+    },
+    onSuccess: (_, variables) => {
+      queryClient.invalidateQueries({
+        queryKey: scheduleKeys.detail(workOSOrganizationId, variables.id)
+      });
+      queryClient.invalidateQueries({ queryKey: scheduleKeys.lists(workOSOrganizationId) });
+    }
+  });
+}
+function usePauseSchedule() {
+  const queryClient = useQueryClient();
+  const { apiRequest, workOSOrganizationId } = useElevasisServices();
+  return useMutation({
+    mutationFn: async (id) => {
+      GetScheduleParamsSchema.parse({ id });
+      const data = await apiRequest(`/task-scheduler/schedules/${id}/pause`, {
+        method: "POST"
+      });
+      return data.schedule;
+    },
+    onSuccess: (_, id) => {
+      queryClient.invalidateQueries({ queryKey: scheduleKeys.detail(workOSOrganizationId, id) });
+      queryClient.invalidateQueries({ queryKey: scheduleKeys.lists(workOSOrganizationId) });
+    }
+  });
+}
+function useResumeSchedule() {
+  const queryClient = useQueryClient();
+  const { apiRequest, workOSOrganizationId } = useElevasisServices();
+  return useMutation({
+    mutationFn: async (id) => {
+      GetScheduleParamsSchema.parse({ id });
+      const data = await apiRequest(`/task-scheduler/schedules/${id}/resume`, {
+        method: "POST"
+      });
+      return data.schedule;
+    },
+    onSuccess: (_, id) => {
+      queryClient.invalidateQueries({ queryKey: scheduleKeys.detail(workOSOrganizationId, id) });
+      queryClient.invalidateQueries({ queryKey: scheduleKeys.lists(workOSOrganizationId) });
+    }
+  });
+}
+function useCancelSchedule() {
+  const queryClient = useQueryClient();
+  const { apiRequest, workOSOrganizationId } = useElevasisServices();
+  return useMutation({
+    mutationFn: async (id) => {
+      GetScheduleParamsSchema.parse({ id });
+      const data = await apiRequest(`/task-scheduler/schedules/${id}/cancel`, {
+        method: "POST"
+      });
+      return data.schedule;
+    },
+    onSuccess: (_, id) => {
+      queryClient.invalidateQueries({ queryKey: scheduleKeys.detail(workOSOrganizationId, id) });
+      queryClient.invalidateQueries({ queryKey: scheduleKeys.lists(workOSOrganizationId) });
+    }
+  });
+}
+function useDeleteSchedule() {
+  const queryClient = useQueryClient();
+  const { apiRequest, workOSOrganizationId } = useElevasisServices();
+  return useMutation({
+    mutationFn: async (id) => {
+      GetScheduleParamsSchema.parse({ id });
+      await apiRequest(`/task-scheduler/schedules/${id}`, { method: "DELETE" });
+    },
+    onSuccess: (_, id) => {
+      queryClient.invalidateQueries({ queryKey: scheduleKeys.detail(workOSOrganizationId, id) });
+      queryClient.invalidateQueries({ queryKey: scheduleKeys.lists(workOSOrganizationId) });
+    }
+  });
+}
+
+export { scheduleKeys, useCancelSchedule, useCreateSchedule, useDeleteSchedule, useGetExecutionHistory, useGetSchedule, useListSchedules, usePauseSchedule, useResumeSchedule, useScheduledTasks, useUpdateAnchor, useUpdateSchedule };