Streamline Pipeline Cleanup with Laravel's finally Method

Laravel enhances pipeline management with the introduction of the finally method, offering a more elegant approach to handling post-pipeline operations regardless of success or failure outcomes.

Managing cleanup operations in Laravel pipelines previously required wrapping pipeline logic in try-finally blocks. The new finally method integrates cleanup directly into the pipeline chain, creating more readable and maintainable code:

$result = Pipeline::send($order)
    ->through([StepOne::class, StepTwo::class])
    ->finally(fn () => /** perform cleanup */)
    ->then(fn () => $order->process());

This approach particularly shines in complex operations that require guaranteed resource cleanup:

class OrderProcessor
{
    public function process(Order $order)
    {
        return Pipeline::send($order)
            ->through([
                ValidateInventory::class,
                CalculateShipping::class,
                ProcessPayment::class,
                UpdateInventory::class
            ])
            ->finally(function () use ($order) {
                // Always release inventory holds
                InventoryManager::releaseHolds($order->id);
 
                // Clear processing lock
                Cache::forget("order-processing:{$order->id}");
 
                // Update order status timestamp
                $order->update(['processed_at' => now()]);
 
                // Send notification regardless of outcome
                event(new OrderProcessingCompleted($order));
            })
            ->then(fn () => $this->completeOrder($order));
    }
 
    protected function completeOrder(Order $order)
    {
        return [
            'status' => 'processed',
            'order_id' => $order->id,
            'total' => $order->total
        ];
    }
}

The finally method offers several advantages over traditional try-finally blocks. It maintains cleanup logic within the pipeline flow, creating more natural code progression that's easier to follow. This approach proves especially valuable when handling complex operations requiring proper resource management.