@graphql-box/connection-resolver 4.1.3 → 5.0.0

package/src/helpers/retrieveCachedConnection.ts

@@ -1,40 +1,48 @@
-import Cachemap from "@cachemap/core";
-import { CachedEdges, ConnectionInputOptions, CursorGroupMetadata } from "../defs";
-import getCursor from "./getCursor";
-import getInRangeCachedEdges from "./getInRangeCachedEdges";
-import getPageNumbersToRequest from "./getPageNumbersToRequest";
-import getPagesMissingFromCache from "./getPagesMissingFromCache";
-import { getEndIndex, getStartIndex } from "./getStartAndEndIndexes";
-import { hasNextPage, hasPreviousPage } from "./hasPreviousNextPage";
-import makeEntry from "./makeEntry";
-import retrieveCachedEdgesByPage from "./retrieveCachedEdgesByPage";
+import { type Core } from '@cachemap/core';
+import { type CachedEdges, type ConnectionInputOptions, type CursorGroupMetadata } from '../types.ts';
+import { getInRangeCachedEdges } from './getInRangeCachedEdges.ts';
+import { getPageNumbersToRequest } from './getPageNumbersToRequest.ts';
+import { getPagesMissingFromCache } from './getPagesMissingFromCache.ts';
+import { getEndIndex, getStartIndex } from './getStartAndEndIndexes.ts';
+import { hasNextPage, hasPreviousPage } from './hasPreviousNextPage.ts';
+import { retrieveCachedEdgesByPage } from './retrieveCachedEdgesByPage.ts';
+import { retrieveEntry } from './retrieveEntry.ts';
 
 export type Context = {
-  cursorCache: Cachemap;
+  cursorCache: Core;
   groupCursor: string;
   resultsPerPage: number;
 };
 
-export default async (args: ConnectionInputOptions, { cursorCache, groupCursor, resultsPerPage }: Context) => {
-  const metadata = (await cursorCache.get(`${groupCursor}-metadata`)) as CursorGroupMetadata;
-  const cursor = getCursor(args);
-  const entry = cursor ? await cursorCache.get(cursor) : makeEntry(args, { metadata, resultsPerPage });
+export const retrieveCachedConnection = async (
+  args: ConnectionInputOptions,
+  { cursorCache, groupCursor, resultsPerPage }: Context
+) => {
+  /**
+   * At this point the cache will always have metadata because `retrieveCachedConnection`
+   * is called from `resolveConnection` and is only called if there is a cursor, either
+   * after a direct check or after calling `validateCursor` or `requestAndCachePages`,
+   * which check and set the metadata respectively.
+   */
+  const metadata = (await cursorCache.get<CursorGroupMetadata>(`${groupCursor}-metadata`))!;
+  const entry = await retrieveEntry(args, metadata, { cursorCache, resultsPerPage });
   const startIndex = getStartIndex(args, { entry, resultsPerPage });
   const endIndex = getEndIndex(args, { entry, metadata, resultsPerPage });
   const promises: Promise<CachedEdges>[] = [];
   const pageNumbersToRequest = getPageNumbersToRequest(args, { endIndex, entry, metadata, resultsPerPage, startIndex });
 
-  pageNumbersToRequest.forEach(pageNumber => {
+  for (const pageNumber of pageNumbersToRequest) {
     promises.push(retrieveCachedEdgesByPage(cursorCache, { groupCursor, pageNumber }));
-  });
+  }
 
   const cachedEdgesByPage = await Promise.all(promises);
   const missingPages = getPagesMissingFromCache(cachedEdgesByPage);
 
   return {
-    cachedEdges: !missingPages.length
-      ? getInRangeCachedEdges(cachedEdgesByPage, { endIndex, resultsPerPage, startIndex })
-      : cachedEdgesByPage,
+    cachedEdges:
+      missingPages.length === 0
+        ? getInRangeCachedEdges(cachedEdgesByPage, { endIndex, resultsPerPage, startIndex })
+        : cachedEdgesByPage,
     hasNextPage: hasNextPage({
       cachedEdgesByPage,
       endIndex,

package/src/helpers/retrieveCachedEdgesByPage.ts

@@ -1,27 +1,27 @@
-import Cachemap, { ExportResult } from "@cachemap/core";
-import { Edge } from "../defs";
+import { type Core } from '@cachemap/core';
+import { type CursorCacheEntry, type Edge } from '../types.ts';
 
 export type Context = {
   groupCursor: string;
   pageNumber: number;
 };
 
-export default async (cursorCache: Cachemap, { groupCursor, pageNumber }: Context) => {
-  const { entries, metadata } = (await cursorCache.export({
+export const retrieveCachedEdgesByPage = async (cursorCache: Core, { groupCursor, pageNumber }: Context) => {
+  const { entries, metadata } = await cursorCache.export<CursorCacheEntry>({
     filterByValue: [
-      { keyChain: "page", comparator: pageNumber },
-      { keyChain: "group", comparator: groupCursor },
+      { comparator: pageNumber, keyChain: 'page' },
+      { comparator: groupCursor, keyChain: 'group' },
     ],
-  })) as ExportResult;
+  });
 
   return {
-    edges: entries.reduce((cached, [key, { index, node }]) => {
-      if (metadata[index].cacheability.checkTTL()) {
+    edges: entries.reduce<Edge[]>((cached, [key, { index, node }]) => {
+      if (metadata[index]?.cacheability.checkTTL()) {
         cached[index] = { cursor: key, node };
       }
 
       return cached;
-    }, [] as Edge[]),
+    }, []),
     pageNumber,
   };
 };

package/src/helpers/retrieveEntry.ts

@@ -0,0 +1,32 @@
+import type { Core } from '@cachemap/core';
+import type {
+  ConnectionInputOptions,
+  CursorCacheEntry,
+  CursorGroupMetadata,
+  PartialCursorCacheEntry,
+} from '../types.ts';
+import { getCursor } from './getCursor.ts';
+import { makeEntry } from './makeEntry.ts';
+
+export type Context = {
+  cursorCache: Core;
+  resultsPerPage: number;
+};
+
+export const retrieveEntry = async (
+  args: ConnectionInputOptions,
+  metadata: CursorGroupMetadata,
+  { cursorCache, resultsPerPage }: Context
+): Promise<PartialCursorCacheEntry> => {
+  const cursor = getCursor(args);
+
+  if (cursor) {
+    const cursorCacheEntry = await cursorCache.get<CursorCacheEntry>(cursor);
+
+    if (cursorCacheEntry) {
+      return cursorCacheEntry;
+    }
+  }
+
+  return makeEntry(args, { metadata, resultsPerPage });
+};

package/src/helpers/validateCursor.test.ts

@@ -1,16 +1,16 @@
-import Cachemap from "@cachemap/core";
-import map from "@cachemap/map";
-import { GraphQLError, GraphQLResolveInfo } from "graphql";
-import validateCursor, { Context } from "./validateCursor";
+import { Core } from '@cachemap/core';
+import { init as map } from '@cachemap/map';
+import { type GraphQLResolveInfo } from 'graphql';
+import { type Context, validateCursor } from './validateCursor.ts';
 
-describe("validateCursor", () => {
+describe('validateCursor', () => {
   const ctx: Context = {
-    cursorCache: new Cachemap({
-      name: "GRAPHQL_BOX_CONNECTION_RESOLVER",
+    cursorCache: new Core({
+      name: 'GRAPHQL_BOX_CONNECTION_RESOLVER',
       store: map(),
-      type: "CONNECTION_RESOLVER",
+      type: 'CONNECTION_RESOLVER',
     }),
-    groupCursor: "abcdefg",
+    groupCursor: 'abcdefg',
     resultsPerPage: 10,
   };
 
@@ -18,93 +18,120 @@ describe("validateCursor", () => {
     await ctx.cursorCache.clear();
   });
 
-  test("when `after` is provided but `first` is NOT", async () => {
+  describe('when `after` is provided but `first` is NOT', () => {
     const info = {};
 
-    expect(
-      ((await validateCursor({ after: "abcdefg" }, info as GraphQLResolveInfo, ctx)) as GraphQLError).message,
-    ).toBe("Invalid connection argument combination. `after` must be used in combination with `first`.");
+    it('should return the correct error', async () => {
+      const result = await validateCursor({ after: 'abcdefg' }, info as GraphQLResolveInfo, ctx);
+
+      expect(result?.message).toBe(
+        'Invalid connection argument combination. `after` must be used in combination with `first`.'
+      );
+    });
   });
 
-  test("when `after` and `last` are provided", async () => {
+  describe('when `after` and `last` are provided', () => {
     const info = {};
 
-    expect(
-      ((await validateCursor({ after: "abcdefg", last: 5 }, info as GraphQLResolveInfo, ctx)) as GraphQLError).message,
-    ).toBe("Invalid connection argument combination. `after` cannot be used in combination with `last`.");
+    it('should return the correct error', async () => {
+      const result = await validateCursor({ after: 'abcdefg', last: 5 }, info as GraphQLResolveInfo, ctx);
+
+      expect(result?.message).toBe(
+        'Invalid connection argument combination. `after` cannot be used in combination with `last`.'
+      );
+    });
   });
 
-  test("when `before` is provided but `last` is NOT", async () => {
+  describe('when `before` is provided but `last` is NOT', () => {
     const info = {};
 
-    expect(
-      ((await validateCursor({ before: "abcdefg" }, info as GraphQLResolveInfo, ctx)) as GraphQLError).message,
-    ).toBe("Invalid connection argument combination. `before` must be used in combination with `last`.");
+    it('should return the correct error', async () => {
+      const result = await validateCursor({ before: 'abcdefg' }, info as GraphQLResolveInfo, ctx);
+
+      expect(result?.message).toBe(
+        'Invalid connection argument combination. `before` must be used in combination with `last`.'
+      );
+    });
   });
 
-  test("when `before` and `first` are provided", async () => {
+  describe('when `before` and `first` are provided', () => {
     const info = {};
 
-    expect(
-      ((await validateCursor({ before: "abcdefg", first: 5 }, info as GraphQLResolveInfo, ctx)) as GraphQLError)
-        .message,
-    ).toBe("Invalid connection argument combination. `before` cannot be used in combination with `first`.");
+    it('should return the correct error', async () => {
+      const result = await validateCursor({ before: 'abcdefg', first: 5 }, info as GraphQLResolveInfo, ctx);
+
+      expect(result?.message).toBe(
+        'Invalid connection argument combination. `before` cannot be used in combination with `first`.'
+      );
+    });
   });
 
-  test("when a cursor was not previously provided", async () => {
-    const args = { after: "abcdefg", first: 5, query: "Hello world!" };
+  describe('when a cursor was not previously provided', () => {
+    const args = { after: 'abcdefg', first: 5, query: 'Hello world!' };
     const info = {};
 
-    expect(((await validateCursor(args, info as GraphQLResolveInfo, ctx)) as GraphQLError).message).toBe(
-      "Curser cannot be supplied without previously being provided.",
-    );
+    it('should return the correct error', async () => {
+      const result = await validateCursor(args, info as GraphQLResolveInfo, ctx);
+      expect(result?.message).toBe('Curser cannot be supplied without previously being provided.');
+    });
   });
 
-  test("when a cursor could not be found", async () => {
-    await ctx.cursorCache.set(`${ctx.groupCursor}-metadata`, { totalPages: 10, totalResults: 100 });
-    const args = { after: "abcdefg", first: 5, query: "Hello world!" };
+  describe('when a cursor could not be found', () => {
+    const args = { after: 'abcdefg', first: 5, query: 'Hello world!' };
     const info = {};
 
-    expect(((await validateCursor(args, info as GraphQLResolveInfo, ctx)) as GraphQLError).message).toBe(
-      "The cursor abcdefg could not be found.",
-    );
+    it('should return the correct error', async () => {
+      await ctx.cursorCache.set(`${ctx.groupCursor}-metadata`, { totalPages: 10, totalResults: 100 });
+      const result = await validateCursor(args, info as GraphQLResolveInfo, ctx);
+      expect(result?.message).toBe('The cursor abcdefg could not be found.');
+    });
   });
 
-  test("when a cursor is the last", async () => {
-    await ctx.cursorCache.set(`${ctx.groupCursor}-metadata`, { totalPages: 6, totalResults: 53 });
-    await ctx.cursorCache.set("abcdefg", { index: 2, page: 6 });
-    const args = { after: "abcdefg", first: 5, query: "Hello world!" };
+  describe('when a cursor is the last', () => {
+    const args = { after: 'abcdefg', first: 5, query: 'Hello world!' };
     const info = {};
 
-    expect(((await validateCursor(args, info as GraphQLResolveInfo, ctx)) as GraphQLError).message).toBe(
-      "The cursor abcdefg is the last, you cannot go forward any further.",
-    );
+    it('should return the correct error', async () => {
+      await ctx.cursorCache.set(`${ctx.groupCursor}-metadata`, { totalPages: 6, totalResults: 53 });
+      await ctx.cursorCache.set('abcdefg', { index: 2, page: 6 });
+      const result = await validateCursor(args, info as GraphQLResolveInfo, ctx);
+      expect(result?.message).toBe('The cursor abcdefg is the last, you cannot go forward any further.');
+    });
   });
 
-  test("when a cursor is the first", async () => {
-    await ctx.cursorCache.set(`${ctx.groupCursor}-metadata`, { totalPages: 6, totalResults: 53 });
-    await ctx.cursorCache.set("abcdefg", { index: 0, page: 1 });
-    const args = { before: "abcdefg", last: 5, query: "Hello world!" };
+  describe('when a cursor is the first', () => {
+    const args = { before: 'abcdefg', last: 5, query: 'Hello world!' };
     const info = {};
 
-    expect(((await validateCursor(args, info as GraphQLResolveInfo, ctx)) as GraphQLError).message).toBe(
-      "The cursor abcdefg is the first, you cannot go backward any further.",
-    );
+    it('should return the correct error', async () => {
+      await ctx.cursorCache.set(`${ctx.groupCursor}-metadata`, { totalPages: 6, totalResults: 53 });
+      await ctx.cursorCache.set('abcdefg', { index: 0, page: 1 });
+      const result = await validateCursor(args, info as GraphQLResolveInfo, ctx);
+      expect(result?.message).toBe('The cursor abcdefg is the first, you cannot go backward any further.');
+    });
   });
 
-  test("when `after` and `first` are provided and the cursor is not invalid", async () => {
-    await ctx.cursorCache.set(`${ctx.groupCursor}-metadata`, { totalPages: 6, totalResults: 53 });
-    await ctx.cursorCache.set("abcdefg", { index: 0, page: 2 });
-    const args = { after: "abcdefg", first: 5, query: "Hello world!" };
+  describe('when `after` and `first` are provided and the cursor is not invalid', () => {
+    const args = { after: 'abcdefg', first: 5, query: 'Hello world!' };
     const info = {};
-    expect(await validateCursor(args, info as GraphQLResolveInfo, ctx)).toBeUndefined();
+
+    it('should return undefined', async () => {
+      await ctx.cursorCache.set(`${ctx.groupCursor}-metadata`, { totalPages: 6, totalResults: 53 });
+      await ctx.cursorCache.set('abcdefg', { index: 0, page: 2 });
+      const result = await validateCursor(args, info as GraphQLResolveInfo, ctx);
+      expect(result).toBeUndefined();
+    });
   });
 
-  test("when `before` and `last` are provided and the cursor is not invalid", async () => {
-    await ctx.cursorCache.set(`${ctx.groupCursor}-metadata`, { totalPages: 6, totalResults: 53 });
-    await ctx.cursorCache.set("abcdefg", { index: 0, page: 2 });
-    const args = { before: "abcdefg", last: 5, query: "Hello world!" };
+  describe('when `before` and `last` are provided and the cursor is not invalid', () => {
+    const args = { before: 'abcdefg', last: 5, query: 'Hello world!' };
     const info = {};
-    expect(await validateCursor(args, info as GraphQLResolveInfo, ctx)).toBeUndefined();
+
+    it('should return undefined', async () => {
+      await ctx.cursorCache.set(`${ctx.groupCursor}-metadata`, { totalPages: 6, totalResults: 53 });
+      await ctx.cursorCache.set('abcdefg', { index: 0, page: 2 });
+      const result = await validateCursor(args, info as GraphQLResolveInfo, ctx);
+      expect(result).toBeUndefined();
+    });
   });
 });

package/src/helpers/validateCursor.ts

@@ -1,72 +1,76 @@
-import Cachemap from "@cachemap/core";
-import { GraphQLError, GraphQLResolveInfo } from "graphql";
-import { ConnectionInputOptions, CursorCacheEntry, CursorGroupMetadata } from "../defs";
-import getCursor from "./getCursor";
-import getDirection from "./getDirection";
-import isCursorFirst from "./isCursorFirst";
-import isCursorLast from "./isCursorLast";
+import { type Core } from '@cachemap/core';
+import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
+import { type ConnectionInputOptions, type CursorCacheEntry, type CursorGroupMetadata } from '../types.ts';
+import { getCursor } from './getCursor.ts';
+import { getDirection } from './getDirection.ts';
+import { isCursorFirst } from './isCursorFirst.ts';
+import { isCursorLast } from './isCursorLast.ts';
 
 export type Context = {
-  cursorCache: Cachemap;
+  cursorCache: Core;
   groupCursor: string;
   resultsPerPage: number;
 };
 
-export default async (
+export const validateCursor = async (
   { after, before, first, last }: ConnectionInputOptions,
   { fieldNodes }: GraphQLResolveInfo,
-  { cursorCache, groupCursor, resultsPerPage }: Context,
+  { cursorCache, groupCursor, resultsPerPage }: Context
 ) => {
   if (after && !first && !last) {
     return new GraphQLError(
-      "Invalid connection argument combination. `after` must be used in combination with `first`.",
-      fieldNodes,
+      'Invalid connection argument combination. `after` must be used in combination with `first`.',
+      { nodes: fieldNodes }
     );
   }
 
   if (after && last) {
     return new GraphQLError(
-      "Invalid connection argument combination. `after` cannot be used in combination with `last`.",
-      fieldNodes,
+      'Invalid connection argument combination. `after` cannot be used in combination with `last`.',
+      { nodes: fieldNodes }
     );
   }
 
   if (before && !last && !first) {
     return new GraphQLError(
-      "Invalid connection argument combination. `before` must be used in combination with `last`.",
-      fieldNodes,
+      'Invalid connection argument combination. `before` must be used in combination with `last`.',
+      { nodes: fieldNodes }
     );
   }
 
   if (before && first) {
     return new GraphQLError(
-      "Invalid connection argument combination. `before` cannot be used in combination with `first`.",
-      fieldNodes,
+      'Invalid connection argument combination. `before` cannot be used in combination with `first`.',
+      { nodes: fieldNodes }
     );
   }
 
-  const metadata = (await cursorCache.get(`${groupCursor}-metadata`)) as CursorGroupMetadata | undefined;
+  const metadata = await cursorCache.get<CursorGroupMetadata>(`${groupCursor}-metadata`);
 
   if (!metadata) {
-    return new GraphQLError("Curser cannot be supplied without previously being provided.", fieldNodes);
+    return new GraphQLError('Curser cannot be supplied without previously being provided.', { nodes: fieldNodes });
   }
 
-  const cursor = getCursor({ after, before }) as string;
-  const entry = (await cursorCache.get(cursor)) as CursorCacheEntry | undefined;
+  const cursor = getCursor({ after, before })!;
+  const entry = await cursorCache.get<CursorCacheEntry>(cursor);
 
   if (!entry) {
-    return new GraphQLError(`The cursor ${cursor} could not be found.`, fieldNodes);
+    return new GraphQLError(`The cursor ${cursor} could not be found.`, { nodes: fieldNodes });
   }
 
   const direction = getDirection(last);
 
   if (isCursorLast({ direction, entry, resultsPerPage, ...metadata })) {
-    return new GraphQLError(`The cursor ${cursor} is the last, you cannot go forward any further.`, fieldNodes);
+    return new GraphQLError(`The cursor ${cursor} is the last, you cannot go forward any further.`, {
+      nodes: fieldNodes,
+    });
   }
 
   if (isCursorFirst({ direction, entry })) {
-    return new GraphQLError(`The cursor ${cursor} is the first, you cannot go backward any further.`, fieldNodes);
+    return new GraphQLError(`The cursor ${cursor} is the first, you cannot go backward any further.`, {
+      nodes: fieldNodes,
+    });
   }
 
-  return undefined;
+  return;
 };

package/src/index.ts

@@ -1,3 +1,3 @@
-export * from "./defs";
-export { default as removeConnectionInputOptions } from "./helpers/removeConnectionInputOptions";
-export { default, connectionResolver } from "./main";
+export * from './types.ts';
+export * from './helpers/removeConnectionInputOptions.ts';
+export * from './main/index.ts';