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

package/src/queries/personTranslations.ts

@@ -1,16 +1,23 @@
-import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
 import { PERSON, TRANSLATIONS } from '../constants.ts';
-import { type Context, type RawPersonTranslations, type RawPersonWithAppendToResponse } from '../types.ts';
+import { buildObjResolver } from '../helpers/buildObjResolver.ts';
+import { type RawPerson, type RawPersonTranslations, type RawPersonWithAppendToResponse } from '../types.ts';
 
-export const resolvePersonTranslations = async (
-  obj: RawPersonWithAppendToResponse & { __headers?: Headers },
-  _args: undefined,
-  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
-  { fieldNodes }: GraphQLResolveInfo
-) => {
-  if (obj.translations && obj.__headers) {
-    setCacheMetadata(`${PERSON}.${TRANSLATIONS}`, obj.__headers);
-    return obj.translations.translations;
+const isRawPersonWithTranslations = (
+  obj: RawPerson | (RawPersonWithAppendToResponse & { __headers?: Headers })
+): obj is RawPersonWithAppendToResponse & { __headers: Headers } => TRANSLATIONS in obj && '__headers' in obj;
+
+export const resolvePersonTranslations = buildObjResolver<
+  RawPerson | (RawPersonWithAppendToResponse & { __headers?: Headers }),
+  RawPersonTranslations['translations']
+>(PERSON, async (obj, ctx) => {
+  const { requestID, restClient, tmdbGuestSessionId } = ctx;
+
+  if (isRawPersonWithTranslations(obj)) {
+    return {
+      data: obj.translations?.translations,
+      headers: obj.__headers,
+      source: 'parentNode',
+    };
   }
 
   const { data, errors, headers } = await restClient.person<RawPersonTranslations>(
@@ -20,13 +27,9 @@ export const resolvePersonTranslations = async (
     { requestID, tmdbGuestSessionId }
   );
 
-  if (errors?.length) {
-    throw new GraphQLError(`Failed to resolve ${PERSON} ${obj.id} ${TRANSLATIONS}.`, {
-      nodes: fieldNodes,
-      originalError: errors[0],
-    });
-  }
-
-  setCacheMetadata(`${PERSON}.${TRANSLATIONS}`, headers);
-  return data?.translations;
-};
+  return {
+    data: data?.translations,
+    errors,
+    headers,
+  };
+});

package/src/queries/personTvCredits.test.ts

@@ -6,42 +6,42 @@ import personTvCredits from '@tmdb-graphql-api/test-utils/responses/themoviedb/p
 import { mockFetch } from 'fetch-mocked';
 import { type FetchResponse, type Getta, type ShortcutProperties } from 'getta';
 import { type GraphQLResolveInfo } from 'graphql';
+import { snakeCase } from 'lodash-es';
 import { buildEndpoint } from '../__testUtils__/helpers/buildEndpoint.ts';
+import { createMockLogger } from '../__testUtils__/helpers/createMockLogger.ts';
 import { createRestClient } from '../__testUtils__/helpers/createRestClient.ts';
-import { type Context, type RawPersonWithAppendToResponse } from '../types.ts';
+import { TV_CREDITS } from '../constants.ts';
+import { type Context } from '../types.ts';
 import { resolvePersonTvCredits } from './personTvCredits.ts';
 
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolvePersonTvCredits >', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
   const personId = 3;
 
-  beforeAll(() => {
-    restClient = createRestClient();
-  });
+  const context = {
+    logger: createMockLogger(jest.fn),
+    restClient: createRestClient(),
+    setCacheMetadata: jest.fn(),
+    tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+  } as unknown as Context;
+
+  const info = { fieldName: TV_CREDITS } as GraphQLResolveInfo;
 
   beforeEach(() => {
-    mockedFetch.mockGetOnce(buildEndpoint(PERSON_PATH, { id: personId, type: 'tv_credits' }), {
+    mockedFetch.mockGetOnce(buildEndpoint(PERSON_PATH, { id: personId, type: snakeCase(TV_CREDITS) }), {
       body: personTvCredits,
     });
   });
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   it('should return the person tv credits', async () => {
-    await expect(
-      resolvePersonTvCredits(
-        personDetails,
-        undefined,
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
-      )
-    ).resolves.toMatchSnapshot();
+    await expect(resolvePersonTvCredits(personDetails, undefined, context, info)).resolves.toMatchSnapshot();
   });
 
   describe('when raw person data has tv credits', () => {
@@ -57,15 +57,15 @@ describe('resolvePersonTvCredits >', () => {
           {
             ...personDetails,
             __headers: new Headers(),
+            // @ts-expect-error minor type mismatch
             tv_credits: rest,
-          } as unknown as RawPersonWithAppendToResponse,
+          },
           undefined,
           {
-            restClient: { person: personFetchMock },
-            setCacheMetadata,
-            tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-          } as unknown as Context,
-          {} as GraphQLResolveInfo
+            ...context,
+            restClient: { person: personFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
+          },
+          info
         )
       ).resolves.toMatchSnapshot();
     });
@@ -81,15 +81,15 @@ describe('resolvePersonTvCredits >', () => {
         {
           ...personDetails,
           __headers: new Headers(),
+          // @ts-expect-error minor type mismatch
           tv_credits: rest,
-        } as unknown as RawPersonWithAppendToResponse,
+        },
         undefined,
         {
-          restClient: { person: personFetchMock },
-          setCacheMetadata,
-          tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-        } as unknown as Context,
-        {} as GraphQLResolveInfo
+          ...context,
+          restClient: { person: personFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
+        },
+        info
       );
 
       expect(personFetchMock).not.toHaveBeenCalled();

package/src/queries/personTvCredits.ts

@@ -1,17 +1,25 @@
-import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
 import { snakeCase } from 'lodash-es';
+import type { Except } from 'type-fest';
 import { PERSON, TV_CREDITS } from '../constants.ts';
-import { type Context, type RawPersonTvCredits, type RawPersonWithAppendToResponse } from '../types.ts';
+import { buildObjResolver } from '../helpers/buildObjResolver.ts';
+import { type RawPerson, type RawPersonTvCredits, type RawPersonWithAppendToResponse } from '../types.ts';
 
-export const resolvePersonTvCredits = async (
-  obj: RawPersonWithAppendToResponse & { __headers?: Headers },
-  _args: undefined,
-  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
-  { fieldNodes }: GraphQLResolveInfo
-) => {
-  if (obj.tv_credits && obj.__headers) {
-    setCacheMetadata(`${PERSON}.${TV_CREDITS}`, obj.__headers);
-    return obj.tv_credits;
+const isRawPersonWithTvCredits = (
+  obj: RawPerson | (RawPersonWithAppendToResponse & { __headers?: Headers })
+): obj is RawPersonWithAppendToResponse & { __headers: Headers } => snakeCase(TV_CREDITS) in obj && '__headers' in obj;
+
+export const resolvePersonTvCredits = buildObjResolver<
+  RawPerson | (RawPersonWithAppendToResponse & { __headers?: Headers }),
+  Except<RawPersonTvCredits, 'id'>
+>(PERSON, async (obj, ctx) => {
+  const { requestID, restClient, tmdbGuestSessionId } = ctx;
+
+  if (isRawPersonWithTvCredits(obj)) {
+    return {
+      data: obj.tv_credits,
+      headers: obj.__headers,
+      source: 'parentNode',
+    };
   }
 
   const { data, errors, headers } = await restClient.person<RawPersonTvCredits>(
@@ -21,14 +29,11 @@ export const resolvePersonTvCredits = async (
     { requestID, tmdbGuestSessionId }
   );
 
-  if (errors?.length) {
-    throw new GraphQLError(`Failed to resolve ${PERSON} ${obj.id} ${TV_CREDITS}.`, {
-      nodes: fieldNodes,
-      originalError: errors[0],
-    });
-  }
+  const { id: personId, ...rest } = data ?? {};
 
-  setCacheMetadata(`${PERSON}.${TV_CREDITS}`, headers);
-  const { id: personId, ...rest } = data!;
-  return rest;
-};
+  return {
+    data: rest,
+    errors,
+    headers,
+  };
+});

package/src/queries/rated.test.ts

@@ -1,5 +1,4 @@
 import { removeConnectionInputOptions } from '@graphql-box/connection-resolver';
-import { type PlainObject } from '@graphql-box/core';
 import { jest } from '@jest/globals';
 import { RATED_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
 import { ScreenType } from '@tmdb-graphql-api/schema/types';
@@ -10,8 +9,9 @@ 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 { RATED } from '../constants.ts';
+import { MOVIE, RATED } from '../constants.ts';
 import { type Context } from '../types.ts';
 import { createMakeCursors, createResourceResolver, cursorCache, resolveRated } from './rated.ts';
 
@@ -21,6 +21,15 @@ const baseArgs = {
   screenType: ScreenType.Movie,
 };
 
+const context = {
+  logger: createMockLogger(jest.fn),
+  restClient: createRestClient(),
+  setCacheMetadata: jest.fn(),
+  tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+} as unknown as Context;
+
+const info = {} as GraphQLResolveInfo;
+
 describe('createMakeCursors', () => {
   const GROUP_CURSOR = `${JSON.stringify(removeConnectionInputOptions(baseArgs))}::${RATED}`;
 
@@ -43,21 +52,22 @@ describe('createResourceResolver', () => {
     rated: jest.fn().mockReturnValue({}),
   } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>;
 
-  const setCacheMetadata = jest.fn();
-  const tmdbGuestSessionId = 'mock-tmdbGuestSessionId';
-
   it('when `restClient.rated` is called', async () => {
-    const resourceResolver = createResourceResolver(undefined, baseArgs, {
-      restClient,
-      setCacheMetadata,
-      tmdbGuestSessionId,
-    } as unknown as Context);
+    const resourceResolver = createResourceResolver(
+      undefined,
+      baseArgs,
+      {
+        ...context,
+        restClient,
+      },
+      info
+    );
 
     await resourceResolver({ page: 1 });
 
     expect(restClient.rated).toHaveBeenCalledWith(
       {
-        pathTemplateData: { id: tmdbGuestSessionId, type: 'movie' },
+        pathTemplateData: { id: context.tmdbGuestSessionId, type: MOVIE },
         queryParams: {
           page: 1,
         },
@@ -68,13 +78,9 @@ describe('createResourceResolver', () => {
 });
 
 describe('resolveRated', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
-  const tmdbGuestSessionId = 'mock-tmdbGuestSessionId';
-
-  const mockEndpoint = ({ screenType }: PlainObject, page: number, body: Jsonifiable) => {
+  const mockEndpoint = ({ screenType }: { screenType: ScreenType }, page: number, body: Jsonifiable) => {
     mockedFetch.mockGetOnce(
-      buildEndpoint(RATED_PATH, { id: tmdbGuestSessionId, type: (screenType as string).toLowerCase() }, { page }),
+      buildEndpoint(RATED_PATH, { id: context.tmdbGuestSessionId, type: screenType.toLowerCase() }, { page }),
       {
         body,
         headers: { 'cache-control': 'public, max-age=6000' },
@@ -82,88 +88,46 @@ describe('resolveRated', () => {
     );
   };
 
-  beforeAll(() => {
-    restClient = createRestClient();
-  });
-
   beforeEach(() => {
     mockEndpoint(baseArgs, 1, ratedMovies);
-    mockEndpoint({ screenType: 'TV' }, 1, ratedTv);
+    mockEndpoint({ screenType: ScreenType.Tv }, 1, ratedTv);
   });
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
     await cursorCache.clear();
+    jest.clearAllMocks();
   });
 
   describe('when the first 5 movies are requested', () => {
     it('should return the correct response', async () => {
-      await expect(
-        resolveRated(
-          undefined,
-          { ...baseArgs, first: 5 },
-          { restClient, setCacheMetadata, tmdbGuestSessionId } as unknown as Context,
-          {} as GraphQLResolveInfo
-        )
-      ).resolves.toMatchSnapshot();
+      await expect(resolveRated(undefined, { ...baseArgs, first: 5 }, context, info)).resolves.toMatchSnapshot();
     });
   });
 
   describe('when the second 5 movies are requested', () => {
     it('should return the correct response', async () => {
-      const { pageInfo } = await resolveRated(
-        undefined,
-        { ...baseArgs, first: 5 },
-        { restClient, setCacheMetadata, tmdbGuestSessionId } as unknown as Context,
-        {} as GraphQLResolveInfo
-      );
+      const { pageInfo } = await resolveRated(undefined, { ...baseArgs, first: 5 }, context, info);
 
       await expect(
-        resolveRated(
-          undefined,
-          { ...baseArgs, after: pageInfo.endCursor, first: 5 },
-          { restClient, setCacheMetadata, tmdbGuestSessionId } as unknown as Context,
-          {} as GraphQLResolveInfo
-        )
+        resolveRated(undefined, { ...baseArgs, after: pageInfo.endCursor, first: 5 }, context, info)
       ).resolves.toMatchSnapshot();
     });
   });
 
   describe('when the first 5 TV shows are requested after the first 5 movies', () => {
     it('should return the correct response', async () => {
-      await resolveRated(
-        undefined,
-        { ...baseArgs, first: 5 },
-        { restClient, setCacheMetadata, tmdbGuestSessionId } as unknown as Context,
-        {} as GraphQLResolveInfo
-      );
+      await resolveRated(undefined, { ...baseArgs, first: 5 }, context, info);
 
       await expect(
-        resolveRated(
-          undefined,
-          { first: 5, screenType: ScreenType.Tv },
-          { restClient, setCacheMetadata, tmdbGuestSessionId } as unknown as Context,
-          {} as GraphQLResolveInfo
-        )
+        resolveRated(undefined, { first: 5, screenType: ScreenType.Tv }, context, info)
       ).resolves.toMatchSnapshot();
     });
 
     it('should request both resources from the server', async () => {
-      await resolveRated(
-        undefined,
-        { ...baseArgs, first: 5 },
-        { restClient, setCacheMetadata, tmdbGuestSessionId } as unknown as Context,
-        {} as GraphQLResolveInfo
-      );
-
-      await resolveRated(
-        undefined,
-        { first: 5, screenType: ScreenType.Tv },
-        { restClient, setCacheMetadata, tmdbGuestSessionId } as unknown as Context,
-        {} as GraphQLResolveInfo
-      );
-
+      await resolveRated(undefined, { ...baseArgs, first: 5 }, context, info);
+      await resolveRated(undefined, { first: 5, screenType: ScreenType.Tv }, context, info);
       expect(mockedFetch).toHaveBeenCalledTimes(2);
     });
   });

package/src/queries/rated.ts

@@ -1,12 +1,17 @@
 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 QueryRatedArgs, type ScreenType } from '@tmdb-graphql-api/schema/types';
 import { encode } from 'js-base64';
 import { capitalize } from 'lodash-es';
 import { RATED } from '../constants.ts';
-import { type Context, type RawRated, type RawRatedScreen } from '../types.ts';
+import { type Context, type RawMovie, type RawRated, type RawTv } from '../types.ts';
 
 /* eslint-disable camelcase */
 
@@ -19,14 +24,10 @@ export const createMakeCursors = (_obj: undefined, args: QueryRatedArgs) => {
   };
 };
 
-export const createResourceResolver =
-  (
-    _obj: undefined,
-    { screenType }: QueryRatedArgs,
-    { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context
-  ) =>
+export const createResourceResolver: CreateResourceResolver<undefined, QueryRatedArgs, Context, RawRated> =
+  (_obj, { screenType }: QueryRatedArgs, { requestID, restClient, tmdbGuestSessionId }: Context) =>
   async ({ page }: { page: number }) => {
-    const result = await restClient.rated<RawRated>(
+    const { data, errors, headers } = await restClient.rated<RawRated>(
       {
         pathTemplateData: { id: tmdbGuestSessionId, type: screenType.toLowerCase() },
         queryParams: { page },
@@ -34,17 +35,25 @@ export const createResourceResolver =
       { requestID, tmdbGuestSessionId }
     );
 
-    if (!result.data) {
-      return result;
+    if (!data) {
+      return {
+        errors,
+        headers,
+      };
     }
 
-    result.data.results = result.data.results.map(entry => {
-      entry.media_type = capitalize(entry.media_type ?? screenType) as ScreenType;
+    data.results = data.results?.map(entry => {
+      // @ts-expect-error required for type resolver
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+      entry.media_type = capitalize(entry.media_type ?? screenType.toLowerCase());
       return entry;
     });
 
-    setCacheMetadata(RATED, result.headers);
-    return result;
+    return {
+      data,
+      errors,
+      headers,
+    };
   };
 
 export const cursorCache = new Core({
@@ -54,11 +63,13 @@ export const cursorCache = new Core({
   type: 'GRAPHQL',
 });
 
-export const getters: Getters<RawRated, RawRatedScreen & { media_type?: 'MOVIE' | 'TV' }> = {
-  nodes: ({ results }) => results,
-  page: ({ page }) => page,
-  totalPages: ({ total_pages }) => total_pages,
-  totalResults: ({ total_results }) => total_results,
+export const getters: Getters<RawRated, (RawMovie | RawTv) & { media_type?: Capitalize<Lowercase<ScreenType>> }> = {
+  // @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 resolveRated = makeConnectionResolver({

package/src/queries/review.test.ts

@@ -1,10 +1,10 @@
 import { jest } from '@jest/globals';
-import { REVIEW_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import { REVIEW_PATH } from '@tmdb-graphql-api/rest-client';
 import reviewDetails from '@tmdb-graphql-api/test-utils/responses/themoviedb/review/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 { resolveReview } from './review.ts';
@@ -12,13 +12,16 @@ import { resolveReview } from './review.ts';
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolveReview >', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
   const id = '58a4ee0ac3a3684ef80000e3';
 
-  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(REVIEW_PATH, { id }), {
@@ -28,17 +31,11 @@ describe('resolveReview >', () => {
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   it('should return the correct review details', async () => {
-    await expect(
-      resolveReview(
-        undefined,
-        { id },
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
-      )
-    ).resolves.toMatchSnapshot();
+    await expect(resolveReview(undefined, { id }, context, info)).resolves.toMatchSnapshot();
   });
 });

package/src/queries/review.ts

@@ -1,39 +1,35 @@
 import { type QueryReviewArgs } from '@tmdb-graphql-api/schema/types';
-import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
 import { isUndefined, snakeCase } from 'lodash-es';
 import { REVIEW } from '../constants.ts';
-import { type Context, type RawReview } from '../types.ts';
+import { buildObjArgsResolver } from '../helpers/buildObjArgsResolver.ts';
+import { type RawReview } from '../types.ts';
 
-export const resolveReview = async (
-  obj: RawReview | undefined,
-  args: QueryReviewArgs,
-  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
-  { fieldName, fieldNodes }: GraphQLResolveInfo
-) => {
-  const typedFieldName = snakeCase(fieldName) as keyof RawReview;
+export const resolveReview = buildObjArgsResolver<RawReview, QueryReviewArgs, RawReview | RawReview[keyof RawReview]>(
+  REVIEW,
+  async (obj, args, ctx, info) => {
+    const id = obj ? obj.id : args.id;
+    const { requestID, restClient, tmdbGuestSessionId } = ctx;
+    const { fieldName } = info;
+    const typedFieldName = snakeCase(fieldName) as keyof RawReview;
 
-  if (obj && !isUndefined(obj[typedFieldName])) {
-    return obj[typedFieldName];
-  }
-
-  const id = obj ? obj.id : args.id;
+    if (obj && !isUndefined(obj[typedFieldName])) {
+      return {
+        data: obj[typedFieldName],
+        source: 'parentNode',
+      };
+    }
 
-  const { data, errors, headers } = await restClient.review<RawReview>(
-    {
-      pathTemplateData: { id },
-    },
-    { requestID, tmdbGuestSessionId }
-  );
+    const { data, errors, headers } = await restClient.review<RawReview>(
+      {
+        pathTemplateData: { id },
+      },
+      { requestID, tmdbGuestSessionId }
+    );
 
-  if (errors?.length) {
-    throw new GraphQLError(`Failed to resolve ${REVIEW} ${id}.`, { nodes: fieldNodes, originalError: errors[0] });
+    return {
+      data: obj ? data?.[typedFieldName] : data,
+      errors,
+      headers,
+    };
   }
-
-  if (obj) {
-    setCacheMetadata(`${REVIEW}.${fieldName}`, headers);
-    return data![typedFieldName];
-  }
-
-  setCacheMetadata(REVIEW, headers);
-  return data;
-};
+);