@ruiapp/rapid-core 0.1.11 → 0.1.13

package/dist/index.js

@@ -1692,6 +1692,27 @@ function mapPropertyNameToColumnName(model, propertyName) {
     return property.columnName || property.code;
 }
 
+function getEntityPartChanges(before, after) {
+    if (!before) {
+        throw new Error("Argument 'before' can not be null.");
+    }
+    if (!after) {
+        throw new Error("Argument 'after' can not be null.");
+    }
+    let changed = null;
+    for (const key in after) {
+        if (after[key] != before[key]) {
+            if (changed) {
+                changed[key] = after[key];
+            }
+            else {
+                changed = { [key]: after[key] };
+            }
+        }
+    }
+    return changed;
+}
+
 function convertToDataAccessOrderBy(model, orderByList) {
     if (!orderByList) {
         return orderByList;
@@ -2079,9 +2100,20 @@ async function createEntity(server, dataAccessor, options) {
     }
     return newEntity;
 }
-async function updateEntityById(server, dataAccessor, options) {
+async function updateEntityById(server, dataAccessor, options, plugin) {
     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 = [];
     const manyRelationPropertiesToUpdate = [];
     ___namespace.keys(changes).forEach((propertyCode) => {
@@ -2187,6 +2219,13 @@ async function updateEntityById(server, dataAccessor, options) {
         }
         updatedEntity[property.code] = relatedEntities;
     }
+    server.emitEvent("entity.update", plugin, {
+        namespace: model.namespace,
+        modelSingularCode: model.singularCode,
+        before: entity,
+        after: updatedEntity,
+        changes: changes,
+    });
     return updatedEntity;
 }
 class EntityManager {
@@ -2196,6 +2235,9 @@ class EntityManager {
         this.#server = server;
         this.#dataAccessor = dataAccessor;
     }
+    getModel() {
+        return this.#dataAccessor.getModel();
+    }
     async findEntities(options) {
         return await findEntities(this.#server, this.#dataAccessor, options);
     }
@@ -2213,20 +2255,102 @@ class EntityManager {
             ]
         });
     }
-    async createEntity(options) {
-        return await createEntity(this.#server, this.#dataAccessor, options);
+    async createEntity(options, plugin) {
+        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) {
-        return await updateEntityById(this.#server, this.#dataAccessor, options);
+    async updateEntityById(options, plugin) {
+        return await updateEntityById(this.#server, this.#dataAccessor, options, plugin);
     }
     async count(options) {
         return await this.#dataAccessor.count(options);
     }
-    async deleteById(id) {
-        return await this.#dataAccessor.deleteById(id);
+    async deleteById(id, plugin) {
+        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() {
-        return this.#dataAccessor.getModel();
+    async addRelations(options, plugin) {
+        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, plugin) {
+        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,
+        });
     }
 }
 
@@ -2557,32 +2681,32 @@ async function generateJwtSecretKey() {
     return encode(exportedKey);
 }
 
-const code$j = "listMetaModels";
-async function handler$j(plugin, ctx, options) {
+const code$k = "listMetaModels";
+async function handler$k(plugin, ctx, options) {
     const { applicationConfig } = ctx;
     ctx.output = { list: applicationConfig.models };
 }
 
 var listMetaModels = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$j,
-  handler: handler$j
+  code: code$k,
+  handler: handler$k
 });
 
-const code$i = "listMetaRoutes";
-async function handler$i(plugin, ctx, options) {
+const code$j = "listMetaRoutes";
+async function handler$j(plugin, ctx, options) {
     const { applicationConfig } = ctx;
     ctx.output = { list: applicationConfig.routes };
 }
 
 var listMetaRoutes = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$i,
-  handler: handler$i
+  code: code$j,
+  handler: handler$j
 });
 
-const code$h = "getMetaModelDetail";
-async function handler$h(plugin, ctx, options) {
+const code$i = "getMetaModelDetail";
+async function handler$i(plugin, ctx, options) {
     const { server, input } = ctx;
     const model = server.getModel(input);
     ctx.output = model;
@@ -2590,8 +2714,8 @@ async function handler$h(plugin, ctx, options) {
 
 var getMetaModelDetail = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$h,
-  handler: handler$h
+  code: code$i,
+  handler: handler$i
 });
 
 /**
@@ -2961,9 +3085,9 @@ function transformFilterWithSubFilters(filter) {
     return filter;
 }
 
-const code$g = "findCollectionEntities";
-async function handler$g(plugin, ctx, options) {
-    await runCollectionEntityActionHandler(ctx, options, code$g, async (entityManager, input) => {
+const code$h = "findCollectionEntities";
+async function handler$h(plugin, ctx, options) {
+    await runCollectionEntityActionHandler(ctx, options, code$h, async (entityManager, input) => {
         input.filters = removeFiltersWithNullValue(input.filters);
         const entities = await entityManager.findEntities(input);
         const result = { list: entities };
@@ -2978,13 +3102,13 @@ async function handler$g(plugin, ctx, options) {
 
 var findCollectionEntities = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$g,
-  handler: handler$g
+  code: code$h,
+  handler: handler$h
 });
 
-const code$f = "findCollectionEntityById";
-async function handler$f(plugin, ctx, options) {
-    console.debug(`Running ${code$f} handler...`);
+const code$g = "findCollectionEntityById";
+async function handler$g(plugin, ctx, options) {
+    console.debug(`Running ${code$g} handler...`);
     const { server, input } = ctx;
     const { id } = input;
     const entityManager = server.getEntityManager(options.singularCode);
@@ -2997,13 +3121,13 @@ async function handler$f(plugin, ctx, options) {
 
 var findCollectionEntityById = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$f,
-  handler: handler$f
+  code: code$g,
+  handler: handler$g
 });
 
-const code$e = "countCollectionEntities";
-async function handler$e(plugin, ctx, options) {
-    await runCollectionEntityActionHandler(ctx, options, code$e, (entityManager, input) => {
+const code$f = "countCollectionEntities";
+async function handler$f(plugin, ctx, options) {
+    await runCollectionEntityActionHandler(ctx, options, code$f, (entityManager, input) => {
         input.filters = removeFiltersWithNullValue(input.filters);
         return entityManager.count(input);
     });
@@ -3011,15 +3135,15 @@ async function handler$e(plugin, ctx, options) {
 
 var countCollectionEntities = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$e,
-  handler: handler$e
+  code: code$f,
+  handler: handler$f
 });
 
-const code$d = "createCollectionEntity";
-async function handler$d(plugin, ctx, options) {
+const code$e = "createCollectionEntity";
+async function handler$e(plugin, ctx, options) {
     const { server, input } = ctx;
     const { defaultInput, fixedInput } = options;
-    console.debug(`Running ${code$d} handler...`);
+    console.debug(`Running ${code$e} handler...`);
     console.debug(`defaultInput: ${JSON.stringify(defaultInput)}`);
     const mergedInput = mergeInput(defaultInput, input, fixedInput);
     console.debug(`fixedInput: ${JSON.stringify(fixedInput)}`);
@@ -3031,26 +3155,21 @@ async function handler$d(plugin, ctx, options) {
     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,
-    });
 }
 
 var createCollectionEntity = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$d,
-  handler: handler$d
+  code: code$e,
+  handler: handler$e
 });
 
-const code$c = "createCollectionEntitiesBatch";
-async function handler$c(plugin, ctx, options) {
+const code$d = "createCollectionEntitiesBatch";
+async function handler$d(plugin, ctx, options) {
     const { server, input } = ctx;
     const { defaultInput, fixedInput } = options;
-    console.debug(`Running ${code$c} handler...`);
+    console.debug(`Running ${code$d} handler...`);
     const { entities } = input;
     if (!_.isArray(entities)) {
         throw new Error("input.entities should be an array.");
@@ -3068,12 +3187,7 @@ async function handler$c(plugin, ctx, options) {
         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;
@@ -3081,202 +3195,90 @@ async function handler$c(plugin, ctx, options) {
 
 var createCollectionEntitiesBatch = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$c,
-  handler: handler$c
+  code: code$d,
+  handler: handler$d
 });
 
-function getEntityPartChanges(before, after) {
-    if (!before) {
-        throw new Error("Argument 'before' can not be null.");
-    }
-    if (!after) {
-        throw new Error("Argument 'after' can not be null.");
-    }
-    let changed = null;
-    for (const key in after) {
-        if (after[key] != before[key]) {
-            if (changed) {
-                changed[key] = after[key];
-            }
-            else {
-                changed = { [key]: after[key] };
-            }
-        }
-    }
-    return changed;
-}
-
-const code$b = "updateCollectionEntityById";
-async function handler$b(plugin, ctx, options) {
+const code$c = "updateCollectionEntityById";
+async function handler$c(plugin, ctx, options) {
     const { server, input } = ctx;
     const { defaultInput, fixedInput } = options;
-    console.debug(`Running ${code$b} handler...`);
+    console.debug(`Running ${code$c} handler...`);
     console.debug(`defaultInput: ${JSON.stringify(defaultInput)}`);
     const mergedInput = mergeInput(defaultInput, input, fixedInput);
     console.debug(`fixedInput: ${JSON.stringify(fixedInput)}`);
     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,
-    });
 }
 
 var updateCollectionEntityById = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$b,
-  handler: handler$b
+  code: code$c,
+  handler: handler$c
 });
 
-const code$a = "deleteCollectionEntityById";
-async function handler$a(plugin, ctx, options) {
-    console.debug(`Running ${code$a} handler...`);
+const code$b = "deleteCollectionEntityById";
+async function handler$b(plugin, ctx, options) {
+    console.debug(`Running ${code$b} 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;
 }
 
 var deleteCollectionEntityById = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$a,
-  handler: handler$a
+  code: code$b,
+  handler: handler$b
 });
 
-const code$9 = "addEntityRelations";
-async function handler$9(plugin, ctx, options) {
+const code$a = "addEntityRelations";
+async function handler$a(plugin, ctx, options) {
     const { server, input } = ctx;
-    const { queryBuilder } = server;
     const { defaultInput, fixedInput } = options;
-    console.debug(`Running ${code$9} handler...`);
+    console.debug(`Running ${code$a} handler...`);
     console.debug(`defaultInput: ${JSON.stringify(defaultInput)}`);
     const mergedInput = mergeInput(defaultInput, input, fixedInput);
     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;
-    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,
-    });
 }
 
 var addEntityRelations = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$9,
-  handler: handler$9
+  code: code$a,
+  handler: handler$a
 });
 
-const code$8 = "removeEntityRelations";
-async function handler$8(plugin, ctx, options) {
+const code$9 = "removeEntityRelations";
+async function handler$9(plugin, ctx, options) {
     const { server, input } = ctx;
-    const { queryBuilder } = server;
     const { defaultInput, fixedInput } = options;
-    console.debug(`Running ${code$8} handler...`);
+    console.debug(`Running ${code$9} handler...`);
     console.debug(`defaultInput: ${JSON.stringify(defaultInput)}`);
     const mergedInput = mergeInput(defaultInput, input, fixedInput);
     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;
-    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,
-    });
 }
 
 var removeEntityRelations = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$8,
-  handler: handler$8
+  code: code$9,
+  handler: handler$9
 });
 
-const code$7 = "queryDatabase";
-async function handler$7(plugin, ctx, options) {
+const code$8 = "queryDatabase";
+async function handler$8(plugin, ctx, options) {
     const { server, input } = ctx;
     const { sql, querySingle, defaultInput, fixedInput } = options;
-    console.debug(`Running ${code$7} handler...`);
+    console.debug(`Running ${code$8} handler...`);
     console.debug(`defaultInput: ${JSON.stringify(defaultInput)}`);
     const mergedInput = mergeInput(defaultInput, input, fixedInput);
     console.debug(`fixedInput: ${JSON.stringify(fixedInput)}`);
@@ -3292,8 +3294,8 @@ async function handler$7(plugin, ctx, options) {
 
 var queryDatabase = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$7,
-  handler: handler$7
+  code: code$8,
+  handler: handler$8
 });
 
 /**
@@ -3485,16 +3487,16 @@ async function sendSourceResponse(proxyCtx, targetRes) {
     srcRes.body = targetRes.body;
 }
 
-const code$6 = "httpProxy";
-async function handler$6(plugin, ctx, options) {
-    console.debug(`Running ${code$6} handler...`);
+const code$7 = "httpProxy";
+async function handler$7(plugin, ctx, options) {
+    console.debug(`Running ${code$7} handler...`);
     await doProxy(ctx.routerContext, options);
 }
 
 var httpProxy = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$6,
-  handler: handler$6
+  code: code$7,
+  handler: handler$7
 });
 
 /**
@@ -3745,8 +3747,8 @@ class WebhooksPlugin {
     }
 }
 
-const code$5 = "createSession";
-async function handler$5(plugin, ctx, options) {
+const code$6 = "createSession";
+async function handler$6(plugin, ctx, options) {
     const { server, input, routerContext } = ctx;
     const { response } = routerContext;
     const { account, password } = input;
@@ -3770,7 +3772,7 @@ async function handler$5(plugin, ctx, options) {
         iss: "authManager",
         sub: "userAccessToken",
         aud: "" + user.id,
-        iat: new Date,
+        iat: Math.floor(Date.now() / 1000),
         act: user.login,
     }, secretKey);
     setCookie(response.headers, {
@@ -3785,12 +3787,12 @@ async function handler$5(plugin, ctx, options) {
 
 var createSession = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$5,
-  handler: handler$5
+  code: code$6,
+  handler: handler$6
 });
 
-const code$4 = "deleteSession";
-async function handler$4(plugin, ctx, options) {
+const code$5 = "deleteSession";
+async function handler$5(plugin, ctx, options) {
     const { server, input, routerContext } = ctx;
     const { response } = routerContext;
     setCookie(response.headers, {
@@ -3803,12 +3805,12 @@ async function handler$4(plugin, ctx, options) {
 
 var deleteSession = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$4,
-  handler: handler$4
+  code: code$5,
+  handler: handler$5
 });
 
-const code$3 = "getMyProfile";
-async function handler$3(plugin, ctx, options) {
+const code$4 = "getMyProfile";
+async function handler$4(plugin, ctx, options) {
     const { server, input, routerContext } = ctx;
     const userId = routerContext.state.userId;
     if (!userId) {
@@ -3838,11 +3840,11 @@ async function handler$3(plugin, ctx, options) {
 
 var getMyProfile$2 = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$3,
-  handler: handler$3
+  code: code$4,
+  handler: handler$4
 });
 
-var pluginActionHandlers = [
+var pluginActionHandlers$1 = [
     createSession,
     deleteSession,
     getMyProfile$2,
@@ -3979,7 +3981,7 @@ class AuthPlugin {
     async registerMiddlewares(server) {
     }
     async registerActionHandlers(server) {
-        for (const actionHandler of pluginActionHandlers) {
+        for (const actionHandler of pluginActionHandlers$1) {
             server.registerActionHandler(this, actionHandler);
         }
     }
@@ -4057,8 +4059,8 @@ async function appendFile(path, data) {
     });
 }
 
-const code$2 = "downloadDocument";
-async function handler$2(plugin, ctx, options) {
+const code$3 = "downloadDocument";
+async function handler$3(plugin, ctx, options) {
     const { server, applicationConfig, routerContext, input } = ctx;
     const { request, response } = routerContext;
     const documentDataAccessor = ctx.server.getDataAccessor({
@@ -4086,12 +4088,12 @@ async function handler$2(plugin, ctx, options) {
 
 var downloadDocumentActionHandler = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$2,
-  handler: handler$2
+  code: code$3,
+  handler: handler$3
 });
 
-const code$1 = "downloadFile";
-async function handler$1(plugin, ctx, options) {
+const code$2 = "downloadFile";
+async function handler$2(plugin, ctx, options) {
     const { server, applicationConfig, routerContext, input } = ctx;
     const { request, response } = routerContext;
     const dataAccessor = ctx.server.getDataAccessor({
@@ -4111,12 +4113,12 @@ async function handler$1(plugin, ctx, options) {
 
 var downloadFileActionHandler = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$1,
-  handler: handler$1
+  code: code$2,
+  handler: handler$2
 });
 
-const code = "uploadFile";
-async function handler(plugin, ctx, options) {
+const code$1 = "uploadFile";
+async function handler$1(plugin, ctx, options) {
     const { server, applicationConfig, routerContext, input } = ctx;
     let file = input.file || input.files;
     if (_.isArray(file)) {
@@ -4137,8 +4139,8 @@ async function handler(plugin, ctx, options) {
 
 var uploadFileActionHandler = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code,
-  handler: handler
+  code: code$1,
+  handler: handler$1
 });
 
 var getMyProfile = {
@@ -4239,10 +4241,176 @@ class FileManager {
     }
 }
 
+const code = "runServerOperation";
+async function handler(plugin, ctx, options) {
+    const { operation } = options;
+    await operation(ctx);
+}
+
+var runServerOperation = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  code: code,
+  handler: handler
+});
+
+var pluginActionHandlers = [
+    runServerOperation,
+];
+
+class ServerOperationPlugin {
+    #operations;
+    constructor(options) {
+        this.#operations = options.operations || [];
+    }
+    get code() {
+        return "serverOperation";
+    }
+    get description() {
+        return "";
+    }
+    get extendingAbilities() {
+        return [];
+    }
+    get configurableTargets() {
+        return [];
+    }
+    get configurations() {
+        return [];
+    }
+    async initPlugin(server) {
+    }
+    async registerMiddlewares(server) {
+    }
+    async registerActionHandlers(server) {
+        for (const actionHandler of pluginActionHandlers) {
+            server.registerActionHandler(this, actionHandler);
+        }
+    }
+    async registerEventHandlers(server) {
+    }
+    async registerMessageHandlers(server) {
+    }
+    async registerTaskProcessors(server) {
+    }
+    async onLoadingApplication(server, applicationConfig) {
+    }
+    async configureModels(server, applicationConfig) {
+    }
+    async configureModelProperties(server, applicationConfig) {
+    }
+    async configureRoutes(server, applicationConfig) {
+        const routes = [];
+        for (const operation of this.#operations) {
+            routes.push({
+                namespace: "app",
+                name: `app.operations.${operation.code}`,
+                code: `app.operations.${operation.code}`,
+                type: "RESTful",
+                method: operation.method,
+                endpoint: `/app/${operation.code}`,
+                actions: [
+                    {
+                        code: "runServerOperation",
+                        config: {
+                            operation: operation.handler,
+                        }
+                    },
+                ],
+            });
+        }
+        server.appendApplicationConfig({ routes });
+    }
+    async onApplicationLoaded(server, applicationConfig) {
+    }
+    async onApplicationReady(server, applicationConfig) {
+    }
+}
+
+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 } = payload;
+        const entityWatchHandlerContext = {
+            server,
+            payload,
+        };
+        if (eventName === "entity.create") {
+            this.#createEventEmitters.emit(modelSingularCode, entityWatchHandlerContext);
+        }
+        else if (eventName === "entity.update") {
+            this.#updateEventEmitters.emit(modelSingularCode, entityWatchHandlerContext);
+        }
+        else if (eventName === "entity.delete") {
+            this.#deleteEventEmitters.emit(modelSingularCode, entityWatchHandlerContext);
+        }
+        else if (eventName === "entity.addRelations") {
+            this.#addRelationsEventEmitters.emit(modelSingularCode, entityWatchHandlerContext);
+        }
+        else if (eventName === "entity.removeRelations") {
+            this.#removeRelationsEventEmitters.emit(modelSingularCode, entityWatchHandlerContext);
+        }
+    }
+}
+
 fixBigIntJSONSerialize();
 
 exports.AuthPlugin = AuthPlugin;
 exports.DataManagePlugin = DataManager;
+exports.EntityWatchPlugin = EntityWatchPlugin;
 exports.FileManagePlugin = FileManager;
 exports.GlobalRequest = GlobalRequest;
 exports.MetaManagePlugin = MetaManager;
@@ -4250,6 +4418,7 @@ exports.RapidRequest = RapidRequest;
 exports.RapidServer = RapidServer;
 exports.RouteContext = RouteContext;
 exports.RouteManagePlugin = RouteManager;
+exports.ServerOperationPlugin = ServerOperationPlugin;
 exports.WebhooksPlugin = WebhooksPlugin;
 exports.bootstrapApplicationConfig = bootstrapApplicationConfig$1;
 exports.createJwt = createJwt;