@ruiapp/rapid-core 0.1.53 → 0.1.55

package/dist/types.d.ts

@@ -1,3 +1,4 @@
+import { RouteContext } from "./core/routeContext";
 import { IRpdServer, RapidPlugin } from "./core/server";
 import { CountRowOptions, FindRowOptions } from "./dataAccess/dataAccessTypes";
 export type RapidServerConfig = {
@@ -55,15 +56,15 @@ export interface GetModelOptions {
     singularCode: string;
 }
 export type RpdServerEventTypes = {
-    "entity.beforeCreate": [RapidPlugin, RpdEntityBeforeCreateEventPayload];
-    "entity.create": [RapidPlugin, RpdEntityCreateEventPayload];
-    "entity.beforeUpdate": [RapidPlugin, RpdEntityBeforeUpdateEventPayload];
-    "entity.update": [RapidPlugin, RpdEntityUpdateEventPayload];
-    "entity.beforeDelete": [RapidPlugin, RpdEntityBeforeDeleteEventPayload];
-    "entity.delete": [RapidPlugin, RpdEntityDeleteEventPayload];
-    "entity.addRelations": [RapidPlugin, RpdEntityAddRelationsEventPayload];
-    "entity.removeRelations": [RapidPlugin, RpdEntityRemoveRelationsEventPayload];
-    "entity.beforeResponse": [RapidPlugin, RpdEntityBeforeResponseEventPayload];
+    "entity.beforeCreate": [RapidPlugin, RpdEntityBeforeCreateEventPayload, RouteContext?];
+    "entity.create": [RapidPlugin, RpdEntityCreateEventPayload, RouteContext?];
+    "entity.beforeUpdate": [RapidPlugin, RpdEntityBeforeUpdateEventPayload, RouteContext?];
+    "entity.update": [RapidPlugin, RpdEntityUpdateEventPayload, RouteContext?];
+    "entity.beforeDelete": [RapidPlugin, RpdEntityBeforeDeleteEventPayload, RouteContext?];
+    "entity.delete": [RapidPlugin, RpdEntityDeleteEventPayload, RouteContext?];
+    "entity.addRelations": [RapidPlugin, RpdEntityAddRelationsEventPayload, RouteContext?];
+    "entity.removeRelations": [RapidPlugin, RpdEntityRemoveRelationsEventPayload, RouteContext?];
+    "entity.beforeResponse": [RapidPlugin, RpdEntityBeforeResponseEventPayload, RouteContext?];
 };
 export interface RpdEntityBeforeCreateEventPayload {
     namespace: string;
@@ -126,6 +127,12 @@ export interface RpdEntityBeforeResponseEventPayload {
     baseModelSingularCode?: string;
     entities: any[];
 }
+export type EmitServerEventOptions<TEventName extends keyof RpdServerEventTypes> = {
+    eventName: TEventName;
+    payload: RpdServerEventTypes[TEventName][1];
+    sender?: RapidPlugin;
+    routeContext?: RouteContext;
+};
 export interface QuoteTableOptions {
     schema?: string;
     tableName: string;
@@ -335,12 +342,19 @@ export type EntityFilterOperators = EntityFilterRelationalOperators | EntityFilt
 export type EntityFilterOptions = FindEntityRelationalFilterOptions | FindEntitySetFilterOptions | FindEntityLogicalFilterOptions | FindEntityUnaryFilterOptions | FindEntityExistenceFilterOptions;
 export type EntityNonRelationPropertyFilterOptions = FindEntityRelationalFilterOptions | FindEntitySetFilterOptions | FindEntityUnaryFilterOptions;
 export interface FindEntityOptions {
+    routeContext?: RouteContext;
     filters?: EntityFilterOptions[];
     orderBy?: FindEntityOrderByOptions[];
     pagination?: FindEntityPaginationOptions;
     properties?: string[];
     keepNonPropertyFields?: boolean;
 }
+export interface FindEntityByIdOptions {
+    routeContext?: RouteContext;
+    id: any;
+    properties?: string[];
+    keepNonPropertyFields?: boolean;
+}
 export interface FindEntityRelationalFilterOptions {
     field: string;
     operator: EntityFilterRelationalOperators;
@@ -375,28 +389,38 @@ export interface FindEntityOrderByOptions {
     desc?: boolean;
 }
 export interface CountEntityOptions {
+    routeContext?: RouteContext;
     filters?: EntityFilterOptions[];
 }
 export interface CountEntityResult {
     count: number;
 }
+export interface DeleteEntityByIdOptions {
+    routeContext?: RouteContext;
+    id: any;
+}
 export interface CreateEntityOptions {
+    routeContext?: RouteContext;
     entity: any;
 }
 export interface UpdateEntityOptions {
+    routeContext?: RouteContext;
     filters?: EntityFilterOptions[];
     entity: any;
 }
 export interface UpdateEntityByIdOptions {
+    routeContext?: RouteContext;
     id: any;
     entityToSave: any;
     operation?: any;
     stateProperties?: string[];
 }
 export interface DeleteEntityOptions {
+    routeContext?: RouteContext;
     filters?: EntityFilterOptions[];
 }
 export interface AddEntityRelationsOptions {
+    routeContext?: RouteContext;
     id: number;
     property: string;
     relations: {
@@ -405,6 +429,7 @@ export interface AddEntityRelationsOptions {
     }[];
 }
 export interface RemoveEntityRelationsOptions {
+    routeContext?: RouteContext;
     id: number;
     property: string;
     relations: {
@@ -422,6 +447,7 @@ export type EntityWatchHandler<TEventName extends keyof RpdServerEventTypes> = (
 export type EntityWatchHandlerContext<TEventName extends keyof RpdServerEventTypes> = {
     server: IRpdServer;
     payload: RpdServerEventTypes[TEventName][1];
+    routerContext?: RouteContext;
 };
 export interface EntityWatchPluginInitOptions {
     watchers: EntityWatcherType[];

package/package.json

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

package/src/core/server.ts

@@ -1,4 +1,4 @@
-import { CreateEntityOptions, EntityWatcherType, GetDataAccessorOptions, GetModelOptions, IDatabaseConfig, IQueryBuilder, IRpdDataAccessor, RapidServerConfig, RpdApplicationConfig, RpdDataModel, RpdDataModelProperty, RpdServerEventTypes, UpdateEntityByIdOptions } from "~/types";
+import { CreateEntityOptions, EmitServerEventOptions, EntityWatcherType, GetDataAccessorOptions, GetModelOptions, IDatabaseConfig, IQueryBuilder, IRpdDataAccessor, RapidServerConfig, RpdApplicationConfig, RpdDataModel, RpdDataModelProperty, RpdServerEventTypes, UpdateEntityByIdOptions } from "~/types";
 import { IPluginActionHandler, ActionHandler, ActionHandlerContext } from "./actionHandler";
 import { Next, RouteContext } from "./routeContext";
 import EntityManager from "~/dataAccess/entityManager";
@@ -30,7 +30,7 @@ export interface IRpdServer {
   getModel(options: GetModelOptions): RpdDataModel | undefined;
   registerEventHandler<K extends keyof RpdServerEventTypes>(eventName: K, listener: (...args: RpdServerEventTypes[K]) => void);
   registerEntityWatcher(entityWatcher: EntityWatcherType);
-  emitEvent<K extends keyof RpdServerEventTypes>(eventName: K, payload: RpdServerEventTypes[K][1], sender?: RapidPlugin): void;
+  emitEvent<TEventName extends keyof RpdServerEventTypes>(event: EmitServerEventOptions<TEventName>): void;
   handleRequest(request: Request, next: Next): Promise<Response>;
   beforeRunRouteActions(handlerContext: ActionHandlerContext): Promise<void>;
   beforeCreateEntity(model: RpdDataModel, options: CreateEntityOptions): Promise<void>;

package/src/dataAccess/entityManager.ts

@@ -3,9 +3,11 @@ import {
   CountEntityOptions,
   CountEntityResult,
   CreateEntityOptions,
+  DeleteEntityByIdOptions,
   EntityFilterOperators,
   EntityFilterOptions,
   EntityNonRelationPropertyFilterOptions,
+  FindEntityByIdOptions,
   FindEntityOptions,
   FindEntityOrderByOptions,
   IRpdDataAccessor,
@@ -24,6 +26,7 @@ import { filter, find, first, forEach, isArray, isObject, keys, map, reject, uni
 import { getEntityPropertiesIncludingBase, getEntityProperty, getEntityPropertyByCode } from "./metaHelper";
 import { ColumnQueryOptions, CountRowOptions, FindRowOptions, FindRowOrderByOptions, RowFilterOptions } from "./dataAccessTypes";
 import { newEntityOperationError } from "~/utilities/errorUtility";
+import { RouteContext } from "~/core/routeContext";
 
 function convertEntityOrderByToRowOrderBy(server: IRpdServer, model: RpdDataModel, baseModel?: RpdDataModel, orderByList?: FindEntityOrderByOptions[]) {
   if (!orderByList) {
@@ -151,7 +154,7 @@ async function findEntities(server: IRpdServer, dataAccessor: IRpdDataAccessor,
           forEach(rows, (row: any) => {
             row[relationProperty.code] = filter(relationLinks, (link: any) => {
               return link[relationProperty.selfIdColumnName!] == row["id"];
-            }).map((link) => mapDbRowToEntity(server, targetModel, link.targetEntity, false));
+            }).map((link) => mapDbRowToEntity(server, targetModel, link.targetEntity, options.keepNonPropertyFields));
           });
         }
       } else {
@@ -175,7 +178,7 @@ async function findEntities(server: IRpdServer, dataAccessor: IRpdDataAccessor,
           if (isManyRelation) {
             row[relationProperty.code] = filter(relatedEntities, (relatedEntity: any) => {
               return relatedEntity[relationProperty.selfIdColumnName!] == row.id;
-            }).map((item) => mapDbRowToEntity(server, targetModel!, item, false));
+            }).map((item) => mapDbRowToEntity(server, targetModel!, item, options.keepNonPropertyFields));
           } else {
             row[relationProperty.code] = mapDbRowToEntity(
               server,
@@ -184,7 +187,7 @@ async function findEntities(server: IRpdServer, dataAccessor: IRpdDataAccessor,
                 // TODO: id property code should be configurable.
                 return relatedEntity["id"] == row[relationProperty.targetIdColumnName!];
               }),
-              false,
+              options.keepNonPropertyFields,
             );
           }
         });
@@ -193,16 +196,17 @@ async function findEntities(server: IRpdServer, dataAccessor: IRpdDataAccessor,
   }
   const entities = rows.map((item) => mapDbRowToEntity(server, model, item, options.keepNonPropertyFields));
 
-  await server.emitEvent(
-    "entity.beforeResponse",
-    {
+  await server.emitEvent({
+    eventName: "entity.beforeResponse",
+    payload: {
       namespace: model.namespace,
       modelSingularCode: model.singularCode,
       baseModelSingularCode: model.base,
       entities,
     },
-    null,
-  );
+    sender: null,
+    routeContext: options.routeContext,
+  });
 
   return entities;
 }
@@ -212,7 +216,8 @@ async function findEntity(server: IRpdServer, dataAccessor: IRpdDataAccessor, op
   return first(entities);
 }
 
-async function findById(server: IRpdServer, dataAccessor: IRpdDataAccessor, id: any, keepNonPropertyFields: boolean = false): Promise<any> {
+async function findById(server: IRpdServer, dataAccessor: IRpdDataAccessor, options: FindEntityByIdOptions): Promise<any> {
+  const { id, properties, keepNonPropertyFields, routeContext } = options;
   return await findEntity(server, dataAccessor, {
     filters: [
       {
@@ -221,7 +226,9 @@ async function findById(server: IRpdServer, dataAccessor: IRpdDataAccessor, id:
         value: id,
       },
     ],
+    properties,
     keepNonPropertyFields,
+    routeContext,
   });
 }
 
@@ -505,20 +512,21 @@ async function createEntity(server: IRpdServer, dataAccessor: IRpdDataAccessor,
     throw newEntityOperationError("Create base entity directly is not allowed.");
   }
 
-  const { entity } = options;
+  const { entity, routeContext } = options;
 
   await server.beforeCreateEntity(model, options);
 
-  await server.emitEvent(
-    "entity.beforeCreate",
-    {
+  await server.emitEvent({
+    eventName: "entity.beforeCreate",
+    payload: {
       namespace: model.namespace,
       modelSingularCode: model.singularCode,
       baseModelSingularCode: model.base,
       before: entity,
     },
-    plugin,
-  );
+    sender: plugin,
+    routeContext,
+  });
 
   const oneRelationPropertiesToCreate: RpdDataModelProperty[] = [];
   const manyRelationPropertiesToCreate: RpdDataModelProperty[] = [];
@@ -558,7 +566,10 @@ async function createEntity(server: IRpdServer, dataAccessor: IRpdDataAccessor,
         newEntityOneRelationProps[property.code] = newTargetEntity;
         targetRow[property.targetIdColumnName!] = newTargetEntity["id"];
       } else {
-        const targetEntity = await findById(server, targetDataAccessor, targetEntityId);
+        const targetEntity = await findById(server, targetDataAccessor, {
+          id: targetEntityId,
+          routeContext,
+        });
         if (!targetEntity) {
           throw newEntityOperationError(`Create ${model.singularCode} entity failed. Property '${property.code}' was invalid. Related ${property.targetSingularCode} entity with id '${targetEntityId}' was not found.`);
         }
@@ -568,7 +579,10 @@ async function createEntity(server: IRpdServer, dataAccessor: IRpdDataAccessor,
     } else {
       // fieldValue is id;
       const targetEntityId = fieldValue;
-      const targetEntity = await findById(server, targetDataAccessor, targetEntityId);
+      const targetEntity = await findById(server, targetDataAccessor, {
+        id: targetEntityId,
+        routeContext,
+      });
       if (!targetEntity) {
         throw newEntityOperationError(`Create ${model.singularCode} entity failed. Property '${property.code}' was invalid. Related ${property.targetSingularCode} entity with id '${targetEntityId}' was not found.`);
       }
@@ -662,28 +676,32 @@ async function createEntity(server: IRpdServer, dataAccessor: IRpdDataAccessor,
     }
   }
 
-  await server.emitEvent(
-    "entity.create",
-    {
+  await server.emitEvent({
+    eventName: "entity.create",
+    payload: {
       namespace: model.namespace,
       modelSingularCode: model.singularCode,
       baseModelSingularCode: model.base,
       after: newEntity,
     },
-    plugin,
-  );
+    sender: plugin,
+    routeContext,
+  });
 
   return newEntity;
 }
 
 async function updateEntityById(server: IRpdServer, dataAccessor: IRpdDataAccessor, options: UpdateEntityByIdOptions, plugin?: RapidPlugin) {
   const model = dataAccessor.getModel();
-  const { id, entityToSave } = options;
+  const { id, entityToSave, routeContext } = options;
   if (!id) {
     throw new Error("Id is required when updating an entity.");
   }
 
-  const entity = await findById(server, dataAccessor, id);
+  const entity = await findById(server, dataAccessor, {
+    id,
+    routeContext,
+  });
   if (!entity) {
     throw new Error(`${model.namespace}.${model.singularCode}  with id "${id}" was not found.`);
   }
@@ -696,16 +714,17 @@ async function updateEntityById(server: IRpdServer, dataAccessor: IRpdDataAccess
   options.entityToSave = changes || {};
   await server.beforeUpdateEntity(model, options, entity);
 
-  await server.emitEvent(
-    "entity.beforeUpdate",
-    {
+  await server.emitEvent({
+    eventName: "entity.beforeUpdate",
+    payload: {
       namespace: model.namespace,
       modelSingularCode: model.singularCode,
       before: entity,
       changes: options.entityToSave,
     },
-    plugin,
-  );
+    sender: plugin,
+    routeContext: options.routeContext,
+  });
 
   changes = getEntityPartChanges(entity, options.entityToSave);
 
@@ -747,7 +766,10 @@ async function updateEntityById(server: IRpdServer, dataAccessor: IRpdDataAccess
         updatedEntityOneRelationProps[property.code] = newTargetEntity;
         targetRow[property.targetIdColumnName!] = newTargetEntity["id"];
       } else {
-        const targetEntity = await findById(server, targetDataAccessor, targetEntityId);
+        const targetEntity = await findById(server, targetDataAccessor, {
+          id: targetEntityId,
+          routeContext,
+        });
         if (!targetEntity) {
           throw newEntityOperationError(`Create ${model.singularCode} entity failed. Property '${property.code}' was invalid. Related ${property.targetSingularCode} entity with id '${targetEntityId}' was not found.`);
         }
@@ -757,7 +779,10 @@ async function updateEntityById(server: IRpdServer, dataAccessor: IRpdDataAccess
     } else {
       // fieldValue is id;
       const targetEntityId = fieldValue;
-      const targetEntity = await findById(server, targetDataAccessor, targetEntityId);
+      const targetEntity = await findById(server, targetDataAccessor, {
+        id: targetEntityId,
+        routeContext,
+      });
       if (!targetEntity) {
         throw newEntityOperationError(`Create ${model.singularCode} entity failed. Property '${property.code}' was invalid. Related ${property.targetSingularCode} entity with id '${targetEntityId}' was not found.`);
       }
@@ -859,9 +884,9 @@ async function updateEntityById(server: IRpdServer, dataAccessor: IRpdDataAccess
     updatedEntity[property.code] = relatedEntities;
   }
 
-  await server.emitEvent(
-    "entity.update",
-    {
+  await server.emitEvent({
+    eventName: "entity.update",
+    payload: {
       namespace: model.namespace,
       modelSingularCode: model.singularCode,
       // TODO: should not emit event on base model if it's not effected.
@@ -870,8 +895,10 @@ async function updateEntityById(server: IRpdServer, dataAccessor: IRpdDataAccess
       after: updatedEntity,
       changes: changes,
     },
-    plugin,
-  );
+    sender: plugin,
+    routeContext: options.routeContext,
+  });
+
   return updatedEntity;
 }
 
@@ -896,8 +923,14 @@ export default class EntityManager<TEntity = any> {
     return await findEntity(this.#server, this.#dataAccessor, options);
   }
 
-  async findById(id: any, keepNonPropertyFields: boolean = false): Promise<TEntity | null> {
-    return await findById(this.#server, this.#dataAccessor, id, keepNonPropertyFields);
+  async findById(options: FindEntityByIdOptions): Promise<TEntity | null> {
+    // options is id
+    if (!isObject(options)) {
+      options = {
+        id: options,
+      };
+    }
+    return await findById(this.#server, this.#dataAccessor, options);
   }
 
   async createEntity(options: CreateEntityOptions, plugin?: RapidPlugin): Promise<TEntity> {
@@ -922,26 +955,41 @@ export default class EntityManager<TEntity = any> {
     return await this.#dataAccessor.count(countRowOptions);
   }
 
-  async deleteById(id: any, plugin?: RapidPlugin): Promise<void> {
+  async deleteById(options: DeleteEntityByIdOptions, plugin?: RapidPlugin): Promise<void> {
+    // options is id
+    if (!isObject(options)) {
+      options = {
+        id: options,
+      };
+    }
+
     const model = this.getModel();
     if (model.derivedTypePropertyCode) {
       throw newEntityOperationError("Delete base entity directly is not allowed.");
     }
 
-    const entity = await this.findById(id, true);
+    const { id, routeContext } = options;
+
+    const entity = await this.findById({
+      id,
+      keepNonPropertyFields: true,
+      routeContext,
+    });
+
     if (!entity) {
       return;
     }
 
-    await this.#server.emitEvent(
-      "entity.beforeDelete",
-      {
+    await this.#server.emitEvent({
+      eventName: "entity.beforeDelete",
+      payload: {
         namespace: model.namespace,
         modelSingularCode: model.singularCode,
         before: entity,
       },
-      plugin,
-    );
+      sender: plugin,
+      routeContext,
+    });
 
     await this.#dataAccessor.deleteById(id);
     if (model.base) {
@@ -951,23 +999,26 @@ export default class EntityManager<TEntity = any> {
       await baseDataAccessor.deleteById(id);
     }
 
-    await this.#server.emitEvent(
-      "entity.delete",
-      {
+    await this.#server.emitEvent({
+      eventName: "entity.delete",
+      payload: {
         namespace: model.namespace,
         modelSingularCode: model.singularCode,
-        baseModelSingularCode: model.base,
         before: entity,
       },
-      plugin,
-    );
+      sender: plugin,
+      routeContext,
+    });
   }
 
   async addRelations(options: AddEntityRelationsOptions, plugin?: RapidPlugin): Promise<void> {
     const server = this.#server;
     const model = this.getModel();
-    const { id, property, relations } = options;
-    const entity = await this.findById(id);
+    const { id, property, relations, routeContext } = options;
+    const entity = await this.findById({
+      id,
+      routeContext,
+    });
     if (!entity) {
       throw new Error(`${model.namespace}.${model.singularCode}  with id "${id}" was not found.`);
     }
@@ -995,24 +1046,28 @@ export default class EntityManager<TEntity = any> {
       }
     }
 
-    await server.emitEvent(
-      "entity.addRelations",
-      {
+    await server.emitEvent({
+      eventName: "entity.addRelations",
+      payload: {
         namespace: model.namespace,
         modelSingularCode: model.singularCode,
         entity,
         property,
         relations,
       },
-      plugin,
-    );
+      sender: plugin,
+      routeContext: options.routeContext,
+    });
   }
 
   async removeRelations(options: RemoveEntityRelationsOptions, plugin?: RapidPlugin): Promise<void> {
     const server = this.#server;
     const model = this.getModel();
-    const { id, property, relations } = options;
-    const entity = await this.findById(id);
+    const { id, property, relations, routeContext } = options;
+    const entity = await this.findById({
+      id,
+      routeContext,
+    });
     if (!entity) {
       throw new Error(`${model.namespace}.${model.singularCode}  with id "${id}" was not found.`);
     }
@@ -1036,16 +1091,17 @@ export default class EntityManager<TEntity = any> {
       }
     }
 
-    await server.emitEvent(
-      "entity.removeRelations",
-      {
+    await server.emitEvent({
+      eventName: "entity.removeRelations",
+      payload: {
         namespace: model.namespace,
         modelSingularCode: model.singularCode,
         entity,
         property,
         relations,
       },
-      plugin,
-    );
+      sender: plugin,
+      routeContext: options.routeContext,
+    });
   }
 }

package/src/plugins/dataManage/actionHandlers/addEntityRelations.ts

@@ -1,4 +1,4 @@
-import { RunEntityActionHandlerOptions } from "~/types";
+import { AddEntityRelationsOptions, RunEntityActionHandlerOptions } from "~/types";
 import { mergeInput } from "~/helpers/inputHelper";
 import { ActionHandlerContext } from "~/core/actionHandler";
 import { RapidPlugin } from "~/core/server";
@@ -9,10 +9,11 @@ export async function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, op
   const { logger, server, input } = ctx;
 
   const { defaultInput, fixedInput } = options;
-  const mergedInput = mergeInput(defaultInput, input, fixedInput);
+  const mergedInput: AddEntityRelationsOptions = mergeInput(defaultInput, input, fixedInput);
   logger.debug(`Running ${code} handler...`, { defaultInput, fixedInput, mergedInput });
 
   const entityManager = server.getEntityManager(options.singularCode);
+  mergedInput.routeContext = ctx.routerContext;
   await entityManager.addRelations(mergedInput, plugin);
 
   ctx.output = {};

package/src/plugins/dataManage/actionHandlers/countCollectionEntities.ts

@@ -1,4 +1,4 @@
-import { RunEntityActionHandlerOptions } from "~/types";
+import { CountEntityOptions, RunEntityActionHandlerOptions } from "~/types";
 import runCollectionEntityActionHandler from "~/helpers/runCollectionEntityActionHandler";
 import { removeFiltersWithNullValue } from "~/dataAccess/filterHelper";
 import { ActionHandlerContext } from "~/core/actionHandler";
@@ -7,8 +7,9 @@ import { RapidPlugin } from "~/core/server";
 export const code = "countCollectionEntities";
 
 export async function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, options: RunEntityActionHandlerOptions) {
-  await runCollectionEntityActionHandler(ctx, options, code, (entityManager, input) => {
+  await runCollectionEntityActionHandler(ctx, options, code, (entityManager, input: CountEntityOptions) => {
     input.filters = removeFiltersWithNullValue(input.filters);
+    input.routeContext = ctx.routerContext;
     return entityManager.count(input);
   });
 }

package/src/plugins/dataManage/actionHandlers/createCollectionEntitiesBatch.ts

@@ -30,6 +30,7 @@ export async function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, op
     const newEntity = await entityManager.createEntity(
       {
         entity: mergedEntity,
+        routeContext: ctx.routerContext,
       },
       plugin,
     );

package/src/plugins/dataManage/actionHandlers/createCollectionEntity.ts

@@ -21,6 +21,7 @@ export async function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, op
   const output = await entityManager.createEntity(
     {
       entity: input,
+      routeContext: ctx.routerContext,
     },
     plugin,
   );

package/src/plugins/dataManage/actionHandlers/deleteCollectionEntityById.ts

@@ -9,7 +9,10 @@ export async function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, op
   logger.debug(`Running ${code} handler...`);
 
   const entityManager = server.getEntityManager(options.singularCode);
-  await entityManager.deleteById(input.id, plugin);
+  await entityManager.deleteById({
+    id: input.id,
+    routeContext: ctx.routerContext,
+  }, plugin);
 
   ctx.status = 200;
   ctx.output = {};

package/src/plugins/dataManage/actionHandlers/findCollectionEntities.ts

@@ -9,6 +9,7 @@ export const code = "findCollectionEntities";
 export async function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, options: RunEntityActionHandlerOptions) {
   await runCollectionEntityActionHandler(ctx, options, code, async (entityManager, input: FindEntityOptions) => {
     input.filters = removeFiltersWithNullValue(input.filters);
+    input.routeContext = ctx.routerContext;
     const entities = await entityManager.findEntities(input);
     const result: {
       list: any;

package/src/plugins/dataManage/actionHandlers/findCollectionEntityById.ts

@@ -10,7 +10,10 @@ export async function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, op
   const { id } = input;
 
   const entityManager = server.getEntityManager(options.singularCode);
-  const entity = await entityManager.findById(id);
+  const entity = await entityManager.findById({
+    id,
+    routeContext: ctx.routerContext,
+  });
   if (!entity) {
     throw new Error(`${options.namespace}.${options.singularCode} with id "${id}" was not found.`);
   }

package/src/plugins/dataManage/actionHandlers/removeEntityRelations.ts

@@ -1,4 +1,4 @@
-import { RunEntityActionHandlerOptions } from "~/types";
+import { RemoveEntityRelationsOptions, RunEntityActionHandlerOptions } from "~/types";
 import { mergeInput } from "~/helpers/inputHelper";
 import { ActionHandlerContext } from "~/core/actionHandler";
 import { RapidPlugin } from "~/core/server";
@@ -9,8 +9,9 @@ export async function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, op
   const { logger, server, input } = ctx;
   const { defaultInput, fixedInput } = options;
 
-  const mergedInput = mergeInput(defaultInput, input, fixedInput);
+  const mergedInput: RemoveEntityRelationsOptions = mergeInput(defaultInput, input, fixedInput);
   logger.debug(`Running ${code} handler...`, { defaultInput, fixedInput, mergedInput });
+  mergedInput.routeContext = ctx.routerContext;
 
   const entityManager = server.getEntityManager(options.singularCode);
   await entityManager.removeRelations(mergedInput, plugin);