@dwtechs/antity 0.5.0 → 0.7.0

package/README.md

@@ -57,7 +57,7 @@ const entity = new Entity("consumers", [
     min: 0,
     max: 120,
     typeCheck: true,
-    operations: ["select", "update", "delete"],
+    operations: ["GET", "PUT", "DELETE"],
     required: true,
     safe: true,
     sanitize: true,
@@ -73,7 +73,7 @@ const entity = new Entity("consumers", [
     min: 0,
     max: 255,
     typeCheck: true,
-    operations: ["select", "insert", "update", "delete"],
+    operations: ["GET", "POST", "PUT", "DELETE"],
     required: true,
     safe: true,
     sanitize: true,
@@ -89,7 +89,7 @@ const entity = new Entity("consumers", [
     min: 0,
     max: 255,
     typeCheck: true,
-    operations: ["select", "insert", "update", "delete"],
+    operations: ["GET", "POST", "PUT", "DELETE"],
     required: true,
     safe: true,
     sanitize: true,
@@ -105,7 +105,7 @@ const entity = new Entity("consumers", [
     min: 0,
     max: 255,
     typeCheck: true,
-    operations: ["select", "insert", "update", "delete"],
+    operations: ["GET", "POST", "PUT", "DELETE"],
     required: true,
     safe: true,
     sanitize: true,
@@ -117,47 +117,45 @@ const entity = new Entity("consumers", [
   },
 ]);
 
-req.body = entity.normalize(req.body); // will also sanitize if true
-const check = entity.validate(req.body, "select");
-const unsafeProps = entity.getUnsafeProps();
+// add a consumer. Used when loggin in from user service
+router.post("/", entity.normalize, entity.validate, ...);
 
 ```
 
-
 ## API Reference
 
 
 ```javascript
 
-type Type = "boolean" | 
-            "string" | 
-            "number" | 
-            "integer" | 
-            "float" |
-            "even" |
-            "odd" |
-            "positve" |
-            "negative" |
-            "powerOfTwo" |
-            "ascii" |
-            "array" | 
-            "jwt" |
-            "symbol" | 
-            "email" |
-            "regex" |
-            "json" |
-            "ipAddress" |
-            "slug" |
-            "hexadecimal" |
-            "date" |
-            "timestamp" |
-            "function" |
-            "htmlElement" |
-            "htmlEventAttribute" |
-            "node" |
-            "object";
+type Type = 
+  "boolean" |
+  "string" |
+  "number" |
+  "integer" |
+  "float" |
+  "even" |
+  "odd" |
+  "positive" |
+  "negative" |
+  "powerOfTwo" |
+  "ascii" |
+  "array" |
+  "jwt" |
+  "symbol" |
+  "email" |
+  "regex" |
+  "json" |
+  "ipAddress" |
+  "slug" |
+  "hexadecimal" |
+  "date" |
+  "timestamp" |
+  "function" |
+  "htmlElement" |
+  "htmlEventAttribute" |
+  "node" |
+  "object";
             
-type Operation = "select" | "insert" | "update" | "merge" | "delete";
 type Method = "GET" | "PATCH" | "PUT" | "POST" | "DELETE";
 
 class Property {
@@ -168,7 +166,7 @@ class Property {
   required: boolean;
   safe: boolean;
   typeCheck: boolean;
-  operations: Operation[];
+  methods: Method[];
   sanitize: boolean;
   normalize: boolean;
   control: boolean;
@@ -178,40 +176,38 @@ class Property {
 };
 
 class Entity {
-  table: string;
-  cols: Record<Operation, string[]>;
-  properties: Property[];
-  normalize(rows: Record<string, any>[]): Record<string, any>[]; // will also sanitize if true
-  validate(rows: Record<string, any>[], operation: Operation | Method): string | null;
-  getTable(): string;
-  // if pagination is true for a select operation, it will return cols + a total column 
-  getCols(operation: Operation, stringify?: boolean, pagination?: boolean): string[] | string;
-  getUnsafeProps(): string[];
+  constructor(name: string, properties: Property[]);
+  get name(): string;
+  get unsafeProps(): string[];
+  get properties(): Property[];
+  set name(name: string);
+  
+  /**
+   * Retrieves a property from the `properties` array that matches the specified key.
+   *
+   * @param {string} key - The key of the property to retrieve.
+   * @returns {Property | undefined} - The property object if found, otherwise `undefined`.
+   */
+  getProp(key: string): Property | undefined;
+  
+  /**
+   * Normalizes an array of records by applying sanitization and normalization
+   * rules defined in the `properties` of the class.
+   */
+  normalize(req: Request, _res: Response, next: NextFunction): void;
+  
+  /**
+   * Validates a set of rows against the defined properties and operation/method.
+   *
+   * 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(req: Request, _res: Response, next: NextFunction): void;
 }
 
 ```
-
-### REST Methods mapping
-
-When validating request inputs, you can use REST methods or SQL operations as second parameter 
-
-| REST method | SQL operation |
-| :---------- | :------------ |
-| GET         | select        |
-| PATCH       | update        |
-| PUT         | update        |
-| POST        | insert        |
-| DELETE      | delete        |
-
-examples : 
-
-```javascript
-
-entity.validate(req.body, "GET"); // will validate "select" properties
-entity.validate(req.body, "PUT"); // will validate "update" properties
-entity.validate(req.body, "DELETE"); // will validate "delete" properties
-
-```
+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,10 +24,8 @@ SOFTWARE.
 https://github.com/DWTechs/Antity.js
 */
 
-
-type Operation = typeof Operations[number];
+import type { Request, Response, NextFunction } from 'express';
 type Method = typeof Methods[number];
-
 type Type = 
   "boolean" |
   "string" |
@@ -57,38 +55,31 @@ type Type =
   "node" |
   "object";
 
-declare const Operations: readonly [ "select", "insert", "update", "merge", "delete" ];
 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;
+  validate: (
+    v: any, 
+    min: number | Date, 
+    max: number | Date, 
+    typeCheck: boolean
+  ) => boolean;
 }>;
 
-declare const Required: {
-  validate: (v: any) => boolean;
-};
-
 declare class Entity {
-  table: string;
-  cols: Record<Operation, string[]>;
-  properties: Property[];
-  constructor(table: string, properties: Property[]);
-  getTable(): string;
-  getCols(operation: Operation, stringify?: boolean, pagination?: boolean): string[] | string;
-  getUnsafeProps(): string[];
-  normalize(rows: Record<string, any>[]): Record<string, any>[];
-  validate(rows: Record<string, any>[], operation: Operation | Method): string | null;
-  private require;
-  private control;
-  private sanitize;
-  private trim;
+  private _name;
+  private _unsafeProps;
+  private _properties;
+  constructor(name: string, properties: Property[]);
+  get name(): string;
+  get unsafeProps(): string[];
+  get properties(): Property[];
+  set name(name: string);
+  getProp(key: string): Property | undefined;
+  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;
@@ -97,21 +88,22 @@ declare class Property {
   required: boolean;
   safe: boolean;
   typeCheck: boolean;
-  operations: Operation[];
+  methods: Method[];
   sanitize: boolean;
   normalize: boolean;
   control: boolean;
   sanitizer: ((v: any) => any) | null;
   normalizer: ((v: any) => any) | null;
   controller: ((v: any) => any) | null;
-  constructor(key: string,
+  constructor(
+    key: string,
     type: Type,
     min: number | Date,
     max: number | Date,
     required: boolean,
     safe: boolean,
     typeCheck: boolean,
-    operations: Operation[],
+    methods: Method[],
     sanitize: boolean,
     normalize: boolean,
     control: boolean,
@@ -121,13 +113,11 @@ declare class Property {
   );
 }
 
-export type { Type, Operation, Method };
+export type { Type, Method };
 export { 
   Entity,
   Property,
-  Messages,
   Types,
-  Required,
-  Operations 
+  Methods,
 };
 

package/dist/antity.js

@@ -24,10 +24,10 @@ SOFTWARE.
 https://github.com/DWTechs/Antity.js
 */
 
-import { isBoolean, isStringOfLength, isValidNumber, isValidInteger, isValidFloat, isEven, isOdd, isPositive, isNegative, isPowerOfTwo, isAscii, isArrayOfLength, isEmail, isRegex, isJson, isJWT, isSymbol, isIpAddress, isSlug, isHexadecimal, isValidDate, isValidTimestamp, isFunction, isHtmlElement, isHtmlEventAttribute, isNode, isObject, isNil, isString, isProperty, isArray, isIn, isDate, isInteger } from '@dwtechs/checkard';
+import { isBoolean, isStringOfLength, isValidNumber, isValidInteger, isValidFloat, isEven, isOdd, isPositive, isNegative, isPowerOfTwo, isAscii, isArrayOfLength, isEmail, isRegex, isJson, isJWT, isSymbol, isIpAddress, isSlug, isHexadecimal, isValidDate, isValidTimestamp, isFunction, isHtmlElement, isHtmlEventAttribute, isNode, isObject, isString, isProperty, isArray, isIn, isDate, isNumber, isInteger, isNil } from '@dwtechs/checkard';
 import { log } from '@dwtechs/winstan';
 
-const Operations = ["select", "insert", "update", "merge", "delete"];
+const Methods = ["GET", "PATCH", "PUT", "POST", "DELETE"];
 
 const Types = {
     boolean: {
@@ -112,20 +112,17 @@ const Types = {
         validate: (v, _min, _max, _typeCheck) => isObject(v)
     }
 };
-const Required = {
-    validate: (v) => !isNil(v)
-};
 
 class Property {
-    constructor(key, type, min, max, required, safe, typeCheck, operations, sanitize, normalize, control, sanitizer, normalizer, controller) {
-        if (!isString(key, true))
-            throw new Error(`Property"key" must be a string. Received ${key}`);
-        if (!isProperty(type, Types))
+    constructor(key, type, min, max, required, safe, typeCheck, methods, sanitize, normalize, control, sanitizer, normalizer, controller) {
+        if (!isString(key, "!0"))
+            throw new Error(`Property "key" must be a string. Received ${key}`);
+        if (!isProperty(Types, type))
             throw new Error(`Property "type" must be a valid type. Received ${type}`);
-        if (isArray(operations)) {
-            for (const o of operations) {
-                if (!isIn(o, Operations))
-                    throw new Error(`Property "operations" must be an array of SQL operations. Received ${o}`);
+        if (isArray(methods)) {
+            for (const m of methods) {
+                if (!isIn(Methods, m))
+                    throw new Error(`Property "methods" must be an array of REST methods. Received ${m}`);
             }
         }
         this.key = key;
@@ -135,7 +132,7 @@ class Property {
         this.required = isBoolean(required) ? required : false;
         this.safe = isBoolean(safe) ? safe : true;
         this.typeCheck = isBoolean(typeCheck) ? typeCheck : false;
-        this.operations = operations || Operations;
+        this.methods = methods || Methods;
         this.sanitize = isBoolean(sanitize) ? sanitize : true;
         this.normalize = isBoolean(normalize) ? normalize : false;
         this.control = isBoolean(control) ? control : true;
@@ -146,53 +143,44 @@ class Property {
     interval(val, type, integerDefault, dateDefault) {
         if (type === "date")
             return isDate(val) ? val : new Date(dateDefault);
-        return isInteger(val, true) ? val : integerDefault;
+        return (isNumber(val, true) && isInteger(val, true)) ? val : integerDefault;
     }
 }
 
-const Messages = {
-    missing: (key) => `Missing ${key}`,
-    invalid: (key, type) => `Invalid ${key}, must be of type ${type}`,
-};
-
-const Methods = ["GET", "PATCH", "PUT", "POST", "DELETE"];
-
 class Entity {
-    constructor(table, properties) {
-        this.table = table;
-        this.properties = [];
-        this.cols = {
-            select: [],
-            insert: [],
-            update: [],
-            merge: [],
-            delete: []
-        };
-        this.unsafeProps = [];
+    constructor(name, properties) {
+        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.operations, p.sanitize, p.normalize, p.control, p.sanitizer, p.normalizer, p.controller);
-            this.properties.push(prop);
-            for (const o of p.operations) {
-                if (o === "update")
-                    this.cols[o].push(`${p.key} = $${this.cols[o].length + 1}`);
-                else
-                    this.cols[o].push(p.key);
-            }
+            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);
+            this._properties.push(prop);
             if (!prop.safe)
-                this.unsafeProps.push(prop.key);
+                this._unsafeProps.push(prop.key);
         }
     }
-    getTable() {
-        return this.table;
+    get name() {
+        return this._name;
     }
-    getCols(operation, stringify, pagination) {
-        const cols = pagination && operation === "select" ? [...this.cols[operation], "COUNT(*) OVER () AS total"] : this.cols[operation];
-        return stringify ? cols.join(', ') : cols;
+    get unsafeProps() {
+        return this._unsafeProps;
     }
-    getUnsafeProps() {
-        return this.unsafeProps;
+    get properties() {
+        return this._properties;
     }
-    normalize(rows) {
+    set name(name) {
+        if (!isString(name, "!0"))
+            throw new Error('name must be a string of length > 0');
+        this._name = name;
+    }
+    getProp(key) {
+        return this.properties.find(p => p.key === key);
+    }
+    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];
@@ -209,39 +197,50 @@ class Entity {
                 }
             }
         }
-        return rows;
+        next();
     }
-    validate(rows, operation) {
-        if (isIn(operation, Methods))
-            operation = this.mapMethods(operation);
+    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 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, operations, control, controller } of this.properties) {
+            for (const { key, type, min, max, required, typeCheck, methods, control, controller } of this.properties) {
                 const v = r[key];
-                if (isIn(operation, operations)) {
+                if (isIn(methods, method)) {
                     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 Required.validate(v) ? null : Messages.missing(key);
+        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);
-        return Types[type].validate(v, min, max, typeCheck) ? 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)
@@ -255,33 +254,18 @@ class Entity {
         return this.trim(v);
     }
     trim(v) {
-        if (isString(v, true))
+        if (isString(v, "!0"))
             return v.trim();
         if (isObject(v, true)) {
-            if (v.has)
-                for (const p in v) {
-                    if (v.prototype.hasOwnProperty.call(p)) {
-                        let o = v[p];
-                        if (isString(o, true))
-                            o = o.trim();
-                    }
+            for (const k in v) {
+                if (Object.prototype.hasOwnProperty.call(v, k)) {
+                    let o = v[k];
+                    if (isString(o, "!0", null))
+                        o = o.trim();
                 }
-            return v;
-        }
-    }
-    mapMethods(method) {
-        switch (method) {
-            case "GET":
-                return Operations[0];
-            case "PATCH":
-                return Operations[2];
-            case "PUT":
-                return Operations[2];
-            case "POST":
-                return Operations[1];
-            case "DELETE":
-                return Operations[4];
+            }
         }
+        return v;
     }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dwtechs/antity",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "Open source library for easy entity management",
   "keywords": [
     "entities"
@@ -25,6 +25,7 @@
   "contributors": [],
   "scripts": {
     "start": "",
+    "prebuild": "npm install",
     "build": "node ./scripts/clear && tsc && npm run rollup && node ./scripts/copy && npm run test",
     "rollup:mjs": "rollup --config rollup.config.mjs",
     "rollup:cjs": "rollup --config rollup.config.cjs.mjs",
@@ -35,8 +36,9 @@
     "dist/"
   ],
   "dependencies": {
-    "@dwtechs/checkard": "2.29.2",
-    "@dwtechs/winstan": "0.3.0",
+    "@dwtechs/checkard": "3.2.3",
+    "@dwtechs/winstan": "0.4.0",
+    "@dwtechs/sparray": "0.1.1",
     "pg": "8.13.1"
   },
   "devDependencies": {
@@ -46,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",