cleanup, edge cases

Author: waleedlatif1

apps/sim/app/api/schedules/[id]/route.test.ts

@@ -6,6 +6,7 @@ import { z } from 'zod'
 import { getSession } from '@/lib/auth'
 import { generateRequestId } from '@/lib/core/utils/request'
 import { createLogger } from '@/lib/logs/console/logger'
+import { validateCronExpression } from '@/lib/workflows/schedules/utils'
 import { getUserEntityPermissions } from '@/lib/workspaces/permissions/utils'
 
 const logger = createLogger('ScheduleAPI')
@@ -44,6 +45,8 @@ export async function PUT(request: NextRequest, { params }: { params: Promise<{
         id: workflowSchedule.id,
         workflowId: workflowSchedule.workflowId,
         status: workflowSchedule.status,
+        cronExpression: workflowSchedule.cronExpression,
+        timezone: workflowSchedule.timezone,
       })
       .from(workflowSchedule)
       .where(eq(workflowSchedule.id, scheduleId))
@@ -85,8 +88,19 @@ export async function PUT(request: NextRequest, { params }: { params: Promise<{
       return NextResponse.json({ message: 'Schedule is already active' }, { status: 200 })
     }
 
+    if (!schedule.cronExpression) {
+      logger.error(`[${requestId}] Schedule has no cron expression: ${scheduleId}`)
+      return NextResponse.json({ error: 'Schedule has no cron expression' }, { status: 400 })
+    }
+
+    const cronResult = validateCronExpression(schedule.cronExpression, schedule.timezone || 'UTC')
+    if (!cronResult.isValid || !cronResult.nextRun) {
+      logger.error(`[${requestId}] Invalid cron expression for schedule: ${scheduleId}`)
+      return NextResponse.json({ error: 'Schedule has invalid cron expression' }, { status: 400 })
+    }
+
     const now = new Date()
-    const nextRunAt = new Date(now.getTime() + 60 * 1000) // Schedule to run in 1 minute
+    const nextRunAt = cronResult.nextRun
 
     await db
       .update(workflowSchedule)

apps/sim/app/api/schedules/[id]/route.ts

@@ -8,7 +8,7 @@ import {
   createSchedulesForDeploy,
   deleteSchedulesForWorkflow,
   validateWorkflowSchedules,
-} from '@/lib/workflows/schedules/deploy'
+} from '@/lib/workflows/schedules'
 import { validateWorkflowPermissions } from '@/lib/workflows/utils'
 import { createErrorResponse, createSuccessResponse } from '@/app/api/workflows/utils'
 
@@ -103,20 +103,17 @@ export async function POST(request: NextRequest, { params }: { params: Promise<{
       return createErrorResponse(error.message, error.status)
     }
 
-    // Attribution: this route is UI-only; require session user as actor
     const actorUserId: string | null = session?.user?.id ?? null
     if (!actorUserId) {
       logger.warn(`[${requestId}] Unable to resolve actor user for workflow deployment: ${id}`)
       return createErrorResponse('Unable to determine deploying user', 400)
     }
 
-    // Load current workflow state to validate schedule blocks before deployment
     const normalizedData = await loadWorkflowFromNormalizedTables(id)
     if (!normalizedData) {
       return createErrorResponse('Failed to load workflow state', 500)
     }
 
-    // Validate schedule blocks before deploying
     const scheduleValidation = validateWorkflowSchedules(normalizedData.blocks)
     if (!scheduleValidation.isValid) {
       logger.warn(
@@ -137,11 +134,9 @@ export async function POST(request: NextRequest, { params }: { params: Promise<{
 
     const deployedAt = deployResult.deployedAt!
 
-    // Create or update schedules for the deployed workflow
     let scheduleInfo: { scheduleId?: string; cronExpression?: string; nextRunAt?: Date } = {}
     const scheduleResult = await createSchedulesForDeploy(id, normalizedData.blocks, db)
     if (!scheduleResult.success) {
-      // Log but don't fail deployment - schedule creation is secondary
       logger.error(
         `[${requestId}] Failed to create schedule for workflow ${id}: ${scheduleResult.error}`
       )
@@ -202,7 +197,6 @@ export async function DELETE(
     }
 
     await db.transaction(async (tx) => {
-      // Delete all schedules for this workflow
       await deleteSchedulesForWorkflow(id, tx)
 
       await tx
@@ -218,7 +212,6 @@ export async function DELETE(
 
     logger.info(`[${requestId}] Workflow undeployed successfully: ${id}`)
 
-    // Track workflow undeployment
     try {
       const { trackPlatformEvent } = await import('@/lib/core/telemetry')
       trackPlatformEvent('platform.workflow.undeployed', {

apps/sim/app/api/workflows/[id]/deploy/route.ts

@@ -573,6 +573,7 @@ export async function executeScheduleJob(payload: ScheduleExecutionPayload) {
             updatedAt: now,
             nextRunAt,
             failedCount: 0,
+            lastQueuedAt: null,
           },
           requestId,
           `Error updating schedule ${payload.scheduleId} after success`,

apps/sim/background/schedule-execution.ts

@@ -61,19 +61,13 @@ vi.mock('./utils', async (importOriginal) => {
   }
 })
 
-// Mock crypto.randomUUID
 vi.stubGlobal('crypto', {
   randomUUID: mockRandomUUID,
 })
 
-import {
-  createSchedulesForDeploy,
-  deleteSchedulesForWorkflow,
-  findScheduleBlocks,
-  validateScheduleBlock,
-  validateWorkflowSchedules,
-} from './deploy'
+import { createSchedulesForDeploy, deleteSchedulesForWorkflow } from './deploy'
 import type { BlockState } from './utils'
+import { findScheduleBlocks, validateScheduleBlock, validateWorkflowSchedules } from './validation'
 
 describe('Schedule Deploy Utilities', () => {
   beforeEach(() => {

apps/sim/lib/workflows/schedules/deploy.test.ts

@@ -5,14 +5,8 @@ import { eq } from 'drizzle-orm'
 import type { PgTransaction } from 'drizzle-orm/pg-core'
 import type { PostgresJsQueryResultHKT } from 'drizzle-orm/postgres-js'
 import { createLogger } from '@/lib/logs/console/logger'
-import {
-  type BlockState,
-  calculateNextRunTime,
-  generateCronExpression,
-  getScheduleTimeValues,
-  getSubBlockValue,
-  validateCronExpression,
-} from './utils'
+import type { BlockState } from '@/lib/workflows/schedules/utils'
+import { findScheduleBlocks, validateScheduleBlock } from '@/lib/workflows/schedules/validation'
 
 const logger = createLogger('ScheduleDeployUtils')
 
@@ -28,18 +22,6 @@ type DbOrTx =
       ExtractTablesWithRelations<typeof schema>
     >
 
-/**
- * Result of schedule validation
- */
-export interface ScheduleValidationResult {
-  isValid: boolean
-  error?: string
-  scheduleType?: string
-  cronExpression?: string
-  nextRunAt?: Date
-  timezone?: string
-}
-
 /**
  * Result of schedule creation during deploy
  */
@@ -52,166 +34,6 @@ export interface ScheduleDeployResult {
   timezone?: string
 }
 
-/**
- * Check if a time value is valid (not empty/null/undefined)
- */
-function isValidTimeValue(value: string | null | undefined): boolean {
-  return !!value && value.trim() !== '' && value.includes(':')
-}
-
-/**
- * Check if a schedule type has valid configuration
- * Uses raw block values to avoid false positives from default parsing
- */
-function hasValidScheduleConfig(scheduleType: string | undefined, block: BlockState): boolean {
-  switch (scheduleType) {
-    case 'minutes': {
-      const rawValue = getSubBlockValue(block, 'minutesInterval')
-      const numValue = Number(rawValue)
-      return !!rawValue && !Number.isNaN(numValue) && numValue >= 1 && numValue <= 1440
-    }
-    case 'hourly': {
-      const rawValue = getSubBlockValue(block, 'hourlyMinute')
-      const numValue = Number(rawValue)
-      return rawValue !== '' && !Number.isNaN(numValue) && numValue >= 0 && numValue <= 59
-    }
-    case 'daily': {
-      const rawTime = getSubBlockValue(block, 'dailyTime')
-      return isValidTimeValue(rawTime)
-    }
-    case 'weekly': {
-      const rawDay = getSubBlockValue(block, 'weeklyDay')
-      const rawTime = getSubBlockValue(block, 'weeklyDayTime')
-      return !!rawDay && isValidTimeValue(rawTime)
-    }
-    case 'monthly': {
-      const rawDay = getSubBlockValue(block, 'monthlyDay')
-      const rawTime = getSubBlockValue(block, 'monthlyTime')
-      const dayNum = Number(rawDay)
-      return (
-        !!rawDay &&
-        !Number.isNaN(dayNum) &&
-        dayNum >= 1 &&
-        dayNum <= 31 &&
-        isValidTimeValue(rawTime)
-      )
-    }
-    case 'custom':
-      return !!getSubBlockValue(block, 'cronExpression')
-    default:
-      return false
-  }
-}
-
-/**
- * Get human-readable error message for missing schedule configuration
- */
-function getMissingConfigError(scheduleType: string): string {
-  switch (scheduleType) {
-    case 'minutes':
-      return 'Minutes interval is required for minute-based schedules'
-    case 'hourly':
-      return 'Minute value is required for hourly schedules'
-    case 'daily':
-      return 'Time is required for daily schedules'
-    case 'weekly':
-      return 'Day and time are required for weekly schedules'
-    case 'monthly':
-      return 'Day and time are required for monthly schedules'
-    case 'custom':
-      return 'Cron expression is required for custom schedules'
-    default:
-      return 'Schedule type is required'
-  }
-}
-
-/**
- * Find schedule blocks in a workflow's blocks
- */
-export function findScheduleBlocks(blocks: Record<string, BlockState>): BlockState[] {
-  return Object.values(blocks).filter((block) => block.type === 'schedule')
-}
-
-/**
- * Validate a schedule block's configuration
- * Returns validation result with error details if invalid
- */
-export function validateScheduleBlock(block: BlockState): ScheduleValidationResult {
-  const scheduleType = getSubBlockValue(block, 'scheduleType')
-
-  if (!scheduleType) {
-    return {
-      isValid: false,
-      error: 'Schedule type is required',
-    }
-  }
-
-  const hasValidConfig = hasValidScheduleConfig(scheduleType, block)
-
-  if (!hasValidConfig) {
-    return {
-      isValid: false,
-      error: getMissingConfigError(scheduleType),
-      scheduleType,
-    }
-  }
-
-  const timezone = getSubBlockValue(block, 'timezone') || 'UTC'
-
-  try {
-    // Get parsed schedule values (safe to use after validation passes)
-    const scheduleValues = getScheduleTimeValues(block)
-    const sanitizedScheduleValues =
-      scheduleType !== 'custom' ? { ...scheduleValues, cronExpression: null } : scheduleValues
-
-    const cronExpression = generateCronExpression(scheduleType, sanitizedScheduleValues)
-
-    const validation = validateCronExpression(cronExpression, timezone)
-    if (!validation.isValid) {
-      return {
-        isValid: false,
-        error: `Invalid cron expression: ${validation.error}`,
-        scheduleType,
-      }
-    }
-
-    const nextRunAt = calculateNextRunTime(scheduleType, sanitizedScheduleValues)
-
-    return {
-      isValid: true,
-      scheduleType,
-      cronExpression,
-      nextRunAt,
-      timezone,
-    }
-  } catch (error) {
-    return {
-      isValid: false,
-      error: error instanceof Error ? error.message : 'Failed to generate schedule',
-      scheduleType,
-    }
-  }
-}
-
-/**
- * Validate all schedule blocks in a workflow
- * Returns the first validation error found, or success if all are valid
- */
-export function validateWorkflowSchedules(
-  blocks: Record<string, BlockState>
-): ScheduleValidationResult {
-  const scheduleBlocks = findScheduleBlocks(blocks)
-
-  for (const block of scheduleBlocks) {
-    const result = validateScheduleBlock(block)
-    if (!result.isValid) {
-      return result
-    }
-  }
-
-  return { isValid: true }
-}
-
 /**
  * Create or update schedule records for a workflow during deployment
  * This should be called within a database transaction

apps/sim/lib/workflows/schedules/deploy.ts

@@ -0,0 +1,23 @@
+export {
+  createSchedulesForDeploy,
+  deleteSchedulesForWorkflow,
+  type ScheduleDeployResult,
+} from './deploy'
+export {
+  type BlockState,
+  calculateNextRunTime,
+  DAY_MAP,
+  generateCronExpression,
+  getScheduleInfo,
+  getScheduleTimeValues,
+  getSubBlockValue,
+  parseCronToHumanReadable,
+  parseTimeString,
+  validateCronExpression,
+} from './utils'
+export {
+  findScheduleBlocks,
+  type ScheduleValidationResult,
+  validateScheduleBlock,
+  validateWorkflowSchedules,
+} from './validation'