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

package/src/queries/genres.test.ts

@@ -1,12 +1,12 @@
 import { jest } from '@jest/globals';
-import { GENRE_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import { GENRE_PATH } from '@tmdb-graphql-api/rest-client';
 import { ScreenType } from '@tmdb-graphql-api/schema/types';
 import movieGenres from '@tmdb-graphql-api/test-utils/responses/themoviedb/genres/movies.json';
 import tvGenres from '@tmdb-graphql-api/test-utils/responses/themoviedb/genres/tv.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 { type Context } from '../types.ts';
 import { resolveGenres } from './genres.ts';
@@ -14,16 +14,19 @@ import { resolveGenres } from './genres.ts';
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolveGenres >', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
+  const context = {
+    logger: createMockLogger(jest.fn),
+    restClient: createRestClient(),
+    setCacheMetadata: jest.fn(),
+    tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+  } as unknown as Context;
 
-  beforeAll(() => {
-    restClient = createRestClient();
-  });
+  const info = {} as GraphQLResolveInfo;
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   describe("when the screenType is 'MOVIE' >", () => {
@@ -35,12 +38,7 @@ describe('resolveGenres >', () => {
 
     it('should return the movie genres', async () => {
       await expect(
-        resolveGenres(
-          undefined,
-          { screenType: ScreenType.Movie },
-          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-          {} as GraphQLResolveInfo
-        )
+        resolveGenres(undefined, { screenType: ScreenType.Movie }, context, info)
       ).resolves.toMatchSnapshot();
     });
   });
@@ -53,14 +51,7 @@ describe('resolveGenres >', () => {
     });
 
     it('should return the tv genres', async () => {
-      await expect(
-        resolveGenres(
-          undefined,
-          { screenType: ScreenType.Tv },
-          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-          {} as GraphQLResolveInfo
-        )
-      ).resolves.toMatchSnapshot();
+      await expect(resolveGenres(undefined, { screenType: ScreenType.Tv }, context, info)).resolves.toMatchSnapshot();
     });
   });
 });

package/src/queries/genres.ts

@@ -1,28 +1,22 @@
 import { type QueryGenresArgs } from '@tmdb-graphql-api/schema/types';
-import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
 import { GENRES } from '../constants.ts';
-import { type Context, type RawGenre } from '../types.ts';
+import { buildArgsResolver } from '../helpers/buildArgsResolver.ts';
+import { type RawGenres } from '../types.ts';
 
-export const resolveGenres = async (
-  _obj: undefined,
-  { screenType }: QueryGenresArgs,
-  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
-  { fieldNodes }: GraphQLResolveInfo
-) => {
-  const { data, errors, headers } = await restClient.genres<{ genres?: RawGenre[] }>(
+export const resolveGenres = buildArgsResolver<QueryGenresArgs, RawGenres['genres']>(GENRES, async (args, ctx) => {
+  const { screenType } = args;
+  const { requestID, restClient, tmdbGuestSessionId } = ctx;
+
+  const { data, errors, headers } = await restClient.genres<RawGenres>(
     {
       pathTemplateData: { type: screenType.toLowerCase() },
     },
     { requestID, tmdbGuestSessionId }
   );
 
-  if (errors?.length) {
-    throw new GraphQLError(`Failed to resolve ${screenType} ${GENRES}.`, {
-      nodes: fieldNodes,
-      originalError: errors[0],
-    });
-  }
-
-  setCacheMetadata(GENRES, headers);
-  return data?.genres;
-};
+  return {
+    data: data?.genres,
+    errors,
+    headers,
+  };
+});

package/src/queries/keyword.test.ts

@@ -1,10 +1,10 @@
 import { jest } from '@jest/globals';
-import { KEYWORD_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import { KEYWORD_PATH } from '@tmdb-graphql-api/rest-client';
 import keywordDetails from '@tmdb-graphql-api/test-utils/responses/themoviedb/keyword/details.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 { type Context } from '../types.ts';
 import { resolveKeyword } from './keyword.ts';
@@ -12,13 +12,16 @@ import { resolveKeyword } from './keyword.ts';
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolveKeyword >', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
   const id = 2;
 
-  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(KEYWORD_PATH, { id }), {
@@ -28,17 +31,11 @@ describe('resolveKeyword >', () => {
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   it('should return the correct keyword details', async () => {
-    await expect(
-      resolveKeyword(
-        undefined,
-        { id },
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
-      )
-    ).resolves.toMatchSnapshot();
+    await expect(resolveKeyword(undefined, { id: String(id) }, context, info)).resolves.toMatchSnapshot();
   });
 });

package/src/queries/keyword.ts

@@ -1,15 +1,13 @@
 import { type QueryKeywordArgs } from '@tmdb-graphql-api/schema/types';
-import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
 import { KEYWORD } from '../constants.ts';
+import { buildArgsResolver } from '../helpers/buildArgsResolver.ts';
 import { snakeCasePropNames } from '../helpers/snakeCasePropNames.ts';
-import { type Context, type RawKeyword } from '../types.ts';
+import { type RawKeyword } from '../types.ts';
+
+export const resolveKeyword = buildArgsResolver<QueryKeywordArgs, RawKeyword>(KEYWORD, async (args, ctx) => {
+  const { id, includeAdult } = args;
+  const { requestID, restClient, tmdbGuestSessionId } = ctx;
 
-export const resolveKeyword = async (
-  _obj: undefined,
-  { id, includeAdult }: QueryKeywordArgs,
-  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
-  { fieldNodes }: GraphQLResolveInfo
-) => {
   const { data, errors, headers } = await restClient.keyword<RawKeyword>(
     {
       pathTemplateData: { id },
@@ -18,10 +16,9 @@ export const resolveKeyword = async (
     { requestID, tmdbGuestSessionId }
   );
 
-  if (errors?.length) {
-    throw new GraphQLError(`Failed to resolve ${KEYWORD} ${id}.`, { nodes: fieldNodes, originalError: errors[0] });
-  }
-
-  setCacheMetadata(KEYWORD, headers);
-  return data;
-};
+  return {
+    data,
+    errors,
+    headers,
+  };
+});

package/src/queries/movie.test.ts

@@ -9,6 +9,7 @@ import { mockFetch } from 'fetch-mocked';
 import { type FetchResponse, type Getta, type ShortcutProperties } from 'getta';
 import { type GraphQLResolveInfo, OperationTypeNode, parse } from 'graphql';
 import { buildEndpoint } from '../__testUtils__/helpers/buildEndpoint.ts';
+import { createMockLogger } from '../__testUtils__/helpers/createMockLogger.ts';
 import { createRestClient } from '../__testUtils__/helpers/createRestClient.ts';
 import { MOVIE } from '../constants.ts';
 import { type Context } from '../types.ts';
@@ -17,13 +18,14 @@ import { resolveMovie } from './movie.ts';
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolveMovie >', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
   const id = 1891;
 
-  beforeAll(() => {
-    restClient = createRestClient();
-  });
+  const context = {
+    logger: createMockLogger(jest.fn),
+    restClient: createRestClient(),
+    setCacheMetadata: jest.fn(),
+    tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+  } as unknown as Context;
 
   beforeEach(() => {
     mockedFetch.mockGetOnce(buildEndpoint(MOVIE_PATH, { id }), {
@@ -33,26 +35,21 @@ describe('resolveMovie >', () => {
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   it('should return the correct movie details', async () => {
     const operationDefinition = getOperationDefinitions(parse(movieDetailsQuery()), OperationTypeNode.QUERY)[0]!;
     const { fieldNode } = getChildFields(operationDefinition, { name: MOVIE })![0]!;
-
-    await expect(
-      resolveMovie(
-        undefined,
-        { id },
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        { fieldNodes: [fieldNode] } as unknown as GraphQLResolveInfo
-      )
-    ).resolves.toMatchSnapshot();
+    const info = { fieldNodes: [fieldNode] } as unknown as GraphQLResolveInfo;
+    await expect(resolveMovie(undefined, { id: String(id) }, context, info)).resolves.toMatchSnapshot();
   });
 
   it('should request the correct resources when append to response fields are found', async () => {
     const operationDefinition = getOperationDefinitions(parse(movieDetailsLgQuery()), OperationTypeNode.QUERY)[0]!;
     const { fieldNode } = getChildFields(operationDefinition, { name: MOVIE })![0]!;
+    const info = { fieldNodes: [fieldNode] } as unknown as GraphQLResolveInfo;
 
     const movieFetchMock = jest
       .fn<(...args: PlainArray) => Promise<FetchResponse>>()
@@ -60,13 +57,12 @@ describe('resolveMovie >', () => {
 
     await resolveMovie(
       undefined,
-      { id },
+      { id: String(id) },
       {
+        ...context,
         restClient: { movie: movieFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-        setCacheMetadata,
-        tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-      } as unknown as Context,
-      { fieldNodes: [fieldNode] } as unknown as GraphQLResolveInfo
+      },
+      info
     );
 
     expect(movieFetchMock.mock.calls[0]![0]).toEqual(

package/src/queries/movie.ts

@@ -1,5 +1,4 @@
 import { type QueryMovieArgs } from '@tmdb-graphql-api/schema/types';
-import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
 import { isUndefined, snakeCase } from 'lodash-es';
 import {
   ALTERNATIVE_TITLES,
@@ -22,8 +21,9 @@ import {
   VIDEOS,
   WATCH_PROVIDERS,
 } from '../constants.ts';
+import { buildObjArgsResolver } from '../helpers/buildObjArgsResolver.ts';
 import { getAppendToResponseKeys } from '../helpers/getAppendToResponseKeys.ts';
-import { type Context, type RawMovie, type RawMovieWithAppendToResponse } from '../types.ts';
+import { type RawMovie, type RawMovieWithAppendToResponse } from '../types.ts';
 
 const appendToResponse = {
   [ALTERNATIVE_TITLES]: snakeCase(ALTERNATIVE_TITLES),
@@ -43,16 +43,21 @@ const appendToResponse = {
   [WATCH_PROVIDERS]: 'watch/providers',
 };
 
-export const resolveMovie = async (
-  obj: RawMovie | undefined,
-  args: QueryMovieArgs,
-  { fragmentDefinitions, requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
-  { fieldName, fieldNodes }: GraphQLResolveInfo
-) => {
+export const resolveMovie = buildObjArgsResolver<
+  RawMovie,
+  QueryMovieArgs,
+  | (RawMovieWithAppendToResponse & { __headers?: Headers })
+  | RawMovieWithAppendToResponse[keyof RawMovieWithAppendToResponse]
+>(MOVIE, async (obj, args, ctx, info) => {
+  const { fragmentDefinitions, requestID, restClient, tmdbGuestSessionId } = ctx;
+  const { fieldName, fieldNodes } = info;
   const typedFieldName = snakeCase(fieldName) as keyof RawMovie;
 
   if (obj && !isUndefined(obj[typedFieldName])) {
-    return obj[typedFieldName];
+    return {
+      data: obj[typedFieldName],
+      source: 'parentNode',
+    };
   }
 
   const id = obj ? obj.id : args.id;
@@ -72,15 +77,9 @@ export const resolveMovie = async (
     { requestID, tmdbGuestSessionId }
   );
 
-  if (errors?.length) {
-    throw new GraphQLError(`Failed to resolve ${MOVIE} ${id}.`, { nodes: fieldNodes, originalError: errors[0] });
-  }
-
-  if (obj) {
-    setCacheMetadata(`${MOVIE}.${fieldName}`, headers);
-    return data![typedFieldName];
-  }
-
-  setCacheMetadata(MOVIE, headers);
-  return appendToResponseKeys.length > 0 ? { ...data, __headers: headers } : data;
-};
+  return {
+    data: obj ? data?.[typedFieldName] : appendToResponseKeys.length > 0 ? { ...data, __headers: headers } : data,
+    errors,
+    headers,
+  };
+});

package/src/queries/movieAlternativeTitles.test.ts

@@ -6,42 +6,42 @@ import movieDetails from '@tmdb-graphql-api/test-utils/responses/themoviedb/movi
 import { mockFetch } from 'fetch-mocked';
 import { type FetchResponse, type Getta, type ShortcutProperties } from 'getta';
 import { type GraphQLResolveInfo } from 'graphql';
+import { snakeCase } from 'lodash-es';
 import { buildEndpoint } from '../__testUtils__/helpers/buildEndpoint.ts';
+import { createMockLogger } from '../__testUtils__/helpers/createMockLogger.ts';
 import { createRestClient } from '../__testUtils__/helpers/createRestClient.ts';
-import { type Context, type RawMovieWithAppendToResponse } from '../types.ts';
+import { ALTERNATIVE_TITLES } from '../constants.ts';
+import { type Context } from '../types.ts';
 import { resolveMovieAlternativeTitles } from './movieAlternativeTitles.ts';
 
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolveMovieAlternativeTitles >', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
   const movieId = 1891;
 
-  beforeAll(() => {
-    restClient = createRestClient();
-  });
+  const context = {
+    logger: createMockLogger(jest.fn),
+    restClient: createRestClient(),
+    setCacheMetadata: jest.fn(),
+    tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+  } as unknown as Context;
+
+  const info = { fieldName: ALTERNATIVE_TITLES } as GraphQLResolveInfo;
 
   beforeEach(() => {
-    mockedFetch.mockGetOnce(buildEndpoint(MOVIE_PATH, { id: movieId, type: 'alternative_titles' }), {
+    mockedFetch.mockGetOnce(buildEndpoint(MOVIE_PATH, { id: movieId, type: snakeCase(ALTERNATIVE_TITLES) }), {
       body: movieAlternativeTitles,
     });
   });
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   it('should return the movie alternative titles', async () => {
-    await expect(
-      resolveMovieAlternativeTitles(
-        movieDetails as RawMovieWithAppendToResponse,
-        {},
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
-      )
-    ).resolves.toMatchSnapshot();
+    await expect(resolveMovieAlternativeTitles(movieDetails, {}, context, info)).resolves.toMatchSnapshot();
   });
 
   describe('when raw movie data has alternativeTitles', () => {
@@ -54,16 +54,13 @@ describe('resolveMovieAlternativeTitles >', () => {
 
       await expect(
         resolveMovieAlternativeTitles(
-          { ...movieDetails, __headers: new Headers(), alternative_titles: rest } as RawMovieWithAppendToResponse & {
-            __headers?: Headers;
-          },
+          { ...movieDetails, __headers: new Headers(), alternative_titles: rest },
           {},
           {
+            ...context,
             restClient: { movie: movieFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-            setCacheMetadata,
-            tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-          } as unknown as Context,
-          {} as GraphQLResolveInfo
+          },
+          info
         )
       ).resolves.toMatchSnapshot();
     });
@@ -76,16 +73,13 @@ describe('resolveMovieAlternativeTitles >', () => {
       const { id, ...rest } = movieAlternativeTitles;
 
       await resolveMovieAlternativeTitles(
-        { ...movieDetails, __headers: new Headers(), alternative_titles: rest } as RawMovieWithAppendToResponse & {
-          __headers?: Headers;
-        },
+        { ...movieDetails, __headers: new Headers(), alternative_titles: rest },
         {},
         {
+          ...context,
           restClient: { movie: movieFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-          setCacheMetadata,
-          tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-        } as unknown as Context,
-        {} as GraphQLResolveInfo
+        },
+        info
       );
 
       expect(movieFetchMock).not.toHaveBeenCalled();

package/src/queries/movieAlternativeTitles.ts

@@ -1,19 +1,35 @@
 import { type MovieAlternativeTitlesArgs } from '@tmdb-graphql-api/schema/types';
-import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
+import { GraphQLError } from 'graphql';
 import { snakeCase } from 'lodash-es';
 import { ALTERNATIVE_TITLES, MOVIE } from '../constants.ts';
-import { type Context, type RawMovieAlternativeTitles, type RawMovieWithAppendToResponse } from '../types.ts';
+import { buildObjArgsResolver } from '../helpers/buildObjArgsResolver.ts';
+import { type RawMovie, type RawMovieAlternativeTitles, type RawMovieWithAppendToResponse } from '../types.ts';
 
-export const resolveMovieAlternativeTitles = async (
-  obj: RawMovieWithAppendToResponse & { __headers?: Headers },
-  { country }: MovieAlternativeTitlesArgs,
-  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
-  { fieldNodes }: GraphQLResolveInfo
-) => {
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-  if (obj.alternative_titles && obj.__headers) {
-    setCacheMetadata(`${MOVIE}.${ALTERNATIVE_TITLES}`, obj.__headers);
-    return obj.alternative_titles.titles;
+const isRawMovieWithAlternativeTitles = (
+  obj: RawMovie | (RawMovieWithAppendToResponse & { __headers?: Headers })
+): obj is RawMovieWithAppendToResponse & { __headers: Headers } =>
+  snakeCase(ALTERNATIVE_TITLES) in obj && '__headers' in obj;
+
+export const resolveMovieAlternativeTitles = buildObjArgsResolver<
+  RawMovie | (RawMovieWithAppendToResponse & { __headers?: Headers }),
+  MovieAlternativeTitlesArgs,
+  RawMovieAlternativeTitles['titles']
+>(MOVIE, async (obj, args, ctx, info) => {
+  const { country } = args;
+  const { logger, requestID, restClient, tmdbGuestSessionId } = ctx;
+  const { fieldNodes } = info;
+
+  if (!obj) {
+    const message = `Required ${ALTERNATIVE_TITLES} node missing`;
+    logger.error(message);
+    throw new GraphQLError(message, { nodes: fieldNodes });
+  }
+
+  if (isRawMovieWithAlternativeTitles(obj)) {
+    return {
+      data: obj.alternative_titles?.titles,
+      source: 'parentNode',
+    };
   }
 
   const { data, errors, headers } = await restClient.movie<RawMovieAlternativeTitles>(
@@ -24,13 +40,9 @@ export const resolveMovieAlternativeTitles = async (
     { requestID, tmdbGuestSessionId }
   );
 
-  if (errors?.length) {
-    throw new GraphQLError(`Failed to resolve ${MOVIE} ${obj.id} ${ALTERNATIVE_TITLES}.`, {
-      nodes: fieldNodes,
-      originalError: errors[0],
-    });
-  }
-
-  setCacheMetadata(`${MOVIE}.${ALTERNATIVE_TITLES}`, headers);
-  return data!.titles;
-};
+  return {
+    data: data?.titles,
+    errors,
+    headers,
+  };
+});

package/src/queries/movieCredits.test.ts

@@ -7,59 +7,47 @@ 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 { type Context, type RawMovieWithAppendToResponse } from '../types.ts';
+import { CAST, CREDITS, CREW } from '../constants.ts';
+import { type Context } from '../types.ts';
 import { resolveMovieCredits } from './movieCredits.ts';
 
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolveMovieCredits >', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
   const movieId = 1891;
 
-  beforeAll(() => {
-    restClient = createRestClient();
-  });
+  const context = {
+    logger: createMockLogger(jest.fn),
+    restClient: createRestClient(),
+    setCacheMetadata: jest.fn(),
+    tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+  } as unknown as Context;
 
   beforeEach(() => {
-    mockedFetch.mockGetOnce(buildEndpoint(MOVIE_PATH, { id: movieId, type: 'credits' }), {
+    mockedFetch.mockGetOnce(buildEndpoint(MOVIE_PATH, { id: movieId, type: CREDITS }), {
       body: movieCredits,
     });
   });
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   describe('when fieldName is cast', () => {
     it('should return the correct response', async () => {
-      await expect(
-        resolveMovieCredits(
-          movieDetails as unknown as RawMovieWithAppendToResponse,
-          undefined,
-          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-          {
-            fieldName: 'cast',
-          } as GraphQLResolveInfo
-        )
-      ).resolves.toMatchSnapshot();
+      const info = { fieldName: CAST } as GraphQLResolveInfo;
+      await expect(resolveMovieCredits(movieDetails, undefined, context, info)).resolves.toMatchSnapshot();
     });
   });
 
   describe('when fieldName is crew', () => {
     it('should return the correct response', async () => {
-      await expect(
-        resolveMovieCredits(
-          movieDetails as RawMovieWithAppendToResponse,
-          undefined,
-          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-          {
-            fieldName: 'crew',
-          } as GraphQLResolveInfo
-        )
-      ).resolves.toMatchSnapshot();
+      const info = { fieldName: CREW } as GraphQLResolveInfo;
+      await expect(resolveMovieCredits(movieDetails, undefined, context, info)).resolves.toMatchSnapshot();
     });
   });
 
@@ -70,21 +58,18 @@ describe('resolveMovieCredits >', () => {
         .mockResolvedValue({ data: {} } as FetchResponse);
 
       const { id, ...rest } = movieCredits;
+      const info = { fieldName: CREW } as GraphQLResolveInfo;
 
       await expect(
         resolveMovieCredits(
-          { ...movieDetails, __headers: new Headers(), credits: rest } as RawMovieWithAppendToResponse & {
-            __headers?: Headers;
-          },
+          // @ts-expect-error arg is slightly modified version of movie details
+          { ...movieDetails, __headers: new Headers(), credits: rest },
           undefined,
           {
+            ...context,
             restClient: { movie: movieFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-            setCacheMetadata,
-            tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-          } as unknown as Context,
-          {
-            fieldName: 'crew',
-          } as GraphQLResolveInfo
+          },
+          info
         )
       ).resolves.toMatchSnapshot();
     });
@@ -95,20 +80,17 @@ describe('resolveMovieCredits >', () => {
         .mockResolvedValue({ data: {} } as FetchResponse);
 
       const { id, ...rest } = movieCredits;
+      const info = { fieldName: CREW } as GraphQLResolveInfo;
 
       await resolveMovieCredits(
-        { ...movieDetails, __headers: new Headers(), credits: rest } as RawMovieWithAppendToResponse & {
-          __headers?: Headers;
-        },
+        // @ts-expect-error arg is slightly modified version of movie details
+        { ...movieDetails, __headers: new Headers(), credits: rest },
         undefined,
         {
+          ...context,
           restClient: { movie: movieFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-          setCacheMetadata,
-          tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
         } as unknown as Context,
-        {
-          fieldName: 'crew',
-        } as GraphQLResolveInfo
+        info
       );
 
       expect(movieFetchMock).not.toHaveBeenCalled();