@ruiapp/rapid-core 0.3.1 → 0.4.0

package/dist/plugins/dataManage/actionHandlers/deleteCollectionEntities.d.ts

@@ -3,6 +3,7 @@ import { ActionHandlerContext } from "../../../core/actionHandler";
 import { RapidPlugin } from "../../../core/server";
 export interface DeleteCollectionEntitiesInput {
     filters: FindEntityOptions["filters"];
+    noTransaction?: boolean;
 }
 export declare const code = "deleteCollectionEntities";
 export declare function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, options: RunEntityActionHandlerOptions): Promise<void>;

package/dist/plugins/sequence/SequenceService.d.ts

@@ -1,5 +1,6 @@
 import { IRpdServer } from "../../core/server";
 import { SequenceSegmentConfig } from "./SequencePluginTypes";
+import { RouteContext } from "../../core/routeContext";
 export interface GenerateSequenceNumbersInput {
     ruleCode: string;
     parameters: Record<string, string>;
@@ -10,10 +11,10 @@ export interface GenerateSequenceNumbersOutput {
 }
 export interface SegmentResolver {
     segmentType: string;
-    resolveSegmentValue(server: IRpdServer, ruleCode: string, config: SequenceSegmentConfig, input: GenerateSequenceNumbersInput): Promise<string>;
+    resolveSegmentValue(routeContext: RouteContext, server: IRpdServer, ruleCode: string, config: SequenceSegmentConfig, input: GenerateSequenceNumbersInput): Promise<string>;
 }
 export default class SequenceService {
     #private;
     constructor(server: IRpdServer);
-    generateSn(server: IRpdServer, input: GenerateSequenceNumbersInput): Promise<string[]>;
+    generateSn(routeContext: RouteContext | null, server: IRpdServer, input: GenerateSequenceNumbersInput): Promise<string[]>;
 }

package/dist/plugins/sequence/segments/autoIncrement.d.ts

@@ -1,5 +1,6 @@
 import { GenerateSequenceNumbersInput } from "../SequenceService";
 import { IRpdServer } from "../../../core/server";
 import { SequenceAutoIncrementSegmentConfig } from "../SequencePluginTypes";
+import { RouteContext } from "../../../core/routeContext";
 export declare const segmentType = "autoIncrement";
-export declare function resolveSegmentValue(server: IRpdServer, ruleCode: string, config: SequenceAutoIncrementSegmentConfig, input: GenerateSequenceNumbersInput): Promise<string>;
+export declare function resolveSegmentValue(routeContext: RouteContext, server: IRpdServer, ruleCode: string, config: SequenceAutoIncrementSegmentConfig, input: GenerateSequenceNumbersInput): Promise<string>;

package/dist/plugins/sequence/segments/dayOfMonth.d.ts

@@ -1,5 +1,6 @@
+import { RouteContext } from "../../../core/routeContext";
 import { SequenceDayOfMonthSegmentConfig } from "../SequencePluginTypes";
 import { GenerateSequenceNumbersInput } from "../SequenceService";
 import { IRpdServer } from "../../../core/server";
 export declare const segmentType = "dayOfMonth";
-export declare function resolveSegmentValue(server: IRpdServer, ruleCode: string, config: SequenceDayOfMonthSegmentConfig, input: GenerateSequenceNumbersInput): Promise<string>;
+export declare function resolveSegmentValue(routeContext: RouteContext, server: IRpdServer, ruleCode: string, config: SequenceDayOfMonthSegmentConfig, input: GenerateSequenceNumbersInput): Promise<string>;

package/dist/plugins/sequence/segments/literal.d.ts

@@ -1,5 +1,6 @@
+import { RouteContext } from "../../../core/routeContext";
 import { SequenceLiteralSegmentConfig } from "../SequencePluginTypes";
 import { GenerateSequenceNumbersInput } from "../SequenceService";
 import { IRpdServer } from "../../../core/server";
 export declare const segmentType = "literal";
-export declare function resolveSegmentValue(server: IRpdServer, ruleCode: string, config: SequenceLiteralSegmentConfig, input: GenerateSequenceNumbersInput): Promise<string>;
+export declare function resolveSegmentValue(routeContext: RouteContext, server: IRpdServer, ruleCode: string, config: SequenceLiteralSegmentConfig, input: GenerateSequenceNumbersInput): Promise<string>;

package/dist/plugins/sequence/segments/month.d.ts

@@ -1,5 +1,6 @@
+import { RouteContext } from "../../../core/routeContext";
 import { SequenceMonthSegmentConfig } from "../SequencePluginTypes";
 import { GenerateSequenceNumbersInput } from "../SequenceService";
 import { IRpdServer } from "../../../core/server";
 export declare const segmentType = "month";
-export declare function resolveSegmentValue(server: IRpdServer, ruleCode: string, config: SequenceMonthSegmentConfig, input: GenerateSequenceNumbersInput): Promise<string>;
+export declare function resolveSegmentValue(routeContext: RouteContext, server: IRpdServer, ruleCode: string, config: SequenceMonthSegmentConfig, input: GenerateSequenceNumbersInput): Promise<string>;

package/dist/plugins/sequence/segments/parameter.d.ts

@@ -1,5 +1,6 @@
+import { RouteContext } from "../../../core/routeContext";
 import { SequenceParameterSegmentConfig } from "../SequencePluginTypes";
 import { GenerateSequenceNumbersInput } from "../SequenceService";
 import { IRpdServer } from "../../../core/server";
 export declare const segmentType = "parameter";
-export declare function resolveSegmentValue(server: IRpdServer, ruleCode: string, config: SequenceParameterSegmentConfig, input: GenerateSequenceNumbersInput): Promise<string>;
+export declare function resolveSegmentValue(routeContext: RouteContext, server: IRpdServer, ruleCode: string, config: SequenceParameterSegmentConfig, input: GenerateSequenceNumbersInput): Promise<string>;

package/dist/plugins/sequence/segments/year.d.ts

@@ -1,5 +1,6 @@
+import { RouteContext } from "../../../core/routeContext";
 import { SequenceYearSegmentConfig } from "../SequencePluginTypes";
 import { GenerateSequenceNumbersInput } from "../SequenceService";
 import { IRpdServer } from "../../../core/server";
 export declare const segmentType = "year";
-export declare function resolveSegmentValue(server: IRpdServer, ruleCode: string, config: SequenceYearSegmentConfig, input: GenerateSequenceNumbersInput): Promise<string>;
+export declare function resolveSegmentValue(routeContext: RouteContext, server: IRpdServer, ruleCode: string, config: SequenceYearSegmentConfig, input: GenerateSequenceNumbersInput): Promise<string>;

package/dist/server.d.ts

@@ -23,6 +23,7 @@ export declare class RapidServer implements IRpdServer {
     constructor(options: InitServerOptions);
     getLogger(): Logger;
     getApplicationConfig(): RpdApplicationConfig;
+    getDatabaseAccessor(): IDatabaseAccessor;
     appendApplicationConfig(config: Partial<RpdApplicationConfig>): void;
     appendModelProperties(modelSingularCode: string, properties: RpdDataModelProperty[]): void;
     registerActionHandler(plugin: RapidPlugin, options: IPluginActionHandler): void;

package/dist/types.d.ts

@@ -20,8 +20,13 @@ export type DatabaseQuery = {
     command: string;
     params?: unknown[] | Record<string, unknown>;
 };
+export interface IDatabaseClient {
+    release(): any;
+    query(sql: any, params?: any): Promise<any>;
+}
 export interface IDatabaseAccessor {
-    queryDatabaseObject: (sql: string, params?: unknown[] | Record<string, unknown>) => Promise<any[]>;
+    getClient(): Promise<IDatabaseClient>;
+    queryDatabaseObject: (sql: string, params?: unknown[] | Record<string, unknown>, client?: IDatabaseClient) => Promise<any[]>;
 }
 export interface RunEntityActionHandlerOptions {
     /** 模型所在的命名空间 */
@@ -380,13 +385,13 @@ export interface RpdRouteActionConfig {
 }
 export interface IRpdDataAccessor<T = any> {
     getModel(): RpdDataModel;
-    create(entity: any): Promise<any>;
-    updateById(id: any, entity: any): Promise<any>;
-    find(options: FindRowOptions): Promise<T[]>;
-    findOne(options: FindRowOptions): Promise<T | null>;
-    findById(id: any): Promise<T | null>;
-    count(options: CountRowOptions): Promise<number>;
-    deleteById(id: any): Promise<void>;
+    create(entity: any, databaseClient: IDatabaseClient | null): Promise<any>;
+    updateById(id: any, entity: any, databaseClient: IDatabaseClient | null): Promise<any>;
+    find(options: FindRowOptions, databaseClient: IDatabaseClient | null): Promise<T[]>;
+    findOne(options: FindRowOptions, databaseClient: IDatabaseClient | null): Promise<T | null>;
+    findById(id: any, databaseClient: IDatabaseClient | null): Promise<T | null>;
+    count(options: CountRowOptions, databaseClient: IDatabaseClient | null): Promise<number>;
+    deleteById(id: any, databaseClient: IDatabaseClient | null): Promise<void>;
 }
 export type EntityFilterRelationalOperators = "eq" | "ne" | "lt" | "lte" | "gt" | "gte" | "contains" | "notContains" | "containsCS" | "notContainsCS" | "startsWith" | "notStartsWith" | "endsWith" | "notEndsWith";
 export type EntityFilterArrayOperators = "arrayContains" | "arrayOverlap";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ruiapp/rapid-core",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/core/routeContext.ts

@@ -4,23 +4,32 @@ import { RapidResponse } from "./response";
 import { HttpStatus, ResponseData } from "./http-types";
 import { IRpdServer } from "./server";
 import { Logger } from "~/facilities/log/LogFacility";
+import { IDatabaseAccessor, IDatabaseClient } from "~/types";
 
 export type Next = () => Promise<void>;
 
+// TODO: should divide to RequestContext and OperationContext
+
 export class RouteContext {
   readonly request: RapidRequest;
   readonly response: RapidResponse;
   readonly state: Record<string, any>;
+  readonly databaseAccessor: IDatabaseAccessor;
   method: string;
   path: string;
   params: Record<string, string>;
   routeConfig: any;
+  #server: IRpdServer;
+  #dbTransactionClient: IDatabaseClient | null;
 
   static newSystemOperationContext(server: IRpdServer) {
     return new RouteContext(server);
   }
 
   constructor(server: IRpdServer, request?: RapidRequest) {
+    this.#server = server;
+    this.#dbTransactionClient = null;
+    this.databaseAccessor = server.getDatabaseAccessor();
     this.request = request;
     this.state = {};
     this.response = new RapidResponse();
@@ -32,6 +41,20 @@ export class RouteContext {
     }
   }
 
+  clone(): RouteContext {
+    const clonedContext = new RouteContext(this.#server);
+    clonedContext.method = this.method;
+    clonedContext.path = this.path;
+    clonedContext.params = this.params;
+    clonedContext.setState(this.state);
+
+    return clonedContext;
+  }
+
+  setState(state: Record<string, any>) {
+    Object.assign(this.state, state);
+  }
+
   // `koa-tree-router` uses this method to set headers
   set(headerName: string, headerValue: string) {
     this.response.headers.set(headerName, headerValue);
@@ -44,4 +67,34 @@ export class RouteContext {
   redirect(url: string, status?: HttpStatus) {
     this.response.redirect(url, status);
   }
+
+  getDbTransactionClient(): IDatabaseClient | null {
+    return this.#dbTransactionClient;
+  }
+
+  async beginDbTransaction(): Promise<IDatabaseClient> {
+    let dbClient = this.#dbTransactionClient;
+    if (dbClient) {
+      throw new Error("Database transaction has been started. You can not start a transaction more than once in a request context.");
+    }
+
+    dbClient = await this.databaseAccessor.getClient();
+    await this.databaseAccessor.queryDatabaseObject("BEGIN", [], dbClient);
+    this.#dbTransactionClient = dbClient;
+    return dbClient;
+  }
+
+  async commitDbTransaction(): Promise<void> {
+    if (!this.#dbTransactionClient) {
+      throw new Error("Database transaction has not been started. You should call beginDbTransaction() first.");
+    }
+    await this.databaseAccessor.queryDatabaseObject("COMMIT", [], this.#dbTransactionClient);
+  }
+
+  async rollbackDbTransaction(): Promise<void> {
+    if (!this.#dbTransactionClient) {
+      throw new Error("Database transaction has not been started. You should call beginDbTransaction() first.");
+    }
+    await this.databaseAccessor.queryDatabaseObject("ROLLBACK", [], this.#dbTransactionClient);
+  }
 }

package/src/core/server.ts

@@ -4,6 +4,7 @@ import {
   EntityWatcherType,
   GetDataAccessorOptions,
   GetModelOptions,
+  IDatabaseAccessor,
   IDatabaseConfig,
   IQueryBuilder,
   IRpdDataAccessor,
@@ -30,6 +31,7 @@ export interface IRpdServer {
 
   getFacility<TFacility = any>(name: string, options?: any): Promise<TFacility>;
 
+  getDatabaseAccessor(): IDatabaseAccessor;
   queryDatabaseObject: (sql: string, params?: unknown[] | Record<string, unknown>) => Promise<any[]>;
   tryQueryDatabaseObject: (sql: string, params?: unknown[] | Record<string, unknown>) => Promise<any[]>;
   registerMiddleware(middleware: any): void;

package/src/dataAccess/dataAccessor.ts

@@ -1,4 +1,4 @@
-import { CreateEntityOptions, IRpdDataAccessor, RpdDataModel, IDatabaseAccessor, DatabaseQuery } from "~/types";
+import { CreateEntityOptions, IRpdDataAccessor, RpdDataModel, IDatabaseAccessor, DatabaseQuery, IDatabaseClient } from "~/types";
 import QueryBuilder from "~/queryBuilder/queryBuilder";
 import { first, set } from "lodash";
 import { IRpdServer } from "~/core/server";
@@ -30,16 +30,16 @@ export default class DataAccessor<T = any> implements IRpdDataAccessor<T> {
     return this.#model;
   }
 
-  async create(entity: Partial<T>): Promise<T> {
+  async create(entity: Partial<T>, databaseClient: IDatabaseClient | null): Promise<T> {
     const options: CreateEntityOptions = {
       entity,
     };
     const query = this.#queryBuilder.insert(this.#model, options);
-    const result = await this.#databaseAccessor.queryDatabaseObject(query.command, query.params);
+    const result = await this.#databaseAccessor.queryDatabaseObject(query.command, query.params, databaseClient);
     return first(result);
   }
 
-  async updateById(id: any, entity: Partial<T>): Promise<{ count: number }> {
+  async updateById(id: any, entity: Partial<T>, databaseClient: IDatabaseClient | null): Promise<{ count: number }> {
     const options: UpdateRowOptions = {
       entity,
       filters: [
@@ -53,11 +53,11 @@ export default class DataAccessor<T = any> implements IRpdDataAccessor<T> {
       ],
     };
     const query = this.#queryBuilder.update(this.#model, options);
-    const result = await this.#databaseAccessor.queryDatabaseObject(query.command, query.params);
+    const result = await this.#databaseAccessor.queryDatabaseObject(query.command, query.params, databaseClient);
     return first(result);
   }
 
-  async find(options: FindRowOptions): Promise<T[]> {
+  async find(options: FindRowOptions, databaseClient: IDatabaseClient | null): Promise<T[]> {
     this.#logger.debug(`Finding '${this.#model.singularCode}' entity.`, { options });
     let query: DatabaseQuery;
     if (this.#model.base) {
@@ -70,19 +70,19 @@ export default class DataAccessor<T = any> implements IRpdDataAccessor<T> {
     }
 
     try {
-      return await this.#databaseAccessor.queryDatabaseObject(query.command, query.params);
+      return await this.#databaseAccessor.queryDatabaseObject(query.command, query.params, databaseClient);
     } catch (err) {
       throw newDatabaseError(`Failed to find entities. ${err.message}`, err);
     }
   }
 
-  async findOne(options: FindRowOptions): Promise<T> {
+  async findOne(options: FindRowOptions, databaseClient: IDatabaseClient | null): Promise<T> {
     set(options, "pagination.limit", 1);
-    const list = await this.find(options);
+    const list = await this.find(options, databaseClient);
     return first(list);
   }
 
-  async findById(id: any): Promise<T | null> {
+  async findById(id: any, databaseClient: IDatabaseClient | null): Promise<T | null> {
     const options: FindRowOptions = {
       filters: [
         {
@@ -94,11 +94,11 @@ export default class DataAccessor<T = any> implements IRpdDataAccessor<T> {
         },
       ],
     };
-    const result = await this.findOne(options);
+    const result = await this.findOne(options, databaseClient);
     return result;
   }
 
-  async count(options: CountRowOptions): Promise<number> {
+  async count(options: CountRowOptions, databaseClient: IDatabaseClient | null): Promise<number> {
     let query: DatabaseQuery;
     if (this.#model.base) {
       const baseModel = this.#server.getModel({
@@ -108,7 +108,7 @@ export default class DataAccessor<T = any> implements IRpdDataAccessor<T> {
     } else {
       query = this.#queryBuilder.count(this.#model, options);
     }
-    const result = await this.#databaseAccessor.queryDatabaseObject(query.command, query.params);
+    const result = await this.#databaseAccessor.queryDatabaseObject(query.command, query.params, databaseClient);
 
     const row = first(result);
     if (row) {
@@ -117,7 +117,7 @@ export default class DataAccessor<T = any> implements IRpdDataAccessor<T> {
     return 0;
   }
 
-  async deleteById(id: any) {
+  async deleteById(id: any, databaseClient: IDatabaseClient | null) {
     const options: FindRowOptions = {
       filters: [
         {
@@ -130,6 +130,6 @@ export default class DataAccessor<T = any> implements IRpdDataAccessor<T> {
       ],
     };
     const query = this.#queryBuilder.delete(this.#model, options);
-    await this.#databaseAccessor.queryDatabaseObject(query.command, query.params);
+    await this.#databaseAccessor.queryDatabaseObject(query.command, query.params, databaseClient);
   }
 }

package/src/dataAccess/entityManager.ts

@@ -143,6 +143,7 @@ function convertEntityOrderByToRowOrderBy(server: IRpdServer, model: RpdDataMode
 }
 
 async function findEntities(server: IRpdServer, dataAccessor: IRpdDataAccessor, options: FindEntityOptions) {
+  const routeContext = options.routeContext;
   const model = dataAccessor.getModel();
   let baseModel: RpdDataModel | undefined;
   if (model.base) {
@@ -242,14 +243,14 @@ async function findEntities(server: IRpdServer, dataAccessor: IRpdDataAccessor,
     });
   }
 
-  const rowFilters = await convertEntityFiltersToRowFilters(server, model, baseModel, options.filters);
+  const rowFilters = await convertEntityFiltersToRowFilters(routeContext, server, model, baseModel, options.filters);
   const findRowOptions: FindRowOptions = {
     filters: rowFilters,
     orderBy: convertEntityOrderByToRowOrderBy(server, model, baseModel, options.orderBy),
     pagination: options.pagination,
     fields: columnsToSelect,
   };
-  const rows = await dataAccessor.find(findRowOptions);
+  const rows = await dataAccessor.find(findRowOptions, routeContext?.getDbTransactionClient());
   if (!rows.length) {
     return [];
   }
@@ -374,6 +375,7 @@ async function findById(server: IRpdServer, dataAccessor: IRpdDataAccessor, opti
 }
 
 async function convertEntityFiltersToRowFilters(
+  routeContext: RouteContext,
   server: IRpdServer,
   model: RpdDataModel,
   baseModel: RpdDataModel,
@@ -389,7 +391,7 @@ async function convertEntityFiltersToRowFilters(
     if (operator === "and" || operator === "or") {
       replacedFilters.push({
         operator: operator,
-        filters: await convertEntityFiltersToRowFilters(server, model, baseModel, filter.filters),
+        filters: await convertEntityFiltersToRowFilters(routeContext, server, model, baseModel, filter.filters),
       });
     } else if (operator === "exists" || operator === "notExists") {
       const relationProperty: RpdDataModelProperty = getEntityPropertyByCode(server, model, filter.field);
@@ -444,15 +446,18 @@ async function convertEntityFiltersToRowFilters(
             singularCode: relatedModel.base,
           });
         }
-        const rows = await dataAccessor.find({
-          filters: await convertEntityFiltersToRowFilters(server, relatedModel, relatedBaseModel, filter.filters),
-          fields: [
-            {
-              name: "id",
-              tableName: relatedModel.tableName,
-            },
-          ],
-        });
+        const rows = await dataAccessor.find(
+          {
+            filters: await convertEntityFiltersToRowFilters(routeContext, server, relatedModel, relatedBaseModel, filter.filters),
+            fields: [
+              {
+                name: "id",
+                tableName: relatedModel.tableName,
+              },
+            ],
+          },
+          routeContext?.getDbTransactionClient(),
+        );
         const entityIds = map(rows, (entity: any) => entity["id"]);
         replacedFilters.push({
           field: {
@@ -478,15 +483,18 @@ async function convertEntityFiltersToRowFilters(
             singularCode: relatedModel.base,
           });
         }
-        const targetEntities = await targetEntityDataAccessor.find({
-          filters: await convertEntityFiltersToRowFilters(server, relatedModel, relatedBaseModel, filter.filters),
-          fields: [
-            {
-              name: relationProperty.selfIdColumnName,
-              tableName: relatedModel.tableName,
-            },
-          ],
-        });
+        const targetEntities = await targetEntityDataAccessor.find(
+          {
+            filters: await convertEntityFiltersToRowFilters(routeContext, server, relatedModel, relatedBaseModel, filter.filters),
+            fields: [
+              {
+                name: relationProperty.selfIdColumnName,
+                tableName: relatedModel.tableName,
+              },
+            ],
+          },
+          routeContext?.getDbTransactionClient(),
+        );
         const selfEntityIds = map(targetEntities, (entity: any) => entity[relationProperty.selfIdColumnName!]);
         replacedFilters.push({
           field: {
@@ -519,15 +527,18 @@ async function convertEntityFiltersToRowFilters(
             singularCode: relatedModel.base,
           });
         }
-        const targetEntities = await targetEntityDataAccessor.find({
-          filters: await convertEntityFiltersToRowFilters(server, relatedModel, relatedBaseModel, filter.filters),
-          fields: [
-            {
-              name: "id",
-              tableName: relatedModel.tableName,
-            },
-          ],
-        });
+        const targetEntities = await targetEntityDataAccessor.find(
+          {
+            filters: await convertEntityFiltersToRowFilters(routeContext, server, relatedModel, relatedBaseModel, filter.filters),
+            fields: [
+              {
+                name: "id",
+                tableName: relatedModel.tableName,
+              },
+            ],
+          },
+          routeContext?.getDbTransactionClient(),
+        );
         const targetEntityIds = map(targetEntities, (entity: any) => entity["id"]);
 
         const command = `SELECT * FROM ${server.queryBuilder.quoteTable({
@@ -880,7 +891,7 @@ async function createEntity(server: IRpdServer, dataAccessor: IRpdDataAccessor,
 
     row.id = newBaseRow.id;
   }
-  const newRow = await dataAccessor.create(row);
+  const newRow = await dataAccessor.create(row, routeContext?.getDbTransactionClient());
   const newEntity = mapDbRowToEntity(server, model, Object.assign({}, newBaseRow, newRow, newEntityOneRelationProps), true);
 
   // save one-relation properties that has selfIdColumnName
@@ -908,7 +919,7 @@ async function createEntity(server: IRpdServer, dataAccessor: IRpdDataAccessor,
           const relationFieldChanges = {
             [property.targetIdColumnName]: newTargetEntity.id,
           };
-          await dataAccessorOfMainEntity.updateById(newEntity.id, relationFieldChanges);
+          await dataAccessorOfMainEntity.updateById(newEntity.id, relationFieldChanges, routeContext?.getDbTransactionClient());
           newEntity[property.code] = newTargetEntity;
         }
       }
@@ -955,7 +966,7 @@ async function createEntity(server: IRpdServer, dataAccessor: IRpdDataAccessor,
           newEntity[property.code].push(newTargetEntity);
         } else {
           // related entity is existed
-          const targetEntity = await targetDataAccessor.findById(relatedEntityId);
+          const targetEntity = await targetDataAccessor.findById(relatedEntityId, routeContext?.getDbTransactionClient());
           if (!targetEntity) {
             throw new Error(`Entity with id '${relatedEntityId}' in field '${property.code}' is not exists.`);
           }
@@ -968,7 +979,7 @@ async function createEntity(server: IRpdServer, dataAccessor: IRpdDataAccessor,
             const params = [newEntity.id, relatedEntityId];
             await server.queryDatabaseObject(command, params);
           } else {
-            await targetDataAccessor.updateById(targetEntity.id, { [property.selfIdColumnName!]: newEntity.id });
+            await targetDataAccessor.updateById(targetEntity.id, { [property.selfIdColumnName!]: newEntity.id }, routeContext?.getDbTransactionClient());
             targetEntity[property.selfIdColumnName!] = newEntity.id;
           }
           newEntity[property.code].push(targetEntity);
@@ -976,7 +987,7 @@ async function createEntity(server: IRpdServer, dataAccessor: IRpdDataAccessor,
       } else {
         // fieldValue is id
         relatedEntityId = relatedEntityToBeSaved;
-        const targetEntity = await targetDataAccessor.findById(relatedEntityId);
+        const targetEntity = await targetDataAccessor.findById(relatedEntityId, routeContext?.getDbTransactionClient());
         if (!targetEntity) {
           throw new Error(`Entity with id '${relatedEntityId}' in field '${property.code}' is not exists.`);
         }
@@ -989,7 +1000,7 @@ async function createEntity(server: IRpdServer, dataAccessor: IRpdDataAccessor,
           const params = [newEntity.id, relatedEntityId];
           await server.queryDatabaseObject(command, params);
         } else {
-          await targetDataAccessor.updateById(targetEntity.id, { [property.selfIdColumnName!]: newEntity.id });
+          await targetDataAccessor.updateById(targetEntity.id, { [property.selfIdColumnName!]: newEntity.id }, routeContext?.getDbTransactionClient());
           targetEntity[property.selfIdColumnName!] = newEntity.id;
         }
 
@@ -1205,7 +1216,7 @@ async function updateEntityById(server: IRpdServer, dataAccessor: IRpdDataAccess
 
   let updatedRow = row;
   if (Object.keys(row).length) {
-    updatedRow = await dataAccessor.updateById(id, row);
+    updatedRow = await dataAccessor.updateById(id, row, routeContext?.getDbTransactionClient());
   }
   let updatedBaseRow = baseRow;
   let baseDataAccessor: any;
@@ -1246,7 +1257,7 @@ async function updateEntityById(server: IRpdServer, dataAccessor: IRpdDataAccess
           const relationFieldChanges = {
             [property.targetIdColumnName]: newTargetEntity.id,
           };
-          await dataAccessorOfMainEntity.updateById(updatedEntity.id, relationFieldChanges);
+          await dataAccessorOfMainEntity.updateById(updatedEntity.id, relationFieldChanges, routeContext?.getDbTransactionClient());
           updatedEntity[property.code] = newTargetEntity;
           changes[property.code] = newTargetEntity;
         }
@@ -1339,7 +1350,7 @@ async function updateEntityById(server: IRpdServer, dataAccessor: IRpdDataAccess
           relatedEntities.push(newTargetEntity);
         } else {
           // related entity is existed
-          let targetEntity = await targetDataAccessor.findById(relatedEntityId);
+          let targetEntity = await targetDataAccessor.findById(relatedEntityId, routeContext?.getDbTransactionClient());
           if (!targetEntity) {
             throw new Error(`Entity with id '${relatedEntityId}' in field '${property.code}' does not exist.`);
           }
@@ -1377,7 +1388,7 @@ async function updateEntityById(server: IRpdServer, dataAccessor: IRpdDataAccess
               const params = [id, relatedEntityId];
               await server.queryDatabaseObject(command, params);
             } else {
-              await targetDataAccessor.updateById(targetEntity.id, { [property.selfIdColumnName!]: id });
+              await targetDataAccessor.updateById(targetEntity.id, { [property.selfIdColumnName!]: id }, routeContext?.getDbTransactionClient());
               targetEntity[property.selfIdColumnName!] = id;
             }
           }
@@ -1386,7 +1397,7 @@ async function updateEntityById(server: IRpdServer, dataAccessor: IRpdDataAccess
       } else {
         // fieldValue is id
         relatedEntityId = relatedEntityToBeSaved;
-        const targetEntity = await targetDataAccessor.findById(relatedEntityId);
+        const targetEntity = await targetDataAccessor.findById(relatedEntityId, routeContext?.getDbTransactionClient());
         if (!targetEntity) {
           throw new Error(`Entity with id '${relatedEntityId}' in field '${property.code}' is not exists.`);
         }
@@ -1400,7 +1411,7 @@ async function updateEntityById(server: IRpdServer, dataAccessor: IRpdDataAccess
             const params = [id, relatedEntityId];
             await server.queryDatabaseObject(command, params);
           } else {
-            await targetDataAccessor.updateById(targetEntity.id, { [property.selfIdColumnName!]: id });
+            await targetDataAccessor.updateById(targetEntity.id, { [property.selfIdColumnName!]: id }, routeContext?.getDbTransactionClient());
             targetEntity[property.selfIdColumnName!] = id;
           }
         }
@@ -1537,6 +1548,7 @@ export default class EntityManager<TEntity = any> {
   }
 
   async count(options: CountEntityOptions): Promise<number> {
+    const routeContext = options.routeContext;
     const model = this.#dataAccessor.getModel();
     let baseModel: RpdDataModel;
     if (model.base) {
@@ -1545,9 +1557,9 @@ export default class EntityManager<TEntity = any> {
       });
     }
     const countRowOptions: CountRowOptions = {
-      filters: await convertEntityFiltersToRowFilters(this.#server, model, baseModel, options.filters),
+      filters: await convertEntityFiltersToRowFilters(routeContext, this.#server, model, baseModel, options.filters),
     };
-    return await this.#dataAccessor.count(countRowOptions);
+    return await this.#dataAccessor.count(countRowOptions, routeContext?.getDbTransactionClient());
   }
 
   async deleteById(options: DeleteEntityByIdOptions | string | number, plugin?: RapidPlugin): Promise<void> {
@@ -1593,17 +1605,21 @@ export default class EntityManager<TEntity = any> {
           })
         : this.#dataAccessor;
       const currentUserId = routeContext?.state?.userId;
-      await dataAccessor.updateById(id, {
-        deleted_at: getNowStringWithTimezone(),
-        deleter_id: currentUserId,
-      });
+      await dataAccessor.updateById(
+        id,
+        {
+          deleted_at: getNowStringWithTimezone(),
+          deleter_id: currentUserId,
+        },
+        routeContext?.getDbTransactionClient(),
+      );
     } else {
-      await this.#dataAccessor.deleteById(id);
+      await this.#dataAccessor.deleteById(id, routeContext?.getDbTransactionClient());
       if (model.base) {
         const baseDataAccessor = this.#server.getDataAccessor({
           singularCode: model.base,
         });
-        await baseDataAccessor.deleteById(id);
+        await baseDataAccessor.deleteById(id, routeContext?.getDbTransactionClient());
       }
     }