fix(core): Always save executions when they go into waiting state

packages/cli/src/execution-lifecycle-hooks/__tests__/save-execution-progress.test.ts

@@ -1,5 +1,4 @@
 import {
-	deepCopy,
 	ErrorReporterProxy,
 	type IRunExecutionData,
 	type ITaskData,
@@ -87,37 +86,6 @@ test('should update execution when saving progress is enabled', async () => {
 	expect(reporterSpy).not.toHaveBeenCalled();
 });
 
-test('should update execution when saving progress is disabled, but waitTill is defined', async () => {
-	jest.spyOn(fnModule, 'toSaveSettings').mockReturnValue({
-		...commonSettings,
-		progress: false,
-	});
-
-	const reporterSpy = jest.spyOn(ErrorReporterProxy, 'error');
-
-	executionRepository.findSingleExecution.mockResolvedValue({} as IExecutionResponse);
-
-	const args = deepCopy(commonArgs);
-	args[4].waitTill = new Date();
-	await saveExecutionProgress(...args);
-
-	expect(executionRepository.updateExistingExecution).toHaveBeenCalledWith('some-execution-id', {
-		data: {
-			executionData: undefined,
-			resultData: {
-				lastNodeExecuted: 'My Node',
-				runData: {
-					'My Node': [{}],
-				},
-			},
-			startData: {},
-		},
-		status: 'running',
-	});
-
-	expect(reporterSpy).not.toHaveBeenCalled();
-});
-
 test('should report error on failure', async () => {
 	jest.spyOn(fnModule, 'toSaveSettings').mockReturnValue({
 		...commonSettings,

packages/cli/src/execution-lifecycle-hooks/save-execution-progress.ts

@@ -16,7 +16,7 @@ export async function saveExecutionProgress(
 ) {
 	const saveSettings = toSaveSettings(workflowData.settings);
 
-	if (!saveSettings.progress && !executionData.waitTill) return;
+	if (!saveSettings.progress) return;
 
 	const logger = Container.get(Logger);
 

packages/cli/src/execution-lifecycle-hooks/to-save-settings.ts

@@ -18,20 +18,20 @@ export function toSaveSettings(workflowSettings: IWorkflowSettings = {}) {
 		PROGRESS: config.getEnv('executions.saveExecutionProgress'),
 	};
 
+	const {
+		saveDataErrorExecution = DEFAULTS.ERROR,
+		saveDataSuccessExecution = DEFAULTS.SUCCESS,
+		saveManualExecutions = DEFAULTS.MANUAL,
+		saveExecutionProgress = DEFAULTS.PROGRESS,
+	} = workflowSettings;
+
 	return {
-		error: workflowSettings.saveDataErrorExecution
-			? workflowSettings.saveDataErrorExecution !== 'none'
-			: DEFAULTS.ERROR !== 'none',
-		success: workflowSettings.saveDataSuccessExecution
-			? workflowSettings.saveDataSuccessExecution !== 'none'
-			: DEFAULTS.SUCCESS !== 'none',
-		manual:
-			workflowSettings === undefined || workflowSettings.saveManualExecutions === 'DEFAULT'
-				? DEFAULTS.MANUAL
-				: (workflowSettings.saveManualExecutions ?? DEFAULTS.MANUAL),
-		progress:
-			workflowSettings === undefined || workflowSettings.saveExecutionProgress === 'DEFAULT'
-				? DEFAULTS.PROGRESS
-				: (workflowSettings.saveExecutionProgress ?? DEFAULTS.PROGRESS),
+		error: saveDataErrorExecution === 'DEFAULT' ? DEFAULTS.ERROR : saveDataErrorExecution === 'all',
+		success:
+			saveDataSuccessExecution === 'DEFAULT'
+				? DEFAULTS.SUCCESS
+				: saveDataSuccessExecution === 'all',
+		manual: saveManualExecutions === 'DEFAULT' ? DEFAULTS.MANUAL : saveManualExecutions,
+		progress: saveExecutionProgress === 'DEFAULT' ? DEFAULTS.PROGRESS : saveExecutionProgress,
 	};
 }

packages/cli/src/webhooks/webhook-helpers.ts

@@ -464,6 +464,11 @@ export async function executeWebhook(
 			projectId: project?.id,
 		};
 
+		// When resuming from a wait node, copy over the pushRef from the execution-data
+		if (!runData.pushRef) {
+			runData.pushRef = runExecutionData.pushRef;
+		}
+
 		let responsePromise: IDeferredPromise<IN8nHttpFullResponse> | undefined;
 		if (responseMode === 'responseNode') {
 			responsePromise = createDeferredPromise<IN8nHttpFullResponse>();

packages/cli/src/workflow-execute-additional-data.ts

@@ -448,7 +448,7 @@ function hookFunctionsSave(): IWorkflowExecuteHooks {
 
 					const saveSettings = toSaveSettings(this.workflowData.settings);
 
-					if (isManualMode && !saveSettings.manual && !fullRunData.waitTill) {
+					if (isManualMode && !saveSettings.manual && fullRunData.finished) {
 						/**
 						 * When manual executions are not being saved, we only soft-delete
 						 * the execution so that the user can access its binary data
@@ -468,22 +468,21 @@ function hookFunctionsSave(): IWorkflowExecuteHooks {
 						(executionStatus === 'success' && !saveSettings.success) ||
 						(executionStatus !== 'success' && !saveSettings.error);
 
-					if (shouldNotSave && !fullRunData.waitTill) {
-						if (!fullRunData.waitTill && !isManualMode) {
-							executeErrorWorkflow(
-								this.workflowData,
-								fullRunData,
-								this.mode,
-								this.executionId,
-								this.retryOf,
-							);
-							await Container.get(ExecutionRepository).hardDelete({
-								workflowId: this.workflowData.id,
-								executionId: this.executionId,
-							});
+					if (shouldNotSave && fullRunData.finished && !isManualMode) {
+						executeErrorWorkflow(
+							this.workflowData,
+							fullRunData,
+							this.mode,
+							this.executionId,
+							this.retryOf,
+						);
 
-							return;
-						}
+						await Container.get(ExecutionRepository).hardDelete({
+							workflowId: this.workflowData.id,
+							executionId: this.executionId,
+						});
+
+						return;
 					}
 
 					// Although it is treated as IWorkflowBase here, it's being instantiated elsewhere with properties that may be sensitive
@@ -1117,6 +1116,9 @@ export function getWorkflowHooksWorkerMain(
 	hookFunctions.nodeExecuteAfter = [];
 	hookFunctions.workflowExecuteAfter = [
 		async function (this: WorkflowHooks, fullRunData: IRun): Promise<void> {
+			// Don't delete executions before they are finished
+			if (!fullRunData.finished) return;
+
 			const executionStatus = determineFinalExecutionStatus(fullRunData);
 			const saveSettings = toSaveSettings(this.workflowData.settings);