Teil 5: Mutations und Live-Updates mit Subscriptions

type Mutation {
  postQuest(input: PostQuestInput!): Quest!
  acceptQuest(questId: ID!, adventurerId: ID!): Quest!
  completeQuest(questId: ID!): Quest!
}

input PostQuestInput {
  guildId: ID!
  title: String!
  reward: Int!
}

type Subscription {
  questPosted(guildId: ID): Quest!
  questUpdated(id: ID!): Quest!
}

import { and, eq } from 'drizzle-orm';
import { GraphQLError } from 'graphql';
import { filter, pipe } from 'graphql-yoga';
import { guilds, quests, type QuestRow } from './db/schema.ts';
import type { Resolvers } from './generated/graphql.ts';

Mutation: {
    postQuest: async (_parent, { input }, { db, loaders, pubsub }) => {
      const title = input.title.trim();
      if (!title) throw badInput('A quest needs a title');
      if (input.reward < 1) throw badInput('The reward must be at least 1 gold');

      const guild = await loaders.guild.load(Number(input.guildId)).catch(() => null);
      if (!guild) throw badInput(`There is no guild with the id ${input.guildId}`);

      const [quest] = await db
        .insert(quests)
        .values({ title, reward: input.reward, guildId: guild.id })
        .returning();
      pubsub.publish('quest:posted', quest);
      return quest;
    },

    acceptQuest: async (_parent, { questId, adventurerId }, { db, loaders, pubsub }) => {
      const adventurer = await loaders.adventurer.load(Number(adventurerId)).catch(() => null);
      if (!adventurer) throw badInput(`There is no adventurer with the id ${adventurerId}`);

      const [quest] = await db
        .update(quests)
        .set({ status: 'ACCEPTED', assigneeId: adventurer.id })
        .where(and(eq(quests.id, Number(questId)), eq(quests.status, 'OPEN')))
        .returning();
      if (!quest) throw badInput(`Quest ${questId} is not open`);

      pubsub.publish('quest:updated', quest.id, quest);
      return quest;
    },

    completeQuest: async (_parent, { questId }, { db, pubsub }) => {
      const [quest] = await db
        .update(quests)
        .set({ status: 'DONE' })
        .where(and(eq(quests.id, Number(questId)), eq(quests.status, 'ACCEPTED')))
        .returning();
      if (!quest) throw badInput(`Quest ${questId} has not been accepted`);

      pubsub.publish('quest:updated', quest.id, quest);
      return quest;
    },
  },

import { createPubSub } from 'graphql-yoga';
import type { QuestRow } from './db/schema.ts';

export const pubsub = createPubSub<{
  'quest:posted': [quest: QuestRow];
  'quest:updated': [id: number, quest: QuestRow];
}>();

export type PubSub = typeof pubsub;

import type { FastifyReply, FastifyRequest } from 'fastify';
import type { YogaInitialContext } from 'graphql-yoga';
import { db, type Database } from './db/index.ts';
import { createLoaders, type Loaders } from './loaders.ts';
import { pubsub, type PubSub } from './pubsub.ts';

export interface ServerContext {
  req: FastifyRequest;
  reply: FastifyReply;
}

export interface Context extends YogaInitialContext, ServerContext {
  db: Database;
  loaders: Loaders;
  pubsub: PubSub;
}

export function createContext(): Pick<Context, 'db' | 'loaders' | 'pubsub'> {
  return { db, loaders: createLoaders(db), pubsub };
}

Subscription: {
    questPosted: {
      subscribe: (_parent, { guildId }, { pubsub }) =>
        pipe(
          pubsub.subscribe('quest:posted'),
          filter((quest) => !guildId || quest.guildId === Number(guildId)),
        ),
      resolve: (quest: QuestRow) => quest,
    },

    questUpdated: {
      subscribe: (_parent, { id }, { pubsub }) => pubsub.subscribe('quest:updated', Number(id)),
      resolve: (quest: QuestRow) => quest,
    },
  },

import Fastify, { LogController } from 'fastify';
import { createYoga } from 'graphql-yoga';
import { useExtendContextValuePerExecuteSubscriptionEvent } from '@envelop/execute-subscription-event';
import { Logger } from '@graphql-hive/logger';
import { PinoLogWriter } from '@graphql-hive/logger/writers/pino';
import { createContext, type Context, type ServerContext } from './context.ts';
import { db } from './db/index.ts';
import { createLoaders } from './loaders.ts';
import { schema } from './schema.ts';

const app = Fastify({
  logger: true,
  logController: new LogController({ disableRequestLogging: true }),
});

const yoga = createYoga<ServerContext>({
  schema,
  context: createContext,
  plugins: [
    // A subscription keeps its context for every event: give each event fresh loaders.
    useExtendContextValuePerExecuteSubscriptionEvent<Context>(() => ({
      contextPartial: { loaders: createLoaders(db) },
    })),
  ],
  logging: new Logger({ writers: [new PinoLogWriter(app.log)] }),
});

app.route({
  url: yoga.graphqlEndpoint,
  method: ['GET', 'POST', 'OPTIONS'],
  handler: (req, reply) => yoga.handleNodeRequestAndResponse(req, reply, { req, reply }),
});

await app.listen({ port: Number(process.env.PORT) });