chore: import upstream snapshot with attribution

apps/sim/hooks/queries/schedules.ts

@@ -0,0 +1,474 @@
+import { toast } from '@sim/emcn'
+import { createLogger } from '@sim/logger'
+import { getErrorMessage } from '@sim/utils/errors'
+import { keepPreviousData, useMutation, useQuery, useQueryClient } from '@tanstack/react-query'
+import { isApiClientError } from '@/lib/api/client/errors'
+import { requestJson } from '@/lib/api/client/request'
+import { deployWorkflowContract } from '@/lib/api/contracts/deployments'
+import {
+  type CreateScheduleBody,
+  createScheduleContract,
+  deleteScheduleContract,
+  disableScheduleContract,
+  excludeOccurrenceContract,
+  getScheduleByIdContract,
+  getScheduleContract,
+  listWorkspaceSchedulesContract,
+  reactivateScheduleContract,
+  type UpdateScheduleBody,
+  updateScheduleContract,
+  type WorkflowScheduleRow,
+  type WorkspaceScheduleRow,
+} from '@/lib/api/contracts/schedules'
+import { parseCronToHumanReadable } from '@/lib/workflows/schedules/utils'
+import { deploymentKeys } from '@/hooks/queries/deployments'
+
+const logger = createLogger('ScheduleQueries')
+
+export const SCHEDULE_LIST_STALE_TIME = 30 * 1000
+export const SCHEDULE_DETAIL_STALE_TIME = 30 * 1000
+export const SCHEDULE_BLOCK_STALE_TIME = 30 * 1000
+
+export const scheduleKeys = {
+  all: ['schedules'] as const,
+  lists: () => [...scheduleKeys.all, 'list'] as const,
+  list: (workspaceId: string) => [...scheduleKeys.lists(), workspaceId] as const,
+  details: () => [...scheduleKeys.all, 'detail'] as const,
+  schedule: (workflowId: string, blockId: string) =>
+    [...scheduleKeys.details(), workflowId, blockId] as const,
+  byId: (scheduleId: string) => [...scheduleKeys.details(), scheduleId] as const,
+}
+
+export type ScheduleData = WorkflowScheduleRow
+export type WorkspaceScheduleData = WorkspaceScheduleRow
+
+export interface ScheduleInfo {
+  id: string
+  status: ScheduleData['status']
+  scheduleTiming: string
+  nextRunAt: string | null
+  lastRanAt: string | null
+  timezone: string
+  isDisabled: boolean
+  failedCount: number
+}
+
+/**
+ * Fetches schedule data for a specific workflow block
+ */
+async function fetchSchedule(
+  workflowId: string,
+  blockId: string,
+  signal?: AbortSignal
+): Promise<ScheduleData | null> {
+  try {
+    const data = await requestJson(getScheduleContract, {
+      query: { workflowId, blockId },
+      signal,
+    })
+    return data.schedule || null
+  } catch (error) {
+    if (isApiClientError(error) && error.status === 404) return null
+    throw error
+  }
+}
+
+/**
+ * Fetch all schedules for a workspace.
+ */
+export function useWorkspaceSchedules(workspaceId?: string) {
+  return useQuery({
+    queryKey: scheduleKeys.list(workspaceId ?? ''),
+    queryFn: async ({ signal }) => {
+      if (!workspaceId) throw new Error('Workspace ID required')
+
+      const data = await requestJson(listWorkspaceSchedulesContract, {
+        query: { workspaceId },
+        signal,
+      })
+      return data.schedules || []
+    },
+    enabled: Boolean(workspaceId),
+    staleTime: SCHEDULE_LIST_STALE_TIME,
+    placeholderData: keepPreviousData,
+  })
+}
+
+/**
+ * Fetch a single schedule (job) by id. Used by the mothership resource viewer so
+ * opening a scheduled-task artifact does a lightweight by-id read instead of the
+ * whole-workspace `useWorkspaceSchedules` fetch (which contended with the chat
+ * stream connection and stalled start/resume).
+ */
+export function useScheduleById(scheduleId?: string) {
+  return useQuery({
+    queryKey: scheduleKeys.byId(scheduleId ?? ''),
+    queryFn: async ({ signal }) => {
+      if (!scheduleId) throw new Error('Schedule ID required')
+
+      const data = await requestJson(getScheduleByIdContract, {
+        params: { id: scheduleId },
+        signal,
+      })
+      return data.schedule
+    },
+    enabled: Boolean(scheduleId),
+    staleTime: SCHEDULE_DETAIL_STALE_TIME,
+    placeholderData: keepPreviousData,
+  })
+}
+
+/**
+ * Hook to fetch schedule data for a workflow block
+ */
+export function useScheduleQuery(
+  workflowId: string | undefined,
+  blockId: string | undefined,
+  options?: { enabled?: boolean }
+) {
+  return useQuery({
+    queryKey: scheduleKeys.schedule(workflowId ?? '', blockId ?? ''),
+    queryFn: ({ signal }) => fetchSchedule(workflowId!, blockId!, signal),
+    enabled: !!workflowId && !!blockId && (options?.enabled ?? true),
+    staleTime: SCHEDULE_BLOCK_STALE_TIME,
+    retry: false,
+    placeholderData: keepPreviousData,
+  })
+}
+
+/**
+ * Hook to get processed schedule info with human-readable timing
+ */
+export function useScheduleInfo(
+  workflowId: string | undefined,
+  blockId: string | undefined,
+  blockType: string,
+  options?: { timezone?: string }
+): {
+  scheduleInfo: ScheduleInfo | null
+  isLoading: boolean
+  refetch: () => void
+} {
+  const isScheduleBlock = blockType === 'schedule'
+
+  const { data, isLoading, refetch } = useScheduleQuery(workflowId, blockId, {
+    enabled: isScheduleBlock,
+  })
+
+  if (!data) {
+    return { scheduleInfo: null, isLoading, refetch }
+  }
+
+  const timezone = options?.timezone || data.timezone || 'UTC'
+  const scheduleTiming = data.cronExpression
+    ? parseCronToHumanReadable(data.cronExpression, timezone)
+    : 'Unknown schedule'
+
+  return {
+    scheduleInfo: {
+      id: data.id,
+      status: data.status,
+      scheduleTiming,
+      nextRunAt: data.nextRunAt,
+      lastRanAt: data.lastRanAt,
+      timezone,
+      isDisabled: data.status === 'disabled',
+      failedCount: data.failedCount || 0,
+    },
+    isLoading,
+    refetch,
+  }
+}
+
+/**
+ * Mutation to reactivate a disabled schedule
+ */
+export function useReactivateSchedule() {
+  const queryClient = useQueryClient()
+
+  return useMutation({
+    mutationFn: async ({
+      scheduleId,
+      workflowId,
+      blockId,
+      workspaceId,
+    }: {
+      scheduleId: string
+      workflowId: string
+      blockId: string
+      workspaceId?: string
+    }) => {
+      await requestJson(reactivateScheduleContract, {
+        params: { id: scheduleId },
+        body: { action: 'reactivate' },
+      })
+
+      return { workflowId, blockId, workspaceId }
+    },
+    onSuccess: ({ workflowId, blockId }) => {
+      logger.info('Schedule reactivated', { workflowId, blockId })
+    },
+    onError: (error) => {
+      logger.error('Failed to reactivate schedule', { error })
+    },
+    onSettled: async (data) => {
+      if (!data) return
+      const { workflowId, blockId, workspaceId } = data
+      await Promise.all([
+        queryClient.invalidateQueries({ queryKey: scheduleKeys.schedule(workflowId, blockId) }),
+        workspaceId
+          ? queryClient.invalidateQueries({ queryKey: scheduleKeys.list(workspaceId) })
+          : Promise.resolve(),
+      ])
+    },
+  })
+}
+
+/**
+ * Mutation to disable an active schedule or job
+ */
+export function useDisableSchedule() {
+  const queryClient = useQueryClient()
+
+  return useMutation({
+    mutationFn: async ({
+      scheduleId,
+      workspaceId,
+    }: {
+      scheduleId: string
+      workspaceId: string
+    }) => {
+      await requestJson(disableScheduleContract, {
+        params: { id: scheduleId },
+        body: { action: 'disable' },
+      })
+
+      return { workspaceId }
+    },
+    onSuccess: () => {
+      toast.success('Task paused')
+    },
+    onError: (error) => {
+      logger.error('Failed to disable schedule', { error })
+      toast.error("Couldn't pause task", { description: getErrorMessage(error) })
+    },
+    onSettled: async (data) => {
+      if (!data) return
+      await Promise.all([
+        queryClient.invalidateQueries({ queryKey: scheduleKeys.list(data.workspaceId) }),
+        queryClient.invalidateQueries({ queryKey: scheduleKeys.details() }),
+      ])
+    },
+  })
+}
+
+/**
+ * Mutation to resume (reactivate) a paused standalone job schedule. Keyed by
+ * `workspaceId` so it invalidates the workspace list; the workflow-block variant
+ * {@link useReactivateSchedule} keys by `workflowId`/`blockId` instead. Resuming
+ * recomputes `nextRunAt` from the schedule's cron, so it applies to recurring
+ * tasks only — one-time tasks carry no cadence to resume.
+ */
+export function useResumeSchedule() {
+  const queryClient = useQueryClient()
+
+  return useMutation({
+    mutationFn: async ({
+      scheduleId,
+      workspaceId,
+    }: {
+      scheduleId: string
+      workspaceId: string
+    }) => {
+      await requestJson(reactivateScheduleContract, {
+        params: { id: scheduleId },
+        body: { action: 'reactivate' },
+      })
+
+      return { workspaceId }
+    },
+    onSuccess: () => {
+      toast.success('Task resumed')
+    },
+    onError: (error) => {
+      logger.error('Failed to resume schedule', { error })
+      toast.error("Couldn't resume task", { description: getErrorMessage(error) })
+    },
+    onSettled: async (data) => {
+      if (!data) return
+      await Promise.all([
+        queryClient.invalidateQueries({ queryKey: scheduleKeys.list(data.workspaceId) }),
+        queryClient.invalidateQueries({ queryKey: scheduleKeys.details() }),
+      ])
+    },
+  })
+}
+
+/**
+ * Mutation to delete a schedule or job
+ */
+export function useDeleteSchedule() {
+  const queryClient = useQueryClient()
+
+  return useMutation({
+    mutationFn: async ({
+      scheduleId,
+      workspaceId,
+    }: {
+      scheduleId: string
+      workspaceId: string
+    }) => {
+      await requestJson(deleteScheduleContract, {
+        params: { id: scheduleId },
+      })
+
+      return { workspaceId }
+    },
+    onSuccess: () => {
+      toast.success('Task deleted')
+    },
+    onError: (error) => {
+      logger.error('Failed to delete schedule', { error })
+      toast.error("Couldn't delete task", { description: getErrorMessage(error) })
+    },
+    onSettled: async (data) => {
+      if (!data) return
+      await Promise.all([
+        queryClient.invalidateQueries({ queryKey: scheduleKeys.list(data.workspaceId) }),
+        queryClient.invalidateQueries({ queryKey: scheduleKeys.details() }),
+      ])
+    },
+  })
+}
+
+/**
+ * Mutation to delete a single occurrence of a recurring task (gcal "this
+ * event"). The whole series is deleted via {@link useDeleteSchedule} instead.
+ */
+export function useExcludeOccurrence() {
+  const queryClient = useQueryClient()
+
+  return useMutation({
+    mutationFn: async ({
+      scheduleId,
+      occurrence,
+      workspaceId,
+    }: {
+      scheduleId: string
+      occurrence: string
+      workspaceId: string
+    }) => {
+      await requestJson(excludeOccurrenceContract, {
+        params: { id: scheduleId },
+        body: { action: 'exclude_occurrence', occurrence },
+      })
+
+      return { workspaceId }
+    },
+    onSuccess: () => {
+      toast.success('Occurrence removed')
+    },
+    onError: (error) => {
+      logger.error('Failed to delete occurrence', { error })
+      toast.error("Couldn't remove occurrence", { description: getErrorMessage(error) })
+    },
+    onSettled: async (data) => {
+      if (!data) return
+      await Promise.all([
+        queryClient.invalidateQueries({ queryKey: scheduleKeys.list(data.workspaceId) }),
+        queryClient.invalidateQueries({ queryKey: scheduleKeys.details() }),
+      ])
+    },
+  })
+}
+
+/**
+ * Mutation to update fields on a standalone job schedule
+ */
+export function useUpdateSchedule() {
+  const queryClient = useQueryClient()
+
+  return useMutation({
+    mutationFn: async ({
+      scheduleId,
+      workspaceId,
+      ...updates
+    }: {
+      scheduleId: string
+      workspaceId: string
+    } & Omit<UpdateScheduleBody, 'action'>) => {
+      await requestJson(updateScheduleContract, {
+        params: { id: scheduleId },
+        body: { action: 'update', ...updates },
+      })
+
+      return { workspaceId }
+    },
+    onSuccess: () => {
+      toast.success('Task updated')
+    },
+    onError: (error) => {
+      logger.error('Failed to update schedule', { error })
+      toast.error("Couldn't update task", { description: getErrorMessage(error) })
+    },
+    onSettled: async (data) => {
+      if (!data) return
+      await Promise.all([
+        queryClient.invalidateQueries({ queryKey: scheduleKeys.list(data.workspaceId) }),
+        queryClient.invalidateQueries({ queryKey: scheduleKeys.details() }),
+      ])
+    },
+  })
+}
+
+/**
+ * Mutation to create a standalone scheduled job
+ */
+export function useCreateSchedule() {
+  const queryClient = useQueryClient()
+
+  return useMutation({
+    mutationFn: async (body: CreateScheduleBody) => requestJson(createScheduleContract, { body }),
+    onSuccess: () => {
+      toast.success('Task scheduled')
+    },
+    onError: (error) => {
+      logger.error('Failed to create schedule', { error })
+      toast.error("Couldn't schedule task", { description: getErrorMessage(error) })
+    },
+    onSettled: (_data, _error, variables) =>
+      queryClient.invalidateQueries({ queryKey: scheduleKeys.list(variables.workspaceId) }),
+  })
+}
+
+/**
+ * Mutation to redeploy a workflow (which recreates the schedule)
+ */
+export function useRedeployWorkflowSchedule() {
+  const queryClient = useQueryClient()
+
+  return useMutation({
+    mutationFn: async ({ workflowId, blockId }: { workflowId: string; blockId: string }) => {
+      await requestJson(deployWorkflowContract, {
+        params: { id: workflowId },
+      })
+
+      return { workflowId, blockId }
+    },
+    onSuccess: ({ workflowId, blockId }) => {
+      logger.info('Workflow redeployed for schedule reset', { workflowId, blockId })
+    },
+    onError: (error) => {
+      logger.error('Failed to redeploy workflow', { error })
+    },
+    onSettled: async (data) => {
+      if (!data) return
+      const { workflowId, blockId } = data
+      await Promise.all([
+        queryClient.invalidateQueries({ queryKey: scheduleKeys.schedule(workflowId, blockId) }),
+        queryClient.invalidateQueries({ queryKey: deploymentKeys.info(workflowId) }),
+        queryClient.invalidateQueries({ queryKey: deploymentKeys.versions(workflowId) }),
+      ])
+    },
+  })
+}