analogueorm / analogue

src/System/Query.php

Indentation +673 added lines, -673 removed lines

@@ -20,677 +20,677 @@
  */
 class Query
 {
-    /**
-     * Mapper Instance.
-     *
-     * @var \Analogue\ORM\System\Mapper
-     */
-    protected $mapper;
-
-    /**
-     * DB Adatper.
-     *
-     * @var \Analogue\ORM\Drivers\DBAdapter
-     */
-    protected $adapter;
-
-    /**
-     * Query Builder Instance.
-     *
-     * @var \Analogue\ORM\Drivers\QueryAdapter|\Analogue\ORM\Drivers\IlluminateQueryAdapter
-     */
-    protected $query;
-
-    /**
-     * Entity Map Instance.
-     *
-     * @var \Analogue\ORM\EntityMap
-     */
-    protected $entityMap;
-
-    /**
-     * The relationships that should be eager loaded.
-     *
-     * @var array
-     */
-    protected $eagerLoad = [];
-
-    /**
-     * All of the registered builder macros.
-     *
-     * @var array
-     */
-    protected $macros = [];
-
-    /**
-     * The methods that should be returned from query builder.
-     *
-     * @var array
-     */
-    protected $passthru = [
-        'toSql',
-        'lists',
-        'pluck',
-        'count',
-        'min',
-        'max',
-        'avg',
-        'sum',
-        'exists',
-        'getBindings',
-    ];
-
-    /**
-     * Query Builder Blacklist.
-     */
-    protected $blacklist = [
-        'insert',
-        'insertGetId',
-        'lock',
-        'lockForUpdate',
-        'sharedLock',
-        'update',
-        'increment',
-        'decrement',
-        'delete',
-        'truncate',
-        'raw',
-    ];
-
-    /**
-     * Create a new Analogue Query Builder instance.
-     *
-     * @param Mapper    $mapper
-     * @param DBAdapter $adapter
-     */
-    public function __construct(Mapper $mapper, DBAdapter $adapter)
-    {
-        $this->mapper = $mapper;
-
-        $this->adapter = $adapter;
-
-        $this->entityMap = $mapper->getEntityMap();
-
-        // Specify the table to work on
-        $this->query = $adapter->getQuery()->from($this->entityMap->getTable());
-
-        $this->with($this->entityMap->getEagerloadedRelationships());
-    }
-
-    /**
-     * Run the query and return the result.
-     *
-     * @param array $columns
-     *
-     * @return \Analogue\ORM\EntityCollection
-     */
-    public function get($columns = ['*']) : Collection
-    {
-        return $this->getEntities($columns);
-    }
-
-    /**
-     * Find an entity by its primary key.
-     *
-     * @param string|int $id
-     * @param array      $columns
-     *
-     * @return \Analogue\ORM\Mappable
-     */
-    public function find($id, $columns = ['*'])
-    {
-        if (is_array($id)) {
-            return $this->findMany($id, $columns);
-        }
-
-        $this->query->where($this->entityMap->getKeyName(), '=', $id);
-
-        return $this->first($columns);
-    }
-
-    /**
-     * Find many entities by their primary keys.
-     *
-     * @param array $id
-     * @param array $columns
-     *
-     * @return EntityCollection
-     */
-    public function findMany($id, $columns = ['*'])
-    {
-        if (empty($id)) {
-            return new EntityCollection();
-        }
-
-        $this->query->whereIn($this->entityMap->getKeyName(), $id);
-
-        return $this->get($columns);
-    }
-
-    /**
-     * Find a model by its primary key or throw an exception.
-     *
-     * @param mixed $id
-     * @param array $columns
-     *
-     * @throws \Analogue\ORM\Exceptions\EntityNotFoundException
-     *
-     * @return mixed|self
-     */
-    public function findOrFail($id, $columns = ['*'])
-    {
-        if (!is_null($entity = $this->find($id, $columns))) {
-            return $entity;
-        }
-
-        throw (new EntityNotFoundException())->setEntity(get_class($this->entityMap));
-    }
-
-    /**
-     * Execute the query and get the first result.
-     *
-     * @param array $columns
-     *
-     * @return \Analogue\ORM\Entity
-     */
-    public function first($columns = ['*'])
-    {
-        return $this->take(1)->get($columns)->first();
-    }
-
-    /**
-     * Execute the query and get the first result or throw an exception.
-     *
-     * @param array $columns
-     *
-     * @throws EntityNotFoundException
-     *
-     * @return \Analogue\ORM\Entity
-     */
-    public function firstOrFail($columns = ['*'])
-    {
-        if (!is_null($entity = $this->first($columns))) {
-            return $entity;
-        }
-
-        throw (new EntityNotFoundException())->setEntity(get_class($this->entityMap));
-    }
-
-    /**
-     * Pluck a single column from the database.
-     *
-     * @param string $column
-     *
-     * @return mixed
-     */
-    public function pluck($column)
-    {
-        $result = $this->first([$column]);
-
-        if ($result) {
-            return $result->{$column};
-        }
-    }
-
-    /**
-     * Chunk the results of the query.
-     *
-     * @param int      $count
-     * @param callable $callback
-     *
-     * @return void
-     */
-    public function chunk($count, callable $callback)
-    {
-        $results = $this->forPage($page = 1, $count)->get();
-
-        while (count($results) > 0) {
-            // On each chunk result set, we will pass them to the callback and then let the
-            // developer take care of everything within the callback, which allows us to
-            // keep the memory low for spinning through large result sets for working.
-            call_user_func($callback, $results);
-
-            $page++;
-
-            $results = $this->forPage($page, $count)->get();
-        }
-    }
-
-    /**
-     * Get an array with the values of a given column.
-     *
-     * @param string $column
-     * @param string $key
-     *
-     * @return array
-     */
-    public function lists($column, $key = null)
-    {
-        return $this->query->pluck($column, $key);
-    }
-
-    /**
-     * Get a paginator for the "select" statement.
-     *
-     * @param int   $perPage
-     * @param array $columns
-     *
-     * @return LengthAwarePaginator
-     */
-    public function paginate($perPage = null, $columns = ['*'])
-    {
-        $total = $this->query->getCountForPagination();
-
-        $this->query->forPage(
-            $page = Paginator::resolveCurrentPage(),
-            $perPage = $perPage ?: $this->entityMap->getPerPage()
-        );
-
-        return new LengthAwarePaginator($this->get($columns)->all(), $total, $perPage, $page, [
-            'path' => Paginator::resolveCurrentPath(),
-        ]);
-    }
-
-    /**
-     * Get a paginator for a grouped statement.
-     *
-     * @param \Illuminate\Pagination\Factory $paginator
-     * @param int                            $perPage
-     * @param array                          $columns
-     *
-     * @return \Illuminate\Pagination\Paginator
-     */
-    protected function groupedPaginate($paginator, $perPage, $columns)
-    {
-        $results = $this->get($columns)->all();
-
-        return $this->query->buildRawPaginator($paginator, $results, $perPage);
-    }
-
-    /**
-     * Get a paginator for an ungrouped statement.
-     *
-     * @param \Illuminate\Pagination\Factory $paginator
-     * @param int                            $perPage
-     * @param array                          $columns
-     *
-     * @return \Illuminate\Pagination\Paginator
-     */
-    protected function ungroupedPaginate($paginator, $perPage, $columns)
-    {
-        $total = $this->query->getPaginationCount();
-
-        // Once we have the paginator we need to set the limit and offset values for
-        // the query so we can get the properly paginated items. Once we have an
-        // array of items we can create the paginator instances for the items.
-        $page = $paginator->getCurrentPage($total);
-
-        $this->query->forPage($page, $perPage);
-
-        return $paginator->make($this->get($columns)->all(), $total, $perPage);
-    }
-
-    /**
-     * Paginate the given query into a simple paginator.
-     *
-     * @param int   $perPage
-     * @param array $columns
-     *
-     * @return \Illuminate\Contracts\Pagination\Paginator
-     */
-    public function simplePaginate($perPage = null, $columns = ['*'])
-    {
-        $page = Paginator::resolveCurrentPage();
-
-        $perPage = $perPage ?: $this->entityMap->getPerPage();
-
-        $this->skip(($page - 1) * $perPage)->take($perPage + 1);
-
-        return new Paginator($this->get($columns)->all(), $perPage, $page, ['path' => Paginator::resolveCurrentPath()]);
-    }
-
-    /**
-     * Add a basic where clause to the query.
-     *
-     * @param string $column
-     * @param string $operator
-     * @param mixed  $value
-     * @param string $boolean
-     *
-     * @return $this
-     */
-    public function where($column, $operator = null, $value = null, $boolean = 'and')
-    {
-        if ($column instanceof Closure) {
-            $query = $this->newQueryWithoutScopes();
-
-            call_user_func($column, $query);
-
-            $this->query->addNestedWhereQuery($query->getQuery(), $boolean);
-        } else {
-            call_user_func_array([$this->query, 'where'], func_get_args());
-        }
-
-        return $this;
-    }
-
-    /**
-     * Add an "or where" clause to the query.
-     *
-     * @param string $column
-     * @param string $operator
-     * @param mixed  $value
-     *
-     * @return \Analogue\ORM\System\Query
-     */
-    public function orWhere($column, $operator = null, $value = null)
-    {
-        return $this->where($column, $operator, $value, 'or');
-    }
-
-    /**
-     * Add a relationship count condition to the query.
-     *
-     * @param string   $relation
-     * @param string   $operator
-     * @param int      $count
-     * @param string   $boolean
-     * @param \Closure $callback
-     *
-     * @return \Analogue\ORM\System\Query
-     */
-    public function has($relation, $operator = '>=', $count = 1, $boolean = 'and', $callback = null)
-    {
-        $entity = $this->mapper->newInstance();
-
-        $relation = $this->getHasRelationQuery($relation, $entity);
-
-        $query = $relation->getRelationCountQuery($relation->getRelatedMapper()->getQuery(), $this);
-
-        if ($callback) {
-            call_user_func($callback, $query);
-        }
-
-        return $this->addHasWhere($query, $relation, $operator, $count, $boolean);
-    }
-
-    /**
-     * Add a relationship count condition to the query with where clauses.
-     *
-     * @param string   $relation
-     * @param \Closure $callback
-     * @param string   $operator
-     * @param int      $count
-     *
-     * @return \Analogue\ORM\System\Query
-     */
-    public function whereHas($relation, Closure $callback, $operator = '>=', $count = 1)
-    {
-        return $this->has($relation, $operator, $count, 'and', $callback);
-    }
-
-    /**
-     * Add a relationship count condition to the query with an "or".
-     *
-     * @param string $relation
-     * @param string $operator
-     * @param int    $count
-     *
-     * @return \Analogue\ORM\System\Query
-     */
-    public function orHas($relation, $operator = '>=', $count = 1)
-    {
-        return $this->has($relation, $operator, $count, 'or');
-    }
-
-    /**
-     * Add a relationship count condition to the query with where clauses and an "or".
-     *
-     * @param string   $relation
-     * @param \Closure $callback
-     * @param string   $operator
-     * @param int      $count
-     *
-     * @return \Analogue\ORM\System\Query
-     */
-    public function orWhereHas($relation, Closure $callback, $operator = '>=', $count = 1)
-    {
-        return $this->has($relation, $operator, $count, 'or', $callback);
-    }
-
-    /**
-     * Add the "has" condition where clause to the query.
-     *
-     * @param \Analogue\ORM\System\Query               $hasQuery
-     * @param \Analogue\ORM\Relationships\Relationship $relation
-     * @param string                                   $operator
-     * @param int                                      $count
-     * @param string                                   $boolean
-     *
-     * @return \Analogue\ORM\System\Query
-     */
-    protected function addHasWhere(Query $hasQuery, Relationship $relation, $operator, $count, $boolean)
-    {
-        $this->mergeWheresToHas($hasQuery, $relation);
-
-        if (is_numeric($count)) {
-            $count = new Expression($count);
-        }
-
-        return $this->where(new Expression('('.$hasQuery->toSql().')'), $operator, $count, $boolean);
-    }
-
-    /**
-     * Merge the "wheres" from a relation query to a has query.
-     *
-     * @param \Analogue\ORM\System\Query               $hasQuery
-     * @param \Analogue\ORM\Relationships\Relationship $relation
-     *
-     * @return void
-     */
-    protected function mergeWheresToHas(Query $hasQuery, Relationship $relation)
-    {
-        // Here we have the "has" query and the original relation. We need to copy over any
-        // where clauses the developer may have put in the relationship function over to
-        // the has query, and then copy the bindings from the "has" query to the main.
-        $relationQuery = $relation->getBaseQuery();
-
-        $hasQuery->mergeWheres(
-            $relationQuery->wheres, $relationQuery->getBindings()
-        );
-
-        $this->query->mergeBindings($hasQuery->getQuery());
-    }
-
-    /**
-     * Get the "has relation" base query instance.
-     *
-     * @param string $relation
-     * @param        $entity
-     *
-     * @return \Analogue\ORM\System\Query
-     */
-    protected function getHasRelationQuery($relation, $entity)
-    {
-        return Relationship::noConstraints(function () use ($relation, $entity) {
-            return $this->entityMap->$relation($entity);
-        });
-    }
-
-    /**
-     * Get the table for the current query object.
-     *
-     * @return string
-     */
-    public function getTable()
-    {
-        return $this->entityMap->getTable();
-    }
-
-    /**
-     * Set the relationships that should be eager loaded.
-     *
-     * @param mixed $relations
-     *
-     * @return $this
-     */
-    public function with($relations)
-    {
-        if (is_string($relations)) {
-            $relations = func_get_args();
-        }
-
-        $this->eagerLoad = array_merge($this->eagerLoad, $relations);
-
-        return $this;
-    }
-
-    /**
-     * Get the relationships being eagerly loaded.
-     *
-     * @return array
-     */
-    public function getEagerLoads()
-    {
-        return $this->eagerLoad;
-    }
-
-    /**
-     * Add the Entity primary key if not in requested columns.
-     *
-     * @param array $columns
-     *
-     * @return array
-     */
-    protected function enforceIdColumn($columns)
-    {
-        if (!in_array($this->entityMap->getKeyName(), $columns)) {
-            $columns[] = $this->entityMap->getKeyName();
-        }
-
-        return $columns;
-    }
-
-    /**
-     * Get the hydrated models without eager loading.
-     *
-     * @param array $columns
-     *
-     * @return \Analogue\ORM\EntityCollection
-     */
-    public function getEntities($columns = ['*'])
-    {
-        // As we need the primary key to feed the
-        // entity cache, we need it loaded on each
-        // request
-        $columns = $this->enforceIdColumn($columns);
-
-        // Run the query
-        $results = $this->query->get($columns);
-
-        // Pass result set to the mapper and return the EntityCollection
-        return $this->mapper->map($results, $this->getEagerLoads());
-
-        // Create a result builder.
-        //$builder = new ResultBuilder($this->mapper);
-
-        //return $builder->build($results, $this->getEagerLoads());
-    }
-
-    /**
-     * Extend the builder with a given callback.
-     *
-     * @param string   $name
-     * @param \Closure $callback
-     *
-     * @return void
-     */
-    public function macro($name, Closure $callback)
-    {
-        $this->macros[$name] = $callback;
-    }
-
-    /**
-     * Get the given macro by name.
-     *
-     * @param string $name
-     *
-     * @return \Closure
-     */
-    public function getMacro($name)
-    {
-        return array_get($this->macros, $name);
-    }
-
-    /**
-     * Get a new query builder for the model's table.
-     *
-     * @return \Analogue\ORM\System\Query
-     */
-    public function newQuery()
-    {
-        $builder = new self($this->mapper, $this->adapter);
-
-        return $this->applyGlobalScopes($builder);
-    }
-
-    /**
-     * Get a new query builder without any scope applied.
-     *
-     * @return \Analogue\ORM\System\Query
-     */
-    public function newQueryWithoutScopes()
-    {
-        return new self($this->mapper, $this->adapter);
-    }
-
-    /**
-     * Get the Mapper instance for this Query Builder.
-     *
-     * @return \Analogue\ORM\System\Mapper
-     */
-    public function getMapper()
-    {
-        return $this->mapper;
-    }
-
-    /**
-     * Get the underlying query adapter.
-     *
-     * (REFACTOR: this method should move out, we need to provide the client classes
-     * with the adapter instead.)
-     *
-     * @return \Analogue\ORM\Drivers\QueryAdapter|\Analogue\ORM\Drivers\IlluminateQueryAdapter
-     */
-    public function getQuery()
-    {
-        return $this->query;
-    }
-
-    /**
-     * Dynamically handle calls into the query instance.
-     *
-     * @param string $method
-     * @param array  $parameters
-     *
-     * @throws Exception
-     *
-     * @return mixed
-     */
-    public function __call($method, $parameters)
-    {
-        if (isset($this->macros[$method])) {
-            array_unshift($parameters, $this);
-
-            return call_user_func_array($this->macros[$method], $parameters);
-        }
-
-        if (in_array($method, $this->blacklist)) {
-            throw new Exception("Method $method doesn't exist");
-        }
-
-        $result = call_user_func_array([$this->query, $method], $parameters);
-
-        return in_array($method, $this->passthru) ? $result : $this;
-    }
+	/**
+	 * Mapper Instance.
+	 *
+	 * @var \Analogue\ORM\System\Mapper
+	 */
+	protected $mapper;
+
+	/**
+	 * DB Adatper.
+	 *
+	 * @var \Analogue\ORM\Drivers\DBAdapter
+	 */
+	protected $adapter;
+
+	/**
+	 * Query Builder Instance.
+	 *
+	 * @var \Analogue\ORM\Drivers\QueryAdapter|\Analogue\ORM\Drivers\IlluminateQueryAdapter
+	 */
+	protected $query;
+
+	/**
+	 * Entity Map Instance.
+	 *
+	 * @var \Analogue\ORM\EntityMap
+	 */
+	protected $entityMap;
+
+	/**
+	 * The relationships that should be eager loaded.
+	 *
+	 * @var array
+	 */
+	protected $eagerLoad = [];
+
+	/**
+	 * All of the registered builder macros.
+	 *
+	 * @var array
+	 */
+	protected $macros = [];
+
+	/**
+	 * The methods that should be returned from query builder.
+	 *
+	 * @var array
+	 */
+	protected $passthru = [
+		'toSql',
+		'lists',
+		'pluck',
+		'count',
+		'min',
+		'max',
+		'avg',
+		'sum',
+		'exists',
+		'getBindings',
+	];
+
+	/**
+	 * Query Builder Blacklist.
+	 */
+	protected $blacklist = [
+		'insert',
+		'insertGetId',
+		'lock',
+		'lockForUpdate',
+		'sharedLock',
+		'update',
+		'increment',
+		'decrement',
+		'delete',
+		'truncate',
+		'raw',
+	];
+
+	/**
+	 * Create a new Analogue Query Builder instance.
+	 *
+	 * @param Mapper    $mapper
+	 * @param DBAdapter $adapter
+	 */
+	public function __construct(Mapper $mapper, DBAdapter $adapter)
+	{
+		$this->mapper = $mapper;
+
+		$this->adapter = $adapter;
+
+		$this->entityMap = $mapper->getEntityMap();
+
+		// Specify the table to work on
+		$this->query = $adapter->getQuery()->from($this->entityMap->getTable());
+
+		$this->with($this->entityMap->getEagerloadedRelationships());
+	}
+
+	/**
+	 * Run the query and return the result.
+	 *
+	 * @param array $columns
+	 *
+	 * @return \Analogue\ORM\EntityCollection
+	 */
+	public function get($columns = ['*']) : Collection
+	{
+		return $this->getEntities($columns);
+	}
+
+	/**
+	 * Find an entity by its primary key.
+	 *
+	 * @param string|int $id
+	 * @param array      $columns
+	 *
+	 * @return \Analogue\ORM\Mappable
+	 */
+	public function find($id, $columns = ['*'])
+	{
+		if (is_array($id)) {
+			return $this->findMany($id, $columns);
+		}
+
+		$this->query->where($this->entityMap->getKeyName(), '=', $id);
+
+		return $this->first($columns);
+	}
+
+	/**
+	 * Find many entities by their primary keys.
+	 *
+	 * @param array $id
+	 * @param array $columns
+	 *
+	 * @return EntityCollection
+	 */
+	public function findMany($id, $columns = ['*'])
+	{
+		if (empty($id)) {
+			return new EntityCollection();
+		}
+
+		$this->query->whereIn($this->entityMap->getKeyName(), $id);
+
+		return $this->get($columns);
+	}
+
+	/**
+	 * Find a model by its primary key or throw an exception.
+	 *
+	 * @param mixed $id
+	 * @param array $columns
+	 *
+	 * @throws \Analogue\ORM\Exceptions\EntityNotFoundException
+	 *
+	 * @return mixed|self
+	 */
+	public function findOrFail($id, $columns = ['*'])
+	{
+		if (!is_null($entity = $this->find($id, $columns))) {
+			return $entity;
+		}
+
+		throw (new EntityNotFoundException())->setEntity(get_class($this->entityMap));
+	}
+
+	/**
+	 * Execute the query and get the first result.
+	 *
+	 * @param array $columns
+	 *
+	 * @return \Analogue\ORM\Entity
+	 */
+	public function first($columns = ['*'])
+	{
+		return $this->take(1)->get($columns)->first();
+	}
+
+	/**
+	 * Execute the query and get the first result or throw an exception.
+	 *
+	 * @param array $columns
+	 *
+	 * @throws EntityNotFoundException
+	 *
+	 * @return \Analogue\ORM\Entity
+	 */
+	public function firstOrFail($columns = ['*'])
+	{
+		if (!is_null($entity = $this->first($columns))) {
+			return $entity;
+		}
+
+		throw (new EntityNotFoundException())->setEntity(get_class($this->entityMap));
+	}
+
+	/**
+	 * Pluck a single column from the database.
+	 *
+	 * @param string $column
+	 *
+	 * @return mixed
+	 */
+	public function pluck($column)
+	{
+		$result = $this->first([$column]);
+
+		if ($result) {
+			return $result->{$column};
+		}
+	}
+
+	/**
+	 * Chunk the results of the query.
+	 *
+	 * @param int      $count
+	 * @param callable $callback
+	 *
+	 * @return void
+	 */
+	public function chunk($count, callable $callback)
+	{
+		$results = $this->forPage($page = 1, $count)->get();
+
+		while (count($results) > 0) {
+			// On each chunk result set, we will pass them to the callback and then let the
+			// developer take care of everything within the callback, which allows us to
+			// keep the memory low for spinning through large result sets for working.
+			call_user_func($callback, $results);
+
+			$page++;
+
+			$results = $this->forPage($page, $count)->get();
+		}
+	}
+
+	/**
+	 * Get an array with the values of a given column.
+	 *
+	 * @param string $column
+	 * @param string $key
+	 *
+	 * @return array
+	 */
+	public function lists($column, $key = null)
+	{
+		return $this->query->pluck($column, $key);
+	}
+
+	/**
+	 * Get a paginator for the "select" statement.
+	 *
+	 * @param int   $perPage
+	 * @param array $columns
+	 *
+	 * @return LengthAwarePaginator
+	 */
+	public function paginate($perPage = null, $columns = ['*'])
+	{
+		$total = $this->query->getCountForPagination();
+
+		$this->query->forPage(
+			$page = Paginator::resolveCurrentPage(),
+			$perPage = $perPage ?: $this->entityMap->getPerPage()
+		);
+
+		return new LengthAwarePaginator($this->get($columns)->all(), $total, $perPage, $page, [
+			'path' => Paginator::resolveCurrentPath(),
+		]);
+	}
+
+	/**
+	 * Get a paginator for a grouped statement.
+	 *
+	 * @param \Illuminate\Pagination\Factory $paginator
+	 * @param int                            $perPage
+	 * @param array                          $columns
+	 *
+	 * @return \Illuminate\Pagination\Paginator
+	 */
+	protected function groupedPaginate($paginator, $perPage, $columns)
+	{
+		$results = $this->get($columns)->all();
+
+		return $this->query->buildRawPaginator($paginator, $results, $perPage);
+	}
+
+	/**
+	 * Get a paginator for an ungrouped statement.
+	 *
+	 * @param \Illuminate\Pagination\Factory $paginator
+	 * @param int                            $perPage
+	 * @param array                          $columns
+	 *
+	 * @return \Illuminate\Pagination\Paginator
+	 */
+	protected function ungroupedPaginate($paginator, $perPage, $columns)
+	{
+		$total = $this->query->getPaginationCount();
+
+		// Once we have the paginator we need to set the limit and offset values for
+		// the query so we can get the properly paginated items. Once we have an
+		// array of items we can create the paginator instances for the items.
+		$page = $paginator->getCurrentPage($total);
+
+		$this->query->forPage($page, $perPage);
+
+		return $paginator->make($this->get($columns)->all(), $total, $perPage);
+	}
+
+	/**
+	 * Paginate the given query into a simple paginator.
+	 *
+	 * @param int   $perPage
+	 * @param array $columns
+	 *
+	 * @return \Illuminate\Contracts\Pagination\Paginator
+	 */
+	public function simplePaginate($perPage = null, $columns = ['*'])
+	{
+		$page = Paginator::resolveCurrentPage();
+
+		$perPage = $perPage ?: $this->entityMap->getPerPage();
+
+		$this->skip(($page - 1) * $perPage)->take($perPage + 1);
+
+		return new Paginator($this->get($columns)->all(), $perPage, $page, ['path' => Paginator::resolveCurrentPath()]);
+	}
+
+	/**
+	 * Add a basic where clause to the query.
+	 *
+	 * @param string $column
+	 * @param string $operator
+	 * @param mixed  $value
+	 * @param string $boolean
+	 *
+	 * @return $this
+	 */
+	public function where($column, $operator = null, $value = null, $boolean = 'and')
+	{
+		if ($column instanceof Closure) {
+			$query = $this->newQueryWithoutScopes();
+
+			call_user_func($column, $query);
+
+			$this->query->addNestedWhereQuery($query->getQuery(), $boolean);
+		} else {
+			call_user_func_array([$this->query, 'where'], func_get_args());
+		}
+
+		return $this;
+	}
+
+	/**
+	 * Add an "or where" clause to the query.
+	 *
+	 * @param string $column
+	 * @param string $operator
+	 * @param mixed  $value
+	 *
+	 * @return \Analogue\ORM\System\Query
+	 */
+	public function orWhere($column, $operator = null, $value = null)
+	{
+		return $this->where($column, $operator, $value, 'or');
+	}
+
+	/**
+	 * Add a relationship count condition to the query.
+	 *
+	 * @param string   $relation
+	 * @param string   $operator
+	 * @param int      $count
+	 * @param string   $boolean
+	 * @param \Closure $callback
+	 *
+	 * @return \Analogue\ORM\System\Query
+	 */
+	public function has($relation, $operator = '>=', $count = 1, $boolean = 'and', $callback = null)
+	{
+		$entity = $this->mapper->newInstance();
+
+		$relation = $this->getHasRelationQuery($relation, $entity);
+
+		$query = $relation->getRelationCountQuery($relation->getRelatedMapper()->getQuery(), $this);
+
+		if ($callback) {
+			call_user_func($callback, $query);
+		}
+
+		return $this->addHasWhere($query, $relation, $operator, $count, $boolean);
+	}
+
+	/**
+	 * Add a relationship count condition to the query with where clauses.
+	 *
+	 * @param string   $relation
+	 * @param \Closure $callback
+	 * @param string   $operator
+	 * @param int      $count
+	 *
+	 * @return \Analogue\ORM\System\Query
+	 */
+	public function whereHas($relation, Closure $callback, $operator = '>=', $count = 1)
+	{
+		return $this->has($relation, $operator, $count, 'and', $callback);
+	}
+
+	/**
+	 * Add a relationship count condition to the query with an "or".
+	 *
+	 * @param string $relation
+	 * @param string $operator
+	 * @param int    $count
+	 *
+	 * @return \Analogue\ORM\System\Query
+	 */
+	public function orHas($relation, $operator = '>=', $count = 1)
+	{
+		return $this->has($relation, $operator, $count, 'or');
+	}
+
+	/**
+	 * Add a relationship count condition to the query with where clauses and an "or".
+	 *
+	 * @param string   $relation
+	 * @param \Closure $callback
+	 * @param string   $operator
+	 * @param int      $count
+	 *
+	 * @return \Analogue\ORM\System\Query
+	 */
+	public function orWhereHas($relation, Closure $callback, $operator = '>=', $count = 1)
+	{
+		return $this->has($relation, $operator, $count, 'or', $callback);
+	}
+
+	/**
+	 * Add the "has" condition where clause to the query.
+	 *
+	 * @param \Analogue\ORM\System\Query               $hasQuery
+	 * @param \Analogue\ORM\Relationships\Relationship $relation
+	 * @param string                                   $operator
+	 * @param int                                      $count
+	 * @param string                                   $boolean
+	 *
+	 * @return \Analogue\ORM\System\Query
+	 */
+	protected function addHasWhere(Query $hasQuery, Relationship $relation, $operator, $count, $boolean)
+	{
+		$this->mergeWheresToHas($hasQuery, $relation);
+
+		if (is_numeric($count)) {
+			$count = new Expression($count);
+		}
+
+		return $this->where(new Expression('('.$hasQuery->toSql().')'), $operator, $count, $boolean);
+	}
+
+	/**
+	 * Merge the "wheres" from a relation query to a has query.
+	 *
+	 * @param \Analogue\ORM\System\Query               $hasQuery
+	 * @param \Analogue\ORM\Relationships\Relationship $relation
+	 *
+	 * @return void
+	 */
+	protected function mergeWheresToHas(Query $hasQuery, Relationship $relation)
+	{
+		// Here we have the "has" query and the original relation. We need to copy over any
+		// where clauses the developer may have put in the relationship function over to
+		// the has query, and then copy the bindings from the "has" query to the main.
+		$relationQuery = $relation->getBaseQuery();
+
+		$hasQuery->mergeWheres(
+			$relationQuery->wheres, $relationQuery->getBindings()
+		);
+
+		$this->query->mergeBindings($hasQuery->getQuery());
+	}
+
+	/**
+	 * Get the "has relation" base query instance.
+	 *
+	 * @param string $relation
+	 * @param        $entity
+	 *
+	 * @return \Analogue\ORM\System\Query
+	 */
+	protected function getHasRelationQuery($relation, $entity)
+	{
+		return Relationship::noConstraints(function () use ($relation, $entity) {
+			return $this->entityMap->$relation($entity);
+		});
+	}
+
+	/**
+	 * Get the table for the current query object.
+	 *
+	 * @return string
+	 */
+	public function getTable()
+	{
+		return $this->entityMap->getTable();
+	}
+
+	/**
+	 * Set the relationships that should be eager loaded.
+	 *
+	 * @param mixed $relations
+	 *
+	 * @return $this
+	 */
+	public function with($relations)
+	{
+		if (is_string($relations)) {
+			$relations = func_get_args();
+		}
+
+		$this->eagerLoad = array_merge($this->eagerLoad, $relations);
+
+		return $this;
+	}
+
+	/**
+	 * Get the relationships being eagerly loaded.
+	 *
+	 * @return array
+	 */
+	public function getEagerLoads()
+	{
+		return $this->eagerLoad;
+	}
+
+	/**
+	 * Add the Entity primary key if not in requested columns.
+	 *
+	 * @param array $columns
+	 *
+	 * @return array
+	 */
+	protected function enforceIdColumn($columns)
+	{
+		if (!in_array($this->entityMap->getKeyName(), $columns)) {
+			$columns[] = $this->entityMap->getKeyName();
+		}
+
+		return $columns;
+	}
+
+	/**
+	 * Get the hydrated models without eager loading.
+	 *
+	 * @param array $columns
+	 *
+	 * @return \Analogue\ORM\EntityCollection
+	 */
+	public function getEntities($columns = ['*'])
+	{
+		// As we need the primary key to feed the
+		// entity cache, we need it loaded on each
+		// request
+		$columns = $this->enforceIdColumn($columns);
+
+		// Run the query
+		$results = $this->query->get($columns);
+
+		// Pass result set to the mapper and return the EntityCollection
+		return $this->mapper->map($results, $this->getEagerLoads());
+
+		// Create a result builder.
+		//$builder = new ResultBuilder($this->mapper);
+
+		//return $builder->build($results, $this->getEagerLoads());
+	}
+
+	/**
+	 * Extend the builder with a given callback.
+	 *
+	 * @param string   $name
+	 * @param \Closure $callback
+	 *
+	 * @return void
+	 */
+	public function macro($name, Closure $callback)
+	{
+		$this->macros[$name] = $callback;
+	}
+
+	/**
+	 * Get the given macro by name.
+	 *
+	 * @param string $name
+	 *
+	 * @return \Closure
+	 */
+	public function getMacro($name)
+	{
+		return array_get($this->macros, $name);
+	}
+
+	/**
+	 * Get a new query builder for the model's table.
+	 *
+	 * @return \Analogue\ORM\System\Query
+	 */
+	public function newQuery()
+	{
+		$builder = new self($this->mapper, $this->adapter);
+
+		return $this->applyGlobalScopes($builder);
+	}
+
+	/**
+	 * Get a new query builder without any scope applied.
+	 *
+	 * @return \Analogue\ORM\System\Query
+	 */
+	public function newQueryWithoutScopes()
+	{
+		return new self($this->mapper, $this->adapter);
+	}
+
+	/**
+	 * Get the Mapper instance for this Query Builder.
+	 *
+	 * @return \Analogue\ORM\System\Mapper
+	 */
+	public function getMapper()
+	{
+		return $this->mapper;
+	}
+
+	/**
+	 * Get the underlying query adapter.
+	 *
+	 * (REFACTOR: this method should move out, we need to provide the client classes
+	 * with the adapter instead.)
+	 *
+	 * @return \Analogue\ORM\Drivers\QueryAdapter|\Analogue\ORM\Drivers\IlluminateQueryAdapter
+	 */
+	public function getQuery()
+	{
+		return $this->query;
+	}
+
+	/**
+	 * Dynamically handle calls into the query instance.
+	 *
+	 * @param string $method
+	 * @param array  $parameters
+	 *
+	 * @throws Exception
+	 *
+	 * @return mixed
+	 */
+	public function __call($method, $parameters)
+	{
+		if (isset($this->macros[$method])) {
+			array_unshift($parameters, $this);
+
+			return call_user_func_array($this->macros[$method], $parameters);
+		}
+
+		if (in_array($method, $this->blacklist)) {
+			throw new Exception("Method $method doesn't exist");
+		}
+
+		$result = call_user_func_array([$this->query, $method], $parameters);
+
+		return in_array($method, $this->passthru) ? $result : $this;
+	}
 }

src/System/Wrappers/ObjectWrapper.php

Indentation +221 added lines, -221 removed lines

@@ -10,226 +10,226 @@
  */
 class ObjectWrapper extends Wrapper
 {
-    /**
-     * Internal Representation of analogue's entity attributes.
-     *
-     * @var array
-     */
-    protected $attributes = [];
-
-    /**
-     * Object properties that are not a part of the entity attributes,
-     * but which are needed to correctly hydrate the Object.
-     *
-     * @var array
-     */
-    protected $unmanagedProperties = [];
-
-    /**
-     * The hydrator for the wrapped object.
-     *
-     * @var HydratorInterface
-     */
-    protected $hydrator;
-
-    /**
-     * Object Wrapper constructor.
-     *
-     * @param mixed                  $object
-     * @param Analogue\ORM\EntityMap $entityMap
-     *
-     * @return void
-     */
-    public function __construct($entity, $entityMap, HydratorInterface $hydrator)
-    {
-        $this->hydrator = $hydrator;
-        parent::__construct($entity, $entityMap);
-        $this->attributes = $this->dehydrate($entity);
-    }
-
-    /**
-     * Returns the wrapped entity.
-     *
-     * @return mixed
-     */
-    public function getObject()
-    {
-        $this->hydrate();
-
-        return $this->entity;
-    }
-
-    /**
-     * Extract entity attributes / properties to an array of attributes.
-     *
-     * @param mixed $entity
-     *
-     * @return array
-     */
-    protected function dehydrate($entity) : array
-    {
-        $properties = $this->hydrator->extract($entity);
-
-        $this->unmanagedProperties = array_except($properties, $this->getManagedProperties());
-
-        return $this->attributesFromProperties($properties);
-    }
-
-    /**
-     * Hydrate object's properties/attribute from the internal array representation.
-     *
-     * @return mixed
-     */
-    public function hydrate()
-    {
-        $properties = $this->propertiesFromAttributes($this->attributes) + $this->unmanagedProperties;
+	/**
+	 * Internal Representation of analogue's entity attributes.
+	 *
+	 * @var array
+	 */
+	protected $attributes = [];
+
+	/**
+	 * Object properties that are not a part of the entity attributes,
+	 * but which are needed to correctly hydrate the Object.
+	 *
+	 * @var array
+	 */
+	protected $unmanagedProperties = [];
+
+	/**
+	 * The hydrator for the wrapped object.
+	 *
+	 * @var HydratorInterface
+	 */
+	protected $hydrator;
+
+	/**
+	 * Object Wrapper constructor.
+	 *
+	 * @param mixed                  $object
+	 * @param Analogue\ORM\EntityMap $entityMap
+	 *
+	 * @return void
+	 */
+	public function __construct($entity, $entityMap, HydratorInterface $hydrator)
+	{
+		$this->hydrator = $hydrator;
+		parent::__construct($entity, $entityMap);
+		$this->attributes = $this->dehydrate($entity);
+	}
+
+	/**
+	 * Returns the wrapped entity.
+	 *
+	 * @return mixed
+	 */
+	public function getObject()
+	{
+		$this->hydrate();
+
+		return $this->entity;
+	}
+
+	/**
+	 * Extract entity attributes / properties to an array of attributes.
+	 *
+	 * @param mixed $entity
+	 *
+	 * @return array
+	 */
+	protected function dehydrate($entity) : array
+	{
+		$properties = $this->hydrator->extract($entity);
+
+		$this->unmanagedProperties = array_except($properties, $this->getManagedProperties());
+
+		return $this->attributesFromProperties($properties);
+	}
+
+	/**
+	 * Hydrate object's properties/attribute from the internal array representation.
+	 *
+	 * @return mixed
+	 */
+	public function hydrate()
+	{
+		$properties = $this->propertiesFromAttributes($this->attributes) + $this->unmanagedProperties;
         
-        $this->hydrator->hydrate($properties, $this->entity);
-    }
-
-    /**
-     * Return properties that will be extracted from the entity.
-     *
-     * @return array
-     */
-    protected function getManagedProperties() : array
-    {
-        $properties = $this->entityMap->getProperties();
-
-        $attributesName = $this->entityMap->getAttributesArrayName();
-
-        return $attributesName == null ? $properties : array_merge($properties, [$attributesName]);
-    }
-
-    /**
-     * Convert object's properties to analogue's internal attributes representation.
-     *
-     * @param array $properties
-     *
-     * @return array
-     */
-    protected function attributesFromProperties(array $properties) : array
-    {
-        // First, we'll only keep the entities that are part of the Entity's
-        // attributes
-        $managedProperties = $this->getManagedProperties();
-
-        $properties = array_only($properties, $managedProperties);
-
-        // If the entity does not uses the attributes array to store
-        // part of its attributes, we'll directly return the properties
-        if (!$this->entityMap->usesAttributesArray()) {
-            return $properties;
-        }
-
-        $arrayName = $this->entityMap->getAttributesArrayName();
-
-        if (!array_key_exists($arrayName, $properties)) {
-            throw new MappingException("Property $arrayName not set on object of type ".$this->getEntityClass());
-        }
-
-        if (!is_array($properties[$arrayName])) {
-            throw new MappingException("Property $arrayName should be an array.");
-        }
-
-        $attributes = $properties[$arrayName];
-
-        unset($properties[$arrayName]);
-
-        return $properties + $attributes;
-    }
-
-    /**
-     * Convert internal representation of attributes to an array of properties
-     * that can hydrate the actual object.
-     *
-     * @param array $attributes
-     *
-     * @return array
-     */
-    protected function propertiesFromAttributes(array $attributes) : array
-    {
-        $attributes = $this->attributes;
-
-        // Get all managed properties
-        $propertyNames = $this->entityMap->getProperties();
-
-        $propertyAttributes = array_only($attributes, $propertyNames);
-        $attributesArray = array_except($attributes, $propertyNames);
-
-        $attributesArrayName = $this->entityMap->getAttributesArrayName();
-
-        if ($attributesArrayName) {
-            $propertyAttributes[$attributesArrayName] = $attributesArray;
-        }
-
-        return $propertyAttributes;
-    }
-
-    /**
-     * Method used by the mapper to set the object
-     * attribute raw values (hydration).
-     *
-     * @param array $attributes
-     *
-     * @return void
-     */
-    public function setEntityAttributes(array $attributes)
-    {
-        $this->attributes = $attributes;
-    }
-
-    /**
-     * Method used by the mapper to get the
-     * raw object's values.
-     *
-     * @return array
-     */
-    public function getEntityAttributes() : array
-    {
-        return $this->attributes;
-    }
-
-    /**
-     * Method used by the mapper to set raw
-     * key-value pair.
-     *
-     * @param string $key
-     * @param string $value
-     *
-     * @return void
-     */
-    public function setEntityAttribute($key, $value)
-    {
-        $this->attributes[$key] = $value;
-    }
-
-    /**
-     * Method used by the mapper to get single
-     * key-value pair.
-     *
-     * @param string $key
-     *
-     * @return mixed|null
-     */
-    public function getEntityAttribute($key)
-    {
-        if ($this->hasAttribute($key)) {
-            return $this->attributes[$key];
-        } else {
-            return;
-        }
-    }
-
-    /**
-     * Test if a given attribute exists.
-     *
-     * @param string $key
-     *
-     * @return bool
-     */
-    public function hasAttribute($key) : bool
-    {
-        return array_key_exists($key, $this->attributes) ? true : false;
-    }
+		$this->hydrator->hydrate($properties, $this->entity);
+	}
+
+	/**
+	 * Return properties that will be extracted from the entity.
+	 *
+	 * @return array
+	 */
+	protected function getManagedProperties() : array
+	{
+		$properties = $this->entityMap->getProperties();
+
+		$attributesName = $this->entityMap->getAttributesArrayName();
+
+		return $attributesName == null ? $properties : array_merge($properties, [$attributesName]);
+	}
+
+	/**
+	 * Convert object's properties to analogue's internal attributes representation.
+	 *
+	 * @param array $properties
+	 *
+	 * @return array
+	 */
+	protected function attributesFromProperties(array $properties) : array
+	{
+		// First, we'll only keep the entities that are part of the Entity's
+		// attributes
+		$managedProperties = $this->getManagedProperties();
+
+		$properties = array_only($properties, $managedProperties);
+
+		// If the entity does not uses the attributes array to store
+		// part of its attributes, we'll directly return the properties
+		if (!$this->entityMap->usesAttributesArray()) {
+			return $properties;
+		}
+
+		$arrayName = $this->entityMap->getAttributesArrayName();
+
+		if (!array_key_exists($arrayName, $properties)) {
+			throw new MappingException("Property $arrayName not set on object of type ".$this->getEntityClass());
+		}
+
+		if (!is_array($properties[$arrayName])) {
+			throw new MappingException("Property $arrayName should be an array.");
+		}
+
+		$attributes = $properties[$arrayName];
+
+		unset($properties[$arrayName]);
+
+		return $properties + $attributes;
+	}
+
+	/**
+	 * Convert internal representation of attributes to an array of properties
+	 * that can hydrate the actual object.
+	 *
+	 * @param array $attributes
+	 *
+	 * @return array
+	 */
+	protected function propertiesFromAttributes(array $attributes) : array
+	{
+		$attributes = $this->attributes;
+
+		// Get all managed properties
+		$propertyNames = $this->entityMap->getProperties();
+
+		$propertyAttributes = array_only($attributes, $propertyNames);
+		$attributesArray = array_except($attributes, $propertyNames);
+
+		$attributesArrayName = $this->entityMap->getAttributesArrayName();
+
+		if ($attributesArrayName) {
+			$propertyAttributes[$attributesArrayName] = $attributesArray;
+		}
+
+		return $propertyAttributes;
+	}
+
+	/**
+	 * Method used by the mapper to set the object
+	 * attribute raw values (hydration).
+	 *
+	 * @param array $attributes
+	 *
+	 * @return void
+	 */
+	public function setEntityAttributes(array $attributes)
+	{
+		$this->attributes = $attributes;
+	}
+
+	/**
+	 * Method used by the mapper to get the
+	 * raw object's values.
+	 *
+	 * @return array
+	 */
+	public function getEntityAttributes() : array
+	{
+		return $this->attributes;
+	}
+
+	/**
+	 * Method used by the mapper to set raw
+	 * key-value pair.
+	 *
+	 * @param string $key
+	 * @param string $value
+	 *
+	 * @return void
+	 */
+	public function setEntityAttribute($key, $value)
+	{
+		$this->attributes[$key] = $value;
+	}
+
+	/**
+	 * Method used by the mapper to get single
+	 * key-value pair.
+	 *
+	 * @param string $key
+	 *
+	 * @return mixed|null
+	 */
+	public function getEntityAttribute($key)
+	{
+		if ($this->hasAttribute($key)) {
+			return $this->attributes[$key];
+		} else {
+			return;
+		}
+	}
+
+	/**
+	 * Test if a given attribute exists.
+	 *
+	 * @param string $key
+	 *
+	 * @return bool
+	 */
+	public function hasAttribute($key) : bool
+	{
+		return array_key_exists($key, $this->attributes) ? true : false;
+	}
 }

src/System/Wrappers/Wrapper.php

Indentation +236 added lines, -236 removed lines

@@ -10,240 +10,240 @@
  */
 abstract class Wrapper implements InternallyMappable
 {
-    /**
-     * Original Entity Object.
-     *
-     * @var mixed
-     */
-    protected $entity;
-
-    /**
-     * Corresponding EntityMap.
-     *
-     * @var \Analogue\ORM\EntityMap
-     */
-    protected $entityMap;
-
-    /**
-     * @var \Analogue\ORM\System\Proxirs\ProxyFactory
-     */
-    protected $proxyFactory;
-
-    /**
-     * Wrapper constructor.
-     *
-     * @param $entity
-     * @param $entityMap
-     */
-    public function __construct($entity, $entityMap)
-    {
-        $this->entity = $entity;
-        $this->entityMap = $entityMap;
-        $this->proxyFactory = new ProxyFactory();
-    }
-
-    /**
-     * Return the wrapped entity class.
-     *
-     * @return mixed
-     */
-    public function getEntityClass()
-    {
-        return get_class($this->entity);
-    }
-
-    /**
-     * Return the entity's primary key valuye.
-     *
-     * @return string
-     */
-    public function getEntityKey()
-    {
-        return $this->getEntityAttribute($this->entityMap->getKeyName());
-    }
-
-    /**
-     * Return the Entity class/primary key couple,
-     * which is used for internall operations.
-     *
-     * @return string
-     */
-    public function getEntityHash()
-    {
-        return $this->getEntityClass().'.'.$this->getEntityKey();
-    }
-
-    /**
-     * Returns the wrapped entity.
-     *
-     * @return mixed
-     */
-    public function getObject()
-    {
-        return $this->entity;
-    }
-
-    /**
-     * Returns the wrapped entity's map.
-     *
-     * @return mixed
-     */
-    public function getMap()
-    {
-        return $this->entityMap;
-    }
-
-    /**
-     * Set the lazyloading proxies on the wrapped entity objet.
-     *
-     * @param array $relations list of relations to be lazy loaded
-     *
-     * @return void
-     */
-    public function setProxies(array $relations = null)
-    {
-        $attributes = $this->getEntityAttributes();
-        $proxies = [];
-
-        //if (is_null($relations)) {
-            $relations = $this->getRelationsToProxy();
-        //}
-        //dump($relations);
-        // Before calling the relationship methods, we'll set the relationship
-        // method to null, to avoid hydration error on class properties
-        foreach ($relations as $relation) {
-            $this->setEntityAttribute($relation, null);
-        }
-
-        foreach ($relations as $relation) {
-
-            // First, we check that the relation has not been already
-            // set, in which case, we'll just pass.
-            if (array_key_exists($relation, $attributes) && !is_null($attributes[$relation])) {
-                continue;
-            }
-
-            // If the key is handled locally and we know it not to be set,
-            // we'll set the relationship to null
-            if (!$this->relationNeedsProxy($relation, $attributes)) {
-                $proxies[$relation] = null;
-            } else {
-                $targetClass = $this->getClassToProxy($relation, $attributes);
-                $proxies[$relation] = $this->proxyFactory->make($this->getObject(), $relation, $targetClass);
-            }
-        }
-
-        foreach ($proxies as $key => $value) {
-            $this->setEntityAttribute($key, $value);
-        }
-
-    }
-
-    /**
-     * Get Target class to proxy for a one to one.
-     *
-     * @param string $relation
-     * @param array  $attributes
-     *
-     * @return string
-     */
-    protected function getClassToProxy($relation, array $attributes)
-    {
-        if ($this->entityMap->isPolymorphic($relation)) {
-            $localTypeAttribute = $this->entityMap->getLocalKeys($relation)['type'];
-
-            return $attributes[$localTypeAttribute];
-        }
-
-        return $this->entityMap->getTargettedClass($relation);
-    }
-
-    /**
-     * Determine which relations we have to build proxy for, by parsing
-     * attributes and finding methods that aren't set.
-     *
-     * @return array
-     */
-    protected function getRelationsToProxy()
-    {
-        $proxies = [];
-        $attributes = $this->getEntityAttributes();
-
-        foreach ($this->entityMap->getRelationships() as $relation) {
-            if (!array_key_exists($relation, $attributes)) {
-                $proxies[] = $relation;
-            }
-        }
-
-        return $proxies;
-    }
-
-    /**
-     * Determine if the relation needs a proxy or not.
-     *
-     * @param string $relation
-     * @param array  $attributes
-     *
-     * @return bool
-     */
-    protected function relationNeedsProxy($relation, $attributes)
-    {
-        if (in_array($relation, $this->entityMap->getRelationshipsWithoutProxy())) {
-            return false;
-        }
-
-        $localKey = $this->entityMap->getLocalKeys($relation);
-
-        if (is_null($localKey)) {
-            return true;
-        }
-
-        if (is_array($localKey)) {
-            $localKey = $localKey['id'];
-        }
-
-        if (!isset($attributes[$localKey])) {
-            return false;
-        }
-
-        if (is_null($attributes[$localKey])) {
-            return false;
-        }
-
-        return true;
-    }
-
-    /**
-     * @param string $key
-     * @param string $value
-     *
-     * @return mixed
-     */
-    abstract public function setEntityAttribute($key, $value);
-
-    /**
-     * @param string $key
-     *
-     * @return mixed
-     */
-    abstract public function getEntityAttribute($key);
-
-    /**
-     * @param array $attributes
-     *
-     * @return mixed
-     */
-    abstract public function setEntityAttributes(array $attributes);
-
-    /**
-     * @return mixed
-     */
-    abstract public function getEntityAttributes();
-
-    /**
-     * @param string $key
-     *
-     * @return mixed
-     */
-    abstract public function hasAttribute($key);
+	/**
+	 * Original Entity Object.
+	 *
+	 * @var mixed
+	 */
+	protected $entity;
+
+	/**
+	 * Corresponding EntityMap.
+	 *
+	 * @var \Analogue\ORM\EntityMap
+	 */
+	protected $entityMap;
+
+	/**
+	 * @var \Analogue\ORM\System\Proxirs\ProxyFactory
+	 */
+	protected $proxyFactory;
+
+	/**
+	 * Wrapper constructor.
+	 *
+	 * @param $entity
+	 * @param $entityMap
+	 */
+	public function __construct($entity, $entityMap)
+	{
+		$this->entity = $entity;
+		$this->entityMap = $entityMap;
+		$this->proxyFactory = new ProxyFactory();
+	}
+
+	/**
+	 * Return the wrapped entity class.
+	 *
+	 * @return mixed
+	 */
+	public function getEntityClass()
+	{
+		return get_class($this->entity);
+	}
+
+	/**
+	 * Return the entity's primary key valuye.
+	 *
+	 * @return string
+	 */
+	public function getEntityKey()
+	{
+		return $this->getEntityAttribute($this->entityMap->getKeyName());
+	}
+
+	/**
+	 * Return the Entity class/primary key couple,
+	 * which is used for internall operations.
+	 *
+	 * @return string
+	 */
+	public function getEntityHash()
+	{
+		return $this->getEntityClass().'.'.$this->getEntityKey();
+	}
+
+	/**
+	 * Returns the wrapped entity.
+	 *
+	 * @return mixed
+	 */
+	public function getObject()
+	{
+		return $this->entity;
+	}
+
+	/**
+	 * Returns the wrapped entity's map.
+	 *
+	 * @return mixed
+	 */
+	public function getMap()
+	{
+		return $this->entityMap;
+	}
+
+	/**
+	 * Set the lazyloading proxies on the wrapped entity objet.
+	 *
+	 * @param array $relations list of relations to be lazy loaded
+	 *
+	 * @return void
+	 */
+	public function setProxies(array $relations = null)
+	{
+		$attributes = $this->getEntityAttributes();
+		$proxies = [];
+
+		//if (is_null($relations)) {
+			$relations = $this->getRelationsToProxy();
+		//}
+		//dump($relations);
+		// Before calling the relationship methods, we'll set the relationship
+		// method to null, to avoid hydration error on class properties
+		foreach ($relations as $relation) {
+			$this->setEntityAttribute($relation, null);
+		}
+
+		foreach ($relations as $relation) {
+
+			// First, we check that the relation has not been already
+			// set, in which case, we'll just pass.
+			if (array_key_exists($relation, $attributes) && !is_null($attributes[$relation])) {
+				continue;
+			}
+
+			// If the key is handled locally and we know it not to be set,
+			// we'll set the relationship to null
+			if (!$this->relationNeedsProxy($relation, $attributes)) {
+				$proxies[$relation] = null;
+			} else {
+				$targetClass = $this->getClassToProxy($relation, $attributes);
+				$proxies[$relation] = $this->proxyFactory->make($this->getObject(), $relation, $targetClass);
+			}
+		}
+
+		foreach ($proxies as $key => $value) {
+			$this->setEntityAttribute($key, $value);
+		}
+
+	}
+
+	/**
+	 * Get Target class to proxy for a one to one.
+	 *
+	 * @param string $relation
+	 * @param array  $attributes
+	 *
+	 * @return string
+	 */
+	protected function getClassToProxy($relation, array $attributes)
+	{
+		if ($this->entityMap->isPolymorphic($relation)) {
+			$localTypeAttribute = $this->entityMap->getLocalKeys($relation)['type'];
+
+			return $attributes[$localTypeAttribute];
+		}
+
+		return $this->entityMap->getTargettedClass($relation);
+	}
+
+	/**
+	 * Determine which relations we have to build proxy for, by parsing
+	 * attributes and finding methods that aren't set.
+	 *
+	 * @return array
+	 */
+	protected function getRelationsToProxy()
+	{
+		$proxies = [];
+		$attributes = $this->getEntityAttributes();
+
+		foreach ($this->entityMap->getRelationships() as $relation) {
+			if (!array_key_exists($relation, $attributes)) {
+				$proxies[] = $relation;
+			}
+		}
+
+		return $proxies;
+	}
+
+	/**
+	 * Determine if the relation needs a proxy or not.
+	 *
+	 * @param string $relation
+	 * @param array  $attributes
+	 *
+	 * @return bool
+	 */
+	protected function relationNeedsProxy($relation, $attributes)
+	{
+		if (in_array($relation, $this->entityMap->getRelationshipsWithoutProxy())) {
+			return false;
+		}
+
+		$localKey = $this->entityMap->getLocalKeys($relation);
+
+		if (is_null($localKey)) {
+			return true;
+		}
+
+		if (is_array($localKey)) {
+			$localKey = $localKey['id'];
+		}
+
+		if (!isset($attributes[$localKey])) {
+			return false;
+		}
+
+		if (is_null($attributes[$localKey])) {
+			return false;
+		}
+
+		return true;
+	}
+
+	/**
+	 * @param string $key
+	 * @param string $value
+	 *
+	 * @return mixed
+	 */
+	abstract public function setEntityAttribute($key, $value);
+
+	/**
+	 * @param string $key
+	 *
+	 * @return mixed
+	 */
+	abstract public function getEntityAttribute($key);
+
+	/**
+	 * @param array $attributes
+	 *
+	 * @return mixed
+	 */
+	abstract public function setEntityAttributes(array $attributes);
+
+	/**
+	 * @return mixed
+	 */
+	abstract public function getEntityAttributes();
+
+	/**
+	 * @param string $key
+	 *
+	 * @return mixed
+	 */
+	abstract public function hasAttribute($key);
 }

src/System/Mapper.php

Indentation +630 added lines, -630 removed lines

@@ -25,634 +25,634 @@
  */
 class Mapper
 {
-    /**
-     * The Manager instance.
-     *
-     * @var \Analogue\ORM\System\Manager
-     */
-    protected $manager;
-
-    /**
-     * Instance of EntityMapper Object.
-     *
-     * @var \Analogue\ORM\EntityMap
-     */
-    protected $entityMap;
-
-    /**
-     * The instance of db adapter.
-     *
-     * @var \Analogue\ORM\Drivers\DBAdapter
-     */
-    protected $adapter;
-
-    /**
-     * Event dispatcher instance.
-     *
-     * @var \Illuminate\Contracts\Events\Dispatcher
-     */
-    protected $dispatcher;
-
-    /**
-     * Entity Cache.
-     *
-     * @var \Analogue\ORM\System\EntityCache
-     */
-    protected $cache;
-
-    /**
-     * Global scopes.
-     *
-     * @var array
-     */
-    protected $globalScopes = [];
-
-    /**
-     * Custom Commands.
-     *
-     * @var array
-     */
-    protected $customCommands = [];
-
-    /**
-     * @param EntityMap  $entityMap
-     * @param DBAdapter  $adapter
-     * @param Dispatcher $dispatcher
-     * @param Manager    $manager
-     */
-    public function __construct(EntityMap $entityMap, DBAdapter $adapter, Dispatcher $dispatcher, Manager $manager)
-    {
-        $this->entityMap = $entityMap;
-
-        $this->adapter = $adapter;
-
-        $this->dispatcher = $dispatcher;
-
-        $this->manager = $manager;
-
-        $this->cache = new EntityCache($entityMap);
-    }
-
-    /**
-     * Map results to a Collection.
-     *
-     * @param array|Collection $results
-     *
-     * @return Collection
-     */
-    public function map($results, array $eagerLoads = []) : Collection
-    {
-        $builder = new ResultBuilder($this);
-
-        if ($results instanceof collection) {
-            // Get underlying collection array
-            $results = $results->all();
-        }
-
-        if (!is_array($results)) {
-            throw new InvalidArgumentException("'results' should be an array or collection.");
-        }
-
-        // First, we'll cast every single result to array
-        $results = array_map(function ($item) {
-            return (array) $item;
-        }, $results);
-
-        // Then, we'll cache every single results as raw attributes, before
-        // adding relationships, which will be cached when the relationship's
-        // query takes place.
-        $this->getEntityCache()->add($results);
-
-        $entities = $builder->build($results, $eagerLoads);
-
-        return $this->entityMap->newCollection($entities);
-    }
-
-    /**
-     * Return all records for a mapped object.
-     *
-     * @return EntityCollection
-     */
-    public function all()
-    {
-        return $this->query()->get();
-    }
-
-    /**
-     * Persist an entity or an entity collection into the database.
-     *
-     * @param Mappable|\Traversable|array $entity
-     *
-     * @throws \InvalidArgumentException
-     * @throws MappingException
-     *
-     * @return Mappable|\Traversable|array
-     */
-    public function store($entity)
-    {
-        if ($this->manager->isTraversable($entity)) {
-            return $this->storeCollection($entity);
-        } else {
-            return $this->storeEntity($entity);
-        }
-    }
-
-    /**
-     * Store an entity collection inside a single DB Transaction.
-     *
-     * @param \Traversable|array $entities
-     *
-     * @throws \InvalidArgumentException
-     * @throws MappingException
-     *
-     * @return \Traversable|array
-     */
-    protected function storeCollection($entities)
-    {
-        $this->adapter->beginTransaction();
-
-        foreach ($entities as $entity) {
-            $this->storeEntity($entity);
-        }
-
-        $this->adapter->commit();
-
-        return $entities;
-    }
-
-    /**
-     * Store a single entity into the database.
-     *
-     * @param Mappable $entity
-     *
-     * @throws \InvalidArgumentException
-     * @throws MappingException
-     *
-     * @return \Analogue\ORM\Entity
-     */
-    protected function storeEntity($entity)
-    {   
-        $this->checkEntityType($entity);
-
-        $store = new Store($this->aggregate($entity), $this->newQueryBuilder());
-
-        return $store->execute();
-    }
-
-    /**
-     * Check that the entity correspond to the current mapper.
-     *
-     * @param mixed $entity
-     *
-     * @throws InvalidArgumentException
-     *
-     * @return void
-     */
-    protected function checkEntityType($entity)
-    {
-        if (get_class($entity) != $this->entityMap->getClass() && !is_subclass_of($entity, $this->entityMap->getClass())) {
-            $expected = $this->entityMap->getClass();
-            $actual = get_class($entity);
-            throw new InvalidArgumentException("Expected : $expected, got $actual.");
-        }
-    }
-
-    /**
-     * Convert an entity into an aggregate root.
-     *
-     * @param mixed $entity
-     *
-     * @throws MappingException
-     *
-     * @return \Analogue\ORM\System\Aggregate
-     */
-    protected function aggregate($entity)
-    {
-        return new Aggregate($entity);
-    }
-
-    /**
-     * Get a the Underlying QueryAdapter.
-     *
-     * @return \Analogue\ORM\Drivers\QueryAdapter
-     */
-    public function newQueryBuilder()
-    {
-        return $this->adapter->getQuery();
-    }
-
-    /**
-     * Delete an entity or an entity collection from the database.
-     *
-     * @param  Mappable|\Traversable|array
-     *
-     * @throws MappingException
-     * @throws \InvalidArgumentException
-     *
-     * @return \Traversable|array
-     */
-    public function delete($entity)
-    {
-        if ($this->manager->isTraversable($entity)) {
-            return $this->deleteCollection($entity);
-        } else {
-            $this->deleteEntity($entity);
-        }
-    }
-
-    /**
-     * Delete an Entity Collection inside a single db transaction.
-     *
-     * @param \Traversable|array $entities
-     *
-     * @throws \InvalidArgumentException
-     * @throws MappingException
-     *
-     * @return \Traversable|array
-     */
-    protected function deleteCollection($entities)
-    {
-        $this->adapter->beginTransaction();
-
-        foreach ($entities as $entity) {
-            $this->deleteEntity($entity);
-        }
-
-        $this->adapter->commit();
-
-        return $entities;
-    }
-
-    /**
-     * Delete a single entity from the database.
-     *
-     * @param Mappable $entity
-     *
-     * @throws \InvalidArgumentException
-     * @throws MappingException
-     *
-     * @return void
-     */
-    protected function deleteEntity($entity)
-    {
-        $this->checkEntityType($entity);
-
-        $delete = new Delete($this->aggregate($entity), $this->newQueryBuilder());
-
-        $delete->execute();
-    }
-
-    /**
-     * Return the entity map for this mapper.
-     *
-     * @return EntityMap
-     */
-    public function getEntityMap()
-    {
-        return $this->entityMap;
-    }
-
-    /**
-     * Get the entity cache for the current mapper.
-     *
-     * @return EntityCache $entityCache
-     */
-    public function getEntityCache()
-    {
-        return $this->cache;
-    }
-
-    /**
-     * Fire the given event for the entity.
-     *
-     * @param string               $event
-     * @param \Analogue\ORM\Entity $entity
-     * @param bool                 $halt
-     *
-     * @throws InvalidArgumentException
-     *
-     * @return mixed
-     */
-    public function fireEvent($event, $entity, $halt = true)
-    {
-        if ($entity instanceof Wrapper) {
-            throw new InvalidArgumentException('Fired Event with invalid Entity Object');
-        }
-
-        $event = "analogue.{$event}.".$this->entityMap->getClass();
-
-        $method = $halt ? 'until' : 'fire';
-
-        return $this->dispatcher->$method($event, $entity);
-    }
-
-    /**
-     * Register an entity event with the dispatcher.
-     *
-     * @param string   $event
-     * @param \Closure $callback
-     *
-     * @return void
-     */
-    public function registerEvent($event, $callback)
-    {
-        $name = $this->entityMap->getClass();
-
-        $this->dispatcher->listen("analogue.{$event}.{$name}", $callback);
-    }
-
-    /**
-     * Add a global scope to this mapper query builder.
-     *
-     * @param ScopeInterface $scope
-     *
-     * @return void
-     */
-    public function addGlobalScope(ScopeInterface $scope)
-    {
-        $this->globalScopes[get_class($scope)] = $scope;
-    }
-
-    /**
-     * Determine if the mapper has a global scope.
-     *
-     * @param \Analogue\ORM\System\ScopeInterface $scope
-     *
-     * @return bool
-     */
-    public function hasGlobalScope($scope)
-    {
-        return !is_null($this->getGlobalScope($scope));
-    }
-
-    /**
-     * Get a global scope registered with the modal.
-     *
-     * @param \Analogue\ORM\System\ScopeInterface $scope
-     *
-     * @return \Analogue\ORM\System\ScopeInterface|null
-     */
-    public function getGlobalScope($scope)
-    {
-        return array_first($this->globalScopes, function ($key, $value) use ($scope) {
-            return $scope instanceof $value;
-        });
-    }
-
-    /**
-     * Get a new query instance without a given scope.
-     *
-     * @param \Analogue\ORM\System\ScopeInterface $scope
-     *
-     * @return \Analogue\ORM\System\Query
-     */
-    public function newQueryWithoutScope($scope)
-    {
-        $this->getGlobalScope($scope)->remove($query = $this->getQuery(), $this);
-
-        return $query;
-    }
-
-    /**
-     * Get the Analogue Query Builder for this instance.
-     *
-     * @return \Analogue\ORM\System\Query
-     */
-    public function getQuery()
-    {
-        $query = new Query($this, $this->adapter);
-
-        return $this->applyGlobalScopes($query);
-    }
-
-    /**
-     * Apply all of the global scopes to an Analogue Query builder.
-     *
-     * @param Query $query
-     *
-     * @return \Analogue\ORM\System\Query
-     */
-    public function applyGlobalScopes($query)
-    {
-        foreach ($this->getGlobalScopes() as $scope) {
-            $scope->apply($query, $this);
-        }
-
-        return $query;
-    }
-
-    /**
-     * Get the global scopes for this class instance.
-     *
-     * @return \Analogue\ORM\System\ScopeInterface
-     */
-    public function getGlobalScopes()
-    {
-        return $this->globalScopes;
-    }
-
-    /**
-     * Add a dynamic method that extends the mapper/repository.
-     *
-     * @param string $command
-     */
-    public function addCustomCommand($command)
-    {
-        $name = lcfirst(class_basename($command));
-
-        $this->customCommands[$name] = $command;
-    }
-
-    /**
-     * Create a new instance of the mapped entity class.
-     *
-     * @return mixed
-     */
-    public function newInstance()
-    {
-        $class = $this->entityMap->getClass();
-
-        if ($this->entityMap->useDependencyInjection()) {
-            return $this->newInstanceUsingDependencyInjection($class);
-        }
-
-        return $this->newInstanceUsingInstantiator($class);
-    }
-
-    /**
-     * Return a new object instance using dependency injection.
-     *
-     * @param string $class
-     *
-     * @return mixed
-     */
-    protected function newInstanceUsingDependencyInjection($class)
-    {
-        if (!class_exists(Container::class)) {
-            throw new ErrorException("Illuminate\Container\Container is required to use Dependency Injection");
-        }
-
-        return Container::getInstance()->make($class);
-    }
-
-    /**
-     * Return a new object instance using doctrine's instantiator.
-     *
-     * @param string $class
-     *
-     * @return mixed
-     */
-    protected function newInstanceUsingInstantiator($class)
-    {
-        $instantiator = new \Doctrine\Instantiator\Instantiator();
-
-        return $instantiator->instantiate($class);
-    }
-
-    /**
-     * Get an unscoped Analogue Query Builder for this instance.
-     *
-     * @return \Analogue\ORM\System\Query
-     */
-    public function globalQuery()
-    {
-        return $this->newQueryWithoutScopes();
-    }
-
-    /**
-     * Get a new query builder that doesn't have any global scopes.
-     *
-     * @return Query
-     */
-    public function newQueryWithoutScopes()
-    {
-        return $this->removeGlobalScopes($this->getQuery());
-    }
-
-    /**
-     * Remove all of the global scopes from an Analogue Query builder.
-     *
-     * @param Query $query
-     *
-     * @return \Analogue\ORM\System\Query
-     */
-    public function removeGlobalScopes($query)
-    {
-        foreach ($this->getGlobalScopes() as $scope) {
-            $scope->remove($query, $this);
-        }
-
-        return $query;
-    }
-
-    /**
-     * Return the manager instance.
-     *
-     * @return \Analogue\ORM\System\Manager
-     */
-    public function getManager()
-    {
-        return $this->manager;
-    }
-
-    /**
-     * Dynamically handle calls to custom commands, or Redirects to query().
-     *
-     * @param string $method
-     * @param array  $parameters
-     *
-     * @throws \Exception
-     *
-     * @return mixed
-     */
-    public function __call($method, $parameters)
-    {
-        // Check if method is a custom command on the mapper
-        if ($this->hasCustomCommand($method)) {
-            if (count($parameters) == 0) {
-                throw new \Exception("$method must at least have 1 argument");
-            }
-
-            return $this->executeCustomCommand($method, $parameters[0]);
-        }
-
-        // Redirect call on a new query instance
-        return call_user_func_array([$this->query(), $method], $parameters);
-    }
-
-    /**
-     * Check if this mapper supports this command.
-     *
-     * @param string $command
-     *
-     * @return bool
-     */
-    public function hasCustomCommand($command)
-    {
-        return in_array($command, $this->getCustomCommands());
-    }
-
-    /**
-     * Get all the custom commands registered on this mapper.
-     *
-     * @return array
-     */
-    public function getCustomCommands()
-    {
-        return array_keys($this->customCommands);
-    }
-
-    /**
-     * Execute a custom command on an Entity.
-     *
-     * @param string                 $command
-     * @param mixed|Collection|array $entity
-     *
-     * @throws \InvalidArgumentException
-     * @throws MappingException
-     *
-     * @return mixed
-     */
-    public function executeCustomCommand($command, $entity)
-    {
-        $commandClass = $this->customCommands[$command];
-
-        if ($this->manager->isTraversable($entity)) {
-            foreach ($entity as $instance) {
-                $this->executeSingleCustomCommand($commandClass, $instance);
-            }
-        } else {
-            return $this->executeSingleCustomCommand($commandClass, $entity);
-        }
-    }
-
-    /**
-     * Execute a single command instance.
-     *
-     * @param string $commandClass
-     * @param mixed  $entity
-     *
-     * @throws \InvalidArgumentException
-     * @throws MappingException
-     *
-     * @return mixed
-     */
-    protected function executeSingleCustomCommand($commandClass, $entity)
-    {
-        $this->checkEntityType($entity);
-
-        $instance = new $commandClass($this->aggregate($entity), $this->newQueryBuilder());
-
-        return $instance->execute();
-    }
-
-    /**
-     * Get the Analogue Query Builder for this instance.
-     *
-     * @return \Analogue\ORM\System\Query
-     */
-    public function query()
-    {
-        return $this->getQuery();
-    }
+	/**
+	 * The Manager instance.
+	 *
+	 * @var \Analogue\ORM\System\Manager
+	 */
+	protected $manager;
+
+	/**
+	 * Instance of EntityMapper Object.
+	 *
+	 * @var \Analogue\ORM\EntityMap
+	 */
+	protected $entityMap;
+
+	/**
+	 * The instance of db adapter.
+	 *
+	 * @var \Analogue\ORM\Drivers\DBAdapter
+	 */
+	protected $adapter;
+
+	/**
+	 * Event dispatcher instance.
+	 *
+	 * @var \Illuminate\Contracts\Events\Dispatcher
+	 */
+	protected $dispatcher;
+
+	/**
+	 * Entity Cache.
+	 *
+	 * @var \Analogue\ORM\System\EntityCache
+	 */
+	protected $cache;
+
+	/**
+	 * Global scopes.
+	 *
+	 * @var array
+	 */
+	protected $globalScopes = [];
+
+	/**
+	 * Custom Commands.
+	 *
+	 * @var array
+	 */
+	protected $customCommands = [];
+
+	/**
+	 * @param EntityMap  $entityMap
+	 * @param DBAdapter  $adapter
+	 * @param Dispatcher $dispatcher
+	 * @param Manager    $manager
+	 */
+	public function __construct(EntityMap $entityMap, DBAdapter $adapter, Dispatcher $dispatcher, Manager $manager)
+	{
+		$this->entityMap = $entityMap;
+
+		$this->adapter = $adapter;
+
+		$this->dispatcher = $dispatcher;
+
+		$this->manager = $manager;
+
+		$this->cache = new EntityCache($entityMap);
+	}
+
+	/**
+	 * Map results to a Collection.
+	 *
+	 * @param array|Collection $results
+	 *
+	 * @return Collection
+	 */
+	public function map($results, array $eagerLoads = []) : Collection
+	{
+		$builder = new ResultBuilder($this);
+
+		if ($results instanceof collection) {
+			// Get underlying collection array
+			$results = $results->all();
+		}
+
+		if (!is_array($results)) {
+			throw new InvalidArgumentException("'results' should be an array or collection.");
+		}
+
+		// First, we'll cast every single result to array
+		$results = array_map(function ($item) {
+			return (array) $item;
+		}, $results);
+
+		// Then, we'll cache every single results as raw attributes, before
+		// adding relationships, which will be cached when the relationship's
+		// query takes place.
+		$this->getEntityCache()->add($results);
+
+		$entities = $builder->build($results, $eagerLoads);
+
+		return $this->entityMap->newCollection($entities);
+	}
+
+	/**
+	 * Return all records for a mapped object.
+	 *
+	 * @return EntityCollection
+	 */
+	public function all()
+	{
+		return $this->query()->get();
+	}
+
+	/**
+	 * Persist an entity or an entity collection into the database.
+	 *
+	 * @param Mappable|\Traversable|array $entity
+	 *
+	 * @throws \InvalidArgumentException
+	 * @throws MappingException
+	 *
+	 * @return Mappable|\Traversable|array
+	 */
+	public function store($entity)
+	{
+		if ($this->manager->isTraversable($entity)) {
+			return $this->storeCollection($entity);
+		} else {
+			return $this->storeEntity($entity);
+		}
+	}
+
+	/**
+	 * Store an entity collection inside a single DB Transaction.
+	 *
+	 * @param \Traversable|array $entities
+	 *
+	 * @throws \InvalidArgumentException
+	 * @throws MappingException
+	 *
+	 * @return \Traversable|array
+	 */
+	protected function storeCollection($entities)
+	{
+		$this->adapter->beginTransaction();
+
+		foreach ($entities as $entity) {
+			$this->storeEntity($entity);
+		}
+
+		$this->adapter->commit();
+
+		return $entities;
+	}
+
+	/**
+	 * Store a single entity into the database.
+	 *
+	 * @param Mappable $entity
+	 *
+	 * @throws \InvalidArgumentException
+	 * @throws MappingException
+	 *
+	 * @return \Analogue\ORM\Entity
+	 */
+	protected function storeEntity($entity)
+	{   
+		$this->checkEntityType($entity);
+
+		$store = new Store($this->aggregate($entity), $this->newQueryBuilder());
+
+		return $store->execute();
+	}
+
+	/**
+	 * Check that the entity correspond to the current mapper.
+	 *
+	 * @param mixed $entity
+	 *
+	 * @throws InvalidArgumentException
+	 *
+	 * @return void
+	 */
+	protected function checkEntityType($entity)
+	{
+		if (get_class($entity) != $this->entityMap->getClass() && !is_subclass_of($entity, $this->entityMap->getClass())) {
+			$expected = $this->entityMap->getClass();
+			$actual = get_class($entity);
+			throw new InvalidArgumentException("Expected : $expected, got $actual.");
+		}
+	}
+
+	/**
+	 * Convert an entity into an aggregate root.
+	 *
+	 * @param mixed $entity
+	 *
+	 * @throws MappingException
+	 *
+	 * @return \Analogue\ORM\System\Aggregate
+	 */
+	protected function aggregate($entity)
+	{
+		return new Aggregate($entity);
+	}
+
+	/**
+	 * Get a the Underlying QueryAdapter.
+	 *
+	 * @return \Analogue\ORM\Drivers\QueryAdapter
+	 */
+	public function newQueryBuilder()
+	{
+		return $this->adapter->getQuery();
+	}
+
+	/**
+	 * Delete an entity or an entity collection from the database.
+	 *
+	 * @param  Mappable|\Traversable|array
+	 *
+	 * @throws MappingException
+	 * @throws \InvalidArgumentException
+	 *
+	 * @return \Traversable|array
+	 */
+	public function delete($entity)
+	{
+		if ($this->manager->isTraversable($entity)) {
+			return $this->deleteCollection($entity);
+		} else {
+			$this->deleteEntity($entity);
+		}
+	}
+
+	/**
+	 * Delete an Entity Collection inside a single db transaction.
+	 *
+	 * @param \Traversable|array $entities
+	 *
+	 * @throws \InvalidArgumentException
+	 * @throws MappingException
+	 *
+	 * @return \Traversable|array
+	 */
+	protected function deleteCollection($entities)
+	{
+		$this->adapter->beginTransaction();
+
+		foreach ($entities as $entity) {
+			$this->deleteEntity($entity);
+		}
+
+		$this->adapter->commit();
+
+		return $entities;
+	}
+
+	/**
+	 * Delete a single entity from the database.
+	 *
+	 * @param Mappable $entity
+	 *
+	 * @throws \InvalidArgumentException
+	 * @throws MappingException
+	 *
+	 * @return void
+	 */
+	protected function deleteEntity($entity)
+	{
+		$this->checkEntityType($entity);
+
+		$delete = new Delete($this->aggregate($entity), $this->newQueryBuilder());
+
+		$delete->execute();
+	}
+
+	/**
+	 * Return the entity map for this mapper.
+	 *
+	 * @return EntityMap
+	 */
+	public function getEntityMap()
+	{
+		return $this->entityMap;
+	}
+
+	/**
+	 * Get the entity cache for the current mapper.
+	 *
+	 * @return EntityCache $entityCache
+	 */
+	public function getEntityCache()
+	{
+		return $this->cache;
+	}
+
+	/**
+	 * Fire the given event for the entity.
+	 *
+	 * @param string               $event
+	 * @param \Analogue\ORM\Entity $entity
+	 * @param bool                 $halt
+	 *
+	 * @throws InvalidArgumentException
+	 *
+	 * @return mixed
+	 */
+	public function fireEvent($event, $entity, $halt = true)
+	{
+		if ($entity instanceof Wrapper) {
+			throw new InvalidArgumentException('Fired Event with invalid Entity Object');
+		}
+
+		$event = "analogue.{$event}.".$this->entityMap->getClass();
+
+		$method = $halt ? 'until' : 'fire';
+
+		return $this->dispatcher->$method($event, $entity);
+	}
+
+	/**
+	 * Register an entity event with the dispatcher.
+	 *
+	 * @param string   $event
+	 * @param \Closure $callback
+	 *
+	 * @return void
+	 */
+	public function registerEvent($event, $callback)
+	{
+		$name = $this->entityMap->getClass();
+
+		$this->dispatcher->listen("analogue.{$event}.{$name}", $callback);
+	}
+
+	/**
+	 * Add a global scope to this mapper query builder.
+	 *
+	 * @param ScopeInterface $scope
+	 *
+	 * @return void
+	 */
+	public function addGlobalScope(ScopeInterface $scope)
+	{
+		$this->globalScopes[get_class($scope)] = $scope;
+	}
+
+	/**
+	 * Determine if the mapper has a global scope.
+	 *
+	 * @param \Analogue\ORM\System\ScopeInterface $scope
+	 *
+	 * @return bool
+	 */
+	public function hasGlobalScope($scope)
+	{
+		return !is_null($this->getGlobalScope($scope));
+	}
+
+	/**
+	 * Get a global scope registered with the modal.
+	 *
+	 * @param \Analogue\ORM\System\ScopeInterface $scope
+	 *
+	 * @return \Analogue\ORM\System\ScopeInterface|null
+	 */
+	public function getGlobalScope($scope)
+	{
+		return array_first($this->globalScopes, function ($key, $value) use ($scope) {
+			return $scope instanceof $value;
+		});
+	}
+
+	/**
+	 * Get a new query instance without a given scope.
+	 *
+	 * @param \Analogue\ORM\System\ScopeInterface $scope
+	 *
+	 * @return \Analogue\ORM\System\Query
+	 */
+	public function newQueryWithoutScope($scope)
+	{
+		$this->getGlobalScope($scope)->remove($query = $this->getQuery(), $this);
+
+		return $query;
+	}
+
+	/**
+	 * Get the Analogue Query Builder for this instance.
+	 *
+	 * @return \Analogue\ORM\System\Query
+	 */
+	public function getQuery()
+	{
+		$query = new Query($this, $this->adapter);
+
+		return $this->applyGlobalScopes($query);
+	}
+
+	/**
+	 * Apply all of the global scopes to an Analogue Query builder.
+	 *
+	 * @param Query $query
+	 *
+	 * @return \Analogue\ORM\System\Query
+	 */
+	public function applyGlobalScopes($query)
+	{
+		foreach ($this->getGlobalScopes() as $scope) {
+			$scope->apply($query, $this);
+		}
+
+		return $query;
+	}
+
+	/**
+	 * Get the global scopes for this class instance.
+	 *
+	 * @return \Analogue\ORM\System\ScopeInterface
+	 */
+	public function getGlobalScopes()
+	{
+		return $this->globalScopes;
+	}
+
+	/**
+	 * Add a dynamic method that extends the mapper/repository.
+	 *
+	 * @param string $command
+	 */
+	public function addCustomCommand($command)
+	{
+		$name = lcfirst(class_basename($command));
+
+		$this->customCommands[$name] = $command;
+	}
+
+	/**
+	 * Create a new instance of the mapped entity class.
+	 *
+	 * @return mixed
+	 */
+	public function newInstance()
+	{
+		$class = $this->entityMap->getClass();
+
+		if ($this->entityMap->useDependencyInjection()) {
+			return $this->newInstanceUsingDependencyInjection($class);
+		}
+
+		return $this->newInstanceUsingInstantiator($class);
+	}
+
+	/**
+	 * Return a new object instance using dependency injection.
+	 *
+	 * @param string $class
+	 *
+	 * @return mixed
+	 */
+	protected function newInstanceUsingDependencyInjection($class)
+	{
+		if (!class_exists(Container::class)) {
+			throw new ErrorException("Illuminate\Container\Container is required to use Dependency Injection");
+		}
+
+		return Container::getInstance()->make($class);
+	}
+
+	/**
+	 * Return a new object instance using doctrine's instantiator.
+	 *
+	 * @param string $class
+	 *
+	 * @return mixed
+	 */
+	protected function newInstanceUsingInstantiator($class)
+	{
+		$instantiator = new \Doctrine\Instantiator\Instantiator();
+
+		return $instantiator->instantiate($class);
+	}
+
+	/**
+	 * Get an unscoped Analogue Query Builder for this instance.
+	 *
+	 * @return \Analogue\ORM\System\Query
+	 */
+	public function globalQuery()
+	{
+		return $this->newQueryWithoutScopes();
+	}
+
+	/**
+	 * Get a new query builder that doesn't have any global scopes.
+	 *
+	 * @return Query
+	 */
+	public function newQueryWithoutScopes()
+	{
+		return $this->removeGlobalScopes($this->getQuery());
+	}
+
+	/**
+	 * Remove all of the global scopes from an Analogue Query builder.
+	 *
+	 * @param Query $query
+	 *
+	 * @return \Analogue\ORM\System\Query
+	 */
+	public function removeGlobalScopes($query)
+	{
+		foreach ($this->getGlobalScopes() as $scope) {
+			$scope->remove($query, $this);
+		}
+
+		return $query;
+	}
+
+	/**
+	 * Return the manager instance.
+	 *
+	 * @return \Analogue\ORM\System\Manager
+	 */
+	public function getManager()
+	{
+		return $this->manager;
+	}
+
+	/**
+	 * Dynamically handle calls to custom commands, or Redirects to query().
+	 *
+	 * @param string $method
+	 * @param array  $parameters
+	 *
+	 * @throws \Exception
+	 *
+	 * @return mixed
+	 */
+	public function __call($method, $parameters)
+	{
+		// Check if method is a custom command on the mapper
+		if ($this->hasCustomCommand($method)) {
+			if (count($parameters) == 0) {
+				throw new \Exception("$method must at least have 1 argument");
+			}
+
+			return $this->executeCustomCommand($method, $parameters[0]);
+		}
+
+		// Redirect call on a new query instance
+		return call_user_func_array([$this->query(), $method], $parameters);
+	}
+
+	/**
+	 * Check if this mapper supports this command.
+	 *
+	 * @param string $command
+	 *
+	 * @return bool
+	 */
+	public function hasCustomCommand($command)
+	{
+		return in_array($command, $this->getCustomCommands());
+	}
+
+	/**
+	 * Get all the custom commands registered on this mapper.
+	 *
+	 * @return array
+	 */
+	public function getCustomCommands()
+	{
+		return array_keys($this->customCommands);
+	}
+
+	/**
+	 * Execute a custom command on an Entity.
+	 *
+	 * @param string                 $command
+	 * @param mixed|Collection|array $entity
+	 *
+	 * @throws \InvalidArgumentException
+	 * @throws MappingException
+	 *
+	 * @return mixed
+	 */
+	public function executeCustomCommand($command, $entity)
+	{
+		$commandClass = $this->customCommands[$command];
+
+		if ($this->manager->isTraversable($entity)) {
+			foreach ($entity as $instance) {
+				$this->executeSingleCustomCommand($commandClass, $instance);
+			}
+		} else {
+			return $this->executeSingleCustomCommand($commandClass, $entity);
+		}
+	}
+
+	/**
+	 * Execute a single command instance.
+	 *
+	 * @param string $commandClass
+	 * @param mixed  $entity
+	 *
+	 * @throws \InvalidArgumentException
+	 * @throws MappingException
+	 *
+	 * @return mixed
+	 */
+	protected function executeSingleCustomCommand($commandClass, $entity)
+	{
+		$this->checkEntityType($entity);
+
+		$instance = new $commandClass($this->aggregate($entity), $this->newQueryBuilder());
+
+		return $instance->execute();
+	}
+
+	/**
+	 * Get the Analogue Query Builder for this instance.
+	 *
+	 * @return \Analogue\ORM\System\Query
+	 */
+	public function query()
+	{
+		return $this->getQuery();
+	}
 }

src/System/Proxies/CollectionProxy.php

Indentation +1310 added lines, -1310 removed lines

@@ -9,1314 +9,1314 @@
 
 class CollectionProxy extends EntityCollection implements ProxyInterface
 {
-    /**
-     * Indicate if the relationship has been lazy loaded.
-     *
-     * @var bool
-     */
-    protected $relationshipLoaded = false;
-
-    protected $addedItems = [];
-
-    /**
-     * Create a new collection.
-     *
-     * @param mixed  $entity
-     * @param string $relation
-     *
-     * @return void
-     */
-    public function __construct($entity, $relation)
-    {
-        $this->parentEntity = $entity;
-        $this->relationshipMethod = $relation;
-    }
-
-    /**
-     * Return Items that has been added without lady loading
-     * the underlying collection.
-     *
-     * @return array
-     */
-    public function getAddedItems()
-    {
-        return $this->addedItems;
-    }
-
-    /**
-     * Force initialization of the proxy.
-     *
-     * @return bool true if the proxy could be initialized
-     */
-    public function initializeProxy() : bool
-    {
-        if ($this->isProxyInitialized()) {
-            return true;
-        }
-
-        $relation = $this->relationshipMethod;
-        $entity = $this->parentEntity;
-
-        $entityMap = Manager::getMapper($entity)->getEntityMap();
-
-        $this->items = $entityMap->$relation($entity)->getResults($relation)->all() + $this->addedItems;
-
-        $this->relationshipLoaded = true;
-
-        return true;
-    }
-
-    /**
-     * Retrieves current initialization status of the proxy.
-     *
-     * @return bool
-     */
-    public function isProxyInitialized() : bool
-    {
-        return $this->relationshipLoaded;
-    }
-
-    /**
-     * Get all of the items in the collection.
-     *
-     * @return array
-     */
-    public function all()
-    {
-        $this->initializeProxy();
-
-        return parent::all();
-    }
-
-    /**
-     * Get the average value of a given key.
-     *
-     * @param callable|string|null $callback
-     *
-     * @return mixed
-     */
-    public function avg($callback = null)
-    {
-        $this->initializeProxy();
-
-        return parent::avg($callback);
-    }
-
-    /**
-     * Get the median of a given key.
-     *
-     * @param null $key
-     *
-     * @return mixed|null
-     */
-    public function median($key = null)
-    {
-        $this->initializeProxy();
-
-        return parent::median($key);
-    }
-
-    /**
-     * Get the mode of a given key.
-     *
-     * @param mixed $key
-     *
-     * @return array
-     */
-    public function mode($key = null)
-    {
-        $this->initializeProxy();
-
-        return parent::mode($key);
-    }
-
-    /**
-     * Collapse the collection of items into a single array.
-     *
-     * @return static
-     */
-    public function collapse()
-    {
-        $this->initializeProxy();
-
-        return parent::collapse();
-    }
-
-    /**
-     * Determine if an item exists in the collection.
-     *
-     * @param mixed $key
-     * @param mixed $value
-     *
-     * @return bool
-     */
-    public function contains($key, $operator = null, $value = null)
-    {
-        $this->initializeProxy();
-
-        return parent::contains($key, $operator, $value);
-    }
-
-    /**
-     * Determine if an item exists in the collection using strict comparison.
-     *
-     * @param mixed $key
-     * @param mixed $value
-     *
-     * @return bool
-     */
-    public function containsStrict($key, $value = null)
-    {
-        $this->initializeProxy();
-
-        return parent::containsStrict($key, $value);
-    }
-
-    /**
-     * Get the items in the collection that are not present in the given items.
-     *
-     * @param mixed $items
-     *
-     * @return static
-     */
-    public function diff($items)
-    {
-        $this->initializeProxy();
-
-        return parent::diff($items);
-    }
-
-    /**
-     * Get the items in the collection whose keys are not present in the given items.
-     *
-     * @param mixed $items
-     *
-     * @return static
-     */
-    public function diffKeys($items)
-    {
-        $this->initializeProxy();
-
-        return parent::diffKeys($items);
-    }
-
-    /**
-     * Execute a callback over each item.
-     *
-     * @param callable $callback
-     *
-     * @return $this
-     */
-    public function each(callable $callback)
-    {
-        $this->initializeProxy();
-
-        return parent::each($callback);
-    }
-
-    /**
-     * Create a new collection consisting of every n-th element.
-     *
-     * @param int $step
-     * @param int $offset
-     *
-     * @return static
-     */
-    public function every($key, $operator = null, $value = null)
-    {
-        $this->initializeProxy();
-
-        return parent::every($key, $operator, $value);
-    }
-
-    /**
-     * Get all items except for those with the specified keys.
-     *
-     * @param mixed $keys
-     *
-     * @return static
-     */
-    public function except($keys)
-    {
-        $this->initializeProxy();
-
-        return parent::except($keys);
-    }
-
-    /**
-     * Run a filter over each of the items.
-     *
-     * @param callable|null $callback
-     *
-     * @return static
-     */
-    public function filter(callable $callback = null)
-    {
-        $this->initializeProxy();
-
-        return parent::filter($callback);
-    }
-
-    /**
-     * Filter items by the given key value pair.
-     *
-     * @param string $key
-     * @param mixed  $operator
-     * @param mixed  $value
-     *
-     * @return static
-     */
-    public function where($key, $operator, $value = null)
-    {
-        $this->initializeProxy();
-
-        return parent::where($key, $operator, $value);
-    }
-
-    /**
-     * Filter items by the given key value pair using strict comparison.
-     *
-     * @param string $key
-     * @param mixed  $value
-     *
-     * @return static
-     */
-    public function whereStrict($key, $value)
-    {
-        $this->initializeProxy();
-
-        return parent::whereStrict($key, $value);
-    }
-
-    /**
-     * Filter items by the given key value pair.
-     *
-     * @param string $key
-     * @param mixed  $values
-     * @param bool   $strict
-     *
-     * @return static
-     */
-    public function whereIn($key, $values, $strict = false)
-    {
-        $this->initializeProxy();
-
-        return parent::whereIn($key, $values, $strict);
-    }
-
-    /**
-     * Filter items by the given key value pair using strict comparison.
-     *
-     * @param string $key
-     * @param mixed  $values
-     *
-     * @return static
-     */
-    public function whereInStrict($key, $values)
-    {
-        $this->initializeProxy();
-
-        return parent::whereInStrict($key, $values);
-    }
-
-    /**
-     * Get the first item from the collection.
-     *
-     * @param callable|null $callback
-     * @param mixed         $default
-     *
-     * @return mixed
-     */
-    public function first(callable $callback = null, $default = null)
-    {
-        // TODO Consider partial loading
-        $this->initializeProxy();
-
-        return parent::first($callback, $default);
-    }
-
-    /**
-     * Get a flattened array of the items in the collection.
-     *
-     * @param int $depth
-     *
-     * @return static
-     */
-    public function flatten($depth = INF)
-    {
-        $this->initializeProxy();
-
-        return parent::flatten($depth);
-    }
-
-    /**
-     * Flip the items in the collection.
-     *
-     * @return static
-     */
-    public function flip()
-    {
-        $this->initializeProxy();
-
-        return parent::flip();
-    }
-
-    /**
-     * Remove an item from the collection by key.
-     *
-     * @param string|array $keys
-     *
-     * @return $this
-     */
-    public function forget($keys)
-    {
-        // TODO, we could consider these as
-        // 'pending deletion', the same way that
-        // we treat added items
-        $this->initializeProxy();
-
-        return parent::forget($keys);
-    }
-
-    /**
-     * Get an item from the collection by key.
-     *
-     * @param mixed $key
-     * @param mixed $default
-     *
-     * @return mixed
-     */
-    public function get($key, $default = null)
-    {
-        // TODO : We could also consider partial loading
-        // here
-        $this->initializeProxy();
-
-        return parent::get($key, $default);
-    }
-
-    /**
-     * Group an associative array by a field or using a callback.
-     *
-     * @param callable|string $groupBy
-     * @param bool            $preserveKeys
-     *
-     * @return static
-     */
-    public function groupBy($groupBy, $preserveKeys = false)
-    {
-        $this->initializeProxy();
-
-        return parent::groupBy($groupBy, $preserveKeys);
-    }
-
-    /**
-     * Key an associative array by a field or using a callback.
-     *
-     * @param callable|string $keyBy
-     *
-     * @return static
-     */
-    public function keyBy($keyBy)
-    {
-        $this->initializeProxy();
-
-        return parent::keyBy($keyBy);
-    }
-
-    /**
-     * Determine if an item exists in the collection by key.
-     *
-     * @param mixed $key
-     *
-     * @return bool
-     */
-    public function has($key)
-    {
-        // TODO : we could do automagic here by directly
-        // calling the database if the collection hasn't
-        // been initialized yet.
-        // Potential issue is that several calls to this
-        // could cause a lot queries vs a single get query.
-        $this->initializeProxy();
-
-        return parent::has($key);
-    }
-
-    /**
-     * Concatenate values of a given key as a string.
-     *
-     * @param string $value
-     * @param string $glue
-     *
-     * @return string
-     */
-    public function implode($value, $glue = null)
-    {
-        $this->initializeProxy();
-
-        return parent::implode($value, $glue);
-    }
-
-    /**
-     * Intersect the collection with the given items.
-     *
-     * @param mixed $items
-     *
-     * @return static
-     */
-    public function intersect($items)
-    {
-        $this->initializeProxy();
-
-        return parent::intersect($items);
-    }
-
-    /**
-     * Determine if the collection is empty or not.
-     *
-     * @return bool
-     */
-    public function isEmpty()
-    {
-        $this->initializeProxy();
-
-        return parent::isEmpty();
-    }
-
-    /**
-     * Get the keys of the collection items.
-     *
-     * @return static
-     */
-    public function keys()
-    {
-        $this->initializeProxy();
-
-        return parent::keys();
-    }
-
-    /**
-     * Get the last item from the collection.
-     *
-     * @param callable|null $callback
-     * @param mixed         $default
-     *
-     * @return mixed
-     */
-    public function last(callable $callback = null, $default = null)
-    {
-        // TODO : we could do partial loading there as well
-        $this->initializeProxy();
-
-        return parent::last($callback, $default);
-    }
-
-    /**
-     * Get the values of a given key.
-     *
-     * @param string      $value
-     * @param string|null $key
-     *
-     * @return static
-     */
-    public function pluck($value, $key = null)
-    {
-        // TODO : automagic call to QB if not initialized
-        $this->initializeProxy();
-
-        return parent::pluck($value, $key);
-    }
-
-    /**
-     * Run a map over each of the items.
-     *
-     * @param callable $callback
-     *
-     * @return static
-     */
-    public function map(callable $callback)
-    {
-        $this->initializeProxy();
-
-        return parent::map($callback);
-    }
-
-    /**
-     * Run an associative map over each of the items.
-     *
-     * The callback should return an associative array with a single key/value pair.
-     *
-     * @param callable $callback
-     *
-     * @return static
-     */
-    public function mapWithKeys(callable $callback)
-    {
-        $this->initializeProxy();
-
-        return parent::mapWithKeys($callback);
-    }
-
-    /**
-     * Map a collection and flatten the result by a single level.
-     *
-     * @param callable $callback
-     *
-     * @return static
-     */
-    public function flatMap(callable $callback)
-    {
-        $this->initializeProxy();
-
-        return parent::flatMap($callback);
-    }
-
-    /**
-     * Get the max value of a given key.
-     *
-     * @param callable|string|null $callback
-     *
-     * @return mixed
-     */
-    public function max($callback = null)
-    {
-        $this->initializeProxy();
-
-        return parent::max($callback);
-    }
-
-    /**
-     * Merge the collection with the given items.
-     *
-     * @param mixed $items
-     *
-     * @return static
-     */
-    public function merge($items)
-    {
-        // TODO : Check if the EntityCollection
-        // returns a native Collection, as it
-        // is what we want here
-        $this->initializeProxy();
-
-        return parent::merge($items);
-    }
-
-    /**
-     * Create a collection by using this collection for keys and another for its values.
-     *
-     * @param mixed $values
-     *
-     * @return static
-     */
-    public function combine($values)
-    {
-        // TODO : Check if the EntityCollection
-        // returns a native Collection, as it
-        // is what we want here
-        $this->initializeProxy();
-
-        return parent::combine($values);
-    }
-
-    /**
-     * Union the collection with the given items.
-     *
-     * @param mixed $items
-     *
-     * @return static
-     */
-    public function union($items)
-    {
-        // TODO : Check if the EntityCollection
-        // returns a native Collection, as it
-        // is what we want here
-        $this->initializeProxy();
-
-        return parent::union($items);
-    }
-
-    /**
-     * Get the min value of a given key.
-     *
-     * @param callable|string|null $callback
-     *
-     * @return mixed
-     */
-    public function min($callback = null)
-    {
-        // TODO : we could rely on the QB
-        // for thos, if initialization has not
-        // take place yet
-        $this->initializeProxy();
-
-        return parent::min($callback);
-    }
-
-    /**
-     * Create a new collection consisting of every n-th element.
-     *
-     * @param int $step
-     * @param int $offset
-     *
-     * @return static
-     */
-    public function nth($step, $offset = 0)
-    {
-        $this->initializeProxy();
-
-        return parent::nth($step, $offset);
-    }
-
-    /**
-     * Get the items with the specified keys.
-     *
-     * @param mixed $keys
-     *
-     * @return static
-     */
-    public function only($keys)
-    {
-        // TODO : we could rely on the QB if
-        // the collection hasn't been initialized yet
-        $this->initializeProxy();
-
-        return parent::only($keys);
-    }
-
-    /**
-     * "Paginate" the collection by slicing it into a smaller collection.
-     *
-     * @param int $page
-     * @param int $perPage
-     *
-     * @return static
-     */
-    public function forPage($page, $perPage)
-    {
-        // TODO : check possibility of partial loading
-        // if not initialized
-        $this->initializeProxy();
-
-        return parent::forPage($page, $perPage);
-    }
-
-    /**
-     * Partition the collection into two arrays using the given callback or key.
-     *
-     * @param callable|string $callback
-     *
-     * @return static
-     */
-    public function partition($callback)
-    {
-        $this->initializeProxy();
-
-        return parent::partition($callback);
-    }
-
-    /**
-     * Pass the collection to the given callback and return the result.
-     *
-     * @param callable $callback
-     *
-     * @return mixed
-     */
-    public function pipe(callable $callback)
-    {
-        $this->initializeProxy();
-
-        return parent::pipe($callback);
-    }
-
-    /**
-     * Get and remove the last item from the collection.
-     *
-     * @return mixed
-     */
-    public function pop()
-    {
-        $this->initializeProxy();
-
-        return parent::pop();
-    }
-
-    /**
-     * Push an item onto the beginning of the collection.
-     *
-     * @param mixed $value
-     * @param mixed $key
-     *
-     * @return $this
-     */
-    public function prepend($value, $key = null)
-    {
-        // TODO : partial adding of values.
-        // we could have a $prepended , and $pushed arrays
-        // which we would combine at full initialization
-
-        $this->initializeProxy();
-
-        return parent::prepend($value, $key);
-    }
-
-    /**
-     * Push an item onto the end of the collection.
-     *
-     * @param mixed $value
-     *
-     * @return $this
-     */
-    public function push($value)
-    {
-        // TODO : partial adding of values.
-        // we could have a $prepended , and $pushed arrays
-        // which we would combine at full initialization
-
-        $this->initializeProxy();
-
-        return parent::push($value);
-    }
-
-    /**
-     * Get and remove an item from the collection.
-     *
-     * @param mixed $key
-     * @param mixed $default
-     *
-     * @return mixed
-     */
-    public function pull($key, $default = null)
-    {
-        // TODO : QB query if the collection
-        // hasn't been initialized yet
-
-        $this->initializeProxy();
-
-        return parent::pull($key, $default);
-    }
-
-    /**
-     * Put an item in the collection by key.
-     *
-     * @param mixed $key
-     * @param mixed $value
-     *
-     * @return $this
-     */
-    public function put($key, $value)
-    {
-        // TODO : Partial loading ?
-
-        $this->initializeProxy();
-
-        return parent::put($key, $value);
-    }
-
-    /**
-     * Get one or more items randomly from the collection.
-     *
-     * @param int $amount
-     *
-     * @throws \InvalidArgumentException
-     *
-     * @return mixed
-     */
-    public function random($amount = 1)
-    {
-        // TODO : we could optimize this by only
-        // fetching the keys from the database
-        // and performing partial loading
-
-        $this->initializeProxy();
-
-        return parent::random($amount);
-    }
-
-    /**
-     * Reduce the collection to a single value.
-     *
-     * @param callable $callback
-     * @param mixed    $initial
-     *
-     * @return mixed
-     */
-    public function reduce(callable $callback, $initial = null)
-    {
-        $this->initializeProxy();
-
-        return parent::reduce($callback, $initial);
-    }
-
-    /**
-     * Create a collection of all elements that do not pass a given truth test.
-     *
-     * @param callable|mixed $callback
-     *
-     * @return static
-     */
-    public function reject($callback)
-    {
-        $this->initializeProxy();
-
-        return parent::reject($callback);
-    }
-
-    /**
-     * Reverse items order.
-     *
-     * @return static
-     */
-    public function reverse()
-    {
-        $this->initializeProxy();
-
-        return parent::reverse();
-    }
-
-    /**
-     * Search the collection for a given value and return the corresponding key if successful.
-     *
-     * @param mixed $value
-     * @param bool  $strict
-     *
-     * @return mixed
-     */
-    public function search($value, $strict = false)
-    {
-        $this->initializeProxy();
-
-        return parent::search($value, $strict);
-    }
-
-    /**
-     * Get and remove the first item from the collection.
-     *
-     * @return mixed
-     */
-    public function shift()
-    {
-        // Todo : Partial Removing
-        // we could have a pending removal array
-        $this->initializeProxy();
-
-        return parent::shift();
-    }
-
-    /**
-     * Shuffle the items in the collection.
-     *
-     * @param int $seed
-     *
-     * @return static
-     */
-    public function shuffle($seed = null)
-    {
-        $this->initializeProxy();
-
-        return parent::shuffle($seed);
-    }
-
-    /**
-     * Slice the underlying collection array.
-     *
-     * @param int $offset
-     * @param int $length
-     *
-     * @return static
-     */
-    public function slice($offset, $length = null)
-    {
-        $this->initializeProxy();
-
-        return parent::slice($offset, $length);
-    }
-
-    /**
-     * Split a collection into a certain number of groups.
-     *
-     * @param int $numberOfGroups
-     *
-     * @return static
-     */
-    public function split($numberOfGroups)
-    {
-        $this->initializeProxy();
-
-        return parent::split($numberOfGroups);
-    }
-
-    /**
-     * Chunk the underlying collection array.
-     *
-     * @param int $size
-     *
-     * @return static
-     */
-    public function chunk($size)
-    {
-        // TODO : partial loading ?
-        $this->initializeProxy();
-
-        return parent::chunk($size);
-    }
-
-    /**
-     * Sort through each item with a callback.
-     *
-     * @param callable|null $callback
-     *
-     * @return static
-     */
-    public function sort(callable $callback = null)
-    {
-        $this->initializeProxy();
-
-        return parent::sort($callback);
-    }
-
-    /**
-     * Sort the collection using the given callback.
-     *
-     * @param callable|string $callback
-     * @param int             $options
-     * @param bool            $descending
-     *
-     * @return static
-     */
-    public function sortBy($callback, $options = SORT_REGULAR, $descending = false)
-    {
-        $this->initializeProxy();
-
-        return parent::sort($callback, $options, $descending);
-    }
-
-    /**
-     * Splice a portion of the underlying collection array.
-     *
-     * @param int      $offset
-     * @param int|null $length
-     * @param mixed    $replacement
-     *
-     * @return static
-     */
-    public function splice($offset, $length = null, $replacement = [])
-    {
-        $this->initializeProxy();
-
-        return parent::splice($offset, $length, $replacement);
-    }
-
-    /**
-     * Get the sum of the given values.
-     *
-     * @param callable|string|null $callback
-     *
-     * @return mixed
-     */
-    public function sum($callback = null)
-    {
-        $this->initializeProxy();
-
-        return parent::sum($callback);
-    }
-
-    /**
-     * Take the first or last {$limit} items.
-     *
-     * @param int $limit
-     *
-     * @return static
-     */
-    public function take($limit)
-    {
-        // TODO: partial loading
-        $this->initializeProxy();
-
-        return parent::take($limit);
-    }
-
-    /**
-     * Pass the collection to the given callback and then return it.
-     *
-     * @param callable $callback
-     *
-     * @return $this
-     */
-    public function tap(callable $callback)
-    {
-        $this->initializeProxy();
-
-        return parent::tap($this);
-    }
-
-    /**
-     * Transform each item in the collection using a callback.
-     *
-     * @param callable $callback
-     *
-     * @return $this
-     */
-    public function transform(callable $callback)
-    {
-        $this->initializeProxy();
-
-        return parent::transform($callback);
-    }
-
-    /**
-     * Return only unique items from the collection array.
-     *
-     * @param string|callable|null $key
-     * @param bool                 $strict
-     *
-     * @return static
-     */
-    public function unique($key = null, $strict = false)
-    {
-        $this->initializeProxy();
-
-        return parent::unique($key, $strict);
-    }
-
-    /**
-     * Reset the keys on the underlying array.
-     *
-     * @return static
-     */
-    public function values()
-    {
-        $this->initializeProxy();
-
-        return parent::values();
-    }
-
-    /**
-     * Apply the callback if the value is truthy.
-     *
-     * @param  bool  $value
-     * @param  callable  $callback
-     * @return mixed
-     */
-    public function when($value, callable $callback)
-    {
-        $this->initializeProxy();
-
-        return parent::when($value, $callback);
-    }
-
-    /**
-     * Zip the collection together with one or more arrays.
-     *
-     * e.g. new Collection([1, 2, 3])->zip([4, 5, 6]);
-     *      => [[1, 4], [2, 5], [3, 6]]
-     *
-     * @param mixed ...$items
-     *
-     * @return static
-     */
-    public function zip($items)
-    {
-        $this->initializeProxy();
-
-        return parent::zip($items);
-    }
-
-    /**
-     * Get the collection of items as a plain array.
-     *
-     * @return array
-     */
-    public function toArray()
-    {
-        // If this is called on all subsequent proxy,
-        // this would eventually trigger all lazy loading,
-        // which is NOT what we would expect...
-        // TODO : must think of this.
-        $this->initializeProxy();
-
-        return parent::toArray();
-    }
-
-    /**
-     * Convert the object into something JSON serializable.
-     *
-     * @return array
-     */
-    public function jsonSerialize()
-    {
-        // If this is called on all subsequent proxy,
-        // this would eventually trigger all lazy loading,
-        // which is NOT what we would expect...
-        // TODO : must think of this.
-        $this->initializeProxy();
-
-        return parent::jsonSerialize();
-    }
-
-    /**
-     * Get the collection of items as JSON.
-     *
-     * @param int $options
-     *
-     * @return string
-     */
-    public function toJson($options = 0)
-    {
-        // If this is called on all subsequent proxy,
-        // this would eventually trigger all lazy loading,
-        // which is NOT what we would expect...
-        // TODO : must think of this.
-        $this->initializeProxy();
-
-        return parent::toJson($options);
-    }
-
-    /**
-     * Get an iterator for the items.
-     *
-     * @return \ArrayIterator
-     */
-    public function getIterator()
-    {
-        $this->initializeProxy();
-
-        return parent::getIterator();
-    }
-
-    /**
-     * Get a CachingIterator instance.
-     *
-     * @param int $flags
-     *
-     * @return \CachingIterator
-     */
-    public function getCachingIterator($flags = CachingIterator::CALL_TOSTRING)
-    {
-        $this->initializeProxy();
-
-        return parent::getCachingIterator($flags);
-    }
-
-    /**
-     * Count the number of items in the collection.
-     *
-     * @return int
-     */
-    public function count()
-    {
-        // TODO rely on QB if not initialized
-        $this->initializeProxy();
-
-        return parent::count();
-    }
-
-    /**
-     * Get a base Support collection instance from this collection.
-     *
-     * @return \Illuminate\Support\Collection
-     */
-    public function toBase()
-    {
-        $this->initializeProxy();
-
-        return parent::toBase();
-    }
-
-    /**
-     * Determine if an item exists at an offset.
-     *
-     * @param mixed $key
-     *
-     * @return bool
-     */
-    public function offsetExists($key)
-    {
-        // TODO rely on QB if no collection
-        // initialized
-        $this->initializeProxy();
-
-        return parent::offsetExists($key);
-    }
-
-    /**
-     * Get an item at a given offset.
-     *
-     * @param mixed $key
-     *
-     * @return mixed
-     */
-    public function offsetGet($key)
-    {
-        // TODO rely on partial init if no collection
-        // initialized
-        $this->initializeProxy();
-
-        return parent::offsetGet($key);
-    }
-
-    /**
-     * Set the item at a given offset.
-     *
-     * @param mixed $key
-     * @param mixed $value
-     *
-     * @return void
-     */
-    public function offsetSet($key, $value)
-    {
-        // TODO : think of the use of it into a ProxyCollection
-        // context
-        $this->initializeProxy();
-
-        return parent::offsetSet($key, $value);
-    }
-
-    /**
-     * Unset the item at a given offset.
-     *
-     * @param string $key
-     *
-     * @return void
-     */
-    public function offsetUnset($key)
-    {
-        // TODO : think of the use of it into a ProxyCollection
-        // context
-        $this->initializeProxy();
-
-        return parent::offsetUnset($key);
-    }
-
-    /**
-     * Dynamically access collection proxies.
-     *
-     * @param string $key
-     *
-     * @throws \Exception
-     *
-     * @return mixed
-     */
-    public function __get($key)
-    {
-        parent::__get($key);
-    }
-
-    /**
-     * Dynamically handle calls to the class.
-     *
-     * @param string $method
-     * @param array  $parameters
-     *
-     * @throws \BadMethodCallException
-     *
-     * @return mixed
-     */
-    public function __call($method, $parameters)
-    {
-        $this->initializeProxy();
-
-        return parent::__call($method, $parameters);
-    }
+	/**
+	 * Indicate if the relationship has been lazy loaded.
+	 *
+	 * @var bool
+	 */
+	protected $relationshipLoaded = false;
+
+	protected $addedItems = [];
+
+	/**
+	 * Create a new collection.
+	 *
+	 * @param mixed  $entity
+	 * @param string $relation
+	 *
+	 * @return void
+	 */
+	public function __construct($entity, $relation)
+	{
+		$this->parentEntity = $entity;
+		$this->relationshipMethod = $relation;
+	}
+
+	/**
+	 * Return Items that has been added without lady loading
+	 * the underlying collection.
+	 *
+	 * @return array
+	 */
+	public function getAddedItems()
+	{
+		return $this->addedItems;
+	}
+
+	/**
+	 * Force initialization of the proxy.
+	 *
+	 * @return bool true if the proxy could be initialized
+	 */
+	public function initializeProxy() : bool
+	{
+		if ($this->isProxyInitialized()) {
+			return true;
+		}
+
+		$relation = $this->relationshipMethod;
+		$entity = $this->parentEntity;
+
+		$entityMap = Manager::getMapper($entity)->getEntityMap();
+
+		$this->items = $entityMap->$relation($entity)->getResults($relation)->all() + $this->addedItems;
+
+		$this->relationshipLoaded = true;
+
+		return true;
+	}
+
+	/**
+	 * Retrieves current initialization status of the proxy.
+	 *
+	 * @return bool
+	 */
+	public function isProxyInitialized() : bool
+	{
+		return $this->relationshipLoaded;
+	}
+
+	/**
+	 * Get all of the items in the collection.
+	 *
+	 * @return array
+	 */
+	public function all()
+	{
+		$this->initializeProxy();
+
+		return parent::all();
+	}
+
+	/**
+	 * Get the average value of a given key.
+	 *
+	 * @param callable|string|null $callback
+	 *
+	 * @return mixed
+	 */
+	public function avg($callback = null)
+	{
+		$this->initializeProxy();
+
+		return parent::avg($callback);
+	}
+
+	/**
+	 * Get the median of a given key.
+	 *
+	 * @param null $key
+	 *
+	 * @return mixed|null
+	 */
+	public function median($key = null)
+	{
+		$this->initializeProxy();
+
+		return parent::median($key);
+	}
+
+	/**
+	 * Get the mode of a given key.
+	 *
+	 * @param mixed $key
+	 *
+	 * @return array
+	 */
+	public function mode($key = null)
+	{
+		$this->initializeProxy();
+
+		return parent::mode($key);
+	}
+
+	/**
+	 * Collapse the collection of items into a single array.
+	 *
+	 * @return static
+	 */
+	public function collapse()
+	{
+		$this->initializeProxy();
+
+		return parent::collapse();
+	}
+
+	/**
+	 * Determine if an item exists in the collection.
+	 *
+	 * @param mixed $key
+	 * @param mixed $value
+	 *
+	 * @return bool
+	 */
+	public function contains($key, $operator = null, $value = null)
+	{
+		$this->initializeProxy();
+
+		return parent::contains($key, $operator, $value);
+	}
+
+	/**
+	 * Determine if an item exists in the collection using strict comparison.
+	 *
+	 * @param mixed $key
+	 * @param mixed $value
+	 *
+	 * @return bool
+	 */
+	public function containsStrict($key, $value = null)
+	{
+		$this->initializeProxy();
+
+		return parent::containsStrict($key, $value);
+	}
+
+	/**
+	 * Get the items in the collection that are not present in the given items.
+	 *
+	 * @param mixed $items
+	 *
+	 * @return static
+	 */
+	public function diff($items)
+	{
+		$this->initializeProxy();
+
+		return parent::diff($items);
+	}
+
+	/**
+	 * Get the items in the collection whose keys are not present in the given items.
+	 *
+	 * @param mixed $items
+	 *
+	 * @return static
+	 */
+	public function diffKeys($items)
+	{
+		$this->initializeProxy();
+
+		return parent::diffKeys($items);
+	}
+
+	/**
+	 * Execute a callback over each item.
+	 *
+	 * @param callable $callback
+	 *
+	 * @return $this
+	 */
+	public function each(callable $callback)
+	{
+		$this->initializeProxy();
+
+		return parent::each($callback);
+	}
+
+	/**
+	 * Create a new collection consisting of every n-th element.
+	 *
+	 * @param int $step
+	 * @param int $offset
+	 *
+	 * @return static
+	 */
+	public function every($key, $operator = null, $value = null)
+	{
+		$this->initializeProxy();
+
+		return parent::every($key, $operator, $value);
+	}
+
+	/**
+	 * Get all items except for those with the specified keys.
+	 *
+	 * @param mixed $keys
+	 *
+	 * @return static
+	 */
+	public function except($keys)
+	{
+		$this->initializeProxy();
+
+		return parent::except($keys);
+	}
+
+	/**
+	 * Run a filter over each of the items.
+	 *
+	 * @param callable|null $callback
+	 *
+	 * @return static
+	 */
+	public function filter(callable $callback = null)
+	{
+		$this->initializeProxy();
+
+		return parent::filter($callback);
+	}
+
+	/**
+	 * Filter items by the given key value pair.
+	 *
+	 * @param string $key
+	 * @param mixed  $operator
+	 * @param mixed  $value
+	 *
+	 * @return static
+	 */
+	public function where($key, $operator, $value = null)
+	{
+		$this->initializeProxy();
+
+		return parent::where($key, $operator, $value);
+	}
+
+	/**
+	 * Filter items by the given key value pair using strict comparison.
+	 *
+	 * @param string $key
+	 * @param mixed  $value
+	 *
+	 * @return static
+	 */
+	public function whereStrict($key, $value)
+	{
+		$this->initializeProxy();
+
+		return parent::whereStrict($key, $value);
+	}
+
+	/**
+	 * Filter items by the given key value pair.
+	 *
+	 * @param string $key
+	 * @param mixed  $values
+	 * @param bool   $strict
+	 *
+	 * @return static
+	 */
+	public function whereIn($key, $values, $strict = false)
+	{
+		$this->initializeProxy();
+
+		return parent::whereIn($key, $values, $strict);
+	}
+
+	/**
+	 * Filter items by the given key value pair using strict comparison.
+	 *
+	 * @param string $key
+	 * @param mixed  $values
+	 *
+	 * @return static
+	 */
+	public function whereInStrict($key, $values)
+	{
+		$this->initializeProxy();
+
+		return parent::whereInStrict($key, $values);
+	}
+
+	/**
+	 * Get the first item from the collection.
+	 *
+	 * @param callable|null $callback
+	 * @param mixed         $default
+	 *
+	 * @return mixed
+	 */
+	public function first(callable $callback = null, $default = null)
+	{
+		// TODO Consider partial loading
+		$this->initializeProxy();
+
+		return parent::first($callback, $default);
+	}
+
+	/**
+	 * Get a flattened array of the items in the collection.
+	 *
+	 * @param int $depth
+	 *
+	 * @return static
+	 */
+	public function flatten($depth = INF)
+	{
+		$this->initializeProxy();
+
+		return parent::flatten($depth);
+	}
+
+	/**
+	 * Flip the items in the collection.
+	 *
+	 * @return static
+	 */
+	public function flip()
+	{
+		$this->initializeProxy();
+
+		return parent::flip();
+	}
+
+	/**
+	 * Remove an item from the collection by key.
+	 *
+	 * @param string|array $keys
+	 *
+	 * @return $this
+	 */
+	public function forget($keys)
+	{
+		// TODO, we could consider these as
+		// 'pending deletion', the same way that
+		// we treat added items
+		$this->initializeProxy();
+
+		return parent::forget($keys);
+	}
+
+	/**
+	 * Get an item from the collection by key.
+	 *
+	 * @param mixed $key
+	 * @param mixed $default
+	 *
+	 * @return mixed
+	 */
+	public function get($key, $default = null)
+	{
+		// TODO : We could also consider partial loading
+		// here
+		$this->initializeProxy();
+
+		return parent::get($key, $default);
+	}
+
+	/**
+	 * Group an associative array by a field or using a callback.
+	 *
+	 * @param callable|string $groupBy
+	 * @param bool            $preserveKeys
+	 *
+	 * @return static
+	 */
+	public function groupBy($groupBy, $preserveKeys = false)
+	{
+		$this->initializeProxy();
+
+		return parent::groupBy($groupBy, $preserveKeys);
+	}
+
+	/**
+	 * Key an associative array by a field or using a callback.
+	 *
+	 * @param callable|string $keyBy
+	 *
+	 * @return static
+	 */
+	public function keyBy($keyBy)
+	{
+		$this->initializeProxy();
+
+		return parent::keyBy($keyBy);
+	}
+
+	/**
+	 * Determine if an item exists in the collection by key.
+	 *
+	 * @param mixed $key
+	 *
+	 * @return bool
+	 */
+	public function has($key)
+	{
+		// TODO : we could do automagic here by directly
+		// calling the database if the collection hasn't
+		// been initialized yet.
+		// Potential issue is that several calls to this
+		// could cause a lot queries vs a single get query.
+		$this->initializeProxy();
+
+		return parent::has($key);
+	}
+
+	/**
+	 * Concatenate values of a given key as a string.
+	 *
+	 * @param string $value
+	 * @param string $glue
+	 *
+	 * @return string
+	 */
+	public function implode($value, $glue = null)
+	{
+		$this->initializeProxy();
+
+		return parent::implode($value, $glue);
+	}
+
+	/**
+	 * Intersect the collection with the given items.
+	 *
+	 * @param mixed $items
+	 *
+	 * @return static
+	 */
+	public function intersect($items)
+	{
+		$this->initializeProxy();
+
+		return parent::intersect($items);
+	}
+
+	/**
+	 * Determine if the collection is empty or not.
+	 *
+	 * @return bool
+	 */
+	public function isEmpty()
+	{
+		$this->initializeProxy();
+
+		return parent::isEmpty();
+	}
+
+	/**
+	 * Get the keys of the collection items.
+	 *
+	 * @return static
+	 */
+	public function keys()
+	{
+		$this->initializeProxy();
+
+		return parent::keys();
+	}
+
+	/**
+	 * Get the last item from the collection.
+	 *
+	 * @param callable|null $callback
+	 * @param mixed         $default
+	 *
+	 * @return mixed
+	 */
+	public function last(callable $callback = null, $default = null)
+	{
+		// TODO : we could do partial loading there as well
+		$this->initializeProxy();
+
+		return parent::last($callback, $default);
+	}
+
+	/**
+	 * Get the values of a given key.
+	 *
+	 * @param string      $value
+	 * @param string|null $key
+	 *
+	 * @return static
+	 */
+	public function pluck($value, $key = null)
+	{
+		// TODO : automagic call to QB if not initialized
+		$this->initializeProxy();
+
+		return parent::pluck($value, $key);
+	}
+
+	/**
+	 * Run a map over each of the items.
+	 *
+	 * @param callable $callback
+	 *
+	 * @return static
+	 */
+	public function map(callable $callback)
+	{
+		$this->initializeProxy();
+
+		return parent::map($callback);
+	}
+
+	/**
+	 * Run an associative map over each of the items.
+	 *
+	 * The callback should return an associative array with a single key/value pair.
+	 *
+	 * @param callable $callback
+	 *
+	 * @return static
+	 */
+	public function mapWithKeys(callable $callback)
+	{
+		$this->initializeProxy();
+
+		return parent::mapWithKeys($callback);
+	}
+
+	/**
+	 * Map a collection and flatten the result by a single level.
+	 *
+	 * @param callable $callback
+	 *
+	 * @return static
+	 */
+	public function flatMap(callable $callback)
+	{
+		$this->initializeProxy();
+
+		return parent::flatMap($callback);
+	}
+
+	/**
+	 * Get the max value of a given key.
+	 *
+	 * @param callable|string|null $callback
+	 *
+	 * @return mixed
+	 */
+	public function max($callback = null)
+	{
+		$this->initializeProxy();
+
+		return parent::max($callback);
+	}
+
+	/**
+	 * Merge the collection with the given items.
+	 *
+	 * @param mixed $items
+	 *
+	 * @return static
+	 */
+	public function merge($items)
+	{
+		// TODO : Check if the EntityCollection
+		// returns a native Collection, as it
+		// is what we want here
+		$this->initializeProxy();
+
+		return parent::merge($items);
+	}
+
+	/**
+	 * Create a collection by using this collection for keys and another for its values.
+	 *
+	 * @param mixed $values
+	 *
+	 * @return static
+	 */
+	public function combine($values)
+	{
+		// TODO : Check if the EntityCollection
+		// returns a native Collection, as it
+		// is what we want here
+		$this->initializeProxy();
+
+		return parent::combine($values);
+	}
+
+	/**
+	 * Union the collection with the given items.
+	 *
+	 * @param mixed $items
+	 *
+	 * @return static
+	 */
+	public function union($items)
+	{
+		// TODO : Check if the EntityCollection
+		// returns a native Collection, as it
+		// is what we want here
+		$this->initializeProxy();
+
+		return parent::union($items);
+	}
+
+	/**
+	 * Get the min value of a given key.
+	 *
+	 * @param callable|string|null $callback
+	 *
+	 * @return mixed
+	 */
+	public function min($callback = null)
+	{
+		// TODO : we could rely on the QB
+		// for thos, if initialization has not
+		// take place yet
+		$this->initializeProxy();
+
+		return parent::min($callback);
+	}
+
+	/**
+	 * Create a new collection consisting of every n-th element.
+	 *
+	 * @param int $step
+	 * @param int $offset
+	 *
+	 * @return static
+	 */
+	public function nth($step, $offset = 0)
+	{
+		$this->initializeProxy();
+
+		return parent::nth($step, $offset);
+	}
+
+	/**
+	 * Get the items with the specified keys.
+	 *
+	 * @param mixed $keys
+	 *
+	 * @return static
+	 */
+	public function only($keys)
+	{
+		// TODO : we could rely on the QB if
+		// the collection hasn't been initialized yet
+		$this->initializeProxy();
+
+		return parent::only($keys);
+	}
+
+	/**
+	 * "Paginate" the collection by slicing it into a smaller collection.
+	 *
+	 * @param int $page
+	 * @param int $perPage
+	 *
+	 * @return static
+	 */
+	public function forPage($page, $perPage)
+	{
+		// TODO : check possibility of partial loading
+		// if not initialized
+		$this->initializeProxy();
+
+		return parent::forPage($page, $perPage);
+	}
+
+	/**
+	 * Partition the collection into two arrays using the given callback or key.
+	 *
+	 * @param callable|string $callback
+	 *
+	 * @return static
+	 */
+	public function partition($callback)
+	{
+		$this->initializeProxy();
+
+		return parent::partition($callback);
+	}
+
+	/**
+	 * Pass the collection to the given callback and return the result.
+	 *
+	 * @param callable $callback
+	 *
+	 * @return mixed
+	 */
+	public function pipe(callable $callback)
+	{
+		$this->initializeProxy();
+
+		return parent::pipe($callback);
+	}
+
+	/**
+	 * Get and remove the last item from the collection.
+	 *
+	 * @return mixed
+	 */
+	public function pop()
+	{
+		$this->initializeProxy();
+
+		return parent::pop();
+	}
+
+	/**
+	 * Push an item onto the beginning of the collection.
+	 *
+	 * @param mixed $value
+	 * @param mixed $key
+	 *
+	 * @return $this
+	 */
+	public function prepend($value, $key = null)
+	{
+		// TODO : partial adding of values.
+		// we could have a $prepended , and $pushed arrays
+		// which we would combine at full initialization
+
+		$this->initializeProxy();
+
+		return parent::prepend($value, $key);
+	}
+
+	/**
+	 * Push an item onto the end of the collection.
+	 *
+	 * @param mixed $value
+	 *
+	 * @return $this
+	 */
+	public function push($value)
+	{
+		// TODO : partial adding of values.
+		// we could have a $prepended , and $pushed arrays
+		// which we would combine at full initialization
+
+		$this->initializeProxy();
+
+		return parent::push($value);
+	}
+
+	/**
+	 * Get and remove an item from the collection.
+	 *
+	 * @param mixed $key
+	 * @param mixed $default
+	 *
+	 * @return mixed
+	 */
+	public function pull($key, $default = null)
+	{
+		// TODO : QB query if the collection
+		// hasn't been initialized yet
+
+		$this->initializeProxy();
+
+		return parent::pull($key, $default);
+	}
+
+	/**
+	 * Put an item in the collection by key.
+	 *
+	 * @param mixed $key
+	 * @param mixed $value
+	 *
+	 * @return $this
+	 */
+	public function put($key, $value)
+	{
+		// TODO : Partial loading ?
+
+		$this->initializeProxy();
+
+		return parent::put($key, $value);
+	}
+
+	/**
+	 * Get one or more items randomly from the collection.
+	 *
+	 * @param int $amount
+	 *
+	 * @throws \InvalidArgumentException
+	 *
+	 * @return mixed
+	 */
+	public function random($amount = 1)
+	{
+		// TODO : we could optimize this by only
+		// fetching the keys from the database
+		// and performing partial loading
+
+		$this->initializeProxy();
+
+		return parent::random($amount);
+	}
+
+	/**
+	 * Reduce the collection to a single value.
+	 *
+	 * @param callable $callback
+	 * @param mixed    $initial
+	 *
+	 * @return mixed
+	 */
+	public function reduce(callable $callback, $initial = null)
+	{
+		$this->initializeProxy();
+
+		return parent::reduce($callback, $initial);
+	}
+
+	/**
+	 * Create a collection of all elements that do not pass a given truth test.
+	 *
+	 * @param callable|mixed $callback
+	 *
+	 * @return static
+	 */
+	public function reject($callback)
+	{
+		$this->initializeProxy();
+
+		return parent::reject($callback);
+	}
+
+	/**
+	 * Reverse items order.
+	 *
+	 * @return static
+	 */
+	public function reverse()
+	{
+		$this->initializeProxy();
+
+		return parent::reverse();
+	}
+
+	/**
+	 * Search the collection for a given value and return the corresponding key if successful.
+	 *
+	 * @param mixed $value
+	 * @param bool  $strict
+	 *
+	 * @return mixed
+	 */
+	public function search($value, $strict = false)
+	{
+		$this->initializeProxy();
+
+		return parent::search($value, $strict);
+	}
+
+	/**
+	 * Get and remove the first item from the collection.
+	 *
+	 * @return mixed
+	 */
+	public function shift()
+	{
+		// Todo : Partial Removing
+		// we could have a pending removal array
+		$this->initializeProxy();
+
+		return parent::shift();
+	}
+
+	/**
+	 * Shuffle the items in the collection.
+	 *
+	 * @param int $seed
+	 *
+	 * @return static
+	 */
+	public function shuffle($seed = null)
+	{
+		$this->initializeProxy();
+
+		return parent::shuffle($seed);
+	}
+
+	/**
+	 * Slice the underlying collection array.
+	 *
+	 * @param int $offset
+	 * @param int $length
+	 *
+	 * @return static
+	 */
+	public function slice($offset, $length = null)
+	{
+		$this->initializeProxy();
+
+		return parent::slice($offset, $length);
+	}
+
+	/**
+	 * Split a collection into a certain number of groups.
+	 *
+	 * @param int $numberOfGroups
+	 *
+	 * @return static
+	 */
+	public function split($numberOfGroups)
+	{
+		$this->initializeProxy();
+
+		return parent::split($numberOfGroups);
+	}
+
+	/**
+	 * Chunk the underlying collection array.
+	 *
+	 * @param int $size
+	 *
+	 * @return static
+	 */
+	public function chunk($size)
+	{
+		// TODO : partial loading ?
+		$this->initializeProxy();
+
+		return parent::chunk($size);
+	}
+
+	/**
+	 * Sort through each item with a callback.
+	 *
+	 * @param callable|null $callback
+	 *
+	 * @return static
+	 */
+	public function sort(callable $callback = null)
+	{
+		$this->initializeProxy();
+
+		return parent::sort($callback);
+	}
+
+	/**
+	 * Sort the collection using the given callback.
+	 *
+	 * @param callable|string $callback
+	 * @param int             $options
+	 * @param bool            $descending
+	 *
+	 * @return static
+	 */
+	public function sortBy($callback, $options = SORT_REGULAR, $descending = false)
+	{
+		$this->initializeProxy();
+
+		return parent::sort($callback, $options, $descending);
+	}
+
+	/**
+	 * Splice a portion of the underlying collection array.
+	 *
+	 * @param int      $offset
+	 * @param int|null $length
+	 * @param mixed    $replacement
+	 *
+	 * @return static
+	 */
+	public function splice($offset, $length = null, $replacement = [])
+	{
+		$this->initializeProxy();
+
+		return parent::splice($offset, $length, $replacement);
+	}
+
+	/**
+	 * Get the sum of the given values.
+	 *
+	 * @param callable|string|null $callback
+	 *
+	 * @return mixed
+	 */
+	public function sum($callback = null)
+	{
+		$this->initializeProxy();
+
+		return parent::sum($callback);
+	}
+
+	/**
+	 * Take the first or last {$limit} items.
+	 *
+	 * @param int $limit
+	 *
+	 * @return static
+	 */
+	public function take($limit)
+	{
+		// TODO: partial loading
+		$this->initializeProxy();
+
+		return parent::take($limit);
+	}
+
+	/**
+	 * Pass the collection to the given callback and then return it.
+	 *
+	 * @param callable $callback
+	 *
+	 * @return $this
+	 */
+	public function tap(callable $callback)
+	{
+		$this->initializeProxy();
+
+		return parent::tap($this);
+	}
+
+	/**
+	 * Transform each item in the collection using a callback.
+	 *
+	 * @param callable $callback
+	 *
+	 * @return $this
+	 */
+	public function transform(callable $callback)
+	{
+		$this->initializeProxy();
+
+		return parent::transform($callback);
+	}
+
+	/**
+	 * Return only unique items from the collection array.
+	 *
+	 * @param string|callable|null $key
+	 * @param bool                 $strict
+	 *
+	 * @return static
+	 */
+	public function unique($key = null, $strict = false)
+	{
+		$this->initializeProxy();
+
+		return parent::unique($key, $strict);
+	}
+
+	/**
+	 * Reset the keys on the underlying array.
+	 *
+	 * @return static
+	 */
+	public function values()
+	{
+		$this->initializeProxy();
+
+		return parent::values();
+	}
+
+	/**
+	 * Apply the callback if the value is truthy.
+	 *
+	 * @param  bool  $value
+	 * @param  callable  $callback
+	 * @return mixed
+	 */
+	public function when($value, callable $callback)
+	{
+		$this->initializeProxy();
+
+		return parent::when($value, $callback);
+	}
+
+	/**
+	 * Zip the collection together with one or more arrays.
+	 *
+	 * e.g. new Collection([1, 2, 3])->zip([4, 5, 6]);
+	 *      => [[1, 4], [2, 5], [3, 6]]
+	 *
+	 * @param mixed ...$items
+	 *
+	 * @return static
+	 */
+	public function zip($items)
+	{
+		$this->initializeProxy();
+
+		return parent::zip($items);
+	}
+
+	/**
+	 * Get the collection of items as a plain array.
+	 *
+	 * @return array
+	 */
+	public function toArray()
+	{
+		// If this is called on all subsequent proxy,
+		// this would eventually trigger all lazy loading,
+		// which is NOT what we would expect...
+		// TODO : must think of this.
+		$this->initializeProxy();
+
+		return parent::toArray();
+	}
+
+	/**
+	 * Convert the object into something JSON serializable.
+	 *
+	 * @return array
+	 */
+	public function jsonSerialize()
+	{
+		// If this is called on all subsequent proxy,
+		// this would eventually trigger all lazy loading,
+		// which is NOT what we would expect...
+		// TODO : must think of this.
+		$this->initializeProxy();
+
+		return parent::jsonSerialize();
+	}
+
+	/**
+	 * Get the collection of items as JSON.
+	 *
+	 * @param int $options
+	 *
+	 * @return string
+	 */
+	public function toJson($options = 0)
+	{
+		// If this is called on all subsequent proxy,
+		// this would eventually trigger all lazy loading,
+		// which is NOT what we would expect...
+		// TODO : must think of this.
+		$this->initializeProxy();
+
+		return parent::toJson($options);
+	}
+
+	/**
+	 * Get an iterator for the items.
+	 *
+	 * @return \ArrayIterator
+	 */
+	public function getIterator()
+	{
+		$this->initializeProxy();
+
+		return parent::getIterator();
+	}
+
+	/**
+	 * Get a CachingIterator instance.
+	 *
+	 * @param int $flags
+	 *
+	 * @return \CachingIterator
+	 */
+	public function getCachingIterator($flags = CachingIterator::CALL_TOSTRING)
+	{
+		$this->initializeProxy();
+
+		return parent::getCachingIterator($flags);
+	}
+
+	/**
+	 * Count the number of items in the collection.
+	 *
+	 * @return int
+	 */
+	public function count()
+	{
+		// TODO rely on QB if not initialized
+		$this->initializeProxy();
+
+		return parent::count();
+	}
+
+	/**
+	 * Get a base Support collection instance from this collection.
+	 *
+	 * @return \Illuminate\Support\Collection
+	 */
+	public function toBase()
+	{
+		$this->initializeProxy();
+
+		return parent::toBase();
+	}
+
+	/**
+	 * Determine if an item exists at an offset.
+	 *
+	 * @param mixed $key
+	 *
+	 * @return bool
+	 */
+	public function offsetExists($key)
+	{
+		// TODO rely on QB if no collection
+		// initialized
+		$this->initializeProxy();
+
+		return parent::offsetExists($key);
+	}
+
+	/**
+	 * Get an item at a given offset.
+	 *
+	 * @param mixed $key
+	 *
+	 * @return mixed
+	 */
+	public function offsetGet($key)
+	{
+		// TODO rely on partial init if no collection
+		// initialized
+		$this->initializeProxy();
+
+		return parent::offsetGet($key);
+	}
+
+	/**
+	 * Set the item at a given offset.
+	 *
+	 * @param mixed $key
+	 * @param mixed $value
+	 *
+	 * @return void
+	 */
+	public function offsetSet($key, $value)
+	{
+		// TODO : think of the use of it into a ProxyCollection
+		// context
+		$this->initializeProxy();
+
+		return parent::offsetSet($key, $value);
+	}
+
+	/**
+	 * Unset the item at a given offset.
+	 *
+	 * @param string $key
+	 *
+	 * @return void
+	 */
+	public function offsetUnset($key)
+	{
+		// TODO : think of the use of it into a ProxyCollection
+		// context
+		$this->initializeProxy();
+
+		return parent::offsetUnset($key);
+	}
+
+	/**
+	 * Dynamically access collection proxies.
+	 *
+	 * @param string $key
+	 *
+	 * @throws \Exception
+	 *
+	 * @return mixed
+	 */
+	public function __get($key)
+	{
+		parent::__get($key);
+	}
+
+	/**
+	 * Dynamically handle calls to the class.
+	 *
+	 * @param string $method
+	 * @param array  $parameters
+	 *
+	 * @throws \BadMethodCallException
+	 *
+	 * @return mixed
+	 */
+	public function __call($method, $parameters)
+	{
+		$this->initializeProxy();
+
+		return parent::__call($method, $parameters);
+	}
 }

src/System/Proxies/ProxyFactory.php

Indentation +43 added lines, -43 removed lines

@@ -14,47 +14,47 @@
  */
 class ProxyFactory
 {
-    public function make($entity, $relation, $class)
-    {
-        $entityMap = Manager::getMapper($entity)->getEntityMap();
-
-        $singleRelations = $entityMap->getSingleRelationships();
-        $manyRelations = $entityMap->getManyRelationships();
-
-        if (in_array($relation, $singleRelations)) {
-            return $this->makeEntityProxy($entity, $relation, $class);
-        }
-
-        if (in_array($relation, $manyRelations)) {
-            return new CollectionProxy($entity, $relation);
-        }
-
-        throw new MappingException("Could not identify relation '$relation'");
-    }
-
-    /**
-     * Create an instance of a proxy object, extending the actual
-     * related class.
-     *
-     * @param mixed  $entity   parent object
-     * @param string $relation the name of the relationship method
-     * @param string $class    the class name of the related object
-     *
-     * @return mixed
-     */
-    protected function makeEntityProxy($entity, $relation, $class)
-    {
-        $factory = new LazyLoadingValueHolderFactory();
-
-        $initializer = function (&$wrappedObject, LazyLoadingInterface $proxy, $method, array $parameters, &$initializer) use ($entity, $relation) {
-            $entityMap = Manager::getMapper($entity)->getEntityMap();
-
-            $wrappedObject = $entityMap->$relation($entity)->getResults($relation);
-
-            $initializer = null; // disable initialization
-            return true; // confirm that initialization occurred correctly
-        };
-
-        return $factory->createProxy($class, $initializer);
-    }
+	public function make($entity, $relation, $class)
+	{
+		$entityMap = Manager::getMapper($entity)->getEntityMap();
+
+		$singleRelations = $entityMap->getSingleRelationships();
+		$manyRelations = $entityMap->getManyRelationships();
+
+		if (in_array($relation, $singleRelations)) {
+			return $this->makeEntityProxy($entity, $relation, $class);
+		}
+
+		if (in_array($relation, $manyRelations)) {
+			return new CollectionProxy($entity, $relation);
+		}
+
+		throw new MappingException("Could not identify relation '$relation'");
+	}
+
+	/**
+	 * Create an instance of a proxy object, extending the actual
+	 * related class.
+	 *
+	 * @param mixed  $entity   parent object
+	 * @param string $relation the name of the relationship method
+	 * @param string $class    the class name of the related object
+	 *
+	 * @return mixed
+	 */
+	protected function makeEntityProxy($entity, $relation, $class)
+	{
+		$factory = new LazyLoadingValueHolderFactory();
+
+		$initializer = function (&$wrappedObject, LazyLoadingInterface $proxy, $method, array $parameters, &$initializer) use ($entity, $relation) {
+			$entityMap = Manager::getMapper($entity)->getEntityMap();
+
+			$wrappedObject = $entityMap->$relation($entity)->getResults($relation);
+
+			$initializer = null; // disable initialization
+			return true; // confirm that initialization occurred correctly
+		};
+
+		return $factory->createProxy($class, $initializer);
+	}
 }

src/System/Aggregate.php

Indentation +1155 added lines, -1155 removed lines

@@ -15,1159 +15,1159 @@
  */
 class Aggregate implements InternallyMappable
 {
-    /**
-     * The Root Entity.
-     *
-     * @var \Analogue\ORM\System\Wrappers\Wrapper
-     */
-    protected $wrappedEntity;
-
-    /**
-     * Class of the entity being aggregated.
-     *
-     * @var string
-     */
-    protected $class;
-
-    /**
-     * Parent Root Aggregate.
-     *
-     * @var \Analogue\ORM\System\Aggregate
-     */
-    protected $parent;
-
-    /**
-     * Parent's relationship method.
-     *
-     * @var string
-     */
-    protected $parentRelationship;
-
-    /**
-     * Root Entity.
-     *
-     * @var \Analogue\ORM\System\Aggregate
-     */
-    protected $root;
-
-    /**
-     * An associative array containing entity's
-     * relationships converted to Aggregates.
-     *
-     * @var array
-     */
-    protected $relationships = [];
-
-    /**
-     * Relationship that need post-command synchronization.
-     *
-     * @var array
-     */
-    protected $needSync = [];
-
-    /**
-     * Mapper.
-     *
-     * @var \Analogue\ORM\System\Mapper;
-     */
-    protected $mapper;
-
-    /**
-     * Entity Map.
-     *
-     * @var \Analogue\ORM\EntityMap;
-     */
-    protected $entityMap;
-
-    /**
-     * Create a new Aggregated Entity instance.
-     *
-     * @param mixed          $entity
-     * @param Aggregate|null $parent
-     * @param string         $parentRelationship
-     * @param Aggregate|null $root
-     *
-     * @throws MappingException
-     */
-    public function __construct($entity, Aggregate $parent = null, $parentRelationship = null, Aggregate $root = null)
-    {
-        $factory = new Factory();
-
-        $this->class = get_class($entity);
-
-        $this->wrappedEntity = $factory->make($entity);
-
-        $this->parent = $parent;
-
-        $this->parentRelationship = $parentRelationship;
-
-        $this->root = $root;
-
-        $mapper = $this->getMapper($entity);
-
-        $this->entityMap = $mapper->getEntityMap();
-
-        $this->parseRelationships();
-    }
-
-    /**
-     * Parse Every relationships defined on the entity.
-     *
-     * @throws MappingException
-     *
-     * @return void
-     */
-    protected function parseRelationships()
-    {
-        foreach ($this->entityMap->getSingleRelationships() as $relation) {
-            $this->parseSingleRelationship($relation);
-        }
-
-        foreach ($this->entityMap->getManyRelationships() as $relation) {
-            $this->parseManyRelationship($relation);
-        }
-    }
-
-    /**
-     * Parse for values common to single & many relations.
-     *
-     * @param string $relation
-     *
-     * @throws MappingException
-     *
-     * @return mixed|bool
-     */
-    protected function parseForCommonValues($relation)
-    {
-        if (!$this->hasAttribute($relation)) {
-            // If no attribute exists for this relationships
-            // we'll make it a simple empty array. This will
-            // save us from constantly checking for the attributes
-            // actual existence.
-            $this->relationships[$relation] = [];
-
-            return false;
-        }
-
-        $value = $this->getRelationshipValue($relation);
-
-        if (is_null($value)) {
-            $this->relationships[$relation] = [];
-
-            // If the relationship's content is the null value
-            // and the Entity's exist in DB, we'll interpret this
-            // as the need to detach all related Entities,
-            // therefore a sync operation is needed.
-            $this->needSync[] = $relation;
-
-            return false;
-        }
-
-        return $value;
-    }
-
-    /**
-     * Parse a 'single' relationship.
-     *
-     * @param string $relation
-     *
-     * @throws MappingException
-     *
-     * @return bool
-     */
-    protected function parseSingleRelationship($relation)
-    {
-        if (!$value = $this->parseForCommonValues($relation)) {
-            return true;
-        }
-
-        if ($value instanceof Collection || is_array($value) || $value instanceof CollectionProxy) {
-            throw new MappingException("Entity's attribute $relation should not be array, or collection");
-        }
-
-        if ($value instanceof LazyLoadingInterface && !$value->isProxyInitialized()) {
-            $this->relationships[$relation] = [];
-
-            return true;
-        }
-
-        // If the attribute is a loaded proxy, swap it for its
-        // loaded entity.
-        if ($value instanceof LazyLoadingInterface && $value->isProxyInitialized()) {
-            $value = $value->getWrappedValueHolderValue();
-        }
-
-        if ($this->isParentOrRoot($value)) {
-            $this->relationships[$relation] = [];
-
-            return true;
-        }
-
-        // At this point, we can assume the attribute is an Entity instance
-        // so we'll treat it as such.
-        $subAggregate = $this->createSubAggregate($value, $relation);
-
-        // Even if it's a single entity, we'll store it as an array
-        // just for consistency with other relationships
-        $this->relationships[$relation] = [$subAggregate];
-
-        // We always need to check a loaded relation is in sync
-        // with its local key
-        $this->needSync[] = $relation;
-
-        return true;
-    }
-
-    /**
-     * Check if value isn't parent or root in the aggregate.
-     *
-     * @param  mixed
-     *
-     * @return bool|null
-     */
-    protected function isParentOrRoot($value)
-    {
-        if (!is_null($this->root)) {
-            $rootClass = get_class($this->root->getEntityObject());
-            if ($rootClass == get_class($value)) {
-                return true;
-            }
-        }
-
-        if (!is_null($this->parent)) {
-            $parentClass = get_class($this->parent->getEntityObject());
-            if ($parentClass == get_class($value)) {
-                return true;
-            }
-        }
-    }
-
-    /**
-     * Parse a 'many' relationship.
-     *
-     * @param string $relation
-     *
-     * @throws MappingException
-     *
-     * @return bool
-     */
-    protected function parseManyRelationship($relation)
-    {
-        if (!$value = $this->parseForCommonValues($relation)) {
-            return true;
-        }
-
-        if (is_array($value) || (!$value instanceof CollectionProxy && $value instanceof Collection)) {
-            $this->needSync[] = $relation;
-        }
-
-        // If the relation is a proxy, we test is the relation
-        // has been lazy loaded, otherwise we'll just treat
-        // the subset of newly added items.
-        if ($value instanceof CollectionProxy && $value->isProxyInitialized()) {
-            $this->needSync[] = $relation;
-            //$value = $value->getUnderlyingCollection();
-        }
-
-        if ($value instanceof CollectionProxy && !$value->isProxyInitialized()) {
-            $value = $value->getAddedItems();
-        }
-
-        // At this point $value should be either an array or an instance
-        // of a collection class.
-        if (!is_array($value) && !$value instanceof Collection) {
-            throw new MappingException("'$relation' attribute should be array() or Collection");
-        }
-
-        $this->relationships[$relation] = $this->createSubAggregates($value, $relation);
-
-        return true;
-    }
-
-    /**
-     * Return Entity's relationship attribute.
-     *
-     * @param string $relation
-     *
-     * @throws MappingException
-     *
-     * @return mixed
-     */
-    protected function getRelationshipValue($relation)
-    {
-        $value = $this->getEntityAttribute($relation);
-
-        if (is_bool($value) || is_float($value) || is_int($value) || is_string($value)) {
-            throw new MappingException("Entity's attribute $relation should be array, object, collection or null");
-        }
-
-        return $value;
-    }
-
-    /**
-     * Create a child, aggregated entity.
-     *
-     * @param mixed  $entities
-     * @param string $relation
-     *
-     * @return array
-     */
-    protected function createSubAggregates($entities, $relation)
-    {
-        $aggregates = [];
-
-        foreach ($entities as $entity) {
-            $aggregates[] = $this->createSubAggregate($entity, $relation);
-        }
-
-        return $aggregates;
-    }
-
-    /**
-     * Create a related subAggregate.
-     *
-     * @param mixed  $entity
-     * @param string $relation
-     *
-     * @throws MappingException
-     *
-     * @return self
-     */
-    protected function createSubAggregate($entity, $relation)
-    {
-        // If root isn't defined, then this is the Aggregate Root
-        if (is_null($this->root)) {
-            $root = $this;
-        } else {
-            $root = $this->root;
-        }
-
-        return new self($entity, $this, $relation, $root);
-    }
-
-    /**
-     * Get the Entity's primary key attribute.
-     *
-     * @return string|int
-     */
-    public function getEntityId()
-    {
-        return $this->wrappedEntity->getEntityKey();
-    }
-
-    /**
-     * Get the name of the primary key.
-     *
-     * @return string
-     */
-    public function getEntityKey()
-    {
-        return $this->entityMap->getKeyName();
-    }
-
-    /**
-     * Return the entity map for the current entity.
-     *
-     * @return \Analogue\ORM\EntityMap
-     */
-    public function getEntityMap()
-    {
-        return $this->entityMap;
-    }
-
-    /**
-     * Return the Entity's hash $class.$id.
-     *
-     * @return string
-     */
-    public function getEntityHash()
-    {
-        return $this->getEntityClass().'.'.$this->getEntityId();
-    }
-
-    /**
-     * Get wrapped entity class.
-     *
-     * @return string
-     */
-    public function getEntityClass()
-    {
-        return $this->entityMap->getClass();
-    }
-
-    /**
-     * Return the Mapper's entity cache.
-     *
-     * @return \Analogue\ORM\System\EntityCache
-     */
-    protected function getEntityCache()
-    {
-        return $this->getMapper()->getEntityCache();
-    }
-
-    /**
-     * Get a relationship as an aggregated entities' array.
-     *
-     * @param string $name
-     *
-     * @return array
-     */
-    public function getRelationship($name)
-    {
-        if (array_key_exists($name, $this->relationships)) {
-            return $this->relationships[$name];
-        } else {
-            return [];
-        }
-    }
-
-    /**
-     * [TO IMPLEMENT].
-     *
-     * @return array
-     */
-    public function getPivotAttributes()
-    {
-        return [];
-    }
-
-    /**
-     * Get Non existing related entities from several relationships.
-     *
-     * @param array $relationships
-     *
-     * @return array
-     */
-    public function getNonExistingRelated(array $relationships)
-    {
-        $nonExisting = [];
-
-        foreach ($relationships as $relation) {
-            if ($this->hasAttribute($relation) && array_key_exists($relation, $this->relationships)) {
-                $nonExisting = array_merge($nonExisting, $this->getNonExistingFromRelation($relation));
-            }
-        }
-
-        return $nonExisting;
-    }
-
-    /**
-     * Get non-existing related entities from a single relation.
-     *
-     * @param string $relation
-     *
-     * @return array
-     */
-    protected function getNonExistingFromRelation($relation)
-    {
-        $nonExisting = [];
-
-        foreach ($this->relationships[$relation] as $aggregate) {
-            if (!$aggregate->exists()) {
-                $nonExisting[] = $aggregate;
-            }
-        }
-
-        return $nonExisting;
-    }
-
-    /**
-     * Synchronize relationships if needed.
-     *
-     * @param array
-     *
-     * @return void
-     */
-    public function syncRelationships(array $relationships)
-    {
-        foreach ($relationships as $relation) {
-            if (in_array($relation, $this->needSync)) {
-                $this->synchronize($relation);
-            }
-        }
-    }
-
-    /**
-     * Synchronize a relationship attribute.
-     *
-     * @param $relation
-     *
-     * @return void
-     */
-    protected function synchronize($relation)
-    {
-        $actualContent = $this->relationships[$relation];
-
-        $relationshipObject = $this->entityMap->$relation($this->getEntityObject());
-        $relationshipObject->setParent($this->wrappedEntity);
-        $relationshipObject->sync($actualContent);
-    }
-
-    /**
-     * Returns an array of Missing related Entities for the
-     * given $relation.
-     *
-     * @param string $relation
-     *
-     * @return array
-     */
-    public function getMissingEntities($relation)
-    {
-        $cachedRelations = $this->getCachedAttribute($relation);
-
-        if (!is_null($cachedRelations)) {
-            $missing = [];
-
-            foreach ($cachedRelations as $hash) {
-                if (!$this->getRelatedAggregateFromHash($hash, $relation)) {
-                    $missing[] = $hash;
-                }
-            }
-
-            return $missing;
-        } else {
-            return [];
-        }
-    }
-
-    /**
-     * Get Relationships who have dirty attributes / dirty relationships.
-     *
-     * @return array
-     */
-    public function getDirtyRelationships()
-    {
-        $dirtyAggregates = [];
-
-        foreach ($this->relationships as $relation) {
-            foreach ($relation as $aggregate) {
-                if (!$aggregate->exists() || $aggregate->isDirty() || count($aggregate->getDirtyRelationships()) > 0) {
-                    $dirtyAggregates[] = $aggregate;
-                }
-            }
-        }
-
-        return $dirtyAggregates;
-    }
-
-    /**
-     * Compare the object's raw attributes with the record in cache.
-     *
-     * @return bool
-     */
-    public function isDirty()
-    {
-        if (count($this->getDirtyRawAttributes()) > 0) {
-            return true;
-        } else {
-            return false;
-        }
-    }
-
-    /**
-     * Get Raw Entity's attributes, as they are represented
-     * in the database, including value objects, foreign keys,
-     * and discriminator column.
-     *
-     * @return array
-     */
-    public function getRawAttributes()
-    {
-        $attributes = $this->wrappedEntity->getEntityAttributes();
-
-        foreach ($this->entityMap->getNonEmbeddedRelationships() as $relation) {
-            unset($attributes[$relation]);
-        }
-
-        if ($this->entityMap->getInheritanceType() == 'single_table') {
-            $attributes = $this->addDiscriminatorColumn($attributes);
-        }
-
-        $attributes = $this->flattenEmbeddables($attributes);
-
-        $foreignKeys = $this->getForeignKeyAttributes();
-
-        return $foreignKeys + $attributes;
-    }
-
-    /**
-     * Add Discriminator Column if it doesn't exist on the actual entity.
-     *
-     * @param array $attributes
-     *
-     * @return array
-     */
-    protected function addDiscriminatorColumn($attributes)
-    {
-        $discriminatorColumn = $this->entityMap->getDiscriminatorColumn();
-        $entityClass = $this->entityMap->getClass();
-
-        if (!array_key_exists($discriminatorColumn, $attributes)) {
-
-            // Use key if present in discriminatorMap
-            $map = $this->entityMap->getDiscriminatorColumnMap();
-
-            $type = array_search($entityClass, $map);
-
-            if ($type === false) {
-                // Use entity FQDN if no corresponding key is set
-                $attributes[$discriminatorColumn] = $entityClass;
-            } else {
-                $attributes[$discriminatorColumn] = $type;
-            }
-        }
-
-        return $attributes;
-    }
-
-    /**
-     * Convert Value Objects to raw db attributes.
-     *
-     * @param array $attributes
-     *
-     * @return array
-     */
-    protected function flattenEmbeddables($attributes)
-    {
-        // TODO : deprecate old implementation
-        $embeddables = $this->entityMap->getEmbeddables();
-
-        foreach ($embeddables as $localKey => $embed) {
-            // Retrieve the value object from the entity's attributes
-            $valueObject = $attributes[$localKey];
-
-            // Unset the corresponding key
-            unset($attributes[$localKey]);
-
-            // TODO Make wrapper object compatible with value objects
-            $valueObjectAttributes = $valueObject->getEntityAttributes();
-
-            // Now (if setup in the entity map) we prefix the value object's
-            // attributes with the snake_case name of the embedded class.
-            $prefix = snake_case(class_basename($embed));
-
-            foreach ($valueObjectAttributes as $key=>$value) {
-                $valueObjectAttributes[$prefix.'_'.$key] = $value;
-                unset($valueObjectAttributes[$key]);
-            }
-
-            $attributes = array_merge($attributes, $valueObjectAttributes);
-        }
-
-        //*********************
-        // New implementation
-        // *****************->
-
-        $embeddedRelations = $this->entityMap->getEmbeddedRelationships();
-
-        foreach ($embeddedRelations as $relation) {
-
-            // Spawn a new instance we can pass to the relationship methdod
-            $parentInstance = $this->getMapper()->newInstance();
-            $relationInstance = $this->entityMap->$relation($parentInstance);
-
-            // Extract the object from the attributes
-            $embeddedObject = $attributes[$relation];
-
-            unset($attributes[$relation]);
-
-            $attributes = $relationInstance->normalize($embeddedObject) + $attributes;
-        }
-
-        return $attributes;
-    }
-
-    /**
-     * Return's entity raw attributes in the state they were at last
-     * query.
-     *
-     * @param array|null $columns
-     *
-     * @return array
-     */
-    protected function getCachedRawAttributes(array $columns = null)
-    {
-        $cachedAttributes = $this->getCache()->get($this->getEntityId());
-
-        if (is_null($columns)) {
-            return $cachedAttributes;
-        } else {
-            return array_only($cachedAttributes, $columns);
-        }
-    }
-
-    /**
-     * Return a single attribute from the cache.
-     *
-     * @param string $key
-     *
-     * @return mixed
-     */
-    protected function getCachedAttribute($key)
-    {
-        $cachedAttributes = $this->getCache()->get($this->getEntityId());
-
-        if (!array_key_exists($key, $cachedAttributes)) {
-            return;
-        } else {
-            return $cachedAttributes[$key];
-        }
-    }
-
-    /**
-     * Convert related Entity's attributes to foreign keys.
-     *
-     * @return array
-     */
-    protected function getForeignKeyAttributes()
-    {
-        $foreignKeys = [];
-
-        foreach ($this->entityMap->getLocalRelationships() as $relation) {
-            // check if relationship has been parsed, meaning it has an actual object
-            // in the entity's attributes
-            if ($this->isActualRelationships($relation)) {
-                $foreignKeys = $foreignKeys + $this->getForeignKeyAttributesFromRelation($relation);
-            } else {
-                $foreignKeys = $foreignKeys + $this->getNullForeignKeyFromRelation($relation);
-            }
-        }
-
-        if (!is_null($this->parent)) {
-            $foreignKeys = $this->getForeignKeyAttributesFromParent() + $foreignKeys;
-        }
-
-        return $foreignKeys;
-    }
-
-    /**
-     * Get a null foreign key value pair for an empty relationship.
-     *
-     * @param [type] $relation [description]
-     *
-     * @return [type] [description]
-     */
-    protected function getNullForeignKeyFromRelation($relation) : array
-    {
-        $key = $this->entityMap->getLocalKeys($relation);
-
-        // If the relation is polymorphic, we'll set both key and type
-        // to null
-        if (is_array($key)) {
-            return [
-                $key['type'] => null,
-                $key['id']   => null,
-            ];
-        }
-
-        return [$key => null];
-    }
-
-    /**
-     * Return an associative array containing the key-value pair(s) from
-     * the related entity.
-     *
-     * @param string $relation
-     *
-     * @return array
-     */
-    protected function getForeignKeyAttributesFromRelation($relation)
-    {
-        // Call Relationship's method
-        $relationship = $this->entityMap->$relation($this->getEntityObject());
-
-        $relatedAggregate = $this->relationships[$relation][0];
-
-        return $relationship->getForeignKeyValuePair($relatedAggregate->getEntityObject());
-    }
-
-    /**
-     * Get foreign key attribute(s) from a parent entity in this
-     * aggregate context.
-     *
-     * @return array
-     */
-    protected function getForeignKeyAttributesFromParent()
-    {
-        $parentMap = $this->parent->getEntityMap();
-
-        $parentForeignRelations = $parentMap->getForeignRelationships();
-        $parentPivotRelations = $parentMap->getPivotRelationships();
-
-        // The parentRelation is the name of the relationship
-        // methods on the parent entity map
-        $parentRelation = $this->parentRelationship;
-
-        if (in_array($parentRelation, $parentForeignRelations)
-            && !in_array($parentRelation, $parentPivotRelations)
-        ) {
-            $parentObject = $this->parent->getEntityObject();
-
-            // Call Relationship's method on parent map
-            $relationship = $parentMap->$parentRelation($parentObject);
-
-            return $relationship->getForeignKeyValuePair($parentObject);
-        } else {
-            return [];
-        }
-    }
-
-    /**
-     * Update Pivot records on loaded relationships, by comparing the
-     * values from the Entity Cache to the actual relationship inside
-     * the aggregated entity.
-     *
-     * @return void
-     */
-    public function updatePivotRecords()
-    {
-        $pivots = $this->entityMap->getPivotRelationships();
-
-        foreach ($pivots as $pivot) {
-            if (array_key_exists($pivot, $this->relationships)) {
-                $this->updatePivotRelation($pivot);
-            }
-        }
-    }
-
-    /**
-     * Update Single pivot relationship.
-     *
-     * @param string $relation
-     *
-     * @return void
-     */
-    protected function updatePivotRelation($relation)
-    {
-        $hashes = $this->getEntityHashesFromRelation($relation);
-
-        $cachedAttributes = $this->getCachedRawAttributes();
-
-        if (array_key_exists($relation, $cachedAttributes)) {
-            // Compare the two array of hashes to find out existing
-            // pivot records, and the ones to be created.
-            $new = array_diff($hashes, array_keys($cachedAttributes[$relation]));
-            $existing = array_intersect($hashes, array_keys($cachedAttributes[$relation]));
-        } else {
-            $existing = [];
-            $new = $hashes;
-        }
-
-        if (count($new) > 0) {
-            $pivots = $this->getRelatedAggregatesFromHashes($new, $relation);
-
-            $this->entityMap->$relation($this->getEntityObject())->createPivots($pivots);
-        }
-
-        if (count($existing) > 0) {
-            foreach ($existing as $pivotHash) {
-                $this->updatePivotIfDirty($pivotHash, $relation);
-            }
-        }
-    }
-
-    /**
-     * Compare existing pivot record in cache and update it
-     * if the pivot attributes are dirty.
-     *
-     * @param string $pivotHash
-     * @param string $relation
-     *
-     * @return void
-     */
-    protected function updatePivotIfDirty($pivotHash, $relation)
-    {
-        $aggregate = $this->getRelatedAggregateFromHash($pivotHash, $relation);
-
-        if ($aggregate->hasAttribute('pivot')) {
-            $pivot = $aggregate->getEntityAttribute('pivot')->getEntityAttributes();
-
-            $cachedPivotAttributes = $this->getPivotAttributesFromCache($pivotHash, $relation);
-
-            $actualPivotAttributes = array_only($pivot, array_keys($cachedPivotAttributes));
-
-            $dirty = $this->getDirtyAttributes($actualPivotAttributes, $cachedPivotAttributes);
-
-            if (count($dirty) > 0) {
-                $id = $aggregate->getEntityId();
-
-                $this->entityMap->$relation($this->getEntityObject())->updateExistingPivot($id, $dirty);
-            }
-        }
-    }
-
-    /**
-     * Compare two attributes array and return dirty attributes.
-     *
-     * @param array $actual
-     * @param array $cached
-     *
-     * @return array
-     */
-    protected function getDirtyAttributes(array $actual, array $cached)
-    {
-        $dirty = [];
-
-        foreach ($actual as $key => $value) {
-            if (!$this->originalIsNumericallyEquivalent($value, $cached[$key])) {
-                $dirty[$key] = $actual[$key];
-            }
-        }
-
-        return $dirty;
-    }
-
-    /**
-     * @param string $pivotHash
-     * @param string $relation
-     *
-     * @return array
-     */
-    protected function getPivotAttributesFromCache($pivotHash, $relation)
-    {
-        $cachedAttributes = $this->getCachedRawAttributes();
-
-        $cachedRelations = $cachedAttributes[$relation];
-
-        foreach ($cachedRelations as $cachedRelation) {
-            if ($cachedRelation == $pivotHash) {
-                return $cachedRelation->getPivotAttributes();
-            }
-        }
-    }
-
-    /**
-     * Returns an array of related Aggregates from its entity hashes.
-     *
-     * @param array  $hashes
-     * @param string $relation
-     *
-     * @return array
-     */
-    protected function getRelatedAggregatesFromHashes(array $hashes, $relation)
-    {
-        $related = [];
-
-        foreach ($hashes as $hash) {
-            $aggregate = $this->getRelatedAggregateFromHash($hash, $relation);
-
-            if (!is_null($aggregate)) {
-                $related[] = $aggregate;
-            }
-        }
-
-        return $related;
-    }
-
-    /**
-     * Get related aggregate from its hash.
-     *
-     * @param string $hash
-     * @param string $relation
-     *
-     * @return \Analogue\ORM\System\Aggregate|null
-     */
-    protected function getRelatedAggregateFromHash($hash, $relation)
-    {
-        foreach ($this->relationships[$relation] as $aggregate) {
-            if ($aggregate->getEntityHash() == $hash) {
-                return $aggregate;
-            }
-        }
-    }
-
-    /**
-     * Return an array of Entity Hashes from a specific relation.
-     *
-     * @param string $relation
-     *
-     * @return array
-     */
-    protected function getEntityHashesFromRelation($relation)
-    {
-        return array_map(function ($aggregate) {
-            return $aggregate->getEntityHash();
-        }, $this->relationships[$relation]);
-    }
-
-    /**
-     * Check the existence of an actual relationship.
-     *
-     * @param string $relation
-     *
-     * @return bool
-     */
-    protected function isActualRelationships($relation)
-    {
-        return array_key_exists($relation, $this->relationships)
-            && count($this->relationships[$relation]) > 0;
-    }
-
-    /**
-     * Return cache instance for the current entity type.
-     *
-     * @return \Analogue\ORM\System\EntityCache
-     */
-    protected function getCache()
-    {
-        return $this->getMapper()->getEntityCache();
-    }
-
-    /**
-     * Get Only Raw Entiy's attributes which have been modified
-     * since last query.
-     *
-     * @return array
-     */
-    public function getDirtyRawAttributes()
-    {
-        $attributes = $this->getRawAttributes();
-        $cachedAttributes = $this->getCachedRawAttributes(array_keys($attributes));
-
-        $dirty = [];
-
-        foreach ($attributes as $key => $value) {
-            if ($this->isRelation($key) || $key == 'pivot') {
-                continue;
-            }
-
-            if (!array_key_exists($key, $cachedAttributes) && !$value instanceof Pivot) {
-                $dirty[$key] = $value;
-            } elseif ($value !== $cachedAttributes[$key] &&
-                !$this->originalIsNumericallyEquivalent($value, $cachedAttributes[$key])) {
-                $dirty[$key] = $value;
-            }
-        }
-
-        return $dirty;
-    }
-
-    /**
-     * @param $key
-     *
-     * @return bool
-     */
-    protected function isRelation($key)
-    {
-        return in_array($key, $this->entityMap->getRelationships());
-    }
-
-    /**
-     * Determine if the new and old values for a given key are numerically equivalent.
-     *
-     * @param $current
-     * @param $original
-     *
-     * @return bool
-     */
-    protected function originalIsNumericallyEquivalent($current, $original)
-    {
-        return is_numeric($current) && is_numeric($original) && strcmp((string) $current, (string) $original) === 0;
-    }
-
-    /**
-     * Get the underlying entity object.
-     *
-     * @return mixed
-     */
-    public function getEntityObject()
-    {
-        return $this->wrappedEntity->getObject();
-    }
-
-    /**
-     * Return the Mapper instance for the current Entity Type.
-     *
-     * @return \Analogue\ORM\System\Mapper
-     */
-    public function getMapper()
-    {
-        return Manager::getMapper($this->class);
-    }
-
-    /**
-     * Check that the entity already exists in the database, by checking
-     * if it has an EntityCache record.
-     *
-     * @return bool
-     */
-    public function exists()
-    {
-        return $this->getCache()->has($this->getEntityId());
-    }
-
-    /**
-     * Set the object attribute raw values (hydration).
-     *
-     * @param array $attributes
-     */
-    public function setEntityAttributes(array $attributes)
-    {
-        $this->wrappedEntity->setEntityAttributes($attributes);
-    }
-
-    /**
-     * Get the raw object's values.
-     *
-     * @return array
-     */
-    public function getEntityAttributes()
-    {
-        return $this->wrappedEntity->getEntityAttributes();
-    }
-
-    /**
-     * Set the raw entity attributes.
-     *
-     * @param string $key
-     * @param string $value
-     */
-    public function setEntityAttribute($key, $value)
-    {
-        $this->wrappedEntity->setEntityAttribute($key, $value);
-    }
-
-    /**
-     * Return the entity's attribute.
-     *
-     * @param string $key
-     *
-     * @return mixed
-     */
-    public function getEntityAttribute($key)
-    {
-        return $this->wrappedEntity->getEntityAttribute($key);
-    }
-
-    /**
-     * Does the attribute exists on the entity.
-     *
-     * @param string $key
-     *
-     * @return bool
-     */
-    public function hasAttribute($key)
-    {
-        return $this->wrappedEntity->hasAttribute($key);
-    }
-
-    /**
-     * Set the lazyloading proxies on the wrapped entity.
-     *
-     * @return void
-     */
-    public function setProxies()
-    {
-        $this->wrappedEntity->setProxies();
-    }
-
-    /**
-     * Hydrate the actual entity.
-     *
-     * @return void
-     */
-    public function hydrate()
-    {
-        $this->wrappedEntity->hydrate();
-    }
+	/**
+	 * The Root Entity.
+	 *
+	 * @var \Analogue\ORM\System\Wrappers\Wrapper
+	 */
+	protected $wrappedEntity;
+
+	/**
+	 * Class of the entity being aggregated.
+	 *
+	 * @var string
+	 */
+	protected $class;
+
+	/**
+	 * Parent Root Aggregate.
+	 *
+	 * @var \Analogue\ORM\System\Aggregate
+	 */
+	protected $parent;
+
+	/**
+	 * Parent's relationship method.
+	 *
+	 * @var string
+	 */
+	protected $parentRelationship;
+
+	/**
+	 * Root Entity.
+	 *
+	 * @var \Analogue\ORM\System\Aggregate
+	 */
+	protected $root;
+
+	/**
+	 * An associative array containing entity's
+	 * relationships converted to Aggregates.
+	 *
+	 * @var array
+	 */
+	protected $relationships = [];
+
+	/**
+	 * Relationship that need post-command synchronization.
+	 *
+	 * @var array
+	 */
+	protected $needSync = [];
+
+	/**
+	 * Mapper.
+	 *
+	 * @var \Analogue\ORM\System\Mapper;
+	 */
+	protected $mapper;
+
+	/**
+	 * Entity Map.
+	 *
+	 * @var \Analogue\ORM\EntityMap;
+	 */
+	protected $entityMap;
+
+	/**
+	 * Create a new Aggregated Entity instance.
+	 *
+	 * @param mixed          $entity
+	 * @param Aggregate|null $parent
+	 * @param string         $parentRelationship
+	 * @param Aggregate|null $root
+	 *
+	 * @throws MappingException
+	 */
+	public function __construct($entity, Aggregate $parent = null, $parentRelationship = null, Aggregate $root = null)
+	{
+		$factory = new Factory();
+
+		$this->class = get_class($entity);
+
+		$this->wrappedEntity = $factory->make($entity);
+
+		$this->parent = $parent;
+
+		$this->parentRelationship = $parentRelationship;
+
+		$this->root = $root;
+
+		$mapper = $this->getMapper($entity);
+
+		$this->entityMap = $mapper->getEntityMap();
+
+		$this->parseRelationships();
+	}
+
+	/**
+	 * Parse Every relationships defined on the entity.
+	 *
+	 * @throws MappingException
+	 *
+	 * @return void
+	 */
+	protected function parseRelationships()
+	{
+		foreach ($this->entityMap->getSingleRelationships() as $relation) {
+			$this->parseSingleRelationship($relation);
+		}
+
+		foreach ($this->entityMap->getManyRelationships() as $relation) {
+			$this->parseManyRelationship($relation);
+		}
+	}
+
+	/**
+	 * Parse for values common to single & many relations.
+	 *
+	 * @param string $relation
+	 *
+	 * @throws MappingException
+	 *
+	 * @return mixed|bool
+	 */
+	protected function parseForCommonValues($relation)
+	{
+		if (!$this->hasAttribute($relation)) {
+			// If no attribute exists for this relationships
+			// we'll make it a simple empty array. This will
+			// save us from constantly checking for the attributes
+			// actual existence.
+			$this->relationships[$relation] = [];
+
+			return false;
+		}
+
+		$value = $this->getRelationshipValue($relation);
+
+		if (is_null($value)) {
+			$this->relationships[$relation] = [];
+
+			// If the relationship's content is the null value
+			// and the Entity's exist in DB, we'll interpret this
+			// as the need to detach all related Entities,
+			// therefore a sync operation is needed.
+			$this->needSync[] = $relation;
+
+			return false;
+		}
+
+		return $value;
+	}
+
+	/**
+	 * Parse a 'single' relationship.
+	 *
+	 * @param string $relation
+	 *
+	 * @throws MappingException
+	 *
+	 * @return bool
+	 */
+	protected function parseSingleRelationship($relation)
+	{
+		if (!$value = $this->parseForCommonValues($relation)) {
+			return true;
+		}
+
+		if ($value instanceof Collection || is_array($value) || $value instanceof CollectionProxy) {
+			throw new MappingException("Entity's attribute $relation should not be array, or collection");
+		}
+
+		if ($value instanceof LazyLoadingInterface && !$value->isProxyInitialized()) {
+			$this->relationships[$relation] = [];
+
+			return true;
+		}
+
+		// If the attribute is a loaded proxy, swap it for its
+		// loaded entity.
+		if ($value instanceof LazyLoadingInterface && $value->isProxyInitialized()) {
+			$value = $value->getWrappedValueHolderValue();
+		}
+
+		if ($this->isParentOrRoot($value)) {
+			$this->relationships[$relation] = [];
+
+			return true;
+		}
+
+		// At this point, we can assume the attribute is an Entity instance
+		// so we'll treat it as such.
+		$subAggregate = $this->createSubAggregate($value, $relation);
+
+		// Even if it's a single entity, we'll store it as an array
+		// just for consistency with other relationships
+		$this->relationships[$relation] = [$subAggregate];
+
+		// We always need to check a loaded relation is in sync
+		// with its local key
+		$this->needSync[] = $relation;
+
+		return true;
+	}
+
+	/**
+	 * Check if value isn't parent or root in the aggregate.
+	 *
+	 * @param  mixed
+	 *
+	 * @return bool|null
+	 */
+	protected function isParentOrRoot($value)
+	{
+		if (!is_null($this->root)) {
+			$rootClass = get_class($this->root->getEntityObject());
+			if ($rootClass == get_class($value)) {
+				return true;
+			}
+		}
+
+		if (!is_null($this->parent)) {
+			$parentClass = get_class($this->parent->getEntityObject());
+			if ($parentClass == get_class($value)) {
+				return true;
+			}
+		}
+	}
+
+	/**
+	 * Parse a 'many' relationship.
+	 *
+	 * @param string $relation
+	 *
+	 * @throws MappingException
+	 *
+	 * @return bool
+	 */
+	protected function parseManyRelationship($relation)
+	{
+		if (!$value = $this->parseForCommonValues($relation)) {
+			return true;
+		}
+
+		if (is_array($value) || (!$value instanceof CollectionProxy && $value instanceof Collection)) {
+			$this->needSync[] = $relation;
+		}
+
+		// If the relation is a proxy, we test is the relation
+		// has been lazy loaded, otherwise we'll just treat
+		// the subset of newly added items.
+		if ($value instanceof CollectionProxy && $value->isProxyInitialized()) {
+			$this->needSync[] = $relation;
+			//$value = $value->getUnderlyingCollection();
+		}
+
+		if ($value instanceof CollectionProxy && !$value->isProxyInitialized()) {
+			$value = $value->getAddedItems();
+		}
+
+		// At this point $value should be either an array or an instance
+		// of a collection class.
+		if (!is_array($value) && !$value instanceof Collection) {
+			throw new MappingException("'$relation' attribute should be array() or Collection");
+		}
+
+		$this->relationships[$relation] = $this->createSubAggregates($value, $relation);
+
+		return true;
+	}
+
+	/**
+	 * Return Entity's relationship attribute.
+	 *
+	 * @param string $relation
+	 *
+	 * @throws MappingException
+	 *
+	 * @return mixed
+	 */
+	protected function getRelationshipValue($relation)
+	{
+		$value = $this->getEntityAttribute($relation);
+
+		if (is_bool($value) || is_float($value) || is_int($value) || is_string($value)) {
+			throw new MappingException("Entity's attribute $relation should be array, object, collection or null");
+		}
+
+		return $value;
+	}
+
+	/**
+	 * Create a child, aggregated entity.
+	 *
+	 * @param mixed  $entities
+	 * @param string $relation
+	 *
+	 * @return array
+	 */
+	protected function createSubAggregates($entities, $relation)
+	{
+		$aggregates = [];
+
+		foreach ($entities as $entity) {
+			$aggregates[] = $this->createSubAggregate($entity, $relation);
+		}
+
+		return $aggregates;
+	}
+
+	/**
+	 * Create a related subAggregate.
+	 *
+	 * @param mixed  $entity
+	 * @param string $relation
+	 *
+	 * @throws MappingException
+	 *
+	 * @return self
+	 */
+	protected function createSubAggregate($entity, $relation)
+	{
+		// If root isn't defined, then this is the Aggregate Root
+		if (is_null($this->root)) {
+			$root = $this;
+		} else {
+			$root = $this->root;
+		}
+
+		return new self($entity, $this, $relation, $root);
+	}
+
+	/**
+	 * Get the Entity's primary key attribute.
+	 *
+	 * @return string|int
+	 */
+	public function getEntityId()
+	{
+		return $this->wrappedEntity->getEntityKey();
+	}
+
+	/**
+	 * Get the name of the primary key.
+	 *
+	 * @return string
+	 */
+	public function getEntityKey()
+	{
+		return $this->entityMap->getKeyName();
+	}
+
+	/**
+	 * Return the entity map for the current entity.
+	 *
+	 * @return \Analogue\ORM\EntityMap
+	 */
+	public function getEntityMap()
+	{
+		return $this->entityMap;
+	}
+
+	/**
+	 * Return the Entity's hash $class.$id.
+	 *
+	 * @return string
+	 */
+	public function getEntityHash()
+	{
+		return $this->getEntityClass().'.'.$this->getEntityId();
+	}
+
+	/**
+	 * Get wrapped entity class.
+	 *
+	 * @return string
+	 */
+	public function getEntityClass()
+	{
+		return $this->entityMap->getClass();
+	}
+
+	/**
+	 * Return the Mapper's entity cache.
+	 *
+	 * @return \Analogue\ORM\System\EntityCache
+	 */
+	protected function getEntityCache()
+	{
+		return $this->getMapper()->getEntityCache();
+	}
+
+	/**
+	 * Get a relationship as an aggregated entities' array.
+	 *
+	 * @param string $name
+	 *
+	 * @return array
+	 */
+	public function getRelationship($name)
+	{
+		if (array_key_exists($name, $this->relationships)) {
+			return $this->relationships[$name];
+		} else {
+			return [];
+		}
+	}
+
+	/**
+	 * [TO IMPLEMENT].
+	 *
+	 * @return array
+	 */
+	public function getPivotAttributes()
+	{
+		return [];
+	}
+
+	/**
+	 * Get Non existing related entities from several relationships.
+	 *
+	 * @param array $relationships
+	 *
+	 * @return array
+	 */
+	public function getNonExistingRelated(array $relationships)
+	{
+		$nonExisting = [];
+
+		foreach ($relationships as $relation) {
+			if ($this->hasAttribute($relation) && array_key_exists($relation, $this->relationships)) {
+				$nonExisting = array_merge($nonExisting, $this->getNonExistingFromRelation($relation));
+			}
+		}
+
+		return $nonExisting;
+	}
+
+	/**
+	 * Get non-existing related entities from a single relation.
+	 *
+	 * @param string $relation
+	 *
+	 * @return array
+	 */
+	protected function getNonExistingFromRelation($relation)
+	{
+		$nonExisting = [];
+
+		foreach ($this->relationships[$relation] as $aggregate) {
+			if (!$aggregate->exists()) {
+				$nonExisting[] = $aggregate;
+			}
+		}
+
+		return $nonExisting;
+	}
+
+	/**
+	 * Synchronize relationships if needed.
+	 *
+	 * @param array
+	 *
+	 * @return void
+	 */
+	public function syncRelationships(array $relationships)
+	{
+		foreach ($relationships as $relation) {
+			if (in_array($relation, $this->needSync)) {
+				$this->synchronize($relation);
+			}
+		}
+	}
+
+	/**
+	 * Synchronize a relationship attribute.
+	 *
+	 * @param $relation
+	 *
+	 * @return void
+	 */
+	protected function synchronize($relation)
+	{
+		$actualContent = $this->relationships[$relation];
+
+		$relationshipObject = $this->entityMap->$relation($this->getEntityObject());
+		$relationshipObject->setParent($this->wrappedEntity);
+		$relationshipObject->sync($actualContent);
+	}
+
+	/**
+	 * Returns an array of Missing related Entities for the
+	 * given $relation.
+	 *
+	 * @param string $relation
+	 *
+	 * @return array
+	 */
+	public function getMissingEntities($relation)
+	{
+		$cachedRelations = $this->getCachedAttribute($relation);
+
+		if (!is_null($cachedRelations)) {
+			$missing = [];
+
+			foreach ($cachedRelations as $hash) {
+				if (!$this->getRelatedAggregateFromHash($hash, $relation)) {
+					$missing[] = $hash;
+				}
+			}
+
+			return $missing;
+		} else {
+			return [];
+		}
+	}
+
+	/**
+	 * Get Relationships who have dirty attributes / dirty relationships.
+	 *
+	 * @return array
+	 */
+	public function getDirtyRelationships()
+	{
+		$dirtyAggregates = [];
+
+		foreach ($this->relationships as $relation) {
+			foreach ($relation as $aggregate) {
+				if (!$aggregate->exists() || $aggregate->isDirty() || count($aggregate->getDirtyRelationships()) > 0) {
+					$dirtyAggregates[] = $aggregate;
+				}
+			}
+		}
+
+		return $dirtyAggregates;
+	}
+
+	/**
+	 * Compare the object's raw attributes with the record in cache.
+	 *
+	 * @return bool
+	 */
+	public function isDirty()
+	{
+		if (count($this->getDirtyRawAttributes()) > 0) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	/**
+	 * Get Raw Entity's attributes, as they are represented
+	 * in the database, including value objects, foreign keys,
+	 * and discriminator column.
+	 *
+	 * @return array
+	 */
+	public function getRawAttributes()
+	{
+		$attributes = $this->wrappedEntity->getEntityAttributes();
+
+		foreach ($this->entityMap->getNonEmbeddedRelationships() as $relation) {
+			unset($attributes[$relation]);
+		}
+
+		if ($this->entityMap->getInheritanceType() == 'single_table') {
+			$attributes = $this->addDiscriminatorColumn($attributes);
+		}
+
+		$attributes = $this->flattenEmbeddables($attributes);
+
+		$foreignKeys = $this->getForeignKeyAttributes();
+
+		return $foreignKeys + $attributes;
+	}
+
+	/**
+	 * Add Discriminator Column if it doesn't exist on the actual entity.
+	 *
+	 * @param array $attributes
+	 *
+	 * @return array
+	 */
+	protected function addDiscriminatorColumn($attributes)
+	{
+		$discriminatorColumn = $this->entityMap->getDiscriminatorColumn();
+		$entityClass = $this->entityMap->getClass();
+
+		if (!array_key_exists($discriminatorColumn, $attributes)) {
+
+			// Use key if present in discriminatorMap
+			$map = $this->entityMap->getDiscriminatorColumnMap();
+
+			$type = array_search($entityClass, $map);
+
+			if ($type === false) {
+				// Use entity FQDN if no corresponding key is set
+				$attributes[$discriminatorColumn] = $entityClass;
+			} else {
+				$attributes[$discriminatorColumn] = $type;
+			}
+		}
+
+		return $attributes;
+	}
+
+	/**
+	 * Convert Value Objects to raw db attributes.
+	 *
+	 * @param array $attributes
+	 *
+	 * @return array
+	 */
+	protected function flattenEmbeddables($attributes)
+	{
+		// TODO : deprecate old implementation
+		$embeddables = $this->entityMap->getEmbeddables();
+
+		foreach ($embeddables as $localKey => $embed) {
+			// Retrieve the value object from the entity's attributes
+			$valueObject = $attributes[$localKey];
+
+			// Unset the corresponding key
+			unset($attributes[$localKey]);
+
+			// TODO Make wrapper object compatible with value objects
+			$valueObjectAttributes = $valueObject->getEntityAttributes();
+
+			// Now (if setup in the entity map) we prefix the value object's
+			// attributes with the snake_case name of the embedded class.
+			$prefix = snake_case(class_basename($embed));
+
+			foreach ($valueObjectAttributes as $key=>$value) {
+				$valueObjectAttributes[$prefix.'_'.$key] = $value;
+				unset($valueObjectAttributes[$key]);
+			}
+
+			$attributes = array_merge($attributes, $valueObjectAttributes);
+		}
+
+		//*********************
+		// New implementation
+		// *****************->
+
+		$embeddedRelations = $this->entityMap->getEmbeddedRelationships();
+
+		foreach ($embeddedRelations as $relation) {
+
+			// Spawn a new instance we can pass to the relationship methdod
+			$parentInstance = $this->getMapper()->newInstance();
+			$relationInstance = $this->entityMap->$relation($parentInstance);
+
+			// Extract the object from the attributes
+			$embeddedObject = $attributes[$relation];
+
+			unset($attributes[$relation]);
+
+			$attributes = $relationInstance->normalize($embeddedObject) + $attributes;
+		}
+
+		return $attributes;
+	}
+
+	/**
+	 * Return's entity raw attributes in the state they were at last
+	 * query.
+	 *
+	 * @param array|null $columns
+	 *
+	 * @return array
+	 */
+	protected function getCachedRawAttributes(array $columns = null)
+	{
+		$cachedAttributes = $this->getCache()->get($this->getEntityId());
+
+		if (is_null($columns)) {
+			return $cachedAttributes;
+		} else {
+			return array_only($cachedAttributes, $columns);
+		}
+	}
+
+	/**
+	 * Return a single attribute from the cache.
+	 *
+	 * @param string $key
+	 *
+	 * @return mixed
+	 */
+	protected function getCachedAttribute($key)
+	{
+		$cachedAttributes = $this->getCache()->get($this->getEntityId());
+
+		if (!array_key_exists($key, $cachedAttributes)) {
+			return;
+		} else {
+			return $cachedAttributes[$key];
+		}
+	}
+
+	/**
+	 * Convert related Entity's attributes to foreign keys.
+	 *
+	 * @return array
+	 */
+	protected function getForeignKeyAttributes()
+	{
+		$foreignKeys = [];
+
+		foreach ($this->entityMap->getLocalRelationships() as $relation) {
+			// check if relationship has been parsed, meaning it has an actual object
+			// in the entity's attributes
+			if ($this->isActualRelationships($relation)) {
+				$foreignKeys = $foreignKeys + $this->getForeignKeyAttributesFromRelation($relation);
+			} else {
+				$foreignKeys = $foreignKeys + $this->getNullForeignKeyFromRelation($relation);
+			}
+		}
+
+		if (!is_null($this->parent)) {
+			$foreignKeys = $this->getForeignKeyAttributesFromParent() + $foreignKeys;
+		}
+
+		return $foreignKeys;
+	}
+
+	/**
+	 * Get a null foreign key value pair for an empty relationship.
+	 *
+	 * @param [type] $relation [description]
+	 *
+	 * @return [type] [description]
+	 */
+	protected function getNullForeignKeyFromRelation($relation) : array
+	{
+		$key = $this->entityMap->getLocalKeys($relation);
+
+		// If the relation is polymorphic, we'll set both key and type
+		// to null
+		if (is_array($key)) {
+			return [
+				$key['type'] => null,
+				$key['id']   => null,
+			];
+		}
+
+		return [$key => null];
+	}
+
+	/**
+	 * Return an associative array containing the key-value pair(s) from
+	 * the related entity.
+	 *
+	 * @param string $relation
+	 *
+	 * @return array
+	 */
+	protected function getForeignKeyAttributesFromRelation($relation)
+	{
+		// Call Relationship's method
+		$relationship = $this->entityMap->$relation($this->getEntityObject());
+
+		$relatedAggregate = $this->relationships[$relation][0];
+
+		return $relationship->getForeignKeyValuePair($relatedAggregate->getEntityObject());
+	}
+
+	/**
+	 * Get foreign key attribute(s) from a parent entity in this
+	 * aggregate context.
+	 *
+	 * @return array
+	 */
+	protected function getForeignKeyAttributesFromParent()
+	{
+		$parentMap = $this->parent->getEntityMap();
+
+		$parentForeignRelations = $parentMap->getForeignRelationships();
+		$parentPivotRelations = $parentMap->getPivotRelationships();
+
+		// The parentRelation is the name of the relationship
+		// methods on the parent entity map
+		$parentRelation = $this->parentRelationship;
+
+		if (in_array($parentRelation, $parentForeignRelations)
+			&& !in_array($parentRelation, $parentPivotRelations)
+		) {
+			$parentObject = $this->parent->getEntityObject();
+
+			// Call Relationship's method on parent map
+			$relationship = $parentMap->$parentRelation($parentObject);
+
+			return $relationship->getForeignKeyValuePair($parentObject);
+		} else {
+			return [];
+		}
+	}
+
+	/**
+	 * Update Pivot records on loaded relationships, by comparing the
+	 * values from the Entity Cache to the actual relationship inside
+	 * the aggregated entity.
+	 *
+	 * @return void
+	 */
+	public function updatePivotRecords()
+	{
+		$pivots = $this->entityMap->getPivotRelationships();
+
+		foreach ($pivots as $pivot) {
+			if (array_key_exists($pivot, $this->relationships)) {
+				$this->updatePivotRelation($pivot);
+			}
+		}
+	}
+
+	/**
+	 * Update Single pivot relationship.
+	 *
+	 * @param string $relation
+	 *
+	 * @return void
+	 */
+	protected function updatePivotRelation($relation)
+	{
+		$hashes = $this->getEntityHashesFromRelation($relation);
+
+		$cachedAttributes = $this->getCachedRawAttributes();
+
+		if (array_key_exists($relation, $cachedAttributes)) {
+			// Compare the two array of hashes to find out existing
+			// pivot records, and the ones to be created.
+			$new = array_diff($hashes, array_keys($cachedAttributes[$relation]));
+			$existing = array_intersect($hashes, array_keys($cachedAttributes[$relation]));
+		} else {
+			$existing = [];
+			$new = $hashes;
+		}
+
+		if (count($new) > 0) {
+			$pivots = $this->getRelatedAggregatesFromHashes($new, $relation);
+
+			$this->entityMap->$relation($this->getEntityObject())->createPivots($pivots);
+		}
+
+		if (count($existing) > 0) {
+			foreach ($existing as $pivotHash) {
+				$this->updatePivotIfDirty($pivotHash, $relation);
+			}
+		}
+	}
+
+	/**
+	 * Compare existing pivot record in cache and update it
+	 * if the pivot attributes are dirty.
+	 *
+	 * @param string $pivotHash
+	 * @param string $relation
+	 *
+	 * @return void
+	 */
+	protected function updatePivotIfDirty($pivotHash, $relation)
+	{
+		$aggregate = $this->getRelatedAggregateFromHash($pivotHash, $relation);
+
+		if ($aggregate->hasAttribute('pivot')) {
+			$pivot = $aggregate->getEntityAttribute('pivot')->getEntityAttributes();
+
+			$cachedPivotAttributes = $this->getPivotAttributesFromCache($pivotHash, $relation);
+
+			$actualPivotAttributes = array_only($pivot, array_keys($cachedPivotAttributes));
+
+			$dirty = $this->getDirtyAttributes($actualPivotAttributes, $cachedPivotAttributes);
+
+			if (count($dirty) > 0) {
+				$id = $aggregate->getEntityId();
+
+				$this->entityMap->$relation($this->getEntityObject())->updateExistingPivot($id, $dirty);
+			}
+		}
+	}
+
+	/**
+	 * Compare two attributes array and return dirty attributes.
+	 *
+	 * @param array $actual
+	 * @param array $cached
+	 *
+	 * @return array
+	 */
+	protected function getDirtyAttributes(array $actual, array $cached)
+	{
+		$dirty = [];
+
+		foreach ($actual as $key => $value) {
+			if (!$this->originalIsNumericallyEquivalent($value, $cached[$key])) {
+				$dirty[$key] = $actual[$key];
+			}
+		}
+
+		return $dirty;
+	}
+
+	/**
+	 * @param string $pivotHash
+	 * @param string $relation
+	 *
+	 * @return array
+	 */
+	protected function getPivotAttributesFromCache($pivotHash, $relation)
+	{
+		$cachedAttributes = $this->getCachedRawAttributes();
+
+		$cachedRelations = $cachedAttributes[$relation];
+
+		foreach ($cachedRelations as $cachedRelation) {
+			if ($cachedRelation == $pivotHash) {
+				return $cachedRelation->getPivotAttributes();
+			}
+		}
+	}
+
+	/**
+	 * Returns an array of related Aggregates from its entity hashes.
+	 *
+	 * @param array  $hashes
+	 * @param string $relation
+	 *
+	 * @return array
+	 */
+	protected function getRelatedAggregatesFromHashes(array $hashes, $relation)
+	{
+		$related = [];
+
+		foreach ($hashes as $hash) {
+			$aggregate = $this->getRelatedAggregateFromHash($hash, $relation);
+
+			if (!is_null($aggregate)) {
+				$related[] = $aggregate;
+			}
+		}
+
+		return $related;
+	}
+
+	/**
+	 * Get related aggregate from its hash.
+	 *
+	 * @param string $hash
+	 * @param string $relation
+	 *
+	 * @return \Analogue\ORM\System\Aggregate|null
+	 */
+	protected function getRelatedAggregateFromHash($hash, $relation)
+	{
+		foreach ($this->relationships[$relation] as $aggregate) {
+			if ($aggregate->getEntityHash() == $hash) {
+				return $aggregate;
+			}
+		}
+	}
+
+	/**
+	 * Return an array of Entity Hashes from a specific relation.
+	 *
+	 * @param string $relation
+	 *
+	 * @return array
+	 */
+	protected function getEntityHashesFromRelation($relation)
+	{
+		return array_map(function ($aggregate) {
+			return $aggregate->getEntityHash();
+		}, $this->relationships[$relation]);
+	}
+
+	/**
+	 * Check the existence of an actual relationship.
+	 *
+	 * @param string $relation
+	 *
+	 * @return bool
+	 */
+	protected function isActualRelationships($relation)
+	{
+		return array_key_exists($relation, $this->relationships)
+			&& count($this->relationships[$relation]) > 0;
+	}
+
+	/**
+	 * Return cache instance for the current entity type.
+	 *
+	 * @return \Analogue\ORM\System\EntityCache
+	 */
+	protected function getCache()
+	{
+		return $this->getMapper()->getEntityCache();
+	}
+
+	/**
+	 * Get Only Raw Entiy's attributes which have been modified
+	 * since last query.
+	 *
+	 * @return array
+	 */
+	public function getDirtyRawAttributes()
+	{
+		$attributes = $this->getRawAttributes();
+		$cachedAttributes = $this->getCachedRawAttributes(array_keys($attributes));
+
+		$dirty = [];
+
+		foreach ($attributes as $key => $value) {
+			if ($this->isRelation($key) || $key == 'pivot') {
+				continue;
+			}
+
+			if (!array_key_exists($key, $cachedAttributes) && !$value instanceof Pivot) {
+				$dirty[$key] = $value;
+			} elseif ($value !== $cachedAttributes[$key] &&
+				!$this->originalIsNumericallyEquivalent($value, $cachedAttributes[$key])) {
+				$dirty[$key] = $value;
+			}
+		}
+
+		return $dirty;
+	}
+
+	/**
+	 * @param $key
+	 *
+	 * @return bool
+	 */
+	protected function isRelation($key)
+	{
+		return in_array($key, $this->entityMap->getRelationships());
+	}
+
+	/**
+	 * Determine if the new and old values for a given key are numerically equivalent.
+	 *
+	 * @param $current
+	 * @param $original
+	 *
+	 * @return bool
+	 */
+	protected function originalIsNumericallyEquivalent($current, $original)
+	{
+		return is_numeric($current) && is_numeric($original) && strcmp((string) $current, (string) $original) === 0;
+	}
+
+	/**
+	 * Get the underlying entity object.
+	 *
+	 * @return mixed
+	 */
+	public function getEntityObject()
+	{
+		return $this->wrappedEntity->getObject();
+	}
+
+	/**
+	 * Return the Mapper instance for the current Entity Type.
+	 *
+	 * @return \Analogue\ORM\System\Mapper
+	 */
+	public function getMapper()
+	{
+		return Manager::getMapper($this->class);
+	}
+
+	/**
+	 * Check that the entity already exists in the database, by checking
+	 * if it has an EntityCache record.
+	 *
+	 * @return bool
+	 */
+	public function exists()
+	{
+		return $this->getCache()->has($this->getEntityId());
+	}
+
+	/**
+	 * Set the object attribute raw values (hydration).
+	 *
+	 * @param array $attributes
+	 */
+	public function setEntityAttributes(array $attributes)
+	{
+		$this->wrappedEntity->setEntityAttributes($attributes);
+	}
+
+	/**
+	 * Get the raw object's values.
+	 *
+	 * @return array
+	 */
+	public function getEntityAttributes()
+	{
+		return $this->wrappedEntity->getEntityAttributes();
+	}
+
+	/**
+	 * Set the raw entity attributes.
+	 *
+	 * @param string $key
+	 * @param string $value
+	 */
+	public function setEntityAttribute($key, $value)
+	{
+		$this->wrappedEntity->setEntityAttribute($key, $value);
+	}
+
+	/**
+	 * Return the entity's attribute.
+	 *
+	 * @param string $key
+	 *
+	 * @return mixed
+	 */
+	public function getEntityAttribute($key)
+	{
+		return $this->wrappedEntity->getEntityAttribute($key);
+	}
+
+	/**
+	 * Does the attribute exists on the entity.
+	 *
+	 * @param string $key
+	 *
+	 * @return bool
+	 */
+	public function hasAttribute($key)
+	{
+		return $this->wrappedEntity->hasAttribute($key);
+	}
+
+	/**
+	 * Set the lazyloading proxies on the wrapped entity.
+	 *
+	 * @return void
+	 */
+	public function setProxies()
+	{
+		$this->wrappedEntity->setProxies();
+	}
+
+	/**
+	 * Hydrate the actual entity.
+	 *
+	 * @return void
+	 */
+	public function hydrate()
+	{
+		$this->wrappedEntity->hydrate();
+	}
 }

src/System/ResultBuilder.php

Indentation +340 added lines, -340 removed lines

@@ -7,344 +7,344 @@
 
 class ResultBuilder
 {
-    /**
-     * The default mapper used to build entities with.
-     *
-     * @var \Analogue\ORM\System\Mapper
-     */
-    protected $defaultMapper;
-
-    /**
-     * Relations that will be eager loaded on this query.
-     *
-     * @var array
-     */
-    protected $eagerLoads;
-
-    /**
-     * The Entity Map for the entity to build.
-     *
-     * @var \Analogue\ORM\EntityMap
-     */
-    protected $entityMap;
-
-    /**
-     * An array of builders used by this class to build necessary
-     * entities for each result type.
-     *
-     * @var array
-     */
-    protected $builders = [];
-
-    /**
-     * @param Mapper $defaultMapper
-     * @param array  $eagerLoads
-     */
-    public function __construct(Mapper $defaultMapper)
-    {
-        $this->defaultMapper = $defaultMapper;
-        $this->entityMap = $defaultMapper->getEntityMap();
-    }
-
-    /**
-     * Convert a result set into an array of entities.
-     *
-     * @param array $results
-     * @param array $eagerLoads name of the relation to be eager loaded on the Entities
-     *
-     * @return \Illuminate\Support\Collection
-     */
-    public function build(array $results, array $eagerLoads)
-    {
-        // Parse embedded relations and build corresponding entities using the default
-        // mapper.
-        $results = $this->buildEmbeddedRelationships($results);
-
-        // Launch the queries related to eager loads, and match the
-        // current result set to these loaded relationships.
-        $results = $this->queryEagerLoadedRelationships($results, $eagerLoads);
-
-        // Note : Maybe we could use a PolymorphicResultBuilder, which would
-        // be shared by both STI and polymorphic relations, as they share the
-        // same process.
-
-        switch ($this->entityMap->getInheritanceType()) {
-            case 'single_table':
-                return $this->buildUsingSingleTableInheritance($results);
-                break;
-
-            default:
-                return $this->buildWithDefaultMapper($results);
-                break;
-        }
-    }
-
-    /**
-     * Build embedded objects and match them to the result set.
-     *
-     * @param array $results
-     *
-     * @return array
-     */
-    protected function buildEmbeddedRelationships(array $results) : array
-    {
-        $entityMap = $this->entityMap;
-        $instance = $this->defaultMapper->newInstance();
-        $embeddeds = $entityMap->getEmbeddedRelationships();
-
-        foreach ($embeddeds as $embedded) {
-            $results = $entityMap->$embedded($instance)->match($results, $embedded);
-        }
-
-        return $results;
-    }
-
-    /**
-     * Launch queries on eager loaded relationships.
-     *
-     * @return array
-     */
-    protected function queryEagerLoadedRelationships(array $results, array $eagerLoads) : array
-    {
-        $this->eagerLoads = $this->parseRelations($eagerLoads);
-
-        return $this->eagerLoadRelations($results);
-    }
-
-    /**
-     * Parse a list of relations into individuals.
-     *
-     * @param array $relations
-     *
-     * @return array
-     */
-    protected function parseRelations(array $relations)
-    {
-        $results = [];
-
-        foreach ($relations as $name => $constraints) {
-            // If the "relation" value is actually a numeric key, we can assume that no
-            // constraints have been specified for the eager load and we'll just put
-            // an empty Closure with the loader so that we can treat all the same.
-            if (is_numeric($name)) {
-                $f = function () {
-                };
-
-                list($name, $constraints) = [$constraints, $f];
-            }
-
-            // We need to separate out any nested includes. Which allows the developers
-            // to load deep relationships using "dots" without stating each level of
-            // the relationship with its own key in the array of eager load names.
-            $results = $this->parseNested($name, $results);
-
-            $results[$name] = $constraints;
-        }
-
-        return $results;
-    }
-
-    /**
-     * Parse the nested relationships in a relation.
-     *
-     * @param string $name
-     * @param array  $results
-     *
-     * @return array
-     */
-    protected function parseNested($name, $results)
-    {
-        $progress = [];
-
-        // If the relation has already been set on the result array, we will not set it
-        // again, since that would override any constraints that were already placed
-        // on the relationships. We will only set the ones that are not specified.
-        foreach (explode('.', $name) as $segment) {
-            $progress[] = $segment;
-
-            if (!isset($results[$last = implode('.', $progress)])) {
-                $results[$last] = function () {
-                };
-            }
-        }
-
-        return $results;
-    }
-
-    /**
-     * Eager load the relationships on a result set.
-     *
-     * @param array $results
-     *
-     * @return array
-     */
-    public function eagerLoadRelations(array $results)
-    {
-        foreach ($this->eagerLoads as $name => $constraints) {
-
-            // For nested eager loads we'll skip loading them here and they will be set as an
-            // eager load on the query to retrieve the relation so that they will be eager
-            // loaded on that query, because that is where they get hydrated as models.
-            if (strpos($name, '.') === false) {
-                $results = $this->loadRelation($results, $name, $constraints);
-            }
-        }
-
-        return $results;
-    }
-
-    /**
-     * Eagerly load the relationship on a set of entities.
-     *
-     * @param array    $results
-     * @param string   $name
-     * @param \Closure $constraints
-     *
-     * @return array
-     */
-    protected function loadRelation(array $results, $name, Closure $constraints) : array
-    {
-        // First we will "back up" the existing where conditions on the query so we can
-        // add our eager constraints. Then we will merge the wheres that were on the
-        // query back to it in order that any where conditions might be specified.
-        $relation = $this->getRelation($name);
-
-        $relation->addEagerConstraints($results);
-
-        call_user_func($constraints, $relation);
-
-        // Once we have the results, we just match those back up to their parent models
-        // using the relationship instance. Then we just return the finished arrays
-        // of models which have been eagerly hydrated and are readied for return.
-
-        return $relation->match($results, $name);
-    }
-
-    /**
-     * Get the relation instance for the given relation name.
-     *
-     * @param string $relation
-     *
-     * @return \Analogue\ORM\Relationships\Relationship
-     */
-    public function getRelation($relation)
-    {
-        // We want to run a relationship query without any constrains so that we will
-        // not have to remove these where clauses manually which gets really hacky
-        // and is error prone while we remove the developer's own where clauses.
-        $query = Relationship::noConstraints(function () use ($relation) {
-            return $this->entityMap->$relation($this->defaultMapper->newInstance());
-        });
-
-        $nested = $this->nestedRelations($relation);
-
-        // If there are nested relationships set on the query, we will put those onto
-        // the query instances so that they can be handled after this relationship
-        // is loaded. In this way they will all trickle down as they are loaded.
-        if (count($nested) > 0) {
-            $query->getQuery()->with($nested);
-        }
-
-        return $query;
-    }
-
-    /**
-     * Get the deeply nested relations for a given top-level relation.
-     *
-     * @param string $relation
-     *
-     * @return array
-     */
-    protected function nestedRelations($relation)
-    {
-        $nested = [];
-
-        // We are basically looking for any relationships that are nested deeper than
-        // the given top-level relationship. We will just check for any relations
-        // that start with the given top relations and adds them to our arrays.
-        foreach ($this->eagerLoads as $name => $constraints) {
-            if ($this->isNested($name, $relation)) {
-                $nested[substr($name, strlen($relation.'.'))] = $constraints;
-            }
-        }
-
-        return $nested;
-    }
-
-    /**
-     * Determine if the relationship is nested.
-     *
-     * @param string $name
-     * @param string $relation
-     *
-     * @return bool
-     */
-    protected function isNested($name, $relation)
-    {
-        $dots = str_contains($name, '.');
-
-        return $dots && starts_with($name, $relation.'.');
-    }
-
-    /**
-     * Build an entity from results, using the default mapper on this builder.
-     * This is the default build plan when no table inheritance is being used.
-     *
-     * @param array $results
-     *
-     * @return Collection
-     */
-    protected function buildWithDefaultMapper(array $results)
-    {
-        $builder = new EntityBuilder($this->defaultMapper, array_keys($this->eagerLoads));
-
-        return collect($results)->map(function ($item, $key) use ($builder) {
-            return $builder->build($item);
-        })->all();
-    }
-
-    /**
-     * Build an entity from results, using single table inheritance.
-     *
-     * @param array $results
-     *
-     * @return Collection
-     */
-    protected function buildUsingSingleTableInheritance(array $results)
-    {
-        return collect($results)->map(function ($item, $key) {
-            $builder = $this->builderForResult($item);
-
-            return $builder->build($item);
-        })->all();
-    }
-
-    /**
-     * Given a result array, return the entity builder needed to correctly
-     * build the result into an entity. If no getDiscriminatorColumnMap property
-     * has been defined on the EntityMap, we'll assume that the value stored in
-     * the $type column is the fully qualified class name of the entity and
-     * we'll use it instead.
-     *
-     * @param array $result
-     *
-     * @return EntityBuilder
-     */
-    protected function builderForResult(array $result)
-    {
-        $type = $result[$this->entityMap->getDiscriminatorColumn()];
-
-        $columnMap = $this->entityMap->getDiscriminatorColumnMap();
-
-        $class = isset($columnMap[$type]) ? $columnMap[$type] : $type;
-
-        if (!isset($this->builders[$type])) {
-            $this->builders[$type] = new EntityBuilder(
-                Manager::getInstance()->mapper($class),
-                array_keys($this->eagerLoads)
-            );
-        }
-
-        return $this->builders[$type];
-    }
+	/**
+	 * The default mapper used to build entities with.
+	 *
+	 * @var \Analogue\ORM\System\Mapper
+	 */
+	protected $defaultMapper;
+
+	/**
+	 * Relations that will be eager loaded on this query.
+	 *
+	 * @var array
+	 */
+	protected $eagerLoads;
+
+	/**
+	 * The Entity Map for the entity to build.
+	 *
+	 * @var \Analogue\ORM\EntityMap
+	 */
+	protected $entityMap;
+
+	/**
+	 * An array of builders used by this class to build necessary
+	 * entities for each result type.
+	 *
+	 * @var array
+	 */
+	protected $builders = [];
+
+	/**
+	 * @param Mapper $defaultMapper
+	 * @param array  $eagerLoads
+	 */
+	public function __construct(Mapper $defaultMapper)
+	{
+		$this->defaultMapper = $defaultMapper;
+		$this->entityMap = $defaultMapper->getEntityMap();
+	}
+
+	/**
+	 * Convert a result set into an array of entities.
+	 *
+	 * @param array $results
+	 * @param array $eagerLoads name of the relation to be eager loaded on the Entities
+	 *
+	 * @return \Illuminate\Support\Collection
+	 */
+	public function build(array $results, array $eagerLoads)
+	{
+		// Parse embedded relations and build corresponding entities using the default
+		// mapper.
+		$results = $this->buildEmbeddedRelationships($results);
+
+		// Launch the queries related to eager loads, and match the
+		// current result set to these loaded relationships.
+		$results = $this->queryEagerLoadedRelationships($results, $eagerLoads);
+
+		// Note : Maybe we could use a PolymorphicResultBuilder, which would
+		// be shared by both STI and polymorphic relations, as they share the
+		// same process.
+
+		switch ($this->entityMap->getInheritanceType()) {
+			case 'single_table':
+				return $this->buildUsingSingleTableInheritance($results);
+				break;
+
+			default:
+				return $this->buildWithDefaultMapper($results);
+				break;
+		}
+	}
+
+	/**
+	 * Build embedded objects and match them to the result set.
+	 *
+	 * @param array $results
+	 *
+	 * @return array
+	 */
+	protected function buildEmbeddedRelationships(array $results) : array
+	{
+		$entityMap = $this->entityMap;
+		$instance = $this->defaultMapper->newInstance();
+		$embeddeds = $entityMap->getEmbeddedRelationships();
+
+		foreach ($embeddeds as $embedded) {
+			$results = $entityMap->$embedded($instance)->match($results, $embedded);
+		}
+
+		return $results;
+	}
+
+	/**
+	 * Launch queries on eager loaded relationships.
+	 *
+	 * @return array
+	 */
+	protected function queryEagerLoadedRelationships(array $results, array $eagerLoads) : array
+	{
+		$this->eagerLoads = $this->parseRelations($eagerLoads);
+
+		return $this->eagerLoadRelations($results);
+	}
+
+	/**
+	 * Parse a list of relations into individuals.
+	 *
+	 * @param array $relations
+	 *
+	 * @return array
+	 */
+	protected function parseRelations(array $relations)
+	{
+		$results = [];
+
+		foreach ($relations as $name => $constraints) {
+			// If the "relation" value is actually a numeric key, we can assume that no
+			// constraints have been specified for the eager load and we'll just put
+			// an empty Closure with the loader so that we can treat all the same.
+			if (is_numeric($name)) {
+				$f = function () {
+				};
+
+				list($name, $constraints) = [$constraints, $f];
+			}
+
+			// We need to separate out any nested includes. Which allows the developers
+			// to load deep relationships using "dots" without stating each level of
+			// the relationship with its own key in the array of eager load names.
+			$results = $this->parseNested($name, $results);
+
+			$results[$name] = $constraints;
+		}
+
+		return $results;
+	}
+
+	/**
+	 * Parse the nested relationships in a relation.
+	 *
+	 * @param string $name
+	 * @param array  $results
+	 *
+	 * @return array
+	 */
+	protected function parseNested($name, $results)
+	{
+		$progress = [];
+
+		// If the relation has already been set on the result array, we will not set it
+		// again, since that would override any constraints that were already placed
+		// on the relationships. We will only set the ones that are not specified.
+		foreach (explode('.', $name) as $segment) {
+			$progress[] = $segment;
+
+			if (!isset($results[$last = implode('.', $progress)])) {
+				$results[$last] = function () {
+				};
+			}
+		}
+
+		return $results;
+	}
+
+	/**
+	 * Eager load the relationships on a result set.
+	 *
+	 * @param array $results
+	 *
+	 * @return array
+	 */
+	public function eagerLoadRelations(array $results)
+	{
+		foreach ($this->eagerLoads as $name => $constraints) {
+
+			// For nested eager loads we'll skip loading them here and they will be set as an
+			// eager load on the query to retrieve the relation so that they will be eager
+			// loaded on that query, because that is where they get hydrated as models.
+			if (strpos($name, '.') === false) {
+				$results = $this->loadRelation($results, $name, $constraints);
+			}
+		}
+
+		return $results;
+	}
+
+	/**
+	 * Eagerly load the relationship on a set of entities.
+	 *
+	 * @param array    $results
+	 * @param string   $name
+	 * @param \Closure $constraints
+	 *
+	 * @return array
+	 */
+	protected function loadRelation(array $results, $name, Closure $constraints) : array
+	{
+		// First we will "back up" the existing where conditions on the query so we can
+		// add our eager constraints. Then we will merge the wheres that were on the
+		// query back to it in order that any where conditions might be specified.
+		$relation = $this->getRelation($name);
+
+		$relation->addEagerConstraints($results);
+
+		call_user_func($constraints, $relation);
+
+		// Once we have the results, we just match those back up to their parent models
+		// using the relationship instance. Then we just return the finished arrays
+		// of models which have been eagerly hydrated and are readied for return.
+
+		return $relation->match($results, $name);
+	}
+
+	/**
+	 * Get the relation instance for the given relation name.
+	 *
+	 * @param string $relation
+	 *
+	 * @return \Analogue\ORM\Relationships\Relationship
+	 */
+	public function getRelation($relation)
+	{
+		// We want to run a relationship query without any constrains so that we will
+		// not have to remove these where clauses manually which gets really hacky
+		// and is error prone while we remove the developer's own where clauses.
+		$query = Relationship::noConstraints(function () use ($relation) {
+			return $this->entityMap->$relation($this->defaultMapper->newInstance());
+		});
+
+		$nested = $this->nestedRelations($relation);
+
+		// If there are nested relationships set on the query, we will put those onto
+		// the query instances so that they can be handled after this relationship
+		// is loaded. In this way they will all trickle down as they are loaded.
+		if (count($nested) > 0) {
+			$query->getQuery()->with($nested);
+		}
+
+		return $query;
+	}
+
+	/**
+	 * Get the deeply nested relations for a given top-level relation.
+	 *
+	 * @param string $relation
+	 *
+	 * @return array
+	 */
+	protected function nestedRelations($relation)
+	{
+		$nested = [];
+
+		// We are basically looking for any relationships that are nested deeper than
+		// the given top-level relationship. We will just check for any relations
+		// that start with the given top relations and adds them to our arrays.
+		foreach ($this->eagerLoads as $name => $constraints) {
+			if ($this->isNested($name, $relation)) {
+				$nested[substr($name, strlen($relation.'.'))] = $constraints;
+			}
+		}
+
+		return $nested;
+	}
+
+	/**
+	 * Determine if the relationship is nested.
+	 *
+	 * @param string $name
+	 * @param string $relation
+	 *
+	 * @return bool
+	 */
+	protected function isNested($name, $relation)
+	{
+		$dots = str_contains($name, '.');
+
+		return $dots && starts_with($name, $relation.'.');
+	}
+
+	/**
+	 * Build an entity from results, using the default mapper on this builder.
+	 * This is the default build plan when no table inheritance is being used.
+	 *
+	 * @param array $results
+	 *
+	 * @return Collection
+	 */
+	protected function buildWithDefaultMapper(array $results)
+	{
+		$builder = new EntityBuilder($this->defaultMapper, array_keys($this->eagerLoads));
+
+		return collect($results)->map(function ($item, $key) use ($builder) {
+			return $builder->build($item);
+		})->all();
+	}
+
+	/**
+	 * Build an entity from results, using single table inheritance.
+	 *
+	 * @param array $results
+	 *
+	 * @return Collection
+	 */
+	protected function buildUsingSingleTableInheritance(array $results)
+	{
+		return collect($results)->map(function ($item, $key) {
+			$builder = $this->builderForResult($item);
+
+			return $builder->build($item);
+		})->all();
+	}
+
+	/**
+	 * Given a result array, return the entity builder needed to correctly
+	 * build the result into an entity. If no getDiscriminatorColumnMap property
+	 * has been defined on the EntityMap, we'll assume that the value stored in
+	 * the $type column is the fully qualified class name of the entity and
+	 * we'll use it instead.
+	 *
+	 * @param array $result
+	 *
+	 * @return EntityBuilder
+	 */
+	protected function builderForResult(array $result)
+	{
+		$type = $result[$this->entityMap->getDiscriminatorColumn()];
+
+		$columnMap = $this->entityMap->getDiscriminatorColumnMap();
+
+		$class = isset($columnMap[$type]) ? $columnMap[$type] : $type;
+
+		if (!isset($this->builders[$type])) {
+			$this->builders[$type] = new EntityBuilder(
+				Manager::getInstance()->mapper($class),
+				array_keys($this->eagerLoads)
+			);
+		}
+
+		return $this->builders[$type];
+	}
 }

src/System/EntityBuilder.php

Indentation +136 added lines, -136 removed lines

@@ -9,141 +9,141 @@
  */
 class EntityBuilder
 {
-    /**
-     * The mapper for the entity to build.
-     *
-     * @var \Analogue\ORM\System\Mapper
-     */
-    protected $mapper;
-
-    /**
-     * The Entity Map for the entity to build.
-     *
-     * @var \Analogue\ORM\EntityMap
-     */
-    protected $entityMap;
-
-    /**
-     * Relations that are eager loaded on this query.
-     *
-     * @var array
-     */
-    protected $eagerLoads;
-
-    /**
-     * @var array
-     */
-    protected $casts;
-
-    /**
-     * Entity Wrapper Factory.
-     *
-     * @var \Analogue\ORM\System\Wrappers\Factory
-     */
-    protected $factory;
-
-    /**
-     * EntityBuilder constructor.
-     *
-     * @param Mapper $mapper
-     * @param array  $eagerLoads
-     */
-    public function __construct(Mapper $mapper, array $eagerLoads)
-    {
-        $this->mapper = $mapper;
-
-        $this->entityMap = $mapper->getEntityMap();
-
-        $this->eagerLoads = $eagerLoads;
-
-        $this->factory = new Factory();
-    }
-
-    /**
-     * Convert an array of values into an entity.
-     *
-     * @param array $result
-     *
-     * @return array
-     */
-    public function build(array $result)
-    {
-        $wrapper = $this->getWrapperInstance();
-
-        // Hydrate any embedded Value Object
-        //
-        // TODO Move this to the result builder instead,
-        // as we'll handle this the same way as they were
-        // eager loaded relationships.
-        $this->hydrateValueObjects($result);
-
-        $wrapper->setEntityAttributes($result);
-
-        $wrapper->setProxies();
+	/**
+	 * The mapper for the entity to build.
+	 *
+	 * @var \Analogue\ORM\System\Mapper
+	 */
+	protected $mapper;
+
+	/**
+	 * The Entity Map for the entity to build.
+	 *
+	 * @var \Analogue\ORM\EntityMap
+	 */
+	protected $entityMap;
+
+	/**
+	 * Relations that are eager loaded on this query.
+	 *
+	 * @var array
+	 */
+	protected $eagerLoads;
+
+	/**
+	 * @var array
+	 */
+	protected $casts;
+
+	/**
+	 * Entity Wrapper Factory.
+	 *
+	 * @var \Analogue\ORM\System\Wrappers\Factory
+	 */
+	protected $factory;
+
+	/**
+	 * EntityBuilder constructor.
+	 *
+	 * @param Mapper $mapper
+	 * @param array  $eagerLoads
+	 */
+	public function __construct(Mapper $mapper, array $eagerLoads)
+	{
+		$this->mapper = $mapper;
+
+		$this->entityMap = $mapper->getEntityMap();
+
+		$this->eagerLoads = $eagerLoads;
+
+		$this->factory = new Factory();
+	}
+
+	/**
+	 * Convert an array of values into an entity.
+	 *
+	 * @param array $result
+	 *
+	 * @return array
+	 */
+	public function build(array $result)
+	{
+		$wrapper = $this->getWrapperInstance();
+
+		// Hydrate any embedded Value Object
+		//
+		// TODO Move this to the result builder instead,
+		// as we'll handle this the same way as they were
+		// eager loaded relationships.
+		$this->hydrateValueObjects($result);
+
+		$wrapper->setEntityAttributes($result);
+
+		$wrapper->setProxies();
         
-        // Hydrate and return the instance
-        $wrapper->hydrate();
-        $entity = $wrapper->getObject();
-
-        return $entity;
-    }
-
-    /**
-     * Get the correct wrapper prototype corresponding to the object type.
-     *
-     * @throws \Analogue\ORM\Exceptions\MappingException
-     *
-     * @return InternallyMappable
-     */
-    protected function getWrapperInstance()
-    {
-        return $this->factory->make($this->mapper->newInstance());
-    }
-
-    /**
-     * Hydrate value object embedded in this entity.
-     *
-     * @param array $attributes
-     *
-     * @throws \Analogue\ORM\Exceptions\MappingException
-     *
-     * @return void
-     */
-    protected function hydrateValueObjects(&$attributes)
-    {
-        foreach ($this->entityMap->getEmbeddables() as $localKey => $valueClass) {
-            $this->hydrateValueObject($attributes, $localKey, $valueClass);
-        }
-    }
-
-    /**
-     * Hydrate a single value object.
-     *
-     * @param array  $attributes
-     * @param string $localKey
-     * @param string $valueClass
-     *
-     * @throws \Analogue\ORM\Exceptions\MappingException
-     *
-     * @return void
-     */
-    protected function hydrateValueObject(&$attributes, $localKey, $valueClass)
-    {
-        $map = $this->mapper->getManager()->getValueMap($valueClass);
-
-        $embeddedAttributes = $map->getAttributes();
-
-        $valueObject = $this->mapper->getManager()->getValueObjectInstance($valueClass);
-        $voWrapper = $this->factory->make($valueObject);
-
-        foreach ($embeddedAttributes as $key) {
-            $prefix = snake_case(class_basename($valueClass)).'_';
-
-            $voWrapper->setEntityAttribute($key, $attributes[$prefix.$key]);
-
-            unset($attributes[$prefix.$key]);
-        }
-
-        $attributes[$localKey] = $voWrapper->getObject();
-    }
+		// Hydrate and return the instance
+		$wrapper->hydrate();
+		$entity = $wrapper->getObject();
+
+		return $entity;
+	}
+
+	/**
+	 * Get the correct wrapper prototype corresponding to the object type.
+	 *
+	 * @throws \Analogue\ORM\Exceptions\MappingException
+	 *
+	 * @return InternallyMappable
+	 */
+	protected function getWrapperInstance()
+	{
+		return $this->factory->make($this->mapper->newInstance());
+	}
+
+	/**
+	 * Hydrate value object embedded in this entity.
+	 *
+	 * @param array $attributes
+	 *
+	 * @throws \Analogue\ORM\Exceptions\MappingException
+	 *
+	 * @return void
+	 */
+	protected function hydrateValueObjects(&$attributes)
+	{
+		foreach ($this->entityMap->getEmbeddables() as $localKey => $valueClass) {
+			$this->hydrateValueObject($attributes, $localKey, $valueClass);
+		}
+	}
+
+	/**
+	 * Hydrate a single value object.
+	 *
+	 * @param array  $attributes
+	 * @param string $localKey
+	 * @param string $valueClass
+	 *
+	 * @throws \Analogue\ORM\Exceptions\MappingException
+	 *
+	 * @return void
+	 */
+	protected function hydrateValueObject(&$attributes, $localKey, $valueClass)
+	{
+		$map = $this->mapper->getManager()->getValueMap($valueClass);
+
+		$embeddedAttributes = $map->getAttributes();
+
+		$valueObject = $this->mapper->getManager()->getValueObjectInstance($valueClass);
+		$voWrapper = $this->factory->make($valueObject);
+
+		foreach ($embeddedAttributes as $key) {
+			$prefix = snake_case(class_basename($valueClass)).'_';
+
+			$voWrapper->setEntityAttribute($key, $attributes[$prefix.$key]);
+
+			unset($attributes[$prefix.$key]);
+		}
+
+		$attributes[$localKey] = $voWrapper->getObject();
+	}
 }