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

package/src/queries/episodeStills.test.ts

@@ -7,56 +7,43 @@ import { mockFetch } from 'fetch-mocked';
 import { type FetchResponse, type Getta, type ShortcutProperties } from 'getta';
 import { type GraphQLResolveInfo } from 'graphql';
 import { buildEndpoint } from '../__testUtils__/helpers/buildEndpoint.ts';
+import { createMockLogger } from '../__testUtils__/helpers/createMockLogger.ts';
 import { createRestClient } from '../__testUtils__/helpers/createRestClient.ts';
-import { encodeId } from '../helpers/encodeId.ts';
-import { type Context, type RawEpisode } from '../types.ts';
+import { IMAGES, STILLS } from '../constants.ts';
+import { type Context } from '../types.ts';
 import { resolveEpisodeStills } from './episodeStills.ts';
 
 const mockedFetch = mockFetch(jest.fn);
 
-const episodeDetailsWithLookupId: RawEpisode = {
-  ...episodeDetails,
-  episode_lookup_id: encodeId({
-    episodeNumber: episodeDetails.episode_number,
-    seasonNumber: episodeDetails.season_number,
-    tvId: episodeDetails.tv_show_id,
-  }),
-};
-
 describe('resolveEpisodeStills >', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
   const tvShowId = 1399;
   const seasonNumber = 1;
   const episodeNumber = 1;
 
-  beforeAll(() => {
-    restClient = createRestClient();
-  });
+  const context = {
+    logger: createMockLogger(jest.fn),
+    restClient: createRestClient(),
+    setCacheMetadata: jest.fn(),
+    tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+  } as unknown as Context;
+
+  const info = { fieldName: STILLS } as GraphQLResolveInfo;
 
   beforeEach(() => {
-    mockedFetch.mockGetOnce(
-      buildEndpoint(EPISODE_PATH, { episodeNumber, id: tvShowId, seasonNumber, type: 'images' }),
-      {
-        body: episodeStills,
-      }
-    );
+    mockedFetch.mockGetOnce(buildEndpoint(EPISODE_PATH, { episodeNumber, id: tvShowId, seasonNumber, type: IMAGES }), {
+      body: episodeStills,
+    });
   });
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   it('should return the episode stills', async () => {
-    await expect(
-      resolveEpisodeStills(
-        episodeDetailsWithLookupId,
-        undefined,
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
-      )
-    ).resolves.toMatchSnapshot();
+    // @ts-expect-error arg is slightly modified version of episode details
+    await expect(resolveEpisodeStills(episodeDetails, undefined, context, info)).resolves.toMatchSnapshot();
   });
 
   describe('when raw episode data has images', () => {
@@ -69,14 +56,14 @@ describe('resolveEpisodeStills >', () => {
 
       await expect(
         resolveEpisodeStills(
-          { ...episodeDetailsWithLookupId, __headers: new Headers(), images: rest },
+          // @ts-expect-error arg is slightly modified version of episode details
+          { ...episodeDetails, __headers: new Headers(), images: rest },
           undefined,
           {
+            ...context,
             restClient: { episode: episodeFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-            setCacheMetadata,
-            tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-          } as unknown as Context,
-          {} as GraphQLResolveInfo
+          },
+          info
         )
       ).resolves.toMatchSnapshot();
     });
@@ -89,14 +76,14 @@ describe('resolveEpisodeStills >', () => {
       const { id, ...rest } = episodeStills;
 
       await resolveEpisodeStills(
-        { ...episodeDetailsWithLookupId, __headers: new Headers(), images: rest },
+        // @ts-expect-error arg is slightly modified version of episode details
+        { ...episodeDetails, __headers: new Headers(), images: rest },
         undefined,
         {
+          ...context,
           restClient: { episode: episodeFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-          setCacheMetadata,
-          tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-        } as unknown as Context,
-        {} as GraphQLResolveInfo
+        },
+        info
       );
 
       expect(episodeFetchMock).not.toHaveBeenCalled();

package/src/queries/episodeStills.ts

@@ -1,16 +1,30 @@
-import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
-import { EPISODE, IMAGES, SEASON, STILLS, TV } from '../constants.ts';
-import { type Context, type RawEpisodeImages, type RawEpisodeWithAppendToResponse } from '../types.ts';
+import { snakeCase } from 'lodash-es';
+import { EPISODE, IMAGES } from '../constants.ts';
+import { buildObjResolver } from '../helpers/buildObjResolver.ts';
+import {
+  type EnrichedRawEpisode,
+  type EnrichedRawEpisodeWithAppendToResponse,
+  type RawEpisodeImages,
+} 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 isEnrichedRawEpisodeWithImages = (
+  obj: EnrichedRawEpisode | (EnrichedRawEpisodeWithAppendToResponse & { __headers?: Headers })
+): obj is EnrichedRawEpisodeWithAppendToResponse & { __headers: Headers } => IMAGES in obj && '__headers' in obj;
+
+export const resolveEpisodeStills = buildObjResolver<
+  EnrichedRawEpisode | (EnrichedRawEpisodeWithAppendToResponse & { __headers?: Headers }),
+  RawEpisodeImages['stills']
+>(EPISODE, async (obj, ctx, info) => {
+  const { requestID, restClient, tmdbGuestSessionId } = ctx;
+  const { fieldName } = info;
+  const typedFieldName = snakeCase(fieldName) as 'stills';
+
+  if (isEnrichedRawEpisodeWithImages(obj)) {
+    return {
+      data: obj.images?.[typedFieldName],
+      headers: obj.__headers,
+      source: 'parentNode',
+    };
   }
 
   const { data, errors, headers } = await restClient.episode<RawEpisodeImages>(
@@ -25,13 +39,9 @@ export const resolveEpisodeStills = async (
     { requestID, tmdbGuestSessionId }
   );
 
-  if (errors?.length) {
-    throw new GraphQLError(
-      `Failed to resolve ${TV} show ${obj.tv_show_id} ${SEASON} ${obj.season_number} ${EPISODE} ${obj.episode_number} ${STILLS}.`,
-      { nodes: fieldNodes, originalError: errors[0] }
-    );
-  }
-
-  setCacheMetadata(`${EPISODE}.${STILLS}`, headers);
-  return data!.stills;
-};
+  return {
+    data: data?.[typedFieldName],
+    errors,
+    headers,
+  };
+});

package/src/queries/episodeTranslations.test.ts

@@ -7,36 +7,31 @@ import { mockFetch } from 'fetch-mocked';
 import { type FetchResponse, type Getta, type ShortcutProperties } from 'getta';
 import { type GraphQLResolveInfo } from 'graphql';
 import { buildEndpoint } from '../__testUtils__/helpers/buildEndpoint.ts';
+import { createMockLogger } from '../__testUtils__/helpers/createMockLogger.ts';
 import { createRestClient } from '../__testUtils__/helpers/createRestClient.ts';
-import { encodeId } from '../helpers/encodeId.ts';
-import { type Context, type RawEpisode } from '../types.ts';
+import { TRANSLATIONS } from '../constants.ts';
+import { type Context } from '../types.ts';
 import { resolveEpisodeTranslations } from './episodeTranslations.ts';
 
 const mockedFetch = mockFetch(jest.fn);
 
-const episodeDetailsWithLookupId: RawEpisode = {
-  ...episodeDetails,
-  episode_lookup_id: encodeId({
-    episodeNumber: episodeDetails.episode_number,
-    seasonNumber: episodeDetails.season_number,
-    tvId: episodeDetails.tv_show_id,
-  }),
-};
-
 describe('resolveEpisodeTranslations >', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
   const tvShowId = 1399;
   const seasonNumber = 1;
   const episodeNumber = 1;
 
-  beforeAll(() => {
-    restClient = createRestClient();
-  });
+  const context = {
+    logger: createMockLogger(jest.fn),
+    restClient: createRestClient(),
+    setCacheMetadata: jest.fn(),
+    tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+  } as unknown as Context;
+
+  const info = { fieldName: TRANSLATIONS } as GraphQLResolveInfo;
 
   beforeEach(() => {
     mockedFetch.mockGetOnce(
-      buildEndpoint(EPISODE_PATH, { episodeNumber, id: tvShowId, seasonNumber, type: 'translations' }),
+      buildEndpoint(EPISODE_PATH, { episodeNumber, id: tvShowId, seasonNumber, type: TRANSLATIONS }),
       {
         body: episodeTranslations,
       }
@@ -45,17 +40,14 @@ describe('resolveEpisodeTranslations >', () => {
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   it('should return the episode translations', async () => {
     await expect(
-      resolveEpisodeTranslations(
-        episodeDetailsWithLookupId,
-        undefined,
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
-      )
+      // @ts-expect-error arg is slightly modified version of episode details
+      resolveEpisodeTranslations(episodeDetails, undefined, context, info)
     ).resolves.toMatchSnapshot();
   });
 
@@ -69,14 +61,14 @@ describe('resolveEpisodeTranslations >', () => {
 
       await expect(
         resolveEpisodeTranslations(
-          { ...episodeDetailsWithLookupId, __headers: new Headers(), translations: rest },
+          // @ts-expect-error arg is slightly modified version of episode details
+          { ...episodeDetails, __headers: new Headers(), translations: rest },
           undefined,
           {
+            ...context,
             restClient: { episode: episodeFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-            setCacheMetadata,
-            tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-          } as unknown as Context,
-          {} as GraphQLResolveInfo
+          },
+          info
         )
       ).resolves.toMatchSnapshot();
     });
@@ -89,14 +81,14 @@ describe('resolveEpisodeTranslations >', () => {
       const { id, ...rest } = episodeTranslations;
 
       await resolveEpisodeTranslations(
-        { ...episodeDetailsWithLookupId, __headers: new Headers(), translations: rest },
+        // @ts-expect-error arg is slightly modified version of episode details
+        { ...episodeDetails, __headers: new Headers(), translations: rest },
         undefined,
         {
+          ...context,
           restClient: { episode: episodeFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-          setCacheMetadata,
-          tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-        } as unknown as Context,
-        {} as GraphQLResolveInfo
+        },
+        info
       );
 
       expect(episodeFetchMock).not.toHaveBeenCalled();

package/src/queries/episodeTranslations.ts

@@ -1,16 +1,27 @@
-import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
-import { EPISODE, SEASON, TRANSLATIONS, TV } from '../constants.ts';
-import { type Context, type RawEpisodeTranslations, type RawEpisodeWithAppendToResponse } from '../types.ts';
+import { EPISODE, TRANSLATIONS } from '../constants.ts';
+import { buildObjResolver } from '../helpers/buildObjResolver.ts';
+import {
+  type EnrichedRawEpisode,
+  type EnrichedRawEpisodeWithAppendToResponse,
+  type RawEpisodeTranslations,
+} 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 isEnrichedRawEpisodeWithTranslations = (
+  obj: EnrichedRawEpisode | (EnrichedRawEpisodeWithAppendToResponse & { __headers?: Headers })
+): obj is EnrichedRawEpisodeWithAppendToResponse & { __headers: Headers } => TRANSLATIONS in obj && '__headers' in obj;
+
+export const resolveEpisodeTranslations = buildObjResolver<
+  EnrichedRawEpisode | (EnrichedRawEpisodeWithAppendToResponse & { __headers?: Headers }),
+  RawEpisodeTranslations['translations']
+>(EPISODE, async (obj, ctx) => {
+  const { requestID, restClient, tmdbGuestSessionId } = ctx;
+
+  if (isEnrichedRawEpisodeWithTranslations(obj)) {
+    return {
+      data: obj.translations?.translations,
+      headers: obj.__headers,
+      source: 'parentNode',
+    };
   }
 
   const { data, errors, headers } = await restClient.episode<RawEpisodeTranslations>(
@@ -25,13 +36,9 @@ export const resolveEpisodeTranslations = async (
     { requestID, tmdbGuestSessionId }
   );
 
-  if (errors?.length) {
-    throw new GraphQLError(
-      `Failed to resolve ${TV} show ${obj.tv_show_id} ${SEASON} ${obj.season_number} ${EPISODE} ${obj.episode_number} ${TRANSLATIONS}.`,
-      { nodes: fieldNodes, originalError: errors[0] }
-    );
-  }
-
-  setCacheMetadata(`${EPISODE}.${TRANSLATIONS}`, headers);
-  return data?.translations;
-};
+  return {
+    data: data?.translations,
+    errors,
+    headers,
+  };
+});

package/src/queries/episodeVideos.test.ts

@@ -7,56 +7,43 @@ import { mockFetch } from 'fetch-mocked';
 import { type FetchResponse, type Getta, type ShortcutProperties } from 'getta';
 import { type GraphQLResolveInfo } from 'graphql';
 import { buildEndpoint } from '../__testUtils__/helpers/buildEndpoint.ts';
+import { createMockLogger } from '../__testUtils__/helpers/createMockLogger.ts';
 import { createRestClient } from '../__testUtils__/helpers/createRestClient.ts';
-import { encodeId } from '../helpers/encodeId.ts';
-import { type Context, type RawEpisode } from '../types.ts';
+import { TRANSLATIONS, VIDEOS } from '../constants.ts';
+import { type Context } from '../types.ts';
 import { resolveEpisodeVideos } from './episodeVideos.ts';
 
 const mockedFetch = mockFetch(jest.fn);
 
-const episodeDetailsWithLookupId: RawEpisode = {
-  ...episodeDetails,
-  episode_lookup_id: encodeId({
-    episodeNumber: episodeDetails.episode_number,
-    seasonNumber: episodeDetails.season_number,
-    tvId: episodeDetails.tv_show_id,
-  }),
-};
-
 describe('resolveEpisodeVideos >', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
   const tvShowId = 1399;
   const seasonNumber = 1;
   const episodeNumber = 1;
 
-  beforeAll(() => {
-    restClient = createRestClient();
-  });
+  const context = {
+    logger: createMockLogger(jest.fn),
+    restClient: createRestClient(),
+    setCacheMetadata: jest.fn(),
+    tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+  } as unknown as Context;
+
+  const info = { fieldName: TRANSLATIONS } as GraphQLResolveInfo;
 
   beforeEach(() => {
-    mockedFetch.mockGetOnce(
-      buildEndpoint(EPISODE_PATH, { episodeNumber, id: tvShowId, seasonNumber, type: 'videos' }),
-      {
-        body: episodeVideos,
-      }
-    );
+    mockedFetch.mockGetOnce(buildEndpoint(EPISODE_PATH, { episodeNumber, id: tvShowId, seasonNumber, type: VIDEOS }), {
+      body: episodeVideos,
+    });
   });
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   it('should return the episode videos', async () => {
-    await expect(
-      resolveEpisodeVideos(
-        episodeDetailsWithLookupId,
-        undefined,
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
-      )
-    ).resolves.toMatchSnapshot();
+    // @ts-expect-error arg is slightly modified version of episode details
+    await expect(resolveEpisodeVideos(episodeDetails, undefined, context, info)).resolves.toMatchSnapshot();
   });
 
   describe('when raw episode data has videos', () => {
@@ -69,14 +56,14 @@ describe('resolveEpisodeVideos >', () => {
 
       await expect(
         resolveEpisodeVideos(
-          { ...episodeDetailsWithLookupId, __headers: new Headers(), videos: rest },
+          // @ts-expect-error arg is slightly modified version of episode details
+          { ...episodeDetails, __headers: new Headers(), videos: rest },
           undefined,
           {
+            ...context,
             restClient: { episode: episodeFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-            setCacheMetadata,
-            tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-          } as unknown as Context,
-          {} as GraphQLResolveInfo
+          },
+          info
         )
       ).resolves.toMatchSnapshot();
     });
@@ -89,14 +76,14 @@ describe('resolveEpisodeVideos >', () => {
       const { id, ...rest } = episodeVideos;
 
       await resolveEpisodeVideos(
-        { ...episodeDetailsWithLookupId, __headers: new Headers(), videos: rest },
+        // @ts-expect-error arg is slightly modified version of episode details
+        { ...episodeDetails, __headers: new Headers(), videos: rest },
         undefined,
         {
+          ...context,
           restClient: { episode: episodeFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-          setCacheMetadata,
-          tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-        } as unknown as Context,
-        {} as GraphQLResolveInfo
+        },
+        info
       );
 
       expect(episodeFetchMock).not.toHaveBeenCalled();

package/src/queries/episodeVideos.ts

@@ -1,16 +1,27 @@
-import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
-import { EPISODE, SEASON, TV, VIDEOS } from '../constants.ts';
-import { type Context, type RawEpisodeVideos, type RawEpisodeWithAppendToResponse } from '../types.ts';
+import { EPISODE, VIDEOS } from '../constants.ts';
+import { buildObjResolver } from '../helpers/buildObjResolver.ts';
+import {
+  type EnrichedRawEpisode,
+  type EnrichedRawEpisodeWithAppendToResponse,
+  type RawEpisodeVideos,
+} 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 isEnrichedRawEpisodeWithVideos = (
+  obj: EnrichedRawEpisode | (EnrichedRawEpisodeWithAppendToResponse & { __headers?: Headers })
+): obj is EnrichedRawEpisodeWithAppendToResponse & { __headers: Headers } => VIDEOS in obj && '__headers' in obj;
+
+export const resolveEpisodeVideos = buildObjResolver<
+  EnrichedRawEpisode | (EnrichedRawEpisodeWithAppendToResponse & { __headers?: Headers }),
+  RawEpisodeVideos['results']
+>(EPISODE, async (obj, ctx) => {
+  const { requestID, restClient, tmdbGuestSessionId } = ctx;
+
+  if (isEnrichedRawEpisodeWithVideos(obj)) {
+    return {
+      data: obj.videos?.results,
+      headers: obj.__headers,
+      source: 'parentNode',
+    };
   }
 
   const { data, errors, headers } = await restClient.episode<RawEpisodeVideos>(
@@ -25,13 +36,9 @@ export const resolveEpisodeVideos = async (
     { requestID, tmdbGuestSessionId }
   );
 
-  if (errors?.length) {
-    throw new GraphQLError(
-      `Failed to resolve ${TV} show ${obj.tv_show_id} ${SEASON} ${obj.season_number} ${EPISODE} ${obj.episode_number} ${VIDEOS}.`,
-      { nodes: fieldNodes, originalError: errors[0] }
-    );
-  }
-
-  setCacheMetadata(`${EPISODE}.${VIDEOS}`, headers);
-  return data?.results;
-};
+  return {
+    data: data?.results,
+    errors,
+    headers,
+  };
+});

package/src/queries/find.test.ts

@@ -1,11 +1,11 @@
 import { jest } from '@jest/globals';
-import { FIND_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import { FIND_PATH } from '@tmdb-graphql-api/rest-client';
 import { type ExternalSource } from '@tmdb-graphql-api/schema/types';
 import findResults from '@tmdb-graphql-api/test-utils/responses/themoviedb/find/results.json';
 import { mockFetch } from 'fetch-mocked';
-import { type Getta, type ShortcutProperties } from 'getta';
 import { type GraphQLResolveInfo } from 'graphql';
 import { buildEndpoint } from '../__testUtils__/helpers/buildEndpoint.ts';
+import { createMockLogger } from '../__testUtils__/helpers/createMockLogger.ts';
 import { createRestClient } from '../__testUtils__/helpers/createRestClient.ts';
 import { snakeCasePropNames } from '../helpers/snakeCasePropNames.ts';
 import { type Context } from '../types.ts';
@@ -14,14 +14,17 @@ import { resolveFind } from './find.ts';
 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();
-  });
+  const context = {
+    logger: createMockLogger(jest.fn),
+    restClient: createRestClient(),
+    setCacheMetadata: jest.fn(),
+    tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+  } as unknown as Context;
+
+  const info = {} as GraphQLResolveInfo;
 
   beforeEach(() => {
     mockedFetch.mockGetOnce(buildEndpoint(FIND_PATH, { id }, snakeCasePropNames({ externalSource: source })), {
@@ -31,17 +34,11 @@ describe('resolveFind >', () => {
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   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();
+    await expect(resolveFind(undefined, { id, source }, context, info)).resolves.toMatchSnapshot();
   });
 });

package/src/queries/find.ts

@@ -1,34 +1,37 @@
 import { type QueryFindArgs } from '@tmdb-graphql-api/schema/types';
-import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
 import { FIND } from '../constants.ts';
+import { buildArgsResolver } from '../helpers/buildArgsResolver.ts';
 import { snakeCasePropNames } from '../helpers/snakeCasePropNames.ts';
-import { type Context, type RawFind } from '../types.ts';
+import { type RawEpisode, type RawFind, type RawMovie, type RawPerson, type RawSeason, type RawTv } from '../types.ts';
+
+type Data = {
+  episodes?: RawEpisode[];
+  movies?: RawMovie[];
+  people?: RawPerson[];
+  seasons?: RawSeason[];
+  tv?: RawTv[];
+};
+
+export const resolveFind = buildArgsResolver<QueryFindArgs, Data>(FIND, async (args, ctx) => {
+  const { requestID, restClient, tmdbGuestSessionId } = ctx;
 
-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 }) },
+      pathTemplateData: { id: args.id },
+      queryParams: { ...snakeCasePropNames({ externalSource: args.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,
+    data: {
+      episodes: data?.tv_episode_results,
+      movies: data?.movie_results,
+      people: data?.person_results,
+      seasons: data?.tv_season_results,
+      tv: data?.tv_results,
+    },
+    errors,
+    headers,
   };
-};
+});