Nova and Action Job Batching

[FSElias]

In https://nova.laravel.com/docs/4.0/actions/defining-actions.html#job-batching, it is not showing clearly how to add a job to a batch through

public function handle(ActionFields $fields, Collection $models)

or at least pass the $models collection to

public function withBatch(ActionFields $fields, PendingBatch $batch)

I need to send emails to each selected user and get notified that the batch has been finished after all the emails are sent.

[juse-less]

Regarding

I need to send emails to each selected user and get notified that the batch has been finished after all the emails are sent.

I'm not sure if I misunderstand the question, but if you look in the withBatch() method that your link goes to, you can see it providing all 3 methods to handle finished and failed batches, as well as, 'finally', which is always run after all jobs in a batch has been attempted (regardless of outcome).
As you can see by the example DocBlock for that method (withBatch()), the PendingBatch is from Laravel itself, so the same logic for batches applies, just like it does in Laravel.

[FSElias]

Here is a simple Nova Action I did to show my point of view

//app/Nova/Actions/EmailUser.php

namespace App\Nova\Actions;

use Illuminate\Bus\Batch;
use Illuminate\Bus\Batchable;
use Illuminate\Bus\PendingBatch;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
use Illuminate\Support\Collection;
use Laravel\Nova\Actions\Action;
use Laravel\Nova\Contracts\BatchableAction;
use Laravel\Nova\Fields\ActionFields;
use Laravel\Nova\Http\Requests\NovaRequest;
use Throwable;

class EmailUser extends Action implements BatchableAction, ShouldQueue
{
    use Batchable, InteractsWithQueue, Queueable, SerializesModels;

    protected Collection $models;

    /**
     * Prepare the given batch for execution.
     *
     * @param  \Laravel\Nova\Fields\ActionFields  $fields
     * @param  \Illuminate\Bus\PendingBatch  $batch
     * @return void
     */
    public function withBatch(ActionFields $fields, PendingBatch $batch)
    {

//Accessing resourceIDs throws "Undefined property: Illuminate\Bus\PendingBatch::$resourceIds", exception
        //dd($batch->resourceIds);

//Accessing $this->>models throws "Typed property App\Nova\Actions\EmailUser::$models must not be accessed before initialization"
        //dd($this->models);


        $batchArray = [];
        foreach ($this->models as $model){
            $batchArray[]= new \App\Jobs\MailUserJob($model);
        }

        $batch->add($batchArray);


        $batch->then(function (Batch $batch) {
            // All jobs completed successfully...

            $selectedModels = $batch->resourceIds;
        })->catch(function (Batch $batch, Throwable $e) {
            // First batch job failure detected...
        })->finally(function (Batch $batch) {
            // The batch has finished executing...
        })->allowFailures();
    }

    /**
     * Perform the action on the given models.
     *
     * @param  \Laravel\Nova\Fields\ActionFields  $fields
     * @param  \Illuminate\Support\Collection  $models
     * @return mixed
     */
    public function handle(ActionFields $fields, Collection $models)
    {
        $this->models = $models;
    }

    /**
     * Get the fields available on the action.
     *
     * @param  \Laravel\Nova\Http\Requests\NovaRequest  $request
     * @return array
     */
    public function fields(NovaRequest $request)
    {
        return [];
    }
}

[juse-less]

Yes. I actually step-debugged and noticed that withBatch() is executed before handle().
But when you think about it, this also makes a lot of sense.
When the Action implements ShouldQueue.
Using ShouldQueue, the withBatch() will be called when the user presses the button in modal.
This is because the Batch hasn't yet been dispatched.
Once the Action is run in the queue worker, this is where the handle() method is called.

I don't need the Action to run on the queue, just my Batches.
So, I removed ShouldQueue, and kept it Batchable.
Because I use standalone Actions, and never really on any Models, I can queue the additional jobs in the withBatch() method.
Since you need the Models, however, this becomes tricky in my experience (but hopefully the Nova developers can shed some light).

As I was step-debugging I realised that.. the $batchId is never set, making Laravel's Batchable trait a bit useless, since it relies on that property.
Nova does use $actionBatchId, but this is the Actions 'internal' UUID, and not the Laravel Batch UUID.
I actually compared that output with the UUID registered in the database for the Batches.

Looking through Nova's code, however, I think this could be solved altogether by also adding the $batchId in Actions\CallQueuedAction::handle().
The reason is that the wrapping 'job' (CallQueuedAction), as it's popped on the queue, will receive the $batchId, as the trait it uses (CallsQueuedActions) in turn uses Laravel's Batchable, as well.
That way we can sort of.. snatch the batch UUID from that one, and pop it into the Action like below.

/**
 * Execute the job.
 *
 * @return void
 */
public function handle()
{
    $this->callAction(function ($action) {
        $action->withActionBatchId($this->actionBatchId);

        if (in_array(Batchable::class, class_uses_recursive(get_class($action)))) {
            $action->withBatchId($this->batchId);
        }

        return $action->{$this->method}($this->fields, $this->models);
    });
}

// ---

// Your Actions `handle()`
public function handle()
{
    if ($this->batching()) {
        $this->batch(); // Batch instance
    }
}

I haven't tested to change this in my vendor directory, but that was my interpretation could fix it (by reading most of the Action code, looking for Batch references).
Also note - I wrote this entire block in the GitHub comment box, so there's probably error(s) somewhere.

Apologies for bouncing back and forth.. but to answer

//Accessing resourceIDs throws "Undefined property: Illuminate\Bus\PendingBatch::$resourceIds", exception

This is because the $resourceIds are present on the Batch, and not PendingBatch.
So you'd need to access them inside $batch->then(). Possibly also exists in $batch->catch(), and $batch->finally(), respectively.

---

Like I said, I could definitely be wrong, but that was the quick conclusion I could make with prior experience trying to get the Batch working in handle(), and the quick debugging I did now.
I can quickly post a standalone Action example next week, possibly, which uses the withBatch(), if it would help.

---

Edit:

Looking through Nova's code, however, I think this could be solved altogether by also adding the $batchId in Actions\CallQueuedAction::handle().

On a second thought, not 'altogether'. I think the Action would still need to implement ShouldQueue. If it doesn't, Laravel won't queue it, and therefore you might miss the $batchId property.
But.. for those Actions that does implement ShouldQueue, it looks like it could work.

[FSElias]

Thank you, I think Nova's batchable action is not mature enough and the documentation is a little bit ambiguous, so for now I'll use https://laravel.com/docs/9.x/queues#dispatching-batches inside the action's handle. I have spent so much time on this issue thinking I have missed something, really appreciate your time.

[juse-less]

I've spent a few hours today, further digging in to this now.

Like mentioned earlier, $batchId is actually never set on the Action.
Laravel does set it on the \Laravel\Nova\Actions\CallQueuedAction, as it's the Job that Nova queues up, which is then wrapping the Action itself.
So, currently, using the Batchable trait on the Action won't do anything as the $batchId is never set, and therefore none of the methods are currently usable, as they require the $batchId to actually return/handle the Batch it belongs to.
A side note on this: if we search through Nova's entire code base, there's no reference to $batchId (or ->batchId, withBatchId, etc) for the Action, which should be needed since \Laravel\Nova\Actions\CallQueuedAction wraps it.

Upon further granular testing, I was able to confirm my theory in an earlier message in this discussion

On a second thought, not 'altogether'. I think the Action would still need to implement ShouldQueue. If it doesn't, Laravel won't queue it, and therefore you might miss the $batchId property.
But.. for those Actions that does implement ShouldQueue, it looks like it could work.

This is also perfectly fine as this is how Laravel is designed. Besides - we need to dispatch the Batch in order to get an ID in the first place.

I also tested my code snippet in an earlier message in this discussion, albeit slightly modified.

// `\Laravel\Nova\Actions\CallQueuedAction::handle()` (line 48-56 in Nova 4.13)
$this->callAction(function ($action) {
    if (\in_array(Batchable::class, \class_uses_recursive($action))) {
        $action->withBatchId($this->batchId);
    }

    return $action->withActionBatchId($this->actionBatchId)->{$this->method}($this->fields, $this->models);
});

This makes it work, and I haven't seen any side effects so far.
I'm able to simply

// TestQueuedAction

public function handle()
{
    if ($this->batching()) {
        $this->batch()->add(new TestBatchJob);
    }
}

TestQueuedAction::handle() will be run when the queue works on the Job, and the TestBatchJob will be queued up at that moment.
Just like Laravel's documentation shows around using Jobs to queue other Jobs as part of a Batch.

I've commited the repo I used to test things.
In the repo root there's also a directory called 'issue-details', which should be fairly straight forward with before/after various steps.
Each directory contains log output and screenshots from the database I used.
To quickly find the actual output location in the code, you can look for TODO: Check output, which is right above each call to the log.
Since the 'fix' needs to be applied to Nova itself, you'll need to apply my code snippet at the location mentioned earlier in this message.

I'm not sure if I should keep this message here, start a feature request, or file a bug report.
But the documentation does mention

In addition, the action should use the Illuminate\Bus\Batchable trait.

Sorry for pinging, but, @crynobone or @davidhemphill could maybe give me a pointer, if I should post elsewhere, or so.

[juse-less]

@FSElias This has now been implemented, in Nova 4.14. 🙂

I haven't tested it yet, but we should now be able to access the Batch in the Action's handle()method.