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

package/src/queries/credit.ts

@@ -1,14 +1,12 @@
 import { type QueryCreditArgs } from '@tmdb-graphql-api/schema/types';
-import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
 import { CREDIT } from '../constants.ts';
-import { type Context, type RawCredit } from '../types.ts';
+import { buildArgsResolver } from '../helpers/buildArgsResolver.ts';
+import { type RawCredit } from '../types.ts';
+
+export const resolveCredit = buildArgsResolver<QueryCreditArgs, RawCredit>(CREDIT, async (args, ctx) => {
+  const { id } = args;
+  const { requestID, restClient, tmdbGuestSessionId } = ctx;
 
-export const resolveCredit = async (
-  _obj: undefined,
-  { id }: QueryCreditArgs,
-  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
-  { fieldNodes }: GraphQLResolveInfo
-) => {
   const { data, errors, headers } = await restClient.credit<RawCredit>(
     {
       pathTemplateData: { id },
@@ -16,10 +14,9 @@ export const resolveCredit = async (
     { requestID, tmdbGuestSessionId }
   );
 
-  if (errors?.length) {
-    throw new GraphQLError(`Failed to resolve ${CREDIT} ${id}.`, { nodes: fieldNodes, originalError: errors[0] });
-  }
-
-  setCacheMetadata(CREDIT, headers);
-  return data;
-};
+  return {
+    data,
+    errors,
+    headers,
+  };
+});

package/src/queries/discoverMovies.test.ts

@@ -1,17 +1,17 @@
 import { removeConnectionInputOptions } from '@graphql-box/connection-resolver';
 import { type PlainObject } from '@graphql-box/core';
 import { jest } from '@jest/globals';
-import { DISCOVER_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import { DISCOVER_PATH } from '@tmdb-graphql-api/rest-client';
 import { type MovieSortBy } from '@tmdb-graphql-api/schema/types';
 import discoverMovies2010 from '@tmdb-graphql-api/test-utils/responses/themoviedb/discoverMovies/2010.json';
 import discoverMovies2020 from '@tmdb-graphql-api/test-utils/responses/themoviedb/discoverMovies/2020.json';
 import { type Jsonifiable, mockFetch } from 'fetch-mocked';
-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 { DISCOVER_MOVIES } from '../constants.ts';
+import { DISCOVER_MOVIES, MOVIE } from '../constants.ts';
 import { formatQueryParams } from '../helpers/formatQueryParams.ts';
 import { removeNullValues } from '../helpers/removeNullValues.ts';
 import { type Context } from '../types.ts';
@@ -49,24 +49,24 @@ describe('createMakeCursors', () => {
 });
 
 describe('createResourceResolver', () => {
-  const restClient = {
-    discover: jest.fn().mockReturnValue({}),
-  } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>;
+  const context = {
+    logger: createMockLogger(jest.fn),
+    restClient: {
+      discover: jest.fn().mockReturnValue({}),
+    },
+    setCacheMetadata: jest.fn(),
+    tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+  } as unknown as Context;
 
-  const setCacheMetadata = jest.fn();
+  const info = {} as GraphQLResolveInfo;
 
   it('when `restClient.discover` is called', async () => {
-    const resourceResolver = createResourceResolver(undefined, baseArgs, {
-      restClient,
-      setCacheMetadata,
-      tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-    } as unknown as Context);
-
+    const resourceResolver = createResourceResolver(undefined, baseArgs, context, info);
     await resourceResolver({ page: 1 });
 
-    expect(restClient.discover).toHaveBeenCalledWith(
+    expect(context.restClient.discover).toHaveBeenCalledWith(
       {
-        pathTemplateData: { type: 'movie' },
+        pathTemplateData: { type: MOVIE },
         queryParams: {
           include_adult: false,
           include_video: false,
@@ -82,9 +82,15 @@ describe('createResourceResolver', () => {
 });
 
 describe('resolveDiscoverMovies', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
-  const type = 'movie';
+  const context = {
+    logger: createMockLogger(jest.fn),
+    restClient: createRestClient(),
+    setCacheMetadata: jest.fn(),
+    tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+  } as unknown as Context;
+
+  const info = {} as GraphQLResolveInfo;
+  const type = MOVIE;
 
   const mockEndpoint = (args: PlainObject, page: number, body: Jsonifiable) => {
     mockedFetch.mockGetOnce(buildEndpoint(DISCOVER_PATH, { type }, { ...formatQueryParams(args), page }), {
@@ -93,10 +99,6 @@ describe('resolveDiscoverMovies', () => {
     });
   };
 
-  beforeAll(() => {
-    restClient = createRestClient();
-  });
-
   beforeEach(() => {
     mockEndpoint(baseArgs, 1, discoverMovies2020);
     mockEndpoint({ ...baseArgs, primaryReleaseYear: 2010 }, 1, discoverMovies2010);
@@ -104,58 +106,33 @@ describe('resolveDiscoverMovies', () => {
 
   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(
-        resolveDiscoverMovies(
-          undefined,
-          { ...baseArgs, first: 5 },
-          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-          {} as GraphQLResolveInfo
-        )
+        resolveDiscoverMovies(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 resolveDiscoverMovies(
-        undefined,
-        { ...baseArgs, first: 5 },
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
-      );
+      const { pageInfo } = await resolveDiscoverMovies(undefined, { ...baseArgs, first: 5 }, context, info);
 
       await expect(
-        resolveDiscoverMovies(
-          undefined,
-          { ...baseArgs, after: pageInfo.endCursor, first: 5 },
-          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-          {} as GraphQLResolveInfo
-        )
+        resolveDiscoverMovies(undefined, { ...baseArgs, after: pageInfo.endCursor, first: 5 }, context, info)
       ).resolves.toMatchSnapshot();
     });
   });
 
   describe('when the first 5 are requested twice', () => {
     beforeEach(async () => {
-      await resolveDiscoverMovies(
-        undefined,
-        { ...baseArgs, first: 5 },
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
-      );
-
-      await resolveDiscoverMovies(
-        undefined,
-        { ...baseArgs, first: 5 },
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
-      );
+      await resolveDiscoverMovies(undefined, { ...baseArgs, first: 5 }, context, info);
+      await resolveDiscoverMovies(undefined, { ...baseArgs, first: 5 }, context, info);
     });
 
     it('should only request the resource from the server once', () => {
@@ -165,33 +142,10 @@ describe('resolveDiscoverMovies', () => {
 
   describe('when the first 5 are requested with different args twice', () => {
     beforeEach(async () => {
-      await resolveDiscoverMovies(
-        undefined,
-        { ...baseArgs, first: 5 },
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
-      );
-
-      await resolveDiscoverMovies(
-        undefined,
-        { ...baseArgs, first: 5 },
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
-      );
-
-      await resolveDiscoverMovies(
-        undefined,
-        { ...baseArgs, first: 5, primaryReleaseYear: 2010 },
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
-      );
-
-      await resolveDiscoverMovies(
-        undefined,
-        { ...baseArgs, first: 5, primaryReleaseYear: 2010 },
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
-      );
+      await resolveDiscoverMovies(undefined, { ...baseArgs, first: 5 }, context, info);
+      await resolveDiscoverMovies(undefined, { ...baseArgs, first: 5 }, context, info);
+      await resolveDiscoverMovies(undefined, { ...baseArgs, first: 5, primaryReleaseYear: 2010 }, context, info);
+      await resolveDiscoverMovies(undefined, { ...baseArgs, first: 5, primaryReleaseYear: 2010 }, context, info);
     });
 
     it('should request each resource from the server once', () => {

package/src/queries/discoverMovies.ts

@@ -1,7 +1,12 @@
 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 QueryDiscoverMoviesArgs } from '@tmdb-graphql-api/schema/types';
 import { encode } from 'js-base64';
 import { DISCOVER_MOVIES, MOVIE } from '../constants.ts';
@@ -20,14 +25,15 @@ export const createMakeCursors = (_obj: undefined, args: QueryDiscoverMoviesArgs
   };
 };
 
-export const createResourceResolver =
-  (
-    _obj: undefined,
-    args: QueryDiscoverMoviesArgs,
-    { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context
-  ) =>
-  async ({ page }: { page: number }) => {
-    const result = await restClient.discover<RawDiscoverMovies>(
+export const createResourceResolver: CreateResourceResolver<
+  undefined,
+  QueryDiscoverMoviesArgs,
+  Context,
+  RawDiscoverMovies
+> =
+  (_obj, args, { requestID, restClient, tmdbGuestSessionId }) =>
+  async ({ page }) =>
+    restClient.discover<RawDiscoverMovies>(
       {
         pathTemplateData: { type: MOVIE },
         queryParams: { ...formatQueryParams(args), page },
@@ -35,13 +41,6 @@ export const createResourceResolver =
       { requestID, tmdbGuestSessionId }
     );
 
-    if (result.data) {
-      setCacheMetadata(DISCOVER_MOVIES, result.headers);
-    }
-
-    return result;
-  };
-
 export const cursorCache = new Core({
   name: 'DISCOVER_MOVIES_CONNECTION_RESOLVER',
   reaper: reaper({ interval: 300_000 }),
@@ -50,10 +49,12 @@ export const cursorCache = new Core({
 });
 
 export const getters: Getters<RawDiscoverMovies, RawMovie> = {
-  nodes: ({ results }) => results,
-  page: ({ page }) => page,
-  totalPages: ({ total_pages }) => total_pages,
-  totalResults: ({ total_results }) => total_results,
+  // @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 resolveDiscoverMovies = makeConnectionResolver({

package/src/queries/discoverTv.test.ts

@@ -1,16 +1,16 @@
 import { removeConnectionInputOptions } from '@graphql-box/connection-resolver';
 import { type PlainObject } from '@graphql-box/core';
 import { jest } from '@jest/globals';
-import { DISCOVER_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import { DISCOVER_PATH } from '@tmdb-graphql-api/rest-client';
 import { type TvSortBy } from '@tmdb-graphql-api/schema/types';
 import discoverTv2020 from '@tmdb-graphql-api/test-utils/responses/themoviedb/discoverTv/2020.json';
 import { type Jsonifiable, mockFetch } from 'fetch-mocked';
-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 { DISCOVER_TV } from '../constants.ts';
+import { DISCOVER_TV, TV } from '../constants.ts';
 import { formatQueryParams } from '../helpers/formatQueryParams.ts';
 import { removeNullValues } from '../helpers/removeNullValues.ts';
 import { type Context } from '../types.ts';
@@ -47,24 +47,24 @@ describe('createMakeCursors', () => {
 });
 
 describe('createResourceResolver', () => {
-  const restClient = {
-    discover: jest.fn().mockReturnValue({}),
-  } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>;
+  const context = {
+    logger: createMockLogger(jest.fn),
+    restClient: {
+      discover: jest.fn().mockReturnValue({}),
+    },
+    setCacheMetadata: jest.fn(),
+    tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+  } as unknown as Context;
 
-  const setCacheMetadata = jest.fn();
+  const info = {} as GraphQLResolveInfo;
 
   it('when `restClient.discover` is called', async () => {
-    const resourceResolver = createResourceResolver(undefined, baseArgs, {
-      restClient,
-      setCacheMetadata,
-      tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-    } as unknown as Context);
-
+    const resourceResolver = createResourceResolver(undefined, baseArgs, context, info);
     await resourceResolver({ page: 1 });
 
-    expect(restClient.discover).toHaveBeenCalledWith(
+    expect(context.restClient.discover).toHaveBeenCalledWith(
       {
-        pathTemplateData: { type: 'tv' },
+        pathTemplateData: { type: TV },
         queryParams: {
           'first_air_date.gte': '2020',
           include_null_first_air_dates: false,
@@ -81,9 +81,15 @@ describe('createResourceResolver', () => {
 });
 
 describe('resolveDiscoverTv', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
-  const type = 'tv';
+  const context = {
+    logger: createMockLogger(jest.fn),
+    restClient: createRestClient(),
+    setCacheMetadata: jest.fn(),
+    tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+  } as unknown as Context;
+
+  const info = {} as GraphQLResolveInfo;
+  const type = TV;
 
   const mockEndpoint = (args: PlainObject, page: number, body: Jsonifiable) => {
     mockedFetch.mockGetOnce(buildEndpoint(DISCOVER_PATH, { type }, { ...formatQueryParams(args), page }), {
@@ -92,49 +98,29 @@ describe('resolveDiscoverTv', () => {
     });
   };
 
-  beforeAll(() => {
-    restClient = createRestClient();
-  });
-
   beforeEach(() => {
     mockEndpoint(baseArgs, 1, discoverTv2020);
   });
 
   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(
-        resolveDiscoverTv(
-          undefined,
-          { ...baseArgs, first: 5 },
-          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-          {} as GraphQLResolveInfo
-        )
-      ).resolves.toMatchSnapshot();
+      await expect(resolveDiscoverTv(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 resolveDiscoverTv(
-        undefined,
-        { ...baseArgs, first: 5 },
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
-      );
+      const { pageInfo } = await resolveDiscoverTv(undefined, { ...baseArgs, first: 5 }, context, info);
 
       await expect(
-        resolveDiscoverTv(
-          undefined,
-          { ...baseArgs, after: pageInfo.endCursor, first: 5 },
-          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-          {} as GraphQLResolveInfo
-        )
+        resolveDiscoverTv(undefined, { ...baseArgs, after: pageInfo.endCursor, first: 5 }, context, info)
       ).resolves.toMatchSnapshot();
     });
   });

package/src/queries/discoverTv.ts

@@ -1,7 +1,12 @@
 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 QueryDiscoverTvArgs } from '@tmdb-graphql-api/schema/types';
 import { encode } from 'js-base64';
 import { DISCOVER_TV, TV } from '../constants.ts';
@@ -20,29 +25,17 @@ export const createMakeCursors = (_obj: undefined, args: QueryDiscoverTvArgs) =>
   };
 };
 
-export const createResourceResolver =
-  (
-    _obj: undefined,
-    args: QueryDiscoverTvArgs,
-    { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context
-  ) =>
-  async ({ page }: { page: number }) => {
-    const result = await restClient.discover<RawDiscoverTv>(
+export const createResourceResolver: CreateResourceResolver<undefined, QueryDiscoverTvArgs, Context, RawDiscoverTv> =
+  (_obj, args, { requestID, restClient, tmdbGuestSessionId }) =>
+  async ({ page }) =>
+    restClient.discover<RawDiscoverTv>(
       {
         pathTemplateData: { type: TV },
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         queryParams: { ...formatQueryParams(args), page },
       },
       { requestID, tmdbGuestSessionId }
     );
 
-    if (result.data) {
-      setCacheMetadata(DISCOVER_TV, result.headers);
-    }
-
-    return result;
-  };
-
 export const cursorCache = new Core({
   name: 'DISCOVER_TV_CONNECTION_RESOLVER',
   reaper: reaper({ interval: 300_000 }),
@@ -51,10 +44,12 @@ export const cursorCache = new Core({
 });
 
 export const getters: Getters<RawDiscoverTv, RawTv> = {
-  nodes: ({ results }) => results,
-  page: ({ page }) => page,
-  totalPages: ({ total_pages }) => total_pages,
-  totalResults: ({ total_results }) => total_results,
+  // @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 resolveDiscoverTv = makeConnectionResolver({

package/src/queries/episode.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 { EPISODE } from '../constants.ts';
 import { encodeId } from '../helpers/encodeId.ts';
@@ -18,13 +19,14 @@ import { resolveEpisode } from './episode.ts';
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolveEpisode >', () => {
-  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(EPISODE_PATH, { episodeNumber: 1, id, seasonNumber: 1 }), {
@@ -34,26 +36,24 @@ describe('resolveEpisode >', () => {
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   it('should return the correct episode details', async () => {
     const operationDefinition = getOperationDefinitions(parse(episodeDetailsQuery()), OperationTypeNode.QUERY)[0]!;
     const { fieldNode } = getChildFields(operationDefinition, { name: EPISODE })![0]!;
+    const info = { fieldNodes: [fieldNode] } as unknown as GraphQLResolveInfo;
 
     await expect(
-      resolveEpisode(
-        undefined,
-        { id: encodeId({ episodeNumber: 1, id, seasonNumber: 1 }) },
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        { fieldNodes: [fieldNode] } as unknown as GraphQLResolveInfo
-      )
+      resolveEpisode(undefined, { id: encodeId({ episodeNumber: 1, 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(episodeDetailsLgQuery()), OperationTypeNode.QUERY)[0]!;
     const { fieldNode } = getChildFields(operationDefinition, { name: EPISODE })![0]!;
+    const info = { fieldNodes: [fieldNode] } as unknown as GraphQLResolveInfo;
 
     const episodeFetchMock = jest
       .fn<(...args: PlainArray) => Promise<FetchResponse>>()
@@ -63,11 +63,10 @@ describe('resolveEpisode >', () => {
       undefined,
       { id: encodeId({ episodeNumber: 1, id, seasonNumber: 1 }) },
       {
+        ...context,
         restClient: { episode: episodeFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-        setCacheMetadata,
-        tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-      } as unknown as Context,
-      { fieldNodes: [fieldNode] } as unknown as GraphQLResolveInfo
+      },
+      info
     );
 
     expect(episodeFetchMock.mock.calls[0]![0]).toEqual(

package/src/queries/episode.ts

@@ -1,11 +1,11 @@
 import { type QueryEpisodeArgs } from '@tmdb-graphql-api/schema/types';
-import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
 import { isUndefined, snakeCase } from 'lodash-es';
-import { CREDITS, EPISODE, EXTERNAL_IDS, IMAGES, SEASON, TRANSLATIONS, TV, VIDEOS } from '../constants.ts';
+import { CREDITS, EPISODE, EXTERNAL_IDS, IMAGES, 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 RawEpisode, type RawEpisodeWithAppendToResponse } from '../types.ts';
+import { type EnrichedRawEpisode, type EnrichedRawEpisodeWithAppendToResponse, type RawEpisode } from '../types.ts';
 
 const appendToResponse = {
   [EXTERNAL_IDS]: snakeCase(EXTERNAL_IDS),
@@ -17,24 +17,30 @@ const appendToResponse = {
   stills: IMAGES,
 };
 
-export const resolveEpisode = async (
-  obj: RawEpisode | undefined,
-  args: QueryEpisodeArgs,
-  { fragmentDefinitions, requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
-  { fieldName, fieldNodes }: GraphQLResolveInfo
-) => {
+export const resolveEpisode = buildObjArgsResolver<
+  EnrichedRawEpisode,
+  QueryEpisodeArgs,
+  | (EnrichedRawEpisodeWithAppendToResponse & { __headers?: Headers })
+  | EnrichedRawEpisodeWithAppendToResponse[keyof EnrichedRawEpisodeWithAppendToResponse]
+>(EPISODE, async (obj, args, ctx, info) => {
+  const { fragmentDefinitions, requestID, restClient, tmdbGuestSessionId } = ctx;
+  const { fieldName, fieldNodes } = info;
   const typedFieldName = snakeCase(fieldName) as keyof RawEpisode;
   const { episodeNumber, id, seasonNumber } = getTvIdSeasonAndEpisode(obj, args);
 
   if (obj && !isUndefined(obj[typedFieldName])) {
-    return typedFieldName === 'id'
-      ? encodeId({ id, seasonNumber, ...(episodeNumber ? { episodeNumber } : {}) })
-      : obj[typedFieldName];
+    return {
+      data:
+        typedFieldName === 'id'
+          ? encodeId({ id, seasonNumber, ...(episodeNumber ? { episodeNumber } : {}) })
+          : obj[typedFieldName],
+      source: 'parentNode',
+    };
   }
 
   const appendToResponseKeys = getAppendToResponseKeys(fieldNodes[0]!, appendToResponse, fragmentDefinitions);
 
-  const { data, errors, headers } = await restClient.episode<RawEpisodeWithAppendToResponse>(
+  const { data, errors, headers } = await restClient.episode<EnrichedRawEpisodeWithAppendToResponse>(
     {
       pathTemplateData: { episodeNumber, id, seasonNumber },
       ...(appendToResponseKeys.length > 0
@@ -48,25 +54,19 @@ export const resolveEpisode = async (
     { requestID, tmdbGuestSessionId }
   );
 
-  if (errors?.length) {
-    throw new GraphQLError(
-      `Failed to resolve ${TV} show ${id} ${SEASON} ${seasonNumber} ${EPISODE} ${episodeNumber!}.`,
-      { nodes: fieldNodes, originalError: errors[0] }
-    );
-  }
-
-  const rawEpisode = data!;
-  rawEpisode.id = encodeId({ id, seasonNumber, ...(episodeNumber ? { episodeNumber } : {}) });
-
-  if (!rawEpisode.tv_show_id) {
-    rawEpisode.tv_show_id = id;
-  }
+  const episodeData = {
+    ...data,
+    id: encodeId({ id, seasonNumber, ...(episodeNumber ? { episodeNumber } : {}) }),
+    tv_show_id: Number(id),
+  };
 
-  if (obj) {
-    setCacheMetadata(`${EPISODE}.${fieldName}`, headers);
-    return rawEpisode[typedFieldName];
-  }
-
-  setCacheMetadata(EPISODE, headers);
-  return appendToResponseKeys.length > 0 ? { ...rawEpisode, __headers: headers } : rawEpisode;
-};
+  return {
+    data: obj
+      ? episodeData[typedFieldName]
+      : appendToResponseKeys.length > 0
+      ? { ...episodeData, __headers: headers }
+      : episodeData,
+    errors,
+    headers,
+  };
+});