@ruiapp/rapid-core 0.1.54 → 0.1.55

package/dist/core/server.d.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";
@@ -26,7 +26,7 @@ export interface IRpdServer {
     getModel(options: GetModelOptions): RpdDataModel | undefined;
     registerEventHandler<K extends keyof RpdServerEventTypes>(eventName: K, listener: (...args: RpdServerEventTypes[K]) => void): any;
     registerEntityWatcher(entityWatcher: EntityWatcherType): any;
-    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/dist/dataAccess/entityManager.d.ts

@@ -1,4 +1,4 @@
-import { AddEntityRelationsOptions, CountEntityOptions, CountEntityResult, CreateEntityOptions, FindEntityOptions, IRpdDataAccessor, RemoveEntityRelationsOptions, RpdDataModel, UpdateEntityByIdOptions } from "../types";
+import { AddEntityRelationsOptions, CountEntityOptions, CountEntityResult, CreateEntityOptions, DeleteEntityByIdOptions, FindEntityByIdOptions, FindEntityOptions, IRpdDataAccessor, RemoveEntityRelationsOptions, RpdDataModel, UpdateEntityByIdOptions } from "../types";
 import { IRpdServer, RapidPlugin } from "../core/server";
 export default class EntityManager<TEntity = any> {
     #private;
@@ -6,11 +6,11 @@ export default class EntityManager<TEntity = any> {
     getModel(): RpdDataModel;
     findEntities(options: FindEntityOptions): Promise<TEntity[]>;
     findEntity(options: FindEntityOptions): Promise<TEntity | null>;
-    findById(id: any, keepNonPropertyFields?: boolean): Promise<TEntity | null>;
+    findById(options: FindEntityByIdOptions): Promise<TEntity | null>;
     createEntity(options: CreateEntityOptions, plugin?: RapidPlugin): Promise<TEntity>;
     updateEntityById(options: UpdateEntityByIdOptions, plugin?: RapidPlugin): Promise<TEntity>;
     count(options: CountEntityOptions): Promise<CountEntityResult>;
-    deleteById(id: any, plugin?: RapidPlugin): Promise<void>;
+    deleteById(options: DeleteEntityByIdOptions, plugin?: RapidPlugin): Promise<void>;
     addRelations(options: AddEntityRelationsOptions, plugin?: RapidPlugin): Promise<void>;
     removeRelations(options: RemoveEntityRelationsOptions, plugin?: RapidPlugin): Promise<void>;
 }

package/dist/index.js

@@ -2079,7 +2079,7 @@ async function findEntities(server, dataAccessor, options) {
                     lodash.forEach(rows, (row) => {
                         row[relationProperty.code] = lodash.filter(relationLinks, (link) => {
                             return link[relationProperty.selfIdColumnName] == row["id"];
-                        }).map((link) => mapDbRowToEntity(server, targetModel, link.targetEntity, false));
+                        }).map((link) => mapDbRowToEntity(server, targetModel, link.targetEntity, options.keepNonPropertyFields));
                     });
                 }
             }
@@ -2099,33 +2099,38 @@ async function findEntities(server, dataAccessor, options) {
                     if (isManyRelation) {
                         row[relationProperty.code] = lodash.filter(relatedEntities, (relatedEntity) => {
                             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, targetModel, lodash.find(relatedEntities, (relatedEntity) => {
                             // TODO: id property code should be configurable.
                             return relatedEntity["id"] == row[relationProperty.targetIdColumnName];
-                        }), false);
+                        }), options.keepNonPropertyFields);
                     }
                 });
             }
         }
     }
     const entities = rows.map((item) => mapDbRowToEntity(server, model, item, options.keepNonPropertyFields));
-    await server.emitEvent("entity.beforeResponse", {
-        routerContext: options.routerContext,
-        namespace: model.namespace,
-        modelSingularCode: model.singularCode,
-        baseModelSingularCode: model.base,
-        entities,
-    }, null);
+    await server.emitEvent({
+        eventName: "entity.beforeResponse",
+        payload: {
+            namespace: model.namespace,
+            modelSingularCode: model.singularCode,
+            baseModelSingularCode: model.base,
+            entities,
+        },
+        sender: null,
+        routeContext: options.routeContext,
+    });
     return entities;
 }
 async function findEntity(server, dataAccessor, options) {
     const entities = await findEntities(server, dataAccessor, options);
     return lodash.first(entities);
 }
-async function findById(server, dataAccessor, id, keepNonPropertyFields = false) {
+async function findById(server, dataAccessor, options) {
+    const { id, properties, keepNonPropertyFields, routeContext } = options;
     return await findEntity(server, dataAccessor, {
         filters: [
             {
@@ -2134,7 +2139,9 @@ async function findById(server, dataAccessor, id, keepNonPropertyFields = false)
                 value: id,
             },
         ],
+        properties,
         keepNonPropertyFields,
+        routeContext,
     });
 }
 async function convertEntityFiltersToRowFilters(server, model, baseModel, filters) {
@@ -2405,15 +2412,19 @@ async function createEntity(server, dataAccessor, options, plugin) {
     if (model.derivedTypePropertyCode) {
         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", {
-        routerContext: options.routerContext,
-        namespace: model.namespace,
-        modelSingularCode: model.singularCode,
-        baseModelSingularCode: model.base,
-        before: entity,
-    }, plugin);
+    await server.emitEvent({
+        eventName: "entity.beforeCreate",
+        payload: {
+            namespace: model.namespace,
+            modelSingularCode: model.singularCode,
+            baseModelSingularCode: model.base,
+            before: entity,
+        },
+        sender: plugin,
+        routeContext,
+    });
     const oneRelationPropertiesToCreate = [];
     const manyRelationPropertiesToCreate = [];
     lodash.keys(entity).forEach((propertyCode) => {
@@ -2451,7 +2462,10 @@ async function createEntity(server, dataAccessor, options, plugin) {
                 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.`);
                 }
@@ -2462,7 +2476,10 @@ async function createEntity(server, dataAccessor, options, plugin) {
         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.`);
             }
@@ -2548,22 +2565,29 @@ async function createEntity(server, dataAccessor, options, plugin) {
             }
         }
     }
-    await server.emitEvent("entity.create", {
-        routerContext: options.routerContext,
-        namespace: model.namespace,
-        modelSingularCode: model.singularCode,
-        baseModelSingularCode: model.base,
-        after: newEntity,
-    }, plugin);
+    await server.emitEvent({
+        eventName: "entity.create",
+        payload: {
+            namespace: model.namespace,
+            modelSingularCode: model.singularCode,
+            baseModelSingularCode: model.base,
+            after: newEntity,
+        },
+        sender: plugin,
+        routeContext,
+    });
     return newEntity;
 }
 async function updateEntityById(server, dataAccessor, options, plugin) {
     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.`);
     }
@@ -2573,12 +2597,17 @@ async function updateEntityById(server, dataAccessor, options, plugin) {
     }
     options.entityToSave = changes || {};
     await server.beforeUpdateEntity(model, options, entity);
-    await server.emitEvent("entity.beforeUpdate", {
-        namespace: model.namespace,
-        modelSingularCode: model.singularCode,
-        before: entity,
-        changes: options.entityToSave,
-    }, plugin);
+    await server.emitEvent({
+        eventName: "entity.beforeUpdate",
+        payload: {
+            namespace: model.namespace,
+            modelSingularCode: model.singularCode,
+            before: entity,
+            changes: options.entityToSave,
+        },
+        sender: plugin,
+        routeContext: options.routeContext,
+    });
     changes = getEntityPartChanges(entity, options.entityToSave);
     const oneRelationPropertiesToUpdate = [];
     const manyRelationPropertiesToUpdate = [];
@@ -2616,7 +2645,10 @@ async function updateEntityById(server, dataAccessor, options, plugin) {
                 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.`);
                 }
@@ -2627,7 +2659,10 @@ async function updateEntityById(server, dataAccessor, options, plugin) {
         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.`);
             }
@@ -2721,15 +2756,20 @@ async function updateEntityById(server, dataAccessor, options, plugin) {
         }
         updatedEntity[property.code] = relatedEntities;
     }
-    await server.emitEvent("entity.update", {
-        namespace: model.namespace,
-        modelSingularCode: model.singularCode,
-        // TODO: should not emit event on base model if it's not effected.
-        baseModelSingularCode: model.base,
-        before: entity,
-        after: updatedEntity,
-        changes: changes,
-    }, plugin);
+    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.
+            baseModelSingularCode: model.base,
+            before: entity,
+            after: updatedEntity,
+            changes: changes,
+        },
+        sender: plugin,
+        routeContext: options.routeContext,
+    });
     return updatedEntity;
 }
 class EntityManager {
@@ -2748,8 +2788,14 @@ class EntityManager {
     async findEntity(options) {
         return await findEntity(this.#server, this.#dataAccessor, options);
     }
-    async findById(id, keepNonPropertyFields = false) {
-        return await findById(this.#server, this.#dataAccessor, id, keepNonPropertyFields);
+    async findById(options) {
+        // options is id
+        if (!lodash.isObject(options)) {
+            options = {
+                id: options,
+            };
+        }
+        return await findById(this.#server, this.#dataAccessor, options);
     }
     async createEntity(options, plugin) {
         return await createEntity(this.#server, this.#dataAccessor, options, plugin);
@@ -2770,20 +2816,36 @@ class EntityManager {
         };
         return await this.#dataAccessor.count(countRowOptions);
     }
-    async deleteById(id, plugin) {
+    async deleteById(options, plugin) {
+        // options is id
+        if (!lodash.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", {
-            namespace: model.namespace,
-            modelSingularCode: model.singularCode,
-            before: entity,
-        }, plugin);
+        await this.#server.emitEvent({
+            eventName: "entity.beforeDelete",
+            payload: {
+                namespace: model.namespace,
+                modelSingularCode: model.singularCode,
+                before: entity,
+            },
+            sender: plugin,
+            routeContext,
+        });
         await this.#dataAccessor.deleteById(id);
         if (model.base) {
             const baseDataAccessor = this.#server.getDataAccessor({
@@ -2791,18 +2853,25 @@ class EntityManager {
             });
             await baseDataAccessor.deleteById(id);
         }
-        await this.#server.emitEvent("entity.delete", {
-            namespace: model.namespace,
-            modelSingularCode: model.singularCode,
-            baseModelSingularCode: model.base,
-            before: entity,
-        }, plugin);
+        await this.#server.emitEvent({
+            eventName: "entity.delete",
+            payload: {
+                namespace: model.namespace,
+                modelSingularCode: model.singularCode,
+                before: entity,
+            },
+            sender: plugin,
+            routeContext,
+        });
     }
     async addRelations(options, plugin) {
         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.`);
         }
@@ -2826,19 +2895,27 @@ class EntityManager {
                 await server.queryDatabaseObject(command, params);
             }
         }
-        await server.emitEvent("entity.addRelations", {
-            namespace: model.namespace,
-            modelSingularCode: model.singularCode,
-            entity,
-            property,
-            relations,
-        }, plugin);
+        await server.emitEvent({
+            eventName: "entity.addRelations",
+            payload: {
+                namespace: model.namespace,
+                modelSingularCode: model.singularCode,
+                entity,
+                property,
+                relations,
+            },
+            sender: plugin,
+            routeContext: options.routeContext,
+        });
     }
     async removeRelations(options, plugin) {
         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.`);
         }
@@ -2858,13 +2935,18 @@ class EntityManager {
                 await server.queryDatabaseObject(command, params);
             }
         }
-        await server.emitEvent("entity.removeRelations", {
-            namespace: model.namespace,
-            modelSingularCode: model.singularCode,
-            entity,
-            property,
-            relations,
-        }, plugin);
+        await server.emitEvent({
+            eventName: "entity.removeRelations",
+            payload: {
+                namespace: model.namespace,
+                modelSingularCode: model.singularCode,
+                entity,
+                property,
+                relations,
+            },
+            sender: plugin,
+            routeContext: options.routeContext,
+        });
     }
 }
 
@@ -3050,9 +3132,10 @@ class RapidServer {
     registerEntityWatcher(entityWatcher) {
         this.#entityWatchers.push(entityWatcher);
     }
-    async emitEvent(eventName, payload, sender) {
+    async emitEvent(event) {
+        const { eventName, payload, sender, routeContext: routerContext } = event;
         this.#logger.debug(`Emitting '${eventName}' event.`, { eventName, payload });
-        await this.#eventManager.emit(eventName, sender, payload);
+        await this.#eventManager.emit(eventName, sender, payload, routerContext);
         // TODO: should move this logic into metaManager
         // if (
         //   (eventName === "entity.create" || eventName === "entity.update" ||
@@ -3187,11 +3270,12 @@ class RapidServer {
     async beforeUpdateEntity(model, options, currentEntity) {
         await this.#pluginManager.beforeUpdateEntity(model, options, currentEntity);
     }
-    async #handleEntityEvent(eventName, sender, payload) {
+    async #handleEntityEvent(eventName, sender, payload, routerContext) {
         const { modelSingularCode, baseModelSingularCode } = payload;
         const entityWatchHandlerContext = {
             server: this,
             payload,
+            routerContext,
         };
         let emitter;
         if (eventName === "entity.beforeCreate") {
@@ -3531,7 +3615,7 @@ async function syncDatabaseSchema(server, applicationConfig) {
     for (const model of applicationConfig.models) {
         logger.debug(`Checking data columns for '${model.namespace}.${model.singularCode}'...`);
         for (const property of model.properties) {
-            let columnDDL;
+            let columnDDL = "";
             if (isRelationProperty(property)) {
                 if (property.relation === "one") {
                     const targetModel = applicationConfig.models.find((item) => item.singularCode === property.targetSingularCode);
@@ -3565,6 +3649,11 @@ async function syncDatabaseSchema(server, applicationConfig) {
                                 selfIdColumnName: property.selfIdColumnName,
                             });
                         }
+                        const contraintName = `${property.linkTableName}_pk`;
+                        columnDDL += `ALTER TABLE ${queryBuilder.quoteTable(({
+                            schema: property.linkSchema,
+                            tableName: property.linkTableName,
+                        }))} ADD CONSTRAINT ${queryBuilder.quoteObject(contraintName)} PRIMARY KEY (id);`;
                     }
                     else {
                         const targetModel = applicationConfig.models.find((item) => item.singularCode === property.targetSingularCode);
@@ -3650,6 +3739,23 @@ async function syncDatabaseSchema(server, applicationConfig) {
             }
         }
     }
+    const sqlQueryConstraints = `SELECT table_schema, table_name, constraint_type, constraint_name FROM information_schema.table_constraints WHERE constraint_type = 'PRIMARY KEY';`;
+    const constraintsInDb = await server.queryDatabaseObject(sqlQueryConstraints);
+    for (const model of applicationConfig.models) {
+        const expectedTableSchema = model.schema || server.databaseConfig.dbDefaultSchema;
+        const expectedTableName = model.tableName;
+        const expectedContraintName = `${expectedTableName}_pk`;
+        logger.debug(`Checking pk for '${expectedTableSchema}.${expectedTableName}'...`);
+        const constraintInDb = lodash.find(constraintsInDb, {
+            table_schema: expectedTableSchema,
+            table_name: expectedTableName,
+            constraint_type: "PRIMARY KEY",
+            constraint_name: expectedContraintName,
+        });
+        if (!constraintInDb) {
+            await server.queryDatabaseObject(`ALTER TABLE ${queryBuilder.quoteTable(model)} ADD CONSTRAINT ${queryBuilder.quoteObject(expectedContraintName)} PRIMARY KEY (id);`, []);
+        }
+    }
 }
 function generateCreateColumnDDL(queryBuilder, options) {
     let columnDDL = `ALTER TABLE ${queryBuilder.quoteTable(options)} ADD`;
@@ -3679,7 +3785,7 @@ function generateLinkTableDDL(queryBuilder, options) {
     })} (`;
     columnDDL += `id serial not null,`;
     columnDDL += `${queryBuilder.quoteObject(options.selfIdColumnName)} integer not null,`;
-    columnDDL += `${queryBuilder.quoteObject(options.targetIdColumnName)} integer not null)`;
+    columnDDL += `${queryBuilder.quoteObject(options.targetIdColumnName)} integer not null);`;
     return columnDDL;
 }
 const pgPropertyTypeColumnMap = {
@@ -3762,7 +3868,7 @@ const code$m = "findCollectionEntities";
 async function handler$m(plugin, ctx, options) {
     await runCollectionEntityActionHandler(ctx, options, code$m, async (entityManager, input) => {
         input.filters = removeFiltersWithNullValue(input.filters);
-        input.routerContext = ctx.routerContext;
+        input.routeContext = ctx.routerContext;
         const entities = await entityManager.findEntities(input);
         const result = { list: entities };
         if (input.pagination && !input.pagination.withoutTotal) {
@@ -3786,7 +3892,10 @@ async function handler$l(plugin, ctx, options) {
     logger.debug(`Running ${code$l} handler...`, { input });
     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.`);
     }
@@ -3803,6 +3912,7 @@ const code$k = "countCollectionEntities";
 async function handler$k(plugin, ctx, options) {
     await runCollectionEntityActionHandler(ctx, options, code$k, (entityManager, input) => {
         input.filters = removeFiltersWithNullValue(input.filters);
+        input.routeContext = ctx.routerContext;
         return entityManager.count(input);
     });
 }
@@ -3826,7 +3936,7 @@ async function handler$j(plugin, ctx, options) {
     const entityManager = server.getEntityManager(options.singularCode);
     const output = await entityManager.createEntity({
         entity: input,
-        routerContext: ctx.routerContext,
+        routeContext: ctx.routerContext,
     }, plugin);
     ctx.output = output;
 }
@@ -3856,7 +3966,7 @@ async function handler$i(plugin, ctx, options) {
         const entityManager = server.getEntityManager(options.singularCode);
         const newEntity = await entityManager.createEntity({
             entity: mergedEntity,
-            routerContext: ctx.routerContext,
+            routeContext: ctx.routerContext,
         }, plugin);
         output.push(newEntity);
     }
@@ -3883,8 +3993,15 @@ async function handler$h(plugin, ctx, options) {
     if (stateProperties) {
         delete mergedInput.$stateProperties;
     }
+    const updateEntityByIdOptions = {
+        id: mergedInput.id,
+        entityToSave: mergedInput,
+        operation,
+        stateProperties,
+        routeContext: ctx.routerContext,
+    };
     const entityManager = server.getEntityManager(options.singularCode);
-    const output = await entityManager.updateEntityById({ id: mergedInput.id, entityToSave: mergedInput, operation, stateProperties }, plugin);
+    const output = await entityManager.updateEntityById(updateEntityByIdOptions, plugin);
     ctx.output = output;
 }
 
@@ -3899,7 +4016,10 @@ async function handler$g(plugin, ctx, options) {
     const { logger, server, input } = ctx;
     logger.debug(`Running ${code$g} 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 = {};
 }
@@ -3917,7 +4037,7 @@ async function handler$f(plugin, ctx, options) {
     const mergedInput = mergeInput(defaultInput, input, fixedInput);
     logger.debug(`Running ${code$f} handler...`, { defaultInput, fixedInput, mergedInput });
     const entityManager = server.getEntityManager(options.singularCode);
-    mergedInput.routerContext = ctx.routerContext;
+    mergedInput.routeContext = ctx.routerContext;
     await entityManager.addRelations(mergedInput, plugin);
     ctx.output = {};
 }
@@ -3934,6 +4054,7 @@ async function handler$e(plugin, ctx, options) {
     const { defaultInput, fixedInput } = options;
     const mergedInput = mergeInput(defaultInput, input, fixedInput);
     logger.debug(`Running ${code$e} handler...`, { defaultInput, fixedInput, mergedInput });
+    mergedInput.routeContext = ctx.routerContext;
     const entityManager = server.getEntityManager(options.singularCode);
     await entityManager.removeRelations(mergedInput, plugin);
     ctx.output = {};

package/dist/server.d.ts

@@ -1,4 +1,4 @@
-import { GetDataAccessorOptions, GetModelOptions, IDatabaseAccessor, IDatabaseConfig, IQueryBuilder, IRpdDataAccessor, RpdApplicationConfig, RpdDataModel, RpdServerEventTypes, RapidServerConfig, RpdDataModelProperty, CreateEntityOptions, UpdateEntityByIdOptions, EntityWatcherType } from "./types";
+import { GetDataAccessorOptions, GetModelOptions, IDatabaseAccessor, IDatabaseConfig, IQueryBuilder, IRpdDataAccessor, RpdApplicationConfig, RpdDataModel, RpdServerEventTypes, RapidServerConfig, RpdDataModelProperty, CreateEntityOptions, UpdateEntityByIdOptions, EntityWatcherType, EmitServerEventOptions } from "./types";
 import { ActionHandler, ActionHandlerContext, IPluginActionHandler } from "./core/actionHandler";
 import { IRpdServer, RapidPlugin } from "./core/server";
 import { Next } from "./core/routeContext";
@@ -33,7 +33,7 @@ export declare class RapidServer implements IRpdServer {
     getEntityManager<TEntity = any>(singularCode: string): EntityManager<TEntity>;
     registerEventHandler<K extends keyof RpdServerEventTypes>(eventName: K, listener: (...args: RpdServerEventTypes[K]) => void): void;
     registerEntityWatcher(entityWatcher: EntityWatcherType): void;
-    emitEvent<K extends keyof RpdServerEventTypes>(eventName: K, payload: RpdServerEventTypes[K][1], sender?: RapidPlugin): Promise<void>;
+    emitEvent<TEventName extends keyof RpdServerEventTypes>(event: EmitServerEventOptions<TEventName>): Promise<void>;
     registerService(name: string, service: any): void;
     getService<TService>(name: string): TService;
     start(): Promise<void>;