Run code after all deleted event

@tisuchi But is there any way able internal trigger in Observer instead of put the caller everywhere?

delete one record also need reorder

delete multiple records also need reorder

i'm looking for something like this https://laravel.com/docs/12.x/queues#dispatching-after-the-response-is-sent-to-browser

@newbie360 Then you can try this:

in your model observer (YourModelObserver):

use Illuminate\Support\Facades\Queue;

class YourModelObserver
{
    protected static bool $queued = false;

    public function deleted(YourModel $model): void
    {
        if (! static::$queued) {
            static::$queued = true;

            Queue::afterResponse(function () {
                YourModel::reorderColumn();
                static::$queued = false;
            });
        }
    }
}

After that Add the reorderColumn() method to your model:

public static function reorderColumn(): void
{
    $ordered = self::orderBy('order_column')->get();

    foreach ($ordered as $index => $item) {
        $item->updateQuietly(['order_column' => $index + 1]);
    }
}

@tisuchi I guess your code should work, but i need some time to make changes to meet my use case =) i will report back soon

tags table

| id | tag_category_id | name | order_column |
| -- | --------------- | ---- | ------------ |
| 1  |       1         | aa   |      1       |
| 2  |       1         | bb   |      2       |
| 3  |       2         | xx   |      1       |
| 4  |       2         | yy   |      2       |

    protected static function booted(): void
    {
        static::creating(function (Tag $tag) {
            static $tagCategoryId = 0;
            static $maxOrder = self::getMaxOrderByTagCategoryId($tag->tag_category_id);

            // Marker
            if ($tagCategoryId !== $tag->tag_category_id) {
                $tagCategoryId = $tag->tag_category_id;
                $maxOrder = 0;
            }

            $tag->order_column = ++$maxOrder;
        });

        // Prevent change `tag_category_id` cause duplicate `order_column`
        static::updating(function (Tag $tag) {
            if ($tag->isDirty('tag_category_id')) {
                static $maxOrder = self::getMaxOrderByTagCategoryId($tag->tag_category_id);

                $tag->order_column = ++$maxOrder;
            }
        });
    }

    /**
     * Get the max value of `order_column` by the `tag_category_id`.
     */
    public static function getMaxOrderByTagCategoryId(int $tagCategoryId): int
    {
        return once(function () use ($tagCategoryId) {
            $maxOrder = self::query()
                ->where('tag_category_id', $tagCategoryId)
                ->max('order_column');

            return $maxOrder ?? 0;
        });
    }

I fall in a trap, actually i want use once() helper to reduce the number of query when use factory

in all my Tests is passed, BUT after read again the above creating event, go to the Web UI create a new tag for the tag_category_id 1, the order_column always is 1, because the //Marker

        // TODO: reduce the number of query when use factory
        static::creating(function (Tag $tag) {
            $maxOrder = self::getMaxOrderBy($tag->tag_category_id);

            $tag->order_column = $maxOrder + 1;
        });

    /**
     * Get the max value of `order_column` by the `tag_category_id`.
     */
    public static function getMaxOrderBy(int $tagCategoryId): int
    {
        $maxOrder = self::query()
            ->where('tag_category_id', $tagCategoryId)
            ->max('order_column');

        return $maxOrder ?? 0;
    }

@tisuchi Call to undefined method Illuminate\Queue\DatabaseQueue::afterResponse()

            Queue::afterResponse(function () {
                YourModel::reorderColumn();
                static::$queued = false;
            });

tags table (bulk delete)

| id | tag_category_id | name | order_column |
| -- | --------------- | ---- | ------------ |
| 1  |       1         | aa   |      1       | delete
| 2  |       1         | bb   |      2       |
| 3  |       2         | xx   |      1       | delete
| 4  |       2         | yy   |      2       | delete
| 5  |       2         | zz   |      3       |

so far i working on this

class Tag extends Model
{
    // use array instead of bool
    // because possible delete different `tag_category_id` in the same request,
    protected static array $queued = [];

    protected static function booted(): void
    {
        static::deleted(function (Tag $tag) {
            info('tag_category_id ' . $tag->tag_category_id);

            if (! in_array($tag->tag_category_id, static::$queued)) {
                static::$queued[] = $tag->tag_category_id;

                info('new array', static::$queued);

                dispatch(function () {
                    self::reorderColumnBy(static::$queued);

                    static::$queued = [];
                })->afterResponse();
            }
        });
    }

    public static function reorderColumnBy(array $queued): void
    {
        info('reorder tag_category_id', $queued);
    }

laravel.log , added line break for easy understand the behavior

local.INFO: tag_category_id 1  
local.INFO: new array [1] 

local.INFO: tag_category_id 2  
local.INFO: new array [1,2] 

local.INFO: tag_category_id 2  

local.INFO: reorder tag_category_id [1,2] 
local.INFO: reorder tag_category_id

it works, but only the problem is dispatch fired two times, any idea to fire once only?