@dwtechs/antity 0.14.0 → 0.16.0

package/README.md

@@ -51,13 +51,9 @@ const entity = new Entity("consumers", [
     type: "integer",
     min: 0,
     max: 120,
-    typeCheck: true,
-    methods: ["GET", "PUT", "DELETE"],
-    required: true,
-    safe: true,
-    sanitize: true,
-    normalize: true,
-    validate: true,
+    isTypeChecked: true,
+    requiredFor: ["PUT"],
+    isPrivate: true,
     sanitizer: null,
     normalizer: null,
     validator: null,
@@ -67,13 +63,9 @@ const entity = new Entity("consumers", [
     type: "string",
     min: 0,
     max: 255,
-    typeCheck: true,
-    methods: ["GET", "POST", "PUT", "DELETE"],
-    required: true,
-    safe: true,
-    sanitize: true,
-    normalize: true,
-    validate: true,
+    isTypeChecked: true,
+    requiredFor: ["PUT"],
+    isPrivate: true,
     sanitizer: null,
     normalizer: normalizeName,
     validator: null,
@@ -83,13 +75,9 @@ const entity = new Entity("consumers", [
     type: "string",
     min: 0,
     max: 255,
-    typeCheck: true,
-    methods: ["GET", "POST", "PUT", "DELETE"],
-    required: true,
-    safe: true,
-    sanitize: true,
-    normalize: true,
-    validate: true,
+    isTypeChecked: true,
+    requiredFor: ["PUT"],
+    isPrivate: true,
     sanitizer: null,
     normalizer: normalizeName,
     validator: null,
@@ -99,13 +87,9 @@ const entity = new Entity("consumers", [
     type: "string",
     min: 0,
     max: 255,
-    typeCheck: true,
-    methods: ["GET", "POST", "PUT", "DELETE"],
-    required: true,
-    safe: true,
-    sanitize: true,
-    normalize: true,
-    validate: true,
+    isTypeChecked: true,
+    requiredFor: ["PUT"],
+    isPrivate: true,
     sanitizer: null,
     normalizer: normalizeNickname,
     validator: null,
@@ -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;
-  typeCheck: boolean;
-  methods: Method[];
-  sanitize: boolean;
-  normalize: boolean;
-  validate: boolean;
+  requiredFor: Method[];
+  isPrivate: boolean;
+  isTypeChecked: boolean;
   sanitizer: Function | null;
   normalizer: Function | null;
   validator: Function | null;
@@ -176,7 +156,7 @@ class Property {
 class Entity {
   constructor(name: string, properties: Property[]);
   get name(): string;
-  get unsafeProps(): string[];
+  get privateProps(): string[];
   get properties(): Property[];
   set name(name: string);
   
@@ -350,39 +330,6 @@ class Entity {
    */
   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.
-   *
-   * - 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 {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.
-   *
-   * **Output Properties:**
-   * - Mutates `req.body.rows` with sanitized/normalized values
-   * - Calls next(error) if any row fails checks, next() if all pass
-   *
-   * @example
-   * ```typescript
-   * router.post('/entity', entity.check, (req, res) => {
-   *   // req.body.rows are now sanitized, normalized, and validated
-   *   res.json({ success: true });
-   * });
-   * ```
-   */
-  check: (req: Request, _res: Response, next: NextFunction) => void;
-}
-
 ```
 **normalizeArray()**, **normalizeOne()**, **validateArray()**, and **validateOne()** methods are made to be used as Express.js middlewares.
 
@@ -423,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
+| requiredFor     | Methods[]                | Property is required for the listed methods only | [ "POST", "PUT", "PATCH" ]
+| isPrivate       | boolean                  | Property should not be sent in the response      | false
+| isTypeChecked   | 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" |
@@ -59,11 +59,11 @@ type Type =
 
 declare class Entity {
   private _name;
-  private _unsafeProps;
+  private _privateProps;
   private _properties;
   constructor(name: string, properties: Property[]);
   get name(): string;
-  get unsafeProps(): string[];
+  get privateProps(): string[];
   get properties(): Property[];
   set name(name: string);
   getProp(key: string): Property | undefined;
@@ -72,7 +72,6 @@ declare class Entity {
   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;
 }
 
 declare class Property {
@@ -81,13 +80,9 @@ declare class Property {
   type: Type;
   min: number | Date | null;
   max: number | Date | null;
-  required: boolean;
-  safe: boolean;
-  typeCheck: boolean;
-  methods: Method[];
-  sanitize: boolean;
-  normalize: boolean;
-  validate: boolean;
+  isPrivate: boolean;
+  requiredFor: Method[];
+  isTypeChecked: boolean;
   sanitizer: ((v: any) => any) | null;
   normalizer: ((v: any) => any) | null;
   validator: ((v: any) => any) | null;
@@ -96,13 +91,9 @@ declare class Property {
     type: Type,
     min: number | Date | null,
     max: number | Date | null,
-    required: boolean,
-    safe: boolean,
-    typeCheck: boolean,
-    methods: Method[],
-    sanitize: boolean,
-    normalize: boolean,
-    validate: boolean,
+    isPrivate: boolean,
+    requiredFor: Method[],
+    isTypeChecked: 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, isPrivate, requiredFor, isTypeChecked, 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(requiredFor)) {
+            for (const m of requiredFor) {
                 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 "requiredFor" 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.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.requiredFor = isArray(requiredFor) ? requiredFor : [];
+        this.isPrivate = isBoolean(isPrivate) ? isPrivate : false;
+        this.isTypeChecked = isBoolean(isTypeChecked) ? isTypeChecked : false;
         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,37 +244,18 @@ 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) {
+function validate(record, properties, method) {
+    for (const { key, type, min, max, requiredFor, isTypeChecked, 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;
-            }
+        if (isIn(requiredFor, method)) {
+            const rq = require(v, key, type);
+            if (rq)
+                return rq;
+        }
+        if (v) {
+            const ct = control(v, key, type, min, max, isTypeChecked, validator);
+            if (ct)
+                return ct;
         }
     }
     return null;
@@ -278,16 +270,16 @@ class Entity {
             if (!isArray(rows, ">", 0))
                 return next({ statusCode: 400, message: `${LOGS_PREFIX}Normalize: no rows found in request body` });
             for (const r of rows) {
-                applyNormalization(r, this._properties);
+                normalize(r, this._properties);
             }
             next();
         };
         this.normalizeOne = (req, _res, next) => {
             log.debug(`normalizeOne ${this.name}`);
-            const record = req.body;
-            if (!isObject(record, true))
+            const r = req.body;
+            if (!isObject(r, true))
                 return next({ statusCode: 400, message: `${LOGS_PREFIX}Normalize: no data found in request body` });
-            applyNormalization(record, this._properties);
+            normalize(r, this._properties);
             next();
         };
         this.validateArray = (req, _res, next) => {
@@ -303,7 +295,7 @@ class Entity {
                     message: `${LOGS_PREFIX}Invalid REST method. Received: ${method}. Must be one of: ${METHODS.toString()}`
                 });
             for (const r of rows) {
-                const error = applyValidation(r, this._properties, method);
+                const error = validate(r, this._properties, method);
                 if (error)
                     return next(error);
             }
@@ -320,80 +312,27 @@ class Entity {
                     statusCode: 400,
                     message: `${LOGS_PREFIX}Invalid REST method. Received: ${method}. Must be one of: ${METHODS.toString()}`
                 });
-            const error = applyValidation(record, this._properties, method);
+            const error = validate(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;
-            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) {
-                return next({
-                    statusCode: 400,
-                    message: `${LOGS_PREFIX}Invalid REST method. Must be one of: ${METHODS.toString()} - caused by: ${err.message}`
-                });
-            }
-            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);
-                        }
-                    }
-                }
-            }
-            next();
-        };
         this._name = name;
         this._properties = [];
-        this._unsafeProps = [];
+        this._privateProps = [];
         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.isPrivate, p.requiredFor, p.isTypeChecked, p.sanitizer, p.normalizer, p.validator);
             Object.assign(prop, p);
             this._properties.push(prop);
-            if (!prop.safe)
-                this._unsafeProps.push(prop.key);
+            if (prop.isPrivate)
+                this._privateProps.push(prop.key);
         }
     }
     get name() {
         return this._name;
     }
-    get unsafeProps() {
-        return this._unsafeProps;
+    get privateProps() {
+        return this._privateProps;
     }
     get properties() {
         return this._properties;
@@ -409,7 +348,7 @@ class Entity {
     getPropsByMethod(method) {
         const props = [];
         for (const p of this.properties) {
-            if (isIn(p.methods, method, 0))
+            if (isIn(p.requiredFor, method, 0))
                 props.push(p);
         }
         return props;

package/package.json

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