@tmdb-graphql-api/resolvers 0.0.6

package/src/helpers/encodeId.ts

@@ -0,0 +1,4 @@
+import { encode } from 'js-base64';
+import type { JsonObject } from 'type-fest';
+
+export const encodeId = <T extends JsonObject>(obj: T) => encode(JSON.stringify(obj));

package/src/helpers/formatDirectionalSuffixes.ts

@@ -0,0 +1,15 @@
+import type { PlainObject } from '@graphql-box/core';
+import type { ValueOf } from 'type-fest';
+
+export const formatDirectionalSuffixes = <P extends PlainObject>(props: P) =>
+  Object.keys(props).reduce<PlainObject>((accumulator, propertyName) => {
+    if (propertyName === 'sort_by') {
+      accumulator[propertyName] = (props[propertyName] as string).toLowerCase().replace(/_([a-z]+)$/, '.$1');
+    } else if (propertyName.endsWith('_gte') || propertyName.endsWith('_lte')) {
+      accumulator[propertyName.replace(/_([a-z]+)$/, '.$1')] = props[propertyName] as ValueOf<P>;
+    } else {
+      accumulator[propertyName] = props[propertyName] as ValueOf<P>;
+    }
+
+    return accumulator;
+  }, {}) as P;

package/src/helpers/formatQueryParams.ts

@@ -0,0 +1,8 @@
+import { removeConnectionInputOptions } from '@graphql-box/connection-resolver';
+import type { PlainObject } from '@graphql-box/core';
+import { formatDirectionalSuffixes } from './formatDirectionalSuffixes.ts';
+import { removeNullValues } from './removeNullValues.ts';
+import { snakeCasePropNames } from './snakeCasePropNames.ts';
+
+export const formatQueryParams = (args: PlainObject) =>
+  formatDirectionalSuffixes(snakeCasePropNames(removeNullValues(removeConnectionInputOptions(args))));

package/src/helpers/getAppendToResponseKeys.ts

@@ -0,0 +1,28 @@
+import type { FragmentDefinitionNodeMap } from '@graphql-box/core';
+import { getChildFields, getName } from '@graphql-box/helpers';
+import type { FieldNode } from 'graphql';
+
+export const getAppendToResponseKeys = (
+  parentFieldNode: FieldNode,
+  appendToResponse: Record<string, string>,
+  fragmentDefinitions?: FragmentDefinitionNodeMap
+) =>
+  (getChildFields(parentFieldNode, { fragmentDefinitions }) ?? []).reduce((acc: string[], { 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;
+  }, []);

package/src/helpers/getTvIdSeasonAndEpisode.ts

@@ -0,0 +1,25 @@
+import type { QueryEpisodeArgs, QuerySeasonArgs } from '@tmdb-graphql-api/schema';
+import type { RawEpisode, RawSeason } from '../types.ts';
+import { decodeId } from './decodeId.ts';
+
+export const getTvIdSeasonAndEpisode = (
+  obj: RawSeason | RawEpisode | undefined,
+  args: QuerySeasonArgs | QueryEpisodeArgs
+) => {
+  let id: string | number;
+  let seasonNumber: number;
+  let episodeNumber: number | undefined;
+
+  if (obj) {
+    id = obj.tv_show_id;
+    seasonNumber = obj.season_number;
+    episodeNumber = 'episode_number' in obj ? obj.episode_number : undefined;
+  } else {
+    const parsed = decodeId<{ episodeNumber?: number; id: string; seasonNumber: number }>(args.id as string);
+    id = parsed.id;
+    seasonNumber = parsed.seasonNumber;
+    episodeNumber = parsed.episodeNumber;
+  }
+
+  return { episodeNumber, id, seasonNumber };
+};

package/src/helpers/makeFallbackFieldResolvers.ts

@@ -0,0 +1,11 @@
+import type { FieldResolver } from '../types.ts';
+import { typePropNames } from './typePropNames.ts';
+
+export const makeFallbackFieldResolvers = (typeName: string, resolver: FieldResolver) => {
+  const propNames = typePropNames[typeName]!;
+
+  return propNames.reduce<Record<string, FieldResolver>>((acc, propName) => {
+    acc[propName] = resolver;
+    return acc;
+  }, {});
+};

package/src/helpers/removeNullValues.ts

@@ -0,0 +1,11 @@
+import { type PlainObject } from '@graphql-box/core';
+
+export const removeNullValues = <P extends PlainObject>(props: P) =>
+  Object.keys(props).reduce<PlainObject>((acc, propName) => {
+    if (props[propName] === null) {
+      return acc;
+    }
+
+    acc[propName] = props[propName];
+    return acc;
+  }, {}) as P;

package/src/helpers/snakeCasePropNames.ts

@@ -0,0 +1,9 @@
+import type { PlainObject } from '@graphql-box/core';
+import { snakeCase } from 'lodash-es';
+import type { SnakeCasedPropertiesDeep } from 'type-fest';
+
+export const snakeCasePropNames = <P extends PlainObject>(props: P) =>
+  Object.keys(props).reduce<PlainObject>((snakeCased, propName) => {
+    snakeCased[snakeCase(propName)] = props[propName];
+    return snakeCased;
+  }, {}) as SnakeCasedPropertiesDeep<P>;

package/src/helpers/typePropNames.test.ts

@@ -0,0 +1,7 @@
+import { typePropNames } from './typePropNames.ts';
+
+describe('typePropNames', () => {
+  it('the correct prop names are returned', () => {
+    expect(typePropNames).toMatchSnapshot();
+  });
+});

package/src/helpers/typePropNames.ts

@@ -0,0 +1,14 @@
+import { schema } from '@tmdb-graphql-api/schema';
+import { type GraphQLObjectType, Kind } from 'graphql';
+
+const typeMap = schema.getTypeMap();
+
+export const typePropNames = Object.keys(typeMap).reduce<Record<string, string[]>>((acc, key) => {
+  const type = typeMap[key];
+
+  if (type?.astNode?.kind === Kind.OBJECT_TYPE_DEFINITION) {
+    acc[key] = Object.keys((type as GraphQLObjectType).getFields());
+  }
+
+  return acc;
+}, {});

package/src/index.ts

@@ -0,0 +1,2 @@
+export { defaultFieldResolver } from './helpers/defaultFieldResolver.ts';
+export { resolvers } from './main.ts';

package/src/main.ts

@@ -0,0 +1,215 @@
+import type { Certifications, MediaType, ScreenType } from '@tmdb-graphql-api/schema';
+import { makeFallbackFieldResolvers } from './helpers/makeFallbackFieldResolvers.ts';
+import { resolveCertifications } from './queries/certifications.ts';
+import { resolveCollection } from './queries/collection.ts';
+import { resolveCollectionImages } from './queries/collectionImages.ts';
+import { resolveCollectionTranslations } from './queries/collectionTranslations.ts';
+import { resolveCompany } from './queries/company.ts';
+import { resolveCompanyAlternativeNames } from './queries/companyAlternativeNames.ts';
+import { resolveCompanyLogos } from './queries/companyLogos.ts';
+import { resolveConfiguration } from './queries/configuration.ts';
+import { resolveConfigurationCountries } from './queries/configurationCountries.ts';
+import { resolveConfigurationJobs } from './queries/configurationJobs.ts';
+import { resolveConfigurationLanguages } from './queries/configurationLanguages.ts';
+import { resolveConfigurationPrimaryTranslations } from './queries/configurationPrimaryTranslations.ts';
+import { resolveConfigurationTimezones } from './queries/configurationTimezones.ts';
+import { resolveCredit } from './queries/credit.ts';
+import { resolveDiscoverMovies } from './queries/discoverMovies.ts';
+import { resolveDiscoverTv } from './queries/discoverTv.ts';
+import { resolveEpisode } from './queries/episode.ts';
+import { resolveEpisodeCredits } from './queries/episodeCredits.ts';
+import { resolveEpisodeExternalIds } from './queries/episodeExternalIds.ts';
+import { resolveEpisodeStills } from './queries/episodeStills.ts';
+import { resolveEpisodeTranslations } from './queries/episodeTranslations.ts';
+import { resolveEpisodeVideos } from './queries/episodeVideos.ts';
+import { resolveFind } from './queries/find.ts';
+import { resolveGenres } from './queries/genres.ts';
+import { resolveKeyword } from './queries/keyword.ts';
+import { resolveMovie } from './queries/movie.ts';
+import { resolveMovieAlternativeTitles } from './queries/movieAlternativeTitles.ts';
+import { resolveMovieCredits } from './queries/movieCredits.ts';
+import { resolveMovieExternalIds } from './queries/movieExternalIds.ts';
+import { resolveMovieImages } from './queries/movieImages.ts';
+import { resolveMovieKeywords } from './queries/movieKeywords.ts';
+import { resolveMovieRecommendations } from './queries/movieRecommendations.ts';
+import { resolveMovieReleaseDates } from './queries/movieReleaseDates.ts';
+import { resolveMovieReviews } from './queries/movieReviews.ts';
+import { resolveMovieSimilarMovies } from './queries/movieSimilarMovies.ts';
+import { resolveMovieTranslations } from './queries/movieTranslations.ts';
+import { resolveMovieVideos } from './queries/movieVideos.ts';
+import { resolveMovieWatchProviders } from './queries/movieWatchProviders.ts';
+import { resolveNetwork } from './queries/network.ts';
+import { resolveNetworkAlternativeNames } from './queries/networkAlternativeNames.ts';
+import { resolveNetworkLogos } from './queries/networkLogos.ts';
+import { resolvePerson } from './queries/person.ts';
+import { resolvePersonCombinedCredits } from './queries/personCombinedCredits.ts';
+import { resolvePersonExternalIds } from './queries/personExternalIds.ts';
+import { resolvePersonMovieCredits } from './queries/personMovieCredits.ts';
+import { resolvePersonProfiles } from './queries/personProfiles.ts';
+import { resolvePersonTranslations } from './queries/personTranslations.ts';
+import { resolvePersonTvCredits } from './queries/personTvCredits.ts';
+import { resolveRated } from './queries/rated.ts';
+import { resolveReview } from './queries/review.ts';
+import { resolveSearch } from './queries/search.ts';
+import { resolveSeason } from './queries/season.ts';
+import { resolveSeasonCredits } from './queries/seasonCredits.ts';
+import { resolveSeasonEpisodeCount } from './queries/seasonEpisodeCount.ts';
+import { resolveSeasonExternalIds } from './queries/seasonExternalIds.ts';
+import { resolveSeasonPosters } from './queries/seasonPosters.ts';
+import { resolveSeasonTranslations } from './queries/seasonTranslations.ts';
+import { resolveSeasonVideos } from './queries/seasonVideos.ts';
+import { resolveTrending } from './queries/trending.ts';
+import { resolveTv } from './queries/tv.ts';
+import { resolveTvAlternativeTitles } from './queries/tvAlternativeTitles.ts';
+import { resolveTvContentRatings } from './queries/tvContentRatings.ts';
+import { resolveTvCredits } from './queries/tvCredits.ts';
+import { resolveTvEpisodeGroups } from './queries/tvEpisodeGroups.ts';
+import { resolveTvExternalIds } from './queries/tvExternalIds.ts';
+import { resolveTvImages } from './queries/tvImages.ts';
+import { resolveTvKeywords } from './queries/tvKeywords.ts';
+import { resolveTvRecommendations } from './queries/tvRecommendations.ts';
+import { resolveTvReviews } from './queries/tvReviews.ts';
+import { resolveTvSimilarTvShows } from './queries/tvSimilarTvShows.ts';
+import { resolveTvTranslations } from './queries/tvTranslations.ts';
+import { resolveTvVideos } from './queries/tvVideos.ts';
+import { resolveTvWatchProviders } from './queries/tvWatchProviders.ts';
+import { resolveVideoType } from './queries/videoType.ts';
+import type { FieldResolver, RawMedia, RawRatedScreen, RawSearch, SearchMediaType } from './types.ts';
+
+export const resolvers: Record<string, Record<string, FieldResolver>> = {
+  Certifications: {
+    CA_QC: (obj: Certifications) => obj['CA-QC' as keyof Certifications],
+  },
+  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: {
+    // eslint-disable-next-line camelcase
+    __resolveType: (obj: RawMedia & { media_type: MediaType }) => {
+      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,
+    // popular: null,
+    rated: resolveRated,
+    review: resolveReview,
+    search: resolveSearch,
+    season: resolveSeason,
+    trending: resolveTrending,
+    tv: resolveTv,
+  },
+  RatedScreen: {
+    // eslint-disable-next-line camelcase
+    __resolveType: (obj: RawRatedScreen & { media_type: ScreenType }) => {
+      return obj.media_type;
+    },
+  },
+  Search: {
+    // eslint-disable-next-line camelcase
+    __resolveType: (obj: RawSearch & { media_type: SearchMediaType }) => {
+      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,
+  },
+};