## Problem Statement Nested GraphQL resolvers trigger N+1 database queries; request-scoped batching is not implemented. ## What needs to be done Introduce DataLoader-based batching for core entities and wire them into the GraphQL context. ## Approach - Create typed DataLoaders for users, organizations, events, and action items. - Batch via Drizzle `inArray()` and preserve the requested key order. - Initialize request-scoped loaders in the GraphQL context factory. - Keep caching request-scoped (no global cross-request cache in this step). ## PR / Files constraint - Each PR SHOULD touch 5–20 files. - If a PR would touch <5 files, treat as an exception. - If the final remainder in a phase is <5 files and there is more than one PR for that phase, merge the remainder into the preceding PR. ## Files (scope guidance) - New: `src/utilities/dataloaders/{userLoader.ts,organizationLoader.ts,eventLoader.ts,actionItemLoader.ts,index.ts}` - Modify: `src/graphql/context.ts`, `src/routes/graphql.ts`, `package.json` (add `dataloader`) ## Links - Blocked by: None - Blocks: #4121, #4123 - Phase: Phase 1 ## Sample code ```ts // src/utilities/dataloaders/userLoader.ts import DataLoader from "dataloader"; import { inArray } from "drizzle-orm"; import { usersTable } from "~/src/drizzle/tables/users"; import type { DrizzleClient } from "~/src/fastifyPlugins/drizzleClient"; export function createUserLoader(db: DrizzleClient) { return new DataLoader(async (ids) => { const rows = await db.select().from(usersTable).where(inArray(usersTable.id, [...ids])); const map = new Map(rows.map(r => [r.id, r])); return ids.map(id => map.get(id) ?? null); }, { batchScheduleFn: cb => setTimeout(cb, 5) }); } // src/graphql/context.ts (snippet) export type GraphQLContext = { // ... dataloaders: { user: ReturnType; // ... }; }; ``` --- - **AI Generated:** Provided only as a guide. This is a representation of what could be done --- This sample code sets up request‑scoped DataLoaders, wire them into GraphQL context, and include a minimal test to verify order preservation and batching. Type definitions and factories ```ts // src/utilities/dataloaders/userLoader.ts import DataLoader from "dataloader"; import { inArray } from "drizzle-orm"; import type { DrizzleClient } from "~/src/fastifyPlugins/drizzleClient"; import { usersTable } from "~/src/drizzle/tables/users"; export type UserRow = typeof usersTable.$inferSelect; export function createUserLoader(db: DrizzleClient) { const batch = async (ids: readonly string[]) => { const rows = await db.select().from(usersTable).where(inArray(usersTable.id, ids as string[])); const map = new Map(rows.map((r) => [r.id, r])); return ids.map((id) => map.get(id) ?? null); }; return new DataLoader(batch, { // Coalesce loads triggered within the same tick batchScheduleFn: (cb) => setTimeout(cb, 0), }); } ``` ```ts // src/utilities/dataloaders/organizationLoader.ts import DataLoader from "dataloader"; import { inArray } from "drizzle-orm"; import type { DrizzleClient } from "~/src/fastifyPlugins/drizzleClient"; import { organizationsTable } from "~/src/drizzle/tables/organizations"; export type OrganizationRow = typeof organizationsTable.$inferSelect; export function createOrganizationLoader(db: DrizzleClient) { const batch = async (ids: readonly string[]) => { const rows = await db.select().from(organizationsTable).where(inArray(organizationsTable.id, ids as string[])); const map = new Map(rows.map((r) => [r.id, r])); return ids.map((id) => map.get(id) ?? null); }; return new DataLoader(batch, { batchScheduleFn: (cb) => setTimeout(cb, 0), }); } ``` ```ts // src/utilities/dataloaders/eventLoader.ts import DataLoader from "dataloader"; import { inArray } from "drizzle-orm"; import type { DrizzleClient } from "~/src/fastifyPlugins/drizzleClient"; import { eventsTable } from "~/src/drizzle/tables/events"; export type EventRow = typeof eventsTable.$inferSelect; export function createEventLoader(db: DrizzleClient) { const batch = async (ids: readonly string[]) => { const rows = await db.select().from(eventsTable).where(inArray(eventsTable.id, ids as string[])); const map = new Map(rows.map((r) => [r.id, r])); return ids.map((id) => map.get(id) ?? null); }; return new DataLoader(batch, { batchScheduleFn: (cb) => setTimeout(cb, 0), }); } ``` Aggregator and factory ```ts // src/utilities/dataloaders/index.ts import type { DrizzleClient } from "~/src/fastifyPlugins/drizzleClient"; import { createUserLoader, type UserRow } from "./userLoader"; import { createOrganizationLoader, type OrganizationRow } from "./organizationLoader"; import { createEventLoader, type EventRow } from "./eventLoader"; export type Dataloaders = { user: ReturnType; organization: ReturnType; event: ReturnType; }; export function createDataloaders(db: DrizzleClient): Dataloaders { return { user: createUserLoader(db), organization: createOrganizationLoader(db), event: createEventLoader(db), }; } // Optional helper types for resolvers export type Loaded = T | null; export type UserLoaded = Loaded; export type OrganizationLoaded = Loaded; export type EventLoaded = Loaded; ``` GraphQL context typing and wiring ```ts // src/graphql/context.ts import type { FastifyBaseLogger } from "fastify"; import type { DrizzleClient } from "~/src/fastifyPlugins/drizzleClient"; import type { Dataloaders } from "~/src/utilities/dataloaders"; export type GraphQLContext = { log: FastifyBaseLogger; drizzleClient: DrizzleClient; dataloaders: Dataloaders; }; ``` ```ts // src/routes/graphql.ts (excerpt) import type { FastifyInstance } from "fastify"; import mercurius from "mercurius"; import { createDataloaders } from "~/src/utilities/dataloaders"; export async function registerGraphQLRoute(app: FastifyInstance) { await app.register(mercurius, { schema: /* build your schema */, context: (req, reply) => { return { log: req.log, drizzleClient: app.drizzleClient, dataloaders: createDataloaders(app.drizzleClient), // request-scoped loaders }; }, }); } ``` Example resolver usage (prevents N+1) ```ts // src/graphql/types/Post/creator.ts (example field resolver) import type { GraphQLContext } from "~/src/graphql/context"; import { TalawaGraphQLError } from "~/src/utilities/TalawaGraphQLError"; import { ErrorCode } from "~/src/utilities/errors/errorCodes"; export const Post_creator = { // parent.creatorId: string resolve: async (parent: any, _args: unknown, ctx: GraphQLContext) => { if (!parent.creatorId) return null; const user = await ctx.dataloaders.user.load(parent.creatorId); if (!user) { throw new TalawaGraphQLError({ code: ErrorCode.NOT_FOUND, message: "User not found" }); } return user; }, }; ``` Minimal test to verify order and batching ```ts // test/utilities/dataloaders/dataloader.infrastructure.test.ts import { describe, it, expect, vi } from "vitest"; import { createUserLoader } from "~/src/utilities/dataloaders/userLoader"; describe("DataLoader infrastructure", () => { it("returns results in the same order as keys and batches calls", async () => { const db = { select: vi.fn().mockReturnThis(), from: vi.fn().mockReturnThis(), where: vi.fn().mockResolvedValue([ { id: "u2", name: "B" }, { id: "u1", name: "A" }, ]), } as any; const loader = createUserLoader(db); // Trigger multiple loads in the same tick to ensure batching const p1 = loader.load("u1"); const p2 = loader.load("u2"); const p3 = loader.load("u3"); const results = await Promise.all([p1, p2, p3]); expect(results).toEqual([{ id: "u1", name: "A" }, { id: "u2", name: "B" }, null]); // One batch execution (select/from/where pipeline invoked once) expect(db.where).toHaveBeenCalledTimes(1); }); }); ``` Key notes - Scope: Loaders are created per request via context to avoid cross‑request memory/caching. - Batching: DataLoader coalesces loads in the same event loop tick (batchScheduleFn); each relation field no longer hits DB per row. - Order: The mapping by id and returning in input order ensures resolvers receive values aligned with keys.

[Streamline - performance] Implement DataLoader Infrastructure for N+1 Query Prevention #4120

Company

Community

Support

Connect