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

package/src/queries/tvSimilarTvShows.ts

@@ -1,11 +1,10 @@
 import { Core } from '@cachemap/core';
 import { init as map } from '@cachemap/map';
 import { init as reaper } from '@cachemap/reaper';
-import { type Getters, makeConnectionResolver } from '@graphql-box/connection-resolver';
+import { type CreateResourceResolver, type Getters, makeConnectionResolver } from '@graphql-box/connection-resolver';
 import { type TvSimilarTvShowsArgs } from '@tmdb-graphql-api/schema/types';
-import { type FetchResponse } from 'getta';
 import { encode } from 'js-base64';
-import { SIMILAR, SIMILAR_TV_SHOWS, TV } from '../constants.ts';
+import { SIMILAR, TV } from '../constants.ts';
 import { type Context, type RawTv, type RawTvSimilarTvShows, type RawTvWithAppendToResponse } from '../types.ts';
 
 /* eslint-disable camelcase */
@@ -19,24 +18,28 @@ export const createMakeCursors = (obj: RawTv) => {
   };
 };
 
-export const createResourceResolver =
-  (
-    obj: RawTvWithAppendToResponse & { __headers?: Headers },
-    _args: TvSimilarTvShowsArgs,
-    { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context
-  ) =>
-  async ({ page }: { page: number }) => {
-    if (obj.similar?.page === page && obj.__headers) {
-      setCacheMetadata(`${TV}.${SIMILAR_TV_SHOWS}`, obj.__headers);
+const isRawTvWithSimilarShows = (
+  obj: RawTv | (RawTvWithAppendToResponse & { __headers?: Headers }),
+  page: number
+): obj is RawTvWithAppendToResponse & { __headers: Headers } =>
+  SIMILAR in obj && obj.similar?.page === page && '__headers' in obj;
 
+export const createResourceResolver: CreateResourceResolver<
+  RawTv | (RawTvWithAppendToResponse & { __headers?: Headers }),
+  TvSimilarTvShowsArgs,
+  Context,
+  RawTvSimilarTvShows
+> =
+  (obj, _args, { requestID, restClient, tmdbGuestSessionId }) =>
+  async ({ page }: { page: number }) => {
+    if (isRawTvWithSimilarShows(obj, page)) {
       return {
         data: obj.similar,
-        errors: [],
         headers: obj.__headers,
-      } as unknown as FetchResponse<RawTvSimilarTvShows>;
+      };
     }
 
-    const result = await restClient.tv<RawTvSimilarTvShows>(
+    const { data, errors, headers } = await restClient.tv<RawTvSimilarTvShows>(
       {
         pathTemplateData: { id: obj.id, type: SIMILAR },
         queryParams: { page },
@@ -44,11 +47,11 @@ export const createResourceResolver =
       { requestID, tmdbGuestSessionId }
     );
 
-    if (result.data) {
-      setCacheMetadata(`${TV}.${SIMILAR_TV_SHOWS}`, result.headers);
-    }
-
-    return result;
+    return {
+      data,
+      errors,
+      headers,
+    };
   };
 
 export const cursorCache = new Core({
@@ -59,10 +62,11 @@ export const cursorCache = new Core({
 });
 
 export const getters: Getters<RawTvSimilarTvShows, RawTv> = {
-  nodes: ({ results }) => results,
-  page: ({ page }) => page,
-  totalPages: ({ total_pages }) => total_pages,
-  totalResults: ({ total_results }) => total_results,
+  // @ts-expect-error minor type mismatch
+  nodes: ({ results = [] }) => results,
+  page: ({ page = 0 }) => page,
+  totalPages: ({ total_pages = 0 }) => total_pages,
+  totalResults: ({ total_results = 0 }) => total_results,
 };
 
 export const resolveTvSimilarTvShows = makeConnectionResolver({

package/src/queries/tvTranslations.test.ts

@@ -7,41 +7,41 @@ 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 RawTvWithAppendToResponse } from '../types.ts';
+import { TRANSLATIONS } from '../constants.ts';
+import { type Context } from '../types.ts';
 import { resolveTvTranslations } from './tvTranslations.ts';
 
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolveTvTranslations >', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
   const tvId = 1399;
 
-  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(TV_PATH, { id: tvId, type: 'translations' }), {
+    mockedFetch.mockGetOnce(buildEndpoint(TV_PATH, { id: tvId, type: TRANSLATIONS }), {
       body: tvTranslations,
     });
   });
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   it('should return the tv translations', async () => {
-    await expect(
-      resolveTvTranslations(
-        tvDetails as unknown as RawTvWithAppendToResponse,
-        undefined,
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
-      )
-    ).resolves.toMatchSnapshot();
+    // @ts-expect-error minor nested type mismatch
+    await expect(resolveTvTranslations(tvDetails, undefined, context, info)).resolves.toMatchSnapshot();
   });
 
   describe('when raw tv data has translations', () => {
@@ -54,20 +54,18 @@ describe('resolveTvTranslations >', () => {
 
       await expect(
         resolveTvTranslations(
+          // @ts-expect-error minor nested type mismatch
           {
             ...tvDetails,
             __headers: new Headers(),
             translations: rest,
-          } as unknown as RawTvWithAppendToResponse & {
-            __headers?: Headers;
           },
           undefined,
           {
+            ...context,
             restClient: { tv: tvFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-            setCacheMetadata,
-            tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-          } as unknown as Context,
-          {} as GraphQLResolveInfo
+          },
+          info
         )
       ).resolves.toMatchSnapshot();
     });
@@ -80,20 +78,18 @@ describe('resolveTvTranslations >', () => {
       const { id, ...rest } = tvTranslations;
 
       await resolveTvTranslations(
+        // @ts-expect-error minor nested type mismatch
         {
           ...tvDetails,
           __headers: new Headers(),
           translations: rest,
-        } as unknown as RawTvWithAppendToResponse & {
-          __headers?: Headers;
         },
         undefined,
         {
+          ...context,
           restClient: { tv: tvFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-          setCacheMetadata,
-          tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-        } as unknown as Context,
-        {} as GraphQLResolveInfo
+        },
+        info
       );
 
       expect(tvFetchMock).not.toHaveBeenCalled();

package/src/queries/tvTranslations.ts

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

package/src/queries/tvVideos.test.ts

@@ -7,41 +7,41 @@ 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 RawTvWithAppendToResponse } from '../types.ts';
+import { VIDEOS } from '../constants.ts';
+import { type Context } from '../types.ts';
 import { resolveTvVideos } from './tvVideos.ts';
 
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolveTvVideos >', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
   const tvId = 1399;
 
-  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(TV_PATH, { id: tvId, type: 'videos' }), {
+    mockedFetch.mockGetOnce(buildEndpoint(TV_PATH, { id: tvId, type: VIDEOS }), {
       body: tvVideos,
     });
   });
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   it('should return the tv videos', async () => {
-    await expect(
-      resolveTvVideos(
-        tvDetails as unknown as RawTvWithAppendToResponse,
-        undefined,
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
-      )
-    ).resolves.toMatchSnapshot();
+    // @ts-expect-error minor nested type mismatch
+    await expect(resolveTvVideos(tvDetails, undefined, context, info)).resolves.toMatchSnapshot();
   });
 
   describe('when raw tv data has videos', () => {
@@ -54,20 +54,18 @@ describe('resolveTvVideos >', () => {
 
       await expect(
         resolveTvVideos(
+          // @ts-expect-error minor nested type mismatch
           {
             ...tvDetails,
             __headers: new Headers(),
             videos: rest,
-          } as unknown as RawTvWithAppendToResponse & {
-            __headers?: Headers;
           },
           undefined,
           {
+            ...context,
             restClient: { tv: tvFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-            setCacheMetadata,
-            tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-          } as unknown as Context,
-          {} as GraphQLResolveInfo
+          },
+          info
         )
       ).resolves.toMatchSnapshot();
     });
@@ -80,20 +78,18 @@ describe('resolveTvVideos >', () => {
       const { id, ...rest } = tvVideos;
 
       await resolveTvVideos(
+        // @ts-expect-error minor nested type mismatch
         {
           ...tvDetails,
           __headers: new Headers(),
           videos: rest,
-        } as unknown as RawTvWithAppendToResponse & {
-          __headers?: Headers;
         },
         undefined,
         {
+          ...context,
           restClient: { tv: tvFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-          setCacheMetadata,
-          tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-        } as unknown as Context,
-        {} as GraphQLResolveInfo
+        },
+        info
       );
 
       expect(tvFetchMock).not.toHaveBeenCalled();

package/src/queries/tvVideos.ts

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

package/src/queries/tvWatchProviders.test.ts

@@ -7,41 +7,41 @@ 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 RawTvWithAppendToResponse } from '../types.ts';
+import { TV } from '../constants.ts';
+import { type Context } from '../types.ts';
 import { resolveTvWatchProviders } from './tvWatchProviders.ts';
 
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolveTvWatchProviders >', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
   const tvId = 1399;
 
-  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(WATCH_PROVIDER_PATH, { id: tvId, type: 'tv' }), {
+    mockedFetch.mockGetOnce(buildEndpoint(WATCH_PROVIDER_PATH, { id: tvId, type: TV }), {
       body: tvWatchProviders,
     });
   });
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   it('should return the tv watch providers', async () => {
-    await expect(
-      resolveTvWatchProviders(
-        tvDetails as unknown as RawTvWithAppendToResponse,
-        undefined,
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
-      )
-    ).resolves.toMatchSnapshot();
+    // @ts-expect-error minor nested type mismatch
+    await expect(resolveTvWatchProviders(tvDetails, undefined, context, info)).resolves.toMatchSnapshot();
   });
 
   describe('when raw tv data has watch providers', () => {
@@ -54,20 +54,18 @@ describe('resolveTvWatchProviders >', () => {
 
       await expect(
         resolveTvWatchProviders(
+          // @ts-expect-error minor nested type mismatch
           {
             ...tvDetails,
             __headers: new Headers(),
             'watch/providers': rest,
-          } as unknown as RawTvWithAppendToResponse & {
-            __headers?: Headers;
           },
           undefined,
           {
+            ...context,
             restClient: { tv: tvFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-            setCacheMetadata,
-            tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-          } as unknown as Context,
-          {} as GraphQLResolveInfo
+          },
+          info
         )
       ).resolves.toMatchSnapshot();
     });
@@ -80,20 +78,18 @@ describe('resolveTvWatchProviders >', () => {
       const { id, ...rest } = tvWatchProviders;
 
       await resolveTvWatchProviders(
+        // @ts-expect-error minor nested type mismatch
         {
           ...tvDetails,
           __headers: new Headers(),
           'watch/providers': rest,
-        } as unknown as RawTvWithAppendToResponse & {
-          __headers?: Headers;
         },
         undefined,
         {
+          ...context,
           restClient: { tv: tvFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
-          setCacheMetadata,
-          tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
-        } as unknown as Context,
-        {} as GraphQLResolveInfo
+        },
+        info
       );
 
       expect(tvFetchMock).not.toHaveBeenCalled();

package/src/queries/tvWatchProviders.ts

@@ -1,32 +1,35 @@
-import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
-import { TV, WATCH_PROVIDERS } from '../constants.ts';
-import { type Context, type RawTvWithAppendToResponse, type RawWatchProviders } from '../types.ts';
+import { RAW_WATCH_PROVIDERS, TV } from '../constants.ts';
+import { buildObjResolver } from '../helpers/buildObjResolver.ts';
+import { type RawTv, type RawTvWatchProviders, type RawTvWithAppendToResponse } from '../types.ts';
 
-export const resolveTvWatchProviders = async (
-  obj: RawTvWithAppendToResponse & { __headers?: Headers },
-  _args: undefined,
-  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
-  { fieldNodes }: GraphQLResolveInfo
-) => {
-  if (obj['watch/providers'] && obj.__headers) {
-    setCacheMetadata(`${TV}.${WATCH_PROVIDERS}`, obj.__headers);
-    return obj['watch/providers'].results;
+const isRawTvWithWatchProviders = (
+  obj: RawTv | (RawTvWithAppendToResponse & { __headers?: Headers })
+): obj is RawTvWithAppendToResponse & { __headers: Headers } => RAW_WATCH_PROVIDERS in obj && '__headers' in obj;
+
+export const resolveTvWatchProviders = buildObjResolver<
+  RawTv | (RawTvWithAppendToResponse & { __headers?: Headers }),
+  RawTvWatchProviders['results']
+>(TV, async (obj, ctx) => {
+  const { requestID, restClient, tmdbGuestSessionId } = ctx;
+
+  if (isRawTvWithWatchProviders(obj)) {
+    return {
+      data: obj[RAW_WATCH_PROVIDERS]?.results,
+      headers: obj.__headers,
+      source: 'parentNode',
+    };
   }
 
-  const { data, errors, headers } = await restClient.watchProviders<RawWatchProviders>(
+  const { data, errors, headers } = await restClient.watchProviders<RawTvWatchProviders>(
     {
       pathTemplateData: { id: obj.id, type: TV },
     },
     { requestID, tmdbGuestSessionId }
   );
 
-  if (errors?.length) {
-    throw new GraphQLError(`Failed to resolve ${TV} ${obj.id} ${WATCH_PROVIDERS}.`, {
-      nodes: fieldNodes,
-      originalError: errors[0],
-    });
-  }
-
-  setCacheMetadata(`${TV}.${WATCH_PROVIDERS}`, headers);
-  return data?.results;
-};
+  return {
+    data: data?.results,
+    errors,
+    headers,
+  };
+});

package/src/queries/videoType.ts

@@ -1,4 +1,4 @@
+import { type Video } from '@tmdb-graphql-api/schema/types';
 import { snakeCase } from 'lodash-es';
-import { type RawVideo } from '../types.ts';
 
-export const resolveVideoType = ({ type }: RawVideo) => snakeCase(type).toUpperCase();
+export const resolveVideoType = ({ type }: Video) => snakeCase(type).toUpperCase();