Check accepted types of filter

Map accepted types to PHP types
Test scalar transformation filter

Author: wol-soft

docs/source/nonStandardExtensions/filter.rst

@@ -23,6 +23,8 @@ Filters can be either supplied as a string or as a list of filters (multiple fil
         }
     }
 
+If the implementation of a filter throws an exception this exception will be caught by the generated model. The model will either throw the exception directly or insert it into the error collection based on your GeneratorConfiguration (compare `collecting errors <../gettingStarted.html#collect-errors-vs-early-return>`__). This behaviour also allows you to hook into the validation process and execute extended validations on the provided property.
+
 If multiple filters are applied to a single property they will be executed in the order of their definition inside the JSON Schema.
 
 If a list is used filters may include additional option parameters. In this case a single filter must be provided as an object with the key **filter** defining the filter:
@@ -208,6 +210,8 @@ The callable filter method must be a static method. Internally it will be called
 
         public function getAcceptedTypes(): array
         {
+            // return an array of types which can be handled by the filter.
+            // valid types are: [integer, number, boolean, string, array]
             return ['string'];
         }
 
@@ -287,8 +291,7 @@ The option will be available if your JSON-Schema uses the object-notation for th
 Custom transforming filter
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-If you want to provide a custom filter which transforms a value (eg. redirect data into a manually written model) you must implement the **PHPModelGenerator\\PropertyProcessor\\Filter\\TransformingFilterInterface**. This interface adds the **getSerializer** method to your filter. The method is similar to the **getFilter** method. It must return a callable which is available during the render process as well as during code execution. The returned callable must return null or a string and undo a transformation (eg. the serializer method of the builtin **dateTime** filter transforms a DateTime object back into a formatted string). The serializer method will be called with the current value of the property as the first argument and with the (optionally provided) additional options of the filter as the second argument. Your custom transforming filter might look like:
-
+If you want to provide a custom filter which transforms a value (eg. redirect data into a manually written model, transforming between data types [eg. accepting values as an integer but handle them internally as binary strings]) you must implement the **PHPModelGenerator\\PropertyProcessor\\Filter\\TransformingFilterInterface**. This interface adds the **getSerializer** method to your filter. The method is similar to the **getFilter** method. It must return a callable which is available during the render process as well as during code execution. The returned callable must return null or a string and undo a transformation (eg. the serializer method of the builtin **dateTime** filter transforms a DateTime object back into a formatted string). The serializer method will be called with the current value of the property as the first argument and with the (optionally provided) additional options of the filter as the second argument. Your custom transforming filter might look like:
 
 .. code-block:: php
 

src/Model/GeneratorConfiguration.php

@@ -84,6 +84,12 @@ public function addFilter(FilterInterface $filter): self
             }
         }
 
+        if (array_diff($filter->getAcceptedTypes(), ['integer', 'number', 'boolean', 'string', 'array'])) {
+            throw new InvalidFilterException(
+                'Filter accepts invalid types. Allowed types are [integer, number, boolean, string, array]'
+            );
+        }
+
         $this->filter[$filter->getToken()] = $filter;
 
         return $this;

src/Model/Validator/FilterValidator.php

@@ -39,7 +39,7 @@ public function __construct(
     ) {
         if (!empty($filter->getAcceptedTypes()) &&
             $property->getType() &&
-            !in_array($property->getType(), $filter->getAcceptedTypes())
+            !in_array($property->getType(), $this->mapDataTypes($filter->getAcceptedTypes()))
         ) {
             throw new SchemaException(
                 sprintf(
@@ -63,7 +63,7 @@ public function __construct(
                 // check if the given value has a type matched by the filter
                 'typeCheck' => !empty($filter->getAcceptedTypes())
                     ? '($value !== null && (!is_' .
-                        implode('($value) && !is_', $filter->getAcceptedTypes()) .
+                        implode('($value) && !is_', $this->mapDataTypes($filter->getAcceptedTypes())) .
                         '($value)))'
                     : '',
                 'filterClass' => $filter->getFilter()[0],
@@ -103,12 +103,34 @@ public function addTransformedCheck(
 
         if ($typeAfterFilter &&
             $typeAfterFilter->getName() &&
-            !in_array($typeAfterFilter->getName(), $filter->getAcceptedTypes())
+            !in_array($typeAfterFilter->getName(), $this->mapDataTypes($filter->getAcceptedTypes()))
         ) {
             $this->templateValues['skipTransformedValuesCheck'] =
                 (new ReflectionTypeCheckValidator($typeAfterFilter, $property, $schema))->getCheck();
         }
 
         return $this;
     }
+
+    /**
+     * Map a list of accepted data types to their corresponding PHP types
+     *
+     * @param array $acceptedTypes
+     *
+     * @return array
+     */
+    private function mapDataTypes(array $acceptedTypes): array
+    {
+        return array_map(function (string $jsonSchemaType): string {
+            switch ($jsonSchemaType) {
+                case 'integer': return 'int';
+                case 'number': return 'float';
+                case 'string': return 'string';
+                case 'boolean': return 'bool';
+                case 'array': return 'array';
+
+                default: throw new SchemaException("Invalid accepted type $jsonSchemaType");
+            }
+        }, $acceptedTypes);
+    }
 }

src/Templates/Serializer/TransformingFilterSerializer.phptpl

@@ -1,7 +1,7 @@
 /**
  * serialize the property {{ property }}
  */
-protected function serialize{{ viewHelper.ucfirst(property) }}(): ?string
+protected function serialize{{ viewHelper.ucfirst(property) }}()
 {
     return call_user_func_array(
         [\{{ serializerClass }}::class, "{{ serializerMethod }}"],

tests/Basic/FilterTest.php

@@ -59,6 +59,18 @@ public function invalidCustomFilterDataProvider(): array
         ];
     }
 
+    public function testFilterWithNotAllowedAcceptedTypeThrowsAnException(): void
+    {
+        $this->expectException(InvalidFilterException::class);
+        $this->expectExceptionMessage(
+            'Filter accepts invalid types. Allowed types are [integer, number, boolean, string, array]'
+        );
+
+        (new GeneratorConfiguration())->addFilter(
+            $this->getCustomFilter([self::class, 'uppercaseFilter'], 'customFilter', [DateTime::class])
+        );
+    }
+
     public function testNonExistingFilterThrowsAnException(): void
     {
         $this->expectException(SchemaException::class);
@@ -323,21 +335,46 @@ public function testAddFilterWithInvalidSerializerThrowsAnException(array $custo
     }
 
     protected function getCustomTransformingFilter(
-        array $customSerializer
+        array $customSerializer,
+        array $customFilter = [],
+        string $token = 'customTransformingFilter',
+        array $acceptedTypes = ['string']
     ): TransformingFilterInterface {
-        return new class ($customSerializer) extends TrimFilter implements TransformingFilterInterface {
+        return new class ($customSerializer, $customFilter, $token, $acceptedTypes)
+            extends TrimFilter
+            implements TransformingFilterInterface
+        {
             private $customSerializer;
+            private $customFilter;
+            private $token;
+            private $acceptedTypes;
 
-            public function __construct(array $customSerializer)
-            {
+            public function __construct(
+                array $customSerializer,
+                array $customFilter,
+                string $token,
+                array $acceptedTypes
+            ) {
                 $this->customSerializer = $customSerializer;
+                $this->customFilter = $customFilter;
+                $this->token = $token;
+                $this->acceptedTypes = $acceptedTypes;
+            }
+
+            public function getAcceptedTypes(): array
+            {
+                return $this->acceptedTypes;
             }
 
             public function getToken(): string
             {
-                return 'customTransformingFilter';
+                return $this->token;
             }
 
+            public function getFilter(): array
+            {
+                return empty($this->customFilter) ? parent::getFilter() : $this->customFilter;
+            }
             public function getSerializer(): array
             {
                 return $this->customSerializer;
@@ -499,4 +536,40 @@ public static function exceptionFilter(string $value): void
     {
         throw new Exception("Exception filter called with $value");
     }
+
+    public function testTransformingToScalarType()
+    {
+        $className = $this->generateClassFromFile(
+            'TransformingScalarFilter.json',
+            (new GeneratorConfiguration())
+                ->setSerialization(true)
+                ->addFilter(
+                    $this->getCustomTransformingFilter(
+                        [self::class, 'serializeBinaryToInt'],
+                        [self::class, 'filterIntToBinary'],
+                        'binary',
+                        ['integer']
+                    )
+                )
+        );
+
+        $object = new $className(['value' => 9]);
+
+        $this->assertSame('1001', $object->getValue());
+        $this->assertSame('1010', $object->setValue('1010')->getValue());
+        $this->assertSame('1011', $object->setValue(11)->getValue());
+
+        $this->assertSame(['value' => 11], $object->toArray());
+        $this->assertSame('{"value":11}', $object->toJSON());
+    }
+
+    public static function filterIntToBinary(int $value): string
+    {
+        return decbin($value);
+    }
+
+    public static function serializeBinaryToInt(string $binary): int
+    {
+        return bindec($binary);
+    }
 }

tests/Schema/FilterTest/TransformingScalarFilter.json

@@ -0,0 +1,9 @@
+{
+  "type": "object",
+  "properties": {
+    "value": {
+      "type": "integer",
+      "filter": "binary"
+    }
+  }
+}