In this post, we’ll dive into how soft deletes work in Laravel and how you can use them to safeguard your application’s data. By the end, you’ll have a solid understanding of soft deletes and their practical applications. Let’s get started! 💪

What Are Soft Deletes? 🤔

Soft deletes are a way to mark a record as deleted without actually removing it from the database. Instead of deleting the record outright, Laravel sets a deleted_at timestamp on the record. This makes it easy to filter "deleted" records out of queries, while still retaining them for recovery or auditing purposes.

Why Use Soft Deletes?

• Data Integrity: Keep records in your database for compliance or historical purposes.
• User Experience: Allow users to recover deleted records, reducing accidental data loss.
• Flexibility: Decide later if data should be permanently deleted or archived.

Implementing Soft Deletes in Laravel

Let’s walk through how to set up and use soft deletes in your Laravel application.

Step 1: Enable Soft Deletes in the Model

To enable soft deletes, add the SoftDeletes trait to your Eloquent model. This trait provides all the necessary functionality to handle soft-deleted records.

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\SoftDeletes;

class Post extends Model
{
    use SoftDeletes;

    /**
     * The attributes that should be mutated to dates.
     *
     * @var array
     */
    protected $dates = ['deleted_at'];
}

Note: The SoftDeletes trait automatically adds methods for managing soft-deleted records.

Step 2: Add the deleted_at Column to Your Database Table

Soft deletes rely on a deleted_at column to track when a record is "deleted." Update your database migration to include this column:

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

class CreatePostsTable extends Migration
{
    public function up()
    {
        Schema::create('posts', function (Blueprint $table) {
            $table->id();
            $table->string('title');
            $table->text('content');
            $table->softDeletes(); // Adds 'deleted_at' column
            $table->timestamps();
        });
    }

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

php artisan migrate

Step 3: Using Soft Deletes in Your Application

1. Soft Deleting a Record

Soft deleting a record sets the deleted_at column to the current timestamp.

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

The record is now "deleted" but remains in the database.

2. Retrieving Records Without Soft-Deleted Items

By default, Eloquent excludes soft-deleted records from queries:

$posts = Post::all(); // Excludes soft-deleted records

3. Including Soft-Deleted Records in Queries

To include soft-deleted records, use the withTrashed method:

$allPosts = Post::withTrashed()->get();

4. Retrieving Only Soft-Deleted Records

To fetch only soft-deleted records, use the onlyTrashed method:

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

5. Restoring a Soft-Deleted Record

Soft-deleted records can be restored with the restore method:

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

This sets the deleted_at column back to null, effectively "undeleting" the record.

6. Permanently Deleting a Record

To remove a record permanently, use the forceDelete method:

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

This completely removes the record from the database.

Step 4: Soft Deletes in Relationships

Soft deletes also work seamlessly with Eloquent relationships. For example, if you have a Comment model associated with a Post, you can configure cascading soft deletes by adding the SoftDeletes trait to both models.

In the Post model:

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

In the Comment model:

use Illuminate\Database\Eloquent\SoftDeletes;

class Comment extends Model
{
    use SoftDeletes;
}

When you delete a Post, all related Comment records can also be soft-deleted.

Benefits of Soft Deletes

• Reversible Deletion: Allows you to recover deleted records easily.
• Auditing: Retain deleted records for logging or historical purposes.
• User-Friendly: Prevents accidental loss of important data.

When to Use Soft Deletes?

Soft deletes are ideal when:

1. You need to allow users to recover deleted data.
2. You want to maintain an audit trail for compliance or debugging.
3. Deleting records outright could lead to data integrity issues.

However, if storage space is a concern or you don’t need to keep deleted records, you may prefer hard deletes.

Soft deletes are a powerful feature of Laravel’s Eloquent ORM that helps protect your data from accidental deletion while maintaining flexibility for recovery. By implementing soft deletes in your application, you can offer a safer and more user-friendly experience.

Start using soft deletes today to safeguard your data and simplify your application’s data management. Your future self (and your users) will thank you! 🙌

What’s Next?

• Explore more about Laravel Soft Deletes in the official documentation.
• Try implementing soft deletes in a project where data recovery is essential.
• Share your experiences or questions in the comments below! 👇

Happy coding! 😄