@graphql-box/connection-resolver 4.1.4 → 5.0.1

package/src/helpers/getResultsOnLastPage.ts

@@ -3,7 +3,7 @@ export type Params = {
   totalResults: number;
 };
 
-export default ({ resultsPerPage, totalResults }: Params) => {
+export const getResultsOnLastPage = ({ resultsPerPage, totalResults }: Params) => {
   const remainder = totalResults % resultsPerPage;
   return remainder === 0 ? resultsPerPage : remainder;
 };

package/src/helpers/getStartAndEndCursors.ts

@@ -1,4 +1,4 @@
-import { Edge } from "../defs";
+import { type Edge } from '../types.ts';
 
 export const getStartCursor = (edges: Edge[]) => edges[0]?.cursor;
 

package/src/helpers/getStartAndEndIndexes.test.ts

@@ -1,17 +1,17 @@
-import { getEndIndex, getStartIndex } from "./getStartAndEndIndexes";
+import { getEndIndex, getStartIndex } from './getStartAndEndIndexes.ts';
 
-describe("getStartIndex", () => {
-  test("when the direction is forward", () => {
+describe('getStartIndex', () => {
+  describe('when the direction is forward', () => {
     const args = {
-      after: "abcdefg",
+      after: 'abcdefg',
       first: 5,
     };
 
     const ctx = {
       entry: {
-        group: "qwerty",
+        group: 'qwerty',
         index: 5,
-        node: { id: "123" },
+        node: { id: '123' },
         page: 3,
       },
       metadata: {
@@ -21,21 +21,23 @@ describe("getStartIndex", () => {
       resultsPerPage: 10,
     };
 
-    expect(getStartIndex(args, ctx)).toEqual({ absolute: 6, relative: 6 });
+    it('should return the correct value', () => {
+      expect(getStartIndex(args, ctx)).toEqual({ absolute: 6, relative: 6 });
+    });
   });
 
-  describe("when the direction is backward", () => {
-    test("when on first page and count takes the start index negative", () => {
+  describe('when the direction is backward', () => {
+    describe('when on first page and count takes the start index negative', () => {
       const args = {
-        before: "abcdefg",
+        before: 'abcdefg',
         last: 5,
       };
 
       const ctx = {
         entry: {
-          group: "qwerty",
+          group: 'qwerty',
           index: 3,
-          node: { id: "123" },
+          node: { id: '123' },
           page: 1,
         },
         metadata: {
@@ -45,20 +47,22 @@ describe("getStartIndex", () => {
         resultsPerPage: 10,
       };
 
-      expect(getStartIndex(args, ctx)).toEqual({ absolute: 0, relative: 0 });
+      it('should return the correct value', () => {
+        expect(getStartIndex(args, ctx)).toEqual({ absolute: 0, relative: 0 });
+      });
     });
 
-    test("when on first page and count DOES NOT takes the start index negative", () => {
+    describe('when on first page and count DOES NOT takes the start index negative', () => {
       const args = {
-        before: "abcdefg",
+        before: 'abcdefg',
         last: 2,
       };
 
       const ctx = {
         entry: {
-          group: "qwerty",
+          group: 'qwerty',
           index: 4,
-          node: { id: "123" },
+          node: { id: '123' },
           page: 1,
         },
         metadata: {
@@ -68,21 +72,23 @@ describe("getStartIndex", () => {
         resultsPerPage: 10,
       };
 
-      expect(getStartIndex(args, ctx)).toEqual({ absolute: 2, relative: 2 });
+      it('should return the correct value', () => {
+        expect(getStartIndex(args, ctx)).toEqual({ absolute: 2, relative: 2 });
+      });
     });
 
-    describe("when NOT on first page", () => {
-      test("when the start index is more than than or equal to 0", () => {
+    describe('when NOT on first page', () => {
+      describe('when the start index is more than than or equal to 0', () => {
         const args = {
-          before: "abcdefg",
+          before: 'abcdefg',
           last: 4,
         };
 
         const ctx = {
           entry: {
-            group: "qwerty",
+            group: 'qwerty',
             index: 7,
-            node: { id: "123" },
+            node: { id: '123' },
             page: 3,
           },
           metadata: {
@@ -92,20 +98,22 @@ describe("getStartIndex", () => {
           resultsPerPage: 10,
         };
 
-        expect(getStartIndex(args, ctx)).toEqual({ absolute: 3, relative: 3 });
+        it('should return the correct value', () => {
+          expect(getStartIndex(args, ctx)).toEqual({ absolute: 3, relative: 3 });
+        });
       });
 
-      test("when the start index is less than 0", () => {
+      describe('when the start index is less than 0', () => {
         const args = {
-          before: "abcdefg",
+          before: 'abcdefg',
           last: 15,
         };
 
         const ctx = {
           entry: {
-            group: "qwerty",
+            group: 'qwerty',
             index: 4,
-            node: { id: "123" },
+            node: { id: '123' },
             page: 3,
           },
           metadata: {
@@ -115,24 +123,26 @@ describe("getStartIndex", () => {
           resultsPerPage: 10,
         };
 
-        expect(getStartIndex(args, ctx)).toEqual({ absolute: -11, relative: 9 });
+        it('should return the correct value', () => {
+          expect(getStartIndex(args, ctx)).toEqual({ absolute: -11, relative: 9 });
+        });
       });
     });
   });
 });
 
-describe("getEndIndex", () => {
-  test("when the direction is backward", () => {
+describe('getEndIndex', () => {
+  describe('when the direction is backward', () => {
     const args = {
-      before: "abcdefg",
+      before: 'abcdefg',
       last: 5,
     };
 
     const ctx = {
       entry: {
-        group: "qwerty",
+        group: 'qwerty',
         index: 5,
-        node: { id: "123" },
+        node: { id: '123' },
         page: 3,
       },
       metadata: {
@@ -142,21 +152,23 @@ describe("getEndIndex", () => {
       resultsPerPage: 10,
     };
 
-    expect(getEndIndex(args, ctx)).toEqual({ absolute: 4, relative: 4 });
+    it('should return the correct value', () => {
+      expect(getEndIndex(args, ctx)).toEqual({ absolute: 4, relative: 4 });
+    });
   });
 
-  describe("when the direction is forward", () => {
-    test("when on last page and count takes end index over last index", () => {
+  describe('when the direction is forward', () => {
+    describe('when on last page and count takes end index over last index', () => {
       const args = {
-        after: "abcdefg",
+        after: 'abcdefg',
         first: 15,
       };
 
       const ctx = {
         entry: {
-          group: "qwerty",
+          group: 'qwerty',
           index: 2,
-          node: { id: "123" },
+          node: { id: '123' },
           page: 6,
         },
         metadata: {
@@ -166,20 +178,22 @@ describe("getEndIndex", () => {
         resultsPerPage: 10,
       };
 
-      expect(getEndIndex(args, ctx)).toEqual({ absolute: 6, relative: 6 });
+      it('should return the correct value', () => {
+        expect(getEndIndex(args, ctx)).toEqual({ absolute: 6, relative: 6 });
+      });
     });
 
-    test("when on last page and count DOES NOT take end index over last index", () => {
+    describe('when on last page and count DOES NOT take end index over last index', () => {
       const args = {
-        after: "abcdefg",
+        after: 'abcdefg',
         first: 2,
       };
 
       const ctx = {
         entry: {
-          group: "qwerty",
+          group: 'qwerty',
           index: 2,
-          node: { id: "123" },
+          node: { id: '123' },
           page: 6,
         },
         metadata: {
@@ -189,21 +203,23 @@ describe("getEndIndex", () => {
         resultsPerPage: 10,
       };
 
-      expect(getEndIndex(args, ctx)).toEqual({ absolute: 4, relative: 4 });
+      it('should return the correct value', () => {
+        expect(getEndIndex(args, ctx)).toEqual({ absolute: 4, relative: 4 });
+      });
     });
 
-    describe("when NOT on last page", () => {
-      test("when the end index is less than or equal to indexes per page", () => {
+    describe('when NOT on last page', () => {
+      describe('when the end index is less than or equal to indexes per page', () => {
         const args = {
-          after: "abcdefg",
+          after: 'abcdefg',
           first: 7,
         };
 
         const ctx = {
           entry: {
-            group: "qwerty",
+            group: 'qwerty',
             index: 2,
-            node: { id: "123" },
+            node: { id: '123' },
             page: 4,
           },
           metadata: {
@@ -213,20 +229,22 @@ describe("getEndIndex", () => {
           resultsPerPage: 10,
         };
 
-        expect(getEndIndex(args, ctx)).toEqual({ absolute: 9, relative: 9 });
+        it('should return the correct value', () => {
+          expect(getEndIndex(args, ctx)).toEqual({ absolute: 9, relative: 9 });
+        });
       });
 
-      test("when end index is greater than indexes per page", () => {
+      describe('when end index is greater than indexes per page', () => {
         const args = {
-          after: "abcdefg",
+          after: 'abcdefg',
           first: 20,
         };
 
         const ctx = {
           entry: {
-            group: "qwerty",
+            group: 'qwerty',
             index: 2,
-            node: { id: "123" },
+            node: { id: '123' },
             page: 4,
           },
           metadata: {
@@ -236,7 +254,9 @@ describe("getEndIndex", () => {
           resultsPerPage: 10,
         };
 
-        expect(getEndIndex(args, ctx)).toEqual({ absolute: 22, relative: 2 });
+        it('should return the correct value', () => {
+          expect(getEndIndex(args, ctx)).toEqual({ absolute: 22, relative: 2 });
+        });
       });
     });
   });

package/src/helpers/getStartAndEndIndexes.ts

@@ -1,61 +1,67 @@
-import { ConnectionInputOptions, Context } from "../defs";
-import getCount from "./getCount";
-import getDirection from "./getDirection";
-import getIndexesOnLastPage from "./getIndexesOnLastPage";
-import isFirstPage from "./isFirstPage";
-import isLastPage from "./isLastPage";
+import { type ConnectionInputOptions, type CursorGroupMetadata, type PartialCursorCacheEntry } from '../types.ts';
+import { getCount } from './getCount.ts';
+import { getDirection } from './getDirection.ts';
+import { getIndexesOnLastPage } from './getIndexesOnLastPage.ts';
+import { isFirstPage } from './isFirstPage.ts';
+import { isLastPage } from './isLastPage.ts';
+
+export type Context = {
+  entry: PartialCursorCacheEntry;
+  metadata: CursorGroupMetadata;
+  resultsPerPage: number;
+};
 
 export const getStartIndex = (
   args: ConnectionInputOptions,
-  { entry: { index, page }, resultsPerPage }: Pick<Context, "entry" | "resultsPerPage">,
+  { entry: { index, page }, resultsPerPage }: Pick<Context, 'entry' | 'resultsPerPage'>
 ) => {
   const count = getCount(args);
 
-  return getDirection(args.last) === "forward"
+  return getDirection(args.last) === 'forward'
     ? { absolute: index + 1, relative: index + 1 }
     : isFirstPage(page) && index - count < 0
     ? { absolute: 0, relative: 0 }
     : (() => {
-        const absStartIndex = index - count;
+        const absoluteStartIndex = index - count;
 
-        if (absStartIndex >= 0) {
-          return { absolute: absStartIndex, relative: absStartIndex };
+        if (absoluteStartIndex >= 0) {
+          return { absolute: absoluteStartIndex, relative: absoluteStartIndex };
         }
 
-        const indexesRemainingAfterLastPage = Math.abs(absStartIndex);
+        const indexesRemainingAfterLastPage = Math.abs(absoluteStartIndex);
         const pagesRemaining = indexesRemainingAfterLastPage / resultsPerPage + 1;
         const remainder = indexesRemainingAfterLastPage % resultsPerPage;
-        const relStartIndex = remainder === 0 ? 0 : page - pagesRemaining < 0 ? 0 : resultsPerPage - remainder;
-        return { absolute: absStartIndex, relative: relStartIndex };
+        const relativeStartIndex = remainder === 0 ? 0 : page - pagesRemaining < 0 ? 0 : resultsPerPage - remainder;
+        return { absolute: absoluteStartIndex, relative: relativeStartIndex };
       })();
 };
 
 export const getEndIndex = (
   args: ConnectionInputOptions,
-  { entry: { index, page }, metadata: { totalPages, totalResults }, resultsPerPage }: Context,
+  { entry: { index, page }, metadata: { totalPages, totalResults }, resultsPerPage }: Context
 ) => {
   const count = getCount(args);
   const indexesOnLastPage = getIndexesOnLastPage({ resultsPerPage, totalResults });
 
-  return getDirection(args.last) === "backward"
+  return getDirection(args.last) === 'backward'
     ? { absolute: index - 1, relative: index - 1 }
     : isLastPage({ page, totalPages }) && index + count > indexesOnLastPage
     ? { absolute: indexesOnLastPage, relative: indexesOnLastPage }
     : (() => {
-        const absEndIndex = index + count;
+        const absoluteEndIndex = index + count;
         const indexesPerPage = resultsPerPage - 1;
 
-        if (absEndIndex <= indexesPerPage) {
-          return { absolute: absEndIndex, relative: absEndIndex };
+        if (absoluteEndIndex <= indexesPerPage) {
+          return { absolute: absoluteEndIndex, relative: absoluteEndIndex };
         }
 
-        const indexesRemainingAfterFirstPage = absEndIndex - indexesPerPage;
+        const indexesRemainingAfterFirstPage = absoluteEndIndex - indexesPerPage;
         const pagesRemaining = indexesRemainingAfterFirstPage / resultsPerPage;
         const remainder = indexesRemainingAfterFirstPage % resultsPerPage;
 
-        const relEndIndex =
+        const relativeEndIndex =
           remainder === 0 ? indexesPerPage : page + pagesRemaining > totalPages ? indexesOnLastPage : remainder - 1;
 
-        return { absolute: absEndIndex, relative: relEndIndex };
+        return { absolute: absoluteEndIndex, relative: relativeEndIndex };
       })();
 };

package/src/helpers/getStartAndEndPageNumbers.test.ts

@@ -1,9 +1,9 @@
-import { getEndPageNumber, getStartPageNumber } from "./getStartAndEndPageNumbers";
+import { getEndPageNumber, getStartPageNumber } from './getStartAndEndPageNumbers.ts';
 
-describe("getStartPageNumber", () => {
-  test("when the direction is forward", () => {
+describe('getStartPageNumber', () => {
+  describe('when the direction is forward', () => {
     const args = {
-      after: "abcdefg",
+      after: 'abcdefg',
     };
 
     const ctx = {
@@ -16,11 +16,13 @@ describe("getStartPageNumber", () => {
       startIndex: { absolute: 5, relative: 5 },
     };
 
-    expect(getStartPageNumber(args, ctx)).toBe(3);
+    it('should return the correct value', () => {
+      expect(getStartPageNumber(args, ctx)).toBe(3);
+    });
   });
 
-  describe("when the direction is backward", () => {
-    test("when start index is greater or equal to zero", () => {
+  describe('when the direction is backward', () => {
+    describe('when start index is greater or equal to zero', () => {
       const args = {
         last: 5,
       };
@@ -35,10 +37,12 @@ describe("getStartPageNumber", () => {
         startIndex: { absolute: 1, relative: 1 },
       };
 
-      expect(getStartPageNumber(args, ctx)).toBe(3);
+      it('should return the correct value', () => {
+        expect(getStartPageNumber(args, ctx)).toBe(3);
+      });
     });
 
-    test("when start page number is less than or equal to 1", () => {
+    describe('when start page number is less than or equal to 1', () => {
       const args = {
         last: 5,
       };
@@ -53,10 +57,12 @@ describe("getStartPageNumber", () => {
         startIndex: { absolute: -35, relative: 5 },
       };
 
-      expect(getStartPageNumber(args, ctx)).toBe(1);
+      it('should return the correct value', () => {
+        expect(getStartPageNumber(args, ctx)).toBe(1);
+      });
     });
 
-    test("when start page number is NOT less than or equal to 1", () => {
+    describe('when start page number is NOT less than or equal to 1', () => {
       const args = {
         last: 5,
       };
@@ -71,13 +77,15 @@ describe("getStartPageNumber", () => {
         startIndex: { absolute: -15, relative: 5 },
       };
 
-      expect(getStartPageNumber(args, ctx)).toBe(2);
+      it('should return the correct value', () => {
+        expect(getStartPageNumber(args, ctx)).toBe(2);
+      });
     });
   });
 });
 
-describe("getEndPageNumber", () => {
-  test("when the direction is backward", () => {
+describe('getEndPageNumber', () => {
+  describe('when the direction is backward', () => {
     const args = {
       last: 5,
     };
@@ -92,13 +100,15 @@ describe("getEndPageNumber", () => {
       resultsPerPage: 10,
     };
 
-    expect(getEndPageNumber(args, ctx)).toBe(3);
+    it('should return the correct value', () => {
+      expect(getEndPageNumber(args, ctx)).toBe(3);
+    });
   });
 
-  describe("when the direction is forward", () => {
-    test("when the page is the last page", () => {
+  describe('when the direction is forward', () => {
+    describe('when the page is the last page', () => {
       const args = {
-        after: "abcdefg",
+        after: 'abcdefg',
       };
 
       const ctx = {
@@ -111,12 +121,14 @@ describe("getEndPageNumber", () => {
         resultsPerPage: 10,
       };
 
-      expect(getEndPageNumber(args, ctx)).toBe(5);
+      it('should return the correct value', () => {
+        expect(getEndPageNumber(args, ctx)).toBe(5);
+      });
     });
 
-    test("when the end index is less than the indexes per page", () => {
+    describe('when the end index is less than the indexes per page', () => {
       const args = {
-        after: "abcdefg",
+        after: 'abcdefg',
       };
 
       const ctx = {
@@ -129,12 +141,14 @@ describe("getEndPageNumber", () => {
         resultsPerPage: 10,
       };
 
-      expect(getEndPageNumber(args, ctx)).toBe(3);
+      it('should return the correct value', () => {
+        expect(getEndPageNumber(args, ctx)).toBe(3);
+      });
     });
 
-    test("when the end page number is greater or equal to total pages", () => {
+    describe('when the end page number is greater or equal to total pages', () => {
       const args = {
-        after: "abcdefg",
+        after: 'abcdefg',
       };
 
       const ctx = {
@@ -147,12 +161,14 @@ describe("getEndPageNumber", () => {
         resultsPerPage: 10,
       };
 
-      expect(getEndPageNumber(args, ctx)).toBe(5);
+      it('should return the correct value', () => {
+        expect(getEndPageNumber(args, ctx)).toBe(5);
+      });
     });
 
-    test("when the end page number is NOT greater or equal to total pages", () => {
+    describe('when the end page number is NOT greater or equal to total pages', () => {
       const args = {
-        after: "abcdefg",
+        after: 'abcdefg',
       };
 
       const ctx = {
@@ -165,7 +181,9 @@ describe("getEndPageNumber", () => {
         resultsPerPage: 10,
       };
 
-      expect(getEndPageNumber(args, ctx)).toBe(4);
+      it('should return the correct value', () => {
+        expect(getEndPageNumber(args, ctx)).toBe(4);
+      });
     });
   });
 });

package/src/helpers/getStartAndEndPageNumbers.ts

@@ -1,6 +1,6 @@
-import { ConnectionInputOptions, Context, Indexes } from "../defs";
-import getDirection from "./getDirection";
-import isLastPage from "./isLastPage";
+import { type ConnectionInputOptions, type CursorGroupMetadata, type Indexes } from '../types.ts';
+import { getDirection } from './getDirection.ts';
+import { isLastPage } from './isLastPage.ts';
 
 export type PageNumberContext = {
   endIndex: Indexes;
@@ -8,11 +8,16 @@ export type PageNumberContext = {
   startIndex: Indexes;
 };
 
+export type Context = {
+  metadata: CursorGroupMetadata;
+  resultsPerPage: number;
+};
+
 export const getStartPageNumber = (
   args: ConnectionInputOptions,
-  { page, startIndex, resultsPerPage }: Omit<PageNumberContext, "endIndex"> & Omit<Context, "entry" | "metadata">,
+  { page, resultsPerPage, startIndex }: Omit<PageNumberContext, 'endIndex'> & Omit<Context, 'metadata'>
 ) => {
-  if (getDirection(args.last) === "forward" || startIndex.absolute >= 0) {
+  if (getDirection(args.last) === 'forward' || startIndex.absolute >= 0) {
     return page;
   }
 
@@ -22,17 +27,12 @@ export const getStartPageNumber = (
 
 export const getEndPageNumber = (
   args: ConnectionInputOptions,
-  {
-    endIndex,
-    metadata: { totalPages },
-    page,
-    resultsPerPage,
-  }: Omit<PageNumberContext, "startIndex"> & Omit<Context, "entry">,
+  { endIndex, metadata: { totalPages }, page, resultsPerPage }: Omit<PageNumberContext, 'startIndex'> & Context
 ) => {
   const indexesPerPage = resultsPerPage - 1;
 
   if (
-    getDirection(args.last) === "backward" ||
+    getDirection(args.last) === 'backward' ||
     isLastPage({ page, totalPages }) ||
     endIndex.absolute <= indexesPerPage
   ) {

package/src/helpers/hasPreviousNextPage.test.ts

@@ -1,7 +1,7 @@
-import { hasPreviousPage } from "./hasPreviousNextPage";
+import { hasPreviousPage } from './hasPreviousNextPage.ts';
 
-describe("hasPreviousPage", () => {
-  test("when first page number is 1 and start index is 0", () => {
+describe('hasPreviousPage', () => {
+  describe('when first page number is 1 and start index is 0', () => {
     const cachedEdgesByPage = [
       {
         edges: [],
@@ -10,10 +10,13 @@ describe("hasPreviousPage", () => {
     ];
 
     const startIndex = { absolute: 0, relative: 0 };
-    expect(hasPreviousPage({ cachedEdgesByPage, startIndex })).toBe(false);
+
+    it('should return the correct value', () => {
+      expect(hasPreviousPage({ cachedEdgesByPage, startIndex })).toBe(false);
+    });
   });
 
-  test("when start index is NOT 0", () => {
+  describe('when start index is NOT 0', () => {
     const cachedEdgesByPage = [
       {
         edges: [],
@@ -22,10 +25,13 @@ describe("hasPreviousPage", () => {
     ];
 
     const startIndex = { absolute: 5, relative: 5 };
-    expect(hasPreviousPage({ cachedEdgesByPage, startIndex })).toBe(true);
+
+    it('should return the correct value', () => {
+      expect(hasPreviousPage({ cachedEdgesByPage, startIndex })).toBe(true);
+    });
   });
 
-  test("when first page number is NOT 1", () => {
+  describe('when first page number is NOT 1', () => {
     const cachedEdgesByPage = [
       {
         edges: [],
@@ -34,6 +40,9 @@ describe("hasPreviousPage", () => {
     ];
 
     const startIndex = { absolute: 0, relative: 0 };
-    expect(hasPreviousPage({ cachedEdgesByPage, startIndex })).toBe(true);
+
+    it('should return the correct value', () => {
+      expect(hasPreviousPage({ cachedEdgesByPage, startIndex })).toBe(true);
+    });
   });
 });