commit: feat(processor-pipeline): add domain-specific exception handling

composer.json

@@ -22,7 +22,9 @@
   "require": {
     "php": "^8.3",
     "kariricode/data-structure": "^1.1",
-    "kariricode/contract": "^2.7"
+    "kariricode/contract": "^2.7",
+    "kariricode/property-inspector": "^1.0",
+    "kariricode/exception": "^1.2"
   },
   "autoload": {
     "psr-4": {

src/Exception/ProcessingException.php

@@ -4,6 +4,30 @@
 
 namespace KaririCode\ProcessorPipeline\Exception;
 
-final class ProcessingException extends \RuntimeException
+use KaririCode\Exception\AbstractException;
+
+final class ProcessingException extends AbstractException
 {
+    private const CODE_PIPELINE_FAILED = 3001;
+    private const CODE_PROCESSOR_FAILED = 3002;
+
+    public static function pipelineExecutionFailed(): self
+    {
+        return self::createException(
+            self::CODE_PIPELINE_FAILED,
+            'PIPELINE_FAILED',
+            'Pipeline processing failed'
+        );
+    }
+
+    public static function processorExecutionFailed(string $processorClass): self
+    {
+        $message = sprintf('Processor %s execution failed', $processorClass);
+
+        return self::createException(
+            self::CODE_PROCESSOR_FAILED,
+            'PROCESSOR_FAILED',
+            $message
+        );
+    }
 }

src/Exception/ProcessorRuntimeException.php

@@ -0,0 +1,62 @@
+<?php
+
+declare(strict_types=1);
+
+namespace KaririCode\ProcessorPipeline\Exception;
+
+use KaririCode\Exception\Runtime\RuntimeException;
+
+final class ProcessorRuntimeException extends RuntimeException
+{
+    private const CODE_CONTEXT_NOT_FOUND = 2601;
+    private const CODE_PROCESSOR_NOT_FOUND = 2602;
+    private const CODE_INVALID_PROCESSOR = 2603;
+    private const CODE_INVALID_CONTEXT = 2604;
+    private const CODE_PROCESSOR_CONFIG_INVALID = 2605;
+    private const ERROR_PREFIX = 'PROCESSOR';
+
+    public static function contextNotFound(string $context): self
+    {
+        return self::createException(
+            self::CODE_CONTEXT_NOT_FOUND,
+            self::ERROR_PREFIX . '_CONTEXT_NOT_FOUND',
+            "Processor context '{$context}' not found"
+        );
+    }
+
+    public static function processorNotFound(string $processorName, string $context): self
+    {
+        return self::createException(
+            self::CODE_PROCESSOR_NOT_FOUND,
+            self::ERROR_PREFIX . '_NOT_FOUND',
+            "Processor '{$processorName}' not found in context '{$context}'"
+        );
+    }
+
+    public static function invalidProcessor(string $processorName, string $details): self
+    {
+        return self::createException(
+            self::CODE_INVALID_PROCESSOR,
+            self::ERROR_PREFIX . '_INVALID',
+            "Invalid processor '{$processorName}': {$details}"
+        );
+    }
+
+    public static function invalidContext(string $context, string $details): self
+    {
+        return self::createException(
+            self::CODE_INVALID_CONTEXT,
+            self::ERROR_PREFIX . '_CONTEXT_INVALID',
+            "Invalid processor context '{$context}': {$details}"
+        );
+    }
+
+    public static function invalidConfiguration(string $processorName, string $details): self
+    {
+        return self::createException(
+            self::CODE_PROCESSOR_CONFIG_INVALID,
+            self::ERROR_PREFIX . '_CONFIG_INVALID',
+            "Invalid processor configuration for '{$processorName}': {$details}"
+        );
+    }
+}

src/Handler/ProcessorAttributeHandler.php

@@ -0,0 +1,102 @@
+<?php
+
+declare(strict_types=1);
+
+namespace KaririCode\ProcessorPipeline\Handler;
+
+use KaririCode\Contract\Processor\ProcessorBuilder;
+use KaririCode\Contract\Processor\ValidatableProcessor;
+use KaririCode\ProcessorPipeline\Result\ProcessedData;
+use KaririCode\ProcessorPipeline\Result\ProcessingError;
+use KaririCode\ProcessorPipeline\Result\ProcessingResultCollection;
+use KaririCode\PropertyInspector\AttributeHandler;
+
+class ProcessorAttributeHandler extends AttributeHandler
+{
+    protected ProcessingResultCollection $results;
+
+    public function __construct(
+        private readonly string $identifier,
+        private readonly ProcessorBuilder $builder
+    ) {
+        parent::__construct($identifier, $builder);
+        $this->results = new ProcessingResultCollection();
+    }
+
+    public function processPropertyValue(string $property, mixed $value): mixed
+    {
+        $pipeline = $this->builder->buildPipeline(
+            $this->identifier,
+            $this->getPropertyProcessors($property)
+        );
+
+        try {
+            $processedValue = $pipeline->process($value);
+            $this->storeProcessedValue($property, $processedValue);
+
+            // Verifica se há erros de validação
+            $this->checkValidationErrors($property, $pipeline);
+
+            return $processedValue;
+        } catch (\Exception $e) {
+            $this->storeProcessingError($property, $e);
+
+            return $value;
+        }
+    }
+
+    protected function checkValidationErrors(string $property, $pipeline): void
+    {
+        foreach ($pipeline->getProcessors() as $processor) {
+            if ($processor instanceof ValidatableProcessor && !$processor->isValid()) {
+                $this->storeValidationError(
+                    $property,
+                    $processor->getErrorKey(),
+                    $processor->getErrorMessage()
+                );
+            }
+        }
+    }
+
+    protected function storeProcessedValue(string $property, mixed $value): void
+    {
+        $processedData = new ProcessedData($property, $value);
+        $this->results->addProcessedData($processedData);
+    }
+
+    protected function storeProcessingError(string $property, \Exception $exception): void
+    {
+        $error = new ProcessingError(
+            $property,
+            'processingError',
+            $exception->getMessage()
+        );
+        $this->results->addError($error);
+    }
+
+    protected function storeValidationError(string $property, string $errorKey, string $message): void
+    {
+        $error = new ProcessingError($property, $errorKey, $message);
+        $this->results->addError($error);
+    }
+
+    public function getProcessingResults(): ProcessingResultCollection
+    {
+        return $this->results;
+    }
+
+    public function getProcessedPropertyValues(): array
+    {
+        return $this->results->getProcessedDataAsArray();
+    }
+
+    public function getProcessingResultErrors(): array
+    {
+        return $this->results->getErrorsAsArray();
+    }
+
+    public function reset(): void
+    {
+        $this->results = new ProcessingResultCollection();
+    }
+}

src/ProcessorBuilder.php

@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 namespace KaririCode\ProcessorPipeline;
 
 use KaririCode\Contract\Processor\ConfigurableProcessor;
@@ -24,9 +26,6 @@ public function build(string $context, string $name, array $processorConfig = []
         return $processor;
     }
 
-    /**
-     * @param array<string, mixed> $processorSpecs
-     */
     public function buildPipeline(string $context, array $processorSpecs): Pipeline
     {
         $pipeline = new ProcessorPipeline();