DEV Community: Adebayo Olukunle

Creating an API in Laravel

Adebayo Olukunle — Sun, 02 Mar 2025 09:03:51 +0000

Laravel is a powerful PHP framework that provides a robust set of tools to build APIs efficiently. In this guide, we'll walk through the process of setting up and creating a RESTful API in Laravel, covering authentication, routing, controllers, and resource management.

Prerequisites

PHP
Composer
Laravel
MySQL/PostgreSQL
Postman or cURL for testing

Step 1: Install Laravel

To start, install Laravel using Composer:

composer create-project --prefer-dist laravel/laravel api_tutorial
cd api_tutorial

Step 2: Set Up Database

Configure your .env file with your database details:

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=myapi_db
DB_USERNAME=root
DB_PASSWORD=secret

Run migrations to set up default tables:

php artisan migrate

Step 3: Create a Model and Migration

Generate a model and migration for a sample Post resource:

php artisan make:model Post -m

Modify the generated migration file in database/migrations/:

public function up()
{
    Schema::create('posts', function (Blueprint $table) {
        $table->id();
        $table->string('title');
        $table->text('content');
        $table->timestamps();
    });
}

Run the migration:

php artisan migrate

Step 4: Create a Controller

Generate a resource controller for the Post model:

php artisan make:controller PostController --api

Modify app/Http/Controllers/PostController.php:

use App\Models\Post;
use Illuminate\Http\Request;

class PostController extends Controller
{
    public function index()
    {
        return response()->json(Post::all());
    }

    public function store(Request $request)
    {
        $post = Post::create($request->all());
        return response()->json($post, 201);
    }

    public function show(Post $post)
    {
        return response()->json($post);
    }

    public function update(Request $request, Post $post)
    {
        $post->update($request->all());
        return response()->json($post);
    }

    public function destroy(Post $post)
    {
        $post->delete();
        return response()->json(null, 204);
    }
}

Step 5: Define API Routes

Modify routes/api.php:

use App\Http\Controllers\PostController;

Route::apiResource('posts', PostController::class);

Step 6: Test API Endpoints

Start the Server and Use Postman or cURL to test your endpoints:

php artisan serve

GET all posts:

curl -X GET http://localhost/api/posts

POST a new post:

curl -X POST http://localhost/api/posts -d "title=New Post&content=This is content" -H "Content-Type: application/json"

GET a single post:

curl -X GET http://localhost/api/posts/1

Update a post:

curl -X PUT http://localhost/api/posts/1 -d "title=Updated Post&content=Updated content" -H "Content-Type: application/json"

DELETE a post:

curl -X DELETE http://localhost/api/posts/1

Step 7: Implement Authentication

Laravel provides API authentication via Laravel Sanctum:

composer require laravel/sanctum

Publish Sanctum’s configuration:

php artisan vendor:publish --provider="Laravel\Sanctum\SanctumServiceProvider"

Run migrations:

php artisan migrate

Ensure that Sanctum middleware is enabled in app/Http/Kernel.php:

'api' => [
    \Laravel\Sanctum\Http\Middleware\EnsureFrontendRequestsAreStateful::class,
    'throttle:api',
    \Illuminate\Routing\Middleware\SubstituteBindings::class,
],

Use HasApiTokens in User.php:

use Laravel\Sanctum\HasApiTokens;

class User extends Authenticatable
{
    use HasApiTokens, Notifiable;
}

Authentication Routes

Modify routes/api.php:

use App\Http\Controllers\AuthController;

Route::post('register', [AuthController::class, 'register']);
Route::post('login', [AuthController::class, 'login']);

Route::middleware('auth:sanctum')->group(function () {
    Route::get('user', [AuthController::class, 'user']);
    Route::post('logout', [AuthController::class, 'logout']);
});

Authentication Controller

Create an authentication controller:

php artisan make:controller AuthController

Modify AuthController.php:

use App\Models\User;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Hash;

class AuthController extends Controller
{
    public function register(Request $request)
    {
        $user = User::create([
            'name' => $request->name,
            'email' => $request->email,
            'password' => Hash::make($request->password),
        ]);

        $token = $user->createToken('auth_token')->plainTextToken;
        return response()->json(['token' => $token], 201);
    }

    public function login(Request $request)
    {
        $user = User::where('email', $request->email)->first();

        if (!$user || !Hash::check($request->password, $user->password)) {
            return response()->json(['message' => 'Invalid credentials'], 401);
        }

        $token = $user->createToken('auth_token')->plainTextToken;
        return response()->json(['token' => $token]);
    }

    public function user(Request $request)
    {
        return response()->json($request->user());
    }

    public function logout(Request $request)
    {
        $request->user()->tokens()->delete();
        return response()->json(['message' => 'Logged out']);
    }
}

Conclusion

You've now built a secure Laravel API with authentication, CRUD operations, and routing. You can further enhance this by adding validation, pagination, and error handling to make it production-ready.

Handling Forms, Validation Rules, and Error Handling in Laravel

Adebayo Olukunle — Sun, 02 Mar 2025 08:42:04 +0000

Laravel provides a robust and elegant way to handle form submissions, validate user input, and manage error handling. This ensures data integrity, enhances user experience, and helps prevent security vulnerabilities such as SQL injection and XSS attacks. This article explores the best practices for handling forms, validation rules, and error handling in Laravel.

1. Creating Forms in Laravel

In Laravel, forms are primarily handled using Blade templates with the built-in @csrf directive to protect against cross-site request forgery (CSRF) attacks.

Example: Basic Form

<form action="{{ route('store.product') }}" method="POST">
    @csrf
    <label for="name">Product Name:</label>
    <input type="text" name="name" id="name" required>

    <label for="price">Price:</label>
    <input type="number" name="price" id="price" required>

    <button type="submit">Submit</button>
</form>

In this example:

The @csrf directive generates a hidden token to prevent CSRF attacks.
The form uses the POST method to send data to the store.product route.
Required fields ensure basic validation at the HTML level.

2. Handling Form Submissions in Controllers

Form submissions in Laravel are typically handled in controllers. The store method processes and validates the form data.
Example: Controller Handling

use Illuminate\Http\Request;
use App\Models\Product;

class ProductController extends Controller
{
    public function store(Request $request)
    {
        // Validate input
        $validatedData = $request->validate([
            'name' => 'required|string|max:255',
            'price' => 'required|numeric|min:1',
        ]);

        // Store data
        Product::create($validatedData);

        // Redirect with success message
        return redirect()->back()->with('success', 'Product added successfully!');
    }
}

Breakdown:

The validate() method ensures the request data adheres to defined rules.
If validation passes, the product is saved in the database.
If validation fails, Laravel automatically redirects the user back with validation errors.

3. Validation Rules in Laravel

Laravel provides numerous validation rules, including:

Example: Advanced Validation

$request->validate([
    'email' => 'required|email|unique:users,email',
    'password' => 'required|min:8|confirmed',
    'age' => 'nullable|integer|min:18',
]);

unique:users,email ensures the email is unique in the users table.
password uses confirmed, meaning a password_confirmation field must match.
nullable allows the field to be empty without validation errors.

4. Displaying Validation Errors

When validation fails, Laravel redirects back with error messages. In the Blade template, we can display these errors.

Example: Displaying Errors in Blade

@if ($errors->any())
    <div class="alert alert-danger">
        <ul>
            @foreach ($errors->all() as $error)
                <li>{{ $error }}</li>
            @endforeach
        </ul>
    </div>
@endif

This will display errors if validation fails.

5. Customizing Validation Error Messages
You can customize validation error messages using the messages() method.

Example: Custom Error Messages

$request->validate([
    'name' => 'required|string',
    'email' => 'required|email|unique:users,email',
], [
    'name.required' => 'The name field is mandatory.',
    'email.unique' => 'This email is already in use.',
]);

6. Form Request Validation

Instead of handling validation directly in controllers, Laravel provides Form Request Validation for cleaner code.

Step 1: Create a Form Request
Run the following command:

php artisan make:request StoreProductRequest

Step 2: Define Validation Rules
Modify the generated StoreProductRequest.php file:

use Illuminate\Foundation\Http\FormRequest;

class StoreProductRequest extends FormRequest
{
    public function rules()
    {
        return [
            'name' => 'required|string|max:255',
            'price' => 'required|numeric|min:1',
        ];
    }

    public function messages()
    {
        return [
            'name.required' => 'Please enter the product name.',
            'price.numeric' => 'Price must be a valid number.',
        ];
    }
}

Step 3: Use It in the Controller

public function store(StoreProductRequest $request)
{
    Product::create($request->validated());
    return redirect()->back()->with('success', 'Product added successfully!');
}

Using Form Request Validation keeps controllers clean and ensures separation of concerns.

7. Error Handling in Laravel

Laravel provides robust error handling through try-catch blocks and custom error pages.

Example: Handling Exceptions in Controllers

use Exception;
use Illuminate\Database\QueryException;

public function store(StoreProductRequest $request)
{
    try {
        Product::create($request->validated());
        return redirect()->back()->with('success', 'Product added successfully!');
    } catch (QueryException $e) {
        return redirect()->back()->with('error', 'Database error: ' . $e->getMessage());
    } catch (Exception $e) {
        return redirect()->back()->with('error', 'An unexpected error occurred.');
    }
}

8. Custom Error Pages

You can customize error pages by modifying the resources/views/errors directory.

Example: Custom 404 Page
Create a file: resources/views/errors/404.blade.php

@extends('layouts.app')

@section('content')
    <h1>Page Not Found</h1>
    <p>Sorry, the page you are looking for does not exist.</p>
    <a href="{{ url('/') }}">Return Home</a>
@endsection

Conclusion

Handling forms, validation, and error handling in Laravel is straightforward and powerful. By utilizing built-in validation rules, form request validation, and error handling mechanisms, developers can create secure and user-friendly applications.

Key Takeaways:

Use Laravel’s validate() method for quick validation.
Use Form Request Validation for cleaner controllers.
Display validation errors properly in Blade views.
Implement try-catch blocks for robust error handling.
Customize error pages for a better user experience.

By following these best practices, you can efficiently handle form submissions and ensure your Laravel applications remain secure and user-friendly.

Eloquent ORM (Models, Relationships) in Laravel

Adebayo Olukunle — Sun, 02 Feb 2025 13:39:16 +0000

Eloquent is Laravel's built-in ORM (Object-Relational Mapper) that provides a simple and expressive way to interact with a database. It follows the Active Record pattern, where each model corresponds to a database table, and each instance of a model represents a single row in that table.

This article covers the following:

Creating and using Eloquent models
Defining and using relationships (One-to-One, One-to-Many, Many-to-Many, Has-One-Through, Has-Many-Through, and Polymorphic Relationships)
Querying related data
Best practices

1. Creating and Using Eloquent Models

To create a new model in Laravel, use the Artisan command:

php artisan make:model Product

This command creates a Product.php file inside the app/Models directory (Laravel 8+). If using Laravel 7 or earlier, it will be in app/.

A typical Eloquent model looks like this:

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Product extends Model
{
    use HasFactory;

    protected $fillable = ['name', 'price', 'description'];
}

Basic CRUD Operations
When a model is created as described above, it can be used to handle basic operations in your application which we often term as CRUD meaning Create a record, Retrieving records, Updating a record, and Deleting a record.

Creating a Record

$product = Product::create([
    'name' => 'Laptop',
    'price' => 1500,
    'description' => 'High-performance laptop'
]);

Retrieving Records

$products = Product::all(); // Get all products
$product = Product::find(1); // Find by ID, it is usually one record
$product = Product::where('name', 'Laptop')->first();

Updating a Record

$product = Product::find(1);
$product->price = 1700;
$product->save();

Deleting a Record

$product->delete();
Product::destroy(1); // Delete by ID

2. Defining and Using Relationships

One-to-One Relationship

In this relationship, one entity is directly related to another entity. Entity in this case, an entity is a model record, say a User record would have a one-to-one-relationship with a Profile model record.

Example: User and Profile

app/Models/User.php

class User extends Model
{
    public function profile()
    {
        return $this->hasOne(Profile::class);
    }
}

app/Models/Profile.php

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

Fetching user profile:
To retrieve a user record, include the following code in one of the methods in the controller class created to handle user modules which typical should be created in app/Http/Controller/UserController.php, although it can be used in any class method.

php artisan make:controller UserController

open the file created in app/Http/Controller/UserController.php, add the following code. you can change the method name to what you prefer, but use a name that clearly describes what the method does.

public function findUserProfile() 
{
   $user = User::find(1); // 1 is the user ID
   $profile = $user->profile;
}

One-to-Many Relationship

In this relationship, one entity is related to multiple entities. Meaning, for instance, a specific post in the Post model would have or own multiple comments in the Comment Model (remember that a model is attached to a single Database table).

Example: Post and Comments

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

class Comment extends Model
{
    public function post()
    {
        return $this->belongsTo(Post::class);
    }
}

Fetching comments for a post: To retrieve comment records for a specific post, include the following code in one of the methods in the controller class which should be created to handle Post modules typical as app/Http/Controller/PostController.php, although it can be used in any class.

php artisan make:controller PostController

public function findPostComment() 
{
   $post = Post::find(1); // 1 is the post ID
   $comments = $post->comments;
}

Many-to-Many Relationship

Many entities are related to many other entities. A user can have many roles and a role can be assigned to many users. For instance, a user can have both Admin role and and HR role.

Example: Users and Roles

class User extends Model
{
    // other methods can be at the top or below

    public function roles()
    {
        return $this->belongsToMany(Role::class);
    }
}

class Role extends Model
{
    public function users()
    {
        return $this->belongsToMany(User::class);
    }
}

Assigning a role to a user: in your controller method, you can assign a role to a user like this

// assign a role using role Id to a user
$user->roles()->attach($roleId);

Has-One-Through Relationship

A relationship between two models through an intermediate model. This is useful when you need to access a related model that is connected through another model.

Example: Mechanic → Car → Owner

In this scenario, a mechanic services a car, and each car has one owner. Instead of defining two separate relationships, we can use a has-one-through relationship to access the owner directly from the mechanic.

class Mechanic extends Model
{
    public function owner()
    {
        return $this->hasOneThrough(Owner::class, Car::class);
    }
}

This allows you to fetch an owner directly from a mechanic:

$mechanic = Mechanic::find(1);
$owner = $mechanic->owner;

Has-Many-Through Relationship

A single model has many related models through an intermediate model. This is useful when a model is indirectly related to another model.

Example: Country → Users → Posts

A country has many users, and each user has many posts. Instead of fetching users first and then fetching their posts, we can define a has-many-through relationship.

class Country extends Model
{
    public function posts()
    {
        return $this->hasManyThrough(Post::class, User::class);
    }
}

Fetching posts from a country directly:

$country = Country::find(1);
$posts = $country->posts;

Polymorphic Relationships

Allows multiple models to share the same relationship, meaning different models can be associated with a single model type.

Example: Comments on Posts and Videos

Both posts and videos can have comments, so we use a polymorphic relationship.

class Comment extends Model
{
    public function commentable()
    {
        return $this->morphTo();
    }
}

class Post extends Model
{
    public function comments()
    {
        return $this->morphMany(Comment::class, 'commentable');
    }
}

class Video extends Model
{
    public function comments()
    {
        return $this->morphMany(Comment::class, 'commentable');
    }
}

This allows us to fetch comments on a post or video:

$post = Post::find(1);
$comments = $post->comments;

$video = Video::find(1);
$comments = $video->comments;

Saving a polymorphic comment:

$post->comments()->create(['body' => 'Great post!']);

3. Querying Related Data

Eloquent provides powerful methods to retrieve related data efficiently.

Eager Loading

Preload related data to optimize queries.

$users = User::with('profile')->get();

Lazy Loading

Loads related data only when accessed.

$user = User::find(1);
$profile = $user->profile;

Constraining Eager Loading
You are able to give a condition to what relationship you want to be eager loaded on your model.

$users = User::with(['posts' => function ($query) {
$query->where('status', 'published');
}])->get();

4. Best Practices

Use fillable or guarded to prevent mass assignment vulnerabilities.
Use eager loading to optimize database queries and reduce N+1 query issues.
Follow naming conventions. Eloquent assumes table names and foreign keys based on model names. table name should be plural, model name should singular, foreign fields are in snake case, like user_id
Use relationships instead of raw joins for cleaner and maintainable code.

Conclusion

Eloquent ORM in Laravel simplifies database interactions by providing an intuitive syntax for working with models and relationships. Mastering Eloquent will help you write efficient, maintainable, and scalable Laravel applications.

Laravel File Structure and MVC Architecture

Adebayo Olukunle — Sun, 02 Feb 2025 11:35:14 +0000

Laravel is one of the most popular PHP frameworks, known for its elegant syntax and robust features. It follows the Model-View-Controller (MVC) architecture, which helps developers organize code efficiently. Understanding Laravel’s file structure is crucial for developing scalable applications. In this article, we’ll explore Laravel’s directory structure and its implementation of the MVC architecture.

Laravel File Structure

When you install Laravel, the framework creates a structured directory layout. Below is an overview of the key directories and files in a Laravel project:

1. Root Directory

app/: Contains the core application logic, including Models, Controllers, and Middleware.
bootstrap/: Stores files required for the initial framework bootstrapping, including the cache directory for optimized application performance.
config/: Contains configuration files for services like database connections, authentication, mail, and more.
database/: Includes database migrations, seeders, and factories.
public/: The entry point of the application (index.php). Also stores assets like CSS, JavaScript, and images.
resources/: Contains view templates, raw assets, and language files.
routes/: Defines application routes (web, API, console, and channels).
storage/: Stores logs, session files, compiled views, and cache files.
tests/: Holds unit and feature tests.
vendor/: Contains third-party dependencies managed by Composer.

1. Key Files

- artisan: Laravel’s command-line interface for executing tasks.

- composer.json: Defines dependencies for the application.

- .env: Stores environment-specific configuration variables.

- server.php: Allows the application to be run using PHP’s built-in server.

Laravel's MVC Architecture

Laravel follows the MVC architecture pattern, which separates the application into three main components which are Model, View, Controller. This means that when the request gets into the application route, the route passes it to the Controller, the controller accesses the Model which is the data layer, and then the Controller also passes the data from the Model to the View for the users.

1. Model (app/Models/)

The Model represents the data structure and business logic. It interacts with the database using Eloquent ORM (Object-Relational Mapping).

Example:

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Product extends Model
{
    protected $fillable = ['name', 'price', 'description'];
}

Object-relational mapping (ORM) is a technique that enables data to be easily mapped between a relational database management system (RDBMS) like MySQL database, and an object-oriented programming (OOP) language. ORM systems serve as a bridge between the two different paradigms.

2. View (resources/views/)

Views handle the presentation layer of the application. Laravel uses Blade templating engine to create dynamic content.

Example:

<!DOCTYPE html>
<html>
<head>
    <title>Product List</title>
</head>
<body>
    <h1>Products</h1>
    <ul>
        @foreach ($products as $product)
            <li>{{ $product->name }} - ${{ $product->price }}</li>
        @endforeach
    </ul>
</body>
</html>

3. Controller (app/Http/Controllers/)

Controllers handle the application logic and bridge the Model and View.

Example:

namespace App\Http\Controllers;

use App\Models\Product;
use Illuminate\Http\Request;

class ProductController extends Controller
{
    public function index()
    {
        $products = Product::all();
        return view('products.index', compact('products'));
    }
}

4. Routes (routes/web.php)

Routes define how the application responds to user requests. It follows the http verb methods to receive the request, and maps the controller class and methods which would handle the request.

Example:

use App\Http\Controllers\ProductController;

Route::get('/products', [ProductController::class, 'index']);

Route::post('/products', [ProductController::class, 'create']);

Conclusion

Understanding Laravel’s file structure and MVC architecture is essential for building efficient applications. The framework's well-organized directory structure and adherence to MVC principles make development streamlined and maintainable. By leveraging Models, Views, and Controllers effectively, developers can create scalable web applications with Laravel.

Database Migrations in Laravel

Adebayo Olukunle — Sun, 02 Feb 2025 01:26:14 +0000

Introduction

Laravel is a popular PHP framework known for its elegant syntax and robust features. One of its most powerful features is its database management system, which includes query builders, Eloquent ORM, and migrations. Migrations allow developers to version-control their database schema, making it easy to collaborate with teams and maintain databases in different environments.

In this article, we will explore databases in Laravel, focusing on database configurations, migrations, database factory seeding, and other best practices.

Database Configuration

Before using Laravel's database features, you need to configure your database connection. The configuration file for databases is located in config/database.php. Laravel supports multiple database connections, including MySQL, PostgreSQL, SQLite, and SQL Server.

Setting Up the .env File

Laravel uses an environment file (.env) to store sensitive database credentials. You can set up your database connection by modifying the .env file:

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=your_database_name
DB_USERNAME=your_database_user
DB_PASSWORD=your_database_password

After updating the .env file, you should run the following command to clear the configuration cache:

php artisan config:clear

Understanding Migrations

Migrations in Laravel provide a version control system for your database schema, allowing you to define and modify tables using PHP instead of raw SQL. This makes database management more structured and easier to track changes across teams, as developers on your project can easily see the history of modifications that was made on your database structure.

Creating Migrations

To create a migration, use the Artisan command. Let us say you would like to create a database table called "products" which holds details about products in your application. your artisan command would be:

php artisan make:migration create_products_table

This will generate a migration file inside the database/migrations directory, which looks like this:

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    /**
     * Run the migrations.
     */
    public function up(): void
    {
        Schema::create('products', function (Blueprint $table) {
            $table->id();
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     */
    public function down(): void
    {
        Schema::dropIfExists('products');
    }
};

You will find two methods in the migration class created above; the 'up' and 'down' methods. The 'up' method creates the table structure into the database using the name (in this case, 'products') which falls in between the 'create' and 'table' keywords in in the previous command above. The down method on the other hand is used to tear down the table structure when specified in the artisan command. Before you proceed to execute the command which would run the migration, you can modify the 'up' method to include all the fields, their data types, default values, position, and other structure that is required for the products table in your application.

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    /**
     * Run the migrations.
     */
    public function up(): void
    {
        Schema::create('products', function (Blueprint $table) {
            $table->id();
            $table->string('name');
            $table->text('description')->nullable();
            $table->decimal('price', 8, 2);
            $table->boolean('is_published')->default(false);
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     */
    public function down(): void
    {
        Schema::dropIfExists('products');
    }
};

Running Migrations

Once the migration file is created, apply it using:

php artisan migrate

This command executes all pending migrations, creating or modifying tables as defined in the migration files.

Rolling Back Migrations

If you need to undo the last migration, use:

php artisan migrate:rollback

To reset the entire database schema and re-run all migrations:

php artisan migrate:reset
php artisan migrate

To rollback and re-run migrations in a single step:

php artisan migrate:refresh

Seeding the Database

Laravel also provides a feature called database seeding, which allows you to insert dummy data into the database for testing and development. Seeder files are located in database/seeders.

To create a seeder:

php artisan make:seeder ProductSeeder

A typical seeder file looks like this:

use Illuminate\Database\Seeder;
use Illuminate\Support\Facades\DB;

class ProductSeeder extends Seeder
{
    public function run()
    {
        DB::table('products')->insert([
            'name' => 'Sample Product',
            'description' => 'This is a sample product.',
            'price' => 100.00,
            'created_at' => now(),
            'updated_at' => now(),
        ]);
    }
}

Run the seeder using:

php artisan db:seed --class=ProductSeeder

To run all seeders defined in DatabaseSeeder.php, use:

php artisan db:seed

Factories and Seeders for Testing

Laravel provides model factories that allow you to generate fake data using the Faker library. First, create a factory:

php artisan make:factory ProductFactory --model=Product

Modify the factory file:

use Illuminate\Database\Eloquent\Factories\Factory;
use App\Models\Product;

class ProductFactory extends Factory
{
    protected $model = Product::class;

    public function definition()
    {
        return [
            'name' => $this->faker->word,
            'description' => $this->faker->sentence,
            'price' => $this->faker->randomFloat(2, 10, 500),
        ];
    }
}

Use the factory in the seeder:

use App\Models\Product;
//...
public function run(): void
{
   Product::factory()->count(50)->create();
}

Run the seeder:

php artisan db:seed

Best Practices

Use Descriptive Migration Names – Always name migrations clearly (e.g., create_orders_table instead of new_table).

Keep Migrations Modular – Avoid modifying multiple tables in a single migration file.

Use Factories for Testing – Generate dummy data efficiently using factories instead of manually inserting records.

Backup Before Migration – Before running destructive commands like migrate:reset, ensure you have a backup of your database.

Run Migrations in CI/CD Pipelines – Automate migrations using CI/CD workflows to keep environments synchronized.

Conclusion

Laravel's database management system, powered by migrations, seeders, and factories, provides a structured and maintainable way to handle databases. By leveraging migrations, you can track schema changes effectively, ensuring smooth collaboration across development teams. Understanding and implementing Laravel migrations properly will greatly enhance the efficiency and scalability of your applications.