@tmdb-graphql-api/resolvers 0.0.6

package/src/queries/certifications.test.ts

@@ -0,0 +1,66 @@
+import { jest } from '@jest/globals';
+import { CERTIFICATIONS_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import movieCertifications from '@tmdb-graphql-api/test-utils/responses/themoviedb/certifications/movie.json';
+import tvCertifications from '@tmdb-graphql-api/test-utils/responses/themoviedb/certifications/tv.json';
+import { mockFetch, polyfillFetch } from 'fetch-mocked';
+import type { 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, ScreenType } from '../types.ts';
+import { resolveCertifications } from './certifications.ts';
+
+polyfillFetch();
+const mockedFetch = mockFetch(jest.fn);
+
+describe('resolveCertifications >', () => {
+  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
+  const setCacheMetadata = jest.fn();
+
+  beforeAll(() => {
+    restClient = createRestClient();
+  });
+
+  afterEach(async () => {
+    mockedFetch.mockReset();
+    await restClient.cache?.clear();
+  });
+
+  describe("when the screenType is 'MOVIE' >", () => {
+    beforeEach(() => {
+      mockedFetch.mockGetOnce(buildEndpoint(CERTIFICATIONS_PATH, { type: ScreenType.MOVIE.toLowerCase() }), {
+        body: movieCertifications,
+      });
+    });
+
+    it('should return the movie certifications', async () => {
+      await expect(
+        resolveCertifications(
+          undefined,
+          { screenType: ScreenType.MOVIE },
+          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+          {} as GraphQLResolveInfo
+        )
+      ).resolves.toMatchSnapshot();
+    });
+  });
+
+  describe("when the screenType is 'TV' >", () => {
+    beforeEach(() => {
+      mockedFetch.mockGetOnce(buildEndpoint(CERTIFICATIONS_PATH, { type: ScreenType.TV.toLowerCase() }), {
+        body: tvCertifications,
+      });
+    });
+
+    it('should return the tv certifications', async () => {
+      await expect(
+        resolveCertifications(
+          undefined,
+          { screenType: ScreenType.TV },
+          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+          {} as GraphQLResolveInfo
+        )
+      ).resolves.toMatchSnapshot();
+    });
+  });
+});

package/src/queries/certifications.ts

@@ -0,0 +1,29 @@
+import type { Certifications, QueryCertificationsArgs } from '@tmdb-graphql-api/schema';
+import { GraphQLError } from 'graphql';
+import type { GraphQLResolveInfo } from 'graphql';
+import { CERTIFICATIONS } from '../constants.ts';
+import type { Context } from '../types.ts';
+
+export const resolveCertifications = async (
+  _obj: undefined,
+  { screenType }: QueryCertificationsArgs,
+  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
+  { fieldNodes }: GraphQLResolveInfo
+) => {
+  const { data, errors } = await restClient.certifications<{ certifications: Certifications }>(
+    {
+      pathTemplateData: { type: screenType.toLowerCase() },
+    },
+    { requestID, tmdbGuestSessionId }
+  );
+
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${screenType} ${CERTIFICATIONS}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0],
+    });
+  }
+
+  setCacheMetadata(CERTIFICATIONS, { cacheControl: 'public, max-age=28800' } as unknown as Headers);
+  return data?.certifications;
+};

package/src/queries/collection.test.ts

@@ -0,0 +1,47 @@
+import { jest } from '@jest/globals';
+import { COLLECTION_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import collectionDetails from '@tmdb-graphql-api/test-utils/responses/themoviedb/collection/details.json';
+import { mockFetch, polyfillFetch } from 'fetch-mocked';
+import type { 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 } from '../types.ts';
+import { resolveCollection } from './collection.ts';
+
+polyfillFetch();
+const mockedFetch = mockFetch(jest.fn);
+
+describe('resolveCollection >', () => {
+  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
+  const setCacheMetadata = jest.fn();
+  const id = 10;
+
+  beforeAll(() => {
+    restClient = createRestClient();
+  });
+
+  beforeEach(() => {
+    mockedFetch.mockGetOnce(buildEndpoint(COLLECTION_PATH, { id }), {
+      body: collectionDetails,
+    });
+  });
+
+  afterEach(async () => {
+    mockedFetch.mockReset();
+    await restClient.cache?.clear();
+  });
+
+  describe('when a collection id >', () => {
+    it('should return the collection details', async () => {
+      await expect(
+        resolveCollection(
+          undefined,
+          { id },
+          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+          {} as GraphQLResolveInfo
+        )
+      ).resolves.toMatchSnapshot();
+    });
+  });
+});

package/src/queries/collection.ts

@@ -0,0 +1,40 @@
+import type { QueryCollectionArgs } from '@tmdb-graphql-api/schema';
+import { GraphQLError } from 'graphql';
+import type { GraphQLResolveInfo } from 'graphql';
+import { isUndefined, snakeCase } from 'lodash-es';
+import { COLLECTION } from '../constants.ts';
+import type { Context, RawCollection } from '../types.ts';
+
+export const resolveCollection = async (
+  obj: RawCollection | undefined,
+  args: QueryCollectionArgs,
+  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
+  { fieldName, fieldNodes }: GraphQLResolveInfo
+) => {
+  const typedFieldName = snakeCase(fieldName) as keyof RawCollection;
+
+  if (obj && !isUndefined(obj[typedFieldName])) {
+    return obj[typedFieldName];
+  }
+
+  const id = obj ? obj.id : args.id;
+
+  const { data, errors, headers } = await restClient.collection<RawCollection>(
+    {
+      pathTemplateData: { id },
+    },
+    { requestID, tmdbGuestSessionId }
+  );
+
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${COLLECTION} ${id}.`, { nodes: fieldNodes, originalError: errors[0] });
+  }
+
+  if (obj) {
+    setCacheMetadata(`${COLLECTION}.${fieldName}`, headers);
+    return data![typedFieldName];
+  }
+
+  setCacheMetadata(COLLECTION, headers);
+  return data;
+};

package/src/queries/collectionImages.test.ts

@@ -0,0 +1,90 @@
+import { jest } from '@jest/globals';
+import { COLLECTION_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import collectionDetails from '@tmdb-graphql-api/test-utils/responses/themoviedb/collection/details.json';
+import collectionImages from '@tmdb-graphql-api/test-utils/responses/themoviedb/collection/images.json';
+import { mockFetch, polyfillFetch } from 'fetch-mocked';
+import type { Getta, ShortcutProperties } from 'getta';
+import { buildEndpoint } from '../__testUtils__/helpers/buildEndpoint.ts';
+import { buildResolveInfoArgument } from '../__testUtils__/helpers/buildResolveInfoArg.ts';
+import { createRestClient } from '../__testUtils__/helpers/createRestClient.ts';
+import type { Context, RawCollection } from '../types.ts';
+import { resolveCollectionImages } from './collectionImages.ts';
+
+polyfillFetch();
+const mockedFetch = mockFetch(jest.fn);
+
+describe('resolveCollectionImages >', () => {
+  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
+  const setCacheMetadata = jest.fn();
+
+  beforeAll(() => {
+    restClient = createRestClient();
+  });
+
+  beforeEach(() => {
+    mockedFetch.mockGetOnce(buildEndpoint(COLLECTION_PATH, { id: 10, type: 'images' }), {
+      body: collectionImages,
+    });
+  });
+
+  afterEach(async () => {
+    mockedFetch.mockReset();
+    await restClient.cache?.clear();
+  });
+
+  describe('when a query has specified backdrops >', () => {
+    it('should return the collection images', async () => {
+      const resolveInfo = buildResolveInfoArgument(
+        `
+          {
+            collection(id: "10") {
+              backdrops {
+                filePath
+              }
+              id
+              name
+            }
+          }
+        `,
+        ['collection', 'backdrops']
+      );
+
+      await expect(
+        resolveCollectionImages(
+          collectionDetails as unknown as RawCollection,
+          undefined,
+          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+          resolveInfo
+        )
+      ).resolves.toMatchSnapshot();
+    });
+  });
+
+  describe('when a query has specified posters >', () => {
+    it('should return the collection images', async () => {
+      const resolveInfo = buildResolveInfoArgument(
+        `
+          {
+            collection(id: "10") {
+              id
+              name
+              posters {
+                filePath
+              }
+            }
+          }
+        `,
+        ['collection', 'posters']
+      );
+
+      await expect(
+        resolveCollectionImages(
+          collectionDetails as unknown as RawCollection,
+          undefined,
+          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+          resolveInfo
+        )
+      ).resolves.toMatchSnapshot();
+    });
+  });
+});

package/src/queries/collectionImages.ts

@@ -0,0 +1,30 @@
+import type { GraphQLResolveInfo } from 'graphql';
+import { GraphQLError } from 'graphql';
+import { COLLECTION, IMAGES } from '../constants.ts';
+import type { Context, RawCollection, RawCollectionImages } from '../types.ts';
+
+export const resolveCollectionImages = async (
+  { id }: RawCollection,
+  _args: undefined,
+  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
+  { fieldName, fieldNodes }: GraphQLResolveInfo
+) => {
+  const typedFieldName = fieldName as 'backdrops' | 'posters';
+
+  const { data, errors, headers } = await restClient.collection<RawCollectionImages>(
+    {
+      pathTemplateData: { id, type: IMAGES },
+    },
+    { requestID, tmdbGuestSessionId }
+  );
+
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${COLLECTION} ${id} ${fieldName}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0],
+    });
+  }
+
+  setCacheMetadata(`${COLLECTION}.${typedFieldName}`, headers);
+  return data![typedFieldName];
+};

package/src/queries/collectionTranslations.test.ts

@@ -0,0 +1,45 @@
+import { jest } from '@jest/globals';
+import { COLLECTION_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import collectionDetails from '@tmdb-graphql-api/test-utils/responses/themoviedb/collection/details.json';
+import collectionTranslations from '@tmdb-graphql-api/test-utils/responses/themoviedb/collection/translations.json';
+import { mockFetch, polyfillFetch } from 'fetch-mocked';
+import type { 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, RawCollection } from '../types.ts';
+import { resolveCollectionTranslations } from './collectionTranslations.ts';
+
+polyfillFetch();
+const mockedFetch = mockFetch(jest.fn);
+
+describe('resolveCollectionTranslations >', () => {
+  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
+  const setCacheMetadata = jest.fn();
+
+  beforeAll(() => {
+    restClient = createRestClient();
+  });
+
+  beforeEach(() => {
+    mockedFetch.mockGetOnce(buildEndpoint(COLLECTION_PATH, { id: 10, type: 'translations' }), {
+      body: collectionTranslations,
+    });
+  });
+
+  afterEach(async () => {
+    mockedFetch.mockReset();
+    await restClient.cache?.clear();
+  });
+
+  it('should return the collection translations', async () => {
+    await expect(
+      resolveCollectionTranslations(
+        collectionDetails as unknown as RawCollection,
+        undefined,
+        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+        {} as GraphQLResolveInfo
+      )
+    ).resolves.toMatchSnapshot();
+  });
+});

package/src/queries/collectionTranslations.ts

@@ -0,0 +1,28 @@
+import { GraphQLError } from 'graphql';
+import type { GraphQLResolveInfo } from 'graphql';
+import { COLLECTION, TRANSLATIONS } from '../constants.ts';
+import type { Context, RawCollection, RawCollectionTranslations } from '../types.ts';
+
+export const resolveCollectionTranslations = async (
+  { id }: RawCollection,
+  _args: undefined,
+  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
+  { fieldNodes }: GraphQLResolveInfo
+) => {
+  const { data, errors, headers } = await restClient.collection<RawCollectionTranslations>(
+    {
+      pathTemplateData: { id, type: 'translations' },
+    },
+    { requestID, tmdbGuestSessionId }
+  );
+
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${COLLECTION} ${id} ${TRANSLATIONS}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0],
+    });
+  }
+
+  setCacheMetadata(`${COLLECTION}.${TRANSLATIONS}`, headers);
+  return data?.translations;
+};

package/src/queries/company.test.ts

@@ -0,0 +1,45 @@
+import { jest } from '@jest/globals';
+import { COMPANY_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import companyDetails from '@tmdb-graphql-api/test-utils/responses/themoviedb/company/details.json';
+import { mockFetch, polyfillFetch } from 'fetch-mocked';
+import type { 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 } from '../types.ts';
+import { resolveCompany } from './company.ts';
+
+polyfillFetch();
+const mockedFetch = mockFetch(jest.fn);
+
+describe('resolveCompany >', () => {
+  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
+  const setCacheMetadata = jest.fn();
+  const id = 2;
+
+  beforeAll(() => {
+    restClient = createRestClient();
+  });
+
+  beforeEach(() => {
+    mockedFetch.mockGetOnce(buildEndpoint(COMPANY_PATH, { id }), {
+      body: companyDetails,
+    });
+  });
+
+  afterEach(async () => {
+    mockedFetch.mockReset();
+    await restClient.cache?.clear();
+  });
+
+  it('should return the correct company details', async () => {
+    await expect(
+      resolveCompany(
+        undefined,
+        { id },
+        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+        {} as GraphQLResolveInfo
+      )
+    ).resolves.toMatchSnapshot();
+  });
+});

package/src/queries/company.ts

@@ -0,0 +1,40 @@
+import type { QueryCompanyArgs } from '@tmdb-graphql-api/schema';
+import { GraphQLError } from 'graphql';
+import type { GraphQLResolveInfo } from 'graphql';
+import { isUndefined, snakeCase } from 'lodash-es';
+import { COMPANY } from '../constants.ts';
+import type { Context, RawCompany } from '../types.ts';
+
+export const resolveCompany = async (
+  obj: RawCompany | undefined,
+  args: QueryCompanyArgs,
+  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
+  { fieldName, fieldNodes }: GraphQLResolveInfo
+) => {
+  const typedFieldName = snakeCase(fieldName) as keyof RawCompany;
+
+  if (obj && !isUndefined(obj[typedFieldName])) {
+    return obj[typedFieldName];
+  }
+
+  const id = obj ? obj.id : args.id;
+
+  const { data, errors, headers } = await restClient.company<RawCompany>(
+    {
+      pathTemplateData: { id },
+    },
+    { requestID, tmdbGuestSessionId }
+  );
+
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${COMPANY} ${id}.`, { nodes: fieldNodes, originalError: errors[0] });
+  }
+
+  if (obj) {
+    setCacheMetadata(`${COMPANY}.${fieldName}`, headers);
+    return data![typedFieldName];
+  }
+
+  setCacheMetadata(COMPANY, headers);
+  return data;
+};

package/src/queries/companyAlternativeNames.test.ts

@@ -0,0 +1,45 @@
+import { jest } from '@jest/globals';
+import { COMPANY_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import companyAlterativeNames from '@tmdb-graphql-api/test-utils/responses/themoviedb/company/alternativeNames.json';
+import companyDetails from '@tmdb-graphql-api/test-utils/responses/themoviedb/company/details.json';
+import { mockFetch, polyfillFetch } from 'fetch-mocked';
+import type { 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, RawCompany } from '../types.ts';
+import { resolveCompanyAlternativeNames } from './companyAlternativeNames.ts';
+
+polyfillFetch();
+const mockedFetch = mockFetch(jest.fn);
+
+describe('resolveCompanyAlternativeNames >', () => {
+  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
+  const setCacheMetadata = jest.fn();
+
+  beforeAll(() => {
+    restClient = createRestClient();
+  });
+
+  beforeEach(() => {
+    mockedFetch.mockGetOnce(buildEndpoint(COMPANY_PATH, { id: 2, type: 'alternative_names' }), {
+      body: companyAlterativeNames,
+    });
+  });
+
+  afterEach(async () => {
+    mockedFetch.mockReset();
+    await restClient.cache?.clear();
+  });
+
+  it('should return the company alternative names', async () => {
+    await expect(
+      resolveCompanyAlternativeNames(
+        companyDetails as unknown as RawCompany,
+        undefined,
+        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+        {} as GraphQLResolveInfo
+      )
+    ).resolves.toMatchSnapshot();
+  });
+});

package/src/queries/companyAlternativeNames.ts

@@ -0,0 +1,29 @@
+import { GraphQLError } from 'graphql';
+import type { GraphQLResolveInfo } from 'graphql';
+import { snakeCase } from 'lodash-es';
+import { ALTERNATIVE_NAMES, COMPANY } from '../constants.ts';
+import type { Context, RawCompany, RawCompanyAlternativeNames } from '../types.ts';
+
+export const resolveCompanyAlternativeNames = async (
+  { id }: RawCompany,
+  _args: undefined,
+  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
+  { fieldNodes }: GraphQLResolveInfo
+) => {
+  const { data, errors, headers } = await restClient.company<RawCompanyAlternativeNames>(
+    {
+      pathTemplateData: { id, type: snakeCase(ALTERNATIVE_NAMES) },
+    },
+    { requestID, tmdbGuestSessionId }
+  );
+
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${COMPANY} ${id} ${ALTERNATIVE_NAMES}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0],
+    });
+  }
+
+  setCacheMetadata(`${COMPANY}.${ALTERNATIVE_NAMES}`, headers);
+  return data!.results;
+};

package/src/queries/companyLogos.test.ts

@@ -0,0 +1,45 @@
+import { jest } from '@jest/globals';
+import { COMPANY_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import companyDetails from '@tmdb-graphql-api/test-utils/responses/themoviedb/company/details.json';
+import companyLogos from '@tmdb-graphql-api/test-utils/responses/themoviedb/company/images.json';
+import { mockFetch, polyfillFetch } from 'fetch-mocked';
+import type { 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, RawCompany } from '../types.ts';
+import { resolveCompanyLogos } from './companyLogos.ts';
+
+polyfillFetch();
+const mockedFetch = mockFetch(jest.fn);
+
+describe('resolveCompanyImages >', () => {
+  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
+  const setCacheMetadata = jest.fn();
+
+  beforeAll(() => {
+    restClient = createRestClient();
+  });
+
+  beforeEach(() => {
+    mockedFetch.mockGetOnce(buildEndpoint(COMPANY_PATH, { id: 2, type: 'images' }), {
+      body: companyLogos,
+    });
+  });
+
+  afterEach(async () => {
+    mockedFetch.mockReset();
+    await restClient.cache?.clear();
+  });
+
+  it('should return the company logos', async () => {
+    await expect(
+      resolveCompanyLogos(
+        companyDetails as unknown as RawCompany,
+        undefined,
+        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+        {} as GraphQLResolveInfo
+      )
+    ).resolves.toMatchSnapshot();
+  });
+});

package/src/queries/companyLogos.ts

@@ -0,0 +1,28 @@
+import type { GraphQLResolveInfo } from 'graphql';
+import { GraphQLError } from 'graphql';
+import { COMPANY, IMAGES, LOGOS } from '../constants.ts';
+import type { Context, RawCompany, RawCompanyLogos } from '../types.ts';
+
+export const resolveCompanyLogos = async (
+  { id }: RawCompany,
+  _args: undefined,
+  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
+  { fieldNodes }: GraphQLResolveInfo
+) => {
+  const { data, errors, headers } = await restClient.company<RawCompanyLogos>(
+    {
+      pathTemplateData: { id, type: IMAGES },
+    },
+    { requestID, tmdbGuestSessionId }
+  );
+
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${COMPANY} ${id} ${LOGOS}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0],
+    });
+  }
+
+  setCacheMetadata(`${COMPANY}.${LOGOS}`, headers);
+  return data!.logos;
+};

package/src/queries/configuration.test.ts

@@ -0,0 +1,44 @@
+import { jest } from '@jest/globals';
+import { CONFIGURATION_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import configurationBase from '@tmdb-graphql-api/test-utils/responses/themoviedb/configuration/base.json';
+import { mockFetch, polyfillFetch } from 'fetch-mocked';
+import type { 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 } from '../types.ts';
+import { resolveConfiguration } from './configuration.ts';
+
+polyfillFetch();
+const mockedFetch = mockFetch(jest.fn);
+
+describe('resolveConfiguration >', () => {
+  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
+  const setCacheMetadata = jest.fn();
+
+  beforeAll(() => {
+    restClient = createRestClient();
+  });
+
+  beforeEach(() => {
+    mockedFetch.mockGetOnce(buildEndpoint(CONFIGURATION_PATH), {
+      body: configurationBase,
+    });
+  });
+
+  afterEach(async () => {
+    mockedFetch.mockReset();
+    await restClient.cache?.clear();
+  });
+
+  it('should return the correct configuration base', async () => {
+    await expect(
+      resolveConfiguration(
+        undefined,
+        undefined,
+        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+        {} as GraphQLResolveInfo
+      )
+    ).resolves.toMatchSnapshot();
+  });
+});