[12.x] Add $deleteWhenMissingModels support for queued notifications

src/Illuminate/Notifications/SendQueuedNotifications.php

@@ -65,6 +65,13 @@ class SendQueuedNotifications implements ShouldQueue
      */
     public $shouldBeEncrypted = false;
 
+    /**
+     * Indicates if the job should be deleted when models are missing.
+     *
+     * @var bool
+     */
+    public $deleteWhenMissingModels = false;
+
     /**
      * Create a new job instance.
      *
@@ -81,6 +88,10 @@ public function __construct($notifiables, $notification, ?array $channels = null
         $this->timeout = property_exists($notification, 'timeout') ? $notification->timeout : null;
         $this->maxExceptions = property_exists($notification, 'maxExceptions') ? $notification->maxExceptions : null;
 
+        $this->deleteWhenMissingModels = property_exists($notification, 'deleteWhenMissingModels')
+            ? $notification->deleteWhenMissingModels
+            : false;
+
         if ($notification instanceof ShouldQueueAfterCommit) {
             $this->afterCommit = true;
         } else {

src/Illuminate/Queue/CallQueuedHandler.php

@@ -15,6 +15,7 @@
 use Illuminate\Contracts\Queue\ShouldBeUniqueUntilProcessing;
 use Illuminate\Database\Eloquent\ModelNotFoundException;
 use Illuminate\Log\Context\Repository as ContextRepository;
+use Illuminate\Notifications\SendQueuedNotifications;
 use Illuminate\Pipeline\Pipeline;
 use Illuminate\Queue\Attributes\DeleteWhenMissingModels;
 use ReflectionClass;
@@ -229,10 +230,16 @@ protected function handleModelNotFound(Job $job, $e)
         $class = $job->resolveQueuedJobClass();
 
         try {
-            $reflectionClass = new ReflectionClass($class);
+            $shouldDelete = $this->shouldDeleteWhenMissingModels($class);
 
-            $shouldDelete = $reflectionClass->getDefaultProperties()['deleteWhenMissingModels']
-                ?? count($reflectionClass->getAttributes(DeleteWhenMissingModels::class)) !== 0;
+            if (! $shouldDelete && $class === SendQueuedNotifications::class) {
+                $payload = $job->payload();
+                $notificationClass = $payload['displayName'] ?? null;
+
+                if ($notificationClass && class_exists($notificationClass)) {
+                    $shouldDelete = $this->shouldDeleteWhenMissingModels($notificationClass);
+                }
+            }
         } catch (Exception) {
             $shouldDelete = false;
         }
@@ -246,6 +253,20 @@ protected function handleModelNotFound(Job $job, $e)
         return $job->fail($e);
     }
 
+    /**
+     * Determine if the job should be deleted when models are missing.
+     *
+     * @param  string  $class
+     * @return bool
+     */
+    protected function shouldDeleteWhenMissingModels(string $class)
+    {
+        $reflectionClass = new ReflectionClass($class);
+
+        return $reflectionClass->getDefaultProperties()['deleteWhenMissingModels']
+            ?? count($reflectionClass->getAttributes(DeleteWhenMissingModels::class)) !== 0;
+    }
+
     /**
      * Ensure the lock for a unique job is released via context.
      *

tests/Integration/Queue/DeleteNotificationWhenMissingModelTest.php

@@ -0,0 +1,137 @@
+<?php
+
+namespace Illuminate\Tests\Integration\Queue;
+
+use Illuminate\Bus\Queueable;
+use Illuminate\Contracts\Queue\ShouldQueue;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Notifications\Notifiable;
+use Illuminate\Notifications\Notification;
+use Illuminate\Support\Facades\Schema;
+use Orchestra\Testbench\Attributes\WithMigration;
+
+#[WithMigration]
+#[WithMigration('queue')]
+class DeleteNotificationWhenMissingModelTest extends QueueTestCase
+{
+    protected function defineEnvironment($app)
+    {
+        parent::defineEnvironment($app);
+        $app['config']->set('queue.default', 'database');
+        $this->driver = 'database';
+    }
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        Schema::create('notification_test_models', function (Blueprint $table) {
+            $table->id();
+            $table->string('name');
+        });
+    }
+
+    protected function tearDown(): void
+    {
+        DeleteMissingModelNotification::$handled = false;
+        FailingMissingModelNotification::$handled = false;
+        Schema::dropIfExists('notification_test_models');
+
+        parent::tearDown();
+    }
+
+    public function test_deleteWhenMissingModels_deletes_job_when_true(): void
+    {
+        $model = NotificationTestModel::query()->create(['name' => 'test']);
+
+        $notifiable = new TestNotifiableUser;
+        $notifiable->notify(new DeleteMissingModelNotification($model));
+
+        NotificationTestModel::query()->where('name', 'test')->delete();
+
+        $this->runQueueWorkerCommand(['--once' => '1']);
+
+        $this->assertFalse(DeleteMissingModelNotification::$handled);
+        $this->assertNull(\DB::table('failed_jobs')->first());
+    }
+
+    public function test_deleteWhenMissingModels_fails_job_when_false(): void
+    {
+        $model = NotificationTestModel::query()->create(['name' => 'test']);
+
+        $notifiable = new TestNotifiableUser;
+        $notifiable->notify(new FailingMissingModelNotification($model));
+
+        NotificationTestModel::query()->where('name', 'test')->delete();
+
+        $this->runQueueWorkerCommand(['--once' => '1']);
+
+        $this->assertFalse(FailingMissingModelNotification::$handled);
+        $this->assertNotNull(\DB::table('failed_jobs')->first());
+    }
+}
+
+class NotificationTestModel extends Model
+{
+    protected $table = 'notification_test_models';
+
+    public $timestamps = false;
+
+    protected $guarded = [];
+}
+
+class TestNotifiableUser
+{
+    use Notifiable;
+}
+
+class DeleteMissingModelNotification extends Notification implements ShouldQueue
+{
+    use Queueable;
+
+    public static bool $handled = false;
+
+    public $deleteWhenMissingModels = true;
+
+    public function __construct(public NotificationTestModel $model)
+    {
+    }
+
+    public function via($notifiable): array
+    {
+        return ['mail'];
+    }
+
+    public function toArray($notifiable): array
+    {
+        self::$handled = true;
+
+        return ['model_id' => $this->model->id];
+    }
+}
+
+class FailingMissingModelNotification extends Notification implements ShouldQueue
+{
+    use Queueable;
+
+    public static bool $handled = false;
+
+    public $deleteWhenMissingModels = false;
+
+    public function __construct(public NotificationTestModel $model)
+    {
+    }
+
+    public function via($notifiable): array
+    {
+        return ['mail'];
+    }
+
+    public function toArray($notifiable): array
+    {
+        self::$handled = true;
+
+        return ['model_id' => $this->model->id];
+    }
+}

tests/Notifications/NotificationSendQueuedNotificationTest.php

@@ -60,6 +60,19 @@ public function testNotificationCanSetMaxExceptions()
 
         $this->assertEquals(23, $job->maxExceptions);
     }
+
+    public function testNotificationCanSetDeleteWhenMissingModels()
+    {
+        $notifiable = new NotifiableUser;
+        $notification = new class
+        {
+            public $deleteWhenMissingModels = true;
+        };
+
+        $job = new SendQueuedNotifications($notifiable, $notification);
+
+        $this->assertTrue($job->deleteWhenMissingModels);
+    }
 }
 
 class NotifiableUser extends Model