@dwtechs/antity 0.6.0 → 0.7.0

package/README.md

@@ -117,13 +117,11 @@ const entity = new Entity("consumers", [
   },
 ]);
 
-req.body = entity.normalize(req.body); // will also sanitize if true
-const check = entity.validate(req.body, "GET");
-const unsafeProps = entity.getUnsafeProps();
+// add a consumer. Used when loggin in from user service
+router.post("/", entity.normalize, entity.validate, ...);
 
 ```
 
-
 ## API Reference
 
 
@@ -195,40 +193,21 @@ class Entity {
   /**
    * Normalizes an array of records by applying sanitization and normalization
    * rules defined in the `properties` of the class.
-   *
-   * @param rows - An array of records where each record is a key-value pair.
-   *               The keys represent property names, and the values are the data
-   *               to be sanitized and normalized.
-   * @returns An array of records with sanitized and normalized values.
    */
-  normalize(rows: Record<string, unknown>[]): Record<string, unknown>[];
+  normalize(req: Request, _res: Response, next: NextFunction): void;
   
   /**
    * Validates a set of rows against the defined properties and operation/method.
    *
-   * @param rows - An array of objects where each object represents a row to validate.
-   *               Each row is a record with string keys and unknown values.
-   * @param operation - The operation or method to validate against. It can be of type `Operation` or `Method`.
-   * 
-   * @returns A string containing the validation error message if validation fails, or `null` if validation passes.
-   *
    * If a property is required and missing, or if it fails the control checks, the function returns an error message.
    * Otherwise, it returns `null` indicating successful validation.
    */
-  validate(rows: Record<string, unknown>[], method: Method): string | null;
+  validate(req: Request, _res: Response, next: NextFunction): void;
 }
 
 ```
-
-examples : 
-
-```javascript
-
-entity.validate(req.body, "GET"); // will validate properties for GET requests
-entity.validate(req.body, "PUT"); // will validate properties for PUT requests
-entity.validate(req.body, "DELETE"); // will validate properties for DELETE requests
-
-```
+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** parmeter.
 
 
 ### Available options for a property

package/dist/antity.d.ts

@@ -24,7 +24,7 @@ SOFTWARE.
 https://github.com/DWTechs/Antity.js
 */
 
-
+import type { Request, Response, NextFunction } from 'express';
 type Method = typeof Methods[number];
 type Type = 
   "boolean" |
@@ -66,10 +66,6 @@ declare const Types: Record<Type, {
   ) => boolean;
 }>;
 
-declare const Required: {
-  validate: (v: any) => boolean;
-};
-
 declare class Entity {
   private _name;
   private _unsafeProps;
@@ -80,15 +76,10 @@ declare class Entity {
   get properties(): Property[];
   set name(name: string);
   getProp(key: string): Property | undefined;
-  normalize(rows: Record<string, unknown>[]): Record<string, unknown>[];
-  validate(rows: Record<string, unknown>[], method: Method): string | null;
+  normalize(req: Request, _res: Response, next: NextFunction): void;
+  validate(req: Request, _res: Response, next: NextFunction): void;
 }
 
-declare const Messages: {
-  missing: (key: string) => string;
-  invalid: (key: string, type: Type) => string;
-};
-
 declare class Property {
   key: string;
   type: Type;
@@ -126,9 +117,7 @@ export type { Type, Method };
 export { 
   Entity,
   Property,
-  Messages,
   Types,
-  Required,
   Methods,
 };
 

package/dist/antity.js

@@ -147,11 +147,6 @@ class Property {
     }
 }
 
-const Messages = {
-    missing: (key) => `Missing ${key}`,
-    invalid: (key, type) => `Invalid ${key}, must be of type ${type}`,
-};
-
 class Entity {
     constructor(name, properties) {
         this._name = name;
@@ -181,7 +176,11 @@ class Entity {
     getProp(key) {
         return this.properties.find(p => p.key === key);
     }
-    normalize(rows) {
+    normalize(req, _res, next) {
+        var _a;
+        const rows = (_a = req.body) === null || _a === void 0 ? void 0 : _a.rows;
+        if (!isObject(rows))
+            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) {
                 let v = r[key];
@@ -198,11 +197,19 @@ class Entity {
                 }
             }
         }
-        return rows;
+        next();
     }
-    validate(rows, method) {
+    validate(req, _res, next) {
+        var _a;
+        const rows = req.body;
+        const method = req.method;
+        if (!isObject((_a = req.body) === null || _a === void 0 ? void 0 : _a.rows))
+            return next({ status: 400, msg: "Sanitize: no rows found in request body" });
         if (!isIn(Methods, method))
-            return `Invalid REST method. Received: ${method}. Must be one of: ${Methods.toString()}`;
+            return next({
+                status: 400,
+                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) {
                 const v = r[key];
@@ -210,28 +217,30 @@ class Entity {
                     if (required) {
                         const rq = this.require(v, key, type);
                         if (rq)
-                            return rq;
+                            return next(rq);
                     }
                     if (v && control) {
                         const ct = this.control(v, key, type, min, max, typeCheck, controller);
                         if (ct)
-                            return ct;
+                            return next(ct);
                     }
                 }
             }
         }
-        return null;
+        next();
     }
     require(v, key, type) {
         log.debug(`require ${key}: ${type} = ${v}`);
-        return isNil(v) ? Messages.missing(key) : null;
+        return isNil(v) ? { status: 400, msg: `Missing ${key} of type ${type}` } : null;
     }
     control(v, key, type, min, max, typeCheck, cb) {
         log.debug(`control ${key}: ${type} = ${v}`);
+        let val;
         if (cb)
-            return cb(v) ? null : Messages.invalid(key, type);
-        const val = Types[type].validate(v, min, max, typeCheck);
-        return val ? null : Messages.invalid(key, type);
+            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}` };
     }
     sanitize(v, cb) {
         if (cb)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dwtechs/antity",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Open source library for easy entity management",
   "keywords": [
     "entities"
@@ -48,6 +48,7 @@
     "@rollup/plugin-node-resolve": "15.3.0",
     "@types/jest": "29.5.14",
     "@types/node": "22.10.1",
+    "@types/express": "5.0.0",
     "babel-jest": "29.7.0",
     "core-js": "3.33.0",
     "jest": "29.7.0",