refactor: integrate GraphQLFieldHelper for field request handling in DockerResolver

- Replaced the custom isFieldRequested method with GraphQLFieldHelper to streamline field request checks.
- Updated DockerResolver to utilize the new helper for determining if the sizeRootFs field is requested.
- Added unit tests to ensure correct behavior of field request handling in various scenarios.
- Improved clarity and maintainability of the resolver code.

Author: elibosley

api/generated-schema.graphql

@@ -1093,7 +1093,7 @@ type DockerContainer implements Node {
   created: Int!
   ports: [ContainerPort!]!
 
-  """Total size of all the files in the container in bytes"""
+  """Total size of all files in the container (in bytes)"""
   sizeRootFs: BigInt
   labels: JSON
   state: ContainerState!

api/src/unraid-api/graph/resolvers/docker/docker.resolver.spec.ts

@@ -8,6 +8,13 @@ import { ContainerState, DockerContainer } from '@app/unraid-api/graph/resolvers
 import { DockerResolver } from '@app/unraid-api/graph/resolvers/docker/docker.resolver.js';
 import { DockerService } from '@app/unraid-api/graph/resolvers/docker/docker.service.js';
 import { DockerOrganizerService } from '@app/unraid-api/graph/resolvers/docker/organizer/docker-organizer.service.js';
+import { GraphQLFieldHelper } from '@app/unraid-api/utils/graphql-field-helper.js';
+
+vi.mock('@app/unraid-api/utils/graphql-field-helper.js', () => ({
+    GraphQLFieldHelper: {
+        isFieldRequested: vi.fn(),
+    },
+}));
 
 describe('DockerResolver', () => {
     let resolver: DockerResolver;
@@ -41,6 +48,9 @@ describe('DockerResolver', () => {
 
         resolver = module.get<DockerResolver>(DockerResolver);
         dockerService = module.get<DockerService>(DockerService);
+
+        // Reset mocks before each test
+        vi.clearAllMocks();
     });
 
     it('should be defined', () => {
@@ -80,19 +90,13 @@ describe('DockerResolver', () => {
             },
         ];
         vi.mocked(dockerService.getContainers).mockResolvedValue(mockContainers);
+        vi.mocked(GraphQLFieldHelper.isFieldRequested).mockReturnValue(false);
 
-        const mockInfo = {
-            fieldNodes: [
-                {
-                    selectionSet: {
-                        selections: [],
-                    },
-                },
-            ],
-        } as any;
+        const mockInfo = {} as any;
 
         const result = await resolver.containers(false, mockInfo);
         expect(result).toEqual(mockContainers);
+        expect(GraphQLFieldHelper.isFieldRequested).toHaveBeenCalledWith(mockInfo, 'sizeRootFs');
         expect(dockerService.getContainers).toHaveBeenCalledWith({ skipCache: false, size: false });
     });
 
@@ -113,99 +117,48 @@ describe('DockerResolver', () => {
             },
         ];
         vi.mocked(dockerService.getContainers).mockResolvedValue(mockContainers);
+        vi.mocked(GraphQLFieldHelper.isFieldRequested).mockReturnValue(true);
 
-        const mockInfoWithSize = {
-            fieldNodes: [
-                {
-                    selectionSet: {
-                        selections: [
-                            {
-                                kind: 'Field',
-                                name: { value: 'sizeRootFs' },
-                            },
-                        ],
-                    },
-                },
-            ],
-        } as any;
+        const mockInfo = {} as any;
 
-        const result = await resolver.containers(false, mockInfoWithSize);
+        const result = await resolver.containers(false, mockInfo);
         expect(result).toEqual(mockContainers);
+        expect(GraphQLFieldHelper.isFieldRequested).toHaveBeenCalledWith(mockInfo, 'sizeRootFs');
         expect(dockerService.getContainers).toHaveBeenCalledWith({ skipCache: false, size: true });
     });
 
-    it('should request size when inline fragment is present', async () => {
+    it('should request size when GraphQLFieldHelper indicates sizeRootFs is requested', async () => {
         const mockContainers: DockerContainer[] = [];
         vi.mocked(dockerService.getContainers).mockResolvedValue(mockContainers);
+        vi.mocked(GraphQLFieldHelper.isFieldRequested).mockReturnValue(true);
 
-        const mockInfoWithFragment = {
-            fieldNodes: [
-                {
-                    selectionSet: {
-                        selections: [
-                            {
-                                kind: 'InlineFragment',
-                            },
-                        ],
-                    },
-                },
-            ],
-        } as any;
+        const mockInfo = {} as any;
 
-        await resolver.containers(false, mockInfoWithFragment);
+        await resolver.containers(false, mockInfo);
+        expect(GraphQLFieldHelper.isFieldRequested).toHaveBeenCalledWith(mockInfo, 'sizeRootFs');
         expect(dockerService.getContainers).toHaveBeenCalledWith({ skipCache: false, size: true });
     });
 
-    it('should request size when fragment spread is present', async () => {
+    it('should not request size when GraphQLFieldHelper indicates sizeRootFs is not requested', async () => {
         const mockContainers: DockerContainer[] = [];
         vi.mocked(dockerService.getContainers).mockResolvedValue(mockContainers);
+        vi.mocked(GraphQLFieldHelper.isFieldRequested).mockReturnValue(false);
 
-        const mockInfoWithFragmentSpread = {
-            fieldNodes: [
-                {
-                    selectionSet: {
-                        selections: [
-                            {
-                                kind: 'FragmentSpread',
-                            },
-                        ],
-                    },
-                },
-            ],
-        } as any;
+        const mockInfo = {} as any;
 
-        await resolver.containers(false, mockInfoWithFragmentSpread);
-        expect(dockerService.getContainers).toHaveBeenCalledWith({ skipCache: false, size: true });
+        await resolver.containers(false, mockInfo);
+        expect(GraphQLFieldHelper.isFieldRequested).toHaveBeenCalledWith(mockInfo, 'sizeRootFs');
+        expect(dockerService.getContainers).toHaveBeenCalledWith({ skipCache: false, size: false });
     });
 
-    it('should not request size when other fields are requested', async () => {
+    it('should handle skipCache parameter', async () => {
         const mockContainers: DockerContainer[] = [];
         vi.mocked(dockerService.getContainers).mockResolvedValue(mockContainers);
+        vi.mocked(GraphQLFieldHelper.isFieldRequested).mockReturnValue(false);
 
-        const mockInfoWithOtherFields = {
-            fieldNodes: [
-                {
-                    selectionSet: {
-                        selections: [
-                            {
-                                kind: 'Field',
-                                name: { value: 'id' },
-                            },
-                            {
-                                kind: 'Field',
-                                name: { value: 'names' },
-                            },
-                            {
-                                kind: 'Field',
-                                name: { value: 'state' },
-                            },
-                        ],
-                    },
-                },
-            ],
-        } as any;
+        const mockInfo = {} as any;
 
-        await resolver.containers(false, mockInfoWithOtherFields);
-        expect(dockerService.getContainers).toHaveBeenCalledWith({ skipCache: false, size: false });
+        await resolver.containers(true, mockInfo);
+        expect(dockerService.getContainers).toHaveBeenCalledWith({ skipCache: true, size: false });
     });
 });

api/src/unraid-api/graph/resolvers/docker/docker.resolver.ts

@@ -16,6 +16,7 @@ import { DockerService } from '@app/unraid-api/graph/resolvers/docker/docker.ser
 import { DockerOrganizerService } from '@app/unraid-api/graph/resolvers/docker/organizer/docker-organizer.service.js';
 import { DEFAULT_ORGANIZER_ROOT_ID } from '@app/unraid-api/organizer/organizer.js';
 import { ResolvedOrganizerV1 } from '@app/unraid-api/organizer/organizer.model.js';
+import { GraphQLFieldHelper } from '@app/unraid-api/utils/graphql-field-helper.js';
 
 @Resolver(() => Docker)
 export class DockerResolver {
@@ -45,8 +46,7 @@ export class DockerResolver {
         @Args('skipCache', { defaultValue: false, type: () => Boolean }) skipCache: boolean,
         @Info() info: GraphQLResolveInfo
     ) {
-        // Check if sizeRootFs field is requested in the query
-        const requestsSize = this.isFieldRequested(info, 'sizeRootFs');
+        const requestsSize = GraphQLFieldHelper.isFieldRequested(info, 'sizeRootFs');
         return this.dockerService.getContainers({ skipCache, size: requestsSize });
     }
 
@@ -146,21 +146,4 @@ export class DockerResolver {
     public async containerUpdateStatuses() {
         return this.dockerPhpService.getContainerUpdateStatuses();
     }
-
-    private isFieldRequested(info: GraphQLResolveInfo, fieldName: string): boolean {
-        const selections = info.fieldNodes[0]?.selectionSet?.selections;
-        if (!selections) return false;
-
-        for (const selection of selections) {
-            if (selection.kind === 'Field' && selection.name.value === fieldName) {
-                return true;
-            }
-            // Check nested selections for fragments
-            if (selection.kind === 'InlineFragment' || selection.kind === 'FragmentSpread') {
-                // For simplicity, if we see fragments, assume the field might be requested
-                return true;
-            }
-        }
-        return false;
-    }
 }