chore: allow bypass delay date on retry

kevinkim-ogp · kevinkim-ogp · commit ddbeced5b057 · 2025-07-23T14:19:05.000+08:00
diff --git a/packages/backend/src/apps/delay/__tests__/delay-until.test.ts b/packages/backend/src/apps/delay/__tests__/delay-until.test.ts
@@ -1,5 +1,6 @@
 import { type IGlobalVariable } from '@plumber/types'
 
+import { DateTime } from 'luxon'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
 import StepError from '@/errors/step'
@@ -8,13 +9,15 @@ import delayUntilAction from '../actions/delay-until'
 import delayApp from '../index'
 
 const PAST_DATE = '2023-11-08'
-const VALID_DATE = '2025-12-31' // long long time later
+const VALID_DATE = '2026-12-31' // long long time later
 const VALID_TIME = '12:00'
 const DEFAULT_TIME = '00:00'
 const INVALID_TIME = '25:00'
+const INVALID_DATE = '2025-12-32'
 
 const mocks = vi.hoisted(() => ({
   setActionItem: vi.fn(),
+  getLastExecutionStep: vi.fn(),
 }))
 
 describe('Delay until action', () => {
@@ -36,6 +39,7 @@ describe('Delay until action', () => {
         name: delayApp.name,
       },
       setActionItem: mocks.setActionItem,
+      getLastExecutionStep: mocks.getLastExecutionStep,
     } as unknown as IGlobalVariable
   })
 
@@ -88,6 +92,8 @@ describe('Delay until action', () => {
       delayUntilTime: DEFAULT_TIME,
     }
 
+    mocks.getLastExecutionStep.mockResolvedValue(null)
+
     // throw step error
     await expect(delayUntilAction.run($)).rejects.toThrowError(StepError)
   })
@@ -98,7 +104,82 @@ describe('Delay until action', () => {
       delayUntilTime: INVALID_TIME,
     }
 
+    mocks.getLastExecutionStep.mockResolvedValue(null)
+
     // throw step error
     await expect(delayUntilAction.run($)).rejects.toThrowError(StepError)
   })
+
+  describe('retry logic', () => {
+    it('uses current date when retrying after invalid timestamp error', async () => {
+      $.step.parameters = {
+        delayUntil: INVALID_DATE,
+        delayUntilTime: VALID_TIME,
+      }
+
+      // Mock last execution step to indicate a retry for invalid timestamp
+      mocks.getLastExecutionStep.mockResolvedValue({
+        errorDetails: {
+          name: 'Invalid timestamp entered',
+        },
+      })
+
+      const result = await delayUntilAction.run($)
+      const expectedDate = DateTime.now().toFormat('yyyy-MM-dd')
+
+      expect(result).toBeFalsy()
+      expect(mocks.setActionItem).toBeCalledWith({
+        raw: { delayUntil: expectedDate, delayUntilTime: DEFAULT_TIME },
+      })
+    })
+
+    it('allows past timestamp when retrying after past timestamp error', async () => {
+      $.step.parameters = {
+        delayUntil: PAST_DATE,
+        delayUntilTime: DEFAULT_TIME,
+      }
+
+      // Mock last execution step to indicate a retry for past timestamp
+      mocks.getLastExecutionStep.mockResolvedValue({
+        errorDetails: {
+          name: 'Delay until timestamp entered is in the past',
+        },
+      })
+
+      const result = await delayUntilAction.run($)
+
+      expect(result).toBeFalsy()
+      expect(mocks.setActionItem).toBeCalledWith({
+        raw: { delayUntil: PAST_DATE, delayUntilTime: DEFAULT_TIME },
+      })
+    })
+
+    it('throws error when retrying with different error type', async () => {
+      $.step.parameters = {
+        delayUntil: INVALID_DATE,
+        delayUntilTime: VALID_TIME,
+      }
+
+      // Mock last execution step with different error type
+      mocks.getLastExecutionStep.mockResolvedValue({
+        errorDetails: {
+          name: 'Some other error',
+        },
+      })
+
+      await expect(delayUntilAction.run($)).rejects.toThrowError(StepError)
+    })
+
+    it('handles retry when last execution step has no error details', async () => {
+      $.step.parameters = {
+        delayUntil: INVALID_DATE,
+        delayUntilTime: VALID_TIME,
+      }
+
+      // Mock last execution step without error details
+      mocks.getLastExecutionStep.mockResolvedValue({})
+
+      await expect(delayUntilAction.run($)).rejects.toThrowError(StepError)
+    })
+  })
 })
diff --git a/packages/backend/src/apps/delay/actions/delay-until/index.ts b/packages/backend/src/apps/delay/actions/delay-until/index.ts
@@ -6,6 +6,20 @@ import StepError from '@/errors/step'
 
 import generateTimestamp from '../../helpers/generate-timestamp'
 
+const ERRORS_TO_RETRY = [
+  'Invalid timestamp entered',
+  'Delay until timestamp entered is in the past',
+]
+
+async function isValidRetry($: any): Promise<boolean> {
+  const lastExecutionStep = await $.getLastExecutionStep({
+    sameExecution: true,
+  })
+  return ERRORS_TO_RETRY.includes(
+    lastExecutionStep?.errorDetails?.name as string,
+  )
+}
+
 const action: IRawAction = {
   name: 'Delay until',
   key: 'delayUntil',
@@ -39,21 +53,42 @@ const action: IRawAction = {
       ? new String(delayUntilTime).trim()
       : defaultTime
 
-    const delayTimestamp = generateTimestamp(
+    let delayTimestamp = generateTimestamp(
       delayUntilString,
       delayUntilTimeString,
     )
 
+    let dataItem = {
+      delayUntil: delayUntilString,
+      delayUntilTime: delayUntilTimeString,
+    }
+
+    /**
+     * RETRY: we check and only allow manual retries for failures due to:
+     * - invalid timestamp
+     * - delay until timestamp entered is in the past
+     */
+    const isRetry = await isValidRetry($)
+
     if (isNaN(delayTimestamp)) {
-      throw new StepError(
-        'Invalid timestamp entered',
-        'Check that the date or time entered is of a valid format.',
-        $.step.position,
-        $.app.name,
-      )
+      if (isRetry) {
+        const dateToday = DateTime.now().toFormat('yyyy-MM-dd')
+        delayTimestamp = generateTimestamp(dateToday, defaultTime)
+        dataItem = {
+          delayUntil: dateToday,
+          delayUntilTime: defaultTime,
+        }
+      } else {
+        throw new StepError(
+          'Invalid timestamp entered',
+          'Check that the date or time entered is of a valid format.',
+          $.step.position,
+          $.app.name,
+        )
+      }
     }
 
-    if (delayTimestamp < DateTime.now().toMillis()) {
+    if (delayTimestamp < DateTime.now().toMillis() && !isRetry) {
       throw new StepError(
         'Delay until timestamp entered is in the past',
         'Check that the date and time entered is not in the past.',
@@ -62,11 +97,6 @@ const action: IRawAction = {
       )
     }
 
-    const dataItem = {
-      delayUntil: delayUntilString,
-      delayUntilTime: delayUntilTimeString,
-    }
-
     $.setActionItem({ raw: dataItem })
   },
 }
diff --git a/packages/frontend/src/components/ExecutionStep/hooks/useExecutionStepStatus.ts b/packages/frontend/src/components/ExecutionStep/hooks/useExecutionStepStatus.ts
@@ -30,6 +30,7 @@ export interface UseExecutionStepStatusReturn {
   isPartialSuccess: boolean
   canRetry: boolean
   loading: boolean
+  customRetryButtonText?: string
 }
 
 export function useExecutionStepStatus({
@@ -63,6 +64,22 @@ export function useExecutionStepStatus({
     return failureIcon
   }, [isPartialSuccess, isStepSuccessful, status])
 
+  const customRetryButtonText = useMemo(() => {
+    // specific to delay until action where we want to allow users to manually
+    // retry and bypass the errors:
+    // - Invalid timestamp entered
+    // - Delay until timestamp entered is in the past
+    if (
+      [
+        'Invalid timestamp entered',
+        'Delay until timestamp entered is in the past',
+      ].includes(errorDetails?.name)
+    ) {
+      return 'Retry and send now'
+    }
+    return undefined
+  }, [errorDetails])
+
   return {
     app,
     appName,
@@ -72,5 +89,6 @@ export function useExecutionStepStatus({
     isPartialSuccess,
     canRetry,
     loading,
+    customRetryButtonText,
   }
 }
diff --git a/packages/frontend/src/components/ExecutionStep/index.tsx b/packages/frontend/src/components/ExecutionStep/index.tsx
@@ -42,14 +42,21 @@ export default function ExecutionStep({
 }: ExecutionStepProps): React.ReactElement | null {
   const { appKey, jobId, errorDetails, status } = executionStep
 
-  const { app, appName, statusIcon, hasError, isPartialSuccess, canRetry } =
-    useExecutionStepStatus({
-      appKey,
-      status,
-      errorDetails,
-      execution,
-      jobId,
-    })
+  const {
+    app,
+    appName,
+    statusIcon,
+    hasError,
+    isPartialSuccess,
+    canRetry,
+    customRetryButtonText,
+  } = useExecutionStepStatus({
+    appKey,
+    status,
+    errorDetails,
+    execution,
+    jobId,
+  })
 
   if (!app) {
     return null
@@ -77,7 +84,10 @@ export default function ExecutionStep({
             {!isInForEach && canRetry && (
               <>
                 <RetryAllButton execution={execution} />
-                <RetryButton executionStepId={executionStep.id} />
+                <RetryButton
+                  executionStepId={executionStep.id}
+                  customButtonText={customRetryButtonText}
+                />
               </>
             )}
           </HStack>
