Introducing Scopes

[aidanm3341]

I have added the concept of Scopes to the MessageBroker. This is a mechanism for building a tree of message brokers in which messages will propagate up the tree until either the root is reacher, or a broker is found which has a subscriber to handle the message.

One outstanding question on this implementation is if the semantics for disposing of a scope is complete. Currently you can .destroy() a broker, which will unlink it from its parent meaning messages will no longer propagate up. Should this functionality do anything else? E.g. should it unlink itself from any children scopes as well?

[Davidhanson90]

I think we need some additional docs for this change which details about how messages propagate up and down scopes.

[Davidhanson90]

What are we doing about scope disposal. I think it needs to be part of this process.

[aidanm3341]

What are we doing about scope disposal. I think it needs to be part of this process.

That's a good point, there should be a mechanism for disposing of a scope similar to what exists for channels. This also made me realise another point - given that messages on a channel trickle down to the same channel in child scopes, the existing disposal logic should dispose of the same channel in the children.

[Davidhanson90]

Some minor suggestions. Where do we stand on destroy or scopes?

[Davidhanson90]

I think the parent may have different generic params. We are assuming all the tree is uniform. Its fine but something to considerr.

[aidanm3341]

If I'm understand right, do you mean supporting something like this?

const broker1 = messagebroker<Contract1>();
const broker2 = broker1.createScope<Contract2>('my-scope');

in this case, would Contract2 be required to extend Contract 1? Otherwise a message sent to broker1 could not necessarily be passed down to broker2.

[Davidhanson90]

Yeah so I think this is governed by the propergation logic you plan to implement. For example say create scope and that scope extends the parents channels type, then it would mean my scope would essentially be a superset of the parent and messages subsribed or publishes essentially propergate upwards.

interface Contract1{
 "foo": boolean;
}

const broker1 = messagebroker<Contract1>();
const broker2 = broker1.createScope<Contract2 extends Contract1>('my-scope');

broker2.publish('foo') //Works

However if you do not extend the parents type then you could it this way

const broker1 = messagebroker<Contract1>();
const broker2 = broker1.createScope<Contract2 extends Contract1>('my-scope');

broker2.publish('foo') //Compile error
broker2.parent.publish('foo') //Works

I prefer the extended types option as it makes more sense that channels delegate upwards

[aidanm3341]

Some minor suggestions. Where do we stand on destroy or scopes?

Yes sorry I had forgotten about the scope destroying my bad. My interpretation of this would be to have the ability to disconnect the child of an instance that you have, e.g.

const broker1 = messagebroker<Contract>();
const broker2 = broker1.createScope('my-scope');
broker1.destroyScope('my-scope');

broker2.get('channel').subscribe(_ => console.log('hello!'));
broker1.create('channel').publish('test'); // nothing happens

so it's essentially orphaning the child broker, stopping any message propagation down to it. What do you think, is this the kind of thing you had in mind or am I misunderstanding?

[aidanm3341]

I've introduced the name property on the messagebroker instance itself to keep track. The root broker has the name 'root'