add relationships sorts

Author: d8vjork

src/Builder.php

@@ -48,4 +48,29 @@ public function jsonApiPaginate()
             ]));
         };
     }
+
+    public function hasJoin()
+    {
+        /**
+         * Check wether join is already on the query instance.
+         *
+         * @param  string  $joinTable
+         * @return bool
+         */
+        return function ($joinTable) {
+            $joins = $this->getQuery()->joins;
+
+            if ($joins === null) {
+                return false;
+            }
+
+            foreach ($joins as $join) {
+                if ($join->table === $joinTable) {
+                    return true;
+                }
+            }
+
+            return false;
+        };
+    }
 }

src/Http/ApplyFieldsToQuery.php

@@ -17,6 +17,8 @@ class ApplyFieldsToQuery implements HandlesRequestQueries
      */
     public function from(RequestQueryObject $request, Closure $next)
     {
+        $request->query->select($request->query->getModel()->qualifyColumn('*'));
+
         if (empty($request->fields()) || empty($request->getAllowedFields())) {
             return $next($request);
         }
@@ -33,7 +35,7 @@ public function from(RequestQueryObject $request, Closure $next)
      */
     protected function applyFields(Builder $query, array $fields)
     {
-        /** @var \OpenSoutheners\LaravelApiable\Contracts\JsonApiable|\Illuminate\Database\Eloquent\Model */
+        /** @var \OpenSoutheners\LaravelApiable\Contracts\JsonApiable|\Illuminate\Database\Eloquent\Model $mainQueryModel */
         $mainQueryModel = $query->getModel();
         $mainQueryResourceType = Apiable::getResourceType($mainQueryModel);
         $queryEagerLoaded = $query->getEagerLoads();
@@ -45,10 +47,10 @@ protected function applyFields(Builder $query, array $fields)
             $matchedFn = match (true) {
                 $mainQueryResourceType === $type => function () use ($query, $mainQueryModel, $columns) {
                     if (! in_array($mainQueryModel->getKeyName(), $columns)) {
-                        $columns[] = $mainQueryModel->getKeyName();
+                        $columns[] = $mainQueryModel->getQualifiedKeyName();
                     }
 
-                    $query->select($columns);
+                    $query->select($mainQueryModel->qualifyColumns($columns));
                 },
                 in_array($typeModel, $queryEagerLoaded) => fn () => $query->with($type, function (Builder $query) use ($queryEagerLoaded, $type, $columns) {
                     $relatedModel = $query->getModel();
@@ -57,7 +59,7 @@ protected function applyFields(Builder $query, array $fields)
                         $columns[] = $relatedModel->getKeyName();
                     }
 
-                    $queryEagerLoaded[$type]($query->select($columns));
+                    $queryEagerLoaded[$type]($query->select($relatedModel->qualifyColumns($columns)));
                 }),
                 default => fn () => null,
             };

src/Http/ApplySortsToQuery.php

@@ -4,6 +4,7 @@
 
 use Closure;
 use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Database\Eloquent\Relations\BelongsToMany;
 use OpenSoutheners\LaravelApiable\Contracts\HandlesRequestQueries;
 
 class ApplySortsToQuery implements HandlesRequestQueries
@@ -39,9 +40,69 @@ public function from(RequestQueryObject $request, Closure $next)
     protected function applySorts(Builder $query, array $sorts)
     {
         foreach ($sorts as $attribute => $direction) {
-            $query->orderBy($attribute, $direction);
+            $query->orderBy($this->getQualifiedAttribute($query, $attribute, $direction), $direction);
         }
 
         return $query;
     }
+
+    /**
+     * Get attribute adding a join when sorting by relationship or a column sort.
+     *  
+     * @param \Illuminate\Database\Eloquent\Builder $query
+     * @param string $attribute
+     * @param string $direction
+     * @return string|\Closure|\Illuminate\Database\Eloquent\Builder
+     */
+    protected function getQualifiedAttribute(Builder $query, string $attribute, string $direction)
+    {
+        $queryModel = $query->getModel();
+
+        if (! str_contains($attribute, '.')) {
+            return $queryModel->qualifyColumn($attribute);
+        }
+
+        [$relationship, $column] = explode('.', $attribute);
+
+        if (! method_exists($queryModel, $relationship)) {
+            return $queryModel->qualifyColumn($column);
+        }
+
+        /** @var \Illuminate\Database\Eloquent\Relations\HasOneOrMany|\Illuminate\Database\Eloquent\Relations\BelongsTo|\Illuminate\Database\Eloquent\Relations\BelongsToMany $relationshipMethod */
+        $relationshipMethod = call_user_func([$queryModel, $relationship]);
+        $relationshipModel = $relationshipMethod->getRelated();
+
+        if (is_a($relationshipMethod, BelongsToMany::class)) {
+            return $relationshipModel->newQuery()
+                ->select($column)
+                ->join($relationshipMethod->getTable(), $relationshipMethod->getRelatedPivotKeyName(), $relationshipModel->getQualifiedKeyName())
+                ->whereColumn($relationshipMethod->getQualifiedForeignPivotKeyName(), $queryModel->getQualifiedKeyName())
+                ->orderBy($column, $direction)
+                ->limit(1);
+        }
+
+        $relationshipTable = $relationshipModel->getTable();
+        $joinAsRelationshipTable = $relationshipTable;
+
+        if ($relationshipTable === $queryModel->getTable()) {
+            $joinAsRelationshipTable = "{$relationship}_{$relationshipTable}";
+        }
+
+        $joinName = $relationshipTable . ($joinAsRelationshipTable !== $relationshipTable ? " as {$joinAsRelationshipTable}" : '');
+
+        $query->select($queryModel->qualifyColumn('*'));
+
+        $query->when(
+            ! $query->hasJoin($joinName),
+            fn (Builder $query) => $query->join(
+                $joinName,
+                "{$joinAsRelationshipTable}.{$relationshipMethod->getOwnerKeyName()}",
+                '=',
+                $relationshipMethod->getQualifiedForeignKeyName()
+            )
+        );
+
+        return "{$joinAsRelationshipTable}.{$column}";
+
+    }
 }

tests/Http/JsonApiResponseTest.php

@@ -247,6 +247,82 @@ public function testSortingFieldsAsAscendant()
         });
     }
 
+    public function testSortingBelongsToManyRelationshipFieldAsAscendant()
+    {
+        Route::get('/', function () {
+            return JsonApiResponse::from(Post::class)
+                ->allowing([
+                    AllowedSort::ascendant('tags.name'),
+                ]);
+        });
+
+        $response = $this->getJson('/?sort=tags.name');
+
+        $response->assertJsonApi(function (AssertableJsonApi $assert) {
+            $assert->isCollection();
+            
+            $assert->at(0)->hasAttribute('title', 'Hola mundo');
+            $assert->at(1)->hasAttribute('title', 'My first test');
+        });
+    }
+
+    public function testSortingBelongsToManyRelationshipFieldAsDescendant()
+    {
+        Route::get('/', function () {
+            return JsonApiResponse::from(Post::class)
+                ->allowing([
+                    AllowedSort::descendant('tags.name'),
+                ]);
+        });
+
+        $response = $this->getJson('/?sort=-tags.name');
+
+        $response->assertJsonApi(function (AssertableJsonApi $assert) {
+            $assert->isCollection();
+            
+            $assert->at(0)->hasAttribute('title', 'Hello world');
+            $assert->at(1)->hasAttribute('title', 'Y esto en español');
+        });
+    }
+
+    public function testSortingBelongsToRelationshipFieldAsAscendant()
+    {
+        Route::get('/', function () {
+            return JsonApiResponse::from(Post::class)
+                ->allowing([
+                    AllowedSort::ascendant('author.name'),
+                ]);
+        });
+
+        $response = $this->getJson('/?sort=author.name');
+
+        $response->assertJsonApi(function (AssertableJsonApi $assert) {
+            $assert->isCollection();
+            
+            $assert->at(0)->hasAttribute('title', 'My first test');
+            $assert->at(1)->hasAttribute('title', 'Y esto en español');
+        });
+    }
+
+    public function testSortingBelongsToRelationshipFieldAsDescendant()
+    {
+        Route::get('/', function () {
+            return JsonApiResponse::from(Post::class)
+                ->allowing([
+                    AllowedSort::descendant('author.name'),
+                ]);
+        });
+
+        $response = $this->getJson('/?sort=-author.name');
+
+        $response->assertJsonApi(function (AssertableJsonApi $assert) {
+            $assert->isCollection();
+            
+            $assert->at(0)->hasAttribute('title', 'Hello world');
+            $assert->at(1)->hasAttribute('title', 'Y esto en español');
+        });
+    }
+
     public function testAddingFieldsAsModelAppendedAttributes()
     {
         Route::get('/', function () {