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

package/src/queries/configurationTimezones.ts

@@ -1,27 +1,23 @@
-import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
 import { CONFIGURATION, TIMEZONES } from '../constants.ts';
-import { type Context, type RawConfiguration, type RawConfigurationTimezones } from '../types.ts';
+import { buildNoObjArgsResolver } from '../helpers/buildNoObjArgsResolver.ts';
+import { type RawConfiguration, type RawConfigurationTimezones } from '../types.ts';
 
-export const resolveConfigurationTimezones = async (
-  _obj: RawConfiguration,
-  _args: undefined,
-  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
-  { fieldNodes }: GraphQLResolveInfo
-) => {
-  const { data, errors, headers } = await restClient.configuration<RawConfigurationTimezones>(
-    {
-      pathTemplateData: { type: TIMEZONES },
-    },
-    { requestID, tmdbGuestSessionId }
-  );
+export const resolveConfigurationTimezones = buildNoObjArgsResolver<RawConfiguration, RawConfigurationTimezones>(
+  CONFIGURATION,
+  async ctx => {
+    const { requestID, restClient, tmdbGuestSessionId } = ctx;
 
-  if (errors?.length) {
-    throw new GraphQLError(`Failed to resolve ${CONFIGURATION} ${TIMEZONES}.`, {
-      nodes: fieldNodes,
-      originalError: errors[0],
-    });
-  }
+    const { data, errors, headers } = await restClient.configuration<RawConfigurationTimezones>(
+      {
+        pathTemplateData: { type: TIMEZONES },
+      },
+      { requestID, tmdbGuestSessionId }
+    );
 
-  setCacheMetadata(`${CONFIGURATION}.${TIMEZONES}`, headers);
-  return data;
-};
+    return {
+      data,
+      errors,
+      headers,
+    };
+  }
+);

package/src/queries/credit.test.ts

@@ -1,10 +1,10 @@
 import { jest } from '@jest/globals';
-import { CREDIT_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import { CREDIT_PATH } from '@tmdb-graphql-api/rest-client';
 import creditDetails from '@tmdb-graphql-api/test-utils/responses/themoviedb/credit/details.json';
 import { mockFetch } from 'fetch-mocked';
-import { 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 } from '../types.ts';
 import { resolveCredit } from './credit.ts';
@@ -12,13 +12,16 @@ import { resolveCredit } from './credit.ts';
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolveCredit >', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
   const id = 2;
 
-  beforeAll(() => {
-    restClient = createRestClient();
-  });
+  const context = {
+    logger: createMockLogger(jest.fn),
+    restClient: createRestClient(),
+    setCacheMetadata: jest.fn(),
+    tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+  } as unknown as Context;
+
+  const info = {} as GraphQLResolveInfo;
 
   beforeEach(() => {
     mockedFetch.mockGetOnce(buildEndpoint(CREDIT_PATH, { id }), {
@@ -28,17 +31,11 @@ describe('resolveCredit >', () => {
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   it('should return the correct credit details', async () => {
-    await expect(
-      resolveCredit(
-        undefined,
-        { id },
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
-      )
-    ).resolves.toMatchSnapshot();
+    await expect(resolveCredit(undefined, { id: String(id) }, context, info)).resolves.toMatchSnapshot();
   });
 });

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({