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

package/src/queries/movieTranslations.test.ts

@@ -7,20 +7,25 @@ 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 { TRANSLATIONS } from '../constants.ts';
 import { type Context, type RawMovieWithAppendToResponse } from '../types.ts';
 import { resolveMovieTranslations } from './movieTranslations.ts';
 
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolveMovieTranslations >', () => {
-  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: TRANSLATIONS } as GraphQLResolveInfo;
 
   beforeEach(() => {
     mockedFetch.mockGetOnce(buildEndpoint(MOVIE_PATH, { id: movieId, type: 'translations' }), {
@@ -30,17 +35,13 @@ describe('resolveMovieTranslations >', () => {
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   it('should return the movie translations', async () => {
     await expect(
-      resolveMovieTranslations(
-        movieDetails as RawMovieWithAppendToResponse,
-        undefined,
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
-      )
+      resolveMovieTranslations(movieDetails as RawMovieWithAppendToResponse, undefined, context, info)
     ).resolves.toMatchSnapshot();
   });
 
@@ -58,16 +59,13 @@ describe('resolveMovieTranslations >', () => {
             ...movieDetails,
             __headers: new Headers(),
             translations: rest,
-          } as unknown as RawMovieWithAppendToResponse & {
-            __headers?: Headers;
           },
           undefined,
           {
+            ...context,
             restClient: { movie: movieFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-            setCacheMetadata,
-            tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-          } as unknown as Context,
-          {} as GraphQLResolveInfo
+          },
+          info
         )
       ).resolves.toMatchSnapshot();
     });
@@ -80,16 +78,13 @@ describe('resolveMovieTranslations >', () => {
       const { id, ...rest } = movieTranslations;
 
       await resolveMovieTranslations(
-        { ...movieDetails, __headers: new Headers(), translations: rest } as unknown as RawMovieWithAppendToResponse & {
-          __headers?: Headers;
-        },
+        { ...movieDetails, __headers: new Headers(), translations: rest },
         undefined,
         {
+          ...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/movieTranslations.ts

@@ -1,16 +1,23 @@
-import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
 import { MOVIE, TRANSLATIONS } from '../constants.ts';
-import { type Context, type RawMovieTranslations, type RawMovieWithAppendToResponse } from '../types.ts';
+import { buildObjResolver } from '../helpers/buildObjResolver.ts';
+import { type RawMovie, type RawMovieTranslations, type RawMovieWithAppendToResponse } from '../types.ts';
 
-export const resolveMovieTranslations = async (
-  obj: RawMovieWithAppendToResponse & { __headers?: Headers },
-  _args: undefined,
-  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
-  { fieldNodes }: GraphQLResolveInfo
-) => {
-  if (obj.translations && obj.__headers) {
-    setCacheMetadata(`${MOVIE}.${TRANSLATIONS}`, obj.__headers);
-    return obj.translations.translations;
+const isRawMovieWithTranslations = (
+  obj: RawMovie | (RawMovieWithAppendToResponse & { __headers?: Headers })
+): obj is RawMovieWithAppendToResponse & { __headers: Headers } => TRANSLATIONS in obj && '__headers' in obj;
+
+export const resolveMovieTranslations = buildObjResolver<
+  RawMovie | (RawMovieWithAppendToResponse & { __headers?: Headers }),
+  RawMovieTranslations['translations']
+>(MOVIE, async (obj, ctx) => {
+  const { requestID, restClient, tmdbGuestSessionId } = ctx;
+
+  if (isRawMovieWithTranslations(obj)) {
+    return {
+      data: obj.translations?.translations,
+      headers: obj.__headers,
+      source: 'parentNode',
+    };
   }
 
   const { data, errors, headers } = await restClient.movie<RawMovieTranslations>(
@@ -20,13 +27,9 @@ export const resolveMovieTranslations = async (
     { requestID, tmdbGuestSessionId }
   );
 
-  if (errors?.length) {
-    throw new GraphQLError(`Failed to resolve ${MOVIE} ${obj.id} ${TRANSLATIONS}.`, {
-      nodes: fieldNodes,
-      originalError: errors[0],
-    });
-  }
-
-  setCacheMetadata(`${MOVIE}.${TRANSLATIONS}`, headers);
-  return data?.translations;
-};
+  return {
+    data: data?.translations,
+    errors,
+    headers,
+  };
+});

package/src/queries/movieVideos.test.ts

@@ -7,20 +7,25 @@ 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 { VIDEOS } from '../constants.ts';
+import { type Context } from '../types.ts';
 import { resolveMovieVideos } from './movieVideos.ts';
 
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolveMovieVideos >', () => {
-  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: VIDEOS } as GraphQLResolveInfo;
 
   beforeEach(() => {
     mockedFetch.mockGetOnce(buildEndpoint(MOVIE_PATH, { id: movieId, type: 'videos' }), {
@@ -30,18 +35,12 @@ describe('resolveMovieVideos >', () => {
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   it('should return the movie videos', async () => {
-    await expect(
-      resolveMovieVideos(
-        movieDetails as RawMovieWithAppendToResponse,
-        undefined,
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
-      )
-    ).resolves.toMatchSnapshot();
+    await expect(resolveMovieVideos(movieDetails, undefined, context, info)).resolves.toMatchSnapshot();
   });
 
   describe('when raw movie data has videos', () => {
@@ -54,16 +53,13 @@ describe('resolveMovieVideos >', () => {
 
       await expect(
         resolveMovieVideos(
-          { ...movieDetails, __headers: new Headers(), videos: rest } as unknown as RawMovieWithAppendToResponse & {
-            __headers?: Headers;
-          },
+          { ...movieDetails, __headers: new Headers(), videos: rest },
           undefined,
           {
+            ...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 +72,13 @@ describe('resolveMovieVideos >', () => {
       const { id, ...rest } = movieVideos;
 
       await resolveMovieVideos(
-        { ...movieDetails, __headers: new Headers(), videos: rest } as unknown as RawMovieWithAppendToResponse & {
-          __headers?: Headers;
-        },
+        { ...movieDetails, __headers: new Headers(), videos: rest },
         undefined,
         {
+          ...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/movieVideos.ts

@@ -1,16 +1,23 @@
-import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
 import { MOVIE, VIDEOS } from '../constants.ts';
-import { type Context, type RawMovieVideos, type RawMovieWithAppendToResponse } from '../types.ts';
+import { buildObjResolver } from '../helpers/buildObjResolver.ts';
+import { type RawMovie, type RawMovieVideos, type RawMovieWithAppendToResponse } from '../types.ts';
 
-export const resolveMovieVideos = async (
-  obj: RawMovieWithAppendToResponse & { __headers?: Headers },
-  _args: undefined,
-  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
-  { fieldNodes }: GraphQLResolveInfo
-) => {
-  if (obj.videos && obj.__headers) {
-    setCacheMetadata(`${MOVIE}.${VIDEOS}`, obj.__headers);
-    return obj.videos.results;
+const isRawMovieWithVideos = (
+  obj: RawMovie | (RawMovieWithAppendToResponse & { __headers?: Headers })
+): obj is RawMovieWithAppendToResponse & { __headers: Headers } => VIDEOS in obj && '__headers' in obj;
+
+export const resolveMovieVideos = buildObjResolver<
+  RawMovie | (RawMovieWithAppendToResponse & { __headers?: Headers }),
+  RawMovieVideos['results']
+>(MOVIE, async (obj, ctx) => {
+  const { requestID, restClient, tmdbGuestSessionId } = ctx;
+
+  if (isRawMovieWithVideos(obj)) {
+    return {
+      data: obj.videos?.results,
+      headers: obj.__headers,
+      source: 'parentNode',
+    };
   }
 
   const { data, errors, headers } = await restClient.movie<RawMovieVideos>(
@@ -20,13 +27,9 @@ export const resolveMovieVideos = async (
     { requestID, tmdbGuestSessionId }
   );
 
-  if (errors?.length) {
-    throw new GraphQLError(`Failed to resolve ${MOVIE} ${obj.id} ${VIDEOS}.`, {
-      nodes: fieldNodes,
-      originalError: errors[0],
-    });
-  }
-
-  setCacheMetadata(`${MOVIE}.${VIDEOS}`, headers);
-  return data?.results;
-};
+  return {
+    data: data?.results,
+    errors,
+    headers,
+  };
+});

package/src/queries/movieWatchProviders.test.ts

@@ -7,20 +7,25 @@ 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 { WATCH_PROVIDERS } from '../constants.ts';
+import { type Context } from '../types.ts';
 import { resolveMovieWatchProviders } from './movieWatchProviders.ts';
 
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolveMovieWatchProviders >', () => {
-  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: WATCH_PROVIDERS } as GraphQLResolveInfo;
 
   beforeEach(() => {
     mockedFetch.mockGetOnce(buildEndpoint(WATCH_PROVIDER_PATH, { id: movieId, type: 'movie' }), {
@@ -30,18 +35,11 @@ describe('resolveMovieWatchProviders >', () => {
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
   });
 
   it('should return the movie watch providers', async () => {
-    await expect(
-      resolveMovieWatchProviders(
-        movieDetails as RawMovieWithAppendToResponse,
-        undefined,
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
-      )
-    ).resolves.toMatchSnapshot();
+    await expect(resolveMovieWatchProviders(movieDetails, undefined, context, info)).resolves.toMatchSnapshot();
   });
 
   describe('when raw movie data has watch providers', () => {
@@ -58,16 +56,13 @@ describe('resolveMovieWatchProviders >', () => {
             ...movieDetails,
             __headers: new Headers(),
             'watch/providers': rest,
-          } as unknown as RawMovieWithAppendToResponse & {
-            __headers?: Headers;
           },
           undefined,
           {
+            ...context,
             restClient: { movie: movieFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-            setCacheMetadata,
-            tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-          } as unknown as Context,
-          {} as GraphQLResolveInfo
+          },
+          info
         )
       ).resolves.toMatchSnapshot();
     });
@@ -84,16 +79,13 @@ describe('resolveMovieWatchProviders >', () => {
           ...movieDetails,
           __headers: new Headers(),
           'watch/providers': rest,
-        } as unknown as RawMovieWithAppendToResponse & {
-          __headers?: Headers;
         },
         undefined,
         {
+          ...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/movieWatchProviders.ts

@@ -1,32 +1,35 @@
-import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
-import { MOVIE, WATCH_PROVIDERS } from '../constants.ts';
-import { type Context, type RawMovieWithAppendToResponse, type RawWatchProviders } from '../types.ts';
+import { MOVIE, RAW_WATCH_PROVIDERS } from '../constants.ts';
+import { buildObjResolver } from '../helpers/buildObjResolver.ts';
+import { type RawMovie, type RawMovieWatchProviders, type RawMovieWithAppendToResponse } from '../types.ts';
 
-export const resolveMovieWatchProviders = async (
-  obj: RawMovieWithAppendToResponse & { __headers?: Headers },
-  _args: undefined,
-  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
-  { fieldNodes }: GraphQLResolveInfo
-) => {
-  if (obj['watch/providers'] && obj.__headers) {
-    setCacheMetadata(`${MOVIE}.${WATCH_PROVIDERS}`, obj.__headers);
-    return obj['watch/providers'].results;
+const isRawMovieWithWatchProviders = (
+  obj: RawMovie | (RawMovieWithAppendToResponse & { __headers?: Headers })
+): obj is RawMovieWithAppendToResponse & { __headers: Headers } => RAW_WATCH_PROVIDERS in obj && '__headers' in obj;
+
+export const resolveMovieWatchProviders = buildObjResolver<
+  RawMovie | (RawMovieWithAppendToResponse & { __headers?: Headers }),
+  RawMovieWatchProviders['results']
+>(MOVIE, async (obj, ctx) => {
+  const { requestID, restClient, tmdbGuestSessionId } = ctx;
+
+  if (isRawMovieWithWatchProviders(obj)) {
+    return {
+      data: obj['watch/providers']?.results,
+      headers: obj.__headers,
+      source: 'parentNode',
+    };
   }
 
-  const { data, errors, headers } = await restClient.watchProviders<RawWatchProviders>(
+  const { data, errors, headers } = await restClient.watchProviders<RawMovieWatchProviders>(
     {
       pathTemplateData: { id: obj.id, type: MOVIE },
     },
     { requestID, tmdbGuestSessionId }
   );
 
-  if (errors?.length) {
-    throw new GraphQLError(`Failed to resolve ${MOVIE} ${obj.id} ${WATCH_PROVIDERS}.`, {
-      nodes: fieldNodes,
-      originalError: errors[0],
-    });
-  }
-
-  setCacheMetadata(`${MOVIE}.${WATCH_PROVIDERS}`, headers);
-  return data?.results;
-};
+  return {
+    data: data?.results,
+    errors,
+    headers,
+  };
+});

package/src/queries/network.test.ts

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

package/src/queries/network.ts

@@ -1,23 +1,26 @@
 import { type QueryNetworkArgs } from '@tmdb-graphql-api/schema/types';
-import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
 import { isUndefined, snakeCase } from 'lodash-es';
 import { NETWORK } from '../constants.ts';
-import { type Context, type RawNetwork } from '../types.ts';
+import { buildObjArgsResolver } from '../helpers/buildObjArgsResolver.ts';
+import { type RawNetwork } from '../types.ts';
 
-export const resolveNetwork = async (
-  obj: RawNetwork | undefined,
-  args: QueryNetworkArgs,
-  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
-  { fieldName, fieldNodes }: GraphQLResolveInfo
-) => {
+export const resolveNetwork = buildObjArgsResolver<
+  RawNetwork,
+  QueryNetworkArgs,
+  RawNetwork | RawNetwork[keyof RawNetwork]
+>(NETWORK, async (obj, args, ctx, info) => {
+  const id = obj ? obj.id : args.id;
+  const { requestID, restClient, tmdbGuestSessionId } = ctx;
+  const { fieldName } = info;
   const typedFieldName = snakeCase(fieldName) as keyof RawNetwork;
 
   if (obj && !isUndefined(obj[typedFieldName])) {
-    return obj[typedFieldName];
+    return {
+      data: obj[typedFieldName],
+      source: 'parentNode',
+    };
   }
 
-  const id = obj ? obj.id : args.id;
-
   const { data, errors, headers } = await restClient.network<RawNetwork>(
     {
       pathTemplateData: { id },
@@ -25,15 +28,9 @@ export const resolveNetwork = async (
     { requestID, tmdbGuestSessionId }
   );
 
-  if (errors?.length) {
-    throw new GraphQLError(`Failed to resolve ${NETWORK} ${id}.`, { nodes: fieldNodes, originalError: errors[0] });
-  }
-
-  if (obj) {
-    setCacheMetadata(`${NETWORK}.${fieldName}`, headers);
-    return data![typedFieldName];
-  }
-
-  setCacheMetadata(NETWORK, headers);
-  return data;
-};
+  return {
+    data: obj ? data?.[typedFieldName] : data,
+    errors,
+    headers,
+  };
+});

package/src/queries/networkAlternativeNames.test.ts

@@ -1,44 +1,42 @@
 import { jest } from '@jest/globals';
-import { NETWORK_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import { NETWORK_PATH } from '@tmdb-graphql-api/rest-client';
 import networkAlterativeNames from '@tmdb-graphql-api/test-utils/responses/themoviedb/network/alternativeNames.json';
 import networkDetails from '@tmdb-graphql-api/test-utils/responses/themoviedb/network/details.json';
 import { mockFetch } from 'fetch-mocked';
-import { 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 RawNetwork } from '../types.ts';
+import { ALTERNATIVE_NAMES } from '../constants.ts';
+import { type Context } from '../types.ts';
 import { resolveNetworkAlternativeNames } from './networkAlternativeNames.ts';
 
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolveNetworkAlternativeNames >', () => {
-  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 = { fieldName: ALTERNATIVE_NAMES } as GraphQLResolveInfo;
 
   beforeEach(() => {
-    mockedFetch.mockGetOnce(buildEndpoint(NETWORK_PATH, { id: 213, type: 'alternative_names' }), {
+    mockedFetch.mockGetOnce(buildEndpoint(NETWORK_PATH, { id: 213, type: snakeCase(ALTERNATIVE_NAMES) }), {
       body: networkAlterativeNames,
     });
   });
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   it('should return the network alternative names', async () => {
-    await expect(
-      resolveNetworkAlternativeNames(
-        networkDetails as unknown as RawNetwork,
-        undefined,
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
-      )
-    ).resolves.toMatchSnapshot();
+    await expect(resolveNetworkAlternativeNames(networkDetails, undefined, context, info)).resolves.toMatchSnapshot();
   });
 });