perfect-payload 2.0.0-beta.3 → 2.0.0

package/README.md

@@ -1,29 +1,21 @@
 # perfect-payload
 
-A lightweight JavaScript library for validating, transforming, and
-sanitizing API and JSON payloads.
-
-`perfect-payload` provides structured validation errors, exact nested
-field paths, synchronous and asynchronous custom validation,
-transformations, nested object/array validation, unknown-field handling,
-and ready-to-use Express and Fastify integrations.
-
-The package is designed to stay simple and lightweight, with no Express
-or Fastify runtime dependency.
+A lightweight JavaScript library for validating, transforming, and sanitizing API and JSON payloads. `perfect-payload` provides structured validation errors, exact nested field paths, synchronous and asynchronous custom validation, transformations, nested object/array validation, unknown-field handling, and ready-to-use Express and Fastify integrations. The package is designed to stay simple and lightweight, with no Express or Fastify runtime dependency.
 
 ## Highlights
 
 - Lightweight, rule-based payload validation
+- TypeScript-first package with built-in declarations — no separate `@types/perfect-payload`
 - Structured errors with stable machine-readable error codes
-- Exact nested paths such as `profile.email` and
-  `products[1].quantity`
+- Exact nested paths such as `profile.email` and `products[1].quantity`
 - Recursive `objectAttr` and `elementConstraints` validation
 - Array constraints with `minItems` and `maxItems`
 - Built-in `trim`, `lowercase`, and `uppercase` transformations
 - Custom synchronous `transform(value, payload)`
+- Array-element transforms with `transform(value, index, payload)`
+- Deterministic validation precedence independent of rule-property order
 - Synchronous custom validators with `perfectPayload()`
-- Synchronous or asynchronous custom validators with
-  `perfectPayloadAsync()`
+- Synchronous or asynchronous custom validators with `perfectPayloadAsync()`
 - Configurable unknown-field handling: `strip`, `allow`, or `reject`
 - Optional simplified errors with `prettyErrors`
 - Express middleware integration
@@ -33,7 +25,7 @@ or Fastify runtime dependency.
 - Framework-aware error paths such as `body.email` and `params.userId`
 - Transformed values returned through `validatedPayload`
 - Original input payload/request data is not mutated
-- No Express or Fastify runtime dependency
+- Zero Express or Fastify runtime dependency
 - Legacy `perfectPayloadV1()` retained during the migration period
 
 ## Quick Links
@@ -41,38 +33,49 @@ or Fastify runtime dependency.
 - [Installation](#installation)
 - [Basic Usage](#basic-usage)
 - [Public API](#public-api)
+- [TypeScript](#typescript)
 - [Options](#options)
-- [Pretty Errors](#pretty-errors)
+- [Pretty Errors](#prettyerrors)
 - [Express Integration](#express-integration)
 - [Fastify Integration](#fastify-integration)
 - [Framework Request Validation](#framework-request-validation)
 - [Unknown Field Handling](#unknown-field-handling)
-- [Synchronous vs Asynchronous
-  Validation](#synchronous-vs-asynchronous-validation)
+- [Synchronous vs Asynchronous Validation](#synchronous-vs-asynchronous-validation)
 - [Validation Rules](#validation-rules)
-- [Array Size and Nested
-  Validation](#array-size-and-nested-validation)
-- [Transformations and
-  Sanitization](#transformations-and-sanitization)
+- [Validation Precedence](#validation-precedence)
+- [Array Size and Nested Validation](#array-size-and-nested-validation)
+- [Transformations and Sanitization](#transformations-and-sanitization)
 - [Custom Validators](#customvalidator)
 - [Asynchronous Validation](#asynchronous-validation)
 - [Error Codes](#error-codes)
 - [Custom Error Messages](#custom-error-messages)
-- [Nested Objects and Array Field
-  Paths](#nested-objects-and-array-field-paths)
+- [Nested Objects and Array Field Paths](#nested-objects-and-array-field-paths)
 - [Examples and Usage](#examples-and-usage)
 - [Legacy API](#legacy-api)
 
-## What's New in v1.8.0
+## What's New in v2.0.0
 
-v1.8.0 adds first-class framework integrations and simpler error output
-while keeping the core validation API framework-independent.
+v2.0.0 establishes the stable TypeScript-first architecture for `perfect-payload` while keeping the package lightweight and framework-independent.
 
-## Express Integration
+Major v2 additions and hardening include:
+
+- Built-in TypeScript declarations generated from the source — no separate `@types/perfect-payload` package.
+- Public validation types such as `ValidationRules` and `ValidationOptions`.
+- Structured validation errors with stable `path`, `code`, and `message` fields.
+- `prettyErrors` for consumers that prefer a simple string array.
+- Recursive unknown-field handling with `strip`, `allow`, and `reject`.
+- Exact nested and indexed paths across `objectAttr` and `elementConstraints`.
+- Synchronous transforms with a complete root-payload context.
+- Array-element transforms with `(value, index, payload)`.
+- Deterministic validation precedence that does not depend on the order in which rule properties are written.
+- `perfectPayloadAsync()` with async `customValidator` support and sync-error pruning.
+- Lightweight Express and Fastify adapters for `headers`, `params`, `query`, and `body`.
+- Framework-aware generated error paths/messages while preserving custom error messages exactly as configured.
+- Legacy `perfectPayloadV1()` retained during the migration period.
 
-`perfect-payload` provides a lightweight Express adapter so request validation can be added directly as middleware.
+## Express Integration
 
-Express is **not** installed as a dependency of `perfect-payload`.
+`perfect-payload` provides a lightweight Express adapter so request validation can be added directly as middleware. Express is **not** installed as a dependency of `perfect-payload`.
 
 ### Import
 
@@ -87,11 +90,8 @@ Use `validatePayload()` when your validation rules are synchronous.
 ```js
 import express from "express";
 import { validatePayload } from "perfect-payload/express";
-
 const app = express();
-
 app.use(express.json());
-
 const userRules = {
   email: {
     mandatory: true,
@@ -105,7 +105,6 @@ const userRules = {
     min: 18,
   },
 };
-
 app.post(
   "/users",
   validatePayload({
@@ -115,7 +114,6 @@ app.post(
   }),
   (req, res) => {
     const user = req.validatedPayload.body;
-
     res.json({
       message: "User created",
       user,
@@ -158,20 +156,17 @@ app.post(
           type: "string",
         },
       },
-
       params: {
         userId: {
           mandatory: true,
           type: "string",
         },
       },
-
       query: {
         notify: {
           type: "boolean",
         },
       },
-
       body: {
         email: {
           mandatory: true,
@@ -184,7 +179,6 @@ app.post(
   }),
   (req, res) => {
     const { headers, params, query, body } = req.validatedPayload;
-
     res.json({
       headers,
       params,
@@ -212,13 +206,13 @@ Structured error paths include the request source:
     {
       path: "body.email",
       code: "INVALID_EMAIL",
-      message: "Invalid email format for attribute email"
+      message: "Invalid email format for attribute body.email"
     }
   ]
 }
 ```
 
-The request source is added to the structured `path`, while the validation message itself is preserved.
+For framework-generated default errors, the request source is part of the generated field path/message. Custom messages such as `mandatoryError`, `typeError`, `regexError`, and `customValidatorError` are returned exactly as configured and are not prefixed or rewritten by the adapter.
 
 ### Adapter Options
 
@@ -247,7 +241,6 @@ Use `validatePayloadAsync()` when the schema contains asynchronous `customValida
 
 ```js
 import { validatePayloadAsync } from "perfect-payload/express";
-
 app.post(
   "/users",
   validatePayloadAsync({
@@ -257,11 +250,9 @@ app.post(
           mandatory: true,
           type: "string",
           trim: true,
-
           customValidator: async (value) => {
             return await isUsernameAvailable(value);
           },
-
           customValidatorCode: "USERNAME_TAKEN",
           customValidatorError: "Username is already taken",
         },
@@ -283,9 +274,7 @@ Validation failures are handled by the middleware automatically. Unexpected erro
 
 ## Fastify Integration
 
-`perfect-payload` provides a lightweight Fastify adapter that can be used directly as a route hook.
-
-Fastify is **not** installed as a dependency of `perfect-payload`.
+`perfect-payload` provides a lightweight Fastify adapter that can be used directly as a route hook. Fastify is **not** installed as a dependency of `perfect-payload`.
 
 ### Import
 
@@ -300,9 +289,7 @@ Use the adapter as a Fastify `preValidation` hook:
 ```js
 import Fastify from "fastify";
 import { validatePayload } from "perfect-payload/fastify";
-
 const fastify = Fastify();
-
 const userRules = {
   email: {
     mandatory: true,
@@ -316,7 +303,6 @@ const userRules = {
     min: 18,
   },
 };
-
 fastify.post(
   "/users",
   {
@@ -328,7 +314,6 @@ fastify.post(
   },
   async (request, reply) => {
     const user = request.validatedPayload.body;
-
     return {
       message: "User created",
       user,
@@ -372,20 +357,17 @@ fastify.post(
             type: "string",
           },
         },
-
         params: {
           userId: {
             mandatory: true,
             type: "string",
           },
         },
-
         query: {
           notify: {
             type: "boolean",
           },
         },
-
         body: {
           email: {
             mandatory: true,
@@ -399,7 +381,6 @@ fastify.post(
   },
   async (request, reply) => {
     const { headers, params, query, body } = request.validatedPayload;
-
     return {
       headers,
       params,
@@ -427,13 +408,13 @@ Structured error paths include the request source:
     {
       path: "body.email",
       code: "INVALID_EMAIL",
-      message: "Invalid email format for attribute email"
+      message: "Invalid email format for attribute body.email"
     }
   ]
 }
 ```
 
-The request source is added to the structured `path`, while the validation message itself is preserved.
+For framework-generated default errors, the request source is part of the generated field path/message. Custom messages such as `mandatoryError`, `typeError`, `regexError`, and `customValidatorError` are returned exactly as configured and are not prefixed or rewritten by the adapter.
 
 ### Adapter Options
 
@@ -462,7 +443,6 @@ Use `validatePayloadAsync()` when the schema contains asynchronous `customValida
 
 ```js
 import { validatePayloadAsync } from "perfect-payload/fastify";
-
 fastify.post(
   "/users",
   {
@@ -473,11 +453,9 @@ fastify.post(
             mandatory: true,
             type: "string",
             trim: true,
-
             customValidator: async (value) => {
               return await isUsernameAvailable(value);
             },
-
             customValidatorCode: "USERNAME_TAKEN",
             customValidatorError: "Username is already taken",
           },
@@ -500,24 +478,48 @@ Validation failures are handled by the hook automatically. Unexpected errors fro
 
 ### Framework-aware error paths
 
-Structured validation errors include the request source in their path:
+Structured framework validation errors include the request source:
 
 ```js
 {
   path: "body.email",
   code: "INVALID_EMAIL",
-  message: "Invalid email format for attribute email"
+  message: "Invalid email format for attribute body.email"
 }
 ```
 
-The `path` identifies the exact request source and field. Custom and
-default validation messages are preserved rather than rewritten by the
-framework adapter.
+Generated default errors use source-aware paths such as:
+
+```text
+headers.x-request-id
+params.userId
+query.page
+body.email
+```
+
+A generated pretty error can therefore look like:
+
+```text
+Custom validation failed for attribute headers.x-test-id
+```
+
+Custom developer-defined messages are preserved exactly. For example:
+
+```js
+customValidatorError: "Invalid x-request-id in headers";
+```
+
+returns:
+
+```text
+Invalid x-request-id in headers
+```
+
+The framework adapter does not prepend `headers.`, `params.`, `query.`, or `body.` to a custom message.
 
 ### `prettyErrors`
 
-v1.8.0 introduces the `prettyErrors` option. Structured errors remain
-the default.
+`prettyErrors` provides a simplified string-error mode. Structured errors remain the default.
 
 ```js
 const result = perfectPayload(payload, rules, {
@@ -525,26 +527,16 @@ const result = perfectPayload(payload, rules, {
 });
 ```
 
-With `prettyErrors: true`, the `errors` array contains human-readable
-message strings instead of structured error objects.
-
-`prettyErrors` is also supported by `perfectPayloadAsync()` and the
-Express/Fastify integrations.
+With `prettyErrors: true`, the `errors` array contains human-readable message strings instead of structured error objects. `prettyErrors` is also supported by `perfectPayloadAsync()` and the Express/Fastify integrations.
 
 ### Error privacy
 
-Default validation messages do not include submitted payload values.
-
-Schema constraints such as allowed enum values, minimums, maximums, and
-ranges may still appear in validation messages. Custom error messages
-are controlled by the application and are returned as configured.
+Default validation messages do not include submitted payload values. Schema constraints such as allowed enum values, minimums, maximums, and ranges may still appear in validation messages. Custom error messages are controlled by the application and are returned as configured.
 
 ### Lightweight framework integrations
 
-Express and Fastify are **not installed as dependencies of
-`perfect-payload`**.
+Express and Fastify are **not installed as dependencies of `perfect-payload`**. The framework integrations are thin adapters around the same validation
 
-The framework integrations are thin adapters around the same validation
 engine used by:
 
 ```js
@@ -552,13 +544,11 @@ perfectPayload();
 perfectPayloadAsync();
 ```
 
-This keeps the package lightweight while allowing framework users to
-integrate validation without writing their own middleware or hooks.
+This keeps the package lightweight while allowing framework users to integrate validation without writing their own middleware or hooks.
 
 ## Installation
 
 ```bash
-
 npm install perfect-payload
 ```
 
@@ -568,117 +558,75 @@ Use `perfectPayload()` for all new implementations.
 
 ```js
 import { perfectPayload } from "perfect-payload";
-
 const payload = {
   name: "Kiran",
-
   email: "kiran@example.com",
-
   age: 29,
 };
-
 const validationRules = {
   name: {
     mandatory: true,
-
     type: "string",
   },
-
   email: {
     mandatory: true,
-
     type: "email",
   },
-
   age: {
     mandatory: true,
-
     type: "number",
-
     min: 18,
   },
 };
-
 const result = perfectPayload(payload, validationRules);
-
 console.log(result);
 ```
 
 ### Valid Response
 
 ```js
-
 {
-
   statusCode: 200,
-
   valid: true,
-
   validatedPayload: {
-
     name: "Kiran",
-
     email: "kiran@example.com",
-
     age: 29
-
   }
-
 }
 ```
 
-By default, `validatedPayload` contains only fields defined in the validation schema. Extra payload fields are stripped unless `unknownFields` is explicitly configured as `"allow"` or `"reject"`.
-
-The original input payload is not mutated. (such as validatedBody, sanitisedData or parsedBody).
+By default, `validatedPayload` contains only fields defined in the validation schema. Extra payload fields are stripped unless `unknownFields` is explicitly configured as `"allow"` or `"reject"`. The original input payload is not mutated. (such as validatedBody, sanitisedData or parsedBody).
 
 ### Invalid Response
 
 ```js
-
 {
-
   statusCode: 400,
-
   valid: false,
-
   message: "One or more attribute values are invalid",
-
   errors: [
-
     {
-
       path: "email",
-
       code: "INVALID_EMAIL",
-
       message: "Invalid email format for attribute email"
-
     }
-
   ]
-
 }
 ```
 
 Each error returned by `perfectPayload()` contains:
 
 ```js
-
 {
-
   path: "field.path",
-
   code: "ERROR_CODE",
-
   message: "Human readable validation message"
-
 }
 ```
 
 - `path` identifies the exact field that failed validation.
-
 - `code` provides a stable machine-readable validation error code.
-
 - `message` provides a human-readable description of the validation
 
 failure.
@@ -687,12 +635,10 @@ failure.
 
 ## Public API
 
-For new implementations, both supported APIs use the same clean three-argument signature:
+For v2 and all new implementations, both supported APIs use the same clean three-argument signature:
 
 ```js
-
 perfectPayload(data, validationRules, options?)
-
 await perfectPayloadAsync(data, validationRules, options?)
 ```
 
@@ -700,67 +646,99 @@ The arguments are:
 
 | Argument          | Required | Description                                                                         |
 | ----------------- | -------- | ----------------------------------------------------------------------------------- |
-| `data`            | No       | Payload/object to validate. Defaults to `{}`.                                       |
-| `validationRules` | No       | Validation schema. Defaults to `{}`.                                                |
+| `data`            | No       | Payload/object to validate. Defaults to`{}`.                                        |
+| `validationRules` | No       | Validation schema. Defaults to`{}`.                                                 |
 | `options`         | No       | API-level configuration such as unknown-field handling and custom response objects. |
 
-The third argument is a single options object. You no longer need to pass separate positional arguments for custom valid and invalid responses.
-
-### Options
-
-```js
-
-{
+The third argument is a single options object. You no longer need to pass separate positional arguments for custom valid and invalid responses. In TypeScript, this object is typed as `ValidationOptions`.
 
-  unknownFields: "strip" | "allow" | "reject",
+### TypeScript
 
-  validPayloadResponse: {
+`perfect-payload` ships its TypeScript declarations with the package. No separate `@types/perfect-payload` installation is required.
 
-    statusCode: 200,
+```ts
+import { perfectPayload, perfectPayloadAsync } from "perfect-payload";
+import type {
+  ValidationOptions,
+  ValidationRules,
+  AttributeValidationRules,
+  ValidationValueType,
+  TransformFunction,
+  ArrayElementTransformFunction,
+  CustomValidator,
+  DependencyRule,
+  DependencyRules,
+} from "perfect-payload";
+```
 
-    valid: true,
+Example:
 
+```ts
+const rules: ValidationRules = {
+  email: {
+    mandatory: true,
+    type: "email",
+    trim: true,
+    lowercase: true,
   },
+};
+const options: ValidationOptions = {
+  unknownFields: "reject",
+  prettyErrors: false,
+};
+const result = perfectPayload(
+  {
+    email: "  KIRAN@EXAMPLE.COM  ",
+  },
+  rules,
+  options,
+);
+if (result.valid === true) {
+  console.log(result.validatedPayload);
+} else {
+  console.log(result.errors);
+}
+```
 
-  inValidPayloadResponse: {
-
-    statusCode: 400,
-
-    valid: false,
+`prettyErrors: true` changes the error collection to strings, while the default structured mode returns objects containing `path`, `code`, and `message`. The runtime package remains the same for JavaScript and TypeScript consumers.
 
-    message: "One or more attribute values are invalid",
+### Options
 
-  },
+The third argument uses the `ValidationOptions` type in TypeScript.
 
+```ts
+interface ValidationOptions {
+  unknownFields?: "strip" | "allow" | "reject";
+  prettyErrors?: boolean;
+  validPayloadResponse?: {
+    statusCode: number;
+    valid: true;
+    [key: string]: unknown;
+  };
+  inValidPayloadResponse?: {
+    statusCode: number;
+    valid: false;
+    message: string;
+    [key: string]: unknown;
+  };
 }
 ```
 
 All properties are optional. The defaults are equivalent to:
 
 ```js
-
 {
-
   unknownFields: "strip",
-
+  prettyErrors: false,
   validPayloadResponse: {
-
     statusCode: 200,
-
     valid: true,
-
   },
-
   inValidPayloadResponse: {
-
     statusCode: 400,
-
     valid: false,
-
     message: "One or more attribute values are invalid",
-
   },
-
 }
 ```
 
@@ -769,20 +747,15 @@ Example:
 ```js
 const result = perfectPayload(payload, validationRules, {
   unknownFields: "reject",
-
+  prettyErrors: false,
   validPayloadResponse: {
     statusCode: 201,
-
     valid: true,
-
     message: "Payload accepted",
   },
-
   inValidPayloadResponse: {
     statusCode: 422,
-
     valid: false,
-
     message: "Payload validation failed",
   },
 });
@@ -793,12 +766,10 @@ The same options object is supported by `perfectPayloadAsync()`:
 ```js
 const result = await perfectPayloadAsync(payload, validationRules, {
   unknownFields: "reject",
-
+  prettyErrors: false,
   inValidPayloadResponse: {
     statusCode: 422,
-
     valid: false,
-
     message: "Payload validation failed",
   },
 });
@@ -810,46 +781,36 @@ const result = await perfectPayloadAsync(payload, validationRules, {
 
 Supported values:
 
-| Value      | Behavior                                                                                                 |
-| ---------- | -------------------------------------------------------------------------------------------------------- |
-| `"strip"`  | Removes unknown fields from `validatedPayload`. This is the default and preserves the existing behavior. |
-| `"allow"`  | Preserves unknown fields in `validatedPayload`.                                                          |
-| `"reject"` | Rejects unknown fields with structured `UNKNOWN_FIELD` validation errors.                                |
+| Value      | Behavior                                                                                                |
+| ---------- | ------------------------------------------------------------------------------------------------------- |
+| `"strip"`  | Removes unknown fields from`validatedPayload`. This is the default and preserves the existing behavior. |
+| `"allow"`  | Preserves unknown fields in`validatedPayload`.                                                          |
+| `"reject"` | Rejects unknown fields with structured`UNKNOWN_FIELD` validation errors.                                |
 
 ### `strip` — default
 
 ```js
 const payload = {
   name: "Kiran",
-
   role: "developer",
 };
-
 const rules = {
   name: {
     type: "string",
   },
 };
-
 const result = perfectPayload(payload, rules);
 ```
 
 Result:
 
 ```js
-
 {
-
   statusCode: 200,
-
   valid: true,
-
   validatedPayload: {
-
     name: "Kiran"
-
   }
-
 }
 ```
 
@@ -863,7 +824,7 @@ perfectPayload(payload, rules, {
 });
 ```
 
-### `allow` --- preserve unknown fields
+### `allow` — preserve unknown fields
 
 ```js
 const result = perfectPayload(payload, rules, {
@@ -874,29 +835,19 @@ const result = perfectPayload(payload, rules, {
 Result:
 
 ```js
-
 {
-
   statusCode: 200,
-
   valid: true,
-
   validatedPayload: {
-
     name: "Kiran",
-
     role: "developer"
-
   }
-
 }
 ```
 
-Schema-defined fields are still validated normally. Unknown fields are
-
-simply preserved.
+Schema-defined fields are still validated normally. Unknown fields are simply preserved.
 
-### `reject` --- reject unknown fields
+### `reject` — reject unknown fields
 
 ```js
 const result = perfectPayload(payload, rules, {
@@ -907,29 +858,17 @@ const result = perfectPayload(payload, rules, {
 Result:
 
 ```js
-
 {
-
   statusCode: 400,
-
   valid: false,
-
   message: "One or more attribute values are invalid",
-
   errors: [
-
     {
-
       path: "role",
-
       code: "UNKNOWN_FIELD",
-
       message: "Unknown field role is not allowed"
-
     }
-
   ]
-
 }
 ```
 
@@ -943,15 +882,12 @@ Unknown-field handling is recursive for schemas using `objectAttr`.
 const payload = {
   profile: {
     city: "Bengaluru",
-
     role: "developer",
   },
 };
-
 const rules = {
   profile: {
     type: "object",
-
     objectAttr: {
       city: {
         type: "string",
@@ -959,7 +895,6 @@ const rules = {
     },
   },
 };
-
 const result = perfectPayload(payload, rules, {
   unknownFields: "reject",
 });
@@ -968,29 +903,17 @@ const result = perfectPayload(payload, rules, {
 Returns:
 
 ```js
-
 {
-
   statusCode: 400,
-
   valid: false,
-
   message: "One or more attribute values are invalid",
-
   errors: [
-
     {
-
       path: "profile.role",
-
       code: "UNKNOWN_FIELD",
-
       message: "Unknown field profile.role is not allowed"
-
     }
-
   ]
-
 }
 ```
 
@@ -1001,15 +924,10 @@ Returns:
 the array index:
 
 ```js
-
 {
-
   path: "products[0].internalId",
-
   code: "UNKNOWN_FIELD",
-
   message: "Unknown field products[0].internalId is not allowed"
-
 }
 ```
 
@@ -1018,7 +936,6 @@ This continues through deeply nested combinations of objects and arrays,
 for example:
 
 ```text
-
 profile.teams[0].members[0].role
 ```
 
@@ -1029,49 +946,27 @@ With `"reject"`, unknown-field errors can be returned together with normal valid
 For example, an invalid email plus two unknown fields can produce:
 
 ```js
-
 {
-
   statusCode: 400,
-
   valid: false,
-
   message: "One or more attribute values are invalid",
-
   errors: [
-
     {
-
       path: "email",
-
       code: "INVALID_EMAIL",
-
       message: "Invalid email format for attribute email"
-
     },
-
     {
-
       path: "role",
-
       code: "UNKNOWN_FIELD",
-
       message: "Unknown field role is not allowed"
-
     },
-
     {
-
       path: "active",
-
       code: "UNKNOWN_FIELD",
-
       message: "Unknown field active is not allowed"
-
     }
-
   ]
-
 }
 ```
 
@@ -1098,18 +993,14 @@ Unknown-field handling considers only the payload object's own enumerable proper
 Only these values are accepted:
 
 ```text
-
 strip
-
 allow
-
 reject
 ```
 
 Any other value throws a configuration error:
 
 ```text
-
 perfect-payload:- unknownFields must be one of strip, allow, reject
 ```
 
@@ -1121,7 +1012,6 @@ For normal synchronous validation, use `perfectPayload()`:
 
 ```js
 import { perfectPayload } from "perfect-payload";
-
 const result = perfectPayload(payload, validationRules, options);
 ```
 
@@ -1129,50 +1019,29 @@ When any `customValidator` needs to perform asynchronous work, use `perfectPaylo
 
 ```js
 import { perfectPayloadAsync } from "perfect-payload";
-
-const result = await perfectPayloadAsync(
-  payload,
-  validationRules,
-
-  options,
-);
+const result = await perfectPayloadAsync(payload, validationRules, options);
 ```
 
 The public APIs are:
 
 ```text
-
 perfectPayloadV1()                            legacy API; deprecated
-
 perfectPayload(data, rules, options?)         synchronous validation
-
 perfectPayloadAsync(data, rules, options?)    synchronous + asynchronous
-
 customValidator
 ```
 
-`perfectPayload()` remains synchronous and intentionally rejects a `customValidator` that returns a Promise. This preserves the existing synchronous API contract.
-
-`perfectPayloadAsync()` first performs transformations and normal synchronous validation. If synchronous validation fails, the result is returned immediately and asynchronous validators are not executed. This avoids unnecessary asynchronous work for payloads that are already invalid.
+`perfectPayload()` remains synchronous and intentionally rejects a `customValidator` that returns a Promise. This preserves the existing synchronous API contract. `perfectPayloadAsync()` first performs transformations and normal synchronous validation. If synchronous validation fails, the result is returned immediately and asynchronous validators are not executed. This avoids unnecessary asynchronous work for payloads that are already invalid.
 
 ```text
-
 transformations
-
       ↓
-
 synchronous validation
-
       ↓
-
 sync errors? ── yes ──→ return validation errors
-
       ↓ no
-
 async customValidator
-
       ↓
-
 return result
 ```
 
@@ -1184,25 +1053,17 @@ return result
 import { perfectPayloadV1 } from "perfect-payload";
 ```
 
-`perfectPayloadV1()` is deprecated and will no longer be supported
-
-after
-
-March 31, 2027.
-
-Existing applications can continue using it during the migration period,
+`perfectPayloadV1()` is deprecated and will no longer be supported after March 31, 2027. Existing applications can continue using it during the migration period,
 
 but all new implementations should use the current API:
 
 ```js
-
 perfectPayload(data, validationRules, options?);
 ```
 
 For asynchronous custom validation:
 
 ```js
-
 await perfectPayloadAsync(data, validationRules, options?);
 ```
 
@@ -1218,9 +1079,7 @@ while the new `perfectPayload()` API returns structured errors:
 errors: [
   {
     path: "email",
-
     code: "INVALID_EMAIL",
-
     message: "Invalid email format for attribute email",
   },
 ];
@@ -1234,9 +1093,7 @@ Note: If an inValidPayloadResponse is provided in the options, the system return
 
 ### `mandatory`
 
-Marks a field as required. An empty string is also treated as missing.
-
-Default: `false`, the field is not required.
+Marks a field as required. An empty string is also treated as missing. Default: `false`, the field is not required.
 
 ```js
 const rules = {
@@ -1246,15 +1103,11 @@ const rules = {
 };
 ```
 
-Error code: `REQUIRED`
-
----
+## Error code: `REQUIRED`
 
 ### `allowNull`
 
-Controls whether `null` values are accepted.
-
-Default: `true`, `null` values are allowed.
+Controls whether `null` values are accepted. Default: `true`, `null` values are allowed.
 
 Example:
 
@@ -1266,15 +1119,11 @@ const rules = {
 };
 ```
 
-Error code: `NULL_NOT_ALLOWED`
-
----
+## Error code: `NULL_NOT_ALLOWED`
 
 ### `allowEmptyObject`
 
-Controls whether an empty object `{}` is accepted.
-
-Default: `true`, empty objects are allowed.
+Controls whether an empty object `{}` is accepted. Default: `true`, empty objects are allowed.
 
 Example:
 
@@ -1282,21 +1131,16 @@ Example:
 const rules = {
   address: {
     type: "object",
-
     allowEmptyObject: false,
   },
 };
 ```
 
-Error code: `EMPTY_OBJECT_NOT_ALLOWED`
-
----
+## Error code: `EMPTY_OBJECT_NOT_ALLOWED`
 
 ### `allowEmptyArray`
 
-Controls whether an empty array `[]` is accepted.
-
-Default: `true`, empty arrays are allowed.
+Controls whether an empty array `[]` is accepted. Default: `true`, empty arrays are allowed.
 
 Example:
 
@@ -1304,27 +1148,21 @@ Example:
 const rules = {
   products: {
     type: "array",
-
     allowEmptyArray: false,
   },
 };
 ```
 
-Error code: `EMPTY_ARRAY_NOT_ALLOWED`
-
----
+## Error code: `EMPTY_ARRAY_NOT_ALLOWED`
 
 ### `minItems`
 
-Defines the minimum number of items required in an array.
-
-Default: `Not applied when omitted.`
+Defines the minimum number of items required in an array. Default: `Not applied when omitted.`
 
 ```js
 const rules = {
   tags: {
     type: "array",
-
     minItems: 2,
   },
 };
@@ -1333,37 +1171,23 @@ const rules = {
 An array with fewer than 2 items returns `MIN_ITEMS`.
 
 ```js
-
 {
-
   path: "tags",
-
   code: "MIN_ITEMS",
-
   message: "Attribute tags must contain at least 2 item(s)"
-
 }
 ```
 
-`minItems` is enforced even when `allowEmptyArray: true` is set. For
-
-example, `minItems: 2` still rejects `[]`.
-
-Error code: `MIN_ITEMS`
-
----
+## `minItems` is enforced even when `allowEmptyArray: true` is set. For example, `minItems: 2` still rejects `[]`. Error code: `MIN_ITEMS`
 
 ### `maxItems`
 
-Defines the maximum number of items allowed in an array.
-
-Default: `Not applied when omitted`.
+Defines the maximum number of items allowed in an array. Default: `Not applied when omitted`.
 
 ```js
 const rules = {
   tags: {
     type: "array",
-
     maxItems: 5,
   },
 };
@@ -1372,23 +1196,14 @@ const rules = {
 An array with more than 5 items returns `MAX_ITEMS`.
 
 ```js
-
 {
-
   path: "tags",
-
   code: "MAX_ITEMS",
-
   message: "Attribute tags must contain at most 5 item(s)"
-
 }
 ```
 
-`minItems` and `maxItems` can be used together.
-
-Error code: `MAX_ITEMS`
-
----
+## `minItems` and `maxItems` can be used together. Error code: `MAX_ITEMS`
 
 ### `type`
 
@@ -1397,33 +1212,19 @@ Validates the expected data type.
 Supported values:
 
 ```text
-
 number
-
 string
-
 boolean
-
 email
-
 url
-
 enum
-
 uuid
-
 uuidv1
-
 uuidv3
-
 uuidv4
-
 uuidv5
-
 objectId
-
 array
-
 object
 ```
 
@@ -1434,11 +1235,9 @@ const rules = {
   age: {
     type: "number",
   },
-
   email: {
     type: "email",
   },
-
   active: {
     type: "boolean",
   },
@@ -1459,7 +1258,6 @@ Example:
 const rules = {
   status: {
     type: "enum",
-
     enumValues: ["active", "inactive", "blocked", 1, 0],
   },
 };
@@ -1479,7 +1277,6 @@ Example:
 const rules = {
   status: {
     type: "enum",
-
     enumValues: ["active", "inactive", "blocked"],
   },
 };
@@ -1490,37 +1287,23 @@ Error code: `INVALID_ENUM`
 Possible error codes for types:
 
 ```text
-
 INVALID_TYPE
-
 INVALID_EMAIL
-
 INVALID_URL
-
 INVALID_ENUM
-
 INVALID_UUID
-
 INVALID_UUID_V1
-
 INVALID_UUID_V3
-
 INVALID_UUID_V4
-
 INVALID_UUID_V5
-
 INVALID_OBJECT_ID
 ```
 
-For `type: "number"`, `NaN` is rejected as `INVALID_TYPE`.
-
----
+## For `type: "number"`, `NaN` is rejected as `INVALID_TYPE`.
 
 ### `regex`
 
-Validates a value using a regular expression.
-
-Default: `Not applied when omitted.`
+Validates a value using a regular expression. Default: `Not applied when omitted.`
 
 Example:
 
@@ -1528,21 +1311,16 @@ Example:
 const rules = {
   employeeCode: {
     type: "string",
-
     regex: /[^1]{3}[0-9]{3}$/,
   },
 };
 ```
 
-Error code: `REGEX_MISMATCH`
-
----
+## Error code: `REGEX_MISMATCH`
 
 ### `minLength`
 
-Defines the minimum allowed string length.
-
-Default: `Not applied when omitted.`
+Defines the minimum allowed string length. Default: `Not applied when omitted.`
 
 Example:
 
@@ -1550,21 +1328,16 @@ Example:
 const rules = {
   username: {
     type: "string",
-
     minLength: 5,
   },
 };
 ```
 
-Error code: `MIN_LENGTH`
-
----
+## Error code: `MIN_LENGTH`
 
 ### `maxLength`
 
-Defines the maximum allowed string length.
-
-Default: `Not applied when omitted.`
+Defines the maximum allowed string length. Default: `Not applied when omitted.`
 
 Example:
 
@@ -1572,21 +1345,16 @@ Example:
 const rules = {
   username: {
     type: "string",
-
     maxLength: 20,
   },
 };
 ```
 
-Error code: `MAX_LENGTH`
-
----
+## Error code: `MAX_LENGTH`
 
 ### `preventDecimal`
 
-Prevents decimal numbers.
-
-Default: `false`; both integer and decimal numbers are allowed.
+Prevents decimal numbers. Default: `false`; both integer and decimal numbers are allowed.
 
 Example:
 
@@ -1594,21 +1362,16 @@ Example:
 const rules = {
   quantity: {
     type: "number",
-
     preventDecimal: true,
   },
 };
 ```
 
-Error code: `DECIMAL_NOT_ALLOWED`
-
----
+## Error code: `DECIMAL_NOT_ALLOWED`
 
 ### `min`
 
-Defines the minimum allowed numeric value.
-
-Default: `Not applied when omitted.`
+Defines the minimum allowed numeric value. Default: `Not applied when omitted.`
 
 Example:
 
@@ -1616,21 +1379,16 @@ Example:
 const rules = {
   age: {
     type: "number",
-
     min: 18,
   },
 };
 ```
 
-Error code: `MIN_VALUE`
-
----
+## Error code: `MIN_VALUE`
 
 ### `max`
 
-Defines the maximum allowed numeric value.
-
-Default: `Not applied when omitted.`
+Defines the maximum allowed numeric value. Default: `Not applied when omitted.`
 
 Example:
 
@@ -1638,21 +1396,16 @@ Example:
 const rules = {
   quantity: {
     type: "number",
-
     max: 100,
   },
 };
 ```
 
-Error code: `MAX_VALUE`
-
----
+## Error code: `MAX_VALUE`
 
 ### `range`
 
-Defines the allowed numeric range.
-
-Default: `Not applied when omitted.`
+Defines the allowed numeric range. Default: `Not applied when omitted.`
 
 Example:
 
@@ -1660,15 +1413,12 @@ Example:
 const rules = {
   marks: {
     type: "number",
-
     range: "0-100",
   },
 };
 ```
 
-Error code: `OUT_OF_RANGE`
-
----
+## Error code: `OUT_OF_RANGE`
 
 ### `elementConstraints`
 
@@ -1680,10 +1430,8 @@ Example:
 const rules = {
   marks: {
     type: "array",
-
     elementConstraints: {
       type: "number",
-
       range: "0-100",
     },
   },
@@ -1693,23 +1441,36 @@ const rules = {
 Example error:
 
 ```js
-
 {
-
   path: "marks[2]",
-
   code: "OUT_OF_RANGE",
+  message: "Attribute marks[2] should have a value between 0 and 100"
+}
+```
 
-  message:
-
-    "Attribute marks[2] should have a value between 0 and 100"
+Array-element transformations receive three arguments:
 
-}
+```js
+const rules = {
+  tags: {
+    type: "array",
+    elementConstraints: {
+      transform: (value, index, payload) => {
+        return String(value).trim().toLowerCase();
+      },
+      type: "string",
+    },
+  },
+};
 ```
 
-When `elementConstraintsError` is explicitly provided, the error code
+For an `elementConstraints` transform:
+
+- `value` is the current array element.
+- `index` is the zero-based index of that element.
+- `payload` is the complete root payload/source object currently being validated.
 
-is: `INVALID_ARRAY_ELEMENT`
+The same root `payload` object is provided even when `elementConstraints` is nested inside another object or array. When `elementConstraintsError` is explicitly provided, the error code is `INVALID_ARRAY_ELEMENT`.
 
 Example:
 
@@ -1717,18 +1478,14 @@ Example:
 const rules = {
   marks: {
     type: "array",
-
     elementConstraints: {
       type: "number",
     },
-
     elementConstraintsError: "Every marks element must be a number",
   },
 };
 ```
 
----
-
 ### `objectAttr`
 
 Validates fields inside a nested object.
@@ -1739,22 +1496,17 @@ Example:
 const rules = {
   address: {
     type: "object",
-
     objectAttr: {
       city: {
         mandatory: true,
-
         type: "string",
       },
-
       location: {
         type: "object",
-
         objectAttr: {
           latitude: {
             type: "number",
           },
-
           longitude: {
             type: "number",
           },
@@ -1768,17 +1520,11 @@ const rules = {
 Nested errors include the complete field path:
 
 ```js
-
 {
-
   path: "address.location.latitude",
-
   code: "INVALID_TYPE",
-
   message:
-
     "Invalid type for attribute address.location.latitude, required number value"
-
 }
 ```
 
@@ -1794,14 +1540,11 @@ Example:
 const rules = {
   minSalary: {
     type: "number",
-
     dependency: {
       maxSalary: {
         setDependencyRule: (minSalary, maxSalary) => ({
           type: "number",
-
           min: minSalary + 1,
-
           minError: "maxSalary must be more than minSalary",
         }),
       },
@@ -1813,21 +1556,61 @@ const rules = {
 Example error:
 
 ```js
-
 {
-
   path: "maxSalary",
-
   code: "MIN_VALUE",
-
   message:
-
     "maxSalary must be more than minSalary"
-
 }
 ```
 
----
+## Validation Precedence
+
+v2 uses a fixed validation order. The order in which properties are written inside a rule object does not change runtime behavior.
+
+```text
+1. mandatory / presence
+2. transformations
+   trim
+   lowercase
+   uppercase
+   transform
+3. allowNull
+4. type
+5. empty-container checks
+   allowEmptyObject
+   allowEmptyArray
+6. structural rules
+   objectAttr
+   elementConstraints
+   minItems
+   maxItems
+7. value constraints
+   regex
+   minLength
+   maxLength
+   preventDecimal
+   min
+   max
+   range
+8. dependency
+9. customValidator
+```
+
+For a single field, once an earlier validation fails, later validations for that field are pruned.
+
+Examples:
+
+```text
+mandatory fails
+→ transform/type/customValidator do not run
+type fails
+→ objectAttr/elementConstraints/regex/customValidator do not run
+regex fails
+→ customValidator does not run
+```
+
+This behavior applies to the modern core API and therefore also to the Express and Fastify adapters. `perfectPayloadV1()` keeps its legacy behavior. `perfectPayloadAsync()` follows the same synchronous precedence first. Async custom validators run only when the synchronous phase completes without validation errors.
 
 ## Array Size and Nested Validation
 
@@ -1841,17 +1624,12 @@ Use `minItems` and `maxItems` with `type: "array"`:
 const rules = {
   products: {
     type: "array",
-
     minItems: 1,
-
     maxItems: 3,
-
     elementConstraints: {
       type: "object",
-
       objectAttr: {
         productId: { mandatory: true, type: "string" },
-
         quantity: { mandatory: true, type: "number", min: 1 },
       },
     },
@@ -1862,15 +1640,10 @@ const rules = {
 If the array is empty, `minItems` reports the array path itself:
 
 ```js
-
 {
-
   path: "products",
-
   code: "MIN_ITEMS",
-
   message: "Attribute products must contain at least 1 item(s)"
-
 }
 ```
 
@@ -1879,7 +1652,6 @@ If the array is empty, `minItems` reports the array path itself:
 `elementConstraints` can contain `objectAttr`, allowing every object in an array to use a nested schema. An invalid quantity in the second product is reported as:
 
 ```text
-
 products[1].quantity
 ```
 
@@ -1891,32 +1663,21 @@ products[1].quantity
 const rules = {
   orders: {
     type: "array",
-
     minItems: 1,
-
     maxItems: 2,
-
     elementConstraints: {
       type: "object",
-
       objectAttr: {
         orderId: { mandatory: true, type: "string" },
-
         items: {
           mandatory: true,
-
           type: "array",
-
           minItems: 1,
-
           maxItems: 2,
-
           elementConstraints: {
             type: "object",
-
             objectAttr: {
               productId: { mandatory: true, type: "string" },
-
               quantity: { mandatory: true, type: "number", min: 1 },
             },
           },
@@ -1932,23 +1693,19 @@ A deep validation failure preserves the complete indexed path, for
 example:
 
 ```text
-
 orders[1].items[2].quantity
 ```
 
 Array constraints work at nested levels too. A nested array can report paths such as:
 
 ```text
-
 orders[1].items
 ```
 
 Nested arrays are supported and every array index is preserved:
 
 ```text
-
 matrix[1][1]
-
 matrix[1][1][1]
 ```
 
@@ -1956,7 +1713,7 @@ Transformations applied inside nested objects or array elements are preserved in
 
 ### Transformations and Sanitization
 
-`perfectPayload()` can transform a field before its validation rules run. The transformed value is returned in `validatedPayload`, while the original input object is not mutated.
+`perfectPayload()` can transform a field before its remaining validation rules run. The transformed value is returned in `validatedPayload`, while the original input object is not mutated.
 
 Supported transformation rules:
 
@@ -1967,66 +1724,58 @@ Supported transformation rules:
 | `uppercase` | Converts strings to uppercase.                        |
 | `transform` | Runs a custom synchronous transformation function.    |
 
-Transformations always run in this fixed order, regardless of the order in which the rule properties are written:
+The v2 validation flow is deterministic and does not depend on the order in which rule properties are written:
 
 ```text
-
+mandatory / presence
+        ↓
 trim
-
-↓
-
+        ↓
 lowercase
-
-↓
-
+        ↓
 uppercase
-
-↓
-
-transform(value, payload)
-
-↓
-
-validation rules
-
-↓
-
+        ↓
+transform
+        ↓
+allowNull
+        ↓
+type
+        ↓
+empty-container checks
+        ↓
+structural validation
+        ↓
+value constraints
+        ↓
+dependency
+        ↓
 customValidator
-
-↓
-
+        ↓
 validatedPayload
 ```
 
+If `mandatory` fails, transformations and all later rules for that field are skipped.
+
 #### `trim`
 
 ```js
 const payload = {
   name: "   Kiran Poojary   ",
 };
-
 const rules = {
   name: {
     type: "string",
-
     trim: true,
   },
 };
-
 const result = perfectPayload(payload, rules);
-
 console.log(result.validatedPayload.name);
-
 // "Kiran Poojary"
-
 console.log(payload.name);
-
 // "   Kiran Poojary   "
 ```
 
-`trim` applies only to string values. Non-string values are left
-
-unchanged.
+`trim` applies only to string values. Non-string values are left unchanged.
 
 #### `lowercase`
 
@@ -2034,9 +1783,7 @@ unchanged.
 const rules = {
   email: {
     trim: true,
-
     lowercase: true,
-
     type: "email",
   },
 };
@@ -2050,7 +1797,6 @@ For `"  KIRAN@EXAMPLE.COM  "`, the validated value becomes `"kiran@example.com"`
 const rules = {
   countryCode: {
     type: "string",
-
     uppercase: true,
   },
 };
@@ -2066,15 +1812,14 @@ Use `transform` when the built-in string transformations are not enough.
 const rules = {
   phone: {
     type: "string",
-
-    transform: (value) => value.replace(/`\s`{=tex}+/g, ""),
+    transform: (value) => String(value).replace(/\s+/g, ""),
   },
 };
 ```
 
 For `"98765 43210"`, the validated value becomes `"9876543210"`.
 
-The transformer receives two arguments:
+A normal transformer receives two arguments:
 
 ```js
 transform: (value, payload) => {
@@ -2083,35 +1828,38 @@ transform: (value, payload) => {
 ```
 
 - `value` is the field value after the built-in transformations have run.
+- `payload` is the **complete root payload/source object currently being validated**.
 
-- `payload` is the current payload/object being validated.
+For direct core usage, `payload` is the complete `data` object passed to `perfectPayload()` or `perfectPayloadAsync()`. For framework adapters, the transform receives the complete request source being validated:
+
+```text
+body rule    → request.body
+headers rule → request.headers
+params rule  → request.params
+query rule   → request.query
+```
 
-This makes cross-field transformations possible:
+This root-payload contract is preserved inside nested `objectAttr` and `elementConstraints` validation.
+
+Example cross-field transformation:
 
 ```js
 const payload = {
   amount: 100,
-
   multiplier: 2,
 };
-
 const rules = {
   amount: {
     transform: (value, payload) => value * payload.multiplier,
-
     type: "number",
   },
-
   multiplier: {
     type: "number",
   },
 };
-
 const result = perfectPayload(payload, rules);
-
 console.log(result.validatedPayload.amount);
-
-// 200***
+// 200
 ```
 
 A custom transformer may also change the data type before validation:
@@ -2120,61 +1868,30 @@ A custom transformer may also change the data type before validation:
 const rules = {
   quantity: {
     transform: (value) => Number(value),
-
     type: "number",
-
     min: 1,
-
     max: 100,
   },
 };
 ```
 
-The transformed value is validated by the normal validation rules and is also the value received by `customValidator`. Transformations work inside `objectAttr` and `elementConstraints`, and transformed nested/array values are preserved in `validatedPayload`.
+For `elementConstraints`, the callback additionally receives the zero-based array index:
 
 ```js
-const rules = {
-  profile: {
-    type: "object",
-
-    objectAttr: {
-      name: {
-        trim: true,
-
-        uppercase: true,
-
-        type: "string",
-      },
-    },
-  },
-
-  tags: {
-    type: "array",
-
-    elementConstraints: {
-      trim: true,
-
-      lowercase: true,
-
-      type: "string",
-    },
+elementConstraints: {
+  transform: (value, index, payload) => {
+    return String(value).trim();
   },
-};
+  type: "string",
+}
 ```
 
-Missing optional fields are not transformed. An input value of `null` is not passed to transformation functions; null handling remains controlled by `allowNull`.
-
-**Important:** `transform` is synchronous. A non-function transformer, an `async` transformer, a transformer that returns a Promise, or a transformer that returns `undefined` is not supported and throws an error.
-
-Returning `null`, `""`, `0`, or `false` is allowed; the transformed value is then processed by the normal validation rules. Exceptions thrown inside the transformer propagate to the caller.
+The transformed value is validated by the normal validation rules and is also the value received by `customValidator`. Transformed nested/array values are preserved in `validatedPayload`. Missing optional fields are not transformed. An input value of `null` is not passed to transformation functions; null handling remains controlled by `allowNull`. **Important:** `transform` is synchronous. A non-function transformer, an `async` transformer, a transformer that returns a Promise, or a transformer that returns `undefined` is not supported and throws an error. Returning `null`, `""`, `0`, or `false` is allowed; the transformed value is then processed by the remaining validation rules. Exceptions thrown inside the transformer propagate to the caller.
 
 For example, returning `undefined` throws:
 
 ```text
-
-perfect-payload:- transform must not return undefined for attribute
-
-username
+perfect-payload:- transform must not return undefined for attribute username
 ```
 
 ### `customValidator`
@@ -2190,13 +1907,9 @@ customValidator: (value, payload) => {
 ```
 
 - `value` is the field value after transformations have been applied.
-
 - `payload` is the current payload/object being validated.
-
 - Return `true` to pass.
-
 - Any value other than `true` fails validation.
-
 - Exceptions thrown by the validator propagate to the caller.
 
 For nested validation, `payload` means the current nested object rather than the root request body.
@@ -2209,50 +1922,32 @@ Use a synchronous validator with `perfectPayload()`:
 const rules = {
   username: {
     mandatory: true,
-
     type: "string",
-
     trim: true,
-
     customValidator: (value) => {
       return !value.toLowerCase().includes("admin");
     },
-
     customValidatorCode: "RESERVED_USERNAME",
-
     customValidatorError: "Username cannot contain admin",
   },
 };
-
 const result = perfectPayload({ username: "  admin_kiran  " }, rules);
 ```
 
 A failure returns:
 
 ```js
-
 {
-
   statusCode: 400,
-
   valid: false,
-
   message: "One or more attribute values are invalid",
-
   errors: [
-
     {
-
       path: "username",
-
       code: "RESERVED_USERNAME",
-
       message: "Username cannot contain admin"
-
     }
-
   ]
-
 }
 ```
 
@@ -2263,16 +1958,12 @@ const rules = {
   limit: {
     type: "number",
   },
-
   amount: {
     type: "number",
-
     customValidator: (value, payload) => {
       return value <= payload.limit;
     },
-
     customValidatorCode: "LIMIT_EXCEEDED",
-
     customValidatorError: "Amount cannot exceed limit",
   },
 };
@@ -2283,26 +1974,17 @@ If `customValidatorCode` and `customValidatorError` are omitted, the
 default error is:
 
 ```js
-
 {
-
   path: "username",
-
   code: "CUSTOM_VALIDATION_FAILED",
-
   message: "Custom validation failed for attribute username"
-
 }
 ```
 
-`customValidator` works recursively inside `objectAttr` and `elementConstraints`. Structured errors preserve the corresponding nested and array paths.
-
-When using `perfectPayload()`, `customValidator` must remain synchronous. A Promise-returning validator throws:
+`customValidator` works recursively inside `objectAttr` and `elementConstraints`. Structured errors preserve the corresponding nested and array paths. When using `perfectPayload()`, `customValidator` must remain synchronous. A Promise-returning validator throws:
 
 ```text
-
 perfect-payload:- customValidator must be synchronous for attribute
-
 username
 ```
 
@@ -2310,38 +1992,27 @@ For asynchronous custom validation, use `perfectPayloadAsync()`.
 
 ## Asynchronous Validation
 
-`perfectPayloadAsync()` supports both synchronous and asynchronous `customValidator` functions without changing the behavior of
-
-`perfectPayload()`.
+`perfectPayloadAsync()` supports both synchronous and asynchronous `customValidator` functions without changing the behavior of `perfectPayload()`.
 
 ```js
 import { perfectPayloadAsync } from "perfect-payload";
-
 const rules = {
   username: {
     mandatory: true,
-
     type: "string",
-
     trim: true,
-
     customValidator: async (value) => {
       const available = await checkUsernameAvailability(value);
-
       return available;
     },
-
     customValidatorCode: "USERNAME_TAKEN",
-
     customValidatorError: "Username is already taken",
   },
 };
-
 const result = await perfectPayloadAsync(
   {
     username: "  kiran  ",
   },
-
   rules,
 );
 ```
@@ -2349,48 +2020,29 @@ const result = await perfectPayloadAsync(
 On success, transformations are preserved:
 
 ```js
-
 {
-
   statusCode: 200,
-
   valid: true,
-
   validatedPayload: {
-
     username: "kiran"
-
   }
-
 }
 ```
 
 On asynchronous validation failure:
 
 ```js
-
 {
-
   statusCode: 400,
-
   valid: false,
-
   message: "One or more attribute values are invalid",
-
   errors: [
-
     {
-
       path: "username",
-
       code: "USERNAME_TAKEN",
-
       message: "Username is already taken"
-
     }
-
   ]
-
 }
 ```
 
@@ -2399,15 +2051,10 @@ On asynchronous validation failure:
 For `perfectPayloadAsync()`:
 
 ```text
-
 true             → pass
-
 false            → validation failure
-
 anything != true → validation failure
-
 throw            → exception propagates
-
 rejected Promise → rejection propagates
 ```
 
@@ -2419,22 +2066,17 @@ API:
 const rules = {
   username: {
     type: "string",
-
     customValidator: (value) => value !== "admin",
   },
 };
-
 const result = await perfectPayloadAsync(payload, rules);
 ```
 
-A configured `customValidator` must be a function. Otherwise an error
-
-is
+A configured `customValidator` must be a function. Otherwise an error is
 
 thrown:
 
 ```text
-
 perfect-payload:- customValidator must be a function for attribute username
 ```
 
@@ -2442,11 +2084,10 @@ perfect-payload:- customValidator must be a function for attribute username
 
 `perfectPayloadAsync()` uses two phases:
 
-1. Transform the payload and run normal synchronous validation.
-
+1. Run presence checks, transformations, and the normal deterministic synchronous validation pipeline.
 2. If phase 1 succeeds, run custom validators with `await`.
 
-If any synchronous validation error exists, phase 2 is skipped and the synchronous validation result is returned immediately. This means asynchronous validators can assume the payload has already passed its normal synchronous validation rules.
+If any synchronous validation error exists, phase 2 is skipped and the synchronous validation result is returned immediately. This means an async `customValidator` is pruned when an earlier rule such as `type`, `regex`, or another synchronous constraint has already failed.
 
 ### Nested async validation
 
@@ -2456,19 +2097,14 @@ Async custom validators work recursively inside `objectAttr`:
 const rules = {
   profile: {
     type: "object",
-
     objectAttr: {
       username: {
         type: "string",
-
         trim: true,
-
         customValidator: async (value) => {
           return await isUsernameAvailable(value);
         },
-
         customValidatorCode: "USERNAME_TAKEN",
-
         customValidatorError: "Username is already taken",
       },
     },
@@ -2479,7 +2115,6 @@ const rules = {
 A failure produces the complete path:
 
 ```text
-
 profile.username
 ```
 
@@ -2489,18 +2124,13 @@ They also work inside `elementConstraints`:
 const rules = {
   usernames: {
     type: "array",
-
     elementConstraints: {
       type: "string",
-
       trim: true,
-
       customValidator: async (value) => {
         return await isUsernameAvailable(value);
       },
-
       customValidatorCode: "USERNAME_TAKEN",
-
       customValidatorError: "Username is already taken",
     },
   },
@@ -2510,7 +2140,6 @@ const rules = {
 For an invalid second element:
 
 ```text
-
 usernames[1]
 ```
 
@@ -2519,9 +2148,7 @@ Deep combinations of objects and arrays preserve every level of the
 path:
 
 ```text
-
 products[1].seller.username
-
 profile.teams[1].members[1].username
 ```
 
@@ -2530,23 +2157,16 @@ Default async custom-validation messages also use the final indexed
 path:
 
 ```js
-
 {
-
   path: "users[1].username",
-
   code: "CUSTOM_VALIDATION_FAILED",
-
   message: "Custom validation failed for attribute users[1].username"
-
 }
 ```
 
 ### Transform remains synchronous
 
-`perfectPayloadAsync()` makes custom validation asynchronous; it does
-
-not make `transform` asynchronous.
+`perfectPayloadAsync()` makes custom validation asynchronous; it does not make `transform` asynchronous.
 
 `transform` must still be synchronous:
 
@@ -2556,9 +2176,7 @@ transform: (value, payload) => {
 };
 ```
 
-An async transformer or a transformer that returns a Promise is not
-
-supported.
+An async transformer or a transformer that returns a Promise is not supported.
 
 ## Error Codes
 
@@ -2567,57 +2185,31 @@ supported.
 validation error codes:
 
 ```text
-
 REQUIRED
-
 NULL_NOT_ALLOWED
-
 EMPTY_OBJECT_NOT_ALLOWED
-
 EMPTY_ARRAY_NOT_ALLOWED
-
 MIN_ITEMS
-
 MAX_ITEMS
-
 INVALID_ARRAY_ELEMENT
-
 REGEX_MISMATCH
-
 INVALID_TYPE
-
 INVALID_EMAIL
-
 INVALID_URL
-
 INVALID_ENUM
-
 INVALID_UUID
-
 INVALID_UUID_V1
-
 INVALID_UUID_V3
-
 INVALID_UUID_V4
-
 INVALID_UUID_V5
-
 INVALID_OBJECT_ID
-
 MIN_LENGTH
-
 MAX_LENGTH
-
 DECIMAL_NOT_ALLOWED
-
 MIN_VALUE
-
 MAX_VALUE
-
 OUT_OF_RANGE
-
 CUSTOM_VALIDATION_FAILED
-
 UNKNOWN_FIELD
 ```
 
@@ -2626,23 +2218,14 @@ These codes are designed for programmatic handling while `message` remains suita
 For example:
 
 ```js
-
 const result = perfectPayload(payload, validationRules);
-
 if (!result.valid) {
-
   const emailError = result.errors.find(
-
     (error) => error.code === "INVALID_EMAIL",
-
   );
-
   if (emailError) {
-
-    *****// Handle invalid email*****
-
+    // Handle invalid email
   }
-
 }
 ```
 
@@ -2651,15 +2234,10 @@ if (!result.valid) {
 Every validation rule can use its corresponding custom error message. Custom messages replace the default human-readable `message` while keeping the same structured error format:
 
 ```js
-
 {
-
   path: "email",
-
   code: "INVALID_EMAIL",
-
   message: "Email address is invalid"
-
 }
 ```
 
@@ -2669,11 +2247,8 @@ Example:
 const rules = {
   email: {
     mandatory: true,
-
     type: "email",
-
     mandatoryError: "Email is required",
-
     typeError: "Email address is invalid",
   },
 };
@@ -2682,30 +2257,20 @@ const rules = {
 If `email` is missing:
 
 ```js
-
 {
-
   path: "email",
-
   code: "REQUIRED",
-
   message: "Email is required"
-
 }
 ```
 
 If `email` is present but invalid:
 
 ```js
-
 {
-
   path: "email",
-
   code: "INVALID_EMAIL",
-
   message: "Email address is invalid"
-
 }
 ```
 
@@ -2732,101 +2297,60 @@ If `email` is present but invalid:
 ```js
 const payload = {
   username: "ab",
-
   age: 15,
-
   score: 120,
 };
-
 const rules = {
   username: {
     mandatory: true,
-
     type: "string",
-
     minLength: 3,
-
     mandatoryError: "Username is required",
-
     typeError: "Username must be a string",
-
     minLengthError: "Username must contain at least 3 characters",
   },
-
   age: {
     type: "number",
-
     min: 18,
-
     minError: "Age must be at least 18",
   },
-
   score: {
     type: "number",
-
     range: "0-100",
-
     rangeError: "Score must be between 0 and 100",
   },
 };
-
 const result = perfectPayload(payload, rules);
 ```
 
 Example result:
 
 ```js
-
 {
-
   statusCode: 400,
-
   valid: false,
-
   message:
-
     "One or more attribute values are invalid",
-
   errors: [
-
     {
-
       path: "username",
-
       code: "MIN_LENGTH",
-
       message:
-
         "Username must contain at least 3 characters"
-
     },
-
     {
-
       path: "age",
-
       code: "MIN_VALUE",
-
       message:
-
         "Age must be at least 18"
-
     },
-
     {
-
       path: "score",
-
       code: "OUT_OF_RANGE",
-
       message:
-
         "Score must be between 0 and 100"
-
     }
-
   ]
-
 }
 ```
 
@@ -2840,9 +2364,7 @@ For example:
 const rules = {
   age: {
     type: "number",
-
     min: 18,
-
     minError: "You must be 18 or older",
   },
 };
@@ -2851,44 +2373,31 @@ const rules = {
 Still returns:
 
 ```js
-
 {
-
   path: "age",
-
   code: "MIN_VALUE",
-
   message: "You must be 18 or older"
-
 }
 ```
 
 This makes it possible to:
 
 - show custom messages to API consumers
-
 - use stable error codes in application logic
-
 - change user-facing wording without changing programmatic error
 
 handling
 
 ## Custom Response Objects
 
-Custom valid and invalid response objects are configured inside the
-
-optional third `options` argument.
+Custom valid and invalid response objects are configured inside the optional third `options` argument.
 
 ```js
-
 perfectPayload(data, validationRules, options?)
-
 await perfectPayloadAsync(data, validationRules, options?)
 ```
 
-This keeps API-level configuration in one place and avoids positional
-
-`undefined` arguments.
+This keeps API-level configuration in one place and avoids positional `undefined` arguments.
 
 ### Custom Valid Response
 
@@ -2896,9 +2405,7 @@ This keeps API-level configuration in one place and avoids positional
 const result = perfectPayload(payload, validationRules, {
   validPayloadResponse: {
     statusCode: 201,
-
     valid: true,
-
     message: "Payload validated successfully",
   },
 });
@@ -2907,25 +2414,15 @@ const result = perfectPayload(payload, validationRules, {
 When validation succeeds, `validatedPayload` is automatically added:
 
 ```js
-
 {
-
   statusCode: 201,
-
   valid: true,
-
   message: "Payload validated successfully",
-
   validatedPayload: {
-
     name: "Kiran",
-
     email: "kiran@example.com",
-
     age: 29
-
   }
-
 }
 ```
 
@@ -2935,9 +2432,7 @@ When validation succeeds, `validatedPayload` is automatically added:
 const result = perfectPayload(payload, validationRules, {
   inValidPayloadResponse: {
     statusCode: 422,
-
     valid: false,
-
     message: "Payload validation failed",
   },
 });
@@ -2946,29 +2441,17 @@ const result = perfectPayload(payload, validationRules, {
 When validation fails, `errors` is automatically added:
 
 ```js
-
 {
-
   statusCode: 422,
-
   valid: false,
-
   message: "Payload validation failed",
-
   errors: [
-
     {
-
       path: "email",
-
       code: "INVALID_EMAIL",
-
       message: "Invalid email format for attribute email"
-
     }
-
   ]
-
 }
 ```
 
@@ -2978,17 +2461,12 @@ When validation fails, `errors` is automatically added:
 const result = perfectPayload(payload, validationRules, {
   validPayloadResponse: {
     statusCode: 201,
-
     valid: true,
-
     message: "CUSTOM_VALID_RESPONSE",
   },
-
   inValidPayloadResponse: {
     statusCode: 422,
-
     valid: false,
-
     message: "CUSTOM_INVALID_RESPONSE",
   },
 });
@@ -2999,35 +2477,26 @@ You can combine response customization with other API options:
 ```js
 const result = perfectPayload(payload, validationRules, {
   unknownFields: "reject",
-
   validPayloadResponse: {
     statusCode: 201,
-
     valid: true,
   },
-
   inValidPayloadResponse: {
     statusCode: 422,
-
     valid: false,
-
     message: "Payload validation failed",
   },
 });
 ```
 
-The response object you provide is preserved while `perfectPayload()` automatically adds `validatedPayload` for successful validation or `errors` for failed validation.
-
-The same response options are supported by `perfectPayloadAsync()`.
+The response object you provide is preserved while `perfectPayload()` automatically adds `validatedPayload` for successful validation or `errors` for failed validation. The same response options are supported by `perfectPayloadAsync()`.
 
-## v1.7 API Migration
+## Migrating to the v2 API
 
-The current `perfectPayload()` and `perfectPayloadAsync()` APIs use one optional third argument for configuration:
+The v2 `perfectPayload()` and `perfectPayloadAsync()` APIs use one optional third argument for configuration:
 
 ```js
-
 perfectPayload(data, validationRules, options?)
-
 perfectPayloadAsync(data, validationRules, options?)
 ```
 
@@ -3038,7 +2507,6 @@ Use:
 ```js
 perfectPayload(payload, rules, {
   validPayloadResponse: customValidResponse,
-
   inValidPayloadResponse: customInvalidResponse,
 });
 ```
@@ -3048,12 +2516,9 @@ instead of passing custom response objects as separate positional arguments. Thi
 ```js
 perfectPayload(payload, rules, {
   unknownFields: "reject",
-
   inValidPayloadResponse: {
     statusCode: 422,
-
     valid: false,
-
     message: "Payload validation failed",
   },
 });
@@ -3066,48 +2531,29 @@ perfectPayload(payload, rules, {
 If no custom response objects are provided, the default valid response is:
 
 ```js
-
 {
-
   statusCode: 200,
-
   valid: true,
-
   validatedPayload: {
-
-    *****// validated fields*****
-
+    // validated fields
   }
-
 }
 ```
 
 The default invalid response is:
 
 ```js
-
 {
-
   statusCode: 400,
-
   valid: false,
-
   message: "One or more attribute values are invalid",
-
   errors: [
-
     {
-
       path: "field",
-
       code: "ERROR_CODE",
-
       message: "Validation error message"
-
     }
-
   ]
-
 }
 ```
 
@@ -3128,15 +2574,10 @@ const payload = {
 An error can be returned as:
 
 ```js
-
 {
-
   path: "email",
-
   code: "INVALID_EMAIL",
-
   message: "Invalid email format for attribute email"
-
 }
 ```
 
@@ -3148,32 +2589,25 @@ Use `objectAttr` to validate properties inside an object.
 const payload = {
   address: {
     city: "Bengaluru",
-
     location: {
       latitude: "12.9716",
-
       longitude: 77.5946,
     },
   },
 };
-
 const rules = {
   address: {
     type: "object",
-
     objectAttr: {
       city: {
         type: "string",
       },
-
       location: {
         type: "object",
-
         objectAttr: {
           latitude: {
             type: "number",
           },
-
           longitude: {
             type: "number",
           },
@@ -3182,35 +2616,25 @@ const rules = {
     },
   },
 };
-
 const result = perfectPayload(payload, rules);
 ```
 
 Because `latitude` is a string instead of a number, the error contains its complete nested path:
 
 ```js
-
 {
-
   path: "address.location.latitude",
-
   code: "INVALID_TYPE",
-
   message:
-
     "Invalid type for attribute address.location.latitude, required number value"
-
 }
 ```
 
 Nested paths use dot notation:
 
 ```text
-
 address.city
-
 address.location.latitude
-
 address.location.longitude
 ```
 
@@ -3222,47 +2646,34 @@ When `elementConstraints` validation fails, the array index is included in the e
 const payload = {
   marks: [50, 75, 150],
 };
-
 const rules = {
   marks: {
     type: "array",
-
     elementConstraints: {
       type: "number",
-
       range: "0-100",
     },
   },
 };
-
 const result = perfectPayload(payload, rules);
 ```
 
 The invalid third element is reported as:
 
 ```js
-
 {
-
   path: "marks[2]",
-
   code: "OUT_OF_RANGE",
-
   message:
-
     "Attribute marks[2] should have a value between 0 and 100"
-
 }
 ```
 
 Array paths use zero-based indexes:
 
 ```text
-
 marks[0]
-
 marks[1]
-
 marks[2]
 ```
 
@@ -3275,11 +2686,8 @@ Paths can also identify fields inside array elements.
 For example:
 
 ```text
-
 products[0].quantity
-
 products[1].quantity
-
 products[2].price
 ```
 
@@ -3297,7 +2705,6 @@ For example:
 
 ```js
 const result = perfectPayload(payload, validationRules);
-
 if (!result.valid) {
   result.errors.forEach((error) => {
     console.log(error.path, error.code, error.message);
@@ -3309,7 +2716,6 @@ A frontend can also map validation errors by path:
 
 ```js
 const fieldErrors = {};
-
 result.errors.forEach((error) => {
   fieldErrors[error.path] = error.message;
 });
@@ -3318,15 +2724,10 @@ result.errors.forEach((error) => {
 Result:
 
 ```js
-
 {
-
   "email": "Invalid email format for attribute email",
-
   "address.location.latitude": "Invalid type for attribute address.location.latitude, required number value",
-
   "marks[2]": "Attribute marks[2] should have a value between 0 and 100"
-
 }
 ```
 
@@ -3337,340 +2738,175 @@ Result:
 sample-1
 
 ```js
-
 {
-
   firstName: {
-
     mandatory: true,
-
     allowNull: false,
-
     type: "string",
-
     minLength: 3,
-
     minLengthError: "First name must have minimum 3 characters."
-
   },
-
   lastName: {
-
     mandatory: false,
-
     allowNull: true,
-
     type: "string",
-
   },
-
   email: {
-
     mandatory: true,
-
     allowNull: false,
-
     type: "email",
-
   },
-
   phone: {
-
     mandatory: true,
-
     allowNull: false,
-
     type: "string",
-
   },
-
   age: {
-
     mandatory: false,
-
     type: "number",
-
     min: 1,
-
     max: 120,
-
   },
-
 };
 ```
 
 sample-2
 
 ```js
-
 {
-
   id: {
-
     mandatory: true,
-
     allowNull: true,
-
     type: "uuidv4",
-
   },
-
   batchId: {
-
     mandatory: true,
-
     allowNull: true,
-
     type: "objectId",
-
   },
-
   firstName: {
-
     mandatory: true,
-
     type: "string",
-
     minLength: 3,
-
   },
-
   lastName: {
-
     mandatory: false,
-
     allowNull: true,
-
     type: "string",
-
   },
-
   age: {
-
     type: "number",
-
     min: 0.1,
-
     max: 120,
-
   },
-
   isAdult: {
-
     type: "boolean",
-
   },
-
   totalWins: {
-
     type: "number",
-
     min: 0,
-
     preventDecimal: true,
-
   },
-
   email: {
-
     regex: /[^2]+@[a-zA-Z0-9.-]+.[a-zA-Z]{2,}$/,
-
   },
-
   githubLink: {
-
     type: "url",
-
   },
-
   accountStatus: {
-
     type: "enum",
-
     enumValues: ["Active", "Inactive", 200],
-
   },
-
   marks: {
-
     range: "0-100",
-
   },
-
   allMarks: {
-
     type: "array",
-
     allowEmptyArray: false,
-
     elementConstraints: {
-
       type: "number",
-
       allowNull: false,
-
       range: "0-100",
-
     },
-
   },
-
   totalScore: {
-
     type: "number",
-
     dependency: {
-
       result: {
-
         setDependencyRule: (totalScore, result) => {
-
           return { mandatory: true, allowNull: false, type: "string" };
-
         },
-
       },
-
     },
-
   },
-
   result: {
-
     type: "string",
-
     dependency: {
-
       totalScore: {
-
         setDependencyRule: (result, totalScore) => {
-
           return { mandatory: true, allowNull: false, type: "number" };
-
         },
-
       },
-
     },
-
   },
-
   minSalary: {
-
     mandatory: true,
-
     min: 1,
-
     type: "number",
-
     dependency: {
-
       maxSalary: {
-
         setDependencyRule: (minSalary, maxSalary) => {
-
           return {
-
             mandatory: true,
-
             min: minSalary + 1,
-
             minError: "maxSalary must be more than minSalary",
-
           };
-
         },
-
       },
-
     },
-
   },
-
   maxSalary: {
-
     dependency: {
-
       minSalary: {
-
         setDependencyRule: (maxSalary, minSalary) => {
-
           return {
-
             mandatory: true,
-
             max: maxSalary - 1,
-
             maxError: "minSalary must be less than maxSalary",
-
           };
-
         },
-
       },
-
     },
-
   },
-
   address: {
-
     mandatory: true,
-
     type: "object",
-
     allowEmptyObject: false,
-
     objectAttr: {
-
       country: { mandatory: true, type: "string" },
-
       state: {
-
         mandatory: true,
-
         type: "string",
-
       },
-
       city: {},
-
       zip: {
-
         mandatory: true,
-
         type: "string",
-
       },
-
       position: {
-
         mandatory: true,
-
         type: "object",
-
         allowEmptyObject: false,
-
         objectAttr: {
-
           lattitude: { mandatory: true, type: "number" },
-
           longitude: {
-
             mandatory: true,
-
             type: "number",
-
           },
-
         },
-
       },
-
     },
-
   },
-
 }
 ```
 
@@ -3679,19 +2915,11 @@ sample-2
 #### Creating a route with payload validation middleware
 
 ```js
-
-****// validatePayload is the middleware that invokes
-
-perfectPayload()****
-
+// validatePayload is the middleware that invokes perfectPayload()
 router.post(
-
   "/payload-validation",
-
   validatePayload({ rule: <your validation rule json object> }),
-
   (req, res) => res.send("OK")
-
 );
 ```
 
@@ -3699,24 +2927,16 @@ router.post(
 
 ```js
 import { perfectPayload } from "perfect-payload";
-
 export const validatePayload = ({ rule }) => {
   return (req, res, next) => {
     try {
-      const { statusCode, ...response } = perfectPayload(
-        req?.body,
-
-        rule,
-      );
-
+      const { statusCode, ...response } = perfectPayload(req?.body, rule);
       if (+statusCode >= 200 && +statusCode <= 299) {
         req.validatedBody = response?.validatedPayload;
-
         next();
       } else res.status(statusCode).json(response);
     } catch (error) {
       console.error("Error validating payload", error);
-
       res.status(500).json({ error: "Internal Server Error" });
     }
   };
@@ -3729,26 +2949,21 @@ When your schema contains an asynchronous `customValidator`, the middleware itse
 
 ```js
 import { perfectPayloadAsync } from "perfect-payload";
-
 export const validatePayloadAsync = ({ rule }) => {
   return async (req, res, next) => {
     try {
       const { statusCode, ...response } = await perfectPayloadAsync(
         req?.body,
-
         rule,
       );
-
       if (+statusCode >= 200 && +statusCode <= 299) {
         req.validatedBody = response?.validatedPayload;
-
         next();
       } else {
         res.status(statusCode).json(response);
       }
     } catch (error) {
       console.error("Error validating payload", error);
-
       res.status(500).json({ error: "Internal Server Error" });
     }
   };
@@ -3758,15 +2973,10 @@ export const validatePayloadAsync = ({ rule }) => {
 Route usage:
 
 ```js
-
 router.post(
-
   "/payload-validation",
-
   validatePayloadAsync({ rule: <your validation rule json object> }),
-
   (req, res) => res.send("OK"),
-
 );
 ```
 
@@ -3777,35 +2987,22 @@ function validatePayload({ rule }) {
   return async (req, res, next) => {
     try {
       const { perfectPayload } = await import("perfect-payload");
-
-      const { statusCode, ...response } = perfectPayload(
-        req?.body,
-
-        rule,
-      );
-
+      const { statusCode, ...response } = perfectPayload(req?.body, rule);
       if (+statusCode >= 200 && +statusCode <= 299) {
         req.validatedBody = response?.validatedPayload;
-
         next();
       } else {
         res.status(statusCode).json(response);
       }
     } catch (error) {
       console.error("Error validating payload", error);
-
       res.status(500).json({ error: "Internal Server Error" });
     }
   };
 }
-
 module.exports = { validatePayload };
 ```
 
 ---
 
-This documentation provides a comprehensive guide to using the data
-
-validation module effectively. Ensure to define your validation rules
-
-clearly to maintain data quality and consistency in your applications.
+This documentation provides a comprehensive guide to using the data validation module effectively. Ensure to define your validation rules clearly to maintain data quality and consistency in your applications.