SoftDeletingScope override

trait AvoidDuplicateConstraintSoftDelete
{
    public static function bootAvoidDuplicateConstraintSoftDelete()
    {
        static::observe(app(UniqueSoftDeleteObserver::class));
    }

    public function getDuplicateAvoidColumns() : array
    {
        return [];
    }
}

class UniqueSoftDeleteObserver
{
    private const DELIMITER = '-#-';

    public function restoring(Model $model)
    {
        if (!$model->trashed()) {
            return;
        }

        foreach ($model->getDuplicateAvoidColumns() as $column) {
            if ($value = (explode(self::DELIMITER, $model->{$column})[1] ?? null)) {
                $model->{$column} = $value;
            }
        }
    }

    public function deleted(Model $model)
    {
        if (!$model->isForceDeleting()) {
            self::mutateColumns($model);
        }
    }

    public static function mutateColumns(Model $model)
    {
        foreach ($model->getDuplicateAvoidColumns() as $column) {
            if (!empty($model->{$column})) {
                $newValue = uniqid() . self::DELIMITER . $model->{$column};
                $model->{$column} = $newValue;
            }
        }

        $model->save();
    }

    public static function restoreColumns(Model $model)
    {
        if (!$model->trashed()) {
            return;
        }

        foreach ($model->getDuplicateAvoidColumns() as $column) {
            if ($value = (explode(self::DELIMITER, $model->{$column})[1] ?? null)) {
                $model->{$column} = $value;
            }
        }

        $model->save();
    }
}

than in your model:

class User extends Model
{
    use HasFactory,
        SoftDeletes,
        AvoidDuplicateConstraintSoftDelete;

  public function getDuplicateAvoidColumns(): array
  {
        return [
            'email',
        ];
  }

now each column defined in getDuplicateAvoidColumns will be mutated to avoid unique constraints, and on restore it will be mutated back to it's original value.

@playing_life This is how you can set a default value.

Schema::table('your_table_name', function (Blueprint $table) {
    $table->timestamp('deleted_at')->default('1970-01-02 00:00:00');
});

It could be that I still need to polish this but the solution I have found is using the timestamp 1970-01-02 00:00:00 instead of the value Null.

Create file App\Http\Traits\CustomSoftDeleteTrait.php

and

Create file App\Models\Scopes\CustomSoftDeletingScope.php

CustomSoftDeleteTrait.php

namespace App\Http\Traits;
use Illuminate\Database\Eloquent\SoftDeletes;
use App\Models\Scopes\CustomSoftDeletingScope;

trait CustomSoftDeletesTrait{
    use SoftDeletes;
    public static function bootSoftDeletes(){
        static::addGlobalScope(new CustomSoftDeletingScope);
    }

    //Override
    protected function restore(){
        if ($this->fireModelEvent('restoring') === false) {
            return false;
        }
        //Changed from original
        $this->{$this->getDeletedAtColumn()} = '1970-01-02 00:00:00';
        //End of change
        $this->exists = true;
        $result = $this->save();
        $this->fireModelEvent('restored', false);
        return $result;
    }

    //Override
    protected function trashed()
    {
        //Changed from original
        return ($this->{$this->getDeletedAtColumn()}) != '1970-01-02 00:00:00';
        //End of change
    }
}

CustomSoftDeletingScope.php

namespace App\Models\Scopes;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Scope;
use Illuminate\Database\Eloquent\SoftDeletingScope;

class CustomSoftDeletingScope extends SoftDeletingScope implements Scope{
    public function apply(Builder $builder, Model $model){
        $builder->where($model->getQualifiedDeletedAtColumn(), '1970-01-02 00:00:00');
    }

    protected function addWithoutTrashed(Builder $builder){
        $builder->macro('withoutTrashed', function (Builder $builder) {
            $model = $builder->getModel();
            $builder->withoutGlobalScope($this)->where($model->getQualifiedDeletedAtColumn(), '1970-01-02 00:00:00');
            return $builder;
        });
    }
}

in migration use virtualAs() concat the columns and set it to invisable

Another way, which I think it's better, is to create a calculated field called deleted_at which would calculate from the Laravel deleted_at field and instead on NULL to save the string "NULL". Then the deleted_at_calculated field can be added to unique constraints.