Merge pull request #93 from Lomkit/fix/belongs-to-many-search-query

Fix/belongs to many search query

Author: GautierDele

Diff for: README.md

@@ -92,4 +92,3 @@ Here is a quick look at what you can do using API search method:
 - Refactor the response class
 - Plain text search using Laravel Scout
 - Alias for includes / aggregates
-- Add accurate examples in auto documentation

Diff for: src/Concerns/Resource/Relationable.php

@@ -27,7 +27,9 @@ public function relation($name)
             return $relation->relation === $relationName;
         });
 
-        if ($isSubRelation && Str::contains($nestedRelation = Str::after($name, '.'), '.')) {
+        if ($isSubRelation) {
+            $nestedRelation = Str::after($name, '.');
+
             return $relation->resource()->relation($nestedRelation);
         }
 

Diff for: src/Query/Traits/PerformSearch.php

@@ -85,7 +85,9 @@ public function filter($field, $operator, $value, $type = 'and', $nested = null)
 
         // Here we assume the user has asked a relation filter
         if (Str::contains($field, '.')) {
-            $relation = $this->resource->relation($field);
+            $relation = $this->resource->relation(
+                Str::beforeLast($field, '.')
+            );
 
             return $relation->filter($this->queryBuilder, $field, $operator, $value, $type, function ($query) use ($relation) {
                 $relation->applySearchQuery($query);

Diff for: src/helpers.php

@@ -10,8 +10,8 @@
      */
     function relation_without_pivot(string $relation)
     {
-        return \Illuminate\Support\Str::contains($relation, '.pivot.') ?
-            \Illuminate\Support\Str::replaceLast('pivot.', '', $relation) :
+        return \Illuminate\Support\Str::contains($relation, '.pivot.') || \Illuminate\Support\Str::endsWith($relation, '.pivot') ?
+            \Illuminate\Support\Str::replaceLast('.pivot', '', $relation) :
             $relation;
     }
 }

Diff for: tests/Feature/Controllers/SearchIncludingRelationshipsOperationsTest.php

@@ -2,8 +2,10 @@
 
 namespace Lomkit\Rest\Tests\Feature\Controllers;
 
+use Illuminate\Support\Arr;
 use Illuminate\Support\Facades\Gate;
 use Lomkit\Rest\Http\Requests\RestRequest;
+use Lomkit\Rest\Relations\Relation;
 use Lomkit\Rest\Tests\Feature\TestCase;
 use Lomkit\Rest\Tests\Support\Database\Factories\BelongsToManyRelationFactory;
 use Lomkit\Rest\Tests\Support\Database\Factories\BelongsToRelationFactory;
@@ -259,6 +261,76 @@ public function test_getting_a_list_of_resources_including_belongs_to_has_many_r
         );
     }
 
+    public function test_getting_a_list_of_resources_including_distant_relation_with_intermediary_search_query_condition(): void
+    {
+        $matchingModel = ModelFactory::new()->create(
+            ['number' => 1]
+        )->fresh();
+
+        $belongsToMany = BelongsToManyRelationFactory::new()
+            ->for($matchingModel)
+            ->create();
+
+        $matchingModel2 = ModelFactory::new()
+            ->afterCreating(function (Model $model) use ($belongsToMany) {
+                $model->belongsToManyQueryChangesRelation()
+                    ->attach($belongsToMany);
+            })
+            ->create()->fresh();
+
+        Gate::policy(Model::class, GreenPolicy::class);
+        Gate::policy(BelongsToManyRelation::class, GreenPolicy::class);
+
+        $response = $this->post(
+            '/api/models/search',
+            [
+                'search' => [
+                    'includes' => [
+                        ['relation' => 'belongsToManyRelation.model'],
+                    ],
+                ],
+            ],
+            ['Accept' => 'application/json']
+        );
+
+        $matchingModelBelongsToManyQueryChangesRelations = $matchingModel2->belongsToManyQueryChangesRelation;
+
+        $this->assertResourcePaginated(
+            $response,
+            [$matchingModel, $matchingModel2],
+            new ModelResource(),
+            [
+                [
+                    'belongs_to_many_relation' => [],
+                ],
+                [
+                    'belongs_to_many_relation' => $matchingModelBelongsToManyQueryChangesRelations
+                            ->map(function (BelongsToManyRelation $belongsToManyRelation) {
+                                return array_merge(
+                                    $belongsToManyRelation
+                                        ->only((new BelongsToManyResource())->getFields(app()->make(RestRequest::class))),
+                                    [
+                                        'model'                 => null,
+                                        'belongs_to_many_pivot' => Arr::only(
+                                            $belongsToManyRelation
+                                                ->belongs_to_many_pivot
+                                                ->toArray(),
+                                            Arr::first(
+                                                (new ModelResource())->getRelations(app()->make(RestRequest::class)),
+                                                function (Relation $relation) {
+                                                    return $relation->relation === 'belongsToManyRelation';
+                                                }
+                                            )->getPivotFields()
+                                        ),
+                                    ]
+                                );
+                            })
+                            ->toArray(),
+                ],
+            ]
+        );
+    }
+
     public function test_getting_a_list_of_resources_including_has_one_relation(): void
     {
         $matchingModel = ModelFactory::new()

Diff for: tests/Support/Database/migrations/2023_10_00_000000_add_model_id_to_belongs_to_many_relations_table.php

@@ -0,0 +1,19 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class() extends Migration {
+    /**
+     * Run the migrations.
+     *
+     * @return void
+     */
+    public function up()
+    {
+        Schema::table('belongs_to_many_relations', function (Blueprint $table) {
+            $table->foreignIdFor(\Lomkit\Rest\Tests\Support\Models\Model::class)->nullable()->constrained();
+        });
+    }
+};

Diff for: tests/Support/Models/BelongsToManyRelation.php

@@ -10,4 +10,9 @@ public function models()
     {
         return $this->belongsToMany(\Lomkit\Rest\Tests\Support\Models\Model::class);
     }
+
+    public function model()
+    {
+        return $this->belongsTo(Model::class);
+    }
 }

Diff for: tests/Support/Models/Model.php

@@ -25,6 +25,13 @@ public function belongsToRelation()
         return $this->belongsTo(BelongsToRelation::class);
     }
 
+    public function belongsToManyQueryChangesRelation()
+    {
+        return $this->belongsToMany(BelongsToManyRelation::class)
+            ->as('belongs_to_many_pivot')
+            ->withPivot('created_at', 'updated_at', 'number');
+    }
+
     public function hasOneThroughRelation()
     {
         return $this->hasOneThrough(HasOneThroughRelation::class, HasOneRelation::class);

Diff for: tests/Support/Rest/Resources/BelongsToManyResource.php

@@ -5,6 +5,7 @@
 use Lomkit\Rest\Concerns\Resource\DisableGates;
 use Lomkit\Rest\Http\Requests\RestRequest;
 use Lomkit\Rest\Http\Resource;
+use Lomkit\Rest\Relations\BelongsTo;
 use Lomkit\Rest\Tests\Support\Models\BelongsToManyRelation;
 
 class BelongsToManyResource extends Resource
@@ -15,7 +16,9 @@ class BelongsToManyResource extends Resource
 
     public function relations(RestRequest $request): array
     {
-        return [];
+        return [
+            BelongsTo::make('model', ModelQueryChangedResource::class),
+        ];
     }
 
     public function fields(RestRequest $request): array

Diff for: tests/Support/Rest/Resources/ModelQueryChangedResource.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace Lomkit\Rest\Tests\Support\Rest\Resources;
+
+class ModelQueryChangedResource extends ModelResource
+{
+    public function searchQuery(\Lomkit\Rest\Http\Requests\RestRequest $request, \Illuminate\Contracts\Database\Eloquent\Builder $query)
+    {
+        $query = parent::searchQuery($request, $query);
+
+        $query->where('number', 10000);
+
+        return $query;
+    }
+}