fixing conflicts

ChainedBatch.php

@@ -0,0 +1,130 @@
+<?php
+
+namespace Illuminate\Bus;
+
+use Illuminate\Container\Container;
+use Illuminate\Contracts\Bus\Dispatcher;
+use Illuminate\Contracts\Queue\ShouldQueue;
+use Illuminate\Foundation\Bus\Dispatchable;
+use Illuminate\Queue\InteractsWithQueue;
+use Illuminate\Support\Collection;
+use Throwable;
+
+class ChainedBatch implements ShouldQueue
+{
+    use Batchable, Dispatchable, InteractsWithQueue, Queueable;
+
+    /**
+     * The collection of batched jobs.
+     *
+     * @var \Illuminate\Support\Collection
+     */
+    public Collection $jobs;
+
+    /**
+     * The name of the batch.
+     *
+     * @var string
+     */
+    public string $name;
+
+    /**
+     * The batch options.
+     *
+     * @var array
+     */
+    public array $options;
+
+    /**
+     * Create a new chained batch instance.
+     *
+     * @param  \Illuminate\Bus\PendingBatch  $batch
+     * @return void
+     */
+    public function __construct(PendingBatch $batch)
+    {
+        $this->jobs = static::prepareNestedBatches($batch->jobs);
+
+        $this->name = $batch->name;
+        $this->options = $batch->options;
+    }
+
+    /**
+     * Prepare any nested batches within the given collection of jobs.
+     *
+     * @param  \Illuminate\Support\Collection  $jobs
+     * @return \Illuminate\Support\Collection
+     */
+    public static function prepareNestedBatches(Collection $jobs): Collection
+    {
+        return $jobs->map(fn ($job) => match (true) {
+            is_array($job) => static::prepareNestedBatches(collect($job))->all(),
+            $job instanceof Collection => static::prepareNestedBatches($job),
+            $job instanceof PendingBatch => new ChainedBatch($job),
+            default => $job,
+        });
+    }
+
+    /**
+     * Handle the job.
+     *
+     * @return void
+     */
+    public function handle()
+    {
+        $batch = new PendingBatch(Container::getInstance(), $this->jobs);
+
+        $batch->name = $this->name;
+        $batch->options = $this->options;
+
+        if ($this->queue) {
+            $batch->onQueue($this->queue);
+        }
+
+        if ($this->connection) {
+            $batch->onConnection($this->connection);
+        }
+
+        $this->dispatchRemainderOfChainAfterBatch($batch);
+
+        foreach ($this->chainCatchCallbacks ?? [] as $callback) {
+            $batch->catch(function (Batch $batch, ?Throwable $exception) use ($callback) {
+                if (! $batch->allowsFailures()) {
+                    $callback($exception);
+                }
+            });
+        }
+
+        $batch->dispatch();
+    }
+
+    /**
+     * Move the remainder of the chain to a "finally" batch callback.
+     *
+     * @param  \Illuminate\Bus\PendingBatch  $batch
+     * @return
+     */
+    protected function dispatchRemainderOfChainAfterBatch(PendingBatch $batch)
+    {
+        if (! empty($this->chained)) {
+            $next = unserialize(array_shift($this->chained));
+
+            $next->chained = $this->chained;
+
+            $next->onConnection($next->connection ?: $this->chainConnection);
+            $next->onQueue($next->queue ?: $this->chainQueue);
+
+            $next->chainConnection = $this->chainConnection;
+            $next->chainQueue = $this->chainQueue;
+            $next->chainCatchCallbacks = $this->chainCatchCallbacks;
+
+            $batch->finally(function (Batch $batch) use ($next) {
+                if (! $batch->cancelled()) {
+                    Container::getInstance()->make(Dispatcher::class)->dispatch($next);
+                }
+            });
+
+            $this->chained = [];
+        }
+    }
+}

Dispatcher.php

@@ -163,6 +163,7 @@ public function batch($jobs)
     public function chain($jobs)
     {
         $jobs = Collection::wrap($jobs);
+        $jobs = ChainedBatch::prepareNestedBatches($jobs);
 
         return new PendingChain($jobs->shift(), $jobs->toArray());
     }