IIUC you can dispatch using the sync transport from your handler.

It won't work if the message is dispatched from a component that is used in different contexts.

If I understand your issue correctly, this should be possible using the TransportNamesStamp as per the Messenger documentation.

Something like:

# config/packages/messenger.yaml
framework:
    messenger:
        transports:
            sync: sync://
            async:
                dsn: '%env(MESSENGER_TRANSPORT_DSN)%'
        routing:
            App\Message\AMessage: async
            App\Message\BMessage: async

use Symfony\Component\Messenger\MessageBusInterface;
use Symfony\Component\Messenger\Stamp\TransportNamesStamp;

#[AsMessageHandler]
class AMessageHandler
{
    public function __construct(MessageBusInterface $bus)
    {
    }

    public function __invoke(AMessage $message)
    {
        $this->bus->dispatch(
            new BMessage(),
            [new TransportNamesStamp(['sync'])]
        );
    }
}

Would this solve your issue?

Hi @yuukikuno

As I said before it would work only if you call dispatch directly in your handler, but if you have a reusable component that is called from different contexts it won't work:

class HardWorkService
{
    public function __construct(MessageBusInterface $bus)
    {
    }

    public function doHardWork()
    {
        $this->bus->dispatch(new BMessage());
    }
}

class SomeController
{
    public function someAction(HardWorkService $service)
    {
        $service->doHardWork();
    }
}

#[AsMessageHandler]
class AMessageHandler
{
    public function __construct(private HardWorkService $service)
    {
    }

    public function __invoke(AMessage $message)
    {
        $this->service->doHardWork();
    }
}

In this simplified case, it's easy to pass some parameter and rely on it to pass TramsportNamesStamp or not, but if the dispatching happens deep in the function call stack, this will be problematic.

Fwiw symfony scheduler works like this, the dispatched messages are handled immediately instead of sending them to respective queues (read transport), you need to use Redispatch stamp to send them to proper queue, which is kinda meh tbh.

I'd rather have consistency, that is, messages should always go into queue unless specified otherwise (even with scheduler)

Thank you for this suggestion.
There has not been a lot of activity here for a while. Would you still like to see this feature?
Every feature is developed by the community.
Perhaps someone would like to try?
You can read how to contribute to get started.

Could I get a reply or should I close this?