Merge pull request #658

Author: alcaeus

docs/includes/apiargs-MongoDBCollection-method-distinct-option.yaml

@@ -19,4 +19,10 @@ source:
   ref: session
 post: |
   .. versionadded:: 1.3
+---
+source:
+  file: apiargs-MongoDBCollection-common-option.yaml
+  ref: typeMap
+post: |
+  .. versionadded:: 1.5
 ...

src/Model/TypeMapArrayIterator.php

@@ -27,7 +27,6 @@
 use MongoDB\Exception\InvalidArgumentException;
 use MongoDB\Exception\UnexpectedValueException;
 use MongoDB\Exception\UnsupportedException;
-use MongoDB\Model\TypeMapArrayIterator;
 use ArrayIterator;
 use stdClass;
 use Traversable;
@@ -280,16 +279,16 @@ public function execute(Server $server)
             return $cursor;
         }
 
+        if (isset($this->options['typeMap'])) {
+            $cursor->setTypeMap(\MongoDB\create_field_path_type_map($this->options['typeMap'], 'result.$'));
+        }
+
         $result = current($cursor->toArray());
 
         if ( ! isset($result->result) || ! is_array($result->result)) {
             throw new UnexpectedValueException('aggregate command did not return a "result" array');
         }
 
-        if (isset($this->options['typeMap'])) {
-            return new TypeMapArrayIterator($result->result, $this->options['typeMap']);
-        }
-
         return new ArrayIterator($result->result);
     }
 

src/Operation/Aggregate.php

@@ -69,6 +69,8 @@ class Distinct implements Executable, Explainable
      *
      *    Sessions are not supported for server versions < 3.6.
      *
+     *  * typeMap (array): Type map for BSON deserialization.
+     *
      * @param string       $databaseName   Database name
      * @param string       $collectionName Collection name
      * @param string       $fieldName      Field for which to return distinct values
@@ -102,6 +104,10 @@ public function __construct($databaseName, $collectionName, $fieldName, $filter
             throw InvalidArgumentException::invalidType('"session" option', $options['session'], Session::class);
         }
 
+        if (isset($options['typeMap']) && ! is_array($options['typeMap'])) {
+            throw InvalidArgumentException::invalidType('"typeMap" option', $options['typeMap'], 'array');
+        }
+
         if (isset($options['readConcern']) && $options['readConcern']->isDefault()) {
             unset($options['readConcern']);
         }
@@ -139,6 +145,11 @@ public function execute(Server $server)
         }
 
         $cursor = $server->executeReadCommand($this->databaseName, new Command($this->createCommandDocument()), $this->createOptions());
+
+        if (isset($this->options['typeMap'])) {
+            $cursor->setTypeMap(\MongoDB\create_field_path_type_map($this->options['typeMap'], 'values.$'));
+        }
+
         $result = current($cursor->toArray());
 
         if ( ! isset($result->values) || ! is_array($result->values)) {

src/Operation/Distinct.php

@@ -216,21 +216,14 @@ public function execute(Server $server)
         }
 
         $cursor = $server->executeWriteCommand($this->databaseName, new Command($this->createCommandDocument($server)), $this->createOptions());
-        $result = current($cursor->toArray());
-
-        if ( ! isset($result->value)) {
-            return null;
-        }
-
-        if ( ! is_object($result->value)) {
-            throw new UnexpectedValueException('findAndModify command did not return a "value" document');
-        }
 
         if (isset($this->options['typeMap'])) {
-            return \MongoDB\apply_type_map_to_document($result->value, $this->options['typeMap']);
+            $cursor->setTypeMap(\MongoDB\create_field_path_type_map($this->options['typeMap'], 'value'));
         }
 
-        return $result->value;
+        $result = current($cursor->toArray());
+
+        return isset($result->value) ? $result->value : null;
     }
 
     public function getCommandDocument(Server $server)

src/Operation/FindAndModify.php

@@ -28,7 +28,6 @@
 use MongoDB\Exception\InvalidArgumentException;
 use MongoDB\Exception\UnexpectedValueException;
 use MongoDB\Exception\UnsupportedException;
-use MongoDB\Model\TypeMapArrayIterator;
 use MongoDB\MapReduceResult;
 use ArrayIterator;
 use stdClass;
@@ -267,6 +266,10 @@ public function execute(Server $server)
             ? $server->executeReadWriteCommand($this->databaseName, $command, $options)
             : $server->executeReadCommand($this->databaseName, $command, $options);
 
+        if (isset($this->options['typeMap']) && ! $hasOutputCollection) {
+            $cursor->setTypeMap(\MongoDB\create_field_path_type_map($this->options['typeMap'], 'results.$'));
+        }
+
         $result = current($cursor->toArray());
 
         $getIterator = $this->createGetIteratorCallable($result, $server);
@@ -326,10 +329,6 @@ private function createGetIteratorCallable(stdClass $result, Server $server)
             $results = $result->results;
 
             return function() use ($results) {
-                if (isset($this->options['typeMap'])) {
-                    return new TypeMapArrayIterator($results, $this->options['typeMap']);
-                }
-
                 return new ArrayIterator($results);
             };
         }

src/Operation/MapReduce.php

@@ -241,3 +241,46 @@ function recursive_copy($element) {
 
     return clone $element;
 }
+
+/**
+ * Creates a type map to apply to a field type
+ *
+ * This is used in the Aggregate, Distinct, and FindAndModify operations to
+ * apply the root-level type map to the document that will be returned. It also
+ * replaces the root type with object for consistency within these operations
+ *
+ * An existing type map for the given field path will not be overwritten
+ *
+ * @internal
+ * @param array  $typeMap   The existing typeMap
+ * @param string $fieldPath The field path to apply the root type to
+ * @return array
+ */
+function create_field_path_type_map(array $typeMap, $fieldPath)
+{
+    // If some field paths already exist, we prefix them with the field path we are assuming as the new root
+    if (isset($typeMap['fieldPaths']) && is_array($typeMap['fieldPaths'])) {
+        $fieldPaths = $typeMap['fieldPaths'];
+
+        $typeMap['fieldPaths'] = [];
+        foreach ($fieldPaths as $existingFieldPath => $type) {
+            $typeMap['fieldPaths'][$fieldPath . '.' . $existingFieldPath] = $type;
+        }
+    }
+
+    // If a root typemap was set, apply this to the field object
+    if (isset($typeMap['root'])) {
+        $typeMap['fieldPaths'][$fieldPath] = $typeMap['root'];
+    }
+
+    /* Special case if we want to convert an array, in which case we need to
+     * ensure that the field containing the array is exposed as an array,
+     * instead of the type given in the type map's array key. */
+    if (substr($fieldPath, -2, 2) === '.$') {
+        $typeMap['fieldPaths'][substr($fieldPath, 0, -2)] = 'array';
+    }
+
+    $typeMap['root'] = 'object';
+
+    return $typeMap;
+}