request-guardian 1.0.3 → 1.0.5

package/README.md

@@ -1,85 +1,84 @@
-## Express Request Body Validation Middleware
+# Readme for Request-Guardian
 
-This middleware provides request body validation using [express-validator](https://express-validator.github.io/docs/) library. It is intended to be used as a middleware function in an Express.js application.
+`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
+## Installation
 
-To use this middleware in your project, install the required dependencies by running the following command:
+To install `request-guardian`, use `npm` or `yarn`.
 
+```bash
+npm install request-guardian
 ```
-npm install express-validator
+
+```bash
+yarn add request-guardian
 ```
 
-### Usage
+## Usage
 
-To use this middleware, simply require it in your route handler and add it as a middleware to your route. For example:
+`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.
 
-```js
+```javascript
 const express = require('express');
-const validate = require('./path/to/validate');
+const validate = require('request-guardian');
 
 const app = express();
 
-app.post('/api/authentication/signup', validate, (req, res) => {
-  // handle signup request
-});
-```
+// use request-guardian middleware
+app.use(validate);
 
-In the above example, the `validate` middleware will validate the request body against the rules specified in `/utils/validations/index.js`.
+// define your routes
+app.get('/', (req, res) => {
+    // handle request
+});
 
-### Validation Rules
+app.post('/users', (req, res) => {
+    // handle validated request
+});
+```
 
-All the validation rules should be located at `/utils/validations/index.js`. The file should export an object with keys as route paths and values as arrays of validation rules.
+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.
 
-For example, the validation rules for the `/api/authentication/signup` route could be defined as follows:
+```javascript
+// utils/validations/index.js
 
-```js
 const { body } = require('express-validator');
 
 module.exports = {
-  '/api/authentication/signup': [
-    body('email').notEmpty().withMessage('Email is required')
-      .isEmail().withMessage('Email is not valid'),
-    body('password').notEmpty().withMessage('Password is required')
-      .isLength({ min: 5 }).withMessage('Password length should be minimum 5')
-  ]
-};
+    '/api/authentication/signup': [
+        body('email').isEmail(),
+        body('password').isLength({ min: 8 }),
+    ]
+} ;
+```
+
+
+
+```javascript
+// app.js
+
+const express = require('express');
+const validate = require('request-guardian');
+
+// use request-guardian middleware
+const app = express();
+
+
+app.use(validate);
+
+// define your routes
+app.get('/', (req, res) => {
+    // handle request
+});
+
+// use request-guardian middleware for a specific route
+app.post('/users', (req, res) => {
+    // handle validated request
+});
+
+app.listen(3000, () => {
+    console.log('Server started on port 3000');
+});
 ```
 
-### Error Handling
-
-If any of the validation rules fail, the middleware will send a `400 Bad Request` response with an array of error messages. The error messages will be in the format specified by `express-validator`.
-
-If the validation rules for a route are not found, the middleware will send a `400 Bad Request` response with an appropriate error message.
-
-### Code
-
-```js
-const { validationResult, ValidationChain } = require('express-validator');
-
-async function validate(req, res, next) {
-    try {
-        let validations = require('../utils/validations')[req.path];
-        if (!validations) return next();
-        for (let validation of validations) {
-            const result = await validation.run(req);
-            if (result.errors.length) break;
-        }
-    
-        const errors = validationResult(req);
-        delete req.validations;
-        if (errors.isEmpty()) {
-            return next();
-        }
-        res.status(400).json({ errors: errors.array() });
-    } catch (error) {
-        let message = error.message;
-        if (error.code === 'MODULE_NOT_FOUND') {
-            message = `Validations rules not found for ${req.path}`;
-        }
-        res.status(400).json({ errors: message });
-    }
-};
-
-module.exports = validate;
-```
+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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "request-guardian",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "",
   "main": "index.js",
   "scripts": {