Support `graphql-ws` protocol for outgoing subscription requests graphql source

[ntziolis]

The Problem:

• When dealing with a graph source that's till uses the legacy graphql-ws protocol mesh currently cannot be used as gateway for subscriptions.
• While graphql-transport-ws adoption is spreading there are many situations where an existing source only supports the legacy graphql-ws protocol.
• Reasons for not being able to use the protocol range from
  • no control over the stack (this applies to any boxed GraphQL engine or GraphQL SaaS provider)
  • to no budget to upgrade server + client (its a terrible reason, but sadly common in enterprises)

Enabling the ability to connect graphql sources that are not yet graphql-transport-ws compliant would further extend the use cases for GraphQL Mesh. In addition it could assist in speeding up the transition to the new protocol since one barrier of entry (server side handling of the new protocol) would be removed or at least phased (at some point people should upgrade their downstream sources).

Our Use Case:

• We leverage hasura in most of our projects
• While there is an open issue they are in the middle of releasing major version with support for additional databases. Hence don't believe this will be addressed any time soon and our Haskell skills are nowhere near good enough to create a PR ourselves :)

Describe the solution you'd like

• Extend the graphql handler config to allow specifying the subscription protocol to be used.
  • graphql-transport-ws would be the default when not provided
  • The other option would be graphql-ws
• The grphql handler then checks this config and decides weather to use the new or legacy client/ protocol

There are 2 general approaches:

• create a separate legacy url loader that is identical to the current url-loader, with only the implementation of buildWSSubscriber being replaced with the legacy client
• extend the url loader constructor to optionally allow overloading the buildWSSubscriber implementation

We have already tested the first approach successfully via monkey patch. Afterwards Mesh was capable of receiving incoming requests in the new protocol but making outgoing requests with the legacy protocol.

Here is the patch we used: https://gist.github.com/ntziolis/e6eff864709b737aadbe82e1ca763010

This is what we replaced after copying the source from @graphql-tools/url-loader:

  buildWSSubscriber(pointer: string, webSocketImpl: typeof WebSocket, headers: Record<string,string>): Subscriber {
    const WS_URL = switchProtocols(pointer, {
      https: 'wss',
      http: 'ws',
    });
    const subscriptionClient = new SubscriptionClient(WS_URL, {
      connectionParams: () => {
        return {
          headers
        }
      }
    }, webSocketImpl);

    return async ({ document, variables }: { document: DocumentNode; variables: any }) => {
      return observableToAsyncIterable(
        subscriptionClient.request({
          query: document,
          variables,
        })
      ) as AsyncIterator<ExecutionResult<any>>;
    };
  }

[ntziolis]

We are happy to take on the implementation but before starting wanted some input in which solution path you would prefer or if any support for the legacy protocol is not an option for you.

[ardatan]

I think you are referring to subscription-transport-ws by graphql-ws. We'd love to have both supported in url-loader. It sounds good to me :)

[ntziolis]

Yes that's what I was referring to. I'll get right on it then and create 2 Prs:

• One to extend the url-loader with a legacy option flag
• One to extend the grahpql handler to allow configuring using the legacy protocol and calling the url-loader with the legacy option flag set

[ardatan]

Thank you @ntziolis ! We'd love to merge and release new versions for those.

[ntziolis]

@ardatan Any preferences on how the config option for the graphql handler should be named? I would suggest adding a boolean flag. Something like useLegacyWsProtocol. But I'll go with whatever you prefer.

This flag would default to false. We can then pass this flag directly to the loader:

• legacy=false => use subscription client from graphql-ws lib (protocol graphql-transport-ws)
• legacy=true => use subscription client from subscriptions-transport-ws lib (protocol graphql-ws)

Btw the naming scheme of the libs their protocols is VERY confusing :D

[ardatan]

Yes they are confusing unfortunately :D So I am fine with your approach.

[ntziolis]

PR for part one was just created. Part 2 is already done but requires part one to be released.

See for part 2 here: https://github.com/Urigo/graphql-mesh/compare/master...ntziolis:support-legacy-ws-protocol

[ntziolis]

For anyone finding this, once released this can be configured via

sources: 
  - name: countries
    handler:
      graphql: 
        endpoint: https://countries.trevorblades.com/
        # this is the new flag
        useWebSocketLegacyProtocol: true