How To: Process multiple different jobs as chunks & chain them by type

In step two you can detect if the chunk is last. If it is last chunk then send boolean flag to that last job that it should fire new job which will then pick up where things were left off. Same applies for following jobs. Only dispatch them when the current is finished.

Thanks @bugsysha meanwhile I came up with this:

DB::table('temporary_platform_reports')
          ->where('platform', $event->platformName)
          ->whereNull('processed')
          ->chunkById(100, function ($stats) {
              array_push($this->importJobs, new ImportPlatformReports($stats));
          });

        // grab first job from array to use in dispatch
        $firstJob = array_shift($this->importJobs);

        // dispatch import job chain
        dispatch($firstJob)->chain([
            $this->importJobs,
            new FirePlatformReportImportCompletedEvent,
        ]);

<?php

namespace App\Jobs;

use App\Events\PlatformReportImportCompleted;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;

class FirePlatformReportImportCompletedEvent
{

    /**
     * Create a new job instance.
     *
     * @return void
     */
    public function __construct()
    {
        //
    }

    /**
     * Execute the job.
     *
     * @return void
     */
    public function handle()
    {
        event(new PlatformReportImportCompleted);
    }
}

This seems to be doing what I wanted, basically I simply chain the first job type, then at the end execute a simple non-queueable job that fires an event and triggers the next listener and so forth.

You think this should work well?

Isn't chain dispatching events that you provide when the current/previous is successful? If so then FirePlatformReportImportCompletedEvent should be dispatched as many times as you have successful jobs.

No, the chain executes in order and only if all previous jobs completed successfully. So the Job which triggers an event is only executed once.

So far it seems to do exactly what I wanted

OK. Then there is no reason not to push all jobs to chain straight away. Why do you need a job which fires an event which then listeners picks up to dispatch more jobs?

Because all of the 5 steps are depending on each other, and each step needs the data created in the previous step. So I cannot simply throw it all in the queue but have to make sure the required data exists. Does that makes sense? :)

Yeah it does make sense. Just seems like a unnecessary step. But on top of my mind I can not think of any other approach which might be cleaner. Maybe I had too much for lunch and now there is no blood reaching my brain.