@tmdb-graphql-api/resolvers 0.0.34 → 0.1.1-unstable.0

package/src/queries/episode.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 { EPISODE } from '../constants.ts';
 import { encodeId } from '../helpers/encodeId.ts';
@@ -18,13 +19,14 @@ import { resolveEpisode } from './episode.ts';
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolveEpisode >', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
   const id = 1399;
 
-  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(EPISODE_PATH, { episodeNumber: 1, id, seasonNumber: 1 }), {
@@ -34,26 +36,24 @@ describe('resolveEpisode >', () => {
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   it('should return the correct episode details', async () => {
     const operationDefinition = getOperationDefinitions(parse(episodeDetailsQuery()), OperationTypeNode.QUERY)[0]!;
     const { fieldNode } = getChildFields(operationDefinition, { name: EPISODE })![0]!;
+    const info = { fieldNodes: [fieldNode] } as unknown as GraphQLResolveInfo;
 
     await expect(
-      resolveEpisode(
-        undefined,
-        { episodeLookupId: encodeId({ episodeNumber: 1, id, seasonNumber: 1 }) },
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        { fieldNodes: [fieldNode] } as unknown as GraphQLResolveInfo
-      )
+      resolveEpisode(undefined, { id: encodeId({ episodeNumber: 1, id, seasonNumber: 1 }) }, context, info)
     ).resolves.toMatchSnapshot();
   });
 
   it('should request the correct resources when append to response fields are found', async () => {
     const operationDefinition = getOperationDefinitions(parse(episodeDetailsLgQuery()), OperationTypeNode.QUERY)[0]!;
     const { fieldNode } = getChildFields(operationDefinition, { name: EPISODE })![0]!;
+    const info = { fieldNodes: [fieldNode] } as unknown as GraphQLResolveInfo;
 
     const episodeFetchMock = jest
       .fn<(...args: PlainArray) => Promise<FetchResponse>>()
@@ -61,13 +61,12 @@ describe('resolveEpisode >', () => {
 
     await resolveEpisode(
       undefined,
-      { episodeLookupId: encodeId({ episodeNumber: 1, id, seasonNumber: 1 }) },
+      { id: encodeId({ episodeNumber: 1, id, seasonNumber: 1 }) },
       {
+        ...context,
         restClient: { episode: episodeFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-        setCacheMetadata,
-        tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-      } as unknown as Context,
-      { fieldNodes: [fieldNode] } as unknown as GraphQLResolveInfo
+      },
+      info
     );
 
     expect(episodeFetchMock.mock.calls[0]![0]).toEqual(

package/src/queries/episode.ts

@@ -1,11 +1,11 @@
 import { type QueryEpisodeArgs } from '@tmdb-graphql-api/schema/types';
-import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
 import { isUndefined, snakeCase } from 'lodash-es';
-import { CREDITS, EPISODE, EXTERNAL_IDS, IMAGES, SEASON, TRANSLATIONS, TV, VIDEOS } from '../constants.ts';
+import { CREDITS, EPISODE, EXTERNAL_IDS, IMAGES, TRANSLATIONS, VIDEOS } from '../constants.ts';
+import { buildObjArgsResolver } from '../helpers/buildObjArgsResolver.ts';
 import { encodeId } from '../helpers/encodeId.ts';
 import { getAppendToResponseKeys } from '../helpers/getAppendToResponseKeys.ts';
 import { getTvIdSeasonAndEpisode } from '../helpers/getTvIdSeasonAndEpisode.ts';
-import { type Context, type RawEpisode, type RawEpisodeWithAppendToResponse } from '../types.ts';
+import { type EnrichedRawEpisode, type EnrichedRawEpisodeWithAppendToResponse, type RawEpisode } from '../types.ts';
 
 const appendToResponse = {
   [EXTERNAL_IDS]: snakeCase(EXTERNAL_IDS),
@@ -17,26 +17,32 @@ const appendToResponse = {
   stills: IMAGES,
 };
 
-export const resolveEpisode = async (
-  obj: RawEpisode | undefined,
-  args: QueryEpisodeArgs,
-  { fragmentDefinitions, requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
-  { fieldName, fieldNodes }: GraphQLResolveInfo
-) => {
+export const resolveEpisode = buildObjArgsResolver<
+  EnrichedRawEpisode,
+  QueryEpisodeArgs,
+  | (EnrichedRawEpisodeWithAppendToResponse & { __headers?: Headers })
+  | EnrichedRawEpisodeWithAppendToResponse[keyof EnrichedRawEpisodeWithAppendToResponse]
+>(EPISODE, async (obj, args, ctx, info) => {
+  const { fragmentDefinitions, requestID, restClient, tmdbGuestSessionId } = ctx;
+  const { fieldName, fieldNodes } = info;
   const typedFieldName = snakeCase(fieldName) as keyof RawEpisode;
-  const { episodeNumber, seasonNumber, tvId } = getTvIdSeasonAndEpisode(obj, args.episodeLookupId);
+  const { episodeNumber, id, seasonNumber } = getTvIdSeasonAndEpisode(obj, args);
 
   if (obj && !isUndefined(obj[typedFieldName])) {
-    return typedFieldName === 'episode_lookup_id'
-      ? encodeId({ seasonNumber, tvId, ...(episodeNumber ? { episodeNumber } : {}) })
-      : obj[typedFieldName];
+    return {
+      data:
+        typedFieldName === 'id'
+          ? encodeId({ id, seasonNumber, ...(episodeNumber ? { episodeNumber } : {}) })
+          : obj[typedFieldName],
+      source: 'parentNode',
+    };
   }
 
   const appendToResponseKeys = getAppendToResponseKeys(fieldNodes[0]!, appendToResponse, fragmentDefinitions);
 
-  const { data, errors, headers } = await restClient.episode<RawEpisodeWithAppendToResponse>(
+  const { data, errors, headers } = await restClient.episode<EnrichedRawEpisodeWithAppendToResponse>(
     {
-      pathTemplateData: { episodeNumber, id: tvId, seasonNumber },
+      pathTemplateData: { episodeNumber, id, seasonNumber },
       ...(appendToResponseKeys.length > 0
         ? {
             queryParams: {
@@ -48,25 +54,19 @@ export const resolveEpisode = async (
     { requestID, tmdbGuestSessionId }
   );
 
-  if (errors?.length) {
-    throw new GraphQLError(
-      `Failed to resolve ${TV} show ${tvId} ${SEASON} ${seasonNumber} ${EPISODE} ${episodeNumber!}.`,
-      { nodes: fieldNodes, originalError: errors[0] }
-    );
-  }
-
-  const rawEpisode = data!;
-  rawEpisode.episode_lookup_id = encodeId({ seasonNumber, tvId, ...(episodeNumber ? { episodeNumber } : {}) });
-
-  if (!rawEpisode.tv_show_id) {
-    rawEpisode.tv_show_id = tvId;
-  }
+  const episodeData = {
+    ...data,
+    id: encodeId({ id, seasonNumber, ...(episodeNumber ? { episodeNumber } : {}) }),
+    tv_show_id: Number(id),
+  };
 
-  if (obj) {
-    setCacheMetadata(`${EPISODE}.${fieldName}`, headers);
-    return rawEpisode[typedFieldName];
-  }
-
-  setCacheMetadata(EPISODE, headers);
-  return appendToResponseKeys.length > 0 ? { ...rawEpisode, __headers: headers } : rawEpisode;
-};
+  return {
+    data: obj
+      ? episodeData[typedFieldName]
+      : appendToResponseKeys.length > 0
+      ? { ...episodeData, __headers: headers }
+      : episodeData,
+    errors,
+    headers,
+  };
+});

package/src/queries/episodeCredits.test.ts

@@ -7,89 +7,59 @@ import { mockFetch } from 'fetch-mocked';
 import { type FetchResponse, 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 { encodeId } from '../helpers/encodeId.ts';
-import { type Context, type RawEpisode } from '../types.ts';
+import { CAST, CREDITS, CREW, GUEST_STARS } from '../constants.ts';
+import { type Context } from '../types.ts';
 import { resolveEpisodeCredits } from './episodeCredits.ts';
 
 const mockedFetch = mockFetch(jest.fn);
 
-const episodeDetailsWithLookupId: RawEpisode = {
-  ...episodeDetails,
-  episode_lookup_id: encodeId({
-    episodeNumber: episodeDetails.episode_number,
-    seasonNumber: episodeDetails.season_number,
-    tvId: episodeDetails.tv_show_id,
-  }),
-};
-
 describe('resolveEpisodeCredits >', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
   const tvShowId = 1399;
   const seasonNumber = 1;
   const episodeNumber = 1;
 
-  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(EPISODE_PATH, { episodeNumber, id: tvShowId, seasonNumber, type: 'credits' }),
-      {
-        body: episodeCredits,
-      }
-    );
+    mockedFetch.mockGetOnce(buildEndpoint(EPISODE_PATH, { episodeNumber, id: tvShowId, seasonNumber, type: CREDITS }), {
+      body: episodeCredits,
+    });
   });
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   describe('when fieldName is cast', () => {
     it('should return the correct response', async () => {
-      await expect(
-        resolveEpisodeCredits(
-          episodeDetailsWithLookupId,
-          undefined,
-          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-          {
-            fieldName: 'cast',
-          } as GraphQLResolveInfo
-        )
-      ).resolves.toMatchSnapshot();
+      const info = { fieldName: CAST } as GraphQLResolveInfo;
+      // @ts-expect-error arg is slightly modified version of episode details
+      await expect(resolveEpisodeCredits(episodeDetails, undefined, context, info)).resolves.toMatchSnapshot();
     });
   });
 
   describe('when fieldName is crew', () => {
     it('should return the correct response', async () => {
-      await expect(
-        resolveEpisodeCredits(
-          episodeDetailsWithLookupId,
-          undefined,
-          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-          {
-            fieldName: 'crew',
-          } as GraphQLResolveInfo
-        )
-      ).resolves.toMatchSnapshot();
+      const info = { fieldName: CREW } as GraphQLResolveInfo;
+      // @ts-expect-error arg is slightly modified version of episode details
+      await expect(resolveEpisodeCredits(episodeDetails, undefined, context, info)).resolves.toMatchSnapshot();
     });
   });
 
   describe('when fieldName is guestStars', () => {
     it('should return the correct response', async () => {
-      await expect(
-        resolveEpisodeCredits(
-          episodeDetailsWithLookupId,
-          undefined,
-          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-          {
-            fieldName: 'guestStars',
-          } as GraphQLResolveInfo
-        )
-      ).resolves.toMatchSnapshot();
+      const info = { fieldName: GUEST_STARS } as GraphQLResolveInfo;
+      // @ts-expect-error arg is slightly modified version of episode details
+      await expect(resolveEpisodeCredits(episodeDetails, undefined, context, info)).resolves.toMatchSnapshot();
     });
   });
 
@@ -100,19 +70,18 @@ describe('resolveEpisodeCredits >', () => {
         .mockResolvedValue({ data: {} } as FetchResponse);
 
       const { id, ...rest } = episodeCredits;
+      const info = { fieldName: GUEST_STARS } as GraphQLResolveInfo;
 
       await expect(
         resolveEpisodeCredits(
-          { ...episodeDetailsWithLookupId, __headers: new Headers(), credits: rest },
+          // @ts-expect-error arg is slightly modified version of credits
+          { ...episodeDetails, __headers: new Headers(), credits: rest },
           undefined,
           {
+            ...context,
             restClient: { episode: episodeFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-            setCacheMetadata,
-            tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-          } as unknown as Context,
-          {
-            fieldName: 'guestStars',
-          } as GraphQLResolveInfo
+          },
+          info
         )
       ).resolves.toMatchSnapshot();
     });
@@ -123,18 +92,17 @@ describe('resolveEpisodeCredits >', () => {
         .mockResolvedValue({ data: {} } as FetchResponse);
 
       const { id, ...rest } = episodeCredits;
+      const info = { fieldName: GUEST_STARS } as GraphQLResolveInfo;
 
       await resolveEpisodeCredits(
-        { ...episodeDetailsWithLookupId, __headers: new Headers(), credits: rest },
+        // @ts-expect-error arg is slightly modified version of credits
+        { ...episodeDetails, __headers: new Headers(), credits: rest },
         undefined,
         {
+          ...context,
           restClient: { episode: episodeFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-          setCacheMetadata,
-          tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-        } as unknown as Context,
-        {
-          fieldName: 'guestStars',
-        } as GraphQLResolveInfo
+        },
+        info
       );
 
       expect(episodeFetchMock).not.toHaveBeenCalled();

package/src/queries/episodeCredits.ts

@@ -1,19 +1,30 @@
-import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
 import { snakeCase } from 'lodash-es';
-import { CREDITS, EPISODE, SEASON, TV } from '../constants.ts';
-import { type Context, type RawEpisodeCredits, type RawEpisodeWithAppendToResponse } from '../types.ts';
+import { CREDITS, EPISODE } from '../constants.ts';
+import { buildObjResolver } from '../helpers/buildObjResolver.ts';
+import {
+  type EnrichedRawEpisode,
+  type EnrichedRawEpisodeWithAppendToResponse,
+  type RawEpisodeCredits,
+} from '../types.ts';
 
-export const resolveEpisodeCredits = async (
-  obj: RawEpisodeWithAppendToResponse & { __headers?: Headers },
-  _args: undefined,
-  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
-  { fieldName, fieldNodes }: GraphQLResolveInfo
-) => {
+const isEnrichedRawEpisodeWithCredits = (
+  obj: EnrichedRawEpisode | (EnrichedRawEpisodeWithAppendToResponse & { __headers?: Headers })
+): obj is EnrichedRawEpisodeWithAppendToResponse & { __headers: Headers } => CREDITS in obj && '__headers' in obj;
+
+export const resolveEpisodeCredits = buildObjResolver<
+  EnrichedRawEpisode | (EnrichedRawEpisodeWithAppendToResponse & { __headers?: Headers }),
+  RawEpisodeCredits['cast'] | RawEpisodeCredits['crew'] | RawEpisodeCredits['guest_stars']
+>(EPISODE, async (obj, ctx, info) => {
+  const { requestID, restClient, tmdbGuestSessionId } = ctx;
+  const { fieldName } = info;
   const typedFieldName = snakeCase(fieldName) as 'cast' | 'crew' | 'guest_stars';
 
-  if (obj.credits && obj.__headers) {
-    setCacheMetadata(`${EPISODE}.${fieldName}`, obj.__headers);
-    return obj.credits[typedFieldName];
+  if (isEnrichedRawEpisodeWithCredits(obj)) {
+    return {
+      data: obj.credits?.[typedFieldName],
+      headers: obj.__headers,
+      source: 'parentNode',
+    };
   }
 
   const { data, errors, headers } = await restClient.episode<RawEpisodeCredits>(
@@ -28,13 +39,9 @@ export const resolveEpisodeCredits = async (
     { requestID, tmdbGuestSessionId }
   );
 
-  if (errors?.length) {
-    throw new GraphQLError(
-      `Failed to resolve ${TV} show ${obj.tv_show_id} ${SEASON} ${obj.season_number} ${EPISODE} ${obj.episode_number} ${fieldName}.`,
-      { nodes: fieldNodes, originalError: errors[0] }
-    );
-  }
-
-  setCacheMetadata(`${EPISODE}.${fieldName}`, headers);
-  return data![typedFieldName];
-};
+  return {
+    data: data?.[typedFieldName],
+    errors,
+    headers,
+  };
+});

package/src/queries/episodeExternalIds.test.ts

@@ -6,37 +6,33 @@ import seasonExternalIds 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 { encodeId } from '../helpers/encodeId.ts';
-import { type Context, type RawEpisode, type RawEpisodeWithAppendToResponse } from '../types.ts';
+import { EXTERNAL_IDS } from '../constants.ts';
+import { type Context, type EnrichedRawEpisodeWithAppendToResponse } from '../types.ts';
 import { resolveEpisodeExternalIds } from './episodeExternalIds.ts';
 
 const mockedFetch = mockFetch(jest.fn);
 
-const episodeDetailsWithLookupId: RawEpisode = {
-  ...episodeDetails,
-  episode_lookup_id: encodeId({
-    episodeNumber: episodeDetails.episode_number,
-    seasonNumber: episodeDetails.season_number,
-    tvId: episodeDetails.tv_show_id,
-  }),
-};
-
 describe('resolveEpisodeExternalIds >', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
   const tvShowId = 1399;
   const seasonNumber = 1;
   const episodeNumber = 1;
 
-  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(EPISODE_PATH, { episodeNumber, id: tvShowId, seasonNumber, type: 'external_ids' }),
+      buildEndpoint(EPISODE_PATH, { episodeNumber, id: tvShowId, seasonNumber, type: snakeCase(EXTERNAL_IDS) }),
       {
         body: seasonExternalIds,
       }
@@ -45,17 +41,14 @@ describe('resolveEpisodeExternalIds >', () => {
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   it('should return the episode external IDs', async () => {
     await expect(
-      resolveEpisodeExternalIds(
-        episodeDetailsWithLookupId,
-        undefined,
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
-      )
+      // @ts-expect-error arg is slightly modified version of episode details
+      resolveEpisodeExternalIds(episodeDetails, undefined, context, info)
     ).resolves.toMatchSnapshot();
   });
 
@@ -69,18 +62,14 @@ describe('resolveEpisodeExternalIds >', () => {
 
       await expect(
         resolveEpisodeExternalIds(
-          {
-            ...episodeDetailsWithLookupId,
-            __headers: new Headers(),
-            external_ids: rest,
-          } as unknown as RawEpisodeWithAppendToResponse,
+          // @ts-expect-error arg is slightly modified version of episode details
+          { ...episodeDetails, __headers: new Headers(), external_ids: rest },
           undefined,
           {
+            ...context,
             restClient: { episode: episodeFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-            setCacheMetadata,
-            tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-          } as unknown as Context,
-          {} as GraphQLResolveInfo
+          },
+          info
         )
       ).resolves.toMatchSnapshot();
     });
@@ -94,17 +83,16 @@ describe('resolveEpisodeExternalIds >', () => {
 
       await resolveEpisodeExternalIds(
         {
-          ...episodeDetailsWithLookupId,
+          ...episodeDetails,
           __headers: new Headers(),
           external_ids: rest,
-        } as unknown as RawEpisodeWithAppendToResponse,
+        } as unknown as EnrichedRawEpisodeWithAppendToResponse,
         undefined,
         {
+          ...context,
           restClient: { episode: episodeFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-          setCacheMetadata,
-          tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-        } as unknown as Context,
-        {} as GraphQLResolveInfo
+        },
+        info
       );
 
       expect(episodeFetchMock).not.toHaveBeenCalled();

package/src/queries/episodeExternalIds.ts

@@ -1,17 +1,32 @@
-import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
 import { snakeCase } from 'lodash-es';
-import { EPISODE, EXTERNAL_IDS, SEASON, TV } from '../constants.ts';
-import { type Context, type RawEpisodeExternalIds, type RawEpisodeWithAppendToResponse } from '../types.ts';
+import type { Except } from 'type-fest';
+import { EPISODE, EXTERNAL_IDS } from '../constants.ts';
+import { buildObjResolver } from '../helpers/buildObjResolver.ts';
+import {
+  type EnrichedRawEpisode,
+  type EnrichedRawEpisodeWithAppendToResponse,
+  type RawEpisodeExternalIds,
+} from '../types.ts';
 
-export const resolveEpisodeExternalIds = async (
-  obj: RawEpisodeWithAppendToResponse & { __headers?: Headers },
-  _args: undefined,
-  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
-  { fieldNodes }: GraphQLResolveInfo
-) => {
-  if (obj.external_ids && obj.__headers) {
-    setCacheMetadata(`${EPISODE}.${EXTERNAL_IDS}`, obj.__headers);
-    return obj.external_ids;
+const isEnrichedRawEpisodeWithExternalIds = (
+  obj: EnrichedRawEpisode | (EnrichedRawEpisodeWithAppendToResponse & { __headers?: Headers })
+): obj is EnrichedRawEpisodeWithAppendToResponse & { __headers: Headers } =>
+  snakeCase(EXTERNAL_IDS) in obj && '__headers' in obj;
+
+export const resolveEpisodeExternalIds = buildObjResolver<
+  EnrichedRawEpisode | (EnrichedRawEpisodeWithAppendToResponse & { __headers?: Headers }),
+  Except<RawEpisodeExternalIds, 'id'>
+>(EPISODE, async (obj, ctx, info) => {
+  const { requestID, restClient, tmdbGuestSessionId } = ctx;
+  const { fieldName } = info;
+  const typedFieldName = snakeCase(fieldName) as 'external_ids';
+
+  if (isEnrichedRawEpisodeWithExternalIds(obj)) {
+    return {
+      data: obj[typedFieldName],
+      headers: obj.__headers,
+      source: 'parentNode',
+    };
   }
 
   const { data, errors, headers } = await restClient.episode<RawEpisodeExternalIds>(
@@ -20,20 +35,17 @@ export const resolveEpisodeExternalIds = async (
         episodeNumber: obj.episode_number,
         id: obj.tv_show_id,
         seasonNumber: obj.season_number,
-        type: snakeCase(EXTERNAL_IDS),
+        type: typedFieldName,
       },
     },
     { requestID, tmdbGuestSessionId }
   );
 
-  if (errors?.length) {
-    throw new GraphQLError(
-      `Failed to resolve ${TV} show ${obj.tv_show_id} ${SEASON} ${obj.season_number} ${EPISODE} ${obj.episode_number} ${EXTERNAL_IDS}.`,
-      { nodes: fieldNodes, originalError: errors[0] }
-    );
-  }
+  const { id: movieId, ...rest } = data ?? {};
 
-  setCacheMetadata(`${EPISODE}.${EXTERNAL_IDS}`, headers);
-  const { id: movieId, ...rest } = data!;
-  return rest;
-};
+  return {
+    data: rest,
+    errors,
+    headers,
+  };
+});