@ruiapp/rapid-core 0.1.12 → 0.1.13

package/dist/plugins/entityWatch/EntityWatchPlugin.d.ts

@@ -0,0 +1,15 @@
+import type { RpdEntityCreateEventPayload, RpdServerEventTypes } from "../../types";
+import { IRpdServer, RapidPlugin, RpdConfigurationItemOptions, RpdServerPluginConfigurableTargetOptions, RpdServerPluginExtendingAbilities } from "../../core/server";
+import { EntityWatchPluginInitOptions } from "./EntityWatchPluginTypes";
+declare class EntityWatchPlugin implements RapidPlugin {
+    #private;
+    constructor(options: EntityWatchPluginInitOptions);
+    get code(): string;
+    get description(): string;
+    get extendingAbilities(): RpdServerPluginExtendingAbilities[];
+    get configurableTargets(): RpdServerPluginConfigurableTargetOptions[];
+    get configurations(): RpdConfigurationItemOptions[];
+    registerEventHandlers(server: IRpdServer): Promise<any>;
+    handleEntityEvent(server: IRpdServer, eventName: keyof RpdServerEventTypes, sender: RapidPlugin, payload: RpdEntityCreateEventPayload): void;
+}
+export default EntityWatchPlugin;

package/dist/plugins/entityWatch/EntityWatchPluginTypes.d.ts

@@ -0,0 +1,15 @@
+import { IRpdServer } from "../../core/server";
+import { RpdServerEventTypes } from "../../types";
+export interface EntityWatcher<TEventName extends keyof RpdServerEventTypes> {
+    eventName: TEventName;
+    modelSingularCode: string;
+    handler: EntityWatchHandler<TEventName>;
+}
+export type EntityWatchHandler<TEventName extends keyof RpdServerEventTypes> = (ctx: EntityWatchHandlerContext<TEventName>) => Promise<void>;
+export type EntityWatchHandlerContext<TEventName extends keyof RpdServerEventTypes> = {
+    server: IRpdServer;
+    payload: RpdServerEventTypes[TEventName][1];
+};
+export interface EntityWatchPluginInitOptions {
+    watchers: EntityWatcher<keyof RpdServerEventTypes>[];
+}

package/dist/plugins/serverOperation/ServerOperationPlugin.d.ts

@@ -0,0 +1,25 @@
+import type { RpdApplicationConfig } from "../../types";
+import { ServerOperationPluginInitOptions } from "./ServerOperationPluginTypes";
+import { IRpdServer, RapidPlugin, RpdConfigurationItemOptions, RpdServerPluginConfigurableTargetOptions, RpdServerPluginExtendingAbilities } from "../../core/server";
+declare class ServerOperationPlugin implements RapidPlugin {
+    #private;
+    constructor(options: ServerOperationPluginInitOptions);
+    get code(): string;
+    get description(): string;
+    get extendingAbilities(): RpdServerPluginExtendingAbilities[];
+    get configurableTargets(): RpdServerPluginConfigurableTargetOptions[];
+    get configurations(): RpdConfigurationItemOptions[];
+    initPlugin(server: IRpdServer): Promise<any>;
+    registerMiddlewares(server: IRpdServer): Promise<any>;
+    registerActionHandlers(server: IRpdServer): Promise<any>;
+    registerEventHandlers(server: IRpdServer): Promise<any>;
+    registerMessageHandlers(server: IRpdServer): Promise<any>;
+    registerTaskProcessors(server: IRpdServer): Promise<any>;
+    onLoadingApplication(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any>;
+    configureModels(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any>;
+    configureModelProperties(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any>;
+    configureRoutes(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any>;
+    onApplicationLoaded(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any>;
+    onApplicationReady(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any>;
+}
+export default ServerOperationPlugin;

package/dist/plugins/serverOperation/ServerOperationPluginTypes.d.ts

@@ -0,0 +1,11 @@
+import { ActionHandlerContext } from "../../core/actionHandler";
+import { RpdHttpMethod } from "../../types";
+export interface ServerOperation {
+    code: string;
+    description?: string;
+    method: RpdHttpMethod;
+    handler: (ctx: ActionHandlerContext) => Promise<void>;
+}
+export interface ServerOperationPluginInitOptions {
+    operations: ServerOperation[];
+}

package/dist/plugins/serverOperation/actionHandlers/index.d.ts

@@ -0,0 +1,3 @@
+import * as runServerOperation from "./runServerOperation";
+declare const _default: (typeof runServerOperation)[];
+export default _default;

package/dist/plugins/serverOperation/actionHandlers/runServerOperation.d.ts

@@ -0,0 +1,6 @@
+import { ActionHandlerContext } from "../../../core/actionHandler";
+import { RapidPlugin } from "../../../core/server";
+export declare const code = "runServerOperation";
+export declare function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, options: {
+    operation: (ctx: ActionHandlerContext) => Promise<void>;
+}): Promise<void>;

package/dist/types.d.ts

@@ -321,9 +321,24 @@ export interface UpdateEntityOptions {
 }
 export interface UpdateEntityByIdOptions {
     id: any;
-    entity: any;
-    changes: any;
+    entityToSave: any;
 }
 export interface DeleteEntityOptions {
     filters?: EntityFilterOptions[];
 }
+export interface AddEntityRelationsOptions {
+    id: number;
+    property: string;
+    relations: {
+        id?: number;
+        [k: string]: any;
+    }[];
+}
+export interface RemoveEntityRelationsOptions {
+    id: number;
+    property: string;
+    relations: {
+        id?: number;
+        [k: string]: any;
+    }[];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ruiapp/rapid-core",
-  "version": "0.1.12",
+  "version": "0.1.13",
   "description": "",
   "main": "dist/index.js",
   "keywords": [],

package/src/core/eventManager.ts

@@ -1,7 +1,6 @@
 import { EventEmitter } from "events";
-import { RpdServerEventTypes as EventTypes } from "~/types";
 
-export default class EventManager {
+export default class EventManager<EventTypes extends Record<string, any[]>> {
   #eventEmitter: EventEmitter;
 
   constructor() {
@@ -12,10 +11,10 @@ export default class EventManager {
     eventName: K,
     listener: (...args: EventTypes[K]) => void,
   ) {
-    this.#eventEmitter.on(eventName, listener);
+    this.#eventEmitter.on(eventName as string, listener);
   }
 
   emit<K extends keyof EventTypes>(eventName: K, ...args: EventTypes[K]) {
-    return this.#eventEmitter.emit(eventName, ...args);
+    return this.#eventEmitter.emit(eventName as string, ...args);
   }
 }

package/src/dataAccess/entityManager.ts

@@ -1,5 +1,6 @@
 import * as _ from "lodash";
 import {
+  AddEntityRelationsOptions,
   CountEntityOptions,
   CountEntityResult,
   CreateEntityOptions,
@@ -8,6 +9,7 @@ import {
   FindEntityOptions,
   FindEntityOrderByOptions,
   IRpdDataAccessor,
+  RemoveEntityRelationsOptions,
   RpdDataModel,
   RpdDataModelProperty,
   UpdateEntityByIdOptions,
@@ -16,7 +18,8 @@ import { isNullOrUndefined } from "~/utilities/typeUtility";
 import { mapDbRowToEntity, mapEntityToDbRow } from "./entityMapper";
 import { mapPropertyNameToColumnName } from "./propertyMapper";
 import { isRelationProperty } from "~/utilities/rapidUtility";
-import { IRpdServer } from "~/core/server";
+import { IRpdServer, RapidPlugin } from "~/core/server";
+import { getEntityPartChanges } from "~/helpers/entityHelpers";
 
 function convertToDataAccessOrderBy(model: RpdDataModel, orderByList?: FindEntityOrderByOptions[]) {
   if (!orderByList) {
@@ -533,9 +536,23 @@ async function updateEntityById(
   server: IRpdServer,
   dataAccessor: IRpdDataAccessor,
   options: UpdateEntityByIdOptions,
+  plugin: RapidPlugin
 ) {
   const model = dataAccessor.getModel();
-  const { id, entity, changes } = options;
+  const { id, entityToSave } = options;
+  if (!id) {
+    throw new Error("Id is required when updating an entity.")
+  }
+
+  const entity = await this.findById(id);
+  if (!entity) {
+    throw new Error(`${model.namespace}.${model.singularCode}  with id "${id}" was not found.`);
+  }
+
+  const changes = getEntityPartChanges(entity, entityToSave);
+  if (!changes) {
+    return entity;
+  }
 
   const oneRelationPropertiesToUpdate: RpdDataModelProperty[] = [];
   const manyRelationPropertiesToUpdate: RpdDataModelProperty[] = [];
@@ -648,6 +665,18 @@ async function updateEntityById(
     updatedEntity[property.code] = relatedEntities;
   }
 
+  
+  server.emitEvent(
+    "entity.update",
+    plugin,
+    {
+      namespace: model.namespace,
+      modelSingularCode: model.singularCode,
+      before: entity,
+      after: updatedEntity,
+      changes: changes,
+    },
+  );
   return updatedEntity;
 }
 
@@ -660,6 +689,10 @@ export default class EntityManager<TEntity=any> {
     this.#dataAccessor = dataAccessor;
   }
 
+  getModel(): RpdDataModel {
+    return this.#dataAccessor.getModel();
+  }
+
   async findEntities(options: FindEntityOptions): Promise<TEntity[]> {
     return await findEntities(this.#server, this.#dataAccessor, options);
   }
@@ -680,23 +713,133 @@ export default class EntityManager<TEntity=any> {
     });
   }
 
-  async createEntity(options: CreateEntityOptions): Promise<TEntity> {
-    return await createEntity(this.#server, this.#dataAccessor, options);
+  async createEntity(options: CreateEntityOptions, plugin: RapidPlugin): Promise<TEntity> {
+    const model = this.getModel();
+    const newEntity = await createEntity(this.#server, this.#dataAccessor, options);
+
+    this.#server.emitEvent(
+      "entity.create",
+      plugin,
+      {
+        namespace: model.namespace,
+        modelSingularCode: model.singularCode,
+        after: newEntity,
+      },
+    );
+
+    return newEntity;
   }
 
-  async updateEntityById(options: UpdateEntityByIdOptions): Promise<TEntity> {
-    return await updateEntityById(this.#server, this.#dataAccessor, options);
+  async updateEntityById(options: UpdateEntityByIdOptions, plugin: RapidPlugin): Promise<TEntity> {
+    return await updateEntityById(this.#server, this.#dataAccessor, options, plugin);
   }
 
   async count(options: CountEntityOptions): Promise<CountEntityResult> {
     return await this.#dataAccessor.count(options);
   }
 
-  async deleteById(id: any): Promise<void> {
-    return await this.#dataAccessor.deleteById(id);
+  async deleteById(id: any, plugin: RapidPlugin): Promise<void> {
+    const model = this.getModel();
+    const entity = await this.findById(id);
+    if (!entity) {
+      return;
+    }
+
+    await this.#dataAccessor.deleteById(id);
+    this.#server.emitEvent(
+      "entity.delete",
+      plugin,
+      {
+        namespace: model.namespace,
+        modelSingularCode: model.singularCode,
+        before: entity,
+      },
+    );
   }
 
-  getModel(): RpdDataModel {
-    return this.#dataAccessor.getModel();
+  async addRelations(options: AddEntityRelationsOptions, plugin: RapidPlugin): Promise<void> {
+    const model = this.getModel();
+    const {id, property, relations} = options;
+    const entity = await this.findById(id);
+    if (!entity) {
+      throw new Error(`${model.namespace}.${model.singularCode}  with id "${id}" was not found.`);
+    }
+
+    const relationProperty = model.properties.find(e => e.code === property);
+    if (!relationProperty) {
+      throw new Error(`Property '${property}' was not found in ${model.namespace}.${model.singularCode}`);
+    }
+
+    if (!(isRelationProperty(relationProperty) && relationProperty.relation === "many")) {
+      throw new Error(`Operation 'addRelations' is only supported on property of 'many' relation`);
+    }
+
+    const server = this.#server;
+    const { queryBuilder } = server;
+    if (relationProperty.linkTableName) {
+      for (const relation of relations) {
+        const command = `INSERT INTO ${queryBuilder.quoteTable({schema:relationProperty.linkSchema, tableName: relationProperty.linkTableName})} (${queryBuilder.quoteObject(relationProperty.selfIdColumnName!)}, ${queryBuilder.quoteObject(relationProperty.targetIdColumnName!)})
+    SELECT $1, $2 WHERE NOT EXISTS (
+      SELECT ${queryBuilder.quoteObject(relationProperty.selfIdColumnName!)}, ${queryBuilder.quoteObject(relationProperty.targetIdColumnName!)}
+        FROM ${queryBuilder.quoteTable({schema:relationProperty.linkSchema, tableName: relationProperty.linkTableName})}
+        WHERE ${queryBuilder.quoteObject(relationProperty.selfIdColumnName!)}=$1 AND ${queryBuilder.quoteObject(relationProperty.targetIdColumnName!)}=$2
+      )`;
+        const params = [id, relation.id];
+        await server.queryDatabaseObject(command, params);
+      }
+    }
+
+    server.emitEvent(
+      "entity.addRelations",
+      plugin,
+      {
+        namespace: model.namespace,
+        modelSingularCode: model.singularCode,
+        entity,
+        property,
+        relations,
+      },
+    );
+  }
+
+  async removeRelations(options: RemoveEntityRelationsOptions, plugin: RapidPlugin): Promise<void> {
+    const model = this.getModel();
+    const {id, property, relations} = options;
+    const entity = await this.findById(id);
+    if (!entity) {
+      throw new Error(`${model.namespace}.${model.singularCode}  with id "${id}" was not found.`);
+    }
+
+    const relationProperty = model.properties.find(e => e.code === property);
+    if (!relationProperty) {
+      throw new Error(`Property '${property}' was not found in ${model.namespace}.${model.singularCode}`);
+    }
+
+    if (!(isRelationProperty(relationProperty) && relationProperty.relation === "many")) {
+      throw new Error(`Operation 'removeRelations' is only supported on property of 'many' relation`);
+    }
+
+    const server = this.#server;
+    const { queryBuilder } = server;
+    if (relationProperty.linkTableName) {
+      for (const relation of relations) {
+        const command = `DELETE FROM ${queryBuilder.quoteTable({schema:relationProperty.linkSchema, tableName: relationProperty.linkTableName})}
+    WHERE ${queryBuilder.quoteObject(relationProperty.selfIdColumnName!)}=$1 AND ${queryBuilder.quoteObject(relationProperty.targetIdColumnName!)}=$2;`;
+        const params = [id, relation.id];
+        await server.queryDatabaseObject(command, params);
+      }
+    }
+
+    server.emitEvent(
+      "entity.removeRelations",
+      plugin,
+      {
+        namespace: model.namespace,
+        modelSingularCode: model.singularCode,
+        entity,
+        property,
+        relations,
+      },
+    );
   }
 }

package/src/index.ts

@@ -19,4 +19,8 @@ export { default as DataManagePlugin } from "./plugins/dataManage/DataManagePlug
 export { default as RouteManagePlugin } from "./plugins/routeManage/RouteManagePlugin";
 export { default as WebhooksPlugin } from "./plugins/webhooks/WebhooksPlugin";
 export { default as AuthPlugin } from "./plugins/auth/AuthPlugin";
-export { default as FileManagePlugin } from "./plugins/fileManage/FileManagePlugin";
+export { default as FileManagePlugin } from "./plugins/fileManage/FileManagePlugin";
+export { default as ServerOperationPlugin } from "./plugins/serverOperation/ServerOperationPlugin";
+export * from "./plugins/serverOperation/ServerOperationPluginTypes";
+export { default as EntityWatchPlugin } from "./plugins/entityWatch/EntityWatchPlugin";
+export * from "./plugins/entityWatch/EntityWatchPluginTypes";

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

@@ -1,24 +1,16 @@
 import { RunEntityActionHandlerOptions } from "~/types";
 import { mergeInput } from "~/helpers/inputHelper";
-import { isRelationProperty } from "~/utilities/rapidUtility";
 import { ActionHandlerContext } from "~/core/actionHandler";
 import { RapidPlugin } from "~/core/server";
 
 export const code = "addEntityRelations";
 
-interface AddEntityRelationsInput {
-  id: number;
-  property: string;
-  relations: {id?: number, [k: string]: any}[];
-}
-
 export async function handler(
   plugin: RapidPlugin,
   ctx: ActionHandlerContext,
   options: RunEntityActionHandlerOptions,
 ) {
   const { server, input } = ctx;
-  const { queryBuilder } = server;
   const { defaultInput, fixedInput } = options;
 
   console.debug(`Running ${code} handler...`);
@@ -28,48 +20,8 @@ export async function handler(
   console.debug(`fixedInput: ${JSON.stringify(fixedInput)}`);
   console.debug(`mergedInput: ${JSON.stringify(mergedInput)}`);
 
-  const dataAccessor = server.getDataAccessor(options);
-  const model = dataAccessor.getModel();
-
-  const {id, property, relations} = mergedInput as AddEntityRelationsInput;
-  const row = await dataAccessor.findById(id);
-  if (!row) {
-    throw new Error(`${options.namespace}.${options.singularCode}  with id "${id}" was not found.`);
-  }
-
-  const relationProperty = model.properties.find(e => e.code === property);
-  if (!relationProperty) {
-    throw new Error(`Property '${property}' was not found in ${options.namespace}.${options.singularCode}`);
-  }
-
-  if (!(isRelationProperty(relationProperty) && relationProperty.relation === "many")) {
-    throw new Error(`Operation 'createEntityRelations' is only supported on property of 'many' relation`);
-  }
-
-  if (relationProperty.linkTableName) {
-    for (const relation of relations) {
-      const command = `INSERT INTO ${queryBuilder.quoteTable({schema:relationProperty.linkSchema, tableName: relationProperty.linkTableName})} (${queryBuilder.quoteObject(relationProperty.selfIdColumnName!)}, ${queryBuilder.quoteObject(relationProperty.targetIdColumnName!)})
-  SELECT $1, $2 WHERE NOT EXISTS (
-    SELECT ${queryBuilder.quoteObject(relationProperty.selfIdColumnName!)}, ${queryBuilder.quoteObject(relationProperty.targetIdColumnName!)}
-      FROM ${queryBuilder.quoteTable({schema:relationProperty.linkSchema, tableName: relationProperty.linkTableName})}
-      WHERE ${queryBuilder.quoteObject(relationProperty.selfIdColumnName!)}=$1 AND ${queryBuilder.quoteObject(relationProperty.targetIdColumnName!)}=$2
-    )`;
-      const params = [id, relation.id];
-      await server.queryDatabaseObject(command, params);
-    }
-  }
+  const entityManager = server.getEntityManager(options.singularCode);
+  await entityManager.addRelations(mergedInput, plugin);
 
   ctx.output = {};
-
-  server.emitEvent(
-    "entity.addRelations",
-    plugin,
-    {
-      namespace: options.namespace,
-      modelSingularCode: options.singularCode,
-      entity: row,
-      property,
-      relations: relations,
-    },
-  );
 }

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

@@ -37,21 +37,10 @@ export async function handler(
     const entityManager = server.getEntityManager(options.singularCode);
     const newEntity = await entityManager.createEntity({
       entity: mergedEntity,
-    });
-
-    server.emitEvent(
-      "entity.create",
-      plugin,
-      {
-        namespace: options.namespace,
-        modelSingularCode: options.singularCode,
-        after: newEntity,
-      },
-    );
+    }, plugin);
 
     output.push(newEntity);
   }
 
   ctx.output = output;
-
 }

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

@@ -28,16 +28,6 @@ export async function handler(
   const entityManager = server.getEntityManager(options.singularCode);
   const output = await entityManager.createEntity({
     entity: input,
-  });
+  }, plugin);
   ctx.output = output;
-
-  server.emitEvent(
-    "entity.create",
-    plugin,
-    {
-      namespace: options.namespace,
-      modelSingularCode: options.singularCode,
-      after: output,
-    },
-  );
 }

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

@@ -14,26 +14,7 @@ export async function handler(
   const { server, input } = ctx;
 
   const entityManager = server.getEntityManager(options.singularCode);
-  const id = input.id;
-  const row = await entityManager.findById(id);
-  if (!row) {
-    ctx.status = 200;
-    return;
-  }
-
-  await entityManager.deleteById(id);
-
-  const entity = mapDbRowToEntity(entityManager.getModel(), row);
-
-  server.emitEvent(
-    "entity.delete",
-    plugin,
-    {
-      namespace: options.namespace,
-      modelSingularCode: options.singularCode,
-      before: entity,
-    },
-  );
+  await entityManager.deleteById(input.id, plugin);
 
   ctx.status = 200;
 }

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

@@ -1,24 +1,16 @@
 import { RunEntityActionHandlerOptions } from "~/types";
 import { mergeInput } from "~/helpers/inputHelper";
-import { isRelationProperty } from "~/utilities/rapidUtility";
 import { ActionHandlerContext } from "~/core/actionHandler";
 import { RapidPlugin } from "~/core/server";
 
 export const code = "removeEntityRelations";
 
-interface RemoveEntityRelationsInput {
-  id: number;
-  property: string;
-  relations: {id?: number, [k: string]: any}[];
-}
-
 export async function handler(
   plugin: RapidPlugin,
   ctx: ActionHandlerContext,
   options: RunEntityActionHandlerOptions,
 ) {
   const { server, input } = ctx;
-  const { queryBuilder } = server;
   const { defaultInput, fixedInput } = options;
 
   console.debug(`Running ${code} handler...`);
@@ -28,46 +20,8 @@ export async function handler(
   console.debug(`fixedInput: ${JSON.stringify(fixedInput)}`);
   console.debug(`mergedInput: ${JSON.stringify(mergedInput)}`);
 
-  const dataAccessor = server.getDataAccessor(options);
-  const model = dataAccessor.getModel();
-
-  const {id, property, relations} = mergedInput as RemoveEntityRelationsInput;
-  const row = await dataAccessor.findById(id);
-  if (!row) {
-    throw new Error(`${options.namespace}.${options.singularCode}  with id "${id}" was not found.`);
-  }
-
-  console.log(mergedInput);
-
-  const relationProperty = model.properties.find(e => e.code === property);
-  if (!relationProperty) {
-    throw new Error(`Property '${property}' was not found in ${options.namespace}.${options.singularCode}`);
-  }
-
-  if (!(isRelationProperty(relationProperty) && relationProperty.relation === "many")) {
-    throw new Error(`Operation 'createEntityRelations' is only supported on property of 'many' relation`);
-  }
-
-  if (relationProperty.linkTableName) {
-    for (const relation of relations) {
-      const command = `DELETE FROM ${queryBuilder.quoteTable({schema:relationProperty.linkSchema, tableName: relationProperty.linkTableName})}
-  WHERE ${queryBuilder.quoteObject(relationProperty.selfIdColumnName!)}=$1 AND ${queryBuilder.quoteObject(relationProperty.targetIdColumnName!)}=$2;`;
-      const params = [id, relation.id];
-      await server.queryDatabaseObject(command, params);
-    }
-  }
+  const entityManager = server.getEntityManager(options.singularCode);
+  await entityManager.removeRelations(mergedInput, plugin);
 
   ctx.output = {};
-
-  server.emitEvent(
-    "entity.removeRelations",
-    plugin,
-    {
-      namespace: options.namespace,
-      modelSingularCode: options.singularCode,
-      entity: row,
-      property,
-      relations: relations,
-    },
-  );
 }

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

@@ -23,31 +23,7 @@ export async function handler(
   console.debug(`mergedInput: ${JSON.stringify(mergedInput)}`);
 
   const entityManager = server.getEntityManager(options.singularCode);
-  const id = mergedInput.id;
-  const row = await entityManager.findById(id);
-  if (!row) {
-    throw new Error(`${options.namespace}.${options.singularCode}  with id "${id}" was not found.`);
-  }
 
-  const entity = mapDbRowToEntity(entityManager.getModel(), row);
-  const changes = getEntityPartChanges(entity, mergedInput);
-  if (!changes) {
-    ctx.output = entity;
-    return;
-  }
-
-  const output = await entityManager.updateEntityById({ id, entity, changes });
+  const output = await entityManager.updateEntityById({ id: mergedInput.id, entityToSave: mergedInput }, plugin);
   ctx.output = output;
-
-  server.emitEvent(
-    "entity.update",
-    plugin,
-    {
-      namespace: options.namespace,
-      modelSingularCode: options.singularCode,
-      before: entity,
-      after: output,
-      changes: changes,
-    },
-  );
 }