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

package/src/queries/tvAlternativeTitles.test.ts

@@ -6,42 +6,43 @@ import tvDetails from '@tmdb-graphql-api/test-utils/responses/themoviedb/tv/1399
 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 RawTvWithAppendToResponse } from '../types.ts';
+import { ALTERNATIVE_TITLES } from '../constants.ts';
+import { type Context } from '../types.ts';
 import { resolveTvAlternativeTitles } from './tvAlternativeTitles.ts';
 
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolveTvAlternativeTitles >', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
   const tvId = 1399;
 
-  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(TV_PATH, { id: tvId, type: 'alternative_titles' }), {
+    mockedFetch.mockGetOnce(buildEndpoint(TV_PATH, { id: tvId, type: snakeCase(ALTERNATIVE_TITLES) }), {
       body: tvAlternativeTitles,
     });
   });
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   it('should return the tv alternative titles', async () => {
-    await expect(
-      resolveTvAlternativeTitles(
-        tvDetails as unknown as RawTvWithAppendToResponse,
-        undefined,
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
-      )
-    ).resolves.toMatchSnapshot();
+    // @ts-expect-error minor nested type mismatch
+    await expect(resolveTvAlternativeTitles(tvDetails, undefined, context, info)).resolves.toMatchSnapshot();
   });
 
   describe('when raw tv data has alternativeTitles', () => {
@@ -54,20 +55,18 @@ describe('resolveTvAlternativeTitles >', () => {
 
       await expect(
         resolveTvAlternativeTitles(
+          // @ts-expect-error minor nested type mismatch
           {
             ...tvDetails,
             __headers: new Headers(),
             alternative_titles: rest,
-          } as unknown as RawTvWithAppendToResponse & {
-            __headers?: Headers;
           },
           undefined,
           {
+            ...context,
             restClient: { tv: tvFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-            setCacheMetadata,
-            tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-          } as unknown as Context,
-          {} as GraphQLResolveInfo
+          },
+          info
         )
       ).resolves.toMatchSnapshot();
     });
@@ -80,20 +79,18 @@ describe('resolveTvAlternativeTitles >', () => {
       const { id, ...rest } = tvAlternativeTitles;
 
       await resolveTvAlternativeTitles(
+        // @ts-expect-error minor nested type mismatch
         {
           ...tvDetails,
           __headers: new Headers(),
           alternative_titles: rest,
-        } as unknown as RawTvWithAppendToResponse & {
-          __headers?: Headers;
         },
         undefined,
         {
+          ...context,
           restClient: { tv: tvFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-          setCacheMetadata,
-          tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-        } as unknown as Context,
-        {} as GraphQLResolveInfo
+        },
+        info
       );
 
       expect(tvFetchMock).not.toHaveBeenCalled();

package/src/queries/tvAlternativeTitles.ts

@@ -1,18 +1,25 @@
-import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
 import { snakeCase } from 'lodash-es';
 import { ALTERNATIVE_TITLES, TV } from '../constants.ts';
-import { type Context, type RawTvAlternativeTitles, type RawTvWithAppendToResponse } from '../types.ts';
+import { buildObjResolver } from '../helpers/buildObjResolver.ts';
+import { type RawTv, type RawTvAlternativeTitles, type RawTvWithAppendToResponse } from '../types.ts';
 
-export const resolveTvAlternativeTitles = async (
-  obj: RawTvWithAppendToResponse & { __headers?: Headers },
-  _args: undefined,
-  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
-  { fieldNodes }: GraphQLResolveInfo
-) => {
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-  if (obj.alternative_titles && obj.__headers) {
-    setCacheMetadata(`${TV}.${ALTERNATIVE_TITLES}`, obj.__headers);
-    return obj.alternative_titles.results;
+const isRawTvWithAlternativeTitles = (
+  obj: RawTv | (RawTvWithAppendToResponse & { __headers?: Headers })
+): obj is RawTvWithAppendToResponse & { __headers: Headers } =>
+  snakeCase(ALTERNATIVE_TITLES) in obj && '__headers' in obj;
+
+export const resolveTvAlternativeTitles = buildObjResolver<
+  RawTv | (RawTvWithAppendToResponse & { __headers?: Headers }),
+  RawTvAlternativeTitles['results']
+>(TV, async (obj, ctx) => {
+  const { requestID, restClient, tmdbGuestSessionId } = ctx;
+
+  if (isRawTvWithAlternativeTitles(obj)) {
+    return {
+      data: obj.alternative_titles.results,
+      headers: obj.__headers,
+      source: 'parentNode',
+    };
   }
 
   const { data, errors, headers } = await restClient.tv<RawTvAlternativeTitles>(
@@ -22,13 +29,9 @@ export const resolveTvAlternativeTitles = async (
     { requestID, tmdbGuestSessionId }
   );
 
-  if (errors?.length) {
-    throw new GraphQLError(`Failed to resolve ${TV} ${obj.id} ${ALTERNATIVE_TITLES}.`, {
-      nodes: fieldNodes,
-      originalError: errors[0],
-    });
-  }
-
-  setCacheMetadata(`${TV}.${ALTERNATIVE_TITLES}`, headers);
-  return data!.results;
-};
+  return {
+    data: data?.results,
+    errors,
+    headers,
+  };
+});

package/src/queries/tvContentRatings.test.ts

@@ -6,42 +6,43 @@ import tvDetails from '@tmdb-graphql-api/test-utils/responses/themoviedb/tv/1399
 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 RawTvWithAppendToResponse } from '../types.ts';
+import { CONTENT_RATINGS } from '../constants.ts';
+import { type Context } from '../types.ts';
 import { resolveTvContentRatings } from './tvContentRatings.ts';
 
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolveTvContentRatings >', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
   const tvId = 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(TV_PATH, { id: tvId, type: 'content_ratings' }), {
+    mockedFetch.mockGetOnce(buildEndpoint(TV_PATH, { id: tvId, type: snakeCase(CONTENT_RATINGS) }), {
       body: tvContentRatings,
     });
   });
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   it('should return the tv content ratings', async () => {
-    await expect(
-      resolveTvContentRatings(
-        tvDetails as unknown as RawTvWithAppendToResponse,
-        undefined,
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
-      )
-    ).resolves.toMatchSnapshot();
+    // @ts-expect-error minor nested type mismatch
+    await expect(resolveTvContentRatings(tvDetails, undefined, context, info)).resolves.toMatchSnapshot();
   });
 
   describe('when raw tv data has content ratings', () => {
@@ -54,20 +55,18 @@ describe('resolveTvContentRatings >', () => {
 
       await expect(
         resolveTvContentRatings(
+          // @ts-expect-error minor nested type mismatch
           {
             ...tvDetails,
             __headers: new Headers(),
             content_ratings: rest,
-          } as unknown as RawTvWithAppendToResponse & {
-            __headers?: Headers;
           },
           undefined,
           {
+            ...context,
             restClient: { tv: tvFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-            setCacheMetadata,
-            tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-          } as unknown as Context,
-          {} as GraphQLResolveInfo
+          },
+          info
         )
       ).resolves.toMatchSnapshot();
     });
@@ -80,20 +79,18 @@ describe('resolveTvContentRatings >', () => {
       const { id, ...rest } = tvContentRatings;
 
       await resolveTvContentRatings(
+        // @ts-expect-error minor nested type mismatch
         {
           ...tvDetails,
           __headers: new Headers(),
           content_ratings: rest,
-        } as unknown as RawTvWithAppendToResponse & {
-          __headers?: Headers;
         },
         undefined,
         {
+          ...context,
           restClient: { tv: tvFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-          setCacheMetadata,
-          tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-        } as unknown as Context,
-        {} as GraphQLResolveInfo
+        },
+        info
       );
 
       expect(tvFetchMock).not.toHaveBeenCalled();

package/src/queries/tvContentRatings.ts

@@ -1,18 +1,24 @@
-import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
 import { snakeCase } from 'lodash-es';
 import { CONTENT_RATINGS, TV } from '../constants.ts';
-import { type Context, type RawTvContentRatings, type RawTvWithAppendToResponse } from '../types.ts';
+import { buildObjResolver } from '../helpers/buildObjResolver.ts';
+import { type RawTv, type RawTvContentRatings, type RawTvWithAppendToResponse } from '../types.ts';
 
-export const resolveTvContentRatings = async (
-  obj: RawTvWithAppendToResponse & { __headers?: Headers },
-  _args: undefined,
-  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
-  { fieldNodes }: GraphQLResolveInfo
-) => {
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-  if (obj.content_ratings && obj.__headers) {
-    setCacheMetadata(`${TV}.${CONTENT_RATINGS}`, obj.__headers);
-    return obj.content_ratings.results;
+const isRawTvWithContentRatings = (
+  obj: RawTv | (RawTvWithAppendToResponse & { __headers?: Headers })
+): obj is RawTvWithAppendToResponse & { __headers: Headers } => snakeCase(CONTENT_RATINGS) in obj && '__headers' in obj;
+
+export const resolveTvContentRatings = buildObjResolver<
+  RawTv | (RawTvWithAppendToResponse & { __headers?: Headers }),
+  RawTvContentRatings['results']
+>(TV, async (obj, ctx) => {
+  const { requestID, restClient, tmdbGuestSessionId } = ctx;
+
+  if (isRawTvWithContentRatings(obj)) {
+    return {
+      data: obj.content_ratings.results,
+      headers: obj.__headers,
+      source: 'parentNode',
+    };
   }
 
   const { data, errors, headers } = await restClient.tv<RawTvContentRatings>(
@@ -22,13 +28,9 @@ export const resolveTvContentRatings = async (
     { requestID, tmdbGuestSessionId }
   );
 
-  if (errors?.length) {
-    throw new GraphQLError(`Failed to resolve ${TV} ${obj.id} ${CONTENT_RATINGS}.`, {
-      nodes: fieldNodes,
-      originalError: errors[0],
-    });
-  }
-
-  setCacheMetadata(`${TV}.${CONTENT_RATINGS}`, headers);
-  return data!.results;
-};
+  return {
+    data: data?.results,
+    errors,
+    headers,
+  };
+});

package/src/queries/tvCredits.test.ts

@@ -7,63 +7,65 @@ 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 RawTvWithAppendToResponse } from '../types.ts';
+import { CAST, CREDITS, CREW } from '../constants.ts';
+import { type Context } from '../types.ts';
 import { resolveTvCredits } from './tvCredits.ts';
 
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolveTvCredits >', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
   const tvId = 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(TV_PATH, { id: tvId, type: 'credits' }), {
+    mockedFetch.mockGetOnce(buildEndpoint(TV_PATH, { id: tvId, type: CREDITS }), {
       body: tvCredits,
     });
   });
 
   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 () => {
+      const info = {
+        fieldName: CAST,
+      } as GraphQLResolveInfo;
+
       await expect(
-        resolveTvCredits(
-          tvDetails as unknown as RawTvWithAppendToResponse,
-          undefined,
-          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-          {
-            fieldName: 'cast',
-          } as GraphQLResolveInfo
-        )
+        // @ts-expect-error minor nested type mismatch
+        resolveTvCredits(tvDetails, undefined, context, info)
       ).resolves.toMatchSnapshot();
     });
   });
 
   describe('when fieldName is crew', () => {
     it('should return the correct response', async () => {
-      await expect(
-        resolveTvCredits(
-          tvDetails as unknown as RawTvWithAppendToResponse,
-          undefined,
-          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-          {
-            fieldName: 'crew',
-          } as GraphQLResolveInfo
-        )
-      ).resolves.toMatchSnapshot();
+      const info = {
+        fieldName: CREW,
+      } as GraphQLResolveInfo;
+
+      // @ts-expect-error minor nested type mismatch
+      await expect(resolveTvCredits(tvDetails, undefined, context, info)).resolves.toMatchSnapshot();
     });
   });
 
   describe('when raw tv data has credits', () => {
+    const info = {
+      fieldName: CREW,
+    } as GraphQLResolveInfo;
+
     it('should return the correct response', async () => {
       const tvFetchMock = jest
         .fn<(...args: PlainArray) => Promise<FetchResponse>>()
@@ -73,18 +75,14 @@ describe('resolveTvCredits >', () => {
 
       await expect(
         resolveTvCredits(
-          { ...tvDetails, __headers: new Headers(), credits: rest } as unknown as RawTvWithAppendToResponse & {
-            __headers?: Headers;
-          },
+          // @ts-expect-error minor nested type mismatch
+          { ...tvDetails, __headers: new Headers(), credits: rest },
           undefined,
           {
+            ...context,
             restClient: { tv: tvFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-            setCacheMetadata,
-            tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-          } as unknown as Context,
-          {
-            fieldName: 'crew',
-          } as GraphQLResolveInfo
+          },
+          info
         )
       ).resolves.toMatchSnapshot();
     });
@@ -97,18 +95,14 @@ describe('resolveTvCredits >', () => {
       const { id, ...rest } = tvCredits;
 
       await resolveTvCredits(
-        { ...tvDetails, __headers: new Headers(), credits: rest } as unknown as RawTvWithAppendToResponse & {
-          __headers?: Headers;
-        },
+        // @ts-expect-error minor nested type mismatch
+        { ...tvDetails, __headers: new Headers(), credits: rest },
         undefined,
         {
+          ...context,
           restClient: { tv: tvFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-          setCacheMetadata,
-          tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-        } as unknown as Context,
-        {
-          fieldName: 'crew',
-        } as GraphQLResolveInfo
+        },
+        info
       );
 
       expect(tvFetchMock).not.toHaveBeenCalled();

package/src/queries/tvCredits.ts

@@ -1,18 +1,25 @@
-import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
 import { CREDITS, TV } from '../constants.ts';
-import { type Context, type RawTvCredits, type RawTvWithAppendToResponse } from '../types.ts';
+import { buildObjResolver } from '../helpers/buildObjResolver.ts';
+import { type RawTv, type RawTvCredits, type RawTvWithAppendToResponse } from '../types.ts';
 
-export const resolveTvCredits = async (
-  obj: RawTvWithAppendToResponse & { __headers?: Headers },
-  _args: undefined,
-  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
-  { fieldName, fieldNodes }: GraphQLResolveInfo
-) => {
+const isRawTvWithCredits = (
+  obj: RawTv | (RawTvWithAppendToResponse & { __headers?: Headers })
+): obj is RawTvWithAppendToResponse & { __headers: Headers } => CREDITS in obj && '__headers' in obj;
+
+export const resolveTvCredits = buildObjResolver<
+  RawTv | (RawTvWithAppendToResponse & { __headers?: Headers }),
+  RawTvCredits['cast'] | RawTvCredits['crew']
+>(TV, async (obj, ctx, info) => {
+  const { requestID, restClient, tmdbGuestSessionId } = ctx;
+  const { fieldName } = info;
   const typedFieldName = fieldName as 'cast' | 'crew';
 
-  if (obj.credits && obj.__headers) {
-    setCacheMetadata(`${TV}.${typedFieldName}`, obj.__headers);
-    return obj.credits[typedFieldName];
+  if (isRawTvWithCredits(obj)) {
+    return {
+      data: obj.credits?.[typedFieldName],
+      headers: obj.__headers,
+      source: 'parentNode',
+    };
   }
 
   const { data, errors, headers } = await restClient.tv<RawTvCredits>(
@@ -22,13 +29,9 @@ export const resolveTvCredits = async (
     { requestID, tmdbGuestSessionId }
   );
 
-  if (errors?.length) {
-    throw new GraphQLError(`Failed to resolve ${TV} ${obj.id} ${typedFieldName}.`, {
-      nodes: fieldNodes,
-      originalError: errors[0],
-    });
-  }
-
-  setCacheMetadata(`${TV}.${typedFieldName}`, headers);
-  return data![typedFieldName];
-};
+  return {
+    data: data?.[typedFieldName],
+    errors,
+    headers,
+  };
+});

package/src/queries/tvEpisodeGroups.test.ts

@@ -6,42 +6,43 @@ import tvEpisodeGroups from '@tmdb-graphql-api/test-utils/responses/themoviedb/t
 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 RawTvWithAppendToResponse } from '../types.ts';
+import { EPISODE_GROUPS } from '../constants.ts';
+import { type Context } from '../types.ts';
 import { resolveTvEpisodeGroups } from './tvEpisodeGroups.ts';
 
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolveTvEpisodeGroups >', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
   const tvId = 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(TV_PATH, { id: tvId, type: 'episode_groups' }), {
+    mockedFetch.mockGetOnce(buildEndpoint(TV_PATH, { id: tvId, type: snakeCase(EPISODE_GROUPS) }), {
       body: tvEpisodeGroups,
     });
   });
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   it('should return the tv episode groups', async () => {
-    await expect(
-      resolveTvEpisodeGroups(
-        tvDetails as unknown as RawTvWithAppendToResponse,
-        undefined,
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
-      )
-    ).resolves.toMatchSnapshot();
+    // @ts-expect-error minor nested type mismatch
+    await expect(resolveTvEpisodeGroups(tvDetails, undefined, context, info)).resolves.toMatchSnapshot();
   });
 
   describe('when raw tv data has episode groups', () => {
@@ -54,20 +55,18 @@ describe('resolveTvEpisodeGroups >', () => {
 
       await expect(
         resolveTvEpisodeGroups(
+          // @ts-expect-error minor nested type mismatch
           {
             ...tvDetails,
             __headers: new Headers(),
             episode_groups: rest,
-          } as unknown as RawTvWithAppendToResponse & {
-            __headers?: Headers;
           },
           undefined,
           {
+            ...context,
             restClient: { tv: tvFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-            setCacheMetadata,
-            tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-          } as unknown as Context,
-          {} as GraphQLResolveInfo
+          },
+          info
         )
       ).resolves.toMatchSnapshot();
     });
@@ -80,20 +79,18 @@ describe('resolveTvEpisodeGroups >', () => {
       const { id, ...rest } = tvEpisodeGroups;
 
       await resolveTvEpisodeGroups(
+        // @ts-expect-error minor nested type mismatch
         {
           ...tvDetails,
           __headers: new Headers(),
           episode_groups: rest,
-        } as unknown as RawTvWithAppendToResponse & {
-          __headers?: Headers;
         },
         undefined,
         {
+          ...context,
           restClient: { tv: tvFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-          setCacheMetadata,
-          tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-        } as unknown as Context,
-        {} as GraphQLResolveInfo
+        },
+        info
       );
 
       expect(tvFetchMock).not.toHaveBeenCalled();