@tmdb-graphql-api/resolvers 0.0.6

package/src/queries/configuration.ts

@@ -0,0 +1,23 @@
+import { GraphQLError } from 'graphql';
+import type { GraphQLResolveInfo } from 'graphql';
+import { CONFIGURATION } from '../constants.ts';
+import type { Context, RawConfiguration } from '../types.ts';
+
+export const resolveConfiguration = async (
+  _obj: undefined,
+  _args: undefined,
+  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
+  { fieldNodes }: GraphQLResolveInfo
+) => {
+  const { data, errors, headers } = await restClient.configuration<RawConfiguration>(undefined, {
+    requestID,
+    tmdbGuestSessionId,
+  });
+
+  if (errors?.length) {
+    throw new GraphQLError('Failed to resolve configuration.', { nodes: fieldNodes, originalError: errors[0] });
+  }
+
+  setCacheMetadata(CONFIGURATION, headers);
+  return data;
+};

package/src/queries/configurationCountries.test.ts

@@ -0,0 +1,45 @@
+import { jest } from '@jest/globals';
+import { CONFIGURATION_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import configurationBase from '@tmdb-graphql-api/test-utils/responses/themoviedb/configuration/base.json';
+import configurationCountries from '@tmdb-graphql-api/test-utils/responses/themoviedb/configuration/countries.json';
+import { mockFetch, polyfillFetch } from 'fetch-mocked';
+import type { 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, RawConfiguration } from '../types.ts';
+import { resolveConfigurationCountries } from './configurationCountries.ts';
+
+polyfillFetch();
+const mockedFetch = mockFetch(jest.fn);
+
+describe('resolveConfigurationCountries >', () => {
+  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
+  const setCacheMetadata = jest.fn();
+
+  beforeAll(() => {
+    restClient = createRestClient();
+  });
+
+  beforeEach(() => {
+    mockedFetch.mockGetOnce(buildEndpoint(CONFIGURATION_PATH, { type: 'countries' }), {
+      body: configurationCountries,
+    });
+  });
+
+  afterEach(async () => {
+    mockedFetch.mockReset();
+    await restClient.cache?.clear();
+  });
+
+  it('should return the configuration countries', async () => {
+    await expect(
+      resolveConfigurationCountries(
+        configurationBase as unknown as RawConfiguration,
+        undefined,
+        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+        {} as GraphQLResolveInfo
+      )
+    ).resolves.toMatchSnapshot();
+  });
+});

package/src/queries/configurationCountries.ts

@@ -0,0 +1,28 @@
+import type { GraphQLResolveInfo } from 'graphql';
+import { GraphQLError } from 'graphql';
+import { CONFIGURATION, COUNTRIES } from '../constants.ts';
+import type { Context, RawConfiguration, RawConfigurationCountries } from '../types.ts';
+
+export const resolveConfigurationCountries = async (
+  _obj: RawConfiguration,
+  _args: undefined,
+  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
+  { fieldNodes }: GraphQLResolveInfo
+) => {
+  const { data, errors, headers } = await restClient.configuration<RawConfigurationCountries>(
+    {
+      pathTemplateData: { type: COUNTRIES },
+    },
+    { requestID, tmdbGuestSessionId }
+  );
+
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${CONFIGURATION} ${COUNTRIES}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0],
+    });
+  }
+
+  setCacheMetadata(`${CONFIGURATION}.${COUNTRIES}`, headers);
+  return data;
+};

package/src/queries/configurationJobs.test.ts

@@ -0,0 +1,45 @@
+import { jest } from '@jest/globals';
+import { CONFIGURATION_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import configurationBase from '@tmdb-graphql-api/test-utils/responses/themoviedb/configuration/base.json';
+import configurationJobs from '@tmdb-graphql-api/test-utils/responses/themoviedb/configuration/jobs.json';
+import { mockFetch, polyfillFetch } from 'fetch-mocked';
+import type { 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, RawConfiguration } from '../types.ts';
+import { resolveConfigurationJobs } from './configurationJobs.ts';
+
+polyfillFetch();
+const mockedFetch = mockFetch(jest.fn);
+
+describe('resolveConfigurationJobs >', () => {
+  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
+  const setCacheMetadata = jest.fn();
+
+  beforeAll(() => {
+    restClient = createRestClient();
+  });
+
+  beforeEach(() => {
+    mockedFetch.mockGetOnce(buildEndpoint(CONFIGURATION_PATH, { type: 'jobs' }), {
+      body: configurationJobs,
+    });
+  });
+
+  afterEach(async () => {
+    mockedFetch.mockReset();
+    await restClient.cache?.clear();
+  });
+
+  it('should return the configuration jobs', async () => {
+    await expect(
+      resolveConfigurationJobs(
+        configurationBase as unknown as RawConfiguration,
+        undefined,
+        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+        {} as GraphQLResolveInfo
+      )
+    ).resolves.toMatchSnapshot();
+  });
+});

package/src/queries/configurationJobs.ts

@@ -0,0 +1,28 @@
+import type { GraphQLResolveInfo } from 'graphql';
+import { GraphQLError } from 'graphql';
+import { CONFIGURATION, JOBS } from '../constants.ts';
+import type { Context, RawConfiguration, RawConfigurationJobs } from '../types.ts';
+
+export const resolveConfigurationJobs = async (
+  _obj: RawConfiguration,
+  _args: undefined,
+  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
+  { fieldNodes }: GraphQLResolveInfo
+) => {
+  const { data, errors, headers } = await restClient.configuration<RawConfigurationJobs>(
+    {
+      pathTemplateData: { type: JOBS },
+    },
+    { requestID, tmdbGuestSessionId }
+  );
+
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${CONFIGURATION} ${JOBS}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0],
+    });
+  }
+
+  setCacheMetadata(`${CONFIGURATION}.${JOBS}`, headers);
+  return data;
+};

package/src/queries/configurationLanguages.test.ts

@@ -0,0 +1,45 @@
+import { jest } from '@jest/globals';
+import { CONFIGURATION_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import configurationBase from '@tmdb-graphql-api/test-utils/responses/themoviedb/configuration/base.json';
+import configurationLanguages from '@tmdb-graphql-api/test-utils/responses/themoviedb/configuration/languages.json';
+import { mockFetch, polyfillFetch } from 'fetch-mocked';
+import type { 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, RawConfiguration } from '../types.ts';
+import { resolveConfigurationLanguages } from './configurationLanguages.ts';
+
+polyfillFetch();
+const mockedFetch = mockFetch(jest.fn);
+
+describe('resolveConfigurationLanguages >', () => {
+  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
+  const setCacheMetadata = jest.fn();
+
+  beforeAll(() => {
+    restClient = createRestClient();
+  });
+
+  beforeEach(() => {
+    mockedFetch.mockGetOnce(buildEndpoint(CONFIGURATION_PATH, { type: 'languages' }), {
+      body: configurationLanguages,
+    });
+  });
+
+  afterEach(async () => {
+    mockedFetch.mockReset();
+    await restClient.cache?.clear();
+  });
+
+  it('should return the configuration languages', async () => {
+    await expect(
+      resolveConfigurationLanguages(
+        configurationBase as unknown as RawConfiguration,
+        undefined,
+        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+        {} as GraphQLResolveInfo
+      )
+    ).resolves.toMatchSnapshot();
+  });
+});

package/src/queries/configurationLanguages.ts

@@ -0,0 +1,28 @@
+import type { GraphQLResolveInfo } from 'graphql';
+import { GraphQLError } from 'graphql';
+import { CONFIGURATION, LANGUAGES } from '../constants.ts';
+import type { Context, RawConfiguration, RawConfigurationLanguages } from '../types.ts';
+
+export const resolveConfigurationLanguages = async (
+  _obj: RawConfiguration,
+  _args: undefined,
+  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
+  { fieldNodes }: GraphQLResolveInfo
+) => {
+  const { data, errors, headers } = await restClient.configuration<RawConfigurationLanguages>(
+    {
+      pathTemplateData: { type: LANGUAGES },
+    },
+    { requestID, tmdbGuestSessionId }
+  );
+
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${CONFIGURATION} ${LANGUAGES}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0],
+    });
+  }
+
+  setCacheMetadata(`${CONFIGURATION}.${LANGUAGES}`, headers);
+  return data;
+};

package/src/queries/configurationPrimaryTranslations.test.ts

@@ -0,0 +1,45 @@
+import { jest } from '@jest/globals';
+import { CONFIGURATION_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import configurationBase from '@tmdb-graphql-api/test-utils/responses/themoviedb/configuration/base.json';
+import configurationPrimaryTranslations from '@tmdb-graphql-api/test-utils/responses/themoviedb/configuration/primaryTranslations.json';
+import { mockFetch, polyfillFetch } from 'fetch-mocked';
+import type { 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, RawConfiguration } from '../types.ts';
+import { resolveConfigurationPrimaryTranslations } from './configurationPrimaryTranslations.ts';
+
+polyfillFetch();
+const mockedFetch = mockFetch(jest.fn);
+
+describe('resolveConfigurationPrimaryTranslations >', () => {
+  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
+  const setCacheMetadata = jest.fn();
+
+  beforeAll(() => {
+    restClient = createRestClient();
+  });
+
+  beforeEach(() => {
+    mockedFetch.mockGetOnce(buildEndpoint(CONFIGURATION_PATH, { type: 'primary_translations' }), {
+      body: configurationPrimaryTranslations,
+    });
+  });
+
+  afterEach(async () => {
+    mockedFetch.mockReset();
+    await restClient.cache?.clear();
+  });
+
+  it('should return the configuration primary translations', async () => {
+    await expect(
+      resolveConfigurationPrimaryTranslations(
+        configurationBase as unknown as RawConfiguration,
+        undefined,
+        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+        {} as GraphQLResolveInfo
+      )
+    ).resolves.toMatchSnapshot();
+  });
+});

package/src/queries/configurationPrimaryTranslations.ts

@@ -0,0 +1,29 @@
+import type { GraphQLResolveInfo } from 'graphql';
+import { GraphQLError } from 'graphql';
+import { snakeCase } from 'lodash-es';
+import { CONFIGURATION, PRIMARY_TRANSLATIONS } from '../constants.ts';
+import type { Context, RawConfiguration, RawConfigurationPrimaryTranslations } from '../types.ts';
+
+export const resolveConfigurationPrimaryTranslations = async (
+  _obj: RawConfiguration,
+  _args: undefined,
+  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
+  { fieldNodes }: GraphQLResolveInfo
+) => {
+  const { data, errors, headers } = await restClient.configuration<RawConfigurationPrimaryTranslations>(
+    {
+      pathTemplateData: { type: snakeCase(PRIMARY_TRANSLATIONS) },
+    },
+    { requestID, tmdbGuestSessionId }
+  );
+
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${CONFIGURATION} ${PRIMARY_TRANSLATIONS}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0],
+    });
+  }
+
+  setCacheMetadata(`${CONFIGURATION}.${PRIMARY_TRANSLATIONS}`, headers);
+  return data;
+};

package/src/queries/configurationTimezones.test.ts

@@ -0,0 +1,45 @@
+import { jest } from '@jest/globals';
+import { CONFIGURATION_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import configurationBase from '@tmdb-graphql-api/test-utils/responses/themoviedb/configuration/base.json';
+import configurationTimezones from '@tmdb-graphql-api/test-utils/responses/themoviedb/configuration/timezones.json';
+import { mockFetch, polyfillFetch } from 'fetch-mocked';
+import type { 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, RawConfiguration } from '../types.ts';
+import { resolveConfigurationTimezones } from './configurationTimezones.ts';
+
+polyfillFetch();
+const mockedFetch = mockFetch(jest.fn);
+
+describe('resolveConfigurationTimezones >', () => {
+  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
+  const setCacheMetadata = jest.fn();
+
+  beforeAll(() => {
+    restClient = createRestClient();
+  });
+
+  beforeEach(() => {
+    mockedFetch.mockGetOnce(buildEndpoint(CONFIGURATION_PATH, { type: 'timezones' }), {
+      body: configurationTimezones,
+    });
+  });
+
+  afterEach(async () => {
+    mockedFetch.mockReset();
+    await restClient.cache?.clear();
+  });
+
+  it('should return the configuration timezones', async () => {
+    await expect(
+      resolveConfigurationTimezones(
+        configurationBase as unknown as RawConfiguration,
+        undefined,
+        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+        {} as GraphQLResolveInfo
+      )
+    ).resolves.toMatchSnapshot();
+  });
+});

package/src/queries/configurationTimezones.ts

@@ -0,0 +1,28 @@
+import type { GraphQLResolveInfo } from 'graphql';
+import { GraphQLError } from 'graphql';
+import { CONFIGURATION, TIMEZONES } from '../constants.ts';
+import type { Context, RawConfiguration, RawConfigurationTimezones } from '../types.ts';
+
+export const resolveConfigurationTimezones = async (
+  _obj: RawConfiguration,
+  _args: undefined,
+  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
+  { fieldNodes }: GraphQLResolveInfo
+) => {
+  const { data, errors, headers } = await restClient.configuration<RawConfigurationTimezones>(
+    {
+      pathTemplateData: { type: TIMEZONES },
+    },
+    { requestID, tmdbGuestSessionId }
+  );
+
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${CONFIGURATION} ${TIMEZONES}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0],
+    });
+  }
+
+  setCacheMetadata(`${CONFIGURATION}.${TIMEZONES}`, headers);
+  return data;
+};

package/src/queries/credit.test.ts

@@ -0,0 +1,45 @@
+import { jest } from '@jest/globals';
+import { CREDIT_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import creditDetails from '@tmdb-graphql-api/test-utils/responses/themoviedb/credit/details.json';
+import { mockFetch, polyfillFetch } from 'fetch-mocked';
+import type { 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 } from '../types.ts';
+import { resolveCredit } from './credit.ts';
+
+polyfillFetch();
+const mockedFetch = mockFetch(jest.fn);
+
+describe('resolveCredit >', () => {
+  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
+  const setCacheMetadata = jest.fn();
+  const id = 2;
+
+  beforeAll(() => {
+    restClient = createRestClient();
+  });
+
+  beforeEach(() => {
+    mockedFetch.mockGetOnce(buildEndpoint(CREDIT_PATH, { id }), {
+      body: creditDetails,
+    });
+  });
+
+  afterEach(async () => {
+    mockedFetch.mockReset();
+    await restClient.cache?.clear();
+  });
+
+  it('should return the correct credit details', async () => {
+    await expect(
+      resolveCredit(
+        undefined,
+        { id },
+        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+        {} as GraphQLResolveInfo
+      )
+    ).resolves.toMatchSnapshot();
+  });
+});

package/src/queries/credit.ts

@@ -0,0 +1,26 @@
+import type { QueryCreditArgs } from '@tmdb-graphql-api/schema';
+import { GraphQLError } from 'graphql';
+import type { GraphQLResolveInfo } from 'graphql';
+import { CREDIT } from '../constants.ts';
+import type { Context, RawCredit } from '../types.ts';
+
+export const resolveCredit = async (
+  _obj: undefined,
+  { id }: QueryCreditArgs,
+  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
+  { fieldNodes }: GraphQLResolveInfo
+) => {
+  const { data, errors, headers } = await restClient.credit<RawCredit>(
+    {
+      pathTemplateData: { id },
+    },
+    { requestID, tmdbGuestSessionId }
+  );
+
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${CREDIT} ${id}.`, { nodes: fieldNodes, originalError: errors[0] });
+  }
+
+  setCacheMetadata(CREDIT, headers);
+  return data;
+};

package/src/queries/discoverMovies.test.ts

@@ -0,0 +1,202 @@
+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 { MovieSortBy } from '@tmdb-graphql-api/schema';
+import discoverMovies2010 from '@tmdb-graphql-api/test-utils/responses/themoviedb/discoverMovies/2010.json';
+import discoverMovies2020 from '@tmdb-graphql-api/test-utils/responses/themoviedb/discoverMovies/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_MOVIES } 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, resolveDiscoverMovies } from './discoverMovies.ts';
+
+polyfillFetch();
+const mockedFetch = mockFetch(jest.fn);
+
+const baseArgs = {
+  includeAdult: false,
+  includeVideo: false,
+  language: 'en-US',
+  primaryReleaseYear: 2020,
+  sortBy: 'POPULARITY_DESC' as MovieSortBy,
+  // eslint-disable-next-line unicorn/no-null
+  voteCountGte: null,
+};
+
+describe('createMakeCursors', () => {
+  const GROUP_CURSOR = `${JSON.stringify(
+    removeNullValues(removeConnectionInputOptions(baseArgs))
+  )}::${DISCOVER_MOVIES}`;
+
+  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: 'movie' },
+        queryParams: {
+          include_adult: false,
+          include_video: false,
+          language: 'en-US',
+          page: 1,
+          primary_release_year: 2020,
+          sort_by: 'popularity.desc',
+        },
+      },
+      { requestID: undefined, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' }
+    );
+  });
+});
+
+describe('resolveDiscoverMovies', () => {
+  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
+  const setCacheMetadata = jest.fn();
+  const type = 'movie';
+
+  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, discoverMovies2020);
+    mockEndpoint({ ...baseArgs, primaryReleaseYear: 2010 }, 1, discoverMovies2010);
+  });
+
+  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(
+        resolveDiscoverMovies(
+          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 resolveDiscoverMovies(
+        undefined,
+        { ...baseArgs, first: 5 },
+        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+        {} as GraphQLResolveInfo
+      );
+
+      await expect(
+        resolveDiscoverMovies(
+          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 twice', () => {
+    beforeEach(async () => {
+      await resolveDiscoverMovies(
+        undefined,
+        { ...baseArgs, first: 5 },
+        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+        {} as GraphQLResolveInfo
+      );
+
+      await resolveDiscoverMovies(
+        undefined,
+        { ...baseArgs, first: 5 },
+        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+        {} as GraphQLResolveInfo
+      );
+    });
+
+    it('should only request the resource from the server once', () => {
+      expect(mockedFetch).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('when the first 5 are requested with different args twice', () => {
+    beforeEach(async () => {
+      await resolveDiscoverMovies(
+        undefined,
+        { ...baseArgs, first: 5 },
+        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+        {} as GraphQLResolveInfo
+      );
+
+      await resolveDiscoverMovies(
+        undefined,
+        { ...baseArgs, first: 5 },
+        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+        {} as GraphQLResolveInfo
+      );
+
+      await resolveDiscoverMovies(
+        undefined,
+        { ...baseArgs, first: 5, primaryReleaseYear: 2010 },
+        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+        {} as GraphQLResolveInfo
+      );
+
+      await resolveDiscoverMovies(
+        undefined,
+        { ...baseArgs, first: 5, primaryReleaseYear: 2010 },
+        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+        {} as GraphQLResolveInfo
+      );
+    });
+
+    it('should request each resource from the server once', () => {
+      expect(mockedFetch).toHaveBeenCalledTimes(2);
+    });
+  });
+});