PHPLIB-1273: Improve $switch syntax (#62)

alcaeus · web-flow · commit ceac70dc15b1 · 2024-02-02T15:32:36.000+01:00
* PHPLIB-1273: Improve $switch syntax * Restore previously deleted encoding type in schema * Introduce dedicated interface for branches in $switch * Remove optional parameter in encodeAsObject * Use case operator throughout tests
diff --git a/generator/config/expression/case.yaml b/generator/config/expression/case.yaml
@@ -0,0 +1,21 @@
+# $schema: ../schema.json
+name: $case
+link: 'https://www.mongodb.com/docs/manual/reference/operator/aggregation/switch/'
+type:
+    - switchBranch
+encode: flat_object
+description: |
+    Represents a single case in a $switch expression
+arguments:
+    -
+        name: case
+        type:
+            - resolvesToBool
+        description: |
+            Can be any valid expression that resolves to a boolean. If the result is not a boolean, it is coerced to a boolean value. More information about how MongoDB evaluates expressions as either true or false can be found here.
+    -
+        name: then
+        type:
+            - expression
+        description: |
+            Can be any valid expression.
diff --git a/generator/config/expression/switch.yaml b/generator/config/expression/switch.yaml
@@ -10,7 +10,7 @@ arguments:
     -
         name: branches
         type:
-            - array # of object{case:resolvesToBool, then:expression}
+            - array # of CaseOperator
         description: |
             An array of control branch documents. Each branch is a document with the following fields:
             - case Can be any valid expression that resolves to a boolean. If the result is not a boolean, it is coerced to a boolean value. More information about how MongoDB evaluates expressions as either true or false can be found here.
diff --git a/generator/config/expressions.php b/generator/config/expressions.php
@@ -113,6 +113,10 @@
         'returnType' => Type\GeometryInterface::class,
         'acceptedTypes' => [Type\GeometryInterface::class, ...$bsonTypes['object']],
     ],
+    'switchBranch' => [
+        'returnType' => Type\SwitchBranchInterface::class,
+        'acceptedTypes' => [Type\SwitchBranchInterface::class, ...$bsonTypes['object']],
+    ],
 
     // @todo add enum values
     'Granularity' => [
diff --git a/generator/config/schema.json b/generator/config/schema.json
@@ -29,6 +29,7 @@
                             "filter",
                             "window",
                             "geometry",
+                            "switchBranch",
                             "resolvesToAny",
                             "resolvesToNumber",
                             "resolvesToDouble",
@@ -59,6 +60,7 @@
                     "enum": [
                         "array",
                         "object",
+                        "flat_object",
                         "dollar_object",
                         "single",
                         "group"
diff --git a/generator/src/Definition/OperatorDefinition.php b/generator/src/Definition/OperatorDefinition.php
@@ -39,6 +39,7 @@ public function __construct(
             'single' => Encode::Single,
             'array' => Encode::Array,
             'object' => Encode::Object,
+            'flat_object' => Encode::FlatObject,
             'dollar_object' => Encode::DollarObject,
             'group' => Encode::Group,
             default => throw new UnexpectedValueException(sprintf('Unexpected "encode" value for operator "%s". Got "%s"', $name, $encode)),
diff --git a/src/Builder/Encoder/OperatorEncoder.php b/src/Builder/Encoder/OperatorEncoder.php
@@ -46,6 +46,7 @@ public function encode(mixed $value): stdClass
                 return $this->encodeAsArray($value);
 
             case Encode::Object:
+            case Encode::FlatObject:
                 return $this->encodeAsObject($value);
 
             case Encode::DollarObject:
@@ -107,7 +108,9 @@ private function encodeAsObject(OperatorInterface $value): stdClass
             $result->{$key} = $this->recursiveEncode($val);
         }
 
-        return $this->wrap($value, $result);
+        return $value::ENCODE === Encode::FlatObject
+            ? $result
+            : $this->wrap($value, $result);
     }
 
     private function encodeAsDollarObject(OperatorInterface $value): stdClass
diff --git a/src/Builder/Expression/CaseOperator.php b/src/Builder/Expression/CaseOperator.php
diff --git a/src/Builder/Expression/FactoryTrait.php b/src/Builder/Expression/FactoryTrait.php
diff --git a/src/Builder/Type/Encode.php b/src/Builder/Type/Encode.php
@@ -23,6 +23,11 @@ enum Encode
      */
     case Object;
 
+    /**
+     * Same as Object, but only parameters are returned. The operator name will not be used.
+     */
+    case FlatObject;
+
     /**
      * Parameters are encoded as an object with keys matching the parameter names prefixed with a dollar sign ($)
      */
diff --git a/src/Builder/Type/SwitchBranchInterface.php b/src/Builder/Type/SwitchBranchInterface.php
@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace MongoDB\Builder\Type;
+
+/**
+ * Interface for branches in $switch operators
+ *
+ * @see https://www.mongodb.com/docs/manual/reference/operator/aggregation/switch/
+ */
+interface SwitchBranchInterface
+{
+}
diff --git a/tests/Builder/Expression/ConvertOperatorTest.php b/tests/Builder/Expression/ConvertOperatorTest.php
@@ -10,8 +10,6 @@
 use MongoDB\Builder\Stage;
 use MongoDB\Tests\Builder\PipelineTestCase;
 
-use function MongoDB\object;
-
 /**
  * Test $convert expression
  */
@@ -43,7 +41,7 @@ public function testExample(): void
             Stage::project(
                 totalPrice: Expression::switch(
                     branches: [
-                        object(
+                        Expression::case(
                             case: Expression::eq(
                                 Expression::type(
                                     Expression::fieldPath('convertedPrice'),
@@ -52,7 +50,7 @@ public function testExample(): void
                             ),
                             then: 'NaN',
                         ),
-                        object(
+                        Expression::case(
                             case: Expression::eq(
                                 Expression::type(
                                     Expression::fieldPath('convertedQty'),
diff --git a/tests/Builder/Expression/IsNumberOperatorTest.php b/tests/Builder/Expression/IsNumberOperatorTest.php
@@ -10,8 +10,6 @@
 use MongoDB\Builder\Stage;
 use MongoDB\Tests\Builder\PipelineTestCase;
 
-use function MongoDB\object;
-
 /**
  * Test $isNumber expression
  */
@@ -28,35 +26,35 @@ public function testConditionallyModifyFieldsUsingIsNumber(): void
                     then: Expression::fieldPath('grade'),
                     else: Expression::switch(
                         branches: [
-                            object(
+                            Expression::case(
                                 case: Expression::eq(
                                     Expression::fieldPath('grade'),
                                     'A',
                                 ),
                                 then: 4,
                             ),
-                            object(
+                            Expression::case(
                                 case: Expression::eq(
                                     Expression::fieldPath('grade'),
                                     'B',
                                 ),
                                 then: 3,
                             ),
-                            object(
+                            Expression::case(
                                 case: Expression::eq(
                                     Expression::fieldPath('grade'),
                                     'C',
                                 ),
                                 then: 2,
                             ),
-                            object(
+                            Expression::case(
                                 case: Expression::eq(
                                     Expression::fieldPath('grade'),
                                     'D',
                                 ),
                                 then: 1,
                             ),
-                            object(
+                            Expression::case(
                                 case: Expression::eq(
                                     Expression::fieldPath('grade'),
                                     'F',
diff --git a/tests/Builder/Expression/SwitchOperatorTest.php b/tests/Builder/Expression/SwitchOperatorTest.php
@@ -9,8 +9,6 @@
 use MongoDB\Builder\Stage;
 use MongoDB\Tests\Builder\PipelineTestCase;
 
-use function MongoDB\object;
-
 /**
  * Test $switch expression
  */
@@ -23,7 +21,7 @@ public function testExample(): void
                 name: 1,
                 summary: Expression::switch(
                     branches: [
-                        object(
+                        Expression::case(
                             case: Expression::gte(
                                 Expression::avg(
                                     Expression::intFieldPath('scores'),
@@ -32,7 +30,7 @@ public function testExample(): void
                             ),
                             then: 'Doing great!',
                         ),
-                        object(
+                        Expression::case(
                             case:Expression::and(
                                 Expression::gte(
                                     Expression::avg(
@@ -49,7 +47,7 @@ public function testExample(): void
                             ),
                             then: 'Doing pretty well.',
                         ),
-                        object(
+                        Expression::case(
                             case: Expression::lt(
                                 Expression::avg(
                                     Expression::intFieldPath('scores'),
diff --git a/tests/Builder/Expression/ToBoolOperatorTest.php b/tests/Builder/Expression/ToBoolOperatorTest.php
@@ -9,8 +9,6 @@
 use MongoDB\Builder\Stage;
 use MongoDB\Tests\Builder\PipelineTestCase;
 
-use function MongoDB\object;
-
 /**
  * Test $toBool expression
  */
@@ -22,14 +20,14 @@ public function testExample(): void
             Stage::addFields(
                 convertedShippedFlag: Expression::switch(
                     branches: [
-                        object(
+                        Expression::case(
                             case: Expression::eq(
                                 Expression::fieldPath('shipped'),
                                 'false',
                             ),
                             then: false,
                         ),
-                        object(
+                        Expression::case(
                             case: Expression::eq(
                                 Expression::fieldPath('shipped'),
                                 '',

Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ arguments:`
`10`	`10`	`-`
`11`	`11`	`name: branches`
`12`	`12`	`type:`
`13`		`- - array # of object{case:resolvesToBool, then:expression}`
	`13`	`+ - array # of CaseOperator`
`14`	`14`	`description: \|`
`15`	`15`	`An array of control branch documents. Each branch is a document with the following fields:`
`16`	`16`	`- case Can be any valid expression that resolves to a boolean. If the result is not a boolean, it is coerced to a boolean value. More information about how MongoDB evaluates expressions as either true or false can be found here.`
Original file line number	Diff line number	Diff line change
`@@ -46,6 +46,7 @@ public function encode(mixed $value): stdClass`
`46`	`46`	`return $this->encodeAsArray($value);`
`47`	`47`
`48`	`48`	`case Encode::Object:`
	`49`	`+ case Encode::FlatObject:`
`49`	`50`	`return $this->encodeAsObject($value);`
`50`	`51`
`51`	`52`	`case Encode::DollarObject:`
`@@ -107,7 +108,9 @@ private function encodeAsObject(OperatorInterface $value): stdClass`
`107`	`108`	`$result->{$key} = $this->recursiveEncode($val);`
`108`	`109`	`}`
`109`	`110`
`110`		`- return $this->wrap($value, $result);`
	`111`	`+ return $value::ENCODE === Encode::FlatObject`
	`112`	`+ ? $result`
	`113`	`+ : $this->wrap($value, $result);`
`111`	`114`	`}`
`112`	`115`
`113`	`116`	`private function encodeAsDollarObject(OperatorInterface $value): stdClass`