fix: Ensure consistent task finalization for queued tasks (TaskError and TaskProcessed events)

src/Tasks/Middleware/FinalizeTaskMiddleware.php

@@ -5,13 +5,38 @@
 namespace Brain\Tasks\Middleware;
 
 use Brain\Task;
+use Brain\Tasks\Events\Error as TasksError;
+use Illuminate\Support\Facades\Context;
+use Throwable;
 
 final class FinalizeTaskMiddleware
 {
+    /**
+     * @throws Throwable
+     */
     public function handle(Task $task, callable $next): void
     {
-        $next($task);
+        [, $runProcessId] = Context::get('process');
 
-        $task->finalize();
+        try {
+            $next($task);
+
+            $task->finalize();
+            // @codeCoverageIgnoreStart
+            // The coverage is ignored because the event doesn't dispatch event in the test environment
+        } catch (Throwable $e) {
+            $meta = [
+                'error' => $e->getMessage(),
+                'line' => $e->getLine(),
+                'file' => $e->getFile(),
+            ];
+
+            event(new TasksError(get_class($task), payload: $task->payload, runProcessId: $runProcessId, meta: $meta));
+
+            $task->fail($e);
+
+            throw $e;
+            // @codeCoverageIgnoreEnd
+        }
     }
 }

tests/Feature/TaskTest.php

@@ -7,6 +7,7 @@
 use Brain\Tasks\Events\Processed;
 use Brain\Tasks\Middleware\FinalizeTaskMiddleware;
 use Illuminate\Bus\Queueable;
+use Illuminate\Contracts\Queue\ShouldQueue;
 use Illuminate\Foundation\Bus\Dispatchable;
 use Illuminate\Foundation\Bus\PendingDispatch;
 use Illuminate\Queue\InteractsWithQueue;
@@ -450,7 +451,6 @@ public function handle(): self
 
     $middleware = new FinalizeTaskMiddleware;
 
-    // Call middleware with a next that simply returns the task
     $middleware->handle($task, fn ($t) => $t);
 
     Event::assertDispatched(Processed::class);
@@ -479,3 +479,26 @@ class ProcessWithFinalize extends Brain\Process
 
     Event::assertDispatched(Processed::class);
 });
+
+it('queued tasks are finalized before going through next middleware', function (): void {
+    Event::fake();
+
+    class QueuedTask extends Task implements ShouldQueue
+    {
+        public function handle(): self
+        {
+            return $this;
+        }
+    }
+
+    class ProcessQueuedTask extends Brain\Process
+    {
+        protected array $tasks = [
+            QueuedTask::class,
+        ];
+    }
+
+    ProcessQueuedTask::dispatchSync();
+
+    Event::assertDispatched(Processed::class);
+});