Merge pull request #152 from Lomkit/feature/laravel-12

⬆️ Laravel 12 compatibility

Author: GautierDele

.github/workflows/tests.yml

@@ -14,12 +14,9 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        php-version: [ '8.1', '8.2', '8.3' ]
-        laravel-version: [ '^10.0', '^11.0' ]
+        php-version: [ '8.2', '8.3', '8.4' ]
+        laravel-version: [ '^11.0', '^12.0' ]
         database: [ 'sqlite', 'mysql', 'pgsql' ]
-        exclude:
-          - php-version: '8.1'
-            laravel-version: '^11.0'
 
     name: Tests on PHP ${{ matrix.php-version }} with Laravel ${{ matrix.laravel-version }} and ${{ matrix.database }}
 

README.md

@@ -6,7 +6,7 @@ Laravel Rest Api is an elegant way to expose your app through an API, it takes f
 
 ## Requirements
 
-PHP 8.1+ and Laravel 10.0+
+PHP 8.2+ and Laravel 11+
 
 ## Documentation, Installation, and Usage Instructions
 

composer.json

@@ -10,15 +10,15 @@
     }
   ],
   "require": {
-    "php": "^8.0",
+    "php": "^8.2",
     "ext-json": "*",
-    "laravel/framework": "^10.0|^11.0"
+    "laravel/framework": "^11|^12"
   },
   "require-dev": {
     "guzzlehttp/guzzle": "^6.0|^7.0",
-    "orchestra/testbench": "^8.5|^9.0",
-    "phpunit/phpunit": "^8.0|^9.0|^10.0|^11.0",
-    "laravel/scout": "^10.0|^11.0"
+    "orchestra/testbench": "^9|^10",
+    "phpunit/phpunit": "^10|^11",
+    "laravel/scout": "^10"
   },
   "autoload": {
     "psr-4": {

src/Actions/DispatchAction.php

@@ -3,6 +3,7 @@
 namespace Lomkit\Rest\Actions;
 
 use Illuminate\Contracts\Queue\ShouldQueue;
+use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Support\Collection;
 use Illuminate\Support\Facades\Bus;
 use Illuminate\Support\Facades\DB;
@@ -109,32 +110,50 @@ public function dispatch($chunkCount)
     }
 
     /**
-     * Dispatch the given action.
+     * Processes models in chunks using classic mode and dispatches an action for each set.
      *
-     * @param int $chunkCount
+     * The method builds a search query for the resource associated with the current request, applying
+     * search criteria from the request input and removing any default result limits. It then processes
+     * the query results in chunks (of size $chunkCount) by invoking the forModels method on each chunk.
+     * Finally, it returns the query limit if one is set; otherwise, it returns the total count of models.
      *
-     * @return int
+     * @param int $chunkCount The number of models to process per chunk.
+     *
+     * @return int The effective result limit if set, or the total count of models.
      */
     public function handleClassic(int $chunkCount)
     {
+        /**
+         * @var Builder $searchQuery
+         */
         $searchQuery =
             app()->make(QueryBuilder::class, ['resource' => $this->request->resource, 'query' => null])
+                ->disableDefaultLimit()
                 ->search($this->request->input('search', []));
 
+        $limit = $searchQuery->toBase()->limit;
+
         $searchQuery
             ->clone()
             ->chunk(
                 $chunkCount,
-                function ($chunk) {
-                    return $this->forModels(
-                        \Illuminate\Database\Eloquent\Collection::make(
-                            $chunk
-                        )
-                    );
+                function ($chunk, $page) use ($limit, $chunkCount) {
+                    $collection = \Illuminate\Database\Eloquent\Collection::make($chunk);
+
+                    // This is to remove for Laravel 12, chunking with limit does not work
+                    // in Laravel 11
+                    if (!is_null($limit) && $page * $chunkCount >= $limit) {
+                        $collection = $collection->take($limit - ($page - 1) * $chunkCount);
+                        $this->forModels($collection);
+
+                        return false;
+                    }
+
+                    return $this->forModels($collection);
                 }
             );
 
-        return $searchQuery->count();
+        return $limit ?? $searchQuery->count();
     }
 
     /**
@@ -202,7 +221,7 @@ protected function dispatchSynchronouslyForCollection(Collection $models)
      *
      * @return $this
      */
-    protected function addQueuedActionJob(Collection $models)
+    protected function addQueuedActionJob(Collection $models): self
     {
         $job = new CallRestApiAction($this->action, $this->fields, $models);
 

src/Http/Response.php

@@ -41,6 +41,18 @@ protected function buildGatesForModel(Model $model, Resource $resource, array $g
         );
     }
 
+    /**
+     * Convert an Eloquent model into an array representation for the HTTP response.
+     *
+     * This method transforms the given model by selecting only the specified attributes and aggregates as defined in the request parameters or resource. If authorization gating is enabled and gate parameters are provided, it appends the corresponding authorization data. Additionally, it recursively processes any loaded relations—returning pivot data when applicable and mapping related models (or collections of models) using the resource’s configuration.
+     *
+     * @param Model         $model        The Eloquent model instance to be converted.
+     * @param resource      $resource     The resource defining the fields and structure of the response.
+     * @param array         $requestArray Request parameters that control field selection, aggregates, and authorization gates.
+     * @param Relation|null $relation     Optional relation context for processing nested relationships.
+     *
+     * @return array The structured array representation of the model, including attributes and recursively processed relations.
+     */
     public function modelToResponse(Model $model, Resource $resource, array $requestArray, Relation $relation = null)
     {
         $currentRequestArray = $relation === null ? $requestArray : collect($requestArray['includes'] ?? [])
@@ -72,7 +84,7 @@ public function modelToResponse(Model $model, Resource $resource, array $request
                 })
                 ->toArray(),
             collect($model->getRelations())
-                ->mapWithKeys(function ($modelRelation, $relationName) use ($requestArray, $currentRequestArray, $relation, $resource) {
+                ->mapWithKeys(function ($modelRelation, $relationName) use ($requestArray, $relation, $resource) {
                     $key = Str::snake($relationName);
 
                     if (is_null($modelRelation)) {
@@ -89,15 +101,8 @@ public function modelToResponse(Model $model, Resource $resource, array $request
 
                     $relationConcrete = $resource->relation($relationName);
                     $relationResource = $relationConcrete->resource();
-                    $requestArrayRelation = collect($currentRequestArray['includes'] ?? [])
-                        ->first(function ($include) use ($relationName) {
-                            return preg_match('/(?:\.\b)?'.$relationName.'\b/', $include['relation']);
-                        });
-
-                    // We reapply the limits in case of BelongsToManyRelation where we can't apply limits easily
-                    if ($modelRelation instanceof Collection) {
-                        $modelRelation = $modelRelation->take($requestArrayRelation['limit'] ?? 50);
-                    } elseif ($modelRelation instanceof Model) {
+
+                    if ($modelRelation instanceof Model) {
                         return [
                             $key => $this->modelToResponse(
                                 $modelRelation,

src/Query/Builder.php

@@ -44,6 +44,13 @@ public function __construct(Resource $resource, \Illuminate\Database\Eloquent\Bu
      */
     protected bool $disableSecurity = false;
 
+    /**
+     * Determine if default limit should be applied.
+     *
+     * @var bool
+     */
+    protected bool $disableDefaultLimit = false;
+
     /**
      * The query builder instance.
      *
@@ -56,13 +63,39 @@ public function newQueryBuilder($parameters)
         return app()->make(QueryBuilder::class, $parameters);
     }
 
+    /**
+     * Sets the security flag for the query builder.
+     *
+     * Toggling this flag disables or enables security checks during query building.
+     *
+     * @param bool $disable Set to true to disable security checks (default), or false to enable them.
+     *
+     * @return $this The current instance for method chaining.
+     */
     public function disableSecurity($disable = true)
     {
         $this->disableSecurity = $disable;
 
         return $this;
     }
 
+    /**
+     * Set whether to disable applying the default query limit.
+     *
+     * When disabled, the query will not enforce any default limit on the number of results,
+     * allowing retrieval of all matching records unless a custom limit is specified.
+     *
+     * @param bool $disable True to disable the default limit, false to enable it.
+     *
+     * @return self Returns the current instance for chaining.
+     */
+    public function disableDefaultLimit($disable = true)
+    {
+        $this->disableDefaultLimit = $disable;
+
+        return $this;
+    }
+
     /**
      * Convert the query builder to an Eloquent query builder.
      *

src/Query/ScoutBuilder.php

@@ -13,11 +13,23 @@ class ScoutBuilder implements QueryBuilder
     use Conditionable;
 
     /**
-     * Perform a search operation on the query builder.
+     * Executes a search query using Laravel Scout with customizable criteria.
      *
-     * @param array $parameters An array of search parameters.
+     * This method configures the underlying search builder by setting the query text,
+     * and conditionally applying filters, sort orders, and additional instructions based
+     * on the provided parameters. It also enforces a limit on the number of results,
+     * defaulting to 50 if no limit is specified. Any extra parameters, after excluding
+     * reserved keys (filters, instructions, sorts, text, and limit), are forwarded to the
+     * underlying search operation.
      *
-     * @return \Laravel\Scout\Builder The modified query builder.
+     * @param array $parameters An associative array of search criteria, which may include:
+     *                          - 'text': The search query string.
+     *                          - 'filters': An array of filter conditions.
+     *                          - 'sorts': An array of sorting directives.
+     *                          - 'instructions': Additional query instructions.
+     *                          - 'limit': Maximum number of results to return (defaults to 50 if not provided).
+     *
+     * @return \Laravel\Scout\Builder The configured Scout query builder.
      */
     public function search(array $parameters = [])
     {
@@ -37,6 +49,8 @@ public function search(array $parameters = [])
             $this->applyInstructions($parameters['instructions']);
         });
 
+        $this->queryBuilder->take($parameters['limit'] ?? 50);
+
         $this->queryBuilder
             ->query(function (Builder $query) use ($parameters) {
                 app()->make(QueryBuilder::class, ['query' => $query, 'resource' => $this->resource])
@@ -48,6 +62,7 @@ public function search(array $parameters = [])
                                 'instructions',
                                 'sorts',
                                 'text',
+                                'limit',
                             ])
                             ->all()
                     );

src/Query/Traits/PerformSearch.php

@@ -10,11 +10,25 @@
 trait PerformSearch
 {
     /**
-     * Perform a search operation on the query builder.
+     * Executes a modular search on the query builder based on provided parameters.
      *
-     * @param array $parameters An array of search parameters.
+     * This method first authorizes the view operation on the model and then, unless security is disabled,
+     * applies a security-aware search query. It conditionally processes various search parameters to:
+     * - Filter results via a nested subquery to prevent conflicts.
+     * - Sort results using custom definitions if provided, or default ordering from the resource.
+     * - Apply named scopes, instructions, includes, and aggregate functions.
+     * - Limit the result set according to a specified limit or a default value of 50.
      *
-     * @return Builder The modified query builder.
+     * @param array $parameters An associative array of search parameters that may include:
+     *                          - 'filters': Criteria for filtering the results.
+     *                          - 'sorts': Definitions for ordering the results.
+     *                          - 'scopes': Named scopes to refine the query.
+     *                          - 'instructions': Additional instructions for query customization.
+     *                          - 'includes': Related resources to include in the query.
+     *                          - 'aggregates': Aggregate functions to apply on related data.
+     *                          - 'limit': Maximum number of records to return.
+     *
+     * @return Builder The modified query builder with the applied search parameters.
      */
     public function search(array $parameters = [])
     {
@@ -32,7 +46,7 @@ public function search(array $parameters = [])
             });
         });
 
-        if (!isset($parameters['sorts']) || empty($parameters['sorts'])) {
+        if (empty($parameters['sorts'])) {
             foreach ($this->resource->defaultOrderBy(
                 app()->make(RestRequest::class)
             ) as $column => $order) {
@@ -59,9 +73,9 @@ public function search(array $parameters = [])
             $this->applyAggregates($parameters['aggregates']);
         });
 
-        // In case we are in a relation we don't apply the limits since we don't know how much records will be related.
-        if (!$this->queryBuilder instanceof Relation && !$this->disableSecurity) {
-            $this->queryBuilder->limit($parameters['limit'] ?? 50);
+        $limit = $this->disableDefaultLimit() && !isset($parameters['limit']) ? null : ($parameters['limit'] ?? 50);
+        if ($limit !== null) {
+            $this->queryBuilder->limit($limit);
         }
 
         return $this->queryBuilder;

tests/Feature/Controllers/ActionsOperationsTest.php

@@ -295,6 +295,43 @@ public function test_operate_action_with_search(): void
         );
     }
 
+    public function test_operate_action_with_search_and_limit(): void
+    {
+        ModelFactory::new()
+            ->count(300)
+            ->create([
+                'string' => 'match',
+            ]);
+
+        ModelFactory::new()->count(2)
+            ->create();
+
+        Gate::policy(Model::class, GreenPolicy::class);
+
+        $response = $this->post(
+            '/api/models/actions/modify-number',
+            [
+                'search' => [
+                    'filters' => [
+                        ['field' => 'string', 'value' => 'match'],
+                    ],
+                    'limit' => 150,
+                ],
+            ],
+            ['Accept' => 'application/json']
+        );
+
+        $response->assertJson([
+            'data' => [
+                'impacted' => 150,
+            ],
+        ]);
+        $this->assertEquals(
+            150,
+            Model::where('number', 100000000)->count()
+        );
+    }
+
     public function test_operate_batchable_action(): void
     {
         ModelFactory::new()->count(150)->create();