Sending messages directly between actors

[Ghirigoro]

Is there a way to have actors to send messages to one another directly? I can see how to do it by pushing messages back up to the parent and then having the parent forward them like below, but that seems a bit clunky. Is there a cleaner alternative?

const machine = setup({
	types: {
		events: {} as { type: "MESSAGE_TO_A" } | { type: "MESSAGE_TO_B" },
	},
	actors: {
		a: fromCallback(({ sendBack }) => {
			setTimeout(() => {
				// Can this be sent directly to b?
				sendBack({ type: "MESSAGE_TO_B" })
			}, 1000)
		}),
		b: fromCallback(({ sendBack }) => {
			setTimeout(() => {
				// Can this be sent directly to a?
				sendBack({ type: "MESSAGE_TO_A" })
			}, 2000)
		}),
	},
}).createMachine({
	states: {
		on: {
			MESSAGE_TO_A: {
				actions: sendTo("a", { type: "MESSAGE_TO_A" }),
			},
			MESSAGE_TO_B: {
				actions: sendTo("b", { type: "MESSAGE_TO_B" }),
			},
		},
		a: {
			invoke: {
				id: "a",
				src: "a",
			},
		},
		b: {
			invoke: {
				id: "b",
				src: "b",
			},
		},
	},
})

[davidkpiano]

Yes, add a systemId: https://stately.ai/docs/system#actor-registration

[Ghirigoro]

@davidkpiano Thanks for the quick response, but I should have been clearer in my question. The part I'm struggling with is not how to get a reference to an actor (although your comment was helpful - I didn't realize there was a systemId that was separate from id), but how to do the actual sending.

I can't use sendTo or enqueueActions inside of the actor logic since they're action creators and I don't see where I can put the resulting action, and I don't see any imperative way to send or enqueue an event from within actor logic.

[with-heart]

Yeah currently the only official way to handle that is to do what you're doing and send an event to the actor's parent machine and handle sending it on from there.

I like the trick you discovered with system.schedule though. Makes me wonder if that couldn't be wrapped up in a cleaner api to make actors created by actor creators a more active part of the system they're in.

[Ghirigoro]

Making the actor API more accessible sounds great. XState leans really heavily into the actor model so anything that makes it easier to use them (and also cuts down on boilerplate) would be appreciated.

[davidkpiano]

Yes, I think that we can provide a better way to do this. Internally, the way to do this is:

fromCallback(({ system, self }) => {
  // ...
  system._relay(self, system.get('a'), { type: 'someMessage' })
})

[Ghirigoro]

_relay is stripped out of the exported types. I'd rather not rely on unexposed internal types, is there any problem with using scheduler.schedule over _relay?

[davidkpiano]

You can use scheduler.schedule; I'm just showing what happens internally.

[Ghirigoro]

The solution I've settled on so far is this:

// ...
a: fromCallback(({system})=>{
  setTimeout(() => {
    system.scheduler.schedule( 
      system.get("a"),
      system.get("b"),
      { type: "MESSAGE_TO_B" },
      0,
      undefined
    );
  }, 1000)
});
// ...

This seems to work, but since I couldn't find documentation around it, it makes me think that this might not be the preferred approach...