How To Make Unique Validations Work With Soft Delete In Laravel

Imagine this: you’re working on your Laravel project, everything’s going smoothly, and then you hit a snag with unique validations and soft deletes. You’ve soft-deleted a record, but when you try to create a new one with the same value, Laravel throws an error. Frustrating, right?

I’ve been there too, pulling my hair out trying to figure out why this keeps happening. Turns out, the solution is simpler than you might think. In this post, I’ll show you how to make unique validations work with soft deletes in Laravel, so you can avoid the same headache.

Need a hand with Laravel?

Sometimes a little help goes a long way. Get in touch for personalized support and keep your development process on track.

Setting Up Soft Delete In Laravel

In addition to actually removing records from your database, Eloquent can also “soft delete” models. When Soft Delete is set on a Migration, a deleted_at column is created in the database like so.

$table->softDeletes();

The above line will be added to the up() function of a migration. This function is run when the database is being migrated. The down() function is run when the migration is being rolled back.

How Soft Delete works In Laravel

When models are soft deleted, they are not actually removed from your database. Instead, a timestamp is set on the deleted_at column. If a model has a non-null deleted_at value, the model has been soft deleted.

use Illuminate\Database\Eloquent\SoftDeletes;
 
class Posts extends Model
{
    use SoftDeletes;
    public $timestamps = true;
    protected $fillable = [
        'display_name',
        'slug',
        'description',
        'meta_information_id',
        'created_by',
        'updated_by',
    ];
}

In the above snippet of code, Eloquent \ SoftDeletes will have to be imported and Used in the Posts Model.

The Issue

Laravel Request Validation has a unique validation which validates that the provided column does not already exist in the provided table. In the request, the ‘slug’ parameter will have to be unique as it will be used for URL of the Post.

The issue is that when you have a SoftDeleted post with slug=”abc” and you create a new post with slug=”abc”, the unique validation in the request will fail.

Even when the post has been deleted by using SoftDelete which is a part of Eloquent, this deleted post is not ignored by the Unique validation and will give an error stating that a Post with this slug already exists.

I faced this issue in two places.

Case I:

The first case was a regular Request file. Where I had specified an array of all the validations. In this, the deleted option was not being ignored while checking for unique.

use App\Http\Requests\Request;
 
class CreatePostRequest extends Request
{
    $id = $this->route('post');
    public function rules()
    {
        return [
     'display_name' => 'required|min:3',
            'slug' => "required|unique:post,slug,{$id}",
            'description' => 'required',
            'meta_information_id' => 'required',
        ];
    }
}

It looked something like above.

Case II:

The second was a custom validation in which space was to be ignored while validating unique which was not possible through normal unique validation. In this function, I was modifying the slug to fit my needs and then validating unique.

Validator::extend('uniquenospace', function ($attribute, $value, $parameters) {
            $value = str_replace(' ', '', $value);
            $value = strtolower($value);
            $queries = DB::table($parameters[0])->selectRaw("id,lower(REPLACE({$parameters[1]}, ' ', '')) as {$parameters[1]}");
            for ($i = 3; $i < count($parameters); $i = $i + 2) {
                $queries->where($parameters[$i], $parameters[$i + 1]);
            }
            $queries = $queries->get();
            foreach ($queries as $query) {
                if ($value == $query->$parameters[1] && $query->id != $parameters[2]) {
                    return false;
                }
            }
 
            return true;
        }, 'The :attribute already exists.');

I was hard pressed to find a solution to this problem. I was at my wit’s end and was going to remove Soft Deletes altogether. I finally found a solution to this by passing a deleted_at as null along with other array data.

The Solution for Case I:

use App\Http\Requests\Request;
 
class CreatePostRequest extends Request
{
    $id = $this->route('post');
    public function rules()
    {
        return [
     'display_name'  => 'required|min:3',
            'slug' => "required|unique:post,slug,{$id},id,deleted_at,NULL",
            'description' => 'required',
            'meta_information_id' => ‘required’,
        ];
    }
}

In a normal Request file in Laravel, we will need to add another parameter to the request unique. This will check if a value was unique in the pool when ‘deleted_at’ was null thus ignoring soft- deleted sets of data.

The Solution for Case II:

Validator::extend('uniquenospace', function ($attribute, $value, $parameters) {
            $value = str_replace(' ', '', $value);
            $value = strtolower($value);
            $queries = DB::table($parameters[0])->selectRaw("id,lower(REPLACE({$parameters[1]}, ' ', '')) as {$parameters[1]}")->where('deleted_at', null);
            for ($i = 3; $i < count($parameters); $i = $i + 2) {
                $queries->where($parameters[$i], $parameters[$i + 1]);
            }
            $queries = $queries->get();
            foreach ($queries as $query) {
                if ($value == $query->$parameters[1] && $query->id != $parameters[2]) {
                    return false;
                }
            }
            return true;
        }, 'The :attribute already exists.');
 

For custom validation, we are getting all records and comparing them with the current slug in the request. Here we can directly select only those rows where deleted_at = NULL so as to filter out deleted results.

If one wants to keep such a filtering optional, then it can be passed to the “uniquenospace” custom validation and handled in the validation. It would work just like the normal validation. If deleted_at, NULL is passed then only the deleted rows will be ignored.

With these adjustments, handling unique validations with soft deletes in Laravel becomes much more straightforward. If you need more guidance or have specific questions, feel free to reach out to our experts and ensure your Laravel projects run smoothly.