Release v1.50.1 (#1147)

Details
- Allow retry of failed executions with past delay timestamp
- Show iteration number in for each variables
- Fix misnamed variable for sso login mutation

---------

Co-authored-by: kevin <[email protected]>
Co-authored-by: Ian Chen <[email protected]>

Author: 3 people

package-lock.json

@@ -109,5 +109,5 @@
     "tsconfig-paths": "^4.2.0",
     "type-fest": "4.10.3"
   },
-  "version": "1.50.0"
+  "version": "1.50.1"
 }

packages/backend/package.json

@@ -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', () => {
@@ -35,7 +38,11 @@ describe('Delay until action', () => {
       app: {
         name: delayApp.name,
       },
+      execution: {
+        testRun: false,
+      },
       setActionItem: mocks.setActionItem,
+      getLastExecutionStep: mocks.getLastExecutionStep,
     } as unknown as IGlobalVariable
   })
 
@@ -88,6 +95,8 @@ describe('Delay until action', () => {
       delayUntilTime: DEFAULT_TIME,
     }
 
+    mocks.getLastExecutionStep.mockResolvedValue(null)
+
     // throw step error
     await expect(delayUntilAction.run($)).rejects.toThrowError(StepError)
   })
@@ -98,7 +107,83 @@ 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('prevents retries during test runs', async () => {
+      $.step.parameters = {
+        delayUntil: PAST_DATE,
+        delayUntilTime: DEFAULT_TIME,
+      }
+
+      // Set testRun to true to simulate test environment
+      $.execution.testRun = true
+
+      // Mock last execution step to indicate a retry for past timestamp
+      mocks.getLastExecutionStep.mockResolvedValue({
+        errorDetails: {
+          name: 'Delay until timestamp entered is in the past',
+        },
+      })
+
+      // Should throw error even with valid retry conditions due to testRun
+      await expect(delayUntilAction.run($)).rejects.toThrowError(StepError)
+    })
+
+    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: DateTime.now().toFormat('dd MMM yyyy'),
+          delayUntilTime: DateTime.now().toFormat('HH:mm'),
+        },
+      })
+    })
+
+    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)
+    })
+  })
 })

packages/backend/src/apps/delay/__tests__/delay-until.test.ts

@@ -1,11 +1,28 @@
-import { IRawAction } from '@plumber/types'
+import { IGlobalVariable, IRawAction } from '@plumber/types'
 
 import { DateTime } from 'luxon'
 
 import StepError from '@/errors/step'
 
 import generateTimestamp from '../../helpers/generate-timestamp'
 
+async function isValidRetry($: IGlobalVariable): Promise<boolean> {
+  // do not allow retries in test runs
+  if ($.execution.testRun) {
+    return false
+  }
+
+  const lastExecutionStep = await $.getLastExecutionStep({
+    sameExecution: true,
+  })
+  // NOTE: only allow retries if the delayed timestamp is in the past
+  // invalid timestamps should be corrected by the user
+  return (
+    lastExecutionStep?.errorDetails?.name ===
+    'Delay until timestamp entered is in the past'
+  )
+}
+
 const action: IRawAction = {
   name: 'Delay until',
   key: 'delayUntil',
@@ -44,6 +61,11 @@ const action: IRawAction = {
       delayUntilTimeString,
     )
 
+    let dataItem = {
+      delayUntil: delayUntilString,
+      delayUntilTime: delayUntilTimeString,
+    }
+
     if (isNaN(delayTimestamp)) {
       throw new StepError(
         'Invalid timestamp entered',
@@ -53,18 +75,27 @@ const action: IRawAction = {
       )
     }
 
-    if (delayTimestamp < DateTime.now().toMillis()) {
-      throw new StepError(
-        'Delay until timestamp entered is in the past',
-        'Check that the date and time entered is not in the past.',
-        $.step.position,
-        $.app.name,
-      )
-    }
+    /**
+     * RETRY: we check and only allow manual retries for failures due to:
+     * - delay until timestamp entered is in the past
+     */
+    const isRetry = await isValidRetry($)
 
-    const dataItem = {
-      delayUntil: delayUntilString,
-      delayUntilTime: delayUntilTimeString,
+    if (delayTimestamp < DateTime.now().toMillis()) {
+      if (isRetry) {
+        const dateTimeNow = DateTime.now()
+        dataItem = {
+          delayUntil: dateTimeNow.toFormat('dd MMM yyyy'),
+          delayUntilTime: dateTimeNow.toFormat('HH:mm'),
+        }
+      } else {
+        throw new StepError(
+          'Delay until timestamp entered is in the past',
+          'This action was scheduled to run at a time that has already passed. Click "Retry" to skip the delay and continue the Pipe now.',
+          $.step.position,
+          $.app.name,
+        )
+      }
     }
 
     $.setActionItem({ raw: dataItem })