Nested relations support added

Author: sleeping-owl

CHANGELOG

@@ -0,0 +1,7 @@
+CHANGELOG
+=========
+
+2014-11-12, v1.0.0
+------------------
+
+* Initial Version

README.md

@@ -1,18 +1,104 @@
-## Package to convert BelongsTo subqueries into one query with left join
+## Package to convert Eloquent BelongsTo subqueries into one query with left join
 
 ### Usage
 
+Mark relation you want to convert into left join using `->references($relations)` method or `Model::includes($relations)` method:
+
 ```php
-\Model::with('other')->references('other')->orderBy('other.title', 'asc')->get();
- # this will make one sql-query with left join of 'other' relation. result object will be the same.
+Model::with('other')->references('other')->orderBy('other.title', 'asc')->get();
+ # this will make one sql-query with left join of 'other' relation
+ # result object will be the same object
+ 
+Model::includes('other', 'another')->where('other.title', '=', 'my title')->get();
+ # will be the same as Model::with('other', 'another')->references('other', 'another')->…
 
-\Model::with('other')->orderBy('field', 'asc')->get();
+Model::with('other')->orderBy('field', 'asc')->get();
  # this will work with default behaviour (perform 2 sql-queries)
 ```
 
+### Object Structure
+
+You will get the same object if you will use `includes()` method. For example:
+
+```php
+StreetImage::includes('street')->first()
+```
+
+will return:
+
+```
+object(StreetImage) {
+	<all street image attributes>
+	street: object(Street) {
+		<all street attributes>
+	}
+}
+```
+
+Structure will be the same even if you using nested relations:
+
+```php
+StreetImage::includes('street.district')->first();
+```
+
+will return:
+
+```
+object(StreetImage) {
+	<all street image attributes>
+	street: object(Street) {
+		<all street attributes>
+		district: object(District) {
+			<all district attributes>
+		}
+	}
+}
+```
+
+### Nested Relations
+
+```php
+StreetImage::includes('street.type', 'street.district')->first();
+```
+
+will perform a following sql-query (*<…> will be replaced with all table columns*):
+
+```sql
+select
+	`streets`.`<…>` as `_foreign_street.<…>`, 
+	`street_types`.`<…>` as `_foreign_street._foreign_type.<…>`, 
+	`districts`.`<…>` as `_foreign_street._foreign_district.<…>`, 
+	`street_images`.* 
+from 
+	`street_images` 
+left join 
+	`streets` on `streets`.`id` = `street_images`.`street_id` 
+left join 
+	`street_types` on `street_types`.`id` = `streets`.`street_type_id` 
+left join 
+	`districts` on `districts`.`id` = `streets`.`district_id` 
+order by `sort` asc
+limit 1
+```
+instead of performing 4 sql-queries by default Eloquent behaviour:
+
+```sql
+select `street_images`.* from `street_images` order by `sort` asc limit 1
+
+select `streets`.* from `streets` where `streets`.`id` in (?) order by `title` asc
+
+select * from `street_types` where `street_types`.`id` in (?) order by `title` asc
+
+select `streets`.* from `streets` where `streets`.`id` in (?) order by `title` asc
+```
+
 ### Installation
 
-1. Use `\SleepingOwl\WithJoin\WithJoinTrait` trait in your eloquent model:
+ 1. Require this package in your composer.json and run composer update (or run `composer require sleeping-owl/with-join:1.x` directly):
+
+		"sleeping-owl/with-join": "1.*"
+
+2. Use `\SleepingOwl\WithJoin\WithJoinTrait` trait in every eloquent model you want to use this package features:
 
 	```php
 	class StreetImage extends \Eloquent
@@ -21,12 +107,7 @@
 	}
 	```
 
-2. That`s all.
-
-### Todo
-
-- Nested relations support
-- Other relation types support
+3. That`s all.
 
 ## Copyright and License
 

composer.json

@@ -1,6 +1,6 @@
 {
     "name": "sleeping-owl/with-join",
-    "description": "Package to convert BelongsTo subqueries into one query with left join.",
+    "description": "Package to convert Eloquent BelongsTo subqueries into one query with left join.",
 	"keywords": ["laravel", "activerecord", "eloquent", "with", "join"],
 	"license": "MIT",
     "authors": [

src/SleepingOwl/WithJoin/WithJoinEloquentBuilder.php

@@ -19,15 +19,16 @@ public function getModels($columns = ['*'])
 	{
 		foreach ($this->eagerLoad as $name => $constraints)
 		{
-			if ($this->isNestedRelation($name) || count($this->nestedRelations($name)) > 0)
+			if ($this->isNestedRelation($name))
 			{
 				continue;
 			}
 			$relation = $this->getRelation($name);
 			if ($this->isReferencedInQuery($name) && $this->isRelationSupported($relation))
 			{
 				$this->disableEagerLoad($name);
-				$this->addJoinToQuery($name, $relation);
+				$this->addJoinToQuery($name, $this->model->getTable(), $relation);
+				$this->addNestedRelations($name, $relation);
 			}
 		}
 		$this->selectFromQuery($this->model->getTable(), '*');
@@ -43,18 +44,34 @@ protected function isNestedRelation($relation)
 		return strpos($relation, '.') !== false;
 	}
 
+	/**
+	 * @param $name
+	 */
+	protected function addNestedRelations($name, BelongsTo $relation)
+	{
+		$nestedRelations = $this->nestedRelations($name);
+		if (count($nestedRelations) <= 0) return;
+
+		$class = $relation->getRelated();
+		foreach ($nestedRelations as $nestedName => $nestedConstraints)
+		{
+			$relation = $class->$nestedName();
+			$this->addJoinToQuery($nestedName, $class->getTable(), $relation, $name . '._foreign_');
+		}
+	}
+
 	/**
 	 * @param $name
 	 * @param BelongsTo $relation
 	 */
-	protected function addJoinToQuery($name, BelongsTo $relation)
+	protected function addJoinToQuery($name, $currentTable, BelongsTo $relation, $prefix = '')
 	{
 		$foreignTable = $relation->getRelated()->getTable();
 		$columns = $this->getColumns($foreignTable);
-		$this->query->leftJoin($foreignTable . ' as ' . $name, $name . '.' . $relation->getOtherKey(), '=', $relation->getForeignKey());
+		$this->query->leftJoin($foreignTable, $foreignTable . '.' . $relation->getOtherKey(), '=', $currentTable . '.' . $relation->getForeignKey());
 		foreach ($columns as $column)
 		{
-			$this->selectFromQuery($name, $column, '_foreign_' . $name . '.' . $column);
+			$this->selectFromQuery($foreignTable, $column, '_foreign_' . $prefix . $name . '.' . $column);
 		};
 	}
 
@@ -64,7 +81,18 @@ protected function addJoinToQuery($name, BelongsTo $relation)
 	 */
 	protected function isReferencedInQuery($name)
 	{
-		return in_array($name, $this->references);
+		if (in_array($name, $this->references))
+		{
+			return true;
+		}
+		foreach ($this->references as $reference)
+		{
+			if (strpos($reference, $name . '.') === 0)
+			{
+				return true;
+			}
+		}
+		return false;
 	}
 
 	/**
@@ -91,7 +119,10 @@ protected function disableEagerLoad($name)
 	 */
 	protected function selectFromQuery($table, $column, $as = null)
 	{
-		$string = implode('.', [$table, $column]);
+		$string = implode('.', [
+			$table,
+			$column
+		]);
 		if ( ! is_null($as))
 		{
 			$string .= ' as ' . $as;

src/SleepingOwl/WithJoin/WithJoinTrait.php

@@ -1,37 +1,35 @@
 <?php namespace SleepingOwl\WithJoin;
 
 use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Support\Arr;
 
-trait WithJoinTrait {
+trait WithJoinTrait
+{
 
 	/**
 	 * @param array $attributes
 	 * @return static
 	 */
 	public function newFromBuilder($attributes = [])
 	{
+		$attributes = (array) $attributes;
 		$prefix = '_foreign_';
 		$foreignData = [];
 		foreach ($attributes as $key => $value)
 		{
 			if (strpos($key, $prefix) === 0)
 			{
-				unset($attributes->$key);
+				unset($attributes[$key]);
 				$key = substr($key, strlen($prefix));
-				list($table, $key) = explode('.', $key, 2);
-				if ( ! isset($foreignData[$table]))
-				{
-					$foreignData[$table] = [];
-				}
-				$foreignData[$table][$key] = $value;
+				Arr::set($foreignData, $key, $value);
 			}
 		}
 		foreach ($foreignData as $relation => $data)
 		{
 			/** @var BelongsTo $relationInstance */
 			$relationInstance = $this->$relation();
 			$foreign = $relationInstance->getRelated()->newFromBuilder($data);
-			$attributes->$relation = $foreign;
+			$attributes[$relation] = $foreign;
 		}
 		return parent::newFromBuilder($attributes);
 	}
@@ -48,7 +46,7 @@ public function newEloquentBuilder($query)
 	/**
 	 * Being querying a model with eager loading.
 	 *
-	 * @param  array|string  $relations
+	 * @param  array|string $relations
 	 * @return \Illuminate\Database\Eloquent\Builder|WithJoinEloquentBuilder|static
 	 */
 	public static function with($relations)
@@ -57,4 +55,16 @@ public static function with($relations)
 		return parent::with($relations);
 	}
 
+	/**
+	 * @param  array|string $relations
+	 * @return \Illuminate\Database\Eloquent\Builder|WithJoinEloquentBuilder|static
+	 */
+	public static function includes($relations)
+	{
+		if (is_string($relations)) $relations = func_get_args();
+		$query = parent::with($relations);
+		$query->references($relations);
+		return $query;
+	}
+
 }