@dwtechs/antity 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 DWTechs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,195 @@
+
+[![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)
+[![minified size](https://img.shields.io/bundlephobia/min/@dwtechs/antity?color=brightgreen)](https://www.npmjs.com/package/@dwtechs/antity)
+
+- [Synopsis](#synopsis)
+- [Support](#support)
+- [Installation](#installation)
+- [Usage](#usage)
+  - [ES6](#es6)
+- [API Reference](#api-reference)
+- [Contributors](#contributors)
+- [Stack](#stack)
+
+
+## Synopsis
+
+**[Antity.js](https://github.com/DWTechs/Antity.js)** is an Open source library for easy entity management.
+
+- Only 1 small dependency to check inputs variables
+- Very lightweight
+- Thoroughly tested
+- Works in Javascript, Typescript
+- Can be used as EcmaScrypt module
+- Written in Typescript
+
+
+## Support
+
+- node: 22
+
+This is the oldest targeted versions. The library should work properly on older versions of Node.js but we do not support it officially.  
+
+
+## Installation
+
+```bash
+$ npm i @dwtechs/antity
+```
+
+
+## Usage
+
+
+### ES6 / TypeScript
+
+```javascript
+
+import { Entity } from "@dwtechs/antity";
+import { normalizeName, normalizeNickname } from "@dwtechs/checkard";
+
+const entity = new Entity("consumer", "consumers", [
+  {
+    key: "id",
+    type: "integer",
+    min: 0,
+    max: 120,
+    typeCheck: true,
+    methods: ["get", "put", "delete"],
+    required: true,
+    sanitize: true,
+    normalize: true,
+    control: true,
+    sanitizer: null,
+    normalizer: null,
+    controller: null,
+  },
+  {
+    key: "firstName",
+    type: "string",
+    min: 0,
+    max: 255,
+    typeCheck: true,
+    methods: ["get", "post", "put", "delete"],
+    required: true,
+    sanitize: true,
+    normalize: true,
+    control: true,
+    sanitizer: null,
+    normalizer: normalizeName,
+    controller: null,
+  },
+  {
+    key: "lastName",
+    type: "string",
+    min: 0,
+    max: 255,
+    typeCheck: true,
+    methods: ["get", "post", "put", "delete"],
+    required: true,
+    sanitize: true,
+    normalize: true,
+    control: true,
+    sanitizer: null,
+    normalizer: normalizeName,
+    controller: null,
+  },
+  {
+    key: "nickname",
+    type: "string",
+    min: 0,
+    max: 255,
+    typeCheck: true,
+    methods: ["get", "post", "put", "delete"],
+    required: true,
+    sanitize: true,
+    normalize: true,
+    control: true,
+    sanitizer: null,
+    normalizer: normalizeNickname,
+    controller: null,
+  },
+]);
+
+req.body = entity.normalize(req.body);
+const check = entity.validate(req.body, req.method);
+
+```
+
+
+## API Reference
+
+
+```javascript
+
+type Type = "boolean" | "string" | "number" | "integer" | "array";
+type Method = "GET" | "PATCH" | "PUT" | "POST" | "DELETE";
+
+class Property {
+  key: string;
+  type: Type;
+  min: number;
+  max: number;
+  required: boolean;
+  typeCheck: boolean;
+  verbs: Verb[];
+  sanitize: boolean;
+  normalize: boolean;
+  control: boolean;
+  sanitizer: Function | null;
+  normalizer: Function | null;
+  controller: Function | null;
+};
+
+class Entity {
+  name: string;
+  table: string;
+  properties: Property[];
+  normalize(rows: Record<string, any>[]): Record<string, any>[];
+  validate(rows: Record<string, any>[], method: Method): string | null;
+}
+
+```
+
+
+### Available options for a property
+
+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
+| typeCheck       |  boolean                  | Type is checked if true                           | false
+| methods         |  Method[]                 | REST Methods that use the property                | [ "GET", "PATCH", "PUT", "POST", "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
+| 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*
+* *TypeCheck Parameter is not used for boolean, string and array types*
+
+
+## Contributors
+
+Antity.js is still in development and we would be glad to get all the help you can provide.
+To contribute please read **[contributor.md](https://github.com/DWTechs/Antity.js/blob/main/contributor.md)** for detailed installation guide.
+
+
+## Stack
+
+| Purpose         |                    Choice                    |                                                     Motivation |
+| :-------------- | :------------------------------------------: | -------------------------------------------------------------: |
+| repository      |        [Github](https://github.com/)         |     hosting for software development version control using Git |
+| package manager |     [npm](https://www.npmjs.com/get-npm)     |                                default node.js package manager |
+| language        | [TypeScript](https://www.typescriptlang.org) | static type checking along with the latest ECMAScript features |
+| module bundler  |      [Rollup](https://rollupjs.org)          |                        advanced module bundler for ES6 modules |
+| unit testing    |          [Jest](https://jestjs.io/)          |                  delightful testing with a focus on simplicity |

package/dist/antity.cjs.js

@@ -0,0 +1,282 @@
+/*
+MIT License
+
+Copyright (c) 2024 DWTechs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+https://github.com/DWTechs/Antity.js
+*/
+
+'use strict';
+
+/*
+MIT License
+
+Copyright (c) 2009 DWTechs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+https://github.com/DWTechs/Checkard.js
+*/
+
+function isNumeric(n) {
+    return !isNaN(n - parseFloat(n));
+}
+function getTag(t) {
+    return t == null ? t === undefined ? '[object Undefined]' : '[object Null]' : toString.call(t);
+}
+
+function isBoolean(b) {
+    return typeof b === "boolean";
+}
+function isNumber(n, type = true) {
+    return !isSymbol(n) && !((n === null || n === void 0 ? void 0 : n.constructor) === Array) && (type ? Number(n) === n : isNumeric(n));
+}
+function isSymbol(s) {
+    const type = typeof s;
+    return type === 'symbol' || (type === 'object' && s != null && getTag(s) === '[object Symbol]');
+}
+function isNil(n) {
+    return n == null;
+}
+
+function isFunction(func) {
+    return Boolean(func && getTag(func) === "[object Function]");
+}
+
+const comparisons = {
+    '=': (a, b) => a == b,
+    '<': (a, b) => a < b,
+    '>': (a, b) => a > b,
+    '<=': (a, b) => a <= b,
+    '>=': (a, b) => a >= b
+};
+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 isValidNumber(n, min = -999999999, max = 999999999, type = true) {
+    return isNumber(n, type) && n >= min && n <= max;
+}
+function isValidInteger(n, min = -999999999, max = 999999999, type = true) {
+    return isInteger(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;
+}
+function isArrayOfLength(a, min = -999999999, max = 999999999) {
+    if (isArray(a, null, null)) {
+        const n = a.length;
+        return n >= min && n <= max;
+    }
+    return false;
+}
+function isIn(val, arr) {
+    return isArray(arr, '>', 0) ? arr.includes(val) : false;
+}
+
+function isString(s, required = false) {
+    return typeof s === "string" && (required ? !!s : true);
+}
+function isStringOfLength(s, min = 0, max = 999999999) {
+    if (isString(s, false)) {
+        const l = s.length;
+        return l >= min && l <= max;
+    }
+    return false;
+}
+
+function isObject(o, empty = false) {
+    return o !== null && typeof o === "object" && !isArray(o) && (empty ? !!Object.keys(o).length : true);
+}
+function isProperty(val, obj) {
+    const v = String(val);
+    return isString(v, true) && isObject(obj) ? Object.keys(obj).includes(v) : false;
+}
+
+const Methods = ["GET", "PATCH", "PUT", "POST", "DELETE"];
+
+const Types = {
+    boolean: {
+        validate: (v, _min, _max, _typeCheck) => isBoolean(v)
+    },
+    string: {
+        validate: (v, min, max, _typeCheck) => isStringOfLength(v, min, max)
+    },
+    number: {
+        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)
+    },
+    array: {
+        validate: (v, min, max, _typeCheck) => isArrayOfLength(v, min, max)
+    }
+};
+const Required = {
+    validate: (v) => !isNil(v)
+};
+
+class Property {
+    constructor(key, type, min, max, required, typeCheck, methods, 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))
+            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}`);
+            }
+        }
+        this.key = key;
+        this.type = type;
+        this.min = isInteger(min, true) ? min : 0;
+        this.max = isInteger(max, true) ? max : 999999999;
+        this.required = isBoolean(required) ? required : false;
+        this.typeCheck = isBoolean(typeCheck) ? typeCheck : false;
+        this.methods = methods || Methods;
+        this.sanitize = isBoolean(sanitize) ? sanitize : true;
+        this.normalize = isBoolean(normalize) ? normalize : false;
+        this.control = isBoolean(control) ? control : true;
+        this.sanitizer = isFunction(sanitizer) ? sanitizer : null;
+        this.normalizer = isFunction(normalizer) ? normalizer : null;
+        this.controller = isFunction(controller) ? controller : null;
+    }
+}
+
+const Messages = {
+    missing: (key) => `Missing ${key}`,
+    invalid: (key, type) => `Invalid ${key}, must be of type ${type}`,
+};
+
+class Entity {
+    constructor(name, table, properties) {
+        this.name = name;
+        this.table = table;
+        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));
+        }
+        return props;
+    }
+    cols(method) {
+        const cols = [];
+        for (const p of this.properties) {
+            if (isIn(method, p.methods))
+                cols.push(p.key);
+        }
+        return cols;
+    }
+    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)
+                        v = this.sanitize(v, sanitizer);
+                    if (normalize && normalizer)
+                        v = normalizer(v);
+                    r[key] = v;
+                }
+            }
+        }
+        return rows;
+    }
+    validate(rows, method) {
+        for (const r of rows) {
+            for (const { key, type, min, max, required, typeCheck, methods, control, controller } of this.properties) {
+                const v = r[key];
+                if (method && isIn(method, methods)) {
+                    if (required) {
+                        const rq = this.require(v, key);
+                        if (rq)
+                            return rq;
+                    }
+                    if (control) {
+                        const ct = this.control(v, key, type, min, max, typeCheck, controller);
+                        if (ct)
+                            return ct;
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    require(v, key) {
+        return Required.validate(v) ? null : Messages.missing(key);
+    }
+    control(v, key, type, min, max, typeCheck, cb) {
+        if (cb)
+            return cb(v) ? null : Messages.invalid(key, type);
+        return Types[type].validate(v, min, max, typeCheck) ? null : Messages.invalid(key, type);
+    }
+    sanitize(v, cb) {
+        if (cb)
+            return cb(v);
+        if (isArray(v, null, null)) {
+            for (let d of v) {
+                d = this.trim(d);
+            }
+            return v;
+        }
+        return this.trim(v);
+    }
+    trim(v) {
+        if (isString(v, true))
+            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();
+                    }
+                }
+            return v;
+        }
+    }
+}
+
+exports.Entity = Entity;

package/dist/antity.d.ts

@@ -0,0 +1,113 @@
+/*
+MIT License
+
+Copyright (c) 2024 DWTechs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+https://github.com/DWTechs/Antity.js
+*/
+
+
+type Type = keyof typeof Types;
+type Method = typeof Methods[number];
+
+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 Required: {
+  validate: (v: any) => boolean;
+};
+
+declare class Entity {
+  name: string;
+  table: string;
+  properties: Property[];
+  constructor(name: string, table: string, properties: Property[]);
+  private init;
+  cols(method: Method): string[];
+  normalize(rows: Record<string, any>[]): Record<string, any>[];
+  validate(rows: Record<string, any>[], method: Method): string | null;
+  private require;
+  private control;
+  private sanitize;
+  private trim;
+}
+
+declare const Messages: {
+    missing: (key: string) => string;
+    invalid: (key: string, type: Type) => string;
+};
+
+declare class Property {
+  key: string;
+  type: Type;
+  min: number;
+  max: number;
+  required: boolean;
+  typeCheck: boolean;
+  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,
+    type: Type,
+    min: number,
+    max: number,
+    required: boolean,
+    typeCheck: boolean,
+    methods: Method[],
+    sanitize: boolean,
+    normalize: boolean,
+    control: boolean,
+    sanitizer: ((v: any) => any) | null,
+    normalizer: ((v: any) => any) | null,
+    controller: ((v: any) => any) | null
+  );
+}
+export type { Type, Method };
+export { 
+  Entity,
+  Property,
+  Messages,
+  Types,
+  Required,
+  Methods 
+};
+

package/dist/antity.js

@@ -0,0 +1,177 @@
+/*
+MIT License
+
+Copyright (c) 2024 DWTechs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+https://github.com/DWTechs/Antity.js
+*/
+
+import { isBoolean, isStringOfLength, isValidNumber, isValidInteger, isArrayOfLength, isNil, isString, isProperty, isArray, isIn, isInteger, isFunction, isObject } from '@dwtechs/checkard';
+
+const Methods = ["GET", "PATCH", "PUT", "POST", "DELETE"];
+
+const Types = {
+    boolean: {
+        validate: (v, _min, _max, _typeCheck) => isBoolean(v)
+    },
+    string: {
+        validate: (v, min, max, _typeCheck) => isStringOfLength(v, min, max)
+    },
+    number: {
+        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)
+    },
+    array: {
+        validate: (v, min, max, _typeCheck) => isArrayOfLength(v, min, max)
+    }
+};
+const Required = {
+    validate: (v) => !isNil(v)
+};
+
+class Property {
+    constructor(key, type, min, max, required, typeCheck, methods, 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))
+            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}`);
+            }
+        }
+        this.key = key;
+        this.type = type;
+        this.min = isInteger(min, true) ? min : 0;
+        this.max = isInteger(max, true) ? max : 999999999;
+        this.required = isBoolean(required) ? required : false;
+        this.typeCheck = isBoolean(typeCheck) ? typeCheck : false;
+        this.methods = methods || Methods;
+        this.sanitize = isBoolean(sanitize) ? sanitize : true;
+        this.normalize = isBoolean(normalize) ? normalize : false;
+        this.control = isBoolean(control) ? control : true;
+        this.sanitizer = isFunction(sanitizer) ? sanitizer : null;
+        this.normalizer = isFunction(normalizer) ? normalizer : null;
+        this.controller = isFunction(controller) ? controller : null;
+    }
+}
+
+const Messages = {
+    missing: (key) => `Missing ${key}`,
+    invalid: (key, type) => `Invalid ${key}, must be of type ${type}`,
+};
+
+class Entity {
+    constructor(name, table, properties) {
+        this.name = name;
+        this.table = table;
+        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));
+        }
+        return props;
+    }
+    cols(method) {
+        const cols = [];
+        for (const p of this.properties) {
+            if (isIn(method, p.methods))
+                cols.push(p.key);
+        }
+        return cols;
+    }
+    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)
+                        v = this.sanitize(v, sanitizer);
+                    if (normalize && normalizer)
+                        v = normalizer(v);
+                    r[key] = v;
+                }
+            }
+        }
+        return rows;
+    }
+    validate(rows, method) {
+        for (const r of rows) {
+            for (const { key, type, min, max, required, typeCheck, methods, control, controller } of this.properties) {
+                const v = r[key];
+                if (method && isIn(method, methods)) {
+                    if (required) {
+                        const rq = this.require(v, key);
+                        if (rq)
+                            return rq;
+                    }
+                    if (control) {
+                        const ct = this.control(v, key, type, min, max, typeCheck, controller);
+                        if (ct)
+                            return ct;
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    require(v, key) {
+        return Required.validate(v) ? null : Messages.missing(key);
+    }
+    control(v, key, type, min, max, typeCheck, cb) {
+        if (cb)
+            return cb(v) ? null : Messages.invalid(key, type);
+        return Types[type].validate(v, min, max, typeCheck) ? null : Messages.invalid(key, type);
+    }
+    sanitize(v, cb) {
+        if (cb)
+            return cb(v);
+        if (isArray(v, null, null)) {
+            for (let d of v) {
+                d = this.trim(d);
+            }
+            return v;
+        }
+        return this.trim(v);
+    }
+    trim(v) {
+        if (isString(v, true))
+            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();
+                    }
+                }
+            return v;
+        }
+    }
+}
+
+export { Entity };

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@dwtechs/antity",
+  "version": "0.1.0",
+  "description": "Open source library for easy entity management",
+  "keywords": [
+    "entities"
+  ],
+  "homepage": "https://github.com/DWTechs/Antity.js",
+  "main": "dist/antity",
+  "types": "dist/antity",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/DWTechs/Antity.js"
+  },
+  "bugs": {
+    "url": "https://github.com/DWTechs/Antity.js/issues",
+    "email": ""
+  },
+  "license": "MIT",
+  "author": {
+    "name": "Ludovic Cluber",
+    "email": "http://www.lcluber.com/contact",
+    "url": "http://www.lcluber.com"
+  },
+  "contributors": [],
+  "scripts": {
+    "start": "",
+    "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",
+    "rollup": "npm run rollup:mjs && npm run rollup:cjs",
+    "test": "jest --coverage"
+  },
+  "files": [
+    "dist/"
+  ],
+  "dependencies": {
+    "@dwtechs/checkard": "2.29.2"
+  },
+  "devDependencies": {
+    "@babel/core": "7.26.0",
+    "@babel/preset-env": "7.26.0",
+    "@rollup/plugin-commonjs": "28.0.1",
+    "@rollup/plugin-node-resolve": "15.3.0",
+    "@types/jest": "29.5.14",
+    "babel-jest": "29.7.0",
+    "core-js": "3.33.0",
+    "jest": "29.7.0",
+    "rollup": "4.24.0",
+    "typescript": "5.6.3"
+  }
+}