{"id":13545664,"url":"https://github.com/heera/requent","last_synced_at":"2026-03-17T16:14:54.021Z","repository":{"id":57049148,"uuid":"92880112","full_name":"heera/requent","owner":"heera","description":"A GraphQL like interface to map a request to eloquent query with data transformation for Laravel.","archived":false,"fork":false,"pushed_at":"2017-09-03T16:44:07.000Z","size":115,"stargazers_count":79,"open_issues_count":0,"forks_count":6,"subscribers_count":3,"default_branch":"master","last_synced_at":"2025-03-04T21:36:09.339Z","etag":null,"topics":["api","data-filtering","eloquent","graphql","laravel","transform-data"],"latest_commit_sha":null,"homepage":"","language":"PHP","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/heera.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null}},"created_at":"2017-05-30T22:03:00.000Z","updated_at":"2024-09-25T13:18:40.000Z","dependencies_parsed_at":"2022-08-23T19:10:16.906Z","dependency_job_id":null,"html_url":"https://github.com/heera/requent","commit_stats":null,"previous_names":[],"tags_count":2,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/heera%2Frequent","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/heera%2Frequent/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/heera%2Frequent/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/heera%2Frequent/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/heera","download_url":"https://codeload.github.com/heera/requent/tar.gz/refs/heads/master","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":246841843,"owners_count":20842656,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["api","data-filtering","eloquent","graphql","laravel","transform-data"],"created_at":"2024-08-01T11:01:08.707Z","updated_at":"2025-12-12T21:43:31.601Z","avatar_url":"https://github.com/heera.png","language":"PHP","funding_links":[],"categories":["PHP"],"sub_categories":[],"readme":"# Laravel Requent [![Build Status](https://travis-ci.org/heera/requent.svg?branch=master)](https://travis-ci.org/heera/requent) [![Latest Stable Version](https://poser.pugx.org/sheikhheera/requent/v/stable)](https://packagist.org/packages/sheikhheera/requent) [![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/heera/requent/blob/master/LICENSE)\n\nAn elegant, light-weight GQL (Graph Query Language) like interface for Eloquent with zero configuration. It maps a request to eloquent query and transforms the result based on query parameters. It also supports to transform the query result explicitly using user defined transformers which provides a more secured way to exchange data from a public API with minimal effort.\n\n- [Installation](#installation)\n- [How It Works](#how-it-works)\n- [Basic Example](#basic-example)\n- [Resource](#resource)\n- [Methods](#methods)\n- [Resource Key By](#key-by)\n- [Data Filtering Using Transformers](#transformer)\n- [Get Raw Result](#raw)\n- [Query Modifier Clause](#query-clause)\n- [Customizations](#customizations)\n\n## \u003ca name=\"installation\"\u003e\u003c/a\u003e Installation\n\nYou can simply run the following command from your terminal to install the package:\n\n    composer require sheikhheera/requent\n\nOr add the following line in \"composer.json\" file within \"require\" section and run `composer install` from terminal:\n\n    \"sheikhheera/requent\": \"1.0.*\"\n\n\u003e If you are using version 5.5 or greater, then you are all done, no need to add service provider or alias in `config\\app`. So you can simply skip the following steps because of Laravel's package auto discovery feature.\n\n\nThis will install the package. Now add the following entry in your `config/app.php` file inside the `providers` section:\n\n    Requent\\RequentServiceProvider::class\n    \nAlso add the following entry in `aliases` section of your `config/app.php` file:\n\n    'Requent' =\u003e Requent\\Facade\\Requent::class,\n\nIf you've done everything right then you can start using it without any configuration but you may customize it.\n\n## \u003ca name=\"how-it-works\"\u003e\u003c/a\u003e How It Works\n\nThis package will allow us to query resources through the request query string parameter. For example, if we've a `User` model and the `User` model has many posts (`Post` model) and each post has many comments (`Comment` model) then we can query the users with their posts and comments of each posts by sending a request like the followig: `http://example.com/users?fields=posts{comments}`. This is the most basic use case but it offers more. We can also select properties of each model through query string, for example, if we want to select only the emal field from the `User` model and title from `Post` and body from the `Comment` model then we can just do it by sending a request using the following `URL`:\n\n    http://example.com/users?fields=email,posts.orderByDesc(id){title,comments{body}}\n\nIt'll be translated into something similar to following (Not literally):\n\n```php\nUser::select('email')\n-\u003ewith(['posts' =\u003e function($query) {\n    $query\n    -\u003eorderByDesc('id')\n    -\u003eselect('title')\n    -\u003ewith(['comments' =\u003e function($query) {\n        $query-\u003eselect('body');\n    }])\n}]);\n```\n\n## \u003ca name=\"basic-example\"\u003e\u003c/a\u003e Basic Example\n\nTo use this package, we need to create some resources (Eloquent Models). For this demonstration, we'll use the same idea using User, Post and Comment models for an imaginary blog. The User model has a `hasMany` relation for posts and the Post model has a `hasMany` relation for comments. So, we need a route, which could be a resourceful route but we'll use an explicite route declaration here:\n\n```php\nRoute::get('users', 'UserController@index');\n```\n\nNow, we need a controller which is just a simple controller, for example:\n\n```php\n\u003c?php\n\nnamespace App\\Http\\Controllers;\n\nuse Requent;\nuse App\\User;\nuse App\\Http\\Controllers\\Controller;\n\nclass UserController extends Controller\n{\n    public function index()\n    {\n        return Requent::resource(User::class)-\u003eget();\n    }\n}\n```\nNow, we can make a request using: `http://example.com/users?fields=email,posts{title,comments{body}}`. This will give us the expected result, which would be an array of users (only email column from `User`) with all the related posts (only title column from `Post`) and all the comments of each post (only body column from `Comment`).\n\nIf we want to load any resource with relations without selecting any properties then we can just do it using the following request: `http://example.com/users?fields=posts{comments}`. This was the most basic example but let's explore it's features.\n\n## \u003ca name=\"resource\"\u003e\u003c/a\u003e Resource\nActually, a resource is just an eloquent model, the first method we should call on the `Requent` class is `resource` which sets the primary resource we want to query on. So we can set the resource using couple of ways, for example:\n\n```php\n$resource = Requent::resource(User::class);\n```\n\nAlso, we can use an object, for example:\n\n```php\n$resource = Requent::resource(new User);\n```\n\nWe can also pass a `Query Builder` for example:\n\n```php\n$resource = Requent::resource(app(User::class)-\u003ewhere('role', 'admin'));\n```\n\nSo, we can call any scope methods as well, which just returns a `Query Builder` instance. The `resource` method returns the `Requent` object so we can chain methods, for example, we can call any query executing method (including other available methods in `Requent`), for example:\n\n```php\n$result = Requent::resource(\n    app(User::class)-\u003ewhere('role', 'admin')\n)\n-\u003etransformBy(UserTransformer::class)\n-\u003ekeyBy('users')\n-\u003eget();\n```\n\nWe'll walk-through all the available methods and features that `Requent` offers. Let's continue.\n\n## \u003ca name=\"methods\"\u003e\u003c/a\u003e Methods\n\n#### Get\n\nWe've seen `get` method earlier which just returns an array of users which is:\n\n```php\nreturn Requent::resource(User::class)-\u003eget();\n```\n\n#### Paginated Result\n\nAt this point, we'll get an array but we can retrieve paginated result using same `get` method and in this case we, we only need to provide a query string parameter in our `URL` like the following example:\n\n    http://example.com/users?fields=posts{comments}\u0026paginate\n\nAlso, we can set the paginator, for example:\n\n    http://example.com/users?fields=posts{comments}\u0026paginate=simple\n    \nThis will return the paginated result using `SimplePaginator` but by default it'll use `LengthAwarePaginator`.\n\n#### Per Page\n\nWe can also tell how many pages we want to get for per page and it's just another parameter, for example:\n\n    http://example.com/users?fields=posts{comments}\u0026paginate=simple\u0026per_page=5\n    \nIf we provide `per_page=n` then we don't need to provide `\u0026paginate` parameter unless we want to use the simple paginator instead of `default`. We can also customize these parameters, we'll check later on.\n\n#### Paginate\nAlso, we can call the `paginate` method on the `Requent` directly, for example:\n\n```php\nreturn Requent::resource(User::class)-\u003epaginate(); // or paginate(10)\n```\n\n#### Simple Paginate\n\nThe `simplePaginate` will return paginated result using `Simple Paginator`. [Check Laravel Documentation](https://laravel.com/docs/5.4/pagination).\n\n```php\nreturn Requent::resource(User::class)-\u003esimplePaginate(); // or simplePaginate(10)\n```\n\n#### Find\n\nIf we want to retrieve a single `user` then we can use `find` and `first` method, for example:\n\n```php\nreturn Requent::resource(User::class)-\u003efind($id);\n```\n\n#### First\n\nFor the first item we can call the `first` method:\n\n```php\nreturn Requent::resource(User::class)-\u003efirst();\n```\n\n#### Fetch\n\nThese are all the available methods for executing query but there is one more method which is `fetch`. This method can return any kind of result, an collection (array), paginated result or a singlr resource. Let's see an example:\n\n```php\n\n// In Controller\n\npublic function fetch($id = null)\n{\n    return Requent::resource(User::class)-\u003efetch($id);\n}\n```\nTo use this method we need a route like: `Route::get('users/{id?}', 'UserController@fetch')` and then we can use this single route to get all kind of results, for example:\n\n#### Get a collection of users (Array)\n\n```php\nhttp://example.com/users?fields=posts{comments}\n```\n\n#### Get paginated result\n\n```php\nhttp://example.com/users?fields=posts{comments}\u0026paginate=simple\u0026per_page=5\n```\n\n#### Get a single user (Array)\n\n```php\nhttp://example.com/users/1?fields=posts{comments}\n```\n\nThe `fetch` method will be useful if we declare explicit route other than RESTfull routes for Resource Controllers. [Check Laravel Documentation](https://laravel.com/docs/5.4/controllers#resource-controllers).\n\n\u003e When selecting properties of a model/resource using query string, i.e: `fields=name,posts{title}`, we can select a dynamic property (getter/accessor), defined using a `getPropertyAttribute` method. Check the documentation for [Defining An Accessor](https://laravel.com/docs/5.4/eloquent-mutators#defining-an-accessor).\n\n\n## \u003ca name=\"key-by\"\u003e\u003c/a\u003e Resource Key By\n\nThe query results for a collection is simply an array with a zero based index but if we want then we can wrap our collection in a key using `keyBy` method, for example:\n\n```php\nreturn Requent::resource(User::class)-\u003ekeyBy('users')-\u003eget();\n```\n\nThis will return a collection of users (Array) as a key value pair where the key will be `users` and the result will be the valuse of that key. We can also use a key for a single user for example:\n\n```php\nreturn Requent::resource(User::class)-\u003ekeyBy('user')-\u003efind(1);\n```\n\nIn case of `fetch` we can use something like the following:\n\n```php\npublic function fetch($id = null)\n{\n    return Requent::resource(User::class)-\u003ekeyBy($id ? 'user' : 'users')-\u003efetch($id);\n}\n```\n\nThe paginated result will remain the same, by default `Laravel` wraps the collection using the `data` as key.\n\n## \u003ca name=\"transformer\"\u003e\u003c/a\u003e Data Filtering Using Transformers\n\n\u003eThe idea of transformers is taken from [Fractal Transformer](http://fractal.thephpleague.com/transformers/) package. This looks like re-inventing the wheel but actually it's not. The main intention for building the `Requent` package was to allow an easy to use interface for fetching resource/data form a web application (non-public `API`), which allows to read data from server using any `javaScript` framework/library even without defining any transformers. Also, the `Eloquent` query is built dynamically on the run-time to load everything eagerly, while `Fractal` uses lazy loading. So, the `Requent` couldn't utilize the data transforming feature that `Fractal` offers. So, to provide the data filtering layer (for public `API`), the `Requent` needed it's own data filtering mechanism but the `Fractal` package is great and I've used it exclusively on my projects.\n\nSo far we've seen the default data transformation, which means that, a user can get any property or available relations of the resource just by asking it through the query string parameter `fields` (we can use something else other than `fields`), but there is no way to keep some data private if you are using this for a public `API`. Here, the `transformer` comes into play.\n\nBy default, the `Requent` uses a `DefaultTransformer` class to return only selected properties/relations, for example, if you send a request using a `URL` like following: `http://example.com/users?fields=email,posts{title,comments}` then it'll return only selected properties/relations. In this case, it'll return what you ask for it but you may need to define explicitly what properties/relations a user can get from a request through query parameter. For this, you can create a custom transformer where you can tell what to return. To create a trunsformer, you just need to create transformer classes by extending the `Requent\\Transformer\\Transformer` class. For example:\n\n```php\n\u003c?php\n\nnamespace App\\Http\\Transformers;\n\nuse Requent\\Transformer\\Transformer;\n\nclass UserTransformer extends Transformer\n{\n    public function transform($model)\n    {\n        return [\n            'id' =\u003e $model-\u003eid,\n            'name' =\u003e $model-\u003ename,\n            'email' =\u003e $model-\u003eemail,\n        ];\n    }\n}\n```\n\nTo use your custom transformer, all you need to pass the transformer class to the `resource` method, i.e:\n\n```php\nreturn Requent::resource(User::class, UserTransformer::class)-\u003efetch($id);\n```\n\nAlso you can pass the class instance:\n\n```php\nreturn Requent::resource(User::class, new UserTransformer)-\u003efetch($id);\n```\n\nAlso, you can set the transformer using `transformBy` method:\n\n```php\nreturn Requent::resource(User::class)-\u003etransformBy(UserTransformer::class)-\u003efetch($id);\n```\nAlso, the `transformBy` method accepts a transformer object instance:\n\n```php\nreturn Requent::resource(User::class)-\u003etransformBy(new UserTransformer)-\u003efetch($id);\n```\n\nThis will transform the resource using by calling the `transform` method defined in the transformer class you created. In this case, the transform mathod will called to transform the `User` model but right now, it'll not load any relations. Which means, if the `URL` is something like: `http://example.com/users?fields=posts{comments}` then only the `User` model will be transformed and the result would be something like the following:\n\n```\n[\n    {\n        id: 1,\n        name: \"Aurelio Graham\",\n        email: \"hharvey@example.org\"\n    },\n    {\n        id: 2,\n        name: \"Adolfo Weissnat\",\n        email: \"serena78@example.com\",\n    }\n    // ...\n]\n```\n\nTo load any relations from the root transformer (`UserTransformer` in this case), we also need to explicitly declare a method using the same name the relation is defined in the model, so for example to load the related posts with each `User`  model we need to declare a `posts` method in our `UserTransformer` class. For example:\n\n```php\nclass UserTransformer extends Transformer\n{\n    public function transform($model)\n    {\n        return [\n            'id' =\u003e $model-\u003eid,\n            'name' =\u003e $model-\u003ename,\n            'email' =\u003e $model-\u003eemail,\n        ];\n    }\n    \n    // To allow inclussion of posts\n    public function posts($model)\n    {\n        return $this-\u003eitems($model, PostTransformer::class);\n    }\n}\n```\nIn this example, we've added a filtering for `Post` model and that's why a user can select the related posts with users from the `URL`, for example: `http://example.com/users?fields=posts`. without the `posts` method in `UserTransformer` a user can't read/fetch the posts relation. At this point, we are not done yet. As you can assume that, we are transforming the posts (Collection) using `items` method available in `UserTransformer` (extended from abstract Transform class) and passing another transformer (PostTransformer) to transform the collection of posts. So, we need to implement the `PostTransformer` and have to implement the `transform` method where we'll explicitly return the transformed array for each `Post` model, for example:\n\n```php\nnamespace App\\Http\\Transformers;\n\nuse Requent\\Transformer\\Transformer;\n\nclass PostTransformer extends Transformer\n{\n    public function transform($model)\n    {\n        return [\n            'post_id' =\u003e $model-\u003eid,\n            'post_title' =\u003e $model-\u003etitle,\n            'post_body' =\u003e $model-\u003ebody,\n        ];\n    }\n\n    // User can select related user for each Post model\n    public function user($model)\n    {\n        return $this-\u003eitem($model, new UserTransformer);\n    }\n\n    // User can select related comments for each Post model\n    public function comments($collection)\n    {\n        return $this-\u003eitems($collection, new CommentTransformer);\n    }\n}\n```\n\nIn this example, we've implemented the `transform` method for the `Post` model for response filtering so only the `id`, `title` and `body` column will be available for the `Post` model in the response and the related posts will be included only if the user selects the posts through the query string parameter in the `URL`.\n\nIn the exmple given above, we've also defined two additional methods, `user` and `comments`. Those methods are also relations of `Post` model. The `user` method is defined as a `belongsTo` relationship which simply maps the related user who published the post and the comments method loads the related comments published under the post. The `Post` model looks something like the followin:\n\n```php\nnamespace App;\n\nuse App\\User;\nuse App\\Comment;\nuse Illuminate\\Database\\Eloquent\\Model;\n\nclass Post extends Model\n{\n    public function user()\n    {\n        return $this-\u003ebelongsTo(User::class);\n    }\n\n    public function comments()\n    {\n        return $this-\u003ehasMany(Comment::class);\n    }\n}\n\n```\n\nAccording to the setup given above, we can make a request using the following `URL` to get all the users with posts and it's related comments and user: `http://example.com/users?fields=posts{user,comments}`.\n\nIn the `PostTransformer` class we've used `item` method inside `user` method, which actually resieves a single `Eloquent` model in `$model` parameter and so we've called the `item` method from the transformer. In the comments method, we've used the `items` method because the `$collection` parameter in comments method recieves a collection of `Comment` models.\n\nSo, it's obvious that, to allow the inclussion of any relation from a resource we've to declare a method for that relation using the same name we've used to declare the relation in the `Eloquent` model and relations will be included only if the user selects/includes it within the `fields` parameter. If user selects a relation from a resource that is not exposed throught the transformer using a method, then it'll not be available in the response.\n\n\u003e The user defined transformers will be used to transform the data only a transformer class is passed as the second parameter in the `resource` method or by calling the `transformBy` method, otherwise, everything will be included in the result/response the user asked for (if those fields/relations are available in the corresponding model).\n\n## \u003ca name=\"raw\"\u003e\u003c/a\u003e Get Raw Result\n\nRequent has a `raw` method which could be useful if someone doesn't want to apply any transformation, because after the transformation, the returned data is an array. So if you want to execute the query but you want to ommit the data transformation by default (selection of columns through the query string) then you can use `raw` method, for example:\n\n```php\n$result = Requent::resource(User::class)-\u003eraw()-\u003efetch($id);\n```\n\nIn this case, when you don't provide a custom transformer to transform data then the requent will transform the data using the defalt transformer. So, if you make a request using `http://example.com/users?fields=email,posts{title}`, then it should return only `email` from the `User` model and `title` from the `Post` model. \n\nIn this case, because of `raw`, the requent will execute the query to load the resource with mentioned relations but it'll not filter the result so the original result returned by the `Eloquent` (could be a collection, paginated data or a modeld) will be returned as the result of `Requent` query.\n\n#### Transform Raw Result\n\n```php\n\nuse Requent;\nuse App\\User;\nuse App\\Http\\Controllers\\Controller;\nuse Requent\\Transformer\\TransformerHelper;\nuse App\\Http\\Transformers\\UserTransformer;\n\nclass HomeController extends Controller\n{\n    use TransformerHelper;\n    \n    public function index()\n    {\n        $result = Requent::resource(User::class)-\u003eraw()-\u003eget();\n    \n        return $this-\u003etransform($result, UserTransformer::class, 'users');\n    }\n}\n```\n\nIn this example, the third parameter `users` passed to transform method is optional, which would be used as the resource key.\n\n\u003e The `Requent` doesn't use lazy loading, which means that, everything (relations) is eager loaded and when it comes to transformer (transform method), the quwey has been already executed and everything is loaded. So, at this point, the `transform` method will recieve a model and and if we want to load other relations that was not loaded through the query, then we can simply call the `load` method on the model before transforming it, for example:\n\n```php\npublic function transform($model)\n{\n    if(!$model-\u003erelationLoaded('comments')) {\n        $model-\u003eload('comments');\n    }\n    \n    return [\n        'post_id' =\u003e $model-\u003eid,\n        'post_title' =\u003e $model-\u003etitle,\n        'post_body' =\u003e $model-\u003ebody,\n    ];\n}\n```\n\n## \u003ca name=\"query-clause\"\u003e\u003c/a\u003e Query Modifier Clause\n\nWhen we make a request, we can add some query modifier clauses for example, `orderBy`, `orderByDesc` e.t.c. There are several clauses that `Requent` offers to use in the `URL`, those are given below:\n\n#### orderBy\n\n```\nhttp://blog54.dev/1?fields=posts{user,comments.orderBy(id){user}}\n```\n\n#### orderByDesc\n\n```\nhttp://example.com/1?fields=posts{user,comments.orderByDesc(id){user}}\n```\n\n#### skip \u0026 take\n\n```\nhttp://example.com/1?fields=posts{user,comments.skip(2).take(1){user}}\n```\n\n#### offset \u0026 limit\n\n```\nhttp://example.com/1?fields=posts{user,comments.offset(2).limit(1){user}}\n```\n#### Multiple Clauses\n\n```\nhttp://example.com/1?fields=posts.orderBy(title).limit(3){user,comments.orderByDesc(id).skip(2).take(1){user}}\n```\n\n\u003e When using limit/take on a relationship and loading a collection of that relation, you may get wrong result because the limit is applied only once on the query by Laravel. [An old issue here](https://github.com/laravel/framework/issues/4835).\n\n## \u003ca name=\"customizations\"\u003e\u003c/a\u003e Customizations\n\nRequent uses some base settings from a config file. By default, it'll work as it's configured but if you need to modify any of the settings then you can publish the config file from vendor to your local app config directory. To publish the config, just execute the following command from your terminal:\n\n```\nphp artisan vendor:publish --provider=\"Requent\\RequentServiceProvider\" --tag=\"config\"\n```\n\nOnce you publish the config file to your local `/config` directory then you can modify any settings to customize `Requent` for your need. Follwing code is taken from the config file which is documented itself.\n\n```\n    /*\n    |--------------------------------------------------------------------------\n    | Query Identifier\n    |--------------------------------------------------------------------------\n    |\n    | Here you may define the parameter name to pass your query string\n    | to select fields/columns. By default, \"fields\" is set but you may\n    | override it if you wish.\n    |\n    */\n    'query_identifier' =\u003e 'fields',\n\n    /*\n    |--------------------------------------------------------------------------\n    | Paginator Identifier\n    |--------------------------------------------------------------------------\n    |\n    | Here you may define the parameter name to get paginated data.\n    | By default, \"paginate\" is set but you may override it if you wish.\n    |\n    */\n    'paginator_identifier' =\u003e 'paginate',\n\n    /*\n    |--------------------------------------------------------------------------\n    | Default Paginator\n    |--------------------------------------------------------------------------\n    |\n    | Here you may define the default paginator to be used when geting paginated\n    | result. By default, the length aware paginator will be used unless you override\n    | it here or pass the pagination type in the query string.\n    |\n    | Available Options: \"simple\", \"default\"\n    |\n    */\n    'default_paginator' =\u003e 'default',\n\n    /*\n    |--------------------------------------------------------------------------\n    | Per Page Identifier\n    |--------------------------------------------------------------------------\n    |\n    | Here you may define the name of the query string to pass the number\n    | of pages you want to retrieve from paginated result. By default, the\n    | package will use \"per_page\" so you can pass ?per_page=10 to get 10 items\n    |  per page unless you override it here.\n    */\n    'per_page_identifier' =\u003e 'per_page',\n\n    /*\n    |--------------------------------------------------------------------------\n    | Default Attributes Selection\n    |--------------------------------------------------------------------------\n    |\n    | Here you may define whether you would like to load all properties/attributes\n    | from a model if no property was explicitly selected using the query string. If\n    | you just select relations of a model, the package will load all the attributes\n    | by default unless you override it here by setting the value to false.\n    */\n    'select_default_attributes' =\u003e true,\n```\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fheera%2Frequent","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fheera%2Frequent","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fheera%2Frequent/lists"}