@tmdb-graphql-api/resolvers 0.0.6

package/src/queries/search.test.ts

@@ -0,0 +1,426 @@
+import { removeConnectionInputOptions } from '@graphql-box/connection-resolver';
+import { jest } from '@jest/globals';
+import { SEARCH_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import type { SearchType } from '@tmdb-graphql-api/schema';
+import searchCollections from '@tmdb-graphql-api/test-utils/responses/themoviedb/search/collections.json';
+import searchCompanies from '@tmdb-graphql-api/test-utils/responses/themoviedb/search/companies.json';
+import searchMoviesPage1 from '@tmdb-graphql-api/test-utils/responses/themoviedb/search/movies/page1.json';
+import searchMoviesPage2 from '@tmdb-graphql-api/test-utils/responses/themoviedb/search/movies/page2.json';
+import searchMultiPage1 from '@tmdb-graphql-api/test-utils/responses/themoviedb/search/multi/page1.json';
+import searchMultiPage2 from '@tmdb-graphql-api/test-utils/responses/themoviedb/search/multi/page2.json';
+import searchPeople from '@tmdb-graphql-api/test-utils/responses/themoviedb/search/people.json';
+import searchTV from '@tmdb-graphql-api/test-utils/responses/themoviedb/search/tv.json';
+import { mockFetch, polyfillFetch } from 'fetch-mocked';
+import type { Getta, ShortcutProperties } from 'getta';
+import type { GraphQLResolveInfo } from 'graphql';
+import { decode } from 'js-base64';
+import { buildEndpoint } from '../__testUtils__/helpers/buildEndpoint.ts';
+import { createRestClient } from '../__testUtils__/helpers/createRestClient.ts';
+import { SEARCH } from '../constants.ts';
+import type { Context } from '../types.ts';
+import { createMakeCursors, createResourceResolver, cursorCache, resolveSearch } from './search.ts';
+
+polyfillFetch();
+const mockedFetch = mockFetch(jest.fn);
+
+describe('createMakeCursors', () => {
+  const input = {
+    after: 'abcdefg',
+    before: 'higklmn',
+    first: 10,
+    last: 5,
+    query: 'Hello world!',
+    searchType: 'MULTI' as SearchType,
+  };
+
+  const GROUP_CURSOR = `${JSON.stringify(removeConnectionInputOptions(input))}::${SEARCH}`;
+
+  it('makeGroupCursor', () => {
+    const { makeGroupCursor } = createMakeCursors(undefined, { ...input });
+    const groupCursor = makeGroupCursor();
+    expect(decode(groupCursor)).toBe(GROUP_CURSOR);
+  });
+
+  it('makeIDCursor', () => {
+    const id = 23;
+    const { makeIDCursor } = createMakeCursors(undefined, { ...input });
+    const idCursor = makeIDCursor(id);
+    expect(decode(idCursor)).toBe(`${id}::${GROUP_CURSOR}`);
+  });
+});
+
+describe('createResourceResolver', () => {
+  const input = {
+    after: 'abcdefg',
+    before: 'higklmn',
+    first: 10,
+    firstAirDateYear: 2005,
+    includeAdult: false,
+    last: 5,
+    primaryReleaseYear: 2005,
+    query: 'Hello world!',
+    searchType: 'MULTI' as SearchType,
+    year: 2005,
+  };
+
+  const restClient = {
+    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);
+
+    await resourceResolver({ page: 1 });
+
+    expect(restClient.search).toHaveBeenCalledWith(
+      {
+        pathTemplateData: { type: 'multi' },
+        queryParams: {
+          first_air_date_year: 2005,
+          include_adult: false,
+          page: 1,
+          primary_release_year: 2005,
+          query: 'Hello world!',
+          year: 2005,
+        },
+      },
+      { requestID: undefined, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' }
+    );
+  });
+});
+
+describe('resolveSearch > collections', () => {
+  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
+  const setCacheMetadata = jest.fn();
+  const searchType = 'COLLECTION';
+
+  const args = {
+    query: 'star wars',
+  };
+
+  beforeAll(() => {
+    restClient = createRestClient();
+  });
+
+  beforeEach(() => {
+    mockedFetch.mockGetOnce(buildEndpoint(SEARCH_PATH, { type: searchType.toLowerCase() }, { ...args, page: 1 }), {
+      body: searchCollections,
+      headers: { 'cache-control': 'public, max-age=6000' },
+    });
+  });
+
+  afterEach(async () => {
+    mockedFetch.mockReset();
+    await restClient.cache?.clear();
+    await cursorCache.clear();
+  });
+
+  describe('when the first 5 are requested', () => {
+    it('should return the correct response', async () => {
+      await expect(
+        resolveSearch(
+          undefined,
+          { ...args, first: 5, searchType },
+          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+          {} as GraphQLResolveInfo
+        )
+      ).resolves.toMatchSnapshot();
+    });
+  });
+
+  describe('when the second 5 are requested', () => {
+    it('should return the correct response', async () => {
+      const { pageInfo } = await resolveSearch(
+        undefined,
+        { ...args, first: 5, searchType },
+        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+        {} as GraphQLResolveInfo
+      );
+
+      await expect(
+        resolveSearch(
+          undefined,
+          { ...args, after: pageInfo.endCursor, first: 5, searchType },
+          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+          {} as GraphQLResolveInfo
+        )
+      ).resolves.toMatchSnapshot();
+    });
+  });
+});
+
+describe('resolveSearch > companies', () => {
+  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
+  const setCacheMetadata = jest.fn();
+  const searchType = 'COMPANY';
+
+  const args = {
+    query: 'orion',
+  };
+
+  beforeAll(() => {
+    restClient = createRestClient();
+  });
+
+  beforeEach(() => {
+    mockedFetch.mockGetOnce(buildEndpoint(SEARCH_PATH, { type: searchType.toLowerCase() }, { ...args, page: 1 }), {
+      body: searchCompanies,
+      headers: { 'cache-control': 'public, max-age=6000' },
+    });
+  });
+
+  afterEach(async () => {
+    mockedFetch.mockReset();
+    await restClient.cache?.clear();
+    await cursorCache.clear();
+  });
+
+  describe('when the last 5 are requested', () => {
+    it('should return the correct response', async () => {
+      await expect(
+        resolveSearch(
+          undefined,
+          { ...args, last: 5, searchType },
+          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+          {} as GraphQLResolveInfo
+        )
+      ).resolves.toMatchSnapshot();
+    });
+  });
+
+  describe('when the second to last 5 are requested', () => {
+    it('should return the correct response', async () => {
+      const { pageInfo } = await resolveSearch(
+        undefined,
+        { ...args, last: 5, searchType },
+        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+        {} as GraphQLResolveInfo
+      );
+
+      await expect(
+        resolveSearch(
+          undefined,
+          { ...args, before: pageInfo.startCursor, last: 5, searchType },
+          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+          {} as GraphQLResolveInfo
+        )
+      ).resolves.toMatchSnapshot();
+    });
+  });
+});
+
+describe('resolveSearch > movies', () => {
+  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
+  const setCacheMetadata = jest.fn();
+  const searchType = 'MOVIE';
+
+  const args = {
+    query: 'harry potter',
+  };
+
+  beforeAll(() => {
+    restClient = createRestClient();
+  });
+
+  beforeEach(() => {
+    mockedFetch.mockGetOnce(buildEndpoint(SEARCH_PATH, { type: searchType.toLowerCase() }, { ...args, page: 1 }), {
+      body: searchMoviesPage1,
+      headers: { 'cache-control': 'public, max-age=6000' },
+    });
+
+    mockedFetch.mockGetOnce(buildEndpoint(SEARCH_PATH, { type: searchType.toLowerCase() }, { ...args, page: 2 }), {
+      body: searchMoviesPage2,
+      headers: { 'cache-control': 'public, max-age=6000' },
+    });
+  });
+
+  afterEach(async () => {
+    mockedFetch.mockReset();
+    await restClient.cache?.clear();
+    await cursorCache.clear();
+  });
+
+  describe('when the first 18 are requested', () => {
+    it('should return the correct response', async () => {
+      await expect(
+        resolveSearch(
+          undefined,
+          { ...args, first: 18, searchType },
+          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+          {} as GraphQLResolveInfo
+        )
+      ).resolves.toMatchSnapshot();
+    });
+  });
+
+  describe('when the second 18 are requested', () => {
+    it('should return the correct response', async () => {
+      const { pageInfo } = await resolveSearch(
+        undefined,
+        { ...args, first: 18, searchType },
+        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+        {} as GraphQLResolveInfo
+      );
+
+      await expect(
+        resolveSearch(
+          undefined,
+          { ...args, after: pageInfo.endCursor, first: 18, searchType },
+          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+          {} as GraphQLResolveInfo
+        )
+      ).resolves.toMatchSnapshot();
+    });
+  });
+});
+
+describe('resolveSearch > multi', () => {
+  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
+  const setCacheMetadata = jest.fn();
+  const searchType = 'MULTI';
+
+  const args = {
+    query: 'marilyn monroe',
+  };
+
+  beforeAll(() => {
+    restClient = createRestClient();
+  });
+
+  beforeEach(() => {
+    mockedFetch.mockGetOnce(buildEndpoint(SEARCH_PATH, { type: searchType.toLowerCase() }, { ...args, page: 1 }), {
+      body: searchMultiPage1,
+      headers: { 'cache-control': 'public, max-age=6000' },
+    });
+
+    mockedFetch.mockGetOnce(buildEndpoint(SEARCH_PATH, { type: searchType.toLowerCase() }, { ...args, page: 2 }), {
+      body: searchMultiPage2,
+      headers: { 'cache-control': 'public, max-age=6000' },
+    });
+  });
+
+  afterEach(async () => {
+    mockedFetch.mockReset();
+    await restClient.cache?.clear();
+    await cursorCache.clear();
+  });
+
+  describe('when the last 5 are requested', () => {
+    it('should return the correct response', async () => {
+      await expect(
+        resolveSearch(
+          undefined,
+          { ...args, last: 5, searchType },
+          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+          {} as GraphQLResolveInfo
+        )
+      ).resolves.toMatchSnapshot();
+    });
+  });
+
+  describe('when the second to last 5 are requested', () => {
+    it('should return the correct response', async () => {
+      const { pageInfo } = await resolveSearch(
+        undefined,
+        { ...args, last: 5, searchType },
+        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+        {} as GraphQLResolveInfo
+      );
+
+      await expect(
+        resolveSearch(
+          undefined,
+          { ...args, before: pageInfo.startCursor, last: 5, searchType },
+          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+          {} as GraphQLResolveInfo
+        )
+      ).resolves.toMatchSnapshot();
+    });
+  });
+});
+
+describe('resolveSearch > people', () => {
+  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
+  const setCacheMetadata = jest.fn();
+  const searchType = 'PERSON';
+
+  const args = {
+    query: 'tom cruise',
+  };
+
+  beforeAll(() => {
+    restClient = createRestClient();
+  });
+
+  beforeEach(() => {
+    mockedFetch.mockGetOnce(buildEndpoint(SEARCH_PATH, { type: searchType.toLowerCase() }, { ...args, page: 1 }), {
+      body: searchPeople,
+      headers: { 'cache-control': 'public, max-age=6000' },
+    });
+  });
+
+  afterEach(async () => {
+    mockedFetch.mockReset();
+    await restClient.cache?.clear();
+    await cursorCache.clear();
+  });
+
+  describe('when the first 5 are requested', () => {
+    it('should return the correct response', async () => {
+      await expect(
+        resolveSearch(
+          undefined,
+          { ...args, first: 5, searchType },
+          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+          {} as GraphQLResolveInfo
+        )
+      ).resolves.toMatchSnapshot();
+    });
+  });
+});
+
+describe('resolveSearch > tv', () => {
+  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
+  const setCacheMetadata = jest.fn();
+  const searchType = 'TV';
+
+  const args = {
+    query: 'true detective',
+  };
+
+  beforeAll(() => {
+    restClient = createRestClient();
+  });
+
+  beforeEach(() => {
+    mockedFetch.mockGetOnce(buildEndpoint(SEARCH_PATH, { type: searchType.toLowerCase() }, { ...args, page: 1 }), {
+      body: searchTV,
+      headers: { 'cache-control': 'public, max-age=6000' },
+    });
+  });
+
+  afterEach(async () => {
+    mockedFetch.mockReset();
+    await restClient.cache?.clear();
+    await cursorCache.clear();
+  });
+
+  describe('when the first 5 are requested', () => {
+    it('should return the correct response', async () => {
+      await expect(
+        resolveSearch(
+          undefined,
+          { ...args, first: 5, searchType },
+          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+          {} as GraphQLResolveInfo
+        )
+      ).resolves.toMatchSnapshot();
+    });
+  });
+});

package/src/queries/search.ts

@@ -0,0 +1,73 @@
+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';
+import { encode } from 'js-base64';
+import { capitalize } from 'lodash-es';
+import { SEARCH } from '../constants.ts';
+import { snakeCasePropNames } from '../helpers/snakeCasePropNames.ts';
+import type { Context, RawSearch, RawSearchResource, SearchMediaType } from '../types.ts';
+
+/* eslint-disable camelcase */
+
+export const createMakeCursors = (_obj: undefined, args: QuerySearchArgs) => {
+  const groupCursor = `${JSON.stringify(removeConnectionInputOptions(args))}::${SEARCH}`;
+
+  return {
+    makeGroupCursor: () => encode(groupCursor),
+    makeIDCursor: (id: string | number) => encode(`${id}::${groupCursor}`),
+  };
+};
+
+export const createResourceResolver = (
+  _obj: undefined,
+  args: QuerySearchArgs,
+  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context
+) => {
+  const { searchType, ...rest } = removeConnectionInputOptions(args);
+
+  return async ({ page }: { page: number }) => {
+    const result = await restClient.search<RawSearchResource>(
+      {
+        pathTemplateData: { type: (searchType ?? 'MULTI').toLowerCase() },
+        queryParams: { ...snakeCasePropNames(rest), page },
+      },
+      { requestID, tmdbGuestSessionId }
+    );
+
+    if (!result.data) {
+      return result;
+    }
+
+    result.data.results = result.data.results.map(entry => {
+      entry.media_type = capitalize(entry.media_type ?? (searchType as SearchMediaType)) as SearchMediaType;
+      return entry;
+    });
+
+    setCacheMetadata(SEARCH, result.headers);
+    return result;
+  };
+};
+
+export const cursorCache = new Core({
+  name: 'SEARCH_CONNECTION_RESOLVER',
+  reaper: reaper({ interval: 300_000 }),
+  store: map(),
+  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 resolveSearch = makeConnectionResolver({
+  createMakeCursors,
+  createResourceResolver,
+  cursorCache,
+  getters,
+  resultsPerPage: 20,
+});

package/src/queries/season.test.ts

@@ -0,0 +1,82 @@
+import type { PlainArray } from '@graphql-box/core';
+import { getChildFields, getOperationDefinitions } from '@graphql-box/helpers';
+import { jest } from '@jest/globals';
+import { SEASON_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import { seasonDetails as seasonDetailsQuery } from '@tmdb-graphql-api/test-utils/requests/queries/season/details.ts';
+import { seasonDetailsLg as seasonDetailsLgQuery } from '@tmdb-graphql-api/test-utils/requests/queries/season/detailsLg.ts';
+import seasonDetails from '@tmdb-graphql-api/test-utils/responses/themoviedb/tv/1399/seasons/1/details.json';
+import { mockFetch, polyfillFetch } from 'fetch-mocked';
+import type { FetchResponse, Getta, ShortcutProperties } from 'getta';
+import { type GraphQLResolveInfo, OperationTypeNode, parse } from 'graphql';
+import { buildEndpoint } from '../__testUtils__/helpers/buildEndpoint.ts';
+import { createRestClient } from '../__testUtils__/helpers/createRestClient.ts';
+import { SEASON } from '../constants.ts';
+import { encodeId } from '../helpers/encodeId.ts';
+import type { Context } from '../types.ts';
+import { resolveSeason } from './season.ts';
+
+polyfillFetch();
+const mockedFetch = mockFetch(jest.fn);
+
+describe('resolveSeason >', () => {
+  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
+  const setCacheMetadata = jest.fn();
+  const id = 1399;
+
+  beforeAll(() => {
+    restClient = createRestClient();
+  });
+
+  beforeEach(() => {
+    mockedFetch.mockGetOnce(buildEndpoint(SEASON_PATH, { id, number: 1 }), {
+      body: seasonDetails,
+    });
+  });
+
+  afterEach(async () => {
+    mockedFetch.mockReset();
+    await restClient.cache?.clear();
+  });
+
+  it('should return the correct season details', async () => {
+    const operationDefinition = getOperationDefinitions(parse(seasonDetailsQuery()), OperationTypeNode.QUERY)[0]!;
+    const { fieldNode } = getChildFields(operationDefinition, { name: SEASON })![0]!;
+
+    await expect(
+      resolveSeason(
+        undefined,
+        { id: encodeId({ id, seasonNumber: 1 }) },
+        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+        { fieldNodes: [fieldNode] } as unknown as GraphQLResolveInfo
+      )
+    ).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 seasonFetchMock = jest
+      .fn<(...args: PlainArray) => Promise<FetchResponse>>()
+      .mockResolvedValue({ data: { episodes: [] } } as FetchResponse<{ episodes: [] }>);
+
+    await resolveSeason(
+      undefined,
+      { id: encodeId({ id, seasonNumber: 1 }) },
+      {
+        restClient: { season: seasonFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
+        setCacheMetadata,
+        tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+      } as unknown as Context,
+      { fieldNodes: [fieldNode] } as unknown as GraphQLResolveInfo
+    );
+
+    expect(seasonFetchMock.mock.calls[0]![0]).toEqual(
+      expect.objectContaining({
+        queryParams: {
+          append_to_response: 'credits,images,videos',
+        },
+      })
+    );
+  });
+});

package/src/queries/season.ts

@@ -0,0 +1,78 @@
+import type { QuerySeasonArgs } from '@tmdb-graphql-api/schema';
+import { GraphQLError } from 'graphql';
+import 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 { encodeId } from '../helpers/encodeId.ts';
+import { getAppendToResponseKeys } from '../helpers/getAppendToResponseKeys.ts';
+import { getTvIdSeasonAndEpisode } from '../helpers/getTvIdSeasonAndEpisode.ts';
+import type { Context, RawSeason, RawSeasonWithAppendToResponse } from '../types.ts';
+
+const appendToResponse = {
+  [CAST]: CREDITS,
+  [CREW]: CREDITS,
+  [EXTERNAL_IDS]: snakeCase(EXTERNAL_IDS),
+  [POSTERS]: IMAGES,
+  [TRANSLATIONS]: TRANSLATIONS,
+  [VIDEOS]: VIDEOS,
+};
+
+const enrichEpisodeData = (obj: RawSeason) => {
+  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
+) => {
+  const typedFieldName = snakeCase(fieldName) as keyof RawSeason;
+  const { id, seasonNumber } = getTvIdSeasonAndEpisode(obj, args);
+
+  if (obj && !isUndefined(obj[typedFieldName])) {
+    return typedFieldName === 'id' ? encodeId({ id, seasonNumber }) : obj[typedFieldName];
+  }
+
+  const appendToResponseKeys = getAppendToResponseKeys(fieldNodes[0]!, appendToResponse, fragmentDefinitions);
+
+  const { data, errors, headers } = await restClient.season<RawSeasonWithAppendToResponse>(
+    {
+      pathTemplateData: { id, number: seasonNumber },
+      ...(appendToResponseKeys.length > 0
+        ? {
+            queryParams: {
+              append_to_response: appendToResponseKeys.join(','),
+            },
+          }
+        : {}),
+    },
+    { requestID, tmdbGuestSessionId }
+  );
+
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${TV} show ${id} ${SEASON} ${seasonNumber}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0],
+    });
+  }
+
+  const rawSeason = data!;
+  rawSeason.id = encodeId({ id, seasonNumber });
+
+  if (!rawSeason.tv_show_id) {
+    rawSeason.tv_show_id = id;
+  }
+
+  enrichEpisodeData(rawSeason);
+
+  if (obj) {
+    setCacheMetadata(`${SEASON}.${fieldName}`, headers);
+    return rawSeason[typedFieldName];
+  }
+
+  setCacheMetadata(SEASON, headers);
+  return appendToResponseKeys.length > 0 ? { ...rawSeason, __headers: headers } : rawSeason;
+};