crud-api-express 1.2.5 → 1.2.6

package/dist/index.cjs

@@ -2,6 +2,12 @@
 
 var express = require('express');
 
+/**
+ * A generic CRUD Controller for Express/Mongoose API development.
+ *
+ * It registers standard CRUD endpoints based on the provided model and endpoint string,
+ * along with any custom routes.
+ */
 class CrudController {
     constructor(model, endpoint, options = {}) {
         this.model = model;
@@ -10,37 +16,58 @@ class CrudController {
         this.routes = [];
         this.configureRoutes(options);
     }
+    /**
+     * Applies middleware to the route handler.
+     * @param routeHandler The original route handler.
+     * @param middlewareList Optional array of middleware functions.
+     * @returns Array of middleware functions including the route handler.
+     */
+    applyMiddleware(handler, middleware) {
+        return [...middleware, handler];
+    }
+    /**
+     * Registers route definitions to the internal list.
+     * @param method HTTP method.
+     * @param path URL path.
+     * @param params Optional route parameter names.
+     */
+    registerRoute(method, path, params) {
+        this.routes.push({ method, path, params });
+    }
+    /**
+     * Configures all endpoints based on given options.
+     * @param options CrudOptions to setup CRUD behaviors.
+     */
     configureRoutes(options) {
+        // Destructure and set default middleware and callbacks
         const { middleware = [], onSuccess = (res, method, result) => res.status(200).send(result), onError = (res, method, error) => res.status(400).send(error), methods = ['POST', 'GET', 'PUT', 'DELETE'] } = options;
-        const applyMiddleware = (routeHandler) => {
-            return [...middleware, routeHandler];
-        };
-        // Helper to register a route
-        const registerRoute = (method, path, params) => {
-            this.routes.push({ method, path, params });
-        };
-        // Create
+        // CREATE operation - POST /endpoint
         if (methods.includes('POST')) {
             const path = `/${this.endpoint}`;
-            this.router.post(path, applyMiddleware(async (req, res) => {
+            this.router.post(path, this.applyMiddleware(async (req, res) => {
                 const method = 'POST';
                 try {
                     const result = await this.model.create(req.body);
+                    // If a related model is defined and supports POST, create related entry
                     if (options.relatedModel && options.relatedMethods?.includes('POST')) {
-                        await options.relatedModel.create({ [options.relatedField]: result._id, ...req.body });
+                        await options.relatedModel.create({
+                            [options.relatedField]: result._id,
+                            ...req.body
+                        });
                     }
-                    onSuccess(res, method, result);
+                    // Return 201 Created status if successful
+                    onSuccess(res.status(201), method, result);
                 }
                 catch (error) {
                     onError(res, method, error);
                 }
-            }));
-            registerRoute('POST', path);
+            }, middleware));
+            this.registerRoute('POST', path);
         }
-        // Read all
+        // READ ALL operation - GET /endpoint
         if (methods.includes('GET')) {
             const path = `/${this.endpoint}`;
-            this.router.get(path, applyMiddleware(async (req, res) => {
+            this.router.get(path, this.applyMiddleware(async (req, res) => {
                 const method = 'GET';
                 try {
                     const { filter, sort, page, limit } = req.query;
@@ -51,6 +78,7 @@ class CrudController {
                     const skip = (pageNumber - 1) * pageSize;
                     let items;
                     if (options.relatedModel && options.relatedMethods?.includes('GET')) {
+                        // Use aggregation with lookup if related model exists
                         items = await this.model.aggregate([
                             { $match: query },
                             {
@@ -74,13 +102,13 @@ class CrudController {
                 catch (error) {
                     onError(res, method, error);
                 }
-            }));
-            registerRoute('GET', path, ['filter', 'sort', 'page', 'limit']);
+            }, middleware));
+            this.registerRoute('GET', path, ['filter', 'sort', 'page', 'limit']);
         }
-        // Read one
+        // READ ONE operation - GET /endpoint/:id
         if (methods.includes('GET')) {
             const path = `/${this.endpoint}/:id`;
-            this.router.get(path, applyMiddleware(async (req, res) => {
+            this.router.get(path, this.applyMiddleware(async (req, res) => {
                 const method = 'GET';
                 try {
                     let item;
@@ -96,32 +124,33 @@ class CrudController {
                                 }
                             }
                         ]);
-                        item = aggregateResult[0];
+                        item = aggregateResult[0] || null;
                     }
                     else {
                         item = await this.model.findById(req.params.id);
                     }
                     if (!item) {
-                        return res.status(404).send();
+                        return res.status(404).send({ message: 'Item not found' });
                     }
                     onSuccess(res, method, item);
                 }
                 catch (error) {
                     onError(res, method, error);
                 }
-            }));
-            registerRoute('GET', path, ['id']);
+            }, middleware));
+            this.registerRoute('GET', path, ['id']);
         }
-        // Update
+        // UPDATE operation - PUT /endpoint/:id
         if (methods.includes('PUT')) {
             const path = `/${this.endpoint}/:id`;
-            this.router.put(path, applyMiddleware(async (req, res) => {
+            this.router.put(path, this.applyMiddleware(async (req, res) => {
                 const method = 'PUT';
                 try {
                     const item = await this.model.findByIdAndUpdate(req.params.id, req.body, { new: true, runValidators: true });
                     if (!item) {
-                        return res.status(404).send();
+                        return res.status(404).send({ message: 'Item not found' });
                     }
+                    // Update related model entries if configured
                     if (options.relatedModel && options.relatedMethods?.includes('PUT')) {
                         await options.relatedModel.updateMany({ [options.relatedField]: item._id }, req.body);
                     }
@@ -130,19 +159,19 @@ class CrudController {
                 catch (error) {
                     onError(res, method, error);
                 }
-            }));
-            registerRoute('PUT', path, ['id']);
+            }, middleware));
+            this.registerRoute('PUT', path, ['id']);
         }
-        // Delete multiple
+        // DELETE MULTIPLE operation - DELETE /endpoint?filter=...
         if (methods.includes('DELETE')) {
             const path = `/${this.endpoint}`;
-            this.router.delete(path, applyMiddleware(async (req, res) => {
+            this.router.delete(path, this.applyMiddleware(async (req, res) => {
                 const method = 'DELETE';
                 try {
                     const query = req.query.filter ? JSON.parse(req.query.filter) : {};
                     const deleteResult = await this.model.deleteMany(query);
                     if (deleteResult.deletedCount === 0) {
-                        return res.status(404).send();
+                        return res.status(404).send({ message: 'No matching items found to delete' });
                     }
                     if (options.relatedModel && options.relatedMethods?.includes('DELETE')) {
                         await options.relatedModel.deleteMany({ [options.relatedField]: { $in: query } });
@@ -152,18 +181,18 @@ class CrudController {
                 catch (error) {
                     onError(res, method, error);
                 }
-            }));
-            registerRoute('DELETE', path, ['filter']);
+            }, middleware));
+            this.registerRoute('DELETE', path, ['filter']);
         }
-        // Delete one
+        // DELETE ONE operation - DELETE /endpoint/:id
         if (methods.includes('DELETE')) {
             const path = `/${this.endpoint}/:id`;
-            this.router.delete(path, applyMiddleware(async (req, res) => {
+            this.router.delete(path, this.applyMiddleware(async (req, res) => {
                 const method = 'DELETE';
                 try {
                     const item = await this.model.findByIdAndDelete(req.params.id);
                     if (!item) {
-                        return res.status(404).send();
+                        return res.status(404).send({ message: 'Item not found' });
                     }
                     if (options.relatedModel && options.relatedMethods?.includes('DELETE')) {
                         await options.relatedModel.deleteMany({ [options.relatedField]: item._id });
@@ -173,39 +202,46 @@ class CrudController {
                 catch (error) {
                     onError(res, method, error);
                 }
-            }));
-            registerRoute('DELETE', path, ['id']);
+            }, middleware));
+            this.registerRoute('DELETE', path, ['id']);
         }
-        // Aggregate
+        // AGGREGATE operation - GET /endpoint/aggregate
         if (methods.includes('GET') && options.aggregatePipeline) {
             const path = `/${this.endpoint}/aggregate`;
-            this.router.get(path, applyMiddleware(async (req, res) => {
+            this.router.get(path, this.applyMiddleware(async (req, res) => {
                 const method = 'GET (Aggregate)';
                 try {
-                    const pipeline = options.aggregatePipeline ?? [];
+                    const pipeline = options.aggregatePipeline || [];
                     const results = await this.model.aggregate(pipeline);
                     onSuccess(res, method, results);
                 }
                 catch (error) {
                     onError(res, method, error);
                 }
-            }));
-            registerRoute('GET', path);
+            }, middleware));
+            this.registerRoute('GET', path);
         }
-        // Custom routes
+        // CUSTOM ROUTES
         if (options.customRoutes) {
             options.customRoutes.forEach(route => {
                 const { method, path, handler } = route;
                 if (methods.includes(method.toUpperCase())) {
-                    this.router[method](`/${this.endpoint}${path}`, applyMiddleware(handler));
-                    registerRoute(method.toUpperCase(), `/${this.endpoint}${path}`);
+                    // Prepend base endpoint to custom route path
+                    this.router[method](`/${this.endpoint}${path}`, this.applyMiddleware(handler, middleware));
+                    this.registerRoute(method.toUpperCase(), `/${this.endpoint}${path}`);
                 }
             });
         }
     }
+    /**
+     * Returns the configured Express router.
+     */
     getRouter() {
         return this.router;
     }
+    /**
+     * Returns an array of registered route definitions.
+     */
     getRoutes() {
         return this.routes;
     }

package/dist/index.d.ts

@@ -25,9 +25,12 @@
 /// <reference types="mongoose/types/inferrawdoctype" />
 import { Request, Response, Router, NextFunction } from 'express';
 import { Document, Model } from 'mongoose';
-interface CrudOptions<T extends Document> {
+/**
+ * Options for configuring the CRUD controller behavior.
+ */
+export interface CrudOptions<T extends Document> {
     middleware?: ((req: Request, res: Response, next: NextFunction) => void)[];
-    onSuccess?: (res: Response, method: string, result: T | T[]) => void;
+    onSuccess?: (res: Response, method: string, result: T | T[] | any) => void;
     onError?: (res: Response, method: string, error: Error) => void;
     methods?: ('POST' | 'GET' | 'PUT' | 'DELETE')[];
     relatedModel?: Model<any>;
@@ -40,14 +43,44 @@ interface CrudOptions<T extends Document> {
         handler: (req: Request, res: Response) => void;
     }[];
 }
+/**
+ * A generic CRUD Controller for Express/Mongoose API development.
+ *
+ * It registers standard CRUD endpoints based on the provided model and endpoint string,
+ * along with any custom routes.
+ */
 declare class CrudController<T extends Document> {
     private model;
     private endpoint;
     private router;
     private routes;
     constructor(model: Model<T>, endpoint: string, options?: CrudOptions<T>);
+    /**
+     * Applies middleware to the route handler.
+     * @param routeHandler The original route handler.
+     * @param middlewareList Optional array of middleware functions.
+     * @returns Array of middleware functions including the route handler.
+     */
+    private applyMiddleware;
+    /**
+     * Registers route definitions to the internal list.
+     * @param method HTTP method.
+     * @param path URL path.
+     * @param params Optional route parameter names.
+     */
+    private registerRoute;
+    /**
+     * Configures all endpoints based on given options.
+     * @param options CrudOptions to setup CRUD behaviors.
+     */
     private configureRoutes;
+    /**
+     * Returns the configured Express router.
+     */
     getRouter(): Router;
+    /**
+     * Returns an array of registered route definitions.
+     */
     getRoutes(): {
         method: string;
         path: string;

package/dist/index.mjs

@@ -1,5 +1,11 @@
 import { Router } from 'express';
 
+/**
+ * A generic CRUD Controller for Express/Mongoose API development.
+ *
+ * It registers standard CRUD endpoints based on the provided model and endpoint string,
+ * along with any custom routes.
+ */
 class CrudController {
     constructor(model, endpoint, options = {}) {
         this.model = model;
@@ -8,37 +14,58 @@ class CrudController {
         this.routes = [];
         this.configureRoutes(options);
     }
+    /**
+     * Applies middleware to the route handler.
+     * @param routeHandler The original route handler.
+     * @param middlewareList Optional array of middleware functions.
+     * @returns Array of middleware functions including the route handler.
+     */
+    applyMiddleware(handler, middleware) {
+        return [...middleware, handler];
+    }
+    /**
+     * Registers route definitions to the internal list.
+     * @param method HTTP method.
+     * @param path URL path.
+     * @param params Optional route parameter names.
+     */
+    registerRoute(method, path, params) {
+        this.routes.push({ method, path, params });
+    }
+    /**
+     * Configures all endpoints based on given options.
+     * @param options CrudOptions to setup CRUD behaviors.
+     */
     configureRoutes(options) {
+        // Destructure and set default middleware and callbacks
         const { middleware = [], onSuccess = (res, method, result) => res.status(200).send(result), onError = (res, method, error) => res.status(400).send(error), methods = ['POST', 'GET', 'PUT', 'DELETE'] } = options;
-        const applyMiddleware = (routeHandler) => {
-            return [...middleware, routeHandler];
-        };
-        // Helper to register a route
-        const registerRoute = (method, path, params) => {
-            this.routes.push({ method, path, params });
-        };
-        // Create
+        // CREATE operation - POST /endpoint
         if (methods.includes('POST')) {
             const path = `/${this.endpoint}`;
-            this.router.post(path, applyMiddleware(async (req, res) => {
+            this.router.post(path, this.applyMiddleware(async (req, res) => {
                 const method = 'POST';
                 try {
                     const result = await this.model.create(req.body);
+                    // If a related model is defined and supports POST, create related entry
                     if (options.relatedModel && options.relatedMethods?.includes('POST')) {
-                        await options.relatedModel.create({ [options.relatedField]: result._id, ...req.body });
+                        await options.relatedModel.create({
+                            [options.relatedField]: result._id,
+                            ...req.body
+                        });
                     }
-                    onSuccess(res, method, result);
+                    // Return 201 Created status if successful
+                    onSuccess(res.status(201), method, result);
                 }
                 catch (error) {
                     onError(res, method, error);
                 }
-            }));
-            registerRoute('POST', path);
+            }, middleware));
+            this.registerRoute('POST', path);
         }
-        // Read all
+        // READ ALL operation - GET /endpoint
         if (methods.includes('GET')) {
             const path = `/${this.endpoint}`;
-            this.router.get(path, applyMiddleware(async (req, res) => {
+            this.router.get(path, this.applyMiddleware(async (req, res) => {
                 const method = 'GET';
                 try {
                     const { filter, sort, page, limit } = req.query;
@@ -49,6 +76,7 @@ class CrudController {
                     const skip = (pageNumber - 1) * pageSize;
                     let items;
                     if (options.relatedModel && options.relatedMethods?.includes('GET')) {
+                        // Use aggregation with lookup if related model exists
                         items = await this.model.aggregate([
                             { $match: query },
                             {
@@ -72,13 +100,13 @@ class CrudController {
                 catch (error) {
                     onError(res, method, error);
                 }
-            }));
-            registerRoute('GET', path, ['filter', 'sort', 'page', 'limit']);
+            }, middleware));
+            this.registerRoute('GET', path, ['filter', 'sort', 'page', 'limit']);
         }
-        // Read one
+        // READ ONE operation - GET /endpoint/:id
         if (methods.includes('GET')) {
             const path = `/${this.endpoint}/:id`;
-            this.router.get(path, applyMiddleware(async (req, res) => {
+            this.router.get(path, this.applyMiddleware(async (req, res) => {
                 const method = 'GET';
                 try {
                     let item;
@@ -94,32 +122,33 @@ class CrudController {
                                 }
                             }
                         ]);
-                        item = aggregateResult[0];
+                        item = aggregateResult[0] || null;
                     }
                     else {
                         item = await this.model.findById(req.params.id);
                     }
                     if (!item) {
-                        return res.status(404).send();
+                        return res.status(404).send({ message: 'Item not found' });
                     }
                     onSuccess(res, method, item);
                 }
                 catch (error) {
                     onError(res, method, error);
                 }
-            }));
-            registerRoute('GET', path, ['id']);
+            }, middleware));
+            this.registerRoute('GET', path, ['id']);
         }
-        // Update
+        // UPDATE operation - PUT /endpoint/:id
         if (methods.includes('PUT')) {
             const path = `/${this.endpoint}/:id`;
-            this.router.put(path, applyMiddleware(async (req, res) => {
+            this.router.put(path, this.applyMiddleware(async (req, res) => {
                 const method = 'PUT';
                 try {
                     const item = await this.model.findByIdAndUpdate(req.params.id, req.body, { new: true, runValidators: true });
                     if (!item) {
-                        return res.status(404).send();
+                        return res.status(404).send({ message: 'Item not found' });
                     }
+                    // Update related model entries if configured
                     if (options.relatedModel && options.relatedMethods?.includes('PUT')) {
                         await options.relatedModel.updateMany({ [options.relatedField]: item._id }, req.body);
                     }
@@ -128,19 +157,19 @@ class CrudController {
                 catch (error) {
                     onError(res, method, error);
                 }
-            }));
-            registerRoute('PUT', path, ['id']);
+            }, middleware));
+            this.registerRoute('PUT', path, ['id']);
         }
-        // Delete multiple
+        // DELETE MULTIPLE operation - DELETE /endpoint?filter=...
         if (methods.includes('DELETE')) {
             const path = `/${this.endpoint}`;
-            this.router.delete(path, applyMiddleware(async (req, res) => {
+            this.router.delete(path, this.applyMiddleware(async (req, res) => {
                 const method = 'DELETE';
                 try {
                     const query = req.query.filter ? JSON.parse(req.query.filter) : {};
                     const deleteResult = await this.model.deleteMany(query);
                     if (deleteResult.deletedCount === 0) {
-                        return res.status(404).send();
+                        return res.status(404).send({ message: 'No matching items found to delete' });
                     }
                     if (options.relatedModel && options.relatedMethods?.includes('DELETE')) {
                         await options.relatedModel.deleteMany({ [options.relatedField]: { $in: query } });
@@ -150,18 +179,18 @@ class CrudController {
                 catch (error) {
                     onError(res, method, error);
                 }
-            }));
-            registerRoute('DELETE', path, ['filter']);
+            }, middleware));
+            this.registerRoute('DELETE', path, ['filter']);
         }
-        // Delete one
+        // DELETE ONE operation - DELETE /endpoint/:id
         if (methods.includes('DELETE')) {
             const path = `/${this.endpoint}/:id`;
-            this.router.delete(path, applyMiddleware(async (req, res) => {
+            this.router.delete(path, this.applyMiddleware(async (req, res) => {
                 const method = 'DELETE';
                 try {
                     const item = await this.model.findByIdAndDelete(req.params.id);
                     if (!item) {
-                        return res.status(404).send();
+                        return res.status(404).send({ message: 'Item not found' });
                     }
                     if (options.relatedModel && options.relatedMethods?.includes('DELETE')) {
                         await options.relatedModel.deleteMany({ [options.relatedField]: item._id });
@@ -171,39 +200,46 @@ class CrudController {
                 catch (error) {
                     onError(res, method, error);
                 }
-            }));
-            registerRoute('DELETE', path, ['id']);
+            }, middleware));
+            this.registerRoute('DELETE', path, ['id']);
         }
-        // Aggregate
+        // AGGREGATE operation - GET /endpoint/aggregate
         if (methods.includes('GET') && options.aggregatePipeline) {
             const path = `/${this.endpoint}/aggregate`;
-            this.router.get(path, applyMiddleware(async (req, res) => {
+            this.router.get(path, this.applyMiddleware(async (req, res) => {
                 const method = 'GET (Aggregate)';
                 try {
-                    const pipeline = options.aggregatePipeline ?? [];
+                    const pipeline = options.aggregatePipeline || [];
                     const results = await this.model.aggregate(pipeline);
                     onSuccess(res, method, results);
                 }
                 catch (error) {
                     onError(res, method, error);
                 }
-            }));
-            registerRoute('GET', path);
+            }, middleware));
+            this.registerRoute('GET', path);
         }
-        // Custom routes
+        // CUSTOM ROUTES
         if (options.customRoutes) {
             options.customRoutes.forEach(route => {
                 const { method, path, handler } = route;
                 if (methods.includes(method.toUpperCase())) {
-                    this.router[method](`/${this.endpoint}${path}`, applyMiddleware(handler));
-                    registerRoute(method.toUpperCase(), `/${this.endpoint}${path}`);
+                    // Prepend base endpoint to custom route path
+                    this.router[method](`/${this.endpoint}${path}`, this.applyMiddleware(handler, middleware));
+                    this.registerRoute(method.toUpperCase(), `/${this.endpoint}${path}`);
                 }
             });
         }
     }
+    /**
+     * Returns the configured Express router.
+     */
     getRouter() {
         return this.router;
     }
+    /**
+     * Returns an array of registered route definitions.
+     */
     getRoutes() {
         return this.routes;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "crud-api-express",
-  "version": "1.2.5",
+  "version": "1.2.6",
   "type": "module",
   "description": "",
   "main": "dist/index.js",

package/src/index.ts

@@ -1,23 +1,36 @@
 import { Request, Response, Router, NextFunction } from 'express';
 import { Document, Model, Aggregate } from 'mongoose';
 
-interface CrudOptions<T extends Document> {
+/**
+ * Options for configuring the CRUD controller behavior.
+ */
+export interface CrudOptions<T extends Document> {
   middleware?: ((req: Request, res: Response, next: NextFunction) => void)[];
-  onSuccess?: (res: Response, method: string, result: T | T[]) => void;
+  onSuccess?: (res: Response, method: string, result: T | T[] | any) => void;
   onError?: (res: Response, method: string, error: Error) => void;
   methods?: ('POST' | 'GET' | 'PUT' | 'DELETE')[];
   relatedModel?: Model<any>;
   relatedField?: string;
   relatedMethods?: ('POST' | 'GET' | 'PUT' | 'DELETE')[];
   aggregatePipeline?: object[];
-  customRoutes?: { method: 'post' | 'get' | 'put' | 'delete', path: string, handler: (req: Request, res: Response) => void }[];
+  customRoutes?: {
+    method: 'post' | 'get' | 'put' | 'delete',
+    path: string,
+    handler: (req: Request, res: Response) => void
+  }[];
 }
 
+/**
+ * A generic CRUD Controller for Express/Mongoose API development.
+ * 
+ * It registers standard CRUD endpoints based on the provided model and endpoint string,
+ * along with any custom routes.
+ */
 class CrudController<T extends Document> {
   private model: Model<T>;
   private endpoint: string;
   private router: Router;
-  private routes: { method: string, path: string, params?: string[] }[];
+  private routes: { method: string; path: string; params?: string[] }[];
 
   constructor(model: Model<T>, endpoint: string, options: CrudOptions<T> = {}) {
     this.model = model;
@@ -27,7 +40,33 @@ class CrudController<T extends Document> {
     this.configureRoutes(options);
   }
 
+  /**
+   * Applies middleware to the route handler.
+   * @param routeHandler The original route handler.
+   * @param middlewareList Optional array of middleware functions.
+   * @returns Array of middleware functions including the route handler.
+   */
+ private applyMiddleware(handler: (req: Request, res: Response) => void, middleware: ((req: Request, res: Response, next: NextFunction) => void)[]) {
+  return [...middleware, handler];
+}
+
+
+  /**
+   * Registers route definitions to the internal list.
+   * @param method HTTP method.
+   * @param path URL path.
+   * @param params Optional route parameter names.
+   */
+  private registerRoute(method: string, path: string, params?: string[]) {
+    this.routes.push({ method, path, params });
+  }
+
+  /**
+   * Configures all endpoints based on given options.
+   * @param options CrudOptions to setup CRUD behaviors.
+   */
   private configureRoutes(options: CrudOptions<T>) {
+    // Destructure and set default middleware and callbacks
     const {
       middleware = [],
       onSuccess = (res, method, result) => res.status(200).send(result),
@@ -35,204 +74,230 @@ class CrudController<T extends Document> {
       methods = ['POST', 'GET', 'PUT', 'DELETE']
     } = options;
 
-    const applyMiddleware = (routeHandler: (req: Request, res: Response) => void) => {
-      return [...middleware, routeHandler];
-    };
-
-    // Helper to register a route
-    const registerRoute = (method: string, path: string, params?: string[]) => {
-      this.routes.push({ method, path, params });
-    };
-
-    // Create
+    // CREATE operation - POST /endpoint
     if (methods.includes('POST')) {
       const path = `/${this.endpoint}`;
-      this.router.post(path, applyMiddleware(async (req, res) => {
-        const method = 'POST';
-        try {
-          const result: any = await this.model.create(req.body);
-          if (options.relatedModel && options.relatedMethods?.includes('POST')) {
-            await options.relatedModel.create({ [options.relatedField!]: result._id, ...req.body });
+      this.router.post(
+        path,
+        this.applyMiddleware(async (req, res) => {
+          const method = 'POST';
+          try {
+            const result: any = await this.model.create(req.body);
+            // If a related model is defined and supports POST, create related entry
+            if (options.relatedModel && options.relatedMethods?.includes('POST')) {
+              await options.relatedModel.create({
+                [options.relatedField!]: result._id,
+                ...req.body
+              });
+            }
+            // Return 201 Created status if successful
+            onSuccess(res.status(201), method, result);
+          } catch (error: any) {
+            onError(res, method, error);
           }
-          onSuccess(res, method, result);
-        } catch (error: any) {
-          onError(res, method, error);
-        }
-      }));
-      registerRoute('POST', path);
+        }, middleware)
+      );
+      this.registerRoute('POST', path);
     }
 
-    // Read all
+    // READ ALL operation - GET /endpoint
     if (methods.includes('GET')) {
       const path = `/${this.endpoint}`;
-      this.router.get(path, applyMiddleware(async (req, res) => {
-        const method = 'GET';
-        try {
-          const { filter, sort, page, limit } = req.query;
-          const query = filter ? JSON.parse(filter as string) : {};
-          const sortOrder = sort ? JSON.parse(sort as string) : {};
-          const pageNumber = parseInt(page as string, 10) || 1;
-          const pageSize = parseInt(limit as string, 10) || 10;
-          const skip = (pageNumber - 1) * pageSize;
-
-          let items: T[] | Aggregate<any[]>;
-          if (options.relatedModel && options.relatedMethods?.includes('GET')) {
-            items = await this.model.aggregate([
-              { $match: query },
-              {
-                $lookup: {
-                  from: options.relatedModel.collection.name,
-                  localField: options.relatedField!,
-                  foreignField: '_id',
-                  as: 'relatedData'
-                }
-              },
-              { $sort: sortOrder },
-              { $skip: skip },
-              { $limit: pageSize }
-            ]);
-          } else {
-            items = await this.model.find(query).sort(sortOrder).skip(skip).limit(pageSize);
+      this.router.get(
+        path,
+        this.applyMiddleware(async (req, res) => {
+          const method = 'GET';
+          try {
+            const { filter, sort, page, limit } = req.query;
+            const query = filter ? JSON.parse(filter as string) : {};
+            const sortOrder = sort ? JSON.parse(sort as string) : {};
+            const pageNumber = parseInt(page as string, 10) || 1;
+            const pageSize = parseInt(limit as string, 10) || 10;
+            const skip = (pageNumber - 1) * pageSize;
+
+            let items: T[] | Aggregate<any[]>;
+            if (options.relatedModel && options.relatedMethods?.includes('GET')) {
+              // Use aggregation with lookup if related model exists
+              items = await this.model.aggregate([
+                { $match: query },
+                {
+                  $lookup: {
+                    from: options.relatedModel.collection.name,
+                    localField: options.relatedField!,
+                    foreignField: '_id',
+                    as: 'relatedData'
+                  }
+                },
+                { $sort: sortOrder },
+                { $skip: skip },
+                { $limit: pageSize }
+              ]);
+            } else {
+              items = await this.model.find(query).sort(sortOrder).skip(skip).limit(pageSize);
+            }
+            onSuccess(res, method, items);
+          } catch (error: any) {
+            onError(res, method, error);
           }
-          onSuccess(res, method, items);
-        } catch (error: any) {
-          onError(res, method, error);
-        }
-      }));
-      registerRoute('GET', path, ['filter', 'sort', 'page', 'limit']);
+        }, middleware)
+      );
+      this.registerRoute('GET', path, ['filter', 'sort', 'page', 'limit']);
     }
 
-    // Read one
+    // READ ONE operation - GET /endpoint/:id
     if (methods.includes('GET')) {
       const path = `/${this.endpoint}/:id`;
-      this.router.get(path, applyMiddleware(async (req, res) => {
-        const method = 'GET';
-        try {
-          let item: T | null;
-          if (options.relatedModel && options.relatedMethods?.includes('GET')) {
-            const aggregateResult = await this.model.aggregate([
-              { $match: { _id: req.params.id } },
-              {
-                $lookup: {
-                  from: options.relatedModel.collection.name,
-                  localField: options.relatedField!,
-                  foreignField: '_id',
-                  as: 'relatedData'
+      this.router.get(
+        path,
+        this.applyMiddleware(async (req, res) => {
+          const method = 'GET';
+          try {
+            let item: T | null;
+            if (options.relatedModel && options.relatedMethods?.includes('GET')) {
+              const aggregateResult = await this.model.aggregate([
+                { $match: { _id: req.params.id } },
+                {
+                  $lookup: {
+                    from: options.relatedModel.collection.name,
+                    localField: options.relatedField!,
+                    foreignField: '_id',
+                    as: 'relatedData'
+                  }
                 }
-              }
-            ]);
-            item = aggregateResult[0] as T;
-          } else {
-            item = await this.model.findById(req.params.id);
+              ]);
+              item = aggregateResult[0] as T || null;
+            } else {
+              item = await this.model.findById(req.params.id);
+            }
+            if (!item) {
+              return res.status(404).send({ message: 'Item not found' });
+            }
+            onSuccess(res, method, item);
+          } catch (error: any) {
+            onError(res, method, error);
           }
-          if (!item) {
-            return res.status(404).send();
-          }
-          onSuccess(res, method, item);
-        } catch (error: any) {
-          onError(res, method, error);
-        }
-      }));
-      registerRoute('GET', path, ['id']);
+        }, middleware)
+      );
+      this.registerRoute('GET', path, ['id']);
     }
 
-    // Update
+    // UPDATE operation - PUT /endpoint/:id
     if (methods.includes('PUT')) {
       const path = `/${this.endpoint}/:id`;
-      this.router.put(path, applyMiddleware(async (req, res) => {
-        const method = 'PUT';
-        try {
-          const item = await this.model.findByIdAndUpdate(req.params.id, req.body, { new: true, runValidators: true });
-          if (!item) {
-            return res.status(404).send();
-          }
-          if (options.relatedModel && options.relatedMethods?.includes('PUT')) {
-            await options.relatedModel.updateMany({ [options.relatedField!]: item._id }, req.body);
+      this.router.put(
+        path,
+        this.applyMiddleware(async (req, res) => {
+          const method = 'PUT';
+          try {
+            const item = await this.model.findByIdAndUpdate(req.params.id, req.body, { new: true, runValidators: true });
+            if (!item) {
+              return res.status(404).send({ message: 'Item not found' });
+            }
+            // Update related model entries if configured
+            if (options.relatedModel && options.relatedMethods?.includes('PUT')) {
+              await options.relatedModel.updateMany({ [options.relatedField!]: item._id }, req.body);
+            }
+            onSuccess(res, method, item);
+          } catch (error: any) {
+            onError(res, method, error);
           }
-          onSuccess(res, method, item);
-        } catch (error: any) {
-          onError(res, method, error);
-        }
-      }));
-      registerRoute('PUT', path, ['id']);
+        }, middleware)
+      );
+      this.registerRoute('PUT', path, ['id']);
     }
 
-    // Delete multiple
+    // DELETE MULTIPLE operation - DELETE /endpoint?filter=...
     if (methods.includes('DELETE')) {
       const path = `/${this.endpoint}`;
-      this.router.delete(path, applyMiddleware(async (req, res) => {
-        const method = 'DELETE';
-        try {
-          const query = req.query.filter ? JSON.parse(req.query.filter as string) : {};
-          const deleteResult: any = await this.model.deleteMany(query);
-          if (deleteResult.deletedCount === 0) {
-            return res.status(404).send();
-          }
-          if (options.relatedModel && options.relatedMethods?.includes('DELETE')) {
-            await options.relatedModel.deleteMany({ [options.relatedField!]: { $in: query } });
+      this.router.delete(
+        path,
+        this.applyMiddleware(async (req, res) => {
+          const method = 'DELETE';
+          try {
+            const query = req.query.filter ? JSON.parse(req.query.filter as string) : {};
+            const deleteResult: any = await this.model.deleteMany(query);
+            if (deleteResult.deletedCount === 0) {
+              return res.status(404).send({ message: 'No matching items found to delete' });
+            }
+            if (options.relatedModel && options.relatedMethods?.includes('DELETE')) {
+              await options.relatedModel.deleteMany({ [options.relatedField!]: { $in: query } });
+            }
+            onSuccess(res, method, deleteResult);
+          } catch (error: any) {
+            onError(res, method, error);
           }
-          onSuccess(res, method, deleteResult);
-        } catch (error: any) {
-          onError(res, method, error);
-        }
-      }));
-      registerRoute('DELETE', path, ['filter']);
+        }, middleware)
+      );
+      this.registerRoute('DELETE', path, ['filter']);
     }
 
-    // Delete one
+    // DELETE ONE operation - DELETE /endpoint/:id
     if (methods.includes('DELETE')) {
       const path = `/${this.endpoint}/:id`;
-      this.router.delete(path, applyMiddleware(async (req, res) => {
-        const method = 'DELETE';
-        try {
-          const item = await this.model.findByIdAndDelete(req.params.id);
-          if (!item) {
-            return res.status(404).send();
-          }
-          if (options.relatedModel && options.relatedMethods?.includes('DELETE')) {
-            await options.relatedModel.deleteMany({ [options.relatedField!]: item._id });
+      this.router.delete(
+        path,
+        this.applyMiddleware(async (req, res) => {
+          const method = 'DELETE';
+          try {
+            const item = await this.model.findByIdAndDelete(req.params.id);
+            if (!item) {
+              return res.status(404).send({ message: 'Item not found' });
+            }
+            if (options.relatedModel && options.relatedMethods?.includes('DELETE')) {
+              await options.relatedModel.deleteMany({ [options.relatedField!]: item._id });
+            }
+            onSuccess(res, method, item);
+          } catch (error: any) {
+            onError(res, method, error);
           }
-          onSuccess(res, method, item);
-        } catch (error: any) {
-          onError(res, method, error);
-        }
-      }));
-      registerRoute('DELETE', path, ['id']);
+        }, middleware)
+      );
+      this.registerRoute('DELETE', path, ['id']);
     }
 
-    // Aggregate
+    // AGGREGATE operation - GET /endpoint/aggregate
     if (methods.includes('GET') && options.aggregatePipeline) {
       const path = `/${this.endpoint}/aggregate`;
-      this.router.get(path, applyMiddleware(async (req, res) => {
-        const method = 'GET (Aggregate)';
-        try {
-          const pipeline: any = options.aggregatePipeline ?? [];
-          const results = await this.model.aggregate(pipeline);
-          onSuccess(res, method, results);
-        } catch (error: any) {
-          onError(res, method, error);
-        }
-      }));
-      registerRoute('GET', path);
+      this.router.get(
+        path,
+        this.applyMiddleware(async (req, res) => {
+          const method = 'GET (Aggregate)';
+          try {
+            const pipeline: any[] = options.aggregatePipeline || [];
+            const results = await this.model.aggregate(pipeline);
+            onSuccess(res, method, results);
+          } catch (error: any) {
+            onError(res, method, error);
+          }
+        }, middleware)
+      );
+      this.registerRoute('GET', path);
     }
 
-    // Custom routes
+    // CUSTOM ROUTES
     if (options.customRoutes) {
       options.customRoutes.forEach(route => {
         const { method, path, handler } = route;
         if (methods.includes(method.toUpperCase() as 'POST' | 'GET' | 'PUT' | 'DELETE')) {
-          this.router[method](`/${this.endpoint}${path}`, applyMiddleware(handler));
-          registerRoute(method.toUpperCase(), `/${this.endpoint}${path}`);
+          // Prepend base endpoint to custom route path
+          this.router[method](`/${this.endpoint}${path}`, this.applyMiddleware(handler, middleware));
+          this.registerRoute(method.toUpperCase(), `/${this.endpoint}${path}`);
         }
       });
     }
   }
 
+  /**
+   * Returns the configured Express router.
+   */
   public getRouter(): Router {
     return this.router;
   }
 
-  public getRoutes(): { method: string, path: string, params?: string[] }[] {
+  /**
+   * Returns an array of registered route definitions.
+   */
+  public getRoutes(): { method: string; path: string; params?: string[] }[] {
     return this.routes;
   }
 }