feat: add DataLoader support to reference resolver to solve n+1 query problem

- Add ReferenceLoader that batches reference queries using service.query
- Update reference resolver to use DataLoader when ExecutionContext is available
- Maintain backward compatibility by falling back to getById when context is missing
- Batch multiple reference queries into single database query to eliminate n+1 problem

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: Diluka

packages/query-graphql/src/loader/index.ts

@@ -3,3 +3,4 @@ export * from './count-relations.loader'
 export * from './dataloader.factory'
 export * from './find-relations.loader'
 export * from './query-relations.loader'
+export * from './reference.loader'

packages/query-graphql/src/loader/reference.loader.ts

@@ -0,0 +1,35 @@
+import { Class, Filter, QueryService } from '@ptc-org/nestjs-query-core'
+
+import { NestjsQueryDataloader } from './relations.loader'
+
+export type ReferenceArgs = {
+  id: string | number
+}
+
+export class ReferenceLoader<DTO> implements NestjsQueryDataloader<DTO, ReferenceArgs, DTO | undefined | Error> {
+  constructor(readonly DTOClass: Class<DTO>) {}
+
+  public createLoader(service: QueryService<DTO, unknown, unknown>) {
+    return async (args: ReadonlyArray<ReferenceArgs>): Promise<(DTO | undefined | Error)[]> => {
+      // Extract all unique IDs from the batch
+      const ids = args.map((arg) => arg.id)
+
+      // Use batch query to fetch all entities at once
+      const entities = await service.query({
+        filter: { id: { in: ids } } as unknown as Filter<DTO>
+      })
+
+      // Create a map for fast lookup by ID
+      const entityMap = new Map<string | number, DTO>()
+      if (entities) {
+        entities.forEach((entity) => {
+          const id = (entity as Record<string, unknown>).id as string | number
+          entityMap.set(id, entity)
+        })
+      }
+
+      // Return results in the same order as requested
+      return args.map((arg) => entityMap.get(arg.id) || undefined)
+    }
+  }
+}

packages/query-graphql/src/resolvers/reference.resolver.ts

@@ -1,9 +1,12 @@
-import { BadRequestException } from '@nestjs/common'
-import { Resolver, ResolveReference } from '@nestjs/graphql'
+import { BadRequestException, ExecutionContext } from '@nestjs/common'
+import { Context, Resolver, ResolveReference } from '@nestjs/graphql'
 import { Class, QueryService } from '@ptc-org/nestjs-query-core'
 
 import { getDTONames } from '../common'
+import { InjectDataLoaderConfig } from '../decorators/inject-dataloader-config.decorator'
 import { RepresentationType } from '../federation'
+import { DataLoaderFactory, ReferenceLoader } from '../loader'
+import { DataLoaderOptions } from '../pipes/inject-data-loader-config.pipe'
 import { BaseServiceResolver, ResolverClass, ServiceResolver } from './resolver.interface'
 
 export interface ReferenceResolverOpts {
@@ -21,17 +24,42 @@ export const Referenceable =
       return BaseClass
     }
     const { key } = opts
+    const { baseName } = getDTONames(DTOClass)
+    const loaderName = `loadReference${baseName}`
+    const referenceLoader = new ReferenceLoader<DTO>(DTOClass)
 
     @Resolver(() => DTOClass, { isAbstract: true })
     class ResolveReferenceResolverBase extends BaseClass {
       @ResolveReference()
-      async resolveReference(representation: RepresentationType): Promise<DTO> {
+      async resolveReference(
+        representation: RepresentationType,
+        @Context() context?: ExecutionContext,
+        @InjectDataLoaderConfig()
+        dataLoaderConfig?: DataLoaderOptions
+      ): Promise<DTO> {
         const id = representation[key]
         if (id === undefined) {
-          throw new BadRequestException(
-            `Unable to resolve reference, missing required key ${key} for ${getDTONames(DTOClass).baseName}`
+          throw new BadRequestException(`Unable to resolve reference, missing required key ${key} for ${baseName}`)
+        }
+
+        // If context is available, use DataLoader for batching
+        if (context) {
+          const loader = DataLoaderFactory.getOrCreateLoader(
+            context,
+            loaderName,
+            () => referenceLoader.createLoader(this.service),
+            dataLoaderConfig
           )
+
+          const result = await loader.load({ id: id as string | number })
+          if (!result) {
+            throw new BadRequestException(`Unable to find ${baseName} with ${key}: ${String(id)}`)
+          }
+
+          return result
         }
+
+        // Fallback to original behavior when context is not available (for backward compatibility)
         return this.service.getById(representation[key] as string | number)
       }
     }