@graphql-box/connection-resolver 4.1.4 → 5.0.1

package/dist/esm/index.mjs

@@ -0,0 +1,700 @@
+import { pickBy, range, isNumber } from 'lodash-es';
+import 'core-js/modules/es.array.push.js';
+import { GraphQLError } from 'graphql';
+
+const connectionInputOptions = new Set(['after', 'before', 'first', 'last']);
+const removeConnectionInputOptions = args => pickBy(args, (_value, key) => !connectionInputOptions.has(key));
+
+const isCursorSupplied = ({
+  after,
+  before
+}) => !!(after ?? before);
+
+const cacheCursors = async (cursorCache, {
+  edges,
+  group,
+  headers,
+  page,
+  totalPages,
+  totalResults
+}) => {
+  const cacheControl = headers.get('cache-control');
+  const options = cacheControl ? {
+    cacheHeaders: {
+      cacheControl
+    }
+  } : undefined;
+  await Promise.all(edges.map(async ({
+    cursor,
+    node
+  }, index) => cursorCache.set(cursor, {
+    group,
+    index,
+    node,
+    page
+  }, options)));
+  await cursorCache.set(`${group}-metadata`, {
+    totalPages,
+    totalResults
+  }, options);
+};
+
+const makeEdges = (nodes, makeCursor) => nodes.map(node => ({
+  cursor: makeCursor(node),
+  node
+}));
+
+const requestAndCachePages = async (pages, {
+  cursorCache,
+  getters,
+  groupCursor,
+  makeIDCursor,
+  resourceResolver
+}) => {
+  const errors = [];
+  const cachedEdges = await Promise.all(pages.map(async page => {
+    const {
+      data: pageResultData,
+      errors: pageResultErrors,
+      headers: pageResultHeaders
+    } = await resourceResolver({
+      page
+    });
+    if (pageResultData && !pageResultErrors?.length) {
+      const edges = makeEdges(getters.nodes(pageResultData), node => makeIDCursor(node.id));
+      await cacheCursors(cursorCache, {
+        edges,
+        group: groupCursor,
+        headers: pageResultHeaders,
+        page,
+        totalPages: getters.totalPages(pageResultData),
+        totalResults: getters.totalResults(pageResultData)
+      });
+      return {
+        edges,
+        pageNumber: page
+      };
+    }
+    if (pageResultErrors?.length) {
+      errors.push(...pageResultErrors);
+    }
+    return {
+      edges: [],
+      pageNumber: page
+    };
+  }));
+  return {
+    cachedEdges,
+    errors
+  };
+};
+
+const extractEdges = cachedEdges => cachedEdges.reduce((edges, cachedEdge) => [...edges, ...cachedEdge.edges], []);
+
+const extractNodes = edges => edges.map(edge => edge.node);
+
+const getCurrentPageStartIndex = ({
+  pageIndex,
+  startIndex
+}) => pageIndex === 0 ? startIndex.relative : 0;
+const getCurrentPageEndIndex = ({
+  endIndex,
+  pageIndex,
+  resultsPerPage,
+  totalCachedPages
+}) => pageIndex === totalCachedPages - 1 ? endIndex.relative : resultsPerPage - 1;
+
+const getInRangeCachedEdges = (cachedEdgesByPage, {
+  endIndex,
+  resultsPerPage,
+  startIndex
+}) => {
+  return cachedEdgesByPage.reduce((inRange, cachedEdgesPage, index) => {
+    const currentPageStartIndex = getCurrentPageStartIndex({
+      pageIndex: index,
+      startIndex
+    });
+    const currentPageEndIndex = getCurrentPageEndIndex({
+      endIndex,
+      pageIndex: index,
+      resultsPerPage,
+      totalCachedPages: cachedEdgesByPage.length
+    });
+    const cachedEdges = cachedEdgesPage.edges.slice(currentPageStartIndex, currentPageEndIndex + 1);
+    inRange.push({
+      edges: cachedEdges,
+      pageNumber: cachedEdgesPage.pageNumber
+    });
+    return inRange;
+  }, []);
+};
+
+const getStartCursor = edges => edges[0]?.cursor;
+const getEndCursor = edges => {
+  const lastEdge = edges[edges.length - 1];
+  return lastEdge?.cursor;
+};
+
+const mergeCachedEdges = (cachedEdges, missingCachedEdges) => cachedEdges.reduce((mergedCachedEdges, cachedEdge) => {
+  if (cachedEdge.edges.length === 0) {
+    const missingCachedEdge = missingCachedEdges.find(missing => missing.pageNumber === cachedEdge.pageNumber);
+    if (missingCachedEdge) {
+      return [...mergedCachedEdges, missingCachedEdge];
+    }
+  }
+  return [...mergedCachedEdges, cachedEdge];
+}, []);
+
+const getDirection = last => last ? 'backward' : 'forward';
+
+const isLastPage = ({
+  page,
+  totalPages
+}) => page === totalPages;
+
+const getStartPageNumber = (args, {
+  page,
+  resultsPerPage,
+  startIndex
+}) => {
+  if (getDirection(args.last) === 'forward' || startIndex.absolute >= 0) {
+    return page;
+  }
+  const startPageNumber = page - Math.ceil(Math.abs(startIndex.absolute) / resultsPerPage);
+  return startPageNumber <= 1 ? 1 : startPageNumber;
+};
+const getEndPageNumber = (args, {
+  endIndex,
+  metadata: {
+    totalPages
+  },
+  page,
+  resultsPerPage
+}) => {
+  const indexesPerPage = resultsPerPage - 1;
+  if (getDirection(args.last) === 'backward' || isLastPage({
+    page,
+    totalPages
+  }) || endIndex.absolute <= indexesPerPage) {
+    return page;
+  }
+  const endPageNumber = page + Math.ceil((endIndex.absolute - indexesPerPage) / resultsPerPage);
+  return endPageNumber >= totalPages ? totalPages : endPageNumber;
+};
+
+const getPageNumbersToRequest = (args, {
+  endIndex,
+  entry: {
+    page
+  },
+  metadata,
+  resultsPerPage,
+  startIndex
+}) => {
+  const startPageNumber = getStartPageNumber(args, {
+    page,
+    resultsPerPage,
+    startIndex
+  });
+  const endPageNumber = getEndPageNumber(args, {
+    endIndex,
+    metadata,
+    page,
+    resultsPerPage
+  });
+  if (startPageNumber === endPageNumber) {
+    return [page];
+  }
+  return [...range(startPageNumber, endPageNumber), endPageNumber];
+};
+
+const getPagesMissingFromCache = cachedEdgesByPage => {
+  return cachedEdgesByPage.reduce((missing, cachedEdgesPage) => {
+    if (cachedEdgesPage.edges.length === 0) {
+      missing.push(cachedEdgesPage.pageNumber);
+    }
+    return missing;
+  }, []);
+};
+
+const getCount = ({
+  first,
+  last
+}) => first ?? last;
+
+const getResultsOnLastPage = ({
+  resultsPerPage,
+  totalResults
+}) => {
+  const remainder = totalResults % resultsPerPage;
+  return remainder === 0 ? resultsPerPage : remainder;
+};
+
+const getIndexesOnLastPage = ({
+  resultsPerPage,
+  totalResults
+}) => getResultsOnLastPage({
+  resultsPerPage,
+  totalResults
+}) - 1;
+
+const isFirstPage = page => page === 1;
+
+const getStartIndex = (args, {
+  entry: {
+    index,
+    page
+  },
+  resultsPerPage
+}) => {
+  const count = getCount(args);
+  return getDirection(args.last) === 'forward' ? {
+    absolute: index + 1,
+    relative: index + 1
+  } : isFirstPage(page) && index - count < 0 ? {
+    absolute: 0,
+    relative: 0
+  } : (() => {
+    const absoluteStartIndex = index - count;
+    if (absoluteStartIndex >= 0) {
+      return {
+        absolute: absoluteStartIndex,
+        relative: absoluteStartIndex
+      };
+    }
+    const indexesRemainingAfterLastPage = Math.abs(absoluteStartIndex);
+    const pagesRemaining = indexesRemainingAfterLastPage / resultsPerPage + 1;
+    const remainder = indexesRemainingAfterLastPage % resultsPerPage;
+    const relativeStartIndex = remainder === 0 ? 0 : page - pagesRemaining < 0 ? 0 : resultsPerPage - remainder;
+    return {
+      absolute: absoluteStartIndex,
+      relative: relativeStartIndex
+    };
+  })();
+};
+const getEndIndex = (args, {
+  entry: {
+    index,
+    page
+  },
+  metadata: {
+    totalPages,
+    totalResults
+  },
+  resultsPerPage
+}) => {
+  const count = getCount(args);
+  const indexesOnLastPage = getIndexesOnLastPage({
+    resultsPerPage,
+    totalResults
+  });
+  return getDirection(args.last) === 'backward' ? {
+    absolute: index - 1,
+    relative: index - 1
+  } : isLastPage({
+    page,
+    totalPages
+  }) && index + count > indexesOnLastPage ? {
+    absolute: indexesOnLastPage,
+    relative: indexesOnLastPage
+  } : (() => {
+    const absoluteEndIndex = index + count;
+    const indexesPerPage = resultsPerPage - 1;
+    if (absoluteEndIndex <= indexesPerPage) {
+      return {
+        absolute: absoluteEndIndex,
+        relative: absoluteEndIndex
+      };
+    }
+    const indexesRemainingAfterFirstPage = absoluteEndIndex - indexesPerPage;
+    const pagesRemaining = indexesRemainingAfterFirstPage / resultsPerPage;
+    const remainder = indexesRemainingAfterFirstPage % resultsPerPage;
+    const relativeEndIndex = remainder === 0 ? indexesPerPage : page + pagesRemaining > totalPages ? indexesOnLastPage : remainder - 1;
+    return {
+      absolute: absoluteEndIndex,
+      relative: relativeEndIndex
+    };
+  })();
+};
+
+const hasPreviousPage = ({
+  cachedEdgesByPage,
+  startIndex
+}) => isNumber(cachedEdgesByPage[0]?.pageNumber) && cachedEdgesByPage[0]?.pageNumber !== 1 || startIndex.relative > 0;
+const hasNextPage = ({
+  cachedEdgesByPage,
+  endIndex,
+  metadata: {
+    totalPages,
+    totalResults
+  },
+  resultsPerPage
+}) => isNumber(cachedEdgesByPage[cachedEdgesByPage.length - 1]?.pageNumber) && cachedEdgesByPage[cachedEdgesByPage.length - 1]?.pageNumber !== totalPages || endIndex.relative < getIndexesOnLastPage({
+  resultsPerPage,
+  totalResults
+});
+
+const retrieveCachedEdgesByPage = async (cursorCache, {
+  groupCursor,
+  pageNumber
+}) => {
+  const {
+    entries,
+    metadata
+  } = await cursorCache.export({
+    filterByValue: [{
+      comparator: pageNumber,
+      keyChain: 'page'
+    }, {
+      comparator: groupCursor,
+      keyChain: 'group'
+    }]
+  });
+  return {
+    edges: entries.reduce((cached, [key, {
+      index,
+      node
+    }]) => {
+      if (metadata[index]?.cacheability.checkTTL()) {
+        cached[index] = {
+          cursor: key,
+          node
+        };
+      }
+      return cached;
+    }, []),
+    pageNumber
+  };
+};
+
+const getCursor = ({
+  after,
+  before
+}) => before ?? after;
+
+const makeEntry = (args, {
+  metadata: {
+    totalPages,
+    totalResults
+  },
+  resultsPerPage
+}) => {
+  if (getDirection(args.last) === 'backward') {
+    return {
+      index: getIndexesOnLastPage({
+        resultsPerPage,
+        totalResults
+      }) + 1,
+      page: totalPages
+    };
+  }
+  return {
+    index: -1,
+    page: 1
+  };
+};
+
+const retrieveEntry = async (args, metadata, {
+  cursorCache,
+  resultsPerPage
+}) => {
+  const cursor = getCursor(args);
+  if (cursor) {
+    const cursorCacheEntry = await cursorCache.get(cursor);
+    if (cursorCacheEntry) {
+      return cursorCacheEntry;
+    }
+  }
+  return makeEntry(args, {
+    metadata,
+    resultsPerPage
+  });
+};
+
+const retrieveCachedConnection = async (args, {
+  cursorCache,
+  groupCursor,
+  resultsPerPage
+}) => {
+  const metadata = await cursorCache.get(`${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 = [];
+  const pageNumbersToRequest = getPageNumbersToRequest(args, {
+    endIndex,
+    entry,
+    metadata,
+    resultsPerPage,
+    startIndex
+  });
+  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 === 0 ? getInRangeCachedEdges(cachedEdgesByPage, {
+      endIndex,
+      resultsPerPage,
+      startIndex
+    }) : cachedEdgesByPage,
+    hasNextPage: hasNextPage({
+      cachedEdgesByPage,
+      endIndex,
+      metadata,
+      resultsPerPage
+    }),
+    hasPreviousPage: hasPreviousPage({
+      cachedEdgesByPage,
+      startIndex
+    }),
+    indexes: {
+      end: endIndex,
+      start: startIndex
+    },
+    missingPages,
+    totalResults: metadata.totalResults
+  };
+};
+
+const resolveConnection = async (args, {
+  cursorCache,
+  getters,
+  groupCursor,
+  makeIDCursor,
+  resourceResolver,
+  resultsPerPage
+}) => {
+  const {
+    cachedEdges,
+    hasNextPage,
+    hasPreviousPage,
+    indexes,
+    missingPages,
+    totalResults
+  } = await retrieveCachedConnection(args, {
+    cursorCache,
+    groupCursor,
+    resultsPerPage
+  });
+  if (missingPages.length === 0) {
+    const edges = extractEdges(cachedEdges);
+    return {
+      edges,
+      errors: [],
+      nodes: extractNodes(edges),
+      pageInfo: {
+        endCursor: getEndCursor(edges),
+        hasNextPage,
+        hasPreviousPage,
+        startCursor: getStartCursor(edges)
+      },
+      totalCount: totalResults
+    };
+  }
+  const {
+    cachedEdges: missingCachedEdges,
+    errors
+  } = await requestAndCachePages(missingPages, {
+    cursorCache,
+    getters,
+    groupCursor,
+    makeIDCursor,
+    resourceResolver
+  });
+  const mergedCachedEdges = getInRangeCachedEdges(mergeCachedEdges(cachedEdges, missingCachedEdges), {
+    endIndex: indexes.end,
+    resultsPerPage,
+    startIndex: indexes.start
+  });
+  const edges = extractEdges(mergedCachedEdges);
+  return {
+    edges,
+    errors,
+    nodes: extractNodes(edges),
+    pageInfo: {
+      endCursor: getEndCursor(edges),
+      hasNextPage,
+      hasPreviousPage,
+      startCursor: getStartCursor(edges)
+    },
+    totalCount: totalResults
+  };
+};
+
+const isCursorFirst = ({
+  direction,
+  entry: {
+    index,
+    page
+  }
+}) => direction === 'backward' && page === 1 && index === 0;
+
+const isCursorLast = ({
+  direction,
+  entry: {
+    index,
+    page
+  },
+  resultsPerPage,
+  totalPages,
+  totalResults
+}) => direction === 'forward' && page === totalPages && index === getIndexesOnLastPage({
+  resultsPerPage,
+  totalResults
+});
+
+const validateCursor = async ({
+  after,
+  before,
+  first,
+  last
+}, {
+  fieldNodes
+}, {
+  cursorCache,
+  groupCursor,
+  resultsPerPage
+}) => {
+  if (after && !first && !last) {
+    return new GraphQLError('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`.', {
+      nodes: fieldNodes
+    });
+  }
+  if (before && !last && !first) {
+    return new GraphQLError('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`.', {
+      nodes: fieldNodes
+    });
+  }
+  const metadata = await cursorCache.get(`${groupCursor}-metadata`);
+  if (!metadata) {
+    return new GraphQLError('Curser cannot be supplied without previously being provided.', {
+      nodes: fieldNodes
+    });
+  }
+  const cursor = getCursor({
+    after,
+    before
+  });
+  const entry = await cursorCache.get(cursor);
+  if (!entry) {
+    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.`, {
+      nodes: fieldNodes
+    });
+  }
+  if (isCursorFirst({
+    direction,
+    entry
+  })) {
+    return new GraphQLError(`The cursor ${cursor} is the first, you cannot go backward any further.`, {
+      nodes: fieldNodes
+    });
+  }
+  return;
+};
+
+const makeConnectionResolver = ({
+  createMakeCursors,
+  createResourceResolver,
+  cursorCache,
+  getters,
+  resolver = result => result,
+  resultsPerPage
+}) => async (source, args, context, info) => {
+  const {
+    makeGroupCursor,
+    makeIDCursor
+  } = createMakeCursors(source, args, context, info);
+  const resourceResolver = createResourceResolver(source, args, context, info);
+  const groupCursor = makeGroupCursor();
+  if (isCursorSupplied(args)) {
+    const cursorError = await validateCursor(args, info, {
+      cursorCache,
+      groupCursor,
+      resultsPerPage
+    });
+    if (cursorError) {
+      return resolver({
+        edges: [],
+        errors: [cursorError],
+        nodes: [],
+        pageInfo: {
+          hasNextPage: false,
+          hasPreviousPage: false
+        },
+        totalCount: 0
+      });
+    }
+    return resolver(await resolveConnection(args, {
+      cursorCache,
+      getters,
+      groupCursor,
+      makeIDCursor,
+      resourceResolver,
+      resultsPerPage
+    }));
+  }
+  if (await cursorCache.has(`${groupCursor}-metadata`)) {
+    return resolver(await resolveConnection(args, {
+      cursorCache,
+      getters,
+      groupCursor,
+      makeIDCursor,
+      resourceResolver,
+      resultsPerPage
+    }));
+  }
+  await requestAndCachePages([1], {
+    cursorCache,
+    getters,
+    groupCursor,
+    makeIDCursor,
+    resourceResolver
+  });
+  return resolver(await resolveConnection(args, {
+    cursorCache,
+    getters,
+    groupCursor,
+    makeIDCursor,
+    resourceResolver,
+    resultsPerPage
+  }));
+};
+
+export { makeConnectionResolver, removeConnectionInputOptions };
+//# sourceMappingURL=index.mjs.map