Therepository Laravel Package

Getting Started

Minimal Setup

1. Installation

   composer require iamkesharinandan/therepository
   

   Publish the config file (if available):

   php artisan vendor:publish --provider="Keshari\Therepository\TherepositoryServiceProvider"
   

2. Basic Usage

   • Define a repository interface (e.g., UserRepositoryInterface):

     namespace App\Repositories;
     
     interface UserRepositoryInterface {
         public function find(int $id);
         public function all();
     }
     

   • Create a concrete repository class (e.g., UserRepository):

     namespace App\Repositories;
     
     use Keshari\Therepository\BaseRepository;
     use App\Models\User;
     
     class UserRepository extends BaseRepository implements UserRepositoryInterface {
         public function model() {
             return User::class;
         }
     }
     

   • Bind the interface to the concrete class in AppServiceProvider:

     $this->app->bind(UserRepositoryInterface::class, UserRepository::class);
     

   • Use the repository in a controller/service:

     use App\Repositories\UserRepositoryInterface;
     
     class UserController {
         protected $userRepository;
     
         public function __construct(UserRepositoryInterface $userRepository) {
             $this->userRepository = $userRepository;
         }
     
         public function show($id) {
             return $this->userRepository->find($id);
         }
     }
     

3. First Use Case

   • Fetch a single record:

     $user = $this->userRepository->find(1);
     

   • Fetch all records:

     $users = $this->userRepository->all();
     

Implementation Patterns

Common Workflows

1. CRUD Operations The package likely provides basic CRUD methods (e.g., create(), update(), delete()). Extend BaseRepository to leverage these:

   class UserRepository extends BaseRepository {
       public function model() {
           return User::class;
       }
   
       public function create(array $data) {
           return $this->model->create($data);
       }
   }
   

2. Query Scoping Add custom scopes to the repository:

   public function active() {
       return $this->model->where('is_active', true);
   }
   

   Usage:

   $activeUsers = $this->userRepository->active()->get();
   

3. Dependency Injection Inject repositories into services/controllers:

   class UserService {
       public function __construct(UserRepositoryInterface $userRepository) {
           $this->userRepository = $userRepository;
       }
   }
   

4. Event Handling Trigger events (e.g., created, deleted) in the repository:

   public function create(array $data) {
       $user = $this->model->create($data);
       event(new UserCreated($user));
       return $user;
   }
   

5. Transactions Wrap operations in transactions:

   public function transferOwnership(int $userId, int $newOwnerId) {
       DB::transaction(function () use ($userId, $newOwnerId) {
           $user = $this->find($userId);
           $user->owner_id = $newOwnerId;
           $user->save();
       });
   }
   

Integration Tips

• Laravel Eloquent: The package likely works seamlessly with Eloquent models. Ensure your model() method returns a valid Eloquent class.
• API Resources: Pair repositories with API resources for consistent responses:

  return $this->userRepository->all()->resource();
  

• Testing: Mock repositories in tests:

  $mock = Mockery::mock(UserRepositoryInterface::class);
  $mock->shouldReceive('find')->andReturn($user);
  $this->app->instance(UserRepositoryInterface::class, $mock);
  

Gotchas and Tips

Pitfalls

1. Missing model() Method Forgetting to define model() in your repository will throw errors. Always implement it:

   public function model() {
       return User::class; // Required!
   }
   

2. No Base Class Methods The package may not include all CRUD methods by default. Extend BaseRepository and manually implement missing methods (e.g., update(), delete()).

3. No Built-in Pagination If pagination is needed, manually add it:

   public function paginate() {
       return $this->model->paginate(15);
   }
   

4. Service Provider Binding Ensure interfaces are properly bound in AppServiceProvider. Avoid hardcoding repository classes in constructors.

5. Naming Conflicts Avoid naming repositories ambiguously (e.g., UserRepository vs. AdminUserRepository). Use clear, consistent naming.

Debugging Tips

• Check for Null Models If $this->model is null, verify model() is correctly implemented and returns a valid Eloquent class.
• Query Logs Enable query logging to debug slow or incorrect queries:

  DB::enableQueryLog();
  $users = $this->userRepository->all();
  dd(DB::getQueryLog());
  

• Interface Mismatches Ensure all methods in your interface are implemented in the concrete repository. PHP will throw errors if they’re missing.

Extension Points

1. Custom Query Builders Override methods to add custom logic:

   public function search(string $query) {
       return $this->model->where('name', 'like', "%{$query}%");
   }
   

2. Repository Decorators Decorate repositories to add cross-cutting concerns (e.g., logging, caching):

   class LoggedUserRepository implements UserRepositoryInterface {
       protected $userRepository;
   
       public function __construct(UserRepositoryInterface $userRepository) {
           $this->userRepository = $userRepository;
       }
   
       public function find(int $id) {
           $user = $this->userRepository->find($id);
           Log::info("User {$id} retrieved", ['user' => $user]);
           return $user;
       }
   }
   

3. Dynamic Model Binding For polymorphic repositories, dynamically set the model:

   public function model(string $modelClass) {
       return app($modelClass);
   }
   

4. Repository Events Listen for repository events (if supported) to trigger actions:

   event(new UserDeleted($user));