vanta-api 1.0.3 → 1.0.5

package/README.md

@@ -258,25 +258,73 @@ These configurations are applied automatically in methods such as `filter()`, `p
 
 ## Error Handling Middleware
 
-A dedicated error-handling middleware is available to centralize error responses:
+Vanta-API provides a centralized error handling system featuring three components:
+
+### 1. handleError
+
+**Purpose:**  
+A custom error class that extends the native JavaScript `Error`.  
+It adds:
+- **`statusCode`:** HTTP status code.
+- **`status`:** Determines if the error is a `"fail"` (client error) or `"error"` (server error).
+- **`isOperational`:** Flags if the error is an expected operational error.
+- **Stack Trace:** Captures the call stack for easier debugging.
+
+**Usage Example in an Async Function:**
+
+Inside an asynchronous function wrapped by **catchAsync**, you can use:
+
+```javascript
+// Inside your async route handler
+if (someConditionFails) {
+  return next(new handleError("Custom error message", 400));
+}
+```
+
+### 2. catchAsync
+
+**Purpose:**  
+A helper function that wraps asynchronous route handlers.  
+It automatically catches any thrown errors and forwards them via `next()`, avoiding repetitive try/catch blocks.
+
+**Usage Example:**
 
 ```javascript
-import catchError from "./errorHandler.js";
+app.get("/example", catchAsync(async (req, res, next) => {
+  // Your async logic here
+  // If an error occurs, use handleError as shown above
+  res.status(200).json({ data: "Success" });
+}));
+```
+
+### 3. catchError
+
+**Purpose:**  
+An Express middleware that catches any error passed along (either from synchronous or asynchronous routes).  
+It sets the appropriate HTTP status and returns a JSON response containing the error’s status and message.
+
+**Usage Example:**
 
-// In your Express app:
-// app.use(catchError);
+```javascript
+// At the end of your middleware stack:
+app.use(catchError);
 ```
 
-This middleware sets the appropriate HTTP status code and JSON error message when an error occurs.
+---
+
 
 ---
 
 ## Full Examples
 
 ### Example 1: Basic Query
+To import the package along with the error handling components, use:
+
+```javascript
+import ApiFeatures, { handleError, catchAsync, catchError } from "vanta-api";
+```
 
 ```javascript
-import ApiFeatures from "./api-features.js";
 import Product from "./models/product.js";
 
 // URL: /api/products?status=active&price[gte]=100&sort=-price,createdAt&fields=name,price,category&page=1&limit=10&populate=category,brand
@@ -362,9 +410,30 @@ console.log(result);
   Integrated advanced logging using winston and centralized error handling with a custom error class and middleware.
 - **Performance Optimizations:**  
   Supports aggregation cursor for large datasets and optimizes aggregation pipelines for efficient resource usage.
+  
+- **ApiFeatures:**  
+  Provides advanced query capabilities such as filtering, sorting, pagination, and document population for your MongoDB data.
+
+- **Error Handling Components:**
+  - **handleError:**  
+    Throw consistent, structured errors with custom messages and status codes.
+  - **catchAsync:**  
+    Wrap asynchronous route handlers to automatically propagate errors.
+  - **catchError:**  
+    Centralized middleware to catch and respond to errors uniformly.
+
+- **Importing:**  
+  Use the following statement to access all features:
+
+  ```javascript
+  import ApiFeatures, { handleError, catchAsync, catchError } from "vanta-api";
+  ```
+
+By following these guidelines, you can integrate and use Vanta-API for advanced, secure query handling and robust error management in your Node.js/Express projects.
 
 ---
 
 VantaApi provides a complete solution for integrating powerful, secure, and customizable query capabilities into any Node.js/MongoDB project.
 
----
+---
+

package/index.js

@@ -0,0 +1,6 @@
+import ApiFeatures from "./src/api-features.js";
+import catchError from "./src/errorHandler.js";
+import HandleERROR from "./src/handleError.js";
+import catchAsync from "./src/catchAsync.js";
+export {catchError,HandleERROR,catchAsync}
+export default ApiFeatures

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "vanta-api",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Advanced API features and security configuration for Node.js/MongoDB.",
-  "main": "src/api-features.js",
+  "main": "index.js",
   "scripts": {
     "postinstall": "node bin/create-security-config.js",
     "test": "jest",
-    "start": "node src/api-features.js"
+    "start": "node index.js"
   },
   "keywords": [
     "api",

package/src/api-features.js

@@ -1,4 +1,3 @@
-// api-features.js
 import mongoose from "mongoose";
 import winston from "winston";
 import { securityConfig } from "./config.js";
@@ -170,8 +169,6 @@ export class ApiFeatures {
       });
     });
   
-    // پشتیبانی از nested populate: در صورت نیاز، منطق تو در تو را می‌توانید اینجا اضافه کنید.
-  
     return this;
   }
   
@@ -184,11 +181,9 @@ export class ApiFeatures {
 
   async execute(options = {}) {
     try {
-      // انتخاب حالت cursor در مواقع پردازش داده‌های حجیم
       if (options.useCursor === true) {
         this.useCursor = true;
       }
-      // اجرای موازی pipeline‌های شمارش و داده
       const [countResult, dataResult] = await Promise.all([
         this.Model.aggregate([...this.countPipeline, { $count: "total" }]),
         (this.useCursor
@@ -258,7 +253,22 @@ export class ApiFeatures {
 
   #sanitizeNestedObjects(obj) {
     return Object.entries(obj).reduce((acc, [key, value]) => {
-      if (typeof value === "object" && !Array.isArray(value)) {
+      // Handle ObjectId fields with nested operators
+      if (key.endsWith("Id") && typeof value === "object" && !Array.isArray(value)) {
+        const sanitizedObj = {};
+        for (const [op, val] of Object.entries(value)) {
+          if (["$eq", "$ne", "$gt", "$gte", "$lt", "$lte"].includes(op) && mongoose.isValidObjectId(val)) {
+            sanitizedObj[op] = new mongoose.Types.ObjectId(val);
+          } else if (["$in", "$nin"].includes(op) && Array.isArray(val)) {
+            sanitizedObj[op] = val
+              .filter(v => mongoose.isValidObjectId(v))
+              .map(v => new mongoose.Types.ObjectId(v));
+          } else {
+            sanitizedObj[op] = val;
+          }
+        }
+        acc[key] = sanitizedObj;
+      } else if (typeof value === "object" && !Array.isArray(value)) {
         acc[key] = this.#sanitizeNestedObjects(value);
       } else {
         acc[key] = this.#sanitizeValue(key, value);
@@ -274,7 +284,7 @@ export class ApiFeatures {
     if (typeof value === "string") {
       if (value === "true") return true;
       if (value === "false") return false;
-      if (/^\d+$/.test(value)) return parseInt(value);
+      if (/^\d+$/.test(value)) return parseInt(value, 10);
     }
     return value;
   }

package/src/catchAsync.js

@@ -0,0 +1,6 @@
+ export const catchAsync=fn=>{
+    return (req,res,next)=>{
+        fn(req,res,next).catch(next)
+    }
+}
+export default catchAsync