Teil 4: Bündeln mit DataLoader

import DataLoader from 'dataloader';
import { inArray } from 'drizzle-orm';
import type { Database } from './db/index.ts';
import { adventurers, guilds, quests } from './db/schema.ts';

/** One row per id, in the order of the ids, or an error where a row is missing. */
function one<T extends { id: number }>(ids: readonly number[], rows: T[], type: string) {
  const byId = new Map(rows.map((row) => [row.id, row]));
  return ids.map((id) => byId.get(id) ?? new Error(`${type} ${id} not found`));
}

/** All rows per key, in the order of the keys, and an empty list where there are none. */
function many<T>(keys: readonly number[], rows: T[], keyOf: (row: T) => number | null) {
  const groups = Map.groupBy(rows, keyOf);
  return keys.map((key) => groups.get(key) ?? []);
}

export function createLoaders(db: Database) {
  const guild = new DataLoader(async (ids: readonly number[]) => {
    const rows = await db.select().from(guilds).where(inArray(guilds.id, [...ids]));
    return one(ids, rows, 'Guild');
  });

  const adventurer = new DataLoader(async (ids: readonly number[]) => {
    const rows = await db.select().from(adventurers).where(inArray(adventurers.id, [...ids]));
    return one(ids, rows, 'Adventurer');
  });

  const adventurersByGuild = new DataLoader(async (guildIds: readonly number[]) => {
    const rows = await db
      .select()
      .from(adventurers)
      .where(inArray(adventurers.guildId, [...guildIds]))
      .orderBy(adventurers.id);
    return many(guildIds, rows, (row) => row.guildId);
  });

  const questsByGuild = new DataLoader(async (guildIds: readonly number[]) => {
    const rows = await db
      .select()
      .from(quests)
      .where(inArray(quests.guildId, [...guildIds]))
      .orderBy(quests.id);
    return many(guildIds, rows, (row) => row.guildId);
  });

  const questsByAssignee = new DataLoader(async (adventurerIds: readonly number[]) => {
    const rows = await db
      .select()
      .from(quests)
      .where(inArray(quests.assigneeId, [...adventurerIds]))
      .orderBy(quests.id);
    return many(adventurerIds, rows, (row) => row.assigneeId);
  });

  return { guild, adventurer, adventurersByGuild, questsByGuild, questsByAssignee };
}

export type Loaders = ReturnType<typeof createLoaders>;

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';

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

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

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

Guild: {
    adventurers: (guild, _args, { loaders }) => loaders.adventurersByGuild.load(guild.id),

    quests: async (guild, { status }, { loaders }) => {
      const guildQuests = await loaders.questsByGuild.load(guild.id);
      return status ? guildQuests.filter((quest) => quest.status === status) : guildQuests;
    },
  },

  Adventurer: {
    guild: (adventurer, _args, { loaders }) => loaders.guild.load(adventurer.guildId),

    quests: (adventurer, _args, { loaders }) => loaders.questsByAssignee.load(adventurer.id),
  },

  Quest: {
    guild: (quest, _args, { loaders }) => loaders.guild.load(quest.guildId),

    assignee: (quest, _args, { loaders }) =>
      quest.assigneeId === null ? null : loaders.adventurer.load(quest.assigneeId),
  },
};

const adventurersByGuild = new DataLoader(async (guildIds: readonly number[]) => {
    const rows = await db
      .select()
      .from(adventurers)
      .where(inArray(adventurers.guildId, [...guildIds]))
      .orderBy(adventurers.id);
    // These adventurers need no query of their own any more in this request.
    for (const row of rows) adventurer.prime(row.id, row);
    return many(guildIds, rows, (row) => row.guildId);
  });