check-rule-mate 0.5.2 → 0.5.4

package/README.md

@@ -13,6 +13,7 @@ It is designed for scenarios where traditional schema-based validators start to
 - Async checks
 - Reusable validation logic across multiple forms
 - Full control over execution flow and error handling
+- Lifecycle Hooks
 
 
 **Github repository:** [check-rule-mate repository](https://github.com/johnrock16/check-rule-mate)
@@ -57,6 +58,7 @@ This separation makes the system flexible, scalable, and easy to maintain.
 - i18n-ready error messages
 - Framework-agnostic (frontend or backend)
 - Auto documentation (automatic generated by a CLI command)
+- Template checker (automatic checked by a CLI command)
 
 ## Table of Contents
 
@@ -66,7 +68,9 @@ This separation makes the system flexible, scalable, and easy to maintain.
   - [Running Tests](#Repository---Running-Tests)
 - [How It Works](#How-It-Works)
   - [Basic Usage](#Basic-Usage)
+  - [Lifecycle Hooks](#Lifecycle-Hooks)
   - [Auto documentation](#Auto-Documentation)
+  - [Auto Checker for Templates](#Auto-Checker-for-Templates)
 - [Defining Validation](#Defining-Validation)
   - [1. Schema](#Defining-a-Schema-What-to-validate)
   - [2. Rules](#Defining-Rules-How-to-validate)
@@ -167,18 +171,163 @@ When is **invalid** and **has errors**:
 }
 ```
 
+### Lifecycle Hooks
+The **check-rule-mate** lifecycle hooks allow you to observe, extend and react to the validation process without coupling logic to rules or helpers.
+
+Hooks are especially useful for:
+
+- Logging and debugging
+- Analytics and metrics
+- Custom side-effects
+- Integrating validation with UI or external systems
+- Advanced error handling and reporting
+- They provide fine-grained control over the validation lifecycle.
+
+```typescript
+hooks?: {
+  onValidateStart?: (payload) => void;
+  onValidateFieldStart?: (payload) => void;
+  onValidateFieldError?: (payload) => void;
+  onValidateFieldSuccess?: (payload) => void;
+  onValidateEnd?: (payload) => void;
+}
+```
+
+#### Hook Payloads
+
+##### `onValidateStart`
+Triggered once before validation begins.
+```typescript
+onValidateStart: ({ data }) => void
+```
+
+**Payload:**
+- `data`: Full form data object being validated
+
+##### `onValidateFieldStart`
+Triggered before validating each field.
+```typescript
+onValidateFieldStart: ({ field, value, schemaField }) => void
+```
+
+**Payload:**
+- `field`: Field name
+- `value`: Field value
+- `schemaField`: Schema configuration for the field (or `null` if missing)
+
+##### `onValidateFieldError`
+Triggered when a field fails validation.
+```typescript
+onValidateFieldError: ({ field, value, schemaField, error }) => void
+```
+
+**Payload:**
+- `field`: Field name
+- `value`: Field value
+- `schemaField`: Schema configuration for the field (or `null` if missing)
+- `error`: Validation error object
+
+##### `onValidateFieldSuccess`
+Triggered when a field is successfully validated.
+```typescript
+onValidateFieldSuccess: ({ field, value, schemaField }) => void
+```
+
+**Payload:**
+- `field`: Field name
+- `value`: Field value
+- `schemaField`: Schema configuration for the field (or `null` if missing)
+
+##### `onValidateEnd`
+Triggered once after validation finishes.
+```typescript
+onValidateEnd: ({ data, errors }) => void
+```
+
+**Payload:**
+- `data`: Full form data object being validated
+- `errors`: Validation errors (if any)
+If no errors occurred, `errors` may be `undefined`.
+
+#### Hooks -  Example Usage
+```javascript
+const validator = createValidator(fields, {
+  validationHelpers: myValidator,
+  rules: MY_RULES,
+  schema: CONTACT_US,
+  errorMessages: ERROR_MESSAGES,
+  hooks: {
+    onValidateStart: ({ data }) => {
+      console.log('Validation started', data);
+    },
+
+    onValidateFieldStart: ({ field, value }) => {
+      console.log(`Validating ${field}`, value);
+    },
+
+    onValidateFieldError: ({ field, error }) => {
+      console.error(`Error on ${field}`, error);
+    },
+
+    onValidateFieldSuccess: ({ field }) => {
+      console.log(`${field} validated successfully`);
+    },
+
+    onValidateEnd: ({ data, errors }) => {
+      if (errors) {
+        console.log('Validation finished with errors', errors);
+      } else {
+        console.log('Validation finished successfully');
+      }
+    }
+  }
+});
+
+await validator.validate();
+```
+
 ### Auto Documentation
 
-check-rule-mate contains a script to generate documentation based in your rules, schemas and error messages.
+**check-rule-mate** contains a script to generate **automatic documentation** based in your rules, schemas and error messages.
 
 To use that it is simple, you only need to run this command:
 
 ```bash
-npx generate-docs --rules rules-path --schemas schemas-path --errors errors-path --out file.html
+npx check-rule-mate-auto-docs --rules {rules path} --schemas {schemas path} --errors {errors path} --out file.html
 ```
 
 This will generate a HTML file containing the rules, schemas and errors.
 
+### Auto Checker for Templates
+You can **auto check** if your template it is working properly with all necessary properties or have something missing.
+
+It is works with: `Schemas`, `Rules` and `Errors`
+
+```bash
+npx check-rule-mate-verify-templates --rules {rules path} --schemas {schemas path} --errors {errors path}
+```
+
+If everything it is **working properly** this should be your message:
+```bash
+✔ Schemas loaded: 4
+✔ Rules loaded: 6
+✔ Errors loaded: 6
+
+✔ No issues found
+```
+
+Else if some error was found could be something like that:
+```bash
+✔ Schemas loaded: 4
+✔ Rules loaded: 6
+✔ Errors loaded: 6
+
+❌ Validation failed
+
+❌ Schema "contactUs.json" → field "phone" references rule "cellphone" which does not exist
+```
+
+
 ## Defining Validation
 
 ### Defining a Schema (What to validate)

package/bin/generate-docs.js

@@ -9,7 +9,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const process = require('process')
+const process = require('process');
 
 /* ---------------------------------------
  * CLI ARGS
@@ -28,7 +28,7 @@ const OUTPUT = getArg('--out') || "check-rule-mate-docs.html";
 if (!RULES_DIR || !SCHEMAS_DIR) {
   console.error(`
 Usage:
-node generate-docs.js --rules ./rules --schemas ./schemas --out docs.html
+npx check-rule-mate-auto-docs --rules ./rules --schemas ./schemas --errors ./errors --out docs.html
 `);
   process.exit(1);
 }

package/bin/verify-templates.js

@@ -0,0 +1,226 @@
+#!/usr/bin/env node
+
+// import fs from 'fs';
+// import path from 'path';
+// import process from 'process';
+
+const fs = require('fs');
+const path = require('path');
+const process = require('process');
+
+/**
+ * ---------------------------
+ * Utils
+ * ---------------------------
+ */
+
+function readJSONFilesFromDir(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    throw new Error(`Directory not found: ${dirPath}`);
+  }
+
+  const files = fs.readdirSync(dirPath).filter(f => f.endsWith('.json'));
+
+  const data = {};
+  for (const file of files) {
+    const fullPath = path.join(dirPath, file);
+    const content = JSON.parse(fs.readFileSync(fullPath, 'utf-8'));
+    data[file] = content;
+  }
+
+  return data;
+}
+
+function parseRuleName(ruleName) {
+  const [base, modifier] = ruleName.split('--');
+  return { base, modifier };
+}
+
+function error(msg) {
+  return { type: 'error', message: msg };
+}
+
+function warning(msg) {
+  return { type: 'warning', message: msg };
+}
+
+/**
+ * ---------------------------
+ * Core Validators
+ * ---------------------------
+ */
+
+function validateSchemas({ schemas, rules }) {
+  const issues = [];
+
+  for (const [schemaFile, schema] of Object.entries(schemas)) {
+    for (const [field, config] of Object.entries(schema)) {
+      if (!config.rule) continue;
+
+      const { base, modifier } = parseRuleName(config.rule);
+
+      if (!rules[base]) {
+        issues.push(
+          error(
+            `Schema "${schemaFile}" → field "${field}" references rule "${base}" which does not exist`
+          )
+        );
+        continue;
+      }
+
+      if (modifier) {
+        if (!rules[base].modifier || !rules[base].modifier[modifier]) {
+          issues.push(
+            error(
+              `Schema "${schemaFile}" → field "${field}" references modifier "${modifier}" on rule "${base}" which does not exist`
+            )
+          );
+        }
+      }
+    }
+  }
+
+  return issues;
+}
+
+function validateRuleErrors({ rules, errors }) {
+  const issues = [];
+
+  for (const [ruleName, rule] of Object.entries(rules)) {
+    const checkErrorMap = (errorMap, context) => {
+      if (!errorMap) return;
+
+      for (const errorKey of Object.values(errorMap)) {
+        const [namespace, key] = errorKey.split('.');
+        if (!errors[namespace] || !errors[namespace][key]) {
+          issues.push(
+            error(
+              `Rule "${ruleName}"${context} references error key "${errorKey}" which does not exist`
+            )
+          );
+        }
+      }
+    };
+
+    checkErrorMap(rule.error, '');
+
+    if (rule.modifier) {
+      for (const [modifierName, modifier] of Object.entries(rule.modifier)) {
+        checkErrorMap(modifier.error, ` (modifier "${modifierName}")`);
+      }
+    }
+  }
+
+  return issues;
+}
+
+function findUnusedErrors({ rules, errors }) {
+  const issues = [];
+  const usedErrors = new Set();
+
+  const collectErrors = errorMap => {
+    if (!errorMap) return;
+    Object.values(errorMap).forEach(e => usedErrors.add(e));
+  };
+
+  for (const rule of Object.values(rules)) {
+    collectErrors(rule.error);
+    if (rule.modifier) {
+      Object.values(rule.modifier).forEach(m => collectErrors(m.error));
+    }
+  }
+
+  for (const [namespace, keys] of Object.entries(errors)) {
+    for (const key of Object.keys(keys)) {
+      const fullKey = `${namespace}.${key}`;
+      if (!usedErrors.has(fullKey)) {
+        issues.push(
+          warning(`Unused error message detected: "${fullKey}"`)
+        );
+      }
+    }
+  }
+
+  return issues;
+}
+
+/**
+ * ---------------------------
+ * CLI Argument Parsing
+ * ---------------------------
+ */
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const options = {};
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i].startsWith('--')) {
+      const key = args[i].replace('--', '');
+      options[key] = args[i + 1];
+      i++;
+    }
+  }
+
+  return options;
+}
+
+/**
+ * ---------------------------
+ * Runner
+ * ---------------------------
+ */
+
+async function runVerify() {
+  try {
+    const args = parseArgs();
+
+    if (!args.schemas || !args.rules || !args.errors) {
+      console.error(
+        'Usage: check-rule-mate-verify-templates --schemas <path> --rules <path> --errors <path>'
+      );
+      process.exit(1);
+    }
+
+    const schemas = readJSONFilesFromDir(args.schemas);
+    const rulesRaw = readJSONFilesFromDir(args.rules);
+    const errorsRaw = readJSONFilesFromDir(args.errors);
+
+    // Merge all rule files into one object
+    const rules = Object.assign({}, ...Object.values(rulesRaw));
+    const errors = Object.assign({}, ...Object.values(errorsRaw));
+
+    let issues = [];
+
+    issues.push(...validateSchemas({ schemas, rules }));
+    issues.push(...validateRuleErrors({ rules, errors }));
+    issues.push(...findUnusedErrors({ rules, errors }));
+
+    const hasErrors = issues.some(i => i.type === 'error');
+
+    console.log('✔ Schemas loaded:', Object.keys(schemas).length);
+    console.log('✔ Rules loaded:', Object.keys(rules).length);
+    console.log('✔ Errors loaded:', Object.keys(errors).length);
+    console.log('');
+
+    if (issues.length === 0) {
+      console.log('✔ No issues found');
+      process.exit(0);
+    }
+
+    console.log(hasErrors ? '❌ Validation failed' : '⚠️ Validation warnings');
+    console.log('');
+
+    for (const issue of issues) {
+      const prefix = issue.type === 'error' ? '❌' : '⚠️';
+      console.log(`${prefix} ${issue.message}`);
+    }
+
+    process.exit(hasErrors ? 1 : 0);
+  } catch (err) {
+    console.error('Fatal error:', err.message);
+    process.exit(1);
+  }
+}
+
+runVerify();

package/dist/main.cjs.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "check-rule-mate",
-  "version": "0.5.2",
+  "version": "0.5.4",
   "description": "",
   "main": "./dist/main.cjs.js",
   "type": "commonjs",
@@ -18,7 +18,8 @@
     "check rule mate"
   ],
   "bin": {
-    "generate-docs": "./bin/generate-docs.js"
+    "check-rule-mate-auto-docs": "./bin/generate-docs.js",
+    "check-rule-mate-verify-templates": "./bin/verify-templates.js"
   },
   "scripts": {
     "start": "node ./examples/vanilla/src/index.js",

package/src/index.d.ts

@@ -86,6 +86,9 @@ export interface DataValidatorConfigs {
 
   /** Validator options */
   options: ValidatorOptions
+
+  /** Validator hooks */
+  hooks: ValidatorHooks
 }
 
 /**
@@ -100,9 +103,12 @@ export interface DataValidatorSuccessResponse {
  * Error object.
  */
 export interface CheckError {
-  /** Field name */
+  /** Error name */
   name: string
 
+  /** Field name */
+  field?: string
+
   /** Error path */
   code?: string
 
@@ -111,6 +117,9 @@ export interface CheckError {
 
   /** Error message */
   message?: string
+
+  /** Internal error flag */
+  internal?: boolean
 }
 
 /**
@@ -126,3 +135,94 @@ export interface DataValidatorErrorResponse {
   /** Additional error details */
   errors?: Record<string, CheckError>
 }
+
+export interface ValidatorHooks {
+  /** Executed before validation runs */
+  onValidateStart?: onValidateStart
+
+  /** Executed before validation runs for each field */
+  onValidateFieldStart?: onValidateFieldStart
+
+  /** Executed when validation fails for some field */
+  onValidateFieldError?: onValidateFieldError
+
+  /** Executed when validation has success for some field */
+  onValidateFieldSuccess?: onValidateFieldSuccess
+
+  /** Executed after validation runs */
+  onValidateEnd?: onValidateEnd
+}
+
+export interface onValidateStart {
+  /** Returns the payload of hook */
+  payload: onValidateStartPayload
+}
+
+export interface onValidateFieldStart {
+  /** Returns the payload of hook */
+  payload: onValidateFieldStartPayload
+}
+
+export interface onValidateFieldError {
+  /** Returns the payload of hook */
+  payload: onValidateFieldErrorPayload
+}
+
+export interface onValidateFieldSuccess {
+  /** Returns the payload of hook */
+  payload: onValidateFieldSuccessPayload
+}
+
+export interface onValidateEnd {
+  /** Returns the payload of hook */
+  payload: onValidateEndPayload
+}
+
+export interface onValidateStartPayload {
+  /** Form data object */
+  data: Object
+}
+
+export interface onValidateFieldStart {
+  /** Field name */
+  field: string
+
+  /** Field value */
+  value: any
+
+  /** Schema field */
+  schemaField: SchemaRuleField
+}
+
+export interface onValidateFieldError {
+  /** Field name */
+  field: string
+
+  /** Field value */
+  value: any
+
+  /** Schema field */
+  schemaField: SchemaRuleField
+
+  /** Field error */
+  error: CheckError
+}
+
+export interface onValidateFieldSuccess {
+  /** Field name */
+  field: string
+
+  /** Field value */
+  value: any
+
+  /** Schema field */
+  schemaField: SchemaRuleField
+}
+
+export interface onValidateEndPayload {
+  /** Form data object */
+  data: Object
+
+  /** Form errors  */
+  errors?: Record<string, CheckError>
+}

package/src/js/dataValidate.js

@@ -5,7 +5,7 @@ const DEFAUL_OPTIONS = { propertiesMustMatch: true, abortEarly: false, cache: tr
  * @param {[DataField]} data - All the data fields to be validate
  * @param {DataValidatorConfigs} config - The configs which will be followed during validation
  */
-export function createValidator(data, {validationHelpers = {}, rules, schema, errorMessages = {}, options = DEFAUL_OPTIONS}) {
+export function createValidator(data, {validationHelpers = {}, rules, schema, errorMessages = {}, hooks = {}, options = DEFAUL_OPTIONS}) {
     options = { ...DEFAUL_OPTIONS, ...options};
     data = data;
     let errors = {};
@@ -41,6 +41,7 @@ export function createValidator(data, {validationHelpers = {}, rules, schema, er
     }
 
     async function inputValidation(dataAttribute, data = null) {
+        hookTrigger('onValidateFieldStart', { field: dataAttribute.key, value: dataAttribute.value, schemaField: schema[dataAttribute.key] || null });
         if (schema[dataAttribute.key]) {
             const { rule, required } = schema[dataAttribute.key];
             const cacheEnabled = schema[dataAttribute.key]?.cache !== undefined ? schema[dataAttribute.key].cache : options.cache;
@@ -56,24 +57,36 @@ export function createValidator(data, {validationHelpers = {}, rules, schema, er
                     const dataAttributeValidation = dataAttributeValidator(dataAttribute.value, rules[INPUT_RULE], RULE_MODIFIER, validationHelpers, data);
                     const { isValid, errorMessage, errorType } = await dataAttributeValidation.validate();
                     if (!isValid) {
-                        errors[dataAttribute.key] = {
+                        const error = {
                             name: dataAttribute.key,
+                            field: dataAttribute.key,
                             code: errorMessage,
                             type: errorType,
                             message: getObjectValueByPath(errorMessages, errorMessage) || ''
-                        }
+                        };
+
+                        errors[dataAttribute.key] = error;
+                        hookTrigger('onValidateFieldError', { field: dataAttribute.key, value: dataAttribute.value, schemaField: schema[dataAttribute.key] , error: error });
+                    } else {
+                        hookTrigger('onValidateFieldSuccess', { field: dataAttribute.key, value: dataAttribute.value, schemaField: schema[dataAttribute.key] });
                     }
                     oldData[dataAttribute.key] = {isValid: isValid, value: data[dataAttribute.key]};
                     return isValid;
                 }
             }
         } else if (options.propertiesMustMatch) {
-            errors[dataAttribute.key] = {
+            const error = {
                 name: dataAttribute.key,
-                message: "Invalid property"
+                field: dataAttribute.key,
+                message: "Invalid property",
+                internal: true
             }
+
+            errors[dataAttribute.key] = error;
+            hookTrigger('onValidateFieldError', { field: dataAttribute.key, value: dataAttribute.value, error: error });
             return false;
         }
+        hookTrigger('onValidateFieldSuccess', { field: dataAttribute.key, value: dataAttribute.value });
         return true;
     }
 
@@ -95,15 +108,18 @@ export function createValidator(data, {validationHelpers = {}, rules, schema, er
      * @returns {DataValidatorSuccessResponse | DataValidatorErrorResponse} - The response of your validation
      */
     async function validate() {
+        hookTrigger('onValidateStart', { data });
         errors = {};
         let dataArr = Object.keys(data).map((key) => ({ key, value: data[key] }));
         if (dataArr && dataArr.length > 0) {
             if(!Object.keys(schema).every((key) => data.hasOwnProperty(key))) {
+                hookTrigger('onValidateEnd', { data, errors: [{name: 'internal: schema - missing properties' , message: 'Missing properties', internal: true}] });
                 return { error: true, errorMessage: "Missing properties"}
             }
             const dataValidators = options?.abortEarly ? await validateByStrategies.first(dataArr) : await validateByStrategies.all(dataArr);
 
             if (dataValidators.some((element) => !element)) {
+                hookTrigger('onValidateEnd', { data, errors: errors });
                 return { error: true, errors: errors };
             }
 
@@ -112,14 +128,27 @@ export function createValidator(data, {validationHelpers = {}, rules, schema, er
             const dataAttributesRequired = dataRuleArr.filter((rule) => rule.required).map((rule) => rule.key);
 
             if (!dataAttributesRequired.every((fieldRequired) => dataAttributesKey.includes(fieldRequired))) {
-                return { error: true };
+                const error = { error: true };
+
+                hookTrigger('onValidateEnd', { data, errors: [{name: 'internal: fields - required' , message: '', internal: true}] });
+                return error;
             }
         } else if (!dataArr || dataArr.length === 0) {
-            return { error: true, errorMessage: "Missing fields for schema"}
+            const error = { error: true, errorMessage: "Missing fields for schema"};
+
+            hookTrigger('onValidateEnd', { data, errors: [{name: 'internal: schema - missing fields' , message: error.errorMessage, internal: true}] });
+            return error;
         }
+        hookTrigger('onValidateEnd', { data });
         return { ok: true };
     }
 
+    function hookTrigger(hookName, parameters) {
+        if (hooks?.[hookName] && typeof hooks[hookName] === 'function') {
+            hooks[hookName]({...parameters});
+        }
+    }
+
     function setData(newData) {
         data = newData;
     }

package/src/types.js

@@ -16,6 +16,7 @@
  * @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
+ * @property {ValidatorHooks} hooks - The hooks you want to execute in some specific phase of validation
  */
 
 /**
@@ -74,8 +75,78 @@
  *  Error Object
  *
  * @typedef {Object} CheckError
- * @property {string} name - Field name
+ * @property {string} name - Error name
+ * @property {string} field - Field name (optional)
  * @property {string} code - Error path (optional)
  * @property {string} type - Error type (optional)
  * @property {string} message - Error message (optional)
+ * @property {boolean} internal - Flag to know if it is a internal error (optional)
+ */
+
+
+/**
+ * @typedef {Object} ValidatorHooks
+ * @property {onValidateStart} onValidateStart - Executed before validation runs
+ * @property {onValidateFieldStart} onValidateFieldStart - Executed before validation runs for each field
+ * @property {onValidateFieldError} onValidateFieldError - Executed when validation fails for some field
+ * @property {onValidateFieldSuccess} onValidateFieldSuccess - Executed when validation has success for some field
+ * @property {onValidateEnd} onValidateEnd - Executed after validation runs
+ */
+
+/**
+ * @typedef {Function} onValidateStart
+ * @property {onValidateStartPayload} payload - Returns the payload of validate form hook
+ */
+
+/**
+ * @typedef {Object} onValidateStartPayload
+ * @property {Object} data - Returns the form data
+ */
+
+/**
+ * @typedef {Function} onValidateFieldStart
+ * @property {onValidateFieldStartPayload} payload - Returns the payload of validate field hook
+ */
+
+/**
+ * @typedef {Object} onValidateFieldStartPayload
+ * @property {string} field - Returns the field name
+ * @property {any} value - Returns the value of field
+ * @property {SchemaRuleField} schemaField - Returns the schema field
+ */
+
+/**
+ * @typedef {Function} onValidateFieldError
+ * @property {onValidateFieldErrorPayload} payload - Returns the payload of validate field error hook
+ */
+
+/**
+ * @typedef {Object} onValidateFieldErrorPayload
+ * @property {string} field - Returns the field name
+ * @property {string} value - Returns the value of field
+ * @property {SchemaRuleField} schemaField - Returns the schema field
+ * @property {CheckError} error - Returns the error data
+ */
+
+/**
+ * @typedef {Function} onValidateFieldSuccess
+ * @property {onValidateFieldSuccessPayload} payload - Returns the payload of validate field success hook
+ */
+
+/**
+ * @typedef {Object} onValidateFieldSuccessPayload
+ * @property {string} field - Returns the field name
+ * @property {string} value - Returns the value of field
+ * @property {SchemaRuleField} schemaField - Returns the schema field
+ */
+
+/**
+ * @typedef {Function} onValidateEnd
+ * @property {onValidateEndPayload} payload - Returns the payload of validate form hook
+ */
+
+/**
+ * @typedef {Object} onValidateEndPayload
+ * @property {Object} data - Returns the form data
+ * @property {DataValidatorErrorResponse} errors - Returns the errors of validation if had
  */