Hono middleware does not support subscription

[motopods]

import { weave } from "@gqloom/core"
import { graphqlServer } from "@hono/graphql-server"
import { serve } from "@hono/node-server"
import { Hono } from "hono"
import { helloResolver } from "./resolvers"

import { createYoga } from "graphql-yoga"

export const app = new Hono()
 
const schema = weave(helloResolver)
 
// this not support subscription
// app.use("/graphql", graphqlServer({ schema, graphiql: true }))
 
// this works
const yoga = createYoga({
	schema,
	graphiql: true,
})
app.use("/graphql", async (ctx) => {
	return await yoga.fetch(ctx.req.raw, ctx)
})

serve(app, (info) => {
  console.info(
    `GraphQL server is running on http://localhost:${info.port}/graphql`
  )
})

I have tested that it is a problem with the hono middleware itself, but I don't know how to pass the context when using yoga.fetch directly.
I can't get context by useContext in subscription resovler, it's always undefined. query and mutation is OK.

[motopods]

I found there is a context in resolve function but not in subscribe.

subscription(v.string(), {
		subscribe: async function* () {
			const ctx = useContext()
			console.log(ctx) // undefined
			while (true) {
				yield "1" 
				await new Promise((resolve) => setTimeout(resolve, 1_000))
			}
		},
		resolve(value) {
			const ctx = useContext()
			console.log(ctx) // has context
			return value
		},
	})

[xcfox]

Thank you for your feedback on this issue. I sincerely apologize for the late response. Fortunately, I've identified the cause of this error.

This problem is caused by async generators because Node.js doesn't capture the async context in async iterators.

I'm afraid GQLoom can't fix this issue on its own. We have to wait for an update from Node.js. However, it can be easily resolved by changing the code implementation.

You can use the following code. In my tests, it worked perfectly:

const CountdownResolver = resolver({
  countdown3: subscription(v.number())
    .subscribe(() => {
      const ctx = useContext()
      console.log(ctx) // has context

      return (async function* () {
        while (true) {
          yield "1"
          await new Promise((resolve) => setTimeout(resolve, 1_000))
        }
      })()
    })
    .resolve((value) => {
      const ctx = useContext()
      console.log(ctx) // has context
      return Number(value)
    }),
})

[motopods]

Thanks for your reply, it seems that there is indeed no perfect solution, you can only remind it in the document. @xcfox

[motopods]

Found an other problem in bun+hono+yoga, the signal can't be aborted after close browser page.

	version: subscription(v.string()).subscribe(() => {
		const ctx = useContext()
		ctx.request.signal.addEventListener("abort", () => console.log("abort")) // no triggered
		return (async function* () {
			while (!ctx.request.signal.aborted) {
				console.log(ctx.request.signal.aborted)
				yield "1"
				await new Promise((resolve) => setTimeout(resolve, 1_000))
			}
			console.log("abort exit") // no triggered
		})()
	}),

[motopods]

honojs/hono#1770

oven-sh/bun#17591

[motopods]

Abort problem only exists in @graphql-yoga/plugin-graphql-sse singleConnection mode

[motopods]

It's singleConnection problem, PUT(CREATE STREAM) -> GET (STREAMING) -> POST (NEW SUBSCRIPTION) ) -> POST (ANOTHER NEW SUBSCRIPTION)

version: subscription(v.string()).subscribe(() => {
		const ctx = useContext()
                // ctx.request.signal is POST method signal(not sse connection), so it will never abort, so we should store GET method signal globally and pass to here.
		return (async function* () {
			while (!ctx.RELATED_GET_STREAMING.signal.aborted) {
				yield "1"
				await new Promise((resolve) => setTimeout(resolve, 1_000))
			}
			console.log("abort exit") 
		})()
	}),

[xcfox]

I've made some minor adjustments to the async iterators within GQLoom.

Starting from version 0.8.3, you can use useContext() without restrictions in subscriptions.
The following code will run as expected:

const CountdownResolver = resolver({
  countdown1: subscription(v.number())
    .input({ seconds: v.pipe(v.nullish(v.number(), 5), v.integer()) })
    .subscribe(async function* ({ seconds }) {
      const ctx = useContext()
      console.log(ctx) // has context
      yield seconds
      while (seconds >= 0) {
        seconds = Math.max(0, Number((seconds - 0.1).toFixed(1)))
        const ctx = useContext()
        console.log(`ctx ${seconds}`, Object.keys(ctx ?? {})) // has context
        await new Promise((resolve) => setTimeout(resolve, 100))
        yield seconds
      }
    }),
})

[motopods]

I've made some minor adjustments to the async iterators within GQLoom.

Starting from version 0.8.3, you can use useContext() without restrictions in subscriptions. The following code will run as expected:

const CountdownResolver = resolver({
countdown1: subscription(v.number())
.input({ seconds: v.pipe(v.nullish(v.number(), 5), v.integer()) })
.subscribe(async function* ({ seconds }) {
const ctx = useContext()
console.log(ctx) // has context
yield seconds
while (seconds >= 0) {
seconds = Math.max(0, Number((seconds - 0.1).toFixed(1)))
const ctx = useContext()
console.log(ctx ${seconds}, Object.keys(ctx ?? {})) // has context
await new Promise((resolve) => setTimeout(resolve, 100))
yield seconds
}
}),
})

Yes, it works! Thanks your job!