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

package/src/queries/seasonCredits.test.ts

@@ -7,20 +7,22 @@ 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 RawSeason, type RawSeasonWithAppendToResponse } from '../types.ts';
+import { type Context } from '../types.ts';
 import { resolveSeasonCredits } from './seasonCredits.ts';
 
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolveSeasonCredits >', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
   const seasonId = 1399;
 
-  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(SEASON_PATH, { id: seasonId, number: 1, type: 'credits' }), {
@@ -30,40 +32,37 @@ describe('resolveSeasonCredits >', () => {
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   describe('when fieldName is cast', () => {
+    const info = {
+      fieldName: 'cast',
+    } as GraphQLResolveInfo;
+
     it('should return the correct response', async () => {
-      await expect(
-        resolveSeasonCredits(
-          seasonDetails as unknown as RawSeason,
-          undefined,
-          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-          {
-            fieldName: 'cast',
-          } as GraphQLResolveInfo
-        )
-      ).resolves.toMatchSnapshot();
+      // @ts-expect-error minor nested type mismatch
+      await expect(resolveSeasonCredits(seasonDetails, undefined, context, info)).resolves.toMatchSnapshot();
     });
   });
 
   describe('when fieldName is crew', () => {
+    const info = {
+      fieldName: 'crew',
+    } as GraphQLResolveInfo;
+
     it('should return the correct response', async () => {
-      await expect(
-        resolveSeasonCredits(
-          seasonDetails as unknown as RawSeason,
-          undefined,
-          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-          {
-            fieldName: 'crew',
-          } as GraphQLResolveInfo
-        )
-      ).resolves.toMatchSnapshot();
+      // @ts-expect-error minor nested type mismatch
+      await expect(resolveSeasonCredits(seasonDetails, undefined, context, info)).resolves.toMatchSnapshot();
     });
   });
 
   describe('when raw season data has credits', () => {
+    const info = {
+      fieldName: 'crew',
+    } as GraphQLResolveInfo;
+
     it('should return the correct response', async () => {
       const seasonFetchMock = jest
         .fn<(...args: PlainArray) => Promise<FetchResponse>>()
@@ -73,18 +72,14 @@ describe('resolveSeasonCredits >', () => {
 
       await expect(
         resolveSeasonCredits(
-          { ...seasonDetails, __headers: new Headers(), credits: rest } as unknown as RawSeasonWithAppendToResponse & {
-            __headers?: Headers;
-          },
+          // @ts-expect-error minor nested type mismatch
+          { ...seasonDetails, __headers: new Headers(), credits: rest },
           undefined,
           {
+            ...context,
             restClient: { season: seasonFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-            setCacheMetadata,
-            tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-          } as unknown as Context,
-          {
-            fieldName: 'crew',
-          } as GraphQLResolveInfo
+          },
+          info
         )
       ).resolves.toMatchSnapshot();
     });
@@ -97,18 +92,14 @@ describe('resolveSeasonCredits >', () => {
       const { id, ...rest } = seasonCredits;
 
       await resolveSeasonCredits(
-        { ...seasonDetails, __headers: new Headers(), credits: rest } as unknown as RawSeasonWithAppendToResponse & {
-          __headers?: Headers;
-        },
+        // @ts-expect-error minor nested type mismatch
+        { ...seasonDetails, __headers: new Headers(), credits: rest },
         undefined,
         {
+          ...context,
           restClient: { season: seasonFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-          setCacheMetadata,
-          tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-        } as unknown as Context,
-        {
-          fieldName: 'crew',
-        } as GraphQLResolveInfo
+        },
+        info
       );
 
       expect(seasonFetchMock).not.toHaveBeenCalled();

package/src/queries/seasonCredits.ts

@@ -1,18 +1,26 @@
-import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
-import { CREDITS, SEASON, TV } from '../constants.ts';
-import { type Context, type RawSeasonCredits, type RawSeasonWithAppendToResponse } from '../types.ts';
+import { snakeCase } from 'lodash-es';
+import { CREDITS, SEASON } from '../constants.ts';
+import { buildObjResolver } from '../helpers/buildObjResolver.ts';
+import { type EnrichedRawSeason, type EnrichedRawSeasonWithAppendToResponse, type RawSeasonCredits } from '../types.ts';
 
-export const resolveSeasonCredits = async (
-  obj: RawSeasonWithAppendToResponse & { __headers?: Headers },
-  _args: undefined,
-  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
-  { fieldName, fieldNodes }: GraphQLResolveInfo
-) => {
-  const typedFieldName = fieldName as 'cast' | 'crew';
+const isEnrichedRawSeasonWithCredits = (
+  obj: EnrichedRawSeason | (EnrichedRawSeasonWithAppendToResponse & { __headers?: Headers })
+): obj is EnrichedRawSeasonWithAppendToResponse & { __headers: Headers } => CREDITS in obj && '__headers' in obj;
 
-  if (obj.credits && obj.__headers) {
-    setCacheMetadata(`${SEASON}.${fieldName}`, obj.__headers);
-    return obj.credits[typedFieldName];
+export const resolveSeasonCredits = buildObjResolver<
+  EnrichedRawSeason | (EnrichedRawSeasonWithAppendToResponse & { __headers?: Headers }),
+  RawSeasonCredits['cast'] | RawSeasonCredits['crew']
+>(SEASON, async (obj, ctx, info) => {
+  const { requestID, restClient, tmdbGuestSessionId } = ctx;
+  const { fieldName } = info;
+  const typedFieldName = snakeCase(fieldName) as 'cast' | 'crew';
+
+  if (isEnrichedRawSeasonWithCredits(obj)) {
+    return {
+      data: obj.credits?.[typedFieldName],
+      headers: obj.__headers,
+      source: 'parentNode',
+    };
   }
 
   const { data, errors, headers } = await restClient.season<RawSeasonCredits>(
@@ -22,13 +30,9 @@ export const resolveSeasonCredits = async (
     { requestID, tmdbGuestSessionId }
   );
 
-  if (errors?.length) {
-    throw new GraphQLError(
-      `Failed to resolve ${TV} show ${obj.tv_show_id} ${SEASON} ${obj.season_number} ${fieldName}.`,
-      { nodes: fieldNodes, originalError: errors[0] }
-    );
-  }
-
-  setCacheMetadata(`${SEASON}.${fieldName}`, headers);
-  return data![typedFieldName];
-};
+  return {
+    data: data?.[typedFieldName],
+    errors,
+    headers,
+  };
+});

package/src/queries/seasonEpisodeCount.ts

@@ -1,9 +1,5 @@
 import { type RawSeason } from '../types.ts';
 
 export const resolveSeasonEpisodeCount = (obj: RawSeason) => {
-  if (obj.episode_count) {
-    return obj.episode_count;
-  }
-
   return obj.episodes?.length ?? 0;
 };

package/src/queries/seasonExternalIds.test.ts

@@ -6,42 +6,43 @@ import seasonExternalIds from '@tmdb-graphql-api/test-utils/responses/themoviedb
 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 RawSeason, type RawSeasonWithAppendToResponse } from '../types.ts';
+import { EXTERNAL_IDS } from '../constants.ts';
+import { type Context } from '../types.ts';
 import { resolveSeasonExternalIds } from './seasonExternalIds.ts';
 
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolveSeasonExternalIds >', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
   const seasonId = 1399;
 
-  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(SEASON_PATH, { id: seasonId, number: 1, type: 'external_ids' }), {
+    mockedFetch.mockGetOnce(buildEndpoint(SEASON_PATH, { id: seasonId, number: 1, type: snakeCase(EXTERNAL_IDS) }), {
       body: seasonExternalIds,
     });
   });
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   it('should return the season external IDs', async () => {
-    await expect(
-      resolveSeasonExternalIds(
-        seasonDetails as unknown as RawSeason,
-        undefined,
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
-      )
-    ).resolves.toMatchSnapshot();
+    // @ts-expect-error minor type mismatch
+    await expect(resolveSeasonExternalIds(seasonDetails, undefined, context, info)).resolves.toMatchSnapshot();
   });
 
   describe('when raw season data has external IDs', () => {
@@ -54,20 +55,18 @@ describe('resolveSeasonExternalIds >', () => {
 
       await expect(
         resolveSeasonExternalIds(
+          // @ts-expect-error minor type mismatch
           {
             ...seasonDetails,
             __headers: new Headers(),
             external_ids: rest,
-          } as unknown as RawSeasonWithAppendToResponse & {
-            __headers?: Headers;
           },
           undefined,
           {
+            ...context,
             restClient: { season: seasonFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-            setCacheMetadata,
-            tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-          } as unknown as Context,
-          {} as GraphQLResolveInfo
+          },
+          info
         )
       ).resolves.toMatchSnapshot();
     });
@@ -80,20 +79,18 @@ describe('resolveSeasonExternalIds >', () => {
       const { id, ...rest } = seasonExternalIds;
 
       await resolveSeasonExternalIds(
+        // @ts-expect-error minor type mismatch
         {
           ...seasonDetails,
           __headers: new Headers(),
           external_ids: rest,
-        } as unknown as RawSeasonWithAppendToResponse & {
-          __headers?: Headers;
         },
         undefined,
         {
+          ...context,
           restClient: { season: seasonFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-          setCacheMetadata,
-          tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-        } as unknown as Context,
-        {} as GraphQLResolveInfo
+        },
+        info
       );
 
       expect(seasonFetchMock).not.toHaveBeenCalled();

package/src/queries/seasonExternalIds.ts

@@ -1,17 +1,30 @@
-import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
 import { snakeCase } from 'lodash-es';
-import { EXTERNAL_IDS, SEASON, TV } from '../constants.ts';
-import { type Context, type RawSeasonExternalIds, type RawSeasonWithAppendToResponse } from '../types.ts';
+import type { Except } from 'type-fest';
+import { EXTERNAL_IDS, SEASON } from '../constants.ts';
+import { buildObjResolver } from '../helpers/buildObjResolver.ts';
+import {
+  type EnrichedRawSeason,
+  type EnrichedRawSeasonWithAppendToResponse,
+  type RawSeasonExternalIds,
+} from '../types.ts';
 
-export const resolveSeasonExternalIds = async (
-  obj: RawSeasonWithAppendToResponse & { __headers?: Headers },
-  _args: undefined,
-  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
-  { fieldNodes }: GraphQLResolveInfo
-) => {
-  if (obj.external_ids && obj.__headers) {
-    setCacheMetadata(`${SEASON}.${EXTERNAL_IDS}`, obj.__headers);
-    return obj.external_ids;
+const isEnrichedRawSeasonWithExternalIds = (
+  obj: EnrichedRawSeason | (EnrichedRawSeasonWithAppendToResponse & { __headers?: Headers })
+): obj is EnrichedRawSeasonWithAppendToResponse & { __headers: Headers } =>
+  snakeCase(EXTERNAL_IDS) in obj && '__headers' in obj;
+
+export const resolveSeasonExternalIds = buildObjResolver<
+  EnrichedRawSeason | (EnrichedRawSeasonWithAppendToResponse & { __headers?: Headers }),
+  Except<RawSeasonExternalIds, 'id'>
+>(SEASON, async (obj, ctx) => {
+  const { requestID, restClient, tmdbGuestSessionId } = ctx;
+
+  if (isEnrichedRawSeasonWithExternalIds(obj)) {
+    return {
+      data: obj.external_ids,
+      headers: obj.__headers,
+      source: 'parentNode',
+    };
   }
 
   const { data, errors, headers } = await restClient.season<RawSeasonExternalIds>(
@@ -21,14 +34,11 @@ export const resolveSeasonExternalIds = async (
     { requestID, tmdbGuestSessionId }
   );
 
-  if (errors?.length) {
-    throw new GraphQLError(
-      `Failed to resolve ${TV} show ${obj.tv_show_id} ${SEASON} ${obj.season_number} ${EXTERNAL_IDS}.`,
-      { nodes: fieldNodes, originalError: errors[0] }
-    );
-  }
+  const { id: movieId, ...rest } = data ?? {};
 
-  setCacheMetadata(`${SEASON}.${EXTERNAL_IDS}`, headers);
-  const { id: movieId, ...rest } = data!;
-  return rest;
-};
+  return {
+    data: rest,
+    errors,
+    headers,
+  };
+});

package/src/queries/seasonPosters.test.ts

@@ -7,40 +7,39 @@ 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 RawSeason, type RawSeasonWithAppendToResponse } from '../types.ts';
+import { IMAGES } from '../constants.ts';
+import { type Context } from '../types.ts';
 import { resolveSeasonPosters } from './seasonPosters.ts';
 
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolveSeasonPosters >', () => {
-  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;
 
   beforeEach(() => {
-    mockedFetch.mockGetOnce(buildEndpoint(SEASON_PATH, { id: 1399, number: 1, type: 'images' }), {
+    mockedFetch.mockGetOnce(buildEndpoint(SEASON_PATH, { id: 1399, number: 1, type: IMAGES }), {
       body: seasonPosters,
     });
   });
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   it('should return the season posters', async () => {
-    await expect(
-      resolveSeasonPosters(
-        seasonDetails as unknown as RawSeason,
-        undefined,
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
-      )
-    ).resolves.toMatchSnapshot();
+    // @ts-expect-error minor nested type mismatch
+    await expect(resolveSeasonPosters(seasonDetails, undefined, context, info)).resolves.toMatchSnapshot();
   });
 
   describe('when raw season data has images', () => {
@@ -53,16 +52,14 @@ describe('resolveSeasonPosters >', () => {
 
       await expect(
         resolveSeasonPosters(
-          { ...seasonDetails, __headers: new Headers(), images: rest } as unknown as RawSeasonWithAppendToResponse & {
-            __headers?: Headers;
-          },
+          // @ts-expect-error minor nested type mismatch
+          { ...seasonDetails, __headers: new Headers(), images: rest },
           undefined,
           {
+            ...context,
             restClient: { season: seasonFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-            setCacheMetadata,
-            tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-          } as unknown as Context,
-          {} as GraphQLResolveInfo
+          },
+          info
         )
       ).resolves.toMatchSnapshot();
     });
@@ -75,16 +72,14 @@ describe('resolveSeasonPosters >', () => {
       const { id, ...rest } = seasonPosters;
 
       await resolveSeasonPosters(
-        { ...seasonDetails, __headers: new Headers(), images: rest } as unknown as RawSeasonWithAppendToResponse & {
-          __headers?: Headers;
-        },
+        // @ts-expect-error minor nested type mismatch
+        { ...seasonDetails, __headers: new Headers(), images: rest },
         undefined,
         {
+          ...context,
           restClient: { season: seasonFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-          setCacheMetadata,
-          tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-        } as unknown as Context,
-        {} as GraphQLResolveInfo
+        },
+        info
       );
 
       expect(seasonFetchMock).not.toHaveBeenCalled();

package/src/queries/seasonPosters.ts

@@ -1,16 +1,23 @@
-import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
-import { IMAGES, POSTERS, SEASON, TV } from '../constants.ts';
-import { type Context, type RawSeasonPosters, type RawSeasonWithAppendToResponse } from '../types.ts';
+import { IMAGES, SEASON } from '../constants.ts';
+import { buildObjResolver } from '../helpers/buildObjResolver.ts';
+import { type EnrichedRawSeason, type EnrichedRawSeasonWithAppendToResponse, type RawSeasonPosters } from '../types.ts';
 
-export const resolveSeasonPosters = async (
-  obj: RawSeasonWithAppendToResponse & { __headers?: Headers },
-  _args: undefined,
-  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
-  { fieldNodes }: GraphQLResolveInfo
-) => {
-  if (obj.images && obj.__headers) {
-    setCacheMetadata(`${SEASON}.${POSTERS}`, obj.__headers);
-    return obj.images.posters;
+const isEnrichedRawSeasonWithPosters = (
+  obj: EnrichedRawSeason | (EnrichedRawSeasonWithAppendToResponse & { __headers?: Headers })
+): obj is EnrichedRawSeasonWithAppendToResponse & { __headers: Headers } => IMAGES in obj && '__headers' in obj;
+
+export const resolveSeasonPosters = buildObjResolver<
+  EnrichedRawSeason | (EnrichedRawSeasonWithAppendToResponse & { __headers?: Headers }),
+  RawSeasonPosters['posters']
+>(SEASON, async (obj, ctx) => {
+  const { requestID, restClient, tmdbGuestSessionId } = ctx;
+
+  if (isEnrichedRawSeasonWithPosters(obj)) {
+    return {
+      data: obj.images?.posters,
+      headers: obj.__headers,
+      source: 'parentNode',
+    };
   }
 
   const { data, errors, headers } = await restClient.season<RawSeasonPosters>(
@@ -20,13 +27,9 @@ export const resolveSeasonPosters = async (
     { requestID, tmdbGuestSessionId }
   );
 
-  if (errors?.length) {
-    throw new GraphQLError(
-      `Failed to resolve ${TV} show ${obj.tv_show_id} ${SEASON} ${obj.season_number} ${POSTERS}.`,
-      { nodes: fieldNodes, originalError: errors[0] }
-    );
-  }
-
-  setCacheMetadata(`${SEASON}.${POSTERS}`, headers);
-  return data!.posters;
-};
+  return {
+    data: data?.posters,
+    errors,
+    headers,
+  };
+});

package/src/queries/seasonTranslations.test.ts

@@ -7,19 +7,22 @@ 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 RawSeason, type RawSeasonWithAppendToResponse } from '../types.ts';
+import { type Context } from '../types.ts';
 import { resolveSeasonTranslations } from './seasonTranslations.ts';
 
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolveSeasonTranslations >', () => {
-  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;
 
   beforeEach(() => {
     mockedFetch.mockGetOnce(buildEndpoint(SEASON_PATH, { id: 1399, number: 1, type: 'translations' }), {
@@ -29,18 +32,13 @@ describe('resolveSeasonTranslations >', () => {
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   it('should return the season translations', async () => {
-    await expect(
-      resolveSeasonTranslations(
-        seasonDetails as unknown as RawSeason,
-        undefined,
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
-      )
-    ).resolves.toMatchSnapshot();
+    // @ts-expect-error minor nested type mismatch
+    await expect(resolveSeasonTranslations(seasonDetails, undefined, context, info)).resolves.toMatchSnapshot();
   });
 
   describe('when raw season data has translations', () => {
@@ -53,20 +51,18 @@ describe('resolveSeasonTranslations >', () => {
 
       await expect(
         resolveSeasonTranslations(
+          // @ts-expect-error minor nested type mismatch
           {
             ...seasonDetails,
             __headers: new Headers(),
             translations: rest,
-          } as unknown as RawSeasonWithAppendToResponse & {
-            __headers?: Headers;
           },
           undefined,
           {
+            ...context,
             restClient: { season: seasonFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-            setCacheMetadata,
-            tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-          } as unknown as Context,
-          {} as GraphQLResolveInfo
+          },
+          info
         )
       ).resolves.toMatchSnapshot();
     });
@@ -79,20 +75,18 @@ describe('resolveSeasonTranslations >', () => {
       const { id, ...rest } = seasonTranslations;
 
       await resolveSeasonTranslations(
+        // @ts-expect-error minor nested type mismatch
         {
           ...seasonDetails,
           __headers: new Headers(),
           translations: rest,
-        } as unknown as RawSeasonWithAppendToResponse & {
-          __headers?: Headers;
         },
         undefined,
         {
+          ...context,
           restClient: { season: seasonFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-          setCacheMetadata,
-          tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-        } as unknown as Context,
-        {} as GraphQLResolveInfo
+        },
+        info
       );
 
       expect(seasonFetchMock).not.toHaveBeenCalled();