kayrunm / polybind
Polymorphic route-model binding for Laravel.
Requires
- php: ^8.2
- illuminate/database: ^10.22
- illuminate/http: ^10.22
- illuminate/routing: ^10.22
Requires (Dev)
- friendsofphp/php-cs-fixer: ^3.9.5
- orchestra/testbench: ^8.0
- phpstan/phpstan: ^1.10
- phpunit/phpunit: ^10.0
README
Polymorphic route-model binding for Laravel.
Pre-requisites
This package requires the following:
- PHP 8.2
- Laravel 10 or higher
Installation
To install the package, you simply need to run the following command:
composer require kayrunm/polybind
The service provider for the package will automatically be registered, but if you wish, you can optionally add
the following in your config/app.php
file:
'providers' => [ // ... Kayrunm\Polybind\PolybindServiceProvider::class, ],
Finally, you just need to alias the middleware in your $middlewareAliases
in app/Http/Kernel.php
:
protected $middlewareAliases = [ // ... 'polybind' => Kayrunm\Polybind\Polybind::class ];
You can skip aliasing the middleware if you have no intention of using per-route parameters, as it just makes it easier to add the middleware parameters. If you do skip this step, you'll have to apply the middleware using the full Polybind classname.
Configuration
This package allows for you to configure the default route parameters and the resolution logic. To start with this, you need to publish the configuration file:
php artisan vendor:publish --provider="Kayrunm\Polybind\PolybindServiceProvider"
You can now edit the config/polybind.php
file with your chosen defaults.
Usage
Polybind works via a middleware that you add to your polymorphic routes. The simplest way to get started is to add the middleware to your route definition, like so:
// routes/web.php Route::get('/{model_type}/{model_id}', [MyController::class, 'show'])->middleware('polybind');
Polybind will then do its magic when you access this route, by automatically resolving the model and allowing you to
access the model in your controller method via the $model
parameter:
// MyController.php public function show($model) { return response()->json($model); }
Note: Polybind requires that your models are registered in Relation::morphMap()
.
Type validation
Polybind allows you to hint the types of model that a route accepts, either with union/intersection types or even with
interfaces. If Polybind resolves a model that doesn't match the type that you have type hinted, it will throw a
Kayrum\Polybind\Exceptions\InvalidModelType
exception. If you don't use any type hinting in your controller method,
Polybind will allow any Model to be resolved.
Here's an example of type hinting with an interface:
// MyController.php public function show(HasAuthor $model) { return response()->json($model); }
And here's an example of type hinting using a union type:
// MyController.php public function show(Post|Comment $model) { return response()->json($model); }
Per-route configuration
Polybind also allows you to configure the route parameters for the model type and model identifier, as well as the name you use for the parameter in your controller method, on a per-route basis. Here's an example of how to do that:
// routes/web.php Route::get('/{author_type}/{author_uuid}', function ($author) { return response()->json($author); })->middleware('polybind:author_type,author_uuid,author');
Adding to your entire application
If you make use of polymorphic route-model binding throughout your application, you may find it easier to simply apply Polybind's functionality on all of your routes. Polybind will only run on routes where it finds a matching type and identifier parameter.
To do this, simply add the Polybind middleware to the middleware groups you would like it to run on, for example in the
web
and api
groups in app/Http/Kernel.php
:
protected $middlewareGroups = [ 'web' => [ // ... \Kayrunm\Polybind\Polybind::class, ], 'api' => [ // ... \Kayrunm\Polybind\Polybind::class, ], ];
Note: Make sure that the Polybind middleware is applied after the SubstituteBindings
middleware.