@atom8n/db 1.2.0

package/dist/repositories/execution.repository.js

@@ -0,0 +1,813 @@
+"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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecutionRepository = void 0;
+const backend_common_1 = require("@n8n/backend-common");
+const config_1 = require("@n8n/config");
+const di_1 = require("@n8n/di");
+const typeorm_1 = require("@n8n/typeorm");
+const DateUtils_1 = require("@n8n/typeorm/util/DateUtils");
+const flatted_1 = require("flatted");
+const pick_1 = __importDefault(require("lodash/pick"));
+const n8n_core_1 = require("n8n-core");
+const n8n_workflow_1 = require("n8n-workflow");
+const execution_data_repository_1 = require("./execution-data.repository");
+const entities_1 = require("../entities");
+const separate_1 = require("../utils/separate");
+class PostgresLiveRowsRetrievalError extends n8n_workflow_1.UnexpectedError {
+    constructor(rows) {
+        super('Failed to retrieve live execution rows in Postgres', { extra: { rows } });
+    }
+}
+function parseFiltersToQueryBuilder(qb, filters) {
+    if (filters?.status) {
+        qb.andWhere('execution.status IN (:...workflowStatus)', {
+            workflowStatus: filters.status,
+        });
+    }
+    if (filters?.finished) {
+        qb.andWhere({ finished: filters.finished });
+    }
+    if (filters?.metadata) {
+        qb.leftJoin(entities_1.ExecutionMetadata, 'md', 'md.executionId = execution.id');
+        for (const md of filters.metadata) {
+            if (md.exactMatch) {
+                qb.andWhere('md.key = :key AND md.value = :value', md);
+            }
+            else {
+                qb.andWhere('md.key = :key AND LOWER(md.value) LIKE LOWER(:value)', md);
+            }
+        }
+    }
+    if (filters?.startedAfter) {
+        qb.andWhere({
+            startedAt: (0, typeorm_1.MoreThanOrEqual)(DateUtils_1.DateUtils.mixedDateToUtcDatetimeString(new Date(filters.startedAfter))),
+        });
+    }
+    if (filters?.startedBefore) {
+        qb.andWhere({
+            startedAt: (0, typeorm_1.LessThanOrEqual)(DateUtils_1.DateUtils.mixedDateToUtcDatetimeString(new Date(filters.startedBefore))),
+        });
+    }
+    if (filters?.workflowId) {
+        qb.andWhere({
+            workflowId: filters.workflowId,
+        });
+    }
+}
+const lessThanOrEqual = (date) => {
+    return (0, typeorm_1.LessThanOrEqual)(DateUtils_1.DateUtils.mixedDateToUtcDatetimeString(new Date(date)));
+};
+const moreThanOrEqual = (date) => {
+    return (0, typeorm_1.MoreThanOrEqual)(DateUtils_1.DateUtils.mixedDateToUtcDatetimeString(new Date(date)));
+};
+const MAX_UPDATE_BATCH_SIZE = 900;
+let ExecutionRepository = class ExecutionRepository extends typeorm_1.Repository {
+    constructor(dataSource, globalConfig, logger, errorReporter, executionDataRepository, binaryDataService) {
+        super(entities_1.ExecutionEntity, dataSource.manager);
+        this.globalConfig = globalConfig;
+        this.logger = logger;
+        this.errorReporter = errorReporter;
+        this.executionDataRepository = executionDataRepository;
+        this.binaryDataService = binaryDataService;
+        this.hardDeletionBatchSize = 100;
+        this.summaryFields = {
+            id: true,
+            workflowId: true,
+            mode: true,
+            retryOf: true,
+            status: true,
+            createdAt: true,
+            startedAt: true,
+            stoppedAt: true,
+        };
+        this.annotationFields = {
+            id: true,
+            vote: true,
+        };
+    }
+    async findQueuedExecutionsWithoutData() {
+        return await this.createQueryBuilder('execution')
+            .where('execution.status = :status', { status: 'new' })
+            .andWhere('NOT EXISTS (' +
+            this.manager
+                .createQueryBuilder()
+                .select('1')
+                .from(entities_1.ExecutionData, 'execution_data')
+                .where('execution_data.executionId = execution.id')
+                .getQuery() +
+            ')')
+            .select('execution.id')
+            .getMany();
+    }
+    async findMultipleExecutions(queryParams, options) {
+        if (options?.includeData) {
+            queryParams.relations ??= [];
+            if (Array.isArray(queryParams.relations)) {
+                queryParams.relations.push('executionData', 'metadata');
+            }
+            else {
+                queryParams.relations.executionData = true;
+                queryParams.relations.metadata = true;
+            }
+        }
+        const executions = await this.find(queryParams);
+        const [valid, invalid] = (0, separate_1.separate)(executions, (e) => e.executionData !== null);
+        this.reportInvalidExecutions(invalid);
+        if (!options?.includeData) {
+            return executions.map((execution) => {
+                const { executionData, ...rest } = execution;
+                return rest;
+            });
+        }
+        return valid.map((execution) => {
+            const { executionData, metadata, ...rest } = execution;
+            const data = this.handleExecutionRunData(executionData.data, options);
+            return {
+                ...rest,
+                data,
+                workflowData: executionData.workflowData,
+                customData: Object.fromEntries(metadata.map((m) => [m.key, m.value])),
+            };
+        });
+    }
+    reportInvalidExecutions(executions) {
+        if (executions.length === 0)
+            return;
+        this.errorReporter.error(new n8n_workflow_1.UnexpectedError('Found executions without executionData', {
+            extra: {
+                executionIds: executions.map(({ id }) => id),
+                isLegacySqlite: this.globalConfig.database.isLegacySqlite,
+            },
+        }));
+    }
+    serializeAnnotation(annotation) {
+        if (!annotation)
+            return null;
+        const { id, vote, tags } = annotation;
+        return {
+            id,
+            vote,
+            tags: tags?.map((tag) => (0, pick_1.default)(tag, ['id', 'name'])) ?? [],
+        };
+    }
+    async findSingleExecution(id, options) {
+        const findOptions = {
+            where: {
+                id,
+                ...options?.where,
+            },
+        };
+        if (options?.includeData) {
+            findOptions.relations = { executionData: true, metadata: true };
+        }
+        if (options?.includeAnnotation) {
+            findOptions.relations = {
+                ...findOptions.relations,
+                annotation: {
+                    tags: true,
+                },
+            };
+        }
+        const execution = await this.findOne(findOptions);
+        if (!execution) {
+            return undefined;
+        }
+        const { executionData, metadata, annotation, ...rest } = execution;
+        const serializedAnnotation = this.serializeAnnotation(annotation);
+        if (execution.status === 'success' && executionData?.data === '[]') {
+            this.errorReporter.error('Found successful execution where data is empty stringified array', {
+                extra: {
+                    executionId: execution.id,
+                    workflowId: executionData?.workflowData.id,
+                },
+            });
+        }
+        if (!options?.includeData) {
+            const { executionData, ...rest } = execution;
+            return {
+                ...rest,
+                ...(options?.includeAnnotation &&
+                    serializedAnnotation && { annotation: serializedAnnotation }),
+            };
+        }
+        const data = this.handleExecutionRunData(executionData.data, options);
+        return {
+            ...rest,
+            data,
+            workflowData: executionData.workflowData,
+            customData: Object.fromEntries(metadata.map((m) => [m.key, m.value])),
+            ...(options?.includeAnnotation &&
+                serializedAnnotation && { annotation: serializedAnnotation }),
+        };
+    }
+    async createNewExecution(execution) {
+        const { data: dataObj, workflowData: currentWorkflow, ...rest } = execution;
+        const { connections, nodes, name, settings } = currentWorkflow ?? {};
+        const workflowData = { connections, nodes, name, settings, id: currentWorkflow.id };
+        const data = (0, flatted_1.stringify)(dataObj);
+        const { type: dbType, sqlite: sqliteConfig } = this.globalConfig.database;
+        if (dbType === 'sqlite' && sqliteConfig.poolSize === 0) {
+            const { identifiers: inserted } = await this.insert({ ...rest, createdAt: new Date() });
+            const { id: executionId } = inserted[0];
+            await this.executionDataRepository.insert({
+                executionId,
+                workflowData,
+                data,
+                workflowVersionId: currentWorkflow.versionId,
+            });
+            return String(executionId);
+        }
+        else {
+            return await this.manager.transaction(async (transactionManager) => {
+                const { identifiers: inserted } = await transactionManager.insert(entities_1.ExecutionEntity, {
+                    ...rest,
+                    createdAt: new Date(),
+                });
+                const { id: executionId } = inserted[0];
+                await this.executionDataRepository.createExecutionDataForExecution({ executionId, workflowData, data, workflowVersionId: currentWorkflow.versionId }, transactionManager);
+                return String(executionId);
+            });
+        }
+    }
+    async markAsCrashed(executionIds) {
+        if (!Array.isArray(executionIds))
+            executionIds = [executionIds];
+        let processed = 0;
+        while (processed < executionIds.length) {
+            const batch = executionIds.slice(processed, processed + MAX_UPDATE_BATCH_SIZE);
+            await this.update({ id: (0, typeorm_1.In)(batch) }, {
+                status: 'crashed',
+                stoppedAt: new Date(),
+            });
+            this.logger.info('Marked executions as `crashed`', { executionIds });
+            processed += batch.length;
+        }
+    }
+    async hardDelete(ids) {
+        return await Promise.all([
+            this.delete(ids.executionId),
+            this.binaryDataService.deleteMany([{ type: 'execution', ...ids }]),
+        ]);
+    }
+    async setRunning(executionId) {
+        const startedAt = new Date();
+        await this.update({ id: executionId }, { status: 'running', startedAt });
+        return startedAt;
+    }
+    async updateExistingExecution(executionId, execution, requireStatus) {
+        const { id, data, workflowId, workflowData, createdAt, startedAt, customData, ...executionInformation } = execution;
+        const executionData = {};
+        if (workflowData)
+            executionData.workflowData = workflowData;
+        if (data)
+            executionData.data = (0, flatted_1.stringify)(data);
+        const { type: dbType, sqlite: sqliteConfig } = this.globalConfig.database;
+        if (dbType === 'sqlite' && sqliteConfig.poolSize === 0) {
+            let executionTableAffectedRows = 0;
+            if (Object.keys(executionInformation).length > 0) {
+                const whereCondition = { id: executionId };
+                if (requireStatus)
+                    whereCondition.status = requireStatus;
+                const result = await this.update(whereCondition, executionInformation);
+                executionTableAffectedRows = result.affected ?? 0;
+                if (requireStatus && executionTableAffectedRows === 0) {
+                    return false;
+                }
+            }
+            if (Object.keys(executionData).length > 0) {
+                await this.executionDataRepository.update({ executionId }, executionData);
+            }
+            return true;
+        }
+        let executionTableAffectedRows = 0;
+        return await this.manager.transaction(async (tx) => {
+            if (Object.keys(executionInformation).length > 0) {
+                const whereCondition = { id: executionId };
+                if (requireStatus)
+                    whereCondition.status = requireStatus;
+                const result = await tx.update(entities_1.ExecutionEntity, whereCondition, executionInformation);
+                executionTableAffectedRows = result.affected ?? 0;
+                if (executionTableAffectedRows === 0) {
+                    return false;
+                }
+            }
+            if (Object.keys(executionData).length > 0) {
+                await tx.update(entities_1.ExecutionData, { executionId }, executionData);
+            }
+            return true;
+        });
+    }
+    async deleteExecutionsByFilter(filters, accessibleWorkflowIds, deleteConditions) {
+        if (!deleteConditions?.deleteBefore && !deleteConditions?.ids) {
+            throw new n8n_workflow_1.UnexpectedError('Either "deleteBefore" or "ids" must be present in the request body');
+        }
+        const query = this.createQueryBuilder('execution')
+            .select(['execution.id', 'execution.workflowId'])
+            .andWhere('execution.workflowId IN (:...accessibleWorkflowIds)', { accessibleWorkflowIds });
+        if (deleteConditions.deleteBefore) {
+            query.andWhere('execution.startedAt <= :deleteBefore', {
+                deleteBefore: deleteConditions.deleteBefore,
+            });
+            parseFiltersToQueryBuilder(query, filters);
+        }
+        else if (deleteConditions.ids) {
+            query.andWhere('execution.id IN (:...executionIds)', { executionIds: deleteConditions.ids });
+        }
+        const executions = await query.getMany();
+        if (!executions.length) {
+            if (deleteConditions.ids) {
+                this.logger.error('Failed to delete an execution due to insufficient permissions', {
+                    executionIds: deleteConditions.ids,
+                });
+            }
+            return;
+        }
+        const ids = executions.map(({ id, workflowId }) => ({
+            type: 'execution',
+            executionId: id,
+            workflowId,
+        }));
+        do {
+            const batch = ids.splice(0, this.hardDeletionBatchSize);
+            await Promise.all([
+                this.delete(batch.map(({ executionId }) => executionId)),
+                this.binaryDataService.deleteMany(batch),
+            ]);
+        } while (ids.length > 0);
+    }
+    async getIdsSince(date) {
+        return await this.find({
+            select: ['id'],
+            where: {
+                startedAt: (0, typeorm_1.MoreThanOrEqual)(DateUtils_1.DateUtils.mixedDateToUtcDatetimeString(date)),
+            },
+        }).then((executions) => executions.map(({ id }) => id));
+    }
+    async softDeletePrunableExecutions() {
+        const { pruneDataMaxAge, pruneDataMaxCount } = this.globalConfig.executions;
+        const annotatedExecutionsSubQuery = this.manager
+            .createQueryBuilder()
+            .subQuery()
+            .select('annotation.executionId')
+            .from(entities_1.ExecutionAnnotation, 'annotation');
+        const date = new Date();
+        date.setHours(date.getHours() - pruneDataMaxAge);
+        const toPrune = [
+            { stoppedAt: (0, typeorm_1.LessThanOrEqual)(DateUtils_1.DateUtils.mixedDateToUtcDatetimeString(date)) },
+        ];
+        if (pruneDataMaxCount > 0) {
+            const executions = await this.createQueryBuilder('execution')
+                .select('execution.id')
+                .where('execution.id NOT IN ' + annotatedExecutionsSubQuery.getQuery())
+                .skip(pruneDataMaxCount)
+                .take(1)
+                .orderBy('execution.id', 'DESC')
+                .getMany();
+            if (executions[0]) {
+                toPrune.push({ id: (0, typeorm_1.LessThanOrEqual)(executions[0].id) });
+            }
+        }
+        const [timeBasedWhere, countBasedWhere] = toPrune;
+        return await this.createQueryBuilder()
+            .update(entities_1.ExecutionEntity)
+            .set({ deletedAt: new Date() })
+            .where({
+            deletedAt: (0, typeorm_1.IsNull)(),
+            status: (0, typeorm_1.Not)((0, typeorm_1.In)(['new', 'running', 'waiting'])),
+        })
+            .andWhere('id NOT IN ' + annotatedExecutionsSubQuery.getQuery())
+            .andWhere(new typeorm_1.Brackets((qb) => countBasedWhere
+            ? qb.where(timeBasedWhere).orWhere(countBasedWhere)
+            : qb.where(timeBasedWhere)))
+            .execute();
+    }
+    async findSoftDeletedExecutions() {
+        const date = new Date();
+        date.setHours(date.getHours() - this.globalConfig.executions.pruneDataHardDeleteBuffer);
+        const workflowIdsAndExecutionIds = (await this.find({
+            select: ['workflowId', 'id'],
+            where: {
+                deletedAt: (0, typeorm_1.LessThanOrEqual)(DateUtils_1.DateUtils.mixedDateToUtcDatetimeString(date)),
+            },
+            take: this.hardDeletionBatchSize,
+            withDeleted: true,
+        })).map(({ id: executionId, workflowId }) => ({
+            type: 'execution',
+            workflowId,
+            executionId,
+        }));
+        return workflowIdsAndExecutionIds;
+    }
+    async deleteByIds(executionIds) {
+        return await this.delete({ id: (0, typeorm_1.In)(executionIds) });
+    }
+    async getWaitingExecutions() {
+        const waitTill = new Date(Date.now() + 70000);
+        const where = {
+            waitTill: (0, typeorm_1.LessThanOrEqual)(waitTill),
+            status: (0, typeorm_1.Not)('crashed'),
+        };
+        const dbType = this.globalConfig.database.type;
+        if (dbType === 'sqlite') {
+            where.waitTill = (0, typeorm_1.LessThanOrEqual)(DateUtils_1.DateUtils.mixedDateToUtcDatetimeString(waitTill));
+        }
+        return await this.findMultipleExecutions({
+            select: ['id', 'waitTill'],
+            where,
+            order: {
+                waitTill: 'ASC',
+            },
+        });
+    }
+    async getExecutionsCountForPublicApi(params) {
+        const executionsCount = await this.count({
+            where: this.getFindExecutionsForPublicApiCondition(params),
+            take: params.limit,
+        });
+        return executionsCount;
+    }
+    getStatusCondition(status) {
+        const condition = {};
+        if (status === 'success') {
+            condition.status = 'success';
+        }
+        else if (status === 'waiting') {
+            condition.status = 'waiting';
+        }
+        else if (status === 'error') {
+            condition.status = (0, typeorm_1.In)(['error', 'crashed']);
+        }
+        else if (status === 'canceled') {
+            condition.status = 'canceled';
+        }
+        else if (status === 'running') {
+            condition.status = 'running';
+        }
+        return condition;
+    }
+    getIdCondition(params) {
+        const condition = {};
+        if (params.lastId && params.excludedExecutionsIds?.length) {
+            condition.id = (0, typeorm_1.And)((0, typeorm_1.LessThan)(params.lastId), (0, typeorm_1.Not)((0, typeorm_1.In)(params.excludedExecutionsIds)));
+        }
+        else if (params.lastId) {
+            condition.id = (0, typeorm_1.LessThan)(params.lastId);
+        }
+        else if (params.excludedExecutionsIds?.length) {
+            condition.id = (0, typeorm_1.Not)((0, typeorm_1.In)(params.excludedExecutionsIds));
+        }
+        return condition;
+    }
+    getFindExecutionsForPublicApiCondition(params) {
+        const where = {
+            ...this.getIdCondition({
+                lastId: params.lastId,
+                excludedExecutionsIds: params.excludedExecutionsIds,
+            }),
+            ...this.getStatusCondition(params.status),
+            ...(params.workflowIds && { workflowId: (0, typeorm_1.In)(params.workflowIds) }),
+        };
+        return where;
+    }
+    async getExecutionsForPublicApi(params) {
+        const where = this.getFindExecutionsForPublicApiCondition(params);
+        return await this.findMultipleExecutions({
+            select: [
+                'id',
+                'mode',
+                'retryOf',
+                'retrySuccessId',
+                'startedAt',
+                'stoppedAt',
+                'workflowId',
+                'waitTill',
+                'finished',
+                'status',
+            ],
+            where,
+            order: { id: 'DESC' },
+            take: params.limit,
+        }, {
+            includeData: params.includeData,
+            unflattenData: true,
+        });
+    }
+    async getExecutionInWorkflowsForPublicApi(id, workflowIds, includeData) {
+        return await this.findSingleExecution(id, {
+            where: {
+                workflowId: (0, typeorm_1.In)(workflowIds),
+            },
+            includeData,
+            unflattenData: true,
+        });
+    }
+    async findWithUnflattenedData(executionId, accessibleWorkflowIds) {
+        return await this.findSingleExecution(executionId, {
+            where: {
+                workflowId: (0, typeorm_1.In)(accessibleWorkflowIds),
+            },
+            includeData: true,
+            unflattenData: true,
+            includeAnnotation: true,
+        });
+    }
+    async findIfShared(executionId, sharedWorkflowIds) {
+        return await this.findSingleExecution(executionId, {
+            where: {
+                workflowId: (0, typeorm_1.In)(sharedWorkflowIds),
+            },
+            includeData: true,
+            unflattenData: false,
+            includeAnnotation: true,
+        });
+    }
+    async findIfAccessible(executionId, accessibleWorkflowIds) {
+        return await this.findSingleExecution(executionId, {
+            where: { workflowId: (0, typeorm_1.In)(accessibleWorkflowIds) },
+        });
+    }
+    async stopBeforeRun(execution) {
+        execution.status = 'canceled';
+        execution.stoppedAt = new Date();
+        await this.update({ id: execution.id }, { status: execution.status, stoppedAt: execution.stoppedAt });
+        return execution;
+    }
+    async stopDuringRun(execution) {
+        const error = new n8n_workflow_1.ManualExecutionCancelledError(execution.id);
+        execution.data = execution.data || (0, n8n_workflow_1.createEmptyRunExecutionData)();
+        execution.data.resultData.error = {
+            ...error,
+            message: error.message,
+            stack: error.stack,
+        };
+        execution.stoppedAt = new Date();
+        execution.waitTill = null;
+        execution.status = 'canceled';
+        await this.updateExistingExecution(execution.id, execution);
+        return execution;
+    }
+    async cancelMany(executionIds) {
+        await this.update({ id: (0, typeorm_1.In)(executionIds) }, { status: 'canceled', stoppedAt: new Date() });
+    }
+    reduceExecutionsWithAnnotations(rawExecutionsWithTags) {
+        return rawExecutionsWithTags.reduce((acc, { annotation_id: _, annotation_vote: vote, annotation_tags_id: tagId, annotation_tags_name: tagName, ...row }) => {
+            const existingExecution = acc.find((e) => e.id === row.id);
+            if (existingExecution) {
+                if (tagId) {
+                    existingExecution.annotation = existingExecution.annotation ?? {
+                        vote,
+                        tags: [],
+                    };
+                    existingExecution.annotation.tags.push({ id: tagId, name: tagName });
+                }
+            }
+            else {
+                acc.push({
+                    ...row,
+                    annotation: {
+                        vote,
+                        tags: tagId ? [{ id: tagId, name: tagName }] : [],
+                    },
+                });
+            }
+            return acc;
+        }, []);
+    }
+    async findManyByRangeQuery(query) {
+        if (query?.accessibleWorkflowIds?.length === 0) {
+            throw new n8n_workflow_1.UnexpectedError('Expected accessible workflow IDs');
+        }
+        const qb = this.toQueryBuilderWithAnnotations(query);
+        const rawExecutionsWithTags = await qb.getRawMany();
+        const executions = this.reduceExecutionsWithAnnotations(rawExecutionsWithTags);
+        return executions.map((execution) => this.toSummary(execution));
+    }
+    toSummary(execution) {
+        execution.id = execution.id.toString();
+        const normalizeDateString = (date) => {
+            if (date.includes(' '))
+                return date.replace(' ', 'T') + 'Z';
+            return date;
+        };
+        if (execution.createdAt) {
+            execution.createdAt =
+                execution.createdAt instanceof Date
+                    ? execution.createdAt.toISOString()
+                    : normalizeDateString(execution.createdAt);
+        }
+        if (execution.startedAt) {
+            execution.startedAt =
+                execution.startedAt instanceof Date
+                    ? execution.startedAt.toISOString()
+                    : normalizeDateString(execution.startedAt);
+        }
+        if (execution.waitTill) {
+            execution.waitTill =
+                execution.waitTill instanceof Date
+                    ? execution.waitTill.toISOString()
+                    : normalizeDateString(execution.waitTill);
+        }
+        if (execution.stoppedAt) {
+            execution.stoppedAt =
+                execution.stoppedAt instanceof Date
+                    ? execution.stoppedAt.toISOString()
+                    : normalizeDateString(execution.stoppedAt);
+        }
+        return execution;
+    }
+    async fetchCount(query) {
+        return await this.toQueryBuilder(query).getCount();
+    }
+    async getLiveExecutionRowsOnPostgres() {
+        const tableName = `${this.globalConfig.database.tablePrefix}execution_entity`;
+        const pgSql = `SELECT n_live_tup as result FROM pg_stat_all_tables WHERE relname = '${tableName}' and schemaname = '${this.globalConfig.database.postgresdb.schema}';`;
+        try {
+            const rows = (await this.query(pgSql));
+            if (rows.length !== 1)
+                throw new PostgresLiveRowsRetrievalError(rows);
+            const [row] = rows;
+            return parseInt(row.result, 10);
+        }
+        catch (error) {
+            if (error instanceof Error)
+                this.logger.error(error.message, { error });
+            return -1;
+        }
+    }
+    toQueryBuilder(query) {
+        const { accessibleWorkflowIds, status, finished, workflowId, startedBefore, startedAfter, executionTimeMin, executionTimeMax, metadata, annotationTags, vote, projectId, } = query;
+        const fields = Object.keys(this.summaryFields)
+            .concat(['waitTill', 'retrySuccessId'])
+            .map((key) => `execution.${key} AS "${key}"`)
+            .concat('workflow.name AS "workflowName"');
+        const qb = this.createQueryBuilder('execution')
+            .select(fields)
+            .innerJoin('execution.workflow', 'workflow')
+            .where('execution.workflowId IN (:...accessibleWorkflowIds)', { accessibleWorkflowIds });
+        if (query.kind === 'range') {
+            const { limit, firstId, lastId } = query.range;
+            qb.limit(limit);
+            if (firstId)
+                qb.andWhere('execution.id > :firstId', { firstId });
+            if (lastId)
+                qb.andWhere('execution.id < :lastId', { lastId });
+            if (query.order?.startedAt === 'DESC') {
+                qb.orderBy({ 'COALESCE(execution.startedAt, execution.createdAt)': 'DESC' });
+            }
+            else if (query.order?.top) {
+                qb.orderBy(`(CASE WHEN execution.status = '${query.order.top}' THEN 0 ELSE 1 END)`);
+            }
+            else {
+                qb.orderBy({ 'execution.id': 'DESC' });
+            }
+        }
+        if (status)
+            qb.andWhere('execution.status IN (:...status)', { status });
+        if (finished)
+            qb.andWhere({ finished });
+        if (workflowId)
+            qb.andWhere({ workflowId });
+        if (startedBefore)
+            qb.andWhere({ startedAt: lessThanOrEqual(startedBefore) });
+        if (startedAfter)
+            qb.andWhere({ startedAt: moreThanOrEqual(startedAfter) });
+        if (executionTimeMin !== undefined || executionTimeMax !== undefined) {
+            const dbType = this.globalConfig.database.type;
+            let durationExpression;
+            if (dbType === 'postgresdb') {
+                durationExpression = 'EXTRACT(EPOCH FROM (execution.stoppedAt - execution.startedAt))';
+            }
+            else if (dbType === 'mysqldb') {
+                durationExpression = 'TIMESTAMPDIFF(SECOND, execution.startedAt, execution.stoppedAt)';
+            }
+            else if (dbType === 'sqlite') {
+                durationExpression =
+                    '(julianday(execution.stoppedAt) - julianday(execution.startedAt)) * 86400';
+            }
+            else {
+                durationExpression = 'EXTRACT(EPOCH FROM (execution.stoppedAt - execution.startedAt))';
+            }
+            qb.andWhere('execution.stoppedAt IS NOT NULL');
+            qb.andWhere('execution.startedAt IS NOT NULL');
+            if (executionTimeMin !== undefined) {
+                qb.andWhere(`${durationExpression} >= :executionTimeMin`, {
+                    executionTimeMin,
+                });
+            }
+            if (executionTimeMax !== undefined) {
+                qb.andWhere(`${durationExpression} <= :executionTimeMax`, {
+                    executionTimeMax,
+                });
+            }
+        }
+        if (metadata?.length === 1) {
+            const [{ key, value, exactMatch }] = metadata;
+            const executionIdMatch = 'md.executionId = execution.id';
+            const keyMatch = exactMatch ? 'md.key = :key' : 'LOWER(md.key) = LOWER(:key)';
+            const valueMatch = exactMatch ? 'md.value = :value' : 'LOWER(md.value) LIKE LOWER(:value)';
+            const matches = [executionIdMatch, keyMatch, valueMatch];
+            qb.innerJoin(entities_1.ExecutionMetadata, 'md', matches.join(' AND '));
+            qb.setParameter('key', key);
+            qb.setParameter('value', exactMatch ? value : `%${value}%`);
+        }
+        if (annotationTags?.length || vote) {
+            qb.innerJoin('execution.annotation', 'annotation');
+            if (annotationTags?.length) {
+                for (let index = 0; index < annotationTags.length; index++) {
+                    qb.innerJoin(entities_1.AnnotationTagMapping, `atm_${index}`, `atm_${index}.annotationId = annotation.id AND atm_${index}.tagId = :tagId_${index}`);
+                    qb.setParameter(`tagId_${index}`, annotationTags[index]);
+                }
+            }
+            if (vote) {
+                qb.andWhere('annotation.vote = :vote', { vote });
+            }
+        }
+        if (projectId) {
+            qb.innerJoin(entities_1.WorkflowEntity, 'w', 'w.id = execution.workflowId')
+                .innerJoin(entities_1.SharedWorkflow, 'sw', 'sw.workflowId = w.id')
+                .andWhere('sw.projectId = :projectId', { projectId });
+        }
+        return qb;
+    }
+    toQueryBuilderWithAnnotations(query) {
+        const annotationFields = Object.keys(this.annotationFields).map((key) => `annotation.${key} AS "annotation_${key}"`);
+        const subQuery = this.toQueryBuilder(query).addSelect(annotationFields);
+        if (!subQuery.expressionMap.joinAttributes.some((join) => join.alias.name === 'annotation')) {
+            subQuery.leftJoin('execution.annotation', 'annotation');
+        }
+        const qb = this.manager
+            .createQueryBuilder()
+            .select(['e.*', 'ate.id AS "annotation_tags_id"', 'ate.name AS "annotation_tags_name"'])
+            .from(`(${subQuery.getQuery()})`, 'e')
+            .setParameters(subQuery.getParameters())
+            .leftJoin(entities_1.AnnotationTagMapping, 'atm', 'atm.annotationId = e.annotation_id')
+            .leftJoin(entities_1.AnnotationTagEntity, 'ate', 'ate.id = atm.tagId');
+        if (query.kind === 'range') {
+            if (query.order?.startedAt === 'DESC') {
+                const table = qb.escape('e');
+                const startedAt = qb.escape('startedAt');
+                const createdAt = qb.escape('createdAt');
+                qb.orderBy({ [`COALESCE(${table}.${startedAt}, ${table}.${createdAt})`]: 'DESC' });
+            }
+            else if (query.order?.top) {
+                qb.orderBy(`(CASE WHEN e.status = '${query.order.top}' THEN 0 ELSE 1 END)`);
+            }
+            else {
+                qb.orderBy({ 'e.id': 'DESC' });
+            }
+        }
+        return qb;
+    }
+    async getAllIds() {
+        const executions = await this.find({ select: ['id'], order: { id: 'ASC' } });
+        return executions.map(({ id }) => id);
+    }
+    async getInProgressExecutionIds(batchSize) {
+        const executions = await this.find({
+            select: ['id'],
+            where: { status: (0, typeorm_1.In)(['new', 'running']) },
+            order: { startedAt: 'DESC' },
+            take: batchSize,
+        });
+        return executions.map(({ id }) => id);
+    }
+    async getConcurrentExecutionsCount() {
+        const concurrentExecutionsCount = await this.count({
+            where: { status: 'running', mode: (0, typeorm_1.In)(['webhook', 'trigger']) },
+        });
+        return concurrentExecutionsCount;
+    }
+    handleExecutionRunData(data, options = {}) {
+        if (options.unflattenData) {
+            const deserializedData = (0, flatted_1.parse)(data);
+            if (deserializedData) {
+                return (0, n8n_workflow_1.migrateRunExecutionData)(deserializedData);
+            }
+            return undefined;
+        }
+        return data;
+    }
+};
+exports.ExecutionRepository = ExecutionRepository;
+exports.ExecutionRepository = ExecutionRepository = __decorate([
+    (0, di_1.Service)(),
+    __metadata("design:paramtypes", [typeorm_1.DataSource,
+        config_1.GlobalConfig,
+        backend_common_1.Logger,
+        n8n_core_1.ErrorReporter,
+        execution_data_repository_1.ExecutionDataRepository,
+        n8n_core_1.BinaryDataService])
+], ExecutionRepository);
+//# sourceMappingURL=execution.repository.js.map