pols-validator 1.0.1

package/.vscode/launch.json

@@ -0,0 +1,22 @@
+{
+	// Use IntelliSense to learn about possible attributes.
+	// Hover to view descriptions of existing attributes.
+	// For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+	"version": "0.2.0",
+	"configurations": [
+		{
+			"type": "node",
+			"request": "launch",
+			"name": "npm run test",
+			"skipFiles": [
+				"<node_internals>/**"
+			],
+			"runtimeExecutable": "npm",
+			"runtimeArgs": [
+				"run",
+				"test",
+				"test/validaciones.ts"
+			]
+		}
+	]
+}

package/.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+	"typescript.tsdk": "node_modules\\typescript\\lib"
+}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+import { Rules } from "./rules";
+import { RulesEngine, RulesParams } from "./rulesEngine";
+export { RulesEngine } from './rulesEngine';
+export type EvaluateResponse<T> = {
+    error: false;
+    success: true;
+    result: T;
+} | {
+    error: true;
+    success: false;
+    messages: string[];
+};
+export declare const validate: <T>(target: unknown, rules: RulesEngine) => EvaluateResponse<T>;
+export declare const rules: (params?: RulesParams) => Rules;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAC/B,OAAO,EAAE,WAAW,EAAE,WAAW,EAAW,MAAM,eAAe,CAAA;AACjE,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAE3C,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI;IACjC,KAAK,EAAE,KAAK,CAAA;IACZ,OAAO,EAAE,IAAI,CAAA;IACb,MAAM,EAAE,CAAC,CAAA;CACT,GAAG;IACH,KAAK,EAAE,IAAI,CAAA;IACX,OAAO,EAAE,KAAK,CAAA;IACd,QAAQ,EAAE,MAAM,EAAE,CAAA;CAClB,CAAA;AAED,eAAO,MAAM,QAAQ,GAAI,CAAC,UAAU,OAAO,SAAS,WAAW,KAAG,gBAAgB,CAAC,CAAC,CAqEnF,CAAA;AAED,eAAO,MAAM,KAAK,YAAa,WAAW,UAAsB,CAAA"}

package/dist/index.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rules = exports.validate = exports.RulesEngine = void 0;
+const pols_utils_1 = require("pols-utils");
+const rules_1 = require("./rules");
+var rulesEngine_1 = require("./rulesEngine");
+Object.defineProperty(exports, "RulesEngine", { enumerable: true, get: function () { return rulesEngine_1.RulesEngine; } });
+const validate = (target, rules) => {
+    const errorMessages = [];
+    if (typeof target == 'string')
+        target = target.trim();
+    const isEmpty = target == null || (typeof target == 'string' && !target);
+    const label = rules.label ?? 'Este valor';
+    if (rules.required && isEmpty) {
+        return {
+            error: true,
+            success: false,
+            messages: [`'${label}' es requerido`]
+        };
+    }
+    if (isEmpty) {
+        return {
+            error: false,
+            success: true,
+            result: rules.default
+        };
+    }
+    const wrapper = {
+        value: pols_utils_1.PUtils.clone(target),
+        label
+    };
+    for (const validationFunction of Object.values(rules.collection)) {
+        const result = validationFunction(wrapper);
+        if (!result)
+            continue;
+        if (typeof result == 'string') {
+            errorMessages.push(result);
+            break;
+        }
+        else {
+            if (wrapper.value == null || typeof wrapper.value != 'object')
+                throw new Error(`El valor no es un objeto para ser validado contra un esquema: ${wrapper.value}`);
+            const newResult = {};
+            for (const key in result.schema) {
+                const rulesInside = result.schema[key];
+                const labelIndise = rulesInside.label ?? key;
+                rulesInside.label = `${result.prefix ? `${result.prefix} ` : ''}${labelIndise}`;
+                newResult[key] = wrapper.value[key];
+                const result2 = (0, exports.validate)(newResult[key], rulesInside);
+                if (result2.error == true) {
+                    errorMessages.push(...result2.messages);
+                }
+                else {
+                    newResult[key] = result2.result;
+                }
+            }
+            wrapper.value = newResult;
+        }
+    }
+    if (errorMessages.length) {
+        return {
+            error: true,
+            success: false,
+            messages: errorMessages
+        };
+    }
+    else {
+        return {
+            error: false,
+            success: true,
+            result: wrapper.value
+        };
+    }
+};
+exports.validate = validate;
+const rules = (params) => new rules_1.Rules(params);
+exports.rules = rules;

package/dist/rules.d.ts

@@ -0,0 +1,37 @@
+import { RulesEngine } from "./rulesEngine";
+export declare class Rules extends RulesEngine {
+    isAlphanumeric(): this;
+    isEmailAddress(): this;
+    isDateTime(): this;
+    isDate(): this;
+    isTime(): this;
+    match(pattern: RegExp): this;
+    isNumber(): this;
+    isInteger(): this;
+    isNatural(): this;
+    isNaturalNoZero(): this;
+    onlyNumbers(): this;
+    maxLength(limit: number): this;
+    minLength(limit: number): this;
+    length(limit: number): this;
+    left(limit: number): this;
+    isIn(...elements: unknown[]): this;
+    isNotIn(...elements: unknown[]): this;
+    gt(limit: number): this;
+    gte(limit: number): this;
+    lt(limit: number): this;
+    lte(limit: number): this;
+    beforeOrSameAsNow(): this;
+    isObject(schema?: Record<string, RulesEngine>, prefix?: string): this;
+    isBoolean(): this;
+    upper(): this;
+    lower(): this;
+    decodeURI(): this;
+    round(decimals: number): this;
+    cleanDoubleSpaces(): this;
+    noSpaces(): this;
+    replace(search: string | RegExp, replace: string | ((substring: string, ...args: any[]) => string)): this;
+    capitalize(): this;
+    split(separator: string | RegExp): this;
+}
+//# sourceMappingURL=rules.d.ts.map

package/dist/rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rules.d.ts","sourceRoot":"","sources":["../src/rules.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAW,MAAM,eAAe,CAAA;AAEpD,qBAAa,KAAM,SAAQ,WAAW;IACrC,cAAc;IAWd,cAAc;IAQd,UAAU;IAcV,MAAM;IAMN,MAAM;IA4BN,KAAK,CAAC,OAAO,EAAE,MAAM;IAQrB,QAAQ;IAUR,SAAS;IAQT,SAAS;IAIT,eAAe;IAIf,WAAW;IAQX,SAAS,CAAC,KAAK,EAAE,MAAM;IAgBvB,SAAS,CAAC,KAAK,EAAE,MAAM;IAQvB,MAAM,CAAC,KAAK,EAAE,MAAM;IAQpB,IAAI,CAAC,KAAK,EAAE,MAAM;IA0ElB,IAAI,CAAC,GAAG,QAAQ,EAAE,OAAO,EAAE;IAa3B,OAAO,CAAC,GAAG,QAAQ,EAAE,OAAO,EAAE;IAe9B,EAAE,CAAC,KAAK,EAAE,MAAM;IAQhB,GAAG,CAAC,KAAK,EAAE,MAAM;IAQjB,EAAE,CAAC,KAAK,EAAE,MAAM;IAQhB,GAAG,CAAC,KAAK,EAAE,MAAM;IAQjB,iBAAiB;IASjB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,CAAC,EAAE,MAAM;IAqB9D,SAAS;IAgDT,KAAK;IAQL,KAAK;IAQL,SAAS;IAQT,KAAK,CAAC,QAAQ,EAAE,MAAM;IAStB,iBAAiB;IAQjB,QAAQ;IASR,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,CAAC,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,MAAM,CAAC;IAMlG,UAAU;IAQV,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;CAKhC"}

package/dist/rules.js

@@ -0,0 +1,422 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Rules = void 0;
+const pols_utils_1 = require("pols-utils");
+const rulesEngine_1 = require("./rulesEngine");
+class Rules extends rulesEngine_1.RulesEngine {
+    isAlphanumeric() {
+        this.add(this.isAlphanumeric.name, (wrapper) => {
+            if (typeof wrapper.value == 'number') {
+                wrapper.value = wrapper.value.toString();
+            }
+            else if (typeof wrapper.value != 'string') {
+                return `'${wrapper.label}' debe ser un alfanumérico`;
+            }
+        });
+        return this;
+    }
+    isEmailAddress() {
+        this.isAlphanumeric();
+        this.add(this.isEmailAddress.name, (wrapper) => {
+            if (!wrapper.value.match(/^[^\s@]+@[^\s@]+\.[^\s@]{2,}$/))
+                return `'${wrapper.label}' debe ser una dirección de correo`;
+        });
+        return this;
+    }
+    isDateTime() {
+        this.add(this.isDateTime.name, (wrapper) => {
+            const message = `'${wrapper.label}' tiene un formato de fecha y hora no válido`;
+            if (typeof wrapper.value == 'string' || typeof wrapper.value == 'number' || wrapper.value instanceof Date || wrapper.value instanceof pols_utils_1.PDate) {
+                const newDate = new pols_utils_1.PDate(wrapper.value);
+                if (newDate.isInvalidDate)
+                    return message;
+                wrapper.value = newDate;
+            }
+            else {
+                return message;
+            }
+        });
+        return this;
+    }
+    isDate() {
+        return this.isDateTime().add(this.isDate.name, (wrapper) => {
+            wrapper.value.clearTime();
+        });
+    }
+    isTime() {
+        this.add(this.isTime.name, (wrapper) => {
+            const message = `'${wrapper.label}' contiene un formato de hora no válido`;
+            const value = wrapper.value.toString();
+            const parts = value.replace(/[.,]/g, ':').replace('m', '').match(/^([0-2]?[0-9])(:?)([0-5]?[0-9]?)(:?)([0-5]?[0-9]?)([ap]?)\.?m?\.?$/);
+            if (!parts)
+                return message;
+            let hours = Number(parts[1]);
+            const minutes = Number(parts[3]);
+            const seconds = Number(parts[5]);
+            const middle = parts[6];
+            if (minutes < 60 && seconds < 60) {
+                /* Si middle es diferente de vacío, es porque el usuario tiene la intención de especificar una hora del día, caso contrario, está indicando una duración. */
+                if (middle) {
+                    if (hours > 0 && hours <= 12) {
+                        if (middle === 'p')
+                            hours += 12;
+                        wrapper.value = `${pols_utils_1.PUtils.String.padLeft(hours, 2)}:${pols_utils_1.PUtils.String.padLeft(minutes, 2)}:${pols_utils_1.PUtils.String.padLeft(seconds, 2)}`;
+                        return;
+                    }
+                }
+                else {
+                    wrapper.value = `${pols_utils_1.PUtils.String.padLeft(hours, 2)}:${pols_utils_1.PUtils.String.padLeft(minutes, 2)}:${pols_utils_1.PUtils.String.padLeft(seconds, 2)}`;
+                    return;
+                }
+            }
+            return message;
+        });
+        return this;
+    }
+    match(pattern) {
+        this.isAlphanumeric();
+        this.add(this.match.name, (wrapper) => {
+            if (!wrapper.value.match(pattern))
+                return `'${wrapper.label}' no cumple con el formato de texto deseado`;
+        });
+        return this;
+    }
+    isNumber() {
+        this.add(this.isNumber.name, (wrapper) => {
+            const message = `'${wrapper.label}' debe ser un número`;
+            const value = Number(wrapper.value);
+            if (isNaN(value) || value == Infinity)
+                return message;
+            wrapper.value = value;
+        });
+        return this;
+    }
+    isInteger() {
+        this.isNumber();
+        this.add(this.isInteger.name, (wrapper) => {
+            if (wrapper.value != Math.floor(wrapper.value))
+                return `'${wrapper.label}' debe ser un número entero`;
+        });
+        return this;
+    }
+    isNatural() {
+        return this.isInteger().gte(0);
+    }
+    isNaturalNoZero() {
+        return this.isInteger().gt(0);
+    }
+    onlyNumbers() {
+        this.isAlphanumeric();
+        this.add(this.onlyNumbers.name, (wrapper) => {
+            if (!wrapper.value.match(/^[0-9]+$/))
+                return `'${wrapper.label}' debe contener sólo números`;
+        });
+        return this;
+    }
+    maxLength(limit) {
+        this.isAlphanumeric();
+        this.add(this.maxLength.name, (wrapper) => {
+            if (wrapper.value.length > limit)
+                return `'${wrapper.label}' debe contener '${limit} ${limit == 1 ? 'caracter' : 'caracteres'}' como máximo`;
+        });
+        return this;
+    }
+    // maxCount(limit: number) {
+    // 	this.isArray()
+    // 	this.add(this.maxLength.name, (wrapper: Wrapper<unknown[]>) => {
+    // 		if (wrapper.value.length > limit) return `'${wrapper.label}' debe contener '${limit} ${limit == 1 ? 'elemento' : 'elementos'}' como máximo`
+    // 	})
+    // 	return this
+    // }
+    minLength(limit) {
+        this.isAlphanumeric();
+        this.add(this.minLength.name, (wrapper) => {
+            if (wrapper.value.length < limit)
+                return `'${wrapper.label}' debe contener '${limit} ${limit == 1 ? 'caracter' : 'caracteres'}' como mínimo`;
+        });
+        return this;
+    }
+    length(limit) {
+        this.isAlphanumeric();
+        this.add(this.length.name, (wrapper) => {
+            if (wrapper.value.length != limit)
+                return `'${wrapper.label}' debe contener sólo '${limit} ${limit == 1 ? 'caracter' : 'caracteres'}'`;
+        });
+        return this;
+    }
+    left(limit) {
+        this.isAlphanumeric();
+        this.add(this.length.name, (wrapper) => {
+            wrapper.value = wrapper.value.substring(0, limit);
+        });
+        return this;
+    }
+    // isArray(checkingElements?: (i: number) => RulesEngine) {
+    // 	this.add(this.isArray.name, (wrapper: Wrapper) => {
+    // 		const message = `'${wrapper.label}' debe ser una lista de elementos`
+    // 		if (typeof wrapper.value == 'string') {
+    // 			try {
+    // 				const value = JSON.parse(wrapper.value)
+    // 				if (!(value instanceof Array)) return message
+    // 				wrapper.value = value
+    // 			} catch (err) {
+    // 				return message
+    // 			}
+    // 		} else {
+    // 			if (!(wrapper.value instanceof Array)) return message
+    // 		}
+    // 		if (checkingElements) {
+    // 			const value = wrapper.value as unknown[]
+    // 			const messageErrors: string[] = []
+    // 			const result: unknown[] = []
+    // 			for (const [i, t] of value.entries()) {
+    // 				const p = wrapper.validator({
+    // 					value: t
+    // 				}, {
+    // 					value: {
+    // 						...checkingElements(i),
+    // 						to: undefined,
+    // 					}
+    // 				})
+    // 				if (p.error == true) {
+    // 					messageErrors.push(...p.messages)
+    // 				} else {
+    // 					result.push(p.result['value'])
+    // 				}
+    // 			}
+    // 			if (messageErrors.length) {
+    // 				return messageErrors
+    // 			} else {
+    // 				wrapper.value = result
+    // 			}
+    // 		}
+    // 	})
+    // 	return this
+    // }
+    // isArrayOfObjects(checkingElements?: (i: number) => FieldsStructure, prefixString?: (i: number) => string) {
+    // 	this.isArray()
+    // 	this.add(this.isArrayOfObjects.name, (wrapper: Wrapper<unknown[]>) => {
+    // 		const message = `'${wrapper.label}' debe ser una lista de objetos`
+    // 		const messages: string[] = []
+    // 		for (const [i, v] of wrapper.value.entries()) {
+    // 			const result = isObject(v)
+    // 			if (result.error == true) return message
+    // 			wrapper.value[i] = result.result
+    // 			if (checkingElements) {
+    // 				const v = wrapper.validator(wrapper.value[i], checkingElements(i), prefixString?.(i))
+    // 				if (v.error == true) {
+    // 					messages.push(...v.messages)
+    // 				} else {
+    // 					wrapper.value[i] = v.result
+    // 				}
+    // 			}
+    // 		}
+    // 		if (messages.length) return messages
+    // 	})
+    // 	return this
+    // }
+    isIn(...elements) {
+        this.add(this.isIn.name, (wrapper) => {
+            if (wrapper.value instanceof Array) {
+                for (const v of wrapper.value) {
+                    if (!elements.includes(v))
+                        return `'${wrapper.label}' no contiene valores válidos`;
+                }
+            }
+            else {
+                if (!elements.includes(wrapper.value))
+                    return `'${wrapper.label}' no tiene un valor válido`;
+            }
+        });
+        return this;
+    }
+    isNotIn(...elements) {
+        this.add(this.isNotIn.name, (wrapper) => {
+            if (elements.includes(wrapper.value))
+                return `'${wrapper.label}' no tiene un valor válido`;
+        });
+        return this;
+    }
+    // hasElements(checkingElements?: (i: number) => FieldStructure) {
+    // 	this.isArray(checkingElements)
+    // 	this.add(this.hasElements.name, (wrapper: Wrapper) => {
+    // 		if (!(wrapper.value as unknown[]).length) return `'${wrapper.label}' debe ser una lista con al menos un elemento`
+    // 	})
+    // 	return this
+    // }
+    gt(limit) {
+        this.isNumber();
+        this.add(this.gt.name, (wrapper) => {
+            if (wrapper.value <= limit)
+                return `'${wrapper.label}' debe ser mayor a '${limit}'`;
+        });
+        return this;
+    }
+    gte(limit) {
+        this.isNumber();
+        this.add(this.gte.name, (wrapper) => {
+            if (wrapper.value < limit)
+                return `'${wrapper.label}' debe ser mayor o igual a '${limit}'`;
+        });
+        return this;
+    }
+    lt(limit) {
+        this.isNumber();
+        this.add(this.lt.name, (wrapper) => {
+            if (wrapper.value >= limit)
+                return `'${wrapper.label}' debe ser menor a '${limit}'`;
+        });
+        return this;
+    }
+    lte(limit) {
+        return this
+            .isNumber()
+            .add(this.lte.name, (wrapper) => {
+            if (wrapper.value > limit)
+                return `'${wrapper.label}' debe ser menor o igual a '${limit}'`;
+        });
+    }
+    beforeOrSameAsNow() {
+        return this
+            .isDateTime()
+            .add(this.beforeOrSameAsNow.name, (wrapper) => {
+            const now = new pols_utils_1.PDate;
+            if (wrapper.value.time > now.time)
+                return `'${wrapper.label}' debe ser anterior o igual a 'ahora'`;
+        });
+    }
+    isObject(schema, prefix) {
+        return this.add(this.isObject.name, (wrapper) => {
+            const message = `'${wrapper.label}' debe ser un objeto`;
+            if (typeof wrapper.value == 'string') {
+                try {
+                    wrapper.value = JSON.parse(wrapper.value);
+                }
+                catch {
+                    return message;
+                }
+                if (pols_utils_1.PUtils.getType(wrapper.value) != 'Object')
+                    return message;
+            }
+            else {
+                if (pols_utils_1.PUtils.getType(wrapper.value) != 'Object') {
+                    return message;
+                }
+            }
+            return { schema, prefix };
+        });
+    }
+    isBoolean() {
+        this.add(this.isBoolean.name, (wrapper) => {
+            const message = `'${wrapper.label}' debe ser de tipo booleano`;
+            if (typeof wrapper.value == 'string') {
+                const value = wrapper.value.trim().toUpperCase();
+                switch (value) {
+                    case '1':
+                    case 'S':
+                    case 'SÍ':
+                    case 'Y':
+                    case 'YES':
+                        wrapper.value = true;
+                        return;
+                    case '0':
+                    case 'N':
+                    case 'NO':
+                        wrapper.value = false;
+                        return;
+                    default: {
+                        let json;
+                        try {
+                            json = JSON.parse(wrapper.value);
+                        }
+                        catch {
+                            return message;
+                        }
+                        if (typeof json != 'boolean' && !([0, 1]).includes(json))
+                            return message;
+                        wrapper.value = json;
+                        return;
+                    }
+                }
+            }
+            else if (typeof wrapper.value == 'number') {
+                switch (wrapper.value) {
+                    case 0:
+                        wrapper.value = false;
+                        return;
+                    case 1:
+                        wrapper.value = true;
+                        return;
+                    default:
+                        return message;
+                }
+            }
+            else {
+                return typeof wrapper.value == 'boolean' ? null : message;
+            }
+        });
+        return this;
+    }
+    upper() {
+        this.isAlphanumeric();
+        this.add(this.upper.name, (wrapper) => {
+            wrapper.value = wrapper.value.toUpperCase();
+        });
+        return this;
+    }
+    lower() {
+        this.isAlphanumeric();
+        this.add(this.lower.name, (wrapper) => {
+            wrapper.value = wrapper.value.toLowerCase();
+        });
+        return this;
+    }
+    decodeURI() {
+        this.isAlphanumeric();
+        this.add(this.decodeURI.name, (wrapper) => {
+            wrapper.value = decodeURI(wrapper.value);
+        });
+        return this;
+    }
+    round(decimals) {
+        this.isNumber();
+        this.add(this.round.name, (wrapper) => {
+            wrapper.value = pols_utils_1.PUtils.Number.round(wrapper.value, decimals);
+        });
+        return this;
+    }
+    /* Reemplaza todos los dobles (o más) espacios juntos por uno simple */
+    cleanDoubleSpaces() {
+        this.isAlphanumeric();
+        this.add(this.cleanDoubleSpaces.name, (wrapper) => {
+            wrapper.value = wrapper.value.replace(/\s{2,}/g, ' ');
+        });
+        return this;
+    }
+    noSpaces() {
+        this.isAlphanumeric();
+        this.add(this.noSpaces.name, (wrapper) => {
+            if (wrapper.value.match(/\s/))
+                return `'${wrapper.label}' no debe contener 'espacios'`;
+        });
+        return this;
+    }
+    replace(search, replace) {
+        return this.isAlphanumeric().add(this.replace.name, (wrapper) => {
+            wrapper.value = wrapper.value.replace(search, replace);
+        });
+    }
+    capitalize() {
+        this.isAlphanumeric();
+        this.add(this.capitalize.name, (wrapper) => {
+            wrapper.value = pols_utils_1.PUtils.String.capitalize(wrapper.value);
+        });
+        return this;
+    }
+    split(separator) {
+        return this.isAlphanumeric().add(this.split.name, (wrapper) => {
+            wrapper.value = wrapper.value.split(separator);
+        });
+    }
+}
+exports.Rules = Rules;

package/dist/rulesEngine.d.ts

@@ -0,0 +1,24 @@
+export type RulesParams = {
+    label?: string;
+} & ({
+    required?: boolean;
+} | {
+    default?: unknown;
+});
+export type ValidationFunction = (wrapper: Wrapper, ...args: unknown[]) => string | void | null | undefined | {
+    schema: Record<string, RulesEngine>;
+    prefix?: string;
+};
+export type Wrapper<T = unknown> = {
+    value: T;
+    label: string;
+};
+export declare class RulesEngine {
+    constructor(params?: RulesParams);
+    label: string;
+    required: boolean;
+    default: unknown;
+    collection: Record<string, ValidationFunction>;
+    protected add(name: string, validationFunction: ValidationFunction): this;
+}
+//# sourceMappingURL=rulesEngine.d.ts.map

package/dist/rulesEngine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rulesEngine.d.ts","sourceRoot":"","sources":["../src/rulesEngine.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,GAAG;IACzB,KAAK,CAAC,EAAE,MAAM,CAAA;CACd,GAAG,CAAC;IACJ,QAAQ,CAAC,EAAE,OAAO,CAAA;CAClB,GAAG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;CACjB,CAAC,CAAA;AAEF,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,MAAM,GAAG,IAAI,GAAG,IAAI,GAAG,SAAS,GAAG;IAC7G,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAA;IACnC,MAAM,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAED,MAAM,MAAM,OAAO,CAAC,CAAC,GAAG,OAAO,IAAI;IAClC,KAAK,EAAE,CAAC,CAAA;IACR,KAAK,EAAE,MAAM,CAAA;CACb,CAAA;AAED,qBAAa,WAAW;gBACX,MAAM,CAAC,EAAE,WAAW;IAOhC,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,OAAO,CAAQ;IACzB,OAAO,EAAE,OAAO,CAAO;IACvB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAK;IAEnD,SAAS,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,kBAAkB,EAAE,kBAAkB;CAIlE"}

package/dist/rulesEngine.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RulesEngine = void 0;
+class RulesEngine {
+    constructor(params) {
+        if (!params)
+            return;
+        this.label = params.label;
+        this.required = 'required' in params ? params.required : false;
+        this.default = 'default' in params ? params.default : null;
+    }
+    label;
+    required = false;
+    default = null;
+    collection = {};
+    add(name, validationFunction) {
+        if (!this.collection[name])
+            this.collection[name] = validationFunction;
+        return this;
+    }
+}
+exports.RulesEngine = RulesEngine;

package/eslint.config.mjs

@@ -0,0 +1,19 @@
+import globals from "globals";
+import pluginJs from "@eslint/js";
+import tseslint from "typescript-eslint";
+
+export default [
+	{
+		files: ["**/*.{ts}"],
+	},
+	{ languageOptions: { globals: globals.node } },
+	pluginJs.configs.recommended,
+	...tseslint.configs.recommended,
+	{
+		rules: {
+			"@typescript-eslint/no-unused-vars": "warn",
+			"@typescript-eslint/no-explicit-any": false,
+			"no-use-before-define": "off"
+		}
+	}
+];

package/package.json

@@ -0,0 +1,26 @@
+{
+	"name": "pols-validator",
+	"version": "1.0.1",
+	"main": "dist/index.js",
+	"module": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"scripts": {
+		"build": "npx tsc",
+		"test": "npx ts-node-dev -r tsconfig-paths/register --project tsconfig.json"
+	},
+	"author": "Jean Paul Sánchez mendoza",
+	"license": "ISC",
+	"description": "",
+	"devDependencies": {
+		"@eslint/js": "^9.13.0",
+		"@types/node": "^22.7.9",
+		"eslint": "^9.13.0",
+		"globals": "^15.11.0",
+		"tsconfig-paths": "^4.2.0",
+		"typescript": "^5.6.3",
+		"typescript-eslint": "^8.11.0"
+	},
+	"dependencies": {
+		"pols-utils": "^1.1.2"
+	}
+}

package/src/index.ts

@@ -0,0 +1,87 @@
+import { PUtils } from "pols-utils"
+import { Rules } from "./rules"
+import { RulesEngine, RulesParams, Wrapper } from "./rulesEngine"
+export { RulesEngine } from './rulesEngine'
+
+export type EvaluateResponse<T> = {
+	error: false
+	success: true
+	result: T
+} | {
+	error: true
+	success: false
+	messages: string[]
+}
+
+export const validate = <T>(target: unknown, rules: RulesEngine): EvaluateResponse<T> => {
+	const errorMessages: string[] = []
+
+	if (typeof target == 'string') target = target.trim()
+
+	const isEmpty = target == null || (typeof target == 'string' && !target)
+	const label = rules.label ?? 'Este valor'
+
+	if (rules.required && isEmpty) {
+		return {
+			error: true,
+			success: false,
+			messages: [`'${label}' es requerido`]
+		}
+	}
+
+	if (isEmpty) {
+		return {
+			error: false,
+			success: true,
+			result: rules.default as T
+		}
+	}
+
+	const wrapper: Wrapper<T> = {
+		value: PUtils.clone(target) as T,
+		label
+	}
+	for (const validationFunction of Object.values(rules.collection)) {
+		const result = validationFunction(wrapper)
+		if (!result) continue
+		if (typeof result == 'string') {
+			errorMessages.push(result)
+			break
+		} else {
+			if (wrapper.value == null || typeof wrapper.value != 'object') throw new Error(`El valor no es un objeto para ser validado contra un esquema: ${wrapper.value}`)
+
+			const newResult: Record<string, unknown> = {}
+			for (const key in result.schema) {
+				const rulesInside = result.schema[key]
+				const labelIndise = rulesInside.label ?? key
+				rulesInside.label = `${result.prefix ? `${result.prefix} ` : ''}${labelIndise}`
+
+				newResult[key] = wrapper.value[key]
+
+				const result2 = validate(newResult[key], rulesInside)
+				if (result2.error == true) {
+					errorMessages.push(...result2.messages)
+				} else {
+					newResult[key] = result2.result
+				}
+			}
+			wrapper.value = newResult as T
+		}
+	}
+
+	if (errorMessages.length) {
+		return {
+			error: true,
+			success: false,
+			messages: errorMessages
+		}
+	} else {
+		return {
+			error: false,
+			success: true,
+			result: wrapper.value
+		}
+	}
+}
+
+export const rules = (params?: RulesParams) => new Rules(params)

package/src/rules.ts

@@ -0,0 +1,427 @@
+import { PDate, PUtils } from "pols-utils"
+import { RulesEngine, Wrapper } from "./rulesEngine"
+
+export class Rules extends RulesEngine {
+	isAlphanumeric() {
+		this.add(this.isAlphanumeric.name, (wrapper: Wrapper) => {
+			if (typeof wrapper.value == 'number') {
+				wrapper.value = wrapper.value.toString()
+			} else if (typeof wrapper.value != 'string') {
+				return `'${wrapper.label}' debe ser un alfanumérico`
+			}
+		})
+		return this
+	}
+
+	isEmailAddress() {
+		this.isAlphanumeric()
+		this.add(this.isEmailAddress.name, (wrapper: Wrapper) => {
+			if (!(wrapper.value as string).match(/^[^\s@]+@[^\s@]+\.[^\s@]{2,}$/)) return `'${wrapper.label}' debe ser una dirección de correo`
+		})
+		return this
+	}
+
+	isDateTime() {
+		this.add(this.isDateTime.name, (wrapper: Wrapper) => {
+			const message = `'${wrapper.label}' tiene un formato de fecha y hora no válido`
+			if (typeof wrapper.value == 'string' || typeof wrapper.value == 'number' || wrapper.value instanceof Date || wrapper.value instanceof PDate) {
+				const newDate = new PDate(wrapper.value)
+				if (newDate.isInvalidDate) return message
+				wrapper.value = newDate
+			} else {
+				return message
+			}
+		})
+		return this
+	}
+
+	isDate() {
+		return this.isDateTime().add(this.isDate.name, (wrapper: Wrapper<PDate>) => {
+			wrapper.value.clearTime()
+		})
+	}
+
+	isTime() {
+		this.add(this.isTime.name, (wrapper: Wrapper) => {
+			const message = `'${wrapper.label}' contiene un formato de hora no válido`
+			const value = wrapper.value.toString()
+			const parts = value.replace(/[.,]/g, ':').replace('m', '').match(/^([0-2]?[0-9])(:?)([0-5]?[0-9]?)(:?)([0-5]?[0-9]?)([ap]?)\.?m?\.?$/)
+			if (!parts) return message
+			let hours = Number(parts[1])
+			const minutes = Number(parts[3])
+			const seconds = Number(parts[5])
+			const middle = parts[6]
+			if (minutes < 60 && seconds < 60) {
+				/* Si middle es diferente de vacío, es porque el usuario tiene la intención de especificar una hora del día, caso contrario, está indicando una duración. */
+				if (middle) {
+					if (hours > 0 && hours <= 12) {
+						if (middle === 'p') hours += 12
+						wrapper.value = `${PUtils.String.padLeft(hours, 2)}:${PUtils.String.padLeft(minutes, 2)}:${PUtils.String.padLeft(seconds, 2)}`
+						return
+					}
+				} else {
+					wrapper.value = `${PUtils.String.padLeft(hours, 2)}:${PUtils.String.padLeft(minutes, 2)}:${PUtils.String.padLeft(seconds, 2)}`
+					return
+				}
+			}
+			return message
+		})
+		return this
+	}
+
+	match(pattern: RegExp) {
+		this.isAlphanumeric()
+		this.add(this.match.name, (wrapper: Wrapper) => {
+			if (!(wrapper.value as string).match(pattern)) return `'${wrapper.label}' no cumple con el formato de texto deseado`
+		})
+		return this
+	}
+
+	isNumber() {
+		this.add(this.isNumber.name, (wrapper: Wrapper) => {
+			const message = `'${wrapper.label}' debe ser un número`
+			const value = Number(wrapper.value)
+			if (isNaN(value) || value == Infinity) return message
+			wrapper.value = value
+		})
+		return this
+	}
+
+	isInteger() {
+		this.isNumber()
+		this.add(this.isInteger.name, (wrapper: Wrapper) => {
+			if (wrapper.value != Math.floor(wrapper.value as number)) return `'${wrapper.label}' debe ser un número entero`
+		})
+		return this
+	}
+
+	isNatural() {
+		return this.isInteger().gte(0)
+	}
+
+	isNaturalNoZero() {
+		return this.isInteger().gt(0)
+	}
+
+	onlyNumbers() {
+		this.isAlphanumeric()
+		this.add(this.onlyNumbers.name, (wrapper: Wrapper) => {
+			if (!(wrapper.value as string).match(/^[0-9]+$/)) return `'${wrapper.label}' debe contener sólo números`
+		})
+		return this
+	}
+
+	maxLength(limit: number) {
+		this.isAlphanumeric()
+		this.add(this.maxLength.name, (wrapper: Wrapper) => {
+			if ((wrapper.value as string).length > limit) return `'${wrapper.label}' debe contener '${limit} ${limit == 1 ? 'caracter' : 'caracteres'}' como máximo`
+		})
+		return this
+	}
+
+	// maxCount(limit: number) {
+	// 	this.isArray()
+	// 	this.add(this.maxLength.name, (wrapper: Wrapper<unknown[]>) => {
+	// 		if (wrapper.value.length > limit) return `'${wrapper.label}' debe contener '${limit} ${limit == 1 ? 'elemento' : 'elementos'}' como máximo`
+	// 	})
+	// 	return this
+	// }
+
+	minLength(limit: number) {
+		this.isAlphanumeric()
+		this.add(this.minLength.name, (wrapper: Wrapper) => {
+			if ((wrapper.value as string).length < limit) return `'${wrapper.label}' debe contener '${limit} ${limit == 1 ? 'caracter' : 'caracteres'}' como mínimo`
+		})
+		return this
+	}
+
+	length(limit: number) {
+		this.isAlphanumeric()
+		this.add(this.length.name, (wrapper: Wrapper) => {
+			if ((wrapper.value as string).length != limit) return `'${wrapper.label}' debe contener sólo '${limit} ${limit == 1 ? 'caracter' : 'caracteres'}'`
+		})
+		return this
+	}
+
+	left(limit: number) {
+		this.isAlphanumeric()
+		this.add(this.length.name, (wrapper: Wrapper) => {
+			(wrapper.value as string) = (wrapper.value as string).substring(0, limit)
+		})
+		return this
+	}
+
+	// isArray(checkingElements?: (i: number) => RulesEngine) {
+	// 	this.add(this.isArray.name, (wrapper: Wrapper) => {
+	// 		const message = `'${wrapper.label}' debe ser una lista de elementos`
+	// 		if (typeof wrapper.value == 'string') {
+	// 			try {
+	// 				const value = JSON.parse(wrapper.value)
+	// 				if (!(value instanceof Array)) return message
+	// 				wrapper.value = value
+	// 			} catch (err) {
+	// 				return message
+	// 			}
+	// 		} else {
+	// 			if (!(wrapper.value instanceof Array)) return message
+	// 		}
+	// 		if (checkingElements) {
+	// 			const value = wrapper.value as unknown[]
+	// 			const messageErrors: string[] = []
+	// 			const result: unknown[] = []
+	// 			for (const [i, t] of value.entries()) {
+	// 				const p = wrapper.validator({
+	// 					value: t
+	// 				}, {
+	// 					value: {
+	// 						...checkingElements(i),
+	// 						to: undefined,
+	// 					}
+	// 				})
+	// 				if (p.error == true) {
+	// 					messageErrors.push(...p.messages)
+	// 				} else {
+	// 					result.push(p.result['value'])
+	// 				}
+	// 			}
+	// 			if (messageErrors.length) {
+	// 				return messageErrors
+	// 			} else {
+	// 				wrapper.value = result
+	// 			}
+	// 		}
+	// 	})
+	// 	return this
+	// }
+
+	// isArrayOfObjects(checkingElements?: (i: number) => FieldsStructure, prefixString?: (i: number) => string) {
+	// 	this.isArray()
+	// 	this.add(this.isArrayOfObjects.name, (wrapper: Wrapper<unknown[]>) => {
+	// 		const message = `'${wrapper.label}' debe ser una lista de objetos`
+	// 		const messages: string[] = []
+	// 		for (const [i, v] of wrapper.value.entries()) {
+	// 			const result = isObject(v)
+	// 			if (result.error == true) return message
+	// 			wrapper.value[i] = result.result
+	// 			if (checkingElements) {
+	// 				const v = wrapper.validator(wrapper.value[i], checkingElements(i), prefixString?.(i))
+	// 				if (v.error == true) {
+	// 					messages.push(...v.messages)
+	// 				} else {
+	// 					wrapper.value[i] = v.result
+	// 				}
+	// 			}
+	// 		}
+	// 		if (messages.length) return messages
+	// 	})
+	// 	return this
+	// }
+
+	isIn(...elements: unknown[]) {
+		this.add(this.isIn.name, (wrapper: Wrapper) => {
+			if (wrapper.value instanceof Array) {
+				for (const v of wrapper.value) {
+					if (!elements.includes(v)) return `'${wrapper.label}' no contiene valores válidos`
+				}
+			} else {
+				if (!elements.includes(wrapper.value)) return `'${wrapper.label}' no tiene un valor válido`
+			}
+		})
+		return this
+	}
+
+	isNotIn(...elements: unknown[]) {
+		this.add(this.isNotIn.name, (wrapper: Wrapper) => {
+			if (elements.includes(wrapper.value)) return `'${wrapper.label}' no tiene un valor válido`
+		})
+		return this
+	}
+
+	// hasElements(checkingElements?: (i: number) => FieldStructure) {
+	// 	this.isArray(checkingElements)
+	// 	this.add(this.hasElements.name, (wrapper: Wrapper) => {
+	// 		if (!(wrapper.value as unknown[]).length) return `'${wrapper.label}' debe ser una lista con al menos un elemento`
+	// 	})
+	// 	return this
+	// }
+
+	gt(limit: number) {
+		this.isNumber()
+		this.add(this.gt.name, (wrapper: Wrapper) => {
+			if (wrapper.value as number <= limit) return `'${wrapper.label}' debe ser mayor a '${limit}'`
+		})
+		return this
+	}
+
+	gte(limit: number) {
+		this.isNumber()
+		this.add(this.gte.name, (wrapper: Wrapper) => {
+			if (wrapper.value as number < limit) return `'${wrapper.label}' debe ser mayor o igual a '${limit}'`
+		})
+		return this
+	}
+
+	lt(limit: number) {
+		this.isNumber()
+		this.add(this.lt.name, (wrapper: Wrapper) => {
+			if (wrapper.value as number >= limit) return `'${wrapper.label}' debe ser menor a '${limit}'`
+		})
+		return this
+	}
+
+	lte(limit: number) {
+		return this
+			.isNumber()
+			.add(this.lte.name, (wrapper: Wrapper) => {
+				if (wrapper.value as number > limit) return `'${wrapper.label}' debe ser menor o igual a '${limit}'`
+			})
+	}
+
+	beforeOrSameAsNow() {
+		return this
+			.isDateTime()
+			.add(this.beforeOrSameAsNow.name, (wrapper: Wrapper<PDate>) => {
+				const now = new PDate
+				if (wrapper.value.time > now.time) return `'${wrapper.label}' debe ser anterior o igual a 'ahora'`
+			})
+	}
+
+	isObject(schema?: Record<string, RulesEngine>, prefix?: string) {
+		return this.add(this.isObject.name, (wrapper: Wrapper) => {
+			const message = `'${wrapper.label}' debe ser un objeto`
+
+			if (typeof wrapper.value == 'string') {
+				try {
+					wrapper.value = JSON.parse(wrapper.value)
+				} catch {
+					return message
+				}
+				if (PUtils.getType(wrapper.value) != 'Object') return message
+			} else {
+				if (PUtils.getType(wrapper.value) != 'Object') {
+					return message
+				}
+			}
+
+			return { schema, prefix }
+		})
+	}
+
+	isBoolean() {
+		this.add(this.isBoolean.name, (wrapper: Wrapper) => {
+			const message = `'${wrapper.label}' debe ser de tipo booleano`
+			if (typeof wrapper.value == 'string') {
+				const value = wrapper.value.trim().toUpperCase()
+				switch (value) {
+					case '1':
+					case 'S':
+					case 'SÍ':
+					case 'Y':
+					case 'YES':
+						wrapper.value = true
+						return
+					case '0':
+					case 'N':
+					case 'NO':
+						wrapper.value = false
+						return
+					default: {
+						let json
+						try {
+							json = JSON.parse(wrapper.value)
+						} catch {
+							return message
+						}
+						if (typeof json != 'boolean' && !([0, 1]).includes(json)) return message
+						wrapper.value = json
+						return
+					}
+				}
+			} else if (typeof wrapper.value == 'number') {
+				switch (wrapper.value) {
+					case 0:
+						wrapper.value = false
+						return
+					case 1:
+						wrapper.value = true
+						return
+					default:
+						return message
+				}
+			} else {
+				return typeof wrapper.value == 'boolean' ? null : message
+			}
+		})
+		return this
+	}
+
+	upper() {
+		this.isAlphanumeric()
+		this.add(this.upper.name, (wrapper: Wrapper) => {
+			wrapper.value = (wrapper.value as string).toUpperCase()
+		})
+		return this
+	}
+
+	lower() {
+		this.isAlphanumeric()
+		this.add(this.lower.name, (wrapper: Wrapper) => {
+			wrapper.value = (wrapper.value as string).toLowerCase()
+		})
+		return this
+	}
+
+	decodeURI() {
+		this.isAlphanumeric()
+		this.add(this.decodeURI.name, (wrapper: Wrapper) => {
+			wrapper.value = decodeURI(wrapper.value as string)
+		})
+		return this
+	}
+
+	round(decimals: number) {
+		this.isNumber()
+		this.add(this.round.name, (wrapper: Wrapper) => {
+			wrapper.value = PUtils.Number.round(wrapper.value as number, decimals)
+		})
+		return this
+	}
+
+	/* Reemplaza todos los dobles (o más) espacios juntos por uno simple */
+	cleanDoubleSpaces() {
+		this.isAlphanumeric()
+		this.add(this.cleanDoubleSpaces.name, (wrapper: Wrapper) => {
+			wrapper.value = (wrapper.value as string).replace(/\s{2,}/g, ' ')
+		})
+		return this
+	}
+
+	noSpaces() {
+		this.isAlphanumeric()
+		this.add(this.noSpaces.name, (wrapper: Wrapper) => {
+			if ((wrapper.value as string).match(/\s/)) return `'${wrapper.label}' no debe contener 'espacios'`
+		})
+		return this
+	}
+
+
+	replace(search: string | RegExp, replace: string | ((substring: string, ...args: any[]) => string)) {
+		return this.isAlphanumeric().add(this.replace.name, (wrapper: Wrapper) => {
+			wrapper.value = (wrapper.value as string).replace(search, replace as any)
+		})
+	}
+
+	capitalize() {
+		this.isAlphanumeric()
+		this.add(this.capitalize.name, (wrapper: Wrapper) => {
+			wrapper.value = PUtils.String.capitalize(wrapper.value as string)
+		})
+		return this
+	}
+
+	split(separator: string | RegExp) {
+		return this.isAlphanumeric().add(this.split.name, (wrapper: Wrapper) => {
+			wrapper.value = (wrapper.value as any).split(separator)
+		})
+	}
+}

package/src/rulesEngine.ts

@@ -0,0 +1,36 @@
+export type RulesParams = {
+	label?: string
+} & ({
+	required?: boolean
+} | {
+	default?: unknown
+})
+
+export type ValidationFunction = (wrapper: Wrapper, ...args: unknown[]) => string | void | null | undefined | {
+	schema: Record<string, RulesEngine>
+	prefix?: string
+}
+
+export type Wrapper<T = unknown> = {
+	value: T
+	label: string
+}
+
+export class RulesEngine {
+	constructor(params?: RulesParams) {
+		if (!params) return
+		this.label = params.label
+		this.required = 'required' in params ? params.required : false
+		this.default = 'default' in params ? params.default : null
+	}
+
+	label: string
+	required: boolean = false
+	default: unknown = null
+	collection: Record<string, ValidationFunction> = {}
+
+	protected add(name: string, validationFunction: ValidationFunction) {
+		if (!this.collection[name]) this.collection[name] = validationFunction
+		return this
+	}
+}

package/test/validaciones.ts

@@ -0,0 +1,22 @@
+import { rules, validate } from '../src/index'
+
+const original = {
+	uno: 'hola',
+	dos: 1,
+	tres: '67',
+	cuatro: {
+		aaa: '2024-10-28 23:56:00',
+		bbb: 'fgh'
+	}
+}
+
+const resultados = validate(original, rules({ label: 'Mi número' }).isObject({
+	uno: rules({ label: 'Uno', required: true }),
+	dos: rules().isBoolean(),
+	tres: rules({ required: true }).isNaturalNoZero(),
+	cuatro: rules({ label: 'Cuatro', default: {} }).isObject({
+		aaa: rules().isDateTime()
+	})
+}, `Mi número >`))
+
+console.log(original, resultados)

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+	"compilerOptions": {
+		"target": "ESNext",
+		"module": "NodeNext",
+		"moduleResolution": "NodeNext",
+		"esModuleInterop": true,
+		"forceConsistentCasingInFileNames": true,
+		"strict": false,
+		"skipLibCheck": true,
+		"declaration": true,
+		"declarationMap": true,
+		"outDir": "./dist"
+	},
+	"include": [
+		"src/**/*.ts"
+	],
+	"exclude": [
+		"node_modules"
+	]
+}