@atom8n/n8n 2.2.0

package/dist/commands/execute-batch.js

@@ -0,0 +1,702 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var ExecuteBatch_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecuteBatch = void 0;
+const db_1 = require("@n8n/db");
+const decorators_1 = require("@n8n/decorators");
+const di_1 = require("@n8n/di");
+const fs_1 = __importDefault(require("fs"));
+const json_diff_1 = require("json-diff");
+const pick_1 = __importDefault(require("lodash/pick"));
+const n8n_workflow_1 = require("n8n-workflow");
+const os_1 = __importDefault(require("os"));
+const path_1 = require("path");
+const zod_1 = require("zod");
+const active_executions_1 = require("../active-executions");
+const ownership_service_1 = require("../services/ownership.service");
+const utils_1 = require("../utils");
+const workflow_runner_1 = require("../workflow-runner");
+const base_command_1 = require("./base-command");
+const re = /\d+/;
+const flagsSchema = zod_1.z.object({
+    debug: zod_1.z
+        .boolean()
+        .describe('Toggles on displaying all errors and debug messages.')
+        .default(false),
+    ids: zod_1.z
+        .string()
+        .describe('Specifies workflow IDs to get executed, separated by a comma or a file containing the ids')
+        .optional(),
+    concurrency: zod_1.z
+        .number()
+        .int()
+        .default(1)
+        .describe('How many workflows can run in parallel. Defaults to 1 which means no concurrency.'),
+    output: zod_1.z
+        .string()
+        .describe('Enable execution saving, You must inform an existing folder to save execution via this param')
+        .optional(),
+    snapshot: zod_1.z
+        .string()
+        .describe('Enables snapshot saving. You must inform an existing folder to save snapshots via this param.')
+        .optional(),
+    compare: zod_1.z
+        .string()
+        .describe('Compares current execution with an existing snapshot. You must inform an existing folder where the snapshots are saved.')
+        .optional(),
+    shallow: zod_1.z
+        .boolean()
+        .describe('Compares only if attributes output from node are the same, with no regards to nested JSON objects.')
+        .optional(),
+    githubWorkflow: zod_1.z
+        .boolean()
+        .describe('Enables more lenient comparison for GitHub workflows. This is useful for reducing false positives when comparing Test workflows.')
+        .optional(),
+    skipList: zod_1.z
+        .string()
+        .describe('File containing a comma separated list of workflow IDs to skip.')
+        .optional(),
+    retries: zod_1.z
+        .number()
+        .int()
+        .default(1)
+        .describe('Retries failed workflows up to N tries. Default is 1. Set 0 to disable.'),
+    shortOutput: zod_1.z
+        .boolean()
+        .describe('Omits the full execution information from output, displaying only summary.')
+        .optional(),
+});
+let ExecuteBatch = ExecuteBatch_1 = class ExecuteBatch extends base_command_1.BaseCommand {
+    constructor() {
+        super(...arguments);
+        this.needsCommunityPackages = true;
+        this.needsTaskRunner = true;
+    }
+    async stopProcess(skipExit = false) {
+        if (ExecuteBatch_1.cancelled) {
+            process.exit(0);
+        }
+        ExecuteBatch_1.cancelled = true;
+        await di_1.Container.get(active_executions_1.ActiveExecutions).shutdown(true);
+        if (skipExit !== true) {
+            process.exit(0);
+        }
+    }
+    formatJsonOutput(data) {
+        return JSON.stringify(data, null, 2);
+    }
+    shouldBeConsideredAsWarning(errorMessage) {
+        const warningStrings = [
+            'refresh token is invalid',
+            'unable to connect to',
+            'econnreset',
+            '429',
+            'econnrefused',
+            'missing a required parameter',
+            'insufficient credit balance',
+            'internal server error',
+            '503',
+            '502',
+            '504',
+            'insufficient balance',
+            'request timed out',
+            'status code 401',
+        ];
+        errorMessage = errorMessage.toLowerCase();
+        for (let i = 0; i < warningStrings.length; i++) {
+            if (errorMessage.includes(warningStrings[i])) {
+                return true;
+            }
+        }
+        return false;
+    }
+    async init() {
+        await super.init();
+        await this.initBinaryDataService();
+        await this.initDataDeduplicationService();
+        await this.initExternalHooks();
+    }
+    async run() {
+        const { flags } = this;
+        ExecuteBatch_1.debug = flags.debug;
+        ExecuteBatch_1.concurrency = flags.concurrency || 1;
+        const ids = [];
+        const skipIds = [];
+        if (flags.snapshot !== undefined) {
+            if (fs_1.default.existsSync(flags.snapshot)) {
+                if (!fs_1.default.lstatSync(flags.snapshot).isDirectory()) {
+                    this.logger.error('The parameter --snapshot must be an existing directory');
+                    return;
+                }
+            }
+            else {
+                this.logger.error('The parameter --snapshot must be an existing directory');
+                return;
+            }
+            ExecuteBatch_1.snapshot = flags.snapshot;
+        }
+        if (flags.compare !== undefined) {
+            if (fs_1.default.existsSync(flags.compare)) {
+                if (!fs_1.default.lstatSync(flags.compare).isDirectory()) {
+                    this.logger.error('The parameter --compare must be an existing directory');
+                    return;
+                }
+            }
+            else {
+                this.logger.error('The parameter --compare must be an existing directory');
+                return;
+            }
+            ExecuteBatch_1.compare = flags.compare;
+        }
+        if (flags.output !== undefined) {
+            if (fs_1.default.existsSync(flags.output)) {
+                if (fs_1.default.lstatSync(flags.output).isDirectory()) {
+                    this.logger.error('The parameter --output must be a writable file');
+                    return;
+                }
+            }
+        }
+        if (flags.ids !== undefined) {
+            if (fs_1.default.existsSync(flags.ids)) {
+                const contents = fs_1.default.readFileSync(flags.ids, { encoding: 'utf-8' });
+                ids.push(...contents
+                    .trimEnd()
+                    .split(',')
+                    .filter((id) => re.exec(id)));
+            }
+            else {
+                const paramIds = flags.ids.split(',');
+                const matchedIds = paramIds.filter((id) => re.exec(id));
+                if (matchedIds.length === 0) {
+                    this.logger.error('The parameter --ids must be a list of numeric IDs separated by a comma or a file with this content.');
+                    return;
+                }
+                ids.push(...matchedIds);
+            }
+        }
+        if (flags.skipList !== undefined) {
+            if (fs_1.default.existsSync(flags.skipList)) {
+                const contents = fs_1.default.readFileSync(flags.skipList, { encoding: 'utf-8' });
+                try {
+                    const parsedSkipList = JSON.parse(contents);
+                    parsedSkipList.forEach((item) => {
+                        skipIds.push(item.workflowId);
+                    });
+                }
+                catch (error) {
+                    this.logger.error('Skip list file is not a valid JSON. Exiting.');
+                    return;
+                }
+            }
+            else {
+                this.logger.error('Skip list file not found. Exiting.');
+                return;
+            }
+        }
+        if (flags.shallow) {
+            ExecuteBatch_1.shallow = true;
+        }
+        if (flags.githubWorkflow) {
+            ExecuteBatch_1.githubWorkflow = true;
+        }
+        ExecuteBatch_1.instanceOwner = await di_1.Container.get(ownership_service_1.OwnershipService).getInstanceOwner();
+        const query = di_1.Container.get(db_1.WorkflowRepository).createQueryBuilder('workflows');
+        if (ids.length > 0) {
+            query.andWhere('workflows.id in (:...ids)', { ids });
+        }
+        if (skipIds.length > 0) {
+            query.andWhere('workflows.id not in (:...skipIds)', { skipIds });
+        }
+        const allWorkflows = (await query.getMany());
+        if (ExecuteBatch_1.debug) {
+            process.stdout.write(`Found ${allWorkflows.length} workflows to execute.\n`);
+        }
+        const results = await this.runTests([...allWorkflows]);
+        let { retries } = flags;
+        while (retries > 0 &&
+            results.summary.warningExecutions + results.summary.failedExecutions > 0 &&
+            !ExecuteBatch_1.cancelled) {
+            const failedWorkflowIds = results.summary.errors.map((execution) => execution.workflowId);
+            failedWorkflowIds.push(...results.summary.warnings.map((execution) => execution.workflowId));
+            const newWorkflowList = allWorkflows.filter((workflow) => failedWorkflowIds.includes(workflow.id));
+            const retryResults = await this.runTests(newWorkflowList);
+            this.mergeResults(results, retryResults);
+            retries--;
+        }
+        if (flags.output !== undefined) {
+            fs_1.default.writeFileSync(flags.output, this.formatJsonOutput(results));
+            this.logger.info('\nExecution finished.');
+            this.logger.info('Summary:');
+            this.logger.info(`\tSuccess: ${results.summary.successfulExecutions}`);
+            this.logger.info(`\tFailures: ${results.summary.failedExecutions}`);
+            this.logger.info(`\tWarnings: ${results.summary.warningExecutions}`);
+            this.logger.info('\nNodes successfully tested:');
+            Object.entries(results.coveredNodes).forEach(([nodeName, nodeCount]) => {
+                this.logger.info(`\t${nodeName}: ${nodeCount}`);
+            });
+            this.logger.info('\nCheck the JSON file for more details.');
+        }
+        else if (flags.shortOutput) {
+            this.logger.info(this.formatJsonOutput({
+                ...results,
+                executions: results.executions.filter((execution) => execution.executionStatus !== 'success'),
+            }));
+        }
+        else {
+            this.logger.info(this.formatJsonOutput(results));
+        }
+        await this.stopProcess(true);
+        if (results.summary.failedExecutions > 0) {
+            process.exit(1);
+        }
+    }
+    mergeResults(results, retryResults) {
+        if (retryResults.summary.successfulExecutions === 0) {
+            return;
+        }
+        retryResults.executions.forEach((newExecution) => {
+            if (newExecution.executionStatus === 'success') {
+                results.executions = results.executions.filter((previousExecutions) => previousExecutions.workflowId !== newExecution.workflowId);
+                const errorIndex = results.summary.errors.findIndex((summaryInformation) => summaryInformation.workflowId === newExecution.workflowId);
+                if (errorIndex !== -1) {
+                    results.summary.failedExecutions--;
+                    results.summary.errors.splice(errorIndex, 1);
+                }
+                const warningIndex = results.summary.warnings.findIndex((summaryInformation) => summaryInformation.workflowId === newExecution.workflowId);
+                if (warningIndex !== -1) {
+                    results.summary.warningExecutions--;
+                    results.summary.warnings.splice(warningIndex, 1);
+                }
+                results.summary.successfulExecutions++;
+                results.executions.push(newExecution);
+            }
+        });
+    }
+    async runTests(allWorkflows) {
+        const result = {
+            totalWorkflows: allWorkflows.length,
+            slackMessage: '',
+            summary: {
+                failedExecutions: 0,
+                warningExecutions: 0,
+                successfulExecutions: 0,
+                errors: [],
+                warnings: [],
+            },
+            coveredNodes: {},
+            executions: [],
+        };
+        if (ExecuteBatch_1.debug) {
+            this.initializeLogs();
+        }
+        return await new Promise(async (res) => {
+            const promisesArray = [];
+            for (let i = 0; i < ExecuteBatch_1.concurrency; i++) {
+                const promise = new Promise(async (resolve) => {
+                    let workflow;
+                    while (allWorkflows.length > 0) {
+                        workflow = allWorkflows.shift();
+                        if (ExecuteBatch_1.cancelled) {
+                            process.stdout.write(`Thread ${i + 1} resolving and quitting.`);
+                            resolve(true);
+                            break;
+                        }
+                        if (workflow === undefined) {
+                            resolve(true);
+                            return;
+                        }
+                        if (ExecuteBatch_1.debug) {
+                            ExecuteBatch_1.workflowExecutionsProgress[i].push({
+                                workflowId: workflow.id,
+                                status: 'running',
+                            });
+                            this.updateStatus();
+                        }
+                        await this.startThread(workflow).then((executionResult) => {
+                            if (ExecuteBatch_1.debug) {
+                                ExecuteBatch_1.workflowExecutionsProgress[i].pop();
+                            }
+                            result.executions.push(executionResult);
+                            if (executionResult.executionStatus === 'success') {
+                                if (ExecuteBatch_1.debug) {
+                                    ExecuteBatch_1.workflowExecutionsProgress[i].push({
+                                        workflowId: workflow.id,
+                                        status: 'success',
+                                    });
+                                    this.updateStatus();
+                                }
+                                result.summary.successfulExecutions++;
+                                const nodeNames = Object.keys(executionResult.coveredNodes);
+                                nodeNames.map((nodeName) => {
+                                    if (result.coveredNodes[nodeName] === undefined) {
+                                        result.coveredNodes[nodeName] = 0;
+                                    }
+                                    result.coveredNodes[nodeName] += executionResult.coveredNodes[nodeName];
+                                });
+                            }
+                            else if (executionResult.executionStatus === 'warning') {
+                                result.summary.warningExecutions++;
+                                result.summary.warnings.push({
+                                    workflowId: executionResult.workflowId,
+                                    error: executionResult.error,
+                                });
+                                if (ExecuteBatch_1.debug) {
+                                    ExecuteBatch_1.workflowExecutionsProgress[i].push({
+                                        workflowId: workflow.id,
+                                        status: 'warning',
+                                    });
+                                    this.updateStatus();
+                                }
+                            }
+                            else if (executionResult.executionStatus === 'error') {
+                                result.summary.failedExecutions++;
+                                result.summary.errors.push({
+                                    workflowId: executionResult.workflowId,
+                                    error: executionResult.error,
+                                });
+                                if (ExecuteBatch_1.debug) {
+                                    ExecuteBatch_1.workflowExecutionsProgress[i].push({
+                                        workflowId: workflow.id,
+                                        status: 'error',
+                                    });
+                                    this.updateStatus();
+                                }
+                            }
+                            else {
+                                throw new n8n_workflow_1.UnexpectedError('Wrong execution status - cannot proceed');
+                            }
+                        });
+                    }
+                    resolve(true);
+                });
+                promisesArray.push(promise);
+            }
+            await Promise.allSettled(promisesArray);
+            if (ExecuteBatch_1.githubWorkflow) {
+                if (result.summary.errors.length < 6) {
+                    const errorMessage = result.summary.errors.map((error) => {
+                        return `*${error.workflowId}*: ${error.error}`;
+                    });
+                    result.slackMessage = `*${result.summary.errors.length} Executions errors*. Workflows failing: ${errorMessage.join(' ')} `;
+                }
+                else {
+                    result.slackMessage = `*${result.summary.errors.length} Executions errors*`;
+                }
+                this.setOutput('slackMessage', JSON.stringify(result.slackMessage));
+            }
+            res(result);
+        });
+    }
+    setOutput(key, value) {
+        const output = process.env.GITHUB_OUTPUT;
+        fs_1.default.appendFileSync(output, `${key}=${value}${os_1.default.EOL}`);
+    }
+    updateStatus() {
+        if (ExecuteBatch_1.cancelled) {
+            return;
+        }
+        if (process.stdout.isTTY) {
+            process.stdout.moveCursor(0, -ExecuteBatch_1.concurrency);
+            process.stdout.cursorTo(0);
+            process.stdout.clearLine(0);
+        }
+        ExecuteBatch_1.workflowExecutionsProgress.map((concurrentThread, index) => {
+            let message = `${index + 1}: `;
+            concurrentThread.map((executionItem, workflowIndex) => {
+                let openColor = '\x1b[0m';
+                const closeColor = '\x1b[0m';
+                switch (executionItem.status) {
+                    case 'success':
+                        openColor = '\x1b[32m';
+                        break;
+                    case 'error':
+                        openColor = '\x1b[31m';
+                        break;
+                    case 'warning':
+                        openColor = '\x1b[33m';
+                        break;
+                    default:
+                        break;
+                }
+                message += `${workflowIndex > 0 ? ', ' : ''}${openColor}${executionItem.workflowId}${closeColor}`;
+            });
+            if (process.stdout.isTTY) {
+                process.stdout.cursorTo(0);
+                process.stdout.clearLine(0);
+            }
+            process.stdout.write(`${message}\n`);
+        });
+    }
+    initializeLogs() {
+        process.stdout.write('**********************************************\n');
+        process.stdout.write('              n8n test workflows\n');
+        process.stdout.write('**********************************************\n');
+        process.stdout.write('\n');
+        process.stdout.write('Batch number:\n');
+        ExecuteBatch_1.workflowExecutionsProgress = [];
+        for (let i = 0; i < ExecuteBatch_1.concurrency; i++) {
+            ExecuteBatch_1.workflowExecutionsProgress.push([]);
+            process.stdout.write(`${i + 1}: \n`);
+        }
+    }
+    async startThread(workflowData) {
+        const executionResult = {
+            workflowId: workflowData.id,
+            workflowName: workflowData.name,
+            executionTime: 0,
+            finished: false,
+            executionStatus: 'running',
+            coveredNodes: {},
+        };
+        const nodeEdgeCases = {};
+        workflowData.nodes.forEach((node) => {
+            executionResult.coveredNodes[node.type] = (executionResult.coveredNodes[node.type] || 0) + 1;
+            if (node.notes !== undefined && node.notes !== '') {
+                node.notes.split('\n').forEach((note) => {
+                    const parts = note.split('=');
+                    if (parts.length === 2) {
+                        if (nodeEdgeCases[node.name] === undefined) {
+                            nodeEdgeCases[node.name] = {};
+                        }
+                        if (parts[0] === 'CAP_RESULTS_LENGTH') {
+                            nodeEdgeCases[node.name].capResults = parseInt(parts[1], 10);
+                        }
+                        else if (parts[0] === 'IGNORED_PROPERTIES') {
+                            nodeEdgeCases[node.name].ignoredProperties = parts[1]
+                                .split(',')
+                                .map((property) => property.trim());
+                        }
+                        else if (parts[0] === 'KEEP_ONLY_PROPERTIES') {
+                            nodeEdgeCases[node.name].keepOnlyProperties = parts[1]
+                                .split(',')
+                                .map((property) => property.trim());
+                        }
+                    }
+                });
+            }
+        });
+        const workflowRunner = di_1.Container.get(workflow_runner_1.WorkflowRunner);
+        if (this.globalConfig.executions.mode === 'queue') {
+            this.logger.warn('`executeBatch` does not support queue mode. Falling back to regular mode.');
+            this.globalConfig.executions.mode = 'regular';
+        }
+        return await new Promise(async (resolve) => {
+            let gotCancel = false;
+            const timeoutTimer = setTimeout(() => {
+                gotCancel = true;
+                executionResult.error = 'Workflow execution timed out.';
+                executionResult.executionStatus = 'warning';
+                resolve(executionResult);
+            }, ExecuteBatch_1.executionTimeout);
+            try {
+                const startingNode = (0, utils_1.findCliWorkflowStart)(workflowData.nodes);
+                const runData = {
+                    executionMode: 'cli',
+                    startNodes: [{ name: startingNode.name, sourceData: null }],
+                    workflowData,
+                    userId: ExecuteBatch_1.instanceOwner.id,
+                };
+                const executionId = await workflowRunner.run(runData);
+                const activeExecutions = di_1.Container.get(active_executions_1.ActiveExecutions);
+                const data = await activeExecutions.getPostExecutePromise(executionId);
+                if (gotCancel || ExecuteBatch_1.cancelled) {
+                    clearTimeout(timeoutTimer);
+                    return;
+                }
+                if (data === undefined) {
+                    executionResult.error = 'Workflow did not return any data.';
+                    executionResult.executionStatus = 'error';
+                }
+                else {
+                    executionResult.executionTime =
+                        (Date.parse(data.stoppedAt) -
+                            Date.parse(data.startedAt)) /
+                            1000;
+                    executionResult.finished = data?.finished !== undefined;
+                    const resultError = data.data.resultData.error;
+                    if (resultError) {
+                        executionResult.error = resultError.description || resultError.message;
+                        if (data.data.resultData.lastNodeExecuted !== undefined) {
+                            executionResult.error += ` on node ${data.data.resultData.lastNodeExecuted}`;
+                        }
+                        executionResult.executionStatus = 'error';
+                        if (this.shouldBeConsideredAsWarning(executionResult.error || '')) {
+                            executionResult.executionStatus = 'warning';
+                        }
+                    }
+                    else {
+                        if (ExecuteBatch_1.shallow) {
+                            Object.keys(data.data.resultData.runData).map((nodeName) => {
+                                data.data.resultData.runData[nodeName].map((taskData) => {
+                                    if (taskData.data === undefined) {
+                                        return;
+                                    }
+                                    Object.keys(taskData.data).map((connectionName) => {
+                                        const connection = taskData.data[connectionName];
+                                        connection.map((executionDataArray) => {
+                                            if (executionDataArray === null) {
+                                                return;
+                                            }
+                                            const { capResults, ignoredProperties, keepOnlyProperties } = nodeEdgeCases[nodeName] || {};
+                                            if (capResults !== undefined) {
+                                                executionDataArray.splice(capResults);
+                                            }
+                                            executionDataArray.map((executionData) => {
+                                                if (executionData.json === undefined) {
+                                                    return;
+                                                }
+                                                if (ignoredProperties !== undefined) {
+                                                    ignoredProperties.forEach((ignoredProperty) => delete executionData.json[ignoredProperty]);
+                                                }
+                                                let keepOnlyFields = [];
+                                                if (keepOnlyProperties !== undefined) {
+                                                    keepOnlyFields = keepOnlyProperties;
+                                                }
+                                                executionData.json =
+                                                    keepOnlyFields.length > 0
+                                                        ? (0, pick_1.default)(executionData.json, keepOnlyFields)
+                                                        : executionData.json;
+                                                const jsonProperties = executionData.json;
+                                                const nodeOutputAttributes = Object.keys(jsonProperties);
+                                                nodeOutputAttributes.map((attributeName) => {
+                                                    if (Array.isArray(jsonProperties[attributeName])) {
+                                                        jsonProperties[attributeName] = ['json array'];
+                                                    }
+                                                    else if (typeof jsonProperties[attributeName] === 'object') {
+                                                        jsonProperties[attributeName] = { object: true };
+                                                    }
+                                                });
+                                            });
+                                        });
+                                    });
+                                });
+                            });
+                        }
+                        else {
+                            const specialCases = Object.keys(nodeEdgeCases);
+                            specialCases.forEach((nodeName) => {
+                                data.data.resultData.runData[nodeName].map((taskData) => {
+                                    if (taskData.data === undefined) {
+                                        return;
+                                    }
+                                    Object.keys(taskData.data).map((connectionName) => {
+                                        const connection = taskData.data[connectionName];
+                                        connection.map((executionDataArray) => {
+                                            if (executionDataArray === null) {
+                                                return;
+                                            }
+                                            const capResults = nodeEdgeCases[nodeName].capResults;
+                                            if (capResults !== undefined) {
+                                                executionDataArray.splice(capResults);
+                                            }
+                                            if (nodeEdgeCases[nodeName].ignoredProperties !== undefined) {
+                                                executionDataArray.map((executionData) => {
+                                                    if (executionData.json === undefined) {
+                                                        return;
+                                                    }
+                                                    nodeEdgeCases[nodeName].ignoredProperties.forEach((ignoredProperty) => delete executionData.json[ignoredProperty]);
+                                                });
+                                            }
+                                        });
+                                    });
+                                });
+                            });
+                        }
+                        const serializedData = this.formatJsonOutput(data);
+                        if (ExecuteBatch_1.compare === undefined) {
+                            executionResult.executionStatus = 'success';
+                        }
+                        else {
+                            const fileName = `${ExecuteBatch_1.compare.endsWith(path_1.sep)
+                                ? ExecuteBatch_1.compare
+                                : ExecuteBatch_1.compare + path_1.sep}${workflowData.id}-snapshot.json`;
+                            if (fs_1.default.existsSync(fileName)) {
+                                const contents = fs_1.default.readFileSync(fileName, { encoding: 'utf-8' });
+                                const expected = (0, n8n_workflow_1.jsonParse)(contents);
+                                const received = (0, n8n_workflow_1.jsonParse)(serializedData);
+                                const changes = (0, json_diff_1.diff)(expected, received, { keysOnly: true });
+                                if (changes !== undefined) {
+                                    const changesJson = JSON.stringify(changes);
+                                    if (changesJson.includes('__deleted')) {
+                                        if (ExecuteBatch_1.githubWorkflow) {
+                                            const deletedChanges = changesJson.match(/__deleted/g) ?? [];
+                                            executionResult.error = `Workflow contains ${deletedChanges.length} deleted data.`;
+                                        }
+                                        else {
+                                            executionResult.error = 'Workflow may contain breaking changes';
+                                        }
+                                        executionResult.changes = changes;
+                                        executionResult.executionStatus = 'error';
+                                    }
+                                    else {
+                                        executionResult.error =
+                                            'Workflow contains new data that previously did not exist.';
+                                        executionResult.changes = changes;
+                                        executionResult.executionStatus = 'warning';
+                                    }
+                                }
+                                else {
+                                    executionResult.executionStatus = 'success';
+                                }
+                            }
+                            else {
+                                executionResult.error = 'Snapshot for not found.';
+                                executionResult.executionStatus = 'warning';
+                            }
+                        }
+                        if (ExecuteBatch_1.snapshot !== undefined) {
+                            const fileName = `${ExecuteBatch_1.snapshot.endsWith(path_1.sep)
+                                ? ExecuteBatch_1.snapshot
+                                : ExecuteBatch_1.snapshot + path_1.sep}${workflowData.id}-snapshot.json`;
+                            fs_1.default.writeFileSync(fileName, serializedData);
+                        }
+                    }
+                }
+            }
+            catch (e) {
+                this.errorReporter.error(e, {
+                    extra: {
+                        workflowId: workflowData.id,
+                    },
+                });
+                executionResult.error = `Workflow failed to execute: ${e.message}`;
+                executionResult.executionStatus = 'error';
+            }
+            clearTimeout(timeoutTimer);
+            resolve(executionResult);
+        });
+    }
+};
+exports.ExecuteBatch = ExecuteBatch;
+ExecuteBatch.cancelled = false;
+ExecuteBatch.shallow = false;
+ExecuteBatch.concurrency = 1;
+ExecuteBatch.githubWorkflow = false;
+ExecuteBatch.debug = false;
+ExecuteBatch.executionTimeout = 3 * 60 * 1000;
+ExecuteBatch.aliases = ['executeBatch'];
+exports.ExecuteBatch = ExecuteBatch = ExecuteBatch_1 = __decorate([
+    (0, decorators_1.Command)({
+        name: 'execute-batch',
+        description: 'Executes multiple workflows once',
+        examples: [
+            '',
+            '--concurrency=10 --skipList=/data/skipList.json',
+            '--debug --output=/data/output.json',
+            '--ids=10,13,15 --shortOutput',
+            '--snapshot=/data/snapshots --shallow',
+            '--compare=/data/previousExecutionData --retries=2',
+        ],
+        flagsSchema,
+    })
+], ExecuteBatch);
+//# sourceMappingURL=execute-batch.js.map