Laravel Entity Generator

https://github.com/ronasit/laravel-entity-generator
Admin
Laravel Entity Generator is a tool for automatically generating entity classes and related code...
Tokens:6,828
Snippets:46
Trust Score:8.4
Update:9 months ago
Show doc for...
Tokens:
Raw
### Install Laravel Entity Generator

Source: https://github.com/ronasit/laravel-entity-generator/blob/master/ReadMe.md

Installs the Laravel Entity Generator package in development mode using Composer. This is the first step to integrate the generator into your Laravel project.

```bash
composer require ronasit/laravel-entity-generator --dev
```

--------------------------------

### Generate Complete Entity Stack (Bash)

Source: https://context7.com/ronasit/laravel-entity-generator/llms.txt

Creates all standard entity-related classes for a full CRUD implementation, including model, repository, service, controller, requests, migration, factory, seeder, tests, and API resources. This command is used for initial entity setup with specified fields and types.

```bash
php artisan make:entity Post -S title -S body -t published_at

# Output creates:
# - app/Models/Post.php
# - app/Repositories/PostRepository.php
# - app/Services/PostService.php
# - app/Http/Controllers/PostController.php
# - app/Http/Requests/Post/CreatePostRequest.php
# - app/Http/Requests/Post/UpdatePostRequest.php
# - app/Http/Resources/PostResource.php
# - database/migrations/2024_01_01_000000_posts_create_table.php
# - database/factories/PostFactory.php
# - database/seeders/PostSeeder.php
# - tests/PostTest.php
# - Updated routes/api.php with REST endpoints
```

--------------------------------

### Generate Entity with Relationships (Bash)

Source: https://context7.com/ronasit/laravel-entity-generator/llms.txt

Creates entities with defined Eloquent relationships (hasOne, hasMany, belongsTo, belongsToMany) and automatically configures the inverse relationships on the related models. This simplifies the setup of interconnected entities.

```bash
php artisan make:entity Post \
  -S title \
  -S body \
  -A Comment \
  -E Tag \
  -e User

# Generated Post model includes:
# public function comments(): HasMany
# public function tags(): BelongsToMany
# public function user(): BelongsTo

# Automatically updates Comment model with:
# public function post(): BelongsTo

# Automatically updates Tag model with:
# public function posts(): BelongsToMany
```

--------------------------------

### Generate Single Entity Component with Artisan CLI

Source: https://context7.com/ronasit/laravel-entity-generator/llms.txt

Command-line interface options for generating individual components of an entity, such as models, repositories, migrations, or tests. This allows for targeted regeneration or addition of specific parts of an entity without generating the entire set of files. Dependencies include the base Laravel installation and the entity generator package itself.

```bash
# Generate only the model class
php artisan make:entity Post --only-model -S title -S body

# Generate only the repository class
php artisan make:entity Post --only-repository

# Generate only the migration
php artisan make:entity Post --only-migration -S title -t published_at

# Generate only tests
php artisan make:entity Post --only-tests

# Other available flags:
# --only-service
# --only-controller
# --only-requests
# --only-factory
# --only-seeder
# --only-resource
# --only-nova-resource
# --only-nova-tests
```

--------------------------------

### Generate Entity with Specific CRUD Methods

Source: https://github.com/ronasit/laravel-entity-generator/blob/master/ReadMe.md

Generates entity classes with a specific set of CRUD methods, such as Read (search and get by id) and Update. This allows for fine-grained control over the generated functionality.

```bash
php artisan make:entity Post --methods=RU
```

--------------------------------

### Publish Laravel Entity Generator Resources

Source: https://github.com/ronasit/laravel-entity-generator/blob/master/ReadMe.md

Publishes the necessary resources for the Laravel Entity Generator, such as configuration files and stubs, to your Laravel project. This command makes the generator's configurations and templates available for customization.

```bash
php artisan vendor:publish --provider="RonasIT\Support\EntityGeneratorServiceProvider"
```

--------------------------------

### Generate Full Entity Stack

Source: https://github.com/ronasit/laravel-entity-generator/blob/master/ReadMe.md

Generates a complete set of classes for a new entity using the `make:entity` Artisan command. This includes the model, requests, tests, and other related files for a given entity name.

```bash
php artisan make:entity Post
```

--------------------------------

### Configure Entity Generator Paths and Stubs (PHP)

Source: https://context7.com/ronasit/laravel-entity-generator/llms.txt

This PHP configuration file defines the directory paths for various generated entity components (models, services, controllers, etc.) and specifies the stub templates used for each. It allows users to publish and modify this configuration to match their project's structure and desired code generation output. Custom stub files can be created for further tailoring.

```php
<?php

// config/entity-generator.php

return [
    'paths' => [
        'models' => 'app/Models',
        'services' => 'app/Services',
        'repositories' => 'app/Repositories',
        'controllers' => 'app/Http/Controllers',
        'requests' => 'app/Http/Requests',
        'resources' => 'app/Http/Resources',
        'migrations' => 'database/migrations',
        'factories' => 'database/factories',
        'seeders' => 'database/seeders',
        'tests' => 'tests',
        'routes' => 'routes/api.php',
        'translations' => 'lang/en/validation.php',
        'nova' => 'app/Nova',
    ],
    'stubs' => [
        'model' => 'entity-generator::model',
        'repository' => 'entity-generator::repository',
        'service' => 'entity-generator::service',
        'controller' => 'entity-generator::controller',
        'request' => 'entity-generator::request',
        'routes' => 'entity-generator::routes',
        'migration' => 'entity-generator::migration',
        'factory' => 'entity-generator::factory',
        'test' => 'entity-generator::test',
        'resource' => 'entity-generator::resource',
    ]
];

// Publish and customize configuration:
// php artisan vendor:publish --provider="RonasIT\Support\EntityGeneratorServiceProvider"

// Custom stub example - create resources/views/vendor/entity-generator/model.blade.php:
/*
namespace {{ $namespace }};

use IlluminateDatabaseEloquentModel;

class {{ $entity }} extends Model
{
    protected $fillable = [@foreach($fields as $field)'{{ $field }}',@endforeach];

    @foreach($relations as $relation)
    public function {{ $relation['name'] }}(): {{ ucfirst($relation['type']) }}
    {
        return $this->{{ $relation['type'] }}({{ $relation['entity'] }}::class);
    }
    @endforeach
}
*/

```

--------------------------------

### Generate Entity API Stack

Source: https://github.com/ronasit/laravel-entity-generator/blob/master/ReadMe.md

Generates a stack of classes for implementing the API part of an existing entity. This includes routes, controller, requests, and tests.

```bash
php artisan make:entity Post --only-api
```

--------------------------------

### Generate Only API Layer for Existing Entity (Bash)

Source: https://context7.com/ronasit/laravel-entity-generator/llms.txt

Creates only the API-related components for an existing entity, including the controller, routes, requests, tests, and API resources. This is beneficial when the core entity logic (model, repository, service) is already implemented or managed separately.

```bash
php artisan make:entity User --only-api

# Creates only:
# - app/Http/Controllers/UserController.php
# - app/Http/Requests/User/CreateUserRequest.php
# - app/Http/Requests/User/UpdateUserRequest.php
# - app/Http/Resources/UserResource.php
# - tests/UserTest.php
# - Updated routes/api.php with REST endpoints for User
```

--------------------------------

### Define Relations with Subfolder Namespaces

Source: https://github.com/ronasit/laravel-entity-generator/blob/master/ReadMe.md

Defines entity relations where related entities are located in subfolders. This enables specifying relative namespaces for relations, improving organization when dealing with complex project structures.

```bash
php artisan make:entity Post -A Blog/Comment -A Forum/Common/Reaction
```

--------------------------------

### Generate Database Migration with MigrationGenerator in PHP

Source: https://context7.com/ronasit/laravel-entity-generator/llms.txt

This code demonstrates how to generate a timestamped database migration file using the MigrationGenerator class. It specifies the model, its fields with types, and relationships to create the table schema. Key dependencies include the MigrationGenerator and RelationsDTO classes.

```php
<?php

use RonasIT\Support\Generators\MigrationGenerator;
use RonasIT\Support\DTO\RelationsDTO;

$generator = app(MigrationGenerator::class);

$generator
    ->setModel('Post')
    ->setFields([
        'string-required' => ['title', 'slug'],
        'string' => ['excerpt', 'body'],
        'integer-required' => ['user_id', 'category_id'],
        'boolean' => ['is_published'],
        'timestamp' => ['published_at'],
        'json' => ['metadata']
    ])
    ->setRelations(new RelationsDTO(
        belongsTo: ['User', 'Category']
    ))
    ->generate();

// Generated migration: database/migrations/2024_01_12_000000_posts_create_table.php
use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    public function up(): void
    {
        Schema::create('posts', function (Blueprint $table) {
            $table->id();
            $table->string('title');
            $table->string('slug');
            $table->string('excerpt')->nullable();
            $table->string('body')->nullable();
            $table->integer('user_id');
            $table->integer('category_id');
            $table->boolean('is_published')->nullable();
            $table->timestamp('published_at')->nullable();
            $table->json('metadata')->nullable();
            $table->timestamps();
        });
    }

    public function down(): void
    {
        Schema::dropIfExists('posts');
    }
};

```

--------------------------------

### Generate Entity with Subfolder Namespace

Source: https://github.com/ronasit/laravel-entity-generator/blob/master/ReadMe.md

Generates entity classes with their respective files placed in subfolders based on the provided namespace. This helps in organizing generated files within your project structure.

```bash
php artisan make:entity Forum/Blog/Post
```

--------------------------------

### Generate Entity with Custom CRUD Methods using Artisan CLI

Source: https://context7.com/ronasit/laravel-entity-generator/llms.txt

Artisan CLI command to generate entities with a restricted set of CRUD methods. This is useful when an entity does not require full CRUD functionality, helping to reduce boilerplate code. The command allows specifying which operations (Create, Read, Update, Delete) to include.

```bash
# Generate entity with only Read and Update operations
php artisan make:entity Post --methods=RU -S title -S body

# Generated PostController includes only:
# - index() method for listing
# - show() method for viewing single item
# - update() method for updating

# Generated routes include only:
# GET /posts (index)
# GET /posts/{id} (show)
# PUT /posts/{id} (update)

# Available method flags:
# C - Create
# R - Read (index and show)
# U - Update
# D - Delete

# Generate with Create and Delete only
php artisan make:entity Post --methods=CD -S title
```

--------------------------------

### Generate Entity with Nested Namespace (Bash)

Source: https://context7.com/ronasit/laravel-entity-generator/llms.txt

Creates entity classes within specified nested folders and namespaces for improved project organization. The generator automatically handles correct namespace declarations and PSR-4 autoloading configuration for the generated files.

```bash
php artisan make:entity Blog/Forum/Post -S title -S content

# Creates:
# - app/Models/Blog/Forum/Post.php with namespace App\Models\Blog\Forum
# - app/Repositories/PostRepository.php importing App\Models\Blog\Forum\Post
# - app/Services/PostService.php
# - All other classes with proper namespace resolution
```

--------------------------------

### MakeEntityCommand Class for Entity Generation

Source: https://context7.com/ronasit/laravel-entity-generator/llms.txt

The core command class for the entity generator. It handles command-line arguments, validates input, parses field and relation definitions, and orchestrates the generation process by invoking various generator classes. It can be used directly via the Artisan CLI or programmatically.

```php
<?php

namespace RonasIT\Support\Commands;

use Illuminate\Console\Command;
use RonasIT\Support\Generators\*;

class MakeEntityCommand extends Command
{
    protected $signature = 'make:entity {name}
        {--only-api}
        {--only-entity}
        {--methods=CRUD}
        {--S|string-required=*}
        {--s|string=*}
        {--I|integer-required=*}
        {--i|integer=*}
        {--A|has-many=*}
        {--e|belongs-to=*}';

    public function handle(): void
    {
        $this->validateInput();
        $this->parseRelations();
        $this->generate();
    }

    protected function generate(): void
    {
        foreach ($this->generators as $generator) {
            app($generator)
                ->setModel($this->entityName)
                ->setFields($this->getFields())
                ->setRelations($this->relations)
                ->setCrudOptions($this->getCrudOptions())
                ->generate();
        }
    }
}

// Usage in tests or custom commands:
use Illuminate\Support\Facades\Artisan;

Artisan::call('make:entity', [
    'name' => 'Article',
    '--string-required' => ['title', 'content'],
    '--timestamp' => ['published_at'],
    '--has-many' => ['Comment'],
]);
```

--------------------------------

### Generate RESTful Controller with ControllerGenerator in PHP

Source: https://context7.com/ronasit/laravel-entity-generator/llms.txt

This snippet shows how to programmatically generate a RESTful controller using the ControllerGenerator class. It demonstrates setting the model, fields, and CRUD options to automatically create controller logic and route definitions. Dependencies include the ControllerGenerator class and Laravel's application container.

```php
<?php

use RonasIT\Support\Generators\ControllerGenerator;

// Generate controller programmatically
$generator = app(ControllerGenerator::class);

$generator
    ->setModel('Post')
    ->setFields([
        'string-required' => ['title', 'content']
    ])
    ->setCrudOptions(['C', 'R', 'U', 'D'])
    ->generate();

// Generated PostController.php:
namespace App\Http\Controllers;

use App\Http\Requests\Post\CreatePostRequest;
use App\Http\Requests\Post\UpdatePostRequest;
use App\Http\Resources\PostResource;
use App\Services\PostService;

class PostController extends Controller
{
    public function __construct(
        private PostService $service
    ) {}

    public function index()
    {
        return PostResource::collection(
            $this->service->search(request()->all())
        );
    }

    public function store(CreatePostRequest $request)
    {
        return new PostResource(
            $this->service->create($request->validated())
        );
    }

    public function show(int $id)
    {
        return new PostResource(
            $this->service->get($id)
        );
    }

    public function update(int $id, UpdatePostRequest $request)
    {
        return new PostResource(
            $this->service->update($id, $request->validated())
        );
    }

    public function destroy(int $id)
    {
        $this->service->delete($id);
        return response()->noContent();
    }
}

// Generated routes in routes/api.php:
use App\Http\Controllers\PostController;

Route::get('/posts', [PostController::class, 'index']);
Route::post('/posts', [PostController::class, 'store']);
Route::get('/posts/{id}', [PostController::class, 'show']);
Route::put('/posts/{id}', [PostController::class, 'update']);
Route::delete('/posts/{id}', [PostController::class, 'destroy']);

```

--------------------------------

### Generate Entity Stack for Internal Use

Source: https://github.com/ronasit/laravel-entity-generator/blob/master/ReadMe.md

Generates a stack of classes for internal application use, excluding API-related components. This includes migration, model, service, and repository classes.

```bash
php artisan make:entity Post --only-entity
```

--------------------------------

### Update Configuration for Version 1.3+

Source: https://github.com/ronasit/laravel-entity-generator/blob/master/ReadMe.md

Updates the configuration file (`config/entity-generator.php`) for version 1.3 and above. This involves adding new keys for 'database_seeder' and 'translations' paths, as well as new stub configurations.

```php
    'paths' => [
        ...
        'database_seeder' => 'database/seeds/DatabaseSeeder.php',
        'translations' => 'lang/en/validation.php'
    ],
    'stubs' => [
        ...
        'empty_factory' => 'entity-generator::empty_factory',
        'translation_not_found' => 'entity-generator::translation_not_found',
        'validation' => 'entity-generator::validation',
        'seeder' => 'entity-generator::seeder',
        'database_empty_seeder' => 'entity-generator::database_empty_seeder'
    ]
```

--------------------------------

### Define Entity Fields with Types

Source: https://github.com/ronasit/laravel-entity-generator/blob/master/ReadMe.md

Defines fields for an entity along with their types and required status. This command allows you to specify data types like string, integer, float, boolean, datetime, and JSON for your entity's attributes.

```bash
php artisan make:entity Post -S title -S text -t published_at
```

--------------------------------

### Generate Entity with Multiple Field Types (Bash)

Source: https://context7.com/ronasit/laravel-entity-generator/llms.txt

Defines entity fields using various data types (integer, float, string, boolean, timestamp, JSON) with optional nullability. The generator automatically configures corresponding Eloquent model casts, migration column types, and validation rules.

```bash
php artisan make:entity Product \
  -I price \
  -f rating \
  -S name \
  -S description \
  -B is_active \
  -t published_at \
  -j metadata

# Generated migration includes:
# $table->integer('price');
# $table->float('rating')->nullable();
# $table->string('name');
# $table->string('description');
# $table->boolean('is_active');
# $table->timestamp('published_at')->nullable();
# $table->json('metadata')->nullable();
```

--------------------------------

### Define Entity Relations

Source: https://github.com/ronasit/laravel-entity-generator/blob/master/ReadMe.md

Defines relationships between entities using the `make:entity` command. This supports various relation types like 'has one', 'has many', 'belongs to', and 'belongs to many', allowing you to establish connections between your models.

```bash
php artisan make:entity Post -A Comment -A Reaction
```

--------------------------------

### Generate Only Entity Classes (No API) (Bash)

Source: https://context7.com/ronasit/laravel-entity-generator/llms.txt

Generates only the internal entity-related classes, such as migration, model, repository, service, factory, and seeder, without creating API-specific components like controllers, routes, requests, or tests. This is useful for data structures used internally within the application.

```bash
php artisan make:entity Setting \
  --only-entity \
  -S key \
  -S value \
  -B is_active

# Creates only:
# - database/migrations/xxx_settings_create_table.php
# - app/Models/Setting.php
# - app/Repositories/SettingRepository.php
# - app/Services/SettingService.php
# - database/factories/SettingFactory.php
# - database/seeders/SettingSeeder.php
# (No controller, routes, requests, or tests)
```

--------------------------------

### Generate Single Entity Class

Source: https://github.com/ronasit/laravel-entity-generator/blob/master/ReadMe.md

Generates only a specific class related to an entity, such as tests, model, repository, or controller. This is useful when you only need to update or create a particular part of the entity's stack.

```bash
php artisan make:entity Post --only-tests
```

--------------------------------

### ModelGenerator Class API for Programmatic Model Creation

Source: https://context7.com/ronasit/laravel-entity-generator/llms.txt

API for the ModelGenerator class, allowing programmatic creation of Eloquent model files. It supports defining fields, relationships, casts, and generating PHPDoc annotations for improved IDE integration. This class is part of the entity generation process and can be used independently.

```php
<?php

use RonasIT\Support\Generators\ModelGenerator;
use RonasIT\Support\DTO\RelationsDTO;

// Create model generator instance
$generator = app(ModelGenerator::class);

// Configure and generate model
$generator
    ->setModel('Post')
    ->setModelSubFolder('Blog')
    ->setFields([
        'string-required' => ['title', 'slug'],
        'string' => ['excerpt'],
        'integer-required' => ['user_id'],
        'timestamp' => ['published_at'],
        'boolean' => ['is_featured'],
        'json' => ['metadata']
    ])
    ->setRelations(new RelationsDTO(
        hasMany: ['Comment', 'Like'],
        belongsTo: ['User'],
        belongsToMany: ['Tag']
    ))
    ->setCrudOptions(['C', 'R', 'U', 'D'])
    ->generate();

// Generated model at app/Models/Blog/Post.php:
/**
 * @property string $title
 * @property string $slug
 * @property string|null $excerpt
 * @property int $user_id
 * @property Carbon|null $published_at
 * @property bool|null $is_featured
 * @property array $metadata
 * @property Collection<Comment> $comments
 * @property Collection<Like> $likes
 * @property User|null $user
 * @property Collection<Tag> $tags
 */
class Post extends Model
{
    protected $fillable = ['title', 'slug', 'excerpt', 'user_id', 'published_at', 'is_featured', 'metadata'];

    protected $casts = [
        'published_at' => 'datetime',
        'is_featured' => 'boolean',
        'metadata' => 'array'
    ];

    public function comments(): HasMany
    {
        return $this->hasMany(Comment::class);
    }

    public function user(): BelongsTo
    {
        return $this->belongsTo(User::class);
    }
}
```
Tokens:
Raw