@tmdb-graphql-api/resolvers 0.0.6

package/src/queries/episodeExternalIds.test.ts

@@ -0,0 +1,104 @@
+import type { PlainArray } from '@graphql-box/core';
+import { jest } from '@jest/globals';
+import { EPISODE_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import episodeDetails from '@tmdb-graphql-api/test-utils/responses/themoviedb/tv/1399/seasons/1/episodes/1/details.json';
+import seasonExternalIds from '@tmdb-graphql-api/test-utils/responses/themoviedb/tv/1399/seasons/1/episodes/1/externalIds.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, RawEpisodeWithAppendToResponse } from '../types.ts';
+import { resolveEpisodeExternalIds } from './episodeExternalIds.ts';
+
+polyfillFetch();
+const mockedFetch = mockFetch(jest.fn);
+
+describe('resolveEpisodeExternalIds >', () => {
+  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: 'external_ids' }),
+      {
+        body: seasonExternalIds,
+      }
+    );
+  });
+
+  afterEach(async () => {
+    mockedFetch.mockReset();
+    await restClient.cache?.clear();
+  });
+
+  it('should return the episode external IDs', async () => {
+    await expect(
+      resolveEpisodeExternalIds(
+        episodeDetails as RawEpisode,
+        undefined,
+        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+        {} as GraphQLResolveInfo
+      )
+    ).resolves.toMatchSnapshot();
+  });
+
+  describe('when raw episode data has external IDs', () => {
+    it('should return the correct response', async () => {
+      const { id, ...rest } = seasonExternalIds;
+
+      const episodeFetchMock = jest
+        .fn<(...args: PlainArray) => Promise<FetchResponse>>()
+        .mockResolvedValue({ data: {} } as FetchResponse);
+
+      await expect(
+        resolveEpisodeExternalIds(
+          {
+            ...episodeDetails,
+            __headers: new Headers(),
+            external_ids: rest,
+          } as unknown as RawEpisodeWithAppendToResponse,
+          undefined,
+          {
+            restClient: { episode: episodeFetchMock } 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 { id, ...rest } = seasonExternalIds;
+
+      const episodeFetchMock = jest
+        .fn<(...args: PlainArray) => Promise<FetchResponse>>()
+        .mockResolvedValue({ data: {} } as FetchResponse);
+
+      await resolveEpisodeExternalIds(
+        {
+          ...episodeDetails,
+          __headers: new Headers(),
+          external_ids: rest,
+        } as unknown as RawEpisodeWithAppendToResponse,
+        undefined,
+        {
+          restClient: { episode: episodeFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
+          setCacheMetadata,
+          tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+        } as unknown as Context,
+        {} as GraphQLResolveInfo
+      );
+
+      expect(episodeFetchMock).not.toHaveBeenCalled();
+    });
+  });
+});

package/src/queries/episodeExternalIds.ts

@@ -0,0 +1,40 @@
+import { GraphQLError } from 'graphql';
+import type { GraphQLResolveInfo } from 'graphql';
+import { snakeCase } from 'lodash-es';
+import { EPISODE, EXTERNAL_IDS, SEASON, TV } from '../constants.ts';
+import type { Context, RawEpisodeExternalIds, RawEpisodeWithAppendToResponse } 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 { data, errors, headers } = await restClient.episode<RawEpisodeExternalIds>(
+    {
+      pathTemplateData: {
+        episodeNumber: obj.episode_number,
+        id: obj.tv_show_id,
+        seasonNumber: obj.season_number,
+        type: snakeCase(EXTERNAL_IDS),
+      },
+    },
+    { 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] }
+    );
+  }
+
+  setCacheMetadata(`${EPISODE}.${EXTERNAL_IDS}`, headers);
+  const { id: movieId, ...rest } = data!;
+  return rest;
+};

package/src/queries/episodeStills.test.ts

@@ -0,0 +1,96 @@
+import type { PlainArray } from '@graphql-box/core';
+import { jest } from '@jest/globals';
+import { EPISODE_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import episodeDetails from '@tmdb-graphql-api/test-utils/responses/themoviedb/tv/1399/seasons/1/episodes/1/details.json';
+import episodeStills from '@tmdb-graphql-api/test-utils/responses/themoviedb/tv/1399/seasons/1/episodes/1/images.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 { resolveEpisodeStills } from './episodeStills.ts';
+
+polyfillFetch();
+const mockedFetch = mockFetch(jest.fn);
+
+describe('resolveEpisodeStills >', () => {
+  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: 'images' }),
+      {
+        body: episodeStills,
+      }
+    );
+  });
+
+  afterEach(async () => {
+    mockedFetch.mockReset();
+    await restClient.cache?.clear();
+  });
+
+  it('should return the episode stills', async () => {
+    await expect(
+      resolveEpisodeStills(
+        episodeDetails as RawEpisode,
+        undefined,
+        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+        {} as GraphQLResolveInfo
+      )
+    ).resolves.toMatchSnapshot();
+  });
+
+  describe('when raw episode data has images', () => {
+    it('should return the correct response', async () => {
+      const episodeFetchMock = jest
+        .fn<(...args: PlainArray) => Promise<FetchResponse>>()
+        .mockResolvedValue({ data: {} } as FetchResponse);
+
+      const { id, ...rest } = episodeStills;
+
+      await expect(
+        resolveEpisodeStills(
+          { ...episodeDetails, __headers: new Headers(), images: rest },
+          undefined,
+          {
+            restClient: { episode: episodeFetchMock } 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 episodeFetchMock = jest
+        .fn<(...args: PlainArray) => Promise<FetchResponse>>()
+        .mockResolvedValue({ data: {} } as FetchResponse);
+
+      const { id, ...rest } = episodeStills;
+
+      await resolveEpisodeStills(
+        { ...episodeDetails, __headers: new Headers(), images: rest },
+        undefined,
+        {
+          restClient: { episode: episodeFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
+          setCacheMetadata,
+          tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+        } as unknown as Context,
+        {} as GraphQLResolveInfo
+      );
+
+      expect(episodeFetchMock).not.toHaveBeenCalled();
+    });
+  });
+});

package/src/queries/episodeStills.ts

@@ -0,0 +1,38 @@
+import type { GraphQLResolveInfo } from 'graphql';
+import { GraphQLError } from 'graphql';
+import { EPISODE, IMAGES, SEASON, STILLS, TV } from '../constants.ts';
+import type { Context, RawEpisodeImages, RawEpisodeWithAppendToResponse } from '../types.ts';
+
+export const resolveEpisodeStills = async (
+  obj: RawEpisodeWithAppendToResponse & { __headers?: Headers },
+  _args: undefined,
+  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
+  { fieldNodes }: GraphQLResolveInfo
+) => {
+  if (obj.images && obj.__headers) {
+    setCacheMetadata(`${EPISODE}.${STILLS}`, obj.__headers);
+    return obj.images.stills;
+  }
+
+  const { data, errors, headers } = await restClient.episode<RawEpisodeImages>(
+    {
+      pathTemplateData: {
+        episodeNumber: obj.episode_number,
+        id: obj.tv_show_id,
+        seasonNumber: obj.season_number,
+        type: IMAGES,
+      },
+    },
+    { 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} ${STILLS}.`,
+      { nodes: fieldNodes, originalError: errors[0] }
+    );
+  }
+
+  setCacheMetadata(`${EPISODE}.${STILLS}`, headers);
+  return data!.stills;
+};

package/src/queries/episodeTranslations.test.ts

@@ -0,0 +1,96 @@
+import type { PlainArray } from '@graphql-box/core';
+import { jest } from '@jest/globals';
+import { EPISODE_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import episodeDetails from '@tmdb-graphql-api/test-utils/responses/themoviedb/tv/1399/seasons/1/episodes/1/details.json';
+import episodeTranslations from '@tmdb-graphql-api/test-utils/responses/themoviedb/tv/1399/seasons/1/episodes/1/translations.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 { resolveEpisodeTranslations } from './episodeTranslations.ts';
+
+polyfillFetch();
+const mockedFetch = mockFetch(jest.fn);
+
+describe('resolveEpisodeTranslations >', () => {
+  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: 'translations' }),
+      {
+        body: episodeTranslations,
+      }
+    );
+  });
+
+  afterEach(async () => {
+    mockedFetch.mockReset();
+    await restClient.cache?.clear();
+  });
+
+  it('should return the episode translations', async () => {
+    await expect(
+      resolveEpisodeTranslations(
+        episodeDetails as RawEpisode,
+        undefined,
+        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+        {} as GraphQLResolveInfo
+      )
+    ).resolves.toMatchSnapshot();
+  });
+
+  describe('when raw episode data has translations', () => {
+    it('should return the correct response', async () => {
+      const episodeFetchMock = jest
+        .fn<(...args: PlainArray) => Promise<FetchResponse>>()
+        .mockResolvedValue({ data: {} } as FetchResponse);
+
+      const { id, ...rest } = episodeTranslations;
+
+      await expect(
+        resolveEpisodeTranslations(
+          { ...episodeDetails, __headers: new Headers(), translations: rest },
+          undefined,
+          {
+            restClient: { episode: episodeFetchMock } 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 episodeFetchMock = jest
+        .fn<(...args: PlainArray) => Promise<FetchResponse>>()
+        .mockResolvedValue({ data: {} } as FetchResponse);
+
+      const { id, ...rest } = episodeTranslations;
+
+      await resolveEpisodeTranslations(
+        { ...episodeDetails, __headers: new Headers(), translations: rest },
+        undefined,
+        {
+          restClient: { episode: episodeFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
+          setCacheMetadata,
+          tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+        } as unknown as Context,
+        {} as GraphQLResolveInfo
+      );
+
+      expect(episodeFetchMock).not.toHaveBeenCalled();
+    });
+  });
+});

package/src/queries/episodeTranslations.ts

@@ -0,0 +1,38 @@
+import { GraphQLError } from 'graphql';
+import type { GraphQLResolveInfo } from 'graphql';
+import { EPISODE, SEASON, TRANSLATIONS, TV } from '../constants.ts';
+import type { Context, RawEpisodeTranslations, RawEpisodeWithAppendToResponse } from '../types.ts';
+
+export const resolveEpisodeTranslations = async (
+  obj: RawEpisodeWithAppendToResponse & { __headers?: Headers },
+  _args: undefined,
+  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
+  { fieldNodes }: GraphQLResolveInfo
+) => {
+  if (obj.translations && obj.__headers) {
+    setCacheMetadata(`${EPISODE}.${TRANSLATIONS}`, obj.__headers);
+    return obj.translations.translations;
+  }
+
+  const { data, errors, headers } = await restClient.episode<RawEpisodeTranslations>(
+    {
+      pathTemplateData: {
+        episodeNumber: obj.episode_number,
+        id: obj.tv_show_id,
+        seasonNumber: obj.season_number,
+        type: TRANSLATIONS,
+      },
+    },
+    { 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} ${TRANSLATIONS}.`,
+      { nodes: fieldNodes, originalError: errors[0] }
+    );
+  }
+
+  setCacheMetadata(`${EPISODE}.${TRANSLATIONS}`, headers);
+  return data?.translations;
+};

package/src/queries/episodeVideos.test.ts

@@ -0,0 +1,96 @@
+import type { PlainArray } from '@graphql-box/core';
+import { jest } from '@jest/globals';
+import { EPISODE_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import episodeDetails from '@tmdb-graphql-api/test-utils/responses/themoviedb/tv/1399/seasons/1/episodes/1/details.json';
+import episodeVideos from '@tmdb-graphql-api/test-utils/responses/themoviedb/tv/1399/seasons/1/episodes/1/videos.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 { resolveEpisodeVideos } from './episodeVideos.ts';
+
+polyfillFetch();
+const mockedFetch = mockFetch(jest.fn);
+
+describe('resolveEpisodeVideos >', () => {
+  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: 'videos' }),
+      {
+        body: episodeVideos,
+      }
+    );
+  });
+
+  afterEach(async () => {
+    mockedFetch.mockReset();
+    await restClient.cache?.clear();
+  });
+
+  it('should return the episode videos', async () => {
+    await expect(
+      resolveEpisodeVideos(
+        episodeDetails as RawEpisode,
+        undefined,
+        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+        {} as GraphQLResolveInfo
+      )
+    ).resolves.toMatchSnapshot();
+  });
+
+  describe('when raw episode data has videos', () => {
+    it('should return the correct response', async () => {
+      const episodeFetchMock = jest
+        .fn<(...args: PlainArray) => Promise<FetchResponse>>()
+        .mockResolvedValue({ data: {} } as FetchResponse);
+
+      const { id, ...rest } = episodeVideos;
+
+      await expect(
+        resolveEpisodeVideos(
+          { ...episodeDetails, __headers: new Headers(), videos: rest },
+          undefined,
+          {
+            restClient: { episode: episodeFetchMock } 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 episodeFetchMock = jest
+        .fn<(...args: PlainArray) => Promise<FetchResponse>>()
+        .mockResolvedValue({ data: {} } as FetchResponse);
+
+      const { id, ...rest } = episodeVideos;
+
+      await resolveEpisodeVideos(
+        { ...episodeDetails, __headers: new Headers(), videos: rest },
+        undefined,
+        {
+          restClient: { episode: episodeFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
+          setCacheMetadata,
+          tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+        } as unknown as Context,
+        {} as GraphQLResolveInfo
+      );
+
+      expect(episodeFetchMock).not.toHaveBeenCalled();
+    });
+  });
+});

package/src/queries/episodeVideos.ts

@@ -0,0 +1,38 @@
+import { GraphQLError } from 'graphql';
+import type { GraphQLResolveInfo } from 'graphql';
+import { EPISODE, SEASON, TV, VIDEOS } from '../constants.ts';
+import type { Context, RawEpisodeVideos, RawEpisodeWithAppendToResponse } from '../types.ts';
+
+export const resolveEpisodeVideos = async (
+  obj: RawEpisodeWithAppendToResponse & { __headers?: Headers },
+  _args: undefined,
+  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
+  { fieldNodes }: GraphQLResolveInfo
+) => {
+  if (obj.videos && obj.__headers) {
+    setCacheMetadata(`${EPISODE}.${VIDEOS}`, obj.__headers);
+    return obj.videos.results;
+  }
+
+  const { data, errors, headers } = await restClient.episode<RawEpisodeVideos>(
+    {
+      pathTemplateData: {
+        episodeNumber: obj.episode_number,
+        id: obj.tv_show_id,
+        seasonNumber: 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} ${EPISODE} ${obj.episode_number} ${VIDEOS}.`,
+      { nodes: fieldNodes, originalError: errors[0] }
+    );
+  }
+
+  setCacheMetadata(`${EPISODE}.${VIDEOS}`, headers);
+  return data?.results;
+};

package/src/queries/find.test.ts

@@ -0,0 +1,48 @@
+import { jest } from '@jest/globals';
+import { FIND_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import type { ExternalSource } from '@tmdb-graphql-api/schema';
+import findResults from '@tmdb-graphql-api/test-utils/responses/themoviedb/find/results.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 { snakeCasePropNames } from '../helpers/snakeCasePropNames.ts';
+import type { Context } from '../types.ts';
+import { resolveFind } from './find.ts';
+
+polyfillFetch();
+const mockedFetch = mockFetch(jest.fn);
+
+describe('resolveFind >', () => {
+  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
+  const setCacheMetadata = jest.fn();
+  const id = 'nm0000129';
+  const source = 'imdb_id' as ExternalSource;
+
+  beforeAll(() => {
+    restClient = createRestClient();
+  });
+
+  beforeEach(() => {
+    mockedFetch.mockGetOnce(buildEndpoint(FIND_PATH, { id }, snakeCasePropNames({ externalSource: source })), {
+      body: findResults,
+    });
+  });
+
+  afterEach(async () => {
+    mockedFetch.mockReset();
+    await restClient.cache?.clear();
+  });
+
+  it('should return the correct find results', async () => {
+    await expect(
+      resolveFind(
+        undefined,
+        { id, source },
+        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+        {} as GraphQLResolveInfo
+      )
+    ).resolves.toMatchSnapshot();
+  });
+});

package/src/queries/find.ts

@@ -0,0 +1,35 @@
+import type { QueryFindArgs } from '@tmdb-graphql-api/schema';
+import { GraphQLError } from 'graphql';
+import type { GraphQLResolveInfo } from 'graphql';
+import { FIND } from '../constants.ts';
+import { snakeCasePropNames } from '../helpers/snakeCasePropNames.ts';
+import type { Context, RawFind } from '../types.ts';
+
+export const resolveFind = async (
+  _obj: undefined,
+  { id, source }: QueryFindArgs,
+  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
+  { fieldNodes }: GraphQLResolveInfo
+) => {
+  const { data, errors, headers } = await restClient.find<RawFind>(
+    {
+      pathTemplateData: { id },
+      queryParams: { ...snakeCasePropNames({ externalSource: source }) },
+    },
+    { requestID, tmdbGuestSessionId }
+  );
+
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${FIND} ${id}.`, { nodes: fieldNodes, originalError: errors[0] });
+  }
+
+  setCacheMetadata(FIND, headers);
+
+  return {
+    episodes: data?.tv_episode_results,
+    movies: data?.movie_results,
+    people: data?.person_results,
+    seasons: data?.tv_season_results,
+    tv: data?.tv_results,
+  };
+};