Eloquentbundle Laravel Package

Getting Started

Minimal Setup

1. Install via Composer:

   composer require cekurte/eloquentbundle
   

2. Enable the Bundle in config/bundles.php:

   return [
       // ...
       Cekurte\EloquentBundle\CekurteEloquentBundle::class => ['all' => true],
   ];
   

3. Configure Database Connection in config/packages/cekurte_eloquent.yaml:

   cekurte_eloquent:
       db_connection: default
       models_namespace: App\Entity
   

4. Define a Model (e.g., src/Entity/User.php):

   namespace App\Entity;
   
   use Cekurte\EloquentBundle\Model\EloquentModel;
   
   class User extends EloquentModel
   {
       protected $table = 'users';
       protected $fillable = ['name', 'email'];
   }
   

5. Use the Model in a Controller:

   use App\Entity\User;
   
   public function index()
   {
       $users = User::all();
       return $this->json($users);
   }
   

First Use Case

• CRUD Operations: Leverage Eloquent’s familiar syntax (create(), find(), save(), delete()) directly in Symfony.
• Example:

  $user = new User();
  $user->name = 'John Doe';
  $user->email = 'john@example.com';
  $user->save(); // Persists to DB
  

Implementation Patterns

Workflows

1. Model Definition:

   • Extend EloquentModel and define $table, $fillable, and relationships (e.g., $belongsTo, $hasMany).
   • Example:

     class Post extends EloquentModel
     {
         public function user()
         {
             return $this->belongsTo(User::class);
         }
     }
     

2. Service Integration:

   • Inject the EloquentManager service to dynamically fetch models:

     public function __construct(private EloquentManager $eloquent)
     {
     }
     
     public function getPost($id)
     {
         return $this->eloquent->getModel('App\Entity\Post')->find($id);
     }
     

3. Query Building:

   • Use Eloquent’s query builder (e.g., where(), orderBy(), with()):

     $activeUsers = User::where('active', true)->with('posts')->get();
     

4. Events & Observers:

   • Register observers in config/packages/cekurte_eloquent.yaml:

     cekurte_eloquent:
         observers:
             App\Entity\User: App\Observer\UserObserver
     

Integration Tips

• Symfony Forms: Bind Eloquent models to forms using ModelType:

  use Cekurte\EloquentBundle\Form\ModelType;
  
  $builder->add('user', ModelType::class, [
      'model' => User::class,
      'fields' => ['name', 'email'],
  ]);
  

• Doctrine Compatibility: Avoid mixing Doctrine and Eloquent entities in the same project (risk of conflicts).
• APIs: Use toArray() or toJson() for serialization:

  return $this->json(User::find(1)->toArray());
  

Gotchas and Tips

Pitfalls

1. Deprecated Package:

   • Last release in 2015; may not support modern Symfony (5.4+) or PHP (8.x) out-of-the-box.
   • Mitigation: Fork and update dependencies (e.g., illuminate/database, laravel/framework) manually.

2. Namespace Conflicts:

   • EloquentBundle uses Laravel’s Illuminate namespace, which may clash with other bundles.
   • Fix: Alias namespaces in composer.json or use fully qualified paths.

3. Missing Features:

   • No built-in support for:
     • Eloquent’s Accessors/Mutators (use __get()/__set() in models).
     • HasApiTokens or Scopes (implement manually).
   • Workaround: Extend the bundle or use traits.

4. Configuration Overrides:

   • Custom configurations (e.g., db_connection) must match Symfony’s Doctrine setup.
   • Debug Tip: Check Cekurte\EloquentBundle\DependencyInjection\Configuration for defaults.

Debugging

• SQL Logging: Enable PDO logging in config/packages/dev/doctrine.yaml:

  doctrine:
      dbal:
          logging: true
          profiling: true
  

• Common Errors:
  • "Class not found": Ensure models are in the configured models_namespace.
  • "Connection not configured": Verify db_connection matches Symfony’s Doctrine DSN.

Extension Points

1. Custom Model Events:
   • Override boot() in your model to add logic:

     protected static function boot()
     {
         parent::boot();
         static::creating(function ($model) {
             $model->created_at = now();
         });
     }
     

2. Service Extensions:
   • Create a compiler pass to add custom Eloquent services:

     use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
     use Symfony\Component\DependencyInjection\ContainerBuilder;
     
     class AddCustomEloquentServicePass implements CompilerPassInterface
     {
         public function process(ContainerBuilder $container)
         {
             $definition = $container->findDefinition('cekurte_eloquent.manager');
             $definition->addMethodCall('addCustomModel', [MyCustomModel::class]);
         }
     }
     

3. Query Scopes:
   • Add static methods to models for reusable queries:

     public function scopeActive($query)
     {
         return $query->where('active', true);
     }
     

     Usage: User::active()->get();