Symfony Entity Serve Classes Generator Laravel Package

Getting Started

Minimal Steps

1. Installation Add the package to your Laravel project via Composer:

   composer require alexskoromnui/symfony-entity-serve-classes-generator
   

   (Note: This package is originally Symfony-focused, but Laravel developers can adapt it via Symfony’s HttpKernel or standalone usage.)

2. Understand the Core Purpose The package generates server-side classes (e.g., DTOs, API responses) from entity definitions (e.g., Doctrine ORM entities). It’s useful for:

   • Auto-generating API response classes from Eloquent models.
   • Reducing boilerplate for serialization/deserialization.

3. First Use Case: Generate a Response Class

   • Define an Eloquent model (e.g., User.php).
   • Use the generator to create a corresponding response class (e.g., UserResponse.php).
   • Example workflow:

     use AlexSk\Generator\Generator;
     
     $generator = new Generator();
     $generator->generateFromEntity(User::class, 'app/Responses/UserResponse.php');
     

   • (Laravel adaptation: Replace Doctrine annotations with Laravel’s attributes or manual mapping.)

Implementation Patterns

Workflows

1. Model-to-Response Pipeline

   • Step 1: Annotate Eloquent models with metadata (e.g., #[ApiResource] or custom attributes).
   • Step 2: Run the generator in a post-update Composer script or Artisan command:

     // app/Console/Commands/GenerateResponses.php
     public function handle() {
         $generator = new Generator();
         $generator->generateFromEntities([
             User::class => 'app/Responses/UserResponse.php',
             Post::class => 'app/Responses/PostResponse.php',
         ]);
     }
     

   • Step 3: Use the generated classes in controllers:

     return new UserResponse(User::find(1));
     

2. Integration with API Resources

   • Extend Laravel’s JsonResource with generated classes:

     public function toArray($request) {
         return new UserResponse($this->resource);
     }
     

3. Dynamic Generation

   • Cache generated classes in bootstrap/cache/ to avoid runtime overhead.
   • Use a ServiceProvider to auto-load responses:

     $this->app->bind(UserResponse::class, function () {
         return new UserResponse(User::find(1));
     });
     

Tips for Laravel Adoption

• Replace Doctrine Annotations: Use Laravel’s attributes (PHP 8+) or a simple config array to map fields.
• Leverage Events: Trigger generation after model updates via ModelEvent listeners.
• Custom Templates: Override the generator’s templates to match Laravel’s naming conventions (e.g., UserResponse instead of UserDto).

Gotchas and Tips

Pitfalls

1. Doctrine Dependency

   • The package assumes Doctrine ORM. For Laravel:
     • Mock Doctrine’s Mapping\ClassMetadata or write a bridge layer.
     • Example: Use getTable() from Eloquent instead of Doctrine’s metadata.

2. Runtime Overhead

   • Generating classes at runtime is slow. Pre-generate them during deployment or use a post-update Composer script.

3. Attribute Conflicts

   • If using PHP 8 attributes, ensure they don’t clash with Laravel’s (e.g., #[ApiResource] vs. #[AsRequest]).

Debugging

• Verify Input: Check if the generator receives correct entity metadata. Log the input before generation:

  $metadata = $generator->getMetadata(User::class);
  \Log::info($metadata);
  

• Template Issues: If generated classes are malformed, inspect the Twig template (located in the package’s Resources/views/).

Extension Points

1. Custom Field Mappings

   • Override the generator’s getPropertyMappings() to handle Laravel-specific fields (e.g., timestamps):

     $generator->setPropertyMappings([
         'created_at' => ['type' => 'datetime', 'serialized_name' => 'createdAt'],
     ]);
     

2. Add Methods to Generated Classes

   • Extend the base template to include helper methods:

     {# app/Responses/UserResponse.php.twig #}
     public function isAdmin(): bool {
         return $this->role === 'admin';
     }
     

3. Conditional Generation

   • Skip generation for models with #[HideFromApi] or similar attributes:

     if (in_array(HideFromApi::class, class_uses_recursive($entityClass))) {
         return;
     }
     

Config Quirks

• Namespace Handling: Ensure generated classes use Laravel’s autoloading namespace (e.g., App\Responses).
• File Permissions: Generated files must be writable by the web server (e.g., storage/ or app/).