refactor: :recycle: tirando a necessidade de um arquivo de collection e mudando Dto para DTO para melhor padrão

app/Commands/CreateCrud.php

@@ -18,152 +18,140 @@ public function __construct(Filesystem $files)
         $this->files = $files;
     }
 
-    public function handle()
+    public function handle(): void
     {
-        $name = $this->argument('name');
-        $this->createModel($name);
-        $this->createRepositoryInterface($name);
-        $this->createRepository($name);
-        $this->createService($name);
-        $this->createController($name);
-        $this->createDto($name);
-        $this->createRequest($name);
-        $this->createResource($name);
-        $this->createCollection($name);
-        $this->updateAppServiceProvider($name);
-        $this->info('CRUD operations created successfully!');
+        $name = $this->argument(key: 'name');
+        $this->createModel(name: $name);
+        $this->createRepositoryInterface(name: $name);
+        $this->createRepository(name: $name);
+        $this->createService(name: $name);
+        $this->createController(name: $name);
+        $this->createDTO(name: $name);
+        $this->createRequest(name: $name);
+        $this->createResource(name: $name);
+        $this->updateAppServiceProvider(name: $name);
+        $this->info(string: 'CRUD operations created successfully!');
     }
 
-    protected function createModel($name)
+    protected function createModel($name): void
     {
         $modelTemplate = str_replace(
-            ['{{modelName}}'],
-            [$name],
-            $this->getStub('Model')
+            search: ['{{modelName}}'],
+            replace: [$name],
+            subject: $this->getStub(type: 'Model')
         );
 
-        $this->put("app/Models/{$name}.php", $modelTemplate);
+        $this->put(path: "app/Models/{$name}.php", contents: $modelTemplate);
     }
 
-    protected function createRepositoryInterface($name)
+    protected function createRepositoryInterface($name): void
     {
         $interfaceTemplate = str_replace(
-            ['{{modelName}}'],
-            [$name],
-            $this->getStub('RepositoryInterface')
+            search: ['{{modelName}}'],
+            replace: [$name],
+            subject: $this->getStub(type: 'RepositoryInterface')
         );
 
-        $this->put("app/Repositories/{$name}RepositoryInterface.php", $interfaceTemplate);
+        $this->put(path: "app/Repositories/{$name}RepositoryInterface.php", contents: $interfaceTemplate);
     }
 
-    protected function createRepository($name)
+    protected function createRepository($name): void
     {
         $repositoryTemplate = str_replace(
-            ['{{modelName}}'],
-            [$name],
-            $this->getStub('Repository')
+            search: ['{{modelName}}'],
+            replace: [$name],
+            subject: $this->getStub(type: 'Repository')
         );
 
-        $this->put("app/Repositories/{$name}Repository.php", $repositoryTemplate);
+        $this->put(path: "app/Repositories/{$name}Repository.php", contents: $repositoryTemplate);
     }
 
-    protected function createService($name)
+    protected function createService($name): void
     {
         $serviceTemplate = str_replace(
-            ['{{modelName}}'],
-            [$name],
-            $this->getStub('Service')
+            search: ['{{modelName}}'],
+            replace: [$name],
+            subject: $this->getStub(type: 'Service')
         );
 
-        $this->put("app/Services/{$name}Service.php", $serviceTemplate);
+        $this->put(path: "app/Services/{$name}Service.php", contents: $serviceTemplate);
     }
 
-    protected function createController($name)
+    protected function createController($name): void
     {
         $controllerTemplate = str_replace(
-            ['{{modelName}}'],
-            [$name],
-            $this->getStub('Controller')
+            search: ['{{modelName}}'],
+            replace: [$name],
+            subject: $this->getStub(type: 'Controller')
         );
 
-        $this->put("app/Http/Controllers/{$name}Controller.php", $controllerTemplate);
+        $this->put(path: "app/Http/Controllers/{$name}Controller.php", contents: $controllerTemplate);
     }
 
-    protected function createDto($name)
+    protected function createDTO($name): void
     {
         $dtoTemplate = str_replace(
-            ['{{modelName}}'],
-            [$name],
-            $this->getStub('Dto')
+            search: ['{{modelName}}'],
+            replace: [$name],
+            subject: $this->getStub(type: 'DTO')
         );
 
-        $this->put("app/DataTransferObjects/{$name}Dto.php", $dtoTemplate);
+        $this->put(path: "app/DTO/{$name}DTO.php", contents: $dtoTemplate);
     }
 
-    protected function createRequest($name)
+    protected function createRequest($name): void
     {
         $requestTemplate = str_replace(
-            ['{{modelName}}'],
-            [$name],
-            $this->getStub('Request')
+            search: ['{{modelName}}'],
+            replace: [$name],
+            subject: $this->getStub(type: 'Request')
         );
 
-        $this->put("app/Http/Requests/{$name}Request.php", $requestTemplate);
+        $this->put(path: "app/Http/Requests/{$name}Request.php", contents: $requestTemplate);
     }
 
-    protected function createResource($name)
+    protected function createResource($name): void
     {
         $resourceTemplate = str_replace(
-            ['{{modelName}}'],
-            [$name],
-            $this->getStub('Resource')
+            search: ['{{modelName}}'],
+            replace: [$name],
+            subject: $this->getStub(type: 'Resource')
         );
 
-        $this->put("app/Http/Resources/{$name}Resource.php", $resourceTemplate);
+        $this->put(path: "app/Http/Resources/{$name}Resource.php", contents: $resourceTemplate);
     }
 
-    protected function createCollection($name)
+    protected function updateAppServiceProvider($name): void
     {
-        $collectionTemplate = str_replace(
-            ['{{modelName}}'],
-            [$name],
-            $this->getStub('Collection')
-        );
-
-        $this->put("app/Http/Resources/{$name}Collection.php", $collectionTemplate);
-    }
-
-    protected function updateAppServiceProvider($name)
-    {
-        $providerPath = app_path('Providers/AppServiceProvider.php');
-        $content = $this->files->get($providerPath);
+        $providerPath = app_path(path: 'Providers/AppServiceProvider.php');
+        $content = $this->files->get(path: $providerPath);
 
         // Add binding
         $binding = "        {$name}RepositoryInterface::class => {$name}Repository::class,";
         $content = preg_replace(
-            '/(public \$bindings = \[)/',
-            "$1\n$binding",
-            $content
+            pattern: '/(public \$bindings = \[)/',
+            replacement: "$1\n$binding",
+            subject: $content
         );
 
         // Add use statement
         $useStatement = "use App\Repositories\\{$name}RepositoryInterface;\nuse App\Repositories\\{$name}Repository;";
         $content = preg_replace(
-            '/(use Illuminate\\\Support\\\ServiceProvider;)/',
-            "$1\n\n{$useStatement}",
-            $content
+            pattern: '/(use Illuminate\\\Support\\\ServiceProvider;)/',
+            replacement: "$1\n\n{$useStatement}",
+            subject: $content
         );
 
-        $this->files->put($providerPath, $content);
+        $this->files->put(path: $providerPath, contents: $content);
     }
 
-    protected function getStub($type)
+    protected function getStub($type): string
     {
-        return $this->files->get(storage_path("stubs/{$type}.stub"));
+        return $this->files->get(path: storage_path(path: "stubs/{$type}.stub"));
     }
 
-    protected function put($path, $contents)
+    protected function put($path, $contents): void
     {
-        $this->files->put($path, $contents);
+        $this->files->put(path: $path, contents: $contents);
     }
 }

app/DataTransferObjects/AuthDto.php → app/DTO/AuthDTO.php

@@ -1,10 +1,10 @@
 <?php
 
-namespace App\DataTransferObjects;
+namespace App\DTO;
 
 use App\Http\Requests\AuthRequest;
 
-readonly class AuthDto
+readonly class AuthDTO
 {
     public function __construct(
         public string $email,
@@ -15,8 +15,8 @@ public function __construct(
     public static function fromRequest(AuthRequest $request): self
     {
         return new self(
-            email: $request->validated('email'),
-            password: $request->validated('password'),
+            email: $request->validated(key: 'email'),
+            password: $request->validated(key: 'password'),
         );
     }
 
@@ -27,4 +27,12 @@ public function toArray(): array
             'password' => $this->password,
         ];
     }
+
+    public static function fromArray(array $data): self
+    {
+        return new self(
+            email: $data['email'],
+            password: $data['password'],
+        );
+    }
 }

app/DataTransferObjects/PermissionDto.php → app/DTO/PermissionDTO.php

@@ -1,10 +1,10 @@
 <?php
 
-namespace App\DataTransferObjects;
+namespace App\DTO;
 
 use App\Http\Requests\PermissionRequest;
 
-readonly class PermissionDto
+readonly class PermissionDTO
 {
     public function __construct(
         public string $scope,
@@ -17,10 +17,10 @@ public function __construct(
     public static function fromRequest(PermissionRequest $request): self
     {
         return new self(
-            scope: $request->validated('scope'),
-            description: $request->validated('description'),
-            bits: $request->validated('bits'),
-            parent_id: $request->validated('parent_id'),
+            scope: $request->validated(key: 'scope'),
+            description: $request->validated(key: 'description'),
+            bits: $request->validated(key: 'bits'),
+            parent_id: $request->validated(key: 'parent_id'),
         );
     }
 
@@ -33,4 +33,14 @@ public static function fromArray(array $data): self
             parent_id: isset($data['parent_id']) ? $data['parent_id'] : null,
         );
     }
+
+    public function toArray(): array
+    {
+        return [
+            'scope' => $this->scope,
+            'description' => $this->description,
+            'bits' => $this->bits,
+            'parent_id' => $this->parent_id,
+        ];
+    }
 }

app/DTO/RefreshTokenDTO.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace App\DTO;
+
+use App\Http\Requests\RefreshTokenRequest;
+
+readonly class RefreshTokenDTO
+{
+    public function __construct(
+        public string $token,
+    ) {
+    }
+
+    public static function fromRequest(RefreshTokenRequest $request): self
+    {
+        return new self(
+            token: $request->validated(key: 'refresh_token'),
+        );
+    }
+
+    public static function fromArray(array $data): self
+    {
+        return new self(
+            token: $data['refresh_token'],
+        );
+    }
+
+    public function toArray(): array
+    {
+        return [
+            'refresh_token' => $this->token,
+        ];
+    }
+}

app/DTO/UserDTO.php

@@ -0,0 +1,46 @@
+<?php
+
+namespace App\DTO;
+
+use App\Http\Requests\UserRequest;
+
+readonly class UserDTO
+{
+    public function __construct(
+        public string $name,
+        public string $email,
+        public ?string $password,
+        public ?string $type,
+    ) {
+    }
+
+    public static function fromRequest(UserRequest $request): self
+    {
+        return new self(
+            name: $request->validated(key: 'name'),
+            email: $request->validated(key: 'email'),
+            password: $request->validated(key: 'password'),
+            type: $request->validated(key: 'type'),
+        );
+    }
+
+    public static function fromArray(array $data): self
+    {
+        return new self(
+            name: $data['name'],
+            email: $data['email'],
+            password: $data['password'],
+            type: $data['type'],
+        );
+    }
+
+    public function toArray(): array
+    {
+        return [
+            'name' => $this->name,
+            'email' => $this->email,
+            'password' => $this->password,
+            'type' => $this->type,
+        ];
+    }
+}

app/DTO/UserLanguageDTO.php

@@ -0,0 +1,51 @@
+<?php
+
+namespace App\DTO;
+
+use App\Http\Requests\UserLanguageRequest;
+use App\Enums\UserLanguageSource;
+
+readonly class UserLanguageDTO
+{
+    public function __construct(
+        public string $language,
+    ) {
+    }
+
+    public static function fromRequest(UserLanguageRequest $request): self
+    {
+        return new self(
+            language: $request->validated(key: 'language'),
+        );
+    }
+
+    public static function fromString(string $language): self
+    {
+        if (!UserLanguageSource::isValid(value: $language)) {
+            throw new \InvalidArgumentException(message: 'Invalid language');
+        }
+
+        return new self(
+            language: $language,
+        );
+    }
+
+    public static function fromArray(array $data): self
+    {
+        return new self(
+            language: $data['language'],
+        );
+    }
+
+    public function toArray(): array
+    {
+        return [
+            'language' => $this->language,
+        ];
+    }
+
+    public function toString(): string
+    {
+        return $this->language;
+    }
+}

app/DataTransferObjects/RefreshTokenDto.php

@@ -1,20 +0,0 @@
-<?php
-
-namespace App\DataTransferObjects;
-
-use App\Http\Requests\RefreshTokenRequest;
-
-readonly class RefreshTokenDto
-{
-    public function __construct(
-        public string $token,
-    ) {
-    }
-
-    public static function fromRequest(RefreshTokenRequest $request): self
-    {
-        return new self(
-            token: $request->validated('refresh_token'),
-        );
-    }
-}

app/DataTransferObjects/UserDto.php

@@ -1,26 +0,0 @@
-<?php
-
-namespace App\DataTransferObjects;
-
-use App\Http\Requests\UserRequest;
-
-readonly class UserDto
-{
-    public function __construct(
-        public string $name,
-        public string $email,
-        public ?string $password,
-        public ?string $type,
-    ) {
-    }
-
-    public static function fromRequest(UserRequest $request): self
-    {
-        return new self(
-            name: $request->validated('name'),
-            email: $request->validated('email'),
-            password: $request->validated('password'),
-            type: $request->validated('type'),
-        );
-    }
-}

app/DataTransferObjects/UserLanguageDto.php

@@ -1,32 +0,0 @@
-<?php
-
-namespace App\DataTransferObjects;
-
-use App\Http\Requests\UserLanguageRequest;
-use App\Enums\UserLanguageSource;
-
-readonly class UserLanguageDto
-{
-    public function __construct(
-        public string $language,
-    ) {
-    }
-
-    public static function fromRequest(UserLanguageRequest $request): self
-    {
-        return new self(
-            language: $request->validated('language'),
-        );
-    }
-
-    public static function fromString(string $language): self
-    {
-        if (!UserLanguageSource::isValid($language)) {
-            throw new \InvalidArgumentException('Invalid language');
-        }
-
-        return new self(
-            language: $language,
-        );
-    }
-}

app/Http/Controllers/AuthController.php

@@ -2,13 +2,13 @@
 
 namespace App\Http\Controllers;
 
-use App\DataTransferObjects\AuthDto;
+use App\DTO\AuthDTO;
 use App\Http\Requests\AuthRequest;
 use App\Http\Requests\RefreshTokenRequest;
 use Illuminate\Http\JsonResponse;
 use App\Http\Resources\AuthResource;
 use App\Services\AuthService;
-use App\DataTransferObjects\RefreshTokenDto;
+use App\DTO\RefreshTokenDTO;
 
 class AuthController extends Controller
 
@@ -19,27 +19,27 @@ public function __construct(
 
     public function login(AuthRequest $request): JsonResponse
     {
-        $tokens = $this->authService->login(AuthDto::fromRequest($request));
+        $tokens = $this->authService->login(credentials: AuthDTO::fromRequest(request: $request));
 
         if (!$tokens) {
-            return $this->errorResponse(message: __('auth.failed'), code: 401);
+            return $this->errorResponse(message: __(key: 'auth.failed'), code: 401);
         }
 
-        return $this->successResponse(payload: new AuthResource($tokens), message: __('auth.logged_in'));
+        return $this->successResponse(payload: new AuthResource(resource: $tokens), message: __(key: 'auth.logged_in'));
     }
 
     public function logout(): JsonResponse
     {
         $this->authService->logout();
-        return $this->successResponse(message: __('auth.logout'));
+        return $this->successResponse(message: __(key: 'auth.logout'));
     }
 
     public function refresh(RefreshTokenRequest $request): JsonResponse
     {
-        $tokens = $this->authService->refresh(RefreshTokenDto::fromRequest($request));
-        if (is_null($tokens)) {
-            return $this->errorResponse(message: __('auth.unauthorized'), code: 403);
+        $tokens = $this->authService->refresh(refreshToken: RefreshTokenDTO::fromRequest(request: $request));
+        if (is_null(value: $tokens)) {
+            return $this->errorResponse(message: __(key: 'auth.unauthorized'), code: 403);
         }
-        return $this->successResponse(payload: new AuthResource($tokens));
+        return $this->successResponse(payload: new AuthResource(resource: $tokens));
     }
 }

app/Http/Controllers/Controller.php

@@ -8,11 +8,11 @@ abstract class Controller
 {
     public function successResponse($payload = null, ?string $message = null, int $code = 200): JsonResponse
     {
-        return response()->json(['payload' => $payload, 'message' => $message], $code);
+        return response()->json(data: ['payload' => $payload, 'message' => $message], status: $code);
     }
 
     public function errorResponse(?string $message = null, int $code = 404): JsonResponse
     {
-        return response()->json(['message' => $message], $code);
+        return response()->json(data: ['message' => $message], status: $code);
     }
 }

app/Http/Controllers/PermissionController.php

@@ -2,9 +2,8 @@
 
 namespace App\Http\Controllers;
 
-use App\DataTransferObjects\PermissionDto;
+use App\DTO\PermissionDTO;
 use App\Http\Requests\PermissionRequest;
-use App\Http\Resources\PermissionCollection;
 use App\Http\Resources\PermissionResource;
 use App\Services\PermissionService;
 use Illuminate\Http\JsonResponse;
@@ -19,13 +18,13 @@ public function __construct(
     public function index(): JsonResponse
     {
         $permissions = $this->permissionService->all();
-        return $this->successResponse(payload: new PermissionCollection($permissions));
+        return $this->successResponse(payload: PermissionResource::collection($permissions));
     }
 
     public function allNoTree(): JsonResponse
     {
         $permissions = $this->permissionService->allNoTree();
-        return $this->successResponse(payload: new PermissionCollection($permissions));
+        return $this->successResponse(payload: PermissionResource::collection($permissions));
     }
 
     public function show(int $id): JsonResponse
@@ -36,13 +35,13 @@ public function show(int $id): JsonResponse
 
     public function store(PermissionRequest $request): JsonResponse
     {
-        $permission = $this->permissionService->store(PermissionDto::fromRequest($request));
+        $permission = $this->permissionService->store(PermissionDTO::fromRequest($request));
         return $this->successResponse(payload: new PermissionResource($permission), message: __('messages.created'), code: 201);
     }
 
     public function update(PermissionRequest $request, int $id): JsonResponse
     {
-        $permission = $this->permissionService->update(PermissionDto::fromRequest($request), $id);
+        $permission = $this->permissionService->update(PermissionDTO::fromRequest($request), $id);
         return $this->successResponse(payload: new PermissionResource($permission), message: __('messages.updated'));
     }
 

app/Http/Controllers/UserController.php

@@ -4,11 +4,10 @@
 
 use App\Http\Resources\UserResource;
 use App\Services\UserService;
-use App\DataTransferObjects\UserDto;
-use App\DataTransferObjects\UserLanguageDto;
+use App\DTO\UserDTO;
+use App\DTO\UserLanguageDTO;
 use App\Http\Requests\UserLanguageRequest;
 use App\Http\Requests\UserRequest;
-use App\Http\Resources\UserCollection;
 use Illuminate\Http\JsonResponse;
 
 class UserController extends Controller
@@ -28,18 +27,18 @@ public function me(): JsonResponse
     public function index(): JsonResponse
     {
         $users = $this->userService->all();
-        return $this->successResponse(payload: new UserCollection($users));
+        return $this->successResponse(payload: UserResource::collection($users));
     }
 
     public function store(UserRequest $request): JsonResponse
     {
-        $user = $this->userService->store(UserDto::fromRequest($request));
+        $user = $this->userService->store(UserDTO::fromRequest($request));
         return $this->successResponse(payload: new UserResource($user), message: __('messages.created'), code: 201);
     }
 
     public function update(UserRequest $request, int $id): JsonResponse
     {
-        $user = $this->userService->update(UserDto::fromRequest($request), $id);
+        $user = $this->userService->update(UserDTO::fromRequest($request), $id);
         return $this->successResponse(payload: new UserResource($user), message: __('messages.updated'));
     }
 
@@ -57,7 +56,7 @@ public function show(int $id): JsonResponse
 
     public function updateLanguage(UserLanguageRequest $request, int $id): JsonResponse
     {
-        $user = $this->userService->updateLanguage(UserLanguageDto::fromRequest($request), $id);
+        $user = $this->userService->updateLanguage(UserLanguageDTO::fromRequest($request), $id);
         return $this->successResponse(payload: new UserResource($user), message: __('messages.updated'));
     }
 }

app/Http/Controllers/UserTypePermissionController.php

@@ -3,6 +3,7 @@
 namespace App\Http\Controllers;
 
 use App\Http\Resources\UserTypePermissionCollection;
+use App\Http\Resources\UserTypePermissionResource;
 use App\Services\UserTypePermissionService;
 use Illuminate\Http\JsonResponse;
 use Illuminate\Support\Facades\Auth;
@@ -17,13 +18,13 @@ public function __construct(
     public function allGuestPermissions(): JsonResponse
     {
         $userTypePermission = $this->userTypePermissionService->allGuestPermissions();
-        return $this->successResponse(payload: new UserTypePermissionCollection($userTypePermission));
+        return $this->successResponse(payload: UserTypePermissionResource::collection($userTypePermission));
     }
 
     public function allPermissionsByUserType(): JsonResponse
     {
         $user = Auth::user();
         $userTypePermission = $this->userTypePermissionService->allPermissionsByUserType($user->type);
-        return $this->successResponse(payload: new UserTypePermissionCollection($userTypePermission));
+        return $this->successResponse(payload: UserTypePermissionResource::collection($userTypePermission));
     }
 }

app/Http/Middleware/CheckPermission.php

@@ -2,7 +2,7 @@
 
 namespace App\Http\Middleware;
 
-use App\Http\Resources\UserTypePermissionCollection;
+use App\Http\Resources\UserTypePermissionResource;
 use Closure;
 use Illuminate\Http\Request;
 use Illuminate\Support\Facades\Auth;
@@ -12,36 +12,44 @@ class CheckPermission
 {
     public function __construct(
         protected UserTypePermissionService $userTypePermissionService,
-    ) {
-    }
+    ) {}
 
     /**
      * Handle an incoming request.
      *
-     * @param  \Illuminate\Http\Request  $request
-     * @param  \Closure(\Illuminate\Http\Request): (\Symfony\Component\HttpFoundation\Response)  $next
-     * @param  string  $scope
-     * @param  string  $permissionType
+     * @param \Illuminate\Http\Request $request
+     * @param \Closure $next
+     * @param string $scopes A string of scopes separated by '|' to check a single permission against.
+     * @param string $permissionType The type of permission to check for each scope.
      * @return \Symfony\Component\HttpFoundation\Response
      */
-    public function handle(Request $request, Closure $next, string $scope, string $permissionType)
+    public function handle(Request $request, Closure $next, string $scopes, string $permissionType)
     {
         $user = Auth::user();
 
+        // Get permissions for the user or guest
         if (!$user) {
-            $userPermissions = new UserTypePermissionCollection($this->userTypePermissionService->allGuestPermissions());
+            $userPermissions = UserTypePermissionResource::collection(resource: $this->userTypePermissionService->allGuestPermissions());
         } else {
-            $userPermissions = new UserTypePermissionCollection($this->userTypePermissionService->allPermissionsByUserType($user->type));
+            $userPermissions = UserTypePermissionResource::collection(resource: $this->userTypePermissionService->allPermissionsByUserType(userType: $user->type));
         }
 
-        if (!$this->hasPermission($userPermissions, $scope, $permissionType)) {
-            return response()->json(['message' => 'Forbidden'], 403);
+        // Check the required permission for each scope
+        $hasPermission = false;
+        foreach (explode(separator: '|', string: $scopes) as $scope) {
+            if ($this->hasPermission(userPermissions: $userPermissions, scope: $scope, permissionType: $permissionType)) {
+                $hasPermission = true;
+                break;
+            }
+        }
+        if (!$hasPermission) {
+            return response()->json(data: ['message' => 'Unauthorized'], status: 403);
         }
 
         return $next($request);
     }
 
-    private function hasPermission(UserTypePermissionCollection $userPermissions, string $scope, string $permissionType): bool
+    private function hasPermission($userPermissions, string $scope, string $permissionType): bool
     {
         $bitwisePermissionTable = [
             'view' => 1,

app/Http/Middleware/SetUserLanguage.php

@@ -6,7 +6,7 @@
 use Illuminate\Http\Request;
 use Symfony\Component\HttpFoundation\Response;
 use Illuminate\Support\Facades\App;
-use App\DataTransferObjects\UserLanguageDto;
+use App\DTO\UserLanguageDTO;
 use App\Enums\UserLanguageSource;
 use Illuminate\Support\Facades\Log;
 
@@ -21,7 +21,7 @@ public function handle(Request $request, Closure $next): Response
     {
         $language = substr($request->header('Accept-Language'), 0, 2);
         try {
-            $language = UserLanguageDto::fromString($language)->language;
+            $language = UserLanguageDTO::fromString($language)->language;
             App::setLocale($language);
         } catch (\InvalidArgumentException $e) {
             Log::error("message: {$e->getMessage()}");

app/Http/Resources/AuthResource.php

@@ -2,6 +2,7 @@
 
 namespace App\Http\Resources;
 
+use Illuminate\Http\Resources\Json\AnonymousResourceCollection;
 use Illuminate\Http\Request;
 use Illuminate\Http\Resources\Json\JsonResource;
 
@@ -23,4 +24,9 @@ public function toArray(Request $request): array
             'user' => new UserResource($this['user']),
         ];
     }
+
+    public static function collection($resource): AnonymousResourceCollection
+    {
+        return parent::collection($resource);
+    }
 }

app/Http/Resources/PermissionCollection.php

@@ -1,21 +0,0 @@
-<?php
-
-namespace App\Http\Resources;
-
-use Illuminate\Http\Request;
-use Illuminate\Http\Resources\Json\ResourceCollection;
-
-class PermissionCollection extends ResourceCollection
-{
-    /**
-     * Transform the resource collection into an array.
-     *
-     * @return array<int|string, mixed>
-     */
-    public function toArray(Request $request): array
-    {
-        return $this->collection->transform(function ($permission) {
-            return new PermissionResource($permission);
-        })->toArray();
-    }
-}

app/Http/Resources/PermissionResource.php

@@ -4,6 +4,7 @@
 
 use Illuminate\Http\Request;
 use Illuminate\Http\Resources\Json\JsonResource;
+use Illuminate\Http\Resources\Json\AnonymousResourceCollection;
 
 class PermissionResource extends JsonResource
 {
@@ -24,4 +25,8 @@ public function toArray(Request $request): array
             'updated_at' => $this->updated_at,
         ];
     }
+    public static function collection($resource): AnonymousResourceCollection
+    {
+        return parent::collection($resource);
+    }
 }

app/Http/Resources/UserCollection.php

@@ -1,21 +0,0 @@
-<?php
-
-namespace App\Http\Resources;
-
-use Illuminate\Http\Request;
-use Illuminate\Http\Resources\Json\ResourceCollection;
-
-class UserCollection extends ResourceCollection
-{
-    /**
-     * Transform the resource collection into an array.
-     *
-     * @return array<int|string, mixed>
-     */
-    public function toArray(Request $request): array
-    {
-        return $this->collection->transform(function ($user) {
-            return new UserResource($user);
-        })->toArray();
-    }
-}

app/Http/Resources/UserResource.php

@@ -4,6 +4,7 @@
 
 use Illuminate\Http\Request;
 use Illuminate\Http\Resources\Json\JsonResource;
+use Illuminate\Http\Resources\Json\AnonymousResourceCollection;
 
 class UserResource extends JsonResource
 {
@@ -23,4 +24,9 @@ public function toArray(Request $request): array
             'updated_at' => $this->updated_at,
         ];
     }
+
+    public static function collection($resource): AnonymousResourceCollection
+    {
+        return parent::collection($resource);
+    }
 }

app/Http/Resources/UserTypePermissionCollection.php

@@ -1,21 +0,0 @@
-<?php
-
-namespace App\Http\Resources;
-
-use Illuminate\Http\Request;
-use Illuminate\Http\Resources\Json\ResourceCollection;
-
-class UserTypePermissionCollection extends ResourceCollection
-{
-    /**
-     * Transform the resource collection into an array.
-     *
-     * @return array<int|string, mixed>
-     */
-    public function toArray(Request $request): array
-    {
-        return $this->collection->transform(function ($user_type_permission) {
-            return new UserTypePermissionResource($user_type_permission);
-        })->toArray();
-    }
-}

app/Http/Resources/UserTypePermissionResource.php

@@ -2,6 +2,7 @@
 
 namespace App\Http\Resources;
 
+use Illuminate\Http\Resources\Json\AnonymousResourceCollection;
 use Illuminate\Http\Request;
 use Illuminate\Http\Resources\Json\JsonResource;
 
@@ -25,4 +26,9 @@ public function toArray(Request $request): array
             'updated_at' => $this->updated_at,
         ];
     }
+
+    public static function collection($resource): AnonymousResourceCollection
+    {
+        return parent::collection($resource);
+    }
 }

app/Repositories/AuthRepository.php

@@ -4,8 +4,9 @@
 
 use App\Models\User;
 use App\Models\PersonalAccessToken;
-use App\DataTransferObjects\AuthDto;
+use App\DTO\AuthDTO;
 use Carbon\Carbon;
+use Illuminate\Contracts\Auth\Authenticatable;
 use Illuminate\Support\Facades\Auth;
 use Illuminate\Support\Facades\DB;
 
@@ -18,56 +19,56 @@ public function __construct(
 
     public function findUserByEmail(string $email): ?User
     {
-        return $this->userModel->where('email', $email)->first();
+        return $this->userModel->where(column: 'email', operator: $email)->first();
     }
 
     public function findToken(string $token): ?PersonalAccessToken
     {
-        return $this->personalAccessTokenModel->findToken($token);
+        return $this->personalAccessTokenModel->findToken(token: $token);
     }
 
     public function createAccessToken(User $user, string $deviceId): string
     {
         return $user->createToken(
-            "access_token_{$deviceId}",
-            ['access'],
-            Carbon::now()->addMinutes(15)
+            name: "access_token_{$deviceId}",
+            abilities: ['access'],
+            expiresAt: Carbon::now()->addMinutes(value: 15)
         )->plainTextToken;
     }
 
     public function createRefreshToken(User $user, string $deviceId): string
     {
         return $user->createToken(
-            "refresh_token_{$deviceId}",
-            ['refresh'],
-            Carbon::now()->addDays(30)
+            name: "refresh_token_{$deviceId}",
+            abilities: ['refresh'],
+            expiresAt: Carbon::now()->addDays(value: 30)
         )->plainTextToken;
     }
 
     public function updateTokenExpiration(PersonalAccessToken $token, \DateTime $expirationTime): void
     {
-        $token->update(['expires_at' => $expirationTime]);
+        $token->update(attributes: ['expires_at' => $expirationTime]);
     }
 
-    public function deleteUserTokensByDevice(User $user, string $deviceId): void
+    public function deleteUserTokensByDevice(User|Authenticatable $user, string $deviceId): void
     {
         $user->tokens()
-            ->where('name', 'like', "%_{$deviceId}")
+            ->where(column: 'name', operator: 'like', value: "%_{$deviceId}")
             ->delete();
     }
 
-    public function attemptLogin(AuthDto $credentials): bool
+    public function attemptLogin(AuthDTO $credentials): bool
     {
-        return Auth::attempt($credentials->toArray());
+        return Auth::attempt(credentials: $credentials->toArray());
     }
 
     public function refreshToken(PersonalAccessToken $tokenModel, User $user, string $deviceId): array
     {
-        return DB::transaction(function () use ($tokenModel, $user, $deviceId) {
-            $this->updateTokenExpiration($tokenModel, Carbon::now()->addMinutes(2));
+        return DB::transaction(callback: function () use ($tokenModel, $user, $deviceId): array {
+            $this->updateTokenExpiration(token: $tokenModel, expirationTime: Carbon::now()->addMinutes(value: 2));
 
-            $accessToken = $this->createAccessToken($user, $deviceId);
-            $refreshToken = $this->createRefreshToken($user, $deviceId);
+            $accessToken = $this->createAccessToken(user: $user, deviceId: $deviceId);
+            $refreshToken = $this->createRefreshToken(user: $user, deviceId: $deviceId);
 
             return [
                 'access_token' => $accessToken,

app/Repositories/AuthRepositoryInterface.php

@@ -4,7 +4,8 @@
 
 use App\Models\User;
 use App\Models\PersonalAccessToken;
-use App\DataTransferObjects\AuthDto;
+use App\DTO\AuthDTO;
+use Illuminate\Contracts\Auth\Authenticatable;
 
 interface AuthRepositoryInterface
 {
@@ -18,9 +19,9 @@ public function createRefreshToken(User $user, string $deviceId): string;
 
     public function updateTokenExpiration(PersonalAccessToken $token, \DateTime $expirationTime): void;
 
-    public function deleteUserTokensByDevice(User $user, string $deviceId): void;
+    public function deleteUserTokensByDevice(User|Authenticatable $user, string $deviceId): void;
 
-    public function attemptLogin(AuthDto $credentials): bool;
+    public function attemptLogin(AuthDTO $credentials): bool;
 
     public function refreshToken(PersonalAccessToken $token, User $user, string $deviceId): array;
-}
+}

app/Repositories/PermissionRepository.php

@@ -4,7 +4,7 @@
 
 use App\Models\Permission;
 use Illuminate\Database\Eloquent\Collection;
-use App\DataTransferObjects\PermissionDto;
+use App\DTO\PermissionDTO;
 
 class PermissionRepository implements PermissionRepositoryInterface
 {
@@ -25,38 +25,37 @@ public function allNoTree(): ?Collection
 
     public function find(int $id): ?Permission
     {
-        return $this->model->find($id);
+        return $this->model->find(id: $id);
     }
 
     public function findByScope(string $scope): ?Permission
     {
-        return $this->model->where('scope', $scope)->first();
+        return $this->model->where(column: 'scope', operator: $scope)->first();
     }
 
-    public function update(PermissionDto $permissionDto, int $id): ?Permission
+    public function update(PermissionDTO $permissionDTO, int $id): ?Permission
     {
-        $permission = $this->model->find($id);
-        $permission->update([
-            'scope' => $permissionDto->scope,
-            'description' => $permissionDto->description,
-            'bits' => $permissionDto->bits,
-            'parent_id' => $permissionDto->parent_id,
+        $permission = $this->model->find(id: $id);
+        $permission->update(attributes: [
+            'scope' => $permissionDTO->scope,
+            'description' => $permissionDTO->description,
+            'bits' => $permissionDTO->bits,
+            'parent_id' => $permissionDTO->parent_id,
         ]);
         return $permission;
     }
 
-    public function store(PermissionDto $permissionDto): Permission
+    public function store(PermissionDTO $permissionDTO): Permission
     {
-        $permission = $this->model->firstOrNew([
-            'scope' => $permissionDto->scope,
-            'description' => $permissionDto->description,
-            'bits' => $permissionDto->bits,
-            'scope' => $permissionDto->scope,
+        $permission = $this->model->firstOrNew(attributes: [
+            'scope' => $permissionDTO->scope,
+            'description' => $permissionDTO->description,
+            'bits' => $permissionDTO->bits,
         ]);
 
-        if ($permissionDto->parent_id) {
-            $parent = $this->model->find($permissionDto->parent_id);
-            $permission->prependToNode($parent);
+        if ($permissionDTO->parent_id) {
+            $parent = $this->model->find(id: $permissionDTO->parent_id);
+            $permission->prependToNode(parent: $parent);
         }
 
         $permission->save();
@@ -66,6 +65,6 @@ public function store(PermissionDto $permissionDto): Permission
 
     public function delete(int $id): bool
     {
-        return $this->model->destroy($id) > 0;
+        return $this->model->destroy(ids: $id) > 0;
     }
 }

app/Repositories/PermissionRepositoryInterface.php

@@ -2,8 +2,7 @@
 
 namespace App\Repositories;
 
-use App\DataTransferObjects\PermissionDto;
-use App\Http\Requests\PermissionRequest;
+use App\DTO\PermissionDTO;
 use App\Models\Permission;
 use Illuminate\Database\Eloquent\Collection;
 
@@ -17,9 +16,9 @@ public function find(int $id): ?Permission;
 
     public function findByScope(string $scope): ?Permission;
 
-    public function update(PermissionDto $permissionDto, int $id): ?Permission;
+    public function update(PermissionDTO $permissionDTO, int $id): ?Permission;
 
-    public function store(PermissionDto $permissionDto): Permission;
+    public function store(PermissionDTO $permissionDTO): Permission;
 
     public function delete(int $id): bool;
 }

app/Repositories/PersonalAccessTokenRepository.php

@@ -13,6 +13,6 @@ public function __construct(
 
     public function findToken(string $token): ?PersonalAccessToken
     {
-        return $this->model->findToken($token);
+        return $this->model->findToken(token: $token);
     }
 }

app/Repositories/UserRepository.php

@@ -4,9 +4,8 @@
 
 use App\Models\User;
 use Illuminate\Database\Eloquent\Collection;
-use App\DataTransferObjects\UserDto;
-use App\DataTransferObjects\UserLanguageDto;
-use App\Enums\UserTypeSource;
+use App\DTO\UserDTO;
+use App\DTO\UserLanguageDTO;
 use Illuminate\Support\Facades\Auth;
 
 class UserRepository implements UserRepositoryInterface
@@ -28,48 +27,48 @@ public function all(): ?Collection
         return $this->model->all();
     }
 
-    public function store(UserDto $userDto): User
+    public function store(UserDTO $userDTO): User
     {
-        return $this->model->create([
-            'name' => $userDto->name,
-            'email' => $userDto->email,
-            'password' => bcrypt($userDto->password),
-            'type' => $userDto->type,
+        return $this->model->create(attributes: [
+            'name' => $userDTO->name,
+            'email' => $userDTO->email,
+            'password' => bcrypt(value: $userDTO->password),
+            'type' => $userDTO->type,
         ]);
     }
 
-    public function update(UserDto $userDto, int $id): ?User
+    public function update(UserDTO $userDTO, int $id): ?User
     {
-        $user = $this->model->findOrFail($id);
-        $user->update([
-            'name' => $userDto->name,
-            'email' => $userDto->email,
-            'password' => bcrypt($userDto->password),
-            'type' => $userDto->type,
+        $user = $this->model->findOrFail(id: $id);
+        $user->update(attributes: [
+            'name' => $userDTO->name,
+            'email' => $userDTO->email,
+            'password' => bcrypt(value: $userDTO->password),
+            'type' => $userDTO->type,
         ]);
         return $user;
     }
 
     public function delete(int $id): bool
     {
-        return $this->model->destroy($id);
+        return $this->model->destroy(ids: $id);
     }
 
     public function find(int $id): ?User
     {
-        return $this->model->findOrFail($id);
+        return $this->model->findOrFail(id: $id);
     }
 
     public function findByEmail(string $email): ?User
     {
-        return $this->model->where('email', $email)->first();
+        return $this->model->where(column: 'email', operator: $email)->first();
     }
 
-    public function updateLanguage(UserLanguageDto $languageDto, int $id): ?User
+    public function updateLanguage(UserLanguageDTO $languageDTO, int $id): ?User
     {
-        $user = $this->model->findOrFail($id);
-        $user->update([
-            'language' => $languageDto->language,
+        $user = $this->model->findOrFail(id: $id);
+        $user->update(attributes: [
+            'language' => $languageDTO->language,
         ]);
         return $user;
     }

app/Repositories/UserRepositoryInterface.php

@@ -4,8 +4,8 @@
 
 use App\Models\User;
 use Illuminate\Database\Eloquent\Collection;
-use App\DataTransferObjects\UserDto;
-use App\DataTransferObjects\UserLanguageDto;
+use App\DTO\UserDTO;
+use App\DTO\UserLanguageDTO;
 
 interface UserRepositoryInterface
 {
@@ -13,15 +13,15 @@ public function me(): ?User;
 
     public function all(): ?Collection;
 
-    public function store(UserDto $userDto): User;
+    public function store(UserDTO $userDTO): User;
 
     public function find(int $id): ?User;
 
-    public function update(UserDto $userDto, int $id): ?User;
+    public function update(UserDTO $userDTO, int $id): ?User;
 
     public function delete(int $id): bool;
 
     public function findByEmail(string $email): ?User;
 
-    public function updateLanguage(UserLanguageDto $language, int $id): ?User;
+    public function updateLanguage(UserLanguageDTO $language, int $id): ?User;
 }

app/Repositories/UserTypePermissionRepository.php

@@ -15,11 +15,11 @@ public function __construct(
 
     public function allGuestPermissions(): ?Collection
     {
-        return $this->model->where('user_type', 'guest')->join('permissions', 'user_type_permissions.permission_id', '=', 'permissions.id')->get();
+        return $this->model->where(column: 'user_type', operator: 'guest')->join(table: 'permissions', first: 'user_type_permissions.permission_id', operator: '=', second: 'permissions.id')->get();
     }
 
     public function allPermissionsByUserType(UserTypeSource $userType): ?Collection
     {
-        return $this->model->where('user_type', $userType)->join('permissions', 'user_type_permissions.permission_id', '=', 'permissions.id')->get();
+        return $this->model->where(column: 'user_type', operator: $userType)->join(table: 'permissions', first: 'user_type_permissions.permission_id', operator: '=', second: 'permissions.id')->get();
     }
 }

app/Services/AuthService.php

@@ -3,8 +3,8 @@
 namespace App\Services;
 
 use App\Repositories\AuthRepositoryInterface;
-use App\DataTransferObjects\AuthDto;
-use App\DataTransferObjects\RefreshTokenDto;
+use App\DTO\AuthDTO;
+use App\DTO\RefreshTokenDTO;
 use Illuminate\Support\Str;
 use Illuminate\Support\Facades\Auth;
 
@@ -14,17 +14,17 @@ public function __construct(
         protected AuthRepositoryInterface $authRepository,
     ) {}
 
-    public function login(AuthDto $credentials): ?array
+    public function login(AuthDTO $credentials): ?array
     {
-        if (!$this->authRepository->attemptLogin($credentials)) {
+        if (!$this->authRepository->attemptLogin(credentials: $credentials)) {
             return null;
         }
 
-        $user = $this->authRepository->findUserByEmail($credentials->email);
+        $user = $this->authRepository->findUserByEmail(email: $credentials->email);
         $deviceId = Str::uuid()->toString();
 
-        $accessToken = $this->authRepository->createAccessToken($user, $deviceId);
-        $refreshToken = $this->authRepository->createRefreshToken($user, $deviceId);
+        $accessToken = $this->authRepository->createAccessToken(user: $user, deviceId: $deviceId);
+        $refreshToken = $this->authRepository->createRefreshToken(user: $user, deviceId: $deviceId);
 
         return [
             'access_token' => $accessToken,
@@ -34,11 +34,11 @@ public function login(AuthDto $credentials): ?array
         ];
     }
 
-    public function refresh(RefreshTokenDto $refreshToken): ?array
+    public function refresh(RefreshTokenDTO $refreshToken): ?array
     {
-        $tokenModel = $this->authRepository->findToken($refreshToken->token);
+        $tokenModel = $this->authRepository->findToken(token: $refreshToken->token);
 
-        if (!$tokenModel || !in_array('refresh', $tokenModel->abilities) || $tokenModel->expires_at < now()) {
+        if (!$tokenModel || !in_array(needle: 'refresh', haystack: $tokenModel->abilities) || $tokenModel->expires_at < now()) {
             return null;
         }
 
@@ -47,9 +47,9 @@ public function refresh(RefreshTokenDto $refreshToken): ?array
             return null;
         }
 
-        $deviceId = Str::afterLast($tokenModel->name, '_');
+        $deviceId = Str::afterLast(subject: $tokenModel->name, search: '_');
 
-        $tokens = $this->authRepository->refreshToken($tokenModel, $user, $deviceId);
+        $tokens = $this->authRepository->refreshToken(token: $tokenModel, user: $user, deviceId: $deviceId);
 
         return array_merge($tokens, [
             'user' => $user,
@@ -66,6 +66,6 @@ public function logout(): void
             return;
         }
 
-        $this->authRepository->deleteUserTokensByDevice($user, $deviceId);
+        $this->authRepository->deleteUserTokensByDevice(user: $user, deviceId: $deviceId);
     }
 }

app/Services/PermissionService.php

@@ -4,7 +4,7 @@
 
 use Illuminate\Database\Eloquent\Collection;
 use App\Repositories\PermissionRepositoryInterface;
-use App\DataTransferObjects\PermissionDto;
+use App\DTO\PermissionDTO;
 use App\Models\Permission;
 
 class PermissionService
@@ -26,26 +26,26 @@ public function allNoTree(): ?Collection
 
     public function find(int $id): ?Permission
     {
-        return $this->permissionRepository->find($id);
+        return $this->permissionRepository->find(id: $id);
     }
 
     public function findByScope(string $scope): ?Permission
     {
-        return $this->permissionRepository->findByScope($scope);
+        return $this->permissionRepository->findByScope(scope: $scope);
     }
 
-    public function store(PermissionDto $permissionDto): Permission
+    public function store(PermissionDTO $permissionDTO): Permission
     {
-        return $this->permissionRepository->store($permissionDto);
+        return $this->permissionRepository->store(permissionDTO: $permissionDTO);
     }
 
-    public function update(PermissionDto $permissionDto, int $id): ?Permission
+    public function update(PermissionDTO $permissionDTO, int $id): ?Permission
     {
-        return $this->permissionRepository->update($permissionDto, $id);
+        return $this->permissionRepository->update(permissionDTO: $permissionDTO, id: $id);
     }
 
     public function delete(int $id): bool
     {
-        return $this->permissionRepository->delete($id);
+        return $this->permissionRepository->delete(id: $id);
     }
 }

app/Services/UserService.php

@@ -4,8 +4,8 @@
 
 use Illuminate\Database\Eloquent\Collection;
 use App\Repositories\UserRepositoryInterface;
-use App\DataTransferObjects\UserDto;
-use App\DataTransferObjects\UserLanguageDto;
+use App\DTO\UserDTO;
+use App\DTO\UserLanguageDTO;
 use App\Models\User;
 
 class UserService
@@ -27,31 +27,31 @@ public function all(): ?Collection
 
     public function find(int $id): ?User
     {
-        return $this->userRepository->find($id);
+        return $this->userRepository->find(id: $id);
     }
 
-    public function store(UserDto $userDto): User
+    public function store(UserDTO $userDTO): User
     {
-        return $this->userRepository->store($userDto);
+        return $this->userRepository->store(userDTO: $userDTO);
     }
 
-    public function update(UserDto $userDto, int $id): ?User
+    public function update(UserDTO $userDTO, int $id): ?User
     {
-        return $this->userRepository->update($userDto, $id);
+        return $this->userRepository->update(userDTO: $userDTO, id: $id);
     }
 
     public function delete(int $id): bool
     {
-        return $this->userRepository->delete($id);
+        return $this->userRepository->delete(id: $id);
     }
 
     public function findByEmail(string $email): ?User
     {
-        return $this->userRepository->findByEmail($email);
+        return $this->userRepository->findByEmail(email: $email);
     }
 
-    public function updateLanguage(UserLanguageDto $language, int $id): ?User
+    public function updateLanguage(UserLanguageDTO $language, int $id): ?User
     {
-        return $this->userRepository->updateLanguage($language, $id);
+        return $this->userRepository->updateLanguage(language: $language, id: $id);
     }
 }

app/Services/UserTypePermissionService.php

@@ -20,6 +20,6 @@ public function allGuestPermissions(): ?Collection
 
     public function allPermissionsByUserType(UserTypeSource $userType): ?Collection
     {
-        return $this->userTypePermissionRepository->allPermissionsByUserType($userType);
+        return $this->userTypePermissionRepository->allPermissionsByUserType(userType: $userType);
     }
 }

app/Tasks/DeleteExpiredTokens.php

@@ -7,9 +7,9 @@
 
 class DeleteExpiredTokens
 {
-    public function __invoke()
+    public function __invoke(): void
     {
-        $deletedTokens = PersonalAccessToken::where('expires_at', '<', now())->delete();
-        Log::channel('expiredTokens')->info('Deleted ' . $deletedTokens . ' expired tokens');
+        $deletedTokens = PersonalAccessToken::where(column: 'expires_at', operator: '<', value: now())->delete();
+        Log::channel(channel: 'expiredTokens')->info(message: 'Deleted ' . $deletedTokens . ' expired tokens');
     }
 }

database/seeders/DatabaseSeeder.php

@@ -11,7 +11,7 @@ class DatabaseSeeder extends Seeder
      */
     public function run(): void
     {
-        $this->call([
+        $this->call(class: [
             UserSeeder::class,
             PermissionSeeder::class,
             UserTypePermissionSeeder::class,

database/seeders/PermissionSeeder.php

@@ -2,7 +2,7 @@
 
 namespace Database\Seeders;
 
-use App\DataTransferObjects\PermissionDto;
+use App\DTO\PermissionDTO;
 use Illuminate\Database\Seeder;
 use App\Services\PermissionService;
 
@@ -57,16 +57,16 @@ public function run(): void
             ],
         ];
 
-        $this->createPermissionsAndChildren($permissions);
+        $this->createPermissionsAndChildren(permissions: $permissions);
     }
 
-    private function createPermissionsAndChildren(array $permissions)
+    private function createPermissionsAndChildren(array $permissions): void
     {
         foreach ($permissions as $permission) {
-            $this->permissionService->store(PermissionDto::fromArray((array) $permission));
+            $this->permissionService->store(permissionDTO: PermissionDTO::fromArray(data: (array) $permission));
 
             if (!empty($permission['children'])) {
-                $this->createPermissionsAndChildren($permission['children']);
+                $this->createPermissionsAndChildren(permissions: $permission['children']);
             }
         }
     }

database/seeders/UserSeeder.php

@@ -13,10 +13,10 @@ class UserSeeder extends Seeder
      */
     public function run(): void
     {
-        $user = User::firstOrNew([
+        $user = User::firstOrNew(attributes: [
             'name' => 'admin',
             'email' => 'admin@admin.com',
-            'password' => bcrypt('admin'),
+            'password' => bcrypt(value: 'admin'),
             'type' => UserTypeSource::Admin,
         ]);
 

database/seeders/UserTypePermissionSeeder.php

@@ -20,7 +20,7 @@ public function run(): void
                 case UserTypeSource::Admin:
                     $permissions = Permission::get();
                     foreach ($permissions as $permission) {
-                        $userTypePermission = UserTypePermission::firstOrNew([
+                        $userTypePermission = UserTypePermission::firstOrNew(attributes: [
                             'user_type' => UserTypeSource::Admin->value,
                             'permission_id' => $permission->id,
                             'bits' => $permission->bits,

storage/stubs/Collection.stub

@@ -1,21 +0,0 @@
-<?php
-
-namespace App\Http\Resources;
-
-use Illuminate\Http\Request;
-use Illuminate\Http\Resources\Json\ResourceCollection;
-
-class {{modelName}}Collection extends ResourceCollection
-{
-    /**
-     * Transform the resource collection into an array.
-     *
-     * @return array<int|string, mixed>
-     */
-    public function toArray(Request $request): array
-    {
-        return $this->collection->transform(function ($resource) {
-            return new {{modelName}}Resource($resource);
-        })->toArray();
-    }
-}

storage/stubs/Controller.stub

@@ -5,8 +5,7 @@ namespace App\Http\Controllers;
 use App\Services\{{modelName}}Service;
 use App\Http\Requests\{{modelName}}Request;
 use App\Http\Resources\{{modelName}}Resource;
-use App\Http\Resources\{{modelName}}Collection;
-use App\DataTransferObjects\{{modelName}}Dto;
+use App\DTO\{{modelName}}DTO;
 use Illuminate\Http\JsonResponse;
 
 class {{modelName}}Controller extends Controller
@@ -18,12 +17,12 @@ class {{modelName}}Controller extends Controller
     public function index(): JsonResponse
     {
         $items = $this->{{modelName}}Service->getAllItems();
-        return $this->successResponse(payload: new {{modelName}}Collection($items));
+        return $this->successResponse(payload: {{modelName}}Resource::collection($items));
     }
 
     public function store({{modelName}}Request $request): JsonResponse
     {
-        $item = $this->{{modelName}}Service->createItem({{modelName}}Dto::fromRequest($request));
+        $item = $this->{{modelName}}Service->createItem({{modelName}}DTO::fromRequest($request));
         return $this->successResponse(payload: new {{modelName}}Resource($item), message: __('messages.created'), code: 201);
     }
 
@@ -35,7 +34,7 @@ class {{modelName}}Controller extends Controller
 
     public function update({{modelName}}Request $request, int $id): JsonResponse
     {
-        $item = $this->{{modelName}}Service->updateItem({{modelName}}Dto::fromRequest($request), $id);
+        $item = $this->{{modelName}}Service->updateItem({{modelName}}DTO::fromRequest($request), $id);
         return $this->successResponse(payload: new {{modelName}}Resource($item), message: __('messages.updated'));
     }
 

storage/stubs/Dto.stub → storage/stubs/DTO.stub

@@ -1,10 +1,10 @@
 <?php
 
-namespace App\DataTransferObjects;
+namespace App\DTO;
 
 use App\Http\Requests\{{modelName}}Request;
 
-class {{modelName}}Dto
+class {{modelName}}DTO
 {
     public function __construct(
         // Add properties here

storage/stubs/Repository.stub

@@ -3,7 +3,7 @@
 namespace App\Repositories;
 
 use App\Models\{{modelName}};
-use App\DataTransferObjects\{{modelName}}Dto;
+use App\DTO\{{modelName}}DTO;
 use Illuminate\Database\Eloquent\Collection;
 
 class {{modelName}}Repository implements {{modelName}}RepositoryInterface
@@ -23,12 +23,12 @@ class {{modelName}}Repository implements {{modelName}}RepositoryInterface
         return $this->model->find($id);
     }
 
-    public function create({{modelName}}Dto $dto): {{modelName}}
+    public function create({{modelName}}DTO $dto): {{modelName}}
     {
         return $this->model->create($dto->toArray());
     }
 
-    public function update(int $id, {{modelName}}Dto $dto): {{modelName}}
+    public function update(int $id, {{modelName}}DTO $dto): {{modelName}}
     {
         $record = $this->find($id);
         $record->update($dto->toArray());

storage/stubs/RepositoryInterface.stub

@@ -2,7 +2,7 @@
 
 namespace App\Repositories;
 
-use App\DataTransferObjects\{{modelName}}Dto;
+use App\DTO\{{modelName}}DTO;
 use Illuminate\Database\Eloquent\Collection;
 use App\Models\{{modelName}};
 
@@ -12,9 +12,9 @@ interface {{modelName}}RepositoryInterface
 
     public function find(int $id): ?{{modelName}};
 
-    public function create({{modelName}}Dto $dto): {{modelName}};
+    public function create({{modelName}}DTO $dto): {{modelName}};
 
-    public function update(int $id, {{modelName}}Dto $dto): {{modelName}};
+    public function update(int $id, {{modelName}}DTO $dto): {{modelName}};
 
     public function delete(int $id): bool;
 }

storage/stubs/Resource.stub

@@ -2,15 +2,26 @@
 
 namespace App\Http\Resources;
 
+use Illuminate\Http\Request;
 use Illuminate\Http\Resources\Json\JsonResource;
+use Illuminate\Http\Resources\Json\AnonymousResourceCollection;
 
 class {{modelName}}Resource extends JsonResource
 {
-    public function toArray($request): array
+    public function toArray(Request $request): array
     {
         return [
             'id' => $this->id,
             // Add other fields here
         ];
     }
+
+    /**
+     * @param \Illuminate\Database\Eloquent\Collection<{{modelName}}> $resource
+     * @return \Illuminate\Http\Resources\Json\AnonymousResourceCollection<{{modelName}}Resource>
+     */
+    public static function collection($resource): AnonymousResourceCollection;
+    {
+        return parent::collection($resource);
+    }
 }

storage/stubs/Service.stub

@@ -3,7 +3,7 @@
 namespace App\Services;
 
 use App\Repositories\{{modelName}}RepositoryInterface;
-use App\DataTransferObjects\{{modelName}}Dto;
+use App\DTO\{{modelName}}DTO;
 use Illuminate\Database\Eloquent\Collection;
 use App\Models\{{modelName}};
 
@@ -24,12 +24,12 @@ class {{modelName}}Service
         return $this->repository->find($id);
     }
 
-    public function createItem({{modelName}}Dto $dto): {{modelName}}
+    public function createItem({{modelName}}DTO $dto): {{modelName}}
     {
         return $this->repository->create($dto);
     }
 
-    public function updateItem({{modelName}}Dto $dto, int $id): {{modelName}}
+    public function updateItem({{modelName}}DTO $dto, int $id): {{modelName}}
     {
         return $this->repository->update($id, $dto);
     }