Graphql federation & closing subscription on the subgraph

[pdambrauskas]

We are using graphql-ws with Graphql Federation.

It works as follows:

• Client initiates graphql subscription
• Our subscription federation gateway (using useServer/makeServer graphql-ws utility functions in combination with graphql-yoga) delegates subscription to one of the subgraphs by using single Websocket client.
• Subgraph service Gets subscription message and initiates Redis Pub/Sub stream.

It seems that when the client closes the connection, subscription federation gateway does not send CompleteMessage to our subgraph. This means, that our Redis Pub/Sub stream stays active and we eventually get to resource exhaustion.

I had an idea to hook up some logic on onClose callback & send CompleteMessage to ur subgraph from there, but it seems that graphql-ws removes subscriptions form the context:

graphql-ws/src/server.ts

Line 860 in 102e634

ctx.subscriptions = {}; // deleting the subscription means no further activity should take place

Are there any other ways/suggestions how to address this issue?
@enisdenjo

[enisdenjo]

Not only are the subscriptions removed from the context, the clients are disconnected immediately after:

graphql-ws/src/server.ts

Lines 862 to 867 in 102e634

	// we return all iterable subscriptions immediatelly, independant of the order
	await Promise.all(
	Object.values(subs)
	.filter(isAsyncGenerator)
	.map((sub) => sub.return(undefined)),
	);

Meaning, even if we left the subscriptions intact, the clients' connections will be closed right after.

---

I'd instead focus on fixing this:

It seems that when the client closes the connection, subscription federation gateway does not send CompleteMessage to our subgraph.

The CompleteMessage is sent as soon as the the subscription completes, i.e. as soon as the subscription iterable returns. Meaning, your iterable is not returning/completing and hence not emitting a CompleteMessage.

[enisdenjo]

If client just disconnects - no completion messages are generated, meaning subgraph does not get notified. (subscription iterable still gets returned).

But the subgraph should get notified? As in, when a WebSocket is closed - the close event is emitted.

Sorry if I am not very helpful here, I don't know how I can help from the maintainers side. 😅

[pdambrauskas]

No problem, its kind of unusual use-case, I guess :).

I mean with Apollo federation it something looks like this:

• We have N clients with N websocket connections to graphql-ws gateway
• We keep a single websocket connection between subgraph and graphql-ws gateway and close it only after the last client disconnects.

What would be nice to have from graphql ws library side - some kind of configurable hook, which would be called every time, when the client disconnects OR subscription gets closed in unexpected way AND have some kind of subscription identifiers that were present before disconnect.

We need this hook to send complete message to the corresponding subgraphs, otherwise downstream subscriptions do not get completed until the last client disconnects.

[enisdenjo]

some kind of configurable hook, which would be called every time, when the client disconnects OR subscription gets closed in unexpected way AND have some kind of subscription identifiers that were present before disconnect

On both the client and server, you have those hooks.

server

You can use onClose on the server to detect closed connections which contains the close code and reason (using it you can detect if it's abnormal or not), additionally you can use onComplete and onError for subscriptions inside a connection.

client

You can use the on events which have everything you need connection-wise like on the server. And use each of the subscriptions iterator/observable for subscriptions inside the connection.

Does this help?

[pdambrauskas]

on the servers onClose hook I don't have any references to subscriptions that have been closed - they are cleaned up, before calling the hook.

[enisdenjo]

You can augment all of the subscriptions' iterables return method in the onOperation hook and do something with them before closing.

Something like this (⚠️ untested code ahead):

import { useServer } from 'graphql-ws/use/ws';
import { webSocketServer } from './my-websocket-server';

useServer(
  {
    onOperation(ctx, id, payload, args, result) {
      if ('return' in result) {
        // is an async iterator, i.e. is a subscription
        const originalReturn = result.return;
        result.return = (...args) => {
          // send manual messages
          const thisSocket = ctx.extra.socket;
          thisSocket.send('whatever you need');
          upstreamWebSocket.send('whatever you need');

          // invoke original return to clean the subscriptions
          return originalReturn(...args);
        };
      }
    },
  },
  webSocketServer,
);

* Code is written for >=v6 of graphql-ws

Does this help?