Pothos Realtime Subscription with Prisma query optimization and context cache

findManyApiKey.ts

// Idea from https://github.com/hayes/pothos/issues/1349

import { builder } from '@/schema/builder'
import { pubsub } from '@/pubsub'
import { withFilter } from 'graphql-subscriptions'
import { queryFromInfo } from '@pothos/plugin-prisma'
import crypto from 'crypto'
import { Context } from '@/context'
import { prisma } from '@orm/db'

function hasher(value: any) {
  const hash = crypto
    .createHash('sha256')
    .update(JSON.stringify(value))
    .digest('hex')
  return hash
}

const trigger = 'general-smart-subscriptions-refetch'

function publishTrigger() {
  console.log('PUBLISHING trigger', trigger)
  pubsub.publish(trigger, {})
}

setInterval(() => {
  publishTrigger()
}, 1000)

type Payload = Record<'', ''>
type Variables = Record<'', ''>

builder.subscriptionFields((t) => {
  return {
    codeDevRealtimeApiKeys: t.prismaField({
      type: ['ApiKey'],
      subscribe: (...subProps) => {
        return withFilter(
          () => {
            // AUTO RESPOND AFTER CONNECTION https://ralexanderson.com/blog/subscription-only-graphql-data
            process.nextTick(() => {
              publishTrigger()
            })
            return pubsub.asyncIterator(trigger)
          },
          async (event: Payload, variables: Variables, ctx: Context, info) => {
            const query = queryFromInfo({
              info,
              context: ctx,
              typeName: 'ApiKey',
            })
            const res = await prisma.apiKey.findMany({
              // complex args
              where: {
                description: {
                  contains: 'Teste -',
                },
              },
              ...query,
            })
            const hashedRes = hasher(res)
            const hashedReq = hasher({
              _operatioName: 'codeDevRealtimeApiKeys',
              ...variables,
            })
            const lastRes = ctx.subscriptionResponses?.[hashedReq]
            if (lastRes?.hashedRes === hashedRes) {
              console.log('SAME', {
                lastRes,
                responses: ctx.subscriptionResponses,
                user: ctx.user,
                ctxKeys: Object.keys(ctx),
              })
              return false
            }
            ctx.subscriptionResponses = { [hashedReq]: { hashedRes, res } }
            console.log({ subRes: ctx.subscriptionResponses })
            return true
          },
        )(...subProps) as any as AsyncIterable<Payload>
      },
      // args: ... complex args
      async resolve(include, parent, args, context, info) {
        const hashedReq = hasher({
          _operatioName: 'codeDevRealtimeApiKeys',
          ...args,
        })

        const resCopy = structuredClone(
          context.subscriptionResponses[hashedReq].res,
        )

        delete context.subscriptionResponses[hashedReq].res

        return resCopy
      },
    }),
  }
})