@tmdb-graphql-api/resolvers 0.1.0 → 0.1.1-unstable.1

package/src/queries/collectionImages.ts

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

package/src/queries/collectionTranslations.test.ts

@@ -1,44 +1,56 @@
 import { jest } from '@jest/globals';
-import { COLLECTION_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import { COLLECTION_PATH } 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 } from 'fetch-mocked';
-import { type Getta, type ShortcutProperties } from 'getta';
-import { type GraphQLResolveInfo } from 'graphql';
 import { buildEndpoint } from '../__testUtils__/helpers/buildEndpoint.ts';
+import { buildResolveInfoArgument } from '../__testUtils__/helpers/buildResolveInfoArg.ts';
+import { createMockLogger } from '../__testUtils__/helpers/createMockLogger.ts';
 import { createRestClient } from '../__testUtils__/helpers/createRestClient.ts';
-import { type Context, type RawCollection } from '../types.ts';
+import { COLLECTION, TRANSLATIONS } from '../constants.ts';
+import { type Context } from '../types.ts';
 import { resolveCollectionTranslations } from './collectionTranslations.ts';
 
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolveCollectionTranslations >', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
+  const context = {
+    logger: createMockLogger(jest.fn),
+    restClient: createRestClient(),
+    setCacheMetadata: jest.fn(),
+    tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+  } as unknown as Context;
 
-  beforeAll(() => {
-    restClient = createRestClient();
-  });
+  const resolveInfo = buildResolveInfoArgument(
+    `
+      {
+        collection(id: "10") {
+          translations {
+            name
+          }
+          id
+          name
+        }
+      }
+    `,
+    [COLLECTION, TRANSLATIONS]
+  );
 
   beforeEach(() => {
-    mockedFetch.mockGetOnce(buildEndpoint(COLLECTION_PATH, { id: 10, type: 'translations' }), {
+    mockedFetch.mockGetOnce(buildEndpoint(COLLECTION_PATH, { id: 10, type: TRANSLATIONS }), {
       body: collectionTranslations,
     });
   });
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   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
-      )
+      resolveCollectionTranslations(collectionDetails, undefined, context, resolveInfo)
     ).resolves.toMatchSnapshot();
   });
 });

package/src/queries/collectionTranslations.ts

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

package/src/queries/company.test.ts

@@ -1,10 +1,10 @@
 import { jest } from '@jest/globals';
-import { COMPANY_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import { COMPANY_PATH } from '@tmdb-graphql-api/rest-client';
 import companyDetails from '@tmdb-graphql-api/test-utils/responses/themoviedb/company/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 { resolveCompany } from './company.ts';
@@ -12,13 +12,16 @@ import { resolveCompany } from './company.ts';
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolveCompany >', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
   const id = 2;
 
-  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(COMPANY_PATH, { id }), {
@@ -28,17 +31,11 @@ describe('resolveCompany >', () => {
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   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();
+    await expect(resolveCompany(undefined, { id: String(id) }, context, info)).resolves.toMatchSnapshot();
   });
 });

package/src/queries/company.ts

@@ -1,23 +1,26 @@
 import { type QueryCompanyArgs } from '@tmdb-graphql-api/schema/types';
-import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
 import { isUndefined, snakeCase } from 'lodash-es';
 import { COMPANY } from '../constants.ts';
-import { type Context, type RawCompany } from '../types.ts';
+import { buildObjArgsResolver } from '../helpers/buildObjArgsResolver.ts';
+import { type RawCompany } from '../types.ts';
 
-export const resolveCompany = async (
-  obj: RawCompany | undefined,
-  args: QueryCompanyArgs,
-  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
-  { fieldName, fieldNodes }: GraphQLResolveInfo
-) => {
+export const resolveCompany = buildObjArgsResolver<
+  RawCompany,
+  QueryCompanyArgs,
+  RawCompany | RawCompany[keyof RawCompany]
+>(COMPANY, async (obj, args, ctx, info) => {
+  const id = obj?.id ?? args.id;
+  const { requestID, restClient, tmdbGuestSessionId } = ctx;
+  const { fieldName } = info;
   const typedFieldName = snakeCase(fieldName) as keyof RawCompany;
 
   if (obj && !isUndefined(obj[typedFieldName])) {
-    return obj[typedFieldName];
+    return {
+      data: obj[typedFieldName],
+      source: 'parentNode',
+    };
   }
 
-  const id = obj ? obj.id : args.id;
-
   const { data, errors, headers } = await restClient.company<RawCompany>(
     {
       pathTemplateData: { id },
@@ -25,15 +28,9 @@ export const resolveCompany = async (
     { 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;
-};
+  return {
+    data: obj ? data?.[typedFieldName] : data,
+    errors,
+    headers,
+  };
+});

package/src/queries/companyAlternativeNames.test.ts

@@ -1,44 +1,59 @@
 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 { COMPANY_PATH } from '@tmdb-graphql-api/rest-client';
+import companyAlternativeNames 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 } from 'fetch-mocked';
-import { type Getta, type ShortcutProperties } from 'getta';
-import { type GraphQLResolveInfo } from 'graphql';
+import { snakeCase } from 'lodash-es';
 import { buildEndpoint } from '../__testUtils__/helpers/buildEndpoint.ts';
+import { buildResolveInfoArgument } from '../__testUtils__/helpers/buildResolveInfoArg.ts';
+import { createMockLogger } from '../__testUtils__/helpers/createMockLogger.ts';
 import { createRestClient } from '../__testUtils__/helpers/createRestClient.ts';
-import { type Context, type RawCompany } from '../types.ts';
+import { ALTERNATIVE_NAMES, COMPANY } from '../constants.ts';
+import { type Context } from '../types.ts';
 import { resolveCompanyAlternativeNames } from './companyAlternativeNames.ts';
 
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolveCompanyAlternativeNames >', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
+  const context = {
+    logger: createMockLogger(jest.fn),
+    restClient: createRestClient(),
+    setCacheMetadata: jest.fn(),
+    tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+  } as unknown as Context;
 
-  beforeAll(() => {
-    restClient = createRestClient();
-  });
+  const apiFieldName = snakeCase(ALTERNATIVE_NAMES);
+
+  const resolveInfo = buildResolveInfoArgument(
+    `
+      {
+        company(id: "10") {
+          alternativeNames {
+            name
+          }
+          id
+          name
+        }
+      }
+    `,
+    [COMPANY, ALTERNATIVE_NAMES]
+  );
 
   beforeEach(() => {
-    mockedFetch.mockGetOnce(buildEndpoint(COMPANY_PATH, { id: 2, type: 'alternative_names' }), {
-      body: companyAlterativeNames,
+    mockedFetch.mockGetOnce(buildEndpoint(COMPANY_PATH, { id: 2, type: apiFieldName }), {
+      body: companyAlternativeNames,
     });
   });
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   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
-      )
+      resolveCompanyAlternativeNames(companyDetails, undefined, context, resolveInfo)
     ).resolves.toMatchSnapshot();
   });
 });

package/src/queries/companyAlternativeNames.ts

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

package/src/queries/companyLogos.test.ts

@@ -1,44 +1,54 @@
 import { jest } from '@jest/globals';
-import { COMPANY_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import { COMPANY_PATH } 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 } from 'fetch-mocked';
-import { type Getta, type ShortcutProperties } from 'getta';
-import { type GraphQLResolveInfo } from 'graphql';
 import { buildEndpoint } from '../__testUtils__/helpers/buildEndpoint.ts';
+import { buildResolveInfoArgument } from '../__testUtils__/helpers/buildResolveInfoArg.ts';
+import { createMockLogger } from '../__testUtils__/helpers/createMockLogger.ts';
 import { createRestClient } from '../__testUtils__/helpers/createRestClient.ts';
-import { type Context, type RawCompany } from '../types.ts';
+import { COMPANY, IMAGES, LOGOS } from '../constants.ts';
+import { type Context } from '../types.ts';
 import { resolveCompanyLogos } from './companyLogos.ts';
 
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolveCompanyImages >', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
+  const context = {
+    logger: createMockLogger(jest.fn),
+    restClient: createRestClient(),
+    setCacheMetadata: jest.fn(),
+    tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+  } as unknown as Context;
 
-  beforeAll(() => {
-    restClient = createRestClient();
-  });
+  const resolveInfo = buildResolveInfoArgument(
+    `
+      {
+        company(id: "10") {
+          logos {
+            filePath
+          }
+          id
+          name
+        }
+      }
+    `,
+    [COMPANY, LOGOS]
+  );
 
   beforeEach(() => {
-    mockedFetch.mockGetOnce(buildEndpoint(COMPANY_PATH, { id: 2, type: 'images' }), {
+    mockedFetch.mockGetOnce(buildEndpoint(COMPANY_PATH, { id: 2, type: IMAGES }), {
       body: companyLogos,
     });
   });
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   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();
+    await expect(resolveCompanyLogos(companyDetails, undefined, context, resolveInfo)).resolves.toMatchSnapshot();
   });
 });

package/src/queries/companyLogos.ts

@@ -1,28 +1,20 @@
-import type { GraphQLResolveInfo } from 'graphql';
-import { GraphQLError } from 'graphql';
-import { COMPANY, IMAGES, LOGOS } from '../constants.ts';
-import type { Context, RawCompany, RawCompanyLogos } from '../types.ts';
+import { COMPANY, IMAGES } from '../constants.ts';
+import { buildObjResolver } from '../helpers/buildObjResolver.ts';
+import type { RawCompany, RawCompanyLogos } from '../types.ts';
+
+export const resolveCompanyLogos = buildObjResolver<RawCompany, RawCompanyLogos['logos']>(COMPANY, async (obj, ctx) => {
+  const { requestID, restClient, tmdbGuestSessionId } = ctx;
 
-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 },
+      pathTemplateData: { id: obj.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;
-};
+  return {
+    data: data?.logos,
+    errors,
+    headers,
+  };
+});

package/src/queries/configuration.test.ts

@@ -1,10 +1,10 @@
 import { jest } from '@jest/globals';
-import { CONFIGURATION_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import { CONFIGURATION_PATH } from '@tmdb-graphql-api/rest-client';
 import configurationBase from '@tmdb-graphql-api/test-utils/responses/themoviedb/configuration/base.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 { resolveConfiguration } from './configuration.ts';
@@ -12,12 +12,14 @@ import { resolveConfiguration } from './configuration.ts';
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolveConfiguration >', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
+  const context = {
+    logger: createMockLogger(jest.fn),
+    restClient: createRestClient(),
+    setCacheMetadata: jest.fn(),
+    tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+  } as unknown as Context;
 
-  beforeAll(() => {
-    restClient = createRestClient();
-  });
+  const info = {} as GraphQLResolveInfo;
 
   beforeEach(() => {
     mockedFetch.mockGetOnce(buildEndpoint(CONFIGURATION_PATH), {
@@ -27,17 +29,11 @@ describe('resolveConfiguration >', () => {
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   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();
+    await expect(resolveConfiguration(undefined, undefined, context, info)).resolves.toMatchSnapshot();
   });
 });

package/src/queries/configuration.ts

@@ -1,22 +1,18 @@
-import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
 import { CONFIGURATION } from '../constants.ts';
-import { type Context, type RawConfiguration } from '../types.ts';
+import { buildNoObjArgsResolver } from '../helpers/buildNoObjArgsResolver.ts';
+import { type RawConfiguration } from '../types.ts';
+
+export const resolveConfiguration = buildNoObjArgsResolver<undefined, RawConfiguration>(CONFIGURATION, async ctx => {
+  const { requestID, restClient, tmdbGuestSessionId } = ctx;
 
-export const resolveConfiguration = async (
-  _obj: undefined,
-  _args: undefined,
-  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
-  { fieldNodes }: GraphQLResolveInfo
-) => {
   const { data, errors, headers } = await restClient.configuration<RawConfiguration>(undefined, {
     requestID,
     tmdbGuestSessionId,
   });
 
-  if (errors?.length) {
-    throw new GraphQLError('Failed to resolve configuration.', { nodes: fieldNodes, originalError: errors[0] });
-  }
-
-  setCacheMetadata(CONFIGURATION, headers);
-  return data;
-};
+  return {
+    data,
+    errors,
+    headers,
+  };
+});