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

package/src/queries/search.test.ts

@@ -15,6 +15,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 { SEARCH } from '../constants.ts';
 import { type Context } from '../types.ts';
@@ -22,6 +23,15 @@ import { createMakeCursors, createResourceResolver, cursorCache, resolveSearch }
 
 const mockedFetch = mockFetch(jest.fn);
 
+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 input = {
     after: 'abcdefg',
@@ -66,14 +76,16 @@ describe('createResourceResolver', () => {
     search: jest.fn().mockReturnValue({}),
   } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>;
 
-  const setCacheMetadata = jest.fn();
-
   it('when `restClient.search` is called', async () => {
-    const resourceResolver = createResourceResolver(undefined, { ...input }, {
-      restClient,
-      setCacheMetadata,
-      tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-    } as unknown as Context);
+    const resourceResolver = createResourceResolver(
+      undefined,
+      { ...input },
+      {
+        ...context,
+        restClient,
+      },
+      info
+    );
 
     await resourceResolver({ page: 1 });
 
@@ -95,17 +107,10 @@ describe('createResourceResolver', () => {
 });
 
 describe('resolveSearch > collections', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
-
   const args = {
     query: 'star wars',
   };
 
-  beforeAll(() => {
-    restClient = createRestClient();
-  });
-
   beforeEach(() => {
     mockedFetch.mockGetOnce(
       buildEndpoint(SEARCH_PATH, { type: SearchType.Collection.toLowerCase() }, { ...args, page: 1 }),
@@ -118,19 +123,15 @@ describe('resolveSearch > collections', () => {
 
   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(
-        resolveSearch(
-          undefined,
-          { ...args, first: 5, searchType: SearchType.Collection },
-          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-          {} as GraphQLResolveInfo
-        )
+        resolveSearch(undefined, { ...args, first: 5, searchType: SearchType.Collection }, context, info)
       ).resolves.toMatchSnapshot();
     });
   });
@@ -140,16 +141,16 @@ describe('resolveSearch > collections', () => {
       const { pageInfo } = await resolveSearch(
         undefined,
         { ...args, first: 5, searchType: SearchType.Collection },
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
+        context,
+        info
       );
 
       await expect(
         resolveSearch(
           undefined,
           { ...args, after: pageInfo.endCursor, first: 5, searchType: SearchType.Collection },
-          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-          {} as GraphQLResolveInfo
+          context,
+          info
         )
       ).resolves.toMatchSnapshot();
     });
@@ -157,17 +158,10 @@ describe('resolveSearch > collections', () => {
 });
 
 describe('resolveSearch > companies', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
-
   const args = {
     query: 'orion',
   };
 
-  beforeAll(() => {
-    restClient = createRestClient();
-  });
-
   beforeEach(() => {
     mockedFetch.mockGetOnce(
       buildEndpoint(SEARCH_PATH, { type: SearchType.Company.toLowerCase() }, { ...args, page: 1 }),
@@ -180,19 +174,15 @@ describe('resolveSearch > companies', () => {
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
     await cursorCache.clear();
+    jest.clearAllMocks();
   });
 
   describe('when the last 5 are requested', () => {
     it('should return the correct response', async () => {
       await expect(
-        resolveSearch(
-          undefined,
-          { ...args, last: 5, searchType: SearchType.Company },
-          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-          {} as GraphQLResolveInfo
-        )
+        resolveSearch(undefined, { ...args, last: 5, searchType: SearchType.Company }, context, info)
       ).resolves.toMatchSnapshot();
     });
   });
@@ -202,16 +192,16 @@ describe('resolveSearch > companies', () => {
       const { pageInfo } = await resolveSearch(
         undefined,
         { ...args, last: 5, searchType: SearchType.Company },
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
+        context,
+        info
       );
 
       await expect(
         resolveSearch(
           undefined,
           { ...args, before: pageInfo.startCursor, last: 5, searchType: SearchType.Company },
-          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-          {} as GraphQLResolveInfo
+          context,
+          info
         )
       ).resolves.toMatchSnapshot();
     });
@@ -219,17 +209,10 @@ describe('resolveSearch > companies', () => {
 });
 
 describe('resolveSearch > movies', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
-
   const args = {
     query: 'harry potter',
   };
 
-  beforeAll(() => {
-    restClient = createRestClient();
-  });
-
   beforeEach(() => {
     mockedFetch.mockGetOnce(
       buildEndpoint(SEARCH_PATH, { type: SearchType.Movie.toLowerCase() }, { ...args, page: 1 }),
@@ -250,19 +233,15 @@ describe('resolveSearch > movies', () => {
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
     await cursorCache.clear();
+    jest.clearAllMocks();
   });
 
   describe('when the first 18 are requested', () => {
     it('should return the correct response', async () => {
       await expect(
-        resolveSearch(
-          undefined,
-          { ...args, first: 18, searchType: SearchType.Movie },
-          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-          {} as GraphQLResolveInfo
-        )
+        resolveSearch(undefined, { ...args, first: 18, searchType: SearchType.Movie }, context, info)
       ).resolves.toMatchSnapshot();
     });
   });
@@ -272,16 +251,16 @@ describe('resolveSearch > movies', () => {
       const { pageInfo } = await resolveSearch(
         undefined,
         { ...args, first: 18, searchType: SearchType.Movie },
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
+        context,
+        info
       );
 
       await expect(
         resolveSearch(
           undefined,
           { ...args, after: pageInfo.endCursor, first: 18, searchType: SearchType.Movie },
-          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-          {} as GraphQLResolveInfo
+          context,
+          info
         )
       ).resolves.toMatchSnapshot();
     });
@@ -289,17 +268,10 @@ describe('resolveSearch > movies', () => {
 });
 
 describe('resolveSearch > multi', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
-
   const args = {
     query: 'marilyn monroe',
   };
 
-  beforeAll(() => {
-    restClient = createRestClient();
-  });
-
   beforeEach(() => {
     mockedFetch.mockGetOnce(
       buildEndpoint(SEARCH_PATH, { type: SearchType.Multi.toLowerCase() }, { ...args, page: 1 }),
@@ -320,19 +292,15 @@ describe('resolveSearch > multi', () => {
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
     await cursorCache.clear();
+    jest.clearAllMocks();
   });
 
   describe('when the last 5 are requested', () => {
     it('should return the correct response', async () => {
       await expect(
-        resolveSearch(
-          undefined,
-          { ...args, last: 5, searchType: SearchType.Multi },
-          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-          {} as GraphQLResolveInfo
-        )
+        resolveSearch(undefined, { ...args, last: 5, searchType: SearchType.Multi }, context, info)
       ).resolves.toMatchSnapshot();
     });
   });
@@ -342,16 +310,16 @@ describe('resolveSearch > multi', () => {
       const { pageInfo } = await resolveSearch(
         undefined,
         { ...args, last: 5, searchType: SearchType.Multi },
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
+        context,
+        info
       );
 
       await expect(
         resolveSearch(
           undefined,
           { ...args, before: pageInfo.startCursor, last: 5, searchType: SearchType.Multi },
-          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-          {} as GraphQLResolveInfo
+          context,
+          info
         )
       ).resolves.toMatchSnapshot();
     });
@@ -359,17 +327,10 @@ describe('resolveSearch > multi', () => {
 });
 
 describe('resolveSearch > people', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
-
   const args = {
     query: 'tom cruise',
   };
 
-  beforeAll(() => {
-    restClient = createRestClient();
-  });
-
   beforeEach(() => {
     mockedFetch.mockGetOnce(
       buildEndpoint(SEARCH_PATH, { type: SearchType.Person.toLowerCase() }, { ...args, page: 1 }),
@@ -382,36 +343,25 @@ describe('resolveSearch > people', () => {
 
   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(
-        resolveSearch(
-          undefined,
-          { ...args, first: 5, searchType: SearchType.Person },
-          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-          {} as GraphQLResolveInfo
-        )
+        resolveSearch(undefined, { ...args, first: 5, searchType: SearchType.Person }, context, info)
       ).resolves.toMatchSnapshot();
     });
   });
 });
 
 describe('resolveSearch > tv', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
-
   const args = {
     query: 'true detective',
   };
 
-  beforeAll(() => {
-    restClient = createRestClient();
-  });
-
   beforeEach(() => {
     mockedFetch.mockGetOnce(buildEndpoint(SEARCH_PATH, { type: SearchType.Tv.toLowerCase() }, { ...args, page: 1 }), {
       body: searchTV,
@@ -421,19 +371,15 @@ describe('resolveSearch > tv', () => {
 
   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(
-        resolveSearch(
-          undefined,
-          { ...args, first: 5, searchType: SearchType.Tv },
-          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-          {} as GraphQLResolveInfo
-        )
+        resolveSearch(undefined, { ...args, first: 5, searchType: SearchType.Tv }, context, info)
       ).resolves.toMatchSnapshot();
     });
   });

package/src/queries/search.ts

@@ -1,13 +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 QuerySearchArgs } from '@tmdb-graphql-api/schema/types';
+import {
+  type CreateResourceResolver,
+  type Getters,
+  makeConnectionResolver,
+  removeConnectionInputOptions,
+} from '@graphql-box/connection-resolver';
+import { type QuerySearchArgs, SearchType } from '@tmdb-graphql-api/schema/types';
 import { encode } from 'js-base64';
 import { capitalize } from 'lodash-es';
 import { SEARCH } from '../constants.ts';
 import { snakeCasePropNames } from '../helpers/snakeCasePropNames.ts';
-import { type Context, type RawSearch, type RawSearchResource, type SearchMediaType } from '../types.ts';
+import { type Context, type RawSearch, type RawSearchType } from '../types.ts';
 
 /* eslint-disable camelcase */
 
@@ -20,33 +25,48 @@ export const createMakeCursors = (_obj: undefined, args: QuerySearchArgs) => {
   };
 };
 
-export const createResourceResolver = (
-  _obj: undefined,
-  args: QuerySearchArgs,
-  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context
+export const createResourceResolver: CreateResourceResolver<undefined, QuerySearchArgs, Context, RawSearch> = (
+  _obj,
+  args,
+  { requestID, restClient, tmdbGuestSessionId }
 ) => {
   const { searchType, ...rest } = removeConnectionInputOptions(args);
 
   return async ({ page }: { page: number }) => {
-    const result = await restClient.search<RawSearchResource>(
+    const { data, errors, headers } = await restClient.search<RawSearch>(
       {
-        pathTemplateData: { type: (searchType ?? 'MULTI').toLowerCase() },
+        pathTemplateData: { type: (searchType ?? SearchType.Multi).toLowerCase() },
         queryParams: { ...snakeCasePropNames(rest), page },
       },
       { 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 ?? (searchType as SearchMediaType)) as SearchMediaType;
+    data.results = data.results?.map(entry => {
+      let mediaType = entry.media_type;
+
+      if (!mediaType && searchType && searchType !== SearchType.Multi) {
+        mediaType = searchType.toLowerCase();
+      }
+
+      if (mediaType) {
+        entry.media_type = capitalize(mediaType);
+      }
+
       return entry;
     });
 
-    setCacheMetadata(SEARCH, result.headers);
-    return result;
+    return {
+      data,
+      errors,
+      headers,
+    };
   };
 };
 
@@ -57,11 +77,13 @@ export const cursorCache = new Core({
   type: 'GRAPHQL',
 });
 
-export const getters: Getters<RawSearchResource, RawSearch & { media_type?: SearchMediaType }> = {
-  nodes: ({ results }: RawSearchResource) => results,
-  page: ({ page }: RawSearchResource) => page,
-  totalPages: ({ total_pages }: RawSearchResource) => total_pages,
-  totalResults: ({ total_results }: RawSearchResource) => total_results,
+export const getters: Getters<RawSearch, RawSearchType & { media_type?: Capitalize<Lowercase<SearchType>> }> = {
+  // @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 resolveSearch = makeConnectionResolver({

package/src/queries/season.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 { SEASON } from '../constants.ts';
 import { encodeId } from '../helpers/encodeId.ts';
@@ -18,13 +19,14 @@ import { resolveSeason } from './season.ts';
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolveSeason >', () => {
-  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(SEASON_PATH, { id, number: 1 }), {
@@ -34,26 +36,24 @@ describe('resolveSeason >', () => {
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   it('should return the correct season details', async () => {
     const operationDefinition = getOperationDefinitions(parse(seasonDetailsQuery()), OperationTypeNode.QUERY)[0]!;
     const { fieldNode } = getChildFields(operationDefinition, { name: SEASON })![0]!;
+    const info = { fieldNodes: [fieldNode] } as unknown as GraphQLResolveInfo;
 
     await expect(
-      resolveSeason(
-        undefined,
-        { seasonLookupId: encodeId({ id, seasonNumber: 1 }) },
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        { fieldNodes: [fieldNode] } as unknown as GraphQLResolveInfo
-      )
+      resolveSeason(undefined, { id: encodeId({ id, seasonNumber: 1 }) }, context, info)
     ).resolves.toMatchSnapshot();
   });
 
   it('should request the correct resources when append to response fields are found', async () => {
     const operationDefinition = getOperationDefinitions(parse(seasonDetailsLgQuery()), OperationTypeNode.QUERY)[0]!;
     const { fieldNode } = getChildFields(operationDefinition, { name: SEASON })![0]!;
+    const info = { fieldNodes: [fieldNode] } as unknown as GraphQLResolveInfo;
 
     const seasonFetchMock = jest
       .fn<(...args: PlainArray) => Promise<FetchResponse>>()
@@ -61,13 +61,12 @@ describe('resolveSeason >', () => {
 
     await resolveSeason(
       undefined,
-      { seasonLookupId: encodeId({ id, seasonNumber: 1 }) },
+      { id: encodeId({ id, seasonNumber: 1 }) },
       {
+        ...context,
         restClient: { season: seasonFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-        setCacheMetadata,
-        tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-      } as unknown as Context,
-      { fieldNodes: [fieldNode] } as unknown as GraphQLResolveInfo
+      },
+      info
     );
 
     expect(seasonFetchMock.mock.calls[0]![0]).toEqual(

package/src/queries/season.ts

@@ -1,11 +1,11 @@
 import { type QuerySeasonArgs } from '@tmdb-graphql-api/schema/types';
-import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
 import { isUndefined, snakeCase } from 'lodash-es';
-import { CAST, CREDITS, CREW, EXTERNAL_IDS, IMAGES, POSTERS, SEASON, TRANSLATIONS, TV, VIDEOS } from '../constants.ts';
+import { CAST, CREDITS, CREW, EXTERNAL_IDS, IMAGES, POSTERS, SEASON, TRANSLATIONS, VIDEOS } from '../constants.ts';
+import { buildObjArgsResolver } from '../helpers/buildObjArgsResolver.ts';
 import { encodeId } from '../helpers/encodeId.ts';
 import { getAppendToResponseKeys } from '../helpers/getAppendToResponseKeys.ts';
 import { getTvIdSeasonAndEpisode } from '../helpers/getTvIdSeasonAndEpisode.ts';
-import { type Context, type RawSeason, type RawSeasonWithAppendToResponse } from '../types.ts';
+import { type EnrichedRawSeason, type EnrichedRawSeasonWithAppendToResponse, type RawSeason } from '../types.ts';
 
 const appendToResponse = {
   [CAST]: CREDITS,
@@ -16,32 +16,29 @@ const appendToResponse = {
   [VIDEOS]: VIDEOS,
 };
 
-const enrichEpisodeData = (obj: RawSeason) => {
-  if (obj.episodes) {
-    for (const episode of obj.episodes) {
-      episode.tv_show_id = obj.tv_show_id;
-    }
-  }
-};
-
-export const resolveSeason = async (
-  obj: RawSeason | undefined,
-  args: QuerySeasonArgs,
-  { fragmentDefinitions, requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
-  { fieldName, fieldNodes }: GraphQLResolveInfo
-) => {
+export const resolveSeason = buildObjArgsResolver<
+  EnrichedRawSeason,
+  QuerySeasonArgs,
+  | (EnrichedRawSeasonWithAppendToResponse & { __headers?: Headers })
+  | EnrichedRawSeasonWithAppendToResponse[keyof EnrichedRawSeasonWithAppendToResponse]
+>(SEASON, async (obj, args, ctx, info) => {
+  const { fragmentDefinitions, requestID, restClient, tmdbGuestSessionId } = ctx;
+  const { fieldName, fieldNodes } = info;
   const typedFieldName = snakeCase(fieldName) as keyof RawSeason;
-  const { seasonNumber, tvId } = getTvIdSeasonAndEpisode(obj, args.seasonLookupId);
+  const { id, seasonNumber } = getTvIdSeasonAndEpisode(obj, args);
 
   if (obj && !isUndefined(obj[typedFieldName])) {
-    return typedFieldName === 'season_lookup_id' ? encodeId({ seasonNumber, tvId }) : obj[typedFieldName];
+    return {
+      data: typedFieldName === 'id' ? encodeId({ id, seasonNumber }) : obj[typedFieldName],
+      source: 'parentNode',
+    };
   }
 
   const appendToResponseKeys = getAppendToResponseKeys(fieldNodes[0]!, appendToResponse, fragmentDefinitions);
 
-  const { data, errors, headers } = await restClient.season<RawSeasonWithAppendToResponse>(
+  const { data, errors, headers } = await restClient.season<EnrichedRawSeasonWithAppendToResponse>(
     {
-      pathTemplateData: { id: tvId, number: seasonNumber },
+      pathTemplateData: { id, number: seasonNumber },
       ...(appendToResponseKeys.length > 0
         ? {
             queryParams: {
@@ -53,27 +50,20 @@ export const resolveSeason = async (
     { requestID, tmdbGuestSessionId }
   );
 
-  if (errors?.length) {
-    throw new GraphQLError(`Failed to resolve ${TV} show ${tvId} ${SEASON} ${seasonNumber}.`, {
-      nodes: fieldNodes,
-      originalError: errors[0],
-    });
-  }
-
-  const rawSeason = data!;
-  rawSeason.season_lookup_id = encodeId({ seasonNumber, tvId });
+  const seasonData = {
+    ...data,
+    episodes: (data?.episodes ?? []).map(episode => ({ ...episode, tv_show_id: Number(id) })),
+    id: encodeId({ id, seasonNumber }),
+    tv_show_id: Number(id),
+  };
 
-  if (!rawSeason.tv_show_id) {
-    rawSeason.tv_show_id = tvId;
-  }
-
-  enrichEpisodeData(rawSeason);
-
-  if (obj) {
-    setCacheMetadata(`${SEASON}.${fieldName}`, headers);
-    return rawSeason[typedFieldName];
-  }
-
-  setCacheMetadata(SEASON, headers);
-  return appendToResponseKeys.length > 0 ? { ...rawSeason, __headers: headers } : rawSeason;
-};
+  return {
+    data: obj
+      ? seasonData[typedFieldName]
+      : appendToResponseKeys.length > 0
+      ? { ...seasonData, __headers: headers }
+      : seasonData,
+    errors,
+    headers,
+  };
+});