Support dot syntax when preparing nested query values

Author: alcaeus

lib/Doctrine/ODM/MongoDB/Persisters/DocumentPersister.php

@@ -39,6 +39,7 @@
 use MongoDB\GridFS\Bucket;
 use stdClass;
 
+use function array_column;
 use function array_combine;
 use function array_fill;
 use function array_intersect_key;
@@ -1067,10 +1068,10 @@ public function prepareQueryOrNewObj(array $query, bool $isNewObj = false): arra
             }
 
             $preparedQueryElements = $this->prepareQueryElement($key, $value, null, true, $isNewObj);
-            foreach ($preparedQueryElements as [$preparedKey, $preparedValue]) {
-                $preparedValue               = $this->convertToDatabaseValue($key, $preparedValue);
-                $preparedQuery[$preparedKey] = $preparedValue;
-            }
+            $preparedQuery         = array_combine(
+                array_column($preparedQueryElements, 0),
+                array_column($preparedQueryElements, 1),
+            );
         }
 
         return $preparedQuery;
@@ -1083,8 +1084,10 @@ public function prepareQueryOrNewObj(array $query, bool $isNewObj = false): arra
      *
      * @return mixed
      */
-    private function convertToDatabaseValue(string $fieldName, $value)
+    private function convertToDatabaseValue(string $fieldName, $value, ?ClassMetadata $class = null)
     {
+        $class ??= $this->class;
+
         if (is_array($value)) {
             foreach ($value as $k => $v) {
                 if ($k === '$exists' || $k === '$type' || $k === '$currentDate') {
@@ -1097,15 +1100,15 @@ private function convertToDatabaseValue(string $fieldName, $value)
             return $value;
         }
 
-        if (! $this->class->hasField($fieldName)) {
+        if (! $class->hasField($fieldName)) {
             if ($value instanceof BackedEnum) {
                 $value = $value->value;
             }
 
             return Type::convertPHPToDatabaseValue($value);
         }
 
-        $mapping  = $this->class->fieldMappings[$fieldName];
+        $mapping  = $class->fieldMappings[$fieldName];
         $typeName = $mapping['type'];
 
         if (! empty($mapping['reference']) || ! empty($mapping['embedded'])) {
@@ -1143,15 +1146,15 @@ private function convertToDatabaseValue(string $fieldName, $value)
      *
      * @return array<array{string, mixed}>
      */
-    private function prepareQueryElement(string $fieldName, $value = null, ?ClassMetadata $class = null, bool $prepareValue = true, bool $inNewObj = false): array
+    private function prepareQueryElement(string $originalFieldName, $value = null, ?ClassMetadata $class = null, bool $prepareValue = true, bool $inNewObj = false): array
     {
         $class ??= $this->class;
 
         // @todo Consider inlining calls to ClassMetadata methods
 
         // Process all non-identifier fields by translating field names
-        if ($class->hasField($fieldName) && ! $class->isIdentifier($fieldName)) {
-            $mapping   = $class->fieldMappings[$fieldName];
+        if ($class->hasField($originalFieldName) && ! $class->isIdentifier($originalFieldName)) {
+            $mapping   = $class->fieldMappings[$originalFieldName];
             $fieldName = $mapping['name'];
 
             if (! $prepareValue) {
@@ -1176,7 +1179,7 @@ private function prepareQueryElement(string $fieldName, $value = null, ?ClassMet
 
             // No further preparation unless we're dealing with a simple reference
             if (empty($mapping['reference']) || $mapping['storeAs'] !== ClassMetadata::REFERENCE_STORE_AS_ID || empty((array) $value)) {
-                return [[$fieldName, $value]];
+                return [[$fieldName, $this->convertToDatabaseValue($originalFieldName, $value, $class)]];
             }
 
             // Additional preparation for one or more simple reference values
@@ -1195,7 +1198,7 @@ private function prepareQueryElement(string $fieldName, $value = null, ?ClassMet
         }
 
         // Process identifier fields
-        if (($class->hasField($fieldName) && $class->isIdentifier($fieldName)) || $fieldName === '_id') {
+        if (($class->hasField($originalFieldName) && $class->isIdentifier($originalFieldName)) || $originalFieldName === '_id') {
             $fieldName = '_id';
 
             if (! $prepareValue) {
@@ -1215,8 +1218,8 @@ private function prepareQueryElement(string $fieldName, $value = null, ?ClassMet
         }
 
         // No processing for unmapped, non-identifier, non-dotted field names
-        if (strpos($fieldName, '.') === false) {
-            return [[$fieldName, $value]];
+        if (strpos($originalFieldName, '.') === false) {
+            return [[$originalFieldName, $value]];
         }
 
         /* Process "fieldName.objectProperty" queries (on arrays or objects).
@@ -1225,11 +1228,11 @@ private function prepareQueryElement(string $fieldName, $value = null, ?ClassMet
          * significant: "fieldName.objectProperty" with an optional index or key
          * for collections stored as either BSON arrays or objects.
          */
-        $e = explode('.', $fieldName, 4);
+        $e = explode('.', $originalFieldName, 4);
 
         // No further processing for unmapped fields
         if (! isset($class->fieldMappings[$e[0]])) {
-            return [[$fieldName, $value]];
+            return [[$originalFieldName, $value]];
         }
 
         $mapping = $class->fieldMappings[$e[0]];
@@ -1246,6 +1249,7 @@ private function prepareQueryElement(string $fieldName, $value = null, ?ClassMet
             $mapping['type'] === ClassMetadata::MANY && CollectionHelper::isHash($mapping['strategy'])
                 && isset($e[2])
         ) {
+            $fieldName            = $originalFieldName;
             $objectProperty       = $e[2];
             $objectPropertyPrefix = $e[1] . '.';
             $nextObjectProperty   = implode('.', array_slice($e, 3));
@@ -1339,7 +1343,7 @@ private function prepareQueryElement(string $fieldName, $value = null, ?ClassMet
             }, $fieldNames);
         }
 
-        return [[$fieldName, $value]];
+        return [[$fieldName, $this->convertToDatabaseValue($objectProperty, $value, $targetClass)]];
     }
 
     /**

tests/Doctrine/ODM/MongoDB/Tests/Query/BuilderTest.php

@@ -837,6 +837,35 @@ public function testNonRewindable(): void
         self::assertInstanceOf(UnrewindableIterator::class, $query->execute());
     }
 
+    public function testQueryPreparesNestedValues(): void
+    {
+        $objectId  = new ObjectId();
+        $oidString = (string) $objectId;
+
+        $embedded           = new EmbeddedForNestedFieldPreparation();
+        $embedded->objectId = $oidString;
+
+        $builder = new Builder($this->dm, DocumentForNestedFieldPreparation::class);
+        $builder
+            ->updateOne()
+            ->field('embedded.embedded.objectId')
+            ->equals($oidString)
+            ->field('embedded.embedded.embedded')
+            ->set($embedded);
+
+        $query  = $builder->getQuery()->getQuery();
+        $filter = $query['query'];
+        $newObj = $query['newObj'];
+
+        self::assertArrayHasKey('embedded.embedded.test', $filter);
+        self::assertInstanceOf(ObjectId::class, $filter['embedded.embedded.test']);
+
+        self::assertArrayHasKey('embedded.embedded.embedded', $newObj['$set']);
+        self::assertIsArray($newObj['$set']['embedded.embedded.embedded']);
+        self::assertArrayHasKey('test', $newObj['$set']['embedded.embedded.embedded']);
+        self::assertInstanceOf(ObjectId::class, $newObj['$set']['embedded.embedded.embedded']['test']);
+    }
+
     private function getTestQueryBuilder(): Builder
     {
         return new Builder($this->dm, User::class);
@@ -922,3 +951,23 @@ class ChildC extends ParentClass
     #[ODM\ReferenceMany(storeAs: 'dbRef')]
     public $featurePartialMany;
 }
+
+#[ODM\Document]
+class DocumentForNestedFieldPreparation
+{
+    #[ODM\Id]
+    public string $id;
+
+    #[ODM\EmbedOne(targetDocument: EmbeddedForNestedFieldPreparation::class)]
+    public EmbeddedForNestedFieldPreparation $embedded;
+}
+
+#[ODM\EmbeddedDocument]
+class EmbeddedForNestedFieldPreparation
+{
+    #[ODM\Field(name: 'test', type: Type::OBJECTID)]
+    public string $objectId;
+
+    #[ODM\EmbedOne(targetDocument: self::class)]
+    public ?EmbeddedForNestedFieldPreparation $embedded = null;
+}