Лучшие PHP REST API фреймворки

Route::apiResource('products', ProductController::class);

class ProductResource extends JsonResource
{
    public function toArray($request)
    {
        return [
            'id' => $this->id,
            'name' => $this->name,
            'price' => $this->price,
            'created_at' => $this->created_at->toIso8601String(),
        ];
    }
}

#[ApiResource(
    collectionOperations: ['get', 'post'],
    itemOperations: ['get', 'put', 'delete'],
)]
class Product
{
    // ...
}

$app->get('/products/{id}', function (Request $request, Response $response, $args) {
    $product = ProductRepository::findById($args['id']);
    $response->getBody()->write(json_encode($product));
    return $response->withHeader('Content-Type', 'application/json');
});

$router->group(['prefix' => 'api'], function () use ($router) {
    $router->get('products', 'ProductController@index');
    $router->post('products', 'ProductController@store');
});

class Products extends ResourceController 
{
    protected $modelName = 'App\Models\ProductModel';
    protected $format    = 'json';
 
    public function index()
    {
        return $this->respond($this->model->findAll());
    }
 
    public function show($id = null)
    {
        $product = $this->model->find($id);
        
        if ($product) {
            return $this->respond($product);
        }
        
        return $this->failNotFound('Product not found with id ' . $id);
    }
 
    // другие методы: create, update, delete
}

use Phalcon\Mvc\Micro;
 
$app = new Micro();
 
// Определение маршрута для GET-запроса
$app->get('/products', function() {
    $products = Products::find();
    
    return $this->response->setJsonContent([
        'status' => 'success',
        'data' => $products
    ]);
});
 
// Обработка POST-запроса
$app->post('/products', function() {
    $product = new Products();
    $success = $product->save($this->request->getJsonRawBody());
    
    return $this->response->setJsonContent([
        'status' => $success ? 'success' : 'fail'
    ]);
});
 
$app->handle();

namespace Album\V1\Rest\Album;
 
use Laminas\ApiTools\ApiProblem\ApiProblem;
use Laminas\ApiTools\Rest\AbstractResourceListener;
 
class AlbumResource extends AbstractResourceListener
{
    public function fetch($id)
    {
        $album = $this->albumTable->getAlbum($id);
        if (!$album) {
            return new ApiProblem(404, 'Album not found');
        }
        return $album;
    }
 
    public function fetchAll($params = [])
    {
        return $this->albumTable->fetchAll();
    }
 
    // другие методы: create, update, delete...
}

namespace app\controllers;
 
use yii\rest\ActiveController;
 
class ProductController extends ActiveController
{
    public $modelClass = 'app\models\Product';
    
    public function actions()
    {
        $actions = parent::actions();
        
        // Кастомизация стандартных действий
        $actions['index']['prepareDataProvider'] = [$this, 'prepareDataProvider'];
        
        return $actions;
    }
    
    public function prepareDataProvider()
    {
        // Своя логика для подготовки данных
        // ...
    }
}

// Создание модели с миграцией и контроллером
php artisan make:model Product -mcr
 
// routes/api.php
Route::apiResource('products', ProductController::class);

class ProductController extends Controller 
{
    public function index()
    {
        $products = Product::all();
        return response()->json([
            'data' => $products,
            'status' => 'success'
        ]);
    }
    
    public function store(Request $request)
    {
        $validated = $request->validate([
            'name' => 'required|string|max:255',
            'price' => 'required|numeric|min:0',
            'description' => 'nullable|string'
        ]);
        
        $product = Product::create($validated);
        
        return response()->json([
            'data' => $product,
            'status' => 'success'
        ], 201);
    }
    
    // Другие методы: show, update, destroy
}

$app = AppFactory::create();
 
// Определение маршрутов
$app->get('/products', function (Request $request, Response $response) {
    $products = Product::all(); // Предполагаем использование Eloquent ORM
    $payload = json_encode($products);
    
    $response->getBody()->write($payload);
    return $response->withHeader('Content-Type', 'application/json');
});
 
$app->post('/products', function (Request $request, Response $response) {
    $data = json_decode($request->getBody(), true);
    
    // Ручная валидация
    if (!isset($data['name']) || !isset($data['price'])) {
        $error = json_encode(['error' => 'Missing required fields']);
        $response->getBody()->write($error);
        return $response->withStatus(400)->withHeader('Content-Type', 'application/json');
    }
    
    $product = Product::create($data);
    $payload = json_encode($product);
    
    $response->getBody()->write($payload);
    return $response->withStatus(201)->withHeader('Content-Type', 'application/json');
});
 
// Другие маршруты: GET, PUT, DELETE для конкретного продукта

#[ORM\Entity]
#[ApiResource(
    collectionOperations: ['get', 'post'],
    itemOperations: ['get', 'put', 'delete']
)]
class Product
{
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column(type: 'integer')]
    private ?int $id = null;
    
    #[ORM\Column(type: 'string')]
    #[Assert\NotBlank]
    private string $name;
    
    #[ORM\Column(type: 'decimal', precision: 10, scale: 2)]
    #[Assert\NotBlank]
    #[Assert\PositiveOrZero]
    private float $price;
    
    #[ORM\Column(type: 'text', nullable: true)]
    private ?string $description = null;
    
    // Геттеры и сеттеры
}

// Установка пакета
// composer require tymon/jwt-auth
 
// Настройка Auth провайдера
// config/auth.php
'guards' => [
    'api' => [
        'driver' => 'jwt',
        'provider' => 'users',
    ],
],
 
// Контроллер аутентификации
class AuthController extends Controller
{
    public function login(Request $request)
    {
        $credentials = $request->validate([
            'email' => 'required|email',
            'password' => 'required',
        ]);
 
        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,
        ]);
    }
}

// Установка пакета
// composer require league/oauth2-server-bundle
 
// Конфигурация в YAML
# config/packages/league_oauth2_server.yaml
league_oauth2_server:
    authorization_server:
        private_key: '%env(resolve:OAUTH_PRIVATE_KEY)%'
        private_key_passphrase: '%env(resolve:OAUTH_PASSPHRASE)%'
        encryption_key: '%env(resolve:OAUTH_ENCRYPTION_KEY)%'
    resource_server:
        public_key: '%env(resolve:OAUTH_PUBLIC_KEY)%'
    scopes: ['read', 'write']
    persistence: 
        doctrine: 
            entity_manager: default

// routes/api.php
Route::prefix('v1')->group(function () {
    Route::apiResource('products', App\Http\Controllers\V1\ProductController::class);
});
 
Route::prefix('v2')->group(function () {
    Route::apiResource('products', App\Http\Controllers\V2\ProductController::class);
});

$app->group('/products', function (Group $group) {
    $group->get('', function (Request $request, Response $response) {
        $version = $request->getHeaderLine('Accept-Version');
        
        if ($version == 'v2') {
            // Логика для версии 2
            return $this->v2ProductService->getAllProducts($request, $response);
        }
        
        // По умолчанию используем версию 1
        return $this->v1ProductService->getAllProducts($request, $response);
    });
});

// app/Exceptions/Handler.php
public function render($request, Throwable $exception)
{
    if ($request->wantsJson()) {
        if ($exception instanceof ValidationException) {
            return response()->json([
                'message' => 'Validation failed',
                'errors' => $exception->errors()
            ], 422);
        }
        
        if ($exception instanceof ModelNotFoundException) {
            return response()->json([
                'message' => 'Resource not found'
            ], 404);
        }
        
        // Обработка других типов исключений
        
        // Общая обработка неизвестных ошибок
        return response()->json([
            'message' => 'Server Error',
            'error' => $exception->getMessage(),
        ], 500);
    }
    
    return parent::render($request, $exception);
}

$app->add(function (Request $request, RequestHandler $handler) {
    try {
        return $handler->handle($request);
    } catch (ModelNotFoundException $e) {
        $response = new Response();
        $response->getBody()->write(json_encode([
            'message' => 'Resource not found'
        ]));
        
        return $response->withStatus(404)->withHeader('Content-Type', 'application/json');
    } catch (Exception $e) {
        $response = new Response();
        $response->getBody()->write(json_encode([
            'message' => 'Server Error',
            'error' => $e->getMessage()
        ]));
        
        return $response->withStatus(500)->withHeader('Content-Type', 'application/json');
    }
});

// ProductController.php
public function index(Request $request)
{
    $perPage = $request->input('per_page', 15);
    $products = Product::query();
    
    // Применение фильтров
    if ($request->has('category')) {
        $products->where('category_id', $request->input('category'));
    }
    
    if ($request->has('price_min')) {
        $products->where('price', '>=', $request->input('price_min'));
    }
    
    if ($request->has('price_max')) {
        $products->where('price', '<=', $request->input('price_max'));
    }
    
    // Пагинация с сохранением параметров запроса
    $paginated = $products->paginate($perPage)->appends($request->query());
    
    return response()->json($paginated);
}

// ProductController.php
public function show($id)
{
    $cacheKey = "product:{$id}";
    
    // Попытка получить данные из кэша
    if (Redis::exists($cacheKey)) {
        return response()->json([
            'data' => json_decode(Redis::get($cacheKey)),
            'source' => 'cache'
        ]);
    }
    
    // Если нет в кэше, получаем из БД
    $product = Product::find($id);
    
    if (!$product) {
        return response()->json(['error' => 'Product not found'], 404);
    }
    
    // Сохраняем в кэш на 30 минут
    Redis::setex($cacheKey, 1800, json_encode($product));
    
    return response()->json([
        'data' => $product,
        'source' => 'database'
    ]);
}

// OrderController.php
#[Route('/api/orders', methods: ['POST'])]
public function createOrder(Request $request, MessageBusInterface $messageBus): Response
{
    $data = json_decode($request->getContent(), true);
    
    // Валидация данных
    // ...
    
    // Создаём запись о заказе с начальным статусом
    $order = new Order();
    $order->setStatus('processing');
    $order->setCustomerData($data['customer']);
    $this->entityManager->persist($order);
    $this->entityManager->flush();
    
    // Отправляем задачу на асинхронную обработку
    $messageBus->dispatch(new ProcessOrderMessage($order->getId()));
    
    return $this->json([
        'message' => 'Order accepted for processing',
        'order_id' => $order->getId()
    ], 202); // 202 Accepted
}

// Конфигурация кэширования
$config['cache_drivers'] = [
    [
        'adapter' => 'redis',
        'host' => '10.0.0.1',  // Первый сервер Redis
        'weight' => 2,         // Вес для распределения нагрузки
    ],
    [
        'adapter' => 'redis',
        'host' => '10.0.0.2',  // Второй сервер Redis
        'weight' => 1,         // Меньший вес
    ]
];
 
// Использование в контроллере
class ProductApi extends ResourceController
{
    public function show($id = null)
    {
        // Пробуем получить из кэша
        $product = cache("product_$id");
        
        if (!$product) {
            // Получаем из БД
            $product = $this->model->find($id);
            
            if (!$product) {
                return $this->failNotFound('Product not found');
            }
            
            // Кэшируем на 30 минут
            cache()->save("product_$id", $product, 1800);
        }
        
        return $this->respond($product);
    }
}

// Настройка правил доступа
public function behaviors()
{
    return [
        'access' => [
            'class' => AccessControl::class,
            'rules' => [
                [
                    'allow' => true,
                    'actions' => ['index', 'view'],
                    'roles' => ['viewer'],
                ],
                [
                    'allow' => true,
                    'actions' => ['create', 'update'],
                    'roles' => ['editor'],
                ],
                [
                    'allow' => true,
                    'actions' => ['delete'],
                    'roles' => ['admin'],
                ],
            ],
        ],
    ];
}
 
// Проверка прав в действиях
public function actionUpdate($id)
{
    $model = $this->findModel($id);
    
    // Дополнительная проверка прав на объект
    if (!Yii::$app->user->can('updateProduct', ['product' => $model])) {
        throw new ForbiddenHttpException('You are not allowed to update this product');
    }
    
    // Логика обновления...
}

// Генерация токена при логине
public function login(Request $request)
{
    $request->validate([
        'email' => 'required|email',
        'password' => 'required',
    ]);
 
    $user = User::where('email', $request->email)->first();
 
    if (!$user || !Hash::check($request->password, $user->password)) {
        return response()->json([
            'message' => 'Invalid credentials'
        ], 401);
    }
    
    // Создание токена с возможностями (abilities)
    $token = $user->createToken('api-token', ['products:read', 'products:write'])->plainTextToken;
    
    return response()->json([
        'token' => $token
    ]);
}
 
// Проверка возможностей в контроллере или middleware
public function update(Request $request, $id)
{
    if (!$request->user()->tokenCan('products:write')) {
        return response()->json(['message' => 'Unauthorized'], 403);
    }
    
    // Логика обновления
}

// Настройка сервера OAuth
$authServer = new AuthorizationServer(
    new ClientRepository(),       // Классы для хранения и 
    new AccessTokenRepository(),  // получения сущностей OAuth
    new ScopeRepository(),
    $privateKey,
    $encryptionKey
);
 
// Добавление типов предоставления (grant types)
$authServer->enableGrantType(
    new ClientCredentialsGrant(),
    new DateInterval('PT1H')  // Токены на 1 час
);
 
// Настройка пути для получения токена
$app->post('/oauth/token', function (Request $request, Response $response) use ($authServer) {
    try {
        $authResponse = $authServer->respondToAccessTokenRequest($request, $response);
        return $authResponse;
    } catch (OAuthServerException $e) {
        return $e->generateHttpResponse($response);
    }
});
 
// Защита API-маршрутов
$app->get('/api/products', function (Request $request, Response $response) {
    // Логика получения продуктов
})->add(new ResourceServerMiddleware($resourceServer));

class ApiThrottleMiddleware
{
    public function handle($request, Closure $next)
    {
        $user = $request->user();
        
        if (!$user) {
            // Для неавторизованных, базовый лимит
            return $this->handleGuestThrottling($request, $next);
        }
        
        $plan = $user->subscription()->plan;
        
        // Получаем лимиты из настроек плана
        $maxRequests = config("plans.$plan.rate_limit.requests_per_minute", 60);
        $key = 'throttle:' . $user->id;
        
        // Проверяем и увеличиваем счётчик запросов
        $currentCount = Redis::get($key) ?: 0;
        
        if ($currentCount >= $maxRequests) {
            // Возвращаем информацию о превышении лимита
            return response()->json([
                'error' => 'Rate limit exceeded',
                'plan' => $plan,
                'limit' => $maxRequests,
                'retry_after' => Redis::ttl($key)
            ], 429);
        }
        
        // Инкрементируем счётчик, устанавливаем TTL при первом запросе
        if ($currentCount == 0) {
            Redis::setex($key, 60, 1);
        } else {
            Redis::incr($key);
        }
        
        // Добавляем заголовки с информацией о лимитах
        $response = $next($request);
        return $response->withHeaders([
            'X-RateLimit-Limit' => $maxRequests,
            'X-RateLimit-Remaining' => $maxRequests - $currentCount - 1,
        ]);
    }
}

class ProductController extends AbstractController
{
    #[Route('/api/products/{id}', methods: ['PUT'])]
    public function update(Request $request, Product $product, EntityManagerInterface $em): Response
    {
        // Создаём историческую запись перед изменением
        $snapshot = new ProductHistory();
        $snapshot->setProductId($product->getId());
        $snapshot->setData($this->serializer->serialize($product, 'json'));
        $snapshot->setChangedBy($this->security->getUser()->getId());
        $snapshot->setVersion($product->getVersion() + 1);
        $em->persist($snapshot);
        
        // Обновляем модель
        $data = json_decode($request->getContent(), true);
        $product->setName($data['name'] ?? $product->getName());
        $product->setPrice($data['price'] ?? $product->getPrice());
        // Другие поля...
        
        // Увеличиваем версию
        $product->incrementVersion();
        
        $em->persist($product);
        $em->flush();
        
        return $this->json($product);
    }
    
    #[Route('/api/products/{id}/history', methods: ['GET'])]
    public function history(Product $product): Response
    {
        $history = $this->historyRepository->findByProductId($product->getId());
        
        return $this->json($history);
    }
}