graphql-mqtt-subscriptions

This package implements the AsyncIterator Interface and PubSubEngine Interface from the graphql-subscriptions package. It allows you to connect your subscriptions manager to an MQTT enabled Pub Sub broker to support horizontally scalable subscriptions setup. This package is an adapted version of my graphql-redis-subscriptions package.

Installation

npm install graphql-mqtt-subscriptions

Using the AsyncIterator Interface

Define your GraphQL schema with a Subscription type.

1schema {
2  query: Query
3  mutation: Mutation
4  subscription: Subscription
5}
6
7type Subscription {
8    somethingChanged: Result
9}
10
11type Result {
12    id: String
13}

Now, create a MQTTPubSub instance.

1import { MQTTPubSub } from 'graphql-mqtt-subscriptions';
2const pubsub = new MQTTPubSub(); // connecting to mqtt://localhost by default

Now, implement the Subscriptions type resolver, using pubsub.asyncIterator to map the event you need.

1const SOMETHING_CHANGED_TOPIC = 'something_changed';
2
3export const resolvers = {
4  Subscription: {
5    somethingChanged: {
6      subscribe: () => pubsub.asyncIterator(SOMETHING_CHANGED_TOPIC)
7    }
8  }
9}

Subscriptions resolvers are not a function, but an object with subscribe method, that returns AsyncIterable.

The AsyncIterator method will tell the MQTT client to listen for messages from the MQTT broker on the topic provided, and wraps that listener in an AsyncIterator object.

When messages are received from the topic, those messages can be returned back to connected clients.

pubsub.publish can be used to send messages to a given topic.

1pubsub.publish(SOMETHING_CHANGED_TOPIC, { somethingChanged: { id: "123" }});

Dynamically Create a Topic Based on Subscription Args Passed on the Query:

1export const resolvers = {
2  Subscription: {
3    somethingChanged: {
4      subscribe: (_, args) => pubsub.asyncIterator(`${SOMETHING_CHANGED_TOPIC}.${args.relevantId}`),
5    },
6  },
7}

Using Arguments and Payload to Filter Events

1import { withFilter } from 'graphql-subscriptions';
2
3export const resolvers = {
4  Subscription: {
5    somethingChanged: {
6      subscribe: withFilter(
7        (_, args) => pubsub.asyncIterator(`${SOMETHING_CHANGED_TOPIC}.${args.relevantId}`),
8        (payload, variables) => payload.somethingChanged.id === variables.relevantId,
9      ),
10    },
11  },
12}

Passing your own client object

The basic usage is great for development and you will be able to connect to any mqtt enabled server running on your system seamlessly. For production usage, it is recommended you pass your own MQTT client.

1import { connect } from 'mqtt';
2import { MQTTPubSub } from 'graphql-mqtt-subscriptions';
3
4const client = connect('mqtt://test.mosquitto.org', {
5  reconnectPeriod: 1000,
6});
7
8const pubsub = new MQTTPubSub({
9  client
10});

You can learn more on the mqtt options object here.

Changing QoS for publications or subscriptions

As specified here, the MQTT.js publish and subscribe functions takes an options object. This object can be defined per trigger with publishOptions and subscribeOptions resolvers.

1const triggerToQoSMap = {
2  'comments.added': 1,
3  'comments.updated': 2,
4};
5
6const pubsub = new MQTTPubSub({
7  publishOptions: trigger => Promise.resolve({ qos: triggerToQoSMap[trigger] }),
8  
9  subscribeOptions: (trigger, channelOptions) => Promise.resolve({ 
10    qos: Math.max(triggerToQoSMap[trigger], channelOptions.maxQoS), 
11  }),
12});

Get Notified of the Actual QoS Assigned for a Subscription

MQTT allows the broker to assign different QoS levels than the one requested by the client. In order to know what QoS was given to your subscription, you can pass in a callback called onMQTTSubscribe

1const onMQTTSubscribe = (subId, granted) => {
2  console.log(`Subscription with id ${subId} was given QoS of ${granted.qos}`);
3}
4
5const pubsub = new MQTTPubSub({onMQTTSubscribe});

Change Encoding Used to Encode and Decode Messages

Supported encodings available here

1const pubsub = new MQTTPubSub({
2  parseMessageWithEncoding: 'utf16le',
3});

Basic Usage with SubscriptionManager (Deprecated)

1import { MQTTPubSub } from 'graphql-mqtt-subscriptions';
2const pubsub = new MQTTPubSub(); // connecting to mqtt://localhost on default
3const subscriptionManager = new SubscriptionManager({
4  schema,
5  pubsub,
6  setupFunctions: {},
7});

Using Trigger Transform (Deprecated)

Similar to the graphql-redis-subscriptions package, this package supports a trigger transform function. This trigger transform allows you to use the channelOptions object provided to the SubscriptionManager instance, and return a trigger string which is more detailed then the regular trigger.

Here is an example of a generic trigger transform.

1const triggerTransform = (trigger, { path }) => [trigger, ...path].join('.');

Note that a path field to be passed to the channelOptions but you can do whatever you want.

Next, pass the triggerTransform to the MQTTPubSub constructor.

1const pubsub = new MQTTPubSub({
2  triggerTransform,
3});

Lastly, a setupFunction is provided for the commentsAdded subscription field. It specifies one trigger called comments.added and it is called with the channelOptions object that holds repoName path fragment.

1const subscriptionManager = new SubscriptionManager({
2  schema,
3  setupFunctions: {
4    commentsAdded: (options, { repoName }) => ({
5      'comments/added': {
6        channelOptions: { path: [repoName] },
7      },
8    }),
9  },
10  pubsub,
11});

Note that the triggerTransform dependency on the path field is satisfied here.

When subscribe is called like this:

1const query = `
2  subscription X($repoName: String!) {
3    commentsAdded(repoName: $repoName)
4  }
5`;
6const variables = {repoName: 'graphql-mqtt-subscriptions'};
7subscriptionManager.subscribe({ query, operationName: 'X', variables, callback });

The subscription string that MQTT will receive will be comments.added.graphql-mqtt-subscriptions. This subscription string is much more specific and means the the filtering required for this type of subscription is not needed anymore. This is one step towards lifting the load off of the graphql api server regarding subscriptions.