Add saveQuietlyOrFail(), updateQuietlyOrFail(), deleteQuietlyOrFail() to Eloquent Model

[Anne-Willems]

I would like to propose a small improvement for Eloquent models.
There is already a identical discussion: #41283
But that one is a few years old and lacks the code suggestions.

Laravel currently has:

• saveQuietly()
• saveOrFail()
• updateQuietly()
• updateOrFail()
• deleteQuietly()
• deleteOrFail()

But there is no quiet variant for: 'saveOrFail' & 'updateOrFail' & 'deleteOrFail.
Because of that, when you want both behaviors together, you currently need to write:

Model::withoutEvents(fn () => $model->saveOrFail());

Model::withoutEvents(fn () => $model->updateOrFail());

Model::withoutEvents(fn () => $model->deleteOrFail());

A dedicated method would make this cleaner and more expressive.

Suggested name:

• saveQuietlyOrFail()
• updateQuietlyOrFail()
• deleteQuietlyOrFail()

Possible implementation:

File: laravel/framework/src/Illuminate/Database/Eloquent/Model.php

public function saveQuietlyOrFail(array $options = [])
{
     return static::withoutEvents(fn () => $this->saveOrFail($options));
}

public function updateQuietlyOrFail(array $attributes = [], array $options = [])
{
     if (! $this->exists) {
         return false;
     }

     return $this->fill($attributes)->saveQuietlyOrFail($options);
}

public function deleteQuietlyOrFail()
{
     if (! $this->exists) {
         return false;
     }

     return static::withoutEvents(fn () => $this->deleteOrFail());
}

Reasoning:

• it follows the existing saveQuietly() naming first.
• it reads naturally as “save quietly, or fail”
• it makes the intent very explicit
• If you want to save things 'quietly' there is a good chance you also want the fail behaviour.
• Since the large amount of eloquent methods added lately these are a good add-on.

[Pola5h]

One small suggestion for deleteQuietlyOrFail() — the exists check is already handled inside deleteOrFail(), so it may be redundant here. Keeping it consistent with how deleteOrFail() works internally would be cleaner:

public function deleteQuietlyOrFail()
{
    return static::withoutEvents(fn () => $this->deleteOrFail());
}

Also worth considering — a forceDeleteQuietlyOrFail() for soft-deletable models, following the same pattern:

public function forceDeleteQuietlyOrFail()
{
    return static::withoutEvents(fn () => $this->forceDeleteOrFail());
}

Overall, this is a clean, consistent addition. The naming reads naturally, the implementation is minimal, and it fills a real gap. The current workaround of wrapping manually in withoutEvents() is easy to forget and less expressive.

+1 from me, would love to see this in the framework.