analogueorm / analogue

src/System/Cache/CachedRelationship.php

Indentation +59 added lines, -59 removed lines

@@ -8,69 +8,69 @@
  */
 class CachedRelationship
 {
-    /**
-     * The Hash of the related entity.
-     *
-     * @var string
-     */
-    protected $hash;
+	/**
+	 * The Hash of the related entity.
+	 *
+	 * @var string
+	 */
+	protected $hash;
 
-    /**
-     * Pivot attributes.
-     *
-     * @var array
-     */
-    protected $pivotAttributes;
+	/**
+	 * Pivot attributes.
+	 *
+	 * @var array
+	 */
+	protected $pivotAttributes;
 
-    /**
-     * CachedRelationship constructor.
-     *
-     * @param string $hash
-     * @param array  $pivotAttributes
-     */
-    public function __construct(string $hash, array $pivotAttributes = [])
-    {
-        $this->hash = $hash;
-        $this->pivotAttributes = $pivotAttributes;
-    }
+	/**
+	 * CachedRelationship constructor.
+	 *
+	 * @param string $hash
+	 * @param array  $pivotAttributes
+	 */
+	public function __construct(string $hash, array $pivotAttributes = [])
+	{
+		$this->hash = $hash;
+		$this->pivotAttributes = $pivotAttributes;
+	}
 
-    /**
-     * Return true if any pivot attributes are present.
-     *
-     * @return bool
-     */
-    public function hasPivotAttributes(): bool
-    {
-        return !empty($this->pivotAttributes);
-    }
+	/**
+	 * Return true if any pivot attributes are present.
+	 *
+	 * @return bool
+	 */
+	public function hasPivotAttributes(): bool
+	{
+		return !empty($this->pivotAttributes);
+	}
 
-    /**
-     * Returns the hash of the related entity.
-     *
-     * @return string
-     */
-    public function getHash(): string
-    {
-        return $this->hash;
-    }
+	/**
+	 * Returns the hash of the related entity.
+	 *
+	 * @return string
+	 */
+	public function getHash(): string
+	{
+		return $this->hash;
+	}
 
-    /**
-     * Get the cached values for the pivot attributes.
-     *
-     * @return array
-     */
-    public function getPivotAttributes(): array
-    {
-        return $this->pivotAttributes;
-    }
+	/**
+	 * Get the cached values for the pivot attributes.
+	 *
+	 * @return array
+	 */
+	public function getPivotAttributes(): array
+	{
+		return $this->pivotAttributes;
+	}
 
-    /**
-     * Access to the hash for fast cache comparison.
-     *
-     * @return string
-     */
-    public function __toString(): string
-    {
-        return $this->hash;
-    }
+	/**
+	 * Access to the hash for fast cache comparison.
+	 *
+	 * @return string
+	 */
+	public function __toString(): string
+	{
+		return $this->hash;
+	}
 }

src/System/InternallyMappable.php

Indentation +59 added lines, -59 removed lines

@@ -4,71 +4,71 @@
 
 interface InternallyMappable
 {
-    /**
-     * Set the object attribute raw values (hydration).
-     *
-     * @param array $attributes
-     */
-    public function setEntityAttributes(array $attributes);
+	/**
+	 * Set the object attribute raw values (hydration).
+	 *
+	 * @param array $attributes
+	 */
+	public function setEntityAttributes(array $attributes);
 
-    /**
-     * Get the entity class name.
-     *
-     * @return string
-     */
-    public function getEntityClass(): string;
+	/**
+	 * Get the entity class name.
+	 *
+	 * @return string
+	 */
+	public function getEntityClass(): string;
 
-    /**
-     * Return the entity's primary key name.
-     *
-     * @return string
-     */
-    public function getEntityKeyName(): string;
+	/**
+	 * Return the entity's primary key name.
+	 *
+	 * @return string
+	 */
+	public function getEntityKeyName(): string;
 
-    /**
-     * Return the entity's primary key value.
-     *
-     * @return mixed
-     */
-    public function getEntityKeyValue();
+	/**
+	 * Return the entity's primary key value.
+	 *
+	 * @return mixed
+	 */
+	public function getEntityKeyValue();
 
-    /**
-     * Return the Entity's hash $class.$id.
-     *
-     * @return string
-     */
-    public function getEntityHash(): string;
+	/**
+	 * Return the Entity's hash $class.$id.
+	 *
+	 * @return string
+	 */
+	public function getEntityHash(): string;
 
-    /**
-     * Get the raw object's values.
-     *
-     * @return array
-     */
-    public function getEntityAttributes();
+	/**
+	 * Get the raw object's values.
+	 *
+	 * @return array
+	 */
+	public function getEntityAttributes();
 
-    /**
-     * Set the raw entity attributes.
-     *
-     * @param string $key
-     * @param mixed  $value
-     */
-    public function setEntityAttribute(string $key, $value);
+	/**
+	 * Set the raw entity attributes.
+	 *
+	 * @param string $key
+	 * @param mixed  $value
+	 */
+	public function setEntityAttribute(string $key, $value);
 
-    /**
-     * Return the entity's attribute.
-     *
-     * @param string $key
-     *
-     * @return mixed
-     */
-    public function getEntityAttribute(string $key);
+	/**
+	 * Return the entity's attribute.
+	 *
+	 * @param string $key
+	 *
+	 * @return mixed
+	 */
+	public function getEntityAttribute(string $key);
 
-    /**
-     * Does the entity posses the given attribute.
-     *
-     * @param string $key
-     *
-     * @return bool
-     */
-    public function hasAttribute(string $key): bool;
+	/**
+	 * Does the entity posses the given attribute.
+	 *
+	 * @param string $key
+	 *
+	 * @return bool
+	 */
+	public function hasAttribute(string $key): bool;
 }

src/System/ResultBuilder.php

Indentation +407 added lines, -407 removed lines

@@ -7,411 +7,411 @@
 
 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 = [];
-
-    /**
-     * ResultBuilder constructor.
-     *
-     * @param Mapper $defaultMapper
-     */
-    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 array
-     */
-    public function build(array $results, array $eagerLoads)
-    {
-        // First, we'll cache the raw result set
-        $this->cacheResults($results);
-
-        // 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);
-
-            default:
-                return $this->buildWithDefaultMapper($results);
-        }
-    }
-
-    /**
-     * Cache result set.
-     *
-     * @param array $results
-     *
-     * @return void
-     */
-    protected function cacheResults(array $results)
-    {
-        switch ($this->entityMap->getInheritanceType()) {
-            case 'single_table':
-
-                $this->cacheSingleTableInheritanceResults($results);
-                break;
-
-            default:
-                $mapper = $this->defaultMapper;
-                 // When hydrating EmbeddedValue object, they'll likely won't
-                // have a primary key set.
-                if (!is_null($mapper->getEntityMap()->getKeyName())) {
-                    $mapper->getEntityCache()->add($results);
-                }
-                break;
-        }
-    }
-
-    /**
-     * Cache results from a STI result set.
-     *
-     * @param array $results
-     *
-     * @return void
-     */
-    protected function cacheSingleTableInheritanceResults(array $results)
-    {
-        foreach ($results as $result) {
-            $mapper = $this->getMapperForSingleRow($result);
-
-            // When hydrating EmbeddedValue object, they'll likely won't
-            // have a primary key set.
-            if (!is_null($mapper->getEntityMap()->getKeyName())) {
-                $mapper->getEntityCache()->add([$result]);
-            }
-        }
-    }
-
-    /**
-     * 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.
-     *
-     * @param array $results
-     * @param array $eagerLoads
-     *
-     * @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): array
-    {
-        $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(string $name, array $results): array
-    {
-        $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): array
-    {
-        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, string $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(string $relation): Relationship
-    {
-        // 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(string $relation): array
-    {
-        $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(string $name, string $relation): bool
-    {
-        $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 array
-     */
-    protected function buildWithDefaultMapper(array $results): array
-    {
-        $builder = new EntityBuilder($this->defaultMapper, array_keys($this->eagerLoads));
-
-        return array_map(function ($item) use ($builder) {
-            return $builder->build($item);
-        }, $results);
-    }
-
-    /**
-     * Build an entity from results, using single table inheritance.
-     *
-     * @param array $results
-     *
-     * @return array
-     */
-    protected function buildUsingSingleTableInheritance(array $results): array
-    {
-        return array_map(function ($item) {
-            $builder = $this->builderForResult($item);
-
-            return $builder->build($item);
-        }, $results);
-    }
-
-    /**
-     * 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): EntityBuilder
-    {
-        $type = $result[$this->entityMap->getDiscriminatorColumn()];
-
-        $mapper = $this->getMapperForSingleRow($result);
-
-        if (!isset($this->builders[$type])) {
-            $this->builders[$type] = new EntityBuilder(
-                $mapper,
-                array_keys($this->eagerLoads)
-            );
-        }
-
-        return $this->builders[$type];
-    }
-
-    /**
-     * Get mapper corresponding to the result type.
-     *
-     * @param array $result
-     *
-     * @return Mapper
-     */
-    protected function getMapperForSingleRow(array $result) : Mapper
-    {
-        $type = $result[$this->entityMap->getDiscriminatorColumn()];
-
-        $columnMap = $this->entityMap->getDiscriminatorColumnMap();
-
-        $class = isset($columnMap[$type]) ? $columnMap[$type] : $type;
-
-        return Manager::getInstance()->mapper($class);
-    }
+	/**
+	 * 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 = [];
+
+	/**
+	 * ResultBuilder constructor.
+	 *
+	 * @param Mapper $defaultMapper
+	 */
+	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 array
+	 */
+	public function build(array $results, array $eagerLoads)
+	{
+		// First, we'll cache the raw result set
+		$this->cacheResults($results);
+
+		// 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);
+
+			default:
+				return $this->buildWithDefaultMapper($results);
+		}
+	}
+
+	/**
+	 * Cache result set.
+	 *
+	 * @param array $results
+	 *
+	 * @return void
+	 */
+	protected function cacheResults(array $results)
+	{
+		switch ($this->entityMap->getInheritanceType()) {
+			case 'single_table':
+
+				$this->cacheSingleTableInheritanceResults($results);
+				break;
+
+			default:
+				$mapper = $this->defaultMapper;
+				 // When hydrating EmbeddedValue object, they'll likely won't
+				// have a primary key set.
+				if (!is_null($mapper->getEntityMap()->getKeyName())) {
+					$mapper->getEntityCache()->add($results);
+				}
+				break;
+		}
+	}
+
+	/**
+	 * Cache results from a STI result set.
+	 *
+	 * @param array $results
+	 *
+	 * @return void
+	 */
+	protected function cacheSingleTableInheritanceResults(array $results)
+	{
+		foreach ($results as $result) {
+			$mapper = $this->getMapperForSingleRow($result);
+
+			// When hydrating EmbeddedValue object, they'll likely won't
+			// have a primary key set.
+			if (!is_null($mapper->getEntityMap()->getKeyName())) {
+				$mapper->getEntityCache()->add([$result]);
+			}
+		}
+	}
+
+	/**
+	 * 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.
+	 *
+	 * @param array $results
+	 * @param array $eagerLoads
+	 *
+	 * @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): array
+	{
+		$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(string $name, array $results): array
+	{
+		$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): array
+	{
+		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, string $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(string $relation): Relationship
+	{
+		// 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(string $relation): array
+	{
+		$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(string $name, string $relation): bool
+	{
+		$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 array
+	 */
+	protected function buildWithDefaultMapper(array $results): array
+	{
+		$builder = new EntityBuilder($this->defaultMapper, array_keys($this->eagerLoads));
+
+		return array_map(function ($item) use ($builder) {
+			return $builder->build($item);
+		}, $results);
+	}
+
+	/**
+	 * Build an entity from results, using single table inheritance.
+	 *
+	 * @param array $results
+	 *
+	 * @return array
+	 */
+	protected function buildUsingSingleTableInheritance(array $results): array
+	{
+		return array_map(function ($item) {
+			$builder = $this->builderForResult($item);
+
+			return $builder->build($item);
+		}, $results);
+	}
+
+	/**
+	 * 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): EntityBuilder
+	{
+		$type = $result[$this->entityMap->getDiscriminatorColumn()];
+
+		$mapper = $this->getMapperForSingleRow($result);
+
+		if (!isset($this->builders[$type])) {
+			$this->builders[$type] = new EntityBuilder(
+				$mapper,
+				array_keys($this->eagerLoads)
+			);
+		}
+
+		return $this->builders[$type];
+	}
+
+	/**
+	 * Get mapper corresponding to the result type.
+	 *
+	 * @param array $result
+	 *
+	 * @return Mapper
+	 */
+	protected function getMapperForSingleRow(array $result) : Mapper
+	{
+		$type = $result[$this->entityMap->getDiscriminatorColumn()];
+
+		$columnMap = $this->entityMap->getDiscriminatorColumnMap();
+
+		$class = isset($columnMap[$type]) ? $columnMap[$type] : $type;
+
+		return Manager::getInstance()->mapper($class);
+	}
 }

Spacing +5 added lines, -5 removed lines

@@ -178,7 +178,7 @@ 
             // 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 () {
+                $f = function() {
                 };
 
                 list($name, $constraints) = [$constraints, $f];
@@ -214,7 +214,7 @@ 
             $progress[] = $segment;
 
             if (!isset($results[$last = implode('.', $progress)])) {
-                $results[$last] = function () {
+                $results[$last] = function() {
                 };
             }
         }
@@ -283,7 +283,7 @@ 
         // 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) {
+        $query = Relationship::noConstraints(function() use ($relation) {
             return $this->entityMap->$relation($this->defaultMapper->newInstance());
         });
 
@@ -349,7 +349,7 @@ 
     {
         $builder = new EntityBuilder($this->defaultMapper, array_keys($this->eagerLoads));
 
-        return array_map(function ($item) use ($builder) {
+        return array_map(function($item) use ($builder) {
             return $builder->build($item);
         }, $results);
     }
@@ -363,7 +363,7 @@ 
      */
     protected function buildUsingSingleTableInheritance(array $results): array
     {
-        return array_map(function ($item) {
+        return array_map(function($item) {
             $builder = $this->builderForResult($item);
 
             return $builder->build($item);

src/System/EntityBuilder.php

Indentation +176 added lines, -176 removed lines

@@ -9,180 +9,180 @@
  */
 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 attributes into an entity, or retrieve entity instance from cache.
-     *
-     * @param array $attributes
-     *
-     * @return array
-     */
-    public function build(array $attributes)
-    {
-        // If the object we are building is a value object,
-        // we won't be using the instance cache.
-        if ($this->entityMap->getKeyName() === null) {
-            return $this->buildEntity($attributes);
-        }
-
-        $instanceCache = $this->mapper->getInstanceCache();
-
-        $id = $this->getPrimaryKeyValue($attributes);
-
-        return $instanceCache->has($id) ? $instanceCache->get($id) : $this->buildEntity($attributes);
-    }
-
-    /**
-     * Actually build an entity.
-     *
-     * @param array $attributes
-     *
-     * @return mixed
-     */
-    protected function buildEntity(array $attributes)
-    {
-        $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($attributes);
-
-        $wrapper->setEntityAttributes($attributes);
-
-        $wrapper->setProxies();
-
-        $entity = $wrapper->unwrap();
-
-        // Once the object has been hydrated, we'll add
-        // the instance to the instance cache.
-        if ($this->entityMap->getKeyName() !== null) {
-            $id = $this->getPrimaryKeyValue($attributes);
-            $this->mapper->getInstanceCache()->add($entity, $id);
-        }
-
-        return $entity;
-    }
-
-    /**
-     * Return the primary key value from attributes.
-     *
-     * @param array $attributes
-     *
-     * @return string
-     */
-    protected function getPrimaryKeyValue(array $attributes)
-    {
-        return $attributes[$this->entityMap->getKeyName()];
-    }
-
-    /**
-     * 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();
-    }
+	/**
+	 * 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 attributes into an entity, or retrieve entity instance from cache.
+	 *
+	 * @param array $attributes
+	 *
+	 * @return array
+	 */
+	public function build(array $attributes)
+	{
+		// If the object we are building is a value object,
+		// we won't be using the instance cache.
+		if ($this->entityMap->getKeyName() === null) {
+			return $this->buildEntity($attributes);
+		}
+
+		$instanceCache = $this->mapper->getInstanceCache();
+
+		$id = $this->getPrimaryKeyValue($attributes);
+
+		return $instanceCache->has($id) ? $instanceCache->get($id) : $this->buildEntity($attributes);
+	}
+
+	/**
+	 * Actually build an entity.
+	 *
+	 * @param array $attributes
+	 *
+	 * @return mixed
+	 */
+	protected function buildEntity(array $attributes)
+	{
+		$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($attributes);
+
+		$wrapper->setEntityAttributes($attributes);
+
+		$wrapper->setProxies();
+
+		$entity = $wrapper->unwrap();
+
+		// Once the object has been hydrated, we'll add
+		// the instance to the instance cache.
+		if ($this->entityMap->getKeyName() !== null) {
+			$id = $this->getPrimaryKeyValue($attributes);
+			$this->mapper->getInstanceCache()->add($entity, $id);
+		}
+
+		return $entity;
+	}
+
+	/**
+	 * Return the primary key value from attributes.
+	 *
+	 * @param array $attributes
+	 *
+	 * @return string
+	 */
+	protected function getPrimaryKeyValue(array $attributes)
+	{
+		return $attributes[$this->entityMap->getKeyName()];
+	}
+
+	/**
+	 * 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();
+	}
 }

src/System/Aggregate.php

Spacing +1 added lines, -1 removed lines

@@ -1060,7 +1060,7 @@
      */
     protected function getEntityHashesFromRelation(string $relation): array
     {
-        return array_map(function (Aggregate $aggregate) {
+        return array_map(function(Aggregate $aggregate) {
             return $aggregate->getEntityHash();
         }, $this->relationships[$relation]);
     }

Doc Comments +2 added lines, -2 removed lines

@@ -87,9 +87,9 @@
      * Create a new Aggregated Entity instance.
      *
      * @param mixed          $entity
-     * @param Aggregate|null $parent
+     * @param null|\self $parent
      * @param string         $parentRelationship
-     * @param Aggregate|null $root
+     * @param null|\self $root
      *
      * @throws MappingException
      */

Indentation +1233 added lines, -1233 removed lines

@@ -19,1237 +19,1237 @@
  */
 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, self $parent = null, string $parentRelationship = null, self $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();
-
-        $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(string $relation): bool
-    {
-        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
-     */
-    protected function isParentOrRoot($value): bool
-    {
-        $id = spl_object_hash($value);
-        $root = $this->root ? $this->root->getWrappedEntity()->getObject() : null;
-        $parent = $this->parent ? $this->parent->getWrappedEntity()->getObject() : null;
-
-        if ($parent && (spl_object_hash($parent) == $id)) {
-            return true;
-        }
-
-        if ($root && (spl_object_hash($root) == $id)) {
-            return true;
-        }
-
-        return false;
-    }
-
-    /**
-     * Parse a 'many' relationship.
-     *
-     * @param string $relation
-     *
-     * @throws MappingException
-     *
-     * @return bool
-     */
-    protected function parseManyRelationship(string $relation): bool
-    {
-        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(string $relation)
-    {
-        $value = $this->getEntityAttribute($relation);
-
-        if (is_scalar($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, string $relation): array
-    {
-        $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 Aggregate
-     */
-    protected function createSubAggregate($entity, string $relation): self
-    {
-        // If root isn't defined, then this is the Aggregate Root
-        $root = is_null($this->root) ? $this : $this->root;
-
-        return new self($entity, $this, $relation, $root);
-    }
-
-    /**
-     * Return the entity map for the current entity.
-     *
-     * @return \Analogue\ORM\EntityMap
-     */
-    public function getEntityMap(): EntityMap
-    {
-        return $this->entityMap;
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function getEntityHash(): string
-    {
-        return $this->getEntityClass().'.'.$this->getEntityKeyValue();
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function getEntityKeyName(): string
-    {
-        return $this->entityMap->getKeyName();
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function getEntityKeyValue()
-    {
-        $keyValue = $this->wrappedEntity->getEntityKeyValue();
-
-        if ($keyValue instanceof ObjectId) {
-            $keyValue = (string) $keyValue;
-        }
-
-        return $keyValue;
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function getEntityClass(): string
-    {
-        return $this->entityMap->getClass();
-    }
-
-    /**
-     * Return the Mapper's entity cache.
-     *
-     * @return \Analogue\ORM\System\Cache\AttributeCache
-     */
-    protected function getEntityCache(): AttributeCache
-    {
-        return $this->getMapper()->getEntityCache();
-    }
-
-    /**
-     * Get a relationship as an aggregated entities' array.
-     *
-     * @param string $name
-     *
-     * @return array
-     */
-    public function getRelationship(string $name): array
-    {
-        if (array_key_exists($name, $this->relationships)) {
-            return $this->relationships[$name];
-        }
-
-        return [];
-    }
-
-    /**
-     * [TO IMPLEMENT].
-     *
-     * @return array
-     */
-    public function getPivotAttributes(): array
-    {
-        return [];
-    }
-
-    /**
-     * Get Non existing related entities from several relationships.
-     *
-     * @param array $relationships
-     *
-     * @return array
-     */
-    public function getNonExistingRelated(array $relationships): array
-    {
-        $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(string $relation): array
-    {
-        $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 string $relation
-     *
-     * @return void
-     */
-    protected function synchronize(string $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(string $relation): array
-    {
-        $cachedRelations = $this->getCachedAttribute($relation);
-
-        if (is_null($cachedRelations)) {
-            return [];
-        }
-
-        $missing = [];
-
-        foreach ($cachedRelations as $hash) {
-            if (!$this->getRelatedAggregateFromHash($hash, $relation)) {
-                $missing[] = $hash;
-            }
-        }
-
-        return $missing;
-    }
-
-    /**
-     * Get Relationships who have dirty attributes / dirty relationships.
-     *
-     * @return array
-     */
-    public function getDirtyRelationships(): array
-    {
-        $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(): bool
-    {
-        return count($this->getDirtyRawAttributes()) > 0;
-    }
-
-    /**
-     * 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(): array
-    {
-        $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 $this->mergeForeignKeysWithAttributes($foreignKeys, $attributes);
-    }
-
-    /**
-     * Merge foreign keys and attributes by comparing their
-     * current value to the cache, and guess the user intent.
-     *
-     * @param array $foreignKeys
-     * @param array $attributes
-     *
-     * @return array
-     */
-    protected function mergeForeignKeysWithAttributes(array $foreignKeys, array $attributes): array
-    {
-        $cachedAttributes = $this->getCachedRawAttributes();
-
-        foreach ($foreignKeys as $fkAttributeKey => $fkAttributeValue) {
-
-            // FK doesn't exist in attributes => we set it
-            if (!array_key_exists($fkAttributeKey, $attributes)) {
-                $attributes[$fkAttributeKey] = $fkAttributeValue;
-                continue;
-            }
-
-            // FK does exists in attributes and is equal => we set it
-            if ($attributes[$fkAttributeKey] === $fkAttributeValue) {
-                $attributes[$fkAttributeKey] = $fkAttributeValue;
-                continue;
-            }
-
-            // ForeignKey exists in attributes array, but the value is different that
-            // the one fetched from the relationship itself.
-
-            // Does it exist in cache
-            if (array_key_exists($fkAttributeKey, $cachedAttributes)) {
-                // attribute is different than cached value, we use it
-                if ($attributes[$fkAttributeKey] !== $cachedAttributes[$fkAttributeKey]) {
-                    continue;
-                }
-                // if not, we use the foreign key value
-                else {
-                    $attributes[$fkAttributeKey] = $fkAttributeValue;
-                }
-            } else {
-                if (is_null($attributes[$fkAttributeKey])) {
-                    $attributes[$fkAttributeKey] = $fkAttributeValue;
-                }
-            }
-        }
-
-        return $attributes;
-    }
-
-    /**
-     * Add Discriminator Column if it doesn't exist on the actual entity.
-     *
-     * @param array $attributes
-     *
-     * @return array
-     */
-    protected function addDiscriminatorColumn(array $attributes): array
-    {
-        $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 FQCN 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(array $attributes): array
-    {
-        // 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 method
-            $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): array
-    {
-        $cachedAttributes = $this->getCache()->get($this->getEntityKeyValue());
-
-        if (is_null($columns)) {
-            return $cachedAttributes;
-        }
-
-        return array_only($cachedAttributes, $columns);
-    }
-
-    /**
-     * Return a single attribute from the cache.
-     *
-     * @param string $key
-     *
-     * @return mixed|null
-     */
-    protected function getCachedAttribute($key)
-    {
-        $cachedAttributes = $this->getCache()->get($this->getEntityKeyValue());
-
-        if (array_key_exists($key, $cachedAttributes)) {
-            return $cachedAttributes[$key];
-        }
-    }
-
-    /**
-     * Convert related Entity's attributes to foreign keys.
-     *
-     * @return array
-     */
-    public function getForeignKeyAttributes(): array
-    {
-        $foreignKeys = [];
-
-        foreach ($this->entityMap->getLocalRelationships() as $relation) {
-
-            // If the actual relationship is a non-loaded proxy, we'll simply retrieve
-            // the foreign key pair without parsing the actual object. This will allow
-            // user to modify the actual related ID's directly by updating the corresponding
-            // attribute.
-            if ($this->isNonLoadedProxy($relation)) {
-                $foreignKeys = $foreignKeys + $this->getForeignKeyAttributesFromNonLoadedRelation($relation);
-                continue;
-            }
-
-            // 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 string $relation
-     *
-     * @throws MappingException
-     *
-     * @return array
-     */
-    protected function getNullForeignKeyFromRelation(string $relation): array
-    {
-        $key = $this->entityMap->getLocalKeys($relation);
-
-        if (is_array($key)) {
-            return $this->entityMap->getEmptyValueForLocalKey($relation);
-        }
-
-        if (is_null($key)) {
-            throw new MappingException("Foreign key for relation $relation cannot be null");
-        }
-
-        return [
-            $key => $this->entityMap->getEmptyValueForLocalKey($relation),
-        ];
-    }
-
-    /**
-     * Return an associative array containing the key-value pair(s) from
-     * the related entity.
-     *
-     * @param string $relation
-     *
-     * @return array
-     */
-    protected function getForeignKeyAttributesFromRelation(string $relation): array
-    {
-        // Call Relationship's method
-        $relationship = $this->entityMap->$relation($this->getEntityObject());
-
-        $relatedAggregate = $this->relationships[$relation][0];
-
-        return $relationship->getForeignKeyValuePair($relatedAggregate->getEntityObject());
-    }
-
-    /**
-     * Return an associative array containing the key-value pair(s) from
-     * the foreign key attribute.
-     *
-     * @param string $relation
-     *
-     * @return array
-     */
-    protected function getForeignKeyAttributesFromNonLoadedRelation(string $relation): array
-    {
-        $keys = $this->entityMap->getLocalKeys($relation);
-
-        // We'll treat single and composite keys (polymorphic) the same way.
-        if (!is_array($keys)) {
-            $keys = [$keys];
-        }
-
-        $foreignKey = [];
-
-        foreach ($keys as $key) {
-            $foreignKey[$key] = $this->getEntityAttribute($key);
-        }
-
-        return $foreignKey;
-    }
-
-    /**
-     * Get foreign key attribute(s) from a parent entity in this
-     * aggregate context.
-     *
-     * @return array
-     */
-    protected function getForeignKeyAttributesFromParent(): array
-    {
-        $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);
-        }
-
-        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(string $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(string $pivotHash, string $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->getEntityKeyValue();
-
-                $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): array
-    {
-        $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|null
-     */
-    protected function getPivotAttributesFromCache(string $pivotHash, string $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, string $relation): array
-    {
-        $related = [];
-
-        foreach ($hashes as $hash) {
-            $aggregate = $this->getRelatedAggregateFromHash($hash, $relation);
-
-            if ($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(string $hash, string $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(string $relation): array
-    {
-        return array_map(function (Aggregate $aggregate) {
-            return $aggregate->getEntityHash();
-        }, $this->relationships[$relation]);
-    }
-
-    /**
-     * Check the existence of an actual relationship.
-     *
-     * @param string $relation
-     *
-     * @return bool
-     */
-    protected function isActualRelationships(string $relation): bool
-    {
-        return array_key_exists($relation, $this->relationships)
-            && count($this->relationships[$relation]) > 0;
-    }
-
-    /**
-     * Return cache instance for the current entity type.
-     *
-     * @return \Analogue\ORM\System\Cache\AttributeCache
-     */
-    protected function getCache(): AttributeCache
-    {
-        return $this->getMapper()->getEntityCache();
-    }
-
-    /**
-     * Get Only Raw Entity attributes which have been modified
-     * since last query.
-     *
-     * @return array
-     */
-    public function getDirtyRawAttributes(): array
-    {
-        $attributes = $this->getRawAttributes();
-
-        $cachedAttributes = $this->getCachedRawAttributes(array_keys($attributes));
-
-        $dirty = [];
-
-        foreach ($attributes as $key => $value) {
-            if ($this->isActualRelation($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 string $key
-     *
-     * @return bool
-     */
-    protected function isActualRelation(string $key): bool
-    {
-        return in_array($key, $this->entityMap->getNonEmbeddedRelationships());
-    }
-
-    /**
-     * Return true if attribute is a non-loaded proxy.
-     *
-     * @param string $key
-     *
-     * @return bool
-     */
-    protected function isNonLoadedProxy(string $key): bool
-    {
-        $relation = $this->getEntityAttribute($key);
-
-        return $relation instanceof ProxyInterface && !$relation->isProxyInitialized();
-    }
-
-    /**
-     * 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): bool
-    {
-        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(): Mapper
-    {
-        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(): bool
-    {
-        return $this->getCache()->has($this->getEntityKeyValue());
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function setEntityAttributes(array $attributes)
-    {
-        $this->wrappedEntity->setEntityAttributes($attributes);
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function getEntityAttributes(): array
-    {
-        return $this->wrappedEntity->getEntityAttributes();
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function setEntityAttribute(string $key, $value)
-    {
-        $this->wrappedEntity->setEntityAttribute($key, $value);
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function getEntityAttribute(string $key)
-    {
-        return $this->wrappedEntity->getEntityAttribute($key);
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function hasAttribute(string $key): bool
-    {
-        return $this->wrappedEntity->hasAttribute($key);
-    }
-
-    /**
-     * Return wrapped entity.
-     *
-     * @return InternallyMappable
-     */
-    public function getWrappedEntity()
-    {
-        return $this->wrappedEntity;
-    }
-
-    /**
-     * Set the lazy loading proxies on the wrapped entity.
-     *
-     * @return void
-     */
-    public function setProxies()
-    {
-        $this->wrappedEntity->setProxies();
-    }
+	/**
+	 * 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, self $parent = null, string $parentRelationship = null, self $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();
+
+		$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(string $relation): bool
+	{
+		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
+	 */
+	protected function isParentOrRoot($value): bool
+	{
+		$id = spl_object_hash($value);
+		$root = $this->root ? $this->root->getWrappedEntity()->getObject() : null;
+		$parent = $this->parent ? $this->parent->getWrappedEntity()->getObject() : null;
+
+		if ($parent && (spl_object_hash($parent) == $id)) {
+			return true;
+		}
+
+		if ($root && (spl_object_hash($root) == $id)) {
+			return true;
+		}
+
+		return false;
+	}
+
+	/**
+	 * Parse a 'many' relationship.
+	 *
+	 * @param string $relation
+	 *
+	 * @throws MappingException
+	 *
+	 * @return bool
+	 */
+	protected function parseManyRelationship(string $relation): bool
+	{
+		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(string $relation)
+	{
+		$value = $this->getEntityAttribute($relation);
+
+		if (is_scalar($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, string $relation): array
+	{
+		$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 Aggregate
+	 */
+	protected function createSubAggregate($entity, string $relation): self
+	{
+		// If root isn't defined, then this is the Aggregate Root
+		$root = is_null($this->root) ? $this : $this->root;
+
+		return new self($entity, $this, $relation, $root);
+	}
+
+	/**
+	 * Return the entity map for the current entity.
+	 *
+	 * @return \Analogue\ORM\EntityMap
+	 */
+	public function getEntityMap(): EntityMap
+	{
+		return $this->entityMap;
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function getEntityHash(): string
+	{
+		return $this->getEntityClass().'.'.$this->getEntityKeyValue();
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function getEntityKeyName(): string
+	{
+		return $this->entityMap->getKeyName();
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function getEntityKeyValue()
+	{
+		$keyValue = $this->wrappedEntity->getEntityKeyValue();
+
+		if ($keyValue instanceof ObjectId) {
+			$keyValue = (string) $keyValue;
+		}
+
+		return $keyValue;
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function getEntityClass(): string
+	{
+		return $this->entityMap->getClass();
+	}
+
+	/**
+	 * Return the Mapper's entity cache.
+	 *
+	 * @return \Analogue\ORM\System\Cache\AttributeCache
+	 */
+	protected function getEntityCache(): AttributeCache
+	{
+		return $this->getMapper()->getEntityCache();
+	}
+
+	/**
+	 * Get a relationship as an aggregated entities' array.
+	 *
+	 * @param string $name
+	 *
+	 * @return array
+	 */
+	public function getRelationship(string $name): array
+	{
+		if (array_key_exists($name, $this->relationships)) {
+			return $this->relationships[$name];
+		}
+
+		return [];
+	}
+
+	/**
+	 * [TO IMPLEMENT].
+	 *
+	 * @return array
+	 */
+	public function getPivotAttributes(): array
+	{
+		return [];
+	}
+
+	/**
+	 * Get Non existing related entities from several relationships.
+	 *
+	 * @param array $relationships
+	 *
+	 * @return array
+	 */
+	public function getNonExistingRelated(array $relationships): array
+	{
+		$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(string $relation): array
+	{
+		$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 string $relation
+	 *
+	 * @return void
+	 */
+	protected function synchronize(string $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(string $relation): array
+	{
+		$cachedRelations = $this->getCachedAttribute($relation);
+
+		if (is_null($cachedRelations)) {
+			return [];
+		}
+
+		$missing = [];
+
+		foreach ($cachedRelations as $hash) {
+			if (!$this->getRelatedAggregateFromHash($hash, $relation)) {
+				$missing[] = $hash;
+			}
+		}
+
+		return $missing;
+	}
+
+	/**
+	 * Get Relationships who have dirty attributes / dirty relationships.
+	 *
+	 * @return array
+	 */
+	public function getDirtyRelationships(): array
+	{
+		$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(): bool
+	{
+		return count($this->getDirtyRawAttributes()) > 0;
+	}
+
+	/**
+	 * 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(): array
+	{
+		$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 $this->mergeForeignKeysWithAttributes($foreignKeys, $attributes);
+	}
+
+	/**
+	 * Merge foreign keys and attributes by comparing their
+	 * current value to the cache, and guess the user intent.
+	 *
+	 * @param array $foreignKeys
+	 * @param array $attributes
+	 *
+	 * @return array
+	 */
+	protected function mergeForeignKeysWithAttributes(array $foreignKeys, array $attributes): array
+	{
+		$cachedAttributes = $this->getCachedRawAttributes();
+
+		foreach ($foreignKeys as $fkAttributeKey => $fkAttributeValue) {
+
+			// FK doesn't exist in attributes => we set it
+			if (!array_key_exists($fkAttributeKey, $attributes)) {
+				$attributes[$fkAttributeKey] = $fkAttributeValue;
+				continue;
+			}
+
+			// FK does exists in attributes and is equal => we set it
+			if ($attributes[$fkAttributeKey] === $fkAttributeValue) {
+				$attributes[$fkAttributeKey] = $fkAttributeValue;
+				continue;
+			}
+
+			// ForeignKey exists in attributes array, but the value is different that
+			// the one fetched from the relationship itself.
+
+			// Does it exist in cache
+			if (array_key_exists($fkAttributeKey, $cachedAttributes)) {
+				// attribute is different than cached value, we use it
+				if ($attributes[$fkAttributeKey] !== $cachedAttributes[$fkAttributeKey]) {
+					continue;
+				}
+				// if not, we use the foreign key value
+				else {
+					$attributes[$fkAttributeKey] = $fkAttributeValue;
+				}
+			} else {
+				if (is_null($attributes[$fkAttributeKey])) {
+					$attributes[$fkAttributeKey] = $fkAttributeValue;
+				}
+			}
+		}
+
+		return $attributes;
+	}
+
+	/**
+	 * Add Discriminator Column if it doesn't exist on the actual entity.
+	 *
+	 * @param array $attributes
+	 *
+	 * @return array
+	 */
+	protected function addDiscriminatorColumn(array $attributes): array
+	{
+		$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 FQCN 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(array $attributes): array
+	{
+		// 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 method
+			$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): array
+	{
+		$cachedAttributes = $this->getCache()->get($this->getEntityKeyValue());
+
+		if (is_null($columns)) {
+			return $cachedAttributes;
+		}
+
+		return array_only($cachedAttributes, $columns);
+	}
+
+	/**
+	 * Return a single attribute from the cache.
+	 *
+	 * @param string $key
+	 *
+	 * @return mixed|null
+	 */
+	protected function getCachedAttribute($key)
+	{
+		$cachedAttributes = $this->getCache()->get($this->getEntityKeyValue());
+
+		if (array_key_exists($key, $cachedAttributes)) {
+			return $cachedAttributes[$key];
+		}
+	}
+
+	/**
+	 * Convert related Entity's attributes to foreign keys.
+	 *
+	 * @return array
+	 */
+	public function getForeignKeyAttributes(): array
+	{
+		$foreignKeys = [];
+
+		foreach ($this->entityMap->getLocalRelationships() as $relation) {
+
+			// If the actual relationship is a non-loaded proxy, we'll simply retrieve
+			// the foreign key pair without parsing the actual object. This will allow
+			// user to modify the actual related ID's directly by updating the corresponding
+			// attribute.
+			if ($this->isNonLoadedProxy($relation)) {
+				$foreignKeys = $foreignKeys + $this->getForeignKeyAttributesFromNonLoadedRelation($relation);
+				continue;
+			}
+
+			// 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 string $relation
+	 *
+	 * @throws MappingException
+	 *
+	 * @return array
+	 */
+	protected function getNullForeignKeyFromRelation(string $relation): array
+	{
+		$key = $this->entityMap->getLocalKeys($relation);
+
+		if (is_array($key)) {
+			return $this->entityMap->getEmptyValueForLocalKey($relation);
+		}
+
+		if (is_null($key)) {
+			throw new MappingException("Foreign key for relation $relation cannot be null");
+		}
+
+		return [
+			$key => $this->entityMap->getEmptyValueForLocalKey($relation),
+		];
+	}
+
+	/**
+	 * Return an associative array containing the key-value pair(s) from
+	 * the related entity.
+	 *
+	 * @param string $relation
+	 *
+	 * @return array
+	 */
+	protected function getForeignKeyAttributesFromRelation(string $relation): array
+	{
+		// Call Relationship's method
+		$relationship = $this->entityMap->$relation($this->getEntityObject());
+
+		$relatedAggregate = $this->relationships[$relation][0];
+
+		return $relationship->getForeignKeyValuePair($relatedAggregate->getEntityObject());
+	}
+
+	/**
+	 * Return an associative array containing the key-value pair(s) from
+	 * the foreign key attribute.
+	 *
+	 * @param string $relation
+	 *
+	 * @return array
+	 */
+	protected function getForeignKeyAttributesFromNonLoadedRelation(string $relation): array
+	{
+		$keys = $this->entityMap->getLocalKeys($relation);
+
+		// We'll treat single and composite keys (polymorphic) the same way.
+		if (!is_array($keys)) {
+			$keys = [$keys];
+		}
+
+		$foreignKey = [];
+
+		foreach ($keys as $key) {
+			$foreignKey[$key] = $this->getEntityAttribute($key);
+		}
+
+		return $foreignKey;
+	}
+
+	/**
+	 * Get foreign key attribute(s) from a parent entity in this
+	 * aggregate context.
+	 *
+	 * @return array
+	 */
+	protected function getForeignKeyAttributesFromParent(): array
+	{
+		$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);
+		}
+
+		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(string $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(string $pivotHash, string $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->getEntityKeyValue();
+
+				$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): array
+	{
+		$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|null
+	 */
+	protected function getPivotAttributesFromCache(string $pivotHash, string $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, string $relation): array
+	{
+		$related = [];
+
+		foreach ($hashes as $hash) {
+			$aggregate = $this->getRelatedAggregateFromHash($hash, $relation);
+
+			if ($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(string $hash, string $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(string $relation): array
+	{
+		return array_map(function (Aggregate $aggregate) {
+			return $aggregate->getEntityHash();
+		}, $this->relationships[$relation]);
+	}
+
+	/**
+	 * Check the existence of an actual relationship.
+	 *
+	 * @param string $relation
+	 *
+	 * @return bool
+	 */
+	protected function isActualRelationships(string $relation): bool
+	{
+		return array_key_exists($relation, $this->relationships)
+			&& count($this->relationships[$relation]) > 0;
+	}
+
+	/**
+	 * Return cache instance for the current entity type.
+	 *
+	 * @return \Analogue\ORM\System\Cache\AttributeCache
+	 */
+	protected function getCache(): AttributeCache
+	{
+		return $this->getMapper()->getEntityCache();
+	}
+
+	/**
+	 * Get Only Raw Entity attributes which have been modified
+	 * since last query.
+	 *
+	 * @return array
+	 */
+	public function getDirtyRawAttributes(): array
+	{
+		$attributes = $this->getRawAttributes();
+
+		$cachedAttributes = $this->getCachedRawAttributes(array_keys($attributes));
+
+		$dirty = [];
+
+		foreach ($attributes as $key => $value) {
+			if ($this->isActualRelation($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 string $key
+	 *
+	 * @return bool
+	 */
+	protected function isActualRelation(string $key): bool
+	{
+		return in_array($key, $this->entityMap->getNonEmbeddedRelationships());
+	}
+
+	/**
+	 * Return true if attribute is a non-loaded proxy.
+	 *
+	 * @param string $key
+	 *
+	 * @return bool
+	 */
+	protected function isNonLoadedProxy(string $key): bool
+	{
+		$relation = $this->getEntityAttribute($key);
+
+		return $relation instanceof ProxyInterface && !$relation->isProxyInitialized();
+	}
+
+	/**
+	 * 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): bool
+	{
+		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(): Mapper
+	{
+		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(): bool
+	{
+		return $this->getCache()->has($this->getEntityKeyValue());
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function setEntityAttributes(array $attributes)
+	{
+		$this->wrappedEntity->setEntityAttributes($attributes);
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function getEntityAttributes(): array
+	{
+		return $this->wrappedEntity->getEntityAttributes();
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function setEntityAttribute(string $key, $value)
+	{
+		$this->wrappedEntity->setEntityAttribute($key, $value);
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function getEntityAttribute(string $key)
+	{
+		return $this->wrappedEntity->getEntityAttribute($key);
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function hasAttribute(string $key): bool
+	{
+		return $this->wrappedEntity->hasAttribute($key);
+	}
+
+	/**
+	 * Return wrapped entity.
+	 *
+	 * @return InternallyMappable
+	 */
+	public function getWrappedEntity()
+	{
+		return $this->wrappedEntity;
+	}
+
+	/**
+	 * Set the lazy loading proxies on the wrapped entity.
+	 *
+	 * @return void
+	 */
+	public function setProxies()
+	{
+		$this->wrappedEntity->setProxies();
+	}
 }

src/Entity.php

Indentation +134 added lines, -134 removed lines

@@ -4,138 +4,138 @@
 
 class Entity extends ValueObject
 {
-    /**
-     * Entities Hidden Attributes, that will be discarded when converting
-     * the entity to Array/Json
-     * (can include any embedded object's attribute).
-     *
-     * @var array
-     */
-    protected $hidden = [];
-
-    /**
-     * Return the entity's attribute.
-     *
-     * @param string $key
-     *
-     * @return mixed
-     */
-    public function __get($key)
-    {
-        if ($this->hasGetMutator($key)) {
-            $method = 'get'.$this->getMutatorMethod($key);
-
-            $attribute = null;
-
-            if (isset($this->attributes[$key])) {
-                $attribute = $this->attributes[$key];
-            }
-
-            return $this->$method($attribute);
-        }
-        if (!array_key_exists($key, $this->attributes)) {
-            return;
-        }
-
-        return $this->attributes[$key];
-    }
-
-    /**
-     * Dynamically set attributes on the entity.
-     *
-     * @param string $key
-     * @param mixed  $value
-     *
-     * @return void
-     */
-    public function __set($key, $value)
-    {
-        if ($this->hasSetMutator($key)) {
-            $method = 'set'.$this->getMutatorMethod($key);
-
-            $this->$method($value);
-        } else {
-            $this->attributes[$key] = $value;
-        }
-    }
-
-    /**
-     * Is a getter method defined ?
-     *
-     * @param string $key
-     *
-     * @return bool
-     */
-    protected function hasGetMutator($key)
-    {
-        return method_exists($this, 'get'.$this->getMutatorMethod($key));
-    }
-
-    /**
-     * Is a setter method defined ?
-     *
-     * @param string $key
-     *
-     * @return bool
-     */
-    protected function hasSetMutator($key)
-    {
-        return method_exists($this, 'set'.$this->getMutatorMethod($key));
-    }
-
-    /**
-     * @param $key
-     *
-     * @return string
-     */
-    protected function getMutatorMethod($key)
-    {
-        $key = ucwords(str_replace(['-', '_'], ' ', $key));
-
-        return str_replace(' ', '', $key).'Attribute';
-    }
-
-    /**
-     * Convert every attributes to value / arrays.
-     *
-     * @return array
-     */
-    public function toArray()
-    {
-        // First, call the trait method before filtering
-        // with Entity specific methods
-        $attributes = $this->attributesToArray($this->attributes);
-
-        foreach ($this->attributes as $key => $attribute) {
-            if (in_array($key, $this->hidden)) {
-                unset($attributes[$key]);
-                continue;
-            }
-            if ($this->hasGetMutator($key)) {
-                $method = 'get'.$this->getMutatorMethod($key);
-                $attributes[$key] = $this->$method($attribute);
-            }
-        }
-
-        return $attributes;
-    }
-
-    /**
-     * Fill an entity with key-value pairs.
-     *
-     * @param array $attributes
-     *
-     * @return void
-     */
-    public function fill(array $attributes)
-    {
-        foreach ($attributes as $key => $attribute) {
-            if ($this->hasSetMutator($key)) {
-                $method = 'set'.$this->getMutatorMethod($key);
-                $this->attributes[$key] = $this->$method($attribute);
-            } else {
-                $this->attributes[$key] = $attribute;
-            }
-        }
-    }
+	/**
+	 * Entities Hidden Attributes, that will be discarded when converting
+	 * the entity to Array/Json
+	 * (can include any embedded object's attribute).
+	 *
+	 * @var array
+	 */
+	protected $hidden = [];
+
+	/**
+	 * Return the entity's attribute.
+	 *
+	 * @param string $key
+	 *
+	 * @return mixed
+	 */
+	public function __get($key)
+	{
+		if ($this->hasGetMutator($key)) {
+			$method = 'get'.$this->getMutatorMethod($key);
+
+			$attribute = null;
+
+			if (isset($this->attributes[$key])) {
+				$attribute = $this->attributes[$key];
+			}
+
+			return $this->$method($attribute);
+		}
+		if (!array_key_exists($key, $this->attributes)) {
+			return;
+		}
+
+		return $this->attributes[$key];
+	}
+
+	/**
+	 * Dynamically set attributes on the entity.
+	 *
+	 * @param string $key
+	 * @param mixed  $value
+	 *
+	 * @return void
+	 */
+	public function __set($key, $value)
+	{
+		if ($this->hasSetMutator($key)) {
+			$method = 'set'.$this->getMutatorMethod($key);
+
+			$this->$method($value);
+		} else {
+			$this->attributes[$key] = $value;
+		}
+	}
+
+	/**
+	 * Is a getter method defined ?
+	 *
+	 * @param string $key
+	 *
+	 * @return bool
+	 */
+	protected function hasGetMutator($key)
+	{
+		return method_exists($this, 'get'.$this->getMutatorMethod($key));
+	}
+
+	/**
+	 * Is a setter method defined ?
+	 *
+	 * @param string $key
+	 *
+	 * @return bool
+	 */
+	protected function hasSetMutator($key)
+	{
+		return method_exists($this, 'set'.$this->getMutatorMethod($key));
+	}
+
+	/**
+	 * @param $key
+	 *
+	 * @return string
+	 */
+	protected function getMutatorMethod($key)
+	{
+		$key = ucwords(str_replace(['-', '_'], ' ', $key));
+
+		return str_replace(' ', '', $key).'Attribute';
+	}
+
+	/**
+	 * Convert every attributes to value / arrays.
+	 *
+	 * @return array
+	 */
+	public function toArray()
+	{
+		// First, call the trait method before filtering
+		// with Entity specific methods
+		$attributes = $this->attributesToArray($this->attributes);
+
+		foreach ($this->attributes as $key => $attribute) {
+			if (in_array($key, $this->hidden)) {
+				unset($attributes[$key]);
+				continue;
+			}
+			if ($this->hasGetMutator($key)) {
+				$method = 'get'.$this->getMutatorMethod($key);
+				$attributes[$key] = $this->$method($attribute);
+			}
+		}
+
+		return $attributes;
+	}
+
+	/**
+	 * Fill an entity with key-value pairs.
+	 *
+	 * @param array $attributes
+	 *
+	 * @return void
+	 */
+	public function fill(array $attributes)
+	{
+		foreach ($attributes as $key => $attribute) {
+			if ($this->hasSetMutator($key)) {
+				$method = 'set'.$this->getMutatorMethod($key);
+				$this->attributes[$key] = $this->$method($attribute);
+			} else {
+				$this->attributes[$key] = $attribute;
+			}
+		}
+	}
 }

src/helpers.php

Indentation +21 added lines, -21 removed lines

@@ -4,29 +4,29 @@
 
 if (!function_exists('analogue')) {
 
-    /**
-     * Return analogue's manager instance.
-     *
-     * @return \Analogue\ORM\System\Manager
-     */
-    function analogue()
-    {
-        return Manager::getInstance();
-    }
+	/**
+	 * Return analogue's manager instance.
+	 *
+	 * @return \Analogue\ORM\System\Manager
+	 */
+	function analogue()
+	{
+		return Manager::getInstance();
+	}
 }
 
 if (!function_exists('mapper')) {
 
-    /**
-     * Create a mapper for a given entity (static alias).
-     *
-     * @param \Analogue\ORM\Mappable|string $entity
-     * @param mixed                         $entityMap
-     *
-     * @return \Analogue\ORM\System\Mapper
-     */
-    function mapper($entity, $entityMap = null)
-    {
-        return Manager::getMapper($entity, $entityMap);
-    }
+	/**
+	 * Create a mapper for a given entity (static alias).
+	 *
+	 * @param \Analogue\ORM\Mappable|string $entity
+	 * @param mixed                         $entityMap
+	 *
+	 * @return \Analogue\ORM\System\Mapper
+	 */
+	function mapper($entity, $entityMap = null)
+	{
+		return Manager::getMapper($entity, $entityMap);
+	}
 }

src/Commands/Command.php

Indentation +24 added lines, -24 removed lines

@@ -7,32 +7,32 @@
 
 abstract class Command
 {
-    /**
-     * The aggregated entity on which the command is executed.
-     *
-     * @var \Analogue\ORM\System\Aggregate
-     */
-    protected $aggregate;
+	/**
+	 * The aggregated entity on which the command is executed.
+	 *
+	 * @var \Analogue\ORM\System\Aggregate
+	 */
+	protected $aggregate;
 
-    /**
-     * Query Builder instance.
-     *
-     * @var \Illuminate\Database\Query\Builder
-     */
-    protected $query;
+	/**
+	 * Query Builder instance.
+	 *
+	 * @var \Illuminate\Database\Query\Builder
+	 */
+	protected $query;
 
-    /**
-     * Command constructor.
-     *
-     * @param Aggregate                          $aggregate
-     * @param \Illuminate\Database\Query\Builder $query
-     */
-    public function __construct(Aggregate $aggregate, Builder $query)
-    {
-        $this->aggregate = $aggregate;
+	/**
+	 * Command constructor.
+	 *
+	 * @param Aggregate                          $aggregate
+	 * @param \Illuminate\Database\Query\Builder $query
+	 */
+	public function __construct(Aggregate $aggregate, Builder $query)
+	{
+		$this->aggregate = $aggregate;
 
-        $this->query = $query->from($aggregate->getEntityMap()->getTable());
-    }
+		$this->query = $query->from($aggregate->getEntityMap()->getTable());
+	}
 
-    abstract public function execute();
+	abstract public function execute();
 }

src/Commands/Delete.php

Indentation +32 added lines, -32 removed lines

@@ -6,36 +6,36 @@
 
 class Delete extends Command
 {
-    /**
-     * Execute the Delete Statement.
-     *
-     * @throws MappingException
-     * @throws \InvalidArgumentException
-     *
-     * @return false|void
-     */
-    public function execute()
-    {
-        $aggregate = $this->aggregate;
-
-        $entity = $aggregate->getEntityObject();
-        $wrappedEntity = $aggregate->getWrappedEntity();
-        $mapper = $aggregate->getMapper();
-
-        if ($mapper->fireEvent('deleting', $wrappedEntity) === false) {
-            return false;
-        }
-
-        $keyName = $aggregate->getEntityMap()->getKeyName();
-
-        $id = $this->aggregate->getEntityKeyValue();
-
-        if (is_null($id)) {
-            throw new MappingException('Executed a delete command on an entity with "null" as primary key');
-        }
-
-        $this->query->where($keyName, '=', $id)->delete();
-
-        $mapper->fireEvent('deleted', $wrappedEntity, false);
-    }
+	/**
+	 * Execute the Delete Statement.
+	 *
+	 * @throws MappingException
+	 * @throws \InvalidArgumentException
+	 *
+	 * @return false|void
+	 */
+	public function execute()
+	{
+		$aggregate = $this->aggregate;
+
+		$entity = $aggregate->getEntityObject();
+		$wrappedEntity = $aggregate->getWrappedEntity();
+		$mapper = $aggregate->getMapper();
+
+		if ($mapper->fireEvent('deleting', $wrappedEntity) === false) {
+			return false;
+		}
+
+		$keyName = $aggregate->getEntityMap()->getKeyName();
+
+		$id = $this->aggregate->getEntityKeyValue();
+
+		if (is_null($id)) {
+			throw new MappingException('Executed a delete command on an entity with "null" as primary key');
+		}
+
+		$this->query->where($keyName, '=', $id)->delete();
+
+		$mapper->fireEvent('deleted', $wrappedEntity, false);
+	}
 }