perfect-payload 1.3.0-beta.2 → 1.5.0-beta.0

package/index.js

@@ -562,7 +562,7 @@ function perfectPayloadStructured(
       basePath,
     );
 
-    const attributeValue = data?.[attributeName] ?? null;
+    let attributeValue = data?.[attributeName] ?? null;
 
     const nullAllowed =
       dataValidationRule?.[attributeName]?.["allowNull"] ?? true;
@@ -570,7 +570,78 @@ function perfectPayloadStructured(
     const isMandatoryField = attributeRules?.["mandatory"] ?? false;
 
     const attrExist = Object.keys(data ?? {}).includes(attributeName);
+    // TRANSFORMATIONS START
+    // NO MULTI TRANSFORMATION
+    if (
+      attributeRules?.lowercase === true &&
+      attributeRules?.uppercase === true
+    ) {
+      throw new Error(
+        `perfect-payload:- lowercase and uppercase cannot both be enabled for attribute ${attributePath}`,
+      );
+    }
+    // TRIM
+    if (
+      attrExist &&
+      attributeValue !== null &&
+      attributeRules?.trim === true &&
+      typeof attributeValue === "string"
+    ) {
+      attributeValue = attributeValue.trim();
+    }
+    // LOWERCASE
+    if (
+      attrExist &&
+      attributeValue !== null &&
+      attributeRules?.lowercase === true &&
+      typeof attributeValue === "string"
+    ) {
+      attributeValue = attributeValue.toLowerCase();
+    }
+
+    // UPPERCASE
+
+    if (
+      attrExist &&
+      attributeValue !== null &&
+      attributeRules?.uppercase === true &&
+      typeof attributeValue === "string"
+    ) {
+      attributeValue = attributeValue.toUpperCase();
+    }
 
+    // CUSTOM TRANSFORM
+
+    if (
+      attrExist &&
+      attributeValue !== null &&
+      attributeRules?.transform !== undefined
+    ) {
+      const transformer = attributeRules.transform;
+
+      if (typeof transformer !== "function") {
+        throw new Error(
+          `perfect-payload:- transform must be a function for attribute ${attributePath}`,
+        );
+      }
+
+      const transformedValue = transformer(attributeValue, data);
+
+      if (transformedValue && typeof transformedValue.then === "function") {
+        throw new Error(
+          `perfect-payload:- transform must be synchronous for attribute ${attributePath}`,
+        );
+      }
+
+      if (transformedValue === undefined) {
+        throw new Error(
+          `perfect-payload:- transform must not return undefined for attribute ${attributePath}`,
+        );
+      }
+
+      attributeValue = transformedValue;
+    }
+    // TRANSFORMATIONS END
     for (const ruleName in attributeRules) {
       switch (ruleName) {
         // ==================================================
@@ -674,6 +745,9 @@ function perfectPayloadStructured(
             if (isArray(attributeValue) && attributeValue.length > 0) {
               let elementError = null;
 
+              // Clone so original payload array is not mutated
+              const transformedArray = [...attributeValue];
+
               for (
                 let elementIndex = 0;
                 elementIndex < attributeValue.length;
@@ -681,7 +755,10 @@ function perfectPayloadStructured(
               ) {
                 const element = attributeValue[elementIndex];
 
-                const { errors = [] } = perfectPayloadStructured(
+                const {
+                  errors = [],
+                  validatedPayload: elementValidatedPayload,
+                } = perfectPayloadStructured(
                   {
                     [attributeName]: element,
                   },
@@ -714,17 +791,63 @@ function perfectPayloadStructured(
 
                   break;
                 }
+
+                // Preserve the transformed element
+                transformedArray[elementIndex] =
+                  elementValidatedPayload?.[attributeName];
               }
 
               if (elementError) {
                 rowErrors.push(elementError);
                 addNextError = false;
+              } else {
+                // All elements passed, so use transformed values
+                attributeValue = transformedArray;
               }
             }
           }
 
           break;
 
+        case "minItems":
+          if (
+            addNextError &&
+            attrExist &&
+            attributeValue !== null &&
+            isArray(attributeValue) &&
+            attributeValue.length < attributeRules[ruleName]
+          ) {
+            addStructuredError(
+              rowErrors,
+              attributePath,
+              "MIN_ITEMS",
+              `Attribute ${attributePath} must contain at least ${attributeRules[ruleName]} item(s)`,
+            );
+
+            addNextError = false;
+          }
+
+          break;
+
+        case "maxItems":
+          if (
+            addNextError &&
+            attrExist &&
+            attributeValue !== null &&
+            isArray(attributeValue) &&
+            attributeValue.length > attributeRules[ruleName]
+          ) {
+            addStructuredError(
+              rowErrors,
+              attributePath,
+              "MAX_ITEMS",
+              `Attribute ${attributePath} must contain at most ${attributeRules[ruleName]} item(s)`,
+            );
+
+            addNextError = false;
+          }
+
+          break;
         // ==================================================
         // REGEX
         // ==================================================
@@ -759,7 +882,10 @@ function perfectPayloadStructured(
 
               switch (expectedType) {
                 case "number":
-                  if (!isNumber(attributeValue)) {
+                  if (
+                    !isNumber(attributeValue) ||
+                    Number.isNaN(attributeValue)
+                  ) {
                     addStructuredError(
                       rowErrors,
                       attributePath,
@@ -776,7 +902,6 @@ function perfectPayloadStructured(
                   }
 
                   break;
-
                 case "string":
                   if (!isString(attributeValue)) {
                     addStructuredError(
@@ -1200,24 +1325,29 @@ function perfectPayloadStructured(
         // ==================================================
         // NESTED OBJECT
         // ==================================================
-
         case "objectAttr":
           if (addNextError) {
-            const { errors = [] } = perfectPayloadStructured(
-              attributeValue,
-              attributeRules[ruleName],
-              { statusCode: 200, valid: true },
-              {
-                statusCode: 400,
-                valid: false,
-                message: "One or more attribute values are invalid",
-              },
-              attributePath,
-            );
+            const { errors = [], validatedPayload: nestedValidatedPayload } =
+              perfectPayloadStructured(
+                attributeValue,
+                attributeRules?.[ruleName],
+                {
+                  statusCode: 200,
+                  valid: true,
+                },
+                {
+                  statusCode: 400,
+                  valid: false,
+                  message: "One or more attribute values are invalid",
+                },
+                attributePath,
+              );
 
-            rowErrors = [...rowErrors, ...errors];
+            if (errors.length === 0) {
+              attributeValue = nestedValidatedPayload;
+            }
 
-            addNextError = true;
+            rowErrors = [...rowErrors, ...errors];
           }
 
           break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "perfect-payload",
-  "version": "1.3.0-beta.2",
+  "version": "1.5.0-beta.0",
   "type": "module",
   "description": "Lightweight JSON payload validation library with structured errors, nested validation, field paths, and customizable validation rules.",
   "main": "index.js",