check-rule-mate 0.4.3 → 0.5.1

package/README.md

@@ -1,11 +1,18 @@
 # check-rule-mate
-Validate any type of data in JS using your own rules and validations.
+Rule-based, extensible and async-friendly data validation engine for complex forms and business rules.
 
 ## Overview
 
-A lightweight and reusable JavaScript "library" for data validation. This library was designed to simplify the process of validating form inputs using flexible rules and error handling. Validating your data by allowing you to define flexible rules, custom error messages, and reusable helper functions—all in a structured format.
+**check-rule-mate** is a lightweight **rule-driven validation engine** for JavaScript.
+Instead of coupling validation logic directly to schemas or fields, check-rule-mate separates concerns into **rules**, **schemas**, **validators**, and **error messages**, allowing you to build **highly reusable**, **composable**, and **context-aware validations**.
 
-The core goal is to provide a **reusable and easy-to-extend** for handling various form inputs, including fields like name, email, birthdate, phone number, and more.
+It is designed for scenarios where traditional schema-based validators start to feel limiting, especially when you need:
+
+- Cross-field validation
+- Contextual rules
+- Async checks
+- Reusable validation logic across multiple forms
+- Full control over execution flow and error handling
 
 
 **Github repository:** [check-rule-mate repository](https://github.com/johnrock16/check-rule-mate)
@@ -15,49 +22,76 @@ The core goal is to provide a **reusable and easy-to-extend** for handling vario
 **Test the core functionalities here:** [check-rule-mate demo](https://johnrock16.github.io/check-rule-mate/)
 (Note: Creating or modifying custom validators is not supported in the demo, as it requires JavaScript implementation.)
 
+## Why check-rule-mate?
 
-## Features
+Use **check-rule-mate** if you:
+- Need reusable validation logic across different forms and contexts
+- Have complex or conditional validation rules
+- Want full control over how validation runs
+- Need async validations (API calls, database checks, etc.)
+- Prefer rule-driven validation instead of tightly coupled schemas
+- Want clean separation between rules, data, and messages
+
+
+## Core Concepts
 
-- **Custom Validation Rules**: Easily define custom rules for form fields.
-- **Modular Design**: Separation of rule definitions and error messages for easy management.
-- **Easy Integration**: Can be used in any JavaScript environment.
-- **Clear Error Handling**: Handles errors and displays messages.
-- **Extendable**: Create your custom validators and rules and extend as you want.
+check-rule-mate is built around four main concepts:
 
-## Advanced Features
+1. **Rules**: How data is validated
+2. **Schema**: What should be validated
+3. **Validation Helpers**: How rules are executed
+4. **Error Messages**: How errors are communicated
 
-- **Modifiers:** Extend rules for specific use cases (e.g., age validation in a date rule).
-- **Dynamic Parameters:** Use $variable to access field data within rules.
-- **Modular Rules and Validators:** Create multiple files for rules and helpers, organizing them by context or form.
-- **Async Validations:** You could create async functions to validate some data. Do You need to use a fetch or wait a promise to be resolved? No problems.
+This separation makes the system flexible, scalable, and easy to maintain.
+
+## Features
+
+- Rule-based validation engine
+- Reusable validation rules
+- Modifiers for contextual rule extensions
+- Cross-field validation using dynamic parameters
+- Async validation support
+- Abort early or collect all errors
+- Strict or loose schema matching
+- i18n-ready error messages
+- Framework-agnostic (frontend or backend)
 
 ## Table of Contents
 
 - [Getting Started](#Getting-Started)
-  - [Installation](#Installation)
-  - [Running Tests](#Running-Tests)
+  - [NPM - Installation](#Installation)
+  - [Repository - Installation](#Repository---Installation)
+  - [Running Tests](#Repository---Running-Tests)
 - [How It Works](#How-It-Works)
-  - [Basic Example](#Basic-Example)
-- [Defining Validation Components](#Defining-Validation-Components)
-  - [1. Data Rules](#Data-Rules)
-  - [2. General Rules](#General-Rules)
-  - [3. Validation Helpers](#Validation-Helpers)
-  - [4. Error Messages](#Error-Messages)
+  - [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-i18n-ready)
   - [5. Example Usage](#Example-Usage)
     - [Vanilla](#vanilla)
     - [Express](#express)
     - [Frontend](#frontend)
+- [When NOT to use check-rule-mate](#When-NOT-to-use-check-rule-mate)
+- [License](#License);
 
 ## Getting Started
+
 ### Installation
+If you are in NPM use this:
+```bash
+npm install check-rule-mate
+```
 
-To install and start the library, run:
+### Repository - Installation
+If you downloaded the repository you can install using:
 ```bash
 npm install
 npm start
 ```
 
-### Running Tests
+### Repository - Running Tests
 
 Execute the test suite with:
 ```bash
@@ -65,69 +99,108 @@ npm test
 ```
 
 ## How It Works
-### Basic Example
+### Basic Usage
 
-Here’s an example of validating a set of fields:
 ```javascript
-  const { myValidator } = require('./dataValidator/validators');
-  const { dataValidate } = require('./dataValidator/dataValidate');
-  const MY_RULES = require('./dataValidator/rules/validators/myValidatorRules.json');
-  const CONTACT_US = require('./dataValidator/rules/data/contactUs.json');
-  const MY_VALIDATION_ERROR_MESSAGES = require('./i18n/en_US/errors/myValidatorRules.json');
-
-  async function runDataValidate() {
-    const fields = {
-      name: "John",
-      lastName: "Doe",
-      email: "email@email.com",
-      emailConfirm: "email@email.com",
-      phone: "",
-      subject: "I need a coffee",
-      message: "Give me coffee"
-    };
-
-    // This should return { ok: true }
-    const result = await dataValidate(fields, {
-      validationHelpers: myValidator,
-      rules: MY_RULES,
-      dataRule: CONTACT_US,
-      dataErrorMessages: MY_VALIDATION_ERROR_MESSAGES,
-    });
-
-    console.log(result);
-  }
+import MY_RULES from './rules/myValidatorRules.json' with { type: 'json' };
+import CONTACT_US from './schemas/contactUs.json' with { type: 'json' };
+import ERROR_MESSAGES from './i18n/en_US/errors.json' with { type: 'json' };
+
+import { createValidator } from 'check-rule-mate';
+import { myValidator } from './validators/myValidator.js';
+
+const fields = {
+  name: 'John',
+  lastName: 'Doe',
+  email: 'email@email.com',
+  emailConfirm: 'email@email.com',
+  phone: '',
+  subject: 'I need a coffee',
+  message: 'Give me coffee'
+};
+
+async function runFormValidate() {
+  const validator = createValidator(fields, {
+    validationHelpers: myValidator,
+    rules: MY_RULES,
+    schema: CONTACT_US,
+    errorMessages: ERROR_MESSAGES,
+    options: {
+      cache: true,
+      abortEarly: false,
+      propertiesMustMatch: true,
+    }
+  });
+
+  const result = await validator.validate();
 
-  runDataValidate();
+  // This should return { ok: true }
+  console.log(result);
+}
+
+runFormValidate();
 ```
 
-#### Parameters for dataValidate:
+### Validation Result
+A validation result follows this structure:
+
+When is **valid**:
+```javascript
+{ ok: true }
+```
+
+When is **invalid** and **has errors**:
+```typescript
+{
+  error: true,
+  errors: {
+    [field: string]: {
+      name: string,
+      type: string,
+      message: string,
+      code: string,
+    }[];
+  };
+}
+```
 
-- **fields**: The object containing data to be validated.
-- **validationHelpers**: Functions to validate field data (see /dataValidator/validators).
-- **rules**: General validation rules for your application.
-- **dataRule**: Specific rules linking fields to validation logic.
-- **dataErrorMessages**: Custom error messages returned upon validation failure.
 
-## Defining Validation Components
+## Defining Validation
 
-### Data Rules
+### Defining a Schema (What to validate)
 
-Define rules for specific datasets, such as forms. Example for a "Contact Us" form:
+Schemas map **data fields** to **rules**.
 ```json
 {
-  "name": { "rule": "name", "required": true },
-  "lastName": { "rule": "name", "required": true },
-  "email": { "rule": "email", "required": true },
-  "emailConfirm": { "rule": "email--confirm", "required": true },
-  "phone": { "rule": "phone", "required": false },
-  "subject": { "rule": "hasText", "required": true },
-  "message": { "rule": "hasText", "required": true }
+  "name": {
+    "rule": "name",
+    "required": true
+  },
+  "email": {
+    "rule": "email",
+    "required": true,
+    "cache": false,
+  },
+  "emailConfirm": {
+    "rule": "email--confirm",
+    "required": true,
+    "cache": false,
+  },
+  "phone": {
+    "rule": "phone",
+    "required": false
+  }
 }
 ```
 
-### General 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)
 
-Define reusable validation logic. Example:
+Rules define validation logic, independent of any specific form.
 
 ```json
 {
@@ -169,17 +242,53 @@ Define reusable validation logic. Example:
   }
 }
 ```
-#### Key Components:
 
-- **validate**: Array of functions to execute for validation.
-- **error**: Error messages for validation failures.
-- **regex**: Regular expression for validation.
-- **modifier**: Overrides specific rules with additional validations.
-- **params**: Parameters for validation functions (e.g., $email accesses email field data).
+#### Rule Properties
+
+- **validate**: Ordered list of validation functions
+- **regex**: Optional regex used by the regex helper
+- **error**: Error keys mapped to validation functions
+- **modifier**: Contextual rule extensions
+- **params**: Parameters passed to validation helpers
+
+#### Modifiers (Contextual Rules)
+Modifiers allow extending a rule **without duplicating logic**.
+
+Example:
+```json
+"email--confirm"
+```
+
+Internally:
+
+- Base rule: email
+- Modifier: confirm
+
+Modifiers can override:
+
+- validate
+- params
+- regex
+- error
+
+This makes rules highly reusable and expressive.
+
+#### Dynamic Parameters ($field)
+Rules can reference other fields dynamically:
+
+```json
+"params": {
+  "equals": ["$email"]
+}
+```
+
+At runtime:
+- `$email` resolves to `data.email`
+- Enables **cross-field validation**
 
 
-### Validation Helpers
-Helper functions perform actual validation. Example:
+### Validation Helpers (Execution Layer)
+Validation helpers are the **runtime implementation** of rules.
 
 ```javascript
 const myValidator = function (value, rule, modifier = null, data = null) {
@@ -219,13 +328,37 @@ const myValidator = function (value, rule, modifier = null, data = null) {
 };
 ```
 
-### Error Messages
+#### Helper Signature
+```typescript
+(value, rule, modifier?, data?) => Record<string, Function>
+```
+
+Helpers:
+- Can be **sync or async**
+- Are **stateless**
+- Do not know about schemas or error messages
 
-Define custom error messages in a structured format:
+### Error Messages (i18n-ready)
+Errors are resolved via keys, not hardcoded strings.
 ``` json
 {
-  "common": { "hasText": "Please fill out this field." },
-  "email": { "regex": "Enter a valid email address." }
+  "common": {
+    "hasText": "Please fill the field"
+  },
+  "email": {
+    "regex": "Please enter a valid email",
+    "equals": "Emails do not match"
+  }
+}
+```
+This makes localization and message customization straightforward.
+
+### Validation Options
+```typescript
+options: {
+  cache?: boolean,               // If cache is enabled or not
+  abortEarly?: boolean,          // Stop on first error
+  propertiesMustMatch?: boolean, // Schema vs data strictness
 }
 ```
 
@@ -270,3 +403,12 @@ npm run example:express
 Here you can found the DEMO page and it's a type of "playground" to test how RULES works and validations works. (Here you can't create customized javascript so custom validatorHelpers are disabled by default)
 
 **Frontend example:** [check-rule-mate demo.](https://johnrock16.github.io/check-rule-mate/)
+
+
+## When NOT to use check-rule-mate
+- Simple one-off forms
+- Basic required-only validation
+- When schema-based validation is enough
+
+## License
+- ISC

package/dist/main.cjs.js

@@ -1 +1 @@
-var h=Object.defineProperty;var w=Object.getOwnPropertyDescriptor;var R=Object.getOwnPropertyNames;var M=Object.prototype.hasOwnProperty;var O=(n,s)=>{for(var o in s)h(n,o,{get:s[o],enumerable:!0})},b=(n,s,o,i)=>{if(s&&typeof s=="object"||typeof s=="function")for(let u of R(s))!M.call(n,u)&&u!==o&&h(n,u,{get:()=>s[u],enumerable:!(i=w(s,u))||i.enumerable});return n};var q=n=>b(h({},"__esModule",{value:!0}),n);var P={};O(P,{dataValidate:()=>V});module.exports=q(P);function V(n,{validationHelpers:s={},rules:o,dataRule:i,dataErrorMessages:u={}}){let y={};function g(e,f){if(!e||typeof f!="string")return;let l=f.split("."),t=e;for(let c of l){if(t[c]===void 0)return;t=t[c]}return t}async function a(e,f=null){let{rule:l,required:t}=i[e.key];if((l&&t||!t&&e.value!="")&&l){let c=l.split("--")[0],r=l.split("--").length>1?l.split("--")[1]:"",m=E(e.value,o[c],r,s,f),{isValid:p,errorMessage:v,errorType:k}=await m.validate();return p||(y[e.key]={name:e.key,error:!0,errorMessage:g(u,v)||v,errorType:k}),p}return!0}async function d(){let e=Object.keys(n).map(f=>({key:f,value:n[f]}));if(e&&e.length>0){if(!Object.keys(i).every(r=>n.hasOwnProperty(r)))return{error:!0,errorMessage:"Missing properties"};if((await Promise.all([...e].map(async r=>await a(r,n)))).some(r=>!r))return{error:!0,dataErrors:y};let l=Object.keys(i).map(r=>({key:r,required:i[r].required})),t=e.map(r=>r.key);if(!l.filter(r=>r.required).map(r=>r.key).every(r=>t.includes(r)))return{error:!0}}else if(!e||e.length===0)return{error:!0,errorMessage:"Missing fields for dataRules"};return{ok:!0}}return d()}function E(n,s,o=null,i=null,u=null){async function y(a){let d,e;return{isValid:!(await Promise.all(a.validate.map(async t=>{let c=!0;if(a.params&&a.params[t]&&a.params[t].length>0){let r=a.params[t].map(p=>typeof p=="string"&&p[0]==="$"?p.substring(1,p.length):p);c=await this[t](...r)}else c=await this[t]();return!c&&!d&&(a!=null&&a.error[t])&&(d=a.error[t],e=t),c}))).some(t=>!t),errorMessage:d,errorType:e}}async function g(){if(i&&typeof i=="function"){let d=i(n,s,o,u);Object.keys(d).forEach(e=>{this[e]=d[e]})}return o?await y.call(this,s.modifier[o]):await y.call(this,s)}return{validate:g}}0&&(module.exports={dataValidate});
+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,10 +1,22 @@
 {
   "name": "check-rule-mate",
-  "version": "0.4.3",
+  "version": "0.5.1",
   "description": "",
   "main": "./dist/main.cjs.js",
   "type": "commonjs",
-  "keywords": ["data validation", "data validation js", "validator", "validate", "form validator", "form validator js", "form validate", "check-rule-mate", "check rule", "check rule mate"],
+  "types": "index.d.ts",
+  "keywords": [
+    "data validation",
+    "data validation js",
+    "validator",
+    "validate",
+    "form validator",
+    "form validator js",
+    "form validate",
+    "check-rule-mate",
+    "check rule",
+    "check rule mate"
+  ],
   "scripts": {
     "start": "node ./examples/vanilla/src/index.js",
     "build": "node build",
@@ -15,7 +27,7 @@
   "author": "João Rocha",
   "license": "ISC",
   "devDependencies": {
-    "esbuild": "^0.24.0",
+    "esbuild": "^0.27.2",
     "express": "^4.21.2",
     "jest": "^29.7.0"
   }

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,30 @@
+const DEFAUL_OPTIONS = { propertiesMustMatch: true, abortEarly: false, cache: true };
+
 /**
  * Validate your data fields using your rules, data rules and validators.
  * @param {[DataField]} data - All the data fields to be validate
  * @param {DataValidatorConfigs} config - The configs which will be followed during validation
- * @returns {DataValidatorSuccessResponse | DataValidatorErrorResponse} - The response of your validation
  */
-export function dataValidate(data, {validationHelpers = {}, rules, dataRule, dataErrorMessages = {}}) {
-    const dataErrors = {};
+export function createValidator(data, {validationHelpers = {}, rules, schema, errorMessages = {}, options = DEFAUL_OPTIONS}) {
+    options = { ...DEFAUL_OPTIONS, ...options};
+    data = data;
+    let errors = {};
+    let oldData = {};
+
+    const validateByStrategies = {
+        all: async (dataArr) => Promise.all([...dataArr].map(async (input) => await inputValidation(input, data))),
+        first: async (dataArr) => {
+            const results = []
+            for (const input of dataArr) {
+                const result = await inputValidation(input, data);
+                results.push(result);
+                if (!result) {
+                    return results
+                }
+            }
+            return results;
+        }
+    };
 
     function getObjectValueByPath(obj, path) {
         if (!obj || typeof path !== 'string') return undefined;
@@ -22,41 +41,73 @@ export function dataValidate(data, {validationHelpers = {}, rules, dataRule, dat
     }
 
     async function inputValidation(dataAttribute, data = null) {
-        const { rule, required } = dataRule[dataAttribute.key];
-
-        if ((rule && required) || (!required && dataAttribute.value != '')) {
-            if (rule) {
-                const INPUT_RULE = rule.split('--')[0];
-                const RULE_MODIFIER = rule.split('--').length > 1 ? rule.split('--')[1] : '';
-                const dataAttributeValidation = dataAttributeValidator(dataAttribute.value, rules[INPUT_RULE], RULE_MODIFIER, validationHelpers, data);
-                const { isValid, errorMessage, errorType } = await dataAttributeValidation.validate();
-                if (!isValid) {
-                    dataErrors[dataAttribute.key] = {
-                        name: dataAttribute.key,
-                        error: true,
-                        errorMessage: getObjectValueByPath(dataErrorMessages, errorMessage) || errorMessage,
-                        errorType: errorType
+        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];
+                    const RULE_MODIFIER = rule.split('--').length > 1 ? rule.split('--')[1] : '';
+                    const dataAttributeValidation = dataAttributeValidator(dataAttribute.value, rules[INPUT_RULE], RULE_MODIFIER, validationHelpers, data);
+                    const { isValid, errorMessage, errorType } = await dataAttributeValidation.validate();
+                    if (!isValid) {
+                        errors[dataAttribute.key] = {
+                            name: dataAttribute.key,
+                            code: errorMessage,
+                            type: errorType,
+                            message: getObjectValueByPath(errorMessages, errorMessage) || ''
+                        }
                     }
+                    oldData[dataAttribute.key] = {isValid: isValid, value: data[dataAttribute.key]};
+                    return isValid;
                 }
-                return isValid;
             }
+        } else if (options.propertiesMustMatch) {
+            errors[dataAttribute.key] = {
+                name: dataAttribute.key,
+                message: "Invalid property"
+            }
+            return false;
         }
         return true;
     }
 
+    /**
+     * Validate only a field using the attribute key
+     * @param {string} key - The field key name you want to validate
+     * @returns {DataValidatorSuccessResponse | DataValidatorErrorResponse} - The response of your validation
+     */
+    async function validateField(key) {
+        const result = await inputValidation({key: key, value: data[key]}, data);
+        if (!result) {
+            return { error: true, errors: errors[key]}
+        }
+        return { ok: true}
+    }
+
+    /**
+     * Validate the entire fields using the schema
+     * @returns {DataValidatorSuccessResponse | DataValidatorErrorResponse} - The response of your validation
+     */
     async function validate() {
+        errors = {};
         let dataArr = Object.keys(data).map((key) => ({ key, value: data[key] }));
         if (dataArr && dataArr.length > 0) {
-            if(!Object.keys(dataRule).every((key) => data.hasOwnProperty(key))) {
+            if(!Object.keys(schema).every((key) => data.hasOwnProperty(key))) {
                 return { error: true, errorMessage: "Missing properties"}
             }
-            const dataValidators = await Promise.all([...dataArr].map(async (input) => await inputValidation(input, data)));
+            const dataValidators = options?.abortEarly ? await validateByStrategies.first(dataArr) : await validateByStrategies.all(dataArr);
 
             if (dataValidators.some((element) => !element)) {
-                return { error: true, dataErrors: dataErrors };
+                return { error: true, errors: errors };
             }
 
-            const dataRuleArr = Object.keys(dataRule).map((key) => ({ key, required: dataRule[key].required}));
+            const dataRuleArr = Object.keys(schema).map((key) => ({ key, required: schema[key].required}));
             const dataAttributesKey = dataArr.map((attribute) => attribute.key);
             const dataAttributesRequired = dataRuleArr.filter((rule) => rule.required).map((rule) => rule.key);
 
@@ -64,12 +115,16 @@ export function dataValidate(data, {validationHelpers = {}, rules, dataRule, dat
                 return { error: true };
             }
         } else if (!dataArr || dataArr.length === 0) {
-            return { error: true, errorMessage: "Missing fields for dataRules"}
+            return { error: true, errorMessage: "Missing fields for schema"}
         }
         return { ok: true };
     }
 
-    return validate();
+    function setData(newData) {
+        data = newData;
+    }
+
+    return {validate, validateField, setData};
 }
 
 /**

package/src/main.js

@@ -1,5 +1,5 @@
-import { dataValidate } from  './js/dataValidate.js';
+import { createValidator } from  './js/dataValidate.js';
 
 export {
-    dataValidate,
+    createValidator,
 }

package/src/types.js

@@ -6,15 +6,23 @@
 /**
  * @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
  */
 
 /**
  * @typedef {Object} DataValidatorConfigs
  * @property {ValidationHelpers} validationHelpers - The validator functions to help your validations
  * @property {Object} rules - The rules you want to use through validation
- * @property {dataRule} dataRule - The rules you want to use per field
- * @property {Object} dataErrorMessages - The error messages you want to show during errors
+ * @property {SchemaRule} schema - The rules you want to use per field
+ * @property {Object} errorMessages - The error messages you want to show during errors
+ * @property {ValidatorOptions} options - Options
+ */
+
+/**
+ * @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
  */
 
 /**
@@ -31,18 +39,19 @@
  */
 
 /**
- * @typedef {Object} DataRule
- * @property {dataRuleFiVeld} field - The field which will use the rule
+ * @typedef {Object} SchemaRule
+ * @property {SchemaRuleField} field - The field which will use the rule
  */
 
 /**
- * @typedef {Object} DataRuleField
+ * @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
  */
 
 /**
- * @typedef {Object.<string, DataRule>} DataRule - A dynamic object where the keys are field names and the values define the field rules.
+ * @typedef {Object.<string, SchemaRule>} SchemaRule - A dynamic object where the keys are field names and the values define the field rules.
  */
 
 /**
@@ -58,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)
  */