@tmdb-graphql-api/resolvers 0.0.6

package/dist/esm/index.mjs

@@ -0,0 +1,3432 @@
+import { snakeCase, isUndefined, capitalize } from 'lodash-es';
+import { schema } from '@tmdb-graphql-api/schema';
+import { Kind, GraphQLError } from 'graphql';
+import { Core } from '@cachemap/core';
+import { init as init$1 } from '@cachemap/map';
+import { init } from '@cachemap/reaper';
+import { removeConnectionInputOptions, makeConnectionResolver } from '@graphql-box/connection-resolver';
+import { encode, decode } from 'js-base64';
+import 'core-js/modules/es.array.push.js';
+import { getChildFields, getName } from '@graphql-box/helpers';
+
+const defaultFieldResolver = (object, _arguments, _context, {
+  fieldNodes
+}) => {
+  const currentField = fieldNodes[0];
+  const {
+    value: name
+  } = currentField.name;
+  if (Object.prototype.hasOwnProperty.call(object, name)) {
+    return object[name];
+  }
+  return object[snakeCase(name)];
+};
+
+const typeMap = schema.getTypeMap();
+const typePropNames = Object.keys(typeMap).reduce((acc, key) => {
+  const type = typeMap[key];
+  if (type?.astNode?.kind === Kind.OBJECT_TYPE_DEFINITION) {
+    acc[key] = Object.keys(type.getFields());
+  }
+  return acc;
+}, {});
+
+const makeFallbackFieldResolvers = (typeName, resolver) => {
+  const propNames = typePropNames[typeName];
+  return propNames.reduce((acc, propName) => {
+    acc[propName] = resolver;
+    return acc;
+  }, {});
+};
+
+const ALTERNATIVE_NAMES = 'alternativeNames';
+const ALTERNATIVE_TITLES = 'alternativeTitles';
+const BACKDROPS = 'backdrops';
+const CAST = 'cast';
+const CERTIFICATIONS = 'certifications';
+const COLLECTION = 'collection';
+const COMBINED_CREDITS = 'combinedCredits';
+const COMPANY = 'company';
+const CONFIGURATION = 'configuration';
+const CONTENT_RATINGS = 'contentRatings';
+const COUNTRIES = 'countries';
+const CREDIT = 'credit';
+const CREDITS = 'credits';
+const CREW = 'crew';
+const DISCOVER_MOVIES = 'discoverMovies';
+const DISCOVER_TV = 'discoverTv';
+const EPISODE = 'episode';
+const EPISODE_GROUPS = 'episodeGroups';
+const EXTERNAL_IDS = 'externalIds';
+const FIND = 'find';
+const GENRES = 'genres';
+const IMAGES = 'images';
+const JOBS = 'jobs';
+const KEYWORD = 'keyword';
+const KEYWORDS = 'keywords';
+const LANGUAGES = 'languages';
+const LOGOS = 'logos';
+const MOVIE = 'movie';
+const MOVIE_CREDITS = 'movieCredits';
+const NETWORK = 'network';
+const PERSON = 'person';
+const POSTERS = 'posters';
+const PRIMARY_TRANSLATIONS = 'primaryTranslations';
+const PROFILES = 'profiles';
+const RATED = 'rated';
+const RECOMMENDATIONS = 'recommendations';
+const RELEASE_DATES = 'releaseDates';
+const REVIEW = 'review';
+const REVIEWS = 'reviews';
+const SEARCH = 'search';
+const SEASON = 'season';
+const SIMILAR = 'similar';
+const SIMILAR_MOVIES = 'similarMovies';
+const SIMILAR_TV_SHOWS = 'similarTvShows';
+const STILLS = 'stills';
+const TIMEZONES = 'timezones';
+const TRANSLATIONS = 'translations';
+const TRENDING = 'trending';
+const TV = 'tv';
+const TV_CREDITS = 'tvCredits';
+const VIDEOS = 'videos';
+const WATCH_PROVIDERS = 'watchProviders';
+
+const resolveCertifications = async (_obj, {
+  screenType
+}, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldNodes
+}) => {
+  const {
+    data,
+    errors
+  } = await restClient.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'
+  });
+  return data?.certifications;
+};
+
+const resolveCollection = async (obj, args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldName,
+  fieldNodes
+}) => {
+  const typedFieldName = snakeCase(fieldName);
+  if (obj && !isUndefined(obj[typedFieldName])) {
+    return obj[typedFieldName];
+  }
+  const id = obj ? obj.id : args.id;
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.collection({
+    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;
+};
+
+const resolveCollectionImages = async ({
+  id
+}, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldName,
+  fieldNodes
+}) => {
+  const typedFieldName = fieldName;
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.collection({
+    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];
+};
+
+const resolveCollectionTranslations = async ({
+  id
+}, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldNodes
+}) => {
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.collection({
+    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;
+};
+
+const resolveCompany = async (obj, args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldName,
+  fieldNodes
+}) => {
+  const typedFieldName = snakeCase(fieldName);
+  if (obj && !isUndefined(obj[typedFieldName])) {
+    return obj[typedFieldName];
+  }
+  const id = obj ? obj.id : args.id;
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.company({
+    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;
+};
+
+const resolveCompanyAlternativeNames = async ({
+  id
+}, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldNodes
+}) => {
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.company({
+    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;
+};
+
+const resolveCompanyLogos = async ({
+  id
+}, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldNodes
+}) => {
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.company({
+    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;
+};
+
+const resolveConfiguration = async (_obj, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldNodes
+}) => {
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.configuration(undefined, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError('Failed to resolve configuration.', {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  setCacheMetadata(CONFIGURATION, headers);
+  return data;
+};
+
+const resolveConfigurationCountries = async (_obj, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldNodes
+}) => {
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.configuration({
+    pathTemplateData: {
+      type: COUNTRIES
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${CONFIGURATION} ${COUNTRIES}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  setCacheMetadata(`${CONFIGURATION}.${COUNTRIES}`, headers);
+  return data;
+};
+
+const resolveConfigurationJobs = async (_obj, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldNodes
+}) => {
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.configuration({
+    pathTemplateData: {
+      type: JOBS
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${CONFIGURATION} ${JOBS}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  setCacheMetadata(`${CONFIGURATION}.${JOBS}`, headers);
+  return data;
+};
+
+const resolveConfigurationLanguages = async (_obj, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldNodes
+}) => {
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.configuration({
+    pathTemplateData: {
+      type: LANGUAGES
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${CONFIGURATION} ${LANGUAGES}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  setCacheMetadata(`${CONFIGURATION}.${LANGUAGES}`, headers);
+  return data;
+};
+
+const resolveConfigurationPrimaryTranslations = async (_obj, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldNodes
+}) => {
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.configuration({
+    pathTemplateData: {
+      type: snakeCase(PRIMARY_TRANSLATIONS)
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${CONFIGURATION} ${PRIMARY_TRANSLATIONS}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  setCacheMetadata(`${CONFIGURATION}.${PRIMARY_TRANSLATIONS}`, headers);
+  return data;
+};
+
+const resolveConfigurationTimezones = async (_obj, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldNodes
+}) => {
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.configuration({
+    pathTemplateData: {
+      type: TIMEZONES
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${CONFIGURATION} ${TIMEZONES}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  setCacheMetadata(`${CONFIGURATION}.${TIMEZONES}`, headers);
+  return data;
+};
+
+const resolveCredit = async (_obj, {
+  id
+}, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldNodes
+}) => {
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.credit({
+    pathTemplateData: {
+      id
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${CREDIT} ${id}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  setCacheMetadata(CREDIT, headers);
+  return data;
+};
+
+const formatDirectionalSuffixes = props => Object.keys(props).reduce((accumulator, propertyName) => {
+  if (propertyName === 'sort_by') {
+    accumulator[propertyName] = props[propertyName].toLowerCase().replace(/_([a-z]+)$/, '.$1');
+  } else if (propertyName.endsWith('_gte') || propertyName.endsWith('_lte')) {
+    accumulator[propertyName.replace(/_([a-z]+)$/, '.$1')] = props[propertyName];
+  } else {
+    accumulator[propertyName] = props[propertyName];
+  }
+  return accumulator;
+}, {});
+
+const removeNullValues = props => Object.keys(props).reduce((acc, propName) => {
+  if (props[propName] === null) {
+    return acc;
+  }
+  acc[propName] = props[propName];
+  return acc;
+}, {});
+
+const snakeCasePropNames = props => Object.keys(props).reduce((snakeCased, propName) => {
+  snakeCased[snakeCase(propName)] = props[propName];
+  return snakeCased;
+}, {});
+
+const formatQueryParams = args => formatDirectionalSuffixes(snakeCasePropNames(removeNullValues(removeConnectionInputOptions(args))));
+
+const createMakeCursors$a = (_obj, args) => {
+  const groupCursor = `${JSON.stringify(removeNullValues(removeConnectionInputOptions(args)))}::${DISCOVER_MOVIES}`;
+  return {
+    makeGroupCursor: () => encode(groupCursor),
+    makeIDCursor: id => encode(`${id}::${groupCursor}`)
+  };
+};
+const createResourceResolver$a = (_obj, args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}) => async ({
+  page
+}) => {
+  const result = await restClient.discover({
+    pathTemplateData: {
+      type: MOVIE
+    },
+    queryParams: {
+      ...formatQueryParams(args),
+      page
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (result.data) {
+    setCacheMetadata(DISCOVER_MOVIES, result.headers);
+  }
+  return result;
+};
+const cursorCache$a = new Core({
+  name: 'DISCOVER_MOVIES_CONNECTION_RESOLVER',
+  reaper: init({
+    interval: 300_000
+  }),
+  store: init$1(),
+  type: 'GRAPHQL'
+});
+const getters$a = {
+  nodes: ({
+    results
+  }) => results,
+  page: ({
+    page
+  }) => page,
+  totalPages: ({
+    total_pages
+  }) => total_pages,
+  totalResults: ({
+    total_results
+  }) => total_results
+};
+const resolveDiscoverMovies = makeConnectionResolver({
+  createMakeCursors: createMakeCursors$a,
+  createResourceResolver: createResourceResolver$a,
+  cursorCache: cursorCache$a,
+  getters: getters$a,
+  resultsPerPage: 20
+});
+
+const createMakeCursors$9 = (_obj, args) => {
+  const groupCursor = `${JSON.stringify(removeNullValues(removeConnectionInputOptions(args)))}::${DISCOVER_TV}`;
+  return {
+    makeGroupCursor: () => encode(groupCursor),
+    makeIDCursor: id => encode(`${id}::${groupCursor}`)
+  };
+};
+const createResourceResolver$9 = (_obj, args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}) => async ({
+  page
+}) => {
+  const result = await restClient.discover({
+    pathTemplateData: {
+      type: TV
+    },
+    queryParams: {
+      ...formatQueryParams(args),
+      page
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (result.data) {
+    setCacheMetadata(DISCOVER_TV, result.headers);
+  }
+  return result;
+};
+const cursorCache$9 = new Core({
+  name: 'DISCOVER_TV_CONNECTION_RESOLVER',
+  reaper: init({
+    interval: 300_000
+  }),
+  store: init$1(),
+  type: 'GRAPHQL'
+});
+const getters$9 = {
+  nodes: ({
+    results
+  }) => results,
+  page: ({
+    page
+  }) => page,
+  totalPages: ({
+    total_pages
+  }) => total_pages,
+  totalResults: ({
+    total_results
+  }) => total_results
+};
+const resolveDiscoverTv = makeConnectionResolver({
+  createMakeCursors: createMakeCursors$9,
+  createResourceResolver: createResourceResolver$9,
+  cursorCache: cursorCache$9,
+  getters: getters$9,
+  resultsPerPage: 20
+});
+
+const encodeId = obj => encode(JSON.stringify(obj));
+
+const getAppendToResponseKeys = (parentFieldNode, appendToResponse, fragmentDefinitions) => (getChildFields(parentFieldNode, {
+  fragmentDefinitions
+}) ?? []).reduce((acc, {
+  fieldNode
+}) => {
+  const name = getName(fieldNode);
+  if (!name) {
+    return acc;
+  }
+  const key = appendToResponse[name];
+  if (!key) {
+    return acc;
+  }
+  if (!acc.includes(key)) {
+    acc.push(key);
+  }
+  return acc;
+}, []);
+
+const decodeId = id => JSON.parse(decode(id));
+
+const getTvIdSeasonAndEpisode = (obj, args) => {
+  let id;
+  let seasonNumber;
+  let episodeNumber;
+  if (obj) {
+    id = obj.tv_show_id;
+    seasonNumber = obj.season_number;
+    episodeNumber = 'episode_number' in obj ? obj.episode_number : undefined;
+  } else {
+    const parsed = decodeId(args.id);
+    id = parsed.id;
+    seasonNumber = parsed.seasonNumber;
+    episodeNumber = parsed.episodeNumber;
+  }
+  return {
+    episodeNumber,
+    id,
+    seasonNumber
+  };
+};
+
+const appendToResponse$4 = {
+  [EXTERNAL_IDS]: snakeCase(EXTERNAL_IDS),
+  [TRANSLATIONS]: TRANSLATIONS,
+  [VIDEOS]: VIDEOS,
+  cast: CREDITS,
+  crew: CREDITS,
+  guestStars: CREDITS,
+  stills: IMAGES
+};
+const resolveEpisode = async (obj, args, {
+  fragmentDefinitions,
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldName,
+  fieldNodes
+}) => {
+  const typedFieldName = snakeCase(fieldName);
+  const {
+    episodeNumber,
+    id,
+    seasonNumber
+  } = getTvIdSeasonAndEpisode(obj, args);
+  if (obj && !isUndefined(obj[typedFieldName])) {
+    return typedFieldName === 'id' ? encodeId({
+      id,
+      seasonNumber,
+      ...(episodeNumber ? {
+        episodeNumber
+      } : {})
+    }) : obj[typedFieldName];
+  }
+  const appendToResponseKeys = getAppendToResponseKeys(fieldNodes[0], appendToResponse$4, fragmentDefinitions);
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.episode({
+    pathTemplateData: {
+      episodeNumber,
+      id,
+      seasonNumber
+    },
+    ...(appendToResponseKeys.length > 0 ? {
+      queryParams: {
+        append_to_response: appendToResponseKeys.join(',')
+      }
+    } : {})
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${TV} show ${id} ${SEASON} ${seasonNumber} ${EPISODE} ${episodeNumber}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  const rawEpisode = data;
+  rawEpisode.id = encodeId({
+    id,
+    seasonNumber,
+    ...(episodeNumber ? {
+      episodeNumber
+    } : {})
+  });
+  if (!rawEpisode.tv_show_id) {
+    rawEpisode.tv_show_id = id;
+  }
+  if (obj) {
+    setCacheMetadata(`${EPISODE}.${fieldName}`, headers);
+    return rawEpisode[typedFieldName];
+  }
+  setCacheMetadata(EPISODE, headers);
+  return appendToResponseKeys.length > 0 ? {
+    ...rawEpisode,
+    __headers: headers
+  } : rawEpisode;
+};
+
+const resolveEpisodeCredits = async (obj, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldName,
+  fieldNodes
+}) => {
+  const typedFieldName = snakeCase(fieldName);
+  if (obj.credits && obj.__headers) {
+    setCacheMetadata(`${EPISODE}.${fieldName}`, obj.__headers);
+    return obj.credits[typedFieldName];
+  }
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.episode({
+    pathTemplateData: {
+      episodeNumber: obj.episode_number,
+      id: obj.tv_show_id,
+      seasonNumber: obj.season_number,
+      type: CREDITS
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${TV} show ${obj.tv_show_id} ${SEASON} ${obj.season_number} ${EPISODE} ${obj.episode_number} ${fieldName}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  setCacheMetadata(`${EPISODE}.${fieldName}`, headers);
+  return data[typedFieldName];
+};
+
+const resolveEpisodeExternalIds = async (obj, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldNodes
+}) => {
+  if (obj.external_ids && obj.__headers) {
+    setCacheMetadata(`${EPISODE}.${EXTERNAL_IDS}`, obj.__headers);
+    return obj.external_ids;
+  }
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.episode({
+    pathTemplateData: {
+      episodeNumber: obj.episode_number,
+      id: obj.tv_show_id,
+      seasonNumber: obj.season_number,
+      type: snakeCase(EXTERNAL_IDS)
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${TV} show ${obj.tv_show_id} ${SEASON} ${obj.season_number} ${EPISODE} ${obj.episode_number} ${EXTERNAL_IDS}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  setCacheMetadata(`${EPISODE}.${EXTERNAL_IDS}`, headers);
+  const {
+    id: movieId,
+    ...rest
+  } = data;
+  return rest;
+};
+
+const resolveEpisodeStills = async (obj, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldNodes
+}) => {
+  if (obj.images && obj.__headers) {
+    setCacheMetadata(`${EPISODE}.${STILLS}`, obj.__headers);
+    return obj.images.stills;
+  }
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.episode({
+    pathTemplateData: {
+      episodeNumber: obj.episode_number,
+      id: obj.tv_show_id,
+      seasonNumber: obj.season_number,
+      type: IMAGES
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${TV} show ${obj.tv_show_id} ${SEASON} ${obj.season_number} ${EPISODE} ${obj.episode_number} ${STILLS}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  setCacheMetadata(`${EPISODE}.${STILLS}`, headers);
+  return data.stills;
+};
+
+const resolveEpisodeTranslations = async (obj, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldNodes
+}) => {
+  if (obj.translations && obj.__headers) {
+    setCacheMetadata(`${EPISODE}.${TRANSLATIONS}`, obj.__headers);
+    return obj.translations.translations;
+  }
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.episode({
+    pathTemplateData: {
+      episodeNumber: obj.episode_number,
+      id: obj.tv_show_id,
+      seasonNumber: obj.season_number,
+      type: TRANSLATIONS
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${TV} show ${obj.tv_show_id} ${SEASON} ${obj.season_number} ${EPISODE} ${obj.episode_number} ${TRANSLATIONS}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  setCacheMetadata(`${EPISODE}.${TRANSLATIONS}`, headers);
+  return data?.translations;
+};
+
+const resolveEpisodeVideos = async (obj, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldNodes
+}) => {
+  if (obj.videos && obj.__headers) {
+    setCacheMetadata(`${EPISODE}.${VIDEOS}`, obj.__headers);
+    return obj.videos.results;
+  }
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.episode({
+    pathTemplateData: {
+      episodeNumber: obj.episode_number,
+      id: obj.tv_show_id,
+      seasonNumber: obj.season_number,
+      type: VIDEOS
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${TV} show ${obj.tv_show_id} ${SEASON} ${obj.season_number} ${EPISODE} ${obj.episode_number} ${VIDEOS}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  setCacheMetadata(`${EPISODE}.${VIDEOS}`, headers);
+  return data?.results;
+};
+
+const resolveFind = async (_obj, {
+  id,
+  source
+}, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldNodes
+}) => {
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.find({
+    pathTemplateData: {
+      id
+    },
+    queryParams: {
+      ...snakeCasePropNames({
+        externalSource: source
+      })
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${FIND} ${id}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  setCacheMetadata(FIND, headers);
+  return {
+    episodes: data?.tv_episode_results,
+    movies: data?.movie_results,
+    people: data?.person_results,
+    seasons: data?.tv_season_results,
+    tv: data?.tv_results
+  };
+};
+
+const resolveGenres = async (_obj, {
+  screenType
+}, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldNodes
+}) => {
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.genres({
+    pathTemplateData: {
+      type: screenType.toLowerCase()
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${screenType} ${GENRES}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  setCacheMetadata(GENRES, headers);
+  return data?.genres;
+};
+
+const resolveKeyword = async (_obj, {
+  id,
+  includeAdult
+}, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldNodes
+}) => {
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.keyword({
+    pathTemplateData: {
+      id
+    },
+    queryParams: {
+      ...snakeCasePropNames({
+        includeAdult
+      })
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${KEYWORD} ${id}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  setCacheMetadata(KEYWORD, headers);
+  return data;
+};
+
+const appendToResponse$3 = {
+  [ALTERNATIVE_TITLES]: snakeCase(ALTERNATIVE_TITLES),
+  [BACKDROPS]: IMAGES,
+  [CAST]: CREDITS,
+  [CREW]: CREDITS,
+  [EXTERNAL_IDS]: snakeCase(EXTERNAL_IDS),
+  [KEYWORDS]: KEYWORDS,
+  [LOGOS]: IMAGES,
+  [POSTERS]: IMAGES,
+  [RECOMMENDATIONS]: RECOMMENDATIONS,
+  [RELEASE_DATES]: snakeCase(RELEASE_DATES),
+  [REVIEWS]: REVIEWS,
+  [SIMILAR_MOVIES]: SIMILAR,
+  [TRANSLATIONS]: TRANSLATIONS,
+  [VIDEOS]: VIDEOS,
+  [WATCH_PROVIDERS]: 'watch/providers'
+};
+const resolveMovie = async (obj, args, {
+  fragmentDefinitions,
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldName,
+  fieldNodes
+}) => {
+  const typedFieldName = snakeCase(fieldName);
+  if (obj && !isUndefined(obj[typedFieldName])) {
+    return obj[typedFieldName];
+  }
+  const id = obj ? obj.id : args.id;
+  const appendToResponseKeys = getAppendToResponseKeys(fieldNodes[0], appendToResponse$3, fragmentDefinitions);
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.movie({
+    pathTemplateData: {
+      id
+    },
+    ...(appendToResponseKeys.length > 0 ? {
+      queryParams: {
+        append_to_response: appendToResponseKeys.join(',')
+      }
+    } : {})
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${MOVIE} ${id}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  if (obj) {
+    setCacheMetadata(`${MOVIE}.${fieldName}`, headers);
+    return data[typedFieldName];
+  }
+  setCacheMetadata(MOVIE, headers);
+  return appendToResponseKeys.length > 0 ? {
+    ...data,
+    __headers: headers
+  } : data;
+};
+
+const resolveMovieAlternativeTitles = async (obj, {
+  country
+}, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldNodes
+}) => {
+  if (obj.alternative_titles && obj.__headers) {
+    setCacheMetadata(`${MOVIE}.${ALTERNATIVE_TITLES}`, obj.__headers);
+    return obj.alternative_titles.titles;
+  }
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.movie({
+    pathTemplateData: {
+      id: obj.id,
+      type: snakeCase(ALTERNATIVE_TITLES)
+    },
+    queryParams: {
+      country
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${MOVIE} ${obj.id} ${ALTERNATIVE_TITLES}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  setCacheMetadata(`${MOVIE}.${ALTERNATIVE_TITLES}`, headers);
+  return data.titles;
+};
+
+const resolveMovieCredits = async (obj, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldName,
+  fieldNodes
+}) => {
+  const typedFieldName = fieldName;
+  if (obj.credits && obj.__headers) {
+    setCacheMetadata(`${MOVIE}.${typedFieldName}`, obj.__headers);
+    return obj.credits[typedFieldName];
+  }
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.movie({
+    pathTemplateData: {
+      id: obj.id,
+      type: CREDITS
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve movie ${obj.id} ${typedFieldName}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  setCacheMetadata(`${MOVIE}.${typedFieldName}`, headers);
+  return data[typedFieldName];
+};
+
+const resolveMovieExternalIds = async (obj, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldNodes
+}) => {
+  if (obj.external_ids && obj.__headers) {
+    setCacheMetadata(`${MOVIE}.${EXTERNAL_IDS}`, obj.__headers);
+    return obj.external_ids;
+  }
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.movie({
+    pathTemplateData: {
+      id: obj.id,
+      type: snakeCase(EXTERNAL_IDS)
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${MOVIE} ${obj.id} ${EXTERNAL_IDS}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  setCacheMetadata(`${MOVIE}.${EXTERNAL_IDS}`, headers);
+  const {
+    id: movieId,
+    ...rest
+  } = data;
+  return rest;
+};
+
+const resolveMovieImages = async (obj, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldName,
+  fieldNodes
+}) => {
+  const typedFieldName = fieldName;
+  if (obj.images && obj.__headers) {
+    setCacheMetadata(`${MOVIE}.${typedFieldName}`, obj.__headers);
+    return obj.images[typedFieldName];
+  }
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.movie({
+    pathTemplateData: {
+      id: obj.id,
+      type: 'images'
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${MOVIE} ${obj.id} ${typedFieldName}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  setCacheMetadata(`${MOVIE}.${typedFieldName}`, headers);
+  return data[typedFieldName];
+};
+
+const resolveMovieKeywords = async (obj, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldNodes
+}) => {
+  if (obj.keywords && obj.__headers) {
+    setCacheMetadata(`${MOVIE}.${KEYWORDS}`, obj.__headers);
+    return obj.keywords.keywords;
+  }
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.movie({
+    pathTemplateData: {
+      id: obj.id,
+      type: KEYWORDS
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${MOVIE} ${obj.id} ${KEYWORDS}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  setCacheMetadata(`${MOVIE}.${KEYWORDS}`, headers);
+  return data?.keywords;
+};
+
+const createMakeCursors$8 = obj => {
+  const groupCursor = `${obj.id}::${MOVIE}::${RECOMMENDATIONS}`;
+  return {
+    makeGroupCursor: () => encode(groupCursor),
+    makeIDCursor: id => encode(`${id}::${groupCursor}`)
+  };
+};
+const createResourceResolver$8 = (obj, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}) => async ({
+  page
+}) => {
+  if (obj.recommendations && obj.__headers) {
+    setCacheMetadata(`${MOVIE}.${RECOMMENDATIONS}`, obj.__headers);
+    return {
+      data: obj.recommendations,
+      errors: [],
+      headers: obj.__headers
+    };
+  }
+  const result = await restClient.movie({
+    pathTemplateData: {
+      id: obj.id,
+      type: RECOMMENDATIONS
+    },
+    queryParams: {
+      page
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (result.data) {
+    setCacheMetadata(`${MOVIE}.${RECOMMENDATIONS}`, result.headers);
+  }
+  return result;
+};
+const cursorCache$8 = new Core({
+  name: 'MOVIE_RECOMMENDATIONS_CONNECTION_RESOLVER',
+  reaper: init({
+    interval: 300_000
+  }),
+  store: init$1(),
+  type: 'GRAPHQL'
+});
+const getters$8 = {
+  nodes: ({
+    results
+  }) => results,
+  page: ({
+    page
+  }) => page,
+  totalPages: ({
+    total_pages
+  }) => total_pages,
+  totalResults: ({
+    total_results
+  }) => total_results
+};
+const resolveMovieRecommendations = makeConnectionResolver({
+  createMakeCursors: createMakeCursors$8,
+  createResourceResolver: createResourceResolver$8,
+  cursorCache: cursorCache$8,
+  getters: getters$8,
+  resultsPerPage: 20
+});
+
+const resolveMovieReleaseDates = async (obj, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldNodes
+}) => {
+  if (obj.release_dates && obj.__headers) {
+    setCacheMetadata(`${MOVIE}.${RELEASE_DATES}`, obj.__headers);
+    return obj.release_dates.results;
+  }
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.movie({
+    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;
+};
+
+const createMakeCursors$7 = obj => {
+  const groupCursor = `${obj.id}::${MOVIE}::${REVIEWS}`;
+  return {
+    makeGroupCursor: () => encode(groupCursor),
+    makeIDCursor: id => encode(`${id}::${groupCursor}`)
+  };
+};
+const createResourceResolver$7 = (obj, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}) => async ({
+  page
+}) => {
+  if (obj.reviews && obj.__headers) {
+    setCacheMetadata(`${MOVIE}.${REVIEWS}`, obj.__headers);
+    return {
+      data: obj.reviews,
+      errors: [],
+      headers: obj.__headers
+    };
+  }
+  const result = await restClient.movie({
+    pathTemplateData: {
+      id: obj.id,
+      type: REVIEWS
+    },
+    queryParams: {
+      page
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (result.data) {
+    setCacheMetadata(`${MOVIE}.${REVIEWS}`, result.headers);
+  }
+  return result;
+};
+const cursorCache$7 = new Core({
+  name: 'MOVIE_REVIEWS_CONNECTION_RESOLVER',
+  reaper: init({
+    interval: 300_000
+  }),
+  store: init$1(),
+  type: 'GRAPHQL'
+});
+const getters$7 = {
+  nodes: ({
+    results
+  }) => results,
+  page: ({
+    page
+  }) => page,
+  totalPages: ({
+    total_pages
+  }) => total_pages,
+  totalResults: ({
+    total_results
+  }) => total_results
+};
+const resolveMovieReviews = makeConnectionResolver({
+  createMakeCursors: createMakeCursors$7,
+  createResourceResolver: createResourceResolver$7,
+  cursorCache: cursorCache$7,
+  getters: getters$7,
+  resultsPerPage: 20
+});
+
+const createMakeCursors$6 = obj => {
+  const groupCursor = `${obj.id}::${MOVIE}::${SIMILAR}`;
+  return {
+    makeGroupCursor: () => encode(groupCursor),
+    makeIDCursor: id => encode(`${id}::${groupCursor}`)
+  };
+};
+const createResourceResolver$6 = (obj, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}) => async ({
+  page
+}) => {
+  if (obj.similar && obj.__headers) {
+    setCacheMetadata(`${MOVIE}.${SIMILAR_MOVIES}`, obj.__headers);
+    return {
+      data: obj.similar,
+      errors: [],
+      headers: obj.__headers
+    };
+  }
+  const result = await restClient.movie({
+    pathTemplateData: {
+      id: obj.id,
+      type: SIMILAR
+    },
+    queryParams: {
+      page
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (result.data) {
+    setCacheMetadata(`${MOVIE}.${SIMILAR_MOVIES}`, result.headers);
+  }
+  return result;
+};
+const cursorCache$6 = new Core({
+  name: 'MOVIE_SIMILAR_MOVIES_CONNECTION_RESOLVER',
+  reaper: init({
+    interval: 300_000
+  }),
+  store: init$1(),
+  type: 'GRAPHQL'
+});
+const getters$6 = {
+  nodes: ({
+    results
+  }) => results,
+  page: ({
+    page
+  }) => page,
+  totalPages: ({
+    total_pages
+  }) => total_pages,
+  totalResults: ({
+    total_results
+  }) => total_results
+};
+const resolveMovieSimilarMovies = makeConnectionResolver({
+  createMakeCursors: createMakeCursors$6,
+  createResourceResolver: createResourceResolver$6,
+  cursorCache: cursorCache$6,
+  getters: getters$6,
+  resultsPerPage: 20
+});
+
+const resolveMovieTranslations = async (obj, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldNodes
+}) => {
+  if (obj.translations && obj.__headers) {
+    setCacheMetadata(`${MOVIE}.${TRANSLATIONS}`, obj.__headers);
+    return obj.translations.translations;
+  }
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.movie({
+    pathTemplateData: {
+      id: obj.id,
+      type: TRANSLATIONS
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${MOVIE} ${obj.id} ${TRANSLATIONS}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  setCacheMetadata(`${MOVIE}.${TRANSLATIONS}`, headers);
+  return data?.translations;
+};
+
+const resolveMovieVideos = async (obj, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldNodes
+}) => {
+  if (obj.videos && obj.__headers) {
+    setCacheMetadata(`${MOVIE}.${VIDEOS}`, obj.__headers);
+    return obj.videos.results;
+  }
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.movie({
+    pathTemplateData: {
+      id: obj.id,
+      type: VIDEOS
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${MOVIE} ${obj.id} ${VIDEOS}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  setCacheMetadata(`${MOVIE}.${VIDEOS}`, headers);
+  return data?.results;
+};
+
+const resolveMovieWatchProviders = async (obj, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldNodes
+}) => {
+  if (obj['watch/providers'] && obj.__headers) {
+    setCacheMetadata(`${MOVIE}.${WATCH_PROVIDERS}`, obj.__headers);
+    return obj['watch/providers'].results;
+  }
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.watchProviders({
+    pathTemplateData: {
+      id: obj.id,
+      type: MOVIE
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${MOVIE} ${obj.id} ${WATCH_PROVIDERS}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  setCacheMetadata(`${MOVIE}.${WATCH_PROVIDERS}`, headers);
+  return data?.results;
+};
+
+const resolveNetwork = async (obj, args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldName,
+  fieldNodes
+}) => {
+  const typedFieldName = snakeCase(fieldName);
+  if (obj && !isUndefined(obj[typedFieldName])) {
+    return obj[typedFieldName];
+  }
+  const id = obj ? obj.id : args.id;
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.network({
+    pathTemplateData: {
+      id
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${NETWORK} ${id}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  if (obj) {
+    setCacheMetadata(`${NETWORK}.${fieldName}`, headers);
+    return data[typedFieldName];
+  }
+  setCacheMetadata(NETWORK, headers);
+  return data;
+};
+
+const resolveNetworkAlternativeNames = async ({
+  id
+}, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldNodes
+}) => {
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.network({
+    pathTemplateData: {
+      id,
+      type: snakeCase(ALTERNATIVE_NAMES)
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${NETWORK} ${id} ${ALTERNATIVE_NAMES}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  setCacheMetadata(`${NETWORK}.${ALTERNATIVE_NAMES}`, headers);
+  return data.results;
+};
+
+const resolveNetworkLogos = async ({
+  id
+}, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldNodes
+}) => {
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.network({
+    pathTemplateData: {
+      id,
+      type: IMAGES
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${NETWORK} ${id} ${LOGOS}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  setCacheMetadata(`${NETWORK}.${LOGOS}`, headers);
+  return data.logos;
+};
+
+const appendToResponse$2 = {
+  [COMBINED_CREDITS]: snakeCase(COMBINED_CREDITS),
+  [EXTERNAL_IDS]: snakeCase(EXTERNAL_IDS),
+  [MOVIE_CREDITS]: snakeCase(MOVIE_CREDITS),
+  [PROFILES]: IMAGES,
+  [TRANSLATIONS]: TRANSLATIONS,
+  [TV_CREDITS]: snakeCase(TV_CREDITS)
+};
+const resolvePerson = async (obj, args, {
+  fragmentDefinitions,
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldName,
+  fieldNodes
+}) => {
+  const typedFieldName = snakeCase(fieldName);
+  if (obj && !isUndefined(obj[typedFieldName])) {
+    return obj[typedFieldName];
+  }
+  const id = obj ? obj.id : args.id;
+  const appendToResponseKeys = getAppendToResponseKeys(fieldNodes[0], appendToResponse$2, fragmentDefinitions);
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.person({
+    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;
+};
+
+const resolvePersonCombinedCredits = async (obj, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldNodes
+}) => {
+  if (obj.combined_credits && obj.__headers) {
+    setCacheMetadata(`${PERSON}.${COMBINED_CREDITS}`, obj.__headers);
+    return obj.combined_credits;
+  }
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.person({
+    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;
+};
+
+const resolvePersonExternalIds = async (obj, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldNodes
+}) => {
+  if (obj.external_ids && obj.__headers) {
+    setCacheMetadata(`${PERSON}.${EXTERNAL_IDS}`, obj.__headers);
+    return obj.external_ids;
+  }
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.person({
+    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;
+};
+
+const resolvePersonMovieCredits = async (obj, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldNodes
+}) => {
+  if (obj.movie_credits && obj.__headers) {
+    setCacheMetadata(`${PERSON}.${MOVIE_CREDITS}`, obj.__headers);
+    return obj.movie_credits;
+  }
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.person({
+    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;
+};
+
+const resolvePersonProfiles = async (obj, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldNodes
+}) => {
+  if (obj.images && obj.__headers) {
+    setCacheMetadata(`${PERSON}.${PROFILES}`, obj.__headers);
+    return obj.images.profiles;
+  }
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.person({
+    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;
+};
+
+const resolvePersonTranslations = async (obj, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldNodes
+}) => {
+  if (obj.translations && obj.__headers) {
+    setCacheMetadata(`${PERSON}.${TRANSLATIONS}`, obj.__headers);
+    return obj.translations.translations;
+  }
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.person({
+    pathTemplateData: {
+      id: obj.id,
+      type: TRANSLATIONS
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${PERSON} ${obj.id} ${TRANSLATIONS}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  setCacheMetadata(`${PERSON}.${TRANSLATIONS}`, headers);
+  return data?.translations;
+};
+
+const resolvePersonTvCredits = async (obj, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldNodes
+}) => {
+  if (obj.tv_credits && obj.__headers) {
+    setCacheMetadata(`${PERSON}.${TV_CREDITS}`, obj.__headers);
+    return obj.tv_credits;
+  }
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.person({
+    pathTemplateData: {
+      id: obj.id,
+      type: snakeCase(TV_CREDITS)
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${PERSON} ${obj.id} ${TV_CREDITS}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  setCacheMetadata(`${PERSON}.${TV_CREDITS}`, headers);
+  const {
+    id: personId,
+    ...rest
+  } = data;
+  return rest;
+};
+
+const createMakeCursors$5 = (_obj, args) => {
+  const groupCursor = `${JSON.stringify(removeConnectionInputOptions(args))}::${RATED}`;
+  return {
+    makeGroupCursor: () => encode(groupCursor),
+    makeIDCursor: id => encode(`${id}::${groupCursor}`)
+  };
+};
+const createResourceResolver$5 = (_obj, {
+  screenType
+}, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}) => async ({
+  page
+}) => {
+  const result = await restClient.rated({
+    pathTemplateData: {
+      id: tmdbGuestSessionId,
+      type: screenType.toLowerCase()
+    },
+    queryParams: {
+      page
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (!result.data) {
+    return result;
+  }
+  result.data.results = result.data.results.map(entry => {
+    entry.media_type = capitalize(entry.media_type ?? screenType);
+    return entry;
+  });
+  setCacheMetadata(RATED, result.headers);
+  return result;
+};
+const cursorCache$5 = new Core({
+  name: 'RATED_CONNECTION_RESOLVER',
+  reaper: init({
+    interval: 300_000
+  }),
+  store: init$1(),
+  type: 'GRAPHQL'
+});
+const getters$5 = {
+  nodes: ({
+    results
+  }) => results,
+  page: ({
+    page
+  }) => page,
+  totalPages: ({
+    total_pages
+  }) => total_pages,
+  totalResults: ({
+    total_results
+  }) => total_results
+};
+const resolveRated = makeConnectionResolver({
+  createMakeCursors: createMakeCursors$5,
+  createResourceResolver: createResourceResolver$5,
+  cursorCache: cursorCache$5,
+  getters: getters$5,
+  resultsPerPage: 20
+});
+
+const resolveReview = async (obj, args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldName,
+  fieldNodes
+}) => {
+  const typedFieldName = snakeCase(fieldName);
+  if (obj && !isUndefined(obj[typedFieldName])) {
+    return obj[typedFieldName];
+  }
+  const id = obj ? obj.id : args.id;
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.review({
+    pathTemplateData: {
+      id
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${REVIEW} ${id}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  if (obj) {
+    setCacheMetadata(`${REVIEW}.${fieldName}`, headers);
+    return data[typedFieldName];
+  }
+  setCacheMetadata(REVIEW, headers);
+  return data;
+};
+
+const createMakeCursors$4 = (_obj, args) => {
+  const groupCursor = `${JSON.stringify(removeConnectionInputOptions(args))}::${SEARCH}`;
+  return {
+    makeGroupCursor: () => encode(groupCursor),
+    makeIDCursor: id => encode(`${id}::${groupCursor}`)
+  };
+};
+const createResourceResolver$4 = (_obj, args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}) => {
+  const {
+    searchType,
+    ...rest
+  } = removeConnectionInputOptions(args);
+  return async ({
+    page
+  }) => {
+    const result = await restClient.search({
+      pathTemplateData: {
+        type: (searchType ?? 'MULTI').toLowerCase()
+      },
+      queryParams: {
+        ...snakeCasePropNames(rest),
+        page
+      }
+    }, {
+      requestID,
+      tmdbGuestSessionId
+    });
+    if (!result.data) {
+      return result;
+    }
+    result.data.results = result.data.results.map(entry => {
+      entry.media_type = capitalize(entry.media_type ?? searchType);
+      return entry;
+    });
+    setCacheMetadata(SEARCH, result.headers);
+    return result;
+  };
+};
+const cursorCache$4 = new Core({
+  name: 'SEARCH_CONNECTION_RESOLVER',
+  reaper: init({
+    interval: 300_000
+  }),
+  store: init$1(),
+  type: 'GRAPHQL'
+});
+const getters$4 = {
+  nodes: ({
+    results
+  }) => results,
+  page: ({
+    page
+  }) => page,
+  totalPages: ({
+    total_pages
+  }) => total_pages,
+  totalResults: ({
+    total_results
+  }) => total_results
+};
+const resolveSearch = makeConnectionResolver({
+  createMakeCursors: createMakeCursors$4,
+  createResourceResolver: createResourceResolver$4,
+  cursorCache: cursorCache$4,
+  getters: getters$4,
+  resultsPerPage: 20
+});
+
+const appendToResponse$1 = {
+  [CAST]: CREDITS,
+  [CREW]: CREDITS,
+  [EXTERNAL_IDS]: snakeCase(EXTERNAL_IDS),
+  [POSTERS]: IMAGES,
+  [TRANSLATIONS]: TRANSLATIONS,
+  [VIDEOS]: VIDEOS
+};
+const enrichEpisodeData = obj => {
+  for (const episode of obj.episodes) {
+    episode.tv_show_id = obj.tv_show_id;
+  }
+};
+const resolveSeason = async (obj, args, {
+  fragmentDefinitions,
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldName,
+  fieldNodes
+}) => {
+  const typedFieldName = snakeCase(fieldName);
+  const {
+    id,
+    seasonNumber
+  } = getTvIdSeasonAndEpisode(obj, args);
+  if (obj && !isUndefined(obj[typedFieldName])) {
+    return typedFieldName === 'id' ? encodeId({
+      id,
+      seasonNumber
+    }) : obj[typedFieldName];
+  }
+  const appendToResponseKeys = getAppendToResponseKeys(fieldNodes[0], appendToResponse$1, fragmentDefinitions);
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.season({
+    pathTemplateData: {
+      id,
+      number: seasonNumber
+    },
+    ...(appendToResponseKeys.length > 0 ? {
+      queryParams: {
+        append_to_response: appendToResponseKeys.join(',')
+      }
+    } : {})
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${TV} show ${id} ${SEASON} ${seasonNumber}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  const rawSeason = data;
+  rawSeason.id = encodeId({
+    id,
+    seasonNumber
+  });
+  if (!rawSeason.tv_show_id) {
+    rawSeason.tv_show_id = id;
+  }
+  enrichEpisodeData(rawSeason);
+  if (obj) {
+    setCacheMetadata(`${SEASON}.${fieldName}`, headers);
+    return rawSeason[typedFieldName];
+  }
+  setCacheMetadata(SEASON, headers);
+  return appendToResponseKeys.length > 0 ? {
+    ...rawSeason,
+    __headers: headers
+  } : rawSeason;
+};
+
+const resolveSeasonCredits = async (obj, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldName,
+  fieldNodes
+}) => {
+  const typedFieldName = fieldName;
+  if (obj.credits && obj.__headers) {
+    setCacheMetadata(`${SEASON}.${fieldName}`, obj.__headers);
+    return obj.credits[typedFieldName];
+  }
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.season({
+    pathTemplateData: {
+      id: obj.tv_show_id,
+      number: obj.season_number,
+      type: CREDITS
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${TV} show ${obj.tv_show_id} ${SEASON} ${obj.season_number} ${fieldName}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  setCacheMetadata(`${SEASON}.${fieldName}`, headers);
+  return data[typedFieldName];
+};
+
+const resolveSeasonEpisodeCount = obj => {
+  if (obj.episode_count) {
+    return obj.episode_count;
+  }
+  return obj.episodes.length;
+};
+
+const resolveSeasonExternalIds = async (obj, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldNodes
+}) => {
+  if (obj.external_ids && obj.__headers) {
+    setCacheMetadata(`${SEASON}.${EXTERNAL_IDS}`, obj.__headers);
+    return obj.external_ids;
+  }
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.season({
+    pathTemplateData: {
+      id: obj.tv_show_id,
+      number: obj.season_number,
+      type: snakeCase(EXTERNAL_IDS)
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${TV} show ${obj.tv_show_id} ${SEASON} ${obj.season_number} ${EXTERNAL_IDS}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  setCacheMetadata(`${SEASON}.${EXTERNAL_IDS}`, headers);
+  const {
+    id: movieId,
+    ...rest
+  } = data;
+  return rest;
+};
+
+const resolveSeasonPosters = async (obj, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldNodes
+}) => {
+  if (obj.images && obj.__headers) {
+    setCacheMetadata(`${SEASON}.${POSTERS}`, obj.__headers);
+    return obj.images.posters;
+  }
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.season({
+    pathTemplateData: {
+      id: obj.tv_show_id,
+      number: obj.season_number,
+      type: IMAGES
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${TV} show ${obj.tv_show_id} ${SEASON} ${obj.season_number} ${POSTERS}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  setCacheMetadata(`${SEASON}.${POSTERS}`, headers);
+  return data.posters;
+};
+
+const resolveSeasonTranslations = async (obj, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldNodes
+}) => {
+  if (obj.translations && obj.__headers) {
+    setCacheMetadata(`${SEASON}.${TRANSLATIONS}`, obj.__headers);
+    return obj.translations.translations;
+  }
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.season({
+    pathTemplateData: {
+      id: obj.tv_show_id,
+      number: obj.season_number,
+      type: TRANSLATIONS
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${TV} show ${obj.tv_show_id} ${SEASON} ${obj.season_number} ${TRANSLATIONS}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  setCacheMetadata(`${SEASON}.${TRANSLATIONS}`, headers);
+  return data?.translations;
+};
+
+const resolveSeasonVideos = async (obj, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldNodes
+}) => {
+  if (obj.videos && obj.__headers) {
+    setCacheMetadata(`${SEASON}.${VIDEOS}`, obj.__headers);
+    return obj.videos.results;
+  }
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.season({
+    pathTemplateData: {
+      id: obj.tv_show_id,
+      number: obj.season_number,
+      type: VIDEOS
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${TV} show ${obj.tv_show_id} ${SEASON} ${obj.season_number} ${VIDEOS}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  setCacheMetadata(`${SEASON}.${VIDEOS}`, headers);
+  return data?.results;
+};
+
+const createMakeCursors$3 = (_obj, args) => {
+  const groupCursor = `${JSON.stringify(removeConnectionInputOptions(args))}::${TRENDING}`;
+  return {
+    makeGroupCursor: () => encode(groupCursor),
+    makeIDCursor: id => encode(`${id}::${groupCursor}`)
+  };
+};
+const createResourceResolver$3 = (_obj, {
+  mediaType,
+  timeWindow
+}, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}) => async ({
+  page
+}) => {
+  const result = await restClient.trending({
+    pathTemplateData: {
+      subType: timeWindow.toLowerCase(),
+      type: mediaType.toLowerCase()
+    },
+    queryParams: {
+      page
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (!result.data) {
+    return result;
+  }
+  result.data.results = result.data.results.map(entry => {
+    entry.media_type = capitalize(entry.media_type ?? mediaType);
+    return entry;
+  });
+  setCacheMetadata(TRENDING, result.headers);
+  return result;
+};
+const cursorCache$3 = new Core({
+  name: 'TRENDING_CONNECTION_RESOLVER',
+  reaper: init({
+    interval: 300_000
+  }),
+  store: init$1(),
+  type: 'GRAPHQL'
+});
+const getters$3 = {
+  nodes: ({
+    results
+  }) => results,
+  page: ({
+    page
+  }) => page,
+  totalPages: ({
+    total_pages
+  }) => total_pages,
+  totalResults: ({
+    total_results
+  }) => total_results
+};
+const resolveTrending = makeConnectionResolver({
+  createMakeCursors: createMakeCursors$3,
+  createResourceResolver: createResourceResolver$3,
+  cursorCache: cursorCache$3,
+  getters: getters$3,
+  resultsPerPage: 20
+});
+
+const appendToResponse = {
+  [ALTERNATIVE_TITLES]: snakeCase(ALTERNATIVE_TITLES),
+  [BACKDROPS]: IMAGES,
+  [CAST]: CREDITS,
+  [CONTENT_RATINGS]: snakeCase(CONTENT_RATINGS),
+  [CREW]: CREDITS,
+  [EPISODE_GROUPS]: snakeCase(EPISODE_GROUPS),
+  [EXTERNAL_IDS]: snakeCase(EXTERNAL_IDS),
+  [KEYWORDS]: KEYWORDS,
+  [LOGOS]: IMAGES,
+  [POSTERS]: IMAGES,
+  [RECOMMENDATIONS]: RECOMMENDATIONS,
+  [REVIEWS]: REVIEWS,
+  [SIMILAR_TV_SHOWS]: SIMILAR,
+  [TRANSLATIONS]: TRANSLATIONS,
+  [VIDEOS]: VIDEOS,
+  [WATCH_PROVIDERS]: 'watch/providers'
+};
+const enrichSeasonData = obj => {
+  for (const season of obj.seasons) {
+    season.tv_show_id = obj.id;
+  }
+};
+const resolveTv = async (obj, args, {
+  fragmentDefinitions,
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldName,
+  fieldNodes
+}) => {
+  const typedFieldName = snakeCase(fieldName);
+  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.tv({
+    pathTemplateData: {
+      id
+    },
+    ...(appendToResponseKeys.length > 0 ? {
+      queryParams: {
+        append_to_response: appendToResponseKeys.join(',')
+      }
+    } : {})
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${TV} ${id}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  const rawTv = data;
+  enrichSeasonData(rawTv);
+  if (obj) {
+    setCacheMetadata(`${TV}.${fieldName}`, headers);
+    return rawTv[typedFieldName];
+  }
+  setCacheMetadata(TV, headers);
+  return appendToResponseKeys.length > 0 ? {
+    ...rawTv,
+    __headers: headers
+  } : rawTv;
+};
+
+const resolveTvAlternativeTitles = async (obj, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldNodes
+}) => {
+  if (obj.alternative_titles && obj.__headers) {
+    setCacheMetadata(`${TV}.${ALTERNATIVE_TITLES}`, obj.__headers);
+    return obj.alternative_titles.results;
+  }
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.tv({
+    pathTemplateData: {
+      id: obj.id,
+      type: snakeCase(ALTERNATIVE_TITLES)
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${TV} ${obj.id} ${ALTERNATIVE_TITLES}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  setCacheMetadata(`${TV}.${ALTERNATIVE_TITLES}`, headers);
+  return data.results;
+};
+
+const resolveTvContentRatings = async (obj, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldNodes
+}) => {
+  if (obj.content_ratings && obj.__headers) {
+    setCacheMetadata(`${TV}.${CONTENT_RATINGS}`, obj.__headers);
+    return obj.content_ratings.results;
+  }
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.tv({
+    pathTemplateData: {
+      id: obj.id,
+      type: snakeCase(CONTENT_RATINGS)
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${TV} ${obj.id} ${CONTENT_RATINGS}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  setCacheMetadata(`${TV}.${CONTENT_RATINGS}`, headers);
+  return data.results;
+};
+
+const resolveTvCredits = async (obj, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldName,
+  fieldNodes
+}) => {
+  const typedFieldName = fieldName;
+  if (obj.credits && obj.__headers) {
+    setCacheMetadata(`${TV}.${typedFieldName}`, obj.__headers);
+    return obj.credits[typedFieldName];
+  }
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.tv({
+    pathTemplateData: {
+      id: obj.id,
+      type: CREDITS
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${TV} ${obj.id} ${typedFieldName}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  setCacheMetadata(`${TV}.${typedFieldName}`, headers);
+  return data[typedFieldName];
+};
+
+const resolveTvEpisodeGroups = async (obj, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldNodes
+}) => {
+  if (obj.episode_groups && obj.__headers) {
+    setCacheMetadata(`${TV}.${EPISODE_GROUPS}`, obj.__headers);
+    return obj.episode_groups.results;
+  }
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.tv({
+    pathTemplateData: {
+      id: obj.id,
+      type: snakeCase(EPISODE_GROUPS)
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${TV} ${obj.id} ${EPISODE_GROUPS}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  setCacheMetadata(`${TV}.${EPISODE_GROUPS}`, headers);
+  return data.results;
+};
+
+const resolveTvExternalIds = async (obj, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldNodes
+}) => {
+  if (obj.external_ids && obj.__headers) {
+    setCacheMetadata(`${TV}.${EXTERNAL_IDS}`, obj.__headers);
+    return obj.external_ids;
+  }
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.tv({
+    pathTemplateData: {
+      id: obj.id,
+      type: snakeCase(EXTERNAL_IDS)
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${TV} ${obj.id} ${EXTERNAL_IDS}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  setCacheMetadata(`${TV}.${EXTERNAL_IDS}`, headers);
+  const {
+    id: tvId,
+    ...rest
+  } = data;
+  return rest;
+};
+
+const resolveTvImages = async (obj, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldName,
+  fieldNodes
+}) => {
+  const typedFieldName = fieldName;
+  if (obj.images && obj.__headers) {
+    setCacheMetadata(`${TV}.${typedFieldName}`, obj.__headers);
+    return obj.images[typedFieldName];
+  }
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.tv({
+    pathTemplateData: {
+      id: obj.id,
+      type: 'images'
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${TV} ${obj.id} ${typedFieldName}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  setCacheMetadata(`${TV}.${typedFieldName}`, headers);
+  return data[typedFieldName];
+};
+
+const resolveTvKeywords = async (obj, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldNodes
+}) => {
+  if (obj.keywords && obj.__headers) {
+    setCacheMetadata(`${TV}.${KEYWORDS}`, obj.__headers);
+    return obj.keywords.results;
+  }
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.tv({
+    pathTemplateData: {
+      id: obj.id,
+      type: KEYWORDS
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${TV} ${obj.id} ${KEYWORDS}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  setCacheMetadata(`${TV}.${KEYWORDS}`, headers);
+  return data?.results;
+};
+
+const createMakeCursors$2 = obj => {
+  const groupCursor = `${obj.id}::${TV}::${RECOMMENDATIONS}`;
+  return {
+    makeGroupCursor: () => encode(groupCursor),
+    makeIDCursor: id => encode(`${id}::${groupCursor}`)
+  };
+};
+const createResourceResolver$2 = (obj, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}) => async ({
+  page
+}) => {
+  if (obj.recommendations && obj.__headers) {
+    setCacheMetadata(`${TV}.${RECOMMENDATIONS}`, obj.__headers);
+    return {
+      data: obj.recommendations,
+      errors: [],
+      headers: obj.__headers
+    };
+  }
+  const result = await restClient.tv({
+    pathTemplateData: {
+      id: obj.id,
+      type: RECOMMENDATIONS
+    },
+    queryParams: {
+      page
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (result.data) {
+    setCacheMetadata(`${TV}.${RECOMMENDATIONS}`, result.headers);
+  }
+  return result;
+};
+const cursorCache$2 = new Core({
+  name: 'TV_RECOMMENDATIONS_CONNECTION_RESOLVER',
+  reaper: init({
+    interval: 300_000
+  }),
+  store: init$1(),
+  type: 'GRAPHQL'
+});
+const getters$2 = {
+  nodes: ({
+    results
+  }) => results,
+  page: ({
+    page
+  }) => page,
+  totalPages: ({
+    total_pages
+  }) => total_pages,
+  totalResults: ({
+    total_results
+  }) => total_results
+};
+const resolveTvRecommendations = makeConnectionResolver({
+  createMakeCursors: createMakeCursors$2,
+  createResourceResolver: createResourceResolver$2,
+  cursorCache: cursorCache$2,
+  getters: getters$2,
+  resultsPerPage: 20
+});
+
+const createMakeCursors$1 = obj => {
+  const groupCursor = `${obj.id}::${TV}::${REVIEWS}`;
+  return {
+    makeGroupCursor: () => encode(groupCursor),
+    makeIDCursor: id => encode(`${id}::${groupCursor}`)
+  };
+};
+const createResourceResolver$1 = (obj, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}) => async ({
+  page
+}) => {
+  if (obj.reviews && obj.__headers) {
+    setCacheMetadata(`${TV}.${REVIEWS}`, obj.__headers);
+    return {
+      data: obj.reviews,
+      errors: [],
+      headers: obj.__headers
+    };
+  }
+  const result = await restClient.tv({
+    pathTemplateData: {
+      id: obj.id,
+      type: REVIEWS
+    },
+    queryParams: {
+      page
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (result.data) {
+    setCacheMetadata(`${TV}.${REVIEWS}`, result.headers);
+  }
+  return result;
+};
+const cursorCache$1 = new Core({
+  name: 'TV_REVIEWS_CONNECTION_RESOLVER',
+  reaper: init({
+    interval: 300_000
+  }),
+  store: init$1(),
+  type: 'GRAPHQL'
+});
+const getters$1 = {
+  nodes: ({
+    results
+  }) => results,
+  page: ({
+    page
+  }) => page,
+  totalPages: ({
+    total_pages
+  }) => total_pages,
+  totalResults: ({
+    total_results
+  }) => total_results
+};
+const resolveTvReviews = makeConnectionResolver({
+  createMakeCursors: createMakeCursors$1,
+  createResourceResolver: createResourceResolver$1,
+  cursorCache: cursorCache$1,
+  getters: getters$1,
+  resultsPerPage: 20
+});
+
+const createMakeCursors = obj => {
+  const groupCursor = `${obj.id}::${TV}::${SIMILAR}`;
+  return {
+    makeGroupCursor: () => encode(groupCursor),
+    makeIDCursor: id => encode(`${id}::${groupCursor}`)
+  };
+};
+const createResourceResolver = (obj, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}) => async ({
+  page
+}) => {
+  if (obj.similar && obj.__headers) {
+    setCacheMetadata(`${TV}.${SIMILAR_TV_SHOWS}`, obj.__headers);
+    return {
+      data: obj.similar,
+      errors: [],
+      headers: obj.__headers
+    };
+  }
+  const result = await restClient.tv({
+    pathTemplateData: {
+      id: obj.id,
+      type: SIMILAR
+    },
+    queryParams: {
+      page
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (result.data) {
+    setCacheMetadata(`${TV}.${SIMILAR_TV_SHOWS}`, result.headers);
+  }
+  return result;
+};
+const cursorCache = new Core({
+  name: 'TV_SIMILAR_TV_SHOWS_CONNECTION_RESOLVER',
+  reaper: init({
+    interval: 300_000
+  }),
+  store: init$1(),
+  type: 'GRAPHQL'
+});
+const getters = {
+  nodes: ({
+    results
+  }) => results,
+  page: ({
+    page
+  }) => page,
+  totalPages: ({
+    total_pages
+  }) => total_pages,
+  totalResults: ({
+    total_results
+  }) => total_results
+};
+const resolveTvSimilarTvShows = makeConnectionResolver({
+  createMakeCursors,
+  createResourceResolver,
+  cursorCache,
+  getters,
+  resultsPerPage: 20
+});
+
+const resolveTvTranslations = async (obj, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldNodes
+}) => {
+  if (obj.translations && obj.__headers) {
+    setCacheMetadata(`${TV}.${TRANSLATIONS}`, obj.__headers);
+    return obj.translations.translations;
+  }
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.tv({
+    pathTemplateData: {
+      id: obj.id,
+      type: TRANSLATIONS
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${TV} ${obj.id} ${TRANSLATIONS}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  setCacheMetadata(`${TV}.${TRANSLATIONS}`, headers);
+  return data?.translations;
+};
+
+const resolveTvVideos = async (obj, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldNodes
+}) => {
+  if (obj.videos && obj.__headers) {
+    setCacheMetadata(`${TV}.${VIDEOS}`, obj.__headers);
+    return obj.videos.results;
+  }
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.tv({
+    pathTemplateData: {
+      id: obj.id,
+      type: VIDEOS
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${TV} ${obj.id} ${VIDEOS}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  setCacheMetadata(`${TV}.${VIDEOS}`, headers);
+  return data?.results;
+};
+
+const resolveTvWatchProviders = async (obj, _args, {
+  requestID,
+  restClient,
+  setCacheMetadata,
+  tmdbGuestSessionId
+}, {
+  fieldNodes
+}) => {
+  if (obj['watch/providers'] && obj.__headers) {
+    setCacheMetadata(`${TV}.${WATCH_PROVIDERS}`, obj.__headers);
+    return obj['watch/providers'].results;
+  }
+  const {
+    data,
+    errors,
+    headers
+  } = await restClient.watchProviders({
+    pathTemplateData: {
+      id: obj.id,
+      type: TV
+    }
+  }, {
+    requestID,
+    tmdbGuestSessionId
+  });
+  if (errors?.length) {
+    throw new GraphQLError(`Failed to resolve ${TV} ${obj.id} ${WATCH_PROVIDERS}.`, {
+      nodes: fieldNodes,
+      originalError: errors[0]
+    });
+  }
+  setCacheMetadata(`${TV}.${WATCH_PROVIDERS}`, headers);
+  return data?.results;
+};
+
+const resolveVideoType = ({
+  type
+}) => snakeCase(type).toUpperCase();
+
+const resolvers = {
+  Certifications: {
+    CA_QC: obj => obj['CA-QC']
+  },
+  Collection: {
+    ...makeFallbackFieldResolvers('Collection', resolveCollection),
+    backdrops: resolveCollectionImages,
+    posters: resolveCollectionImages,
+    translations: resolveCollectionTranslations
+  },
+  Company: {
+    ...makeFallbackFieldResolvers('Company', resolveCompany),
+    alternativeNames: resolveCompanyAlternativeNames,
+    logos: resolveCompanyLogos
+  },
+  Configuration: {
+    countries: resolveConfigurationCountries,
+    jobs: resolveConfigurationJobs,
+    languages: resolveConfigurationLanguages,
+    primaryTranslations: resolveConfigurationPrimaryTranslations,
+    timezones: resolveConfigurationTimezones
+  },
+  Episode: {
+    ...makeFallbackFieldResolvers('Episode', resolveEpisode),
+    cast: resolveEpisodeCredits,
+    crew: resolveEpisodeCredits,
+    externalIds: resolveEpisodeExternalIds,
+    stills: resolveEpisodeStills,
+    translations: resolveEpisodeTranslations,
+    videos: resolveEpisodeVideos
+  },
+  Media: {
+    __resolveType: obj => {
+      return obj.media_type;
+    }
+  },
+  Movie: {
+    ...makeFallbackFieldResolvers('Movie', resolveMovie),
+    alternativeTitles: resolveMovieAlternativeTitles,
+    backdrops: resolveMovieImages,
+    cast: resolveMovieCredits,
+    crew: resolveMovieCredits,
+    externalIds: resolveMovieExternalIds,
+    keywords: resolveMovieKeywords,
+    logos: resolveMovieImages,
+    posters: resolveMovieImages,
+    recommendations: resolveMovieRecommendations,
+    releaseDates: resolveMovieReleaseDates,
+    reviews: resolveMovieReviews,
+    similarMovies: resolveMovieSimilarMovies,
+    translations: resolveMovieTranslations,
+    videos: resolveMovieVideos,
+    watchProviders: resolveMovieWatchProviders
+  },
+  Network: {
+    ...makeFallbackFieldResolvers('Network', resolveNetwork),
+    alternativeNames: resolveNetworkAlternativeNames,
+    logos: resolveNetworkLogos
+  },
+  Person: {
+    ...makeFallbackFieldResolvers('Person', resolvePerson),
+    combinedCredits: resolvePersonCombinedCredits,
+    externalIds: resolvePersonExternalIds,
+    movieCredits: resolvePersonMovieCredits,
+    profiles: resolvePersonProfiles,
+    translations: resolvePersonTranslations,
+    tvCredits: resolvePersonTvCredits
+  },
+  Query: {
+    certifications: resolveCertifications,
+    collection: resolveCollection,
+    company: resolveCompany,
+    configuration: resolveConfiguration,
+    credit: resolveCredit,
+    discoverMovies: resolveDiscoverMovies,
+    discoverTv: resolveDiscoverTv,
+    episode: resolveEpisode,
+    find: resolveFind,
+    genres: resolveGenres,
+    keyword: resolveKeyword,
+    movie: resolveMovie,
+    network: resolveNetwork,
+    person: resolvePerson,
+    rated: resolveRated,
+    review: resolveReview,
+    search: resolveSearch,
+    season: resolveSeason,
+    trending: resolveTrending,
+    tv: resolveTv
+  },
+  RatedScreen: {
+    __resolveType: obj => {
+      return obj.media_type;
+    }
+  },
+  Search: {
+    __resolveType: obj => {
+      return obj.media_type;
+    }
+  },
+  Season: {
+    ...makeFallbackFieldResolvers('Season', resolveSeason),
+    cast: resolveSeasonCredits,
+    crew: resolveSeasonCredits,
+    episodeCount: resolveSeasonEpisodeCount,
+    externalIds: resolveSeasonExternalIds,
+    posters: resolveSeasonPosters,
+    translations: resolveSeasonTranslations,
+    videos: resolveSeasonVideos
+  },
+  Tv: {
+    ...makeFallbackFieldResolvers('Tv', resolveTv),
+    alternativeTitles: resolveTvAlternativeTitles,
+    backdrops: resolveTvImages,
+    cast: resolveTvCredits,
+    contentRatings: resolveTvContentRatings,
+    crew: resolveTvCredits,
+    episodeGroups: resolveTvEpisodeGroups,
+    externalIds: resolveTvExternalIds,
+    keywords: resolveTvKeywords,
+    logos: resolveTvImages,
+    posters: resolveTvImages,
+    recommendations: resolveTvRecommendations,
+    reviews: resolveTvReviews,
+    similarTvShows: resolveTvSimilarTvShows,
+    translations: resolveTvTranslations,
+    videos: resolveTvVideos,
+    watchProviders: resolveTvWatchProviders
+  },
+  Video: {
+    type: resolveVideoType
+  }
+};
+
+export { defaultFieldResolver, resolvers };
+//# sourceMappingURL=index.mjs.map