@dwtechs/antity 0.13.0 → 0.15.0

package/README.md

@@ -52,12 +52,8 @@ const entity = new Entity("consumers", [
     min: 0,
     max: 120,
     typeCheck: true,
-    methods: ["GET", "PUT", "DELETE"],
-    required: true,
+    need: ["PUT"],
     safe: true,
-    sanitize: true,
-    normalize: true,
-    validate: true,
     sanitizer: null,
     normalizer: null,
     validator: null,
@@ -68,12 +64,8 @@ const entity = new Entity("consumers", [
     min: 0,
     max: 255,
     typeCheck: true,
-    methods: ["GET", "POST", "PUT", "DELETE"],
-    required: true,
+    need: ["PUT"],
     safe: true,
-    sanitize: true,
-    normalize: true,
-    validate: true,
     sanitizer: null,
     normalizer: normalizeName,
     validator: null,
@@ -84,12 +76,8 @@ const entity = new Entity("consumers", [
     min: 0,
     max: 255,
     typeCheck: true,
-    methods: ["GET", "POST", "PUT", "DELETE"],
-    required: true,
+    need: ["PUT"],
     safe: true,
-    sanitize: true,
-    normalize: true,
-    validate: true,
     sanitizer: null,
     normalizer: normalizeName,
     validator: null,
@@ -100,21 +88,17 @@ const entity = new Entity("consumers", [
     min: 0,
     max: 255,
     typeCheck: true,
-    methods: ["GET", "POST", "PUT", "DELETE"],
-    required: true,
+    need: ["PUT"],
     safe: true,
-    sanitize: true,
-    normalize: true,
-    validate: true,
     sanitizer: null,
     normalizer: normalizeNickname,
     validator: null,
   },
 ]);
 
-// 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, ...);
 
 ```
@@ -154,20 +138,16 @@ type Type =
   "node" |
   "object";
             
-type Method = "GET" | "PATCH" | "PUT" | "POST" | "DELETE";
+type Method = "PATCH" | "PUT" | "POST";
 
 class Property {
   key: string;
   type: Type;
   min: number | Date | null;
   max: number | Date | null;
-  required: boolean;
-  safe: boolean;
+  need: Method[];
+  send: boolean;
   typeCheck: boolean;
-  methods: Method[];
-  sanitize: boolean;
-  normalize: boolean;
-  validate: boolean;
   sanitizer: Function | null;
   normalizer: Function | null;
   validator: Function | null;
@@ -227,11 +207,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 +222,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;
   
   /**
-   * Validates each row in req.body.rows according to property config and HTTP method.
+   * 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 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 +285,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,50 +293,48 @@ 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;
+  
   /**
-   * Checks, sanitizes, normalizes, and validates each row in req.body.rows according to property config and HTTP method.
+   * Validates a single record according to property config and HTTP method.
    *
-   * - Applies sanitization if `sanitize: true` and method matches
-   * - Applies normalization if `normalize: true` and method matches
    * - Checks required properties and validates values
    * - Calls next(error) on failure, next() on success
    *
-   * @param {Request} req - Express request object containing rows
+   * @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.rows` (array) - Array of objects to check
-   * - Each property config can specify sanitize, normalize, validate, required, etc.
+   * - `req.body` (object) - Single object to validate
+   * - Each property config can specify validate, required, etc.
    *
    * **Output Properties:**
-   * - Mutates `req.body.rows` with sanitized/normalized values
-   * - Calls next(error) if any row fails checks, next() if all pass
+   * - Calls next(error) if validation fails, next() if success
    *
    * @example
    * ```typescript
-   * router.post('/entity', entity.check, (req, res) => {
-   *   // req.body.rows are now sanitized, normalized, and validated
+   * router.post('/entity', entity.validateOne, (req, res) => {
+   *   // req.body is now validated
    *   res.json({ success: true });
    * });
    * ```
    */
-  check: (req: Request, _res: Response, next: NextFunction) => void;
-}
+  validateOne: (req: Request, _res: Response, next: NextFunction) => void;
 
 ```
-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
@@ -358,22 +370,18 @@ Properties **min** and **max** of the password properties will override default
 
 Any of these can be passed into the options object for each function.
 
-| Name            | Type                      |               Description                         |  Default value  |  
-| :-------------- | :------------------------ | :------------------------------------------------ | :-------------- |
-| key             |  string                   | Name of the property                              |
-| type            |  Type                     | Type of the property                              |
-| min             |  number \| Date           | Minimum value                                     | 0 \| 1900-01-01
-| max             |  number \| Date           | Maximum value                                     | 999999999 \| 2200-12-31
-| required        |  boolean                  | Property is required during validation            | false
-| safe            |  boolean                  | Property is sent in the response                  | true
-| typeCheck       |  boolean                  | Type is checked during validation                 | false
-| methods         |  Method[]                 | property is validated for the listed methods only | [ "GET", "POST", "PUT", "DELETE" ]
-| sanitize        |  boolean                  | Sanitize the property if true                     | true
-| normalize       |  boolean                  | Normalize the property if true                    | false
-| validate        |  boolean                  | validate the property if true                     | true
-| sanitizer       |  ((v:any) => any) \| null | Custom sanitizer function if sanitize is true     | null
-| normalizer      |  ((v:any) => any) \| null | Custop Normalizer function if normalize is true   | null
-| validator       |  ((v:any, min:number, max:number, typeCheck:boolean) => any) \| null  | validator function if validate is true            | null
+| Name            | Type                     |               Description                        |  Default value  |  
+| :-------------- | :----------------------- | :----------------------------------------------- | :-------------- |
+| key             | string                   | Name of the property                             |
+| type            | Type                     | Type of the property                             |
+| min             | number \| Date           | Minimum value if applicable                      | 0 \| 1900-01-01
+| max             | number \| Date           | Maximum value if applicable                      | 999999999 \| 2200-12-31
+| need            | Methods[]                | Property is required for the listed methods only | [ "POST", "PUT", "PATCH" ]
+| send            | boolean                  | Property is sent in the response                 | true
+| typeCheck       | boolean                  | Strict type check at validation                  | false
+| sanitizer       | ((v:any) => any) \| null | Custom sanitizer function                        | null
+| normalizer      | ((v:any) => any) \| null | Custom Normalizer function                       | null
+| validator       | ((v:any, min:number, max:number, typeCheck:boolean) => any) \| null         | Custom validator | null
 
 * *Min and max parameters are not used for boolean type*
 * *TypeCheck Parameter is not used for boolean, string and array types*

package/dist/antity.d.ts

@@ -25,7 +25,7 @@ https://github.com/DWTechs/Antity.js
 */
 
 import type { Request, Response, NextFunction } from 'express';
-declare const Methods: readonly [ "GET", "PATCH", "PUT", "POST", "DELETE" ];
+declare const Methods: readonly ["PATCH", "PUT", "POST"];
 type Method = typeof Methods[number];
 type Type = 
   "boolean" |
@@ -68,9 +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;
-  check: (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;
 }
 
 declare class Property {
@@ -79,13 +80,9 @@ declare class Property {
   type: Type;
   min: number | Date | null;
   max: number | Date | null;
-  required: boolean;
-  safe: boolean;
+  send: boolean;
+  need: Method[];
   typeCheck: boolean;
-  methods: Method[];
-  sanitize: boolean;
-  normalize: boolean;
-  validate: boolean;
   sanitizer: ((v: any) => any) | null;
   normalizer: ((v: any) => any) | null;
   validator: ((v: any) => any) | null;
@@ -94,13 +91,9 @@ declare class Property {
     type: Type,
     min: number | Date | null,
     max: number | Date | null,
-    required: boolean,
-    safe: boolean,
+    send: boolean,
+    need: Method[],
     typeCheck: boolean,
-    methods: Method[],
-    sanitize: boolean,
-    normalize: boolean,
-    validate: boolean,
     sanitizer: ((v: any) => any) | null,
     normalizer: ((v: any) => any) | null,
     validator: ((v: any) => any) | null

package/dist/antity.js

@@ -28,7 +28,7 @@ import { isBoolean, isStringOfLength, isValidNumber, isValidInteger, isValidFloa
 import { log } from '@dwtechs/winstan';
 
 const LOGS_PREFIX = "Antity: ";
-const METHODS = ["GET", "PATCH", "PUT", "POST", "DELETE"];
+const METHODS = ["PATCH", "PUT", "POST"];
 const { PWD_MIN_LENGTH_POLICY, PWD_MAX_LENGTH_POLICY, PWD_NUMBERS_POLICY, PWD_UPPERCASE_POLICY, PWD_LOWERCASE_POLICY, PWD_SYMBOLS_POLICY } = process.env;
 const PWD_MIN_LENGTH = PWD_MIN_LENGTH_POLICY ? +PWD_MIN_LENGTH_POLICY : 9;
 const PWD_MAX_LENGTH = PWD_MAX_LENGTH_POLICY ? +PWD_MAX_LENGTH_POLICY : 20;
@@ -135,7 +135,7 @@ const Types = {
 };
 
 class Property {
-    constructor(key, type, min, max, required, safe, typeCheck, methods, sanitize, normalize, validate, sanitizer, normalizer, validator) {
+    constructor(key, type, min, max, send, need, typeCheck, sanitizer, normalizer, validator) {
         try {
             isString(key, "!0", null, true);
         }
@@ -148,13 +148,13 @@ class Property {
         catch (err) {
             throw new Error(`${LOGS_PREFIX}Property "type" must be a valid type - caused by: ${err.message}`);
         }
-        if (isArray(methods)) {
-            for (const m of methods) {
+        if (isArray(need)) {
+            for (const m of need) {
                 try {
                     isIn(METHODS, m, 0, true);
                 }
                 catch (err) {
-                    throw new Error(`${LOGS_PREFIX}Property "methods" must be an array of REST methods - caused by: ${err.message}`);
+                    throw new Error(`${LOGS_PREFIX}Property "need" must be an array of REST methods - caused by: ${err.message}`);
                 }
             }
         }
@@ -162,13 +162,9 @@ class Property {
         this.type = type;
         this.min = this.interval(min, type, 0, "1900-01-01T00:00:00Z");
         this.max = this.interval(max, type, 999999999, "2200-12-31T00:00:00Z");
-        this.required = isBoolean(required) ? required : false;
-        this.safe = isBoolean(safe) ? safe : true;
+        this.need = isArray(need) ? need : [];
+        this.send = isBoolean(send) ? send : true;
         this.typeCheck = isBoolean(typeCheck) ? typeCheck : false;
-        this.methods = methods || METHODS;
-        this.sanitize = isBoolean(sanitize) ? sanitize : true;
-        this.normalize = isBoolean(normalize) ? normalize : false;
-        this.validate = isBoolean(validate) ? validate : true;
         this.sanitizer = isFunction(sanitizer) ? sanitizer : null;
         this.normalizer = isFunction(normalizer) ? normalizer : null;
         this.validator = isFunction(validator) ? validator : null;
@@ -206,6 +202,21 @@ function trim(v) {
     return v;
 }
 
+function normalize(record, properties) {
+    for (const { key, type, sanitizer, normalizer, } of properties) {
+        let v = record[key];
+        if (v) {
+            log.debug(`sanitize ${key}: ${type} = ${v}`);
+            v = sanitize(v, sanitizer);
+            if (isFunction(normalizer)) {
+                log.debug(`normalize ${key}: ${type} = ${v}`);
+                v = normalizer(v);
+            }
+            record[key] = v;
+        }
+    }
+}
+
 function control(v, key, type, min, max, typeCheck, cb) {
     log.debug(`control ${key}: ${type} = ${v}`);
     let errorMessage = "";
@@ -233,38 +244,50 @@ function require(v, key, type) {
     return isNil(v) ? { statusCode: 400, message: `${LOGS_PREFIX}Missing ${key} of type ${type}` } : null;
 }
 
+function validate(record, properties, method) {
+    for (const { key, type, min, max, need, typeCheck, validator } of properties) {
+        const v = record[key];
+        if (isIn(need, method)) {
+            const rq = require(v, key, type);
+            if (rq)
+                return rq;
+        }
+        if (v) {
+            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;
-                    }
-                }
+                normalize(r, this._properties);
             }
             next();
         };
-        this.validate = (req, _res, next) => {
+        this.normalizeOne = (req, _res, next) => {
+            log.debug(`normalizeOne ${this.name}`);
+            const r = req.body;
+            if (!isObject(r, true))
+                return next({ statusCode: 400, message: `${LOGS_PREFIX}Normalize: no data found in request body` });
+            normalize(r, 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,82 +295,33 @@ 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 = validate(r, 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;
+        this.validateOne = (req, _res, next) => {
+            log.debug(`validateOne ${this.name}`);
+            const record = req.body;
             const method = req.method;
-            log.debug(`check ${this.name}`);
-            try {
-                isArray(rows, "!0", null, true);
-            }
-            catch (err) {
-                return next({
-                    statusCode: 400,
-                    message: `${LOGS_PREFIX}no rows found in request body - caused by: ${err.message}`
-                });
-            }
-            try {
-                isIn(METHODS, method, 0, true);
-            }
-            catch (err) {
+            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. Must be one of: ${METHODS.toString()} - caused by: ${err.message}`
+                    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, sanitize: sanitize$1, normalize, sanitizer, normalizer, validator } of this._properties) {
-                    let v = r[key];
-                    if (isIn(methods, method)) {
-                        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;
-                            if (validate) {
-                                const ct = control(v, key, type, min, max, typeCheck, validator);
-                                if (ct)
-                                    return next(ct);
-                            }
-                        }
-                        if (required) {
-                            const rq = require(v, key, type);
-                            if (rq)
-                                return next(rq);
-                        }
-                    }
-                }
-            }
+            const error = validate(record, this._properties, method);
+            if (error)
+                return next(error);
             next();
         };
         this._name = name;
         this._properties = [];
         this._unsafeProps = [];
         for (const p of properties) {
-            const prop = new Property(p.key, p.type, p.min, p.max, p.required, p.safe, p.typeCheck, p.methods, p.sanitize, p.normalize, p.validate, p.sanitizer, p.normalizer, p.validator);
+            const prop = new Property(p.key, p.type, p.min, p.max, p.send, p.need, p.typeCheck, p.sanitizer, p.normalizer, p.validator);
             Object.assign(prop, p);
             this._properties.push(prop);
             if (!prop.safe)
@@ -374,7 +348,7 @@ class Entity {
     getPropsByMethod(method) {
         const props = [];
         for (const p of this.properties) {
-            if (isIn(p.methods, method, 0))
+            if (isIn(p.need, method, 0))
                 props.push(p);
         }
         return props;

package/package.json

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