Spatie Laravel Route Attributes

https://github.com/spatie/laravel-route-attributes
Admin
This package provides PHP 8 attributes to automatically register routes in a Laravel application,...
Tokens:27,473
Snippets:364
Trust Score:10
License:MIT
Update:3 months ago
Show doc for...
Tokens:
Raw
### Install spatie/laravel-route-attributes

Source: https://github.com/spatie/laravel-route-attributes/blob/main/README.md

Install the package using Composer.

```bash
composer require spatie/laravel-route-attributes
```

--------------------------------

### Usage of Get attribute

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/RouteAttributes.md

Examples of applying the Get attribute to controller methods with various configurations.

```php
class UserController
{
    #[Get('users')]
    public function index() {}

    #[Get('users/{id}', name: 'users.show')]
    public function show($id) {}

    #[Get('users/{id}/edit', middleware: ['auth', 'verified'])]
    public function edit($id) {}
}
```

--------------------------------

### Usage example for Any attribute

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/RouteAttributes.md

Example of applying the Any attribute to a controller method.

```php
class WebhookController
{
    #[Any('webhook/incoming')]
    public function handle(Request $request) {}
}
```

--------------------------------

### Use DomainFromConfig Attribute

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/ClassModifiersAttributes.md

Example showing how to load a domain from a configuration key for a controller.

```php
// config/services.php
return [
    'api' => [
        'domain' => env('API_DOMAIN', 'api.local')
    ]
];

// Controller
use Spatie
outeAttributes\Attributes\DomainFromConfig;
use Spatie
outeAttributes\Attributes\Get;

#[DomainFromConfig('services.api.domain')]
class ApiController
{
    #[Get('users')]
    public function index() {}
}
// Domain is loaded from config at registration time
```

--------------------------------

### Basic configuration setup

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/RouteAttributesServiceProvider.md

Defines the default directory to scan for route attributes and global middleware.

```php
return [
    'enabled' => true,
    'directories' => [
        app_path('Http/Controllers'),
    ],
    'middleware' => [SubstituteBindings::class],
];
```

--------------------------------

### Usage example for Route attribute

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/RouteAttributes.md

Example of applying the Route attribute with specific HTTP methods.

```php
class FormController
{
    #[Route(['put', 'patch'], 'forms/{id}', name: 'forms.update')]
    public function update(Request $request, $id) {}
}
```

--------------------------------

### Use Middleware Attribute

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/ClassModifiersAttributes.md

Example showing how to apply middleware to a controller class and individual methods.

```php
use Spatie
outeAttributes\Attributes\Middleware;
use Spatie
outeAttributes\Attributes\Get;
use Spatie
outeAttributes\Attributes\Post;

#[Middleware(['auth', 'verified'])]
class DashboardController
{
    #[Get('dashboard')]
    public function index() {}

    #[Post('settings', middleware: 'admin')]
    public function updateSettings(Request $request) {}
}
// All methods have auth and verified middleware
// updateSettings additionally has admin middleware
```

--------------------------------

### Configure Directory Options

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/configuration.md

Example showing all available directory-specific configuration options including prefixes, middleware, and file patterns.

```php
'directories' => [
    app_path('Http/Controllers/Api') => [
        'prefix' => 'api/v1',
        'middleware' => ['api', 'throttle:60,1'],
        'namespace' => 'App\Http\Controllers\Api\',
        'patterns' => ['*Controller.php'],
        'not_patterns' => ['*Test.php', '*Stub.php'],
    ],
],
```

--------------------------------

### Usage Example for Put

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/RouteAttributes.md

Example of applying the Put attribute to a controller method.

```php
class UserController
{
    #[Put('users/{id}', name: 'users.update')]
    public function update(Request $request, $id) {}
}
```

--------------------------------

### Usage of Defaults Attribute

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/ClassModifiersAttributes.md

Example showing how to apply the Defaults attribute to controllers and methods.

```php
use Spatie
outeAttributes\Attributes\
Defaults;
use Spatie\RouteAttributes\Attributes\Get;

#[Defaults('page', '1')]
class ArticleController
{
    #[Get('articles/{page?}')]
    public function paginated($page = 1) {}

    #[Get('posts/{id}/comments/{comment_page?}')]
    #[Defaults('comment_page', '1')]
    public function showComments($id, $comment_page = 1) {}
}
```

--------------------------------

### Get attribute constructor signature

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/RouteAttributes.md

Constructor parameters for the Get attribute.

```php
public function __construct(
    string $uri,
    ?string $name = null,
    array|string $middleware = [],
    array|string $withoutMiddleware = [],
)
```

--------------------------------

### Get Resource Only Option

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/ClassRouteAttributes.md

Retrieve the list of actions to include for resource routes.

```php
#[Resource('posts', only: ['index', 'show'])]
class PostController {}

$only = $classAttrs->only(); // Returns ['index', 'show']
```

--------------------------------

### Usage of Post attribute

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/RouteAttributes.md

Examples of applying the Post attribute to controller methods.

```php
class UserController
{
    #[Post('users', name: 'users.store')]
    public function store(Request $request) {}

    #[Post('users/{id}/avatar', middleware: 'auth')]
    public function uploadAvatar(Request $request, $id) {}
}
```

--------------------------------

### Define Basic Routes

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/INDEX.md

Use the Get attribute to define route paths and optional route names.

```php
#[Get('posts')]
public function index() {}

#[Get('posts/{id}', name: 'posts.show')]
public function show($id) {}
```

--------------------------------

### Register Basic Routes

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/REFERENCE.md

Use the Get attribute on controller methods to define route paths.

```php
use Spatie\RouteAttributes\Attributes\Get;

class PostController
{
    #[Get('posts')]
    public function index() {}
    
    #[Get('posts/{id}')]
    public function show($id) {}
}
```

--------------------------------

### Get Middleware

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/RouteRegistrar.md

Retrieve the currently configured global middleware array.

```php
$middleware = $registrar->middleware();
```

--------------------------------

### Usage Example for Patch

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/RouteAttributes.md

Example of applying the Patch attribute to a controller method.

```php
class UserController
{
    #[Patch('users/{id}', name: 'users.update')]
    public function update(Request $request, $id) {}
}
```

--------------------------------

### Apply WithTrashed Attribute

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/ClassModifiersAttributes.md

Example showing how to apply WithTrashed at the class level and override it at the method level.

```php
use Spatie
outeAttributes	ributes	Get;
use Spatie
outeAttributes	ributes	WithTrashed;

#[WithTrashed]
class RestoreController
{
    #[Get('posts/{post}/restore')]
    public function restoreForm(Post $post) {}
    // Post can be soft-deleted

    #[Get('posts/{post}')]
    #[WithTrashed(false)]
    public function show(Post $post) {}
    // Post must not be soft-deleted
}
```

--------------------------------

### Usage of ScopeBindings Attribute

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/ClassModifiersAttributes.md

Example showing how to enable or disable scoped bindings on controllers and methods.

```php
use Spatie\RouteAttributes\Attributes\Get;
use Spatie\RouteAttributes\Attributes\ScopeBindings;

#[ScopeBindings]
class CommentController
{
    #[Get('posts/{post}/comments/{comment}')]
    public function show(Post $post, Comment $comment) {}
    // Comment is automatically scoped to the Post
}

class PostController
{
    #[Get('users/{user}/posts/{post}')]
    #[ScopeBindings(false)]
    public function show(User $user, Post $post) {}
    // Scoped bindings disabled for this route
}
```

--------------------------------

### Define GET Route with Attribute

Source: https://github.com/spatie/laravel-route-attributes/blob/main/README.md

Use the `#[Get]` attribute on a controller method to automatically register a GET route. Ensure the attribute class is imported.

```php
use Spatie\RouteAttributes\Attributes\Get;

class MyController
{
    #[Get('my-route')]
    public function myMethod()
    {
    }
}
```

--------------------------------

### Define Get attribute class

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/RouteAttributes.md

The Get attribute class definition for registering GET routes.

```php
#[Attribute(Attribute::TARGET_METHOD | Attribute::IS_REPEATABLE)]
class Get extends Route
```

--------------------------------

### Get Attribute

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/RouteAttributes.md

The Get attribute registers a route that responds to HTTP GET requests.

```APIDOC
## #[Get(uri, name, middleware, withoutMiddleware)]

### Description
Registers a route that responds to GET requests.

### Parameters
- **uri** (string) - Required - The URI path for the route.
- **name** (string|null) - Optional - The route name for URL generation.
- **middleware** (array|string) - Optional - Middleware class(es) to apply to the route.
- **withoutMiddleware** (array|string) - Optional - Middleware to explicitly exclude from the route.

### Example
```php
#[Get('users/{id}', name: 'users.show')]
public function show($id) {}
```
```

--------------------------------

### Implement Fallback Route

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/SpecializedAttributes.md

Example usage of the Fallback attribute on a controller method.

```php
use Spatie
outeAttributes	ributes	oute;
use Spatie
outeAttributes	ributes	allback;

class FallbackController
{
    #[Route(['get', 'post', 'put', 'patch', 'delete'], '{path}')]
    #[Fallback]
    public function notFound($path = '')
    {
        return response()->json(['message' => 'Not found'], 404);
    }
}
```

```php
Route::match(['get', 'post', 'put', 'patch', 'delete'], '{path}', [FallbackController::class, 'notFound'])
    ->fallback();
```

--------------------------------

### Get Resource Except Option

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/ClassRouteAttributes.md

Retrieve the list of actions to exclude for resource routes.

```php
#[Resource('posts', except: 'destroy')]
class PostController {}

$except = $classAttrs->except(); // Returns 'destroy'
```

--------------------------------

### Configure Directories with Namespaces

Source: https://github.com/spatie/laravel-route-attributes/blob/main/README.md

When controllers are outside the application's root namespace, you can specify the namespace and path mapping in the configuration. This example includes controllers from a 'Modules\Admin\Http\Controllers' namespace.

```php
'directories' => [
    'Modules\Admin\Http\Controllers\' => base_path('admin-module/Http/Controllers'),
    // Or
    base_path('admin-module/Http/Controllers') => [
        'namespace' => 'Modules\Admin\Http\Controllers\'
    ],
    app_path('Http/Controllers'),
],
```

--------------------------------

### Prefix Routes with Class Annotation

Source: https://github.com/spatie/laravel-route-attributes/blob/main/README.md

Use the Prefix annotation on a class to apply a common prefix to all routes defined within that class. Ensure the Spatie Route Attributes package is installed.

```php
use Spatie\RouteAttributes\Attributes\Get;
use Spatie\RouteAttributes\Attributes\Post;
use Spatie\RouteAttributes\Attributes\Prefix;

#[Prefix('my-prefix')]
class MyController
{
    #[Get('my-get-route')]
    public function myGetMethod()
    {
    }

    #[Post('my-post-route')]
    public function myPostMethod()
    {
    }
}
```

```php
Route::get('my-prefix/my-get-route', [MyController::class, 'myGetMethod']);
Route::post('my-prefix/my-post-route', [MyController::class, 'myPostMethod']);
```

--------------------------------

### Generated Route Registration

Source: https://github.com/spatie/laravel-route-attributes/blob/main/README.md

This is how the `#[Get]` attribute translates into a standard Laravel route registration.

```php
Route::get('my-route', [MyController::class, 'myMethod']);
```

--------------------------------

### Automatically Registered Routes for Resource Controller

Source: https://github.com/spatie/laravel-route-attributes/blob/main/README.md

These are the routes automatically registered by the Resource attribute configuration in the PhotoCommentController example.

```php
Route::get('api/v1/photos/{photo}/comments', [PhotoCommentController::class, 'index'])->name('api.v1.photoComments.index');
Route::post('api/v1/photos/{photo}/comments', [PhotoCommentController::class, 'store'])->name('api.v1.photoComments.store');
Route::get('api/v1/comments/{comment}', [PhotoCommentController::class, 'show'])->name('api.v1.photoComments.show');
Route::match(['put', 'patch'], 'api/v1/comments/{comment}', [PhotoCommentController::class, 'update'])->name('api.v1.photoComments.update');
```

--------------------------------

### Retrieve Route Groups

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/ClassRouteAttributes.md

Get all route group configurations applied to the class, including domain and prefix settings.

```php
#[Group(prefix: 'api/v1')]
#[Group(prefix: 'api/v2')]
class ApiController {}

$groups = $classAttrs->groups();
// Returns:
// [
//     ['prefix' => 'api/v1', 'domain' => null, ...],
//     ['prefix' => 'api/v2', 'domain' => null, ...]
// ]
```

--------------------------------

### Automatically Registered Route with Middleware

Source: https://github.com/spatie/laravel-route-attributes/blob/main/README.md

This is the route automatically registered by the `Get` attribute with the specified `middleware` parameter.

```php
Route::get('my-route', [MyController::class, 'myMethod'])->middleware(MyMiddleware::class);
```

--------------------------------

### Apply Domain Attribute to Controller

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/ClassModifiersAttributes.md

Example of using the Domain attribute to constrain all routes in a controller to a specific domain.

```php
use Spatie\RouteAttributes\Attributes\Domain;
use Spatie\RouteAttributes\Attributes\Get;

#[Domain('api.example.com')]
class ApiController
{
    #[Get('users')]
    public function index() {}
}
// Registers with domain constraint: api.example.com
```

--------------------------------

### Boot method definition

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/RouteAttributesServiceProvider.md

The boot method handles configuration publishing and triggers the route registration process during the application bootstrap phase.

```php
public function boot()
```

--------------------------------

### Run Tests

Source: https://github.com/spatie/laravel-route-attributes/blob/main/README.md

Execute the project's test suite using Composer.

```bash
composer test
```

--------------------------------

### Configure Route Discovery

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/REFERENCE.md

Define directories to scan and global middleware settings in the configuration file.

```php
return [
    'enabled' => true,  // Enable/disable automatic registration
    
    'directories' => [  // Directories to scan for controllers
        app_path('Http/Controllers'),
        app_path('Http/Controllers/Api') => [
            'prefix' => 'api',
            'middleware' => ['api'],
        ],
    ],
    
    'middleware' => [   // Global middleware applied to all routes
        SubstituteBindings::class,
    ],
    
    'scope-bindings' => null,  // Default scoped bindings behavior
];
```

--------------------------------

### Default Configuration File

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/configuration.md

The standard configuration structure provided by the package for defining directories and global middleware.

```php
<?php

use Illuminate
outing\Middleware\SubstituteBindings;

return [
    /*
     *  Automatic registration of routes will only happen if this setting is `true`
     */
    'enabled' => true,

    /*
     * Controllers in these directories that have routing attributes
     * will automatically be registered.
     *
     * Optionally, you can specify group configuration by using key/values
     */
    'directories' => [
        app_path('Http/Controllers'),
    ],

    /*
     * This middleware will be applied to all routes.
     */
    'middleware' => [
        SubstituteBindings::class,
    ],

    /*
     * When enabled, implicitly scoped bindings will be enabled by default.
     * You can override this behaviour by using the `ScopeBindings` attribute, and passing `false` to it.
     *
     * Possible values:
     *  - null: use the default behaviour
     *  - true: enable implicitly scoped bindings for all routes
     *  - false: disable implicitly scoped bindings for all routes
     */
    'scope-bindings' => null,
];
```

--------------------------------

### Configure Directories for Scanning

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/configuration.md

Define paths to scan for controller classes, supporting simple paths, configuration arrays, and namespace mappings.

```php
'directories' => [
    app_path('Http/Controllers'),
    app_path('Http/Controllers/Admin'),
],
```

```php
'directories' => [
    app_path('Http/Controllers/Api') => [
        'prefix' => 'api',
        'middleware' => ['api'],
    ],
],
```

```php
'directories' => [
    'Modules\Admin\Http\Controllers\' => base_path('modules/Admin/Http/Controllers'),
    base_path('custom/controllers') => [
        'namespace' => 'App\Custom\Controllers\',
    ],
],
```

--------------------------------

### Publish Configuration

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/00-START-HERE.md

Run this command to publish the package configuration file to your Laravel project.

```bash
php artisan vendor:publish --provider="Spatie\RouteAttributes\RouteAttributesServiceProvider" --tag="config"
```

--------------------------------

### Publish Configuration File

Source: https://github.com/spatie/laravel-route-attributes/blob/main/README.md

Publish the package's configuration file using the Artisan vendor:publish command.

```bash
php artisan vendor:publish --provider="Spatie\RouteAttributes\RouteAttributesServiceProvider" --tag="config"
```

--------------------------------

### Any Attribute

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/RouteAttributes.md

Registers a route that responds to all HTTP verbs.

```APIDOC
## #[Any(string $uri, ?string $name, array|string $middleware, array|string $withoutMiddleware)]

### Description
Registers a route that responds to all HTTP verbs.

### Parameters
- **$uri** (string) - Required - URI path
- **$name** (string|null) - Optional - Route name
- **$middleware** (array|string) - Optional - Middleware to apply
- **$withoutMiddleware** (array|string) - Optional - Middleware to exclude

### Example
```php
class WebhookController
{
    #[Any('webhook/incoming')]
    public function handle(Request $request) {}
}
```
```

--------------------------------

### Configure API Versioning

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/configuration.md

Manage multiple API versions by mapping specific directories to unique prefixes and middleware.

```php
return [
    'directories' => [
        app_path('Http/Controllers/Api/V1') => [
            'prefix' => 'api/v1',
            'middleware' => ['api', 'api.v1'],
        ],
        app_path('Http/Controllers/Api/V2') => [
            'prefix' => 'api/v2',
            'middleware' => ['api', 'api.v2'],
        ],
        app_path('Http/Controllers/Api/V3') => [
            'prefix' => 'api/v3',
            'middleware' => ['api', 'api.v3'],
        ],
    ],
    'middleware' => [SubstituteBindings::class],
];
```

--------------------------------

### Initialize RouteRegistrar

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/RouteRegistrar.md

Create a new instance of the registrar by passing the Laravel router.

```php
$registrar = new RouteRegistrar($router);
```

--------------------------------

### Automatically Registered Routes with Class and Method Middleware

Source: https://github.com/spatie/laravel-route-attributes/blob/main/README.md

These routes demonstrate how middleware applied at the class level and method level are combined.

```php
Route::get('my-route', [MyController::class, 'firstMethod'])->middleware(MyMiddleware::class);
Route::get('my-other-route', [MyController::class, 'secondMethod'])->middleware([MyMiddleware::class, MyOtherMiddleware::class]);
```

--------------------------------

### Configure Global ScopeBindings Default

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/SpecializedAttributes.md

Setting the default behavior in the package configuration file.

```php
// config/route-attributes.php
return [
    'scope-bindings' => null,  // null = use Laravel default
];
```

--------------------------------

### Register method definition

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/RouteAttributesServiceProvider.md

The register method is responsible for merging package configuration with application defaults before the boot process.

```php
public function register()
```

--------------------------------

### Automatically Registered Route with Custom Name

Source: https://github.com/spatie/laravel-route-attributes/blob/main/README.md

This is the route automatically registered by the `Get` attribute with the specified `name` parameter.

```php
Route::get('my-route', [MyController::class, 'myMethod'])->name('my-route-name');
```

--------------------------------

### Configure Environment-Specific Routes

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/configuration.md

Adjust controller registration directories based on the current application environment.

```php
return [
    'enabled' => env('REGISTER_ROUTE_ATTRIBUTES', true),
    'directories' => env('APP_ENV') === 'production'
        ? [app_path('Http/Controllers')]
        : [
            app_path('Http/Controllers'),
            app_path('Http/Controllers/Dev'),
        ],
    'middleware' => [SubstituteBindings::class],
];
```

--------------------------------

### Configure Route Directories

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/00-START-HERE.md

Specify the directories where the package should scan for route attributes in the configuration file.

```php
'directories' => [
    app_path('Http/Controllers'),
],
```

--------------------------------

### Register Route for All HTTP Verbs

Source: https://github.com/spatie/laravel-route-attributes/blob/main/README.md

Use the `Any` attribute to register a route that responds to all standard HTTP verbs.

```php
#[Spatie\RouteAttributes\Attributes\Any('my-uri')]
```

--------------------------------

### Configure Multi-Tenant API Routes

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/configuration.md

Define API routes across multiple subdomains using configuration and controller attributes.

```php
return [
    'enabled' => true,
    'directories' => [
        app_path('Http/Controllers/Api') => [
            'prefix' => 'api/v1',
            'middleware' => ['api', 'throttle:60,1'],
        ],
    ],
    'middleware' => [SubstituteBindings::class],
];
```

```php
#[Group(domain: 'api.example.com')]
#[Group(domain: 'api.staging.example.com')]
#[Prefix('api/v1')]
class ApiController {}
```

--------------------------------

### Configuration File Structure

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/RouteAttributesServiceProvider.md

The default structure of the published config/route-attributes.php file.

```php
return [
    'enabled' => true,
    'directories' => [
        app_path('Http/Controllers'),
        app_path('Http/Controllers/Api') => [
            'prefix' => 'api',
            'middleware' => 'api',
            'patterns' => ['*Controller.php'],
            'not_patterns' => [],
        ],
    ],
    'middleware' => [
        SubstituteBindings::class,
    ],
    'scope-bindings' => null,
];
```

--------------------------------

### Retrieve parameters configuration

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/ClassRouteAttributes.md

Returns the parameters option for custom resource parameter binding.

```php
public function parameters(): array|string|null
```

--------------------------------

### Configure Route Attributes with Environment Variables

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/configuration.md

Use environment variables to dynamically set configuration values for route discovery and middleware.

```php
return [
    'enabled' => env('ROUTE_ATTRIBUTES_ENABLED', true),

    'directories' => [
        app_path('Http/Controllers'),

        app_path('Http/Controllers/Api') => [
            'prefix' => env('API_PREFIX', 'api'),
            'middleware' => [env('API_MIDDLEWARE', 'api')],
        ],
    ],

    'middleware' => [
        SubstituteBindings::class,
    ],

    'scope-bindings' => env('ROUTE_SCOPE_BINDINGS', null),
];
```

```env
ROUTE_ATTRIBUTES_ENABLED=true
API_PREFIX=api/v1
API_MIDDLEWARE=api,throttle:60,1
ROUTE_SCOPE_BINDINGS=true
```

--------------------------------

### RouteRegistrar::__construct

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/RouteRegistrar.md

Initializes a new instance of the RouteRegistrar service.

```APIDOC
## __construct(Router $router)

### Description
Initialize a new RouteRegistrar instance.

### Parameters
- **$router** (Illuminate\Routing\Router) - Required - The Laravel router instance.
```

--------------------------------

### Apply Prefixes and Middleware

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/REFERENCE.md

Use class-level attributes to apply prefixes and middleware to all routes defined within the controller.

```php
use Spatie\RouteAttributes\Attributes\Prefix;
use Spatie\RouteAttributes\Attributes\Middleware;
use Spatie\RouteAttributes\Attributes\Get;
use Spatie\RouteAttributes\Attributes\Post;

#[Prefix('api/v1')]
#[Middleware(['api', 'auth'])]
class ApiController
{
    #[Get('users')]
    public function index() {}
    
    #[Post('users')]
    public function store(Request $request) {}
}
```

--------------------------------

### Register Directories

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/RouteRegistrar.md

Scan one or more directories for controller files, optionally using glob patterns for inclusion or exclusion.

```php
// Register all routes in a single directory
$registrar->registerDirectory(app_path('Http/Controllers'));

// Register with file patterns
$registrar->registerDirectory(
    app_path('Http/Controllers'),
    ['*Controller.php'],
    ['*Test.php']
);

// Register multiple directories
$registrar->registerDirectory([
    app_path('Http/Controllers'),
    app_path('Http/Controllers/Api'),
]);
```

--------------------------------

### Internal RouteRegistrar integration

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/RouteAttributesServiceProvider.md

Demonstrates how the service provider initializes and uses the RouteRegistrar internally.

```php
$routeRegistrar = $this->app->make(RouteRegistrar::class, [app()->router])
    ->useMiddleware(config('route-attributes.middleware') ?? []);

// For each directory configuration:
$routeRegistrar
    ->useRootNamespace($namespace)
    ->useBasePath($path)
    ->registerDirectory($directory);
```

--------------------------------

### Initialize ClassRouteAttributes

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/ClassRouteAttributes.md

Instantiate the class by passing a ReflectionClass instance of the target controller.

```php
$reflection = new ReflectionClass(UserController::class);
$classAttrs = new ClassRouteAttributes($reflection);
```

--------------------------------

### Default Configuration

Source: https://github.com/spatie/laravel-route-attributes/blob/main/README.md

The default configuration file enables route registration and specifies directories to scan for controller attributes. It supports nested configurations for middleware and prefixes.

```php
return [
    /*
     *  Automatic registration of routes will only happen if this setting is `true`
     */
    'enabled' => true,

    /*
     * Controllers in these directories that have routing attributes
     * will automatically be registered.
     *
     * Optionally, you can specify group configuration by using key/values
     */
    'directories' => [
        app_path('Http/Controllers'),

        app_path('Http/Controllers/Web') => [
            'middleware' => ['web']
        ],

        app_path('Http/Controllers/Api') => [
            'prefix' => 'api',
            'middleware' => 'api'
        ],
    ],
];
```

--------------------------------

### Define Directory Configuration Array

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/types.md

Structure when configuring a directory in config/route-attributes.php.

```php
[
    'prefix' => ?string,         // URL prefix for routes in this directory
    'middleware' => array|string, // Middleware to apply
    'namespace' => ?string,      // PHP namespace for classes
    'patterns' => ?array,        // Glob patterns to include (e.g., ['*Controller.php'])
    'not_patterns' => ?array,    // Glob patterns to exclude (e.g., ['*Test.php'])
]
```

--------------------------------

### Documentation File Structure

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/00-START-HERE.md

Visual representation of the documentation directory layout.

```text
output/
├── 00-START-HERE.md                 ← Navigation guide
├── INDEX.md                         ← Full index & matrix
├── REFERENCE.md                     ← Architecture overview
├── configuration.md                 ← Config reference
├── types.md                         ← Type definitions
└── api-reference/                   ← 8 detailed API files
    ├── RouteRegistrar.md
    ├── RouteAttributes.md
    ├── ClassModifiersAttributes.md
    ├── ResourceAttributes.md
    ├── GroupAttributes.md
    ├── SpecializedAttributes.md
    ├── ClassRouteAttributes.md
    └── RouteAttributesServiceProvider.md
```

--------------------------------

### Configure Enabled Status

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/configuration.md

Toggle automatic route registration using the enabled key.

```php
return [
    'enabled' => env('ROUTE_ATTRIBUTES_ENABLED', true),
];
```

--------------------------------

### Configure Modular Architecture Routes

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/configuration.md

Register controllers from multiple feature modules with specific prefixes and middleware.

```php
return [
    'directories' => [
        'Modules\Users\Http\Controllers\' => base_path('modules/Users/Http/Controllers'),
        'Modules\Blog\Http\Controllers\' => base_path('modules/Blog/Http/Controllers'),
        'Modules\Shop\Http\Controllers\' => base_path('modules/Shop/Http/Controllers'),
        'Modules\Admin\Http\Controllers\' => base_path('modules/Admin/Http/Controllers') => [
            'prefix' => 'admin',
            'middleware' => ['admin'],
        ],
    ],
    'middleware' => [SubstituteBindings::class],
];
```

--------------------------------

### Combine ApiResource with Prefix and Middleware

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/ResourceAttributes.md

Applies API resource routing under a specific prefix with required authentication and verification middleware.

```php
use Spatie\RouteAttributes\Attributes\Prefix;
use Spatie\RouteAttributes\Attributes\Middleware;
use Spatie\RouteAttributes\Attributes\ApiResource;

#[Prefix('api/v1')]
#[Middleware(['auth', 'verified'])]
#[ApiResource('articles')]
class ArticleController
{
    public function index() {}
    public function store(Request $request) {}
    public function show(Article $article) {}
    public function update(Request $request, Article $article) {}
    public function destroy(Article $article) {}
}
// All API resource routes are registered under /api/v1/articles
// with auth and verified middleware applied
```

--------------------------------

### Resource Constructor Signature

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/ResourceAttributes.md

The constructor parameters available for configuring the Resource attribute.

```php
public function __construct(
    public string $resource,
    public bool $apiResource = false,
    public array|string|null $except = null,
    public array|string|null $only = null,
    public array|string|null $names = null,
    public array|string|null $parameters = null,
    public ?bool $shallow = null,
)
```

--------------------------------

### Options Attribute

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/RouteAttributes.md

Registers a route that responds to OPTIONS requests using the #[Options] attribute.

```APIDOC
## #[Options]

### Description
Registers a route that responds to OPTIONS requests.

### Parameters
- **$uri** (string) - Required - URI path
- **$name** (string|null) - Optional - Route name
- **$middleware** (array|string) - Optional - Middleware to apply

### Example
```php
class UserController
{
    #[Options('users')]
    public function options() {}
}
```
```

--------------------------------

### Define an OPTIONS route attribute

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/RouteAttributes.md

Use the Options attribute to register a method for OPTIONS requests. The constructor accepts the URI, route name, and middleware.

```php
#[Attribute(Attribute::TARGET_METHOD | Attribute::IS_REPEATABLE)]
class Options extends Route
```

```php
public function __construct(
    string $uri,
    ?string $name = null,
    array|string $middleware = [],
)
```

```php
class UserController
{
    #[Options('users')]
    public function options() {}
}
```

--------------------------------

### Manage Route Caching

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/configuration.md

Use artisan commands to cache or clear routes, which automatically handles the registration state.

```bash
# Cache routes for production
php artisan route:cache

# Clear cache to re-register routes
php artisan route:clear
```

--------------------------------

### Where Constructor Signature

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/ClassModifiersAttributes.md

The constructor requires the parameter name and the regex constraint string.

```php
public function __construct(
    public string $param,
    public string $constraint,
)
```

--------------------------------

### Basic Resource Registration

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/ResourceAttributes.md

Registers all standard RESTful routes for the specified resource.

```php
use Spatie\
\nouteAttributes\
\ttributes\
\esource;

#[Resource('posts')]
class PostController
{
    public function index() {}
    public function create() {}
    public function store(Request $request) {}
    public function show(Post $post) {}
    public function edit(Post $post) {}
    public function update(Request $request, Post $post) {}
    public function destroy(Post $post) {}
}
```

--------------------------------

### Register routes on dynamic subdomains

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/GroupAttributes.md

Applies the same controller logic across multiple distinct domains.

```php
#[Group(domain: 'api.example.com')]
#[Group(domain: 'api.staging.example.com')]
#[Group(domain: 'api.local')]
class ApiController
{
    #[Get('users')]
    public function index() {}

    #[Post('users')]
    public function store(Request $request) {}
}
// Routes work on all three domains
```

--------------------------------

### External module controller registration

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/RouteAttributesServiceProvider.md

Maps specific namespaces to external package or module directory paths.

```php
return [
    'directories' => [
        'Modules\Blog\Http\Controllers\' => base_path('modules/Blog/Http/Controllers'),
        'Modules\Shop\Http\Controllers\' => base_path('modules/Shop/Http/Controllers'),
    ],
];
```

--------------------------------

### Prefix route names using Group attributes

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/GroupAttributes.md

Use the 'as' parameter in the Group attribute to prepend a string to route names.

```php
#[Group(prefix: 'admin', as: 'admin.')]
#[Group(prefix: 'api', as: 'api.')]
class ResourceController
{
    #[Get('items', name: 'items')]
    public function index() {}

    #[Get('items/{id}', name: 'show')]
    public function show($id) {}
}
// Registers:
// GET /admin/items -> named 'admin.items'
// GET /admin/items/{id} -> named 'admin.show'
// GET /api/items -> named 'api.items'
// GET /api/items/{id} -> named 'api.show'
```

--------------------------------

### Group Routes with Domain and Prefix

Source: https://github.com/spatie/laravel-route-attributes/blob/main/README.md

Use the `Group` annotation on a class to apply common domains and prefixes to all routes within that class.

```php
use Spatie\RouteAttributes\Attributes\Get;
use Spatie\RouteAttributes\Attributes\Post;
use Spatie\RouteAttributes\Attributes\Domain;

#[Group(domain: 'my-subdomain.localhost', prefix: 'my-prefix')]
#[Group(domain: 'my-second-subdomain.localhost', prefix: 'my-second-prefix')]
class MyController
{
    #[Get('my-get-route')]
    public function myGetMethod()
    {
    }

    #[Post('my-post-route')]
    public function myPostMethod()
    {
    }
}
```

--------------------------------

### Implement multi-tenant routing

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/GroupAttributes.md

Uses domain-specific groups to isolate routes for different tenants.

```php
#[Group(domain: 'tenant1.local', prefix: 'api')]
#[Group(domain: 'tenant2.local', prefix: 'api')]
class TenantApiController
{
    #[Get('resources')]
    public function index() {}

    #[Get('resources/{id}')]
    public function show($id) {}
}
// Registers on both tenant1.local and tenant2.local domains
// Each tenant has isolated routes under /api prefix
```

--------------------------------

### Define Prefix Attribute

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/ClassModifiersAttributes.md

The Prefix attribute definition and constructor signature.

```php
#[Attribute(Attribute::TARGET_CLASS)]
class Prefix implements RouteAttribute
```

```php
public function __construct(
    public string $prefix
)
```

--------------------------------

### Retrieve withTrashed configuration

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/ClassRouteAttributes.md

Returns true if soft-deleted models should be included, false otherwise.

```php
public function withTrashed(): bool
```

```php
#[WithTrashed]
class RestoreController {}

$withTrashed = $classAttrs->withTrashed(); // Returns true
```

--------------------------------

### Specify Route Domain from Config

Source: https://github.com/spatie/laravel-route-attributes/blob/main/README.md

Define route domains using configuration values by utilizing the DomainFromConfig annotation. This allows for environment-specific domain settings.

```php
// config/domains.php
return [
    'main' => env('SITE_URL', 'example.com'),
    'subdomain' => env('SUBDOMAIN_URL', 'subdomain.example.com')
];
```

```php
use Spatie\RouteAttributes\Attributes\Get;
use Spatie\RouteAttributes\Attributes\Post;
use Spatie\RouteAttributes\Attributes\DomainFromConfig;

#[DomainFromConfig('domains.main')]
class MyController
{
    #[Get('my-get-route')]
    public function myGetMethod()
    {
    }
}
```

```php
Route::get('my-get-route', [MyController::class, 'myGetMethod'])->domain('example.com');
```

--------------------------------

### Manual ScopeBindings Registration

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/SpecializedAttributes.md

Equivalent manual route registration for enabling or disabling scoped bindings.

```php
// Enable scoped bindings
Route::get('posts/{post}/comments/{comment}', [CommentController::class, 'show'])
    ->scopeBindings();

// Disable scoped bindings
Route::get('posts/{post}/comments/{comment}', [CommentController::class, 'show'])
    ->withoutScopedBindings();
```

--------------------------------

### Retrieve shallow nesting configuration

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/ClassRouteAttributes.md

Returns the shallow option for nested resource routes.

```php
public function shallow(): ?bool
```

--------------------------------

### Configure Fine-Grained File Filtering

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/configuration.md

Restrict controller registration using glob patterns to include or exclude specific files.

```php
return [
    'directories' => [
        base_path('app/Http/Controllers') => [
            // Only register files ending with Controller.php
            'patterns' => ['*Controller.php'],
            // Exclude test files
            'not_patterns' => ['*Test.php'],
        ],
    ],
];
```

--------------------------------

### ReflectionClass Usage

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/types.md

Basic usage of PHP's reflection API to inspect class metadata and methods.

```php
use ReflectionClass;

$reflection = new ReflectionClass(UserController::class);
$reflection->getName();           // Get class name
$reflection->getMethods();        // Get all methods
```

--------------------------------

### Configure Global Middleware

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/configuration.md

Define middleware applied to all routes registered via attributes.

```php
use Illuminate\Routing\Middleware\SubstituteBindings;

return [
    'middleware' => [
        SubstituteBindings::class,
        'throttle:60,1',
    ],
];
```

--------------------------------

### Apply parameter constraints

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/RouteRegistrar.md

Applies parameter constraints to a route if available.

```php
public function setWheresIfAvailable(ClassRouteAttributes $classRouteAttributes, array $wheresAttributes, Route $route): void
```

--------------------------------

### Set Base Path

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/RouteRegistrar.md

Define the absolute file system path to scan for controller files.

```php
$registrar->useBasePath(app_path('Http/Controllers'));
```

--------------------------------

### Retrieve scope bindings configuration

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/ClassRouteAttributes.md

Returns the configuration for scoped bindings, or null if not set.

```php
public function scopeBindings(): ?bool
```

```php
#[ScopeBindings(true)]
class CommentController {}

$scoped = $classAttrs->scopeBindings(); // Returns true
```

--------------------------------

### Implement Basic API Resource

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/ResourceAttributes.md

Registers standard API routes for a controller using the ApiResource attribute.

```php
use Spatie
outeAttributes\Attributes\
ApiResource;

#[Prefix('api/v1')]
#[ApiResource('posts')]
class PostController
{
    public function index() {}
    public function store(Request $request) {}
    public function show(Post $post) {}
    public function update(Request $request, Post $post) {}
    public function destroy(Post $post) {}
}
```

--------------------------------

### Implement API versioning with Group attributes

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/GroupAttributes.md

Apply multiple Group attributes to a controller to register the same methods under different versioned prefixes.

```php
#[Group(prefix: 'api/v1', as: 'api.v1.')]
#[Group(prefix: 'api/v2', as: 'api.v2.')]
class UserController
{
    #[Get('users')]
    public function index() {}

    #[Get('users/{id}')]
    public function show($id) {}
}
// Registers:
// GET /api/v1/users (named: api.v1.users)
// GET /api/v1/users/{id} (named: api.v1.users.show)
// GET /api/v2/users (named: api.v2.users)
// GET /api/v2/users/{id} (named: api.v2.users.show)
```

--------------------------------

### Namespace mapping configuration

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/RouteAttributesServiceProvider.md

Explicitly maps directory paths to specific namespaces for non-standard controller locations.

```php
return [
    'directories' => [
        // Path-based with explicit namespace
        base_path('custom/controllers') => [
            'namespace' => 'App\Custom\Controllers\',
        ],
        // Or as namespace => path
        'App\Custom\Controllers\' => base_path('custom/controllers'),
    ],
];
```

--------------------------------

### Combined Usage of Specialized Attributes

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/SpecializedAttributes.md

Demonstrates applying multiple attributes at both the class and method levels to manage route scoping and soft-deleted model access.

```php
use Spatie\RouteAttributes\Attributes\Get;
use Spatie\RouteAttributes\Attributes\Post;
use Spatie\RouteAttributes\Attributes\Put;
use Spatie\RouteAttributes\Attributes\Delete;
use Spatie\RouteAttributes\Attributes\ScopeBindings;
use Spatie\RouteAttributes\Attributes\WithTrashed;
use Spatie\RouteAttributes\Attributes\Prefix;

#[Prefix('admin')]
#[ScopeBindings(true)]
#[WithTrashed(true)]
class AdminCommentController
{
    #[Get('posts/{post}/comments')]
    public function index(Post $post)
    {
        // Scoped: comments belong to post
        // WithTrashed: post can be soft-deleted
    }

    #[Get('posts/{post}/comments/{comment}')]
    public function show(Post $post, Comment $comment)
    {
        // Both inherited from class level
    }

    #[Put('posts/{post}/comments/{comment}')]
    public function update(Post $post, Comment $comment)
    {
        // Both inherited from class level
    }

    #[Delete('posts/{post}/comments/{comment}')]
    public function destroy(Post $post, Comment $comment)
    {
        // Both inherited from class level
    }

    #[Get('posts/{post}')]
    #[ScopeBindings(false)]
    #[WithTrashed(false)]
    public function postDetail(Post $post)
    {
        // Overrides class-level settings
        // Not scoped, excludes trashed posts
    }
}
```

--------------------------------

### Equivalent Manual Route Registration

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/SpecializedAttributes.md

Manual route registration equivalent to using the WithTrashed attribute.

```php
// Include soft-deleted models
Route::get('posts/{post}/restore', [PostController::class, 'restore'])
    ->withTrashed();

// Exclude soft-deleted models (default)
Route::get('posts/{post}', [PostController::class, 'show'])
    ->withTrashed(false);
```

--------------------------------

### API and Web controller separation

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/RouteAttributesServiceProvider.md

Applies different middleware and route prefixes based on the directory path.

```php
return [
    'enabled' => true,
    'directories' => [
        app_path('Http/Controllers/Web') => [
            'middleware' => ['web'],
        ],
        app_path('Http/Controllers/Api') => [
            'prefix' => 'api/v1',
            'middleware' => ['api'],
        ],
    ],
    'middleware' => [SubstituteBindings::class],
];
```

--------------------------------

### Define Middleware Array

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/types.md

Middleware can be specified as a string or array.

```php
// Single middleware
'middleware' => 'auth'

// Multiple middleware
'middleware' => ['auth', 'verified', 'admin']

// Middleware with parameters
'middleware' => 'throttle:60,1'
```

--------------------------------

### Apply Middleware to Routes

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/INDEX.md

Pass an array of middleware aliases to the middleware parameter of the route attribute.

```php
#[Get('dashboard', middleware: ['auth', 'verified'])]
public function dashboard() {}
```

--------------------------------

### Define DomainFromConfig Attribute

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/ClassModifiersAttributes.md

Defines the DomainFromConfig attribute class and its constructor signature.

```php
#[Attribute(Attribute::TARGET_CLASS)]
class DomainFromConfig implements RouteAttribute
```

```php
public function __construct(
    public string $domain
)
```

--------------------------------

### Custom Parameter Binding

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/ResourceAttributes.md

Configures custom parameter bindings for resource routes.

```php
#[Resource(
    resource: 'users.posts',
    parameters: ['users' => 'user:uuid', 'posts' => 'post:slug']
)]
class UserPostController
{
    public function show(User $user, Post $post) {}
}
// Uses UUID for user parameter and slug for post parameter
```

--------------------------------

### Define Routes for Various HTTP Verbs

Source: https://github.com/spatie/laravel-route-attributes/blob/main/README.md

Use specific attributes for each HTTP verb like Post, Put, Patch, Delete, and Options to define routes for controller methods.

```php
#[Spatie\RouteAttributes\Attributes\Post('my-uri')]
#[Spatie\RouteAttributes\Attributes\Put('my-uri')]
#[Spatie\RouteAttributes\Attributes\Patch('my-uri')]
#[Spatie\RouteAttributes\Attributes\Delete('my-uri')]
#[Spatie\RouteAttributes\Attributes\Options('my-uri')]
```

--------------------------------

### Define Route Class Structure

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/types.md

Base class properties for defining route attributes.

```php
namespace Spatie
outeAttributes	ributes;

class Route implements RouteAttribute
{
    public array $methods;           // HTTP methods in uppercase
    public array $middleware;        // Middleware to apply
    public array $withoutMiddleware; // Middleware to exclude
    public string $uri;              // Route URI
    public ?string $name;            // Route name
}
```

--------------------------------

### Apply default parameter values

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/RouteRegistrar.md

Sets default values for optional route parameters if available.

```php
public function setDefaultsIfAvailable(ClassRouteAttributes $classRouteAttributes, array $defaultAttributes, Route $route): void
```

--------------------------------

### Apply Middleware to All Class Methods

Source: https://github.com/spatie/laravel-route-attributes/blob/main/README.md

Use the `Middleware` attribute on a controller class to apply middleware to all methods within that class. Individual methods can still override or add middleware.

```php
use Spatie\RouteAttributes\Attributes\Get;
use Spatie\RouteAttributes\Attributes\Middleware;

#[Middleware(MyMiddleware::class)]
class MyController
{
    #[Get('my-route')]
    public function firstMethod()
    {
    }

    #[Get('my-other-route', middleware: MyOtherMiddleware::class)]
    public function secondMethod()
    {
    }
}
```

--------------------------------

### Integrate ClassRouteAttributes in RouteRegistrar

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/ClassRouteAttributes.md

Demonstrates how to extract route configuration from a controller class using reflection and the ClassRouteAttributes helper.

```php
$reflection = new ReflectionClass($controllerClass);
$classAttrs = new ClassRouteAttributes($reflection);

// Get group configuration
foreach ($classAttrs->groups() as $group) {
    $this->router->group($group, function () {
        // Register routes in this group
    });
}

// Check if it's a resource controller
if ($classAttrs->resource()) {
    $this->registerResource($reflection, $classAttrs);
}

// Get class-level middleware
$classMiddleware = $classAttrs->middleware();

// Get parameter constraints
$wheres = $classAttrs->wheres();
```

--------------------------------

### Group Routes for Multi-Version APIs

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/INDEX.md

Apply multiple Group attributes to a class to register the same controller methods under different route prefixes.

```php
#[Group(prefix: 'api/v1', as: 'api.v1.')]
#[Group(prefix: 'api/v2', as: 'api.v2.')]
class ResourceController {
    #[Get('items')]
    public function index() {}
}
```

--------------------------------

### Group route registration

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/RouteRegistrar.md

Wraps route registration within a group using specified options like prefix or middleware.

```php
public function group(array $options, $routes): self
```

```php
$registrar->group(['prefix' => 'api'], function () {
    $registrar->registerDirectory(app_path('Http/Controllers/Api'));
});
```

--------------------------------

### Illuminate\Routing\Route Configuration

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/types.md

Methods for configuring individual route properties such as names, middleware, and bindings.

```php
use Illuminate\
Routing\Route;

// Methods:
$route->name($name);
$route->middleware($middleware);
$route->setWheres($patterns);
$route->setDefaults($defaults);
$route->scopeBindings();
$route->withoutScopedBindings();
$route->withTrashed();
$route->fallback();
```

--------------------------------

### Constructor signature for Route attribute

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/RouteAttributes.md

The constructor signature for the base Route attribute.

```php
public function __construct(
    array|string $methods,
    string $uri,
    ?string $name = null,
    array|string $middleware = [],
    array|string $withoutMiddleware = [],
)
```

--------------------------------

### Register Resource Controllers with Customizations

Source: https://github.com/spatie/laravel-route-attributes/blob/main/README.md

Use the Resource attribute to register resource controllers. Customize available actions with 'only' or 'except', modify default parameters, set route names, enable shallow nesting, or designate API resources.

```php
use Spatie\RouteAttributes\Attributes\Resource;

#[Prefix('api/v1')]
#[Resource(
    resource: 'photos.comments',
    apiResource: true,
    shallow: true,
    parameters: ['comments' => 'comment:uuid'],
    names: 'api.v1.photoComments',
    except: ['destroy'],
)]
// OR #[ApiResource(resource: 'photos.comments', shallow: true, ...)]
class PhotoCommentController
{
    public function index(Photo $photo)
    {
    }

    public function store(Request $request, Photo $photo)
    {
    }

    public function show(Comment $comment)
    {
    }

    public function update(Request $request, Comment $comment)
    {
    }
}
```

--------------------------------

### Set Global Middleware

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/RouteRegistrar.md

Apply global middleware to all routes registered by the instance.

```php
$registrar->useMiddleware(['api', SubstituteBindings::class]);
```

--------------------------------

### Middleware

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/ClassModifiersAttributes.md

Applies specified middleware to all routes defined within a controller class.

```APIDOC
## #[Middleware(string|array $middleware)]

### Description
Apply middleware to all routes in a controller class.

### Parameters
- **$middleware** (string|array) - Optional - Middleware class(es) to apply. Defaults to [].

### Example
#[Middleware(['auth', 'verified'])]
class DashboardController { ... }
```

--------------------------------

### Register Routes with Parameter Constraints

Source: https://github.com/spatie/laravel-route-attributes/blob/main/README.md

These annotations automatically register routes with specified parameter constraints.

```php
Route::get('my-get-route/{my-where}', [MyController::class, 'myGetMethod'])->where(['my-where' => '[0-9]+']);
Route::post('my-post-route/{my-where}/{my-alpha-numeric}', [MyController::class, 'myPostMethod'])->where(['my-where' => '[0-9]+', 'my-alpha-numeric' => '[a-zA-Z0-9]+']);
```

--------------------------------

### Define the Any attribute class

Source: https://github.com/spatie/laravel-route-attributes/blob/main/_autodocs/api-reference/RouteAttributes.md

The Any attribute class definition for handling all HTTP verbs.

```php
#[Attribute(Attribute::TARGET_METHOD | Attribute::IS_REPEATABLE)]
class Any extends Route
```

--------------------------------

### Convenience Helper Attributes for Route Constraints

Source: https://github.com/spatie/laravel-route-attributes/blob/main/README.md

Helper attributes provide quick ways to add common regular expression pattern constraints to routes.

```php
#[WhereAlpha('alpha')]
#[WhereAlphaNumeric('alpha-numeric')]
#[WhereIn('in', ['value1', 'value2'])]
#[WhereNumber('number')]
#[WhereUlid('ulid')]
#[WhereUuid('uuid')]
```
Tokens:
Raw