n8n 1.78.0 → 1.79.0

package/dist/execution-lifecycle/execution-lifecycle-hooks.js

@@ -1,13 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getWorkflowHooksIntegrated = getWorkflowHooksIntegrated;
-exports.getWorkflowHooksWorkerExecuter = getWorkflowHooksWorkerExecuter;
-exports.getWorkflowHooksWorkerMain = getWorkflowHooksWorkerMain;
-exports.getWorkflowHooksMain = getWorkflowHooksMain;
+exports.getLifecycleHooksForSubExecutions = getLifecycleHooksForSubExecutions;
+exports.getLifecycleHooksForScalingWorker = getLifecycleHooksForScalingWorker;
+exports.getLifecycleHooksForScalingMain = getLifecycleHooksForScalingMain;
+exports.getLifecycleHooksForRegularMain = getLifecycleHooksForRegularMain;
 const di_1 = require("@n8n/di");
 const flatted_1 = require("flatted");
 const n8n_core_1 = require("n8n-core");
-const n8n_workflow_1 = require("n8n-workflow");
 const execution_repository_1 = require("../databases/repositories/execution.repository");
 const event_service_1 = require("../events/event.service");
 const external_hooks_1 = require("../external-hooks");
@@ -20,359 +19,305 @@ const restore_binary_data_id_1 = require("./restore-binary-data-id");
 const save_execution_progress_1 = require("./save-execution-progress");
 const shared_hook_functions_1 = require("./shared/shared-hook-functions");
 const to_save_settings_1 = require("./to-save-settings");
-function mergeHookFunctions(...hookFunctions) {
-    const result = {
-        nodeExecuteBefore: [],
-        nodeExecuteAfter: [],
-        workflowExecuteBefore: [],
-        workflowExecuteAfter: [],
-        sendResponse: [],
-        nodeFetchedData: [],
-    };
-    for (const hooks of hookFunctions) {
-        for (const key in hooks) {
-            if (!result[key] || !hooks[key])
-                continue;
-            result[key].push(...hooks[key]);
-        }
-    }
-    return result;
-}
-function hookFunctionsWorkflowEvents(userId) {
+function hookFunctionsWorkflowEvents(hooks, userId) {
     const eventService = di_1.Container.get(event_service_1.EventService);
-    return {
-        workflowExecuteBefore: [
-            async function () {
-                const { executionId, workflowData } = this;
-                eventService.emit('workflow-pre-execute', { executionId, data: workflowData });
-            },
-        ],
-        workflowExecuteAfter: [
-            async function (runData) {
-                if (runData.status === 'waiting')
-                    return;
-                const { executionId, workflowData: workflow } = this;
-                eventService.emit('workflow-post-execute', { executionId, runData, workflow, userId });
-            },
-        ],
-    };
+    hooks.addHandler('workflowExecuteBefore', function () {
+        const { executionId, workflowData } = this;
+        eventService.emit('workflow-pre-execute', { executionId, data: workflowData });
+    });
+    hooks.addHandler('workflowExecuteAfter', function (runData) {
+        if (runData.status === 'waiting')
+            return;
+        const { executionId, workflowData: workflow } = this;
+        eventService.emit('workflow-post-execute', { executionId, runData, workflow, userId });
+    });
 }
-function hookFunctionsNodeEvents() {
+function hookFunctionsNodeEvents(hooks) {
     const eventService = di_1.Container.get(event_service_1.EventService);
-    return {
-        nodeExecuteBefore: [
-            async function (nodeName) {
-                const { executionId, workflowData: workflow } = this;
-                eventService.emit('node-pre-execute', { executionId, workflow, nodeName });
-            },
-        ],
-        nodeExecuteAfter: [
-            async function (nodeName) {
-                const { executionId, workflowData: workflow } = this;
-                eventService.emit('node-post-execute', { executionId, workflow, nodeName });
-            },
-        ],
-    };
+    hooks.addHandler('nodeExecuteBefore', function (nodeName) {
+        const { executionId, workflowData: workflow } = this;
+        eventService.emit('node-pre-execute', { executionId, workflow, nodeName });
+    });
+    hooks.addHandler('nodeExecuteAfter', function (nodeName) {
+        const { executionId, workflowData: workflow } = this;
+        eventService.emit('node-post-execute', { executionId, workflow, nodeName });
+    });
 }
-function hookFunctionsPush({ pushRef, retryOf }) {
+function hookFunctionsPush(hooks, { pushRef, retryOf }) {
     if (!pushRef)
-        return {};
+        return;
     const logger = di_1.Container.get(n8n_core_1.Logger);
     const pushInstance = di_1.Container.get(push_1.Push);
-    return {
-        nodeExecuteBefore: [
-            async function (nodeName) {
-                const { executionId } = this;
-                logger.debug(`Executing hook on node "${nodeName}" (hookFunctionsPush)`, {
-                    executionId,
-                    pushRef,
-                    workflowId: this.workflowData.id,
-                });
-                pushInstance.send({ type: 'nodeExecuteBefore', data: { executionId, nodeName } }, pushRef);
-            },
-        ],
-        nodeExecuteAfter: [
-            async function (nodeName, data) {
-                const { executionId } = this;
-                logger.debug(`Executing hook on node "${nodeName}" (hookFunctionsPush)`, {
-                    executionId,
-                    pushRef,
-                    workflowId: this.workflowData.id,
-                });
-                pushInstance.send({ type: 'nodeExecuteAfter', data: { executionId, nodeName, data } }, pushRef);
-            },
-        ],
-        workflowExecuteBefore: [
-            async function (_workflow, data) {
-                const { executionId } = this;
-                const { id: workflowId, name: workflowName } = this.workflowData;
-                logger.debug('Executing hook (hookFunctionsPush)', {
-                    executionId,
-                    pushRef,
-                    workflowId,
-                });
-                pushInstance.send({
-                    type: 'executionStarted',
-                    data: {
-                        executionId,
-                        mode: this.mode,
-                        startedAt: new Date(),
-                        retryOf,
-                        workflowId,
-                        workflowName,
-                        flattedRunData: data?.resultData.runData
-                            ? (0, flatted_1.stringify)(data.resultData.runData)
-                            : (0, flatted_1.stringify)({}),
-                    },
-                }, pushRef);
-            },
-        ],
-        workflowExecuteAfter: [
-            async function (fullRunData) {
-                const { executionId } = this;
-                const { id: workflowId } = this.workflowData;
-                logger.debug('Executing hook (hookFunctionsPush)', {
-                    executionId,
-                    pushRef,
-                    workflowId,
-                });
-                const { status } = fullRunData;
-                if (status === 'waiting') {
-                    pushInstance.send({ type: 'executionWaiting', data: { executionId } }, pushRef);
-                }
-                else {
-                    const rawData = (0, flatted_1.stringify)(fullRunData.data);
-                    pushInstance.send({ type: 'executionFinished', data: { executionId, workflowId, status, rawData } }, pushRef);
-                }
+    hooks.addHandler('nodeExecuteBefore', function (nodeName) {
+        const { executionId } = this;
+        logger.debug(`Executing hook on node "${nodeName}" (hookFunctionsPush)`, {
+            executionId,
+            pushRef,
+            workflowId: this.workflowData.id,
+        });
+        pushInstance.send({ type: 'nodeExecuteBefore', data: { executionId, nodeName } }, pushRef);
+    });
+    hooks.addHandler('nodeExecuteAfter', function (nodeName, data) {
+        const { executionId } = this;
+        logger.debug(`Executing hook on node "${nodeName}" (hookFunctionsPush)`, {
+            executionId,
+            pushRef,
+            workflowId: this.workflowData.id,
+        });
+        pushInstance.send({ type: 'nodeExecuteAfter', data: { executionId, nodeName, data } }, pushRef);
+    });
+    hooks.addHandler('workflowExecuteBefore', function (_workflow, data) {
+        const { executionId } = this;
+        const { id: workflowId, name: workflowName } = this.workflowData;
+        logger.debug('Executing hook (hookFunctionsPush)', {
+            executionId,
+            pushRef,
+            workflowId,
+        });
+        pushInstance.send({
+            type: 'executionStarted',
+            data: {
+                executionId,
+                mode: this.mode,
+                startedAt: new Date(),
+                retryOf,
+                workflowId,
+                workflowName,
+                flattedRunData: data?.resultData.runData
+                    ? (0, flatted_1.stringify)(data.resultData.runData)
+                    : (0, flatted_1.stringify)({}),
             },
-        ],
-    };
+        }, pushRef);
+    });
+    hooks.addHandler('workflowExecuteAfter', function (fullRunData) {
+        const { executionId } = this;
+        const { id: workflowId } = this.workflowData;
+        logger.debug('Executing hook (hookFunctionsPush)', {
+            executionId,
+            pushRef,
+            workflowId,
+        });
+        const { status } = fullRunData;
+        if (status === 'waiting') {
+            pushInstance.send({ type: 'executionWaiting', data: { executionId } }, pushRef);
+        }
+        else {
+            const rawData = (0, flatted_1.stringify)(fullRunData.data);
+            pushInstance.send({ type: 'executionFinished', data: { executionId, workflowId, status, rawData } }, pushRef);
+        }
+    });
 }
-function hookFunctionsExternalHooks() {
+function hookFunctionsExternalHooks(hooks) {
     const externalHooks = di_1.Container.get(external_hooks_1.ExternalHooks);
-    return {
-        workflowExecuteBefore: [
-            async function (workflow) {
-                await externalHooks.run('workflow.preExecute', [workflow, this.mode]);
-            },
-        ],
-        workflowExecuteAfter: [
-            async function (fullRunData) {
-                await externalHooks.run('workflow.postExecute', [
-                    fullRunData,
-                    this.workflowData,
-                    this.executionId,
-                ]);
-            },
-        ],
-    };
+    hooks.addHandler('workflowExecuteBefore', async function (workflow) {
+        await externalHooks.run('workflow.preExecute', [workflow, this.mode]);
+    });
+    hooks.addHandler('workflowExecuteAfter', async function (fullRunData) {
+        await externalHooks.run('workflow.postExecute', [
+            fullRunData,
+            this.workflowData,
+            this.executionId,
+        ]);
+    });
 }
-function hookFunctionsSaveProgress({ saveSettings }) {
+function hookFunctionsSaveProgress(hooks, { saveSettings }) {
     if (!saveSettings.progress)
-        return {};
-    return {
-        nodeExecuteAfter: [
-            async function (nodeName, data, executionData) {
-                await (0, save_execution_progress_1.saveExecutionProgress)(this.workflowData.id, this.executionId, nodeName, data, executionData);
-            },
-        ],
-    };
+        return;
+    hooks.addHandler('nodeExecuteAfter', async function (nodeName, data, executionData) {
+        await (0, save_execution_progress_1.saveExecutionProgress)(this.workflowData.id, this.executionId, nodeName, data, executionData);
+    });
 }
-function hookFunctionsFinalizeExecutionStatus() {
-    return {
-        workflowExecuteAfter: [
-            async function (fullRunData) {
-                fullRunData.status = (0, shared_hook_functions_1.determineFinalExecutionStatus)(fullRunData);
-            },
-        ],
-    };
+function hookFunctionsFinalizeExecutionStatus(hooks) {
+    hooks.addHandler('workflowExecuteAfter', (fullRunData) => {
+        fullRunData.status = (0, shared_hook_functions_1.determineFinalExecutionStatus)(fullRunData);
+    });
 }
-function hookFunctionsStatistics() {
+function hookFunctionsStatistics(hooks) {
     const workflowStatisticsService = di_1.Container.get(workflow_statistics_service_1.WorkflowStatisticsService);
-    return {
-        nodeFetchedData: [
-            async (workflowId, node) => {
-                workflowStatisticsService.emit('nodeFetchedData', { workflowId, node });
-            },
-        ],
-    };
+    hooks.addHandler('nodeFetchedData', (workflowId, node) => {
+        workflowStatisticsService.emit('nodeFetchedData', { workflowId, node });
+    });
 }
-function hookFunctionsSave({ pushRef, retryOf, saveSettings, }) {
+function hookFunctionsSave(hooks, { pushRef, retryOf, saveSettings }) {
     const logger = di_1.Container.get(n8n_core_1.Logger);
     const errorReporter = di_1.Container.get(n8n_core_1.ErrorReporter);
     const executionRepository = di_1.Container.get(execution_repository_1.ExecutionRepository);
     const workflowStaticDataService = di_1.Container.get(workflow_static_data_service_1.WorkflowStaticDataService);
     const workflowStatisticsService = di_1.Container.get(workflow_statistics_service_1.WorkflowStatisticsService);
-    return {
-        workflowExecuteAfter: [
-            async function (fullRunData, newStaticData) {
-                logger.debug('Executing hook (hookFunctionsSave)', {
-                    executionId: this.executionId,
-                    workflowId: this.workflowData.id,
-                });
-                await (0, restore_binary_data_id_1.restoreBinaryDataId)(fullRunData, this.executionId, this.mode);
-                const isManualMode = this.mode === 'manual';
+    hooks.addHandler('workflowExecuteAfter', async function (fullRunData, newStaticData) {
+        logger.debug('Executing hook (hookFunctionsSave)', {
+            executionId: this.executionId,
+            workflowId: this.workflowData.id,
+        });
+        await (0, restore_binary_data_id_1.restoreBinaryDataId)(fullRunData, this.executionId, this.mode);
+        const isManualMode = this.mode === 'manual';
+        try {
+            if (!isManualMode && (0, utils_1.isWorkflowIdValid)(this.workflowData.id) && newStaticData) {
                 try {
-                    if (!isManualMode && (0, utils_1.isWorkflowIdValid)(this.workflowData.id) && newStaticData) {
-                        try {
-                            await workflowStaticDataService.saveStaticDataById(this.workflowData.id, newStaticData);
-                        }
-                        catch (e) {
-                            errorReporter.error(e);
-                            logger.error(`There was a problem saving the workflow with id "${this.workflowData.id}" to save changed staticData: "${e.message}" (hookFunctionsSave)`, { executionId: this.executionId, workflowId: this.workflowData.id });
-                        }
-                    }
-                    if (isManualMode && !saveSettings.manual && !fullRunData.waitTill) {
-                        await executionRepository.softDelete(this.executionId);
-                        return;
-                    }
-                    const shouldNotSave = (fullRunData.status === 'success' && !saveSettings.success) ||
-                        (fullRunData.status !== 'success' && !saveSettings.error);
-                    if (shouldNotSave && !fullRunData.waitTill && !isManualMode) {
-                        (0, execute_error_workflow_1.executeErrorWorkflow)(this.workflowData, fullRunData, this.mode, this.executionId, retryOf);
-                        await executionRepository.hardDelete({
-                            workflowId: this.workflowData.id,
-                            executionId: this.executionId,
-                        });
-                        return;
-                    }
-                    const fullExecutionData = (0, shared_hook_functions_1.prepareExecutionDataForDbUpdate)({
-                        runData: fullRunData,
-                        workflowData: this.workflowData,
-                        workflowStatusFinal: fullRunData.status,
-                        retryOf,
-                    });
-                    if (fullRunData.waitTill && isManualMode) {
-                        fullExecutionData.data.pushRef = pushRef;
-                    }
-                    await (0, shared_hook_functions_1.updateExistingExecution)({
-                        executionId: this.executionId,
-                        workflowId: this.workflowData.id,
-                        executionData: fullExecutionData,
-                    });
-                    if (!isManualMode) {
-                        (0, execute_error_workflow_1.executeErrorWorkflow)(this.workflowData, fullRunData, this.mode, this.executionId, retryOf);
-                    }
+                    await workflowStaticDataService.saveStaticDataById(this.workflowData.id, newStaticData);
                 }
-                finally {
-                    workflowStatisticsService.emit('workflowExecutionCompleted', {
-                        workflowData: this.workflowData,
-                        fullRunData,
-                    });
+                catch (e) {
+                    errorReporter.error(e);
+                    logger.error(`There was a problem saving the workflow with id "${this.workflowData.id}" to save changed staticData: "${e.message}" (hookFunctionsSave)`, { executionId: this.executionId, workflowId: this.workflowData.id });
                 }
-            },
-        ],
-    };
+            }
+            if (isManualMode && !saveSettings.manual && !fullRunData.waitTill) {
+                await executionRepository.softDelete(this.executionId);
+                return;
+            }
+            const shouldNotSave = (fullRunData.status === 'success' && !saveSettings.success) ||
+                (fullRunData.status !== 'success' && !saveSettings.error);
+            if (shouldNotSave && !fullRunData.waitTill && !isManualMode) {
+                (0, execute_error_workflow_1.executeErrorWorkflow)(this.workflowData, fullRunData, this.mode, this.executionId, retryOf);
+                await executionRepository.hardDelete({
+                    workflowId: this.workflowData.id,
+                    executionId: this.executionId,
+                });
+                return;
+            }
+            const fullExecutionData = (0, shared_hook_functions_1.prepareExecutionDataForDbUpdate)({
+                runData: fullRunData,
+                workflowData: this.workflowData,
+                workflowStatusFinal: fullRunData.status,
+                retryOf,
+            });
+            if (fullRunData.waitTill && isManualMode) {
+                fullExecutionData.data.pushRef = pushRef;
+            }
+            await (0, shared_hook_functions_1.updateExistingExecution)({
+                executionId: this.executionId,
+                workflowId: this.workflowData.id,
+                executionData: fullExecutionData,
+            });
+            if (!isManualMode) {
+                (0, execute_error_workflow_1.executeErrorWorkflow)(this.workflowData, fullRunData, this.mode, this.executionId, retryOf);
+            }
+        }
+        finally {
+            workflowStatisticsService.emit('workflowExecutionCompleted', {
+                workflowData: this.workflowData,
+                fullRunData,
+            });
+        }
+    });
 }
-function hookFunctionsSaveWorker({ pushRef, retryOf, }) {
+function hookFunctionsSaveWorker(hooks, { pushRef, retryOf }) {
     const logger = di_1.Container.get(n8n_core_1.Logger);
     const errorReporter = di_1.Container.get(n8n_core_1.ErrorReporter);
     const workflowStaticDataService = di_1.Container.get(workflow_static_data_service_1.WorkflowStaticDataService);
     const workflowStatisticsService = di_1.Container.get(workflow_statistics_service_1.WorkflowStatisticsService);
-    return {
-        workflowExecuteAfter: [
-            async function (fullRunData, newStaticData) {
-                logger.debug('Executing hook (hookFunctionsSaveWorker)', {
-                    executionId: this.executionId,
-                    workflowId: this.workflowData.id,
-                });
-                const isManualMode = this.mode === 'manual';
+    hooks.addHandler('workflowExecuteAfter', async function (fullRunData, newStaticData) {
+        logger.debug('Executing hook (hookFunctionsSaveWorker)', {
+            executionId: this.executionId,
+            workflowId: this.workflowData.id,
+        });
+        const isManualMode = this.mode === 'manual';
+        try {
+            if (!isManualMode && (0, utils_1.isWorkflowIdValid)(this.workflowData.id) && newStaticData) {
                 try {
-                    if (!isManualMode && (0, utils_1.isWorkflowIdValid)(this.workflowData.id) && newStaticData) {
-                        try {
-                            await workflowStaticDataService.saveStaticDataById(this.workflowData.id, newStaticData);
-                        }
-                        catch (e) {
-                            errorReporter.error(e);
-                            logger.error(`There was a problem saving the workflow with id "${this.workflowData.id}" to save changed staticData: "${e.message}" (workflowExecuteAfter)`, { workflowId: this.workflowData.id });
-                        }
-                    }
-                    if (!isManualMode &&
-                        fullRunData.status !== 'success' &&
-                        fullRunData.status !== 'waiting') {
-                        (0, execute_error_workflow_1.executeErrorWorkflow)(this.workflowData, fullRunData, this.mode, this.executionId, retryOf);
-                    }
-                    const fullExecutionData = (0, shared_hook_functions_1.prepareExecutionDataForDbUpdate)({
-                        runData: fullRunData,
-                        workflowData: this.workflowData,
-                        workflowStatusFinal: fullRunData.status,
-                        retryOf,
-                    });
-                    if (fullRunData.waitTill && isManualMode) {
-                        fullExecutionData.data.pushRef = pushRef;
-                    }
-                    await (0, shared_hook_functions_1.updateExistingExecution)({
-                        executionId: this.executionId,
-                        workflowId: this.workflowData.id,
-                        executionData: fullExecutionData,
-                    });
+                    await workflowStaticDataService.saveStaticDataById(this.workflowData.id, newStaticData);
                 }
-                finally {
-                    workflowStatisticsService.emit('workflowExecutionCompleted', {
-                        workflowData: this.workflowData,
-                        fullRunData,
-                    });
+                catch (e) {
+                    errorReporter.error(e);
+                    logger.error(`There was a problem saving the workflow with id "${this.workflowData.id}" to save changed staticData: "${e.message}" (workflowExecuteAfter)`, { workflowId: this.workflowData.id });
                 }
-            },
-        ],
-    };
+            }
+            if (!isManualMode && fullRunData.status !== 'success' && fullRunData.status !== 'waiting') {
+                (0, execute_error_workflow_1.executeErrorWorkflow)(this.workflowData, fullRunData, this.mode, this.executionId, retryOf);
+            }
+            const fullExecutionData = (0, shared_hook_functions_1.prepareExecutionDataForDbUpdate)({
+                runData: fullRunData,
+                workflowData: this.workflowData,
+                workflowStatusFinal: fullRunData.status,
+                retryOf,
+            });
+            if (fullRunData.waitTill && isManualMode) {
+                fullExecutionData.data.pushRef = pushRef;
+            }
+            await (0, shared_hook_functions_1.updateExistingExecution)({
+                executionId: this.executionId,
+                workflowId: this.workflowData.id,
+                executionData: fullExecutionData,
+            });
+        }
+        finally {
+            workflowStatisticsService.emit('workflowExecutionCompleted', {
+                workflowData: this.workflowData,
+                fullRunData,
+            });
+        }
+    });
 }
-function getWorkflowHooksIntegrated(mode, executionId, workflowData, userId) {
+function getLifecycleHooksForSubExecutions(mode, executionId, workflowData, userId) {
+    const hooks = new n8n_core_1.ExecutionLifecycleHooks(mode, executionId, workflowData);
     const saveSettings = (0, to_save_settings_1.toSaveSettings)(workflowData.settings);
-    const hookFunctions = mergeHookFunctions(hookFunctionsWorkflowEvents(userId), hookFunctionsNodeEvents(), hookFunctionsFinalizeExecutionStatus(), hookFunctionsSave({ saveSettings }), hookFunctionsSaveProgress({ saveSettings }), hookFunctionsStatistics(), hookFunctionsExternalHooks());
-    return new n8n_workflow_1.WorkflowHooks(hookFunctions, mode, executionId, workflowData);
+    hookFunctionsWorkflowEvents(hooks, userId);
+    hookFunctionsNodeEvents(hooks);
+    hookFunctionsFinalizeExecutionStatus(hooks);
+    hookFunctionsSave(hooks, { saveSettings });
+    hookFunctionsSaveProgress(hooks, { saveSettings });
+    hookFunctionsStatistics(hooks);
+    hookFunctionsExternalHooks(hooks);
+    return hooks;
 }
-function getWorkflowHooksWorkerExecuter(mode, executionId, workflowData, { pushRef, retryOf } = {}) {
+function getLifecycleHooksForScalingWorker(mode, executionId, workflowData, { pushRef, retryOf } = {}) {
+    const hooks = new n8n_core_1.ExecutionLifecycleHooks(mode, executionId, workflowData);
     const saveSettings = (0, to_save_settings_1.toSaveSettings)(workflowData.settings);
     const optionalParameters = { pushRef, retryOf, saveSettings };
-    const toMerge = [
-        hookFunctionsNodeEvents(),
-        hookFunctionsFinalizeExecutionStatus(),
-        hookFunctionsSaveWorker(optionalParameters),
-        hookFunctionsSaveProgress(optionalParameters),
-        hookFunctionsStatistics(),
-        hookFunctionsExternalHooks(),
-    ];
+    hookFunctionsNodeEvents(hooks);
+    hookFunctionsFinalizeExecutionStatus(hooks);
+    hookFunctionsSaveWorker(hooks, optionalParameters);
+    hookFunctionsSaveProgress(hooks, optionalParameters);
+    hookFunctionsStatistics(hooks);
+    hookFunctionsExternalHooks(hooks);
     if (mode === 'manual' && di_1.Container.get(n8n_core_1.InstanceSettings).isWorker) {
-        toMerge.push(hookFunctionsPush(optionalParameters));
+        hookFunctionsPush(hooks, optionalParameters);
     }
-    const hookFunctions = mergeHookFunctions(...toMerge);
-    return new n8n_workflow_1.WorkflowHooks(hookFunctions, mode, executionId, workflowData);
+    return hooks;
 }
-function getWorkflowHooksWorkerMain(mode, executionId, workflowData, { pushRef, retryOf } = {}) {
+function getLifecycleHooksForScalingMain(mode, executionId, workflowData, { pushRef, retryOf } = {}) {
+    const hooks = new n8n_core_1.ExecutionLifecycleHooks(mode, executionId, workflowData);
     const saveSettings = (0, to_save_settings_1.toSaveSettings)(workflowData.settings);
     const optionalParameters = { pushRef, retryOf, saveSettings };
     const executionRepository = di_1.Container.get(execution_repository_1.ExecutionRepository);
-    const hookFunctions = mergeHookFunctions(hookFunctionsWorkflowEvents(), hookFunctionsSaveProgress(optionalParameters), hookFunctionsExternalHooks(), hookFunctionsFinalizeExecutionStatus(), {
-        workflowExecuteAfter: [
-            async function (fullRunData) {
-                if (!fullRunData.finished)
-                    return;
-                const isManualMode = this.mode === 'manual';
-                if (isManualMode && !saveSettings.manual && !fullRunData.waitTill) {
-                    await executionRepository.softDelete(this.executionId);
-                    return;
-                }
-                const shouldNotSave = (fullRunData.status === 'success' && !saveSettings.success) ||
-                    (fullRunData.status !== 'success' && !saveSettings.error);
-                if (!isManualMode && shouldNotSave && !fullRunData.waitTill) {
-                    await executionRepository.hardDelete({
-                        workflowId: this.workflowData.id,
-                        executionId: this.executionId,
-                    });
-                }
-            },
-        ],
+    hookFunctionsWorkflowEvents(hooks);
+    hookFunctionsSaveProgress(hooks, optionalParameters);
+    hookFunctionsExternalHooks(hooks);
+    hookFunctionsFinalizeExecutionStatus(hooks);
+    hooks.addHandler('workflowExecuteAfter', async function (fullRunData) {
+        if (!fullRunData.finished)
+            return;
+        const isManualMode = this.mode === 'manual';
+        if (isManualMode && !saveSettings.manual && !fullRunData.waitTill) {
+            await executionRepository.softDelete(this.executionId);
+            return;
+        }
+        const shouldNotSave = (fullRunData.status === 'success' && !saveSettings.success) ||
+            (fullRunData.status !== 'success' && !saveSettings.error);
+        if (!isManualMode && shouldNotSave && !fullRunData.waitTill) {
+            await executionRepository.hardDelete({
+                workflowId: this.workflowData.id,
+                executionId: this.executionId,
+            });
+        }
     });
-    hookFunctions.nodeExecuteBefore = [];
-    hookFunctions.nodeExecuteAfter = [];
-    return new n8n_workflow_1.WorkflowHooks(hookFunctions, mode, executionId, workflowData);
+    hooks.handlers.nodeExecuteBefore = [];
+    hooks.handlers.nodeExecuteAfter = [];
+    return hooks;
 }
-function getWorkflowHooksMain(data, executionId) {
-    const { pushRef, retryOf } = data;
-    const saveSettings = (0, to_save_settings_1.toSaveSettings)(data.workflowData.settings);
+function getLifecycleHooksForRegularMain(data, executionId) {
+    const { pushRef, retryOf, executionMode, workflowData } = data;
+    const hooks = new n8n_core_1.ExecutionLifecycleHooks(executionMode, executionId, workflowData);
+    const saveSettings = (0, to_save_settings_1.toSaveSettings)(workflowData.settings);
     const optionalParameters = { pushRef, retryOf: retryOf ?? undefined, saveSettings };
-    const hookFunctions = mergeHookFunctions(hookFunctionsWorkflowEvents(), hookFunctionsNodeEvents(), hookFunctionsFinalizeExecutionStatus(), hookFunctionsSave(optionalParameters), hookFunctionsPush(optionalParameters), hookFunctionsSaveProgress(optionalParameters), hookFunctionsStatistics(), hookFunctionsExternalHooks());
-    return new n8n_workflow_1.WorkflowHooks(hookFunctions, data.executionMode, executionId, data.workflowData);
+    hookFunctionsWorkflowEvents(hooks);
+    hookFunctionsNodeEvents(hooks);
+    hookFunctionsFinalizeExecutionStatus(hooks);
+    hookFunctionsSave(hooks, optionalParameters);
+    hookFunctionsPush(hooks, optionalParameters);
+    hookFunctionsSaveProgress(hooks, optionalParameters);
+    hookFunctionsStatistics(hooks);
+    hookFunctionsExternalHooks(hooks);
+    return hooks;
 }
 //# sourceMappingURL=execution-lifecycle-hooks.js.map