@tmdb-graphql-api/resolvers 0.0.6

package/src/queries/movieReleaseDates.test.ts

@@ -0,0 +1,103 @@
+import type { PlainArray } from '@graphql-box/core';
+import { jest } from '@jest/globals';
+import { MOVIE_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import movieDetails from '@tmdb-graphql-api/test-utils/responses/themoviedb/movie/1891/details.json';
+import movieReleaseDates from '@tmdb-graphql-api/test-utils/responses/themoviedb/movie/1891/releaseDates.json';
+import { mockFetch, polyfillFetch } from 'fetch-mocked';
+import type { FetchResponse, Getta, ShortcutProperties } from 'getta';
+import type { GraphQLResolveInfo } from 'graphql';
+import { buildEndpoint } from '../__testUtils__/helpers/buildEndpoint.ts';
+import { createRestClient } from '../__testUtils__/helpers/createRestClient.ts';
+import type { Context, RawMovieWithAppendToResponse } from '../types.ts';
+import { resolveMovieReleaseDates } from './movieReleaseDates.ts';
+
+polyfillFetch();
+const mockedFetch = mockFetch(jest.fn);
+
+describe('resolveMovieReleaseDates >', () => {
+  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
+  const setCacheMetadata = jest.fn();
+  const movieId = 1891;
+
+  beforeAll(() => {
+    restClient = createRestClient();
+  });
+
+  beforeEach(() => {
+    mockedFetch.mockGetOnce(buildEndpoint(MOVIE_PATH, { id: movieId, type: 'release_dates' }), {
+      body: movieReleaseDates,
+    });
+  });
+
+  afterEach(async () => {
+    mockedFetch.mockReset();
+    await restClient.cache?.clear();
+  });
+
+  it('should return the movie release dates', async () => {
+    await expect(
+      resolveMovieReleaseDates(
+        movieDetails as RawMovieWithAppendToResponse,
+        undefined,
+        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+        {} as GraphQLResolveInfo
+      )
+    ).resolves.toMatchSnapshot();
+  });
+
+  describe('when raw movie data has releaseDates', () => {
+    it('should return the correct response', async () => {
+      const movieFetchMock = jest
+        .fn<(...args: PlainArray) => Promise<FetchResponse>>()
+        .mockResolvedValue({ data: {} } as FetchResponse);
+
+      const { id, ...rest } = movieReleaseDates;
+
+      await expect(
+        resolveMovieReleaseDates(
+          {
+            ...movieDetails,
+            __headers: new Headers(),
+            release_dates: rest,
+          } as unknown as RawMovieWithAppendToResponse & {
+            __headers?: Headers;
+          },
+          undefined,
+          {
+            restClient: { movie: movieFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
+            setCacheMetadata,
+            tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+          } as unknown as Context,
+          {} as GraphQLResolveInfo
+        )
+      ).resolves.toMatchSnapshot();
+    });
+
+    it('should not make a request to the server', async () => {
+      const movieFetchMock = jest
+        .fn<(...args: PlainArray) => Promise<FetchResponse>>()
+        .mockResolvedValue({ data: {} } as FetchResponse);
+
+      const { id, ...rest } = movieReleaseDates;
+
+      await resolveMovieReleaseDates(
+        {
+          ...movieDetails,
+          __headers: new Headers(),
+          release_dates: rest,
+        } as unknown as RawMovieWithAppendToResponse & {
+          __headers?: Headers;
+        },
+        undefined,
+        {
+          restClient: { movie: movieFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
+          setCacheMetadata,
+          tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+        } as unknown as Context,
+        {} as GraphQLResolveInfo
+      );
+
+      expect(movieFetchMock).not.toHaveBeenCalled();
+    });
+  });
+});

package/src/queries/movieReleaseDates.ts

@@ -0,0 +1,34 @@
+import { GraphQLError } from 'graphql';
+import type { GraphQLResolveInfo } from 'graphql';
+import { snakeCase } from 'lodash-es';
+import { MOVIE, RELEASE_DATES } from '../constants.ts';
+import type { Context, RawMovieReleaseDates, RawMovieWithAppendToResponse } from '../types.ts';
+
+export const resolveMovieReleaseDates = async (
+  obj: RawMovieWithAppendToResponse & { __headers?: Headers },
+  _args: undefined,
+  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
+  { fieldNodes }: GraphQLResolveInfo
+) => {
+  if (obj.release_dates && obj.__headers) {
+    setCacheMetadata(`${MOVIE}.${RELEASE_DATES}`, obj.__headers);
+    return obj.release_dates.results;
+  }
+
+  const { data, errors, headers } = await restClient.movie<RawMovieReleaseDates>(
+    {
+      pathTemplateData: { id: obj.id, type: snakeCase(RELEASE_DATES) },
+    },
+    { requestID, tmdbGuestSessionId }
+  );
+
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${MOVIE} ${obj.id} ${RELEASE_DATES}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0],
+    });
+  }
+
+  setCacheMetadata(`${MOVIE}.${RELEASE_DATES}`, headers);
+  return data!.results;
+};

package/src/queries/movieReviews.test.ts

@@ -0,0 +1,152 @@
+import type { PlainArray } from '@graphql-box/core';
+import { jest } from '@jest/globals';
+import { MOVIE_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import movieDetails from '@tmdb-graphql-api/test-utils/responses/themoviedb/movie/1891/details.json';
+import movieReviews from '@tmdb-graphql-api/test-utils/responses/themoviedb/movie/1891/reviews.json';
+import { type Jsonifiable, mockFetch, polyfillFetch } from 'fetch-mocked';
+import type { FetchResponse, Getta, ShortcutProperties } from 'getta';
+import type { GraphQLResolveInfo } from 'graphql';
+import { decode } from 'js-base64';
+import { buildEndpoint } from '../__testUtils__/helpers/buildEndpoint.ts';
+import { createRestClient } from '../__testUtils__/helpers/createRestClient.ts';
+import { MOVIE, REVIEWS } from '../constants.ts';
+import type { Context, RawMovie, RawMovieWithAppendToResponse } from '../types.ts';
+import { createMakeCursors, createResourceResolver, cursorCache, resolveMovieReviews } from './movieReviews.ts';
+
+polyfillFetch();
+const mockedFetch = mockFetch(jest.fn);
+const movieId = 1891;
+
+describe('createMakeCursors', () => {
+  const GROUP_CURSOR = `${movieId}::${MOVIE}::${REVIEWS}`;
+
+  it('makeGroupCursor', () => {
+    const { makeGroupCursor } = createMakeCursors({ id: movieId } as unknown as RawMovie);
+    const groupCursor = makeGroupCursor();
+    expect(decode(groupCursor)).toBe(GROUP_CURSOR);
+  });
+
+  it('makeIDCursor', () => {
+    const reviewId = '6';
+    const { makeIDCursor } = createMakeCursors({ id: movieId } as unknown as RawMovie);
+    const idCursor = makeIDCursor(reviewId);
+    expect(decode(idCursor)).toBe(`${reviewId}::${GROUP_CURSOR}`);
+  });
+});
+
+describe('createResourceResolver', () => {
+  const restClient = {
+    movie: jest.fn().mockReturnValue({}),
+  } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>;
+
+  const setCacheMetadata = jest.fn();
+
+  it('when `restClient.movie` is called', async () => {
+    const resourceResolver = createResourceResolver({ id: movieId } as RawMovieWithAppendToResponse, {}, {
+      restClient,
+      setCacheMetadata,
+      tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+    } as unknown as Context);
+
+    await resourceResolver({ page: 1 });
+
+    expect(restClient.movie).toHaveBeenCalledWith(
+      {
+        pathTemplateData: { id: movieId, type: REVIEWS },
+        queryParams: { page: 1 },
+      },
+      { requestID: undefined, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' }
+    );
+  });
+});
+
+describe('resolveMovieReviews', () => {
+  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
+  const setCacheMetadata = jest.fn();
+
+  const mockEndpoint = (page: number, body: Jsonifiable) => {
+    mockedFetch.mockGetOnce(buildEndpoint(MOVIE_PATH, { id: movieId, type: REVIEWS }, { page }), {
+      body,
+      headers: { 'cache-control': 'public, max-age=6000' },
+    });
+  };
+
+  beforeAll(() => {
+    restClient = createRestClient();
+  });
+
+  beforeEach(() => {
+    mockEndpoint(1, movieReviews);
+  });
+
+  afterEach(async () => {
+    mockedFetch.mockReset();
+    await restClient.cache?.clear();
+    await cursorCache.clear();
+  });
+
+  describe('when the first 5 are requested', () => {
+    it('should return the correct response', async () => {
+      await expect(
+        resolveMovieReviews(
+          { id: movieId } as RawMovieWithAppendToResponse,
+          { first: 5 },
+          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+          {} as GraphQLResolveInfo
+        )
+      ).resolves.toMatchSnapshot();
+    });
+  });
+
+  describe('when raw movie data has reviews', () => {
+    it('should return the correct response', async () => {
+      const movieFetchMock = jest
+        .fn<(...args: PlainArray) => Promise<FetchResponse>>()
+        .mockResolvedValue({ data: {} } as FetchResponse);
+
+      const { id, ...rest } = movieReviews;
+
+      await expect(
+        resolveMovieReviews(
+          {
+            ...movieDetails,
+            __headers: new Headers(),
+            reviews: rest,
+          } as unknown as RawMovieWithAppendToResponse & { __headers?: Headers },
+          { first: 5 },
+          {
+            restClient: { movie: movieFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
+            setCacheMetadata,
+            tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+          } as unknown as Context,
+          {} as GraphQLResolveInfo
+        )
+      ).resolves.toMatchSnapshot();
+    });
+
+    it('should not make a request to the server', async () => {
+      const movieFetchMock = jest
+        .fn<(...args: PlainArray) => Promise<FetchResponse>>()
+        .mockResolvedValue({ data: {} } as FetchResponse);
+
+      const { id, ...rest } = movieReviews;
+
+      await resolveMovieReviews(
+        {
+          ...movieDetails,
+          __headers: new Headers(),
+          reviews: rest,
+        } as unknown as RawMovieWithAppendToResponse & { __headers?: Headers },
+        { first: 5 },
+        {
+          restClient: { movie: movieFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
+          setCacheMetadata,
+          tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+        } as unknown as Context,
+        {} as GraphQLResolveInfo
+      );
+
+      expect(movieFetchMock).not.toHaveBeenCalled();
+    });
+  });
+});

package/src/queries/movieReviews.ts

@@ -0,0 +1,74 @@
+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 { MovieReviewsArgs } from '@tmdb-graphql-api/schema';
+import type { FetchResponse } from 'getta';
+import { encode } from 'js-base64';
+import { MOVIE, REVIEWS } from '../constants.ts';
+import type { Context, RawMovie, RawMovieReviews, RawMovieWithAppendToResponse, RawReview } from '../types.ts';
+
+/* eslint-disable camelcase */
+
+export const createMakeCursors = (obj: RawMovie) => {
+  const groupCursor = `${obj.id}::${MOVIE}::${REVIEWS}`;
+
+  return {
+    makeGroupCursor: () => encode(groupCursor),
+    makeIDCursor: (id: string | number) => encode(`${id}::${groupCursor}`),
+  };
+};
+
+export const createResourceResolver =
+  (
+    obj: RawMovieWithAppendToResponse & { __headers?: Headers },
+    _args: MovieReviewsArgs,
+    { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context
+  ) =>
+  async ({ page }: { page: number }) => {
+    if (obj.reviews && obj.__headers) {
+      setCacheMetadata(`${MOVIE}.${REVIEWS}`, obj.__headers);
+
+      return {
+        data: obj.reviews,
+        errors: [],
+        headers: obj.__headers,
+      } as unknown as FetchResponse<RawMovieReviews>;
+    }
+
+    const result = await restClient.movie<RawMovieReviews>(
+      {
+        pathTemplateData: { id: obj.id, type: REVIEWS },
+        queryParams: { page },
+      },
+      { requestID, tmdbGuestSessionId }
+    );
+
+    if (result.data) {
+      setCacheMetadata(`${MOVIE}.${REVIEWS}`, result.headers);
+    }
+
+    return result;
+  };
+
+export const cursorCache = new Core({
+  name: 'MOVIE_REVIEWS_CONNECTION_RESOLVER',
+  reaper: reaper({ interval: 300_000 }),
+  store: map(),
+  type: 'GRAPHQL',
+});
+
+export const getters: Getters<RawMovieReviews, RawReview> = {
+  nodes: ({ results }) => results,
+  page: ({ page }) => page,
+  totalPages: ({ total_pages }) => total_pages,
+  totalResults: ({ total_results }) => total_results,
+};
+
+export const resolveMovieReviews = makeConnectionResolver({
+  createMakeCursors,
+  createResourceResolver,
+  cursorCache,
+  getters,
+  resultsPerPage: 20,
+});

package/src/queries/movieSimilarMovies.test.ts

@@ -0,0 +1,173 @@
+import type { PlainArray } from '@graphql-box/core';
+import { jest } from '@jest/globals';
+import { MOVIE_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import movieDetails from '@tmdb-graphql-api/test-utils/responses/themoviedb/movie/1891/details.json';
+import movieSimilarMovies from '@tmdb-graphql-api/test-utils/responses/themoviedb/movie/1891/similarMovies.json';
+import { type Jsonifiable, mockFetch, polyfillFetch } from 'fetch-mocked';
+import type { FetchResponse, Getta, ShortcutProperties } from 'getta';
+import type { GraphQLResolveInfo } from 'graphql';
+import { decode } from 'js-base64';
+import { buildEndpoint } from '../__testUtils__/helpers/buildEndpoint.ts';
+import { createRestClient } from '../__testUtils__/helpers/createRestClient.ts';
+import { MOVIE, SIMILAR } from '../constants.ts';
+import type { Context, RawMovie, RawMovieWithAppendToResponse } from '../types.ts';
+import {
+  createMakeCursors,
+  createResourceResolver,
+  cursorCache,
+  resolveMovieSimilarMovies,
+} from './movieSimilarMovies.ts';
+
+polyfillFetch();
+const mockedFetch = mockFetch(jest.fn);
+const id = 1891;
+
+describe('createMakeCursors', () => {
+  const GROUP_CURSOR = `${id}::${MOVIE}::${SIMILAR}`;
+
+  it('makeGroupCursor', () => {
+    const { makeGroupCursor } = createMakeCursors({ id } as unknown as RawMovie);
+    const groupCursor = makeGroupCursor();
+    expect(decode(groupCursor)).toBe(GROUP_CURSOR);
+  });
+
+  it('makeIDCursor', () => {
+    const similiarMovieId = '6';
+    const { makeIDCursor } = createMakeCursors({ id } as unknown as RawMovie);
+    const idCursor = makeIDCursor(similiarMovieId);
+    expect(decode(idCursor)).toBe(`${similiarMovieId}::${GROUP_CURSOR}`);
+  });
+});
+
+describe('createResourceResolver', () => {
+  const restClient = {
+    movie: jest.fn().mockReturnValue({}),
+  } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>;
+
+  const setCacheMetadata = jest.fn();
+
+  it('when `restClient.movie` is called', async () => {
+    const resourceResolver = createResourceResolver({ id } as RawMovieWithAppendToResponse, {}, {
+      restClient,
+      setCacheMetadata,
+      tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+    } as unknown as Context);
+
+    await resourceResolver({ page: 1 });
+
+    expect(restClient.movie).toHaveBeenCalledWith(
+      {
+        pathTemplateData: { id, type: SIMILAR },
+        queryParams: { page: 1 },
+      },
+      { requestID: undefined, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' }
+    );
+  });
+});
+
+describe('resolveMovieSimilarMovies', () => {
+  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
+  const setCacheMetadata = jest.fn();
+
+  const mockEndpoint = (page: number, body: Jsonifiable) => {
+    mockedFetch.mockGetOnce(buildEndpoint(MOVIE_PATH, { id, type: SIMILAR }, { page }), {
+      body,
+      headers: { 'cache-control': 'public, max-age=6000' },
+    });
+  };
+
+  beforeAll(() => {
+    restClient = createRestClient();
+  });
+
+  beforeEach(() => {
+    mockEndpoint(1, movieSimilarMovies);
+  });
+
+  afterEach(async () => {
+    mockedFetch.mockReset();
+    await restClient.cache?.clear();
+    await cursorCache.clear();
+  });
+
+  describe('when the first 5 are requested', () => {
+    it('should return the correct response', async () => {
+      await expect(
+        resolveMovieSimilarMovies(
+          { id } as RawMovieWithAppendToResponse,
+          { first: 5 },
+          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+          {} as GraphQLResolveInfo
+        )
+      ).resolves.toMatchSnapshot();
+    });
+  });
+
+  describe('when the second 5 are requested', () => {
+    it('should return the correct response', async () => {
+      const { pageInfo } = await resolveMovieSimilarMovies(
+        { id } as RawMovieWithAppendToResponse,
+        { first: 5 },
+        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+        {} as GraphQLResolveInfo
+      );
+
+      await expect(
+        resolveMovieSimilarMovies(
+          { id } as RawMovieWithAppendToResponse,
+          { after: pageInfo.endCursor, first: 5 },
+          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+          {} as GraphQLResolveInfo
+        )
+      ).resolves.toMatchSnapshot();
+    });
+  });
+
+  describe('when raw movie data has similarMovies', () => {
+    it('should return the correct response', async () => {
+      const movieFetchMock = jest
+        .fn<(...args: PlainArray) => Promise<FetchResponse>>()
+        .mockResolvedValue({ data: {} } as FetchResponse);
+
+      await expect(
+        resolveMovieSimilarMovies(
+          {
+            ...movieDetails,
+            __headers: new Headers(),
+            similar: movieSimilarMovies,
+          } as unknown as RawMovieWithAppendToResponse & { __headers?: Headers },
+          { first: 5 },
+          {
+            restClient: { movie: movieFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
+            setCacheMetadata,
+            tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+          } as unknown as Context,
+          {} as GraphQLResolveInfo
+        )
+      ).resolves.toMatchSnapshot();
+    });
+
+    it('should not make a request to the server', async () => {
+      const movieFetchMock = jest
+        .fn<(...args: PlainArray) => Promise<FetchResponse>>()
+        .mockResolvedValue({ data: {} } as FetchResponse);
+
+      await resolveMovieSimilarMovies(
+        {
+          ...movieDetails,
+          __headers: new Headers(),
+          similar: movieSimilarMovies,
+        } as unknown as RawMovieWithAppendToResponse & { __headers?: Headers },
+        { first: 5 },
+        {
+          restClient: { movie: movieFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
+          setCacheMetadata,
+          tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+        } as unknown as Context,
+        {} as GraphQLResolveInfo
+      );
+
+      expect(movieFetchMock).not.toHaveBeenCalled();
+    });
+  });
+});

package/src/queries/movieSimilarMovies.ts

@@ -0,0 +1,74 @@
+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 { MovieSimilarMoviesArgs } from '@tmdb-graphql-api/schema';
+import type { FetchResponse } from 'getta';
+import { encode } from 'js-base64';
+import { MOVIE, SIMILAR, SIMILAR_MOVIES } from '../constants.ts';
+import type { Context, RawMovie, RawMovieSimilarMovies, RawMovieWithAppendToResponse } from '../types.ts';
+
+/* eslint-disable camelcase */
+
+export const createMakeCursors = (obj: RawMovie) => {
+  const groupCursor = `${obj.id}::${MOVIE}::${SIMILAR}`;
+
+  return {
+    makeGroupCursor: () => encode(groupCursor),
+    makeIDCursor: (id: string | number) => encode(`${id}::${groupCursor}`),
+  };
+};
+
+export const createResourceResolver =
+  (
+    obj: RawMovieWithAppendToResponse & { __headers?: Headers },
+    _args: MovieSimilarMoviesArgs,
+    { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context
+  ) =>
+  async ({ page }: { page: number }) => {
+    if (obj.similar && obj.__headers) {
+      setCacheMetadata(`${MOVIE}.${SIMILAR_MOVIES}`, obj.__headers);
+
+      return {
+        data: obj.similar,
+        errors: [],
+        headers: obj.__headers,
+      } as unknown as FetchResponse<RawMovieSimilarMovies>;
+    }
+
+    const result = await restClient.movie<RawMovieSimilarMovies>(
+      {
+        pathTemplateData: { id: obj.id, type: SIMILAR },
+        queryParams: { page },
+      },
+      { requestID, tmdbGuestSessionId }
+    );
+
+    if (result.data) {
+      setCacheMetadata(`${MOVIE}.${SIMILAR_MOVIES}`, result.headers);
+    }
+
+    return result;
+  };
+
+export const cursorCache = new Core({
+  name: 'MOVIE_SIMILAR_MOVIES_CONNECTION_RESOLVER',
+  reaper: reaper({ interval: 300_000 }),
+  store: map(),
+  type: 'GRAPHQL',
+});
+
+export const getters: Getters<RawMovieSimilarMovies, RawMovie> = {
+  nodes: ({ results }) => results,
+  page: ({ page }) => page,
+  totalPages: ({ total_pages }) => total_pages,
+  totalResults: ({ total_results }) => total_results,
+};
+
+export const resolveMovieSimilarMovies = makeConnectionResolver({
+  createMakeCursors,
+  createResourceResolver,
+  cursorCache,
+  getters,
+  resultsPerPage: 20,
+});