@tmdb-graphql-api/resolvers 0.0.6

package/src/queries/person.test.ts

@@ -0,0 +1,81 @@
+import type { PlainArray } from '@graphql-box/core';
+import { getChildFields, getOperationDefinitions } from '@graphql-box/helpers';
+import { jest } from '@jest/globals';
+import { PERSON_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import { personDetails as personDetailsQuery } from '@tmdb-graphql-api/test-utils/requests/queries/person/details.ts';
+import { personDetailsLg as personDetailsLgQuery } from '@tmdb-graphql-api/test-utils/requests/queries/person/detailsLg.ts';
+import personDetails from '@tmdb-graphql-api/test-utils/responses/themoviedb/person/3/details.json';
+import { mockFetch, polyfillFetch } from 'fetch-mocked';
+import type { FetchResponse, Getta, ShortcutProperties } from 'getta';
+import { type GraphQLResolveInfo, OperationTypeNode, parse } from 'graphql';
+import { buildEndpoint } from '../__testUtils__/helpers/buildEndpoint.ts';
+import { createRestClient } from '../__testUtils__/helpers/createRestClient.ts';
+import { PERSON } from '../constants.ts';
+import type { Context } from '../types.ts';
+import { resolvePerson } from './person.ts';
+
+polyfillFetch();
+const mockedFetch = mockFetch(jest.fn);
+
+describe('resolvePerson >', () => {
+  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
+  const setCacheMetadata = jest.fn();
+  const id = 3;
+
+  beforeAll(() => {
+    restClient = createRestClient();
+  });
+
+  beforeEach(() => {
+    mockedFetch.mockGetOnce(buildEndpoint(PERSON_PATH, { id }), {
+      body: personDetails,
+    });
+  });
+
+  afterEach(async () => {
+    mockedFetch.mockReset();
+    await restClient.cache?.clear();
+  });
+
+  it('should return the correct person details', async () => {
+    const operationDefinition = getOperationDefinitions(parse(personDetailsQuery()), OperationTypeNode.QUERY)[0]!;
+    const { fieldNode } = getChildFields(operationDefinition, { name: PERSON })![0]!;
+
+    await expect(
+      resolvePerson(
+        undefined,
+        { id },
+        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+        { fieldNodes: [fieldNode] } as unknown as GraphQLResolveInfo
+      )
+    ).resolves.toMatchSnapshot();
+  });
+
+  it('should request the correct resources when append to response fields are found', async () => {
+    const operationDefinition = getOperationDefinitions(parse(personDetailsLgQuery()), OperationTypeNode.QUERY)[0]!;
+    const { fieldNode } = getChildFields(operationDefinition, { name: PERSON })![0]!;
+
+    const personFetchMock = jest
+      .fn<(...args: PlainArray) => Promise<FetchResponse>>()
+      .mockResolvedValue({ data: {} } as FetchResponse);
+
+    await resolvePerson(
+      undefined,
+      { id },
+      {
+        restClient: { person: personFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
+        setCacheMetadata,
+        tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+      } as unknown as Context,
+      { fieldNodes: [fieldNode] } as unknown as GraphQLResolveInfo
+    );
+
+    expect(personFetchMock.mock.calls[0]![0]).toEqual(
+      expect.objectContaining({
+        queryParams: {
+          append_to_response: 'movie_credits,images,tv_credits',
+        },
+      })
+    );
+  });
+});

package/src/queries/person.ts

@@ -0,0 +1,67 @@
+import type { QueryPersonArgs } from '@tmdb-graphql-api/schema';
+import { GraphQLError } from 'graphql';
+import type { GraphQLResolveInfo } from 'graphql';
+import { isUndefined, snakeCase } from 'lodash-es';
+import {
+  COMBINED_CREDITS,
+  EXTERNAL_IDS,
+  IMAGES,
+  MOVIE_CREDITS,
+  PERSON,
+  PROFILES,
+  TRANSLATIONS,
+  TV_CREDITS,
+} from '../constants.ts';
+import { getAppendToResponseKeys } from '../helpers/getAppendToResponseKeys.ts';
+import type { Context, RawPerson, RawPersonWithAppendToResponse } from '../types.ts';
+
+const appendToResponse = {
+  [COMBINED_CREDITS]: snakeCase(COMBINED_CREDITS),
+  [EXTERNAL_IDS]: snakeCase(EXTERNAL_IDS),
+  [MOVIE_CREDITS]: snakeCase(MOVIE_CREDITS),
+  [PROFILES]: IMAGES,
+  [TRANSLATIONS]: TRANSLATIONS,
+  [TV_CREDITS]: snakeCase(TV_CREDITS),
+};
+
+export const resolvePerson = async (
+  obj: RawPerson | undefined,
+  args: QueryPersonArgs,
+  { fragmentDefinitions, requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
+  { fieldName, fieldNodes }: GraphQLResolveInfo
+) => {
+  const typedFieldName = snakeCase(fieldName) as keyof RawPerson;
+
+  if (obj && !isUndefined(obj[typedFieldName])) {
+    return obj[typedFieldName];
+  }
+
+  const id = obj ? obj.id : args.id;
+  const appendToResponseKeys = getAppendToResponseKeys(fieldNodes[0]!, appendToResponse, fragmentDefinitions);
+
+  const { data, errors, headers } = await restClient.person<RawPersonWithAppendToResponse>(
+    {
+      pathTemplateData: { id },
+      ...(appendToResponseKeys.length > 0
+        ? {
+            queryParams: {
+              append_to_response: appendToResponseKeys.join(','),
+            },
+          }
+        : {}),
+    },
+    { requestID, tmdbGuestSessionId }
+  );
+
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${PERSON} ${id}.`, { nodes: fieldNodes, originalError: errors[0] });
+  }
+
+  if (obj) {
+    setCacheMetadata(`${PERSON}.${fieldName}`, headers);
+    return data![typedFieldName];
+  }
+
+  setCacheMetadata(PERSON, headers);
+  return appendToResponseKeys.length > 0 ? { ...data, __headers: headers } : data;
+};

package/src/queries/personCombinedCredits.test.ts

@@ -0,0 +1,99 @@
+import type { PlainArray } from '@graphql-box/core';
+import { jest } from '@jest/globals';
+import { PERSON_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import personCombinedCredits from '@tmdb-graphql-api/test-utils/responses/themoviedb/person/3/combinedCredits.json';
+import personDetails from '@tmdb-graphql-api/test-utils/responses/themoviedb/person/3/details.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, RawPerson, RawPersonWithAppendToResponse } from '../types.ts';
+import { resolvePersonCombinedCredits } from './personCombinedCredits.ts';
+
+polyfillFetch();
+const mockedFetch = mockFetch(jest.fn);
+
+describe('resolvePersonCombinedCredits >', () => {
+  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
+  const setCacheMetadata = jest.fn();
+  const personId = 3;
+
+  beforeAll(() => {
+    restClient = createRestClient();
+  });
+
+  beforeEach(() => {
+    mockedFetch.mockGetOnce(buildEndpoint(PERSON_PATH, { id: personId, type: 'combined_credits' }), {
+      body: personCombinedCredits,
+    });
+  });
+
+  afterEach(async () => {
+    mockedFetch.mockReset();
+    await restClient.cache?.clear();
+  });
+
+  it('should return the person combined credits', async () => {
+    await expect(
+      resolvePersonCombinedCredits(
+        personDetails as RawPerson,
+        undefined,
+        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+        {} as GraphQLResolveInfo
+      )
+    ).resolves.toMatchSnapshot();
+  });
+
+  describe('when raw person data has combined credits', () => {
+    it('should return the correct response', async () => {
+      const personFetchMock = jest
+        .fn<(...args: PlainArray) => Promise<FetchResponse>>()
+        .mockResolvedValue({ data: {} } as FetchResponse);
+
+      const { id, ...rest } = personCombinedCredits;
+
+      await expect(
+        resolvePersonCombinedCredits(
+          {
+            ...personDetails,
+            __headers: new Headers(),
+            combined_credits: rest,
+          } as unknown as RawPersonWithAppendToResponse,
+          undefined,
+          {
+            restClient: { person: personFetchMock } 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 personFetchMock = jest
+        .fn<(...args: PlainArray) => Promise<FetchResponse>>()
+        .mockResolvedValue({ data: {} } as FetchResponse);
+
+      const { id, ...rest } = personCombinedCredits;
+
+      await resolvePersonCombinedCredits(
+        {
+          ...personDetails,
+          __headers: new Headers(),
+          combined_credits: rest,
+        } as unknown as RawPersonWithAppendToResponse,
+        undefined,
+        {
+          restClient: { person: personFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
+          setCacheMetadata,
+          tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+        } as unknown as Context,
+        {} as GraphQLResolveInfo
+      );
+
+      expect(personFetchMock).not.toHaveBeenCalled();
+    });
+  });
+});

package/src/queries/personCombinedCredits.ts

@@ -0,0 +1,35 @@
+import { GraphQLError } from 'graphql';
+import type { GraphQLResolveInfo } from 'graphql';
+import { snakeCase } from 'lodash-es';
+import { COMBINED_CREDITS, PERSON } from '../constants.ts';
+import type { Context, RawPersonCombinedCredits, RawPersonWithAppendToResponse } from '../types.ts';
+
+export const resolvePersonCombinedCredits = async (
+  obj: RawPersonWithAppendToResponse & { __headers?: Headers },
+  _args: undefined,
+  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
+  { fieldNodes }: GraphQLResolveInfo
+) => {
+  if (obj.combined_credits && obj.__headers) {
+    setCacheMetadata(`${PERSON}.${COMBINED_CREDITS}`, obj.__headers);
+    return obj.combined_credits;
+  }
+
+  const { data, errors, headers } = await restClient.person<RawPersonCombinedCredits>(
+    {
+      pathTemplateData: { id: obj.id, type: snakeCase(COMBINED_CREDITS) },
+    },
+    { requestID, tmdbGuestSessionId }
+  );
+
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${PERSON} ${obj.id} ${COMBINED_CREDITS}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0],
+    });
+  }
+
+  setCacheMetadata(`${PERSON}.${COMBINED_CREDITS}`, headers);
+  const { id: personId, ...rest } = data!;
+  return rest;
+};

package/src/queries/personExternalIds.test.ts

@@ -0,0 +1,99 @@
+import type { PlainArray } from '@graphql-box/core';
+import { jest } from '@jest/globals';
+import { PERSON_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import personDetails from '@tmdb-graphql-api/test-utils/responses/themoviedb/person/3/details.json';
+import personExternalIds from '@tmdb-graphql-api/test-utils/responses/themoviedb/person/3/externalIds.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, RawPerson, RawPersonWithAppendToResponse } from '../types.ts';
+import { resolvePersonExternalIds } from './personExternalIds.ts';
+
+polyfillFetch();
+const mockedFetch = mockFetch(jest.fn);
+
+describe('resolvePersonExternalIds >', () => {
+  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
+  const setCacheMetadata = jest.fn();
+  const personId = 3;
+
+  beforeAll(() => {
+    restClient = createRestClient();
+  });
+
+  beforeEach(() => {
+    mockedFetch.mockGetOnce(buildEndpoint(PERSON_PATH, { id: personId, type: 'external_ids' }), {
+      body: personExternalIds,
+    });
+  });
+
+  afterEach(async () => {
+    mockedFetch.mockReset();
+    await restClient.cache?.clear();
+  });
+
+  it('should return the person external IDs', async () => {
+    await expect(
+      resolvePersonExternalIds(
+        personDetails as unknown as RawPerson,
+        undefined,
+        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+        {} as GraphQLResolveInfo
+      )
+    ).resolves.toMatchSnapshot();
+  });
+
+  describe('when raw person data has external IDs', () => {
+    it('should return the correct response', async () => {
+      const personFetchMock = jest
+        .fn<(...args: PlainArray) => Promise<FetchResponse>>()
+        .mockResolvedValue({ data: {} } as FetchResponse);
+
+      const { id, ...rest } = personExternalIds;
+
+      await expect(
+        resolvePersonExternalIds(
+          {
+            ...personDetails,
+            __headers: new Headers(),
+            external_ids: rest,
+          } as unknown as RawPersonWithAppendToResponse,
+          undefined,
+          {
+            restClient: { person: personFetchMock } 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 personFetchMock = jest
+        .fn<(...args: PlainArray) => Promise<FetchResponse>>()
+        .mockResolvedValue({ data: {} } as FetchResponse);
+
+      const { id, ...rest } = personExternalIds;
+
+      await resolvePersonExternalIds(
+        {
+          ...personDetails,
+          __headers: new Headers(),
+          external_ids: rest,
+        } as unknown as RawPersonWithAppendToResponse,
+        undefined,
+        {
+          restClient: { person: personFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
+          setCacheMetadata,
+          tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+        } as unknown as Context,
+        {} as GraphQLResolveInfo
+      );
+
+      expect(personFetchMock).not.toHaveBeenCalled();
+    });
+  });
+});

package/src/queries/personExternalIds.ts

@@ -0,0 +1,35 @@
+import { GraphQLError } from 'graphql';
+import type { GraphQLResolveInfo } from 'graphql';
+import { snakeCase } from 'lodash-es';
+import { EXTERNAL_IDS, PERSON } from '../constants.ts';
+import type { Context, RawPersonExternalIds, RawPersonWithAppendToResponse } from '../types.ts';
+
+export const resolvePersonExternalIds = async (
+  obj: RawPersonWithAppendToResponse & { __headers?: Headers },
+  _args: undefined,
+  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
+  { fieldNodes }: GraphQLResolveInfo
+) => {
+  if (obj.external_ids && obj.__headers) {
+    setCacheMetadata(`${PERSON}.${EXTERNAL_IDS}`, obj.__headers);
+    return obj.external_ids;
+  }
+
+  const { data, errors, headers } = await restClient.person<RawPersonExternalIds>(
+    {
+      pathTemplateData: { id: obj.id, type: snakeCase(EXTERNAL_IDS) },
+    },
+    { requestID, tmdbGuestSessionId }
+  );
+
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${PERSON} ${obj.id} ${EXTERNAL_IDS}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0],
+    });
+  }
+
+  setCacheMetadata(`${PERSON}.${EXTERNAL_IDS}`, headers);
+  const { id: personId, ...rest } = data!;
+  return rest;
+};

package/src/queries/personMovieCredits.test.ts

@@ -0,0 +1,99 @@
+import type { PlainArray } from '@graphql-box/core';
+import { jest } from '@jest/globals';
+import { PERSON_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import personDetails from '@tmdb-graphql-api/test-utils/responses/themoviedb/person/3/details.json';
+import personMovieCredits from '@tmdb-graphql-api/test-utils/responses/themoviedb/person/3/movieCredits.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, RawPerson, RawPersonWithAppendToResponse } from '../types.ts';
+import { resolvePersonMovieCredits } from './personMovieCredits.ts';
+
+polyfillFetch();
+const mockedFetch = mockFetch(jest.fn);
+
+describe('resolvePersonMovieCredits >', () => {
+  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
+  const setCacheMetadata = jest.fn();
+  const personId = 3;
+
+  beforeAll(() => {
+    restClient = createRestClient();
+  });
+
+  beforeEach(() => {
+    mockedFetch.mockGetOnce(buildEndpoint(PERSON_PATH, { id: personId, type: 'movie_credits' }), {
+      body: personMovieCredits,
+    });
+  });
+
+  afterEach(async () => {
+    mockedFetch.mockReset();
+    await restClient.cache?.clear();
+  });
+
+  it('should return the person movie credits', async () => {
+    await expect(
+      resolvePersonMovieCredits(
+        personDetails as unknown as RawPerson,
+        undefined,
+        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+        {} as GraphQLResolveInfo
+      )
+    ).resolves.toMatchSnapshot();
+  });
+
+  describe('when raw person data has movie credits', () => {
+    it('should return the correct response', async () => {
+      const personFetchMock = jest
+        .fn<(...args: PlainArray) => Promise<FetchResponse>>()
+        .mockResolvedValue({ data: {} } as FetchResponse);
+
+      const { id, ...rest } = personMovieCredits;
+
+      await expect(
+        resolvePersonMovieCredits(
+          {
+            ...personDetails,
+            __headers: new Headers(),
+            movie_credits: rest,
+          } as unknown as RawPersonWithAppendToResponse,
+          undefined,
+          {
+            restClient: { person: personFetchMock } 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 personFetchMock = jest
+        .fn<(...args: PlainArray) => Promise<FetchResponse>>()
+        .mockResolvedValue({ data: {} } as FetchResponse);
+
+      const { id, ...rest } = personMovieCredits;
+
+      await resolvePersonMovieCredits(
+        {
+          ...personDetails,
+          __headers: new Headers(),
+          movie_credits: rest,
+        } as unknown as RawPersonWithAppendToResponse,
+        undefined,
+        {
+          restClient: { person: personFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
+          setCacheMetadata,
+          tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+        } as unknown as Context,
+        {} as GraphQLResolveInfo
+      );
+
+      expect(personFetchMock).not.toHaveBeenCalled();
+    });
+  });
+});

package/src/queries/personMovieCredits.ts

@@ -0,0 +1,35 @@
+import { GraphQLError } from 'graphql';
+import type { GraphQLResolveInfo } from 'graphql';
+import { snakeCase } from 'lodash-es';
+import { MOVIE_CREDITS, PERSON } from '../constants.ts';
+import type { Context, RawPersonMovieCredits, RawPersonWithAppendToResponse } from '../types.ts';
+
+export const resolvePersonMovieCredits = async (
+  obj: RawPersonWithAppendToResponse & { __headers?: Headers },
+  _args: undefined,
+  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
+  { fieldNodes }: GraphQLResolveInfo
+) => {
+  if (obj.movie_credits && obj.__headers) {
+    setCacheMetadata(`${PERSON}.${MOVIE_CREDITS}`, obj.__headers);
+    return obj.movie_credits;
+  }
+
+  const { data, errors, headers } = await restClient.person<RawPersonMovieCredits>(
+    {
+      pathTemplateData: { id: obj.id, type: snakeCase(MOVIE_CREDITS) },
+    },
+    { requestID, tmdbGuestSessionId }
+  );
+
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${PERSON} ${obj.id} ${MOVIE_CREDITS}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0],
+    });
+  }
+
+  setCacheMetadata(`${PERSON}.${MOVIE_CREDITS}`, headers);
+  const { id: personId, ...rest } = data!;
+  return rest;
+};

package/src/queries/personProfiles.test.ts

@@ -0,0 +1,98 @@
+import type { PlainArray } from '@graphql-box/core';
+import { jest } from '@jest/globals';
+import { PERSON_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import personDetails from '@tmdb-graphql-api/test-utils/responses/themoviedb/person/3/details.json';
+import personProfiles from '@tmdb-graphql-api/test-utils/responses/themoviedb/person/3/images.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, RawPerson, RawPersonWithAppendToResponse } from '../types.ts';
+import { resolvePersonProfiles } from './personProfiles.ts';
+
+polyfillFetch();
+const mockedFetch = mockFetch(jest.fn);
+
+describe('resolvePersonProfiles >', () => {
+  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
+  const setCacheMetadata = jest.fn();
+
+  beforeAll(() => {
+    restClient = createRestClient();
+  });
+
+  beforeEach(() => {
+    mockedFetch.mockGetOnce(buildEndpoint(PERSON_PATH, { id: 3, type: 'images' }), {
+      body: personProfiles,
+    });
+  });
+
+  afterEach(async () => {
+    mockedFetch.mockReset();
+    await restClient.cache?.clear();
+  });
+
+  it('should return the person profiles', async () => {
+    await expect(
+      resolvePersonProfiles(
+        personDetails as RawPerson,
+        undefined,
+        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
+        {} as GraphQLResolveInfo
+      )
+    ).resolves.toMatchSnapshot();
+  });
+
+  describe('when raw person data has images', () => {
+    it('should return the correct response', async () => {
+      const personFetchMock = jest
+        .fn<(...args: PlainArray) => Promise<FetchResponse>>()
+        .mockResolvedValue({ data: {} } as FetchResponse);
+
+      const { id, ...rest } = personProfiles;
+
+      await expect(
+        resolvePersonProfiles(
+          {
+            ...personDetails,
+            __headers: new Headers(),
+            images: rest,
+          } as unknown as RawPersonWithAppendToResponse,
+          undefined,
+          {
+            restClient: { person: personFetchMock } 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 personFetchMock = jest
+        .fn<(...args: PlainArray) => Promise<FetchResponse>>()
+        .mockResolvedValue({ data: {} } as FetchResponse);
+
+      const { id, ...rest } = personProfiles;
+
+      await resolvePersonProfiles(
+        {
+          ...personDetails,
+          __headers: new Headers(),
+          images: rest,
+        } as unknown as RawPersonWithAppendToResponse,
+        undefined,
+        {
+          restClient: { person: personFetchMock } as unknown as Getta & ShortcutProperties<ShortcutMethodNames>,
+          setCacheMetadata,
+          tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+        } as unknown as Context,
+        {} as GraphQLResolveInfo
+      );
+
+      expect(personFetchMock).not.toHaveBeenCalled();
+    });
+  });
+});

package/src/queries/personProfiles.ts

@@ -0,0 +1,33 @@
+import type { GraphQLResolveInfo } from 'graphql';
+import { GraphQLError } from 'graphql';
+import { IMAGES, PERSON, PROFILES } from '../constants.ts';
+import type { Context, RawPersonProfiles, RawPersonWithAppendToResponse } from '../types.ts';
+
+export const resolvePersonProfiles = async (
+  obj: RawPersonWithAppendToResponse & { __headers?: Headers },
+  _args: undefined,
+  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
+  { fieldNodes }: GraphQLResolveInfo
+) => {
+  if (obj.images && obj.__headers) {
+    setCacheMetadata(`${PERSON}.${PROFILES}`, obj.__headers);
+    return obj.images.profiles;
+  }
+
+  const { data, errors, headers } = await restClient.person<RawPersonProfiles>(
+    {
+      pathTemplateData: { id: obj.id, type: IMAGES },
+    },
+    { requestID, tmdbGuestSessionId }
+  );
+
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${PERSON} ${obj.id} ${PROFILES}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0],
+    });
+  }
+
+  setCacheMetadata(`${PERSON}.${PROFILES}`, headers);
+  return data!.profiles;
+};