Teil 3: Erst das Schema, typisiert von Codegen

type Query {
  guilds: [Guild!]!
  guild(id: ID!): Guild
  quests(status: QuestStatus, first: Int! = 20): [Quest!]!
  quest(id: ID!): Quest
}

type Guild {
  id: ID!
  name: String!
  motto: String
  adventurers: [Adventurer!]!
  quests(status: QuestStatus): [Quest!]!
}

type Adventurer {
  id: ID!
  name: String!
  class: AdventurerClass!
  level: Int!
  guild: Guild!
  quests: [Quest!]!
}

type Quest {
  id: ID!
  title: String!
  reward: Int!
  status: QuestStatus!
  guild: Guild!
  assignee: Adventurer
}

enum AdventurerClass {
  WARRIOR
  MAGE
  ROGUE
  RANGER
}

enum QuestStatus {
  OPEN
  ACCEPTED
  DONE
}

import type { CodegenConfig } from '@graphql-codegen/cli';

const config: CodegenConfig = {
  schema: 'src/schema.graphql',
  generates: {
    'src/generated/graphql.ts': {
      plugins: ['typescript', 'typescript-resolvers'],
      config: {
        useTypeImports: true,
        enumsAsTypes: true,
        contextType: '../context.ts#Context',
        mappers: {
          Guild: '../db/schema.ts#GuildRow',
          Adventurer: '../db/schema.ts#AdventurerRow',
          Quest: '../db/schema.ts#QuestRow',
        },
        scalars: {
          ID: { input: 'string', output: 'string | number' },
        },
      },
    },
  },
};

export default config;

"codegen": "graphql-codegen",

export type ResolversParentTypes = {
  Adventurer: AdventurerRow;
  Boolean: Scalars['Boolean']['output'];
  Guild: GuildRow;
  ID: Scalars['ID']['output'];
  Int: Scalars['Int']['output'];
  Query: Record<PropertyKey, never>;
  Quest: QuestRow;
  String: Scalars['String']['output'];
};

export type QuestResolvers<ContextType = Context, ParentType extends ResolversParentTypes['Quest'] = ResolversParentTypes['Quest']> = {
  assignee?: Resolver<Maybe<ResolversTypes['Adventurer']>, ParentType, ContextType>;
  guild?: Resolver<ResolversTypes['Guild'], ParentType, ContextType>;
  id?: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
  reward?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
  status?: Resolver<ResolversTypes['QuestStatus'], ParentType, ContextType>;
  title?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
};

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

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

export interface Context extends YogaInitialContext, ServerContext {
  db: Database;
}

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

import { and, eq } from 'drizzle-orm';
import { GraphQLError } from 'graphql';
import type { Database } from './db/index.ts';
import { adventurers, guilds, quests } from './db/schema.ts';
import type { Resolvers } from './generated/graphql.ts';

function badInput(message: string) {
  return new GraphQLError(message, { extensions: { code: 'BAD_USER_INPUT' } });
}

async function findGuild(db: Database, id: number) {
  const [guild] = await db.select().from(guilds).where(eq(guilds.id, id));
  if (!guild) throw new Error(`Guild ${id} not found`);
  return guild;
}

async function findAdventurer(db: Database, id: number) {
  const [adventurer] = await db.select().from(adventurers).where(eq(adventurers.id, id));
  if (!adventurer) throw new Error(`Adventurer ${id} not found`);
  return adventurer;
}

export const resolvers: Resolvers = {
  Query: {
    guilds: (_parent, _args, { db }) => db.select().from(guilds).orderBy(guilds.id),

    guild: async (_parent, { id }, { db }) => {
      const [guild] = await db.select().from(guilds).where(eq(guilds.id, Number(id)));
      return guild ?? null;
    },

    quests: (_parent, { status, first }, { db }) => {
      if (first < 1 || first > 100) throw badInput('first must be between 1 and 100');
      return db
        .select()
        .from(quests)
        .where(status ? eq(quests.status, status) : undefined)
        .orderBy(quests.id)
        .limit(first);
    },

    quest: async (_parent, { id }, { db }) => {
      const [quest] = await db.select().from(quests).where(eq(quests.id, Number(id)));
      return quest ?? null;
    },
  },

  Guild: {
    adventurers: (guild, _args, { db }) =>
      db.select().from(adventurers).where(eq(adventurers.guildId, guild.id)).orderBy(adventurers.id),

    quests: (guild, { status }, { db }) =>
      db
        .select()
        .from(quests)
        .where(and(eq(quests.guildId, guild.id), status ? eq(quests.status, status) : undefined))
        .orderBy(quests.id),
  },

  Adventurer: {
    guild: (adventurer, _args, { db }) => findGuild(db, adventurer.guildId),

    quests: (adventurer, _args, { db }) =>
      db.select().from(quests).where(eq(quests.assigneeId, adventurer.id)).orderBy(quests.id),
  },

  Quest: {
    guild: (quest, _args, { db }) => findGuild(db, quest.guildId),

    assignee: (quest, _args, { db }) =>
      quest.assigneeId === null ? null : findAdventurer(db, quest.assigneeId),
  },
};

import { readFileSync } from 'node:fs';
import { createSchema } from 'graphql-yoga';
import type { Context } from './context.ts';
import { resolvers } from './resolvers.ts';

export const schema = createSchema<Context>({
  typeDefs: readFileSync(new URL('./schema.graphql', import.meta.url), 'utf8'),
  resolvers,
});

import Fastify, { LogController } from 'fastify';
import { createYoga } from 'graphql-yoga';
import { Logger } from '@graphql-hive/logger';
import { PinoLogWriter } from '@graphql-hive/logger/writers/pino';
import { createContext, type ServerContext } from './context.ts';
import { schema } from './schema.ts';

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

const yoga = createYoga<ServerContext>({
  schema,
  context: createContext,
  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) });

"dev": "node --env-file=.env --watch-path=src src/server.ts | pino-pretty",
    "codegen": "graphql-codegen",

LOG_SQL=true

{ guilds { name adventurers { name quests { title } } quests { title assignee { name } } } }