Enhance robustness of data scrubbing with improved error handling (#60)

* Simplify replacement value logic in ScrubberService::autoSanitize using a ternary operator for better readability.
* Add try-catch in ScrubberService::autoSanitize to skip invalid regex patterns, preventing loop breaks.
* Update ScrubberService::patternChecker to safely update content only with non-null results from checkAndSanitize.
* Standardize nested structure handling in ProcessArrayTrait::processArrayRecursively to use recursive processing consistently.
* Wrap string sanitization in ProcessArrayTrait::processArrayRecursively with try-catch to skip problematic values.
* Enhance ProcessArrayTrait::processArray with comprehensive fallbacks for JSON encoding failures, sanitization exceptions, non-string content, and invalid JSON decoding, ensuring an array is always returned.

These changes are attempting to resolve the type exception reported in issue #50

Author: yordadev

src/Services/ScrubberService.php

@@ -49,22 +49,25 @@ public static function autoSanitize(string &$jsonContent): void
                 ? Secret::decrypt($regexClass->getPattern())
                 : $regexClass->getPattern();
 
-            if (method_exists($regexClass, 'getReplacementValue')) {
-                // Check if getReplacementValue() exists on the regex class and if it does, use it.
-                $replace = $regexClass->getReplacementValue();
-            } else {
-                // Otherwise, use the default replacement pattern.
-                $replace = config('scrubber.redaction');
-            }
+            $replace = method_exists($regexClass, 'getReplacementValue')
+                ? $regexClass->getReplacementValue()
+                : config('scrubber.redaction');
 
-            self::patternChecker($pattern, $jsonContent, $replace);
+            try {
+                self::patternChecker($pattern, $jsonContent, $replace);
+            } catch (\Exception $e) {
+                // Skip this regex $pattern to prevent breaking the autoSanitizer loop.
+            }
         });
     }
 
     protected static function patternChecker(string $regexPattern, string &$jsonContent, string $replace): void
     {
         $hits = 0;
-        $jsonContent = RegexRepository::checkAndSanitize($regexPattern, $replace, $jsonContent, $hits);
+        $result = RegexRepository::checkAndSanitize($regexPattern, $replace, $jsonContent, $hits);
+        if (! is_null($result)) {
+            $jsonContent = $result;
+        }
 
         /**
          * @todo

src/Strategies/ContentProcessingStrategy/Traits/ProcessArrayTrait.php

@@ -11,14 +11,16 @@ public function processArrayRecursively(array $content): array
         foreach ($content as $key => $value) {
             if ($value !== null) {
                 if (is_array($value)) {
-                    $content[$key] = $this->processArray($value);
+                    $content[$key] = $this->processArrayRecursively($value);
                 } elseif (is_object($value) && ! method_exists($value, '__toString')) {
-                    $content[$key] = $this->processArray((array) $value);
+                    $content[$key] = $this->processArrayRecursively((array) $value);
                 } else {
                     $value = (string) $value;
-
-                    ScrubberService::autoSanitize($value);
-
+                    try {
+                        ScrubberService::autoSanitize($value);
+                    } catch (\Exception $e) {
+                        // Skip sanitization for this value to prevent breaking the array
+                    }
                     $content[$key] = $value;
                 }
             }
@@ -35,8 +37,22 @@ public function processArray(array $content): array
             return $this->processArrayRecursively($content);
         }
 
-        ScrubberService::autoSanitize($jsonContent);
+        try {
+            ScrubberService::autoSanitize($jsonContent);
+
+        } catch (\Exception $e) {
+            return $this->processArrayRecursively($content);
+        }
+
+        if (! is_string($jsonContent)) {
+            return $this->processArrayRecursively($content);
+        }
+
+        $decoded = ScrubberService::decodeRecord($jsonContent);
+        if ($decoded === null) {
+            return $this->processArrayRecursively($content);
+        }
 
-        return ScrubberService::decodeRecord($jsonContent);
+        return $decoded;
     }
 }