taktik - laravel

.gitignore

@@ -0,0 +1,5 @@
+.phpcs-cache
+vendor
+storage
+.phpunit*
+

Dockerfile.fpm

@@ -0,0 +1,11 @@
+FROM php:8.3-fpm
+
+RUN apt-get update && apt-get install -y nodejs npm unzip libzip-dev && rm -rf /var/cache/apt/*
+RUN curl -sSL https://github.com/mlocati/docker-php-extension-installer/releases/latest/download/install-php-extensions -o - | sh -s \
+       opentelemetry-php/ext-opentelemetry@main  opcache zip grpc intl calendar pdo_mysql mysqli redis
+RUN curl -sS https://getcomposer.org/installer | php && mv composer.phar /usr/local/bin/composer
+RUN composer self-update
+RUN usermod -a -G www-data root
+RUN mkdir -p /var/www/html
+RUN chown -R www-data:www-data /var/www/html
+WORKDIR /var/www/html/

Dockerfile.nginx

@@ -0,0 +1,3 @@
+FROM nginx:1.25.3-alpine
+COPY docker/nginx/default.conf /etc/nginx/conf.d/default.conf
+EXPOSE 80

README.md

@@ -0,0 +1,83 @@
+How to start with development
+===
+
+* **Requirements:**
+    * bash
+    * Docker with Docker Compose (v2) command
+
+* **Run:**
+    ```bash
+    develop.sh
+    ```
+    * Enjoy your coffee ;-)
+    * Laravel will serve the web at [http://localhost:8000] (which redirects to API documentation).
+
+* **To try the API:**
+    * Use tools like Swagger ([http://localhost:8000/api/documentation]).
+
+---
+
+Tests
+---
+Run the following command to execute the tests:
+
+```bash
+docker compose exec php-fpm vendor/bin/phpunit
+```
+
+---
+
+PHPStan & CS
+---
+
+* Run PHP CodeSniffer:
+    ```bash
+    docker compose exec php-fpm vendor/bin/phpcs
+    ```
+* Run PHPStan with increased memory limit:
+    ```bash
+    docker compose exec php-fpm vendor/bin/phpstan --memory-limit=2G
+    ```
+
+---
+
+Swagger
+---
+To regenerate Swagger documentation, use:
+
+```bash
+docker compose exec php-fpm /var/www/html/artisan l5-swagger:generate
+```
+
+---
+
+Containers
+---
+
+* `php-fpm` - FPM and additional tooling
+* `nginx` - Serves static content, proxies requests to FPM
+* `mysql` - Database
+
+---
+
+TODO
+---
+
+* [ ] Add more filtering options
+* [ ] Different DB for testing (and revert changes)
+* [ ] The current tests are very basic. Write additional testing scenarios (feature tests).
+* [ ] Write unit tests!
+* [ ] Extend Swagger documentation; currently, only one controller is documented.
+* [ ] Add a monitoring stack (Prometheus, Otel, Loki, Grafana, etc.).
+* [ ] Integrate Sentry.
+* [ ] Establish deployment pipelines for dev/test and production environments. Configure production settings and Docker
+  images.
+* [ ] Integrate CI/CD.
+
+---
+
+Notes
+---
+Rate-limiting is managed at the NGINX layer (per IP). Therefore, there is no need to send "banned" traffic to `php-fpm`
+and occupy workers.
+

app/Http/Controllers/CategoryController.php

@@ -0,0 +1,103 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Http\Controllers;
+
+use App\Http\Requests\Category\DestroyCategoryRequest;
+use App\Http\Requests\Category\ListCategoryRequest;
+use App\Http\Requests\Category\ShowCategoryRequest;
+use App\Http\Requests\Category\StoreCategoryRequest;
+use App\Http\Requests\Category\UpdateCategoryRequest;
+use App\Http\Resources\CategoryCollection;
+use App\Http\Resources\CategoryResource;
+use App\Http\Resources\PaginableResource;
+use App\Services\Category\CategoryServiceInterface;
+use Illuminate\Http\JsonResponse;
+use OpenApi\Annotations as OA;
+
+final class CategoryController
+{
+    public function __construct(
+        private readonly CategoryServiceInterface $categoryService,
+    )
+    {
+    }
+
+    public function list(ListCategoryRequest $request, int $page): JsonResponse
+    {
+        $categories = $this->categoryService->fetchCategories(
+            $page,
+            $request->filters(),
+            $request->order()
+        );
+        return response()->json(PaginableResource::make($categories, CategoryCollection::class));
+    }
+
+    /**
+     * @OA\Post(
+     *     path="/api/v1/categories",
+     *     operationId="storeCategory",
+     *     tags={"Categories"},
+     *     summary="Create a new category",
+     *     description="Creates a new category and returns the created category data.",
+     *     @OA\RequestBody(
+     *         required=true,
+     *         @OA\JsonContent(
+     *             type="object",
+     *             required={"name"},
+     *             @OA\Property(property="name", type="string", example="Technology", description="The name of the category")
+     *         )
+     *     ),
+     *     @OA\Response(
+     *         response=201,
+     *         description="Category successfully created",
+     *         @OA\JsonContent(
+     *             type="object",
+     *                 ref="#/components/schemas/CategoryResource"
+     *             )
+     *         )
+     *     ),
+     * @OA\Response(
+     *         response=422,
+     *         description="Validation error",
+     *         @OA\JsonContent(ref="#/components/schemas/ValidationError")
+     *     )
+     * )
+     */
+    public function store(StoreCategoryRequest $request): JsonResponse
+    {
+        return response()->json(CategoryResource::make($this->categoryService->storeCategory($request->all())), 201);
+    }
+
+    public function show(ShowCategoryRequest $request, int $id): JsonResponse
+    {
+        $post = $this->categoryService->findCategory($id);
+
+        if ($post === null) {
+            return response()->json(null, 404);
+        }
+
+        return response()->json(CategoryResource::make($post));
+    }
+
+    public function update(UpdateCategoryRequest $request, int $id): JsonResponse
+    {
+        $post = $this->categoryService->updateCategory($request->all(), $id);
+
+        if ($post === null) {
+            return response()->json(null, 404);
+        }
+
+        return response()->json(CategoryResource::make($post));
+    }
+
+    public function destroy(DestroyCategoryRequest $post, int $id): JsonResponse
+    {
+        $isSuccessfullyDeleted = $this->categoryService->deleteCategory($id);
+        return match ($isSuccessfullyDeleted) {
+            false => response()->json(null, 404),
+            true => response()->json(null, 204),
+        };
+    }
+}

app/Http/Controllers/CommentController.php

@@ -0,0 +1,59 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Http\Controllers;
+
+use App\Http\Requests\Comment\DestroyCommentRequest;
+use App\Http\Requests\Comment\ListCommentRequest;
+use App\Http\Requests\Comment\StoreCommentRequest;
+use App\Http\Requests\Comment\UpdateCommentRequest;
+use App\Http\Resources\CommentCollection;
+use App\Http\Resources\CommentResource;
+use App\Http\Resources\PaginableResource;
+use App\Services\Comment\PostCommentService;
+use Illuminate\Http\JsonResponse;
+
+class CommentController extends Controller
+{
+    public function __construct(
+        private readonly PostCommentService $commentService,
+    ) {
+    }
+
+    public function list(ListCommentRequest $request, int $postId, int $page): JsonResponse
+    {
+        $comments = $this->commentService->fetchComments(
+            $postId,
+            $page,
+            $request->filters(),
+            $request->order()
+        );
+        return response()->json(PaginableResource::make($comments, CommentCollection::class));
+    }
+
+    public function store(StoreCommentRequest $request, int $postId): JsonResponse
+    {
+        return response()->json(CommentResource::make($this->commentService->storeComment($request->all(), $postId)), 201);
+    }
+
+    public function update(UpdateCommentRequest $request, int $postId, int $id): JsonResponse
+    {
+        $comment = $this->commentService->updateComment($request->all(), $postId, $id);
+
+        if ($comment === null) {
+            return response()->json(null, 404);
+        }
+
+        return response()->json(CommentResource::make($comment));
+    }
+
+    public function destroy(DestroyCommentRequest $post, int $postId, int $id): JsonResponse
+    {
+        $isSuccessfullyDeleted = $this->commentService->deleteComment($postId, $id);
+        return match ($isSuccessfullyDeleted) {
+            false => response()->json(null, 404),
+            true => response()->json(null, 204),
+        };
+    }
+}

app/Http/Controllers/Controller.php

@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Http\Controllers;
+
+abstract class Controller extends \Illuminate\Routing\Controller
+{
+}

app/Http/Controllers/PostController.php

@@ -0,0 +1,308 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Http\Controllers;
+
+use App\Http\Requests\Post\DestroyPostRequest;
+use App\Http\Requests\Post\ListPostRequest;
+use App\Http\Requests\Post\ShowPostRequest;
+use App\Http\Requests\Post\StorePostRequest;
+use App\Http\Requests\Post\UpdatePostRequest;
+use App\Http\Resources\PaginableResource;
+use App\Http\Resources\PostCollection;
+use App\Http\Resources\PostResource;
+use App\Services\Post\PostServiceInterface;
+use Illuminate\Http\JsonResponse;
+use OpenApi\Annotations as OA;
+
+final class PostController extends Controller
+{
+    public function __construct(
+        private readonly PostServiceInterface $postService,
+    )
+    {
+    }
+
+    /**
+     * @OA\Get(
+     *     path="/api/v1/posts/{page}",
+     *     summary="List all posts",
+     *     description="Fetch a paginated list of all posts.",
+     *     tags={"Posts"},
+     *     @OA\Parameter(
+     *         name="direction",
+     *         in="query",
+     *         description="Order posts by ascending or descending",
+     *         required=false,
+     *         @OA\Schema(
+     *             type="string",
+     *             enum={"asc", "desc"},
+     *             example="asc"
+     *         )
+     *     ),
+     *     @OA\Parameter(
+     *          name="order",
+     *          in="query",
+     *          description="Order posts by column name",
+     *          required=false,
+     *          @OA\Schema(
+     *              type="string",
+     *              example="title"
+     *          )
+     *      ),
+     *     @OA\Parameter(
+     *         name="title",
+     *         in="query",
+     *         description="Filter posts by title",
+     *         required=false,
+     *         @OA\Schema(
+     *             type="string",
+     *             example="Sample Post"
+     *         )
+     *     ),
+     *     @OA\Parameter(
+     *         name="page",
+     *         in="path",
+     *         description="Pagination page number",
+     *         required=false,
+     *         @OA\Schema(
+     *             type="integer",
+     *             example=1
+     *         )
+     *     ),
+     *     @OA\Response(
+     *         response=200,
+     *         description="Successful response",
+     *         @OA\JsonContent(
+     *             type="object",
+     *             @OA\Property(
+     *                 property="items",
+     *                 ref="#/components/schemas/PostCollection"
+     *             ),
+     *             @OA\Property(
+     *                 property="meta",
+     *                 type="object",
+     *                 description="Pagination metadata",
+     *                 ref="#/components/schemas/PaginableResourceMeta"
+     *              )
+     *          )
+     *     ),
+     *     @OA\Response(
+     *         response=422,
+     *         description="Validation error",
+     *         @OA\JsonContent(ref="#/components/schemas/ValidationError")
+     *     ),
+     *     @OA\Response(
+     *         response=429,
+     *         description="Rate limiting. Try again later.",
+     *     )
+     * )
+     */
+    public function list(ListPostRequest $request, int $page): JsonResponse
+    {
+        $posts = $this->postService->fetchPosts(
+            $page,
+            $request->filters(),
+            $request->order()
+        );
+        return response()->json(PaginableResource::make($posts, PostCollection::class));
+    }
+
+    /**
+     * @OA\Post(
+     *     path="/api/v1/posts",
+     *     operationId="storePost",
+     *     tags={"Posts"},
+     *     summary="Create a new post",
+     *     description="Creates a new post in the system based on the provided input data.",
+     *     @OA\RequestBody(
+     *         description="Payload for creating a new post",
+     *         required=true,
+     *         @OA\JsonContent(
+     *             type="object",
+     *             @OA\Property(property="title", type="string", maxLength=255, example="My First Post"),
+     *             @OA\Property(property="content", type="string", example="This is the content of my first post."),
+     *             @OA\Property(property="category_id", type="integer", example=1),
+     *             @OA\Property(property="tags", type="array", @OA\Items(type="string", example="Laravel")),
+     *         )
+     *     ),
+     *     @OA\Response(
+     *         response=201,
+     *         description="Post successfully created",
+     *         @OA\JsonContent(
+     *             type="object",
+     *             @OA\Property(property="status", type="string", example="success"),
+     *             @OA\Property(property="message", type="string", example="Post created successfully."),
+     *             @OA\Property(
+     *                 property="data",
+     *                 type="object",
+     *                 ref="#/components/schemas/PostResource"
+     *             )
+     *         )
+     *     ),
+     *     @OA\Response(
+     *         response=422,
+     *         description="Validation error",
+     *         @OA\JsonContent(ref="#/components/schemas/ValidationError")
+     *     ),
+     *     @OA\Response(
+     *         response=429,
+     *         description="Rate limiting. Try again later.",
+     *     )
+     * )
+     */
+    public function store(StorePostRequest $request): JsonResponse
+    {
+        return response()->json(PostResource::make($this->postService->storePost($request->all())), 201);
+    }
+
+    /**
+     * @OA\Get(
+     *     path="/api/v1/posts/{id}",
+     *     operationId="getPostById",
+     *     tags={"Posts"},
+     *     summary="Get a specific post by ID",
+     *     description="Returns a specific post identified by its unique ID.",
+     *     @OA\Parameter(
+     *         name="id",
+     *         in="path",
+     *         description="ID of the post to retrieve",
+     *         required=true,
+     *         @OA\Schema(type="integer", example=1)
+     *     ),
+     *     @OA\Response(
+     *         response=200,
+     *         description="Post data retrieved successfully",
+     *         @OA\JsonContent(
+     *             type="object",
+     *             @OA\Property(property="status", type="string", example="success"),
+     *             @OA\Property(
+     *                 property="data",
+     *                 type="object",
+     *                 ref="#/components/schemas/PostResource"
+     *             )
+     *         )
+     *     ),
+     *     @OA\Response(
+     *         response=404,
+     *         description="Post not found",
+     *     ),
+     *     @OA\Response(
+     *         response=429,
+     *         description="Rate limiting. Try again later.",
+     *     )
+     * )
+     */
+    public function show(ShowPostRequest $request, int $id): JsonResponse
+    {
+        $post = $this->postService->findPost($id);
+
+        if ($post === null) {
+            return response()->json(null, 404);
+        }
+
+        return response()->json(PostResource::make($post));
+    }
+
+    /**
+     * @OA\Put(
+     *     path="/api/v1/post/{id}",
+     *     operationId="updatePost",
+     *     tags={"Posts"},
+     *     summary="Update a specific post by ID",
+     *     description="Updates specific fields of a post identified by its unique ID.",
+     *     @OA\Parameter(
+     *         name="id",
+     *         in="path",
+     *         description="ID of the post to update",
+     *         required=true,
+     *         @OA\Schema(type="integer", example=1)
+     *     ),
+     *     @OA\RequestBody(
+     *         description="Payload for updating a post",
+     *         required=true,
+     *         @OA\JsonContent(
+     *             type="object",
+     *             @OA\Property(property="title", type="string", maxLength=255, example="Updated Title"),
+     *             @OA\Property(property="content", type="string", example="Updated content of the post."),
+     *             @OA\Property(property="category_id", type="integer", example=2),
+     *             @OA\Property(property="tags", type="array", @OA\Items(type="string", example="Laravel"))
+     *         )
+     *     ),
+     *     @OA\Response(
+     *         response=200,
+     *         description="Post data updated sucessfully",
+     *         @OA\JsonContent(
+     *             type="object",
+     *             @OA\Property(property="status", type="string", example="success"),
+     *             @OA\Property(
+     *                 property="data",
+     *                 type="object",
+     *                 ref="#/components/schemas/PostResource"
+     *             )
+     *         )
+     *     ),
+     *     @OA\Response(
+     *         response=404,
+     *         description="Post not found",
+     *     ),
+     *     @OA\Response(
+     *         response=422,
+     *         description="Validation error",
+     *         @OA\JsonContent(ref="#/components/schemas/ValidationError")
+     *     ),
+     *     @OA\Response(
+     *         response=429,
+     *         description="Rate limiting. Try again later.",
+     *     )
+     * )
+     */
+    public function update(UpdatePostRequest $request, int $id): JsonResponse
+    {
+        $post = $this->postService->updatePost($request->all(), $id);
+
+        if ($post === null) {
+            return response()->json(null, 404);
+        }
+
+        return response()->json(PostResource::make($post));
+    }
+
+    /**
+     * @OA\Delete(
+     *     path="/api/v1/post/{id}",
+     *     operationId="deletePost",
+     *     tags={"Posts"},
+     *     summary="Delete a specific post by ID",
+     *     description="Deletes a specific post identified by its unique ID. This operation is irreversible.",
+     *     @OA\Parameter(
+     *         name="id",
+     *         in="path",
+     *         description="ID of the post to delete",
+     *         required=true,
+     *         @OA\Schema(type="integer", example=1)
+     *     ),
+     *     @OA\Response(
+     *         response=204,
+     *         description="Post successfully deleted",
+     *     ),
+     *     @OA\Response(
+     *         response=404,
+     *         description="Post not found",
+     *     ),
+     *     @OA\Response(
+     *         response=429,
+     *         description="Rate limiting. Try again later.",
+     *     )
+     * )
+     */
+    public function destroy(DestroyPostRequest $post, int $id): JsonResponse
+    {
+        $isSuccessfullyDeleted = $this->postService->deletePost($id);
+        return match ($isSuccessfullyDeleted) {
+            false => response()->json(null, 404),
+            true => response()->json(null, 204),
+        };
+    }
+}

app/Http/Requests/Category/DestroyCategoryRequest.php

@@ -0,0 +1,41 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Http\Requests\Category;
+
+use App\Http\Requests\InvalidDataResponseTrait;
+use Illuminate\Foundation\Http\FormRequest;
+
+class DestroyCategoryRequest extends FormRequest
+{
+    use InvalidDataResponseTrait;
+
+    /**
+     * @return array<string, string>
+     */
+    public function all($keys = null): array
+    {
+        $request = parent::all($keys);
+
+        $request['id'] = $this->route('id');
+
+        return $request;
+    }
+
+
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /**
+     * @return array<string, string>
+     */
+    public function rules(): array
+    {
+        return [
+            'id' => 'required|integer|min:0',
+        ];
+    }
+}

app/Http/Requests/Category/ListCategoryRequest.php

@@ -0,0 +1,74 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Http\Requests\Category;
+
+use App\Http\Requests\InvalidDataResponseTrait;
+use App\Services\QueryRequestModifiers\Category\CategoryFilter;
+use App\Services\QueryRequestModifiers\Category\CategoryFilterDTO;
+use App\Services\QueryRequestModifiers\Category\CategoryOrder;
+use App\Services\QueryRequestModifiers\Category\CategoryOrderDTO;
+use Illuminate\Foundation\Http\FormRequest;
+
+class ListCategoryRequest extends FormRequest
+{
+    use InvalidDataResponseTrait;
+
+    public function __construct(
+        private readonly CategoryOrder $categoryOrder,
+        private readonly CategoryFilter $categoryFilter,
+    ) {
+    }
+
+
+    /**
+     * @return array<string, string>
+     */
+    public function all($keys = null): array
+    {
+        $request = parent::all($keys);
+
+        $request['page'] = $this->route('page');
+
+        return $request;
+    }
+
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /**
+     * @return array<string, string>
+     */
+    public function rules(): array
+    {
+        return [
+            'page' => 'required|integer|min:1',
+            ... $this->categoryOrder->validateRules(),
+            ... $this->categoryFilter->validateRules()
+        ];
+    }
+
+
+    /**
+     * @return array<string, string>
+     */
+    public function attributes(): array
+    {
+        return [
+            'page' => 'page number',
+        ];
+    }
+
+    public function filters(): ?CategoryFilterDTO
+    {
+        return $this->categoryFilter->makeFromRequest($this);
+    }
+
+    public function order(): ?CategoryOrderDTO
+    {
+        return $this->categoryOrder->makeFromRequest($this);
+    }
+}

app/Http/Requests/Category/ShowCategoryRequest.php

@@ -0,0 +1,45 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Http\Requests\Category;
+
+use App\Http\Requests\InvalidDataResponseTrait;
+use Illuminate\Foundation\Http\FormRequest;
+
+class ShowCategoryRequest extends FormRequest
+{
+    use InvalidDataResponseTrait;
+
+    /**
+     * @return array<string, string>
+     */
+    public function all($keys = null): array
+    {
+        $request = parent::all($keys);
+
+        $request['id'] = $this->route('id');
+
+        return $request;
+    }
+
+    /**
+     * Determine if the user is authorized to make this request.
+     */
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /**
+     * Get the validation rules that apply to the request.
+     *
+     * @return array<string, \Illuminate\Contracts\Validation\ValidationRule|array<mixed>|string>
+     */
+    public function rules(): array
+    {
+        return [
+            'id' => 'required|integer|min:0',
+        ];
+    }
+}

app/Http/Requests/Category/StoreCategoryRequest.php

@@ -0,0 +1,47 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Http\Requests\Category;
+
+use App\Http\Requests\InvalidDataResponseTrait;
+use App\Http\Resources\CategoryResource;
+use Illuminate\Foundation\Http\FormRequest;
+
+class StoreCategoryRequest extends FormRequest
+{
+    use InvalidDataResponseTrait;
+
+    /**
+     * Determine if the user is authorized to make this request.
+     */
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /**
+     * Get the validation rules that apply to the request.
+     *
+     * @return array<string, string>
+     */
+    public function rules(): array
+    {
+        return static::rulesDefinition();
+    }
+
+    /**
+     * @return array<string, string>
+     */
+    public static function rulesDefinition(): array
+    {
+        return [
+            'name' => 'required|string',
+        ];
+    }
+
+    public function getCategory(): CategoryResource
+    {
+        return CategoryResource::make($this->all());
+    }
+}

app/Http/Requests/Category/UpdateCategoryRequest.php

@@ -0,0 +1,47 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Http\Requests\Category;
+
+use App\Http\Requests\InvalidDataResponseTrait;
+use Illuminate\Foundation\Http\FormRequest;
+
+class UpdateCategoryRequest extends FormRequest
+{
+    use InvalidDataResponseTrait;
+
+    /**
+     * @return array<string, string>
+     */
+    public function all($keys = null): array
+    {
+        $request = parent::all($keys);
+
+        $request['id'] = $this->route('id');
+
+        return $request;
+    }
+
+
+    /**
+     * Determine if the user is authorized to make this request.
+     */
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /**
+     * Get the validation rules that apply to the request.
+     *
+     * @return array<string, string>
+     */
+    public function rules(): array
+    {
+        return [
+            ...StoreCategoryRequest::rulesDefinition(),
+            'id' => 'required|integer|min:0',
+        ];
+    }
+}

app/Http/Requests/Comment/DestroyCommentRequest.php

@@ -0,0 +1,43 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Http\Requests\Comment;
+
+use App\Http\Requests\InvalidDataResponseTrait;
+use Illuminate\Foundation\Http\FormRequest;
+
+class DestroyCommentRequest extends FormRequest
+{
+    use InvalidDataResponseTrait;
+
+    /**
+     * @return array<string, string>
+     */
+    public function all($keys = null): array
+    {
+        $request = parent::all($keys);
+
+        $request['id'] = $this->route('id');
+        $request['post_id'] = $this->route('post_id');
+
+        return $request;
+    }
+
+
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /**
+     * @return array<string, string>
+     */
+    public function rules(): array
+    {
+        return [
+            'id' => 'required|integer|exists:comments,id',
+            'post_id' => 'required|exists:posts,id',
+        ];
+    }
+}

app/Http/Requests/Comment/ListCommentRequest.php

@@ -0,0 +1,77 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Http\Requests\Comment;
+
+use App\Http\Requests\InvalidDataResponseTrait;
+use App\Services\QueryRequestModifiers\Comment\CommentFilter;
+use App\Services\QueryRequestModifiers\Comment\CommentFilterDTO;
+use App\Services\QueryRequestModifiers\Comment\CommentOrder;
+use App\Services\QueryRequestModifiers\Comment\CommentOrderDTO;
+use Illuminate\Foundation\Http\FormRequest;
+
+class ListCommentRequest extends FormRequest
+{
+    use InvalidDataResponseTrait;
+
+    public function __construct(
+        private readonly CommentOrder $commentOrder,
+        private readonly CommentFilter $commentFilter,
+    ) {
+    }
+
+
+    /**
+     * @return array<string, string>
+     */
+    public function all($keys = null): array
+    {
+        $request = parent::all($keys);
+
+        $request['page'] = $this->route('page');
+        $request['post_id'] = $this->route('post_id');
+
+        return $request;
+    }
+
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /**
+     * @return array<string, string>
+     */
+    public function rules(): array
+    {
+        return [
+            'page' => 'required|integer|min:1',
+            'post_id' => 'required|integer|min:0',
+            ... $this->commentFilter->validateRules(),
+            ... $this->commentOrder->validateRules()
+        ];
+    }
+
+
+    /**
+     * @return array<string, string>
+     */
+    public function attributes(): array
+    {
+        return [
+            'page' => 'page number',
+            'post_id' => 'post id',
+        ];
+    }
+
+    public function filters(): ?CommentFilterDTO
+    {
+        return $this->commentFilter->makeFromRequest($this);
+    }
+
+    public function order(): ?CommentOrderDTO
+    {
+        return $this->commentOrder->makeFromRequest($this);
+    }
+}

app/Http/Requests/Comment/StoreCommentRequest.php

@@ -0,0 +1,49 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Http\Requests\Comment;
+
+use App\Http\Requests\InvalidDataResponseTrait;
+use Illuminate\Foundation\Http\FormRequest;
+
+class StoreCommentRequest extends FormRequest
+{
+    use InvalidDataResponseTrait;
+
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /**
+     * @return array<string, string>
+     */
+    public function all($keys = null): array
+    {
+        $request = parent::all($keys);
+
+        $request['post_id'] = $this->route('post_id');
+
+        return $request;
+    }
+
+    /**
+     * @return array<string, \Illuminate\Contracts\Validation\ValidationRule|array<mixed>|string>
+     */
+    public function rules(): array
+    {
+        return static::rulesDefinition();
+    }
+
+    /**
+     * @return array<string, string>
+     */
+    public static function rulesDefinition()
+    {
+        return [
+            'content' => 'required|string',
+            'post_id' => 'required|exists:posts,id',
+        ];
+    }
+}

app/Http/Requests/Comment/UpdateCommentRequest.php

@@ -0,0 +1,46 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Http\Requests\Comment;
+
+use App\Http\Requests\InvalidDataResponseTrait;
+use Illuminate\Foundation\Http\FormRequest;
+
+class UpdateCommentRequest extends FormRequest
+{
+    use InvalidDataResponseTrait;
+
+    /**
+     * @return array<string, string>
+     */
+    public function all($keys = null): array
+    {
+        $request = parent::all($keys);
+
+        $request['id'] = $this->route('id');
+        $request['post_id'] = $this->route('post_id');
+
+        return $request;
+    }
+
+
+    /**
+     * Determine if the user is authorized to make this request.
+     */
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /**
+     * @return array<string, \Illuminate\Contracts\Validation\ValidationRule|array<mixed>|string>
+     */
+    public function rules(): array
+    {
+        return [
+            ...StoreCommentRequest::rulesDefinition(),
+            'id' => 'required|integer|exists:comments,id',
+        ];
+    }
+}

app/Http/Requests/InvalidDataResponseTrait.php

@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Http\Requests;
+
+use Illuminate\Contracts\Validation\Validator;
+use Illuminate\Http\Exceptions\HttpResponseException;
+use OpenApi\Annotations as OA;
+
+/**
+ * @OA\Schema(
+ *     schema="ValidationError",
+ *     type="object",
+ *     @OA\Property(property="message", type="string", example="The given data was invalid."),
+ *     @OA\Property(
+ *      property="errors",
+ *      type="object",
+ *      @OA\AdditionalProperties(
+ *          type="array",
+ *          @OA\Items(type="string", example="The title field is required.")
+ *      )
+ *   )
+ * )
+ */
+trait InvalidDataResponseTrait
+{
+    protected function failedValidation(Validator $validator): void
+    {
+        throw new HttpResponseException(response()->json([
+            'message' => 'Invalid data.',
+            'errors' => $validator->errors(),
+        ], 422));
+    }
+}

app/Http/Requests/Post/DestroyPostRequest.php

@@ -0,0 +1,41 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Http\Requests\Post;
+
+use App\Http\Requests\InvalidDataResponseTrait;
+use Illuminate\Foundation\Http\FormRequest;
+
+class DestroyPostRequest extends FormRequest
+{
+    use InvalidDataResponseTrait;
+
+    /**
+     * @return array<string, string>
+     */
+    public function all($keys = null): array
+    {
+        $request = parent::all($keys);
+
+        $request['id'] = $this->route('id');
+
+        return $request;
+    }
+
+
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /**
+     * @return array<string, string>
+     */
+    public function rules(): array
+    {
+        return [
+            'id' => 'required|integer|min:0',
+        ];
+    }
+}

app/Http/Requests/Post/ListPostRequest.php

@@ -0,0 +1,73 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Http\Requests\Post;
+
+use App\Http\Requests\InvalidDataResponseTrait;
+use App\Services\QueryRequestModifiers\Post\PostFilter;
+use App\Services\QueryRequestModifiers\Post\PostFilterDTO;
+use App\Services\QueryRequestModifiers\Post\PostOrder;
+use App\Services\QueryRequestModifiers\Post\PostOrderDTO;
+use Illuminate\Foundation\Http\FormRequest;
+
+class ListPostRequest extends FormRequest
+{
+    use InvalidDataResponseTrait;
+
+    public function __construct(
+        private readonly PostOrder $postOrder,
+        private readonly PostFilter $postFilter,
+    ) {
+    }
+
+    /**
+     * @return array<string, string>
+     */
+    public function all($keys = null): array
+    {
+        $request = parent::all($keys);
+
+        $request['page'] = $this->route('page');
+
+        return $request;
+    }
+
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /**
+     * @return array<string, string>
+     */
+    public function rules(): array
+    {
+        return [
+            'page' => 'required|integer|min:1',
+            ... $this->postFilter->validateRules(),
+            ... $this->postOrder->validateRules()
+        ];
+    }
+
+    /**
+     * @return array<string, string>
+     */
+    public function attributes(): array
+    {
+        return [
+            'page' => 'page number',
+        ];
+    }
+
+
+    public function filters(): ?PostFilterDTO
+    {
+        return $this->postFilter->makeFromRequest($this);
+    }
+
+    public function order(): ?PostOrderDTO
+    {
+        return $this->postOrder->makeFromRequest($this);
+    }
+}

app/Http/Requests/Post/ShowPostRequest.php

@@ -0,0 +1,45 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Http\Requests\Post;
+
+use App\Http\Requests\InvalidDataResponseTrait;
+use Illuminate\Foundation\Http\FormRequest;
+
+class ShowPostRequest extends FormRequest
+{
+    use InvalidDataResponseTrait;
+
+    /**
+     * @return array<string, string>
+     */
+    public function all($keys = null): array
+    {
+        $request = parent::all($keys);
+
+        $request['id'] = $this->route('id');
+
+        return $request;
+    }
+
+    /**
+     * Determine if the user is authorized to make this request.
+     */
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /**
+     * Get the validation rules that apply to the request.
+     *
+     * @return array<string, \Illuminate\Contracts\Validation\ValidationRule|array<mixed>|string>
+     */
+    public function rules(): array
+    {
+        return [
+            'id' => 'required|integer|min:0',
+        ];
+    }
+}

app/Http/Requests/Post/StorePostRequest.php

@@ -0,0 +1,50 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Http\Requests\Post;
+
+use App\Http\Requests\InvalidDataResponseTrait;
+use App\Http\Resources\PostResource;
+use Illuminate\Foundation\Http\FormRequest;
+
+class StorePostRequest extends FormRequest
+{
+    use InvalidDataResponseTrait;
+
+    /**
+     * Determine if the user is authorized to make this request.
+     */
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /**
+     * Get the validation rules that apply to the request.
+     *
+     * @return array<string, string>
+     */
+    public function rules(): array
+    {
+        return static::rulesDefinition();
+    }
+
+    /**
+     * @return array<string, string>
+     */
+    public static function rulesDefinition(): array
+    {
+        return [
+            'title' => 'required|string|max:255',
+            'content' => 'required|string',
+            'category_id' => 'nullable|exists:categories,id',
+            'tags' => 'nullable|array',
+        ];
+    }
+
+    public function getPost(): PostResource
+    {
+        return PostResource::make($this->all());
+    }
+}

app/Http/Requests/Post/UpdatePostRequest.php

@@ -0,0 +1,47 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Http\Requests\Post;
+
+use App\Http\Requests\InvalidDataResponseTrait;
+use Illuminate\Foundation\Http\FormRequest;
+
+class UpdatePostRequest extends FormRequest
+{
+    use InvalidDataResponseTrait;
+
+    /**
+     * @return array<string, string>
+     */
+    public function all($keys = null): array
+    {
+        $request = parent::all($keys);
+
+        $request['id'] = $this->route('id');
+
+        return $request;
+    }
+
+
+    /**
+     * Determine if the user is authorized to make this request.
+     */
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /**
+     * Get the validation rules that apply to the request.
+     *
+     * @return array<string, string>
+     */
+    public function rules(): array
+    {
+        return [
+            ...StorePostRequest::rulesDefinition(),
+            'id' => 'required|integer|min:0',
+        ];
+    }
+}

app/Http/Resources/CategoryCollection.php

@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Http\Resources;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\ResourceCollection;
+use OpenApi\Annotations as OA;
+
+/**
+ * @OA\Schema(
+ *     schema="CategoryCollection",
+ *     type="array",
+ *     title="Category Collection",
+ *     description="A collection of CategoryResource",
+ *     @OA\Items(ref="#/components/schemas/CategoryResource")
+ * )
+ */
+class CategoryCollection extends ResourceCollection
+{
+    /**
+     * @param Request $request
+     * @return array<string, mixed>|\Illuminate\Contracts\Support\Arrayable<string, mixed>|\JsonSerializable
+     */
+    public function toArray(Request $request): array|\Illuminate\Contracts\Support\Arrayable|\JsonSerializable
+    {
+        return parent::toArray($request);
+    }
+}

app/Http/Resources/CategoryResource.php

@@ -0,0 +1,63 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Http\Resources;
+
+use App\Models\Category;
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+use OpenApi\Annotations as OA;
+
+/**
+ * @mixin Category
+ * @OA\Schema(
+ *     schema="CategoryResource",
+ *     type="object",
+ *     title="Category Resource",
+ *     description="Resource representing a single category",
+ *     @OA\Property(
+ *         property="id",
+ *         type="integer",
+ *         description="ID of the category",
+ *         example=1
+ *     ),
+ *     @OA\Property(
+ *         property="name",
+ *         type="string",
+ *         description="Name of the category",
+ *         example="Technology"
+ *     ),
+ *     @OA\Property(
+ *         property="created_at",
+ *         type="string",
+ *         format="date-time",
+ *         description="Timestamp when the category was created",
+ *         example="2023-12-10T14:17:00Z"
+ *     ),
+ *     @OA\Property(
+ *         property="updated_at",
+ *         type="string",
+ *         format="date-time",
+ *         description="Timestamp when the category was last updated",
+ *         example="2023-12-11T15:20:00Z"
+ *     )
+ * )
+ */
+class CategoryResource extends JsonResource
+{
+    /**
+     * Transform the resource into an array.
+     *
+     * @return array<string, mixed>
+     */
+    public function toArray(Request $request): array
+    {
+        return [
+            'id' => $this->id,
+            'name' => $this->name,
+            'created_at' => $this->created_at->toDateTimeString(),
+            'updated_at' => $this->updated_at->toDateTimeString(),
+        ];
+    }
+}

app/Http/Resources/CommentCollection.php

@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Http\Resources;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\ResourceCollection;
+use OpenApi\Annotations as OA;
+
+/**
+ * @OA\Schema(
+ *     schema="CommentCollection",
+ *     type="array",
+ *     title="Comment Collection",
+ *     description="A collection of CommentCollection",
+ *     @OA\Items(ref="#/components/schemas/CommentResource")
+ * )
+ */
+class CommentCollection extends ResourceCollection
+{
+    /**
+     * @param Request $request
+     * @return array<string, mixed>|\Illuminate\Contracts\Support\Arrayable<string, mixed>|\JsonSerializable
+     */
+    public function toArray(Request $request): array|\Illuminate\Contracts\Support\Arrayable|\JsonSerializable
+    {
+        return parent::toArray($request);
+    }
+}

app/Http/Resources/CommentResource.php

@@ -0,0 +1,62 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Http\Resources;
+
+use App\Models\Comment;
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+use OpenApi\Annotations as OA;
+
+/**
+ * @mixin Comment
+ * @OA\Schema(
+ *     schema="CommentResource",
+ *     type="object",
+ *     title="Comment Resource",
+ *     description="Resource representing a single comment",
+ *     @OA\Property(
+ *         property="id",
+ *         type="integer",
+ *         description="ID of the comment",
+ *         example=1
+ *     ),
+ *     @OA\Property(
+ *         property="content",
+ *         type="string",
+ *         description="Content of the comment",
+ *         example="This is a sample comment."
+ *     ),
+ *     @OA\Property(
+ *         property="created_at",
+ *         type="string",
+ *         format="date-time",
+ *         description="Timestamp when the comment was created",
+ *         example="2023-12-10T15:24:00Z"
+ *     ),
+ *     @OA\Property(
+ *         property="updated_at",
+ *         type="string",
+ *         format="date-time",
+ *         description="Timestamp when the comment was last updated",
+ *         example="2023-12-10T16:30:00Z"
+ *     )
+ * )
+ */
+class CommentResource extends JsonResource
+{
+    /** Transform the resource into an array.
+     *
+     * @return array<string, mixed>
+     */
+    public function toArray(Request $request): array
+    {
+        return [
+            'id' => $this->id,
+            'content' => $this->content,
+            'created_at' => $this->created_at->toDateTimeString(),
+            'updated_at' => $this->updated_at->toDateTimeString(),
+        ];
+    }
+}

app/Http/Resources/PaginableResource.php

@@ -0,0 +1,47 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Http\Resources;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+use OpenApi\Annotations as OA;
+
+/**
+ * @template T
+ * @mixin \App\Services\PaginableResource<T>
+ * Souhrnný formát výstupu pro paginovaná data s metadaty.
+ *
+ * @OA\Schema(
+ *     schema="PaginableResourceMeta",
+ *     type="object",
+ *     title="Paginable Resource (meta)",
+ *     description="A paginated collection with meta information",
+ *     @OA\Property(property="totalCount", type="integer", example=1),
+ *     @OA\Property(property="pages", type="integer", example=10),
+ * )
+ */
+class PaginableResource extends JsonResource
+{
+    public function __construct(mixed $resource, protected readonly string $classResource)
+    {
+        parent::__construct($resource);
+    }
+
+    /**
+     * Transform the resource collection into an array.
+     *
+     * @return array<int|string, mixed>
+     */
+    public function toArray(Request $request): array
+    {
+        return [
+            'items' => $this->classResource::make($this->data),
+            'meta' => [
+                'totalCount' => $this->totalCount,
+                'pages' => $this->totalPages,
+            ]
+        ];
+    }
+}

app/Http/Resources/PostCollection.php

@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Http\Resources;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\ResourceCollection;
+use OpenApi\Annotations as OA;
+
+/**
+ * @OA\Schema(
+ *     schema="PostCollection",
+ *     type="array",
+ *     title="Post Collection",
+ *     description="A collection of PostResource",
+ *     @OA\Items(ref="#/components/schemas/PostResource")
+ * )
+ */
+class PostCollection extends ResourceCollection
+{
+    /**
+     * @param Request $request
+     * @return array<string, mixed>|\Illuminate\Contracts\Support\Arrayable<string, mixed>|\JsonSerializable
+     */
+    public function toArray(Request $request): array|\Illuminate\Contracts\Support\Arrayable|\JsonSerializable
+    {
+        return parent::toArray($request);
+    }
+}

app/Http/Resources/PostResource.php

@@ -0,0 +1,89 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Http\Resources;
+
+use App\Models\Post;
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+use OpenApi\Annotations as OA;
+
+/**
+ * @mixin Post
+ * @OA\Schema(
+ *     schema="PostResource",
+ *     type="object",
+ *     title="Post Resource",
+ *     description="Resource representing a single post",
+ *     @OA\Property(
+ *         property="id",
+ *         type="integer",
+ *         description="ID of the post",
+ *         example=1
+ *     ),
+ *     @OA\Property(
+ *         property="title",
+ *         type="string",
+ *         description="Title of the post",
+ *         example="Sample Post Title"
+ *     ),
+ *     @OA\Property(
+ *         property="content",
+ *         type="string",
+ *         description="Content of the post",
+ *         example="This is a sample post content."
+ *     ),
+ *     @OA\Property(
+ *         property="category_id",
+ *         type="integer",
+ *         description="Category ID the post belongs to",
+ *         example=1
+ *     ),
+ *     @OA\Property(
+ *         property="category",
+ *         description="Category object",
+ *         ref="#/components/schemas/CategoryResource",
+ *     ),
+ *     @OA\Property(
+ *          property="tags",
+ *          ref="#/components/schemas/TagCollection",
+ *          description="Collection of tags related to the post"
+ *      ),
+ *     @OA\Property(
+ *         property="created_at",
+ *         type="string",
+ *         format="date-time",
+ *         description="Timestamp when the post was created",
+ *         example="2023-12-10T15:24:00Z"
+ *     ),
+ *     @OA\Property(
+ *         property="updated_at",
+ *         type="string",
+ *         format="date-time",
+ *         description="Timestamp when the post was last updated",
+ *         example="2023-12-10T15:26:00Z"
+ *     )
+ * )
+ */
+class PostResource extends JsonResource
+{
+    /**
+     * Transform the resource collection into an array.
+     *
+     * @return array<int|string, mixed>
+     */
+    public function toArray(Request $request): array
+    {
+        return [
+            'id' => $this->id,
+            'title' => $this->title,
+            'content' => $this->content,
+            'category_id' => $this->category_id,
+            'category' => new CategoryResource($this->whenLoaded('category')),
+            'tags' => new TagCollection($this->whenLoaded('tags')),
+            'created_at' => $this->created_at->toDateTimeString(),
+            'updated_at' => $this->updated_at->toDateTimeString(),
+        ];
+    }
+}

app/Http/Resources/TagCollection.php

@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Http\Resources;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\ResourceCollection;
+use OpenApi\Annotations as OA;
+
+/**
+ * @OA\Schema(
+ *     schema="TagCollection",
+ *     type="array",
+ *     title="Tag Collection",
+ *     description="A collection of TagResource",
+ *     @OA\Items(ref="#/components/schemas/TagResource")
+ * )
+ */
+class TagCollection extends ResourceCollection
+{
+    /**
+     * @param Request $request
+     * @return array<string, mixed>|\Illuminate\Contracts\Support\Arrayable<string, mixed>|\JsonSerializable
+     */
+    public function toArray(Request $request): array|\Illuminate\Contracts\Support\Arrayable|\JsonSerializable
+    {
+        return parent::toArray($request);
+    }
+}

app/Http/Resources/TagResource.php

@@ -0,0 +1,67 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Http\Resources;
+
+use App\Models\Tag;
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+use OpenApi\Annotations as OA;
+
+/**
+ * @mixin Tag
+ */
+
+/**
+ * @mixin Tag
+ * @OA\Schema(
+ *     schema="TagResource",
+ *     type="object",
+ *     title="Tag Resource",
+ *     description="Resource representing a single tag",
+ *     @OA\Property(
+ *         property="id",
+ *         type="integer",
+ *         description="ID of the tag",
+ *         example=1
+ *     ),
+ *     @OA\Property(
+ *         property="name",
+ *         type="string",
+ *         description="Name of the tag",
+ *         example="Laravel"
+ *     ),
+ *     @OA\Property(
+ *         property="created_at",
+ *         type="string",
+ *         format="date-time",
+ *         description="Timestamp when the tag was created",
+ *         example="2023-12-10T14:17:00Z"
+ *     ),
+ *     @OA\Property(
+ *         property="updated_at",
+ *         type="string",
+ *         format="date-time",
+ *         description="Timestamp when the tag was last updated",
+ *         example="2023-12-11T15:20:00Z"
+ *     )
+ * )
+ */
+class TagResource extends JsonResource
+{
+    /**
+     * Transform the resource into an array.
+     *
+     * @return array<string, mixed>
+     */
+    public function toArray(Request $request): array
+    {
+        return [
+            'id' => $this->id,
+            'name' => $this->name,
+            'created_at' => $this->created_at->toDateTimeString(),
+            'updated_at' => $this->updated_at->toDateTimeString(),
+        ];
+    }
+}

app/Models/Category.php

@@ -0,0 +1,32 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Models;
+
+use Carbon\CarbonInterface;
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\HasMany;
+
+/**
+ * @property int $id
+ * @property string $name
+ * @property CarbonInterface $created_at
+ * @property CarbonInterface $updated_at
+ */
+class Category extends Model
+{
+    /** @use HasFactory<\Database\Factories\CategoryFactory> */
+    use HasFactory;
+
+    protected $fillable = ['name'];
+
+    /**
+     * @return HasMany<Post, $this>
+     */
+    public function posts(): HasMany
+    {
+        return $this->hasMany(Post::class);
+    }
+}

app/Models/Comment.php

@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Models;
+
+use Carbon\CarbonInterface;
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Database\Eloquent\Model;
+
+/**
+ * @property int $id
+ * @property string $content
+ * @property CarbonInterface $created_at
+ * @property CarbonInterface $updated_at
+ */
+class Comment extends Model
+{
+    /** @use HasFactory<\Database\Factories\CommentFactory> */
+    use HasFactory;
+
+    protected $fillable = ['content'];
+
+    /**
+     * @return \Illuminate\Database\Eloquent\Relations\MorphTo<Model, $this>
+     */
+    public function commentable()
+    {
+        return $this->morphTo();
+    }
+}

app/Models/Post.php

@@ -0,0 +1,61 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Models;
+
+use Carbon\CarbonInterface;
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Database\Eloquent\Relations\BelongsToMany;
+
+/**
+ * @property int $id
+ * @property string $title
+ * @property string $content
+ * @property ?Category $category
+ * @property int $category_id
+ * @property CarbonInterface $created_at
+ * @property CarbonInterface $updated_at
+ */
+class Post extends Model
+{
+    /** @use HasFactory<\Database\Factories\PostFactory> */
+    use HasFactory;
+
+    /**
+     * The attributes that are mass assignable.
+     *
+     * @var list<string>
+     */
+    protected $fillable = [
+        'title',
+        'content',
+        'category_id',
+    ];
+
+    /**
+     * @return BelongsTo<Category, $this>
+     */
+    public function category()
+    {
+        return $this->belongsTo(Category::class);
+    }
+
+    /**
+     * @return BelongsToMany<Tag, $this>
+     */
+    public function tags()
+    {
+        return $this->belongsToMany(Tag::class);
+    }
+
+    /**
+     * @return \Illuminate\Database\Eloquent\Relations\MorphMany<Comment, $this>
+     */
+    public function comments()
+    {
+        return $this->morphMany(Comment::class, 'commentable');
+    }
+}

app/Models/Tag.php

@@ -0,0 +1,32 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Models;
+
+use Carbon\CarbonInterface;
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsToMany;
+
+/**
+ * @property int $id
+ * @property string $name
+ * @property CarbonInterface $created_at
+ * @property CarbonInterface $updated_at
+ */
+class Tag extends Model
+{
+    /** @use HasFactory<\Database\Factories\TagFactory> */
+    use HasFactory;
+
+    protected $fillable = ['name'];
+
+    /**
+     * @return BelongsToMany<Post, $this>
+     */
+    public function posts()
+    {
+        return $this->belongsToMany(Post::class);
+    }
+}

app/Models/User.php

@@ -0,0 +1,51 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Models;
+
+// use Illuminate\Contracts\Auth\MustVerifyEmail;
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Foundation\Auth\User as Authenticatable;
+use Illuminate\Notifications\Notifiable;
+
+class User extends Authenticatable
+{
+    /** @use HasFactory<\Database\Factories\UserFactory> */
+    use HasFactory;
+    use Notifiable;
+
+    /**
+     * The attributes that are mass assignable.
+     *
+     * @var list<string>
+     */
+    protected $fillable = [
+        'name',
+        'email',
+        'password',
+    ];
+
+    /**
+     * The attributes that should be hidden for serialization.
+     *
+     * @var list<string>
+     */
+    protected $hidden = [
+        'password',
+        'remember_token',
+    ];
+
+    /**
+     * Get the attributes that should be cast.
+     *
+     * @return array<string, string>
+     */
+    protected function casts(): array
+    {
+        return [
+            'email_verified_at' => 'datetime',
+            'password' => 'hashed',
+        ];
+    }
+}

app/Providers/AppServiceProvider.php

@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Providers;
+
+use Illuminate\Support\ServiceProvider;
+
+class AppServiceProvider extends ServiceProvider
+{
+    /**
+     * Register any application services.
+     */
+    public function register(): void
+    {
+        //
+    }
+
+    /**
+     * Bootstrap any application services.
+     */
+    public function boot(): void
+    {
+        //
+    }
+}

app/Providers/CategoryServiceProvider.php

@@ -0,0 +1,44 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Providers;
+
+use App\Services\Category\CategoryService;
+use App\Services\Category\CategoryServiceInterface;
+use App\Services\QueryRequestModifiers\Category\CategoryFilter;
+use App\Services\QueryRequestModifiers\Category\CategoryOrder;
+use Illuminate\Foundation\Application;
+use Illuminate\Support\ServiceProvider;
+
+class CategoryServiceProvider extends ServiceProvider
+{
+    /**
+     * Register services.
+     */
+    public function register(): void
+    {
+        $this->app->singleton(CategoryFilter::class, function (Application $app) {
+            return new CategoryFilter();
+        });
+
+        $this->app->singleton(CategoryOrder::class, function (Application $app) {
+            return new CategoryOrder();
+        });
+
+        $this->app->singleton(CategoryServiceInterface::class, function (Application $app) {
+            return new CategoryService(
+                $this->app->get(CategoryFilter::class),
+                $this->app->get(CategoryOrder::class),
+            );
+        });
+    }
+
+    /**
+     * Bootstrap services.
+     */
+    public function boot(): void
+    {
+        //
+    }
+}

app/Providers/CommentServiceProvider.php

@@ -0,0 +1,44 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Providers;
+
+use App\Services\Comment\PostCommentService;
+use App\Services\QueryRequestModifiers\Comment\CommentFilter;
+use App\Services\QueryRequestModifiers\Comment\CommentOrder;
+use App\Services\QueryRequestModifiers\Comment\CommentOrderDTO;
+use Illuminate\Foundation\Application;
+use Illuminate\Support\ServiceProvider;
+
+class CommentServiceProvider extends ServiceProvider
+{
+    /**
+     * Register services.
+     */
+    public function register(): void
+    {
+        $this->app->singleton(CommentFilter::class, function (Application $app) {
+            return new CommentFilter();
+        });
+
+        $this->app->singleton(CommentOrder::class, function (Application $app) {
+            return new CommentOrder();
+        });
+
+        $this->app->singleton(PostCommentService::class, function (Application $app) {
+            return new PostCommentService(
+                $this->app->get(CommentFilter::class),
+                $this->app->get(CommentOrder::class),
+            );
+        });
+    }
+
+    /**
+     * Bootstrap services.
+     */
+    public function boot(): void
+    {
+        //
+    }
+}

app/Providers/PostServiceProvider.php

@@ -0,0 +1,46 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Providers;
+
+use App\Services\Comment\PostCommentService;
+use App\Services\Post\CachedPostService;
+use App\Services\CacheKeyBuilder;
+use App\Services\Post\PostServiceInterface;
+use App\Services\QueryRequestModifiers\Post\PostFilter;
+use App\Services\QueryRequestModifiers\Post\PostOrder;
+use Illuminate\Foundation\Application;
+use Illuminate\Support\ServiceProvider;
+
+class PostServiceProvider extends ServiceProvider
+{
+    /**
+     * Register services.
+     */
+    public function register(): void
+    {
+        $this->app->singleton(PostFilter::class, function (Application $app) {
+            return new PostFilter();
+        });
+
+        $this->app->singleton(PostOrder::class, function (Application $app) {
+            return new PostOrder();
+        });
+
+        $this->app->singleton(PostServiceInterface::class, function (Application $app) {
+            return new CachedPostService(
+                $this->app->get(PostFilter::class),
+                $this->app->get(PostOrder::class),
+                $this->app->get(CacheKeyBuilder::class),
+            );
+        });
+    }
+
+    /**
+     * Bootstrap services.
+     */
+    public function boot(): void
+    {
+    }
+}

app/Providers/SwaggerProvider.php

@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Providers;
+
+use Illuminate\Support\ServiceProvider;
+use L5Swagger\L5SwaggerServiceProvider;
+use OpenApi\Annotations as OA;
+
+/**
+ * @OA\Info(
+ *     title="Post API",
+ *     version="1.0.0",
+ * )
+ */
+class SwaggerProvider extends ServiceProvider
+{
+    public function register()
+    {
+        $this->app->register(L5SwaggerServiceProvider::class);
+    }
+
+    /**
+     * Bootstrap services.
+     */
+    public function boot(): void
+    {
+        //
+    }
+}

app/Services/CacheKeyBuilder.php

@@ -0,0 +1,32 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Services;
+
+class CacheKeyBuilder
+{
+    /**
+     * @param mixed ...$args
+     * @return string
+     */
+    public function buildCacheKeyFromArgs(...$args): string
+    {
+        $cacheName = '';
+        foreach ($args as $key => $arg) {
+            if (is_array($arg)) {
+                $cacheName .= http_build_query($arg, '', '|');
+            } elseif ($arg === null) {
+                $cacheName .= '|N';
+            } elseif (is_scalar($arg)) {
+                $cacheName .= '|' . (string) $arg;
+            } elseif ($arg instanceof CacheKeyInterface) {
+                $cacheName .= $arg->toCacheKey();
+            } else {
+                throw new \InvalidArgumentException("Invalid argument $key type for key generator.");
+            }
+        }
+
+        return $cacheName;
+    }
+}

app/Services/CacheKeyInterface.php

@@ -0,0 +1,10 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Services;
+
+interface CacheKeyInterface
+{
+    public function toCacheKey(): string;
+}

app/Services/Category/CategoryService.php

@@ -0,0 +1,70 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Services\Category;
+
+use App\Models\Category;
+use App\Services\PaginableResource;
+use App\Services\QueryRequestModifiers\Category\CategoryFilter;
+use App\Services\QueryRequestModifiers\Category\CategoryFilterDTO;
+use App\Services\QueryRequestModifiers\Category\CategoryOrder;
+use App\Services\QueryRequestModifiers\Category\CategoryOrderDTO;
+
+class CategoryService implements CategoryServiceInterface
+{
+    public function __construct(
+        protected readonly CategoryFilter $categoryFilter,
+        protected readonly CategoryOrder $categoryOrder,
+        protected readonly int $paginate = 10,
+    ) {
+    }
+
+    public function fetchCategories(int $page, ?CategoryFilterDTO $filters, ?CategoryOrderDTO $orderDef): PaginableResource
+    {
+        $categories = $this->categoryFilter->apply(
+            $this->categoryOrder->apply(Category::query(), $orderDef),
+            $filters
+        )->paginate($this->paginate);
+        return PaginableResource::createFromLengthAwarePaginator($categories);
+    }
+
+    public function findCategory(int $id): ?Category
+    {
+        return Category::find($id);
+    }
+
+    public function storeCategory(array $data): Category
+    {
+        $category = Category::create($data);
+        return Category::findOrFail($category->id);
+    }
+
+    public function updateCategory(array $data, int $id): ?Category
+    {
+        $category = Category::find($id);
+
+        if ($category === null) {
+            return null;
+        }
+
+        $category->update($data);
+        return Category::findOrFail($id);
+    }
+
+    public function deleteCategory(int $id): bool
+    {
+        $category = Category::find($id);
+
+        if ($category === null) {
+            return false;
+        }
+
+        if ($category->posts()->count() > 0) {
+            // TODO: return code
+            return false;
+        }
+
+        return $category->delete();
+    }
+}

app/Services/Category/CategoryServiceInterface.php

@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Services\Category;
+
+use App\Models\Category;
+use App\Services\PaginableResource;
+use App\Services\QueryRequestModifiers\Category\CategoryFilterDTO;
+use App\Services\QueryRequestModifiers\Category\CategoryOrderDTO;
+
+interface CategoryServiceInterface
+{
+    /**
+     * @return PaginableResource<Category>
+     */
+    public function fetchCategories(int $page, ?CategoryFilterDTO $filters, ?CategoryOrderDTO $orderDef): PaginableResource;
+
+    public function findCategory(int $id): ?Category;
+
+    /**
+     * @param array<string, mixed> $data
+     * @return Category
+     */
+    public function storeCategory(array $data): Category;
+
+    /**
+     * @param array<string, mixed> $data
+     */
+    public function updateCategory(array $data, int $id): ?Category;
+
+    public function deleteCategory(int $id): bool;
+}

app/Services/Comment/CommentServiceInterface.php

@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Services\Comment;
+
+use App\Models\Comment;
+use App\Services\PaginableResource;
+use App\Services\QueryRequestModifiers\Comment\CommentFilterDTO;
+use App\Services\QueryRequestModifiers\Comment\CommentOrderDTO;
+
+interface CommentServiceInterface
+{
+    /**
+     * @return PaginableResource<Comment>
+     */
+    public function fetchComments(int $remoteId, int $page, ?CommentFilterDTO $filters, ?CommentOrderDTO $orderDef): PaginableResource;
+
+    /**
+     * @param array<string, mixed> $data
+     */
+    public function storeComment(array $data, int $postId): ?Comment;
+
+    /**
+     * @param array<string, mixed> $data
+     */
+    public function updateComment(array $data, int $remoteId, int $id): ?Comment;
+
+    public function deleteComment(int $remoteId, int $id): bool;
+}

app/Services/Comment/PostCommentService.php

@@ -0,0 +1,82 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Services\Comment;
+
+use App\Models\Comment;
+use App\Models\Post;
+use App\Services\PaginableResource;
+use App\Services\QueryRequestModifiers\Comment\CommentFilter;
+use App\Services\QueryRequestModifiers\Comment\CommentFilterDTO;
+use App\Services\QueryRequestModifiers\Comment\CommentOrder;
+use App\Services\QueryRequestModifiers\Comment\CommentOrderDTO;
+
+class PostCommentService implements CommentServiceInterface
+{
+    public function __construct(
+        protected readonly CommentFilter $commentFilter,
+        protected readonly CommentOrder $commentOrder,
+        protected readonly int $paginate = 10,
+    ) {
+    }
+
+    public function fetchComments(int $remoteId, int $page, ?CommentFilterDTO $filters, ?CommentOrderDTO $orderDef): PaginableResource
+    {
+        $post = Post::findOrFail($remoteId);
+
+        $comments = $this->commentOrder->apply(
+            $this->commentFilter->apply($post->comments()->getQuery(), $filters),
+            $orderDef
+        )->paginate($this->paginate);
+
+        return PaginableResource::createFromLengthAwarePaginator($comments);
+    }
+
+    public function storeComment(array $data, int $postId): ?Comment
+    {
+        $post = Post::findOrFail($postId);
+
+        $comment = $post->comments()->create([
+            'content' => $data['content'],
+        ]);
+
+        return Comment::findOrFail($comment->id);
+    }
+
+    public function deleteComment(int $remoteId, int $id): bool
+    {
+        $post = Post::find($remoteId);
+
+        if ($post === null) {
+            return false;
+        }
+
+        $comment = $post->comments()->find($id);
+
+        if ($comment === null) {
+            return false;
+        }
+
+        return $comment->delete();
+    }
+
+    public function updateComment(array $data, int $remoteId, int $id): ?Comment
+    {
+        $post = Post::find($remoteId);
+
+        if ($post === null) {
+            return null;
+        }
+
+        $comment = $post->comments()->find($id);
+
+        if ($comment === null) {
+            return null;
+        }
+
+        $comment->update($data);
+
+        return Comment::findOrFail($comment->id);
+    }
+}

app/Services/PaginableResource.php

@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Services;
+
+use Illuminate\Contracts\Pagination\LengthAwarePaginator;
+
+/**
+ * @template T
+ */
+class PaginableResource
+{
+    /**
+     * @param array<int, T> $data
+     * @param int $totalCount
+     */
+    public function __construct(public array $data, public int $totalCount, public int $totalPages)
+    {
+    }
+
+    /**
+     * @param LengthAwarePaginator<int, T> $paginator
+     * @return PaginableResource<T>
+     */
+    public static function createFromLengthAwarePaginator(LengthAwarePaginator $paginator): PaginableResource
+    {
+        return new PaginableResource($paginator->items(), $paginator->total(), (int)ceil($paginator->total() / $paginator->perPage()));
+    }
+}

app/Services/Post/CachedPostService.php

@@ -0,0 +1,75 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Services\Post;
+
+use App\Models\Post;
+use App\Services\CacheKeyBuilder;
+use App\Services\PaginableResource;
+use App\Services\QueryRequestModifiers\Post\PostFilter;
+use App\Services\QueryRequestModifiers\Post\PostFilterDTO;
+use App\Services\QueryRequestModifiers\Post\PostOrder;
+use App\Services\QueryRequestModifiers\Post\PostOrderDTO;
+use Illuminate\Support\Facades\Cache;
+
+class CachedPostService extends PostService
+{
+    public function __construct(
+        PostFilter $postFilter,
+        PostOrder $postOrder,
+        protected readonly CacheKeyBuilder $cacheKeyBuilder,
+        protected readonly int $cacheTtl = 60,
+    ) {
+        parent::__construct($postFilter, $postOrder);
+    }
+
+    public function fetchPosts(int $page, ?PostFilterDTO $filters, ?PostOrderDTO $orderDef): PaginableResource
+    {
+        return Cache::tags(['posts', 'fetch-posts', 'post-page-' . $page])
+            ->remember(
+                $this->cacheKeyBuilder->buildCacheKeyFromArgs('post-page', $page, $filters, $orderDef),
+                $this->cacheTtl,
+                function () use ($page, $filters, $orderDef) {
+                    return parent::fetchPosts($page, $filters, $orderDef);
+                }
+            );
+    }
+
+    public function findPost(int $id): ?Post
+    {
+        return Cache::tags(['posts', 'find-post-' . $id])
+            ->remember('post-' . $id, $this->cacheTtl, function () use ($id) {
+                return parent::findPost($id);
+            });
+    }
+
+    public function storePost(array $data): Post
+    {
+        $newPost = parent::storePost($data);
+
+        Cache::tags('fetch-posts')->flush();
+
+        return $newPost;
+    }
+
+    public function updatePost(array $data, int $id): ?Post
+    {
+        $updatedPost = parent::updatePost($data, $id);
+
+        if ($updatedPost !== null) {
+            Cache::tags('fetch-posts')->flush();
+            Cache::tags('find-post-' . $id)->flush();
+        }
+
+        return $updatedPost;
+    }
+
+    public function deletePost(int $id): bool
+    {
+        Cache::tags('fetch-posts')->flush();
+        Cache::tags('find-post-' . $id)->flush();
+
+        return parent::deletePost($id); // TODO: Change the autogenerated stub
+    }
+}

app/Services/Post/PostService.php

@@ -0,0 +1,106 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Services\Post;
+
+use App\Models\Post;
+use App\Models\Tag;
+use App\Services\PaginableResource;
+use App\Services\QueryRequestModifiers\Post\PostFilter;
+use App\Services\QueryRequestModifiers\Post\PostFilterDTO;
+use App\Services\QueryRequestModifiers\Post\PostOrder;
+use App\Services\QueryRequestModifiers\Post\PostOrderDTO;
+use Illuminate\Support\Facades\DB;
+
+class PostService implements PostServiceInterface
+{
+    public function __construct(
+        protected readonly PostFilter $postFilter,
+        protected readonly PostOrder $postOrder,
+        protected readonly int $paginate = 10,
+    ) {
+    }
+
+    public function fetchPosts(int $page, ?PostFilterDTO $filters, ?PostOrderDTO $orderDef): PaginableResource
+    {
+        $posts = $this->postOrder->apply(
+            $this->postFilter->apply(Post::with(['category', 'tags', 'comments']), $filters),
+            $orderDef
+        )->paginate($this->paginate, page: $page);
+        return PaginableResource::createFromLengthAwarePaginator($posts);
+    }
+
+    public function findPost(int $id): ?Post
+    {
+        return Post::with(['category', 'tags', 'comments'])->find($id);
+    }
+
+    public function storePost(array $data): Post
+    {
+        DB::beginTransaction();
+
+        $post = Post::create($data);
+
+        if (isset($data['tags'])) {
+            $tags = [];
+
+            foreach ($data['tags'] as $tag) {
+                $tag = Tag::firstOrCreate(['name' => $tag]);
+                $tags[] = $tag;
+            }
+
+            $post->tags()->sync($tags);
+        }
+
+        $post = $this->findPost($post->id);
+
+        if ($post === null) {
+            throw new \InvalidArgumentException('This should never happen - post is null');
+        }
+
+        DB::commit();
+
+        return $post;
+    }
+
+    public function updatePost(array $data, int $id): ?Post
+    {
+        DB::beginTransaction();
+
+        $post = Post::find($id);
+
+        if ($post === null) {
+            return null;
+        }
+
+        if (isset($data['tags'])) {
+            $tags = [];
+
+            foreach ($data['tags'] as $tag) {
+                $tag = Tag::firstOrCreate(['name' => $tag]);
+                $tags[] = $tag;
+            }
+
+            $post->tags()->sync($tags);
+        }
+
+        $post->update($data);
+
+        DB::commit();
+
+        return $this->findPost($post->id);
+    }
+
+    public function deletePost(int $id): bool
+    {
+        $post = Post::find($id);
+
+        if ($post === null) {
+            return false;
+        }
+
+        $post->delete();
+        return true;
+    }
+}

app/Services/Post/PostServiceInterface.php

@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Services\Post;
+
+use App\Models\Post;
+use App\Services\PaginableResource;
+use App\Services\QueryRequestModifiers\Post\PostFilterDTO;
+use App\Services\QueryRequestModifiers\Post\PostOrderDTO;
+
+interface PostServiceInterface
+{
+    /**
+     * @return PaginableResource<Post>
+     */
+    public function fetchPosts(int $page, ?PostFilterDTO $filters, ?PostOrderDTO $orderDef): PaginableResource;
+
+    public function findPost(int $id): ?Post;
+
+    /**
+     * @param array<string, mixed> $data
+     * @return Post
+     */
+    public function storePost(array $data): Post;
+
+    /**
+     * @param array<string, mixed> $data
+     */
+    public function updatePost(array $data, int $id): ?Post;
+
+    public function deletePost(int $id): bool;
+}

app/Services/QueryRequestModifiers/Category/CategoryFilter.php

@@ -0,0 +1,51 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Services\QueryRequestModifiers\Category;
+
+use App\Http\Requests\Category\ListCategoryRequest;
+use App\Models\Category;
+use App\Services\QueryRequestModifiers\Filterable;
+use Illuminate\Database\Eloquent\Builder;
+
+class CategoryFilter
+{
+    /**
+     * @use Filterable<Category, CategoryFilterDTO>
+     */
+    use Filterable;
+
+    /**
+     * @param Builder<Category> $query
+     * @return Builder<Category>
+     */
+    public function apply(Builder $query, ?CategoryFilterDTO $filters): Builder
+    {
+        return $this->applyFilterable($query, $filters);
+    }
+
+    public function makeFromRequest(ListCategoryRequest $request): ?CategoryFilterDTO
+    {
+        return $this->makeFilterableFromRequest($request, CategoryFilterDTO::class);
+    }
+
+    /**
+     * @return array<string, string>
+     */
+    public function validateRules(): array
+    {
+        return [
+            'name' => 'sometimes|string|max:255',
+        ];
+    }
+
+
+    /**
+     * @return array<int, string>
+     */
+    protected static function keys(): array
+    {
+        return ['name'];
+    }
+}

app/Services/QueryRequestModifiers/Category/CategoryFilterDTO.php

@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Services\QueryRequestModifiers\Category;
+
+use App\Services\CacheKeyInterface;
+
+class CategoryFilterDTO implements CacheKeyInterface
+{
+    /**
+     * @param array<string, string> $filters
+     */
+    public function __construct(public array $filters)
+    {
+    }
+
+    public function toCacheKey(): string
+    {
+        return http_build_query($this->filters, '', '|');
+    }
+}

app/Services/QueryRequestModifiers/Category/CategoryOrder.php

@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Services\QueryRequestModifiers\Category;
+
+use App\Http\Requests\Category\ListCategoryRequest;
+use App\Models\Category;
+use App\Services\QueryRequestModifiers\Orderable;
+use Illuminate\Database\Eloquent\Builder;
+
+class CategoryOrder
+{
+    /**
+     * @use Orderable<Category, CategoryOrderDTO>
+     */
+    use Orderable;
+
+
+    /**
+     * @param Builder<Category> $query
+     * @return Builder<Category>
+     */
+    public function apply(Builder $query, ?CategoryOrderDTO $filters): Builder
+    {
+        return $this->applyOrderable($query, $filters);
+    }
+
+    public function makeFromRequest(ListCategoryRequest $request): ?CategoryOrderDTO
+    {
+        return $this->makeOrderableFromRequest($request, CategoryOrderDTO::class);
+    }
+}

app/Services/QueryRequestModifiers/Category/CategoryOrderDTO.php

@@ -0,0 +1,42 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Services\QueryRequestModifiers\Category;
+
+use App\Services\CacheKeyInterface;
+use App\Services\QueryRequestModifiers\OrderableDTO;
+use App\Services\QueryRequestModifiers\SortDirection;
+
+/**
+ * @implements OrderableDTO<CategoryOrderDTO>
+ */
+class CategoryOrderDTO implements CacheKeyInterface, OrderableDTO
+{
+    public function __construct(public string $column, public SortDirection $direction)
+    {
+    }
+
+    public function toCacheKey(): string
+    {
+        return $this->column . '|' . $this->direction->value;
+    }
+
+    public function getColumn(): string
+    {
+        return $this->column;
+    }
+
+    public function getDirection(): SortDirection
+    {
+        return $this->direction;
+    }
+
+    public static function createFromValues(string $column, SortDirection $sortDirection): OrderableDTO
+    {
+        return new self(
+            $column,
+            $sortDirection
+        );
+    }
+}

app/Services/QueryRequestModifiers/Comment/CommentFilter.php

@@ -0,0 +1,51 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Services\QueryRequestModifiers\Comment;
+
+use App\Http\Requests\Comment\ListCommentRequest;
+use App\Models\Comment;
+use App\Services\QueryRequestModifiers\Filterable;
+use Illuminate\Database\Eloquent\Builder;
+
+class CommentFilter
+{
+    /**
+     * @use Filterable<Comment, CommentFilterDTO>
+     */
+    use Filterable;
+
+    /**
+     * @param Builder<Comment> $query
+     * @return Builder<Comment>
+     */
+    public function apply(Builder $query, ?CommentFilterDTO $filters): Builder
+    {
+        return $this->applyFilterable($query, $filters);
+    }
+
+    public function makeFromRequest(ListCommentRequest $request): ?CommentFilterDTO
+    {
+        return $this->makeFilterableFromRequest($request, CommentFilterDTO::class);
+    }
+
+    /**
+     * @return array<string, string>
+     */
+    public function validateRules(): array
+    {
+        return [
+            'content' => 'sometimes|string',
+        ];
+    }
+
+
+    /**
+     * @return array<int, string>
+     */
+    protected static function keys(): array
+    {
+        return ['content'];
+    }
+}

app/Services/QueryRequestModifiers/Comment/CommentFilterDTO.php

@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Services\QueryRequestModifiers\Comment;
+
+use App\Services\CacheKeyInterface;
+
+readonly class CommentFilterDTO implements CacheKeyInterface
+{
+    /**
+     * @param array<string, string> $filters
+     */
+    public function __construct(public array $filters)
+    {
+    }
+
+    public function toCacheKey(): string
+    {
+        return http_build_query($this->filters, '', '|');
+    }
+}

app/Services/QueryRequestModifiers/Comment/CommentOrder.php

@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Services\QueryRequestModifiers\Comment;
+
+use App\Http\Requests\Comment\ListCommentRequest;
+use App\Models\Comment;
+use App\Services\QueryRequestModifiers\Orderable;
+use Illuminate\Database\Eloquent\Builder;
+
+class CommentOrder
+{
+    /**
+     * @use Orderable<Comment, CommentOrderDTO>
+     */
+    use Orderable;
+
+
+    /**
+     * @param Builder<Comment> $query
+     * @return Builder<Comment>
+     */
+    public function apply(Builder $query, ?CommentOrderDTO $filters): Builder
+    {
+        return $this->applyOrderable($query, $filters);
+    }
+
+    public function makeFromRequest(ListCommentRequest $request): ?CommentOrderDTO
+    {
+        return $this->makeOrderableFromRequest($request, CommentOrderDTO::class);
+    }
+}

app/Services/QueryRequestModifiers/Comment/CommentOrderDTO.php

@@ -0,0 +1,41 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Services\QueryRequestModifiers\Comment;
+
+use App\Services\QueryRequestModifiers\OrderableDTO;
+use App\Services\QueryRequestModifiers\SortDirection;
+
+/**
+ * @implements OrderableDTO<CommentOrderDTO>
+ */
+readonly class CommentOrderDTO implements OrderableDTO
+{
+    public function __construct(public string $column, public SortDirection $direction)
+    {
+    }
+
+    public function toCacheKey(): string
+    {
+        return $this->column . '|' . $this->direction->value;
+    }
+
+    public function getColumn(): string
+    {
+        return $this->column;
+    }
+
+    public function getDirection(): SortDirection
+    {
+        return $this->direction;
+    }
+
+    public static function createFromValues(string $column, SortDirection $sortDirection): OrderableDTO
+    {
+        return new self(
+            $column,
+            $sortDirection
+        );
+    }
+}

app/Services/QueryRequestModifiers/Filterable.php

@@ -0,0 +1,52 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Services\QueryRequestModifiers;
+
+use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Foundation\Http\FormRequest;
+
+/**
+ * @template C of Model
+ * @template D
+ */
+trait Filterable
+{
+    abstract public static function keys();
+
+    /**
+     * @param Builder<C>  $query
+     * @return Builder<C>
+     */
+    protected function applyFilterable(Builder $query, ?object $filters): Builder
+    {
+        if ($filters === null) {
+            return $query;
+        }
+
+        foreach (self::keys() as $filterName) {
+            if (isset($filters->filters[$filterName])) {
+                $query->where($filterName, '=', $filters->filters[$filterName]);
+            }
+        }
+        return $query;
+    }
+
+    /**
+     * @param class-string<D> $className
+     * @return D|null
+     */
+    protected function makeFilterableFromRequest(FormRequest $request, string $className): ?object
+    {
+        $keys = $request->all(self::keys());
+
+        // no filtering
+        if (count($keys) === 0) {
+            return null;
+        }
+
+        return new $className($keys);
+    }
+}

app/Services/QueryRequestModifiers/Orderable.php

@@ -0,0 +1,75 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Services\QueryRequestModifiers;
+
+use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Foundation\Http\FormRequest;
+use Illuminate\Support\Facades\Validator;
+
+/**
+ * @template C of Model
+ * @template D of OrderableDTO
+ */
+trait Orderable
+{
+    /**
+     * @param Builder<C> $query
+     * @param ?OrderableDTO<D> $orderDef
+     * @return Builder<C>
+     */
+    protected function applyOrderable(Builder $query, ?OrderableDTO $orderDef): Builder
+    {
+        if ($orderDef !== null) {
+            $query->orderBy($orderDef->getColumn(), $orderDef->getDirection()->value);
+        }
+
+        return $query;
+    }
+
+    /**
+     * @param class-string<D> $className
+     * @return D|null
+     */
+    protected function makeOrderableFromRequest(FormRequest $request, string $className): ?object
+    {
+        $keys = $request->all(self::keys());
+
+        if (!isset($keys['order']) || !isset($keys['direction'])) {
+            return null;
+        }
+
+        $validator = Validator::make($keys, $this->validateRules());
+
+        if ($validator->fails()) {
+            // this should never happen... Invalid request
+            throw new \InvalidArgumentException($validator->errors()->first());
+        }
+
+        $column = $keys['order'];
+        $direction = $keys['direction'];
+
+        return call_user_func([$className, 'createFromValues'], $column, SortDirection::from($direction));
+    }
+
+    /**
+     * @return array<string, string>
+     */
+    public function validateRules(): array
+    {
+        return [
+            'order' => 'sometimes|string|in:title',
+            'direction' => 'sometimes|string|in:asc,desc',
+        ];
+    }
+
+    /**
+     * @return array<int, string>
+     */
+    protected static function keys(): array
+    {
+        return ['order', 'direction'];
+    }
+}

app/Services/QueryRequestModifiers/OrderableDTO.php

@@ -0,0 +1,19 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Services\QueryRequestModifiers;
+
+/**
+ * @template T of OrderableDTO
+ */
+interface OrderableDTO
+{
+    public function getColumn(): string;
+    public function getDirection(): SortDirection;
+
+    /**
+     * @return T
+     */
+    public static function createFromValues(string $column, SortDirection $sortDirection): self;
+}

app/Services/QueryRequestModifiers/Post/PostFilter.php

@@ -0,0 +1,52 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Services\QueryRequestModifiers\Post;
+
+use App\Http\Requests\Post\ListPostRequest;
+use App\Models\Post;
+use App\Services\QueryRequestModifiers\Filterable;
+use Illuminate\Database\Eloquent\Builder;
+
+class PostFilter
+{
+    /**
+     * @use Filterable<Post, PostFilterDTO>
+     */
+    use Filterable;
+
+    /**
+     * @param Builder<Post> $query
+     * @return Builder<Post>
+     */
+    public function apply(Builder $query, ?PostFilterDTO $filters): Builder
+    {
+        return $this->applyFilterable($query, $filters);
+    }
+
+    public function makeFromRequest(ListPostRequest $request): ?PostFilterDTO
+    {
+        return $this->makeFilterableFromRequest($request, PostFilterDTO::class);
+    }
+
+    /**
+     * @return array<string, string>
+     */
+    public function validateRules(): array
+    {
+        return [
+            'title' => 'sometimes|string',
+            'content' => 'sometimes|string',
+        ];
+    }
+
+
+    /**
+     * @return array<int, string>
+     */
+    protected static function keys(): array
+    {
+        return ['title', 'content'];
+    }
+}

app/Services/QueryRequestModifiers/Post/PostFilterDTO.php

@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Services\QueryRequestModifiers\Post;
+
+use App\Services\CacheKeyInterface;
+
+readonly class PostFilterDTO implements CacheKeyInterface
+{
+    /**
+     * @param array<string, string> $filters
+     */
+    public function __construct(public array $filters)
+    {
+    }
+
+    public function toCacheKey(): string
+    {
+        return http_build_query($this->filters, '', '|');
+    }
+}

app/Services/QueryRequestModifiers/Post/PostOrder.php

@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Services\QueryRequestModifiers\Post;
+
+use App\Http\Requests\Post\ListPostRequest;
+use App\Models\Post;
+use App\Services\QueryRequestModifiers\Orderable;
+use Illuminate\Database\Eloquent\Builder;
+
+class PostOrder
+{
+    /**
+     * @use Orderable<Post, PostOrderDTO>
+     */
+    use Orderable;
+
+
+    /**
+     * @param Builder<Post> $query
+     * @return Builder<Post>
+     */
+    public function apply(Builder $query, ?PostOrderDTO $filters): Builder
+    {
+        return $this->applyOrderable($query, $filters);
+    }
+
+    public function makeFromRequest(ListPostRequest $request): ?PostOrderDTO
+    {
+        return $this->makeOrderableFromRequest($request, PostOrderDTO::class);
+    }
+}

app/Services/QueryRequestModifiers/Post/PostOrderDTO.php

@@ -0,0 +1,42 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Services\QueryRequestModifiers\Post;
+
+use App\Services\CacheKeyInterface;
+use App\Services\QueryRequestModifiers\SortDirection;
+use App\Services\QueryRequestModifiers\OrderableDTO;
+
+/**
+ * @implements OrderableDTO<PostOrderDTO>
+ */
+readonly class PostOrderDTO implements CacheKeyInterface, OrderableDTO
+{
+    public function __construct(public string $column, public SortDirection $direction)
+    {
+    }
+
+    public function toCacheKey(): string
+    {
+        return $this->column . '|' . $this->direction->value;
+    }
+
+    public function getColumn(): string
+    {
+        return $this->column;
+    }
+
+    public function getDirection(): SortDirection
+    {
+        return $this->direction;
+    }
+
+    public static function createFromValues(string $column, SortDirection $sortDirection): OrderableDTO
+    {
+        return new self(
+            $column,
+            $sortDirection
+        );
+    }
+}

app/Services/QueryRequestModifiers/SortDirection.php

@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Services\QueryRequestModifiers;
+
+enum SortDirection: string
+{
+    case ASC = "asc";
+    case DESC = "desc";
+}

artisan

@@ -0,0 +1,15 @@
+#!/usr/bin/env php
+<?php
+
+use Symfony\Component\Console\Input\ArgvInput;
+
+define('LARAVEL_START', microtime(true));
+
+// Register the Composer autoloader...
+require __DIR__.'/vendor/autoload.php';
+
+// Bootstrap Laravel and handle the command...
+$status = (require_once __DIR__.'/bootstrap/app.php')
+    ->handleCommand(new ArgvInput);
+
+exit($status);

bootstrap/app.php

@@ -0,0 +1,19 @@
+<?php
+
+use Illuminate\Foundation\Application;
+use Illuminate\Foundation\Configuration\Exceptions;
+use Illuminate\Foundation\Configuration\Middleware;
+
+return Application::configure(basePath: dirname(__DIR__))
+    ->withRouting(
+        web: __DIR__.'/../routes/web.php',
+        api: __DIR__.'/../routes/api.php',
+        commands: __DIR__.'/../routes/console.php',
+        health: '/up',
+    )
+    ->withMiddleware(function (Middleware $middleware) {
+        //
+    })
+    ->withExceptions(function (Exceptions $exceptions) {
+        //
+    })->create();

bootstrap/cache/.gitignore

@@ -0,0 +1,2 @@
+*
+!.gitignore

bootstrap/providers.php

@@ -0,0 +1,9 @@
+<?php
+
+return [
+    App\Providers\AppServiceProvider::class,
+    App\Providers\CategoryServiceProvider::class,
+    App\Providers\CommentServiceProvider::class,
+    App\Providers\PostServiceProvider::class,
+    App\Providers\SwaggerProvider::class,
+];

composer.json

@@ -0,0 +1,75 @@
+{
+    "$schema": "https://getcomposer.org/schema.json",
+    "name": "laravel/laravel",
+    "type": "project",
+    "description": "The skeleton application for the Laravel framework.",
+    "keywords": ["laravel", "framework"],
+    "license": "MIT",
+    "require": {
+        "php": "^8.2",
+        "darkaonline/l5-swagger": "^8.6",
+        "laravel/framework": "^11.31",
+        "laravel/tinker": "^2.9"
+    },
+    "require-dev": {
+        "fakerphp/faker": "^1.23",
+        "laravel/pail": "^1.1",
+        "laravel/pint": "^1.13",
+        "laravel/sail": "^1.26",
+        "mockery/mockery": "^1.6",
+        "nunomaduro/collision": "^8.1",
+        "phpstan/phpstan": "^2.1",
+        "phpunit/phpunit": "^11.0.1",
+        "slevomat/coding-standard": "^8.15"
+    },
+    "autoload": {
+        "psr-4": {
+            "App\\": "app/",
+            "Database\\Factories\\": "database/factories/",
+            "Database\\Seeders\\": "database/seeders/"
+        }
+    },
+    "autoload-dev": {
+        "psr-4": {
+            "Tests\\": "tests/"
+        }
+    },
+    "scripts": {
+        "post-autoload-dump": [
+            "Illuminate\\Foundation\\ComposerScripts::postAutoloadDump",
+            "@php artisan package:discover --ansi"
+        ],
+        "post-update-cmd": [
+            "@php artisan vendor:publish --tag=laravel-assets --ansi --force"
+        ],
+        "post-root-package-install": [
+            "@php -r \"file_exists('.env') || copy('.env.example', '.env');\""
+        ],
+        "post-create-project-cmd": [
+            "@php artisan key:generate --ansi",
+            "@php -r \"file_exists('database/database.sqlite') || touch('database/database.sqlite');\"",
+            "@php artisan migrate --graceful --ansi"
+        ],
+        "dev": [
+            "Composer\\Config::disableProcessTimeout",
+            "npx concurrently -c \"#93c5fd,#c4b5fd,#fb7185,#fdba74\" \"php artisan serve\" \"php artisan queue:listen --tries=1\" \"php artisan pail --timeout=0\" \"npm run dev\" --names=server,queue,logs,vite"
+        ]
+    },
+    "extra": {
+        "laravel": {
+            "dont-discover": []
+        }
+    },
+    "config": {
+        "optimize-autoloader": true,
+        "preferred-install": "dist",
+        "sort-packages": true,
+        "allow-plugins": {
+            "dealerdirect/phpcodesniffer-composer-installer": true,
+            "pestphp/pest-plugin": true,
+            "php-http/discovery": true
+        }
+    },
+    "minimum-stability": "stable",
+    "prefer-stable": true
+}

config/app.php

@@ -0,0 +1,126 @@
+<?php
+
+return [
+
+    /*
+    |--------------------------------------------------------------------------
+    | Application Name
+    |--------------------------------------------------------------------------
+    |
+    | This value is the name of your application, which will be used when the
+    | framework needs to place the application's name in a notification or
+    | other UI elements where an application name needs to be displayed.
+    |
+    */
+
+    'name' => env('APP_NAME', 'Laravel'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Application Environment
+    |--------------------------------------------------------------------------
+    |
+    | This value determines the "environment" your application is currently
+    | running in. This may determine how you prefer to configure various
+    | services the application utilizes. Set this in your ".env" file.
+    |
+    */
+
+    'env' => env('APP_ENV', 'production'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Application Debug Mode
+    |--------------------------------------------------------------------------
+    |
+    | When your application is in debug mode, detailed error messages with
+    | stack traces will be shown on every error that occurs within your
+    | application. If disabled, a simple generic error page is shown.
+    |
+    */
+
+    'debug' => (bool) env('APP_DEBUG', false),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Application URL
+    |--------------------------------------------------------------------------
+    |
+    | This URL is used by the console to properly generate URLs when using
+    | the Artisan command line tool. You should set this to the root of
+    | the application so that it's available within Artisan commands.
+    |
+    */
+
+    'url' => env('APP_URL', 'http://localhost'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Application Timezone
+    |--------------------------------------------------------------------------
+    |
+    | Here you may specify the default timezone for your application, which
+    | will be used by the PHP date and date-time functions. The timezone
+    | is set to "UTC" by default as it is suitable for most use cases.
+    |
+    */
+
+    'timezone' => env('APP_TIMEZONE', 'UTC'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Application Locale Configuration
+    |--------------------------------------------------------------------------
+    |
+    | The application locale determines the default locale that will be used
+    | by Laravel's translation / localization methods. This option can be
+    | set to any locale for which you plan to have translation strings.
+    |
+    */
+
+    'locale' => env('APP_LOCALE', 'en'),
+
+    'fallback_locale' => env('APP_FALLBACK_LOCALE', 'en'),
+
+    'faker_locale' => env('APP_FAKER_LOCALE', 'en_US'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Encryption Key
+    |--------------------------------------------------------------------------
+    |
+    | This key is utilized by Laravel's encryption services and should be set
+    | to a random, 32 character string to ensure that all encrypted values
+    | are secure. You should do this prior to deploying the application.
+    |
+    */
+
+    'cipher' => 'AES-256-CBC',
+
+    'key' => env('APP_KEY'),
+
+    'previous_keys' => [
+        ...array_filter(
+            explode(',', env('APP_PREVIOUS_KEYS', ''))
+        ),
+    ],
+
+    /*
+    |--------------------------------------------------------------------------
+    | Maintenance Mode Driver
+    |--------------------------------------------------------------------------
+    |
+    | These configuration options determine the driver used to determine and
+    | manage Laravel's "maintenance mode" status. The "cache" driver will
+    | allow maintenance mode to be controlled across multiple machines.
+    |
+    | Supported drivers: "file", "cache"
+    |
+    */
+
+    'maintenance' => [
+        'driver' => env('APP_MAINTENANCE_DRIVER', 'file'),
+        'store' => env('APP_MAINTENANCE_STORE', 'database'),
+    ],
+
+];

config/auth.php

@@ -0,0 +1,115 @@
+<?php
+
+return [
+
+    /*
+    |--------------------------------------------------------------------------
+    | Authentication Defaults
+    |--------------------------------------------------------------------------
+    |
+    | This option defines the default authentication "guard" and password
+    | reset "broker" for your application. You may change these values
+    | as required, but they're a perfect start for most applications.
+    |
+    */
+
+    'defaults' => [
+        'guard' => env('AUTH_GUARD', 'web'),
+        'passwords' => env('AUTH_PASSWORD_BROKER', 'users'),
+    ],
+
+    /*
+    |--------------------------------------------------------------------------
+    | Authentication Guards
+    |--------------------------------------------------------------------------
+    |
+    | Next, you may define every authentication guard for your application.
+    | Of course, a great default configuration has been defined for you
+    | which utilizes session storage plus the Eloquent user provider.
+    |
+    | All authentication guards have a user provider, which defines how the
+    | users are actually retrieved out of your database or other storage
+    | system used by the application. Typically, Eloquent is utilized.
+    |
+    | Supported: "session"
+    |
+    */
+
+    'guards' => [
+        'web' => [
+            'driver' => 'session',
+            'provider' => 'users',
+        ],
+    ],
+
+    /*
+    |--------------------------------------------------------------------------
+    | User Providers
+    |--------------------------------------------------------------------------
+    |
+    | All authentication guards have a user provider, which defines how the
+    | users are actually retrieved out of your database or other storage
+    | system used by the application. Typically, Eloquent is utilized.
+    |
+    | If you have multiple user tables or models you may configure multiple
+    | providers to represent the model / table. These providers may then
+    | be assigned to any extra authentication guards you have defined.
+    |
+    | Supported: "database", "eloquent"
+    |
+    */
+
+    'providers' => [
+        'users' => [
+            'driver' => 'eloquent',
+            'model' => env('AUTH_MODEL', App\Models\User::class),
+        ],
+
+        // 'users' => [
+        //     'driver' => 'database',
+        //     'table' => 'users',
+        // ],
+    ],
+
+    /*
+    |--------------------------------------------------------------------------
+    | Resetting Passwords
+    |--------------------------------------------------------------------------
+    |
+    | These configuration options specify the behavior of Laravel's password
+    | reset functionality, including the table utilized for token storage
+    | and the user provider that is invoked to actually retrieve users.
+    |
+    | The expiry time is the number of minutes that each reset token will be
+    | considered valid. This security feature keeps tokens short-lived so
+    | they have less time to be guessed. You may change this as needed.
+    |
+    | The throttle setting is the number of seconds a user must wait before
+    | generating more password reset tokens. This prevents the user from
+    | quickly generating a very large amount of password reset tokens.
+    |
+    */
+
+    'passwords' => [
+        'users' => [
+            'provider' => 'users',
+            'table' => env('AUTH_PASSWORD_RESET_TOKEN_TABLE', 'password_reset_tokens'),
+            'expire' => 60,
+            'throttle' => 60,
+        ],
+    ],
+
+    /*
+    |--------------------------------------------------------------------------
+    | Password Confirmation Timeout
+    |--------------------------------------------------------------------------
+    |
+    | Here you may define the amount of seconds before a password confirmation
+    | window expires and users are asked to re-enter their password via the
+    | confirmation screen. By default, the timeout lasts for three hours.
+    |
+    */
+
+    'password_timeout' => env('AUTH_PASSWORD_TIMEOUT', 10800),
+
+];

config/cache.php

@@ -0,0 +1,108 @@
+<?php
+
+use Illuminate\Support\Str;
+
+return [
+
+    /*
+    |--------------------------------------------------------------------------
+    | Default Cache Store
+    |--------------------------------------------------------------------------
+    |
+    | This option controls the default cache store that will be used by the
+    | framework. This connection is utilized if another isn't explicitly
+    | specified when running a cache operation inside the application.
+    |
+    */
+
+    'default' => env('CACHE_STORE', 'redis'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Cache Stores
+    |--------------------------------------------------------------------------
+    |
+    | Here you may define all of the cache "stores" for your application as
+    | well as their drivers. You may even define multiple stores for the
+    | same cache driver to group types of items stored in your caches.
+    |
+    | Supported drivers: "array", "database", "file", "memcached",
+    |                    "redis", "dynamodb", "octane", "null"
+    |
+    */
+
+    'stores' => [
+
+        'array' => [
+            'driver' => 'array',
+            'serialize' => false,
+        ],
+
+        'database' => [
+            'driver' => 'database',
+            'connection' => env('DB_CACHE_CONNECTION'),
+            'table' => env('DB_CACHE_TABLE', 'cache'),
+            'lock_connection' => env('DB_CACHE_LOCK_CONNECTION'),
+            'lock_table' => env('DB_CACHE_LOCK_TABLE'),
+        ],
+
+        'file' => [
+            'driver' => 'file',
+            'path' => storage_path('framework/cache/data'),
+            'lock_path' => storage_path('framework/cache/data'),
+        ],
+
+        'memcached' => [
+            'driver' => 'memcached',
+            'persistent_id' => env('MEMCACHED_PERSISTENT_ID'),
+            'sasl' => [
+                env('MEMCACHED_USERNAME'),
+                env('MEMCACHED_PASSWORD'),
+            ],
+            'options' => [
+                // Memcached::OPT_CONNECT_TIMEOUT => 2000,
+            ],
+            'servers' => [
+                [
+                    'host' => env('MEMCACHED_HOST', '127.0.0.1'),
+                    'port' => env('MEMCACHED_PORT', 11211),
+                    'weight' => 100,
+                ],
+            ],
+        ],
+
+        'redis' => [
+            'driver' => 'redis',
+            'connection' => env('REDIS_CACHE_CONNECTION', 'cache'),
+            'lock_connection' => env('REDIS_CACHE_LOCK_CONNECTION', 'default'),
+        ],
+
+        'dynamodb' => [
+            'driver' => 'dynamodb',
+            'key' => env('AWS_ACCESS_KEY_ID'),
+            'secret' => env('AWS_SECRET_ACCESS_KEY'),
+            'region' => env('AWS_DEFAULT_REGION', 'us-east-1'),
+            'table' => env('DYNAMODB_CACHE_TABLE', 'cache'),
+            'endpoint' => env('DYNAMODB_ENDPOINT'),
+        ],
+
+        'octane' => [
+            'driver' => 'octane',
+        ],
+
+    ],
+
+    /*
+    |--------------------------------------------------------------------------
+    | Cache Key Prefix
+    |--------------------------------------------------------------------------
+    |
+    | When utilizing the APC, database, memcached, Redis, and DynamoDB cache
+    | stores, there might be other applications using the same cache. For
+    | that reason, you may prefix every cache key to avoid collisions.
+    |
+    */
+
+    'prefix' => env('CACHE_PREFIX', Str::slug(env('APP_NAME', 'laravel'), '_').'_cache_'),
+
+];

config/database.php

@@ -0,0 +1,173 @@
+<?php
+
+use Illuminate\Support\Str;
+
+return [
+
+    /*
+    |--------------------------------------------------------------------------
+    | Default Database Connection Name
+    |--------------------------------------------------------------------------
+    |
+    | Here you may specify which of the database connections below you wish
+    | to use as your default connection for database operations. This is
+    | the connection which will be utilized unless another connection
+    | is explicitly specified when you execute a query / statement.
+    |
+    */
+
+    'default' => env('DB_CONNECTION', 'sqlite'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Database Connections
+    |--------------------------------------------------------------------------
+    |
+    | Below are all of the database connections defined for your application.
+    | An example configuration is provided for each database system which
+    | is supported by Laravel. You're free to add / remove connections.
+    |
+    */
+
+    'connections' => [
+
+        'sqlite' => [
+            'driver' => 'sqlite',
+            'url' => env('DB_URL'),
+            'database' => env('DB_DATABASE', database_path('database.sqlite')),
+            'prefix' => '',
+            'foreign_key_constraints' => env('DB_FOREIGN_KEYS', true),
+            'busy_timeout' => null,
+            'journal_mode' => null,
+            'synchronous' => null,
+        ],
+
+        'mysql' => [
+            'driver' => 'mysql',
+            'url' => env('DB_URL'),
+            'host' => env('DB_HOST', '127.0.0.1'),
+            'port' => env('DB_PORT', '3306'),
+            'database' => env('DB_DATABASE', 'laravel'),
+            'username' => env('DB_USERNAME', 'root'),
+            'password' => env('DB_PASSWORD', ''),
+            'unix_socket' => env('DB_SOCKET', ''),
+            'charset' => env('DB_CHARSET', 'utf8mb4'),
+            'collation' => env('DB_COLLATION', 'utf8mb4_unicode_ci'),
+            'prefix' => '',
+            'prefix_indexes' => true,
+            'strict' => true,
+            'engine' => null,
+            'options' => extension_loaded('pdo_mysql') ? array_filter([
+                PDO::MYSQL_ATTR_SSL_CA => env('MYSQL_ATTR_SSL_CA'),
+            ]) : [],
+        ],
+
+        'mariadb' => [
+            'driver' => 'mariadb',
+            'url' => env('DB_URL'),
+            'host' => env('DB_HOST', '127.0.0.1'),
+            'port' => env('DB_PORT', '3306'),
+            'database' => env('DB_DATABASE', 'laravel'),
+            'username' => env('DB_USERNAME', 'root'),
+            'password' => env('DB_PASSWORD', ''),
+            'unix_socket' => env('DB_SOCKET', ''),
+            'charset' => env('DB_CHARSET', 'utf8mb4'),
+            'collation' => env('DB_COLLATION', 'utf8mb4_unicode_ci'),
+            'prefix' => '',
+            'prefix_indexes' => true,
+            'strict' => true,
+            'engine' => null,
+            'options' => extension_loaded('pdo_mysql') ? array_filter([
+                PDO::MYSQL_ATTR_SSL_CA => env('MYSQL_ATTR_SSL_CA'),
+            ]) : [],
+        ],
+
+        'pgsql' => [
+            'driver' => 'pgsql',
+            'url' => env('DB_URL'),
+            'host' => env('DB_HOST', '127.0.0.1'),
+            'port' => env('DB_PORT', '5432'),
+            'database' => env('DB_DATABASE', 'laravel'),
+            'username' => env('DB_USERNAME', 'root'),
+            'password' => env('DB_PASSWORD', ''),
+            'charset' => env('DB_CHARSET', 'utf8'),
+            'prefix' => '',
+            'prefix_indexes' => true,
+            'search_path' => 'public',
+            'sslmode' => 'prefer',
+        ],
+
+        'sqlsrv' => [
+            'driver' => 'sqlsrv',
+            'url' => env('DB_URL'),
+            'host' => env('DB_HOST', 'localhost'),
+            'port' => env('DB_PORT', '1433'),
+            'database' => env('DB_DATABASE', 'laravel'),
+            'username' => env('DB_USERNAME', 'root'),
+            'password' => env('DB_PASSWORD', ''),
+            'charset' => env('DB_CHARSET', 'utf8'),
+            'prefix' => '',
+            'prefix_indexes' => true,
+            // 'encrypt' => env('DB_ENCRYPT', 'yes'),
+            // 'trust_server_certificate' => env('DB_TRUST_SERVER_CERTIFICATE', 'false'),
+        ],
+
+    ],
+
+    /*
+    |--------------------------------------------------------------------------
+    | Migration Repository Table
+    |--------------------------------------------------------------------------
+    |
+    | This table keeps track of all the migrations that have already run for
+    | your application. Using this information, we can determine which of
+    | the migrations on disk haven't actually been run on the database.
+    |
+    */
+
+    'migrations' => [
+        'table' => 'migrations',
+        'update_date_on_publish' => true,
+    ],
+
+    /*
+    |--------------------------------------------------------------------------
+    | Redis Databases
+    |--------------------------------------------------------------------------
+    |
+    | Redis is an open source, fast, and advanced key-value store that also
+    | provides a richer body of commands than a typical key-value system
+    | such as Memcached. You may define your connection settings here.
+    |
+    */
+
+    'redis' => [
+
+        'client' => env('REDIS_CLIENT', 'phpredis'),
+
+        'options' => [
+            'cluster' => env('REDIS_CLUSTER', 'redis'),
+            'prefix' => env('REDIS_PREFIX', Str::slug(env('APP_NAME', 'laravel'), '_').'_database_'),
+        ],
+
+        'default' => [
+            'url' => env('REDIS_URL'),
+            'host' => env('REDIS_HOST', '127.0.0.1'),
+            'username' => env('REDIS_USERNAME'),
+            'password' => env('REDIS_PASSWORD'),
+            'port' => env('REDIS_PORT', '6379'),
+            'database' => env('REDIS_DB', '0'),
+        ],
+
+        'cache' => [
+            'url' => env('REDIS_URL'),
+            'host' => env('REDIS_HOST', '127.0.0.1'),
+            'username' => env('REDIS_USERNAME'),
+            'password' => env('REDIS_PASSWORD'),
+            'port' => env('REDIS_PORT', '6379'),
+            'database' => env('REDIS_CACHE_DB', '1'),
+        ],
+
+    ],
+
+];

config/filesystems.php

@@ -0,0 +1,77 @@
+<?php
+
+return [
+
+    /*
+    |--------------------------------------------------------------------------
+    | Default Filesystem Disk
+    |--------------------------------------------------------------------------
+    |
+    | Here you may specify the default filesystem disk that should be used
+    | by the framework. The "local" disk, as well as a variety of cloud
+    | based disks are available to your application for file storage.
+    |
+    */
+
+    'default' => env('FILESYSTEM_DISK', 'local'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Filesystem Disks
+    |--------------------------------------------------------------------------
+    |
+    | Below you may configure as many filesystem disks as necessary, and you
+    | may even configure multiple disks for the same driver. Examples for
+    | most supported storage drivers are configured here for reference.
+    |
+    | Supported drivers: "local", "ftp", "sftp", "s3"
+    |
+    */
+
+    'disks' => [
+
+        'local' => [
+            'driver' => 'local',
+            'root' => storage_path('app/private'),
+            'serve' => true,
+            'throw' => false,
+        ],
+
+        'public' => [
+            'driver' => 'local',
+            'root' => storage_path('app/public'),
+            'url' => env('APP_URL').'/storage',
+            'visibility' => 'public',
+            'throw' => false,
+        ],
+
+        's3' => [
+            'driver' => 's3',
+            'key' => env('AWS_ACCESS_KEY_ID'),
+            'secret' => env('AWS_SECRET_ACCESS_KEY'),
+            'region' => env('AWS_DEFAULT_REGION'),
+            'bucket' => env('AWS_BUCKET'),
+            'url' => env('AWS_URL'),
+            'endpoint' => env('AWS_ENDPOINT'),
+            'use_path_style_endpoint' => env('AWS_USE_PATH_STYLE_ENDPOINT', false),
+            'throw' => false,
+        ],
+
+    ],
+
+    /*
+    |--------------------------------------------------------------------------
+    | Symbolic Links
+    |--------------------------------------------------------------------------
+    |
+    | Here you may configure the symbolic links that will be created when the
+    | `storage:link` Artisan command is executed. The array keys should be
+    | the locations of the links and the values should be their targets.
+    |
+    */
+
+    'links' => [
+        public_path('storage') => storage_path('app/public'),
+    ],
+
+];

config/l5-swagger.php

@@ -0,0 +1,299 @@
+<?php
+return [
+    'default' => 'default',
+    'documentations' => [
+        'default' => [
+            'api' => [
+                'title' => 'L5 Swagger UI',
+            ],
+
+            'routes' => [
+                /*
+                 * Route for accessing api documentation interface
+                */
+                'api' => 'api/documentation',
+            ],
+            'paths' => [
+                /*
+                 * Edit to include full URL in ui for assets
+                */
+                'use_absolute_path' => env('L5_SWAGGER_USE_ABSOLUTE_PATH', true),
+
+                /*
+                 * File name of the generated json documentation file
+                */
+                'docs_json' => 'api-docs.json',
+
+                /*
+                 * File name of the generated YAML documentation file
+                */
+                'docs_yaml' => 'api-docs.yaml',
+
+                /*
+                * Set this to `json` or `yaml` to determine which documentation file to use in UI
+                */
+                'format_to_use_for_docs' => env('L5_FORMAT_TO_USE_FOR_DOCS', 'json'),
+
+                /*
+                 * Absolute paths to directory containing the swagger annotations are stored.
+                */
+                'annotations' => [
+                    base_path('app'),
+                ],
+
+            ],
+        ],
+    ],
+    'defaults' => [
+        'routes' => [
+            /*
+             * Route for accessing parsed swagger annotations.
+            */
+            'docs' => 'docs',
+
+            /*
+             * Route for Oauth2 authentication callback.
+            */
+            'oauth2_callback' => 'api/oauth2-callback',
+
+            /*
+             * Middleware allows to prevent unexpected access to API documentation
+            */
+            'middleware' => [
+                'api' => [],
+                'asset' => [],
+                'docs' => [],
+                'oauth2_callback' => [],
+            ],
+
+            /*
+             * Route Group options
+            */
+            'group_options' => [],
+        ],
+
+        'paths' => [
+            /*
+             * Absolute path to location where parsed annotations will be stored
+            */
+            'docs' => storage_path('api-docs'),
+
+            /*
+             * Absolute path to directory where to export views
+            */
+            'views' => base_path('resources/views/vendor/l5-swagger'),
+
+            /*
+             * Edit to set the api's base path
+            */
+            'base' => env('L5_SWAGGER_BASE_PATH', null),
+
+            /*
+             * Edit to set path where swagger ui assets should be stored
+            */
+            'swagger_ui_assets_path' => env('L5_SWAGGER_UI_ASSETS_PATH', 'vendor/swagger-api/swagger-ui/dist/'),
+
+            /*
+             * Absolute path to directories that should be excluded from scanning
+             * @deprecated Please use `scanOptions.exclude`
+             * `scanOptions.exclude` overwrites this
+            */
+            'excludes' => [],
+        ],
+
+        'scanOptions' => [
+            /**
+             * analyser: defaults to \OpenApi\StaticAnalyser .
+             *
+             * @see \OpenApi\scan
+             */
+            'analyser' => null,
+
+            /**
+             * analysis: defaults to a new \OpenApi\Analysis .
+             *
+             * @see \OpenApi\scan
+             */
+            'analysis' => null,
+
+            /**
+             * Custom query path processors classes.
+             *
+             * @link https://github.com/zircote/swagger-php/tree/master/Examples/processors/schema-query-parameter
+             * @see \OpenApi\scan
+             */
+            'processors' => [
+                // new \App\SwaggerProcessors\SchemaQueryParameter(),
+            ],
+
+            /**
+             * pattern: string       $pattern File pattern(s) to scan (default: *.php) .
+             *
+             * @see \OpenApi\scan
+             */
+            'pattern' => null,
+
+            /*
+             * Absolute path to directories that should be excluded from scanning
+             * @note This option overwrites `paths.excludes`
+             * @see \OpenApi\scan
+            */
+            'exclude' => [],
+
+            /*
+             * Allows to generate specs either for OpenAPI 3.0.0 or OpenAPI 3.1.0.
+             * By default the spec will be in version 3.0.0
+             */
+            'open_api_spec_version' => env('L5_SWAGGER_OPEN_API_SPEC_VERSION', \L5Swagger\Generator::OPEN_API_DEFAULT_SPEC_VERSION),
+        ],
+
+        /*
+         * API security definitions. Will be generated into documentation file.
+        */
+        'securityDefinitions' => [
+            'securitySchemes' => [
+                /*
+                 * Examples of Security schemes
+                */
+                /*
+                'api_key_security_example' => [ // Unique name of security
+                    'type' => 'apiKey', // The type of the security scheme. Valid values are "basic", "apiKey" or "oauth2".
+                    'description' => 'A short description for security scheme',
+                    'name' => 'api_key', // The name of the header or query parameter to be used.
+                    'in' => 'header', // The location of the API key. Valid values are "query" or "header".
+                ],
+                'oauth2_security_example' => [ // Unique name of security
+                    'type' => 'oauth2', // The type of the security scheme. Valid values are "basic", "apiKey" or "oauth2".
+                    'description' => 'A short description for oauth2 security scheme.',
+                    'flow' => 'implicit', // The flow used by the OAuth2 security scheme. Valid values are "implicit", "password", "application" or "accessCode".
+                    'authorizationUrl' => 'http://example.com/auth', // The authorization URL to be used for (implicit/accessCode)
+                    //'tokenUrl' => 'http://example.com/auth' // The authorization URL to be used for (password/application/accessCode)
+                    'scopes' => [
+                        'read:projects' => 'read your projects',
+                        'write:projects' => 'modify projects in your account',
+                    ]
+                ],
+                */
+
+                /* Open API 3.0 support
+                'passport' => [ // Unique name of security
+                    'type' => 'oauth2', // The type of the security scheme. Valid values are "basic", "apiKey" or "oauth2".
+                    'description' => 'Laravel passport oauth2 security.',
+                    'in' => 'header',
+                    'scheme' => 'https',
+                    'flows' => [
+                        "password" => [
+                            "authorizationUrl" => config('app.url') . '/oauth/authorize',
+                            "tokenUrl" => config('app.url') . '/oauth/token',
+                            "refreshUrl" => config('app.url') . '/token/refresh',
+                            "scopes" => []
+                        ],
+                    ],
+                ],
+                'sanctum' => [ // Unique name of security
+                    'type' => 'apiKey', // Valid values are "basic", "apiKey" or "oauth2".
+                    'description' => 'Enter token in format (Bearer <token>)',
+                    'name' => 'Authorization', // The name of the header or query parameter to be used.
+                    'in' => 'header', // The location of the API key. Valid values are "query" or "header".
+                ],
+                */
+            ],
+            'security' => [
+                /*
+                 * Examples of Securities
+                */
+                [
+                    /*
+                    'oauth2_security_example' => [
+                        'read',
+                        'write'
+                    ],
+
+                    'passport' => []
+                    */
+                ],
+            ],
+        ],
+
+        /*
+         * Set this to `true` in development mode so that docs would be regenerated on each request
+         * Set this to `false` to disable swagger generation on production
+        */
+        'generate_always' => env('L5_SWAGGER_GENERATE_ALWAYS', false),
+
+        /*
+         * Set this to `true` to generate a copy of documentation in yaml format
+        */
+        'generate_yaml_copy' => env('L5_SWAGGER_GENERATE_YAML_COPY', false),
+
+        /*
+         * Edit to trust the proxy's ip address - needed for AWS Load Balancer
+         * string[]
+        */
+        'proxy' => false,
+
+        /*
+         * Configs plugin allows to fetch external configs instead of passing them to SwaggerUIBundle.
+         * See more at: https://github.com/swagger-api/swagger-ui#configs-plugin
+        */
+        'additional_config_url' => null,
+
+        /*
+         * Apply a sort to the operation list of each API. It can be 'alpha' (sort by paths alphanumerically),
+         * 'method' (sort by HTTP method).
+         * Default is the order returned by the server unchanged.
+        */
+        'operations_sort' => env('L5_SWAGGER_OPERATIONS_SORT', null),
+
+        /*
+         * Pass the validatorUrl parameter to SwaggerUi init on the JS side.
+         * A null value here disables validation.
+        */
+        'validator_url' => null,
+
+        /*
+         * Swagger UI configuration parameters
+        */
+        'ui' => [
+            'display' => [
+                /*
+                 * Controls the default expansion setting for the operations and tags. It can be :
+                 * 'list' (expands only the tags),
+                 * 'full' (expands the tags and operations),
+                 * 'none' (expands nothing).
+                 */
+                'doc_expansion' => env('L5_SWAGGER_UI_DOC_EXPANSION', 'none'),
+
+                /**
+                 * If set, enables filtering. The top bar will show an edit box that
+                 * you can use to filter the tagged operations that are shown. Can be
+                 * Boolean to enable or disable, or a string, in which case filtering
+                 * will be enabled using that string as the filter expression. Filtering
+                 * is case-sensitive matching the filter expression anywhere inside
+                 * the tag.
+                 */
+                'filter' => env('L5_SWAGGER_UI_FILTERS', true), // true | false
+            ],
+
+            'authorization' => [
+                /*
+                 * If set to true, it persists authorization data, and it would not be lost on browser close/refresh
+                 */
+                'persist_authorization' => env('L5_SWAGGER_UI_PERSIST_AUTHORIZATION', false),
+
+                'oauth2' => [
+                    /*
+                    * If set to true, adds PKCE to AuthorizationCodeGrant flow
+                    */
+                    'use_pkce_with_authorization_code_grant' => false,
+                ],
+            ],
+        ],
+        /*
+         * Constants which can be used in annotations
+         */
+        'constants' => [
+            'L5_SWAGGER_CONST_HOST' => env('L5_SWAGGER_CONST_HOST', 'http://my-default-host.com'),
+        ],
+    ],
+];

config/logging.php

@@ -0,0 +1,132 @@
+<?php
+
+use Monolog\Handler\NullHandler;
+use Monolog\Handler\StreamHandler;
+use Monolog\Handler\SyslogUdpHandler;
+use Monolog\Processor\PsrLogMessageProcessor;
+
+return [
+
+    /*
+    |--------------------------------------------------------------------------
+    | Default Log Channel
+    |--------------------------------------------------------------------------
+    |
+    | This option defines the default log channel that is utilized to write
+    | messages to your logs. The value provided here should match one of
+    | the channels present in the list of "channels" configured below.
+    |
+    */
+
+    'default' => env('LOG_CHANNEL', 'stderr'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Deprecations Log Channel
+    |--------------------------------------------------------------------------
+    |
+    | This option controls the log channel that should be used to log warnings
+    | regarding deprecated PHP and library features. This allows you to get
+    | your application ready for upcoming major versions of dependencies.
+    |
+    */
+
+    'deprecations' => [
+        'channel' => env('LOG_DEPRECATIONS_CHANNEL', 'null'),
+        'trace' => env('LOG_DEPRECATIONS_TRACE', false),
+    ],
+
+    /*
+    |--------------------------------------------------------------------------
+    | Log Channels
+    |--------------------------------------------------------------------------
+    |
+    | Here you may configure the log channels for your application. Laravel
+    | utilizes the Monolog PHP logging library, which includes a variety
+    | of powerful log handlers and formatters that you're free to use.
+    |
+    | Available drivers: "single", "daily", "slack", "syslog",
+    |                    "errorlog", "monolog", "custom", "stack"
+    |
+    */
+
+    'channels' => [
+
+        'stack' => [
+            'driver' => 'stack',
+            'channels' => explode(',', env('LOG_STACK', 'single')),
+            'ignore_exceptions' => false,
+        ],
+
+        'single' => [
+            'driver' => 'single',
+            'path' => storage_path('logs/laravel.log'),
+            'level' => env('LOG_LEVEL', 'debug'),
+            'replace_placeholders' => true,
+        ],
+
+        'daily' => [
+            'driver' => 'daily',
+            'path' => storage_path('logs/laravel.log'),
+            'level' => env('LOG_LEVEL', 'debug'),
+            'days' => env('LOG_DAILY_DAYS', 14),
+            'replace_placeholders' => true,
+        ],
+
+        'slack' => [
+            'driver' => 'slack',
+            'url' => env('LOG_SLACK_WEBHOOK_URL'),
+            'username' => env('LOG_SLACK_USERNAME', 'Laravel Log'),
+            'emoji' => env('LOG_SLACK_EMOJI', ':boom:'),
+            'level' => env('LOG_LEVEL', 'critical'),
+            'replace_placeholders' => true,
+        ],
+
+        'papertrail' => [
+            'driver' => 'monolog',
+            'level' => env('LOG_LEVEL', 'debug'),
+            'handler' => env('LOG_PAPERTRAIL_HANDLER', SyslogUdpHandler::class),
+            'handler_with' => [
+                'host' => env('PAPERTRAIL_URL'),
+                'port' => env('PAPERTRAIL_PORT'),
+                'connectionString' => 'tls://'.env('PAPERTRAIL_URL').':'.env('PAPERTRAIL_PORT'),
+            ],
+            'processors' => [PsrLogMessageProcessor::class],
+        ],
+
+        'stderr' => [
+            'driver' => 'monolog',
+            'level' => env('LOG_LEVEL', 'debug'),
+            'handler' => StreamHandler::class,
+            'formatter' => env('LOG_STDERR_FORMATTER'),
+            'with' => [
+                'stream' => 'php://stderr',
+            ],
+            'processors' => [PsrLogMessageProcessor::class],
+        ],
+
+        'syslog' => [
+            'driver' => 'syslog',
+            'level' => env('LOG_LEVEL', 'debug'),
+            'facility' => env('LOG_SYSLOG_FACILITY', LOG_USER),
+            'replace_placeholders' => true,
+        ],
+
+        'errorlog' => [
+            'driver' => 'errorlog',
+            'level' => env('LOG_LEVEL', 'debug'),
+            'replace_placeholders' => true,
+        ],
+
+        'null' => [
+            'driver' => 'monolog',
+            'handler' => NullHandler::class,
+        ],
+
+        'emergency' => [
+            'path' => storage_path('logs/laravel.log'),
+        ],
+
+    ],
+
+];

config/mail.php

@@ -0,0 +1,116 @@
+<?php
+
+return [
+
+    /*
+    |--------------------------------------------------------------------------
+    | Default Mailer
+    |--------------------------------------------------------------------------
+    |
+    | This option controls the default mailer that is used to send all email
+    | messages unless another mailer is explicitly specified when sending
+    | the message. All additional mailers can be configured within the
+    | "mailers" array. Examples of each type of mailer are provided.
+    |
+    */
+
+    'default' => env('MAIL_MAILER', 'log'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Mailer Configurations
+    |--------------------------------------------------------------------------
+    |
+    | Here you may configure all of the mailers used by your application plus
+    | their respective settings. Several examples have been configured for
+    | you and you are free to add your own as your application requires.
+    |
+    | Laravel supports a variety of mail "transport" drivers that can be used
+    | when delivering an email. You may specify which one you're using for
+    | your mailers below. You may also add additional mailers if needed.
+    |
+    | Supported: "smtp", "sendmail", "mailgun", "ses", "ses-v2",
+    |            "postmark", "resend", "log", "array",
+    |            "failover", "roundrobin"
+    |
+    */
+
+    'mailers' => [
+
+        'smtp' => [
+            'transport' => 'smtp',
+            'scheme' => env('MAIL_SCHEME'),
+            'url' => env('MAIL_URL'),
+            'host' => env('MAIL_HOST', '127.0.0.1'),
+            'port' => env('MAIL_PORT', 2525),
+            'username' => env('MAIL_USERNAME'),
+            'password' => env('MAIL_PASSWORD'),
+            'timeout' => null,
+            'local_domain' => env('MAIL_EHLO_DOMAIN', parse_url(env('APP_URL', 'http://localhost'), PHP_URL_HOST)),
+        ],
+
+        'ses' => [
+            'transport' => 'ses',
+        ],
+
+        'postmark' => [
+            'transport' => 'postmark',
+            // 'message_stream_id' => env('POSTMARK_MESSAGE_STREAM_ID'),
+            // 'client' => [
+            //     'timeout' => 5,
+            // ],
+        ],
+
+        'resend' => [
+            'transport' => 'resend',
+        ],
+
+        'sendmail' => [
+            'transport' => 'sendmail',
+            'path' => env('MAIL_SENDMAIL_PATH', '/usr/sbin/sendmail -bs -i'),
+        ],
+
+        'log' => [
+            'transport' => 'log',
+            'channel' => env('MAIL_LOG_CHANNEL'),
+        ],
+
+        'array' => [
+            'transport' => 'array',
+        ],
+
+        'failover' => [
+            'transport' => 'failover',
+            'mailers' => [
+                'smtp',
+                'log',
+            ],
+        ],
+
+        'roundrobin' => [
+            'transport' => 'roundrobin',
+            'mailers' => [
+                'ses',
+                'postmark',
+            ],
+        ],
+
+    ],
+
+    /*
+    |--------------------------------------------------------------------------
+    | Global "From" Address
+    |--------------------------------------------------------------------------
+    |
+    | You may wish for all emails sent by your application to be sent from
+    | the same address. Here you may specify a name and address that is
+    | used globally for all emails that are sent by your application.
+    |
+    */
+
+    'from' => [
+        'address' => env('MAIL_FROM_ADDRESS', 'hello@example.com'),
+        'name' => env('MAIL_FROM_NAME', 'Example'),
+    ],
+
+];

config/queue.php

@@ -0,0 +1,112 @@
+<?php
+
+return [
+
+    /*
+    |--------------------------------------------------------------------------
+    | Default Queue Connection Name
+    |--------------------------------------------------------------------------
+    |
+    | Laravel's queue supports a variety of backends via a single, unified
+    | API, giving you convenient access to each backend using identical
+    | syntax for each. The default queue connection is defined below.
+    |
+    */
+
+    'default' => env('QUEUE_CONNECTION', 'database'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Queue Connections
+    |--------------------------------------------------------------------------
+    |
+    | Here you may configure the connection options for every queue backend
+    | used by your application. An example configuration is provided for
+    | each backend supported by Laravel. You're also free to add more.
+    |
+    | Drivers: "sync", "database", "beanstalkd", "sqs", "redis", "null"
+    |
+    */
+
+    'connections' => [
+
+        'sync' => [
+            'driver' => 'sync',
+        ],
+
+        'database' => [
+            'driver' => 'database',
+            'connection' => env('DB_QUEUE_CONNECTION'),
+            'table' => env('DB_QUEUE_TABLE', 'jobs'),
+            'queue' => env('DB_QUEUE', 'default'),
+            'retry_after' => (int) env('DB_QUEUE_RETRY_AFTER', 90),
+            'after_commit' => false,
+        ],
+
+        'beanstalkd' => [
+            'driver' => 'beanstalkd',
+            'host' => env('BEANSTALKD_QUEUE_HOST', 'localhost'),
+            'queue' => env('BEANSTALKD_QUEUE', 'default'),
+            'retry_after' => (int) env('BEANSTALKD_QUEUE_RETRY_AFTER', 90),
+            'block_for' => 0,
+            'after_commit' => false,
+        ],
+
+        'sqs' => [
+            'driver' => 'sqs',
+            'key' => env('AWS_ACCESS_KEY_ID'),
+            'secret' => env('AWS_SECRET_ACCESS_KEY'),
+            'prefix' => env('SQS_PREFIX', 'https://sqs.us-east-1.amazonaws.com/your-account-id'),
+            'queue' => env('SQS_QUEUE', 'default'),
+            'suffix' => env('SQS_SUFFIX'),
+            'region' => env('AWS_DEFAULT_REGION', 'us-east-1'),
+            'after_commit' => false,
+        ],
+
+        'redis' => [
+            'driver' => 'redis',
+            'connection' => env('REDIS_QUEUE_CONNECTION', 'default'),
+            'queue' => env('REDIS_QUEUE', 'default'),
+            'retry_after' => (int) env('REDIS_QUEUE_RETRY_AFTER', 90),
+            'block_for' => null,
+            'after_commit' => false,
+        ],
+
+    ],
+
+    /*
+    |--------------------------------------------------------------------------
+    | Job Batching
+    |--------------------------------------------------------------------------
+    |
+    | The following options configure the database and table that store job
+    | batching information. These options can be updated to any database
+    | connection and table which has been defined by your application.
+    |
+    */
+
+    'batching' => [
+        'database' => env('DB_CONNECTION', 'sqlite'),
+        'table' => 'job_batches',
+    ],
+
+    /*
+    |--------------------------------------------------------------------------
+    | Failed Queue Jobs
+    |--------------------------------------------------------------------------
+    |
+    | These options configure the behavior of failed queue job logging so you
+    | can control how and where failed jobs are stored. Laravel ships with
+    | support for storing failed jobs in a simple file or in a database.
+    |
+    | Supported drivers: "database-uuids", "dynamodb", "file", "null"
+    |
+    */
+
+    'failed' => [
+        'driver' => env('QUEUE_FAILED_DRIVER', 'database-uuids'),
+        'database' => env('DB_CONNECTION', 'sqlite'),
+        'table' => 'failed_jobs',
+    ],
+
+];

config/services.php

@@ -0,0 +1,38 @@
+<?php
+
+return [
+
+    /*
+    |--------------------------------------------------------------------------
+    | Third Party Services
+    |--------------------------------------------------------------------------
+    |
+    | This file is for storing the credentials for third party services such
+    | as Mailgun, Postmark, AWS and more. This file provides the de facto
+    | location for this type of information, allowing packages to have
+    | a conventional file to locate the various service credentials.
+    |
+    */
+
+    'postmark' => [
+        'token' => env('POSTMARK_TOKEN'),
+    ],
+
+    'ses' => [
+        'key' => env('AWS_ACCESS_KEY_ID'),
+        'secret' => env('AWS_SECRET_ACCESS_KEY'),
+        'region' => env('AWS_DEFAULT_REGION', 'us-east-1'),
+    ],
+
+    'resend' => [
+        'key' => env('RESEND_KEY'),
+    ],
+
+    'slack' => [
+        'notifications' => [
+            'bot_user_oauth_token' => env('SLACK_BOT_USER_OAUTH_TOKEN'),
+            'channel' => env('SLACK_BOT_USER_DEFAULT_CHANNEL'),
+        ],
+    ],
+
+];

config/session.php

@@ -0,0 +1,217 @@
+<?php
+
+use Illuminate\Support\Str;
+
+return [
+
+    /*
+    |--------------------------------------------------------------------------
+    | Default Session Driver
+    |--------------------------------------------------------------------------
+    |
+    | This option determines the default session driver that is utilized for
+    | incoming requests. Laravel supports a variety of storage options to
+    | persist session data. Database storage is a great default choice.
+    |
+    | Supported: "file", "cookie", "database", "apc",
+    |            "memcached", "redis", "dynamodb", "array"
+    |
+    */
+
+    'driver' => env('SESSION_DRIVER', 'database'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Session Lifetime
+    |--------------------------------------------------------------------------
+    |
+    | Here you may specify the number of minutes that you wish the session
+    | to be allowed to remain idle before it expires. If you want them
+    | to expire immediately when the browser is closed then you may
+    | indicate that via the expire_on_close configuration option.
+    |
+    */
+
+    'lifetime' => env('SESSION_LIFETIME', 120),
+
+    'expire_on_close' => env('SESSION_EXPIRE_ON_CLOSE', false),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Session Encryption
+    |--------------------------------------------------------------------------
+    |
+    | This option allows you to easily specify that all of your session data
+    | should be encrypted before it's stored. All encryption is performed
+    | automatically by Laravel and you may use the session like normal.
+    |
+    */
+
+    'encrypt' => env('SESSION_ENCRYPT', false),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Session File Location
+    |--------------------------------------------------------------------------
+    |
+    | When utilizing the "file" session driver, the session files are placed
+    | on disk. The default storage location is defined here; however, you
+    | are free to provide another location where they should be stored.
+    |
+    */
+
+    'files' => storage_path('framework/sessions'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Session Database Connection
+    |--------------------------------------------------------------------------
+    |
+    | When using the "database" or "redis" session drivers, you may specify a
+    | connection that should be used to manage these sessions. This should
+    | correspond to a connection in your database configuration options.
+    |
+    */
+
+    'connection' => env('SESSION_CONNECTION'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Session Database Table
+    |--------------------------------------------------------------------------
+    |
+    | When using the "database" session driver, you may specify the table to
+    | be used to store sessions. Of course, a sensible default is defined
+    | for you; however, you're welcome to change this to another table.
+    |
+    */
+
+    'table' => env('SESSION_TABLE', 'sessions'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Session Cache Store
+    |--------------------------------------------------------------------------
+    |
+    | When using one of the framework's cache driven session backends, you may
+    | define the cache store which should be used to store the session data
+    | between requests. This must match one of your defined cache stores.
+    |
+    | Affects: "apc", "dynamodb", "memcached", "redis"
+    |
+    */
+
+    'store' => env('SESSION_STORE'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Session Sweeping Lottery
+    |--------------------------------------------------------------------------
+    |
+    | Some session drivers must manually sweep their storage location to get
+    | rid of old sessions from storage. Here are the chances that it will
+    | happen on a given request. By default, the odds are 2 out of 100.
+    |
+    */
+
+    'lottery' => [2, 100],
+
+    /*
+    |--------------------------------------------------------------------------
+    | Session Cookie Name
+    |--------------------------------------------------------------------------
+    |
+    | Here you may change the name of the session cookie that is created by
+    | the framework. Typically, you should not need to change this value
+    | since doing so does not grant a meaningful security improvement.
+    |
+    */
+
+    'cookie' => env(
+        'SESSION_COOKIE',
+        Str::slug(env('APP_NAME', 'laravel'), '_').'_session'
+    ),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Session Cookie Path
+    |--------------------------------------------------------------------------
+    |
+    | The session cookie path determines the path for which the cookie will
+    | be regarded as available. Typically, this will be the root path of
+    | your application, but you're free to change this when necessary.
+    |
+    */
+
+    'path' => env('SESSION_PATH', '/'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Session Cookie Domain
+    |--------------------------------------------------------------------------
+    |
+    | This value determines the domain and subdomains the session cookie is
+    | available to. By default, the cookie will be available to the root
+    | domain and all subdomains. Typically, this shouldn't be changed.
+    |
+    */
+
+    'domain' => env('SESSION_DOMAIN'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | HTTPS Only Cookies
+    |--------------------------------------------------------------------------
+    |
+    | By setting this option to true, session cookies will only be sent back
+    | to the server if the browser has a HTTPS connection. This will keep
+    | the cookie from being sent to you when it can't be done securely.
+    |
+    */
+
+    'secure' => env('SESSION_SECURE_COOKIE'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | HTTP Access Only
+    |--------------------------------------------------------------------------
+    |
+    | Setting this value to true will prevent JavaScript from accessing the
+    | value of the cookie and the cookie will only be accessible through
+    | the HTTP protocol. It's unlikely you should disable this option.
+    |
+    */
+
+    'http_only' => env('SESSION_HTTP_ONLY', true),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Same-Site Cookies
+    |--------------------------------------------------------------------------
+    |
+    | This option determines how your cookies behave when cross-site requests
+    | take place, and can be used to mitigate CSRF attacks. By default, we
+    | will set this value to "lax" to permit secure cross-site requests.
+    |
+    | See: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie#samesitesamesite-value
+    |
+    | Supported: "lax", "strict", "none", null
+    |
+    */
+
+    'same_site' => env('SESSION_SAME_SITE', 'lax'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Partitioned Cookies
+    |--------------------------------------------------------------------------
+    |
+    | Setting this value to true will tie the cookie to the top-level site for
+    | a cross-site context. Partitioned cookies are accepted by the browser
+    | when flagged "secure" and the Same-Site attribute is set to "none".
+    |
+    */
+
+    'partitioned' => env('SESSION_PARTITIONED_COOKIE', false),
+
+];

database/.gitignore

@@ -0,0 +1 @@
+*.sqlite*

database/factories/CategoryFactory.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace Database\Factories;
+
+use Illuminate\Database\Eloquent\Factories\Factory;
+
+/**
+ * @extends \Illuminate\Database\Eloquent\Factories\Factory<\App\Models\Category>
+ */
+class CategoryFactory extends Factory
+{
+    /**
+     * Define the model's default state.
+     *
+     * @return array<string, mixed>
+     */
+    public function definition(): array
+    {
+        return [
+            'name' => $this->faker->name(),
+        ];
+    }
+}

database/factories/CommentFactory.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace Database\Factories;
+
+use Illuminate\Database\Eloquent\Factories\Factory;
+
+/**
+ * @extends \Illuminate\Database\Eloquent\Factories\Factory<\App\Models\Comment>
+ */
+class CommentFactory extends Factory
+{
+    /**
+     * Define the model's default state.
+     *
+     * @return array<string, mixed>
+     */
+    public function definition(): array
+    {
+        return [
+            'content' => $this->faker->paragraphs(3, true),
+        ];
+    }
+}

database/factories/PostFactory.php

@@ -0,0 +1,36 @@
+<?php
+
+namespace Database\Factories;
+
+use App\Models\Category;
+use App\Models\Post;
+use Illuminate\Database\Eloquent\Factories\Factory;
+
+/**
+ * @extends \Illuminate\Database\Eloquent\Factories\Factory<\App\Models\Post>
+ */
+class PostFactory extends Factory
+{
+    /**
+     * The name of the factory's corresponding model.
+     *
+     * @var string
+     */
+    protected $model = Post::class;
+
+    /**
+     * Define the model's default state.
+     *
+     * @return array
+     */
+    public function definition()
+    {
+        return [
+            'title' => $this->faker->sentence,
+            'content' => $this->faker->paragraphs(3, true),
+            'category_id' => Category::inRandomOrder()->first()->id ?? null,
+            'created_at' => now(),
+            'updated_at' => now(),
+        ];
+    }
+}

database/factories/TagFactory.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace Database\Factories;
+
+use Illuminate\Database\Eloquent\Factories\Factory;
+
+/**
+ * @extends \Illuminate\Database\Eloquent\Factories\Factory<\App\Models\Tag>
+ */
+class TagFactory extends Factory
+{
+    /**
+     * Define the model's default state.
+     *
+     * @return array<string, mixed>
+     */
+    public function definition(): array
+    {
+        return [
+            'name' => $this->faker->word(),
+        ];
+    }
+}

database/factories/UserFactory.php

@@ -0,0 +1,44 @@
+<?php
+
+namespace Database\Factories;
+
+use Illuminate\Database\Eloquent\Factories\Factory;
+use Illuminate\Support\Facades\Hash;
+use Illuminate\Support\Str;
+
+/**
+ * @extends \Illuminate\Database\Eloquent\Factories\Factory<\App\Models\User>
+ */
+class UserFactory extends Factory
+{
+    /**
+     * The current password being used by the factory.
+     */
+    protected static ?string $password;
+
+    /**
+     * Define the model's default state.
+     *
+     * @return array<string, mixed>
+     */
+    public function definition(): array
+    {
+        return [
+            'name' => $this->faker->name(),
+            'email' => $this->faker->unique()->safeEmail(),
+            'email_verified_at' => now(),
+            'password' => static::$password ??= Hash::make('password'),
+            'remember_token' => Str::random(10),
+        ];
+    }
+
+    /**
+     * Indicate that the model's email address should be unverified.
+     */
+    public function unverified(): static
+    {
+        return $this->state(fn(array $attributes) => [
+            'email_verified_at' => null,
+        ]);
+    }
+}

database/migrations/0001_01_01_000000_create_users_table.php

@@ -0,0 +1,49 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::create('users', function (Blueprint $table) {
+            $table->id();
+            $table->string('name');
+            $table->string('email')->unique();
+            $table->timestamp('email_verified_at')->nullable();
+            $table->string('password');
+            $table->rememberToken();
+            $table->timestamps();
+        });
+
+        Schema::create('password_reset_tokens', function (Blueprint $table) {
+            $table->string('email')->primary();
+            $table->string('token');
+            $table->timestamp('created_at')->nullable();
+        });
+
+        Schema::create('sessions', function (Blueprint $table) {
+            $table->string('id')->primary();
+            $table->foreignId('user_id')->nullable()->index();
+            $table->string('ip_address', 45)->nullable();
+            $table->text('user_agent')->nullable();
+            $table->longText('payload');
+            $table->integer('last_activity')->index();
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('users');
+        Schema::dropIfExists('password_reset_tokens');
+        Schema::dropIfExists('sessions');
+    }
+};

database/migrations/0001_01_01_000001_create_cache_table.php

@@ -0,0 +1,35 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::create('cache', function (Blueprint $table) {
+            $table->string('key')->primary();
+            $table->mediumText('value');
+            $table->integer('expiration');
+        });
+
+        Schema::create('cache_locks', function (Blueprint $table) {
+            $table->string('key')->primary();
+            $table->string('owner');
+            $table->integer('expiration');
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('cache');
+        Schema::dropIfExists('cache_locks');
+    }
+};

database/migrations/0001_01_01_000002_create_jobs_table.php

@@ -0,0 +1,57 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::create('jobs', function (Blueprint $table) {
+            $table->id();
+            $table->string('queue')->index();
+            $table->longText('payload');
+            $table->unsignedTinyInteger('attempts');
+            $table->unsignedInteger('reserved_at')->nullable();
+            $table->unsignedInteger('available_at');
+            $table->unsignedInteger('created_at');
+        });
+
+        Schema::create('job_batches', function (Blueprint $table) {
+            $table->string('id')->primary();
+            $table->string('name');
+            $table->integer('total_jobs');
+            $table->integer('pending_jobs');
+            $table->integer('failed_jobs');
+            $table->longText('failed_job_ids');
+            $table->mediumText('options')->nullable();
+            $table->integer('cancelled_at')->nullable();
+            $table->integer('created_at');
+            $table->integer('finished_at')->nullable();
+        });
+
+        Schema::create('failed_jobs', function (Blueprint $table) {
+            $table->id();
+            $table->string('uuid')->unique();
+            $table->text('connection');
+            $table->text('queue');
+            $table->longText('payload');
+            $table->longText('exception');
+            $table->timestamp('failed_at')->useCurrent();
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('jobs');
+        Schema::dropIfExists('job_batches');
+        Schema::dropIfExists('failed_jobs');
+    }
+};

database/migrations/2025_01_18_124802_create_post_tag_table.php

@@ -0,0 +1,28 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::create('categories', function (Blueprint $table) {
+            $table->id();
+            $table->string('name');
+            $table->timestamps();
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('categories');
+    }
+};

database/migrations/2025_01_18_124804_create_comments_table.php

@@ -0,0 +1,30 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::create('comments', function (Blueprint $table) {
+            $table->id();
+            $table->text('content');
+            $table->unsignedBigInteger('commentable_id');
+            $table->string('commentable_type');
+            $table->timestamps();
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('comments');
+    }
+};

database/migrations/2025_01_18_124804_create_posts_table.php

@@ -0,0 +1,32 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration {
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::create('posts', function (Blueprint $table) {
+            $table->id();
+            $table->string('title');
+            $table->text('content');
+            $table->unsignedBigInteger('category_id')->nullable();
+
+            $table->timestamps();
+
+            $table->foreign('category_id')->references('id')->on('categories')->onDelete('restrict');
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('posts');
+    }
+};

database/migrations/2025_01_18_124804_create_tags_table.php

@@ -0,0 +1,28 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::create('tags', function (Blueprint $table) {
+            $table->id();
+            $table->string('name');
+            $table->timestamps();
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('tags');
+    }
+};

database/migrations/2025_01_18_124805_create_post_tag_table.php

@@ -0,0 +1,32 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::create('post_tag', function (Blueprint $table) {
+            $table->id();
+            $table->unsignedBigInteger('post_id');
+            $table->unsignedBigInteger('tag_id');
+            $table->timestamps();
+
+            $table->foreign('post_id')->references('id')->on('posts')->onDelete('cascade');
+            $table->foreign('tag_id')->references('id')->on('tags')->onDelete('cascade');
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('post_tag');
+    }
+};