merged FieldFormatDefinition and RequestParamData - now all checks are done using Validators (except for nullability/required)

Author: eceltov

app/V1Module/presenters/base/BasePresenter.php

@@ -243,29 +243,9 @@ private function processParamsLoose(array $paramData)
             $paramValue = $this->getValueFromParamData($param);
             $formatInstanceArr[$param->name] = $paramValue;
 
-            // check if null
-            if ($paramValue === null) {
-                if ($param->required) {
-                    throw new InvalidArgumentException($param->name, "The parameter is required and cannot be null.");
-                }
-
-                if (!$param->nullable) {
-                    throw new InvalidArgumentException(
-                        $param->name,
-                        "The parameter is not nullable and thus cannot be null."
-                    );
-                }
-
-                // only non null values should be validated
-                continue;
-            }
-
-            // use every provided validator
-            foreach ($param->validators as $validator) {
-                if (!$validator->validate($paramValue)) {
-                    throw new InvalidArgumentException($param->name);
-                }
-            }
+            // this throws when it does not conform
+            $this->logger->log(var_export($param, true), ILogger::DEBUG);
+            $param->conformsToDefinition($paramValue);
         }
 
         // cast to stdClass
@@ -285,10 +265,7 @@ private function processParamsFormat(string $format)
 
         ///TODO: handle nested MetaFormat creation
         $formatInstance = MetaFormatHelper::createFormatInstance($format);
-        foreach ($nameToFieldDefinitionsMap as $fieldName => $fieldData) {
-            $requestParamData = $fieldData->requestData;
-            //$this->logger->log(var_export($requestParamData, true), ILogger::DEBUG);
-
+        foreach ($nameToFieldDefinitionsMap as $fieldName => $requestParamData) {
             $value = $this->getValueFromParamData($requestParamData);
 
             if (!$formatInstance->checkedAssign($fieldName, $value)) {

app/helpers/MetaFormats/FieldFormatDefinition.php

@@ -152,21 +152,15 @@ public static function createNameToFieldDefinitionsMap(string $className)
         $formats = [];
         foreach ($fields as $fieldName => $value) {
             $field = $class->getProperty($fieldName);
-            // the format can be null (not present)
-            $format = self::extractFormatFromAttribute($field);
-            // get null if there is no type
-            $reflectionType = $field->getType();
-            $fieldType = $reflectionType?->getName();
-            $nullable = $reflectionType?->allowsNull() ?? false;
-
             $requestParamData = self::extractFormatParameterData($field);
             if ($requestParamData === null) {
                 throw new InternalServerException(
                     "The field $fieldName of class $className does not have a RequestAttribute."
                 );
             }
 
-            $formats[$fieldName] = new FieldFormatDefinition($format, $fieldType, $nullable, $requestParamData);
+            ///TODO: add base type (PHP type of the field) validators to $requestParamData
+            $formats[$fieldName] = $requestParamData;
         }
 
         return $formats;

app/helpers/MetaFormats/MetaFormatHelper.php

@@ -2,6 +2,7 @@
 
 namespace App\Helpers\MetaFormats;
 
+use App\Exceptions\InvalidArgumentException;
 use App\Helpers\MetaFormats\Validators\StringValidator;
 use App\Helpers\Swagger\AnnotationParameterData;
 
@@ -30,6 +31,44 @@ public function __construct(
         $this->nullable = $nullable;
     }
 
+    /**
+     * Checks whether a value meets this definition.
+     * @param mixed $value The value to be checked.
+     * @throws \App\Exceptions\InvalidArgumentException Thrown when the value does not meet the definition.
+     * @return bool Returns whether the value passed the test.
+     */
+    public function conformsToDefinition(mixed $value)
+    {
+        // check if null
+        if ($value === null) {
+            if (!$this->required) {
+                ///TODO: what if a required param can be null? Does that mean that required & null is fine? How to check the required constrains then?
+                //throw new InvalidArgumentException($this->name, "The parameter is required and cannot be null.");
+                return true;
+            }
+
+            if (!$this->nullable) {
+                throw new InvalidArgumentException(
+                    $this->name,
+                    "The parameter is not nullable and thus cannot be null."
+                );
+            }
+
+            // only non null values should be validated
+            // (validators do not expect null)
+            return true;
+        }
+
+        // use every provided validator
+        foreach ($this->validators as $validator) {
+            if (!$validator->validate($value)) {
+                throw new InvalidArgumentException($this->name);
+            }
+        }
+
+        return true;
+    }
+
     public function toAnnotationParameterData()
     {
         $dataType = null;