@ruiapp/rapid-core 0.1.49 → 0.1.51

package/dist/core/server.d.ts

@@ -1,4 +1,4 @@
-import { CreateEntityOptions, GetDataAccessorOptions, GetModelOptions, IDatabaseConfig, IQueryBuilder, IRpdDataAccessor, RapidServerConfig, RpdApplicationConfig, RpdDataModel, RpdDataModelProperty, RpdServerEventTypes, UpdateEntityByIdOptions } from "../types";
+import { CreateEntityOptions, 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";
@@ -24,7 +24,8 @@ export interface IRpdServer {
     appendApplicationConfig(config: Partial<RpdApplicationConfig>): any;
     appendModelProperties(modelSingularCode: string, properties: RpdDataModelProperty[]): any;
     getModel(options: GetModelOptions): RpdDataModel | undefined;
-    registerEventHandler<K extends keyof RpdServerEventTypes>(eventName: K, listener: (...args: RpdServerEventTypes[K]) => void): this;
+    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;
     handleRequest(request: Request, next: Next): Promise<Response>;
     beforeRunRouteActions(handlerContext: ActionHandlerContext): Promise<void>;

package/dist/index.d.ts

@@ -21,6 +21,4 @@ export { default as CronJobPlugin } from "./plugins/cronJob/CronJobPlugin";
 export * from "./plugins/cronJob/CronJobPluginTypes";
 export { default as StateMachinePlugin } from "./plugins/stateMachine/StateMachinePlugin";
 export * from "./plugins/stateMachine/StateMachinePluginTypes";
-export { default as EntityWatchPlugin } from "./plugins/entityWatch/EntityWatchPlugin";
-export * from "./plugins/entityWatch/EntityWatchPluginTypes";
 export { default as EntityAccessControlPlugin } from "./plugins/entityAccessControl/EntityAccessControlPlugin";

package/dist/index.js

@@ -2859,6 +2859,16 @@ class RapidServer {
     #actionHandlersMapByCode;
     #databaseAccessor;
     #cachedDataAccessors;
+    #entityBeforeCreateEventEmitters;
+    #entityCreateEventEmitters;
+    #entityBeforeUpdateEventEmitters;
+    #entityUpdateEventEmitters;
+    #entityBeforeDeleteEventEmitters;
+    #entityDeleteEventEmitters;
+    #entityAddRelationsEventEmitters;
+    #entityRemoveRelationsEventEmitters;
+    #entityWatchers;
+    #appEntityWatchers;
     #cachedEntityManager;
     #services;
     queryBuilder;
@@ -2882,6 +2892,24 @@ class RapidServer {
         this.#databaseAccessor = options.databaseAccessor;
         this.#cachedDataAccessors = new Map();
         this.#cachedEntityManager = new Map();
+        this.#entityBeforeCreateEventEmitters = new EventManager();
+        this.#entityCreateEventEmitters = new EventManager();
+        this.#entityBeforeUpdateEventEmitters = new EventManager();
+        this.#entityUpdateEventEmitters = new EventManager();
+        this.#entityBeforeDeleteEventEmitters = new EventManager();
+        this.#entityDeleteEventEmitters = new EventManager();
+        this.#entityAddRelationsEventEmitters = new EventManager();
+        this.#entityRemoveRelationsEventEmitters = new EventManager();
+        this.registerEventHandler("entity.beforeCreate", this.#handleEntityEvent.bind(this, "entity.beforeCreate"));
+        this.registerEventHandler("entity.create", this.#handleEntityEvent.bind(this, "entity.create"));
+        this.registerEventHandler("entity.beforeUpdate", this.#handleEntityEvent.bind(this, "entity.beforeUpdate"));
+        this.registerEventHandler("entity.update", this.#handleEntityEvent.bind(this, "entity.update"));
+        this.registerEventHandler("entity.beforeDelete", this.#handleEntityEvent.bind(this, "entity.beforeDelete"));
+        this.registerEventHandler("entity.delete", this.#handleEntityEvent.bind(this, "entity.delete"));
+        this.registerEventHandler("entity.addRelations", this.#handleEntityEvent.bind(this, "entity.addRelations"));
+        this.registerEventHandler("entity.removeRelations", this.#handleEntityEvent.bind(this, "entity.removeRelations"));
+        this.#entityWatchers = [];
+        this.#appEntityWatchers = options.entityWatchers || [];
         this.#services = new Map();
         this.queryBuilder = new QueryBuilder({
             dbDefaultSchema: options.databaseConfig.dbDefaultSchema,
@@ -2994,7 +3022,9 @@ class RapidServer {
     }
     registerEventHandler(eventName, listener) {
         this.#eventManager.on(eventName, listener);
-        return this;
+    }
+    registerEntityWatcher(entityWatcher) {
+        this.#entityWatchers.push(entityWatcher);
     }
     async emitEvent(eventName, payload, sender) {
         this.#logger.debug(`Emitting '${eventName}' event.`, { eventName, payload });
@@ -3024,6 +3054,33 @@ class RapidServer {
         await pluginManager.registerEventHandlers();
         await pluginManager.registerMessageHandlers();
         await pluginManager.registerTaskProcessors();
+        this.#entityWatchers = this.#entityWatchers.concat(this.#appEntityWatchers);
+        for (const entityWatcher of this.#entityWatchers) {
+            if (entityWatcher.eventName === "entity.beforeCreate") {
+                this.#entityBeforeCreateEventEmitters.on(entityWatcher.modelSingularCode, entityWatcher.handler);
+            }
+            else if (entityWatcher.eventName === "entity.create") {
+                this.#entityCreateEventEmitters.on(entityWatcher.modelSingularCode, entityWatcher.handler);
+            }
+            else if (entityWatcher.eventName === "entity.beforeUpdate") {
+                this.#entityBeforeUpdateEventEmitters.on(entityWatcher.modelSingularCode, entityWatcher.handler);
+            }
+            else if (entityWatcher.eventName === "entity.update") {
+                this.#entityUpdateEventEmitters.on(entityWatcher.modelSingularCode, entityWatcher.handler);
+            }
+            else if (entityWatcher.eventName === "entity.beforeDelete") {
+                this.#entityBeforeDeleteEventEmitters.on(entityWatcher.modelSingularCode, entityWatcher.handler);
+            }
+            else if (entityWatcher.eventName === "entity.delete") {
+                this.#entityDeleteEventEmitters.on(entityWatcher.modelSingularCode, entityWatcher.handler);
+            }
+            else if (entityWatcher.eventName === "entity.addRelations") {
+                this.#entityAddRelationsEventEmitters.on(entityWatcher.modelSingularCode, entityWatcher.handler);
+            }
+            else if (entityWatcher.eventName === "entity.removeRelations") {
+                this.#entityRemoveRelationsEventEmitters.on(entityWatcher.modelSingularCode, entityWatcher.handler);
+            }
+        }
         await this.configureApplication();
         this.#logger.info(`Rapid server ready.`);
         await pluginManager.onApplicationReady(this.#applicationConfig);
@@ -3103,6 +3160,42 @@ class RapidServer {
     async beforeUpdateEntity(model, options, currentEntity) {
         await this.#pluginManager.beforeUpdateEntity(model, options, currentEntity);
     }
+    #handleEntityEvent(eventName, sender, payload) {
+        const { modelSingularCode, baseModelSingularCode } = payload;
+        const entityWatchHandlerContext = {
+            server: this,
+            payload,
+        };
+        let emitter;
+        if (eventName === "entity.beforeCreate") {
+            emitter = this.#entityBeforeCreateEventEmitters;
+        }
+        else if (eventName === "entity.create") {
+            emitter = this.#entityCreateEventEmitters;
+        }
+        else if (eventName === "entity.beforeUpdate") {
+            emitter = this.#entityBeforeUpdateEventEmitters;
+        }
+        else if (eventName === "entity.update") {
+            emitter = this.#entityUpdateEventEmitters;
+        }
+        else if (eventName === "entity.beforeDelete") {
+            emitter = this.#entityBeforeDeleteEventEmitters;
+        }
+        else if (eventName === "entity.delete") {
+            emitter = this.#entityDeleteEventEmitters;
+        }
+        else if (eventName === "entity.addRelations") {
+            emitter = this.#entityAddRelationsEventEmitters;
+        }
+        else if (eventName === "entity.removeRelations") {
+            emitter = this.#entityRemoveRelationsEventEmitters;
+        }
+        emitter.emit(modelSingularCode, entityWatchHandlerContext);
+        if (baseModelSingularCode) {
+            emitter.emit(baseModelSingularCode, entityWatchHandlerContext);
+        }
+    }
 }
 
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
@@ -5672,91 +5765,6 @@ function getStateMachineCode(model, property) {
     }
 }
 
-class EntityWatchPlugin {
-    #createEventEmitters;
-    #updateEventEmitters;
-    #deleteEventEmitters;
-    #addRelationsEventEmitters;
-    #removeRelationsEventEmitters;
-    constructor(options) {
-        const { watchers } = options;
-        this.#createEventEmitters = new EventManager();
-        this.#updateEventEmitters = new EventManager();
-        this.#deleteEventEmitters = new EventManager();
-        this.#addRelationsEventEmitters = new EventManager();
-        this.#removeRelationsEventEmitters = new EventManager();
-        for (const watcher of watchers) {
-            if (watcher.eventName === "entity.create") {
-                this.#createEventEmitters.on(watcher.modelSingularCode, watcher.handler);
-            }
-            else if (watcher.eventName === "entity.update") {
-                this.#updateEventEmitters.on(watcher.modelSingularCode, watcher.handler);
-            }
-            else if (watcher.eventName === "entity.delete") {
-                this.#deleteEventEmitters.on(watcher.modelSingularCode, watcher.handler);
-            }
-            else if (watcher.eventName === "entity.addRelations") {
-                this.#addRelationsEventEmitters.on(watcher.modelSingularCode, watcher.handler);
-            }
-            else if (watcher.eventName === "entity.removeRelations") {
-                this.#removeRelationsEventEmitters.on(watcher.modelSingularCode, watcher.handler);
-            }
-        }
-    }
-    get code() {
-        return "entityWatch";
-    }
-    get description() {
-        return "";
-    }
-    get extendingAbilities() {
-        return [];
-    }
-    get configurableTargets() {
-        return [];
-    }
-    get configurations() {
-        return [];
-    }
-    async registerEventHandlers(server) {
-        server.registerEventHandler("entity.create", this.handleEntityEvent.bind(this, server, "entity.create"));
-        server.registerEventHandler("entity.update", this.handleEntityEvent.bind(this, server, "entity.update"));
-        server.registerEventHandler("entity.delete", this.handleEntityEvent.bind(this, server, "entity.delete"));
-        server.registerEventHandler("entity.addRelations", this.handleEntityEvent.bind(this, server, "entity.addRelations"));
-        server.registerEventHandler("entity.removeRelations", this.handleEntityEvent.bind(this, server, "entity.removeRelations"));
-    }
-    handleEntityEvent(server, eventName, sender, payload) {
-        if (sender === this) {
-            return;
-        }
-        const { modelSingularCode, baseModelSingularCode } = payload;
-        const entityWatchHandlerContext = {
-            server,
-            payload,
-        };
-        let emitter;
-        if (eventName === "entity.create") {
-            emitter = this.#createEventEmitters;
-        }
-        else if (eventName === "entity.update") {
-            emitter = this.#updateEventEmitters;
-        }
-        else if (eventName === "entity.delete") {
-            emitter = this.#deleteEventEmitters;
-        }
-        else if (eventName === "entity.addRelations") {
-            emitter = this.#addRelationsEventEmitters;
-        }
-        else if (eventName === "entity.removeRelations") {
-            emitter = this.#removeRelationsEventEmitters;
-        }
-        emitter.emit(modelSingularCode, entityWatchHandlerContext);
-        if (baseModelSingularCode) {
-            emitter.emit(baseModelSingularCode, entityWatchHandlerContext);
-        }
-    }
-}
-
 function isAccessAllowed(policy, allowedActions) {
     let isAnyCheckPassed = true;
     let isAllCheckPassed = true;
@@ -5867,7 +5875,6 @@ exports.AuthPlugin = AuthPlugin;
 exports.CronJobPlugin = CronJobPlugin;
 exports.DataManagePlugin = DataManager;
 exports.EntityAccessControlPlugin = EntityAccessControlPlugin;
-exports.EntityWatchPlugin = EntityWatchPlugin;
 exports.FileManagePlugin = FileManager;
 exports.GlobalRequest = GlobalRequest;
 exports.MetaManagePlugin = MetaManager;

package/dist/server.d.ts

@@ -1,4 +1,4 @@
-import { GetDataAccessorOptions, GetModelOptions, IDatabaseAccessor, IDatabaseConfig, IQueryBuilder, IRpdDataAccessor, RpdApplicationConfig, RpdDataModel, RpdServerEventTypes, RapidServerConfig, RpdDataModelProperty, CreateEntityOptions, UpdateEntityByIdOptions } from "./types";
+import { GetDataAccessorOptions, GetModelOptions, IDatabaseAccessor, IDatabaseConfig, IQueryBuilder, IRpdDataAccessor, RpdApplicationConfig, RpdDataModel, RpdServerEventTypes, RapidServerConfig, RpdDataModelProperty, CreateEntityOptions, UpdateEntityByIdOptions, EntityWatcherType } from "./types";
 import { ActionHandler, ActionHandlerContext, IPluginActionHandler } from "./core/actionHandler";
 import { IRpdServer, RapidPlugin } from "./core/server";
 import { Next } from "./core/routeContext";
@@ -13,6 +13,7 @@ export interface InitServerOptions {
     applicationConfig?: RpdApplicationConfig;
     facilityFactories?: FacilityFactory[];
     plugins?: RapidPlugin[];
+    entityWatchers?: EntityWatcherType[];
 }
 export declare class RapidServer implements IRpdServer {
     #private;
@@ -30,7 +31,8 @@ export declare class RapidServer implements IRpdServer {
     getDataAccessor<T = any>(options: GetDataAccessorOptions): IRpdDataAccessor<T>;
     getModel(options: GetModelOptions): RpdDataModel | undefined;
     getEntityManager<TEntity = any>(singularCode: string): EntityManager<TEntity>;
-    registerEventHandler<K extends keyof RpdServerEventTypes>(eventName: K, listener: (...args: RpdServerEventTypes[K]) => void): this;
+    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>;
     registerService(name: string, service: any): void;
     getService<TService>(name: string): TService;

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import { RapidPlugin } from "./core/server";
+import { IRpdServer, RapidPlugin } from "./core/server";
 import { CountRowOptions, FindRowOptions } from "./dataAccess/dataAccessTypes";
 export type RapidServerConfig = {
     baseUrl?: string;
@@ -405,3 +405,17 @@ export interface RemoveEntityRelationsOptions {
         [k: string]: any;
     }[];
 }
+export type EntityWatcherType = EntityWatcher<"entity.create"> | EntityWatcher<"entity.update"> | EntityWatcher<"entity.delete"> | EntityWatcher<"entity.addRelations"> | EntityWatcher<"entity.removeRelations"> | EntityWatcher<any>;
+export interface EntityWatcher<TEventName extends keyof RpdServerEventTypes = any> {
+    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: EntityWatcherType[];
+}

package/package.json

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

package/src/core/server.ts

@@ -1,4 +1,4 @@
-import { CreateEntityOptions, GetDataAccessorOptions, GetModelOptions, IDatabaseConfig, IQueryBuilder, IRpdDataAccessor, RapidServerConfig, RpdApplicationConfig, RpdDataModel, RpdDataModelProperty, RpdServerEventTypes, UpdateEntityByIdOptions } from "~/types";
+import { CreateEntityOptions, 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";
@@ -28,7 +28,8 @@ export interface IRpdServer {
   appendApplicationConfig(config: Partial<RpdApplicationConfig>);
   appendModelProperties(modelSingularCode: string, properties: RpdDataModelProperty[]);
   getModel(options: GetModelOptions): RpdDataModel | undefined;
-  registerEventHandler<K extends keyof RpdServerEventTypes>(eventName: K, listener: (...args: RpdServerEventTypes[K]) => void): this;
+  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;
   handleRequest(request: Request, next: Next): Promise<Response>;
   beforeRunRouteActions(handlerContext: ActionHandlerContext): Promise<void>;

package/src/index.ts

@@ -38,7 +38,4 @@ export * from "./plugins/cronJob/CronJobPluginTypes";
 export { default as StateMachinePlugin } from "./plugins/stateMachine/StateMachinePlugin";
 export * from "./plugins/stateMachine/StateMachinePluginTypes";
 
-export { default as EntityWatchPlugin } from "./plugins/entityWatch/EntityWatchPlugin";
-export * from "./plugins/entityWatch/EntityWatchPluginTypes";
-
 export { default as EntityAccessControlPlugin } from "./plugins/entityAccessControl/EntityAccessControlPlugin";

package/src/server.ts

@@ -1,5 +1,5 @@
 import DataAccessor from "./dataAccess/dataAccessor";
-import { GetDataAccessorOptions, GetModelOptions, IDatabaseAccessor, IDatabaseConfig, IQueryBuilder, IRpdDataAccessor, RpdApplicationConfig, RpdDataModel, RpdServerEventTypes, RapidServerConfig, RpdDataModelProperty, CreateEntityOptions, UpdateEntityByIdOptions } from "./types";
+import { GetDataAccessorOptions, GetModelOptions, IDatabaseAccessor, IDatabaseConfig, IQueryBuilder, IRpdDataAccessor, RpdApplicationConfig, RpdDataModel, RpdServerEventTypes, RapidServerConfig, RpdDataModelProperty, CreateEntityOptions, UpdateEntityByIdOptions, EntityWatchHandlerContext, EntityWatcherType, RpdEntityCreateEventPayload } from "./types";
 
 import QueryBuilder from "./queryBuilder/queryBuilder";
 import PluginManager from "./core/pluginManager";
@@ -23,6 +23,7 @@ export interface InitServerOptions {
   applicationConfig?: RpdApplicationConfig;
   facilityFactories?: FacilityFactory[];
   plugins?: RapidPlugin[];
+  entityWatchers?: EntityWatcherType[];
 }
 
 export class RapidServer implements IRpdServer {
@@ -37,6 +38,18 @@ export class RapidServer implements IRpdServer {
   #actionHandlersMapByCode: Map<string, ActionHandler>;
   #databaseAccessor: IDatabaseAccessor;
   #cachedDataAccessors: Map<string, DataAccessor>;
+
+  #entityBeforeCreateEventEmitters: EventManager<Record<string, [EntityWatchHandlerContext<any>]>>;
+  #entityCreateEventEmitters: EventManager<Record<string, [EntityWatchHandlerContext<any>]>>;
+  #entityBeforeUpdateEventEmitters: EventManager<Record<string, [EntityWatchHandlerContext<any>]>>;
+  #entityUpdateEventEmitters: EventManager<Record<string, [EntityWatchHandlerContext<any>]>>;
+  #entityBeforeDeleteEventEmitters: EventManager<Record<string, [EntityWatchHandlerContext<any>]>>;
+  #entityDeleteEventEmitters: EventManager<Record<string, [EntityWatchHandlerContext<any>]>>;
+  #entityAddRelationsEventEmitters: EventManager<Record<string, [EntityWatchHandlerContext<any>]>>;
+  #entityRemoveRelationsEventEmitters: EventManager<Record<string, [EntityWatchHandlerContext<any>]>>;
+  #entityWatchers: EntityWatcherType[];
+  #appEntityWatchers: EntityWatcherType[];
+
   #cachedEntityManager: Map<string, EntityManager>;
   #services: Map<string, any>;
   queryBuilder: IQueryBuilder;
@@ -44,6 +57,7 @@ export class RapidServer implements IRpdServer {
   databaseConfig: IDatabaseConfig;
   #buildedRoutes: (ctx: any, next: any) => any;
 
+
   constructor(options: InitServerOptions) {
     this.#logger = options.logger;
 
@@ -65,6 +79,27 @@ export class RapidServer implements IRpdServer {
     this.#cachedDataAccessors = new Map();
     this.#cachedEntityManager = new Map();
 
+    this.#entityBeforeCreateEventEmitters = new EventManager();
+    this.#entityCreateEventEmitters = new EventManager();
+    this.#entityBeforeUpdateEventEmitters = new EventManager();
+    this.#entityUpdateEventEmitters = new EventManager();
+    this.#entityBeforeDeleteEventEmitters = new EventManager();
+    this.#entityDeleteEventEmitters = new EventManager();
+    this.#entityAddRelationsEventEmitters = new EventManager();
+    this.#entityRemoveRelationsEventEmitters = new EventManager();
+
+    this.registerEventHandler("entity.beforeCreate", this.#handleEntityEvent.bind(this, "entity.beforeCreate"));
+    this.registerEventHandler("entity.create", this.#handleEntityEvent.bind(this, "entity.create"));
+    this.registerEventHandler("entity.beforeUpdate", this.#handleEntityEvent.bind(this, "entity.beforeUpdate"));
+    this.registerEventHandler("entity.update", this.#handleEntityEvent.bind(this, "entity.update"));
+    this.registerEventHandler("entity.beforeDelete", this.#handleEntityEvent.bind(this, "entity.beforeDelete"));
+    this.registerEventHandler("entity.delete", this.#handleEntityEvent.bind(this, "entity.delete"));
+    this.registerEventHandler("entity.addRelations", this.#handleEntityEvent.bind(this, "entity.addRelations"));
+    this.registerEventHandler("entity.removeRelations", this.#handleEntityEvent.bind(this, "entity.removeRelations"));
+
+    this.#entityWatchers = [];
+    this.#appEntityWatchers = options.entityWatchers || [];
+
     this.#services = new Map();
 
     this.queryBuilder = new QueryBuilder({
@@ -191,9 +226,12 @@ export class RapidServer implements IRpdServer {
     return entityManager;
   }
 
-  registerEventHandler<K extends keyof RpdServerEventTypes>(eventName: K, listener: (...args: RpdServerEventTypes[K]) => void): this {
+  registerEventHandler<K extends keyof RpdServerEventTypes>(eventName: K, listener: (...args: RpdServerEventTypes[K]) => void) {
     this.#eventManager.on(eventName, listener);
-    return this;
+  }
+
+  registerEntityWatcher(entityWatcher: EntityWatcherType) {
+    this.#entityWatchers.push(entityWatcher);
   }
 
   async emitEvent<K extends keyof RpdServerEventTypes>(eventName: K, payload: RpdServerEventTypes[K][1], sender?: RapidPlugin) {
@@ -231,6 +269,27 @@ export class RapidServer implements IRpdServer {
     await pluginManager.registerMessageHandlers();
     await pluginManager.registerTaskProcessors();
 
+    this.#entityWatchers = this.#entityWatchers.concat(this.#appEntityWatchers);
+    for (const entityWatcher of this.#entityWatchers) {
+      if (entityWatcher.eventName === "entity.beforeCreate") {
+        this.#entityBeforeCreateEventEmitters.on(entityWatcher.modelSingularCode, entityWatcher.handler);
+      } else if (entityWatcher.eventName === "entity.create") {
+        this.#entityCreateEventEmitters.on(entityWatcher.modelSingularCode, entityWatcher.handler);
+      } else if (entityWatcher.eventName === "entity.beforeUpdate") {
+        this.#entityBeforeUpdateEventEmitters.on(entityWatcher.modelSingularCode, entityWatcher.handler);
+      } else if (entityWatcher.eventName === "entity.update") {
+        this.#entityUpdateEventEmitters.on(entityWatcher.modelSingularCode, entityWatcher.handler);
+      } else if (entityWatcher.eventName === "entity.beforeDelete") {
+        this.#entityBeforeDeleteEventEmitters.on(entityWatcher.modelSingularCode, entityWatcher.handler);
+      } else if (entityWatcher.eventName === "entity.delete") {
+        this.#entityDeleteEventEmitters.on(entityWatcher.modelSingularCode, entityWatcher.handler);
+      } else if (entityWatcher.eventName === "entity.addRelations") {
+        this.#entityAddRelationsEventEmitters.on(entityWatcher.modelSingularCode, entityWatcher.handler);
+      } else if (entityWatcher.eventName === "entity.removeRelations") {
+        this.#entityRemoveRelationsEventEmitters.on(entityWatcher.modelSingularCode, entityWatcher.handler);
+      }
+    }
+
     await this.configureApplication();
 
     this.#logger.info(`Rapid server ready.`);
@@ -327,4 +386,36 @@ export class RapidServer implements IRpdServer {
   async beforeUpdateEntity(model: RpdDataModel, options: UpdateEntityByIdOptions, currentEntity: any) {
     await this.#pluginManager.beforeUpdateEntity(model, options, currentEntity);
   }
+
+  #handleEntityEvent(eventName: keyof RpdServerEventTypes, sender: RapidPlugin, payload: RpdEntityCreateEventPayload) {
+    const { modelSingularCode, baseModelSingularCode } = payload;
+    const entityWatchHandlerContext: EntityWatchHandlerContext<typeof eventName> = {
+      server: this,
+      payload,
+    };
+
+    let emitter: EventManager<Record<string, [EntityWatchHandlerContext<any>]>>;
+    if (eventName === "entity.beforeCreate") {
+      emitter = this.#entityBeforeCreateEventEmitters;
+    } else if (eventName === "entity.create") {
+      emitter = this.#entityCreateEventEmitters;
+    } else if (eventName === "entity.beforeUpdate") {
+      emitter = this.#entityBeforeUpdateEventEmitters;
+    } else if (eventName === "entity.update") {
+      emitter = this.#entityUpdateEventEmitters;
+    } else if (eventName === "entity.beforeDelete") {
+      emitter = this.#entityBeforeDeleteEventEmitters;
+    } else if (eventName === "entity.delete") {
+      emitter = this.#entityDeleteEventEmitters;
+    } else if (eventName === "entity.addRelations") {
+      emitter = this.#entityAddRelationsEventEmitters;
+    } else if (eventName === "entity.removeRelations") {
+      emitter = this.#entityRemoveRelationsEventEmitters;
+    }
+
+    emitter.emit(modelSingularCode, entityWatchHandlerContext);
+    if (baseModelSingularCode) {
+      emitter.emit(baseModelSingularCode, entityWatchHandlerContext);
+    }
+  }
 }

package/src/types.ts

@@ -1,4 +1,4 @@
-import { RapidPlugin } from "./core/server";
+import { IRpdServer, RapidPlugin } from "./core/server";
 import { CountRowOptions, FindRowOptions } from "./dataAccess/dataAccessTypes";
 
 export type RapidServerConfig = {
@@ -467,3 +467,23 @@ export interface RemoveEntityRelationsOptions {
   property: string;
   relations: { id?: number; [k: string]: any }[];
 }
+
+
+export type EntityWatcherType = EntityWatcher<"entity.create"> | EntityWatcher<"entity.update"> | EntityWatcher<"entity.delete"> | EntityWatcher<"entity.addRelations"> | EntityWatcher<"entity.removeRelations"> | EntityWatcher<any>;
+
+export interface EntityWatcher<TEventName extends keyof RpdServerEventTypes = any> {
+  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: EntityWatcherType[];
+}

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

@@ -1,15 +0,0 @@
-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

@@ -1,16 +0,0 @@
-import { IRpdServer } from "../../core/server";
-import { RpdServerEventTypes } from "../../types";
-export type EntityWatcherType = EntityWatcher<"entity.create"> | EntityWatcher<"entity.update"> | EntityWatcher<"entity.delete"> | EntityWatcher<"entity.addRelations"> | EntityWatcher<"entity.removeRelations"> | EntityWatcher<any>;
-export interface EntityWatcher<TEventName extends keyof RpdServerEventTypes = any> {
-    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: EntityWatcherType[];
-}

package/src/plugins/entityWatch/EntityWatchPlugin.ts

@@ -1,96 +0,0 @@
-import type { RpdEntityCreateEventPayload, RpdServerEventTypes } from "~/types";
-import { IRpdServer, RapidPlugin, RpdConfigurationItemOptions, RpdServerPluginConfigurableTargetOptions, RpdServerPluginExtendingAbilities } from "~/core/server";
-import { EntityWatchHandlerContext, EntityWatchPluginInitOptions } from "./EntityWatchPluginTypes";
-import EventManager from "~/core/eventManager";
-
-class EntityWatchPlugin implements RapidPlugin {
-  #createEventEmitters: EventManager<Record<string, [EntityWatchHandlerContext<any>]>>;
-  #updateEventEmitters: EventManager<Record<string, [EntityWatchHandlerContext<any>]>>;
-  #deleteEventEmitters: EventManager<Record<string, [EntityWatchHandlerContext<any>]>>;
-  #addRelationsEventEmitters: EventManager<Record<string, [EntityWatchHandlerContext<any>]>>;
-  #removeRelationsEventEmitters: EventManager<Record<string, [EntityWatchHandlerContext<any>]>>;
-
-  constructor(options: EntityWatchPluginInitOptions) {
-    const { watchers } = options;
-
-    this.#createEventEmitters = new EventManager();
-    this.#updateEventEmitters = new EventManager();
-    this.#deleteEventEmitters = new EventManager();
-    this.#addRelationsEventEmitters = new EventManager();
-    this.#removeRelationsEventEmitters = new EventManager();
-
-    for (const watcher of watchers) {
-      if (watcher.eventName === "entity.create") {
-        this.#createEventEmitters.on(watcher.modelSingularCode, watcher.handler);
-      } else if (watcher.eventName === "entity.update") {
-        this.#updateEventEmitters.on(watcher.modelSingularCode, watcher.handler);
-      } else if (watcher.eventName === "entity.delete") {
-        this.#deleteEventEmitters.on(watcher.modelSingularCode, watcher.handler);
-      } else if (watcher.eventName === "entity.addRelations") {
-        this.#addRelationsEventEmitters.on(watcher.modelSingularCode, watcher.handler);
-      } else if (watcher.eventName === "entity.removeRelations") {
-        this.#removeRelationsEventEmitters.on(watcher.modelSingularCode, watcher.handler);
-      }
-    }
-  }
-
-  get code(): string {
-    return "entityWatch";
-  }
-
-  get description(): string {
-    return "";
-  }
-
-  get extendingAbilities(): RpdServerPluginExtendingAbilities[] {
-    return [];
-  }
-
-  get configurableTargets(): RpdServerPluginConfigurableTargetOptions[] {
-    return [];
-  }
-
-  get configurations(): RpdConfigurationItemOptions[] {
-    return [];
-  }
-
-  async registerEventHandlers(server: IRpdServer): Promise<any> {
-    server.registerEventHandler("entity.create", this.handleEntityEvent.bind(this, server, "entity.create"));
-    server.registerEventHandler("entity.update", this.handleEntityEvent.bind(this, server, "entity.update"));
-    server.registerEventHandler("entity.delete", this.handleEntityEvent.bind(this, server, "entity.delete"));
-    server.registerEventHandler("entity.addRelations", this.handleEntityEvent.bind(this, server, "entity.addRelations"));
-    server.registerEventHandler("entity.removeRelations", this.handleEntityEvent.bind(this, server, "entity.removeRelations"));
-  }
-
-  handleEntityEvent(server: IRpdServer, eventName: keyof RpdServerEventTypes, sender: RapidPlugin, payload: RpdEntityCreateEventPayload) {
-    if (sender === this) {
-      return;
-    }
-
-    const { modelSingularCode, baseModelSingularCode } = payload;
-    const entityWatchHandlerContext: EntityWatchHandlerContext<typeof eventName> = {
-      server,
-      payload,
-    };
-
-    let emitter: EventManager<Record<string, [EntityWatchHandlerContext<any>]>>;
-    if (eventName === "entity.create") {
-      emitter = this.#createEventEmitters;
-    } else if (eventName === "entity.update") {
-      emitter = this.#updateEventEmitters;
-    } else if (eventName === "entity.delete") {
-      emitter = this.#deleteEventEmitters;
-    } else if (eventName === "entity.addRelations") {
-      emitter = this.#addRelationsEventEmitters;
-    } else if (eventName === "entity.removeRelations") {
-      emitter = this.#removeRelationsEventEmitters;
-    }
-
-    emitter.emit(modelSingularCode, entityWatchHandlerContext);
-    if (baseModelSingularCode) {
-      emitter.emit(baseModelSingularCode, entityWatchHandlerContext);
-    }
-  }
-}
-
-export default EntityWatchPlugin;

package/src/plugins/entityWatch/EntityWatchPluginTypes.ts

@@ -1,21 +0,0 @@
-import { IRpdServer } from "~/core/server";
-import { RpdServerEventTypes } from "~/types";
-
-export type EntityWatcherType = EntityWatcher<"entity.create"> | EntityWatcher<"entity.update"> | EntityWatcher<"entity.delete"> | EntityWatcher<"entity.addRelations"> | EntityWatcher<"entity.removeRelations"> | EntityWatcher<any>;
-
-export interface EntityWatcher<TEventName extends keyof RpdServerEventTypes = any> {
-  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: EntityWatcherType[];
-}