findOneAndX functions always returns stdClass

[lindelius]

When using findOneAndReplace(), findOneAndDelete(), and findOneAndUpdate() a stdClass object is returned even though the typeMap option has been set to return arrays for both root and document.

The findOne() function returns the correct type, though.

[jmikola]

This is noted in code comments on the affected methods:

Note: BSON deserialization of the returned document does not yet support a custom type map (depends on: PHPC-314).

It's also listed as a limitation in the Collection documentation:

Operations within the Collection class (e.g. find(), insertOne()) will generally inherit the Collection’s options. One notable exception to this rule is that aggregate() (when not using a cursor) and the findAndModify variants do not yet support a type map option due to a driver limitation. This means that they will return BSON documents and arrays as stdClass objects and PHP arrays, respectively.

We're still awaiting some functionality to be implemented in the driver (tentatively for its 1.2.0 release) before we can properly support this behavior in the aforementioned library methods. In short, the driver needs to allow a typeMap to kick in at a nested level of command result document. For commands that return single result documents (e.g. inline aggregation or findAndModify), your root document(s) is actually contained within a "result" field (or elements within a "results" array) in that document.

[lindelius]

All right. Thank you for the information!

For any one else requiring the result to be an array, casting it to an array is all you need to do until this is fixed in the driver:

$result = (array) $collection->findOneAndReplace(...);

[jmikola]

Note: this caveat is now mentioned in the Collection method documentation: http://mongodb.github.io/mongo-php-library/classes/collection/#findoneandreplace and related methods.

[rikkiloades]

Additional note @lindelius workaround will work if you have a simple document with no embedded documents and it only contains a single level of scalar values. If you have a slightly more complex data structure then you need to walk the result like so:

/**
 * Here we take a object in a response from MongoDB and we walk it casting to an array here as new
 * MongoDB driver seems to return a \stdObject even though in the MongoClient object we specify a
 * typeMap which says it should return an array (mimicking the older driver's behaviour).
 *
 * Any method other than find or findOne which actually under the hood returns a result array structure where
 * the returned object is nested inside it seems to just ignore the typeMap and there is no way with the library
 * to specify via individual method calls like "findOneAndUpdate".
 *
 * So we use a heavy handed cast on anything that looks like an array to achieve the desired result.
 */
private function respectTypeMap($responseValue)
{
    $returnValue = $responseValue;
    if ($responseValue instanceof \stdClass) {
        $returnValue = (array)$responseValue;
    }

    if (is_array($returnValue)) {
        foreach ($returnValue as &$value) {
            $value = $this->respectTypeMap($value);
        }
    }

    return $returnValue;
}

And that should get you want. In my case it was important that embedded structures were all described with arrays rather than stdClass as the result was then used in a whole ecosystem where this stuff was passed around functions through array typed function arguments which would cause everything to blow up. It was much easier doing this than rewriting parts of that whole ecosystem.

[jmikola]

@rikkiloades: Thanks for sharing your work-around. I have another alternative proposal (also shared in #256 (comment)), which should provide some more flexibility until we can get the necessary functionality in the drivers.