Merge pull request #63 from MortalFlesh/feature/apply-function

Add apply function

Author: MortalFlesh

src/ApiFilter.php

@@ -7,13 +7,17 @@
 use Lmc\ApiFilter\Constant\Priority;
 use Lmc\ApiFilter\Entity\Filterable;
 use Lmc\ApiFilter\Exception\ApiFilterExceptionInterface;
+use Lmc\ApiFilter\Exception\TupleException;
 use Lmc\ApiFilter\Filter\FilterInterface;
 use Lmc\ApiFilter\Filters\FiltersInterface;
 use Lmc\ApiFilter\Service\FilterApplicator;
 use Lmc\ApiFilter\Service\FilterFactory;
 use Lmc\ApiFilter\Service\FunctionCreator;
 use Lmc\ApiFilter\Service\Functions;
 use Lmc\ApiFilter\Service\QueryParametersParser;
+use MF\Collection\Exception\TupleExceptionInterface;
+use MF\Collection\Immutable\ITuple;
+use MF\Collection\Immutable\Tuple;
 
 class ApiFilter
 {
@@ -288,4 +292,42 @@ public function executeFunction(string $functionName, array $queryParameters, $f
             ->execute($functionName, $filters, new Filterable($filterable))
             ->getValue();
     }
+
+    /**
+     * Apply a function with parsed query parameters and prepare values
+     *
+     * It will parse filters and apply registered function with parsed filters + prepare values for applied function
+     *
+     * @example
+     * Applying a function directly on filterable
+     * [$sql, $preparedValues] = $apiFilter
+     *      ->declareFunction('fullName', ['firstName', 'surname'])
+     *      ->applyFunction('fullName', ['fullName' => '(Jon, Snow)'], 'SELECT * FROM person');
+     *
+     * $sql:            SELECT * FROM person WHERE firstName = :firstName_function_parameter AND surname = :surname_function_parameter
+     * $preparedValues: ['firstName_function_parameter' => 'Jon', 'surname_function_parameter' => 'Snow']
+     *
+     * @see ApiFilter::declareFunction()
+     * @see ApiFilter::registerFunction()
+     * @see ApiFilter::executeFunction() if you just want to bypass ApiFilter applicators
+     *
+     * @param mixed $filterable of type <T>
+     * @throws ApiFilterExceptionInterface
+     * @return ITuple (<U>, array) where <U> is the output of the registered function and array contains prepared values
+     */
+    public function applyFunction(string $functionName, array $queryParameters, $filterable): ITuple
+    {
+        try {
+            $filters = $this->parser->parse($queryParameters);
+            $this->applicator->setFilters($filters);
+            $filterable = new Filterable($filterable);
+
+            $appliedFilterable = $this->functions->execute($functionName, $filters, $filterable);
+            $preparedValues = $this->applicator->getPreparedValues($filters, $filterable);
+
+            return Tuple::of($appliedFilterable->getValue(), $preparedValues);
+        } catch (TupleExceptionInterface $e) {
+            throw TupleException::forBaseTupleException($e);
+        }
+    }
 }

src/Filters/Filters.php

@@ -5,6 +5,7 @@
 use Lmc\ApiFilter\Applicator\ApplicatorInterface;
 use Lmc\ApiFilter\Assertion;
 use Lmc\ApiFilter\Entity\Filterable;
+use Lmc\ApiFilter\Filter\FilterFunction;
 use Lmc\ApiFilter\Filter\FilterIn;
 use Lmc\ApiFilter\Filter\FilterInterface;
 use Lmc\ApiFilter\Filter\FunctionParameter;
@@ -48,11 +49,19 @@ public function getIterator(): iterable
         yield from $this->filters;
     }
 
-    public function getPreparedValues(ApplicatorInterface $applicator): array
-    {
+    public function getPreparedValues(
+        ApplicatorInterface $applicator,
+        callable $findParametersForFunction,
+        callable $findParameterDefinitions
+    ): array {
         $preparedValues = [];
         foreach ($this->filters as $filter) {
-            $preparedValues += $applicator->getPreparedValue($filter);
+            $preparedValues += $filter instanceof FilterFunction
+                ? $applicator->getPreparedValuesForFunction(
+                    $findParametersForFunction($filter),
+                    $findParameterDefinitions($filter)
+                )
+                : $applicator->getPreparedValue($filter);
         }
 
         return $preparedValues;

src/Filters/FiltersInterface.php

@@ -16,7 +16,15 @@ interface FiltersInterface extends IEnumerable
      */
     public function applyAllTo(Filterable $filterable, FilterApplicator $filterApplicator): Filterable;
 
-    public function getPreparedValues(ApplicatorInterface $applicator): array;
+    /**
+     * @param callable $findParametersForFunction (FilterFunction): FunctionParameter[]
+     * @param callable $findParameterDefinitions (FilterFunction): ParameterDefinition[]
+     */
+    public function getPreparedValues(
+        ApplicatorInterface $applicator,
+        callable $findParametersForFunction,
+        callable $findParameterDefinitions
+    ): array;
 
     public function hasFilter(FilterInterface $filter): bool;
 

src/Service/FilterApplicator.php

@@ -98,6 +98,14 @@ public function applyAll(FiltersInterface $filters, Filterable $filterable): Fil
 
     public function getPreparedValues(FiltersInterface $filters, Filterable $filterable): array
     {
-        return $filters->getPreparedValues($this->findApplicatorFor($filterable));
+        return $filters->getPreparedValues(
+            $this->findApplicatorFor($filterable),
+            function (FilterFunction $filterFunction) {
+                return $this->getParametersForFunction($filterFunction);
+            },
+            function (FilterFunction $filterFunction) {
+                return $this->functions->getParameterDefinitionsFor($filterFunction->getColumn());
+            }
+        );
     }
 }

src/Service/QueryParametersParser.php

@@ -4,6 +4,7 @@
 
 use Lmc\ApiFilter\Constant\Priority;
 use Lmc\ApiFilter\Exception\TupleException;
+use Lmc\ApiFilter\Filter\FilterInterface;
 use Lmc\ApiFilter\Filters\Filters;
 use Lmc\ApiFilter\Filters\FiltersInterface;
 use Lmc\ApiFilter\Service\Parser\FunctionParser;
@@ -64,6 +65,7 @@ public function parse(array $queryParameters): FiltersInterface
         }
     }
 
+    /** @return FilterInterface[] */
     private function parseFilters(array $queryParameters): iterable
     {
         foreach ($queryParameters as $rawColumn => $rawValue) {

tests/AbstractTestCase.php

@@ -32,7 +32,7 @@ protected function assertDqlWhere(?array $expectedDqlWhere, QueryBuilder $queryB
         if ($expectedDqlWhere === null) {
             $this->assertNull($where);
         } else {
-            $this->assertSame($expectedDqlWhere, $where->getParts());
+            $this->assertSameValues($expectedDqlWhere, $where->getParts());
         }
     }
 
@@ -63,4 +63,20 @@ protected function iteratorToArray(iterable $iterable): array
 
         return $result;
     }
+
+    protected function assertSameValues(array $expected, array $actual): void
+    {
+        if (!empty($expected)) {
+            [$key] = array_keys($expected);
+            if (is_int($key)) {
+                sort($expected);
+                sort($actual);
+            } else {
+                asort($expected);
+                asort($actual);
+            }
+        }
+
+        $this->assertSame($expected, $actual);
+    }
 }