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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tmdb-graphql-api/resolvers",
   "description": "The TMDB GraphQL resolvers module.",
-  "version": "0.1.0",
+  "version": "0.1.1-unstable.0",
   "author": "Dylan Aubrey",
   "license": "MIT",
   "homepage": "https://github.com/badbatch/themoviedb-graphql-api",
@@ -29,18 +29,19 @@
     "access": "public"
   },
   "dependencies": {
-    "@cachemap/core": "^5.0.8",
-    "@cachemap/map": "^5.0.6",
-    "@cachemap/reaper": "^5.0.6",
-    "@graphql-box/connection-resolver": "^5.0.1",
-    "@graphql-box/core": "^5.0.1",
+    "@cachemap/core": "^5.2.7",
+    "@cachemap/map": "^5.0.9",
+    "@cachemap/reaper": "^5.1.3",
+    "@graphql-box/connection-resolver": "^5.4.6",
+    "@graphql-box/core": "^5.4.2",
     "cacheability": "^4.0.20",
     "getta": "^1.0.6",
     "js-base64": "^3.6.0",
     "query-string": "^8.1.0",
-    "type-fest": "^4.5.0",
-    "@tmdb-graphql-api/rest-client": "0.0.9",
-    "@tmdb-graphql-api/schema": "0.1.0"
+    "type-fest": "^4.37.0",
+    "winston": "^3.17.0",
+    "@tmdb-graphql-api/rest-client": "0.0.10-unstable.0",
+    "@tmdb-graphql-api/schema": "0.1.1-unstable.0"
   },
   "peerDependencies": {
     "@babel/runtime": "<8",
@@ -50,7 +51,7 @@
   },
   "devDependencies": {
     "@babel/runtime": "^7.23.2",
-    "@graphql-box/helpers": "^5.0.1",
+    "@graphql-box/helpers": "^5.4.2",
     "@jest/globals": "^29.7.0",
     "@types/lodash-es": "^4.14.191",
     "core-js": "^3.33.1",

package/src/__testUtils__/helpers/createMockLogger.ts

@@ -0,0 +1,10 @@
+import { type jest } from '@jest/globals';
+import type { LeveledLogMethod, Logger } from 'winston';
+
+export const createMockLogger = (mockFn: typeof jest.fn): Logger => {
+  const mockLogger = {} as unknown as Logger;
+  mockLogger.child = mockFn().mockReturnValue(mockLogger) as (options: Record<string, unknown>) => Logger;
+  mockLogger.error = mockFn() as LeveledLogMethod;
+  mockLogger.info = mockFn() as LeveledLogMethod;
+  return mockLogger;
+};

package/src/constants.ts

@@ -25,6 +25,7 @@ export const EXTERNAL_IDS = 'externalIds' as const;
 export const FIND = 'find' as const;
 
 export const GENRES = 'genres' as const;
+export const GUEST_STARS = 'guestStars' as const;
 
 export const IMAGES = 'images' as const;
 
@@ -50,6 +51,7 @@ export const PROFILES = 'profiles' as const;
 export const RATED = 'rated' as const;
 export const RECOMMENDATIONS = 'recommendations' as const;
 export const RELEASE_DATES = 'releaseDates' as const;
+export const RESULTS = 'results' as const;
 export const REVIEW = 'review' as const;
 export const REVIEWS = 'reviews' as const;
 
@@ -69,3 +71,4 @@ export const TV_CREDITS = 'tvCredits' as const;
 export const VIDEOS = 'videos' as const;
 
 export const WATCH_PROVIDERS = 'watchProviders' as const;
+export const RAW_WATCH_PROVIDERS = 'watch/providers' as const;

package/src/helpers/buildArgsResolver.ts

@@ -0,0 +1,37 @@
+import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
+import { type Context } from '../types.ts';
+
+export const buildArgsResolver =
+  <Args extends object, Data>(
+    field: string,
+    callback: (
+      args: Args,
+      ctx: Context,
+      info: GraphQLResolveInfo
+    ) => Promise<{ data?: Data; errors?: Error[]; headers: Headers; source?: string }>
+  ) =>
+  async (_obj: undefined, args: Args, ctx: Context, info: GraphQLResolveInfo) => {
+    const { logger, operationName, requestID, setCacheMetadata, tmdbGuestSessionId } = ctx;
+    const { fieldNodes } = info;
+
+    const childLogger = logger.child({
+      args,
+      field,
+      operationName,
+      requestID,
+      tmdbGuestSessionId,
+    });
+
+    childLogger.info(`Resolving ${field}`);
+    const { data, errors, headers, source = 'api' } = await callback(args, ctx, info);
+
+    if (errors?.length) {
+      const message = `Failed to resolve ${field}`;
+      childLogger.error(message, { errors });
+      throw new GraphQLError(message, { nodes: fieldNodes, originalError: errors[0] });
+    }
+
+    childLogger.info(`Successfully resolved ${field} from ${source}`);
+    setCacheMetadata(field, headers);
+    return data;
+  };

package/src/helpers/buildNoObjArgsResolver.ts

@@ -0,0 +1,36 @@
+import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
+import type { Context } from '../types.ts';
+
+export const buildNoObjArgsResolver =
+  <Obj, Data>(
+    parentFieldName: string,
+    callback: (
+      ctx: Context,
+      info: GraphQLResolveInfo
+    ) => Promise<{ data?: Data; errors?: Error[]; headers: Headers; source?: string }>
+  ) =>
+  async (obj: Obj | undefined, _args: undefined, ctx: Context, info: GraphQLResolveInfo) => {
+    const { logger, operationName, requestID, setCacheMetadata, tmdbGuestSessionId } = ctx;
+    const { fieldName, fieldNodes } = info;
+    const fieldPath = obj ? `${parentFieldName}.${fieldName}` : parentFieldName;
+
+    const childLogger = logger.child({
+      fieldPath,
+      operationName,
+      requestID,
+      tmdbGuestSessionId,
+    });
+
+    childLogger.info(`Resolving ${fieldPath}`);
+    const { data, errors, headers } = await callback(ctx, info);
+
+    if (errors?.length) {
+      const message = `Failed to resolve ${fieldPath}`;
+      childLogger.error(message, { errors });
+      throw new GraphQLError(message, { nodes: fieldNodes, originalError: errors[0] });
+    }
+
+    childLogger.info(`Successfully resolved ${fieldPath} from api`);
+    setCacheMetadata(fieldPath, headers);
+    return data;
+  };

package/src/helpers/buildObjArgsResolver.ts

@@ -0,0 +1,43 @@
+import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
+import { type Context } from '../types.ts';
+
+export const buildObjArgsResolver =
+  <Obj extends object, Args extends object, Data>(
+    parentFieldName: string,
+    callback: (
+      obj: Obj | undefined,
+      args: Args,
+      ctx: Context,
+      info: GraphQLResolveInfo
+    ) => Promise<{ data?: Data; errors?: Error[]; headers?: Headers; source?: string }>
+  ) =>
+  async (obj: Obj | undefined, args: Args, ctx: Context, info: GraphQLResolveInfo) => {
+    const { logger, operationName, requestID, setCacheMetadata, tmdbGuestSessionId } = ctx;
+    const { fieldName, fieldNodes } = info;
+    const fieldPath = obj ? `${parentFieldName}.${fieldName}` : parentFieldName;
+
+    const childLogger = logger.child({
+      args,
+      fieldPath,
+      operationName,
+      requestID,
+      tmdbGuestSessionId,
+    });
+
+    childLogger.info(`Resolving ${fieldPath}`);
+    const { data, errors, headers, source = 'api' } = await callback(obj, args, ctx, info);
+
+    if (errors?.length) {
+      const message = `Failed to resolve ${fieldPath}`;
+      childLogger.error(message, { errors });
+      throw new GraphQLError(message, { nodes: fieldNodes, originalError: errors[0] });
+    }
+
+    childLogger.info(`Successfully resolved ${fieldPath} from ${source}`);
+
+    if (headers) {
+      setCacheMetadata(fieldPath, headers);
+    }
+
+    return data;
+  };

package/src/helpers/buildObjResolver.ts

@@ -0,0 +1,48 @@
+import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
+import { type Context } from '../types.ts';
+
+export const buildObjResolver =
+  <Obj extends { id: number | string }, Data>(
+    parentFieldName: string,
+    callback: (
+      obj: Obj,
+      ctx: Context,
+      info: GraphQLResolveInfo
+    ) => Promise<{ data?: Data; errors?: Error[]; headers?: Headers; source?: string }>
+  ) =>
+  async (obj: Obj | undefined, _args: undefined, ctx: Context, info: GraphQLResolveInfo) => {
+    const { logger, operationName, requestID, setCacheMetadata, tmdbGuestSessionId } = ctx;
+    const { fieldName, fieldNodes } = info;
+    const fieldPath = `${parentFieldName}.${fieldName}`;
+
+    const childLogger = logger.child({
+      fieldPath,
+      operationName,
+      parentFieldId: obj?.id,
+      requestID,
+      tmdbGuestSessionId,
+    });
+
+    if (!obj) {
+      const message = `Required ${parentFieldName} node missing`;
+      childLogger.error(message);
+      throw new GraphQLError(message, { nodes: fieldNodes });
+    }
+
+    childLogger.info(`Resolving ${fieldPath}`);
+    const { data, errors, headers, source = 'api' } = await callback(obj, ctx, info);
+
+    if (errors?.length) {
+      const message = `Failed to resolve ${fieldPath}`;
+      childLogger.error(message, { errors });
+      throw new GraphQLError(message, { nodes: fieldNodes, originalError: errors[0] });
+    }
+
+    childLogger.info(`Successfully resolved ${fieldPath} from ${source}`);
+
+    if (headers) {
+      setCacheMetadata(fieldPath, headers);
+    }
+
+    return data;
+  };

package/src/helpers/getTvIdSeasonAndEpisode.ts

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

package/src/main.ts

@@ -1,4 +1,4 @@
-import { type Certifications, type MediaType, type ScreenType } from '@tmdb-graphql-api/schema/types';
+import { type Certifications, type MediaType, type ScreenType, type SearchType } from '@tmdb-graphql-api/schema/types';
 import { makeFallbackFieldResolvers } from './helpers/makeFallbackFieldResolvers.ts';
 import { resolveCertifications } from './queries/certifications.ts';
 import { resolveCollection } from './queries/collection.ts';
@@ -74,13 +74,7 @@ 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,
-  type RawMedia,
-  type RawRatedScreen,
-  type RawSearch,
-  type SearchMediaType,
-} from './types.ts';
+import { type FieldResolver, type RawMediaType, type RawMovie, type RawSearchType, type RawTv } from './types.ts';
 
 export const resolvers: Record<string, Record<string, string | number | FieldResolver>> = {
   Certifications: {
@@ -115,7 +109,7 @@ export const resolvers: Record<string, Record<string, string | number | FieldRes
   },
   Media: {
     // eslint-disable-next-line camelcase
-    __resolveType: (obj: RawMedia & { media_type: MediaType }) => {
+    __resolveType: (obj: RawMediaType & { media_type: Capitalize<Lowercase<MediaType>> }) => {
       return obj.media_type;
     },
   },
@@ -192,13 +186,13 @@ export const resolvers: Record<string, Record<string, string | number | FieldRes
   },
   RatedScreen: {
     // eslint-disable-next-line camelcase
-    __resolveType: (obj: RawRatedScreen & { media_type: ScreenType }) => {
+    __resolveType: (obj: (RawMovie | RawTv) & { media_type: Capitalize<Lowercase<ScreenType>> }) => {
       return obj.media_type;
     },
   },
   Search: {
     // eslint-disable-next-line camelcase
-    __resolveType: (obj: RawSearch & { media_type: SearchMediaType }) => {
+    __resolveType: (obj: RawSearchType & { media_type: Capitalize<Lowercase<SearchType>> }) => {
       return obj.media_type;
     },
   },

package/src/queries/certifications.test.ts

@@ -1,12 +1,12 @@
 import { jest } from '@jest/globals';
-import { CERTIFICATIONS_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import { CERTIFICATIONS_PATH } from '@tmdb-graphql-api/rest-client';
 import { ScreenType } from '@tmdb-graphql-api/schema/types';
 import movieCertifications from '@tmdb-graphql-api/test-utils/responses/themoviedb/certifications/movie.json';
 import tvCertifications from '@tmdb-graphql-api/test-utils/responses/themoviedb/certifications/tv.json';
 import { mockFetch } from 'fetch-mocked';
-import { type Getta, type ShortcutProperties } from 'getta';
 import { type GraphQLResolveInfo } from 'graphql';
 import { buildEndpoint } from '../__testUtils__/helpers/buildEndpoint.ts';
+import { createMockLogger } from '../__testUtils__/helpers/createMockLogger.ts';
 import { createRestClient } from '../__testUtils__/helpers/createRestClient.ts';
 import { type Context } from '../types.ts';
 import { resolveCertifications } from './certifications.ts';
@@ -14,16 +14,19 @@ import { resolveCertifications } from './certifications.ts';
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolveCertifications >', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
+  const context = {
+    logger: createMockLogger(jest.fn),
+    restClient: createRestClient(),
+    setCacheMetadata: jest.fn(),
+    tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+  } as unknown as Context;
 
-  beforeAll(() => {
-    restClient = createRestClient();
-  });
+  const info = {} as GraphQLResolveInfo;
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   describe("when the screenType is 'MOVIE' >", () => {
@@ -35,12 +38,7 @@ describe('resolveCertifications >', () => {
 
     it('should return the movie certifications', async () => {
       await expect(
-        resolveCertifications(
-          undefined,
-          { screenType: ScreenType.Movie },
-          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-          {} as GraphQLResolveInfo
-        )
+        resolveCertifications(undefined, { screenType: ScreenType.Movie }, context, info)
       ).resolves.toMatchSnapshot();
     });
   });
@@ -54,12 +52,7 @@ describe('resolveCertifications >', () => {
 
     it('should return the tv certifications', async () => {
       await expect(
-        resolveCertifications(
-          undefined,
-          { screenType: ScreenType.Tv },
-          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-          {} as GraphQLResolveInfo
-        )
+        resolveCertifications(undefined, { screenType: ScreenType.Tv }, context, info)
       ).resolves.toMatchSnapshot();
     });
   });

package/src/queries/certifications.ts

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

package/src/queries/collection.test.ts

@@ -1,10 +1,10 @@
 import { jest } from '@jest/globals';
-import { COLLECTION_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import { COLLECTION_PATH } from '@tmdb-graphql-api/rest-client';
 import collectionDetails from '@tmdb-graphql-api/test-utils/responses/themoviedb/collection/details.json';
 import { mockFetch } from 'fetch-mocked';
-import { type Getta, type ShortcutProperties } from 'getta';
 import { type GraphQLResolveInfo } from 'graphql';
 import { buildEndpoint } from '../__testUtils__/helpers/buildEndpoint.ts';
+import { createMockLogger } from '../__testUtils__/helpers/createMockLogger.ts';
 import { createRestClient } from '../__testUtils__/helpers/createRestClient.ts';
 import { type Context } from '../types.ts';
 import { resolveCollection } from './collection.ts';
@@ -12,13 +12,16 @@ import { resolveCollection } from './collection.ts';
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolveCollection >', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
   const id = 10;
 
-  beforeAll(() => {
-    restClient = createRestClient();
-  });
+  const context = {
+    logger: createMockLogger(jest.fn),
+    restClient: createRestClient(),
+    setCacheMetadata: jest.fn(),
+    tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+  } as unknown as Context;
+
+  const info = {} as GraphQLResolveInfo;
 
   beforeEach(() => {
     mockedFetch.mockGetOnce(buildEndpoint(COLLECTION_PATH, { id }), {
@@ -28,19 +31,13 @@ describe('resolveCollection >', () => {
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   describe('when a collection id >', () => {
     it('should return the collection details', async () => {
-      await expect(
-        resolveCollection(
-          undefined,
-          { id },
-          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-          {} as GraphQLResolveInfo
-        )
-      ).resolves.toMatchSnapshot();
+      await expect(resolveCollection(undefined, { id: String(id) }, context, info)).resolves.toMatchSnapshot();
     });
   });
 });

package/src/queries/collection.ts

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

package/src/queries/collectionImages.test.ts

@@ -1,24 +1,25 @@
 import { jest } from '@jest/globals';
-import { COLLECTION_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import { COLLECTION_PATH } from '@tmdb-graphql-api/rest-client';
 import collectionDetails from '@tmdb-graphql-api/test-utils/responses/themoviedb/collection/details.json';
 import collectionImages from '@tmdb-graphql-api/test-utils/responses/themoviedb/collection/images.json';
 import { mockFetch } from 'fetch-mocked';
-import { type Getta, type ShortcutProperties } from 'getta';
 import { buildEndpoint } from '../__testUtils__/helpers/buildEndpoint.ts';
 import { buildResolveInfoArgument } from '../__testUtils__/helpers/buildResolveInfoArg.ts';
+import { createMockLogger } from '../__testUtils__/helpers/createMockLogger.ts';
 import { createRestClient } from '../__testUtils__/helpers/createRestClient.ts';
-import { type Context, type RawCollection } from '../types.ts';
+import { BACKDROPS, COLLECTION, POSTERS } from '../constants.ts';
+import { type Context } from '../types.ts';
 import { resolveCollectionImages } from './collectionImages.ts';
 
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolveCollectionImages >', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
-
-  beforeAll(() => {
-    restClient = createRestClient();
-  });
+  const context = {
+    logger: createMockLogger(jest.fn),
+    restClient: createRestClient(),
+    setCacheMetadata: jest.fn(),
+    tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+  } as unknown as Context;
 
   beforeEach(() => {
     mockedFetch.mockGetOnce(buildEndpoint(COLLECTION_PATH, { id: 10, type: 'images' }), {
@@ -28,7 +29,8 @@ describe('resolveCollectionImages >', () => {
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   describe('when a query has specified backdrops >', () => {
@@ -45,16 +47,11 @@ describe('resolveCollectionImages >', () => {
             }
           }
         `,
-        ['collection', 'backdrops']
+        [COLLECTION, BACKDROPS]
       );
 
       await expect(
-        resolveCollectionImages(
-          collectionDetails as unknown as RawCollection,
-          undefined,
-          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-          resolveInfo
-        )
+        resolveCollectionImages(collectionDetails, undefined, context, resolveInfo)
       ).resolves.toMatchSnapshot();
     });
   });
@@ -73,16 +70,11 @@ describe('resolveCollectionImages >', () => {
             }
           }
         `,
-        ['collection', 'posters']
+        [COLLECTION, POSTERS]
       );
 
       await expect(
-        resolveCollectionImages(
-          collectionDetails as unknown as RawCollection,
-          undefined,
-          { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-          resolveInfo
-        )
+        resolveCollectionImages(collectionDetails, undefined, context, resolveInfo)
       ).resolves.toMatchSnapshot();
     });
   });