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

package/src/queries/seasonTranslations.ts

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

package/src/queries/seasonVideos.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 { VIDEOS } from '../constants.ts';
+import { type Context } from '../types.ts';
 import { resolveSeasonVideos } from './seasonVideos.ts';
 
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolveSeasonVideos >', () => {
-  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: 'videos' }), {
+    mockedFetch.mockGetOnce(buildEndpoint(SEASON_PATH, { id: 1399, number: 1, type: VIDEOS }), {
       body: seasonVideos,
     });
   });
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   it('should return the season videos', async () => {
-    await expect(
-      resolveSeasonVideos(
-        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(resolveSeasonVideos(seasonDetails, undefined, context, info)).resolves.toMatchSnapshot();
   });
 
   describe('when raw season data has videos', () => {
@@ -53,20 +52,18 @@ describe('resolveSeasonVideos >', () => {
 
       await expect(
         resolveSeasonVideos(
+          // @ts-expect-error minor nested type mismatch
           {
             ...seasonDetails,
             __headers: new Headers(),
             videos: 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 +76,18 @@ describe('resolveSeasonVideos >', () => {
       const { id, ...rest } = seasonVideos;
 
       await resolveSeasonVideos(
+        // @ts-expect-error minor nested type mismatch
         {
           ...seasonDetails,
           __headers: new Headers(),
           videos: 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/seasonVideos.ts

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

package/src/queries/trending.test.ts

@@ -1,5 +1,4 @@
 import { removeConnectionInputOptions } from '@graphql-box/connection-resolver';
-import { type PlainObject } from '@graphql-box/core';
 import { jest } from '@jest/globals';
 import { type ShortcutMethodNames, TRENDING_PATH } from '@tmdb-graphql-api/rest-client';
 import { TrendingMediaType, TrendingTimeWindow } from '@tmdb-graphql-api/schema/types';
@@ -11,6 +10,7 @@ import { type Getta, type ShortcutProperties } from 'getta';
 import { type GraphQLResolveInfo } from 'graphql';
 import { decode } from 'js-base64';
 import { buildEndpoint } from '../__testUtils__/helpers/buildEndpoint.ts';
+import { createMockLogger } from '../__testUtils__/helpers/createMockLogger.ts';
 import { createRestClient } from '../__testUtils__/helpers/createRestClient.ts';
 import { TRENDING } from '../constants.ts';
 import { type Context } from '../types.ts';
@@ -23,6 +23,15 @@ const baseArgs = {
   timeWindow: 'DAY' as TrendingTimeWindow,
 };
 
+const context = {
+  logger: createMockLogger(jest.fn),
+  restClient: createRestClient(),
+  setCacheMetadata: jest.fn(),
+  tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+} as unknown as Context;
+
+const info = {} as GraphQLResolveInfo;
+
 describe('createMakeCursors', () => {
   const GROUP_CURSOR = `${JSON.stringify(removeConnectionInputOptions(baseArgs))}::${TRENDING}`;
 
@@ -45,15 +54,8 @@ describe('createResourceResolver', () => {
     trending: jest.fn().mockReturnValue({}),
   } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>;
 
-  const setCacheMetadata = jest.fn();
-
   it('when `restClient.trending` is called', async () => {
-    const resourceResolver = createResourceResolver(undefined, baseArgs, {
-      restClient,
-      setCacheMetadata,
-      tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-    } as unknown as Context);
-
+    const resourceResolver = createResourceResolver(undefined, baseArgs, { ...context, restClient }, info);
     await resourceResolver({ page: 1 });
 
     expect(restClient.trending).toHaveBeenCalledWith(
@@ -69,16 +71,13 @@ describe('createResourceResolver', () => {
 });
 
 describe('resolveTrending', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
-
-  const mockEndpoint = ({ mediaType, timeWindow }: PlainObject, page: number, body: Jsonifiable) => {
+  const mockEndpoint = (
+    { mediaType, timeWindow }: { mediaType: TrendingMediaType; timeWindow: TrendingTimeWindow },
+    page: number,
+    body: Jsonifiable
+  ) => {
     mockedFetch.mockGetOnce(
-      buildEndpoint(
-        TRENDING_PATH,
-        { subType: (timeWindow as string).toLowerCase(), type: (mediaType as string).toLowerCase() },
-        { page }
-      ),
+      buildEndpoint(TRENDING_PATH, { subType: timeWindow.toLowerCase(), type: mediaType.toLowerCase() }, { page }),
       {
         body,
         headers: { 'cache-control': 'public, max-age=6000' },
@@ -86,76 +85,45 @@ describe('resolveTrending', () => {
     );
   };
 
-  beforeAll(() => {
-    restClient = createRestClient();
-  });
-
   beforeEach(() => {
     mockEndpoint(baseArgs, 1, trendingAllDay);
-    mockEndpoint({ ...baseArgs, mediaType: 'MOVIE' }, 1, trendingMovieDay);
-    mockEndpoint({ mediaType: 'MOVIE', timeWindow: 'WEEK' }, 1, trendingMovieWeek);
+    mockEndpoint({ ...baseArgs, mediaType: TrendingMediaType.Movie }, 1, trendingMovieDay);
+    mockEndpoint({ mediaType: TrendingMediaType.Movie, timeWindow: TrendingTimeWindow.Week }, 1, trendingMovieWeek);
   });
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
     await cursorCache.clear();
+    jest.clearAllMocks();
   });
 
   describe('when the first 5 are requested', () => {
     it('should return the correct response', async () => {
-      await expect(
-        resolveTrending(
-          undefined,
-          { ...baseArgs, first: 5 },
-          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-          {} as GraphQLResolveInfo
-        )
-      ).resolves.toMatchSnapshot();
+      await expect(resolveTrending(undefined, { ...baseArgs, first: 5 }, context, info)).resolves.toMatchSnapshot();
     });
   });
 
   describe('when the second 5 are requested', () => {
     it('should return the correct response', async () => {
-      const { pageInfo } = await resolveTrending(
-        undefined,
-        { ...baseArgs, first: 5 },
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
-      );
+      const { pageInfo } = await resolveTrending(undefined, { ...baseArgs, first: 5 }, context, info);
 
       await expect(
-        resolveTrending(
-          undefined,
-          { ...baseArgs, after: pageInfo.endCursor, first: 5 },
-          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-          {} as GraphQLResolveInfo
-        )
+        resolveTrending(undefined, { ...baseArgs, after: pageInfo.endCursor, first: 5 }, context, info)
       ).resolves.toMatchSnapshot();
     });
   });
 
   describe('when the first 5 are requested with different args', () => {
     it('should request each resource from the server once', async () => {
-      await resolveTrending(
-        undefined,
-        { ...baseArgs, first: 5 },
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
-      );
-
-      await resolveTrending(
-        undefined,
-        { ...baseArgs, first: 5, mediaType: TrendingMediaType.Movie },
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
-      );
+      await resolveTrending(undefined, { ...baseArgs, first: 5 }, context, info);
+      await resolveTrending(undefined, { ...baseArgs, first: 5, mediaType: TrendingMediaType.Movie }, context, info);
 
       await resolveTrending(
         undefined,
         { ...baseArgs, first: 5, mediaType: TrendingMediaType.Movie, timeWindow: TrendingTimeWindow.Week },
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
+        context,
+        info
       );
 
       expect(mockedFetch).toHaveBeenCalledTimes(3);

package/src/queries/trending.ts

@@ -1,12 +1,18 @@
 import { Core } from '@cachemap/core';
 import { init as map } from '@cachemap/map';
 import { init as reaper } from '@cachemap/reaper';
-import { type Getters, makeConnectionResolver, removeConnectionInputOptions } from '@graphql-box/connection-resolver';
+import {
+  type CreateResourceResolver,
+  type Getters,
+  makeConnectionResolver,
+  removeConnectionInputOptions,
+} from '@graphql-box/connection-resolver';
 import { type MediaType, type QueryTrendingArgs } from '@tmdb-graphql-api/schema/types';
+import { TrendingMediaType } from '@tmdb-graphql-api/schema/types';
 import { encode } from 'js-base64';
 import { capitalize } from 'lodash-es';
 import { TRENDING } from '../constants.ts';
-import { type Context, type RawMedia, type RawTrending } from '../types.ts';
+import { type Context, type RawMediaType, type RawTrending } from '../types.ts';
 
 /* eslint-disable camelcase */
 
@@ -19,14 +25,13 @@ export const createMakeCursors = (_obj: undefined, args: QueryTrendingArgs) => {
   };
 };
 
-export const createResourceResolver =
-  (
-    _obj: undefined,
-    { mediaType, timeWindow }: QueryTrendingArgs,
-    { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context
-  ) =>
+export const createResourceResolver: CreateResourceResolver<undefined, QueryTrendingArgs, Context, RawTrending> =
+  (_obj, args, ctx) =>
   async ({ page }: { page: number }) => {
-    const result = await restClient.trending<RawTrending>(
+    const { mediaType, timeWindow } = args;
+    const { requestID, restClient, tmdbGuestSessionId } = ctx;
+
+    const { data, errors, headers } = await restClient.trending<RawTrending>(
       {
         pathTemplateData: { subType: timeWindow.toLowerCase(), type: mediaType.toLowerCase() },
         queryParams: { page },
@@ -34,17 +39,32 @@ export const createResourceResolver =
       { requestID, tmdbGuestSessionId }
     );
 
-    if (!result.data) {
-      return result;
+    if (!data) {
+      return {
+        errors,
+        headers,
+      };
     }
 
-    result.data.results = result.data.results.map(entry => {
-      entry.media_type = capitalize(entry.media_type ?? mediaType) as MediaType;
+    data.results = data.results?.map(entry => {
+      let type = entry.media_type;
+
+      if (!type && mediaType !== TrendingMediaType.All) {
+        type = mediaType.toLowerCase();
+      }
+
+      if (type) {
+        entry.media_type = capitalize(type);
+      }
+
       return entry;
     });
 
-    setCacheMetadata(TRENDING, result.headers);
-    return result;
+    return {
+      data,
+      errors,
+      headers,
+    };
   };
 
 export const cursorCache = new Core({
@@ -54,11 +74,13 @@ export const cursorCache = new Core({
   type: 'GRAPHQL',
 });
 
-export const getters: Getters<RawTrending, RawMedia & { media_type?: MediaType }> = {
-  nodes: ({ results }) => results,
-  page: ({ page }) => page,
-  totalPages: ({ total_pages }) => total_pages,
-  totalResults: ({ total_results }) => total_results,
+export const getters: Getters<RawTrending, RawMediaType & { media_type?: Capitalize<Lowercase<MediaType>> }> = {
+  // @ts-expect-error nested identifier is optional when
+  // it shouldn't be
+  nodes: ({ results = [] }) => results,
+  page: ({ page = 0 }) => page,
+  totalPages: ({ total_pages = 0 }) => total_pages,
+  totalResults: ({ total_results = 0 }) => total_results,
 };
 
 export const resolveTrending = makeConnectionResolver({

package/src/queries/tv.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 { TV } from '../constants.ts';
 import { type Context } from '../types.ts';
@@ -17,13 +18,14 @@ import { resolveTv } from './tv.ts';
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolveTv >', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
   const id = 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 }), {
@@ -33,26 +35,21 @@ describe('resolveTv >', () => {
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   it('should return the correct tv details', async () => {
     const operationDefinition = getOperationDefinitions(parse(tvDetailsQuery()), OperationTypeNode.QUERY)[0]!;
     const { fieldNode } = getChildFields(operationDefinition, { name: TV })![0]!;
-
-    await expect(
-      resolveTv(
-        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(resolveTv(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(tvDetailsLgQuery()), OperationTypeNode.QUERY)[0]!;
     const { fieldNode } = getChildFields(operationDefinition, { name: TV })![0]!;
+    const info = { fieldNodes: [fieldNode] } as unknown as GraphQLResolveInfo;
 
     const tvFetchMock = jest
       .fn<(...args: PlainArray) => Promise<FetchResponse>>()
@@ -60,13 +57,12 @@ describe('resolveTv >', () => {
 
     await resolveTv(
       undefined,
-      { id },
+      { id: String(id) },
       {
+        ...context,
         restClient: { tv: tvFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-        setCacheMetadata,
-        tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-      } as unknown as Context,
-      { fieldNodes: [fieldNode] } as unknown as GraphQLResolveInfo
+      },
+      info
     );
 
     expect(tvFetchMock.mock.calls[0]![0]).toEqual(

package/src/queries/tv.ts

@@ -1,5 +1,4 @@
 import { type QueryTvArgs } from '@tmdb-graphql-api/schema/types';
-import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
 import { isUndefined, snakeCase } from 'lodash-es';
 import {
   ALTERNATIVE_TITLES,
@@ -23,8 +22,9 @@ import {
   VIDEOS,
   WATCH_PROVIDERS,
 } from '../constants.ts';
+import { buildObjArgsResolver } from '../helpers/buildObjArgsResolver.ts';
 import { getAppendToResponseKeys } from '../helpers/getAppendToResponseKeys.ts';
-import { type Context, type RawTv, type RawTvWithAppendToResponse } from '../types.ts';
+import { type RawTv, type RawTvWithAppendToResponse } from '../types.ts';
 
 const appendToResponse = {
   [ALTERNATIVE_TITLES]: snakeCase(ALTERNATIVE_TITLES),
@@ -45,27 +45,20 @@ const appendToResponse = {
   [WATCH_PROVIDERS]: 'watch/providers',
 };
 
-const enrichSeasonData = (obj: RawTv) => {
-  // Although RawTv should always have seasons there are some
-  // instances where this is undefined and causes an exception.
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-  if (obj.seasons) {
-    for (const season of obj.seasons) {
-      season.tv_show_id = obj.id;
-    }
-  }
-};
-
-export const resolveTv = async (
-  obj: RawTv | undefined,
-  args: QueryTvArgs,
-  { fragmentDefinitions, requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
-  { fieldName, fieldNodes }: GraphQLResolveInfo
-) => {
+export const resolveTv = buildObjArgsResolver<
+  RawTv,
+  QueryTvArgs,
+  (RawTvWithAppendToResponse & { __headers?: Headers }) | RawTvWithAppendToResponse[keyof RawTvWithAppendToResponse]
+>(TV, async (obj, args, ctx, info) => {
+  const { fragmentDefinitions, requestID, restClient, tmdbGuestSessionId } = ctx;
+  const { fieldName, fieldNodes } = info;
   const typedFieldName = snakeCase(fieldName) as keyof RawTv;
 
   if (obj && !isUndefined(obj[typedFieldName])) {
-    return obj[typedFieldName];
+    return {
+      data: obj[typedFieldName],
+      source: 'parentNode',
+    };
   }
 
   const id = obj ? obj.id : args.id;
@@ -85,18 +78,17 @@ export const resolveTv = async (
     { requestID, tmdbGuestSessionId }
   );
 
-  if (errors?.length) {
-    throw new GraphQLError(`Failed to resolve ${TV} ${id}.`, { nodes: fieldNodes, originalError: errors[0] });
-  }
-
-  const rawTv = data!;
-  enrichSeasonData(rawTv);
-
-  if (obj) {
-    setCacheMetadata(`${TV}.${fieldName}`, headers);
-    return rawTv[typedFieldName];
-  }
+  const tvData = {
+    ...data,
+    seasons: (data?.seasons ?? []).map(season => ({
+      ...season,
+      tv_show_id: Number(id),
+    })),
+  };
 
-  setCacheMetadata(TV, headers);
-  return appendToResponseKeys.length > 0 ? { ...rawTv, __headers: headers } : rawTv;
-};
+  return {
+    data: obj ? tvData[typedFieldName] : appendToResponseKeys.length > 0 ? { ...tvData, __headers: headers } : tvData,
+    errors,
+    headers,
+  };
+});