n8n 1.110.1 → 1.112.0

package/dist/modules/data-table/data-store-proxy.service.d.ts

@@ -1,7 +1,7 @@
 import { Logger } from '@n8n/backend-common';
 import { DataStoreProxyProvider, IDataStoreProjectAggregateService, IDataStoreProjectService, INode, Workflow } from 'n8n-workflow';
-import { DataStoreService } from './data-store.service';
 import { OwnershipService } from '../../services/ownership.service';
+import { DataStoreService } from './data-store.service';
 export declare class DataStoreProxyService implements DataStoreProxyProvider {
     private readonly dataStoreService;
     private readonly ownershipService;
@@ -9,8 +9,8 @@ export declare class DataStoreProxyService implements DataStoreProxyProvider {
     constructor(dataStoreService: DataStoreService, ownershipService: OwnershipService, logger: Logger);
     private validateRequest;
     private getProjectId;
-    getDataStoreAggregateProxy(workflow: Workflow, node: INode, dataStoreProjectId?: string): Promise<IDataStoreProjectAggregateService>;
-    getDataStoreProxy(workflow: Workflow, node: INode, dataStoreId: string, dataStoreProjectId?: string): Promise<IDataStoreProjectService>;
+    getDataStoreAggregateProxy(workflow: Workflow, node: INode, projectId?: string): Promise<IDataStoreProjectAggregateService>;
+    getDataStoreProxy(workflow: Workflow, node: INode, dataStoreId: string, projectId?: string): Promise<IDataStoreProjectService>;
     private makeAggregateOperations;
     private makeDataStoreOperations;
 }

package/dist/modules/data-table/data-store-proxy.service.js

@@ -12,8 +12,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DataStoreProxyService = void 0;
 const backend_common_1 = require("@n8n/backend-common");
 const di_1 = require("@n8n/di");
-const data_store_service_1 = require("./data-store.service");
 const ownership_service_1 = require("../../services/ownership.service");
+const data_store_service_1 = require("./data-store.service");
 let DataStoreProxyService = class DataStoreProxyService {
     constructor(dataStoreService, ownershipService, logger) {
         this.dataStoreService = dataStoreService;
@@ -23,21 +23,21 @@ let DataStoreProxyService = class DataStoreProxyService {
     }
     validateRequest(node) {
         if (node.type !== 'n8n-nodes-base.dataTable' && node.type !== 'n8n-nodes-base.dataTableTool') {
-            throw new Error('This proxy is only available for data table nodes');
+            throw new Error('This proxy is only available for Data table nodes');
         }
     }
     async getProjectId(workflow) {
         const homeProject = await this.ownershipService.getWorkflowProjectCached(workflow.id);
         return homeProject.id;
     }
-    async getDataStoreAggregateProxy(workflow, node, dataStoreProjectId) {
+    async getDataStoreAggregateProxy(workflow, node, projectId) {
         this.validateRequest(node);
-        const projectId = dataStoreProjectId ?? (await this.getProjectId(workflow));
+        projectId = projectId ?? (await this.getProjectId(workflow));
         return this.makeAggregateOperations(projectId);
     }
-    async getDataStoreProxy(workflow, node, dataStoreId, dataStoreProjectId) {
+    async getDataStoreProxy(workflow, node, dataStoreId, projectId) {
         this.validateRequest(node);
-        const projectId = dataStoreProjectId ?? (await this.getProjectId(workflow));
+        projectId = projectId ?? (await this.getProjectId(workflow));
         return this.makeDataStoreOperations(projectId, dataStoreId);
     }
     makeAggregateOperations(projectId) {
@@ -85,17 +85,17 @@ let DataStoreProxyService = class DataStoreProxyService {
             async getManyRowsAndCount(options) {
                 return await dataStoreService.getManyRowsAndCount(dataStoreId, projectId, options);
             },
-            async insertRows(rows) {
-                return await dataStoreService.insertRows(dataStoreId, projectId, rows, true);
+            async insertRows(rows, returnType) {
+                return await dataStoreService.insertRows(dataStoreId, projectId, rows, returnType);
             },
-            async updateRows(options) {
+            async updateRow(options) {
                 return await dataStoreService.updateRow(dataStoreId, projectId, options, true);
             },
-            async upsertRows(options) {
-                return await dataStoreService.upsertRows(dataStoreId, projectId, options, true);
+            async upsertRow(options) {
+                return await dataStoreService.upsertRow(dataStoreId, projectId, options, true);
             },
-            async deleteRows(ids) {
-                return await dataStoreService.deleteRows(dataStoreId, projectId, ids);
+            async deleteRows(options) {
+                return await dataStoreService.deleteRows(dataStoreId, projectId, options, true);
             },
         };
     }

package/dist/modules/data-table/data-store-proxy.service.js.map

@@ -1 +1 @@
-{"version":3,"file":"data-store-proxy.service.js","sourceRoot":"","sources":["../../../src/modules/data-table/data-store-proxy.service.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"data-store-proxy.service.js","sourceRoot":"","sources":["../../../src/modules/data-table/data-store-proxy.service.ts"],"names":[],"mappings":"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"}

package/dist/modules/data-table/data-store-rows.repository.d.ts

@@ -1,42 +1,35 @@
-import type { ListDataStoreContentQueryDto } from '@n8n/api-types';
-import { GlobalConfig } from '@n8n/config';
-import { DataSource, DataSourceOptions, QueryRunner } from '@n8n/typeorm';
-import { DataStoreColumnJsType, DataStoreRows, DataStoreRowReturn, DataStoreRowsReturn } from 'n8n-workflow';
+import { ListDataStoreContentQueryDto, DataTableFilter } from '@n8n/api-types';
+import { DataSource, DataSourceOptions, QueryRunner, EntityManager } from '@n8n/typeorm';
+import { DataStoreColumnJsType, DataStoreRows, DataStoreRowReturn, DataStoreRowsReturn, DataTableInsertRowsReturnType, DataTableInsertRowsResult } from 'n8n-workflow';
 import { DataStoreUserTableName } from './data-store.types';
 import { DataTableColumn } from './data-table-column.entity';
 export declare class DataStoreRowsRepository {
     private dataSource;
-    private readonly globalConfig;
-    constructor(dataSource: DataSource, globalConfig: GlobalConfig);
-    toTableName(dataStoreId: string): DataStoreUserTableName;
-    insertRows<T extends boolean | undefined>(dataStoreId: string, rows: DataStoreRows, columns: DataTableColumn[], returnData?: T): Promise<Array<T extends true ? DataStoreRowReturn : Pick<DataStoreRowReturn, 'id'>>>;
-    updateRow(dataStoreId: string, setData: Record<string, DataStoreColumnJsType | null>, whereData: Record<string, DataStoreColumnJsType | null>, columns: DataTableColumn[], returnData?: boolean): Promise<true | {
-        [x: string]: DataStoreColumnJsType;
-        id: number;
-        createdAt: Date;
-        updatedAt: Date;
-    }[]>;
-    upsertRows<T extends boolean | undefined>(dataStoreId: string, matchFields: string[], rows: DataStoreRows, columns: DataTableColumn[], returnData?: T): Promise<T extends true ? DataStoreRowReturn[] : true>;
-    deleteRows(dataStoreId: string, ids: number[]): Promise<boolean>;
+    constructor(dataSource: DataSource);
+    insertRowsBulk(table: DataStoreUserTableName, rows: DataStoreRows, columns: DataTableColumn[], em: EntityManager): Promise<{
+        readonly success: true;
+        readonly insertedRows: number;
+    }>;
+    insertRows<T extends DataTableInsertRowsReturnType>(dataStoreId: string, rows: DataStoreRows, columns: DataTableColumn[], returnType: T, em?: EntityManager): Promise<DataTableInsertRowsResult<T>>;
+    updateRow<T extends boolean | undefined>(dataStoreId: string, data: Record<string, DataStoreColumnJsType | null>, filter: DataTableFilter, columns: DataTableColumn[], returnData?: T, em?: EntityManager): Promise<T extends true ? DataStoreRowReturn[] : true>;
+    deleteRows(dataTableId: string, columns: DataTableColumn[], filter: DataTableFilter | undefined, returnData?: boolean): Promise<true | DataStoreRowReturn[]>;
     createTableWithColumns(dataStoreId: string, columns: DataTableColumn[], queryRunner: QueryRunner): Promise<void>;
     dropTable(dataStoreId: string, queryRunner: QueryRunner): Promise<void>;
     addColumn(dataStoreId: string, column: DataTableColumn, queryRunner: QueryRunner, dbType: DataSourceOptions['type']): Promise<void>;
     dropColumnFromTable(dataStoreId: string, columnName: string, queryRunner: QueryRunner, dbType: DataSourceOptions['type']): Promise<void>;
-    getManyAndCount(dataStoreId: string, dto: ListDataStoreContentQueryDto, columns?: DataTableColumn[]): Promise<{
+    getManyAndCount(dataStoreId: string, dto: ListDataStoreContentQueryDto, columns?: DataTableColumn[], em?: EntityManager): Promise<{
         count: number;
         data: DataStoreRowsReturn;
     }>;
-    getManyByIds(dataStoreId: string, ids: number[], columns: DataTableColumn[]): Promise<{
+    getManyByIds(dataStoreId: string, ids: number[], columns: DataTableColumn[], em: EntityManager): Promise<{
         [x: string]: DataStoreColumnJsType;
         id: number;
         createdAt: Date;
         updatedAt: Date;
     }[]>;
-    getRowIds(dataStoreId: string, dto: ListDataStoreContentQueryDto): Promise<number[]>;
     private getManyQuery;
     private applyFilters;
     private applySorting;
     private applySortingByField;
     private applyPagination;
-    private fetchAndSplitRowsByExistence;
 }

package/dist/modules/data-table/data-store-rows.repository.js

@@ -10,21 +10,22 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DataStoreRowsRepository = void 0;
-const config_1 = require("@n8n/config");
 const db_1 = require("@n8n/db");
 const di_1 = require("@n8n/di");
 const typeorm_1 = require("@n8n/typeorm");
 const n8n_workflow_1 = require("n8n-workflow");
 const sql_utils_1 = require("./utils/sql-utils");
-function getConditionAndParams(filter, index, dbType, columns) {
+function getConditionAndParams(filter, index, dbType, tableReference, columns) {
     const paramName = `filter_${index}`;
-    const column = `${(0, sql_utils_1.quoteIdentifier)('dataStore', dbType)}.${(0, sql_utils_1.quoteIdentifier)(filter.columnName, dbType)}`;
+    const columnRef = tableReference
+        ? `${(0, sql_utils_1.quoteIdentifier)(tableReference, dbType)}.${(0, sql_utils_1.quoteIdentifier)(filter.columnName, dbType)}`
+        : (0, sql_utils_1.quoteIdentifier)(filter.columnName, dbType);
     if (filter.value === null) {
         switch (filter.condition) {
             case 'eq':
-                return [`${column} IS NULL`, {}];
+                return [`${columnRef} IS NULL`, {}];
             case 'neq':
-                return [`${column} IS NOT NULL`, {}];
+                return [`${columnRef} IS NOT NULL`, {}];
         }
     }
     const columnInfo = columns?.find((col) => col.name === filter.columnName);
@@ -38,63 +39,93 @@ function getConditionAndParams(filter, index, dbType, columns) {
         lte: '<=',
     };
     if (operators[filter.condition]) {
-        return [`${column} ${operators[filter.condition]} :${paramName}`, { [paramName]: value }];
+        return [`${columnRef} ${operators[filter.condition]} :${paramName}`, { [paramName]: value }];
     }
     switch (filter.condition) {
         case 'like':
             if (['sqlite', 'sqlite-pooled'].includes(dbType)) {
                 const globValue = (0, sql_utils_1.toSqliteGlobFromPercent)(value);
-                return [`${column} GLOB :${paramName}`, { [paramName]: globValue }];
+                return [`${columnRef} GLOB :${paramName}`, { [paramName]: globValue }];
             }
             if (['mysql', 'mariadb'].includes(dbType)) {
                 const escapedValue = (0, sql_utils_1.escapeLikeSpecials)(value);
-                return [`${column} LIKE BINARY :${paramName} ESCAPE '\\\\'`, { [paramName]: escapedValue }];
+                return [
+                    `${columnRef} LIKE BINARY :${paramName} ESCAPE '\\\\'`,
+                    { [paramName]: escapedValue },
+                ];
             }
             if (dbType === 'postgres') {
                 const escapedValue = (0, sql_utils_1.escapeLikeSpecials)(value);
-                return [`${column} LIKE :${paramName} ESCAPE '\\'`, { [paramName]: escapedValue }];
+                return [`${columnRef} LIKE :${paramName} ESCAPE '\\'`, { [paramName]: escapedValue }];
             }
-            return [`${column} LIKE :${paramName}`, { [paramName]: value }];
+            return [`${columnRef} LIKE :${paramName}`, { [paramName]: value }];
         case 'ilike':
             if (['sqlite', 'sqlite-pooled'].includes(dbType)) {
                 const escapedValue = (0, sql_utils_1.escapeLikeSpecials)(value);
                 return [
-                    `UPPER(${column}) LIKE UPPER(:${paramName}) ESCAPE '\\'`,
+                    `UPPER(${columnRef}) LIKE UPPER(:${paramName}) ESCAPE '\\'`,
                     { [paramName]: escapedValue },
                 ];
             }
             if (['mysql', 'mariadb'].includes(dbType)) {
                 const escapedValue = (0, sql_utils_1.escapeLikeSpecials)(value);
                 return [
-                    `UPPER(${column}) LIKE UPPER(:${paramName}) ESCAPE '\\\\'`,
+                    `UPPER(${columnRef}) LIKE UPPER(:${paramName}) ESCAPE '\\\\'`,
                     { [paramName]: escapedValue },
                 ];
             }
             if (dbType === 'postgres') {
                 const escapedValue = (0, sql_utils_1.escapeLikeSpecials)(value);
-                return [`${column} ILIKE :${paramName} ESCAPE '\\'`, { [paramName]: escapedValue }];
+                return [`${columnRef} ILIKE :${paramName} ESCAPE '\\'`, { [paramName]: escapedValue }];
             }
-            return [`UPPER(${column}) LIKE UPPER(:${paramName})`, { [paramName]: value }];
+            return [`UPPER(${columnRef}) LIKE UPPER(:${paramName})`, { [paramName]: value }];
     }
     throw new Error(`Unsupported filter condition: ${filter.condition}`);
 }
 let DataStoreRowsRepository = class DataStoreRowsRepository {
-    constructor(dataSource, globalConfig) {
+    constructor(dataSource) {
         this.dataSource = dataSource;
-        this.globalConfig = globalConfig;
     }
-    toTableName(dataStoreId) {
-        const { tablePrefix } = this.globalConfig.database;
-        return `${tablePrefix}data_table_user_${dataStoreId}`;
+    async insertRowsBulk(table, rows, columns, em) {
+        const batchSize = 800;
+        const batches = Math.max(1, Math.ceil((columns.length * rows.length) / batchSize));
+        const rowsPerBatch = Math.ceil(rows.length / batches);
+        const columnNames = columns.map((x) => x.name);
+        const dbType = this.dataSource.options.type;
+        let insertedRows = 0;
+        for (let i = 0; i < batches; ++i) {
+            const start = i * rowsPerBatch;
+            const endExclusive = Math.min(rows.length, (i + 1) * rowsPerBatch);
+            if (endExclusive <= start)
+                break;
+            const completeRows = new Array(endExclusive - start);
+            for (let j = start; j < endExclusive; ++j) {
+                const insertArray = [];
+                for (let h = 0; h < columnNames.length; ++h) {
+                    const column = columns[h];
+                    const value = rows[j][column.name] ?? null;
+                    insertArray[h] = (0, sql_utils_1.normalizeValue)(value, column.type, dbType);
+                }
+                completeRows[j - start] = insertArray;
+            }
+            const query = em.createQueryBuilder().insert().into(table, columnNames).values(completeRows);
+            await query.execute();
+            insertedRows += completeRows.length;
+        }
+        return { success: true, insertedRows };
     }
-    async insertRows(dataStoreId, rows, columns, returnData) {
+    async insertRows(dataStoreId, rows, columns, returnType, em) {
+        em = em ?? this.dataSource.manager;
         const inserted = [];
         const dbType = this.dataSource.options.type;
         const useReturning = dbType === 'postgres' || dbType === 'mariadb';
-        const table = this.toTableName(dataStoreId);
+        const table = (0, sql_utils_1.toTableName)(dataStoreId);
         const escapedColumns = columns.map((c) => this.dataSource.driver.escape(c.name));
         const escapedSystemColumns = n8n_workflow_1.DATA_TABLE_SYSTEM_COLUMNS.map((x) => this.dataSource.driver.escape(x));
         const selectColumns = [...escapedSystemColumns, ...escapedColumns];
+        if (returnType === 'count') {
+            return await this.insertRowsBulk(table, rows, columns, em);
+        }
         for (const row of rows) {
             const completeRow = { ...row };
             for (const column of columns) {
@@ -103,13 +134,13 @@ let DataStoreRowsRepository = class DataStoreRowsRepository {
                 }
                 completeRow[column.name] = (0, sql_utils_1.normalizeValue)(completeRow[column.name], column.type, dbType);
             }
-            const query = this.dataSource.createQueryBuilder().insert().into(table).values(completeRow);
+            const query = em.createQueryBuilder().insert().into(table).values(completeRow);
             if (useReturning) {
-                query.returning(returnData ? selectColumns.join(',') : 'id');
+                query.returning(returnType === 'all' ? selectColumns.join(',') : 'id');
             }
             const result = await query.execute();
             if (useReturning) {
-                const returned = returnData
+                const returned = returnType === 'all'
                     ? (0, sql_utils_1.normalizeRows)((0, sql_utils_1.extractReturningData)(result.raw), columns)
                     : (0, sql_utils_1.extractInsertedIds)(result.raw, dbType).map((id) => ({ id }));
                 inserted.push.apply(inserted, returned);
@@ -119,41 +150,39 @@ let DataStoreRowsRepository = class DataStoreRowsRepository {
             if (ids.length === 0) {
                 throw new n8n_workflow_1.UnexpectedError("Couldn't find the inserted row ID");
             }
-            if (!returnData) {
+            if (returnType === 'id') {
                 inserted.push(...ids.map((id) => ({ id })));
                 continue;
             }
-            const insertedRows = await this.getManyByIds(dataStoreId, ids, columns);
+            const insertedRows = await this.getManyByIds(dataStoreId, ids, columns, em);
             inserted.push(...insertedRows);
         }
         return inserted;
     }
-    async updateRow(dataStoreId, setData, whereData, columns, returnData = false) {
+    async updateRow(dataStoreId, data, filter, columns, returnData = false, em) {
+        em = em ?? this.dataSource.manager;
         const dbType = this.dataSource.options.type;
         const useReturning = dbType === 'postgres';
-        const table = this.toTableName(dataStoreId);
+        const table = (0, sql_utils_1.toTableName)(dataStoreId);
         const escapedColumns = columns.map((c) => this.dataSource.driver.escape(c.name));
         const escapedSystemColumns = n8n_workflow_1.DATA_TABLE_SYSTEM_COLUMNS.map((x) => this.dataSource.driver.escape(x));
         const selectColumns = [...escapedSystemColumns, ...escapedColumns];
+        const setData = { ...data };
         for (const column of columns) {
             if (column.name in setData) {
                 setData[column.name] = (0, sql_utils_1.normalizeValue)(setData[column.name], column.type, dbType);
             }
-            if (column.name in whereData) {
-                whereData[column.name] = (0, sql_utils_1.normalizeValue)(whereData[column.name], column.type, dbType);
-            }
         }
         let affectedRows = [];
         if (!useReturning && returnData) {
-            affectedRows = await this.dataSource
-                .createQueryBuilder()
-                .select('id')
-                .from(table, 'dataStore')
-                .where(whereData)
-                .getRawMany();
+            const selectQuery = em.createQueryBuilder().select('id').from(table, 'dataTable');
+            this.applyFilters(selectQuery, filter, 'dataTable', columns);
+            affectedRows = await selectQuery.getRawMany();
         }
         setData.updatedAt = (0, sql_utils_1.normalizeValue)(new Date(), 'date', dbType);
-        const query = this.dataSource.createQueryBuilder().update(table).set(setData).where(whereData);
+        const query = em.createQueryBuilder().update(table);
+        this.applyFilters(query, filter, undefined, columns);
+        query.set(setData);
         if (useReturning && returnData) {
             query.returning(selectColumns.join(','));
         }
@@ -165,109 +194,116 @@ let DataStoreRowsRepository = class DataStoreRowsRepository {
             return (0, sql_utils_1.normalizeRows)((0, sql_utils_1.extractReturningData)(result.raw), columns);
         }
         const ids = affectedRows.map((row) => row.id);
-        return await this.getManyByIds(dataStoreId, ids, columns);
+        return await this.getManyByIds(dataStoreId, ids, columns, em);
     }
-    async upsertRows(dataStoreId, matchFields, rows, columns, returnData) {
-        returnData = returnData ?? false;
-        const { rowsToInsert, rowsToUpdate } = await this.fetchAndSplitRowsByExistence(dataStoreId, matchFields, rows);
-        const output = [];
-        if (rowsToInsert.length > 0) {
-            const result = await this.insertRows(dataStoreId, rowsToInsert, columns, returnData);
-            if (returnData) {
-                output.push.apply(output, result);
-            }
-        }
-        if (rowsToUpdate.length > 0) {
-            for (const row of rowsToUpdate) {
-                const updateKeys = Object.keys(row).filter((key) => !matchFields.includes(key));
-                if (updateKeys.length === 0) {
-                    return true;
-                }
-                const setData = Object.fromEntries(updateKeys.map((key) => [key, row[key]]));
-                const whereData = Object.fromEntries(matchFields.map((key) => [key, row[key]]));
-                const result = await this.updateRow(dataStoreId, setData, whereData, columns, returnData);
-                if (returnData) {
-                    output.push.apply(output, result);
+    async deleteRows(dataTableId, columns, filter, returnData = false) {
+        const dbType = this.dataSource.options.type;
+        const useReturning = dbType === 'postgres';
+        const table = (0, sql_utils_1.toTableName)(dataTableId);
+        if (!returnData) {
+            await this.dataSource.manager.transaction(async (em) => {
+                const query = em.createQueryBuilder().delete().from(table, 'dataTable');
+                if (filter) {
+                    this.applyFilters(query, filter, undefined, columns);
                 }
-            }
-        }
-        return returnData ? output : true;
-    }
-    async deleteRows(dataStoreId, ids) {
-        if (ids.length === 0) {
+                await query.execute();
+            });
             return true;
         }
-        const table = this.toTableName(dataStoreId);
-        await this.dataSource
-            .createQueryBuilder()
-            .delete()
-            .from(table, 'dataStore')
-            .where({ id: (0, typeorm_1.In)(ids) })
-            .execute();
-        return true;
+        let affectedRows = [];
+        await this.dataSource.manager.transaction(async (em) => {
+            if (!useReturning) {
+                const selectQuery = em.createQueryBuilder().select('*').from(table, 'dataTable');
+                if (filter) {
+                    this.applyFilters(selectQuery, filter, 'dataTable', columns);
+                }
+                const rawRows = await selectQuery.getRawMany();
+                affectedRows = (0, sql_utils_1.normalizeRows)(rawRows, columns);
+            }
+            const query = em.createQueryBuilder().delete().from(table, 'dataTable');
+            if (useReturning) {
+                const escapedColumns = columns.map((c) => this.dataSource.driver.escape(c.name));
+                const escapedSystemColumns = n8n_workflow_1.DATA_TABLE_SYSTEM_COLUMNS.map((x) => this.dataSource.driver.escape(x));
+                const selectColumns = [...escapedSystemColumns, ...escapedColumns];
+                query.returning(selectColumns.join(','));
+            }
+            if (filter) {
+                this.applyFilters(query, filter, undefined, columns);
+            }
+            const result = await query.execute();
+            if (useReturning) {
+                affectedRows = (0, sql_utils_1.normalizeRows)((0, sql_utils_1.extractReturningData)(result.raw), columns);
+            }
+        });
+        return affectedRows;
     }
     async createTableWithColumns(dataStoreId, columns, queryRunner) {
         const dslColumns = [new db_1.DslColumn('id').int.autoGenerate2.primary, ...(0, sql_utils_1.toDslColumns)(columns)];
-        const createTable = new db_1.CreateTable(this.toTableName(dataStoreId), '', queryRunner).withColumns(...dslColumns).withTimestamps;
+        const createTable = new db_1.CreateTable((0, sql_utils_1.toTableName)(dataStoreId), '', queryRunner).withColumns(...dslColumns).withTimestamps;
         await createTable.execute(queryRunner);
     }
     async dropTable(dataStoreId, queryRunner) {
-        await queryRunner.dropTable(this.toTableName(dataStoreId), true);
+        await queryRunner.dropTable((0, sql_utils_1.toTableName)(dataStoreId), true);
     }
     async addColumn(dataStoreId, column, queryRunner, dbType) {
-        await queryRunner.query((0, sql_utils_1.addColumnQuery)(this.toTableName(dataStoreId), column, dbType));
+        await queryRunner.query((0, sql_utils_1.addColumnQuery)((0, sql_utils_1.toTableName)(dataStoreId), column, dbType));
     }
     async dropColumnFromTable(dataStoreId, columnName, queryRunner, dbType) {
-        await queryRunner.query((0, sql_utils_1.deleteColumnQuery)(this.toTableName(dataStoreId), columnName, dbType));
+        await queryRunner.query((0, sql_utils_1.deleteColumnQuery)((0, sql_utils_1.toTableName)(dataStoreId), columnName, dbType));
     }
-    async getManyAndCount(dataStoreId, dto, columns) {
-        const [countQuery, query] = this.getManyQuery(dataStoreId, dto, columns);
+    async getManyAndCount(dataStoreId, dto, columns, em) {
+        em = em ?? this.dataSource.manager;
+        const [countQuery, query] = this.getManyQuery(dataStoreId, dto, em, columns);
         const data = await query.select('*').getRawMany();
         const countResult = await countQuery.select('COUNT(*) as count').getRawOne();
         const count = typeof countResult?.count === 'number' ? countResult.count : Number(countResult?.count) || 0;
         return { count: count ?? -1, data };
     }
-    async getManyByIds(dataStoreId, ids, columns) {
-        const table = this.toTableName(dataStoreId);
+    async getManyByIds(dataStoreId, ids, columns, em) {
+        const table = (0, sql_utils_1.toTableName)(dataStoreId);
         const escapedColumns = columns.map((c) => this.dataSource.driver.escape(c.name));
         const escapedSystemColumns = n8n_workflow_1.DATA_TABLE_SYSTEM_COLUMNS.map((x) => this.dataSource.driver.escape(x));
         const selectColumns = [...escapedSystemColumns, ...escapedColumns];
         if (ids.length === 0) {
             return [];
         }
-        const updatedRows = await this.dataSource
+        const updatedRows = await em
             .createQueryBuilder()
             .select(selectColumns)
-            .from(table, 'dataStore')
+            .from(table, 'dataTable')
             .where({ id: (0, typeorm_1.In)(ids) })
             .getRawMany();
         return (0, sql_utils_1.normalizeRows)(updatedRows, columns);
     }
-    async getRowIds(dataStoreId, dto) {
-        const [_, query] = this.getManyQuery(dataStoreId, dto);
-        const result = await query.select('dataStore.id').getRawMany();
-        return result;
-    }
-    getManyQuery(dataStoreId, dto, columns) {
-        const query = this.dataSource.createQueryBuilder();
-        query.from(this.toTableName(dataStoreId), 'dataStore');
-        this.applyFilters(query, dto, columns);
+    getManyQuery(dataStoreId, dto, em, columns) {
+        const query = em.createQueryBuilder();
+        const tableReference = 'dataTable';
+        query.from((0, sql_utils_1.toTableName)(dataStoreId), tableReference);
+        if (dto.filter) {
+            this.applyFilters(query, dto.filter, tableReference, columns);
+        }
         const countQuery = query.clone().select('COUNT(*)');
         this.applySorting(query, dto);
         this.applyPagination(query, dto);
         return [countQuery, query];
     }
-    applyFilters(query, dto, columns) {
-        const filters = dto.filter?.filters ?? [];
-        const filterType = dto.filter?.type ?? 'and';
+    applyFilters(query, filter, tableReference, columns) {
+        const filters = filter.filters ?? [];
+        const filterType = filter.type ?? 'and';
         const dbType = this.dataSource.options.type;
-        const conditionsAndParams = filters.map((filter, i) => getConditionAndParams(filter, i, dbType, columns));
-        for (const [condition, params] of conditionsAndParams) {
-            if (filterType === 'or') {
-                query.orWhere(condition, params);
-            }
-            else {
-                query.andWhere(condition, params);
+        const conditionsAndParams = filters.map((filter, i) => getConditionAndParams(filter, i, dbType, tableReference, columns));
+        if (conditionsAndParams.length === 1) {
+            const [condition, params] = conditionsAndParams[0];
+            query.andWhere(condition, params);
+        }
+        else {
+            for (const [condition, params] of conditionsAndParams) {
+                if (filterType === 'or') {
+                    query.orWhere(condition, params);
+                }
+                else {
+                    query.andWhere(condition, params);
+                }
             }
         }
     }
@@ -280,35 +316,18 @@ let DataStoreRowsRepository = class DataStoreRowsRepository {
     }
     applySortingByField(query, field, direction) {
         const dbType = this.dataSource.options.type;
-        const quotedField = `${(0, sql_utils_1.quoteIdentifier)('dataStore', dbType)}.${(0, sql_utils_1.quoteIdentifier)(field, dbType)}`;
+        const quotedField = `${(0, sql_utils_1.quoteIdentifier)('dataTable', dbType)}.${(0, sql_utils_1.quoteIdentifier)(field, dbType)}`;
         query.orderBy(quotedField, direction);
     }
     applyPagination(query, dto) {
-        query.skip(dto.skip);
-        query.take(dto.take);
-    }
-    async fetchAndSplitRowsByExistence(dataStoreId, matchFields, rows) {
-        const queryBuilder = this.dataSource
-            .createQueryBuilder()
-            .select(matchFields)
-            .from(this.toTableName(dataStoreId), 'datastore');
-        rows.forEach((row, index) => {
-            const matchData = Object.fromEntries(matchFields.map((field) => [field, row[field]]));
-            if (index === 0) {
-                queryBuilder.where(matchData);
-            }
-            else {
-                queryBuilder.orWhere(matchData);
-            }
-        });
-        const existing = await queryBuilder.getRawMany();
-        return (0, sql_utils_1.splitRowsByExistence)(existing, matchFields, rows);
+        query.skip(dto.skip ?? 0);
+        if (dto.take)
+            query.take(dto.take);
     }
 };
 exports.DataStoreRowsRepository = DataStoreRowsRepository;
 exports.DataStoreRowsRepository = DataStoreRowsRepository = __decorate([
     (0, di_1.Service)(),
-    __metadata("design:paramtypes", [typeorm_1.DataSource,
-        config_1.GlobalConfig])
+    __metadata("design:paramtypes", [typeorm_1.DataSource])
 ], DataStoreRowsRepository);
 //# sourceMappingURL=data-store-rows.repository.js.map