check-rule-mate 0.5.0 → 0.5.1

package/README.md

@@ -61,14 +61,14 @@ This separation makes the system flexible, scalable, and easy to maintain.
 - [Getting Started](#Getting-Started)
   - [NPM - Installation](#Installation)
   - [Repository - Installation](#Repository---Installation)
-  - [Running Tests](#Running-Tests)
+  - [Running Tests](#Repository---Running-Tests)
 - [How It Works](#How-It-Works)
-  - [Basic Example](#Basic-Example)
+  - [Basic Usage](#Basic-Usage)
 - [Defining Validation](#Defining-Validation)
   - [1. Schema](#Defining-a-Schema-What-to-validate)
   - [2. Rules](#Defining-Rules-How-to-validate)
   - [3. Validation Helpers](#Validation-Helpers-Execution-Layer)
-  - [4. Error Messages](#Error-Messages)
+  - [4. Error Messages](#Error-Messages-i18n-ready)
   - [5. Example Usage](#Example-Usage)
     - [Vanilla](#vanilla)
     - [Express](#express)
@@ -126,8 +126,9 @@ async function runFormValidate() {
     schema: CONTACT_US,
     errorMessages: ERROR_MESSAGES,
     options: {
+      cache: true,
       abortEarly: false,
-      propertiesMustMatch: true
+      propertiesMustMatch: true,
     }
   });
 
@@ -149,13 +150,15 @@ When is **valid**:
 ```
 
 When is **invalid** and **has errors**:
-```javascript
+```typescript
 {
-  error: true;
+  error: true,
   errors: {
     [field: string]: {
-      type: string;
-      message: string;
+      name: string,
+      type: string,
+      message: string,
+      code: string,
     }[];
   };
 }
@@ -175,11 +178,13 @@ Schemas map **data fields** to **rules**.
   },
   "email": {
     "rule": "email",
-    "required": true
+    "required": true,
+    "cache": false,
   },
   "emailConfirm": {
     "rule": "email--confirm",
-    "required": true
+    "required": true,
+    "cache": false,
   },
   "phone": {
     "rule": "phone",
@@ -191,6 +196,7 @@ Schemas map **data fields** to **rules**.
 #### Schema Properties
 - **rule**: Rule name (supports modifiers via `rule--modifier`)
 - **required**: Whether the field must exist and not be empty
+- **cache**: if this field will have cache or not
 
 ### Defining Rules (How to validate)
 
@@ -350,8 +356,9 @@ This makes localization and message customization straightforward.
 ### Validation Options
 ```typescript
 options: {
-  abortEarly?: boolean;          // Stop on first error
-  propertiesMustMatch?: boolean; // Schema vs data strictness
+  cache?: boolean,               // If cache is enabled or not
+  abortEarly?: boolean,          // Stop on first error
+  propertiesMustMatch?: boolean, // Schema vs data strictness
 }
 ```
 

package/dist/main.cjs.js

@@ -1 +1 @@
-var k=Object.defineProperty;var E=Object.getOwnPropertyDescriptor;var b=Object.getOwnPropertyNames;var P=Object.prototype.hasOwnProperty;var j=(u,n)=>{for(var c in n)k(u,c,{get:n[c],enumerable:!0})},I=(u,n,c,i)=>{if(n&&typeof n=="object"||typeof n=="function")for(let f of b(n))!P.call(u,f)&&f!==c&&k(u,f,{get:()=>n[f],enumerable:!(i=E(n,f))||i.enumerable});return u};var T=u=>I(k({},"__esModule",{value:!0}),u);var x={};j(x,{createValidator:()=>V});module.exports=T(x);function V(u,{validationHelpers:n={},rules:c,schema:i,errorMessages:f={},options:y={propertiesMustMatch:!0,abortEarly:!1}}){let p={},r=u,d={all:async e=>Promise.all([...e].map(async s=>await h(s,r))),first:async e=>{let s=[];for(let t of e){let l=await h(t,r);if(s.push(l),!l)return s}return s}};function g(e,s){if(!e||typeof s!="string")return;let t=s.split("."),l=e;for(let M of t){if(l[M]===void 0)return;l=l[M]}return l}async function h(e,s=null){if(i[e.key]){let{rule:t,required:l}=i[e.key];if((t&&l||!l&&e.value!="")&&t){let M=t.split("--")[0],a=t.split("--").length>1?t.split("--")[1]:"",O=U(e.value,c[M],a,n,s),{isValid:R,errorMessage:m,errorType:q}=await O.validate();return R||(p[e.key]={name:e.key,error:!0,errorMessage:g(f,m)||m,errorType:q}),R}}else if(y.propertiesMustMatch)return p[e.key]={name:e.key,error:!0,errorMessage:"Invalid property"},!1;return!0}async function w(e){return await h({key:e,value:r[e]},r)?{ok:!0}:{error:!0,errors:p[e]}}async function o(){p={};let e=Object.keys(r).map(s=>({key:s,value:r[s]}));if(e&&e.length>0){if(!Object.keys(i).every(a=>r.hasOwnProperty(a)))return{error:!0,errorMessage:"Missing properties"};if((y!=null&&y.abortEarly?await d.first(e):await d.all(e)).some(a=>!a))return{error:!0,errors:p};let t=Object.keys(i).map(a=>({key:a,required:i[a].required})),l=e.map(a=>a.key);if(!t.filter(a=>a.required).map(a=>a.key).every(a=>l.includes(a)))return{error:!0}}else if(!e||e.length===0)return{error:!0,errorMessage:"Missing fields for schema"};return{ok:!0}}function v(e){r=e}return{validate:o,validateField:w,setData:v}}function U(u,n,c=null,i=null,f=null){async function y(r){let d,g;return{isValid:!(await Promise.all(r.validate.map(async o=>{let v=!0;if(r.params&&r.params[o]&&r.params[o].length>0){let e=r.params[o].map(t=>typeof t=="string"&&t[0]==="$"?t.substring(1,t.length):t);v=await this[o](...e)}else v=await this[o]();return!v&&!d&&(r!=null&&r.error[o])&&(d=r.error[o],g=o),v}))).some(o=>!o),errorMessage:d,errorType:g}}async function p(){if(i&&typeof i=="function"){let d=i(u,n,c,f);Object.keys(d).forEach(g=>{this[g]=d[g]})}return c?await y.call(this,n.modifier[c]):await y.call(this,n)}return{validate:p}}0&&(module.exports={createValidator});
+var V=Object.defineProperty;var j=Object.getOwnPropertyDescriptor;var D=Object.getOwnPropertyNames;var T=Object.prototype.hasOwnProperty;var U=(r,n)=>{for(var u in n)V(r,u,{get:n[u],enumerable:!0})},F=(r,n,u,i)=>{if(n&&typeof n=="object"||typeof n=="function")for(let y of D(n))!T.call(r,y)&&y!==u&&V(r,y,{get:()=>n[y],enumerable:!(i=j(n,y))||i.enumerable});return r};var L=r=>F(V({},"__esModule",{value:!0}),r);var x={};U(x,{createValidator:()=>E});module.exports=L(x);var m={propertiesMustMatch:!0,abortEarly:!1,cache:!0};function E(r,{validationHelpers:n={},rules:u,schema:i,errorMessages:y={},options:f=m}){f={...m,...f},r=r;let k={},a={},p={all:async e=>Promise.all([...e].map(async s=>await v(s,r))),first:async e=>{let s=[];for(let l of e){let c=await v(l,r);if(s.push(c),!c)return s}return s}};function g(e,s){if(!e||typeof s!="string")return;let l=s.split("."),c=e;for(let d of l){if(c[d]===void 0)return;c=c[d]}return c}async function v(e,s=null){var l,c;if(i[e.key]){let{rule:d,required:t}=i[e.key];if((((l=i[e.key])==null?void 0:l.cache)!==void 0?i[e.key].cache:f.cache)&&s[e.key]===((c=a[e.key])==null?void 0:c.value))return a[e.key].isValid;if((d&&t||!t&&e.value!="")&&d){let O=d.split("--")[0],q=d.split("--").length>1?d.split("--")[1]:"",P=_(e.value,u[O],q,n,s),{isValid:w,errorMessage:R,errorType:I}=await P.validate();return w||(k[e.key]={name:e.key,code:R,type:I,message:g(y,R)||""}),a[e.key]={isValid:w,value:s[e.key]},w}}else if(f.propertiesMustMatch)return k[e.key]={name:e.key,message:"Invalid property"},!1;return!0}async function M(e){return await v({key:e,value:r[e]},r)?{ok:!0}:{error:!0,errors:k[e]}}async function o(){k={};let e=Object.keys(r).map(s=>({key:s,value:r[s]}));if(e&&e.length>0){if(!Object.keys(i).every(t=>r.hasOwnProperty(t)))return{error:!0,errorMessage:"Missing properties"};if((f!=null&&f.abortEarly?await p.first(e):await p.all(e)).some(t=>!t))return{error:!0,errors:k};let l=Object.keys(i).map(t=>({key:t,required:i[t].required})),c=e.map(t=>t.key);if(!l.filter(t=>t.required).map(t=>t.key).every(t=>c.includes(t)))return{error:!0}}else if(!e||e.length===0)return{error:!0,errorMessage:"Missing fields for schema"};return{ok:!0}}function h(e){r=e}return{validate:o,validateField:M,setData:h}}function _(r,n,u=null,i=null,y=null){async function f(a){let p,g;return{isValid:!(await Promise.all(a.validate.map(async o=>{let h=!0;if(a.params&&a.params[o]&&a.params[o].length>0){let e=a.params[o].map(l=>typeof l=="string"&&l[0]==="$"?l.substring(1,l.length):l);h=await this[o](...e)}else h=await this[o]();return!h&&!p&&(a!=null&&a.error[o])&&(p=a.error[o],g=o),h}))).some(o=>!o),errorMessage:p,errorType:g}}async function k(){if(i&&typeof i=="function"){let p=i(r,n,u,y);Object.keys(p).forEach(g=>{this[g]=p[g]})}return u?await f.call(this,n.modifier[u]):await f.call(this,n)}return{validate:k}}0&&(module.exports={createValidator});

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "check-rule-mate",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "",
   "main": "./dist/main.cjs.js",
   "type": "commonjs",
+  "types": "index.d.ts",
   "keywords": [
     "data validation",
     "data validation js",

package/src/index.d.ts

@@ -0,0 +1,128 @@
+/**
+ * This file contains all type definitions used in the project.
+ */
+
+/**
+ * Represents a single data field.
+ */
+export interface DataField {
+  /** The name and key of the field */
+  name: string
+
+  /** The value of the field */
+  value: string
+}
+
+/**
+ * Options to control validator behavior.
+ */
+export interface ValidatorOptions {
+  /** If the form fields don't match the expected structure, triggers an error */
+  propertiesMustMatch: boolean
+
+  /** Stops validation when the first error is caught */
+  abortEarly: boolean
+
+  /** Defines if the schema will use cache by default */
+  cache: boolean
+}
+
+/**
+ * A single validation helper function.
+ */
+export type ValidatorHelper = (
+  value: any,
+  rule: string,
+  modifier: string,
+  data: DataField[]
+) => boolean
+
+/**
+ * A map of validation helper functions.
+ */
+export type ValidationHelpers = Record<string, ValidatorHelper>
+
+/**
+ * Schema rule for a single field.
+ */
+export interface SchemaRuleField {
+  /** The validation rule for the field (e.g., "name", "email", "phone", "hasText") */
+  rule: string
+
+  /** Indicates whether the field is required */
+  required: boolean
+
+  /** Indicates if the field requires cache or not */
+  cache: boolean
+}
+
+/**
+ * Schema rule object.
+ */
+export interface SchemaRule {
+  field: SchemaRuleField
+}
+
+/**
+ * Validation schema mapping field names to rules.
+ */
+export type SchemaRules = Record<string, SchemaRule>
+
+/**
+ * Validator configuration object.
+ */
+export interface DataValidatorConfigs {
+  /** The validator functions to help your validations */
+  validationHelpers: ValidationHelpers
+
+  /** The rules you want to use through validation */
+  rules: object
+
+  /** The rules you want to use per field */
+  schema: SchemaRules
+
+  /** The error messages you want to show during errors */
+  errorMessages: object
+
+  /** Validator options */
+  options: ValidatorOptions
+}
+
+/**
+ * Represents a successful response.
+ */
+export interface DataValidatorSuccessResponse {
+  /** Indicates the operation was successful */
+  ok: boolean
+}
+
+/**
+ * Error object.
+ */
+export interface CheckError {
+  /** Field name */
+  name: string
+
+  /** Error path */
+  code?: string
+
+  /** Error type */
+  type?: string
+
+  /** Error message */
+  message?: string
+}
+
+/**
+ * Represents an error response.
+ */
+export interface DataValidatorErrorResponse {
+  /** Indicates an error occurred */
+  error: boolean
+
+  /** A message describing the error */
+  errorMessage?: string
+
+  /** Additional error details */
+  errors?: Record<string, CheckError>
+}

package/src/js/dataValidate.js

@@ -1,11 +1,15 @@
+const DEFAUL_OPTIONS = { propertiesMustMatch: true, abortEarly: false, cache: true };
+
 /**
  * Validate your data fields using your rules, data rules and validators.
- * @param {[DataField]} dataParameter - All the data fields to be validate
+ * @param {[DataField]} data - All the data fields to be validate
  * @param {DataValidatorConfigs} config - The configs which will be followed during validation
  */
-export function createValidator(dataParameter, {validationHelpers = {}, rules, schema, errorMessages = {}, options = { propertiesMustMatch: true, abortEarly: false}}) {
+export function createValidator(data, {validationHelpers = {}, rules, schema, errorMessages = {}, options = DEFAUL_OPTIONS}) {
+    options = { ...DEFAUL_OPTIONS, ...options};
+    data = data;
     let errors = {};
-    let data = dataParameter;
+    let oldData = {};
 
     const validateByStrategies = {
         all: async (dataArr) => Promise.all([...dataArr].map(async (input) => await inputValidation(input, data))),
@@ -39,6 +43,12 @@ export function createValidator(dataParameter, {validationHelpers = {}, rules, s
     async function inputValidation(dataAttribute, data = null) {
         if (schema[dataAttribute.key]) {
             const { rule, required } = schema[dataAttribute.key];
+            const cacheEnabled = schema[dataAttribute.key]?.cache !== undefined ? schema[dataAttribute.key].cache : options.cache;
+
+            if (cacheEnabled && data[dataAttribute.key] === oldData[dataAttribute.key]?.value) {
+                return oldData[dataAttribute.key].isValid;
+            }
+
             if ((rule && required) || (!required && dataAttribute.value != '')) {
                 if (rule) {
                     const INPUT_RULE = rule.split('--')[0];
@@ -48,19 +58,19 @@ export function createValidator(dataParameter, {validationHelpers = {}, rules, s
                     if (!isValid) {
                         errors[dataAttribute.key] = {
                             name: dataAttribute.key,
-                            error: true,
-                            errorMessage: getObjectValueByPath(errorMessages, errorMessage) || errorMessage,
-                            errorType: errorType
+                            code: errorMessage,
+                            type: errorType,
+                            message: getObjectValueByPath(errorMessages, errorMessage) || ''
                         }
                     }
+                    oldData[dataAttribute.key] = {isValid: isValid, value: data[dataAttribute.key]};
                     return isValid;
                 }
             }
         } else if (options.propertiesMustMatch) {
             errors[dataAttribute.key] = {
                 name: dataAttribute.key,
-                error: true,
-                errorMessage: "Invalid property"
+                message: "Invalid property"
             }
             return false;
         }

package/src/types.js

@@ -6,7 +6,7 @@
 /**
  * @typedef {Object} DataField
  * @property {string} name - The name and key of the field
- * @property {string} value - the value of the field
+ * @property {any} value - the value of the field
  */
 
 /**
@@ -15,13 +15,14 @@
  * @property {Object} rules - The rules you want to use through validation
  * @property {SchemaRule} schema - The rules you want to use per field
  * @property {Object} errorMessages - The error messages you want to show during errors
- * @property {ValidatorOption} options - Options
+ * @property {ValidatorOptions} options - Options
  */
 
 /**
- * @typedef {Object} ValidatorOption
+ * @typedef {Object} ValidatorOptions
  * @property {boolean} propertiesMustMatch - If the form fields doesn't match with the expected structure will triggers an error
  * @property {boolean} abortEarly - Stops when caughts the first error
+ * @property {boolean} cache - Defines if the schema will uses cache as default or not
  */
 
 /**
@@ -39,13 +40,14 @@
 
 /**
  * @typedef {Object} SchemaRule
- * @property {SchemaRuleFiVeld} field - The field which will use the rule
+ * @property {SchemaRuleField} field - The field which will use the rule
  */
 
 /**
  * @typedef {Object} SchemaRuleField
  * @property {string} rule - The validation rule for the field (e.g., "name", "email", "phone", "hasText").
  * @property {boolean} required - Indicates whether the field is required.
+ * @property {boolean} cache - Indicates if the field requires cache or not
  */
 
 /**
@@ -65,5 +67,15 @@
  * @typedef {Object} DataValidatorErrorResponse
  * @property {boolean} error - Indicates an error occurred.
  * @property {string} [errorMessage] - A message describing the error (optional).
- * @property {Object} [dataErrors] - Additional error details (optional).
+ * @property {Object.<string, CheckError>} [errors] - Additional error details (optional).
+ */
+
+/**
+ *  Error Object
+ *
+ * @typedef {Object} CheckError
+ * @property {string} name - Field name
+ * @property {string} code - Error path (optional)
+ * @property {string} type - Error type (optional)
+ * @property {string} message - Error message (optional)
  */