Refactor query mapper

spec/EzSystems/EzPlatformGraphQL/GraphQL/InputMapper/Search/QueryBuilderSpec.php

@@ -0,0 +1,52 @@
+<?php
+
+namespace spec\EzSystems\EzPlatformGraphQL\GraphQL\InputMapper\Search;
+
+use eZ\Publish\API\Repository\Values\Content\Query;
+use eZ\Publish\API\Repository\Values\Content\Query\Criterion;
+use EzSystems\EzPlatformGraphQL\GraphQL\InputMapper\Search\QueryBuilder;
+use PhpSpec\ObjectBehavior;
+
+class QueryBuilderSpec extends ObjectBehavior
+{
+    function it_is_initializable()
+    {
+        $this->shouldHaveType(QueryBuilder::class);
+    }
+
+    function it_builds_a_query_when_no_citerion_is_defined()
+    {
+        $query = $this->buildQuery();
+        $query->shouldBeAnInstanceOf(Query::class);
+    }
+
+    function it_builds_a_query_when_only_one_criterion_is_criterion($criterion)
+    {
+        $criterion->beADoubleOf(Criterion::class);
+        $this->addCriterion($criterion);
+        $query = $this->buildQuery();
+        $query->filter->shouldBe($criterion);
+    }
+
+    function it_builds_a_query_when_more_than_criterion_is_passed($criterion1, $criterion2)
+    {
+        $criterion1->beADoubleOf(Criterion::class);
+        $criterion2->beADoubleOf(Criterion::class);
+
+        $this->addCriterion($criterion1);
+        $this->addCriterion($criterion2);
+
+        $query = $this->buildQuery();
+
+        $query->filter->shouldBeAnInstanceOf(Criterion\LogicalAnd::class);
+    }
+
+    function it_builds_a_query_with_sort_criterias($sortClause)
+    {
+        $sortClause->beADoubleOf(Query\SortClause::class);
+        $this->addSortClause($sortClause);
+
+        $query = $this->buildQuery();
+        $query->sortClauses->shouldBeArray();
+    }
+}

spec/EzSystems/EzPlatformGraphQL/GraphQL/InputMapper/SearchQueryMapperSpec.php

@@ -2,253 +2,51 @@
 
 namespace spec\EzSystems\EzPlatformGraphQL\GraphQL\InputMapper;
 
+use EzSystems\EzPlatformGraphQL\GraphQL\InputMapper\Search\QueryBuilder;
+use EzSystems\EzPlatformGraphQL\GraphQL\InputMapper\Search\QueryInputVisitor;
 use EzSystems\EzPlatformGraphQL\GraphQL\InputMapper\SearchQueryMapper;
-use DateTime;
-use eZ\Publish\API\Repository\Values\Content\Query;
-use eZ\Publish\Core\REST\Server\Input\Parser\Criterion\Operator;
 use PhpSpec\ObjectBehavior;
+use Prophecy\Argument;
 
 class SearchQueryMapperSpec extends ObjectBehavior
 {
-    function it_is_initializable()
-    {
-        $this->shouldHaveType(SearchQueryMapper::class);
-    }
-
-    public function it_maps_ContentTypeIdentifier_to_a_ContentTypeIdentifier_criterion()
+    function let(QueryInputVisitor $visitor1, QueryInputVisitor $visitor2, QueryBuilder $queryBuilder)
     {
-        $this->mapInputToQuery(['ContentTypeIdentifier' => ['article']])->shouldFilterByContentType(['article']);
+        $this->beConstructedWith(['visitor_1' => $visitor1, 'visitor_2' => $visitor2, 'visitor_3' => $visitor2], $queryBuilder);
     }
 
-    public function it_maps_Text_to_a_FullText_criterion()
-    {
-        $this
-            ->mapInputToQuery(['Text' => 'graphql'])
-            ->shouldFilterByFullText('graphql');
-    }
-
-    public function it_maps_Modified_before_to_a_created_lte_DateMetaData_criterion()
-    {
-        $this
-            ->mapInputToQuery(['Modified' => ['before' => '1977/05/04']])
-            ->shouldFilterByDateModified(Query\Criterion\Operator::LTE, '1977/05/04');
-    }
-
-    public function it_maps_Modified_on_to_a_created_eq_DateMetaData_criterion()
-    {
-        $this
-            ->mapInputToQuery(['Modified' => ['on' => '1977/05/04']])
-            ->shouldFilterByDateModified(Query\Criterion\Operator::EQ, '1977/05/04');
-    }
-
-    public function it_maps_Modified_after_to_a_created_gte_DateMetaData_criterion()
-    {
-        $this
-            ->mapInputToQuery(['Modified' => ['after' => '1977/05/04']])
-            ->shouldFilterByDateModified(Query\Criterion\Operator::GTE, '1977/05/04');
-    }
-
-    public function it_maps_Created_before_to_a_created_lte_DateMetaData_criterion()
-    {
-        $this
-            ->mapInputToQuery(['Created' => ['before' => '1977/05/04']])
-            ->shouldFilterByDateCreated(Query\Criterion\Operator::LTE, '1977/05/04');
-    }
-
-    public function it_maps_Created_on_to_a_created_eq_DateMetaData_criterion()
-    {
-        $this
-            ->mapInputToQuery(['Created' => ['on' => '1977/05/04']])
-            ->shouldFilterByDateCreated(Query\Criterion\Operator::EQ, '1977/05/04');
-    }
-
-    public function it_maps_Created_after_to_a_created_gte_DateMetaData_criterion()
-    {
-        $this
-            ->mapInputToQuery(['Created' => ['after' => '1977/05/04']])
-            ->shouldFilterByDateCreated(Query\Criterion\Operator::GTE, '1977/05/04');
-    }
-
-    function it_maps_Field_to_a_Field_criterion()
-    {
-        $this
-            ->mapInputToQuery(['Field' => ['target' => 'target_field', 'eq' => 'bar']])
-            ->shouldFilterByField('target_field');
-    }
-
-    function it_maps_Field_target_to_the_Field_criterion_target()
-    {
-        $this
-            ->mapInputToQuery(['Field' => ['target' => 'target_field', 'eq' => 'bar']])
-            ->shouldFilterByField('target_field', Query\Criterion\Operator::EQ, 'bar');
-    }
-
-    function it_maps_Field_with_value_at_operator_key_to_the_Field_criterion_value()
-    {
-        $this
-            ->mapInputToQuery(['Field' => ['target' => 'target_field', 'eq' => 'bar']])
-            ->shouldFilterByField('target_field', null, 'bar');
-    }
-
-    function it_maps_Field_operator_eq_to_Field_criterion_operator_EQ()
-    {
-        $this
-            ->mapInputToQuery(['Field' => ['target' => 'target_field', 'eq' => 'bar']])
-            ->shouldFilterByFieldWithOperator(Query\Criterion\Operator::EQ);
-    }
-
-    function it_maps_Field_operator_in_to_Field_criterion_operator_IN()
-    {
-        $this
-            ->mapInputToQuery(['Field' => ['target' => 'target_field', 'eq' => 'bar']])
-            ->shouldFilterByFieldWithOperator(Query\Criterion\Operator::EQ);
-    }
-
-    function it_maps_Field_operator_lt_to_Field_criterion_operator_LT()
-    {
-        $this
-            ->mapInputToQuery(['Field' => ['target' => 'target_field', 'lt' => 'bar']])
-            ->shouldFilterByFieldWithOperator(Query\Criterion\Operator::LT);
-    }
-
-    function it_maps_Field_operator_lte_to_Field_criterion_operator_LTE()
-    {
-        $this
-            ->mapInputToQuery(['Field' => ['target' => 'target_field', 'lte' => 'bar']])
-            ->shouldFilterByFieldWithOperator(Query\Criterion\Operator::LTE);
-    }
-
-    function it_maps_Field_operator_gte_to_Field_criterion_operator_GTE()
-    {
-        $this
-            ->mapInputToQuery(['Field' => ['target' => 'target_field', 'gte' => 'bar']])
-            ->shouldFilterByFieldWithOperator(Query\Criterion\Operator::GTE);
-    }
-
-    function it_maps_Field_operator_gt_to_Field_criterion_operator_GT()
-    {
-        $this
-            ->mapInputToQuery(['Field' => ['target' => 'target_field', 'gt' => 'bar']])
-            ->shouldFilterByFieldWithOperator(Query\Criterion\Operator::GT);
-    }
-
-    function it_maps_Field_operator_between_to_Field_criterion_operator_BETWEEN()
+    function it_is_initializable()
     {
-        $this
-            ->mapInputToQuery(['Field' => ['target' => 'target_field', 'between' => [10, 20]]])
-            ->shouldFilterByFieldWithOperator(Query\Criterion\Operator::BETWEEN);
+        $this->shouldHaveType(SearchQueryMapper::class);
     }
 
-    public function getMatchers(): array
-    {
-        return [
-            'filterByContentType' => function(Query $query, array $contentTypes) {
-                $criterion = $this->findCriterionInQueryFilter(
-                    $query,
-                    Query\Criterion\ContentTypeIdentifier::class
-                );
-
-                if ($criterion === null) {
-                    return false;
-                }
-
-                return $criterion->value === $contentTypes;
-            },
-            'filterByFullText' => function(Query $query, $text) {
-                $criterion = $this->findCriterionInQueryFilter(
-                    $query,
-                    Query\Criterion\FullText::class
-                );
-
-                if ($criterion === null) {
-                    return false;
-                }
-
-                return $criterion->value === $text;
-            },
-            'filterByDateModified' => function(Query $query, $operator, $date) {
-                $criterion = $this->findCriterionInQueryFilter($query, Query\Criterion\DateMetadata::class);
-
-                if ($criterion === null) {
-                    return false;
-                }
-
-                if ($criterion->target !== Query\Criterion\DateMetadata::MODIFIED) {
-                    return false;
-                }
-
-                return $criterion->operator == $operator
-                    && $criterion->value[0] == strtotime($date);
-            },
-            'filterByDateCreated' => function(Query $query, $operator, $date) {
-                $criterion = $this->findCriterionInQueryFilter($query, Query\Criterion\DateMetadata::class);
-
-                if ($criterion === null) {
-                    return false;
-                }
+    function it_uses_one_visitor_and_not_the_other(
+        QueryInputVisitor $visitor1,
+        QueryInputVisitor $visitor2,
+        QueryBuilder $queryBuilder
+    ) {
+        $queryBuilder->buildQuery()->shouldBeCalledOnce();
 
-                if ($criterion->target !== Query\Criterion\DateMetadata::CREATED) {
-                    return false;
-                }
+        $visitor1->visit($queryBuilder, 'a_value')->shouldBeCalled();
+        $visitor2->visit()->shouldNotBeCalled();
 
-                return $criterion->operator == $operator
-                    && $criterion->value[0] == strtotime($date);
-            },
-            'filterByField' => function(Query $query, $field, $operator = null, $value = null) {
-                $criterion = $this->findCriterionInQueryFilter($query, Query\Criterion\Field::class);
-
-                if ($criterion === null) {
-                    return false;
-                }
-
-                if ($criterion->target !== $field) {
-                    return false;
-                }
-
-                if ($operator !== null && $criterion->operator != $operator) {
-                    return false;
-                }
-                return ($value === null || $criterion->value == $value);
-            },
-            'filterByFieldWithOperator' => function(Query $query, $operator) {
-                $criterion = $this->findCriterionInQueryFilter($query, Query\Criterion\Field::class);
-                if ($criterion === null) {
-                    return false;
-                }
-
-                return $criterion->operator == $operator;
-            }
-        ];
+        $this->mapInputToQuery(['visitor_1' => 'a_value']);
     }
 
-    private function findCriterionInQueryFilter(Query $query, $searchedCriterionClass)
-    {
-        if ($query->filter instanceof Query\Criterion\LogicalOperator) {
-            return $this->findCriterionInCriterion($query->filter, $searchedCriterionClass);
-        } else {
-            if ($query->filter instanceof $searchedCriterionClass) {
-                return $query->filter;
-            }
-        }
-
-        return null;
-    }
-
-    private function findCriterionInCriterion(Query\Criterion\LogicalOperator $logicalCriterion, $searchedCriterionClass)
-    {
-        foreach ($logicalCriterion->criteria as $criterion) {
-            if ($criterion instanceof Query\Criterion\LogicalOperator) {
-                $criterion = $this->findCriterionInCriterion($criterion, $searchedCriterionClass);
-                if ($criterion !== null) {
-                    return $criterion;
-                }
-            }
+    function it_visits_same_visitor_more_than_once(
+        QueryInputVisitor $visitor1,
+        QueryInputVisitor $visitor2,
+        QueryBuilder $queryBuilder
+    ) {
+        $queryBuilder->buildQuery()->shouldBeCalledOnce();
 
-            if ($criterion instanceof $searchedCriterionClass) {
-                return $criterion;
-            }
-        }
+        $visitor1->visit($queryBuilder, 'a_value')->shouldBeCalledOnce();
+        $visitor2->visit($queryBuilder, Argument::type('string'))->shouldBeCalledTimes(2);
 
-        return null;
+        $this->mapInputToQuery([
+            'visitor_1' => 'a_value',
+            'visitor_2' => 'value2',
+            'visitor_3' => 'value3'
+        ]);
     }
 }

spec/EzSystems/EzPlatformGraphQL/Schema/Domain/Content/Worker/ContentType/AddDomainContentCollectionToDomainGroupSpec.php

@@ -89,7 +89,7 @@ function it_adds_a_collection_field_for_the_ContentType_to_the_ContentTypeGroup(
                 self::COLLECTION_FIELD,
                 Argument::allOf(
                     FieldArgArgument::withName('sortBy'),
-                    FieldArgArgument::withType('[SortByOptions]')
+                    FieldArgArgument::withType('SortByOptions∫')
                 )
             )
             ->shouldBeCalled();

src/DependencyInjection/Compiler/SearchQueryMappersPass.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace EzSystems\EzPlatformGraphQL\DependencyInjection\Compiler;
+
+use EzSystems\EzPlatformGraphQL\GraphQL\InputMapper\SearchQueryMapper;
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Reference;
+
+class SearchQueryMappersPass implements CompilerPassInterface
+{
+    public function process(ContainerBuilder $container)
+    {
+        if (!$container->has(SearchQueryMapper::class)) {
+            return;
+        }
+
+        $definition = $container->findDefinition(SearchQueryMapper::class);
+        $criteriaTaggedServices = $container->findTaggedServiceIds('ezplatform_graphql.query_input_visitor');
+
+        $queryInputVisitors = [];
+        foreach ($criteriaTaggedServices as $id => $tags) {
+            foreach ($tags as $tag) {
+                if (isset($tag['inputKey'])) {
+                    $queryInputVisitors[$tag['inputKey']] = new Reference($id);
+                }
+            }
+        }
+
+        $definition->setArgument('$queryInputVisitors', $queryInputVisitors);
+    }
+}