Создаем RESTful API с Laravel

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=laravel_api
DB_USERNAME=root
DB_PASSWORD=password

public function up()
{
    Schema::create('books', function (Blueprint $table) {
        $table->id();
        $table->string('title');
        $table->text('description');
        $table->unsignedBigInteger('author_id');
        $table->foreign('author_id')->references('id')->on('authors');
        $table->timestamps();
    });
}

protected $middleware = [
    // ...
    \Fruitcake\Cors\HandleCors::class,
];

return [
    'paths' => ['api/*'],
    'allowed_methods' => ['*'],
    'allowed_origins' => ['*'],
    'allowed_origins_patterns' => [],
    'allowed_headers' => ['*'],
    'exposed_headers' => [],
    'max_age' => 0,
    'supports_credentials' => false,
];

namespace App\Models;
 
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;
 
class Book extends Model
{
    use HasFactory;
    
    // Поля, доступные для массового заполнения
    protected $fillable = [
        'title',
        'description',
        'author_id'
    ];
    
    // Отношения с другими моделями
    public function author()
    {
        return $this->belongsTo(Author::class);
    }
}

protected $hidden = [
    'created_at',
    'updated_at'
];

namespace App\Http\Controllers\API;
 
use App\Http\Controllers\Controller;
use App\Models\Book;
use Illuminate\Http\Request;
 
class BookController extends Controller
{
    public function index()
    {
        $books = Book::all();
        return response()->json($books);
    }
    
    public function store(Request $request)
    {
        $request->validate([
            'title' => 'required|string|max:255',
            'description' => 'required|string',
            'author_id' => 'required|exists:authors,id'
        ]);
        
        $book = Book::create($request->all());
        
        return response()->json($book, 201);
    }
    
    public function show(Book $book)
    {
        return response()->json($book);
    }
    
    public function update(Request $request, Book $book)
    {
        $request->validate([
            'title' => 'sometimes|required|string|max:255',
            'description' => 'sometimes|required|string',
            'author_id' => 'sometimes|required|exists:authors,id'
        ]);
        
        $book->update($request->all());
        
        return response()->json($book);
    }
    
    public function destroy(Book $book)
    {
        $book->delete();
        
        return response()->json(null, 204);
    }
}

use App\Http\Controllers\API\BookController;
 
Route::apiResource('books', BookController::class);

Route::group(['prefix' => 'v1', 'namespace' => 'API'], function () {
    Route::apiResource('books', BookController::class);
    Route::apiResource('authors', AuthorController::class);
    
    Route::get('books/{book}/author', [BookController::class, 'author']);
});

Route::get('books/{book}', [BookController::class, 'show']);

public function index(Request $request)
{
    $perPage = $request->query('per_page', 15); // По умолчанию 15 элементов на страницу
    
    $books = Book::paginate($perPage);
    
    return response()->json($books);
}

public function index(Request $request)
{
    $query = Book::query();
    
    // Фильтрация по названию
    if ($request->has('title')) {
        $query->where('title', 'like', '%' . $request->title . '%');
    }
    
    // Фильтрация по автору
    if ($request->has('author_id')) {
        $query->where('author_id', $request->author_id);
    }
    
    // Сортировка
    $sortBy = $request->query('sort_by', 'created_at');
    $sortDirection = $request->query('sort_direction', 'desc');
    $query->orderBy($sortBy, $sortDirection);
    
    $books = $query->paginate(15);
    
    return response()->json($books);
}

Route::group(['prefix' => 'v1'], function () {
    Route::apiResource('books', 'API\V1\BookController');
});
 
Route::group(['prefix' => 'v2'], function () {
    Route::apiResource('books', 'API\V2\BookController');
});

Route::group(['middleware' => 'api.version:v1'], function () {
    Route::apiResource('books', 'API\V1\BookController');
});
 
Route::group(['middleware' => 'api.version:v2'], function () {
    Route::apiResource('books', 'API\V2\BookController');
});

public function show(Book $book)
{
    $data = [
        'id' => $book->id,
        'title' => $book->title,
        'description' => $book->description,
        '_links' => [
            'self' => [
                'href' => route('books.show', $book->id)
            ],
            'author' => [
                'href' => route('authors.show', $book->author_id)
            ],
            'collection' => [
                'href' => route('books.index')
            ]
        ]
    ];
    
    return response()->json($data);
}

namespace App\Http\Middleware;
 
use Closure;
use Illuminate\Http\Request;
 
class ApiResponseMiddleware
{
    public function handle(Request $request, Closure $next)
    {
        $response = $next($request);
        
        // Проверяем, является ли ответ JSON
        if ($response->headers->get('Content-Type') === 'application/json') {
            $content = json_decode($response->getContent(), true);
            
            // Оборачиваем ответ в единую структуру
            $wrappedContent = [
                'status' => $response->getStatusCode(),
                'data' => $content,
                'timestamp' => now()->toIso8601String()
            ];
            
            $response->setContent(json_encode($wrappedContent));
        }
        
        return $response;
    }
}

protected $middlewareGroups = [
    'api' => [
        \App\Http\Middleware\ApiResponseMiddleware::class,
        'throttle:api',
        \Illuminate\Routing\Middleware\SubstituteBindings::class,
    ],
];

namespace App\Http\Requests;
 
use Illuminate\Foundation\Http\FormRequest;
 
class StoreBookRequest extends FormRequest
{
    public function authorize()
    {
        return true; // Или проверка авторизации
    }
 
    public function rules()
    {
        return [
            'title' => 'required|string|max:255|unique:books',
            'description' => 'required|string',
            'author_id' => 'required|exists:authors,id',
            'categories' => 'sometimes|array',
            'categories.*' => 'exists:categories,id'
        ];
    }
    
    public function messages()
    {
        return [
            'title.required' => 'Название книги обязательно',
            'title.unique' => 'Книга с таким названием уже существует',
            'author_id.exists' => 'Указанный автор не найден'
        ];
    }
}

public function store(StoreBookRequest $request)
{
    $book = Book::create($request->validated());
    
    if ($request->has('categories')) {
        $book->categories()->attach($request->categories);
    }
    
    return response()->json($book, 201);
}

protected function failedValidation(Validator $validator)
{
    throw new HttpResponseException(
        response()->json([
            'status' => 'error',
            'message' => 'Ошибка валидации',
            'errors' => $validator->errors()
        ], 422)
    );
}

namespace App\Http\Resources;
 
use Illuminate\Http\Resources\Json\JsonResource;
 
class BookResource extends JsonResource
{
    public function toArray($request)
    {
        return [
            'id' => $this->id,
            'title' => $this->title,
            'description' => $this->description,
            'author' => new AuthorResource($this->whenLoaded('author')),
            'categories' => CategoryResource::collection($this->whenLoaded('categories')),
            'created_at' => $this->created_at->toDateTimeString(),
            'updated_at' => $this->updated_at->toDateTimeString(),
            // HATEOAS-ссылки
            'links' => [
                'self' => route('books.show', $this->id),
                'author' => route('authors.show', $this->author_id),
                'all_books' => route('books.index')
            ]
        ];
    }
}

namespace App\Http\Resources;
 
use Illuminate\Http\Resources\Json\ResourceCollection;
 
class BookCollection extends ResourceCollection
{
    public function toArray($request)
    {
        return [
            'data' => $this->collection,
            'meta' => [
                'total_count' => $this->collection->count(),
                'filters' => $request->query()
            ],
            'links' => [
                'self' => url()->current(),
            ]
        ];
    }
}

public function index()
{
    $books = Book::with(['author', 'categories'])->paginate(15);
    
    return new BookCollection($books);
}
 
public function show(Book $book)
{
    $book->load(['author', 'categories']);
    
    return new BookResource($book);
}

namespace App\Exceptions;
 
use Illuminate\Database\Eloquent\ModelNotFoundException;
use Illuminate\Foundation\Exceptions\Handler as ExceptionHandler;
use Illuminate\Validation\ValidationException;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
use Throwable;
 
class Handler extends ExceptionHandler
{
    public function render($request, Throwable $exception)
    {
        if ($request->expectsJson()) {
            if ($exception instanceof ModelNotFoundException) {
                return response()->json([
                    'status' => 'error',
                    'message' => 'Запрашиваемый ресурс не найден'
                ], 404);
            }
            
            if ($exception instanceof NotFoundHttpException) {
                return response()->json([
                    'status' => 'error',
                    'message' => 'Указанный URL не существует'
                ], 404);
            }
            
            if ($exception instanceof ValidationException) {
                return response()->json([
                    'status' => 'error',
                    'message' => 'Ошибка валидации',
                    'errors' => $exception->errors()
                ], 422);
            }
            
            // Другие типы исключений
            
            // Общий обработчик для всех остальных ошибок
            return response()->json([
                'status' => 'error',
                'message' => config('app.debug') ? $exception->getMessage() : 'Произошла ошибка на сервере'
            ], 500);
        }
        
        return parent::render($request, $exception);
    }
}

// Плохо: N+1 проблема
$books = Book::all();
foreach ($books as $book) {
    echo $book->author->name; // Дополнительный запрос для каждой книги
}
 
// Хорошо: одним запросом загружаем все связанные данные
$books = Book::with('author')->get();
foreach ($books as $book) {
    echo $book->author->name; // Данные уже загружены
}

public function index()
{
    $books = Book::with(['author', 'categories', 'reviews'])
                ->paginate(15);
                
    return BookResource::collection($books);
}

Schema::table('users', function (Blueprint $table) {
    $table->string('api_token', 80)
          ->unique()
          ->nullable()
          ->default(null);
});

$token = Str::random(60);
 
$user->forceFill([
    'api_token' => hash('sha256', $token),
])->save();
 
return response()->json(['token' => $token]);

Route::middleware('auth:api')->group(function () {
    Route::apiResource('books', BookController::class);
});

use Tymon\JWTAuth\Contracts\JWTSubject;
 
class User extends Authenticatable implements JWTSubject
{
    // Существующие методы...
    
    public function getJWTIdentifier()
    {
        return $this->getKey();
    }
    
    public function getJWTCustomClaims()
    {
        return [];
    }
}

public function login(Request $request)
{
    $credentials = $request->only('email', 'password');
    
    if (!$token = auth('api')->attempt($credentials)) {
        return response()->json(['error' => 'Unauthorized'], 401);
    }
    
    return $this->respondWithToken($token);
}
 
protected function respondWithToken($token)
{
    return response()->json([
        'access_token' => $token,
        'token_type' => 'bearer',
        'expires_in' => auth('api')->factory()->getTTL() * 60
    ]);
}

Route::middleware(['auth:api', 'can:manage-books'])->group(function () {
    Route::apiResource('books', BookController::class);
});

public function handle(Request $request, Closure $next, $role)
{
    if (!$request->user() || !$request->user()->hasRole($role)) {
        return response()->json(['error' => 'Access denied'], 403);
    }
    
    return $next($request);
}

Route::middleware(['auth:api', 'role:admin'])->group(function () {
    Route::apiResource('users', UserController::class);
});

public function update(User $user, Book $book)
{
    return $user->id === $book->user_id || $user->hasRole('editor');
}
 
public function delete(User $user, Book $book)
{
    return $user->id === $book->user_id || $user->hasRole('admin');
}

public function update(Request $request, Book $book)
{
    $this->authorize('update', $book);
    
    // Логика обновления...
}

use Laravel\Passport\Passport;
 
public function boot()
{
    $this->registerPolicies();
    
    Passport::routes();
    Passport::tokensExpireIn(now()->addDays(15));
    Passport::refreshTokensExpireIn(now()->addDays(30));
}

'guards' => [
    'api' => [
        'driver' => 'passport',
        'provider' => 'users',
    ],
],

public function login(Request $request)
{
    $credentials = $request->validate([
        'email' => 'required|email',
        'password' => 'required',
    ]);
    
    $request->request->add([
        'grant_type' => 'password',
        'client_id' => config('passport.password_client.id'),
        'client_secret' => config('passport.password_client.secret'),
        'username' => $credentials['email'],
        'password' => $credentials['password'],
        'scope' => '',
    ]);
    
    $tokenRequest = Request::create('/oauth/token', 'POST', $request->all());
    
    return app()->handle($tokenRequest);
}

Route::middleware(['throttle:60,1'])->group(function () {
    Route::apiResource('books', BookController::class);
});

// В RouteServiceProvider
protected function configureRateLimiting()
{
    RateLimiter::for('api', function (Request $request) {
        return $request->user()
            ? Limit::perMinute(100)->by($request->user()->id)
            : Limit::perMinute(20)->by($request->ip());
    });
}

// Публичные эндпойнты с высоким лимитом
Route::middleware(['throttle:public'])->group(function () {
    Route::get('books', [BookController::class, 'index']);
});
 
// Эндпойнты записи с более строгим лимитом
Route::middleware(['throttle:writes'])->group(function () {
    Route::post('books', [BookController::class, 'store']);
    Route::put('books/{book}', [BookController::class, 'update']);
    Route::delete('books/{book}', [BookController::class, 'destroy']);
});

Schema::table('users', function (Blueprint $table) {
    $table->string('two_factor_secret')->nullable();
    $table->boolean('two_factor_enabled')->default(false);
});

use PragmaRX\Google2FA\Google2FA;
 
$google2fa = new Google2FA();
$secretKey = $google2fa->generateSecretKey();
 
$user->two_factor_secret = $secretKey;
$user->save();

use BaconQrCode\Renderer\Image\SvgImageBackEnd;
use BaconQrCode\Renderer\ImageRenderer;
use BaconQrCode\Renderer\RendererStyle\RendererStyle;
use BaconQrCode\Writer;
 
$qrUrl = $google2fa->getQRCodeUrl(
    config('app.name'),
    $user->email,
    $user->two_factor_secret
);
 
$renderer = new ImageRenderer(
    new RendererStyle(200),
    new SvgImageBackEnd()
);
$writer = new Writer($renderer);
$qrCodeSvg = $writer->writeString($qrUrl);

public function verifyTwoFactor(Request $request)
{
    $request->validate([
        'code' => 'required|string|size:6',
    ]);
    
    $google2fa = new Google2FA();
    $valid = $google2fa->verifyKey(
        $request->user()->two_factor_secret,
        $request->code
    );
    
    if (!$valid) {
        return response()->json(['error' => 'Invalid authentication code'], 401);
    }
    
    // Завершение процесса аутентификации
    $token = $request->user()->createToken('auth_token')->plainTextToken;
    
    return response()->json(['token' => $token]);
}

public function toArray($request)
{
    return [
        'id' => $this->id,
        'title' => $this->title,
        $this->mergeWhen($request->user()->isAdmin(), [
            'created_at' => $this->created_at,
            'updated_at' => $this->updated_at,
            'deleted_at' => $this->deleted_at,
        ]),
        'author' => new AuthorResource($this->whenLoaded('author')),
    ];
}

public function toArray($request)
{
    return [
        'id' => $this->id,
        'name' => $this->name,
        'email' => $this->email,
        'books' => BookResource::collection($this->whenLoaded('books')),
        'book_count' => $this->when(
            isset($this->books_count), 
            $this->books_count
        ),
    ];
}

public function toArray($request)
{
    return [
        'data' => $this->collection,
        'meta' => [
            'total' => $this->total(),
            'count' => $this->count(),
            'per_page' => $this->perPage(),
            'current_page' => $this->currentPage(),
            'total_pages' => $this->lastPage(),
            'filters' => $request->query(),
        ],
        'links' => [
            'first' => $this->url(1),
            'last' => $this->url($this->lastPage()),
            'prev' => $this->previousPageUrl(),
            'next' => $this->nextPageUrl(),
        ],
    ];
}

// В AppServiceProvider::boot
JsonResource::withoutWrapping();

class BookNotFoundException extends Exception
{
    public function __construct($bookId)
    {
        parent::__construct("Книга с ID {$bookId} не найдена", 404);
    }
    
    public function render($request)
    {
        return response()->json([
            'error' => 'book_not_found',
            'message' => $this->getMessage(),
            'book_id' => (int) str_replace('Книга с ID ', '', $this->getMessage()),
        ], $this->getCode());
    }
}

public function show($id)
{
    $book = Book::find($id);
    
    if (!$book) {
        throw new BookNotFoundException($id);
    }
    
    return new BookResource($book);
}

$validator = Validator::make($request->all(), [
    'email' => 'required|email|unique:users',
    'password' => [
        'required',
        'min:8',
        'regex:/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).+$/'
    ],
]);
 
if ($validator->fails()) {
    $errors = $validator->errors();
    
    // Улучшаем сообщение об ошибке для пароля
    if ($errors->has('password')) {
        $messages = $errors->get('password');
        if (in_array('The password format is invalid.', $messages)) {
            $errors->add('password', 'Пароль должен содержать как минимум одну заглавную букву, одну строчную букву и одну цифру.');
        }
    }
    
    return response()->json([
        'error' => 'validation_failed',
        'errors' => $errors
    ], 422);
}

APP_ENV=testing
DB_CONNECTION=sqlite
DB_DATABASE=:memory:

namespace Tests\Feature;
 
use App\Models\Book;
use App\Models\User;
use Laravel\Sanctum\Sanctum;
use Tests\TestCase;
 
class BookApiTest extends TestCase
{
    public function test_can_get_all_books()
    {
        // Создаём тестовые данные
        Book::factory()->count(3)->create();
        
        // Выполняем запрос к API
        $response = $this->getJson('/api/books');
        
        // Проверяем статус и структуру ответа
        $response->assertStatus(200)
            ->assertJsonCount(3, 'data')
            ->assertJsonStructure([
                'data' => [
                    '*' => ['id', 'title', 'description', 'links']
                ],
                'meta',
                'links'
            ]);
    }
    
    public function test_can_create_book()
    {
        // Авторизуемся как пользователь
        Sanctum::actingAs(
            User::factory()->create(),
            ['*']
        );
        
        $data = [
            'title' => 'Тестовая книга',
            'description' => 'Описание тестовой книги',
            'author_id' => 1
        ];
        
        // Отправляем запрос на создание
        $response = $this->postJson('/api/books', $data);
        
        // Проверяем статус и данные
        $response->assertStatus(201)
            ->assertJson([
                'data' => [
                    'title' => 'Тестовая книга',
                    'description' => 'Описание тестовой книги'
                ]
            ]);
            
        // Проверяем наличие в базе данных
        $this->assertDatabaseHas('books', [
            'title' => 'Тестовая книга'
        ]);
    }
    
    public function test_cannot_create_book_without_authentication()
    {
        $data = [
            'title' => 'Тестовая книга',
            'description' => 'Описание тестовой книги'
        ];
        
        // Отправляем запрос без аутентификации
        $response = $this->postJson('/api/books', $data);
        
        // Проверяем статус 401 Unauthorized
        $response->assertStatus(401);
    }
}

public function test_cannot_create_book_with_invalid_data()
{
    Sanctum::actingAs(
        User::factory()->create(),
        ['*']
    );
    
    // Отправляем запрос с неполными данными
    $response = $this->postJson('/api/books', [
        'description' => 'Только описание без названия'
    ]);
    
    // Проверяем статус и ошибки валидации
    $response->assertStatus(422)
        ->assertJsonValidationErrors(['title']);
}

public function test_book_availability_check()
{
    // Мокируем HTTP-клиент
    Http::fake([
        'api.example.com/books/*' => Http::response([
            'available' => true,
            'stock' => 15
        ], 200)
    ]);
    
    $book = Book::factory()->create();
    
    // Тестируем метод, который использует HTTP-запрос
    $availability = $book->checkAvailability();
    
    // Проверяем, что был сделан правильный запрос
    Http::assertSent(function ($request) use ($book) {
        return $request->url() == "api.example.com/books/{$book->id}" &&
               $request->method() == 'GET';
    });
    
    // Проверяем результат
    $this->assertTrue($availability['available']);
    $this->assertEquals(15, $availability['stock']);
}

/**
 * @OA\Info(
 *   title="Bookstore API",
 *   version="1.0.0",
 *   description="API для управления книжным магазином"
 * )
 */
class BookController extends Controller
{
    /**
     * @OA\Get(
     *   path="/api/books",
     *   summary="Получить список всех книг",
     *   tags={"Books"},
     *   @OA\Parameter(
     *     name="page",
     *     in="query",
     *     description="Номер страницы",
     *     required=false,
     *     @OA\Schema(type="integer")
     *   ),
     *   @OA\Response(
     *     response=200,
     *     description="Успешный ответ",
     *     @OA\JsonContent(
     *       type="object",
     *       @OA\Property(property="data", type="array", @OA\Items(ref="#/components/schemas/Book")),
     *       @OA\Property(property="meta", type="object"),
     *       @OA\Property(property="links", type="object")
     *     )
     *   )
     * )
     */
    public function index()
    {
        // Реализация метода
    }
    
    // Другие методы с аннотациями
}

public function index(Request $request)
{
    $page = $request->query('page', 1);
    $perPage = $request->query('per_page', 15);
    
    // Создаём уникальный ключ для кэша
    $cacheKey = "books_page_{$page}_per_page_{$perPage}";
    
    // Попытка получить данные из кэша
    $books = Cache::remember($cacheKey, now()->addMinutes(5), function () use ($perPage) {
        return Book::with('author')->paginate($perPage);
    });
    
    return BookResource::collection($books);
}

public function store(Request $request)
{
    // Валидация и создание книги
    $book = Book::create($request->validated());
    
    // Очистка кэша
    Cache::tags(['books'])->flush();
    
    return new BookResource($book);
}

// Кэширование с тегом
$books = Cache::tags(['books', 'api'])->remember($cacheKey, now()->addMinutes(5), function () {
    return Book::all();
});
 
// Очистка только кэша книг
Cache::tags(['books'])->flush();

public function show(Book $book)
{
    $etag = md5($book->updated_at);
    
    if (request()->header('If-None-Match') === $etag) {
        return response()->noContent(304);
    }
    
    return (new BookResource($book))
        ->response()
        ->header('ETag', $etag)
        ->header('Cache-Control', 'max-age=3600, public');
}

use Illuminate\Support\Facades\Http;
 
public function getExternalBooks($query)
{
    $response = Http::withToken('api_token')
        ->get('https://api.example.com/books', [
            'query' => $query,
            'limit' => 10
        ]);
    
    if ($response->successful()) {
        return $response->json();
    }
    
    return response()->json(['error' => 'Не удалось получить данные'], 500);
}

interface BookServiceInterface
{
    public function search(string $query): array;
    public function getDetails(string $id): array;
}
 
class GoogleBooksAdapter implements BookServiceInterface
{
    private $apiKey;
    
    public function __construct(string $apiKey)
    {
        $this->apiKey = $apiKey;
    }
    
    public function search(string $query): array
    {
        $response = Http::get('https://www.googleapis.com/books/v1/volumes', [
            'q' => $query,
            'key' => $this->apiKey
        ]);
        
        return $this->transformSearchResults($response->json());
    }
    
    public function getDetails(string $id): array
    {
        $response = Http::get("https://www.googleapis.com/books/v1/volumes/{$id}", [
            'key' => $this->apiKey
        ]);
        
        return $this->transformBookDetails($response->json());
    }
    
    private function transformSearchResults(array $data): array
    {
        // Преобразование формата Google Books API в формат нашего API
        return collect($data['items'] ?? [])->map(function ($item) {
            return [
                'id' => $item['id'],
                'title' => $item['volumeInfo']['title'] ?? 'Unknown',
                'authors' => $item['volumeInfo']['authors'] ?? [],
                'thumbnail' => $item['volumeInfo']['imageLinks']['thumbnail'] ?? null
            ];
        })->toArray();
    }
    
    private function transformBookDetails(array $data): array
    {
        // Преобразование детальной информации
        // ...
    }
}

namespace App\Http\Middleware;
 
use Closure;
use Illuminate\Support\Facades\Log;
 
class ApiLogger
{
    public function handle($request, Closure $next)
    {
        $startTime = microtime(true);
        
        $response = $next($request);
        
        $duration = microtime(true) - $startTime;
        
        Log::channel('api')->info('API Request', [
            'method' => $request->method(),
            'uri' => $request->fullUrl(),
            'status' => $response->status(),
            'duration' => round($duration * 1000, 2) . 'ms',
            'ip' => $request->ip(),
            'user_id' => $request->user()->id ?? 'guest'
        ]);
        
        return $response;
    }
}

SENTRY_LARAVEL_DSN=https://your-sentry-dsn

// В middleware ApiLogger
if ($duration > 1.0) { // Более 1 секунды
    Log::channel('slow-api')->warning('Slow API Request', [
        'method' => $request->method(),
        'uri' => $request->fullUrl(),
        'duration' => round($duration, 2) . 's',
        'params' => $request->all()
    ]);
}

// Экспорт метрик для Prometheus
Route::get('/metrics', function () {
    $registry = app(\Prometheus\CollectorRegistry::class);
    
    $counter = $registry->getOrRegisterCounter(
        'app',
        'api_requests_total',
        'Total number of API requests',
        ['method', 'endpoint', 'status']
    );
    
    // Метрики заполняются в middleware
    
    return response($registry->render(), 200, ['Content-Type' => 'text/plain']);
});