@tmdb-graphql-api/resolvers 0.1.0 → 0.1.1-unstable.1

package/src/queries/networkAlternativeNames.ts

@@ -1,28 +1,24 @@
-import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
 import { snakeCase } from 'lodash-es';
 import { ALTERNATIVE_NAMES, NETWORK } from '../constants.ts';
-import { type Context, type RawNetwork, type RawNetworkAlternativeNames } from '../types.ts';
+import { buildObjResolver } from '../helpers/buildObjResolver.ts';
+import { type RawNetwork, type RawNetworkAlternativeNames } from '../types.ts';
 
-export const resolveNetworkAlternativeNames = async (
-  { id }: RawNetwork,
-  _args: undefined,
-  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
-  { fieldNodes }: GraphQLResolveInfo
-) => {
-  const { data, errors, headers } = await restClient.network<RawNetworkAlternativeNames>(
-    {
-      pathTemplateData: { id, type: snakeCase(ALTERNATIVE_NAMES) },
-    },
-    { requestID, tmdbGuestSessionId }
-  );
+export const resolveNetworkAlternativeNames = buildObjResolver<RawNetwork, RawNetworkAlternativeNames['results']>(
+  NETWORK,
+  async (obj, ctx) => {
+    const { requestID, restClient, tmdbGuestSessionId } = ctx;
 
-  if (errors?.length) {
-    throw new GraphQLError(`Failed to resolve ${NETWORK} ${id} ${ALTERNATIVE_NAMES}.`, {
-      nodes: fieldNodes,
-      originalError: errors[0],
-    });
-  }
+    const { data, errors, headers } = await restClient.network<RawNetworkAlternativeNames>(
+      {
+        pathTemplateData: { id: obj.id, type: snakeCase(ALTERNATIVE_NAMES) },
+      },
+      { requestID, tmdbGuestSessionId }
+    );
 
-  setCacheMetadata(`${NETWORK}.${ALTERNATIVE_NAMES}`, headers);
-  return data!.results;
-};
+    return {
+      data: data?.results,
+      errors,
+      headers,
+    };
+  }
+);

package/src/queries/networkLogos.test.ts

@@ -1,44 +1,43 @@
 import { jest } from '@jest/globals';
-import { NETWORK_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import { NETWORK_PATH } from '@tmdb-graphql-api/rest-client';
 import networkDetails from '@tmdb-graphql-api/test-utils/responses/themoviedb/network/details.json';
 import networkLogos from '@tmdb-graphql-api/test-utils/responses/themoviedb/network/images.json';
 import { mockFetch } from 'fetch-mocked';
-import { type Getta, type ShortcutProperties } from 'getta';
 import { type GraphQLResolveInfo } from 'graphql';
 import { buildEndpoint } from '../__testUtils__/helpers/buildEndpoint.ts';
+import { createMockLogger } from '../__testUtils__/helpers/createMockLogger.ts';
 import { createRestClient } from '../__testUtils__/helpers/createRestClient.ts';
+import { IMAGES, LOGOS } from '../constants.ts';
 import { type Context, type RawNetwork } from '../types.ts';
 import { resolveNetworkLogos } from './networkLogos.ts';
 
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolveNetworkLogos >', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
+  const context = {
+    logger: createMockLogger(jest.fn),
+    restClient: createRestClient(),
+    setCacheMetadata: jest.fn(),
+    tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+  } as unknown as Context;
 
-  beforeAll(() => {
-    restClient = createRestClient();
-  });
+  const info = { fieldName: LOGOS } as GraphQLResolveInfo;
 
   beforeEach(() => {
-    mockedFetch.mockGetOnce(buildEndpoint(NETWORK_PATH, { id: 213, type: 'images' }), {
+    mockedFetch.mockGetOnce(buildEndpoint(NETWORK_PATH, { id: 213, type: IMAGES }), {
       body: networkLogos,
     });
   });
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   it('should return the network logos', async () => {
     await expect(
-      resolveNetworkLogos(
-        networkDetails as unknown as RawNetwork,
-        undefined,
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
-      )
+      resolveNetworkLogos(networkDetails as unknown as RawNetwork, undefined, context, info)
     ).resolves.toMatchSnapshot();
   });
 });

package/src/queries/networkLogos.ts

@@ -1,27 +1,20 @@
-import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
-import { IMAGES, LOGOS, NETWORK } from '../constants.ts';
-import { type Context, type RawNetwork, type RawNetworkLogos } from '../types.ts';
+import { IMAGES, NETWORK } from '../constants.ts';
+import { buildObjResolver } from '../helpers/buildObjResolver.ts';
+import { type RawNetwork, type RawNetworkLogos } from '../types.ts';
+
+export const resolveNetworkLogos = buildObjResolver<RawNetwork, RawNetworkLogos['logos']>(NETWORK, async (obj, ctx) => {
+  const { requestID, restClient, tmdbGuestSessionId } = ctx;
 
-export const resolveNetworkLogos = async (
-  { id }: RawNetwork,
-  _args: undefined,
-  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
-  { fieldNodes }: GraphQLResolveInfo
-) => {
   const { data, errors, headers } = await restClient.network<RawNetworkLogos>(
     {
-      pathTemplateData: { id, type: IMAGES },
+      pathTemplateData: { id: obj.id, type: IMAGES },
     },
     { requestID, tmdbGuestSessionId }
   );
 
-  if (errors?.length) {
-    throw new GraphQLError(`Failed to resolve ${NETWORK} ${id} ${LOGOS}.`, {
-      nodes: fieldNodes,
-      originalError: errors[0],
-    });
-  }
-
-  setCacheMetadata(`${NETWORK}.${LOGOS}`, headers);
-  return data!.logos;
-};
+  return {
+    data: data?.logos,
+    errors,
+    headers,
+  };
+});

package/src/queries/person.test.ts

@@ -9,6 +9,7 @@ import { mockFetch } from 'fetch-mocked';
 import { type FetchResponse, type Getta, type ShortcutProperties } from 'getta';
 import { type GraphQLResolveInfo, OperationTypeNode, parse } from 'graphql';
 import { buildEndpoint } from '../__testUtils__/helpers/buildEndpoint.ts';
+import { createMockLogger } from '../__testUtils__/helpers/createMockLogger.ts';
 import { createRestClient } from '../__testUtils__/helpers/createRestClient.ts';
 import { PERSON } from '../constants.ts';
 import { type Context } from '../types.ts';
@@ -17,13 +18,14 @@ import { resolvePerson } from './person.ts';
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolvePerson >', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
   const id = 3;
 
-  beforeAll(() => {
-    restClient = createRestClient();
-  });
+  const context = {
+    logger: createMockLogger(jest.fn),
+    restClient: createRestClient(),
+    setCacheMetadata: jest.fn(),
+    tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+  } as unknown as Context;
 
   beforeEach(() => {
     mockedFetch.mockGetOnce(buildEndpoint(PERSON_PATH, { id }), {
@@ -33,26 +35,21 @@ describe('resolvePerson >', () => {
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   it('should return the correct person details', async () => {
     const operationDefinition = getOperationDefinitions(parse(personDetailsQuery()), OperationTypeNode.QUERY)[0]!;
     const { fieldNode } = getChildFields(operationDefinition, { name: PERSON })![0]!;
-
-    await expect(
-      resolvePerson(
-        undefined,
-        { id },
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        { fieldNodes: [fieldNode] } as unknown as GraphQLResolveInfo
-      )
-    ).resolves.toMatchSnapshot();
+    const info = { fieldNodes: [fieldNode] } as unknown as GraphQLResolveInfo;
+    await expect(resolvePerson(undefined, { id: String(id) }, context, info)).resolves.toMatchSnapshot();
   });
 
   it('should request the correct resources when append to response fields are found', async () => {
     const operationDefinition = getOperationDefinitions(parse(personDetailsLgQuery()), OperationTypeNode.QUERY)[0]!;
     const { fieldNode } = getChildFields(operationDefinition, { name: PERSON })![0]!;
+    const info = { fieldNodes: [fieldNode] } as unknown as GraphQLResolveInfo;
 
     const personFetchMock = jest
       .fn<(...args: PlainArray) => Promise<FetchResponse>>()
@@ -60,13 +57,12 @@ describe('resolvePerson >', () => {
 
     await resolvePerson(
       undefined,
-      { id },
+      { id: String(id) },
       {
+        ...context,
         restClient: { person: personFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-        setCacheMetadata,
-        tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-      } as unknown as Context,
-      { fieldNodes: [fieldNode] } as unknown as GraphQLResolveInfo
+      },
+      info
     );
 
     expect(personFetchMock.mock.calls[0]![0]).toEqual(

package/src/queries/person.ts

@@ -1,5 +1,4 @@
 import { type QueryPersonArgs } from '@tmdb-graphql-api/schema/types';
-import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
 import { isUndefined, snakeCase } from 'lodash-es';
 import {
   COMBINED_CREDITS,
@@ -11,8 +10,9 @@ import {
   TRANSLATIONS,
   TV_CREDITS,
 } from '../constants.ts';
+import { buildObjArgsResolver } from '../helpers/buildObjArgsResolver.ts';
 import { getAppendToResponseKeys } from '../helpers/getAppendToResponseKeys.ts';
-import { type Context, type RawPerson, type RawPersonWithAppendToResponse } from '../types.ts';
+import { type RawPerson, type RawPersonWithAppendToResponse } from '../types.ts';
 
 const appendToResponse = {
   [COMBINED_CREDITS]: snakeCase(COMBINED_CREDITS),
@@ -23,16 +23,21 @@ const appendToResponse = {
   [TV_CREDITS]: snakeCase(TV_CREDITS),
 };
 
-export const resolvePerson = async (
-  obj: RawPerson | undefined,
-  args: QueryPersonArgs,
-  { fragmentDefinitions, requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
-  { fieldName, fieldNodes }: GraphQLResolveInfo
-) => {
+export const resolvePerson = buildObjArgsResolver<
+  RawPerson,
+  QueryPersonArgs,
+  | (RawPersonWithAppendToResponse & { __headers?: Headers })
+  | RawPersonWithAppendToResponse[keyof RawPersonWithAppendToResponse]
+>(PERSON, async (obj, args, ctx, info) => {
+  const { fragmentDefinitions, requestID, restClient, tmdbGuestSessionId } = ctx;
+  const { fieldName, fieldNodes } = info;
   const typedFieldName = snakeCase(fieldName) as keyof RawPerson;
 
   if (obj && !isUndefined(obj[typedFieldName])) {
-    return obj[typedFieldName];
+    return {
+      data: obj[typedFieldName],
+      source: 'parentNode',
+    };
   }
 
   const id = obj ? obj.id : args.id;
@@ -52,15 +57,9 @@ export const resolvePerson = async (
     { requestID, tmdbGuestSessionId }
   );
 
-  if (errors?.length) {
-    throw new GraphQLError(`Failed to resolve ${PERSON} ${id}.`, { nodes: fieldNodes, originalError: errors[0] });
-  }
-
-  if (obj) {
-    setCacheMetadata(`${PERSON}.${fieldName}`, headers);
-    return data![typedFieldName];
-  }
-
-  setCacheMetadata(PERSON, headers);
-  return appendToResponseKeys.length > 0 ? { ...data, __headers: headers } : data;
-};
+  return {
+    data: obj ? data?.[typedFieldName] : appendToResponseKeys.length > 0 ? { ...data, __headers: headers } : data,
+    errors,
+    headers,
+  };
+});

package/src/queries/personCombinedCredits.test.ts

@@ -6,42 +6,42 @@ import personDetails from '@tmdb-graphql-api/test-utils/responses/themoviedb/per
 import { mockFetch } from 'fetch-mocked';
 import { type FetchResponse, type Getta, type ShortcutProperties } from 'getta';
 import { type GraphQLResolveInfo } from 'graphql';
+import { snakeCase } from 'lodash-es';
 import { buildEndpoint } from '../__testUtils__/helpers/buildEndpoint.ts';
+import { createMockLogger } from '../__testUtils__/helpers/createMockLogger.ts';
 import { createRestClient } from '../__testUtils__/helpers/createRestClient.ts';
-import { type Context, type RawPerson, type RawPersonWithAppendToResponse } from '../types.ts';
+import { COMBINED_CREDITS } from '../constants.ts';
+import { type Context } from '../types.ts';
 import { resolvePersonCombinedCredits } from './personCombinedCredits.ts';
 
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolvePersonCombinedCredits >', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
   const personId = 3;
 
-  beforeAll(() => {
-    restClient = createRestClient();
-  });
+  const context = {
+    logger: createMockLogger(jest.fn),
+    restClient: createRestClient(),
+    setCacheMetadata: jest.fn(),
+    tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+  } as unknown as Context;
+
+  const info = { fieldName: COMBINED_CREDITS } as GraphQLResolveInfo;
 
   beforeEach(() => {
-    mockedFetch.mockGetOnce(buildEndpoint(PERSON_PATH, { id: personId, type: 'combined_credits' }), {
+    mockedFetch.mockGetOnce(buildEndpoint(PERSON_PATH, { id: personId, type: snakeCase(COMBINED_CREDITS) }), {
       body: personCombinedCredits,
     });
   });
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   it('should return the person combined credits', async () => {
-    await expect(
-      resolvePersonCombinedCredits(
-        personDetails as RawPerson,
-        undefined,
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
-      )
-    ).resolves.toMatchSnapshot();
+    await expect(resolvePersonCombinedCredits(personDetails, undefined, context, info)).resolves.toMatchSnapshot();
   });
 
   describe('when raw person data has combined credits', () => {
@@ -57,15 +57,15 @@ describe('resolvePersonCombinedCredits >', () => {
           {
             ...personDetails,
             __headers: new Headers(),
+            // @ts-expect-error minor type mismatch
             combined_credits: rest,
-          } as unknown as RawPersonWithAppendToResponse,
+          },
           undefined,
           {
+            ...context,
             restClient: { person: personFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-            setCacheMetadata,
-            tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-          } as unknown as Context,
-          {} as GraphQLResolveInfo
+          },
+          info
         )
       ).resolves.toMatchSnapshot();
     });
@@ -81,15 +81,15 @@ describe('resolvePersonCombinedCredits >', () => {
         {
           ...personDetails,
           __headers: new Headers(),
+          // @ts-expect-error minor type mismatch
           combined_credits: rest,
-        } as unknown as RawPersonWithAppendToResponse,
+        },
         undefined,
         {
+          ...context,
           restClient: { person: personFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-          setCacheMetadata,
-          tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-        } as unknown as Context,
-        {} as GraphQLResolveInfo
+        },
+        info
       );
 
       expect(personFetchMock).not.toHaveBeenCalled();

package/src/queries/personCombinedCredits.ts

@@ -1,17 +1,26 @@
-import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
 import { snakeCase } from 'lodash-es';
+import type { Except } from 'type-fest';
 import { COMBINED_CREDITS, PERSON } from '../constants.ts';
-import { type Context, type RawPersonCombinedCredits, type RawPersonWithAppendToResponse } from '../types.ts';
+import { buildObjResolver } from '../helpers/buildObjResolver.ts';
+import { type RawPerson, type RawPersonCombinedCredits, type RawPersonWithAppendToResponse } from '../types.ts';
 
-export const resolvePersonCombinedCredits = async (
-  obj: RawPersonWithAppendToResponse & { __headers?: Headers },
-  _args: undefined,
-  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
-  { fieldNodes }: GraphQLResolveInfo
-) => {
-  if (obj.combined_credits && obj.__headers) {
-    setCacheMetadata(`${PERSON}.${COMBINED_CREDITS}`, obj.__headers);
-    return obj.combined_credits;
+const isRawPersonWithCombinedCredits = (
+  obj: RawPerson | (RawPersonWithAppendToResponse & { __headers?: Headers })
+): obj is RawPersonWithAppendToResponse & { __headers: Headers } =>
+  snakeCase(COMBINED_CREDITS) in obj && '__headers' in obj;
+
+export const resolvePersonCombinedCredits = buildObjResolver<
+  RawPerson | (RawPersonWithAppendToResponse & { __headers?: Headers }),
+  Except<RawPersonCombinedCredits, 'id'>
+>(PERSON, async (obj, ctx) => {
+  const { requestID, restClient, tmdbGuestSessionId } = ctx;
+
+  if (isRawPersonWithCombinedCredits(obj)) {
+    return {
+      data: obj.combined_credits,
+      headers: obj.__headers,
+      source: 'parentNode',
+    };
   }
 
   const { data, errors, headers } = await restClient.person<RawPersonCombinedCredits>(
@@ -21,14 +30,11 @@ export const resolvePersonCombinedCredits = async (
     { requestID, tmdbGuestSessionId }
   );
 
-  if (errors?.length) {
-    throw new GraphQLError(`Failed to resolve ${PERSON} ${obj.id} ${COMBINED_CREDITS}.`, {
-      nodes: fieldNodes,
-      originalError: errors[0],
-    });
-  }
+  const { id: personId, ...rest } = data ?? {};
 
-  setCacheMetadata(`${PERSON}.${COMBINED_CREDITS}`, headers);
-  const { id: personId, ...rest } = data!;
-  return rest;
-};
+  return {
+    data: rest,
+    errors,
+    headers,
+  };
+});

package/src/queries/personExternalIds.test.ts

@@ -6,42 +6,42 @@ import personExternalIds from '@tmdb-graphql-api/test-utils/responses/themoviedb
 import { mockFetch } from 'fetch-mocked';
 import { type FetchResponse, type Getta, type ShortcutProperties } from 'getta';
 import { type GraphQLResolveInfo } from 'graphql';
+import { snakeCase } from 'lodash-es';
 import { buildEndpoint } from '../__testUtils__/helpers/buildEndpoint.ts';
+import { createMockLogger } from '../__testUtils__/helpers/createMockLogger.ts';
 import { createRestClient } from '../__testUtils__/helpers/createRestClient.ts';
-import { type Context, type RawPerson, type RawPersonWithAppendToResponse } from '../types.ts';
+import { EXTERNAL_IDS } from '../constants.ts';
+import { type Context } from '../types.ts';
 import { resolvePersonExternalIds } from './personExternalIds.ts';
 
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolvePersonExternalIds >', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
   const personId = 3;
 
-  beforeAll(() => {
-    restClient = createRestClient();
-  });
+  const context = {
+    logger: createMockLogger(jest.fn),
+    restClient: createRestClient(),
+    setCacheMetadata: jest.fn(),
+    tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+  } as unknown as Context;
+
+  const info = { fieldName: EXTERNAL_IDS } as GraphQLResolveInfo;
 
   beforeEach(() => {
-    mockedFetch.mockGetOnce(buildEndpoint(PERSON_PATH, { id: personId, type: 'external_ids' }), {
+    mockedFetch.mockGetOnce(buildEndpoint(PERSON_PATH, { id: personId, type: snakeCase(EXTERNAL_IDS) }), {
       body: personExternalIds,
     });
   });
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   it('should return the person external IDs', async () => {
-    await expect(
-      resolvePersonExternalIds(
-        personDetails as unknown as RawPerson,
-        undefined,
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
-      )
-    ).resolves.toMatchSnapshot();
+    await expect(resolvePersonExternalIds(personDetails, undefined, context, info)).resolves.toMatchSnapshot();
   });
 
   describe('when raw person data has external IDs', () => {
@@ -57,15 +57,15 @@ describe('resolvePersonExternalIds >', () => {
           {
             ...personDetails,
             __headers: new Headers(),
+            // @ts-expect-error minor type mismatch
             external_ids: rest,
-          } as unknown as RawPersonWithAppendToResponse,
+          },
           undefined,
           {
+            ...context,
             restClient: { person: personFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-            setCacheMetadata,
-            tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-          } as unknown as Context,
-          {} as GraphQLResolveInfo
+          },
+          info
         )
       ).resolves.toMatchSnapshot();
     });
@@ -81,15 +81,15 @@ describe('resolvePersonExternalIds >', () => {
         {
           ...personDetails,
           __headers: new Headers(),
+          // @ts-expect-error minor type mismatch
           external_ids: rest,
-        } as unknown as RawPersonWithAppendToResponse,
+        },
         undefined,
         {
+          ...context,
           restClient: { person: personFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-          setCacheMetadata,
-          tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-        } as unknown as Context,
-        {} as GraphQLResolveInfo
+        },
+        info
       );
 
       expect(personFetchMock).not.toHaveBeenCalled();

package/src/queries/personExternalIds.ts

@@ -1,17 +1,26 @@
-import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
 import { snakeCase } from 'lodash-es';
+import type { Except } from 'type-fest';
 import { EXTERNAL_IDS, PERSON } from '../constants.ts';
-import { type Context, type RawPersonExternalIds, type RawPersonWithAppendToResponse } from '../types.ts';
+import { buildObjResolver } from '../helpers/buildObjResolver.ts';
+import { type RawPerson, type RawPersonExternalIds, type RawPersonWithAppendToResponse } from '../types.ts';
 
-export const resolvePersonExternalIds = async (
-  obj: RawPersonWithAppendToResponse & { __headers?: Headers },
-  _args: undefined,
-  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
-  { fieldNodes }: GraphQLResolveInfo
-) => {
-  if (obj.external_ids && obj.__headers) {
-    setCacheMetadata(`${PERSON}.${EXTERNAL_IDS}`, obj.__headers);
-    return obj.external_ids;
+const isRawPersonWithExternalIds = (
+  obj: RawPerson | (RawPersonWithAppendToResponse & { __headers?: Headers })
+): obj is RawPersonWithAppendToResponse & { __headers: Headers } =>
+  snakeCase(EXTERNAL_IDS) in obj && '__headers' in obj;
+
+export const resolvePersonExternalIds = buildObjResolver<
+  RawPerson | (RawPersonWithAppendToResponse & { __headers?: Headers }),
+  Except<RawPersonExternalIds, 'id'>
+>(PERSON, async (obj, ctx) => {
+  const { requestID, restClient, tmdbGuestSessionId } = ctx;
+
+  if (isRawPersonWithExternalIds(obj)) {
+    return {
+      data: obj.external_ids,
+      headers: obj.__headers,
+      source: 'parentNode',
+    };
   }
 
   const { data, errors, headers } = await restClient.person<RawPersonExternalIds>(
@@ -21,14 +30,11 @@ export const resolvePersonExternalIds = async (
     { requestID, tmdbGuestSessionId }
   );
 
-  if (errors?.length) {
-    throw new GraphQLError(`Failed to resolve ${PERSON} ${obj.id} ${EXTERNAL_IDS}.`, {
-      nodes: fieldNodes,
-      originalError: errors[0],
-    });
-  }
+  const { id: personId, ...rest } = data ?? {};
 
-  setCacheMetadata(`${PERSON}.${EXTERNAL_IDS}`, headers);
-  const { id: personId, ...rest } = data!;
-  return rest;
-};
+  return {
+    data: rest,
+    errors,
+    headers,
+  };
+});