@tmdb-graphql-api/resolvers 0.0.6

package/src/queries/seasonVideos.ts

@@ -0,0 +1,33 @@
+import { GraphQLError } from 'graphql';
+import type { GraphQLResolveInfo } from 'graphql';
+import { SEASON, TV, VIDEOS } from '../constants.ts';
+import type { Context, RawSeasonVideos, RawSeasonWithAppendToResponse } from '../types.ts';
+
+export const resolveSeasonVideos = async (
+  obj: RawSeasonWithAppendToResponse & { __headers?: Headers },
+  _args: undefined,
+  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
+  { fieldNodes }: GraphQLResolveInfo
+) => {
+  if (obj.videos && obj.__headers) {
+    setCacheMetadata(`${SEASON}.${VIDEOS}`, obj.__headers);
+    return obj.videos.results;
+  }
+
+  const { data, errors, headers } = await restClient.season<RawSeasonVideos>(
+    {
+      pathTemplateData: { id: obj.tv_show_id, number: obj.season_number, type: VIDEOS },
+    },
+    { requestID, tmdbGuestSessionId }
+  );
+
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${TV} show ${obj.tv_show_id} ${SEASON} ${obj.season_number} ${VIDEOS}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0],
+    });
+  }
+
+  setCacheMetadata(`${SEASON}.${VIDEOS}`, headers);
+  return data?.results;
+};

package/src/queries/trending.test.ts

@@ -0,0 +1,165 @@
+import { removeConnectionInputOptions } from '@graphql-box/connection-resolver';
+import type { PlainObject } from '@graphql-box/core';
+import { jest } from '@jest/globals';
+import { type ShortcutMethodNames, TRENDING_PATH } from '@tmdb-graphql-api/rest-client';
+import type { TrendingMediaType, TrendingTimeWindow } from '@tmdb-graphql-api/schema';
+import trendingAllDay from '@tmdb-graphql-api/test-utils/responses/themoviedb/trending/allDay.json';
+import trendingMovieDay from '@tmdb-graphql-api/test-utils/responses/themoviedb/trending/movieDay.json';
+import trendingMovieWeek from '@tmdb-graphql-api/test-utils/responses/themoviedb/trending/movieWeek.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 { TRENDING } from '../constants.ts';
+import type { Context } from '../types.ts';
+import { createMakeCursors, createResourceResolver, cursorCache, resolveTrending } from './trending.ts';
+
+polyfillFetch();
+const mockedFetch = mockFetch(jest.fn);
+
+const baseArgs = {
+  mediaType: 'ALL' as TrendingMediaType,
+  timeWindow: 'DAY' as TrendingTimeWindow,
+};
+
+describe('createMakeCursors', () => {
+  const GROUP_CURSOR = `${JSON.stringify(removeConnectionInputOptions(baseArgs))}::${TRENDING}`;
+
+  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 = {
+    trending: jest.fn().mockReturnValue({}),
+  } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>;
+
+  const setCacheMetadata = jest.fn();
+
+  it('when `restClient.trending` is called', async () => {
+    const resourceResolver = createResourceResolver(undefined, baseArgs, {
+      restClient,
+      setCacheMetadata,
+      tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+    } as unknown as Context);
+
+    await resourceResolver({ page: 1 });
+
+    expect(restClient.trending).toHaveBeenCalledWith(
+      {
+        pathTemplateData: { subType: 'day', type: 'all' },
+        queryParams: {
+          page: 1,
+        },
+      },
+      { requestID: undefined, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' }
+    );
+  });
+});
+
+describe('resolveTrending', () => {
+  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
+  const setCacheMetadata = jest.fn();
+
+  const mockEndpoint = ({ mediaType, timeWindow }: PlainObject, page: number, body: Jsonifiable) => {
+    mockedFetch.mockGetOnce(
+      buildEndpoint(
+        TRENDING_PATH,
+        { subType: (timeWindow as string).toLowerCase(), type: (mediaType as string).toLowerCase() },
+        { page }
+      ),
+      {
+        body,
+        headers: { 'cache-control': 'public, max-age=6000' },
+      }
+    );
+  };
+
+  beforeAll(() => {
+    restClient = createRestClient();
+  });
+
+  beforeEach(() => {
+    mockEndpoint(baseArgs, 1, trendingAllDay);
+    mockEndpoint({ ...baseArgs, mediaType: 'MOVIE' }, 1, trendingMovieDay);
+    mockEndpoint({ mediaType: 'MOVIE', timeWindow: 'WEEK' }, 1, trendingMovieWeek);
+  });
+
+  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(
+        resolveTrending(
+          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 resolveTrending(
+        undefined,
+        { ...baseArgs, first: 5 },
+        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+        {} as GraphQLResolveInfo
+      );
+
+      await expect(
+        resolveTrending(
+          undefined,
+          { ...baseArgs, after: pageInfo.endCursor, first: 5 },
+          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+          {} as GraphQLResolveInfo
+        )
+      ).resolves.toMatchSnapshot();
+    });
+  });
+
+  describe('when the first 5 are requested with different args', () => {
+    it('should request each resource from the server once', async () => {
+      await resolveTrending(
+        undefined,
+        { ...baseArgs, first: 5 },
+        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+        {} as GraphQLResolveInfo
+      );
+
+      await resolveTrending(
+        undefined,
+        { ...baseArgs, first: 5, mediaType: 'MOVIE' },
+        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+        {} as GraphQLResolveInfo
+      );
+
+      await resolveTrending(
+        undefined,
+        { ...baseArgs, first: 5, mediaType: 'MOVIE', timeWindow: 'WEEK' },
+        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+        {} as GraphQLResolveInfo
+      );
+
+      expect(mockedFetch).toHaveBeenCalledTimes(3);
+    });
+  });
+});

package/src/queries/trending.ts

@@ -0,0 +1,70 @@
+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 { MediaType, QueryTrendingArgs } from '@tmdb-graphql-api/schema';
+import { encode } from 'js-base64';
+import { capitalize } from 'lodash-es';
+import { TRENDING } from '../constants.ts';
+import type { Context, RawMedia, RawTrending } from '../types.ts';
+
+/* eslint-disable camelcase */
+
+export const createMakeCursors = (_obj: undefined, args: QueryTrendingArgs) => {
+  const groupCursor = `${JSON.stringify(removeConnectionInputOptions(args))}::${TRENDING}`;
+
+  return {
+    makeGroupCursor: () => encode(groupCursor),
+    makeIDCursor: (id: string | number) => encode(`${id}::${groupCursor}`),
+  };
+};
+
+export const createResourceResolver =
+  (
+    _obj: undefined,
+    { mediaType, timeWindow }: QueryTrendingArgs,
+    { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context
+  ) =>
+  async ({ page }: { page: number }) => {
+    const result = await restClient.trending<RawTrending>(
+      {
+        pathTemplateData: { subType: timeWindow.toLowerCase(), type: mediaType.toLowerCase() },
+        queryParams: { page },
+      },
+      { requestID, tmdbGuestSessionId }
+    );
+
+    if (!result.data) {
+      return result;
+    }
+
+    result.data.results = result.data.results.map(entry => {
+      entry.media_type = capitalize(entry.media_type ?? mediaType) as MediaType;
+      return entry;
+    });
+
+    setCacheMetadata(TRENDING, result.headers);
+    return result;
+  };
+
+export const cursorCache = new Core({
+  name: 'TRENDING_CONNECTION_RESOLVER',
+  reaper: reaper({ interval: 300_000 }),
+  store: map(),
+  type: 'GRAPHQL',
+});
+
+export const getters: Getters<RawTrending, RawMedia & { media_type?: MediaType }> = {
+  nodes: ({ results }) => results,
+  page: ({ page }) => page,
+  totalPages: ({ total_pages }) => total_pages,
+  totalResults: ({ total_results }) => total_results,
+};
+
+export const resolveTrending = makeConnectionResolver({
+  createMakeCursors,
+  createResourceResolver,
+  cursorCache,
+  getters,
+  resultsPerPage: 20,
+});

package/src/queries/tv.test.ts

@@ -0,0 +1,81 @@
+import type { PlainArray } from '@graphql-box/core';
+import { getChildFields, getOperationDefinitions } from '@graphql-box/helpers';
+import { jest } from '@jest/globals';
+import { type ShortcutMethodNames, TV_PATH } from '@tmdb-graphql-api/rest-client';
+import { tvDetails as tvDetailsQuery } from '@tmdb-graphql-api/test-utils/requests/queries/tv/details.ts';
+import { tvDetailsLg as tvDetailsLgQuery } from '@tmdb-graphql-api/test-utils/requests/queries/tv/detailsLg.ts';
+import tvDetails from '@tmdb-graphql-api/test-utils/responses/themoviedb/tv/1399/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 { TV } from '../constants.ts';
+import type { Context } from '../types.ts';
+import { resolveTv } from './tv.ts';
+
+polyfillFetch();
+const mockedFetch = mockFetch(jest.fn);
+
+describe('resolveTv >', () => {
+  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
+  const setCacheMetadata = jest.fn();
+  const id = 1399;
+
+  beforeAll(() => {
+    restClient = createRestClient();
+  });
+
+  beforeEach(() => {
+    mockedFetch.mockGetOnce(buildEndpoint(TV_PATH, { id }), {
+      body: tvDetails,
+    });
+  });
+
+  afterEach(async () => {
+    mockedFetch.mockReset();
+    await restClient.cache?.clear();
+  });
+
+  it('should return the correct tv details', async () => {
+    const operationDefinition = getOperationDefinitions(parse(tvDetailsQuery()), OperationTypeNode.QUERY)[0]!;
+    const { fieldNode } = getChildFields(operationDefinition, { name: TV })![0]!;
+
+    await expect(
+      resolveTv(
+        undefined,
+        { id },
+        { 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(tvDetailsLgQuery()), OperationTypeNode.QUERY)[0]!;
+    const { fieldNode } = getChildFields(operationDefinition, { name: TV })![0]!;
+
+    const tvFetchMock = jest
+      .fn<(...args: PlainArray) => Promise<FetchResponse>>()
+      .mockResolvedValue({ data: { seasons: [] } } as FetchResponse<{ seasons: [] }>);
+
+    await resolveTv(
+      undefined,
+      { id },
+      {
+        restClient: { tv: tvFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
+        setCacheMetadata,
+        tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+      } as unknown as Context,
+      { fieldNodes: [fieldNode] } as unknown as GraphQLResolveInfo
+    );
+
+    expect(tvFetchMock.mock.calls[0]![0]).toEqual(
+      expect.objectContaining({
+        queryParams: {
+          append_to_response: 'credits,content_ratings,recommendations,reviews,similar',
+        },
+      })
+    );
+  });
+});

package/src/queries/tv.ts

@@ -0,0 +1,98 @@
+import type { QueryTvArgs } from '@tmdb-graphql-api/schema';
+import { GraphQLError } from 'graphql';
+import type { GraphQLResolveInfo } from 'graphql';
+import { isUndefined, snakeCase } from 'lodash-es';
+import {
+  ALTERNATIVE_TITLES,
+  BACKDROPS,
+  CAST,
+  CONTENT_RATINGS,
+  CREDITS,
+  CREW,
+  EPISODE_GROUPS,
+  EXTERNAL_IDS,
+  IMAGES,
+  KEYWORDS,
+  LOGOS,
+  POSTERS,
+  RECOMMENDATIONS,
+  REVIEWS,
+  SIMILAR,
+  SIMILAR_TV_SHOWS,
+  TRANSLATIONS,
+  TV,
+  VIDEOS,
+  WATCH_PROVIDERS,
+} from '../constants.ts';
+import { getAppendToResponseKeys } from '../helpers/getAppendToResponseKeys.ts';
+import type { Context, RawTv, RawTvWithAppendToResponse } from '../types.ts';
+
+const appendToResponse = {
+  [ALTERNATIVE_TITLES]: snakeCase(ALTERNATIVE_TITLES),
+  [BACKDROPS]: IMAGES,
+  [CAST]: CREDITS,
+  [CONTENT_RATINGS]: snakeCase(CONTENT_RATINGS),
+  [CREW]: CREDITS,
+  [EPISODE_GROUPS]: snakeCase(EPISODE_GROUPS),
+  [EXTERNAL_IDS]: snakeCase(EXTERNAL_IDS),
+  [KEYWORDS]: KEYWORDS,
+  [LOGOS]: IMAGES,
+  [POSTERS]: IMAGES,
+  [RECOMMENDATIONS]: RECOMMENDATIONS,
+  [REVIEWS]: REVIEWS,
+  [SIMILAR_TV_SHOWS]: SIMILAR,
+  [TRANSLATIONS]: TRANSLATIONS,
+  [VIDEOS]: VIDEOS,
+  [WATCH_PROVIDERS]: 'watch/providers',
+};
+
+const enrichSeasonData = (obj: RawTv) => {
+  for (const season of obj.seasons) {
+    season.tv_show_id = obj.id;
+  }
+};
+
+export const resolveTv = async (
+  obj: RawTv | undefined,
+  args: QueryTvArgs,
+  { fragmentDefinitions, requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
+  { fieldName, fieldNodes }: GraphQLResolveInfo
+) => {
+  const typedFieldName = snakeCase(fieldName) as keyof RawTv;
+
+  if (obj && !isUndefined(obj[typedFieldName])) {
+    return obj[typedFieldName];
+  }
+
+  const id = obj ? obj.id : args.id;
+  const appendToResponseKeys = getAppendToResponseKeys(fieldNodes[0]!, appendToResponse, fragmentDefinitions);
+
+  const { data, errors, headers } = await restClient.tv<RawTvWithAppendToResponse>(
+    {
+      pathTemplateData: { id },
+      ...(appendToResponseKeys.length > 0
+        ? {
+            queryParams: {
+              append_to_response: appendToResponseKeys.join(','),
+            },
+          }
+        : {}),
+    },
+    { requestID, tmdbGuestSessionId }
+  );
+
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${TV} ${id}.`, { nodes: fieldNodes, originalError: errors[0] });
+  }
+
+  const rawTv = data!;
+  enrichSeasonData(rawTv);
+
+  if (obj) {
+    setCacheMetadata(`${TV}.${fieldName}`, headers);
+    return rawTv[typedFieldName];
+  }
+
+  setCacheMetadata(TV, headers);
+  return appendToResponseKeys.length > 0 ? { ...rawTv, __headers: headers } : rawTv;
+};

package/src/queries/tvAlternativeTitles.test.ts

@@ -0,0 +1,103 @@
+import type { PlainArray } from '@graphql-box/core';
+import { jest } from '@jest/globals';
+import { type ShortcutMethodNames, TV_PATH } from '@tmdb-graphql-api/rest-client';
+import tvAlternativeTitles from '@tmdb-graphql-api/test-utils/responses/themoviedb/tv/1399/alternativeTitles.json';
+import tvDetails from '@tmdb-graphql-api/test-utils/responses/themoviedb/tv/1399/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, RawTvWithAppendToResponse } from '../types.ts';
+import { resolveTvAlternativeTitles } from './tvAlternativeTitles.ts';
+
+polyfillFetch();
+const mockedFetch = mockFetch(jest.fn);
+
+describe('resolveTvAlternativeTitles >', () => {
+  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
+  const setCacheMetadata = jest.fn();
+  const tvId = 1399;
+
+  beforeAll(() => {
+    restClient = createRestClient();
+  });
+
+  beforeEach(() => {
+    mockedFetch.mockGetOnce(buildEndpoint(TV_PATH, { id: tvId, type: 'alternative_titles' }), {
+      body: tvAlternativeTitles,
+    });
+  });
+
+  afterEach(async () => {
+    mockedFetch.mockReset();
+    await restClient.cache?.clear();
+  });
+
+  it('should return the tv alternative titles', async () => {
+    await expect(
+      resolveTvAlternativeTitles(
+        tvDetails as unknown as RawTvWithAppendToResponse,
+        undefined,
+        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+        {} as GraphQLResolveInfo
+      )
+    ).resolves.toMatchSnapshot();
+  });
+
+  describe('when raw tv data has alternativeTitles', () => {
+    it('should return the correct response', async () => {
+      const tvFetchMock = jest
+        .fn<(...args: PlainArray) => Promise<FetchResponse>>()
+        .mockResolvedValue({ data: {} } as FetchResponse);
+
+      const { id, ...rest } = tvAlternativeTitles;
+
+      await expect(
+        resolveTvAlternativeTitles(
+          {
+            ...tvDetails,
+            __headers: new Headers(),
+            alternative_titles: rest,
+          } as unknown as RawTvWithAppendToResponse & {
+            __headers?: Headers;
+          },
+          undefined,
+          {
+            restClient: { tv: tvFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
+            setCacheMetadata,
+            tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+          } as unknown as Context,
+          {} as GraphQLResolveInfo
+        )
+      ).resolves.toMatchSnapshot();
+    });
+
+    it('should not make a request to the server', async () => {
+      const tvFetchMock = jest
+        .fn<(...args: PlainArray) => Promise<FetchResponse>>()
+        .mockResolvedValue({ data: {} } as FetchResponse);
+
+      const { id, ...rest } = tvAlternativeTitles;
+
+      await resolveTvAlternativeTitles(
+        {
+          ...tvDetails,
+          __headers: new Headers(),
+          alternative_titles: rest,
+        } as unknown as RawTvWithAppendToResponse & {
+          __headers?: Headers;
+        },
+        undefined,
+        {
+          restClient: { tv: tvFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
+          setCacheMetadata,
+          tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+        } as unknown as Context,
+        {} as GraphQLResolveInfo
+      );
+
+      expect(tvFetchMock).not.toHaveBeenCalled();
+    });
+  });
+});

package/src/queries/tvAlternativeTitles.ts

@@ -0,0 +1,35 @@
+import { GraphQLError } from 'graphql';
+import type { GraphQLResolveInfo } from 'graphql';
+import { snakeCase } from 'lodash-es';
+import { ALTERNATIVE_TITLES, TV } from '../constants.ts';
+import type { Context, RawTvAlternativeTitles, RawTvWithAppendToResponse } from '../types.ts';
+
+export const resolveTvAlternativeTitles = async (
+  obj: RawTvWithAppendToResponse & { __headers?: Headers },
+  _args: undefined,
+  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
+  { fieldNodes }: GraphQLResolveInfo
+) => {
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+  if (obj.alternative_titles && obj.__headers) {
+    setCacheMetadata(`${TV}.${ALTERNATIVE_TITLES}`, obj.__headers);
+    return obj.alternative_titles.results;
+  }
+
+  const { data, errors, headers } = await restClient.tv<RawTvAlternativeTitles>(
+    {
+      pathTemplateData: { id: obj.id, type: snakeCase(ALTERNATIVE_TITLES) },
+    },
+    { requestID, tmdbGuestSessionId }
+  );
+
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${TV} ${obj.id} ${ALTERNATIVE_TITLES}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0],
+    });
+  }
+
+  setCacheMetadata(`${TV}.${ALTERNATIVE_TITLES}`, headers);
+  return data!.results;
+};

package/src/queries/tvContentRatings.test.ts

@@ -0,0 +1,103 @@
+import type { PlainArray } from '@graphql-box/core';
+import { jest } from '@jest/globals';
+import { type ShortcutMethodNames, TV_PATH } from '@tmdb-graphql-api/rest-client';
+import tvContentRatings from '@tmdb-graphql-api/test-utils/responses/themoviedb/tv/1399/contentRatings.json';
+import tvDetails from '@tmdb-graphql-api/test-utils/responses/themoviedb/tv/1399/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, RawTvWithAppendToResponse } from '../types.ts';
+import { resolveTvContentRatings } from './tvContentRatings.ts';
+
+polyfillFetch();
+const mockedFetch = mockFetch(jest.fn);
+
+describe('resolveTvContentRatings >', () => {
+  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
+  const setCacheMetadata = jest.fn();
+  const tvId = 1399;
+
+  beforeAll(() => {
+    restClient = createRestClient();
+  });
+
+  beforeEach(() => {
+    mockedFetch.mockGetOnce(buildEndpoint(TV_PATH, { id: tvId, type: 'content_ratings' }), {
+      body: tvContentRatings,
+    });
+  });
+
+  afterEach(async () => {
+    mockedFetch.mockReset();
+    await restClient.cache?.clear();
+  });
+
+  it('should return the tv content ratings', async () => {
+    await expect(
+      resolveTvContentRatings(
+        tvDetails as unknown as RawTvWithAppendToResponse,
+        undefined,
+        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+        {} as GraphQLResolveInfo
+      )
+    ).resolves.toMatchSnapshot();
+  });
+
+  describe('when raw tv data has content ratings', () => {
+    it('should return the correct response', async () => {
+      const tvFetchMock = jest
+        .fn<(...args: PlainArray) => Promise<FetchResponse>>()
+        .mockResolvedValue({ data: {} } as FetchResponse);
+
+      const { id, ...rest } = tvContentRatings;
+
+      await expect(
+        resolveTvContentRatings(
+          {
+            ...tvDetails,
+            __headers: new Headers(),
+            content_ratings: rest,
+          } as unknown as RawTvWithAppendToResponse & {
+            __headers?: Headers;
+          },
+          undefined,
+          {
+            restClient: { tv: tvFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
+            setCacheMetadata,
+            tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+          } as unknown as Context,
+          {} as GraphQLResolveInfo
+        )
+      ).resolves.toMatchSnapshot();
+    });
+
+    it('should not make a request to the server', async () => {
+      const tvFetchMock = jest
+        .fn<(...args: PlainArray) => Promise<FetchResponse>>()
+        .mockResolvedValue({ data: {} } as FetchResponse);
+
+      const { id, ...rest } = tvContentRatings;
+
+      await resolveTvContentRatings(
+        {
+          ...tvDetails,
+          __headers: new Headers(),
+          content_ratings: rest,
+        } as unknown as RawTvWithAppendToResponse & {
+          __headers?: Headers;
+        },
+        undefined,
+        {
+          restClient: { tv: tvFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
+          setCacheMetadata,
+          tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+        } as unknown as Context,
+        {} as GraphQLResolveInfo
+      );
+
+      expect(tvFetchMock).not.toHaveBeenCalled();
+    });
+  });
+});