@graphql-box/connection-resolver 4.1.4 → 5.0.0

package/src/helpers/hasPreviousNextPage.ts

@@ -1,5 +1,6 @@
-import { CachedEdges, CursorGroupMetadata, Indexes } from "../defs";
-import getIndexesOnLastPage from "./getIndexesOnLastPage";
+import { isNumber } from 'lodash-es';
+import { type CachedEdges, type CursorGroupMetadata, type Indexes } from '../types.ts';
+import { getIndexesOnLastPage } from './getIndexesOnLastPage.ts';
 
 export type HasPreviousPageParams = {
   cachedEdgesByPage: CachedEdges[];
@@ -14,7 +15,7 @@ export type HasNextPageParams = {
 };
 
 export const hasPreviousPage = ({ cachedEdgesByPage, startIndex }: HasPreviousPageParams) =>
-  cachedEdgesByPage[0].pageNumber !== 1 || startIndex.relative > 0;
+  (isNumber(cachedEdgesByPage[0]?.pageNumber) && cachedEdgesByPage[0]?.pageNumber !== 1) || startIndex.relative > 0;
 
 export const hasNextPage = ({
   cachedEdgesByPage,
@@ -22,5 +23,6 @@ export const hasNextPage = ({
   metadata: { totalPages, totalResults },
   resultsPerPage,
 }: HasNextPageParams) =>
-  cachedEdgesByPage[cachedEdgesByPage.length - 1].pageNumber !== totalPages ||
+  (isNumber(cachedEdgesByPage[cachedEdgesByPage.length - 1]?.pageNumber) &&
+    cachedEdgesByPage[cachedEdgesByPage.length - 1]?.pageNumber !== totalPages) ||
   endIndex.relative < getIndexesOnLastPage({ resultsPerPage, totalResults });

package/src/helpers/isCursorFirst.test.ts

@@ -1,14 +1,20 @@
-import { CursorCacheEntry } from "../defs";
-import isCursorFirst from "./isCursorFirst";
+import { type CursorCacheEntry } from '../types.ts';
+import { isCursorFirst } from './isCursorFirst.ts';
 
-describe("isCursorFirst", () => {
-  test("when cursor is first", () => {
+describe('isCursorFirst', () => {
+  describe('when cursor is first', () => {
     const entry = { index: 0, page: 1 };
-    expect(isCursorFirst({ direction: "backward", entry: entry as CursorCacheEntry })).toBe(true);
+
+    it('should return the correct value', () => {
+      expect(isCursorFirst({ direction: 'backward', entry: entry as CursorCacheEntry })).toBe(true);
+    });
   });
 
-  test("when cursor is NOT first", () => {
+  describe('when cursor is NOT first', () => {
     const entry = { index: 1, page: 1 };
-    expect(isCursorFirst({ direction: "backward", entry: entry as CursorCacheEntry })).toBe(false);
+
+    it('should return the correct value', () => {
+      expect(isCursorFirst({ direction: 'backward', entry: entry as CursorCacheEntry })).toBe(false);
+    });
   });
 });

package/src/helpers/isCursorFirst.ts

@@ -1,8 +1,9 @@
-import { CursorCacheEntry, Direction } from "../defs";
+import { type CursorCacheEntry, type Direction } from '../types.ts';
 
 export type Params = {
   direction: Direction;
   entry: CursorCacheEntry;
 };
 
-export default ({ direction, entry: { index, page } }: Params) => direction === "backward" && page === 1 && index === 0;
+export const isCursorFirst = ({ direction, entry: { index, page } }: Params) =>
+  direction === 'backward' && page === 1 && index === 0;

package/src/helpers/isCursorLast.test.ts

@@ -1,32 +1,36 @@
-import { CursorCacheEntry } from "../defs";
-import isCursorLast from "./isCursorLast";
+import { type CursorCacheEntry } from '../types.ts';
+import { isCursorLast } from './isCursorLast.ts';
 
-describe("isCursorLast", () => {
-  test("when cursor is last", () => {
+describe('isCursorLast', () => {
+  describe('when cursor is last', () => {
     const entry = { index: 2, page: 6 };
 
-    expect(
-      isCursorLast({
-        direction: "forward",
-        entry: entry as CursorCacheEntry,
-        resultsPerPage: 10,
-        totalPages: 6,
-        totalResults: 53,
-      }),
-    ).toBe(true);
+    it('should return the correct value', () => {
+      expect(
+        isCursorLast({
+          direction: 'forward',
+          entry: entry as CursorCacheEntry,
+          resultsPerPage: 10,
+          totalPages: 6,
+          totalResults: 53,
+        })
+      ).toBe(true);
+    });
   });
 
-  test("when cursor is NOT last", () => {
+  describe('when cursor is NOT last', () => {
     const entry = { index: 0, page: 6 };
 
-    expect(
-      isCursorLast({
-        direction: "forward",
-        entry: entry as CursorCacheEntry,
-        resultsPerPage: 10,
-        totalPages: 6,
-        totalResults: 53,
-      }),
-    ).toBe(false);
+    it('should return the correct value', () => {
+      expect(
+        isCursorLast({
+          direction: 'forward',
+          entry: entry as CursorCacheEntry,
+          resultsPerPage: 10,
+          totalPages: 6,
+          totalResults: 53,
+        })
+      ).toBe(false);
+    });
   });
 });

package/src/helpers/isCursorLast.ts

@@ -1,5 +1,5 @@
-import { CursorCacheEntry, Direction } from "../defs";
-import getIndexesOnLastPage from "./getIndexesOnLastPage";
+import { type CursorCacheEntry, type Direction } from '../types.ts';
+import { getIndexesOnLastPage } from './getIndexesOnLastPage.ts';
 
 export type Params = {
   direction: Direction;
@@ -9,5 +9,5 @@ export type Params = {
   totalResults: number;
 };
 
-export default ({ direction, entry: { index, page }, resultsPerPage, totalPages, totalResults }: Params) =>
-  direction === "forward" && page === totalPages && index === getIndexesOnLastPage({ resultsPerPage, totalResults });
+export const isCursorLast = ({ direction, entry: { index, page }, resultsPerPage, totalPages, totalResults }: Params) =>
+  direction === 'forward' && page === totalPages && index === getIndexesOnLastPage({ resultsPerPage, totalResults });

package/src/helpers/isCursorSupplied.test.ts

@@ -1,19 +1,27 @@
-import isCursorSupplied from "./isCursorSupplied";
+import { isCursorSupplied } from './isCursorSupplied.ts';
 
-describe("isCursorSupplied", () => {
-  test("when neither 'before' nor 'after' are passed in", () => {
-    expect(isCursorSupplied({})).toBe(false);
+describe('isCursorSupplied', () => {
+  describe("when neither 'before' nor 'after' are passed in", () => {
+    it('should return the correct value', () => {
+      expect(isCursorSupplied({})).toBe(false);
+    });
   });
 
-  test("when 'before' is passed in", () => {
-    expect(isCursorSupplied({ before: "12345" })).toBe(true);
+  describe("when 'before' is passed in", () => {
+    it('should return the correct value', () => {
+      expect(isCursorSupplied({ before: '12345' })).toBe(true);
+    });
   });
 
-  test("when 'after' is passed in", () => {
-    expect(isCursorSupplied({ after: "12345" })).toBe(true);
+  describe("when 'after' is passed in", () => {
+    it('should return the correct value', () => {
+      expect(isCursorSupplied({ after: '12345' })).toBe(true);
+    });
   });
 
-  test("when 'before' and 'after' are passed in", () => {
-    expect(isCursorSupplied({ after: "12345", before: "12345" })).toBe(true);
+  describe("when 'before' and 'after' are passed in", () => {
+    it('should return the correct value', () => {
+      expect(isCursorSupplied({ after: '12345', before: '12345' })).toBe(true);
+    });
   });
 });

package/src/helpers/isCursorSupplied.ts

@@ -1,3 +1,4 @@
-import { ConnectionInputOptions, PlainObject } from "../defs";
+import type { PlainObject } from '@graphql-box/core';
+import { type ConnectionInputOptions } from '../types.ts';
 
-export default ({ after, before }: PlainObject & ConnectionInputOptions) => !!(after || before);
+export const isCursorSupplied = ({ after, before }: PlainObject & ConnectionInputOptions) => !!(after ?? before);

package/src/helpers/isFirstPage.test.ts

@@ -1,11 +1,15 @@
-import isFirstPage from "./isFirstPage";
+import { isFirstPage } from './isFirstPage.ts';
 
-describe("isFirstPage", () => {
-  test("when page is first page", () => {
-    expect(isFirstPage(1)).toBe(true);
+describe('isFirstPage', () => {
+  describe('when page is first page', () => {
+    it('should return the correct value', () => {
+      expect(isFirstPage(1)).toBe(true);
+    });
   });
 
-  test("when page is NOT first page", () => {
-    expect(isFirstPage(5)).toBe(false);
+  describe('when page is NOT first page', () => {
+    it('should return the correct value', () => {
+      expect(isFirstPage(5)).toBe(false);
+    });
   });
 });

package/src/helpers/isFirstPage.ts

@@ -1 +1 @@
-export default (page: number) => page === 1;
+export const isFirstPage = (page: number) => page === 1;

package/src/helpers/isLastPage.test.ts

@@ -1,11 +1,15 @@
-import isLastPage from "./isLastPage";
+import { isLastPage } from './isLastPage.ts';
 
-describe("isLastPage", () => {
-  test("when page is last page", () => {
-    expect(isLastPage({ page: 5, totalPages: 5 })).toBe(true);
+describe('isLastPage', () => {
+  describe('when page is last page', () => {
+    it('should return the correct value', () => {
+      expect(isLastPage({ page: 5, totalPages: 5 })).toBe(true);
+    });
   });
 
-  test("when page is NOT last page", () => {
-    expect(isLastPage({ page: 4, totalPages: 5 })).toBe(false);
+  describe('when page is NOT last page', () => {
+    it('should return the correct value', () => {
+      expect(isLastPage({ page: 4, totalPages: 5 })).toBe(false);
+    });
   });
 });

package/src/helpers/isLastPage.ts

@@ -3,4 +3,4 @@ export type Params = {
   totalPages: number;
 };
 
-export default ({ page, totalPages }: Params) => page === totalPages;
+export const isLastPage = ({ page, totalPages }: Params) => page === totalPages;

package/src/helpers/makeEdges.ts

@@ -1,4 +1,4 @@
-import { Node } from "../defs";
+import { type Node } from '../types.ts';
 
-export default (nodes: Node[], makeCursor: (node: Node) => string) =>
-  nodes.map(node => ({ node, cursor: makeCursor(node) }));
+export const makeEdges = (nodes: Node[], makeCursor: (node: Node) => string) =>
+  nodes.map(node => ({ cursor: makeCursor(node), node }));

package/src/helpers/makeEntry.ts

@@ -1,14 +1,17 @@
-import { ConnectionInputOptions, CursorGroupMetadata } from "..";
-import getDirection from "./getDirection";
-import getIndexesOnLastPage from "./getIndexesOnLastPage";
+import { type ConnectionInputOptions, type CursorGroupMetadata } from '../types.ts';
+import { getDirection } from './getDirection.ts';
+import { getIndexesOnLastPage } from './getIndexesOnLastPage.ts';
 
 export type Context = {
   metadata: CursorGroupMetadata;
   resultsPerPage: number;
 };
 
-export default (args: ConnectionInputOptions, { metadata: { totalPages, totalResults }, resultsPerPage }: Context) => {
-  if (getDirection(args.last) === "backward") {
+export const makeEntry = (
+  args: ConnectionInputOptions,
+  { metadata: { totalPages, totalResults }, resultsPerPage }: Context
+) => {
+  if (getDirection(args.last) === 'backward') {
     return { index: getIndexesOnLastPage({ resultsPerPage, totalResults }) + 1, page: totalPages };
   }
 

package/src/helpers/mergeCachedEdges.ts

@@ -1,8 +1,8 @@
-import { CachedEdges } from "../defs";
+import { type CachedEdges } from '../types.ts';
 
-export default (cachedEdges: CachedEdges[], missingCachedEdges: CachedEdges[]) =>
-  cachedEdges.reduce((mergedCachedEdges, cachedEdge) => {
-    if (!cachedEdge.edges.length) {
+export const mergeCachedEdges = (cachedEdges: CachedEdges[], missingCachedEdges: CachedEdges[]) =>
+  cachedEdges.reduce<CachedEdges[]>((mergedCachedEdges, cachedEdge) => {
+    if (cachedEdge.edges.length === 0) {
       const missingCachedEdge = missingCachedEdges.find(missing => missing.pageNumber === cachedEdge.pageNumber);
 
       if (missingCachedEdge) {
@@ -11,4 +11,4 @@ export default (cachedEdges: CachedEdges[], missingCachedEdges: CachedEdges[]) =
     }
 
     return [...mergedCachedEdges, cachedEdge];
-  }, [] as CachedEdges[]);
+  }, []);

package/src/helpers/removeConnectionInputOptions.test.ts

@@ -1,17 +1,19 @@
-import removeConnectionInputOptions from "./removeConnectionInputOptions";
+import { removeConnectionInputOptions } from './removeConnectionInputOptions.ts';
 
-describe("removeConnectionInputOptions", () => {
-  test("when connection input options are passed in", () => {
+describe('removeConnectionInputOptions', () => {
+  describe('when connection input options are passed in', () => {
     const args = {
-      after: "abcdefg",
-      alpha: "bravo",
-      before: "higklmn",
+      after: 'abcdefg',
+      alpha: 'bravo',
+      before: 'higklmn',
       first: 10,
       last: 5,
     };
 
-    expect(removeConnectionInputOptions(args)).toEqual({
-      alpha: "bravo",
+    it('should return the correct value', () => {
+      expect(removeConnectionInputOptions(args)).toEqual({
+        alpha: 'bravo',
+      });
     });
   });
 });

package/src/helpers/removeConnectionInputOptions.ts

@@ -1,5 +1,6 @@
-import { pickBy } from "lodash";
+import { pickBy } from 'lodash-es';
 
-const connectionInputOptions = ["after", "before", "first", "last"];
+const connectionInputOptions = new Set(['after', 'before', 'first', 'last']);
 
-export default <O extends object>(args: O) => pickBy(args, (_value, key) => !connectionInputOptions.includes(key));
+export const removeConnectionInputOptions = <O extends object>(args: O) =>
+  pickBy(args, (_value, key) => !connectionInputOptions.has(key));

package/src/helpers/requestAndCachePages.ts

@@ -1,25 +1,30 @@
-import Cachemap from "@cachemap/core";
-import { Getters, Node, PlainObject, ResourceResolver } from "../defs";
-import cacheCursors from "./cacheCursors";
-import makeEdges from "./makeEdges";
+import { type Core } from '@cachemap/core';
+import type { PlainObject } from '@graphql-box/core';
+import { type Getters, type Node, type ResourceResolver } from '../types.ts';
+import { cacheCursors } from './cacheCursors.ts';
+import { makeEdges } from './makeEdges.ts';
 
 export type Context<Resource extends PlainObject, ResourceNode extends Node> = {
-  cursorCache: Cachemap;
+  cursorCache: Core;
   getters: Getters<Resource, ResourceNode>;
   groupCursor: string;
   makeIDCursor: (id: string | number) => string;
   resourceResolver: ResourceResolver<Resource>;
 };
 
-const requestAndCachePages = async <Resource extends PlainObject, ResourceNode extends Node>(
+export const requestAndCachePages = async <Resource extends PlainObject, ResourceNode extends Node>(
   pages: number[],
-  { cursorCache, getters, groupCursor, makeIDCursor, resourceResolver }: Context<Resource, ResourceNode>,
+  { cursorCache, getters, groupCursor, makeIDCursor, resourceResolver }: Context<Resource, ResourceNode>
 ) => {
   const errors: Error[] = [];
 
   const cachedEdges = await Promise.all(
     pages.map(async page => {
-      const { data: pageResultData, errors: pageResultErrors, headers: pageResultHeaders } = await resourceResolver({
+      const {
+        data: pageResultData,
+        errors: pageResultErrors,
+        headers: pageResultHeaders,
+      } = await resourceResolver({
         page,
       });
 
@@ -43,10 +48,8 @@ const requestAndCachePages = async <Resource extends PlainObject, ResourceNode e
       }
 
       return { edges: [], pageNumber: page };
-    }),
+    })
   );
 
   return { cachedEdges, errors };
 };
-
-export default requestAndCachePages;

package/src/helpers/requestOutstandingPages.ts

@@ -1,6 +1,8 @@
+import type { PlainArray } from '@graphql-box/core';
+
 export type RequestMissingPagesParams = {
   count: number;
-  direction: "forward" | "backward";
+  direction: 'forward' | 'backward';
   page: number;
   results: number;
   resultsPerPage: number;
@@ -8,49 +10,46 @@ export type RequestMissingPagesParams = {
   totalResults: number;
 };
 
-export type RequestMissingPagesCallback = (params: { nextPage: number }) => Promise<any>;
+export type RequestMissingPagesCallback = (params: { nextPage: number }) => Promise<unknown>;
 
-export default async (
+export const requestOutstandingPages = async (
   { count, direction, page, results, resultsPerPage, totalPages, totalResults }: RequestMissingPagesParams,
-  requestCallback: RequestMissingPagesCallback,
+  requestCallback: RequestMissingPagesCallback
 ) => {
   const resultsOnLastPage = totalResults % totalPages;
   const outstanding = count - results;
   let toRequest: number;
 
-  if (direction === "forward") {
+  if (direction === 'forward') {
     toRequest = Math.ceil(outstanding / resultsPerPage);
   } else {
     if (page === totalPages) {
-      if (count <= resultsOnLastPage) {
-        toRequest = 1;
-      } else {
-        toRequest = Math.ceil(count - resultsOnLastPage / resultsPerPage) + 1;
-      }
+      toRequest = count <= resultsOnLastPage ? 1 : Math.ceil(count - resultsOnLastPage / resultsPerPage) + 1;
     } else {
       toRequest = Math.ceil(outstanding / resultsPerPage);
     }
   }
 
-  const promises = [];
+  const promises: Promise<unknown>[] = [];
 
-  for (let i = 0; i < toRequest; i += 1) {
-    promises.push(requestCallback({ nextPage: direction === "forward" ? page + i : page - i }));
+  for (let index = 0; index < toRequest; index += 1) {
+    promises.push(requestCallback({ nextPage: direction === 'forward' ? page + index : page - index }));
   }
 
   const missingPages: number[] = [];
+  const settledResults = await Promise.allSettled(promises);
 
-  const pageResults = (await Promise.allSettled(promises)).reduce((pages, { status, ...rest }, i) => {
-    if (status === "fulfilled") {
-      pages.push((rest as { value: any }).value);
+  const pageResults = settledResults.reduce<PlainArray>((pages, result, index) => {
+    if (result.status === 'fulfilled') {
+      pages.push(result.value);
     }
 
-    if (status === "rejected") {
-      missingPages.push(direction === "forward" ? page + i : page - i);
+    if (result.status === 'rejected') {
+      missingPages.push(direction === 'forward' ? page + index : page - index);
     }
 
     return pages;
-  }, [] as any[]);
+  }, []);
 
   return {
     missingPages,

package/src/helpers/resolveConnection.ts

@@ -1,15 +1,16 @@
-import Cachemap from "@cachemap/core";
-import { ConnectionInputOptions, Getters, Node, PlainObject, ResourceResolver } from "../defs";
-import extractEdges from "./extractEdges";
-import extractNodes from "./extractNodes";
-import getInRangeCachedEdges from "./getInRangeCachedEdges";
-import { getEndCursor, getStartCursor } from "./getStartAndEndCursors";
-import mergeCachedEdges from "./mergeCachedEdges";
-import requestAndCachePages from "./requestAndCachePages";
-import retrieveCachedConnection from "./retrieveCachedConnection";
+import { type Core } from '@cachemap/core';
+import type { PlainObject } from '@graphql-box/core';
+import { type ConnectionInputOptions, type Getters, type Node, type ResourceResolver } from '../types.ts';
+import { extractEdges } from './extractEdges.ts';
+import { extractNodes } from './extractNodes.ts';
+import { getInRangeCachedEdges } from './getInRangeCachedEdges.ts';
+import { getEndCursor, getStartCursor } from './getStartAndEndCursors.ts';
+import { mergeCachedEdges } from './mergeCachedEdges.ts';
+import { requestAndCachePages } from './requestAndCachePages.ts';
+import { retrieveCachedConnection } from './retrieveCachedConnection.ts';
 
 export type Context<Resource extends PlainObject, ResourceNode extends Node> = {
-  cursorCache: Cachemap;
+  cursorCache: Core;
   getters: Getters<Resource, ResourceNode>;
   groupCursor: string;
   makeIDCursor: (id: string | number) => string;
@@ -17,31 +18,18 @@ export type Context<Resource extends PlainObject, ResourceNode extends Node> = {
   resultsPerPage: number;
 };
 
-const resolveConnection = async <Resource extends PlainObject, ResourceNode extends Node>(
+export const resolveConnection = async <Resource extends PlainObject, ResourceNode extends Node>(
   args: PlainObject & ConnectionInputOptions,
-  {
-    cursorCache,
-    getters,
-    groupCursor,
-    makeIDCursor,
-    resourceResolver,
-    resultsPerPage,
-  }: Context<Resource, ResourceNode>,
+  { cursorCache, getters, groupCursor, makeIDCursor, resourceResolver, resultsPerPage }: Context<Resource, ResourceNode>
 ) => {
-  const {
-    cachedEdges,
-    hasNextPage,
-    hasPreviousPage,
-    indexes,
-    missingPages,
-    totalResults,
-  } = await retrieveCachedConnection(args, {
-    cursorCache,
-    groupCursor,
-    resultsPerPage,
-  });
+  const { cachedEdges, hasNextPage, hasPreviousPage, indexes, missingPages, totalResults } =
+    await retrieveCachedConnection(args, {
+      cursorCache,
+      groupCursor,
+      resultsPerPage,
+    });
 
-  if (!missingPages.length) {
+  if (missingPages.length === 0) {
     const edges = extractEdges(cachedEdges);
 
     return {
@@ -87,5 +75,3 @@ const resolveConnection = async <Resource extends PlainObject, ResourceNode exte
     totalCount: totalResults,
   };
 };
-
-export default resolveConnection;