perfect-payload 1.2.3 → 1.3.0

package/README.md

@@ -1,6 +1,7 @@
 # perfect-payload
 
 A lightweight JavaScript payload validation utility for validating API
+
 and JSON payloads with simple rule-based configuration.
 
 ## Installation
@@ -8,6 +9,7 @@ and JSON payloads with simple rule-based configuration.
 ```bash
 
 npm install perfect-payload
+
 ```
 
 ## Basic Usage
@@ -19,24 +21,30 @@ 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,
   },
 };
@@ -51,19 +59,31 @@ console.log(result);
 ```js
 
 {
-  statusCode: 200,
-  valid: true,
-  validatedPayload: {
-    name: "Kiran",
-    email: "kiran@example.com",
-    age: 29
-  }
+
+  statusCode: 200,
+
+  valid: true,
+
+  validatedPayload: {
+
+    name: "Kiran",
+
+    email: "kiran@example.com",
+
+    age: 29
+
+  }
+
 }
+
 ```
 
 **Note:** The validatedPayload contains only the fields defined in the
+
 schema, automatically filtering out any extra attributes. You can use it
+
 to safely overwrite request.body or assign it to a new request property
+
 (such as validatedBody, sanitisedData or parsedBody).
 
 ### Invalid Response
@@ -71,17 +91,29 @@ to safely overwrite request.body or assign it to a new request property
 ```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"
-    }
-  ]
+
+  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:
@@ -89,17 +121,26 @@ Each error returned by `perfectPayload()` contains:
 ```js
 
 {
-  path: "field.path",
-  code: "ERROR_CODE",
-  message: "Human readable validation message"
+
+  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.
-- Submitted payload values are not included in default error messages.
+\- `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.
+
+\- Submitted payload values are not included in default error messages.
 
 ## Legacy API
 
@@ -110,9 +151,11 @@ import { perfectPayloadV1 } from "perfect-payload";
 ```
 
 `perfectPayloadV1()` is deprecated and will no longer be supported after
-**\*\*March 31, 2027\*\***.
+
+**March 31, 2027**.
 
 Existing applications can continue using it during the migration period,
+
 but all new implementations should use:
 
 ```js
@@ -131,15 +174,20 @@ while the new `perfectPayload()` API returns structured errors:
 errors: [
   {
     path: "email",
+
     code: "INVALID_EMAIL",
+
     message: "Invalid email format for attribute email",
   },
 ];
 ```
 
 **Note:** If an inValidPayloadResponse is provided, the system returns
+
 it alongside an automatically generated errors property. Do not include
+
 your own errors attribute inside the custom inValidPayloadResponse
+
 object.
 
 ## Validation Rules
@@ -162,7 +210,7 @@ const rules = {
 
 Error code: `REQUIRED`
 
----
+**---**
 
 ### `allowNull`
 
@@ -182,7 +230,7 @@ const rules = {
 
 Error code: `NULL_NOT_ALLOWED`
 
----
+**---**
 
 ### `allowEmptyObject`
 
@@ -196,6 +244,7 @@ Example:
 const rules = {
   address: {
     type: "object",
+
     allowEmptyObject: false,
   },
 };
@@ -203,7 +252,7 @@ const rules = {
 
 Error code: `EMPTY_OBJECT_NOT_ALLOWED`
 
----
+**---**
 
 ### `allowEmptyArray`
 
@@ -217,6 +266,7 @@ Example:
 const rules = {
   products: {
     type: "array",
+
     allowEmptyArray: false,
   },
 };
@@ -224,7 +274,7 @@ const rules = {
 
 Error code: `EMPTY_ARRAY_NOT_ALLOWED`
 
----
+**---**
 
 ### `type`
 
@@ -235,19 +285,33 @@ Supported values:
 ```text
 
 number
+
 string
+
 boolean
+
 email
+
 url
+
 enum
+
 uuid
+
 uuidv1
+
 uuidv3
+
 uuidv4
+
 uuidv5
+
 objectId
+
 array
+
 object
+
 ```
 
 Example:
@@ -257,9 +321,11 @@ const rules = {
   age: {
     type: "number",
   },
+
   email: {
     type: "email",
   },
+
   active: {
     type: "boolean",
   },
@@ -280,6 +346,7 @@ Example:
 const rules = {
   status: {
     type: "enum",
+
     enumValues: ["active", "inactive", "blocked", 1, 0],
   },
 };
@@ -299,6 +366,7 @@ Example:
 const rules = {
   status: {
     type: "enum",
+
     enumValues: ["active", "inactive", "blocked"],
   },
 };
@@ -311,18 +379,28 @@ 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
+
 ```
 
----
+**---**
 
 ### `regex`
 
@@ -336,6 +414,7 @@ Example:
 const rules = {
   employeeCode: {
     type: "string",
+
     regex: /^[A-Z]{3}[0-9]{3}$/,
   },
 };
@@ -343,7 +422,7 @@ const rules = {
 
 Error code: `REGEX_MISMATCH`
 
----
+**---**
 
 ### `minLength`
 
@@ -357,6 +436,7 @@ Example:
 const rules = {
   username: {
     type: "string",
+
     minLength: 5,
   },
 };
@@ -364,7 +444,7 @@ const rules = {
 
 Error code: `MIN_LENGTH`
 
----
+**---**
 
 ### `maxLength`
 
@@ -378,6 +458,7 @@ Example:
 const rules = {
   username: {
     type: "string",
+
     maxLength: 20,
   },
 };
@@ -385,7 +466,7 @@ const rules = {
 
 Error code: `MAX_LENGTH`
 
----
+**---**
 
 ### `preventDecimal`
 
@@ -399,6 +480,7 @@ Example:
 const rules = {
   quantity: {
     type: "number",
+
     preventDecimal: true,
   },
 };
@@ -406,7 +488,7 @@ const rules = {
 
 Error code: `DECIMAL_NOT_ALLOWED`
 
----
+**---**
 
 ### `min`
 
@@ -420,6 +502,7 @@ Example:
 const rules = {
   age: {
     type: "number",
+
     min: 18,
   },
 };
@@ -427,7 +510,7 @@ const rules = {
 
 Error code: `MIN_VALUE`
 
----
+**---**
 
 ### `max`
 
@@ -441,6 +524,7 @@ Example:
 const rules = {
   quantity: {
     type: "number",
+
     max: 100,
   },
 };
@@ -448,7 +532,7 @@ const rules = {
 
 Error code: `MAX_VALUE`
 
----
+**---**
 
 ### `range`
 
@@ -462,6 +546,7 @@ Example:
 const rules = {
   marks: {
     type: "number",
+
     range: "0-100",
   },
 };
@@ -469,7 +554,7 @@ const rules = {
 
 Error code: `OUT_OF_RANGE`
 
----
+**---**
 
 ### `elementConstraints`
 
@@ -481,8 +566,10 @@ Example:
 const rules = {
   marks: {
     type: "array",
+
     elementConstraints: {
       type: "number",
+
       range: "0-100",
     },
   },
@@ -495,14 +582,20 @@ Example error:
 
 {
 
-  path: "marks[2]",
-  code: "OUT_OF_RANGE",
-  message:
-    "Attribute marks[2] should have a value between 0 and 100"
+  path: "marks[2]",
+
+  code: "OUT_OF_RANGE",
+
+  message:
+
+    "Attribute marks[2] should have a value between 0 and 100"
+
 }
+
 ```
 
 When `elementConstraintsError` is explicitly provided, the error code
+
 is: `INVALID_ARRAY_ELEMENT`
 
 Example:
@@ -511,15 +604,17 @@ Example:
 const rules = {
   marks: {
     type: "array",
+
     elementConstraints: {
       type: "number",
     },
+
     elementConstraintsError: "Every marks element must be a number",
   },
 };
 ```
 
----
+**---**
 
 ### `objectAttr`
 
@@ -531,17 +626,22 @@ Example:
 const rules = {
   address: {
     type: "object",
+
     objectAttr: {
       city: {
         mandatory: true,
+
         type: "string",
       },
+
       location: {
         type: "object",
+
         objectAttr: {
           latitude: {
             type: "number",
           },
+
           longitude: {
             type: "number",
           },
@@ -557,14 +657,20 @@ 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"
+
+  path: "address.location.latitude",
+
+  code: "INVALID_TYPE",
+
+  message:
+
+    "Invalid type for attribute address.location.latitude, required number value"
+
 }
+
 ```
 
----
+**---**
 
 ### `dependency`
 
@@ -576,11 +682,14 @@ Example:
 const rules = {
   minSalary: {
     type: "number",
+
     dependency: {
       maxSalary: {
         setDependencyRule: (minSalary, maxSalary) => ({
           type: "number",
+
           min: minSalary + 1,
+
           minError: "maxSalary must be more than minSalary",
         }),
       },
@@ -595,61 +704,182 @@ Example error:
 
 {
 
-  path: "maxSalary",
-  code: "MIN_VALUE",
-  message:
-    "maxSalary must be more than minSalary"
+  path: "maxSalary",
+
+  code: "MIN_VALUE",
+
+  message:
+
+    "maxSalary must be more than minSalary"
+
+}
+
+```
+
+**---**
+
+### `customValidator`
+
+Allows you to define custom synchronous validation logic for a field when the built-in validation rules are not enough.
+
+The validator receives the field value and the complete payload:
+
+```js
+customValidator: (value, payload) => {
+  return true;
+};
+```
+
+The validator must return `true` to pass validation. Any other return value causes validation to fail.
+
+Example:
+
+```js
+const rules = {
+  username: {
+    mandatory: true,
+    type: "string",
+    customValidator: (value) => {
+      return !value.toLowerCase().includes("admin");
+    },
+    customValidatorCode: "RESERVED_USERNAME",
+    customValidatorError: "Username cannot contain admin",
+  },
+};
+```
+
+For this payload:
+
+```js
+const payload = {
+  username: "admin_kiran",
+};
+```
+
+The validation error is:
+
+```js
+{
+  path: "username",
+  code: "RESERVED_USERNAME",
+  message: "Username cannot contain admin"
+}
+```
+
+If `customValidatorCode` and `customValidatorError` are not provided, the default error is:
+
+```js
+{
+  path: "username",
+  code: "CUSTOM_VALIDATION_FAILED",
+  message: "Custom validation failed for attribute username"
 }
 ```
 
+The complete payload can be used as the second argument when required:
+
+```js
+const rules = {
+  limit: {
+    type: "number",
+  },
+  amount: {
+    type: "number",
+    customValidator: (value, payload) => {
+      return value <= payload.limit;
+    },
+    customValidatorCode: "LIMIT_EXCEEDED",
+    customValidatorError: "Amount cannot exceed limit",
+  },
+};
+```
+
+`customValidator` also works with nested objects and array `elementConstraints`. The generated structured error automatically contains the corresponding nested or array path.
+
+**Important:** `customValidator` is synchronous. An `async` validator or a validator that returns a Promise is not supported and throws an error. Asynchronous validation is not part of this feature.
+
+Error code when no custom code is provided: `CUSTOM_VALIDATION_FAILED`
+
 ## Error Codes
 
 `perfectPayload()` currently exposes the following machine-readable
+
 validation error codes:
 
 ```text
 
 REQUIRED
+
 NULL_NOT_ALLOWED
+
 EMPTY_OBJECT_NOT_ALLOWED
+
 EMPTY_ARRAY_NOT_ALLOWED
+
 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
+
 ```
 
 These codes are designed for programmatic handling while `message`
+
 remains suitable for human-readable API responses.
 
 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*
+
   }
+
 }
+
 ```
 
 ## Custom Error Messages
@@ -657,15 +887,21 @@ 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"
+
+  path: "email",
+
+  code: "INVALID_EMAIL",
+
+  message: "Email address is invalid"
+
 }
+
 ```
 
 Example:
@@ -674,8 +910,11 @@ Example:
 const rules = {
   email: {
     mandatory: true,
+
     type: "email",
+
     mandatoryError: "Email is required",
+
     typeError: "Email address is invalid",
   },
 };
@@ -686,10 +925,15 @@ If `email` is missing:
 ```js
 
 {
-  path: "email",
-  code: "REQUIRED",
-  message: "Email is required"
+
+  path: "email",
+
+  code: "REQUIRED",
+
+  message: "Email is required"
+
 }
+
 ```
 
 If `email` is present but invalid:
@@ -697,70 +941,88 @@ If `email` is present but invalid:
 ```js
 
 {
-  path: "email",
-  code: "INVALID_EMAIL",
-  message: "Email address is invalid"
+
+  path: "email",
+
+  code: "INVALID_EMAIL",
+
+  message: "Email address is invalid"
+
 }
+
 ```
 
 ### Supported Custom Error Properties
 
-\| Validation Rule      \| Custom Error Property     \|
+\| Validation Rule \| Custom Error Property \|
 
 \| -------------------- \| ------------------------- \|
 
-\| `mandatory`          \| `mandatoryError`          \|
+\| `mandatory` \| `mandatoryError` \|
 
-\| `allowNull`          \| `allowNullError`          \|
+\| `allowNull` \| `allowNullError` \|
 
-\| `allowEmptyObject`   \| `emptyObjectError`        \|
+\| `allowEmptyObject` \| `emptyObjectError` \|
 
-\| `allowEmptyArray`    \| `emptyArrayError`         \|
+\| `allowEmptyArray` \| `emptyArrayError` \|
 
 \| `elementConstraints` \| `elementConstraintsError` \|
 
-\| `regex`              \| `regexError`              \|
+\| `regex` \| `regexError` \|
 
-\| `type`               \| `typeError`               \|
+\| `type` \| `typeError` \|
 
-\| `minLength`          \| `minLengthError`          \|
+\| `minLength` \| `minLengthError` \|
 
-\| `maxLength`          \| `maxLengthError`          \|
+\| `maxLength` \| `maxLengthError` \|
 
-\| `preventDecimal`     \| `preventDecimalError`     \|
+\| `preventDecimal` \| `preventDecimalError` \|
 
-\| `min`                \| `minError`                \|
+\| `min` \| `minError` \|
 
-\| `max`                \| `maxError`                \|
+\| `max` \| `maxError` \|
 
-\| `range`              \| `rangeError`              \|
+\| `range` \| `rangeError` \|
 
 ### Example with Multiple Custom Errors
 
 ```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",
   },
 };
@@ -773,72 +1035,109 @@ 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"
-    }
-  ]
-}
-```
 
-### Custom Messages and Error Codes
+  statusCode: 400,
 
-Custom messages only replace the `message`.
+  valid: false,
 
-They do not change the validation error `code`.
+  message:
 
-For example:
+    "One or more attribute values are invalid",
 
-```js
-const rules = {
-  age: {
-    type: "number",
-    min: 18,
-    minError: "You must be 18 or older",
-  },
-};
-```
+  errors: [
 
-Still returns:
+    {
 
-```js
+      path: "username",
 
-{
-  path: "age",
-  code: "MIN_VALUE",
-  message: "You must be 18 or older"
-}
-```
+      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"
+
+    }
+
+  ]
+
+}
+
+```
+
+### Custom Messages and Error Codes
+
+Custom messages only replace the `message`.
+
+They do not change the validation error `code`.
+
+For example:
+
+```js
+const rules = {
+  age: {
+    type: "number",
+
+    min: 18,
+
+    minError: "You must be 18 or older",
+  },
+};
+```
+
+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
+\- 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
 
 `perfectPayload()` allows you to customize both the valid and invalid
+
 response objects.
 
 The third argument is the custom valid response.
@@ -852,7 +1151,9 @@ Example:
 ```js
 const customValidResponse = {
   statusCode: 201,
+
   valid: true,
+
   message: "Payload validated successfully",
 };
 
@@ -864,15 +1165,25 @@ 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
-  }
+
+  statusCode: 201,
+
+  valid: true,
+
+  message: "Payload validated successfully",
+
+  validatedPayload: {
+
+    name: "Kiran",
+
+    email: "kiran@example.com",
+
+    age: 29
+
+  }
+
 }
+
 ```
 
 ### Custom Invalid Response
@@ -882,14 +1193,19 @@ Example:
 ```js
 const customInvalidResponse = {
   statusCode: 422,
+
   valid: false,
+
   message: "Payload validation failed",
 };
 
 const result = perfectPayload(
   payload,
+
   validationRules,
+
   undefined,
+
   customInvalidResponse,
 );
 ```
@@ -900,18 +1216,30 @@ When validation fails, `errors` is automatically added:
 
 {
 
-  statusCode: 422,
-  valid: false,
-  message: "Payload validation failed",
-  errors: [
-    {
-      path: "email",
-      code: "INVALID_EMAIL",
-      message:
-        "Invalid email format for attribute email"
-    }
-  ]
+  statusCode: 422,
+
+  valid: false,
+
+  message: "Payload validation failed",
+
+  errors: [
+
+    {
+
+      path: "email",
+
+      code: "INVALID_EMAIL",
+
+      message:
+
+        "Invalid email format for attribute email"
+
+    }
+
+  ]
+
 }
+
 ```
 
 ### Custom Valid and Invalid Responses Together
@@ -919,30 +1247,39 @@ When validation fails, `errors` is automatically added:
 ```js
 const customValidResponse = {
   statusCode: 201,
+
   valid: true,
+
   message: "CUSTOM_VALID_RESPONSE",
 };
 
 const customInvalidResponse = {
   statusCode: 422,
+
   valid: false,
+
   message: "CUSTOM_INVALID_RESPONSE",
 };
 
 const result = perfectPayload(
   payload,
+
   validationRules,
+
   customValidResponse,
+
   customInvalidResponse,
 );
 ```
 
 The response object you provide is preserved, while `perfectPayload()`
+
 automatically adds either:
 
 ```text
 
 validatedPayload
+
 ```
 
 for successful validation, or:
@@ -950,6 +1287,7 @@ for successful validation, or:
 ```text
 
 errors
+
 ```
 
 for failed validation.
@@ -957,17 +1295,25 @@ for failed validation.
 ## Default Responses
 
 If no custom response objects are provided, the default valid response
+
 is:
 
 ```js
 
 {
-  statusCode: 200,
-  valid: true,
-  validatedPayload: {
-    // validated fields
-  }
+
+  statusCode: 200,
+
+  valid: true,
+
+  validatedPayload: {
+
+    *// validated fields*
+
+  }
+
 }
+
 ```
 
 The default invalid response is:
@@ -975,25 +1321,39 @@ 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"
-    }
-  ]
+
+  statusCode: 400,
+
+  valid: false,
+
+  message: "One or more attribute values are invalid",
+
+  errors: [
+
+    {
+
+      path: "field",
+
+      code: "ERROR_CODE",
+
+      message: "Validation error message"
+
+    }
+
+  ]
+
 }
+
 ```
 
 ## Nested Objects and Array Field Paths
 
 `perfectPayload()` returns the exact location of a validation failure
+
 through the `path` property.
 
 This makes validation errors easier to map to API fields, forms, logs,
+
 and frontend components.
 
 ### Top-Level Field
@@ -1011,10 +1371,15 @@ An error can be returned as:
 ```js
 
 {
-  path: "email",
-  code: "INVALID_EMAIL",
-  message: "Invalid email format for attribute email"
+
+  path: "email",
+
+  code: "INVALID_EMAIL",
+
+  message: "Invalid email format for attribute email"
+
 }
+
 ```
 
 ### Nested Object
@@ -1025,8 +1390,10 @@ Use `objectAttr` to validate properties inside an object.
 const payload = {
   address: {
     city: "Bengaluru",
+
     location: {
       latitude: "12.9716",
+
       longitude: 77.5946,
     },
   },
@@ -1035,16 +1402,20 @@ const payload = {
 const rules = {
   address: {
     type: "object",
+
     objectAttr: {
       city: {
         type: "string",
       },
+
       location: {
         type: "object",
+
         objectAttr: {
           latitude: {
             type: "number",
           },
+
           longitude: {
             type: "number",
           },
@@ -1058,16 +1429,23 @@ 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"
+
+  path: "address.location.latitude",
+
+  code: "INVALID_TYPE",
+
+  message:
+
+    "Invalid type for attribute address.location.latitude, required number value"
+
 }
+
 ```
 
 Nested paths use dot notation:
@@ -1075,13 +1453,17 @@ Nested paths use dot notation:
 ```text
 
 address.city
+
 address.location.latitude
+
 address.location.longitude
+
 ```
 
 ### Array Elements
 
 When `elementConstraints` validation fails, the array index is included
+
 in the error path.
 
 ```js
@@ -1092,8 +1474,10 @@ const payload = {
 const rules = {
   marks: {
     type: "array",
+
     elementConstraints: {
       type: "number",
+
       range: "0-100",
     },
   },
@@ -1107,11 +1491,17 @@ 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"
+
+  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:
@@ -1119,8 +1509,11 @@ Array paths use zero-based indexes:
 ```text
 
 marks[0]
+
 marks[1]
+
 marks[2]
+
 ```
 
 ### Nested Fields Inside Arrays
@@ -1132,16 +1525,21 @@ For example:
 ```text
 
 products[0].quantity
+
 products[1].quantity
+
 products[2].price
+
 ```
 
 This provides enough information for consumers to identify the exact
+
 field that caused the validation error.
 
 ### Why Structured Paths Are Useful
 
 Instead of parsing an error message to determine which field failed,
+
 applications can directly use:
 
 ```js
@@ -1176,11 +1574,14 @@ Result:
 
 {
 
-  "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"
+  "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"
 
 }
+
 ```
 
 ## Examples And Usage
@@ -1193,35 +1594,64 @@ sample-1
 
 {
 
-  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,
-  },
+  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
@@ -1229,140 +1659,275 @@ sample-2
 ```javascript
 
 {
-  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: /^[a-zA-Z0-9._%+-]+@[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",
-          },
-        },
-      },
-    },
-  },
+
+  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: /^[a-zA-Z0-9._%+-]+@[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",
+
+          },
+
+        },
+
+      },
+
+    },
+
+  },
+
 }
+
 ```
 
 ### Usage
@@ -1371,13 +1936,18 @@ sample-2
 
 ```javascript
 
-//Here validatePayload is your middleware function, where you're invoking perfect payload
+*//Here validatePayload is your middleware function, where you're invoking perfect payload*
 
 router.post(
-  "/payload-validation",
-  validatePayload({ rule: <your validation rule json object> }),
-  (req, res) => res.send("OK")
+
+  "/payload-validation",
+
+  validatePayload({ rule: <your validation rule json object> }),
+
+  (req, res) => res.send("OK")
+
 );
+
 ```
 
 #### 1 Use perfect-payload in your middleware like below(for MODULE JS)
@@ -1389,12 +1959,15 @@ export const validatePayload = ({ rule }) => {
   return (req, res, next) => {
     try {
       const { statusCode, ...response } = perfectPayloadV1(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" });
     }
   };
@@ -1408,15 +1981,19 @@ function validatePayload({ rule }) {
   return async (req, res, next) => {
     try {
       const { perfectPayloadV1 } = await import("perfect-payload");
+
       const { statusCode, ...response } = perfectPayloadV1(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" });
     }
   };
@@ -1425,8 +2002,10 @@ function validatePayload({ rule }) {
 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.