@dwtechs/antity 0.13.0 → 0.14.0

package/README.md

@@ -112,9 +112,9 @@ const entity = new Entity("consumers", [
   },
 ]);
 
-// add a consumer. Used when loggin in from user service
-router.post("/", entity.normalize, entity.validate, ...);
-// or use check method to both normalize and validate at once
+// add a consumer. Used when logging in from user service
+router.post("/", entity.normalizeArray, entity.validateArray, ...);
+// or use check method to normalize and validate array at once
 router.put("/", entity.check, ...);
 
 ```
@@ -227,11 +227,12 @@ class Entity {
   getPropsByMethod(method: Method): Property[];
   
   /**
-   * Normalizes each row in req.body.rows according to property config and HTTP method.
+   * Normalizes an array of records by applying sanitization and normalization
+   * rules defined in the properties of the class.
    *
-   * - Applies sanitization if `sanitize: true` and method matches
-   * - Applies normalization if `normalize: true` and method matches
-   * - Mutates req.body.rows with sanitized/normalized values
+   * - Applies sanitization if `sanitize: true`
+   * - Applies normalization if `normalize: true`
+   * - Mutates req.body.rows or req.body with sanitized/normalized values
    * - Calls next(error) on failure, next() on success
    *
    * @param {Request} req - Express request object containing rows
@@ -241,25 +242,58 @@ class Entity {
    * @returns {void}
    *
    * **Input Properties Required:**
-   * - `req.body.rows` (array) - Array of objects to normalize
+   * - `req.body.rows` (array) or `req.body` (array) - Array of objects to normalize
    * - Each property config can specify sanitize, normalize, etc.
    *
    * **Output Properties:**
-   * - Mutates `req.body.rows` with sanitized/normalized values
-   * - Calls next(error) if any row fails normalization, next() if all pass
+   * - Mutates array with sanitized/normalized values
+   * - Calls next(error) if normalization fails, next() if all pass
    *
    * @example
    * ```typescript
-   * router.post('/entity', entity.normalize, (req, res) => {
+   * router.post('/entities', entity.normalizeArray, (req, res) => {
    *   // req.body.rows are now sanitized and normalized
    *   res.json({ success: true });
    * });
    * ```
    */
-  normalize: (req: Request, _res: Response, next: NextFunction) => void;
+  normalizeArray: (req: Request, _res: Response, next: NextFunction) => void;
+  
+  /**
+   * Normalizes a single record by applying sanitization and normalization
+   * rules defined in the properties of the class.
+   *
+   * - Applies sanitization if `sanitize: true`
+   * - Applies normalization if `normalize: true`
+   * - Mutates req.body with sanitized/normalized values
+   * - Calls next(error) on failure, next() on success
+   *
+   * @param {Request} req - Express request object containing a single record
+   * @param {Response} _res - Express response object (not used)
+   * @param {NextFunction} next - Express next function
+   *
+   * @returns {void}
+   *
+   * **Input Properties Required:**
+   * - `req.body` (object) - Single object to normalize
+   * - Each property config can specify sanitize, normalize, etc.
+   *
+   * **Output Properties:**
+   * - Mutates `req.body` with sanitized/normalized values
+   * - Calls next(error) if normalization fails, next() if success
+   *
+   * @example
+   * ```typescript
+   * router.post('/entity', entity.normalizeOne, (req, res) => {
+   *   // req.body is now sanitized and normalized
+   *   res.json({ success: true });
+   * });
+   * ```
+   */
+  normalizeOne: (req: Request, _res: Response, next: NextFunction) => void;
   
   /**
-   * Validates each row in req.body.rows according to property config and HTTP method.
+   * Validates an array of rows according to property config and HTTP method.
    *
    * - Checks required properties and validates values
    * - Calls next(error) on failure, next() on success
@@ -271,7 +305,7 @@ class Entity {
    * @returns {void}
    *
    * **Input Properties Required:**
-   * - `req.body.rows` (array) - Array of objects to validate
+   * - `req.body.rows` (array) or `req.body` (array) - Array of objects to validate
    * - Each property config can specify validate, required, etc.
    *
    * **Output Properties:**
@@ -279,13 +313,42 @@ class Entity {
    *
    * @example
    * ```typescript
-   * router.post('/entity', entity.validate, (req, res) => {
+   * router.post('/entities', entity.validateArray, (req, res) => {
    *   // req.body.rows are now validated
    *   res.json({ success: true });
    * });
    * ```
    */
-  validate: (req: Request, _res: Response, next: NextFunction) => void;
+  validateArray: (req: Request, _res: Response, next: NextFunction) => void;
+  
+  /**
+   * Validates a single record according to property config and HTTP method.
+   *
+   * - Checks required properties and validates values
+   * - Calls next(error) on failure, next() on success
+   *
+   * @param {Request} req - Express request object containing a single record
+   * @param {Response} _res - Express response object (not used)
+   * @param {NextFunction} next - Express next function
+   *
+   * @returns {void}
+   *
+   * **Input Properties Required:**
+   * - `req.body` (object) - Single object to validate
+   * - Each property config can specify validate, required, etc.
+   *
+   * **Output Properties:**
+   * - Calls next(error) if validation fails, next() if success
+   *
+   * @example
+   * ```typescript
+   * router.post('/entity', entity.validateOne, (req, res) => {
+   *   // req.body is now validated
+   *   res.json({ success: true });
+   * });
+   * ```
+   */
+  validateOne: (req: Request, _res: Response, next: NextFunction) => void;
 
   /**
    * Checks, sanitizes, normalizes, and validates each row in req.body.rows according to property config and HTTP method.
@@ -321,8 +384,10 @@ class Entity {
 }
 
 ```
-normalize() and validate() methods are made to be used as Express.js middlewares.
-Each method will look for data to work on in the **req.body.rows** parameter.
+**normalizeArray()**, **normalizeOne()**, **validateArray()**, and **validateOne()** methods are made to be used as Express.js middlewares.
+
+- **normalizeArray()** and **validateArray()** will look for data in the **req.body.rows** parameter or **req.body** as an array.
+- **normalizeOne()** and **validateOne()** will look for data in the **req.body** parameter as a single object.
 
 
 ### Password validation

package/dist/antity.d.ts

@@ -68,8 +68,10 @@ declare class Entity {
   set name(name: string);
   getProp(key: string): Property | undefined;
   getPropsByMethod(method: Method): Property[];
-  normalize: (req: Request, _res: Response, next: NextFunction) => void;
-  validate: (req: Request, _res: Response, next: NextFunction) => void;
+  normalizeArray: (req: Request, _res: Response, next: NextFunction) => void;
+  normalizeOne: (req: Request, _res: Response, next: NextFunction) => void;
+  validateArray: (req: Request, _res: Response, next: NextFunction) => void;
+  validateOne: (req: Request, _res: Response, next: NextFunction) => void;
   check: (req: Request, _res: Response, next: NextFunction) => void;
 }
 

package/dist/antity.js

@@ -233,38 +233,69 @@ function require(v, key, type) {
     return isNil(v) ? { statusCode: 400, message: `${LOGS_PREFIX}Missing ${key} of type ${type}` } : null;
 }
 
+function applyNormalization(record, properties) {
+    for (const { key, type, sanitize: sanitize$1, normalize, sanitizer, normalizer, } of properties) {
+        let v = record[key];
+        if (v) {
+            if (sanitize$1) {
+                log.debug(`sanitize ${key}: ${type} = ${v}`);
+                v = sanitize(v, sanitizer);
+            }
+            if (normalize && isFunction(normalizer)) {
+                log.debug(`normalize ${key}: ${type} = ${v}`);
+                v = normalizer(v);
+            }
+            record[key] = v;
+        }
+    }
+}
+
+function applyValidation(record, properties, method) {
+    for (const { key, type, min, max, required, typeCheck, methods, validate, validator } of properties) {
+        const v = record[key];
+        if (isIn(methods, method)) {
+            if (required) {
+                const rq = require(v, key, type);
+                if (rq)
+                    return rq;
+            }
+            if (v && validate) {
+                const ct = control(v, key, type, min, max, typeCheck, validator);
+                if (ct)
+                    return ct;
+            }
+        }
+    }
+    return null;
+}
+
 class Entity {
     constructor(name, properties) {
-        this.normalize = (req, _res, next) => {
+        this.normalizeArray = (req, _res, next) => {
             var _a;
+            log.debug(`normalizeArray ${this.name}`);
             const rows = (_a = req.body) === null || _a === void 0 ? void 0 : _a.rows;
-            log.debug(`normalize ${this.name}`);
-            if (!isArray(rows, "!0"))
+            if (!isArray(rows, ">", 0))
                 return next({ statusCode: 400, message: `${LOGS_PREFIX}Normalize: no rows found in request body` });
             for (const r of rows) {
-                for (const { key, type, sanitize: sanitize$1, normalize, sanitizer, normalizer, } of this._properties) {
-                    let v = r[key];
-                    if (v) {
-                        if (sanitize$1) {
-                            log.debug(`sanitize ${key}: ${type} = ${v}`);
-                            v = sanitize(v, sanitizer);
-                        }
-                        if (normalize && isFunction(normalizer)) {
-                            log.debug(`normalize ${key}: ${type} = ${v}`);
-                            v = normalizer(v);
-                        }
-                        r[key] = v;
-                    }
-                }
+                applyNormalization(r, this._properties);
             }
             next();
         };
-        this.validate = (req, _res, next) => {
+        this.normalizeOne = (req, _res, next) => {
+            log.debug(`normalizeOne ${this.name}`);
+            const record = req.body;
+            if (!isObject(record, true))
+                return next({ statusCode: 400, message: `${LOGS_PREFIX}Normalize: no data found in request body` });
+            applyNormalization(record, this._properties);
+            next();
+        };
+        this.validateArray = (req, _res, next) => {
             var _a;
+            log.debug(`validateArray ${this.name}`);
             const rows = (_a = req.body) === null || _a === void 0 ? void 0 : _a.rows;
             const method = req.method;
-            log.debug(`validate ${this.name}`);
-            if (!isArray(rows, "!0"))
+            if (!isArray(rows, ">", 0))
                 return next({ statusCode: 400, message: `${LOGS_PREFIX}Validate: no rows found in request body` });
             if (!isIn(METHODS, method))
                 return next({
@@ -272,24 +303,28 @@ class Entity {
                     message: `${LOGS_PREFIX}Invalid REST method. Received: ${method}. Must be one of: ${METHODS.toString()}`
                 });
             for (const r of rows) {
-                for (const { key, type, min, max, required, typeCheck, methods, validate, validator } of this._properties) {
-                    const v = r[key];
-                    if (isIn(methods, method)) {
-                        if (required) {
-                            const rq = require(v, key, type);
-                            if (rq)
-                                return next(rq);
-                        }
-                        if (v && validate) {
-                            const ct = control(v, key, type, min, max, typeCheck, validator);
-                            if (ct)
-                                return next(ct);
-                        }
-                    }
-                }
+                const error = applyValidation(r, this._properties, method);
+                if (error)
+                    return next(error);
             }
             next();
         };
+        this.validateOne = (req, _res, next) => {
+            log.debug(`validateOne ${this.name}`);
+            const record = req.body;
+            const method = req.method;
+            if (!isObject(record, true))
+                return next({ statusCode: 400, message: `${LOGS_PREFIX}Validate: no data found in request body` });
+            if (!isIn(METHODS, method))
+                return next({
+                    statusCode: 400,
+                    message: `${LOGS_PREFIX}Invalid REST method. Received: ${method}. Must be one of: ${METHODS.toString()}`
+                });
+            const error = applyValidation(record, this._properties, method);
+            if (error)
+                return next(error);
+            next();
+        };
         this.check = (req, _res, next) => {
             var _a;
             const rows = (_a = req.body) === null || _a === void 0 ? void 0 : _a.rows;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dwtechs/antity",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "Open source library for easy entity management",
   "keywords": [
     "entities"