request-guardian 1.0.19 → 2.0.2

package/README.md

@@ -1,56 +1,115 @@
-# Readme for Request-Guardian
-
-`request-guardian` is a middleware function that validates incoming requests against a set of validation rules using `express-validator`. It can be used to ensure that data sent to a server is in the expected format and meets certain criteria. If the validation fails, it returns a 400 error response with an array of validation errors.
-
-## Installation
-
-To install `request-guardian`, use `npm` or `yarn`.
-
-```bash
-npm install request-guardian
-```
-
-```bash
-yarn add request-guardian
-```
-
-## Usage
-
-`request-guardian` is a middleware function that can be used with `Express` applications. To use it, simply require the module and use it as middleware for your routes.
-
-***NOTE: Make sure that you call the validate() method after a middleware to parse incoming requests with JSON payloads.***
-
-```javascript
-const express = require('express');
-const validate = require('request-guardian');
-
-const app = express();
-
-// middleware to parse incoming requests with JSON payloads.
-app.use(express.json());
-
-// Use Request Guardian middleware
-validate(app);
-
-// define your routes
-app.post('/users', (req, res) => {
-    // handle validated request
-});
-```
-
-Validation rules are defined in separate files located in the `utils/validations/index.js` directory. `request-guardian` will look for a file with the same name as the current route and load any validation rules defined within that file.
-
-```javascript
-// utils/validations/index.js
-
-const { body } = require('express-validator');
-
-module.exports = {
-    '/api/authentication/signup': [
-        body('email').isEmail(),
-        body('password').isLength({ min: 8 }),
-    ]
-} ;
-```
-
-If no validation rules are found for the current route, `request-guardian` will simply pass the request to the next middleware function in the stack.
+# Request Guardian
+
+`request-guardian` registers [express-validator](https://express-validator.github.io/) rules on an Express app. Rules come from your project's `utils/validations/index.js`. Failed validation returns **422**. Unexpected errors while running validators return **400**.
+
+## Installation
+
+```bash
+npm install request-guardian
+```
+
+```bash
+yarn add request-guardian
+```
+
+This package depends on `express-validator`. Use it with Express.
+
+## Usage
+
+Call `validate(app)` **after** body parsers such as `express.json()`, and **before** you define route handlers. `validate` attaches middleware when it runs, so calling it after `app.post(...)` can skip validation.
+
+```javascript
+const express = require('express');
+const validate = require('request-guardian');
+
+const app = express();
+
+app.use(express.json());
+validate(app);
+
+app.post('/users', (req, res) => {
+    // request already passed validation for this path
+});
+```
+
+Put validation rules in `utils/validations/index.js` at the **application root** (the process working directory), not inside `node_modules`. Keys must match the Express paths you register.
+
+Each path can be:
+
+- An **array** of validation chains: applied to every method (`app.use`).
+- An **object** keyed by HTTP method: different rules for `GET`, `POST`, and other methods on the same path.
+
+Supported method keys (case-insensitive): `all`, `get`, `post`, `put`, `delete`, `patch`, `options`, `head`. Unknown keys are ignored.
+
+### Method-specific rules
+
+Use this when the same path needs different rules per method:
+
+```javascript
+// utils/validations/index.js
+const { body, query } = require('express-validator');
+
+module.exports = {
+    '/api/authentication/signup': {
+        GET: [
+            query('page').optional().isInt({ min: 1 }),
+        ],
+        POST: [
+            body('email').isEmail(),
+            body('password').isLength({ min: 8 }),
+        ],
+    },
+};
+```
+
+`all` applies to every method on that path, the same as a bare array:
+
+```javascript
+module.exports = {
+    '/api/reports': {
+        all: [
+            query('from').optional().isISO8601(),
+        ],
+    },
+};
+```
+
+### Same rules for every method
+
+```javascript
+const { body } = require('express-validator');
+
+module.exports = {
+    '/api/users': [
+        body('name').notEmpty(),
+    ],
+};
+```
+
+If a path is not listed, no validation middleware is attached for it. If `utils/validations/index.js` is missing, `validate()` logs `Validations rules not found at utils/validations/index.js` and registers nothing.
+
+## Responses
+
+Validation failure:
+
+```json
+{
+    "data": [],
+    "status": "VALIDATION_ERROR",
+    "message": "Invalid Data, Validation Failed."
+}
+```
+
+`data` is `express-validator`'s `errors.array()`.
+
+Unexpected error while running validators:
+
+```json
+{
+    "data": "error message",
+    "status": "BAD_REQUEST",
+    "message": "error message"
+}
+```
+
+HTTP status codes: **422** for validation errors, **400** for other failures in the validator.

package/index.js

@@ -1,45 +1,90 @@
-const { validationResult } = require('express-validator');
-const path = require('path');
-
-function runValidator(validations) {
-    return async function _runValidator(req, res, next) {
-        try {
-            if (!validations) return next();
-            for (let validation of validations) {
-                const result = await validation.run(req);
-                if (result.errors.length) break;
-            }
-            const errors = validationResult(req);
-            if (errors.isEmpty()) {
-                return next();
-            }
-            res.status(422).json({
-                data: errors.array(),
-                status: 'VALIDATION_ERROR',
-                message: 'Invalid Data, Validation Failed.',
-            });
-        } catch (error) {
-            let message = error.message;
-            if (error.code === 'MODULE_NOT_FOUND') {
-                message = `Validations rules not found for ${req.path}`;
-            }
-            res.status(400).json({
-                data: message,
-                status: 'BAD_REQUEST',
-                message: message,
-            });
-        }
-    };
-}
-function validate(app) {
-    try {
-        for (const key in require(path.resolve('utils/validations/index'))) {
-            app.use(key, runValidator(require(path.resolve('utils/validations/index'))[key]));
-        }
-    } catch (error) {
-        if (error.code === 'MODULE_NOT_FOUND') {
-            console.log(`Validations rules not found at utils/validations/index.js`)
-        }
-    }
-}
+const { validationResult } = require('express-validator');
+const path = require('path');
+
+const VALID_HTTP_METHODS = new Set([
+    'all',
+    'get',
+    'post',
+    'put',
+    'delete',
+    'patch',
+    'options',
+    'head',
+]);
+
+function runValidator(validations) {
+    return async function _runValidator(req, res, next) {
+        try {
+            if (!validations) return next();
+            for (let validation of validations) {
+                const result = await validation.run(req);
+                if (result.errors.length) break;
+            }
+            const errors = validationResult(req);
+            if (errors.isEmpty()) {
+                return next();
+            }
+            res.status(422).json({
+                data: errors.array(),
+                status: 'VALIDATION_ERROR',
+                message: 'Invalid Data, Validation Failed.',
+            });
+        } catch (error) {
+            let message = error.message;
+            if (error.code === 'MODULE_NOT_FOUND') {
+                message = `Validations rules not found for ${req.path}`;
+            }
+            res.status(400).json({
+                data: message,
+                status: 'BAD_REQUEST',
+                message: message,
+            });
+        }
+    };
+}
+
+function registerRouteValidation(app, routeName, validationConfig) {
+    if (!validationConfig) return;
+
+    if (Array.isArray(validationConfig)) {
+        app.use(routeName, runValidator(validationConfig));
+        return;
+    }
+
+    if (typeof validationConfig !== 'object') {
+        return;
+    }
+
+    for (const [method, rules] of Object.entries(validationConfig)) {
+        const normalizedMethod = method.toLowerCase();
+
+        if (!VALID_HTTP_METHODS.has(normalizedMethod)) {
+            continue;
+        }
+
+        if (Array.isArray(rules)) {
+            if (normalizedMethod === 'all') {
+                app.use(routeName, runValidator(rules));
+                continue;
+            }
+
+            app[normalizedMethod](routeName, runValidator(rules));
+        }
+    }
+}
+
+function validate(app) {
+    try {
+        const validationRules = require(path.resolve('utils/validations/index'));
+
+        for (const [key, value] of Object.entries(validationRules || {})) {
+            registerRouteValidation(app, key, value);
+        }
+    } catch (error) {
+        if (error.code === 'MODULE_NOT_FOUND') {
+            console.log(`Validations rules not found at utils/validations/index.js`);
+        }
+    }
+}
+
 module.exports = validate;

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "request-guardian",
-  "version": "1.0.19",
-  "description": "",
+  "version": "2.0.2",
+  "description": "Express middleware that runs express-validator rules from utils/validations/index.js, including per-method rules.",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/saiyadzaid/request-guardian.git"
+    "url": "git+https://github.com/saiyadzaid/request-guardian.git"
   },
   "keywords": [
     "express",

package/utils/validations/index.js

@@ -0,0 +1,13 @@
+const { body, query } = require('express-validator');
+
+module.exports = {
+    '/api/authentication/signup': {
+        GET: [
+            query('page').optional().isInt({ min: 1 }),
+        ],
+        POST: [
+            body('email').isEmail(),
+            body('password').isLength({ min: 8 }),
+        ],
+    },
+};