@tmdb-graphql-api/resolvers 0.0.6

package/src/queries/discoverMovies.ts

@@ -0,0 +1,65 @@
+import { Core } from '@cachemap/core';
+import { init as map } from '@cachemap/map';
+import { init as reaper } from '@cachemap/reaper';
+import { type Getters, makeConnectionResolver, removeConnectionInputOptions } from '@graphql-box/connection-resolver';
+import type { QueryDiscoverMoviesArgs } from '@tmdb-graphql-api/schema';
+import { encode } from 'js-base64';
+import { DISCOVER_MOVIES, MOVIE } from '../constants.ts';
+import { formatQueryParams } from '../helpers/formatQueryParams.ts';
+import { removeNullValues } from '../helpers/removeNullValues.ts';
+import type { Context, RawDiscoverMovies, RawMovie } from '../types.ts';
+
+/* eslint-disable camelcase */
+
+export const createMakeCursors = (_obj: undefined, args: QueryDiscoverMoviesArgs) => {
+  const groupCursor = `${JSON.stringify(removeNullValues(removeConnectionInputOptions(args)))}::${DISCOVER_MOVIES}`;
+
+  return {
+    makeGroupCursor: () => encode(groupCursor),
+    makeIDCursor: (id: string | number) => encode(`${id}::${groupCursor}`),
+  };
+};
+
+export const createResourceResolver =
+  (
+    _obj: undefined,
+    args: QueryDiscoverMoviesArgs,
+    { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context
+  ) =>
+  async ({ page }: { page: number }) => {
+    const result = await restClient.discover<RawDiscoverMovies>(
+      {
+        pathTemplateData: { type: MOVIE },
+        queryParams: { ...formatQueryParams(args), page },
+      },
+      { requestID, tmdbGuestSessionId }
+    );
+
+    if (result.data) {
+      setCacheMetadata(DISCOVER_MOVIES, result.headers);
+    }
+
+    return result;
+  };
+
+export const cursorCache = new Core({
+  name: 'DISCOVER_MOVIES_CONNECTION_RESOLVER',
+  reaper: reaper({ interval: 300_000 }),
+  store: map(),
+  type: 'GRAPHQL',
+});
+
+export const getters: Getters<RawDiscoverMovies, RawMovie> = {
+  nodes: ({ results }) => results,
+  page: ({ page }) => page,
+  totalPages: ({ total_pages }) => total_pages,
+  totalResults: ({ total_results }) => total_results,
+};
+
+export const resolveDiscoverMovies = makeConnectionResolver({
+  createMakeCursors,
+  createResourceResolver,
+  cursorCache,
+  getters,
+  resultsPerPage: 20,
+});

package/src/queries/discoverTv.test.ts

@@ -0,0 +1,142 @@
+import { removeConnectionInputOptions } from '@graphql-box/connection-resolver';
+import type { PlainObject } from '@graphql-box/core';
+import { jest } from '@jest/globals';
+import { DISCOVER_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import type { TvSortBy } from '@tmdb-graphql-api/schema';
+import discoverTv2020 from '@tmdb-graphql-api/test-utils/responses/themoviedb/discoverTv/2020.json';
+import { type Jsonifiable, mockFetch, polyfillFetch } from 'fetch-mocked';
+import type { Getta, ShortcutProperties } from 'getta';
+import type { GraphQLResolveInfo } from 'graphql';
+import { decode } from 'js-base64';
+import { buildEndpoint } from '../__testUtils__/helpers/buildEndpoint.ts';
+import { createRestClient } from '../__testUtils__/helpers/createRestClient.ts';
+import { DISCOVER_TV } from '../constants.ts';
+import { formatQueryParams } from '../helpers/formatQueryParams.ts';
+import { removeNullValues } from '../helpers/removeNullValues.ts';
+import type { Context } from '../types.ts';
+import { createMakeCursors, createResourceResolver, cursorCache, resolveDiscoverTv } from './discoverTv.ts';
+
+polyfillFetch();
+const mockedFetch = mockFetch(jest.fn);
+
+const baseArgs = {
+  firstAirDateGte: '2020',
+  includeNullFirstAirDates: false,
+  language: 'en-US',
+  sortBy: 'VOTE_AVERAGE_DESC' as TvSortBy,
+  timezone: 'America/New_York',
+  // eslint-disable-next-line unicorn/no-null
+  voteCountGte: null,
+  withOriginalLanguage: 'en',
+};
+
+describe('createMakeCursors', () => {
+  const GROUP_CURSOR = `${JSON.stringify(removeNullValues(removeConnectionInputOptions(baseArgs)))}::${DISCOVER_TV}`;
+
+  it('makeGroupCursor', () => {
+    const { makeGroupCursor } = createMakeCursors(undefined, baseArgs);
+    const groupCursor = makeGroupCursor();
+    expect(decode(groupCursor)).toBe(GROUP_CURSOR);
+  });
+
+  it('makeIDCursor', () => {
+    const id = 23;
+    const { makeIDCursor } = createMakeCursors(undefined, baseArgs);
+    const idCursor = makeIDCursor(id);
+    expect(decode(idCursor)).toBe(`${id}::${GROUP_CURSOR}`);
+  });
+});
+
+describe('createResourceResolver', () => {
+  const restClient = {
+    discover: jest.fn().mockReturnValue({}),
+  } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>;
+
+  const setCacheMetadata = jest.fn();
+
+  it('when `restClient.discover` is called', async () => {
+    const resourceResolver = createResourceResolver(undefined, baseArgs, {
+      restClient,
+      setCacheMetadata,
+      tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+    } as unknown as Context);
+
+    await resourceResolver({ page: 1 });
+
+    expect(restClient.discover).toHaveBeenCalledWith(
+      {
+        pathTemplateData: { type: 'tv' },
+        queryParams: {
+          'first_air_date.gte': '2020',
+          include_null_first_air_dates: false,
+          language: 'en-US',
+          page: 1,
+          sort_by: 'vote_average.desc',
+          timezone: 'America/New_York',
+          with_original_language: 'en',
+        },
+      },
+      { requestID: undefined, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' }
+    );
+  });
+});
+
+describe('resolveDiscoverTv', () => {
+  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
+  const setCacheMetadata = jest.fn();
+  const type = 'tv';
+
+  const mockEndpoint = (args: PlainObject, page: number, body: Jsonifiable) => {
+    mockedFetch.mockGetOnce(buildEndpoint(DISCOVER_PATH, { type }, { ...formatQueryParams(args), page }), {
+      body,
+      headers: { 'cache-control': 'public, max-age=6000' },
+    });
+  };
+
+  beforeAll(() => {
+    restClient = createRestClient();
+  });
+
+  beforeEach(() => {
+    mockEndpoint(baseArgs, 1, discoverTv2020);
+  });
+
+  afterEach(async () => {
+    mockedFetch.mockReset();
+    await restClient.cache?.clear();
+    await cursorCache.clear();
+  });
+
+  describe('when the first 5 are requested', () => {
+    it('should return the correct response', async () => {
+      await expect(
+        resolveDiscoverTv(
+          undefined,
+          { ...baseArgs, first: 5 },
+          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+          {} as GraphQLResolveInfo
+        )
+      ).resolves.toMatchSnapshot();
+    });
+  });
+
+  describe('when the second 5 are requested', () => {
+    it('should return the correct response', async () => {
+      const { pageInfo } = await resolveDiscoverTv(
+        undefined,
+        { ...baseArgs, first: 5 },
+        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+        {} as GraphQLResolveInfo
+      );
+
+      await expect(
+        resolveDiscoverTv(
+          undefined,
+          { ...baseArgs, after: pageInfo.endCursor, first: 5 },
+          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+          {} as GraphQLResolveInfo
+        )
+      ).resolves.toMatchSnapshot();
+    });
+  });
+});

package/src/queries/discoverTv.ts

@@ -0,0 +1,66 @@
+import { Core } from '@cachemap/core';
+import { init as map } from '@cachemap/map';
+import { init as reaper } from '@cachemap/reaper';
+import { type Getters, makeConnectionResolver, removeConnectionInputOptions } from '@graphql-box/connection-resolver';
+import type { QueryDiscoverTvArgs } from '@tmdb-graphql-api/schema';
+import { encode } from 'js-base64';
+import { DISCOVER_TV, TV } from '../constants.ts';
+import { formatQueryParams } from '../helpers/formatQueryParams.ts';
+import { removeNullValues } from '../helpers/removeNullValues.ts';
+import type { Context, RawDiscoverTv, RawTv } from '../types.ts';
+
+/* eslint-disable camelcase */
+
+export const createMakeCursors = (_obj: undefined, args: QueryDiscoverTvArgs) => {
+  const groupCursor = `${JSON.stringify(removeNullValues(removeConnectionInputOptions(args)))}::${DISCOVER_TV}`;
+
+  return {
+    makeGroupCursor: () => encode(groupCursor),
+    makeIDCursor: (id: string | number) => encode(`${id}::${groupCursor}`),
+  };
+};
+
+export const createResourceResolver =
+  (
+    _obj: undefined,
+    args: QueryDiscoverTvArgs,
+    { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context
+  ) =>
+  async ({ page }: { page: number }) => {
+    const result = await restClient.discover<RawDiscoverTv>(
+      {
+        pathTemplateData: { type: TV },
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        queryParams: { ...formatQueryParams(args), page },
+      },
+      { requestID, tmdbGuestSessionId }
+    );
+
+    if (result.data) {
+      setCacheMetadata(DISCOVER_TV, result.headers);
+    }
+
+    return result;
+  };
+
+export const cursorCache = new Core({
+  name: 'DISCOVER_TV_CONNECTION_RESOLVER',
+  reaper: reaper({ interval: 300_000 }),
+  store: map(),
+  type: 'GRAPHQL',
+});
+
+export const getters: Getters<RawDiscoverTv, RawTv> = {
+  nodes: ({ results }) => results,
+  page: ({ page }) => page,
+  totalPages: ({ total_pages }) => total_pages,
+  totalResults: ({ total_results }) => total_results,
+};
+
+export const resolveDiscoverTv = makeConnectionResolver({
+  createMakeCursors,
+  createResourceResolver,
+  cursorCache,
+  getters,
+  resultsPerPage: 20,
+});

package/src/queries/episode.test.ts

@@ -0,0 +1,82 @@
+import type { PlainArray } from '@graphql-box/core';
+import { getChildFields, getOperationDefinitions } from '@graphql-box/helpers';
+import { jest } from '@jest/globals';
+import { EPISODE_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import { episodeDetails as episodeDetailsQuery } from '@tmdb-graphql-api/test-utils/requests/queries/episode/details.ts';
+import { episodeDetailsLg as episodeDetailsLgQuery } from '@tmdb-graphql-api/test-utils/requests/queries/episode/detailsLg.ts';
+import episodeDetails from '@tmdb-graphql-api/test-utils/responses/themoviedb/tv/1399/seasons/1/episodes/1/details.json';
+import { mockFetch, polyfillFetch } from 'fetch-mocked';
+import type { FetchResponse, Getta, ShortcutProperties } from 'getta';
+import { type GraphQLResolveInfo, OperationTypeNode, parse } from 'graphql';
+import { buildEndpoint } from '../__testUtils__/helpers/buildEndpoint.ts';
+import { createRestClient } from '../__testUtils__/helpers/createRestClient.ts';
+import { EPISODE } from '../constants.ts';
+import { encodeId } from '../helpers/encodeId.ts';
+import type { Context } from '../types.ts';
+import { resolveEpisode } from './episode.ts';
+
+polyfillFetch();
+const mockedFetch = mockFetch(jest.fn);
+
+describe('resolveEpisode >', () => {
+  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
+  const setCacheMetadata = jest.fn();
+  const id = 1399;
+
+  beforeAll(() => {
+    restClient = createRestClient();
+  });
+
+  beforeEach(() => {
+    mockedFetch.mockGetOnce(buildEndpoint(EPISODE_PATH, { episodeNumber: 1, id, seasonNumber: 1 }), {
+      body: episodeDetails,
+    });
+  });
+
+  afterEach(async () => {
+    mockedFetch.mockReset();
+    await restClient.cache?.clear();
+  });
+
+  it('should return the correct episode details', async () => {
+    const operationDefinition = getOperationDefinitions(parse(episodeDetailsQuery()), OperationTypeNode.QUERY)[0]!;
+    const { fieldNode } = getChildFields(operationDefinition, { name: EPISODE })![0]!;
+
+    await expect(
+      resolveEpisode(
+        undefined,
+        { id: encodeId({ episodeNumber: 1, id, seasonNumber: 1 }) },
+        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+        { fieldNodes: [fieldNode] } as unknown as GraphQLResolveInfo
+      )
+    ).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 episodeFetchMock = jest
+      .fn<(...args: PlainArray) => Promise<FetchResponse>>()
+      .mockResolvedValue({ data: {} } as FetchResponse);
+
+    await resolveEpisode(
+      undefined,
+      { id: encodeId({ episodeNumber: 1, id, seasonNumber: 1 }) },
+      {
+        restClient: { episode: episodeFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
+        setCacheMetadata,
+        tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+      } as unknown as Context,
+      { fieldNodes: [fieldNode] } as unknown as GraphQLResolveInfo
+    );
+
+    expect(episodeFetchMock.mock.calls[0]![0]).toEqual(
+      expect.objectContaining({
+        queryParams: {
+          append_to_response: 'credits,external_ids,images,videos',
+        },
+      })
+    );
+  });
+});

package/src/queries/episode.ts

@@ -0,0 +1,73 @@
+import type { QueryEpisodeArgs } from '@tmdb-graphql-api/schema';
+import { GraphQLError } from 'graphql';
+import type { GraphQLResolveInfo } from 'graphql';
+import { isUndefined, snakeCase } from 'lodash-es';
+import { CREDITS, EPISODE, EXTERNAL_IDS, IMAGES, SEASON, TRANSLATIONS, TV, VIDEOS } from '../constants.ts';
+import { encodeId } from '../helpers/encodeId.ts';
+import { getAppendToResponseKeys } from '../helpers/getAppendToResponseKeys.ts';
+import { getTvIdSeasonAndEpisode } from '../helpers/getTvIdSeasonAndEpisode.ts';
+import type { Context, RawEpisode, RawEpisodeWithAppendToResponse } from '../types.ts';
+
+const appendToResponse = {
+  [EXTERNAL_IDS]: snakeCase(EXTERNAL_IDS),
+  [TRANSLATIONS]: TRANSLATIONS,
+  [VIDEOS]: VIDEOS,
+  cast: CREDITS,
+  crew: CREDITS,
+  guestStars: CREDITS,
+  stills: IMAGES,
+};
+
+export const resolveEpisode = async (
+  obj: RawEpisode | undefined,
+  args: QueryEpisodeArgs,
+  { fragmentDefinitions, requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
+  { fieldName, fieldNodes }: GraphQLResolveInfo
+) => {
+  const typedFieldName = snakeCase(fieldName) as keyof RawEpisode;
+  const { episodeNumber, id, seasonNumber } = getTvIdSeasonAndEpisode(obj, args);
+
+  if (obj && !isUndefined(obj[typedFieldName])) {
+    return typedFieldName === 'id'
+      ? encodeId({ id, seasonNumber, ...(episodeNumber ? { episodeNumber } : {}) })
+      : obj[typedFieldName];
+  }
+
+  const appendToResponseKeys = getAppendToResponseKeys(fieldNodes[0]!, appendToResponse, fragmentDefinitions);
+
+  const { data, errors, headers } = await restClient.episode<RawEpisodeWithAppendToResponse>(
+    {
+      pathTemplateData: { episodeNumber, id, seasonNumber },
+      ...(appendToResponseKeys.length > 0
+        ? {
+            queryParams: {
+              append_to_response: appendToResponseKeys.join(','),
+            },
+          }
+        : {}),
+    },
+    { requestID, tmdbGuestSessionId }
+  );
+
+  if (errors?.length) {
+    throw new GraphQLError(
+      `Failed to resolve ${TV} show ${id} ${SEASON} ${seasonNumber} ${EPISODE} ${episodeNumber!}.`,
+      { nodes: fieldNodes, originalError: errors[0] }
+    );
+  }
+
+  const rawEpisode = data!;
+  rawEpisode.id = encodeId({ id, seasonNumber, ...(episodeNumber ? { episodeNumber } : {}) });
+
+  if (!rawEpisode.tv_show_id) {
+    rawEpisode.tv_show_id = id;
+  }
+
+  if (obj) {
+    setCacheMetadata(`${EPISODE}.${fieldName}`, headers);
+    return rawEpisode[typedFieldName];
+  }
+
+  setCacheMetadata(EPISODE, headers);
+  return appendToResponseKeys.length > 0 ? { ...rawEpisode, __headers: headers } : rawEpisode;
+};

package/src/queries/episodeCredits.test.ts

@@ -0,0 +1,134 @@
+import type { PlainArray } from '@graphql-box/core';
+import { jest } from '@jest/globals';
+import { EPISODE_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import episodeCredits from '@tmdb-graphql-api/test-utils/responses/themoviedb/tv/1399/seasons/1/episodes/1/credits.json';
+import episodeDetails from '@tmdb-graphql-api/test-utils/responses/themoviedb/tv/1399/seasons/1/episodes/1/details.json';
+import { mockFetch, polyfillFetch } from 'fetch-mocked';
+import type { FetchResponse, Getta, ShortcutProperties } from 'getta';
+import type { GraphQLResolveInfo } from 'graphql';
+import { buildEndpoint } from '../__testUtils__/helpers/buildEndpoint.ts';
+import { createRestClient } from '../__testUtils__/helpers/createRestClient.ts';
+import type { Context, RawEpisode } from '../types.ts';
+import { resolveEpisodeCredits } from './episodeCredits.ts';
+
+polyfillFetch();
+const mockedFetch = mockFetch(jest.fn);
+
+describe('resolveEpisodeCredits >', () => {
+  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
+  const setCacheMetadata = jest.fn();
+  const tvShowId = 1399;
+  const seasonNumber = 1;
+  const episodeNumber = 1;
+
+  beforeAll(() => {
+    restClient = createRestClient();
+  });
+
+  beforeEach(() => {
+    mockedFetch.mockGetOnce(
+      buildEndpoint(EPISODE_PATH, { episodeNumber, id: tvShowId, seasonNumber, type: 'credits' }),
+      {
+        body: episodeCredits,
+      }
+    );
+  });
+
+  afterEach(async () => {
+    mockedFetch.mockReset();
+    await restClient.cache?.clear();
+  });
+
+  describe('when fieldName is cast', () => {
+    it('should return the correct response', async () => {
+      await expect(
+        resolveEpisodeCredits(
+          episodeDetails as RawEpisode,
+          undefined,
+          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+          {
+            fieldName: 'cast',
+          } as GraphQLResolveInfo
+        )
+      ).resolves.toMatchSnapshot();
+    });
+  });
+
+  describe('when fieldName is crew', () => {
+    it('should return the correct response', async () => {
+      await expect(
+        resolveEpisodeCredits(
+          episodeDetails as RawEpisode,
+          undefined,
+          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+          {
+            fieldName: 'crew',
+          } as GraphQLResolveInfo
+        )
+      ).resolves.toMatchSnapshot();
+    });
+  });
+
+  describe('when fieldName is guestStars', () => {
+    it('should return the correct response', async () => {
+      await expect(
+        resolveEpisodeCredits(
+          episodeDetails as RawEpisode,
+          undefined,
+          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+          {
+            fieldName: 'guestStars',
+          } as GraphQLResolveInfo
+        )
+      ).resolves.toMatchSnapshot();
+    });
+  });
+
+  describe('when raw episode data has credits', () => {
+    it('should return the correct response', async () => {
+      const episodeFetchMock = jest
+        .fn<(...args: PlainArray) => Promise<FetchResponse>>()
+        .mockResolvedValue({ data: {} } as FetchResponse);
+
+      const { id, ...rest } = episodeCredits;
+
+      await expect(
+        resolveEpisodeCredits(
+          { ...episodeDetails, __headers: new Headers(), credits: rest },
+          undefined,
+          {
+            restClient: { episode: episodeFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
+            setCacheMetadata,
+            tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+          } as unknown as Context,
+          {
+            fieldName: 'guestStars',
+          } as GraphQLResolveInfo
+        )
+      ).resolves.toMatchSnapshot();
+    });
+
+    it('should not make a request to the server', async () => {
+      const episodeFetchMock = jest
+        .fn<(...args: PlainArray) => Promise<FetchResponse>>()
+        .mockResolvedValue({ data: {} } as FetchResponse);
+
+      const { id, ...rest } = episodeCredits;
+
+      await resolveEpisodeCredits(
+        { ...episodeDetails, __headers: new Headers(), credits: rest },
+        undefined,
+        {
+          restClient: { episode: episodeFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
+          setCacheMetadata,
+          tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+        } as unknown as Context,
+        {
+          fieldName: 'guestStars',
+        } as GraphQLResolveInfo
+      );
+
+      expect(episodeFetchMock).not.toHaveBeenCalled();
+    });
+  });
+});

package/src/queries/episodeCredits.ts

@@ -0,0 +1,41 @@
+import { GraphQLError } from 'graphql';
+import type { GraphQLResolveInfo } from 'graphql';
+import { snakeCase } from 'lodash-es';
+import { CREDITS, EPISODE, SEASON, TV } from '../constants.ts';
+import type { Context, RawEpisodeCredits, RawEpisodeWithAppendToResponse } from '../types.ts';
+
+export const resolveEpisodeCredits = async (
+  obj: RawEpisodeWithAppendToResponse & { __headers?: Headers },
+  _args: undefined,
+  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
+  { fieldName, fieldNodes }: GraphQLResolveInfo
+) => {
+  const typedFieldName = snakeCase(fieldName) as 'cast' | 'crew' | 'guest_stars';
+
+  if (obj.credits && obj.__headers) {
+    setCacheMetadata(`${EPISODE}.${fieldName}`, obj.__headers);
+    return obj.credits[typedFieldName];
+  }
+
+  const { data, errors, headers } = await restClient.episode<RawEpisodeCredits>(
+    {
+      pathTemplateData: {
+        episodeNumber: obj.episode_number,
+        id: obj.tv_show_id,
+        seasonNumber: obj.season_number,
+        type: CREDITS,
+      },
+    },
+    { 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];
+};