refactor: simplify reference resolver by removing backward compatibility

- Remove optional ExecutionContext parameter, make it required
- Always use DataLoader for reference resolution, no fallback to getById
- Simplify tests to always provide context, matching real-world usage
- Reduce code complexity while maintaining full DataLoader functionality
- All tests pass, confirming the simplified approach works correctly

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

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

Author: Diluka

packages/query-graphql/__tests__/resolvers/reference.resolver.spec.ts

@@ -36,21 +36,7 @@ describe('ReferenceResolver', () => {
   describe('#resolveReference', () => {
     const createContext = (): ExecutionContext => ({}) as unknown as ExecutionContext
 
-    it('should call the service getById with the provided input (without context)', async () => {
-      const { resolver, mockService } = await createResolverFromNest(TestResolver)
-      const id = 'id-1'
-      const output: TestResolverDTO = {
-        id,
-        stringField: 'foo'
-      }
-      when(mockService.getById(id)).thenResolve(output)
-      // @ts-ignore
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/naming-convention
-      const result = await resolver.resolveReference({ __type: 'TestReference', id })
-      return expect(result).toEqual(output)
-    })
-
-    it('should use DataLoader when context is provided', async () => {
+    it('should use DataLoader to resolve reference', async () => {
       const { resolver, mockService } = await createResolverFromNest(TestResolver)
       const context = createContext()
       const id = 'id-1'
@@ -59,7 +45,6 @@ describe('ReferenceResolver', () => {
         stringField: 'foo'
       }
 
-      // Mock the query method for DataLoader with proper ts-mockito syntax
       when(mockService.query(anything())).thenResolve([output])
 
       // @ts-ignore
@@ -69,26 +54,21 @@ describe('ReferenceResolver', () => {
     })
 
     it('should reject if the id is not found', async () => {
-      const { resolver, mockService } = await createResolverFromNest(TestResolver)
-      const id = 'id-1'
-      const output: TestResolverDTO = {
-        id,
-        stringField: 'foo'
-      }
-      when(mockService.getById(id)).thenResolve(output)
+      const { resolver } = await createResolverFromNest(TestResolver)
+      const context = createContext()
+      
       // @ts-ignore
       // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/naming-convention
-      return expect(resolver.resolveReference({ __type: 'TestReference' })).rejects.toThrow(
+      return expect(resolver.resolveReference({ __type: 'TestReference' }, context)).rejects.toThrow(
         'Unable to resolve reference, missing required key id for TestResolverDTO'
       )
     })
 
-    it('should reject if entity is not found when using DataLoader', async () => {
+    it('should reject if entity is not found', async () => {
       const { resolver, mockService } = await createResolverFromNest(TestResolver)
       const context = createContext()
       const id = 'id-not-found'
 
-      // Mock the query method to return empty array
       when(mockService.query(anything())).thenResolve([])
 
       // @ts-ignore

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

@@ -33,7 +33,7 @@ export const Referenceable =
       @ResolveReference()
       async resolveReference(
         representation: RepresentationType,
-        @Context() context?: ExecutionContext,
+        @Context() context: ExecutionContext,
         @InjectDataLoaderConfig()
         dataLoaderConfig?: DataLoaderOptions
       ): Promise<DTO> {
@@ -42,25 +42,19 @@ export const Referenceable =
           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 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
+        const result = await loader.load({ id: id as string | number })
+        if (!result) {
+          throw new BadRequestException(`Unable to find ${baseName} with ${key}: ${String(id)}`)
         }
 
-        // Fallback to original behavior when context is not available (for backward compatibility)
-        return this.service.getById(representation[key] as string | number)
+        return result
       }
     }