@graphql-box/connection-resolver 0.1.2 → 0.1.6

package/src/helpers/requestAndCachePages.ts

@@ -1,19 +1,19 @@
 import Cachemap from "@cachemap/core";
-import { Getters, ResourceResolver } from "../defs";
+import { Getters, Node, PlainObject, ResourceResolver } from "../defs";
 import cacheCursors from "./cacheCursors";
 import makeEdges from "./makeEdges";
 
-export type Context = {
+export type Context<Resource extends PlainObject, ResourceNode extends Node> = {
   cursorCache: Cachemap;
-  getters: Getters;
+  getters: Getters<Resource, ResourceNode>;
   groupCursor: string;
   makeIDCursor: (id: string | number) => string;
-  resourceResolver: ResourceResolver;
+  resourceResolver: ResourceResolver<Resource>;
 };
 
-export default async (
+const requestAndCachePages = async <Resource extends PlainObject, ResourceNode extends Node>(
   pages: number[],
-  { cursorCache, getters, groupCursor, makeIDCursor, resourceResolver }: Context,
+  { cursorCache, getters, groupCursor, makeIDCursor, resourceResolver }: Context<Resource, ResourceNode>,
 ) => {
   const errors: Error[] = [];
 
@@ -48,3 +48,5 @@ export default async (
 
   return { cachedEdges, errors };
 };
+
+export default requestAndCachePages;

package/src/helpers/resolveConnection.ts

@@ -1,5 +1,5 @@
 import Cachemap from "@cachemap/core";
-import { ConnectionInputOptions, Getters, ResourceResolver } from "../defs";
+import { ConnectionInputOptions, Getters, Node, PlainObject, ResourceResolver } from "../defs";
 import extractEdges from "./extractEdges";
 import extractNodes from "./extractNodes";
 import getInRangeCachedEdges from "./getInRangeCachedEdges";
@@ -8,18 +8,25 @@ import mergeCachedEdges from "./mergeCachedEdges";
 import requestAndCachePages from "./requestAndCachePages";
 import retrieveCachedConnection from "./retrieveCachedConnection";
 
-export type Context = {
+export type Context<Resource extends PlainObject, ResourceNode extends Node> = {
   cursorCache: Cachemap;
-  getters: Getters;
+  getters: Getters<Resource, ResourceNode>;
   groupCursor: string;
   makeIDCursor: (id: string | number) => string;
-  resourceResolver: ResourceResolver;
+  resourceResolver: ResourceResolver<Resource>;
   resultsPerPage: number;
 };
 
-export default async (
-  args: Record<string, any> & ConnectionInputOptions,
-  { cursorCache, getters, groupCursor, makeIDCursor, resourceResolver, resultsPerPage }: Context,
+const resolveConnection = async <Resource extends PlainObject, ResourceNode extends Node>(
+  args: PlainObject & ConnectionInputOptions,
+  {
+    cursorCache,
+    getters,
+    groupCursor,
+    makeIDCursor,
+    resourceResolver,
+    resultsPerPage,
+  }: Context<Resource, ResourceNode>,
 ) => {
   const {
     cachedEdges,
@@ -51,7 +58,7 @@ export default async (
     };
   }
 
-  const { cachedEdges: missingCachedEdges, errors } = await requestAndCachePages(missingPages, {
+  const { cachedEdges: missingCachedEdges, errors } = await requestAndCachePages<Resource, ResourceNode>(missingPages, {
     cursorCache,
     getters,
     groupCursor,
@@ -80,3 +87,5 @@ export default async (
     totalCount: totalResults,
   };
 };
+
+export default resolveConnection;

package/src/helpers/retrieveCachedConnection.test.ts

@@ -30,8 +30,8 @@ describe("retrieveCachedConnection", () => {
 
       const edges = extractEdges(cachedEdges);
       expect(edges.length).toBe(5);
-      expect(decode(edges[0].node.id.split("::")[0])).toBe("1::1");
-      expect(decode(edges[edges.length - 1].node.id.split("::")[0])).toBe("5::1");
+      expect(decode((edges[0].node.id as string).split("::")[0])).toBe("1::1");
+      expect(decode((edges[edges.length - 1].node.id as string).split("::")[0])).toBe("5::1");
       expect(hasPreviousPage).toBe(true);
       expect(hasNextPage).toBe(true);
       expect(missingPages.length).toBe(0);
@@ -59,8 +59,8 @@ describe("retrieveCachedConnection", () => {
 
       const edges = extractEdges(cachedEdges);
       expect(edges.length).toBe(15);
-      expect(decode(edges[0].node.id.split("::")[0])).toBe("6::1");
-      expect(decode(edges[edges.length - 1].node.id.split("::")[0])).toBe("0::3");
+      expect(decode((edges[0].node.id as string).split("::")[0])).toBe("6::1");
+      expect(decode((edges[edges.length - 1].node.id as string).split("::")[0])).toBe("0::3");
       expect(hasPreviousPage).toBe(true);
       expect(hasNextPage).toBe(true);
       expect(missingPages.length).toBe(0);
@@ -88,8 +88,8 @@ describe("retrieveCachedConnection", () => {
 
       const edges = extractEdges(cachedEdges);
       expect(edges.length).toBe(9);
-      expect(decode(edges[0].node.id.split("::")[0])).toBe("1::10");
-      expect(decode(edges[edges.length - 1].node.id.split("::")[0])).toBe("9::10");
+      expect(decode((edges[0].node.id as string).split("::")[0])).toBe("1::10");
+      expect(decode((edges[edges.length - 1].node.id as string).split("::")[0])).toBe("9::10");
       expect(hasPreviousPage).toBe(true);
       expect(hasNextPage).toBe(false);
       expect(missingPages.length).toBe(0);
@@ -118,8 +118,8 @@ describe("retrieveCachedConnection", () => {
 
         const edges = extractEdges(cachedEdges);
         expect(edges.length).toBe(29);
-        expect(decode(edges[0].node.id.split("::")[0])).toBe("1::8");
-        expect(decode(edges[edges.length - 1].node.id.split("::")[0])).toBe("9::10");
+        expect(decode((edges[0].node.id as string).split("::")[0])).toBe("1::8");
+        expect(decode((edges[edges.length - 1].node.id as string).split("::")[0])).toBe("9::10");
         expect(hasPreviousPage).toBe(true);
         expect(hasNextPage).toBe(false);
         expect(missingPages.length).toBe(0);
@@ -147,8 +147,8 @@ describe("retrieveCachedConnection", () => {
 
         const edges = extractEdges(cachedEdges);
         expect(edges.length).toBe(25);
-        expect(decode(edges[0].node.id.split("::")[0])).toBe("1::8");
-        expect(decode(edges[edges.length - 1].node.id.split("::")[0])).toBe("5::10");
+        expect(decode((edges[0].node.id as string).split("::")[0])).toBe("1::8");
+        expect(decode((edges[edges.length - 1].node.id as string).split("::")[0])).toBe("5::10");
         expect(hasPreviousPage).toBe(true);
         expect(hasNextPage).toBe(false);
         expect(missingPages.length).toBe(0);
@@ -178,8 +178,8 @@ describe("retrieveCachedConnection", () => {
 
         const edges = extractEdges(cachedEdges);
         expect(edges.length).toBe(25);
-        expect(decode(edges[0].node.id.split("::")[0])).toBe("1::8");
-        expect(decode(edges[edges.length - 1].node.id.split("::")[0])).toBe("5::10");
+        expect(decode((edges[0].node.id as string).split("::")[0])).toBe("1::8");
+        expect(decode((edges[edges.length - 1].node.id as string).split("::")[0])).toBe("5::10");
         expect(hasPreviousPage).toBe(true);
         expect(hasNextPage).toBe(true);
         expect(missingPages.length).toBe(0);
@@ -207,8 +207,8 @@ describe("retrieveCachedConnection", () => {
 
         const edges = extractEdges(cachedEdges);
         expect(edges.length).toBe(25);
-        expect(decode(edges[0].node.id.split("::")[0])).toBe("1::8");
-        expect(decode(edges[edges.length - 1].node.id.split("::")[0])).toBe("5::10");
+        expect(decode((edges[0].node.id as string).split("::")[0])).toBe("1::8");
+        expect(decode((edges[edges.length - 1].node.id as string).split("::")[0])).toBe("5::10");
         expect(hasPreviousPage).toBe(true);
         expect(hasNextPage).toBe(false);
         expect(missingPages.length).toBe(0);
@@ -238,8 +238,8 @@ describe("retrieveCachedConnection", () => {
 
         const edges = extractEdges(cachedEdges);
         expect(edges.length).toBe(20);
-        expect(decode(edges[0].node.id.split("::")[0])).toBe("0::8");
-        expect(decode(edges[edges.length - 1].node.id.split("::")[0])).toBe("9::10");
+        expect(decode((edges[0].node.id as string).split("::")[0])).toBe("0::8");
+        expect(decode((edges[edges.length - 1].node.id as string).split("::")[0])).toBe("9::10");
         expect(hasPreviousPage).toBe(true);
         expect(hasNextPage).toBe(false);
         expect(missingPages.length).toBe(1);
@@ -268,8 +268,8 @@ describe("retrieveCachedConnection", () => {
 
         const edges = extractEdges(cachedEdges);
         expect(edges.length).toBe(20);
-        expect(decode(edges[0].node.id.split("::")[0])).toBe("0::8");
-        expect(decode(edges[edges.length - 1].node.id.split("::")[0])).toBe("9::10");
+        expect(decode((edges[0].node.id as string).split("::")[0])).toBe("0::8");
+        expect(decode((edges[edges.length - 1].node.id as string).split("::")[0])).toBe("9::10");
         expect(hasPreviousPage).toBe(true);
         expect(hasNextPage).toBe(true);
         expect(missingPages.length).toBe(1);
@@ -301,8 +301,8 @@ describe("retrieveCachedConnection", () => {
 
       const edges = extractEdges(cachedEdges);
       expect(edges.length).toBe(5);
-      expect(decode(edges[0].node.id.split("::")[0])).toBe("4::10");
-      expect(decode(edges[edges.length - 1].node.id.split("::")[0])).toBe("8::10");
+      expect(decode((edges[0].node.id as string).split("::")[0])).toBe("4::10");
+      expect(decode((edges[edges.length - 1].node.id as string).split("::")[0])).toBe("8::10");
       expect(hasPreviousPage).toBe(true);
       expect(hasNextPage).toBe(true);
       expect(missingPages.length).toBe(0);
@@ -330,8 +330,8 @@ describe("retrieveCachedConnection", () => {
 
       const edges = extractEdges(cachedEdges);
       expect(edges.length).toBe(15);
-      expect(decode(edges[0].node.id.split("::")[0])).toBe("4::9");
-      expect(decode(edges[edges.length - 1].node.id.split("::")[0])).toBe("8::10");
+      expect(decode((edges[0].node.id as string).split("::")[0])).toBe("4::9");
+      expect(decode((edges[edges.length - 1].node.id as string).split("::")[0])).toBe("8::10");
       expect(hasPreviousPage).toBe(true);
       expect(hasNextPage).toBe(true);
       expect(missingPages.length).toBe(0);
@@ -359,8 +359,8 @@ describe("retrieveCachedConnection", () => {
 
       const edges = extractEdges(cachedEdges);
       expect(edges.length).toBe(9);
-      expect(decode(edges[0].node.id.split("::")[0])).toBe("0::1");
-      expect(decode(edges[edges.length - 1].node.id.split("::")[0])).toBe("8::1");
+      expect(decode((edges[0].node.id as string).split("::")[0])).toBe("0::1");
+      expect(decode((edges[edges.length - 1].node.id as string).split("::")[0])).toBe("8::1");
       expect(hasPreviousPage).toBe(false);
       expect(hasNextPage).toBe(true);
       expect(missingPages.length).toBe(0);
@@ -388,8 +388,8 @@ describe("retrieveCachedConnection", () => {
 
       const edges = extractEdges(cachedEdges);
       expect(edges.length).toBe(27);
-      expect(decode(edges[0].node.id.split("::")[0])).toBe("0::1");
-      expect(decode(edges[edges.length - 1].node.id.split("::")[0])).toBe("6::3");
+      expect(decode((edges[0].node.id as string).split("::")[0])).toBe("0::1");
+      expect(decode((edges[edges.length - 1].node.id as string).split("::")[0])).toBe("6::3");
       expect(hasPreviousPage).toBe(false);
       expect(hasNextPage).toBe(true);
       expect(missingPages.length).toBe(0);
@@ -417,8 +417,8 @@ describe("retrieveCachedConnection", () => {
 
       const edges = extractEdges(cachedEdges);
       expect(edges.length).toBe(25);
-      expect(decode(edges[0].node.id.split("::")[0])).toBe("2::1");
-      expect(decode(edges[edges.length - 1].node.id.split("::")[0])).toBe("6::3");
+      expect(decode((edges[0].node.id as string).split("::")[0])).toBe("2::1");
+      expect(decode((edges[edges.length - 1].node.id as string).split("::")[0])).toBe("6::3");
       expect(hasPreviousPage).toBe(true);
       expect(hasNextPage).toBe(true);
       expect(missingPages.length).toBe(0);
@@ -447,8 +447,8 @@ describe("retrieveCachedConnection", () => {
 
         const edges = extractEdges(cachedEdges);
         expect(edges.length).toBe(20);
-        expect(decode(edges[0].node.id.split("::")[0])).toBe("0::1");
-        expect(decode(edges[edges.length - 1].node.id.split("::")[0])).toBe("9::3");
+        expect(decode((edges[0].node.id as string).split("::")[0])).toBe("0::1");
+        expect(decode((edges[edges.length - 1].node.id as string).split("::")[0])).toBe("9::3");
         expect(hasPreviousPage).toBe(false);
         expect(hasNextPage).toBe(true);
         expect(missingPages.length).toBe(1);
@@ -477,8 +477,8 @@ describe("retrieveCachedConnection", () => {
 
         const edges = extractEdges(cachedEdges);
         expect(edges.length).toBe(20);
-        expect(decode(edges[0].node.id.split("::")[0])).toBe("0::1");
-        expect(decode(edges[edges.length - 1].node.id.split("::")[0])).toBe("9::3");
+        expect(decode((edges[0].node.id as string).split("::")[0])).toBe("0::1");
+        expect(decode((edges[edges.length - 1].node.id as string).split("::")[0])).toBe("9::3");
         expect(hasPreviousPage).toBe(true);
         expect(hasNextPage).toBe(true);
         expect(missingPages.length).toBe(1);

package/src/main/index.test.ts

@@ -5,31 +5,27 @@ import { encode } from "js-base64";
 import makeConnectionResolver from ".";
 import generateCursorCache from "../__testUtils__/generateCursorCache";
 import generatePageResponse from "../__testUtils__/generatePageResponse";
-import { Getters } from "../defs";
+import { PlainObject } from "../defs";
 import removeConnectionInputOptions from "../helpers/removeConnectionInputOptions";
 
 describe("connectionResolver", () => {
-  const createMakeCursors = (_source: Record<string, any>, args: Record<string, any>) => ({
+  const createMakeCursors = (_source: PlainObject, args: PlainObject) => ({
     makeGroupCursor: () => encode(JSON.stringify(removeConnectionInputOptions(args))),
     makeIDCursor: (id: string | number) => encode(`${id}::${JSON.stringify(removeConnectionInputOptions(args))}`),
   });
 
-  const getters: Getters = {
-    nodes: ({ results }) => results,
-    page: ({ page }) => page,
-    totalPages: ({ totalPages }) => totalPages,
-    totalResults: ({ totalResults }) => totalResults,
+  const getters = {
+    nodes: ({ results }: PlainObject) => results,
+    page: ({ page }: PlainObject) => page,
+    totalPages: ({ totalPages }: PlainObject) => totalPages,
+    totalResults: ({ totalResults }: PlainObject) => totalResults,
   };
 
   const resultsPerPage = 10;
 
   describe("when a cursor is supplied", () => {
     test("when the cursor is invalid", async () => {
-      const createResourceResolver = (
-        _obj: Record<string, any>,
-        args: Record<string, any>,
-        { restClient }: Record<string, any>,
-      ) => {
+      const createResourceResolver = (_obj: PlainObject, args: PlainObject, { restClient }: PlainObject) => {
         return async ({ page }: { page: number }) => restClient({ ...removeConnectionInputOptions(args), page });
       };
 
@@ -41,7 +37,6 @@ describe("connectionResolver", () => {
           store: map(),
         }),
         getters,
-        resolver: result => result,
         resultsPerPage,
       });
 
@@ -57,11 +52,7 @@ describe("connectionResolver", () => {
     });
 
     test("when there are NO missing pages in the cache", async () => {
-      const createResourceResolver = (
-        _obj: Record<string, any>,
-        args: Record<string, any>,
-        { restClient }: Record<string, any>,
-      ) => {
+      const createResourceResolver = (_obj: PlainObject, args: PlainObject, { restClient }: PlainObject) => {
         return async ({ page }: { page: number }) => restClient({ ...removeConnectionInputOptions(args), page });
       };
 
@@ -79,8 +70,7 @@ describe("connectionResolver", () => {
         createMakeCursors,
         createResourceResolver,
         cursorCache,
-        getters: (getters as unknown) as Getters,
-        resolver: result => result,
+        getters,
         resultsPerPage,
       });
 
@@ -99,9 +89,9 @@ describe("connectionResolver", () => {
       const mock = jest.fn().mockImplementation(page => pageResponse(page));
 
       const createResourceResolver = (
-        _obj: Record<string, any>,
-        _args: Record<string, any>,
-        _context: Record<string, any>,
+        _obj: PlainObject,
+        _args: PlainObject,
+        _context: PlainObject,
         _info: GraphQLResolveInfo,
       ) => async ({ page }: { page: number }) => mock(page);
 
@@ -119,8 +109,7 @@ describe("connectionResolver", () => {
         createMakeCursors,
         createResourceResolver,
         cursorCache,
-        getters: (getters as unknown) as Getters,
-        resolver: result => result,
+        getters,
         resultsPerPage,
       });
 
@@ -139,11 +128,7 @@ describe("connectionResolver", () => {
 
   describe("when the first [X] number are requested", () => {
     test("when there is a fresh cache and there are NO missing pages in the cache", async () => {
-      const createResourceResolver = (
-        _obj: Record<string, any>,
-        args: Record<string, any>,
-        { restClient }: Record<string, any>,
-      ) => {
+      const createResourceResolver = (_obj: PlainObject, args: PlainObject, { restClient }: PlainObject) => {
         return async ({ page }: { page: number }) => restClient({ ...removeConnectionInputOptions(args), page });
       };
 
@@ -161,8 +146,7 @@ describe("connectionResolver", () => {
         createMakeCursors,
         createResourceResolver,
         cursorCache,
-        getters: (getters as unknown) as Getters,
-        resolver: result => result,
+        getters,
         resultsPerPage,
       });
 
@@ -180,9 +164,9 @@ describe("connectionResolver", () => {
       const mock = jest.fn().mockImplementation(page => pageResponse(page));
 
       const createResourceResolver = (
-        _obj: Record<string, any>,
-        _args: Record<string, any>,
-        _context: Record<string, any>,
+        _obj: PlainObject,
+        _args: PlainObject,
+        _context: PlainObject,
         _info: GraphQLResolveInfo,
       ) => async ({ page }: { page: number }) => mock(page);
 
@@ -200,8 +184,7 @@ describe("connectionResolver", () => {
         createMakeCursors,
         createResourceResolver,
         cursorCache,
-        getters: (getters as unknown) as Getters,
-        resolver: result => result,
+        getters,
         resultsPerPage,
       });
 
@@ -221,9 +204,9 @@ describe("connectionResolver", () => {
       const mock = jest.fn().mockImplementation(page => pageResponse(page));
 
       const createResourceResolver = (
-        _obj: Record<string, any>,
-        _args: Record<string, any>,
-        _context: Record<string, any>,
+        _obj: PlainObject,
+        _args: PlainObject,
+        _context: PlainObject,
         _info: GraphQLResolveInfo,
       ) => async ({ page }: { page: number }) => mock(page);
 
@@ -236,8 +219,7 @@ describe("connectionResolver", () => {
         createMakeCursors,
         createResourceResolver,
         cursorCache,
-        getters: (getters as unknown) as Getters,
-        resolver: result => result,
+        getters,
         resultsPerPage,
       });
 
@@ -255,11 +237,7 @@ describe("connectionResolver", () => {
 
   describe("when the last [X] number are requested", () => {
     test("when there is a fresh cache and there are NO missing pages in the cache", async () => {
-      const createResourceResolver = (
-        _obj: Record<string, any>,
-        args: Record<string, any>,
-        { restClient }: Record<string, any>,
-      ) => {
+      const createResourceResolver = (_obj: PlainObject, args: PlainObject, { restClient }: PlainObject) => {
         return async ({ page }: { page: number }) => restClient({ ...removeConnectionInputOptions(args), page });
       };
 
@@ -277,8 +255,7 @@ describe("connectionResolver", () => {
         createMakeCursors,
         createResourceResolver,
         cursorCache,
-        getters: (getters as unknown) as Getters,
-        resolver: result => result,
+        getters,
         resultsPerPage,
       });
 
@@ -296,9 +273,9 @@ describe("connectionResolver", () => {
       const mock = jest.fn().mockImplementation(page => pageResponse(page));
 
       const createResourceResolver = (
-        _obj: Record<string, any>,
-        _args: Record<string, any>,
-        _context: Record<string, any>,
+        _obj: PlainObject,
+        _args: PlainObject,
+        _context: PlainObject,
         _info: GraphQLResolveInfo,
       ) => async ({ page }: { page: number }) => mock(page);
 
@@ -316,8 +293,7 @@ describe("connectionResolver", () => {
         createMakeCursors,
         createResourceResolver,
         cursorCache,
-        getters: (getters as unknown) as Getters,
-        resolver: result => result,
+        getters,
         resultsPerPage,
       });
 
@@ -337,9 +313,9 @@ describe("connectionResolver", () => {
       const mock = jest.fn().mockImplementation(page => pageResponse(page));
 
       const createResourceResolver = (
-        _obj: Record<string, any>,
-        _args: Record<string, any>,
-        _context: Record<string, any>,
+        _obj: PlainObject,
+        _args: PlainObject,
+        _context: PlainObject,
         _info: GraphQLResolveInfo,
       ) => async ({ page }: { page: number }) => mock(page);
 
@@ -352,8 +328,7 @@ describe("connectionResolver", () => {
         createMakeCursors,
         createResourceResolver,
         cursorCache,
-        getters: (getters as unknown) as Getters,
-        resolver: result => result,
+        getters,
         resultsPerPage,
       });
 

package/src/main/index.ts

@@ -1,21 +1,27 @@
 import { GraphQLResolveInfo } from "graphql";
-import { Connection, ConnectionAdapterUserOptions, ConnectionInputOptions } from "../defs";
+import { Connection, ConnectionInputOptions, ConnectionResolverUserOptions, Node, PlainObject } from "../defs";
 import isCursorSupplied from "../helpers/isCursorSupplied";
 import requestAndCachePages from "../helpers/requestAndCachePages";
 import resolveConnection from "../helpers/resolveConnection";
 import validateCursor from "../helpers/validateCursor";
 
-export default ({
+const main = <
+  Source extends PlainObject,
+  Args extends PlainObject,
+  Ctx extends PlainObject,
+  Resource extends PlainObject,
+  ResourceNode extends Node
+>({
   cursorCache,
   createMakeCursors,
   createResourceResolver,
   getters,
-  resolver,
+  resolver = result => result,
   resultsPerPage,
-}: ConnectionAdapterUserOptions) => async (
-  source: Record<string, any>,
-  args: Record<string, any> & ConnectionInputOptions,
-  context: Record<string, any>,
+}: ConnectionResolverUserOptions<Source, Args, Ctx, Resource, ResourceNode>) => async (
+  source: Source,
+  args: Args & ConnectionInputOptions,
+  context: Ctx,
   info: GraphQLResolveInfo,
 ): Promise<Connection> => {
   try {
@@ -68,7 +74,7 @@ export default ({
       );
     }
 
-    await requestAndCachePages([1], {
+    await requestAndCachePages<Resource, ResourceNode>([1], {
       cursorCache,
       getters,
       groupCursor,
@@ -90,3 +96,5 @@ export default ({
     throw e;
   }
 };
+
+export default main;