Skip to content
TheChatArchiveThe Chat Archive
Claudeclaude-opus-4-20250514· AnthropicHugging Face LMArena Human Preference 140K

داخل پروژه لاراولی یه استراکچر ساختم که سرویس و ریپزتوری و دی تیو ... داره بست…

  1. User

    داخل پروژه لاراولی یه استراکچر ساختم که سرویس و ریپزتوری و دی تیو ... داره بست پرکتیوترین و ابتیمایزترین حالت کدزنیش رو نشونم بده تمیز و پیشرفته

  2. Claude Assistant

    برای پیاده‌سازی بهینه و حرفه‌ای Service-Repository Pattern در لاراول، این ساختار رو پیشنهاد می‌دم:

    ساختار پوشه‌ها

    app/
    ├── Http/
    │   ├── Controllers/
    │   │   └── Api/
    │   │       └── UserController.php
    │   └── Requests/
    │       └── User/
    │           ├── StoreUserRequest.php
    │           └── UpdateUserRequest.php
    ├── Services/
    │   ├── Contracts/
    │   │   └── UserServiceInterface.php
    │   └── UserService.php
    ├── Repositories/
    │   ├── Contracts/
    │   │   └── UserRepositoryInterface.php
    │   └── Eloquent/
    │       └── UserRepository.php
    ├── DTOs/
    │   └── User/
    │       ├── UserData.php
    │       └── CreateUserData.php
    ├── Models/
    │   └── User.php
    └── Providers/
        └── RepositoryServiceProvider.php
    

    نمونه کدها

    DTO (Data Transfer Object)

    <?php
    
    namespace App\DTOs\User;
    
    use Spatie\LaravelData\Data;
    use Spatie\LaravelData\Attributes\Validation\Email;
    use Spatie\LaravelData\Attributes\Validation\Min;
    use Spatie\LaravelData\Attributes\Validation\Required;
    
    class CreateUserData extends Data
    {
        public function __construct(
            #[Required, Min(3)]
            public string $name,
            
            #[Required, Email]
            public string $email,
            
            #[Required, Min(8)]
            public string $password,
            
            public ?string $phone = null,
            public ?array $roles = []
        ) {}
        
        public static function rules(): array
        {
            return [
                'name' => ['required', 'string', 'min:3'],
                'email' => ['required', 'email', 'unique:users,email'],
                'password' => ['required', 'string', 'min:8'],
                'phone' => ['nullable', 'string'],
                'roles' => ['nullable', 'array'],
                'roles.*' => ['exists:roles,id']
            ];
        }
    }
    

    Repository Interface

    <?php
    
    namespace App\Repositories\Contracts;
    
    use App\Models\User;
    use Illuminate\Contracts\Pagination\LengthAwarePaginator;
    use Illuminate\Database\Eloquent\Collection;
    
    interface UserRepositoryInterface
    {
        public function find(int $id): ?User;
        
        public function findByEmail(string $email): ?User;
        
        public function all(array $filters = []): Collection;
        
        public function paginate(int $perPage = 15, array $filters = []): LengthAwarePaginator;
        
        public function create(array $data): User;
        
        public function update(int $id, array $data): bool;
        
        public function delete(int $id): bool;
        
        public function exists(array $criteria): bool;
    }
    

    Repository Implementation

    <?php
    
    namespace App\Repositories\Eloquent;
    
    use App\Models\User;
    use App\Repositories\Contracts\UserRepositoryInterface;
    use Illuminate\Contracts\Pagination\LengthAwarePaginator;
    use Illuminate\Database\Eloquent\Builder;
    use Illuminate\Database\Eloquent\Collection;
    use Illuminate\Support\Facades\Cache;
    
    class UserRepository implements UserRepositoryInterface
    {
        public function __construct(
            private User $model
        ) {}
        
        public function find(int $id): ?User
        {
            return Cache::remember(
                "user.{$id}",
                now()->addMinutes(5),
                fn() => $this->model->find($id)
            );
        }
        
        public function findByEmail(string $email): ?User
        {
            return $this->model->where('email', $email)->first();
        }
        
        public function all(array $filters = []): Collection
        {
            return $this->applyFilters($this->model->query(), $filters)->get();
        }
        
        public function paginate(int $perPage = 15, array $filters = []): LengthAwarePaginator
        {
            return $this->applyFilters($this->model->query(), $filters)
                ->paginate($perPage);
        }
        
        public function create(array $data): User
        {
            $user = $this->model->create($data);
            
            if (isset($data['roles'])) {
                $user->roles()->sync($data['roles']);
            }
            
            return $user->fresh('roles');
        }
        
        public function update(int $id, array $data): bool
        {
            $user = $this->find($id);
            
            if (!$user) {
                return false;
            }
            
            $updated = $user->update($data);
            
            if ($updated && isset($data['roles'])) {
                $user->roles()->sync($data['roles']);
            }
            
            Cache::forget("user.{$id}");
            
            return $updated;
        }
        
        public function delete(int $id): bool
        {
            $deleted = $this->model->destroy($id);
            
            if ($deleted) {
                Cache::forget("user.{$id}");
            }
            
            return (bool) $deleted;
        }
        
        public function exists(array $criteria): bool
        {
            return $this->model->where($criteria)->exists();
        }
        
        private function applyFilters(Builder $query, array $filters): Builder
        {
            return $query
                ->when($filters['search'] ?? null, function ($q, $search) {
                    $q->where(function ($query) use ($search) {
                        $query->where('name', 'like', "%{$search}%")
                              ->orWhere('email', 'like', "%{$search}%");
                    });
                })
                ->when($filters['role'] ?? null, function ($q, $role) {
                    $q->whereHas('roles', function ($query) use ($role) {
                        $query->where('name', $role);
                    });
                })
                ->when($filters['status'] ?? null, function ($q, $status) {
                    $q->where('status', $status);
                })
                ->when($filters['sort_by'] ?? null, function ($q, $sortBy) use ($filters) {
                    $q->orderBy($sortBy, $filters['sort_direction'] ?? 'asc');
                });
        }
    }
    

    Service Interface

    <?php
    
    namespace App\Services\Contracts;
    
    use App\DTOs\User\CreateUserData;
    use App\DTOs\User\UpdateUserData;
    use App\Models\User;
    use Illuminate\Contracts\Pagination\LengthAwarePaginator;
    
    interface UserServiceInterface
    {
        public function getUser(int $id): User;
        
        public function getUsersPaginated(array $filters = [], int $perPage = 15): LengthAwarePaginator;
        
        public function createUser(CreateUserData $data): User;
        
        public function updateUser(int $id, UpdateUserData $data): User;
        
        public function deleteUser(int $id): void;
        
        public function assignRole(int $userId, string $role): void;
    }
    

    Service Implementation

    <?php
    
    namespace App\Services;
    
    use App\DTOs\User\CreateUserData;
    use App\DTOs\User\UpdateUserData;
    use App\Exceptions\UserNotFoundException;
    use App\Models\User;
    use App\Repositories\Contracts\UserRepositoryInterface;
    use App\Services\Contracts\UserServiceInterface;
    use Illuminate\Contracts\Pagination\LengthAwarePaginator;
    use Illuminate\Support\Facades\DB;
    use Illuminate\Support\Facades\Hash;
    use Illuminate\Support\Facades\Log;
    
    class UserService implements UserServiceInterface
    {
        public function __construct(
            private UserRepositoryInterface $userRepository
        ) {}
        
        public function getUser(int $id): User
        {
            $user = $this->userRepository->find($id);
            
            if (!$user) {
                throw new UserNotFoundException("User with ID {$id} not found");
            }
            
            return $user;
        }
        
        public function getUsersPaginated(array $filters = [], int $perPage = 15): LengthAwarePaginator
        {
            return $this->userRepository->paginate($perPage, $filters);
        }
        
        public function createUser(CreateUserData $data): User
        {
            try {
                DB::beginTransaction();
                
                $userData = $data->toArray();
                $userData['password'] = Hash::make($userData['password']);
                
                $user = $this->userRepository->create($userData);
                
                DB::commit();
                
                Log::info('User created successfully', ['user_id' => $user->id]);
                
                return $user;
                
            } catch (\Exception $e) {
                DB::rollBack();
                Log::error('Failed to create user', [
                    'error' => $e->getMessage(),
                    'data' => $data->toArray()
                ]);
                throw $e;
            }
        }
        
        public function updateUser(int $id, UpdateUserData $data): User
        {
            try {
                DB::beginTransaction();
                
                $user = $this->getUser($id);
                
                $updateData = $data->toArray();
                
                if (isset($updateData['password'])) {
                    $updateData['password'] = Hash::make($updateData['password']);
                }
                
                $this->userRepository->update($id, $updateData);
                
                DB::commit();
                
                Log::info('User updated successfully', ['user_id' => $id]);
                
                return $user->fresh();
                
            } catch (\Exception $e) {
                DB::rollBack();
                Log::error('Failed to update user', [
                    'error' => $e->getMessage(),
                    'user_id' => $id
                ]);
                throw $e;
            }
        }
        
        public function deleteUser(int $id): void
        {
            try {
                $this->getUser($id); // Check if user exists
                
                $this->userRepository->delete($id);
                
                Log::info('User deleted successfully', ['user_id' => $id]);
                
            } catch (\Exception $e) {
                Log::error('Failed to delete user', [
                    'error' => $e->getMessage(),
                    'user_id' => $id
                ]);
                throw $e;
            }
        }
        
        public function assignRole(int $userId, string $role): void
        {
            $user = $this->getUser($userId);
            $user->assignRole($role);
        }
    }
    

    Controller

    <?php
    
    namespace App\Http\Controllers\Api;
    
    use App\DTOs\User\CreateUserData;
    use App\DTOs\User\UpdateUserData;
    use App\Http\Controllers\Controller;
    use App\Http\Resources\UserResource;
    use App\Services\Contracts\UserServiceInterface;
    use Illuminate\Http\JsonResponse;
    use Illuminate\Http\Request;
    use Illuminate\Http\Resources\Json\AnonymousResourceCollection;
    
    class UserController extends Controller
    {
        public function __construct(
            private UserServiceInterface $userService
        ) {}
        
        public function index(Request $request): AnonymousResourceCollection
        {
            $filters = $request->only(['search', 'role', 'status', 'sort_by', 'sort_direction']);
            $perPage = $request->input('per_page', 15);
            
            $users = $this->userService->getUsersPaginated($filters, $perPage);
            
            return UserResource::collection($users);
        }
        
        public function show(int $id): UserResource
        {
            $user = $this->userService->getUser($id);
            
            return new UserResource($user);
        }
        
        public function store(CreateUserData $data): JsonResponse
        {
            $user = $this->userService->createUser($data);
            
            return response()->json([
                'message' => 'User created successfully',
                'data' => new UserResource($user)
            ], 201);
        }
        
        public function update(int $id, UpdateUserData $data): JsonResponse
        {
            $user = $this->userService->updateUser($id, $data);
            
            return response()->json([
                'message' => 'User updated successfully',
                'data' => new UserResource($user)
            ]);
        }
        
        public function destroy(int $id): JsonResponse
        {
            $this->userService->deleteUser($id);
            
            return response()->json([
                'message' => 'User deleted successfully'
            ], 204);
        }
    }
    

    Service Provider

    <?php
    
    namespace App\Providers;
    
    use App\Repositories\Contracts\UserRepositoryInterface;
    use App\Repositories\Eloquent\UserRepository;
    use App\Services\Contracts\UserServiceInterface;
    use App\Services\UserService;
    use Illuminate\Support\ServiceProvider;
    
    class RepositoryServiceProvider extends ServiceProvider
    {
        public function register(): void
        {
            // Bind repositories
            $this->app->bind(UserRepositoryInterface::class, UserRepository::class);
            
            // Bind services
            $this->app->bind(UserServiceInterface::class, UserService::class);
        }
    }
    

    نکات مهم:

    1. استفاده از Interface: برای Repository و Service حتماً Interface تعریف کنید تا Dependency Injection راحت‌تر باشه و تست‌پذیری بالا بره

    2. DTO با Spatie Laravel Data: این پکیج validation و type safety رو خیلی راحت می‌کنه

    3. Cache Strategy: برای query های پرتکرار از کش استفاده کنید

    4. Transaction Management: برای عملیات‌های حساس از DB Transaction استفاده کنید

    5. Error Handling: Exception های مناسب تعریف کنید و Log مناسب داشته باشید

    6. Query Optimization: از Eager Loading استفاده کنید و N+1 Query Problem رو حل کنید

    این ساختار scalable، testable و maintainable هست و برای پروژه‌های بزرگ خیلی مناسبه.