@dwtechs/antity 0.2.0 → 0.4.0

package/README.md

@@ -50,15 +50,16 @@ $ npm i @dwtechs/antity
 import { Entity } from "@dwtechs/antity";
 import { normalizeName, normalizeNickname } from "@dwtechs/checkard";
 
-const entity = new Entity("consumer", "consumers", [
+const entity = new Entity("consumers", [
   {
     key: "id",
     type: "integer",
     min: 0,
     max: 120,
     typeCheck: true,
-    methods: ["get", "put", "delete"],
+    operations: ["select", "update", "delete"],
     required: true,
+    safe: true,
     sanitize: true,
     normalize: true,
     control: true,
@@ -72,8 +73,9 @@ const entity = new Entity("consumer", "consumers", [
     min: 0,
     max: 255,
     typeCheck: true,
-    methods: ["get", "post", "put", "delete"],
+    operations: ["select", "insert", "update", "delete"],
     required: true,
+    safe: true,
     sanitize: true,
     normalize: true,
     control: true,
@@ -87,8 +89,9 @@ const entity = new Entity("consumer", "consumers", [
     min: 0,
     max: 255,
     typeCheck: true,
-    methods: ["get", "post", "put", "delete"],
+    operations: ["select", "insert", "update", "delete"],
     required: true,
+    safe: true,
     sanitize: true,
     normalize: true,
     control: true,
@@ -102,8 +105,9 @@ const entity = new Entity("consumer", "consumers", [
     min: 0,
     max: 255,
     typeCheck: true,
-    methods: ["get", "post", "put", "delete"],
+    operations: ["select", "insert", "update", "delete"],
     required: true,
+    safe: true,
     sanitize: true,
     normalize: true,
     control: true,
@@ -113,8 +117,9 @@ const entity = new Entity("consumer", "consumers", [
   },
 ]);
 
-req.body = entity.normalize(req.body);
-const check = entity.validate(req.body, req.method);
+req.body = entity.normalize(req.body); // will also sanitize if true
+const check = entity.validate(req.body, "select");
+const unsafeProps = entity.getUnsafeProps();
 
 ```
 
@@ -152,6 +157,7 @@ type Type = "boolean" |
             "node" |
             "object";
             
+type Operation = "select" | "insert" | "update" | "merge" | "delete";
 type Method = "GET" | "PATCH" | "PUT" | "POST" | "DELETE";
 
 class Property {
@@ -160,8 +166,9 @@ class Property {
   min: number | Date;
   max: number | Date;
   required: boolean;
+  safe: boolean;
   typeCheck: boolean;
-  methods: Method[];
+  operations: Operation[];
   sanitize: boolean;
   normalize: boolean;
   control: boolean;
@@ -171,15 +178,41 @@ class Property {
 };
 
 class Entity {
-  name: string;
   table: string;
+  cols: Record<Operation, string[]>;
   properties: Property[];
-  normalize(rows: Record<string, any>[]): Record<string, any>[];
-  validate(rows: Record<string, any>[], method: Method): string | null;
+  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[];
 }
 
 ```
 
+### 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
+
+```
+
 
 ### Available options for a property
 
@@ -188,17 +221,18 @@ 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                   | Minimum value                                     | 0
-| max             |  number                   | Maximum value                                     | 999999999
-| required        |  boolean                  | Is this property required for these methods       | false
+| 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                  | 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
-| methods         |  Method[]                 | REST Methods that use the property                | [ "GET", "PATCH", "PUT", "POST", "DELETE" ]
+| operations      |  Operation[]              | 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
-| sanitizer       |  ((v:any) => any) \| null  | Sanitizer function if sanitize is true            | null
-| normalizer      |  ((v:any) => any) \| null  | Normalizer function if normalize is true          | null
+| 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
 
 * *Min and max parameters are not used for boolean type*

package/dist/antity.cjs.js

@@ -331,7 +331,7 @@ function isValidTimestamp(t, min = -2208989361000, max = 7258114800000, type = t
     return isTimestamp(t, type) && t >= min && t <= max;
 }
 
-const Methods = ["GET", "PATCH", "PUT", "POST", "DELETE"];
+const Operations = ["select", "insert", "update", "merge", "delete"];
 
 const Types = {
     boolean: {
@@ -421,24 +421,25 @@ const Required = {
 };
 
 class Property {
-    constructor(key, type, min, max, required, typeCheck, methods, sanitize, normalize, control, sanitizer, normalizer, controller) {
+    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}`);
+            throw new Error(`Property"key" must be a string. Received ${key}`);
         if (!isProperty(type, Types))
-            throw new Error(`Property type must be a valid type. Received ${type}`);
-        if (isArray(methods)) {
-            for (const m of methods) {
-                if (!isIn(m, Methods))
-                    throw new Error(`Property methods must be an array of REST Methods. Received ${m}`);
+            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}`);
             }
         }
         this.key = key;
         this.type = type;
-        this.min = isInteger(min, true) ? min : 0;
-        this.max = isInteger(max, true) ? max : 999999999;
+        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.operations = operations || Operations;
         this.sanitize = isBoolean(sanitize) ? sanitize : true;
         this.normalize = isBoolean(normalize) ? normalize : false;
         this.control = isBoolean(control) ? control : true;
@@ -446,6 +447,11 @@ class Property {
         this.normalizer = isFunction(normalizer) ? normalizer : null;
         this.controller = isFunction(controller) ? controller : null;
     }
+    interval(val, type, integerDefault, dateDefault) {
+        if (type === "date")
+            return isDate(val) ? val : new Date(dateDefault);
+        return isInteger(val, true) ? val : integerDefault;
+    }
 }
 
 const Messages = {
@@ -453,47 +459,67 @@ const Messages = {
     invalid: (key, type) => `Invalid ${key}, must be of type ${type}`,
 };
 
+const Methods = ["GET", "PATCH", "PUT", "POST", "DELETE"];
+
 class Entity {
-    constructor(name, table, properties) {
-        this.name = name;
+    constructor(table, properties) {
         this.table = table;
-        this.properties = this.init(properties);
-    }
-    init(properties) {
-        const props = [];
+        this.properties = [];
+        this.cols = {
+            select: [],
+            insert: [],
+            update: [],
+            merge: [],
+            delete: []
+        };
+        this.unsafeProps = [];
         for (const p of properties) {
-            props.push(new Property(p.key, p.type, p.min, p.max, p.required, 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.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);
+            }
+            if (!prop.safe)
+                this.unsafeProps.push(prop.key);
         }
-        return props;
     }
-    cols(method) {
-        const cols = [];
-        for (const p of this.properties) {
-            if (isIn(method, p.methods))
-                cols.push(p.key);
-        }
-        return cols;
+    getTable() {
+        return this.table;
+    }
+    getCols(operation, stringify, pagination) {
+        const cols = pagination && operation === "select" ? [...this.cols[operation], "COUNT(*) OVER () AS total"] : this.cols[operation];
+        return stringify ? cols.join(', ') : cols;
+    }
+    getUnsafeProps() {
+        return this.unsafeProps;
     }
     normalize(rows) {
         for (const r of rows) {
             for (const { key, sanitize, normalize, sanitizer, normalizer, } of this.properties) {
                 let v = r[key];
                 if (v) {
-                    if (sanitize)
+                    if (sanitize) {
                         v = this.sanitize(v, sanitizer);
-                    if (normalize && normalizer)
+                    }
+                    if (normalize && normalizer) {
                         v = normalizer(v);
+                    }
                     r[key] = v;
                 }
             }
         }
         return rows;
     }
-    validate(rows, method) {
+    validate(rows, operation) {
+        if (isIn(operation, Methods))
+            operation = this.mapMethods(operation);
         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, operations, control, controller } of this.properties) {
                 const v = r[key];
-                if (method && isIn(method, methods)) {
+                if (isIn(operation, operations)) {
                     if (required) {
                         const rq = this.require(v, key);
                         if (rq)
@@ -543,6 +569,20 @@ class Entity {
             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];
+        }
+    }
 }
 
 exports.Entity = Entity;

package/dist/antity.d.ts

@@ -25,30 +25,59 @@ https://github.com/DWTechs/Antity.js
 */
 
 
-type Type = keyof typeof Types;
+type Operation = typeof Operations[number];
 type Method = typeof Methods[number];
 
-declare const Methods: readonly ["GET", "PATCH", "PUT", "POST", "DELETE"];
+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";
 
-declare const Types: {
-  [key: string]: {
-      validate: (v: any, min: number | Date, max: number | Date, typeCheck: boolean) => boolean;
-  };
-};
+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;
+}>;
 
 declare const Required: {
   validate: (v: any) => boolean;
 };
 
 declare class Entity {
-  name: string;
   table: string;
+  cols: Record<Operation, string[]>;
   properties: Property[];
-  constructor(name: string, table: string, properties: Property[]);
-  private init;
-  cols(method: Method): string[];
+  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>[], method: Method): string | null;
+  validate(rows: Record<string, any>[], operation: Operation | Method): string | null;
   private require;
   private control;
   private sanitize;
@@ -63,11 +92,12 @@ declare const Messages: {
 declare class Property {
   key: string;
   type: Type;
-  min: number;
-  max: number;
+  min: number | Date;
+  max: number | Date;
   required: boolean;
+  safe: boolean;
   typeCheck: boolean;
-  methods: Method[];
+  operations: Operation[];
   sanitize: boolean;
   normalize: boolean;
   control: boolean;
@@ -79,8 +109,9 @@ declare class Property {
     min: number | Date,
     max: number | Date,
     required: boolean,
+    safe: boolean,
     typeCheck: boolean,
-    methods: Method[],
+    operations: Operation[],
     sanitize: boolean,
     normalize: boolean,
     control: boolean,
@@ -90,13 +121,13 @@ declare class Property {
   );
 }
 
-export type { Type, Method };
+export type { Type, Operation, Method };
 export { 
   Entity,
   Property,
   Messages,
   Types,
   Required,
-  Methods 
+  Operations 
 };
 

package/dist/antity.js

@@ -24,9 +24,9 @@ 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, 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, isNil, isString, isProperty, isArray, isIn, isDate, isInteger } from '@dwtechs/checkard';
 
-const Methods = ["GET", "PATCH", "PUT", "POST", "DELETE"];
+const Operations = ["select", "insert", "update", "merge", "delete"];
 
 const Types = {
     boolean: {
@@ -116,24 +116,25 @@ const Required = {
 };
 
 class Property {
-    constructor(key, type, min, max, required, typeCheck, methods, sanitize, normalize, control, sanitizer, normalizer, controller) {
+    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}`);
+            throw new Error(`Property"key" must be a string. Received ${key}`);
         if (!isProperty(type, Types))
-            throw new Error(`Property type must be a valid type. Received ${type}`);
-        if (isArray(methods)) {
-            for (const m of methods) {
-                if (!isIn(m, Methods))
-                    throw new Error(`Property methods must be an array of REST Methods. Received ${m}`);
+            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}`);
             }
         }
         this.key = key;
         this.type = type;
-        this.min = isInteger(min, true) ? min : 0;
-        this.max = isInteger(max, true) ? max : 999999999;
+        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.operations = operations || Operations;
         this.sanitize = isBoolean(sanitize) ? sanitize : true;
         this.normalize = isBoolean(normalize) ? normalize : false;
         this.control = isBoolean(control) ? control : true;
@@ -141,6 +142,11 @@ class Property {
         this.normalizer = isFunction(normalizer) ? normalizer : null;
         this.controller = isFunction(controller) ? controller : null;
     }
+    interval(val, type, integerDefault, dateDefault) {
+        if (type === "date")
+            return isDate(val) ? val : new Date(dateDefault);
+        return isInteger(val, true) ? val : integerDefault;
+    }
 }
 
 const Messages = {
@@ -148,47 +154,67 @@ const Messages = {
     invalid: (key, type) => `Invalid ${key}, must be of type ${type}`,
 };
 
+const Methods = ["GET", "PATCH", "PUT", "POST", "DELETE"];
+
 class Entity {
-    constructor(name, table, properties) {
-        this.name = name;
+    constructor(table, properties) {
         this.table = table;
-        this.properties = this.init(properties);
-    }
-    init(properties) {
-        const props = [];
+        this.properties = [];
+        this.cols = {
+            select: [],
+            insert: [],
+            update: [],
+            merge: [],
+            delete: []
+        };
+        this.unsafeProps = [];
         for (const p of properties) {
-            props.push(new Property(p.key, p.type, p.min, p.max, p.required, 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.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);
+            }
+            if (!prop.safe)
+                this.unsafeProps.push(prop.key);
         }
-        return props;
     }
-    cols(method) {
-        const cols = [];
-        for (const p of this.properties) {
-            if (isIn(method, p.methods))
-                cols.push(p.key);
-        }
-        return cols;
+    getTable() {
+        return this.table;
+    }
+    getCols(operation, stringify, pagination) {
+        const cols = pagination && operation === "select" ? [...this.cols[operation], "COUNT(*) OVER () AS total"] : this.cols[operation];
+        return stringify ? cols.join(', ') : cols;
+    }
+    getUnsafeProps() {
+        return this.unsafeProps;
     }
     normalize(rows) {
         for (const r of rows) {
             for (const { key, sanitize, normalize, sanitizer, normalizer, } of this.properties) {
                 let v = r[key];
                 if (v) {
-                    if (sanitize)
+                    if (sanitize) {
                         v = this.sanitize(v, sanitizer);
-                    if (normalize && normalizer)
+                    }
+                    if (normalize && normalizer) {
                         v = normalizer(v);
+                    }
                     r[key] = v;
                 }
             }
         }
         return rows;
     }
-    validate(rows, method) {
+    validate(rows, operation) {
+        if (isIn(operation, Methods))
+            operation = this.mapMethods(operation);
         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, operations, control, controller } of this.properties) {
                 const v = r[key];
-                if (method && isIn(method, methods)) {
+                if (isIn(operation, operations)) {
                     if (required) {
                         const rq = this.require(v, key);
                         if (rq)
@@ -238,6 +264,20 @@ class Entity {
             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];
+        }
+    }
 }
 
 export { Entity };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dwtechs/antity",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Open source library for easy entity management",
   "keywords": [
     "entities"
@@ -35,7 +35,9 @@
     "dist/"
   ],
   "dependencies": {
-    "@dwtechs/checkard": "2.29.2"
+    "@dwtechs/checkard": "2.29.2",
+    "@dwtechs/winstan": "0.2.1",
+    "pg": "8.13.1"
   },
   "devDependencies": {
     "@babel/core": "7.26.0",
@@ -43,6 +45,7 @@
     "@rollup/plugin-commonjs": "28.0.1",
     "@rollup/plugin-node-resolve": "15.3.0",
     "@types/jest": "29.5.14",
+    "@types/node": "22.10.1",
     "babel-jest": "29.7.0",
     "core-js": "3.33.0",
     "jest": "29.7.0",