@dwtechs/antity 0.1.0 → 0.3.0

package/README.md

@@ -116,6 +116,8 @@ const entity = new Entity("consumer", "consumers", [
 req.body = entity.normalize(req.body);
 const check = entity.validate(req.body, req.method);
 
+
+
 ```
 
 
@@ -124,17 +126,44 @@ const check = entity.validate(req.body, req.method);
 
 ```javascript
 
-type Type = "boolean" | "string" | "number" | "integer" | "array";
+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 Method = "GET" | "PATCH" | "PUT" | "POST" | "DELETE";
 
 class Property {
   key: string;
   type: Type;
-  min: number;
-  max: number;
+  min: number | Date;
+  max: number | Date;
   required: boolean;
   typeCheck: boolean;
-  verbs: Verb[];
+  methods: Method[];
   sanitize: boolean;
   normalize: boolean;
   control: boolean;
@@ -146,9 +175,12 @@ class Property {
 class Entity {
   name: string;
   table: string;
+  cols: Record<Method, string>;
   properties: Property[];
   normalize(rows: Record<string, any>[]): Record<string, any>[];
   validate(rows: Record<string, any>[], method: Method): string | null;
+  getTable(): string;
+  getCols(method: Method): string;
 }
 
 ```

package/dist/antity.cjs.js

@@ -84,12 +84,40 @@ const comparisons = {
     '<=': (a, b) => a <= b,
     '>=': (a, b) => a >= b
 };
+
+function isAscii(c, ext = true) {
+    return isInteger(c, false) && ((ext && c >= 0 && c <= 255) || (c >= 0 && c <= 127));
+}
 function isInteger(n, type = true) {
     if (!isNumber(n, type))
         return false;
     const int = Number.parseInt(String(n), 10);
     return type ? n === int : n == int;
 }
+function isFloat(n, type = true) {
+    if (isSymbol(n))
+        return false;
+    const modulo = n % 1 !== 0;
+    return type ? (Number(n) === n && modulo) : (Number(n) == n && modulo);
+}
+function isEven(n, type = true) {
+    return isInteger(n, type) && !(n & 1);
+}
+function isOdd(n, type = true) {
+    return isInteger(n, type) && Boolean(n & 1);
+}
+function isOrigin(n, type = true) {
+    return type ? n === 0 : n == 0;
+}
+function isPositive(n, type = true) {
+    return isNumber(n, type) && n > 0;
+}
+function isNegative(n, type = true) {
+    return isNumber(n, type) && n < 0;
+}
+function isPowerOfTwo(n, type = true) {
+    return isInteger(n, type) && !isOrigin(n, type) && (n & (n - 1)) === 0;
+}
 
 function isValidNumber(n, min = -999999999, max = 999999999, type = true) {
     return isNumber(n, type) && n >= min && n <= max;
@@ -97,6 +125,9 @@ function isValidNumber(n, min = -999999999, max = 999999999, type = true) {
 function isValidInteger(n, min = -999999999, max = 999999999, type = true) {
     return isInteger(n, type) && n >= min && n <= max;
 }
+function isValidFloat(n, min = -999999999.9, max = 999999999.9, type = true) {
+    return isFloat(n, type) && n >= min && n <= max;
+}
 
 function isArray(a, comp, len) {
     return (a === null || a === void 0 ? void 0 : a.constructor) === Array ? (comp && isValidInteger(len, 0, 999999999)) ? comparisons.hasOwnProperty(comp) ? comparisons[comp](a.length, len) : false : true : false;
@@ -122,6 +153,64 @@ function isStringOfLength(s, min = 0, max = 999999999) {
     }
     return false;
 }
+function isJson(s) {
+    if (!isString(s))
+        return false;
+    try {
+        JSON.parse(s);
+    }
+    catch (e) {
+        return false;
+    }
+    return true;
+}
+function isRegex(r, type = true) {
+    if (type)
+        return r instanceof RegExp;
+    try {
+        new RegExp(r);
+    }
+    catch (e) {
+        return false;
+    }
+    return true;
+}
+const emailReg = /^(?=[a-z0-9@.!$%&'*+\/=?^_‘{|}~-]{6,254}$)(?=[a-z0-9.!#$%&'*+\/=?^_‘{|}~-]{1,64}@)[a-z0-9!#$%&'*+\/=?^‘{|}~]+(?:[\._-][a-z0-9!#$%&'*+\/=?^‘{|}~]+)*@(?:(?=[a-z0-9-]{1,63}\.)[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+(?=[a-z0-9-]{2,63}$)[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
+function isEmail(e) {
+    return !isSymbol(e) && emailReg.test(String(e).toLowerCase());
+}
+const ipReg = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
+function isIpAddress(i) {
+    return !isSymbol(i) && ipReg.test(i);
+}
+const b64Reg = /^[A-Za-z0-9\-_]+={0,2}$/;
+function isJWT(t) {
+    if (!isString(t))
+        return false;
+    const p = t.split('.');
+    if (p.length !== 3)
+        return false;
+    const header = p[0];
+    const payload = p[1];
+    const signature = p[3];
+    if (b64Reg.test(header) && b64Reg.test(payload) && b64Reg.test(signature)) {
+        try {
+            return isJson(atob(header)) && isJson(atob(payload));
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    return false;
+}
+const slugReg = /^[^\s-_](?!.*?[-_]{2,})[a-z0-9-\\][^\s]*[^-_\s]$/;
+function isSlug(s) {
+    return isString(s) && slugReg.test(s);
+}
+const hexadecimal = /^(#|0x|0h)?[0-9A-F]+$/i;
+function isHexadecimal(s) {
+    return isString(s) && hexadecimal.test(s);
+}
 
 function isObject(o, empty = false) {
     return o !== null && typeof o === "object" && !isArray(o) && (empty ? !!Object.keys(o).length : true);
@@ -131,6 +220,117 @@ function isProperty(val, obj) {
     return isString(v, true) && isObject(obj) ? Object.keys(obj).includes(v) : false;
 }
 
+function isHtmlElement(h) {
+    return Boolean(typeof HTMLElement === "object"
+        ? h instanceof HTMLElement
+        : h &&
+            typeof h === "object" &&
+            h.nodeType === 1 &&
+            typeof h.nodeName === "string");
+}
+function isHtmlEventAttribute(h) {
+    switch (h) {
+        case "onafterprint":
+        case "onbeforeprint":
+        case "onbeforeunload":
+        case "onerror":
+        case "onhashchange":
+        case "onload":
+        case "onmessage":
+        case "onoffline":
+        case "ononline":
+        case "onpagehide":
+        case "onpageshow":
+        case "onpopstate":
+        case "onresize":
+        case "onstorage":
+        case "onunload":
+        case "onblur":
+        case "onchange":
+        case "oncontextmenu":
+        case "onfocus":
+        case "oninput":
+        case "oninvalid":
+        case "onreset":
+        case "onsearch":
+        case "onselect":
+        case "onsubmit":
+        case "onkeydown":
+        case "onkeypress":
+        case "onkeyup":
+        case "onclick":
+        case "ondblclick":
+        case "onmousedown":
+        case "onmousemove":
+        case "onmouseout":
+        case "onmouseover":
+        case "onmouseup":
+        case "onmousewheel":
+        case "onwheel":
+        case "ondrag":
+        case "ondragend":
+        case "ondragenter":
+        case "ondragleave":
+        case "ondragover":
+        case "ondragstart":
+        case "ondrop":
+        case "onscroll":
+        case "oncopy":
+        case "oncut":
+        case "onpaste":
+        case "onabort":
+        case "oncanplay":
+        case "oncanplaythrough":
+        case "oncuechange":
+        case "ondurationchange":
+        case "onemptied":
+        case "onended":
+        case "onerror":
+        case "onloadeddata":
+        case "onloadedmetadata":
+        case "onloadstart":
+        case "onpause":
+        case "onplay":
+        case "onplaying":
+        case "onprogress":
+        case "onratechange":
+        case "onseeked":
+        case "onseeking":
+        case "onstalled":
+        case "onsuspend":
+        case "ontimeupdate":
+        case "onvolumechange":
+        case "onwaiting":
+        case "ontoggle":
+            return true;
+        default:
+            return false;
+    }
+}
+function isNode(n) {
+    return Boolean(typeof Node === "object"
+        ? n instanceof Node
+        : n &&
+            typeof n === "object" &&
+            typeof n.nodeType === "number" &&
+            typeof n.nodeName === "string");
+}
+
+function isDate(d) {
+    return !isNaN(d) && d instanceof Date;
+}
+const minDate = new Date('1/1/1900');
+const maxDate = new Date('1/1/2200');
+function isValidDate(d, min = minDate, max = maxDate) {
+    return isDate(d) && d >= min && d <= max;
+}
+function isTimestamp(t, type = true) {
+    return isInteger(t, type) && isNumeric(new Date(parseInt(t + '')).getTime());
+}
+function isValidTimestamp(t, min = -2208989361000, max = 7258114800000, type = true) {
+    return isTimestamp(t, type) && t >= min && t <= max;
+}
+
 const Methods = ["GET", "PATCH", "PUT", "POST", "DELETE"];
 
 const Types = {
@@ -146,8 +346,74 @@ const Types = {
     integer: {
         validate: (v, min, max, typeCheck) => isValidInteger(v, min || undefined, max || undefined, typeCheck || undefined)
     },
+    float: {
+        validate: (v, min, max, typeCheck) => isValidFloat(v, min || undefined, max || undefined, typeCheck || undefined)
+    },
+    even: {
+        validate: (v, _min, _max, typeCheck) => isEven(v, typeCheck || undefined)
+    },
+    odd: {
+        validate: (v, _min, _max, typeCheck) => isOdd(v, typeCheck || undefined)
+    },
+    positive: {
+        validate: (v, _min, _max, typeCheck) => isPositive(v, typeCheck || undefined)
+    },
+    negative: {
+        validate: (v, _min, _max, typeCheck) => isNegative(v, typeCheck || undefined)
+    },
+    powerOfTwo: {
+        validate: (v, _min, _max, typeCheck) => isPowerOfTwo(v, typeCheck || undefined)
+    },
+    ascii: {
+        validate: (v, _min, _max, typeCheck) => isAscii(v, typeCheck || undefined)
+    },
     array: {
-        validate: (v, min, max, _typeCheck) => isArrayOfLength(v, min, max)
+        validate: (v, min, max, _typeCheck) => isArrayOfLength(v, min || undefined, max || undefined)
+    },
+    email: {
+        validate: (v, _min, _max, _typeCheck) => isEmail(v)
+    },
+    regex: {
+        validate: (v, _min, _max, typeCheck) => isRegex(v, typeCheck || undefined)
+    },
+    json: {
+        validate: (v, _min, _max, _typeCheck) => isJson(v)
+    },
+    jwt: {
+        validate: (v, _min, _max, _typeCheck) => isJWT(v)
+    },
+    symbol: {
+        validate: (v, _min, _max, _typeCheck) => isSymbol(v)
+    },
+    ipAddress: {
+        validate: (v, _min, _max, _typeCheck) => isIpAddress(v)
+    },
+    slug: {
+        validate: (v, _min, _max, _typeCheck) => isSlug(v)
+    },
+    hexadecimal: {
+        validate: (v, _min, _max, _typeCheck) => isHexadecimal(v)
+    },
+    date: {
+        validate: (v, min, max, _typeCheck) => isValidDate(v, min || undefined, max || undefined)
+    },
+    timestamp: {
+        validate: (v, min, max, typeCheck) => isValidTimestamp(v, min || undefined, max || undefined, typeCheck || undefined)
+    },
+    function: {
+        validate: (v, _min, _max, _typeCheck) => isFunction(v)
+    },
+    htmlElement: {
+        validate: (v, _min, _max, _typeCheck) => isHtmlElement(v)
+    },
+    htmlEventAttribute: {
+        validate: (v, _min, _max, _typeCheck) => isHtmlEventAttribute(v)
+    },
+    node: {
+        validate: (v, _min, _max, _typeCheck) => isNode(v)
+    },
+    object: {
+        validate: (v, _min, _max, _typeCheck) => isObject(v)
     }
 };
 const Required = {
@@ -191,22 +457,30 @@ class Entity {
     constructor(name, table, properties) {
         this.name = name;
         this.table = table;
+        this.cols = {
+            GET: "",
+            POST: "",
+            PUT: "",
+            PATCH: "",
+            DELETE: "",
+        };
         this.properties = this.init(properties);
     }
     init(properties) {
         const props = [];
         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));
+            for (const m of p.methods) {
+                this.cols[m] += this.cols[m].length ? `, ${p.key}` : `${p.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(method) {
+        return this.cols[method];
     }
     normalize(rows) {
         for (const r of rows) {
@@ -233,7 +507,7 @@ class Entity {
                         if (rq)
                             return rq;
                     }
-                    if (control) {
+                    if (v && control) {
                         const ct = this.control(v, key, type, min, max, typeCheck, controller);
                         if (ct)
                             return ct;

package/dist/antity.d.ts

@@ -25,28 +25,41 @@ https://github.com/DWTechs/Antity.js
 */
 
 
-type Type = keyof typeof Types;
 type Method = typeof Methods[number];
+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 Methods: readonly ["GET", "PATCH", "PUT", "POST", "DELETE"];
 
-declare const Types: {
-  readonly boolean: {
-      readonly validate: (v: any, _min: number, _max: number, _typeCheck: boolean) => v is boolean;
-  };
-  readonly string: {
-      readonly validate: (v: any, min: number, max: number, _typeCheck: boolean) => v is string;
-  };
-  readonly number: {
-      readonly validate: (v: any, min: number, max: number, typeCheck: boolean) => v is number;
-  };
-  readonly integer: {
-      readonly validate: (v: any, min: number, max: number, typeCheck: boolean) => v is number;
-  };
-  readonly array: {
-      readonly validate: (v: any, min: number, max: number, _typeCheck: boolean) => v is any[];
-  };
-};
+declare const Types: Record<Type, {
+  validate: (v: any, min: number | Date, max: number | Date, typeCheck: boolean) => boolean;
+}>;
 
 declare const Required: {
   validate: (v: any) => boolean;
@@ -55,10 +68,12 @@ declare const Required: {
 declare class Entity {
   name: string;
   table: string;
+  cols: Record<Method, string>;
   properties: Property[];
   constructor(name: string, table: string, properties: Property[]);
   private init;
-  cols(method: Method): string[];
+  getTable(): string;
+  getCols(method: Method): string;
   normalize(rows: Record<string, any>[]): Record<string, any>[];
   validate(rows: Record<string, any>[], method: Method): string | null;
   private require;
@@ -88,8 +103,8 @@ declare class Property {
   controller: ((v: any) => any) | null;
   constructor(key: string,
     type: Type,
-    min: number,
-    max: number,
+    min: number | Date,
+    max: number | Date,
     required: boolean,
     typeCheck: boolean,
     methods: Method[],
@@ -101,6 +116,7 @@ declare class Property {
     controller: ((v: any) => any) | null
   );
 }
+
 export type { Type, Method };
 export { 
   Entity,

package/dist/antity.js

@@ -24,7 +24,7 @@ SOFTWARE.
 https://github.com/DWTechs/Antity.js
 */
 
-import { isBoolean, isStringOfLength, isValidNumber, isValidInteger, isArrayOfLength, isNil, isString, isProperty, isArray, isIn, isInteger, isFunction, isObject } 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, isInteger } from '@dwtechs/checkard';
 
 const Methods = ["GET", "PATCH", "PUT", "POST", "DELETE"];
 
@@ -41,8 +41,74 @@ const Types = {
     integer: {
         validate: (v, min, max, typeCheck) => isValidInteger(v, min || undefined, max || undefined, typeCheck || undefined)
     },
+    float: {
+        validate: (v, min, max, typeCheck) => isValidFloat(v, min || undefined, max || undefined, typeCheck || undefined)
+    },
+    even: {
+        validate: (v, _min, _max, typeCheck) => isEven(v, typeCheck || undefined)
+    },
+    odd: {
+        validate: (v, _min, _max, typeCheck) => isOdd(v, typeCheck || undefined)
+    },
+    positive: {
+        validate: (v, _min, _max, typeCheck) => isPositive(v, typeCheck || undefined)
+    },
+    negative: {
+        validate: (v, _min, _max, typeCheck) => isNegative(v, typeCheck || undefined)
+    },
+    powerOfTwo: {
+        validate: (v, _min, _max, typeCheck) => isPowerOfTwo(v, typeCheck || undefined)
+    },
+    ascii: {
+        validate: (v, _min, _max, typeCheck) => isAscii(v, typeCheck || undefined)
+    },
     array: {
-        validate: (v, min, max, _typeCheck) => isArrayOfLength(v, min, max)
+        validate: (v, min, max, _typeCheck) => isArrayOfLength(v, min || undefined, max || undefined)
+    },
+    email: {
+        validate: (v, _min, _max, _typeCheck) => isEmail(v)
+    },
+    regex: {
+        validate: (v, _min, _max, typeCheck) => isRegex(v, typeCheck || undefined)
+    },
+    json: {
+        validate: (v, _min, _max, _typeCheck) => isJson(v)
+    },
+    jwt: {
+        validate: (v, _min, _max, _typeCheck) => isJWT(v)
+    },
+    symbol: {
+        validate: (v, _min, _max, _typeCheck) => isSymbol(v)
+    },
+    ipAddress: {
+        validate: (v, _min, _max, _typeCheck) => isIpAddress(v)
+    },
+    slug: {
+        validate: (v, _min, _max, _typeCheck) => isSlug(v)
+    },
+    hexadecimal: {
+        validate: (v, _min, _max, _typeCheck) => isHexadecimal(v)
+    },
+    date: {
+        validate: (v, min, max, _typeCheck) => isValidDate(v, min || undefined, max || undefined)
+    },
+    timestamp: {
+        validate: (v, min, max, typeCheck) => isValidTimestamp(v, min || undefined, max || undefined, typeCheck || undefined)
+    },
+    function: {
+        validate: (v, _min, _max, _typeCheck) => isFunction(v)
+    },
+    htmlElement: {
+        validate: (v, _min, _max, _typeCheck) => isHtmlElement(v)
+    },
+    htmlEventAttribute: {
+        validate: (v, _min, _max, _typeCheck) => isHtmlEventAttribute(v)
+    },
+    node: {
+        validate: (v, _min, _max, _typeCheck) => isNode(v)
+    },
+    object: {
+        validate: (v, _min, _max, _typeCheck) => isObject(v)
     }
 };
 const Required = {
@@ -86,22 +152,30 @@ class Entity {
     constructor(name, table, properties) {
         this.name = name;
         this.table = table;
+        this.cols = {
+            GET: "",
+            POST: "",
+            PUT: "",
+            PATCH: "",
+            DELETE: "",
+        };
         this.properties = this.init(properties);
     }
     init(properties) {
         const props = [];
         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));
+            for (const m of p.methods) {
+                this.cols[m] += this.cols[m].length ? `, ${p.key}` : `${p.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(method) {
+        return this.cols[method];
     }
     normalize(rows) {
         for (const r of rows) {
@@ -128,7 +202,7 @@ class Entity {
                         if (rq)
                             return rq;
                     }
-                    if (control) {
+                    if (v && control) {
                         const ct = this.control(v, key, type, min, max, typeCheck, controller);
                         if (ct)
                             return ct;

package/package.json

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