Cast data before saving it into database and mongoId as Relationships

patch.txt

@@ -0,0 +1,46 @@
+diff --git a/src/Jenssegers/Mongodb/Eloquent/Model.php b/src/Jenssegers/Mongodb/Eloquent/Model.php
+index 3707c86cb7f732c97908d8ca3754118f4256e422..4a17b0f8c045b2d02f3f834ae0b207dccd2be311 100644
+--- a/src/Jenssegers/Mongodb/Eloquent/Model.php
++++ b/src/Jenssegers/Mongodb/Eloquent/Model.php
+@@ -615,7 +615,7 @@ abstract class Model extends BaseModel
+     public function castAttribute($key, $value, $castType = 'get')
+     {
+         if (is_null($value)) {
+-            return null;
++            return;
+         }
+
+         if (!$this->hasCast($key, null, $castType)) {
+diff --git a/tests/RelationsWithMongoIdTest.php b/tests/RelationsWithMongoIdTest.php
+index 8e78bf592b016b7a85609e699c6f0fa24c55dc0e..517c3be993b8eb68bae2349a061c6677be3cbfa7 100644
+--- a/tests/RelationsWithMongoIdTest.php
++++ b/tests/RelationsWithMongoIdTest.php
+@@ -533,15 +533,15 @@ class RelationsWithMongoIdTest extends TestCase
+         $user = new User;
+         $user->setCasts([
+             'last_seen' => 'UTCDatetime',
+-            'age'=>'int',
+-            'name'=>'string',
+-            'rate'=>'float',
+-            'birthday'=>'timestamp',
+-            'isActive'=>'bool',
+-            'default'=>'default',
++            'age' => 'int',
++            'name' => 'string',
++            'rate' => 'float',
++            'birthday' => 'timestamp',
++            'isActive' => 'bool',
++            'default' => 'default',
+         ], 'set');
+         $user->setCasts([
+-            'name'=>'string',
++            'name' => 'string',
+         ]);
+         $carbon = Carbon\Carbon::now();
+         $UTCDateTime = new \MongoDB\BSON\UTCDateTime($carbon->timestamp * 1000);
+@@ -562,5 +562,4 @@ class RelationsWithMongoIdTest extends TestCase
+         $test = $user->castAttribute('default', 'test', 'set');
+         $this->assertEquals('test', $test);
+     }
+-
+ }

phpunit.xml.dist

@@ -36,6 +36,7 @@
         <testsuite name="relations">
             <directory>tests/RelationsTest.php</directory>
             <directory>tests/EmbeddedRelationsTest.php</directory>
+            <directory>tests/RelationsWithMongoIdTest.php</directory>
         </testsuite>
         <testsuite name="mysqlrelations">
             <directory>tests/RelationsTest.php</directory>

src/Jenssegers/Mongodb/Eloquent/Builder.php

@@ -169,9 +169,10 @@ protected function addHasWhere(EloquentBuilder $hasQuery, Relation $relation, $o
 
         // Get the number of related objects for each possible parent.
         $relations = $query->pluck($relation->getHasCompareKey());
-        $relationCount = array_count_values(array_map(function ($id) {
-            return (string) $id; // Convert Back ObjectIds to Strings
-        }, is_array($relations) ? $relations : $relations->toArray()));
+        $relations = array_map(function ($id) {
+            return (string) $id;
+        }, is_array($relations) ? $relations : $relations->toArray());
+        $relationCount = array_count_values($relations);
 
         // Remove unwanted related objects based on the operator and count.
         $relationCount = array_filter($relationCount, function ($counted) use ($count, $operator) {
@@ -202,7 +203,15 @@ protected function addHasWhere(EloquentBuilder $hasQuery, Relation $relation, $o
         }
 
         // All related ids.
-        $relatedIds = array_keys($relationCount);
+        $relatedIds = array_map(function ($id) use ($relation) {
+            $relationModel = $relation->getRelated();
+            $relationModel->setRelationCast($relation->getHasCompareKey());
+            if ($relationModel->useMongoId()
+                && $relationModel->hasCast($relation->getHasCompareKey(), null, 'set')) {
+                $id = $relationModel->castAttribute($relation->getHasCompareKey(), $id, 'set');
+            }
+            return $id;
+        }, array_keys($relationCount));
 
         // Add whereIn to the query.
         return $this->whereIn($this->model->getKeyName(), $relatedIds, $boolean, $not);

src/Jenssegers/Mongodb/Eloquent/HybridRelations.php

@@ -1,13 +1,13 @@
 <?php namespace Jenssegers\Mongodb\Eloquent;
 
-use Illuminate\Database\Eloquent\Relations\MorphMany;
-use Illuminate\Database\Eloquent\Relations\MorphOne;
 use Illuminate\Support\Str;
 use Jenssegers\Mongodb\Relations\BelongsTo;
 use Jenssegers\Mongodb\Relations\BelongsToMany;
 use Jenssegers\Mongodb\Relations\HasMany;
 use Jenssegers\Mongodb\Relations\HasOne;
 use Jenssegers\Mongodb\Relations\MorphTo;
+use Jenssegers\Mongodb\Relations\MorphMany;
+use Jenssegers\Mongodb\Relations\MorphOne;
 
 trait HybridRelations
 {

src/Jenssegers/Mongodb/Eloquent/Model.php

@@ -37,6 +37,13 @@ abstract class Model extends BaseModel
      */
     protected $parentRelation;
 
+    /**
+     * The attributes that should be cast to native types.
+     *
+     * @var array
+     */
+    protected $saveCasts = [];
+
     /**
      * Custom accessor for the model's id.
      *
@@ -290,15 +297,13 @@ protected function getAttributeFromArray($key)
      */
     public function setAttribute($key, $value)
     {
-        // Convert _id to ObjectID.
-        if ($key == '_id' and is_string($value)) {
-            $builder = $this->newBaseQueryBuilder();
-
-            $value = $builder->convertKey($value);
-        }
+        // cast data for saving.
+        // set _id to converted into ObjectID if its possible.
+        $this->setRelationCast($key);
+        $value = $this->castAttribute($key, $value, 'set');
 
         // Support keys in dot notation.
-        elseif (str_contains($key, '.')) {
+        if (str_contains($key, '.')) {
             if (in_array($key, $this->getDates()) && $value) {
                 $value = $this->fromDateTime($value);
             }
@@ -340,16 +345,6 @@ public function attributesToArray()
         return $attributes;
     }
 
-    /**
-     * Get the casts array.
-     *
-     * @return array
-     */
-    public function getCasts()
-    {
-        return $this->casts;
-    }
-
     /**
      * Determine if the new and old values for a given key are numerically equivalent.
      *
@@ -552,4 +547,163 @@ public function __call($method, $parameters)
 
         return parent::__call($method, $parameters);
     }
+
+    /**
+     * setter for casts
+     * @param $cast
+     * @param string $castType
+     * @return void
+     */
+    public function setCasts($cast, $castType = 'get')
+    {
+        if ($castType == 'set') {
+            $this->saveCasts = $cast;
+            return;
+        }
+        $this->casts = $cast;
+    }
+
+    /**
+     * Get the casts array.
+     *
+     * @param string $castType
+     * @return array
+     */
+    public function getCasts($castType = 'get')
+    {
+        if ($castType == 'set') {
+            return $this->saveCasts;
+        }
+        return $this->casts;
+    }
+
+    /**
+     * Get the type of save cast for a model attribute.
+     *
+     * @param  string $key
+     * @param string $castType
+     * @return string
+     */
+    protected function getCastType($key, $castType = 'get')
+    {
+        return trim(strtolower($this->getCasts($castType)[$key]));
+    }
+
+    /**
+     * Determine whether an attribute should be cast to a native type.
+     *
+     * @param  string $key
+     * @param  array|string|null $types
+     * @param string $castType
+     * @return bool
+     */
+    public function hasCast($key, $types = null, $castType = 'get')
+    {
+        if (array_key_exists($key, $this->getCasts($castType))) {
+            return $types ? in_array($this->getCastType($key, $castType), (array) $types, true) : true;
+        }
+
+        return false;
+    }
+    /**
+     * check if driver uses mongoId in relations.
+     *
+     * @return bool
+     */
+    public function useMongoId()
+    {
+        return (bool) config('database.connections.mongodb.use_mongo_id', false);
+    }
+
+    /**
+     * Cast an attribute to a mongo type.
+     *
+     * @param  string $key
+     * @param  mixed $value
+     * @param string $castType
+     * @return mixed
+     */
+    public function castAttribute($key, $value, $castType = 'get')
+    {
+        if (is_null($value)) {
+            return;
+        }
+
+        if (!$this->hasCast($key, null, $castType)) {
+            return $value;
+        }
+
+        switch ($this->getCastType($key, $castType)) {
+            case 'int':
+            case 'integer':
+                return (int) $value;
+            case 'real':
+            case 'float':
+            case 'double':
+                return (float) $value;
+            case 'string':
+                return (string) $value;
+            case 'bool':
+            case 'boolean':
+                return (bool) $value;
+            case 'date':
+            case 'utcdatetime':
+            case 'mongodate':
+                return $this->asMongoDate($value);
+            case 'mongoid':
+            case 'objectid':
+                return $this->asMongoID($value);
+            case 'timestamp':
+                return $this->asTimeStamp($value);
+            default:
+                return $value;
+        }
+    }
+
+    /**
+     * convert value into ObjectID if its possible
+     *
+     * @param $value
+     * @return UTCDatetime
+     */
+    protected function asMongoID($value)
+    {
+        if (is_string($value) and strlen($value) === 24 and ctype_xdigit($value)) {
+            return new ObjectID($value);
+        }
+        return $value;
+    }
+
+    /**
+     * convert value into UTCDatetime
+     * @param $value
+     * @return UTCDatetime
+     */
+    protected function asMongoDate($value)
+    {
+        if ($value instanceof UTCDatetime) {
+            return $value;
+        }
+
+        return new UTCDatetime($this->asTimeStamp($value) * 1000);
+    }
+
+    /**
+     * add relation that ended with _id into objectId
+     * if config allow it
+     *
+     * @param $key
+     */
+    public function setRelationCast($key)
+    {
+        if ($key == '_id') {
+            $this->saveCasts['_id'] = 'ObjectID';
+            return;
+        }
+        if ($this->useMongoId()) {
+            if (ends_with($key, '_id')) {
+                $this->saveCasts[$key] = 'ObjectID';
+            }
+        }
+    }
 }

src/Jenssegers/Mongodb/Relations/BelongsTo.php

@@ -29,4 +29,34 @@ public function addEagerConstraints(array $models)
 
         $this->query->whereIn($key, $this->getEagerModelKeys($models));
     }
+
+    /**
+     * Match the eagerly loaded results to their parents.
+     *
+     * @param  array   $models
+     * @param  \Illuminate\Database\Eloquent\Collection  $results
+     * @param  string  $relation
+     * @return array
+     */
+    public function match(array $models, \Illuminate\Database\Eloquent\Collection $results, $relation)
+    {
+        $foreign = $this->foreignKey;
+        $other = $this->otherKey;
+        // First we will get to build a dictionary of the child models by their primary
+        // key of the relationship, then we can easily match the children back onto
+        // the parents using that dictionary and the primary key of the children.
+        $dictionary = [];
+        foreach ($results as $result) {
+            $dictionary[$result->getAttribute($other)] = $result;
+        }
+        // Once we have the dictionary constructed, we can loop through all the parents
+        // and match back onto their children using these keys of the dictionary and
+        // the primary key of the children to map them onto the correct instances.
+        foreach ($models as $model) {
+            if (isset($dictionary[(string) $model->$foreign])) {
+                $model->setRelation($relation, $dictionary[(string) $model->$foreign]);
+            }
+        }
+        return $models;
+    }
 }

src/Jenssegers/Mongodb/Relations/HasMany.php

@@ -5,6 +5,8 @@
 
 class HasMany extends EloquentHasMany
 {
+    use HasOneOrManyTrait;
+
     /**
      * Add the constraints for a relationship count query.
      *

src/Jenssegers/Mongodb/Relations/HasOne.php

@@ -5,6 +5,8 @@
 
 class HasOne extends EloquentHasOne
 {
+    use HasOneOrManyTrait;
+
     /**
      * Add the constraints for a relationship count query.
      *