Deep live queries with gateway-to-service persistent connections

[maxbol]

Hi y'all!

I've been working with more unusual and bleeding edge GraphQL patterns for the last couple of years, to a large extent thanks to the Guild and all your amazing work. I've implemented custom schema stitching gateways using Github as a schema registry (before Hive was announced), written custom delegation libraries utilizing graphql-tools to achieve multi-service responsibility for singular object fields, created hybrid gateways combining registry schemas with live-polling of external sources, etc. Not afraid to roll my sleeves up and get under the hood of things!

I'm currently working on a read view project using @n1ru4l 's amazing live query pattern with all operations running smoothly over both WS and HTTP-SSE wires (thank you, Helix!).

Two concurrent issues are facing me atm:

1. Our implemented domainspace is growing and being stratified into new subdomains. These should ideally not be handled by the same read layer service, but especially with the live query component, handling coordination of multiple schemas through persistent connections would likely be too complex a problem for our frontend to handle. Thus, stitching comes to mind. However, I know the stream/defer support is still being worked on in the stitching library (defer stream support within stitching graphql-tools#1941), and I suspect that persistent gateway-to-service connections right now is simply unmanageable with the current Guild stack - even in Mesh?
2. Authoring APIs within our domain are currently being developed as a mix of HTTP rest APIs (OpenAPI) and gRPC services. We have a zero-trust proxy at the boundary of our system which we can utilize as an authorization mechanism for these calls, so I though it would be cool to have a GraphQL mesh running on the edge to tie everything together.

I know there's a native live query plugin for Mesh, and I think I've figured out how I could feasibly refactor the read layer to send invalidation mutations to a intra-boundary read layer mesh (unfortch, far from all our data mutations are user-driven, so simply relying on the pattern of invalidation-through-mutation will not work...)

However, to be able to leverage our zero-trust proxy the way we want to (path based authorization), the mesh would have to exist outside of the domain boundary - so having it listen to an intra-boundary pubsub would be a no go. Ideally, we should be able to have the mesh set up persistent HTTP/2 connections directly to read layer services and stream results back to the client.

Is there any way to do "deep" live queries like this with GraphQL mesh at the moment? Or should I simply try to take a less extravagant route? :^)

If nothing else, just wanted you to know that even the more niche of the use cases you are developing for have their stakeholders, and if there's anything our team can do to help in getting Mesh/other Guild tech to the place we want it to be at, let us know!

Cheers
Max Bolotin