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

package/src/queries/movieCredits.ts

@@ -1,18 +1,25 @@
-import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
 import { CREDITS, MOVIE } from '../constants.ts';
-import { type Context, type RawMovieCredits, type RawMovieWithAppendToResponse } from '../types.ts';
+import { buildObjResolver } from '../helpers/buildObjResolver.ts';
+import { type RawMovie, type RawMovieCredits, type RawMovieWithAppendToResponse } from '../types.ts';
 
-export const resolveMovieCredits = async (
-  obj: RawMovieWithAppendToResponse & { __headers?: Headers },
-  _args: undefined,
-  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
-  { fieldName, fieldNodes }: GraphQLResolveInfo
-) => {
+const isRawMovieWithCredits = (
+  obj: RawMovie | (RawMovieWithAppendToResponse & { __headers?: Headers })
+): obj is RawMovieWithAppendToResponse & { __headers: Headers } => CREDITS in obj && '__headers' in obj;
+
+export const resolveMovieCredits = buildObjResolver<
+  RawMovie | (RawMovieWithAppendToResponse & { __headers?: Headers }),
+  RawMovieCredits['cast'] | RawMovieCredits['crew']
+>(MOVIE, async (obj, ctx, info) => {
+  const { requestID, restClient, tmdbGuestSessionId } = ctx;
+  const { fieldName } = info;
   const typedFieldName = fieldName as 'cast' | 'crew';
 
-  if (obj.credits && obj.__headers) {
-    setCacheMetadata(`${MOVIE}.${typedFieldName}`, obj.__headers);
-    return obj.credits[typedFieldName];
+  if (isRawMovieWithCredits(obj)) {
+    return {
+      data: obj.credits?.[typedFieldName],
+      headers: obj.__headers,
+      source: 'parentNode',
+    };
   }
 
   const { data, errors, headers } = await restClient.movie<RawMovieCredits>(
@@ -22,13 +29,9 @@ export const resolveMovieCredits = async (
     { requestID, tmdbGuestSessionId }
   );
 
-  if (errors?.length) {
-    throw new GraphQLError(`Failed to resolve movie ${obj.id} ${typedFieldName}.`, {
-      nodes: fieldNodes,
-      originalError: errors[0],
-    });
-  }
-
-  setCacheMetadata(`${MOVIE}.${typedFieldName}`, headers);
-  return data![typedFieldName];
-};
+  return {
+    data: data?.[typedFieldName],
+    errors,
+    headers,
+  };
+});

package/src/queries/movieExternalIds.test.ts

@@ -7,20 +7,25 @@ import { mockFetch } from 'fetch-mocked';
 import { type FetchResponse, 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, type RawMovieWithAppendToResponse } from '../types.ts';
+import { EXTERNAL_IDS } from '../constants.ts';
+import { type Context } from '../types.ts';
 import { resolveMovieExternalIds } from './movieExternalIds.ts';
 
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolveMovieExternalIds >', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
   const movieId = 1891;
 
-  beforeAll(() => {
-    restClient = createRestClient();
-  });
+  const context = {
+    logger: createMockLogger(jest.fn),
+    restClient: createRestClient(),
+    setCacheMetadata: jest.fn(),
+    tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+  } as unknown as Context;
+
+  const info = { fieldName: EXTERNAL_IDS } as GraphQLResolveInfo;
 
   beforeEach(() => {
     mockedFetch.mockGetOnce(buildEndpoint(MOVIE_PATH, { id: movieId, type: 'external_ids' }), {
@@ -30,18 +35,12 @@ describe('resolveMovieExternalIds >', () => {
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   it('should return the movie external IDs', async () => {
-    await expect(
-      resolveMovieExternalIds(
-        movieDetails as RawMovieWithAppendToResponse,
-        undefined,
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
-      )
-    ).resolves.toMatchSnapshot();
+    await expect(resolveMovieExternalIds(movieDetails, undefined, context, info)).resolves.toMatchSnapshot();
   });
 
   describe('when raw movie data has externalIds', () => {
@@ -54,16 +53,13 @@ describe('resolveMovieExternalIds >', () => {
 
       await expect(
         resolveMovieExternalIds(
-          { ...movieDetails, __headers: new Headers(), external_ids: rest } as RawMovieWithAppendToResponse & {
-            __headers?: Headers;
-          },
+          { ...movieDetails, __headers: new Headers(), external_ids: rest },
           undefined,
           {
+            ...context,
             restClient: { movie: movieFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-            setCacheMetadata,
-            tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-          } as unknown as Context,
-          {} as GraphQLResolveInfo
+          },
+          info
         )
       ).resolves.toMatchSnapshot();
     });
@@ -76,16 +72,13 @@ describe('resolveMovieExternalIds >', () => {
       const { id, ...rest } = movieExternalIds;
 
       await resolveMovieExternalIds(
-        { ...movieDetails, __headers: new Headers(), external_ids: rest } as RawMovieWithAppendToResponse & {
-          __headers?: Headers;
-        },
+        { ...movieDetails, __headers: new Headers(), external_ids: rest },
         undefined,
         {
+          ...context,
           restClient: { movie: movieFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-          setCacheMetadata,
-          tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-        } as unknown as Context,
-        {} as GraphQLResolveInfo
+        },
+        info
       );
 
       expect(movieFetchMock).not.toHaveBeenCalled();

package/src/queries/movieExternalIds.ts

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

package/src/queries/movieImages.test.ts

@@ -7,64 +7,54 @@ import { mockFetch } from 'fetch-mocked';
 import { type FetchResponse, 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, type RawMovieWithAppendToResponse } from '../types.ts';
+import { BACKDROPS, IMAGES, LOGOS } from '../constants.ts';
+import { type Context } from '../types.ts';
 import { resolveMovieImages } from './movieImages.ts';
 
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolveMovieImages >', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
   const movieId = 1891;
 
-  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(MOVIE_PATH, { id: movieId, type: 'images' }), {
+    mockedFetch.mockGetOnce(buildEndpoint(MOVIE_PATH, { id: movieId, type: IMAGES }), {
       body: movieImages,
     });
   });
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   describe('when fieldName is backdrops', () => {
     it('should return the correct response', async () => {
-      await expect(
-        resolveMovieImages(
-          movieDetails as RawMovieWithAppendToResponse,
-          undefined,
-          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-          {
-            fieldName: 'backdrops',
-          } as GraphQLResolveInfo
-        )
-      ).resolves.toMatchSnapshot();
+      const info = { fieldName: BACKDROPS } as GraphQLResolveInfo;
+      await expect(resolveMovieImages(movieDetails, undefined, context, info)).resolves.toMatchSnapshot();
     });
   });
 
   describe('when fieldName is logos', () => {
     it('should return the correct response', async () => {
-      await expect(
-        resolveMovieImages(
-          movieDetails as RawMovieWithAppendToResponse,
-          undefined,
-          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-          {
-            fieldName: 'logos',
-          } as GraphQLResolveInfo
-        )
-      ).resolves.toMatchSnapshot();
+      const info = { fieldName: LOGOS } as GraphQLResolveInfo;
+      await expect(resolveMovieImages(movieDetails, undefined, context, info)).resolves.toMatchSnapshot();
     });
   });
 
   describe('when raw movie data has images', () => {
     it('should return the correct response', async () => {
+      const info = { fieldName: LOGOS } as GraphQLResolveInfo;
+
       const movieFetchMock = jest
         .fn<(...args: PlainArray) => Promise<FetchResponse>>()
         .mockResolvedValue({ data: {} } as FetchResponse);
@@ -73,23 +63,20 @@ describe('resolveMovieImages >', () => {
 
       await expect(
         resolveMovieImages(
-          { ...movieDetails, __headers: new Headers(), images: rest } as unknown as RawMovieWithAppendToResponse & {
-            __headers?: Headers;
-          },
+          { ...movieDetails, __headers: new Headers(), images: rest },
           undefined,
           {
+            ...context,
             restClient: { movie: movieFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-            setCacheMetadata,
-            tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-          } as unknown as Context,
-          {
-            fieldName: 'logos',
-          } as GraphQLResolveInfo
+          },
+          info
         )
       ).resolves.toMatchSnapshot();
     });
 
     it('should not make a request to the server', async () => {
+      const info = { fieldName: LOGOS } as GraphQLResolveInfo;
+
       const movieFetchMock = jest
         .fn<(...args: PlainArray) => Promise<FetchResponse>>()
         .mockResolvedValue({ data: {} } as FetchResponse);
@@ -97,18 +84,13 @@ describe('resolveMovieImages >', () => {
       const { id, ...rest } = movieImages;
 
       await resolveMovieImages(
-        { ...movieDetails, __headers: new Headers(), images: rest } as unknown as RawMovieWithAppendToResponse & {
-          __headers?: Headers;
-        },
+        { ...movieDetails, __headers: new Headers(), images: rest },
         undefined,
         {
+          ...context,
           restClient: { movie: movieFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-          setCacheMetadata,
-          tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-        } as unknown as Context,
-        {
-          fieldName: 'logos',
-        } as GraphQLResolveInfo
+        },
+        info
       );
 
       expect(movieFetchMock).not.toHaveBeenCalled();

package/src/queries/movieImages.ts

@@ -1,34 +1,37 @@
-import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
-import { MOVIE } from '../constants.ts';
-import { type Context, type RawMovieImages, type RawMovieWithAppendToResponse } from '../types.ts';
+import { IMAGES, MOVIE } from '../constants.ts';
+import { buildObjResolver } from '../helpers/buildObjResolver.ts';
+import { type RawMovie, type RawMovieImages, type RawMovieWithAppendToResponse } from '../types.ts';
 
-export const resolveMovieImages = async (
-  obj: RawMovieWithAppendToResponse & { __headers?: Headers },
-  _args: undefined,
-  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
-  { fieldName, fieldNodes }: GraphQLResolveInfo
-) => {
+const isRawMovieWithImages = (
+  obj: RawMovie | (RawMovieWithAppendToResponse & { __headers?: Headers })
+): obj is RawMovieWithAppendToResponse & { __headers: Headers } => IMAGES in obj && '__headers' in obj;
+
+export const resolveMovieImages = buildObjResolver<
+  RawMovie | (RawMovieWithAppendToResponse & { __headers?: Headers }),
+  RawMovieImages['backdrops'] | RawMovieImages['logos'] | RawMovieImages['posters']
+>(MOVIE, async (obj, ctx, info) => {
+  const { requestID, restClient, tmdbGuestSessionId } = ctx;
+  const { fieldName } = info;
   const typedFieldName = fieldName as 'backdrops' | 'logos' | 'posters';
 
-  if (obj.images && obj.__headers) {
-    setCacheMetadata(`${MOVIE}.${typedFieldName}`, obj.__headers);
-    return obj.images[typedFieldName];
+  if (isRawMovieWithImages(obj)) {
+    return {
+      data: obj.images?.[typedFieldName],
+      headers: obj.__headers,
+      source: 'parentNode',
+    };
   }
 
   const { data, errors, headers } = await restClient.movie<RawMovieImages>(
     {
-      pathTemplateData: { id: obj.id, type: 'images' },
+      pathTemplateData: { id: obj.id, type: IMAGES },
     },
     { requestID, tmdbGuestSessionId }
   );
 
-  if (errors?.length) {
-    throw new GraphQLError(`Failed to resolve ${MOVIE} ${obj.id} ${typedFieldName}.`, {
-      nodes: fieldNodes,
-      originalError: errors[0],
-    });
-  }
-
-  setCacheMetadata(`${MOVIE}.${typedFieldName}`, headers);
-  return data![typedFieldName];
-};
+  return {
+    data: data?.[typedFieldName],
+    errors,
+    headers,
+  };
+});

package/src/queries/movieKeywords.test.ts

@@ -7,20 +7,25 @@ import { mockFetch } from 'fetch-mocked';
 import { type FetchResponse, 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 { KEYWORDS } from '../constants.ts';
 import { type Context, type RawMovieWithAppendToResponse } from '../types.ts';
 import { resolveMovieKeywords } from './movieKeywords.ts';
 
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolveMovieKeywords >', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
   const movieId = 1891;
 
-  beforeAll(() => {
-    restClient = createRestClient();
-  });
+  const context = {
+    logger: createMockLogger(jest.fn),
+    restClient: createRestClient(),
+    setCacheMetadata: jest.fn(),
+    tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+  } as unknown as Context;
+
+  const info = { fieldName: KEYWORDS } as GraphQLResolveInfo;
 
   beforeEach(() => {
     mockedFetch.mockGetOnce(buildEndpoint(MOVIE_PATH, { id: movieId, type: 'keywords' }), {
@@ -30,17 +35,13 @@ describe('resolveMovieKeywords >', () => {
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   it('should return the movie keywords', async () => {
     await expect(
-      resolveMovieKeywords(
-        movieDetails as RawMovieWithAppendToResponse,
-        undefined,
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
-      )
+      resolveMovieKeywords(movieDetails as RawMovieWithAppendToResponse, undefined, context, info)
     ).resolves.toMatchSnapshot();
   });
 
@@ -54,16 +55,13 @@ describe('resolveMovieKeywords >', () => {
 
       await expect(
         resolveMovieKeywords(
-          { ...movieDetails, __headers: new Headers(), keywords: rest } as RawMovieWithAppendToResponse & {
-            __headers?: Headers;
-          },
+          { ...movieDetails, __headers: new Headers(), keywords: rest },
           undefined,
           {
+            ...context,
             restClient: { movie: movieFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-            setCacheMetadata,
-            tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-          } as unknown as Context,
-          {} as GraphQLResolveInfo
+          },
+          info
         )
       ).resolves.toMatchSnapshot();
     });
@@ -76,16 +74,13 @@ describe('resolveMovieKeywords >', () => {
       const { id, ...rest } = movieKeywords;
 
       await resolveMovieKeywords(
-        { ...movieDetails, __headers: new Headers(), keywords: rest } as RawMovieWithAppendToResponse & {
-          __headers?: Headers;
-        },
+        { ...movieDetails, __headers: new Headers(), keywords: rest },
         undefined,
         {
+          ...context,
           restClient: { movie: movieFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-          setCacheMetadata,
-          tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-        } as unknown as Context,
-        {} as GraphQLResolveInfo
+        },
+        info
       );
 
       expect(movieFetchMock).not.toHaveBeenCalled();

package/src/queries/movieKeywords.ts

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