@dwtechs/antity 0.7.0 → 0.9.0

package/README.md

@@ -2,6 +2,7 @@
 [![License: MIT](https://img.shields.io/npm/l/@dwtechs/antity.svg?color=brightgreen)](https://opensource.org/licenses/MIT)
 [![npm version](https://badge.fury.io/js/%40dwtechs%2Fantity.svg)](https://www.npmjs.com/package/@dwtechs/antity)
 [![last version release date](https://img.shields.io/github/release-date/DWTechs/Antity.js)](https://www.npmjs.com/package/@dwtechs/antity)
+![Jest:coverage](https://img.shields.io/badge/Jest:coverage-100%25-brightgreen.svg)
 [![minified size](https://img.shields.io/bundlephobia/min/@dwtechs/antity?color=brightgreen)](https://www.npmjs.com/package/@dwtechs/antity)
 
 - [Synopsis](#synopsis)
@@ -57,15 +58,15 @@ const entity = new Entity("consumers", [
     min: 0,
     max: 120,
     typeCheck: true,
-    operations: ["GET", "PUT", "DELETE"],
+    methods: ["GET", "PUT", "DELETE"],
     required: true,
     safe: true,
     sanitize: true,
     normalize: true,
-    control: true,
+    validate: true,
     sanitizer: null,
     normalizer: null,
-    controller: null,
+    validator: null,
   },
   {
     key: "firstName",
@@ -73,15 +74,15 @@ const entity = new Entity("consumers", [
     min: 0,
     max: 255,
     typeCheck: true,
-    operations: ["GET", "POST", "PUT", "DELETE"],
+    methods: ["GET", "POST", "PUT", "DELETE"],
     required: true,
     safe: true,
     sanitize: true,
     normalize: true,
-    control: true,
+    validate: true,
     sanitizer: null,
     normalizer: normalizeName,
-    controller: null,
+    validator: null,
   },
   {
     key: "lastName",
@@ -89,15 +90,15 @@ const entity = new Entity("consumers", [
     min: 0,
     max: 255,
     typeCheck: true,
-    operations: ["GET", "POST", "PUT", "DELETE"],
+    methods: ["GET", "POST", "PUT", "DELETE"],
     required: true,
     safe: true,
     sanitize: true,
     normalize: true,
-    control: true,
+    validate: true,
     sanitizer: null,
     normalizer: normalizeName,
-    controller: null,
+    validator: null,
   },
   {
     key: "nickname",
@@ -105,15 +106,15 @@ const entity = new Entity("consumers", [
     min: 0,
     max: 255,
     typeCheck: true,
-    operations: ["GET", "POST", "PUT", "DELETE"],
+    methods: ["GET", "POST", "PUT", "DELETE"],
     required: true,
     safe: true,
     sanitize: true,
     normalize: true,
-    control: true,
+    validate: true,
     sanitizer: null,
     normalizer: normalizeNickname,
-    controller: null,
+    validator: null,
   },
 ]);
 
@@ -169,10 +170,10 @@ class Property {
   methods: Method[];
   sanitize: boolean;
   normalize: boolean;
-  control: boolean;
+  validate: boolean;
   sanitizer: Function | null;
   normalizer: Function | null;
-  controller: Function | null;
+  validator: Function | null;
 };
 
 class Entity {
@@ -189,6 +190,14 @@ class Entity {
    * @returns {Property | undefined} - The property object if found, otherwise `undefined`.
    */
   getProp(key: string): Property | undefined;
+
+  /**
+   * Retrieves a list of properties associated with a specific method.
+   *
+   * @param {Method} method - The method to filter properties by.
+   * @returns {Property[]} An array of properties that are associated with the specified method.
+   */
+  getPropsByMethod(method: Method): Property[];
   
   /**
    * Normalizes an array of records by applying sanitization and normalization
@@ -223,13 +232,13 @@ Any of these can be passed into the options object for each function.
 | required        |  boolean                  | Is this property required on insert               | false
 | safe            |  boolean                  | Is this property safe to send to the client       | true
 | typeCheck       |  boolean                  | Type is checked if true                           | false
-| operations      |  Operation[]              | SQL DML operations concerned by the property      | [ "select", "insert", "update", "merge", "delete" ]
+| methods         |  Method[]                 | SQL DML operations concerned by the property      | [ "select", "insert", "update", "merge", "delete" ]
 | sanitize        |  boolean                  | Sanitize the property if true                     | true
 | normalize       |  boolean                  | Normalize the property if true                    | false
-| control         |  boolean                  | Control the property if true                      | true
+| validate        |  boolean                  | validate the property if true                     | true
 | sanitizer       |  ((v:any) => any) \| null | Sanitizer function if sanitize is true            | null
 | normalizer      |  ((v:any) => any) \| null | Normalizer function if normalize is true          | null
-| controller      |  ((v:any, min:number, max:number, typeCheck:boolean) => any) \| null  | Controller function if control is true            | null
+| validator       |  ((v:any, min:number, max:number, typeCheck:boolean) => any) \| null  | validator function if validate is true            | 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,6 +25,7 @@ https://github.com/DWTechs/Antity.js
 */
 
 import type { Request, Response, NextFunction } from 'express';
+declare const Methods: readonly [ "GET", "PATCH", "PUT", "POST", "DELETE" ];
 type Method = typeof Methods[number];
 type Type = 
   "boolean" |
@@ -55,17 +56,6 @@ type Type =
   "node" |
   "object";
 
-declare const Methods: readonly [ "GET", "PATCH", "PUT", "POST", "DELETE" ];
-
-declare const Types: Record<Type, {
-  validate: (
-    v: any, 
-    min: number | Date, 
-    max: number | Date, 
-    typeCheck: boolean
-  ) => boolean;
-}>;
-
 declare class Entity {
   private _name;
   private _unsafeProps;
@@ -76,6 +66,7 @@ declare class Entity {
   get properties(): Property[];
   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;
 }
@@ -91,10 +82,10 @@ declare class Property {
   methods: Method[];
   sanitize: boolean;
   normalize: boolean;
-  control: boolean;
+  validate: boolean;
   sanitizer: ((v: any) => any) | null;
   normalizer: ((v: any) => any) | null;
-  controller: ((v: any) => any) | null;
+  validator: ((v: any) => any) | null;
   constructor(
     key: string,
     type: Type,
@@ -106,10 +97,10 @@ declare class Property {
     methods: Method[],
     sanitize: boolean,
     normalize: boolean,
-    control: boolean,
+    validate: boolean,
     sanitizer: ((v: any) => any) | null,
     normalizer: ((v: any) => any) | null,
-    controller: ((v: any) => any) | null
+    validator: ((v: any) => any) | null
   );
 }
 
@@ -117,7 +108,5 @@ export type { Type, Method };
 export { 
   Entity,
   Property,
-  Types,
-  Methods,
 };
 

package/dist/antity.js

@@ -40,7 +40,7 @@ const Types = {
         validate: (v, min, max, typeCheck) => isValidNumber(v, min || undefined, max || undefined, typeCheck || undefined)
     },
     integer: {
-        validate: (v, min, max, typeCheck) => isValidInteger(v, min || undefined, max || undefined, typeCheck || undefined)
+        validate: (v, min, max, typeCheck) => isValidInteger(v, min !== null && min !== void 0 ? min : undefined, max !== null && max !== void 0 ? max : undefined, typeCheck || undefined)
     },
     float: {
         validate: (v, min, max, typeCheck) => isValidFloat(v, min || undefined, max || undefined, typeCheck || undefined)
@@ -114,7 +114,7 @@ const Types = {
 };
 
 class Property {
-    constructor(key, type, min, max, required, safe, typeCheck, methods, sanitize, normalize, control, sanitizer, normalizer, controller) {
+    constructor(key, type, min, max, required, safe, typeCheck, methods, sanitize, normalize, validate, sanitizer, normalizer, validator) {
         if (!isString(key, "!0"))
             throw new Error(`Property "key" must be a string. Received ${key}`);
         if (!isProperty(Types, type))
@@ -135,10 +135,10 @@ class Property {
         this.methods = methods || Methods;
         this.sanitize = isBoolean(sanitize) ? sanitize : true;
         this.normalize = isBoolean(normalize) ? normalize : false;
-        this.control = isBoolean(control) ? control : true;
+        this.validate = isBoolean(validate) ? validate : true;
         this.sanitizer = isFunction(sanitizer) ? sanitizer : null;
         this.normalizer = isFunction(normalizer) ? normalizer : null;
-        this.controller = isFunction(controller) ? controller : null;
+        this.validator = isFunction(validator) ? validator : null;
     }
     interval(val, type, integerDefault, dateDefault) {
         if (type === "date")
@@ -153,7 +153,7 @@ class Entity {
         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.control, p.sanitizer, p.normalizer, p.controller);
+            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);
             this._properties.push(prop);
             if (!prop.safe)
                 this._unsafeProps.push(prop.key);
@@ -176,10 +176,18 @@ class Entity {
     getProp(key) {
         return this.properties.find(p => p.key === key);
     }
+    getPropsByMethod(method) {
+        const props = [];
+        for (const p of this.properties) {
+            if (isIn(p.methods, method, 0))
+                props.push(p);
+        }
+        return props;
+    }
     normalize(req, _res, next) {
         var _a;
         const rows = (_a = req.body) === null || _a === void 0 ? void 0 : _a.rows;
-        if (!isObject(rows))
+        if (!isArray(rows, "!0"))
             return next({ status: 400, msg: "Normalize: no rows found in request body" });
         for (const r of rows) {
             for (const { key, type, sanitize, normalize, sanitizer, normalizer, } of this.properties) {
@@ -189,7 +197,7 @@ class Entity {
                         log.debug(`sanitize ${key}: ${type} = ${v}`);
                         v = this.sanitize(v, sanitizer);
                     }
-                    if (normalize && normalizer) {
+                    if (normalize && isFunction(normalizer)) {
                         log.debug(`normalize ${key}: ${type} = ${v}`);
                         v = normalizer(v);
                     }
@@ -201,9 +209,9 @@ class Entity {
     }
     validate(req, _res, next) {
         var _a;
-        const rows = req.body;
+        const rows = (_a = req.body) === null || _a === void 0 ? void 0 : _a.rows;
         const method = req.method;
-        if (!isObject((_a = req.body) === null || _a === void 0 ? void 0 : _a.rows))
+        if (!isArray(rows, "!0"))
             return next({ status: 400, msg: "Sanitize: no rows found in request body" });
         if (!isIn(Methods, method))
             return next({
@@ -211,7 +219,7 @@ class Entity {
                 msg: `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, control, controller } of this.properties) {
+            for (const { key, type, min, max, required, typeCheck, methods, validate, validator } of this.properties) {
                 const v = r[key];
                 if (isIn(methods, method)) {
                     if (required) {
@@ -219,8 +227,8 @@ class Entity {
                         if (rq)
                             return next(rq);
                     }
-                    if (v && control) {
-                        const ct = this.control(v, key, type, min, max, typeCheck, controller);
+                    if (v && validate) {
+                        const ct = this.control(v, key, type, min, max, typeCheck, validator);
                         if (ct)
                             return next(ct);
                     }
@@ -240,7 +248,12 @@ class Entity {
             val = cb(v);
         else
             val = Types[type].validate(v, min, max, typeCheck);
-        return val ? null : { status: 400, msg: `Invalid ${key}, must be of type ${type}` };
+        let c = "";
+        if (!isNil(min))
+            c += ` and >= ${min}`;
+        if (!isNil(max))
+            c += ` and <= ${max}`;
+        return val ? null : { status: 400, msg: `Invalid ${key}, must be of type ${type}${c}` };
     }
     sanitize(v, cb) {
         if (cb)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dwtechs/antity",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "Open source library for easy entity management",
   "keywords": [
     "entities"
@@ -30,7 +30,7 @@
     "rollup:mjs": "rollup --config rollup.config.mjs",
     "rollup:cjs": "rollup --config rollup.config.cjs.mjs",
     "rollup": "npm run rollup:mjs",
-    "test": "jest --coverage"
+    "test": "jest --coverage --config jest.config.js"
   },
   "files": [
     "dist/"