@modular-rest/server 1.20.1 → 1.21.0

package/dist/class/cms_trigger.d.ts

@@ -1,4 +1,4 @@
-import { DatabaseTriggerContext } from './database_trigger';
+import DatabaseTrigger, { DatabaseTriggerContext } from './database_trigger';
 /**
  * Type for CMS operations that can trigger a callback
  * @typedef {('update-one' | 'insert-one' | 'remove-one')} CmsOperation
@@ -27,9 +27,7 @@ export type CmsOperation = 'update-one' | 'insert-one' | 'remove-one';
  * });
  * ```
  */
-export declare class CmsTrigger {
-    operation: CmsOperation;
-    callback: (context: DatabaseTriggerContext) => void;
+export declare class CmsTrigger extends DatabaseTrigger {
     /**
      * Creates a new CmsTrigger instance
      * @param {CmsOperation} operation - The CMS operation to trigger on

package/dist/class/cms_trigger.js

@@ -1,6 +1,10 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CmsTrigger = void 0;
+const database_trigger_1 = __importDefault(require("./database_trigger"));
 /**
  * Defines a callback to be executed on specific CMS operations
  * @class CmsTrigger
@@ -20,7 +24,7 @@ exports.CmsTrigger = void 0;
  * });
  * ```
  */
-class CmsTrigger {
+class CmsTrigger extends database_trigger_1.default {
     /**
      * Creates a new CmsTrigger instance
      * @param {CmsOperation} operation - The CMS operation to trigger on
@@ -39,8 +43,7 @@ class CmsTrigger {
      * ```
      */
     constructor(operation, callback = () => { }) {
-        this.operation = operation;
-        this.callback = callback;
+        super(operation, callback);
     }
 }
 exports.CmsTrigger = CmsTrigger;

package/dist/class/collection_definition.js

@@ -138,6 +138,12 @@ class CollectionDefinition {
         this.schema = schema;
         this.permissions = permissions;
         this.triggers = triggers;
+        // Apply triggers to schema
+        if (this.triggers) {
+            this.triggers.forEach(trigger => {
+                trigger.applyToSchema(this.schema);
+            });
+        }
     }
     /**
      * Get the mongoose model for this collection

package/dist/class/database_trigger.d.ts

@@ -1,22 +1,24 @@
 /**
  * Type for database operations that can trigger a callback
  */
-export type DatabaseOperation = 'find' | 'find-one' | 'count' | 'update-one' | 'insert-one' | 'remove-one' | 'aggregate';
+export type DatabaseOperation = 'find' | 'find-one' | 'count' | 'update-one' | 'insert-one' | 'remove-one' | 'aggregate' | 'insert-many' | 'delete-many' | 'find-one-and-update' | 'find-one-and-delete' | 'distinct' | 'validate';
 /**
  * Context interface for database trigger callbacks
  * @interface DatabaseTriggerContext
- * @property {Record<string, any>} doc - The document data for insert/update operations
- * @property {Record<string, any>} query - The query data for find/find-one operations
+ * @property {Record<string, any>} doc - The document data for insert/update/validate operations.
+ * @property {Record<string, any>[]} docs - The documents data for insert-many operations.
+ * @property {Record<string, any>} query - The query data for find/remove/count/distinct operations
  * @property {Record<string, any>} update - The update data for update operations
  * @property {Record<string, any>[]} pipelines - The aggregation pipelines for aggregate operations
- * @property {Record<string, any> } queryResult - The result of the database operation
+ * @property {any} queryResult - The result of the database operation (can be document, array of documents, number, or null)
  */
 export interface DatabaseTriggerContext {
     doc?: Record<string, any>;
+    docs?: Record<string, any>[];
     query?: Record<string, any>;
     update?: Record<string, any>;
     pipelines?: Record<string, any>[];
-    queryResult: Record<string, any>;
+    queryResult: any;
 }
 /**
  * The callback function to be executed on specific database operations
@@ -30,36 +32,39 @@ export interface DatabaseTriggerContext {
  */
 type DatabaseTriggerCallback = (context: DatabaseTriggerContext) => void;
 /**
- * in a complex application, you may need to perform additional actions after a database operation.
- * this is where DatabaseTrigger comes in. so you can define a callback to be executed on specific database operations for a collection.
+ * In a complex application, you may need to perform additional actions after a database operation.
+ * This is where DatabaseTrigger comes in, allowing you to define callbacks for specific database operations on a collection.
  *
- * Supported triggers are:
+ * ### Supported Triggers and Contexts
  *
- * | Trigger      | Description                                                  |
- * | ------------ | ------------------------------------------------------------ |
- * | `find`       | Triggered when a find query is executed on collection.       |
- * | `find-one`   | Triggered when a find one query is executed on collection.   |
- * | `count`      | Triggered when a count query is executed on collection.      |
- * | `update-one` | Triggered when a update one query is executed on collection. |
- * | `insert-one` | Triggered when a insert one query is executed on collection. |
- * | `remove-one` | Triggered when a remove one query is executed on collection. |
- * | `aggregate`  | Triggered when a aggregate query is executed on collection.  |
+ * The `callback` function associated with a trigger receives a {@link DatabaseTriggerContext} object. The properties available in this context vary depending on the trigger operation.
+ *
+ * | Trigger Operation | Description | Context Data |
+ * | :--- | :--- | :--- |
+ * | `insert-one` | Triggered after a single document insertion. | `doc`: The inserted document.<br>`queryResult`: The inserted document. |
+ * | `insert-many` | Triggered after multiple document insertions. | `docs`: The array of inserted documents.<br>`queryResult`: The array of inserted documents. |
+ * | `update-one` | Triggered after updating a single document (using `updateOne`). | `query`: The query filter used.<br>`update`: The update operations applied.<br>`queryResult`: The operation result. |
+ * | `find-one-and-update` | Triggered after `findOneAndUpdate`. | `query`: The query filter used.<br>`update`: The update operations applied.<br>`queryResult`: The updated document. |
+ * | `delete-many` | Triggered after removing multiple documents (using `deleteMany`). | `query`: The query filter used.<br>`queryResult`: The operation result. |
+ * | `remove-one` | Triggered after removing a single document (using `deleteOne`). | `query`: The query filter used.<br>`queryResult`: The operation result. |
+ * | `find-one-and-delete` | Triggered after `findOneAndDelete` or `findOneAndRemove`. | `query`: The query filter used.<br>`queryResult`: The removed document. |
+ * | `find` | Triggered after a `find` query. | `query`: The query filter used.<br>`queryResult`: Array of found documents. |
+ * | `find-one` | Triggered after a `findOne` query. | `query`: The query filter used.<br>`queryResult`: The found document. |
+ * | `count` | Triggered after a `countDocuments` query. | `query`: The query filter used.<br>`queryResult`: The count (number). |
+ * | `aggregate` | Triggered after an aggregation pipeline. | `pipelines`: The aggregation pipeline used.<br>`queryResult`: The aggregation result. |
+ * | `distinct` | Triggered after a `distinct` query. | `query`: The query filter used.<br>`queryResult`: The distinct values. |
+ * | `validate` | Triggered after document validation. | `doc`: The validated document.<br>`queryResult`: The validated document. |
  *
  * @property {DatabaseOperation} operation - The database operation that triggers the callback
  * @property {DatabaseTriggerCallback} callback - The callback function to be executed
  *
  * @example
  * ```typescript
- * import { DatabaseTrigger } from '@server-ts/database';
+ * import { DatabaseTrigger } from '@modular-rest/server';
  *
- * const trigger = new DatabaseTrigger('insert-one', ({ query, queryResult }) => {
+ * const trigger = new DatabaseTrigger('insert-one', ({ doc, queryResult }) => {
  *   console.log('New document inserted:', queryResult);
- *
- *   try {
- *     // Perform additional actions after document insertion
- *   } catch (error) {
- *     console.error('Error performing additional actions:', error);
- *   }
+ *   // Perform additional actions
  * });
  *
  * // Use the trigger in a collection definition
@@ -86,5 +91,10 @@ export declare class DatabaseTrigger {
      *
      */
     constructor(operation: DatabaseOperation, callback?: DatabaseTriggerCallback);
+    /**
+     * Applies the trigger to a Mongoose schema
+     * @param {Schema} schema - The mongoose schema to apply the trigger to
+     */
+    applyToSchema(schema: any): void;
 }
 export default DatabaseTrigger;

package/dist/class/database_trigger.js

@@ -2,36 +2,39 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DatabaseTrigger = void 0;
 /**
- * in a complex application, you may need to perform additional actions after a database operation.
- * this is where DatabaseTrigger comes in. so you can define a callback to be executed on specific database operations for a collection.
+ * In a complex application, you may need to perform additional actions after a database operation.
+ * This is where DatabaseTrigger comes in, allowing you to define callbacks for specific database operations on a collection.
  *
- * Supported triggers are:
+ * ### Supported Triggers and Contexts
  *
- * | Trigger      | Description                                                  |
- * | ------------ | ------------------------------------------------------------ |
- * | `find`       | Triggered when a find query is executed on collection.       |
- * | `find-one`   | Triggered when a find one query is executed on collection.   |
- * | `count`      | Triggered when a count query is executed on collection.      |
- * | `update-one` | Triggered when a update one query is executed on collection. |
- * | `insert-one` | Triggered when a insert one query is executed on collection. |
- * | `remove-one` | Triggered when a remove one query is executed on collection. |
- * | `aggregate`  | Triggered when a aggregate query is executed on collection.  |
+ * The `callback` function associated with a trigger receives a {@link DatabaseTriggerContext} object. The properties available in this context vary depending on the trigger operation.
+ *
+ * | Trigger Operation | Description | Context Data |
+ * | :--- | :--- | :--- |
+ * | `insert-one` | Triggered after a single document insertion. | `doc`: The inserted document.<br>`queryResult`: The inserted document. |
+ * | `insert-many` | Triggered after multiple document insertions. | `docs`: The array of inserted documents.<br>`queryResult`: The array of inserted documents. |
+ * | `update-one` | Triggered after updating a single document (using `updateOne`). | `query`: The query filter used.<br>`update`: The update operations applied.<br>`queryResult`: The operation result. |
+ * | `find-one-and-update` | Triggered after `findOneAndUpdate`. | `query`: The query filter used.<br>`update`: The update operations applied.<br>`queryResult`: The updated document. |
+ * | `delete-many` | Triggered after removing multiple documents (using `deleteMany`). | `query`: The query filter used.<br>`queryResult`: The operation result. |
+ * | `remove-one` | Triggered after removing a single document (using `deleteOne`). | `query`: The query filter used.<br>`queryResult`: The operation result. |
+ * | `find-one-and-delete` | Triggered after `findOneAndDelete` or `findOneAndRemove`. | `query`: The query filter used.<br>`queryResult`: The removed document. |
+ * | `find` | Triggered after a `find` query. | `query`: The query filter used.<br>`queryResult`: Array of found documents. |
+ * | `find-one` | Triggered after a `findOne` query. | `query`: The query filter used.<br>`queryResult`: The found document. |
+ * | `count` | Triggered after a `countDocuments` query. | `query`: The query filter used.<br>`queryResult`: The count (number). |
+ * | `aggregate` | Triggered after an aggregation pipeline. | `pipelines`: The aggregation pipeline used.<br>`queryResult`: The aggregation result. |
+ * | `distinct` | Triggered after a `distinct` query. | `query`: The query filter used.<br>`queryResult`: The distinct values. |
+ * | `validate` | Triggered after document validation. | `doc`: The validated document.<br>`queryResult`: The validated document. |
  *
  * @property {DatabaseOperation} operation - The database operation that triggers the callback
  * @property {DatabaseTriggerCallback} callback - The callback function to be executed
  *
  * @example
  * ```typescript
- * import { DatabaseTrigger } from '@server-ts/database';
+ * import { DatabaseTrigger } from '@modular-rest/server';
  *
- * const trigger = new DatabaseTrigger('insert-one', ({ query, queryResult }) => {
+ * const trigger = new DatabaseTrigger('insert-one', ({ doc, queryResult }) => {
  *   console.log('New document inserted:', queryResult);
- *
- *   try {
- *     // Perform additional actions after document insertion
- *   } catch (error) {
- *     console.error('Error performing additional actions:', error);
- *   }
+ *   // Perform additional actions
  * });
  *
  * // Use the trigger in a collection definition
@@ -59,6 +62,130 @@ class DatabaseTrigger {
         this.operation = operation;
         this.callback = callback;
     }
+    /**
+     * Applies the trigger to a Mongoose schema
+     * @param {Schema} schema - The mongoose schema to apply the trigger to
+     */
+    applyToSchema(schema) {
+        const callback = this.callback;
+        switch (this.operation) {
+            case 'insert-one':
+                schema.post('save', function (doc) {
+                    callback({
+                        doc: doc.toObject ? doc.toObject() : doc,
+                        queryResult: doc,
+                    });
+                });
+                break;
+            case 'update-one':
+                schema.post('updateOne', function (result) {
+                    callback({
+                        query: this.getQuery(),
+                        update: this.getUpdate(),
+                        queryResult: result,
+                    });
+                });
+                break;
+            case 'remove-one':
+                schema.post('deleteOne', function (result) {
+                    callback({
+                        query: this.getQuery(),
+                        queryResult: result,
+                    });
+                });
+                break;
+            case 'find':
+                schema.post('find', function (docs) {
+                    callback({
+                        query: this.getQuery(),
+                        queryResult: docs, // Pass docs directly, Mongoose returns documents
+                    });
+                });
+                break;
+            case 'find-one':
+                schema.post('findOne', function (doc) {
+                    callback({
+                        query: this.getQuery(),
+                        queryResult: doc,
+                    });
+                });
+                break;
+            case 'count':
+                schema.post('countDocuments', function (count) {
+                    callback({
+                        query: this.getQuery(),
+                        queryResult: count,
+                    });
+                });
+                break;
+            case 'aggregate':
+                schema.post('aggregate', function (docs) {
+                    callback({
+                        pipelines: this.pipeline(),
+                        queryResult: docs,
+                    });
+                });
+                break;
+            case 'insert-many':
+                schema.post('insertMany', function (docs) {
+                    callback({
+                        docs: docs,
+                        queryResult: docs,
+                    });
+                });
+                break;
+            case 'delete-many':
+                schema.post('deleteMany', function (result) {
+                    callback({
+                        query: this.getQuery(),
+                        queryResult: result,
+                    });
+                });
+                break;
+            case 'find-one-and-update':
+                schema.post('findOneAndUpdate', function (doc) {
+                    callback({
+                        query: this.getQuery(),
+                        update: this.getUpdate(),
+                        queryResult: doc,
+                    });
+                });
+                break;
+            case 'find-one-and-delete':
+                schema.post('findOneAndDelete', function (doc) {
+                    callback({
+                        query: this.getQuery(),
+                        queryResult: doc,
+                    });
+                });
+                // Also support findOneAndRemove which is deprecated but might be used
+                schema.post('findOneAndRemove', function (doc) {
+                    callback({
+                        query: this.getQuery(),
+                        queryResult: doc,
+                    });
+                });
+                break;
+            case 'distinct':
+                schema.post('distinct', function (result) {
+                    callback({
+                        query: this.getQuery(),
+                        queryResult: result,
+                    });
+                });
+                break;
+            case 'validate':
+                schema.post('validate', function (doc) {
+                    callback({
+                        doc: doc.toObject ? doc.toObject() : doc,
+                        queryResult: doc,
+                    });
+                });
+                break;
+            default:
+                console.warn(`Unsupported trigger operation: ${this.operation}`);
+        }
+    }
 }
 exports.DatabaseTrigger = DatabaseTrigger;
 exports.default = DatabaseTrigger;

package/dist/services/data_provider/router.js

@@ -111,11 +111,6 @@ dataProvider.post('/find', async (ctx) => {
     await queryRequest
         .exec()
         .then(async (docs) => {
-        // Call trigger
-        service.triggers.call('find', body.database, body.collection, {
-            query: body.query,
-            queryResult: docs,
-        });
         ctx.body = { data: docs };
     })
         .catch(err => {
@@ -157,11 +152,6 @@ dataProvider.post('/find-one', async (ctx) => {
     await queryRequest
         .exec()
         .then(async (doc) => {
-        // Call trigger
-        service.triggers.call('find-one', body.database, body.collection, {
-            query: body.query,
-            queryResult: doc,
-        });
         ctx.body = { data: doc };
     })
         .catch(err => {
@@ -189,11 +179,6 @@ dataProvider.post('/count', async (ctx) => {
         .countDocuments(body.query)
         .exec()
         .then(count => {
-        // Call trigger
-        service.triggers.call('count', body.database, body.collection, {
-            query: body.query,
-            queryResult: count,
-        });
         ctx.body = { data: count };
     })
         .catch(err => {
@@ -224,12 +209,6 @@ dataProvider.post('/update-one', async (ctx) => {
         .updateOne(body.query, body.update, body.options)
         .exec()
         .then(writeOpResult => {
-        // Call trigger
-        service.triggers.call('update-one', body.database, body.collection, {
-            query: body.query,
-            update: body.update,
-            queryResult: writeOpResult,
-        });
         ctx.body = { data: writeOpResult };
     })
         .catch(err => {
@@ -260,11 +239,6 @@ dataProvider.post('/insert-one', async (ctx) => {
     await new collection(body.doc)
         .save()
         .then(async (newDoc) => {
-        // Call trigger
-        service.triggers.call('insert-one', body.database, body.collection, {
-            doc: body.doc,
-            queryResult: newDoc,
-        });
         ctx.body = { data: newDoc };
     })
         .catch(err => {
@@ -295,11 +269,6 @@ dataProvider.post('/remove-one', async (ctx) => {
         .deleteOne(body.query)
         .exec()
         .then(async (result) => {
-        // Call trigger
-        service.triggers.call('remove-one', body.database, body.collection, {
-            query: body.query,
-            queryResult: result,
-        });
         ctx.body = { data: result };
     })
         .catch((err) => {
@@ -328,11 +297,6 @@ dataProvider.post('/aggregate', async (ctx) => {
         .aggregate(body.pipelines)
         .exec()
         .then(async (result) => {
-        // Call trigger
-        service.triggers.call('aggregate', body.database, body.collection, {
-            pipelines: body.pipelines,
-            queryResult: result,
-        });
         ctx.body = { data: result };
     })
         .catch((err) => {

package/dist/services/data_provider/service.d.ts

@@ -1,5 +1,4 @@
 import mongoose, { Model, PopulateOptions, Query } from 'mongoose';
-import triggerOperator from '../../class/trigger_operator';
 import TypeCasters from './typeCasters';
 import { CollectionDefinition } from '../../class/collection_definition';
 import { User } from '../../class/user';
@@ -129,4 +128,4 @@ export declare function performPopulateToQueryObject<T = any>(queryObj: Query<T,
  * ```
  */
 export declare function performAdditionalOptionsToQueryObject<T = any>(queryObj: Query<T, any>, options: Record<string, any>): Query<T, any>;
-export { triggerOperator as triggers, TypeCasters };
+export { TypeCasters };

package/dist/services/data_provider/service.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeCasters = exports.triggers = exports.name = void 0;
+exports.TypeCasters = exports.name = void 0;
 exports.addCollectionDefinitionByList = addCollectionDefinitionByList;
 exports.getCollection = getCollection;
 exports.checkAccess = checkAccess;
@@ -12,8 +12,6 @@ exports.performPopulateToQueryObject = performPopulateToQueryObject;
 exports.performAdditionalOptionsToQueryObject = performAdditionalOptionsToQueryObject;
 const mongoose_1 = __importDefault(require("mongoose"));
 const security_1 = require("../../class/security");
-const trigger_operator_1 = __importDefault(require("../../class/trigger_operator"));
-exports.triggers = trigger_operator_1.default;
 const typeCasters_1 = __importDefault(require("./typeCasters"));
 exports.TypeCasters = typeCasters_1.default;
 const model_registry_1 = __importDefault(require("./model_registry"));
@@ -100,19 +98,6 @@ function connectToDatabaseByCollectionDefinitionList(dbName, collectionDefinitio
                 collection: collection,
                 permissionList: collectionDefinition.permissions,
             });
-            // add trigger
-            if (collectionDefinition.triggers != undefined) {
-                if (!Array.isArray(collectionDefinition.triggers)) {
-                    throw new Error('Triggers must be an array');
-                }
-                collectionDefinition.triggers.forEach(trigger => {
-                    trigger_operator_1.default.addTrigger({
-                        ...trigger,
-                        database: collectionDefinition.database,
-                        collection: collectionDefinition.collection,
-                    });
-                });
-            }
         });
         // If connection is already connected, resolve immediately
         if (connection.readyState === 1) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@modular-rest/server",
-	"version": "1.20.1",
+	"version": "1.21.0",
 	"description": "TypeScript version of a nodejs module based on KOAJS for developing Rest-APIs in a modular solution.",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",

package/src/class/cms_trigger.ts

@@ -1,4 +1,4 @@
-import { DatabaseTriggerContext } from './database_trigger';
+import DatabaseTrigger, { DatabaseTriggerContext } from './database_trigger';
 
 /**
  * Type for CMS operations that can trigger a callback
@@ -29,9 +29,8 @@ export type CmsOperation = 'update-one' | 'insert-one' | 'remove-one';
  * });
  * ```
  */
-export class CmsTrigger {
-  operation: CmsOperation;
-  callback: (context: DatabaseTriggerContext) => void;
+export class CmsTrigger extends DatabaseTrigger {
+
 
   /**
    * Creates a new CmsTrigger instance
@@ -52,10 +51,9 @@ export class CmsTrigger {
    */
   constructor(
     operation: CmsOperation,
-    callback: (context: DatabaseTriggerContext) => void = () => {}
+    callback: (context: DatabaseTriggerContext) => void = () => { }
   ) {
-    this.operation = operation;
-    this.callback = callback;
+    super(operation, callback);
   }
 }
 

package/src/class/collection_definition.ts

@@ -117,8 +117,8 @@ export function defineCollection(
 
       throw new Error(
         `Model for ${definition.database}.${definition.collection} is not available. ` +
-          `Ensure mongoOption is provided in defineCollection options, config.mongo is set, ` +
-          `or the collection is registered via addCollectionDefinitionByList before accessing the model.`
+        `Ensure mongoOption is provided in defineCollection options, config.mongo is set, ` +
+        `or the collection is registered via addCollectionDefinitionByList before accessing the model.`
       );
     },
     enumerable: true,
@@ -204,6 +204,13 @@ export class CollectionDefinition {
     this.schema = schema;
     this.permissions = permissions;
     this.triggers = triggers;
+
+    // Apply triggers to schema
+    if (this.triggers) {
+      this.triggers.forEach(trigger => {
+        trigger.applyToSchema(this.schema);
+      });
+    }
   }
 
   /**

package/src/class/database_trigger.ts

@@ -8,25 +8,34 @@ export type DatabaseOperation =
   | 'update-one'
   | 'insert-one'
   | 'remove-one'
-  | 'aggregate';
+  | 'aggregate'
+  | 'insert-many'
+  | 'delete-many'
+  | 'find-one-and-update'
+  | 'find-one-and-delete'
+  | 'distinct'
+  | 'validate';
 
 /**
  * Context interface for database trigger callbacks
  * @interface DatabaseTriggerContext
- * @property {Record<string, any>} doc - The document data for insert/update operations
- * @property {Record<string, any>} query - The query data for find/find-one operations
+ * @property {Record<string, any>} doc - The document data for insert/update/validate operations.
+ * @property {Record<string, any>[]} docs - The documents data for insert-many operations.
+ * @property {Record<string, any>} query - The query data for find/remove/count/distinct operations
  * @property {Record<string, any>} update - The update data for update operations
  * @property {Record<string, any>[]} pipelines - The aggregation pipelines for aggregate operations
- * @property {Record<string, any> } queryResult - The result of the database operation
+ * @property {any} queryResult - The result of the database operation (can be document, array of documents, number, or null)
  */
 export interface DatabaseTriggerContext {
   doc?: Record<string, any>;
+  docs?: Record<string, any>[];
   query?: Record<string, any>;
   update?: Record<string, any>;
   pipelines?: Record<string, any>[];
-  queryResult: Record<string, any>;
+  queryResult: any;
 }
 
+
 /**
  * The callback function to be executed on specific database operations
  * @param {DatabaseTriggerContext} context - The context of the database operation
@@ -40,36 +49,39 @@ export interface DatabaseTriggerContext {
 type DatabaseTriggerCallback = (context: DatabaseTriggerContext) => void;
 
 /**
- * in a complex application, you may need to perform additional actions after a database operation.
- * this is where DatabaseTrigger comes in. so you can define a callback to be executed on specific database operations for a collection.
+ * In a complex application, you may need to perform additional actions after a database operation.
+ * This is where DatabaseTrigger comes in, allowing you to define callbacks for specific database operations on a collection.
+ *
+ * ### Supported Triggers and Contexts
  *
- * Supported triggers are:
+ * The `callback` function associated with a trigger receives a {@link DatabaseTriggerContext} object. The properties available in this context vary depending on the trigger operation.
  *
- * | Trigger      | Description                                                  |
- * | ------------ | ------------------------------------------------------------ |
- * | `find`       | Triggered when a find query is executed on collection.       |
- * | `find-one`   | Triggered when a find one query is executed on collection.   |
- * | `count`      | Triggered when a count query is executed on collection.      |
- * | `update-one` | Triggered when a update one query is executed on collection. |
- * | `insert-one` | Triggered when a insert one query is executed on collection. |
- * | `remove-one` | Triggered when a remove one query is executed on collection. |
- * | `aggregate`  | Triggered when a aggregate query is executed on collection.  |
+ * | Trigger Operation | Description | Context Data |
+ * | :--- | :--- | :--- |
+ * | `insert-one` | Triggered after a single document insertion. | `doc`: The inserted document.<br>`queryResult`: The inserted document. |
+ * | `insert-many` | Triggered after multiple document insertions. | `docs`: The array of inserted documents.<br>`queryResult`: The array of inserted documents. |
+ * | `update-one` | Triggered after updating a single document (using `updateOne`). | `query`: The query filter used.<br>`update`: The update operations applied.<br>`queryResult`: The operation result. |
+ * | `find-one-and-update` | Triggered after `findOneAndUpdate`. | `query`: The query filter used.<br>`update`: The update operations applied.<br>`queryResult`: The updated document. |
+ * | `delete-many` | Triggered after removing multiple documents (using `deleteMany`). | `query`: The query filter used.<br>`queryResult`: The operation result. |
+ * | `remove-one` | Triggered after removing a single document (using `deleteOne`). | `query`: The query filter used.<br>`queryResult`: The operation result. |
+ * | `find-one-and-delete` | Triggered after `findOneAndDelete` or `findOneAndRemove`. | `query`: The query filter used.<br>`queryResult`: The removed document. |
+ * | `find` | Triggered after a `find` query. | `query`: The query filter used.<br>`queryResult`: Array of found documents. |
+ * | `find-one` | Triggered after a `findOne` query. | `query`: The query filter used.<br>`queryResult`: The found document. |
+ * | `count` | Triggered after a `countDocuments` query. | `query`: The query filter used.<br>`queryResult`: The count (number). |
+ * | `aggregate` | Triggered after an aggregation pipeline. | `pipelines`: The aggregation pipeline used.<br>`queryResult`: The aggregation result. |
+ * | `distinct` | Triggered after a `distinct` query. | `query`: The query filter used.<br>`queryResult`: The distinct values. |
+ * | `validate` | Triggered after document validation. | `doc`: The validated document.<br>`queryResult`: The validated document. |
  *
  * @property {DatabaseOperation} operation - The database operation that triggers the callback
  * @property {DatabaseTriggerCallback} callback - The callback function to be executed
  *
  * @example
  * ```typescript
- * import { DatabaseTrigger } from '@server-ts/database';
+ * import { DatabaseTrigger } from '@modular-rest/server';
  *
- * const trigger = new DatabaseTrigger('insert-one', ({ query, queryResult }) => {
+ * const trigger = new DatabaseTrigger('insert-one', ({ doc, queryResult }) => {
  *   console.log('New document inserted:', queryResult);
- *
- *   try {
- *     // Perform additional actions after document insertion
- *   } catch (error) {
- *     console.error('Error performing additional actions:', error);
- *   }
+ *   // Perform additional actions
  * });
  *
  * // Use the trigger in a collection definition
@@ -96,10 +108,149 @@ export class DatabaseTrigger {
    * });
    *
    */
-  constructor(operation: DatabaseOperation, callback: DatabaseTriggerCallback = () => {}) {
+  constructor(operation: DatabaseOperation, callback: DatabaseTriggerCallback = () => { }) {
     this.operation = operation;
     this.callback = callback;
   }
+  /**
+   * Applies the trigger to a Mongoose schema
+   * @param {Schema} schema - The mongoose schema to apply the trigger to
+   */
+  applyToSchema(schema: any): void {
+    const callback = this.callback;
+
+    switch (this.operation) {
+      case 'insert-one':
+        schema.post('save', function (doc: any) {
+          callback({
+            doc: doc.toObject ? doc.toObject() : doc,
+            queryResult: doc,
+          });
+        });
+        break;
+
+      case 'update-one':
+        schema.post('updateOne', function (this: any, result: any) {
+          callback({
+            query: this.getQuery(),
+            update: this.getUpdate(),
+            queryResult: result,
+          });
+        });
+        break;
+
+      case 'remove-one':
+        schema.post('deleteOne', function (this: any, result: any) {
+          callback({
+            query: this.getQuery(),
+            queryResult: result,
+          });
+        });
+        break;
+
+      case 'find':
+        schema.post('find', function (this: any, docs: any[]) {
+          callback({
+            query: this.getQuery(),
+            queryResult: docs, // Pass docs directly, Mongoose returns documents
+          });
+        });
+        break;
+
+      case 'find-one':
+        schema.post('findOne', function (this: any, doc: any) {
+          callback({
+            query: this.getQuery(),
+            queryResult: doc,
+          });
+        });
+        break;
+
+      case 'count':
+        schema.post('countDocuments', function (this: any, count: any) {
+          callback({
+            query: this.getQuery(),
+            queryResult: count,
+          });
+        });
+        break;
+
+      case 'aggregate':
+        schema.post('aggregate', function (this: any, docs: any[]) {
+          callback({
+            pipelines: this.pipeline(),
+            queryResult: docs,
+          });
+        });
+        break;
+
+      case 'insert-many':
+        schema.post('insertMany', function (docs: any[]) {
+          callback({
+            docs: docs,
+            queryResult: docs,
+          });
+        });
+        break;
+
+      case 'delete-many':
+        schema.post('deleteMany', function (this: any, result: any) {
+          callback({
+            query: this.getQuery(),
+            queryResult: result,
+          });
+        });
+        break;
+
+      case 'find-one-and-update':
+        schema.post('findOneAndUpdate', function (this: any, doc: any) {
+          callback({
+            query: this.getQuery(),
+            update: this.getUpdate(),
+            queryResult: doc,
+          });
+        });
+        break;
+
+      case 'find-one-and-delete':
+        schema.post('findOneAndDelete', function (this: any, doc: any) {
+          callback({
+            query: this.getQuery(),
+            queryResult: doc,
+          });
+        });
+        // Also support findOneAndRemove which is deprecated but might be used
+        schema.post('findOneAndRemove', function (this: any, doc: any) {
+          callback({
+            query: this.getQuery(),
+            queryResult: doc,
+          });
+        });
+        break;
+
+      case 'distinct':
+        schema.post('distinct', function (this: any, result: any) {
+          callback({
+            query: this.getQuery(),
+            queryResult: result,
+          });
+        });
+        break;
+
+      case 'validate':
+        schema.post('validate', function (doc: any) {
+          callback({
+            doc: doc.toObject ? doc.toObject() : doc,
+            queryResult: doc,
+          });
+        });
+        break;
+
+
+      default:
+        console.warn(`Unsupported trigger operation: ${this.operation}`);
+    }
+  }
 }
 
 export default DatabaseTrigger;

package/src/services/data_provider/router.ts

@@ -92,11 +92,7 @@ dataProvider.post('/find', async (ctx: Context) => {
   await queryRequest
     .exec()
     .then(async docs => {
-      // Call trigger
-      service.triggers.call('find', body.database, body.collection, {
-        query: body.query,
-        queryResult: docs,
-      });
+
 
       ctx.body = { data: docs };
     })
@@ -151,11 +147,7 @@ dataProvider.post('/find-one', async (ctx: Context) => {
   await queryRequest
     .exec()
     .then(async doc => {
-      // Call trigger
-      service.triggers.call('find-one', body.database, body.collection, {
-        query: body.query,
-        queryResult: doc,
-      });
+
 
       ctx.body = { data: doc };
     })
@@ -194,11 +186,7 @@ dataProvider.post('/count', async (ctx: Context) => {
     .countDocuments(body.query)
     .exec()
     .then(count => {
-      // Call trigger
-      service.triggers.call('count', body.database, body.collection, {
-        query: body.query,
-        queryResult: count,
-      });
+
 
       ctx.body = { data: count };
     })
@@ -241,12 +229,7 @@ dataProvider.post('/update-one', async (ctx: Context) => {
     .updateOne(body.query, body.update, body.options)
     .exec()
     .then(writeOpResult => {
-      // Call trigger
-      service.triggers.call('update-one', body.database, body.collection, {
-        query: body.query,
-        update: body.update,
-        queryResult: writeOpResult,
-      });
+
 
       ctx.body = { data: writeOpResult };
     })
@@ -289,11 +272,7 @@ dataProvider.post('/insert-one', async (ctx: Context) => {
   await new collection(body.doc)
     .save()
     .then(async newDoc => {
-      // Call trigger
-      service.triggers.call('insert-one', body.database, body.collection, {
-        doc: body.doc,
-        queryResult: newDoc,
-      });
+
 
       ctx.body = { data: newDoc };
     })
@@ -336,11 +315,7 @@ dataProvider.post('/remove-one', async (ctx: Context) => {
     .deleteOne(body.query)
     .exec()
     .then(async (result: any) => {
-      // Call trigger
-      service.triggers.call('remove-one', body.database, body.collection, {
-        query: body.query,
-        queryResult: result,
-      });
+
 
       ctx.body = { data: result };
     })
@@ -380,11 +355,7 @@ dataProvider.post('/aggregate', async (ctx: Context) => {
     .aggregate(body.pipelines)
     .exec()
     .then(async (result: any) => {
-      // Call trigger
-      service.triggers.call('aggregate', body.database, body.collection, {
-        pipelines: body.pipelines,
-        queryResult: result,
-      });
+
 
       ctx.body = { data: result };
     })

package/src/services/data_provider/service.ts

@@ -1,6 +1,6 @@
 import mongoose, { Connection, Model, PopulateOptions, Query } from 'mongoose';
 import { AccessTypes, AccessDefinition, Permission } from '../../class/security';
-import triggerOperator from '../../class/trigger_operator';
+
 import TypeCasters from './typeCasters';
 import { config } from '../../config';
 import { CollectionDefinition } from '../../class/collection_definition';
@@ -128,20 +128,7 @@ function connectToDatabaseByCollectionDefinitionList(
         permissionList: collectionDefinition.permissions,
       });
 
-      // add trigger
-      if (collectionDefinition.triggers != undefined) {
-        if (!Array.isArray(collectionDefinition.triggers)) {
-          throw new Error('Triggers must be an array');
-        }
 
-        collectionDefinition.triggers.forEach(trigger => {
-          triggerOperator.addTrigger({
-            ...trigger,
-            database: collectionDefinition.database,
-            collection: collectionDefinition.collection,
-          });
-        });
-      }
     });
 
     // If connection is already connected, resolve immediately
@@ -362,5 +349,5 @@ export function performAdditionalOptionsToQueryObject<T = any>(
   return queryObj;
 }
 
-// Instead, export triggerOperator as triggers
-export { triggerOperator as triggers, TypeCasters };
+// Instead, export TypeCasters
+export { TypeCasters };

package/tests/helpers/test-app.ts

@@ -28,6 +28,7 @@ export interface TestAppContext {
   uploadDir: string;
   adminToken: string;
   dbPrefix: string;
+  mongoOption?: RestOptions['mongo'];
   cleanup: () => Promise<void>;
 }
 
@@ -138,6 +139,7 @@ export async function createIntegrationTestApp(
     uploadDir,
     adminToken,
     dbPrefix,
+    mongoOption: options.mongo,
     cleanup,
   };
 }

package/tests/router/data-provider.router.int.test.ts

@@ -189,4 +189,162 @@ describe('data-provider router integration', () => {
       });
     expect(verifyRes.body.data).toBeNull();
   });
+
+  it('triggers are executed on direct model usage and api usage', async () => {
+    // 1. Define a trigger
+    const triggerMock = jest.fn();
+
+    // We need to access the collection definition to add a trigger dynamically for testing
+    // or we assume the existing setup allows us to mock/spy on something.
+    // However, since we are in an integration test with a real app context, 
+    // modifying the collection definition on the fly might be tricky if models are already compiled.
+    // Ideally we should have a test collection with triggers defined.
+
+    // Let's create a dynamic collection definition with a trigger for this test if possible,
+    // or allow the test helper to set one up.
+    // Since we cannot easily modify the setup here without changing helpers, 
+    // and the user asked to "add new test case" to this file, 
+    // we need to assume there is a way or we need to add a collection definition here.
+
+    // Looking at the imports, we can import defineCollection etc.
+    // But the app is already created in beforeAll via createIntegrationTestApp().
+
+    // IF we cannot add a new collection easily, we'll try to spy on console or a side effect 
+    // if there are existing triggers. But the current test app seems to use standard collections.
+
+    // Let's assume we can register a new collection via a service method if available, 
+    // or we might need to modify the test helper. 
+    // For now, I will write the test assuming we can verify the trigger via a mocked callback 
+    // attached to a new collection we define locally and register.
+
+    const { defineCollection } = require('../../src/class/collection_definition');
+    const { Permission } = require('../../src/class/security');
+    const { DatabaseTrigger } = require('../../src/class/database_trigger');
+    const { Schema } = require('mongoose');
+    const modelRegistry = require('../../src/services/data_provider/model_registry').default;
+    const service = require('../../src/services/data_provider/service');
+
+    const triggerCallback = jest.fn();
+    const trigger = new DatabaseTrigger('insert-one', triggerCallback);
+
+    const testCollectionDef = defineCollection({
+      database: 'test_db',
+      collection: 'trigger_test',
+      schema: new Schema({ name: String }),
+      permissions: [
+        new Permission({ accessType: 'anonymous_access', read: true, write: true }),
+        new Permission({ accessType: 'god_access', read: true, write: true })
+      ],
+      triggers: [trigger]
+    });
+
+    // Register this new collection
+    await service.addCollectionDefinitionByList({
+      list: [testCollectionDef],
+      mongoOption: ctx.mongoOption // We need to access mongoOption from ctx
+    });
+
+    // 2. Perform operation via API
+    await ctx.request
+      .post('/data-provider/insert-one')
+      .set('authorization', ctx.adminToken)
+      .send({
+        database: 'test_db',
+        collection: 'trigger_test',
+        doc: { name: 'api_insert' }
+      })
+      .expect(200);
+
+    // Verify trigger called
+    expect(triggerCallback).toHaveBeenCalledTimes(1);
+    expect(triggerCallback.mock.calls[0][0].doc).toMatchObject({ name: 'api_insert' });
+
+    // 3. Perform operation via Mongoose Model directly
+    const Model = testCollectionDef.model;
+    await new Model({ name: 'direct_insert' }).save();
+
+    // Verify trigger called again
+    expect(triggerCallback).toHaveBeenCalledTimes(2);
+    expect(triggerCallback.mock.calls[1][0].doc).toMatchObject({ name: 'direct_insert' });
+  });
+
+  it('triggers find-one-and-update', async () => {
+    // 1. Setup Trigger
+    const { defineCollection } = require('../../src/class/collection_definition');
+    const { Permission } = require('../../src/class/security');
+    const { DatabaseTrigger } = require('../../src/class/database_trigger');
+    const { Schema } = require('mongoose');
+    const service = require('../../src/services/data_provider/service');
+
+    const triggerCallback = jest.fn();
+    const trigger = new DatabaseTrigger('find-one-and-update', triggerCallback);
+
+    const testCollectionDef = defineCollection({
+      database: 'test_db',
+      collection: 'trigger_update_test',
+      schema: new Schema({ name: String, version: Number }),
+      permissions: [
+        new Permission({ accessType: 'anonymous_access', read: true, write: true }),
+        new Permission({ accessType: 'god_access', read: true, write: true })
+      ],
+      triggers: [trigger]
+    });
+
+    await service.addCollectionDefinitionByList({
+      list: [testCollectionDef],
+      mongoOption: ctx.mongoOption
+    });
+
+    // 2. Insert initial doc
+    const Model = testCollectionDef.model;
+    const doc = await new Model({ name: 'initial', version: 1 }).save();
+
+    // 3. Update via Mongoose
+    await Model.findOneAndUpdate({ _id: doc._id }, { $set: { version: 2 } });
+
+    // 4. Verify Trigger
+    expect(triggerCallback).toHaveBeenCalledTimes(1);
+    expect(triggerCallback.mock.calls[0][0].query).toMatchObject({ _id: doc._id });
+    expect(triggerCallback.mock.calls[0][0].update).toMatchObject({ $set: { version: 2 } });
+  });
+
+  it('triggers delete-many', async () => {
+    // 1. Setup Trigger
+    const { defineCollection } = require('../../src/class/collection_definition');
+    const { Permission } = require('../../src/class/security');
+    const { DatabaseTrigger } = require('../../src/class/database_trigger');
+    const { Schema } = require('mongoose');
+    const service = require('../../src/services/data_provider/service');
+
+    const triggerCallback = jest.fn();
+    const trigger = new DatabaseTrigger('delete-many', triggerCallback);
+
+    const testCollectionDef = defineCollection({
+      database: 'test_db',
+      collection: 'trigger_delete_many_test',
+      schema: new Schema({ name: String }),
+      permissions: [
+        new Permission({ accessType: 'anonymous_access', read: true, write: true }),
+        new Permission({ accessType: 'god_access', read: true, write: true })
+      ],
+      triggers: [trigger]
+    });
+
+    await service.addCollectionDefinitionByList({
+      list: [testCollectionDef],
+      mongoOption: ctx.mongoOption
+    });
+
+    // 2. Insert docs
+    const Model = testCollectionDef.model;
+    await Model.insertMany([{ name: 'doc1' }, { name: 'doc2' }]);
+
+    // 3. Delete via Mongoose
+    await Model.deleteMany({ name: { $regex: 'doc' } });
+
+    // 4. Verify Trigger
+    expect(triggerCallback).toHaveBeenCalledTimes(1);
+    expect(triggerCallback.mock.calls[0][0].query).toMatchObject({ name: { $regex: 'doc' } });
+    expect(triggerCallback.mock.calls[0][0].queryResult.deletedCount).toBe(2);
+  });
 });