@graphql-box/connection-resolver 5.0.1 → 5.1.0

package/dist/cjs/index.cjs

@@ -1,703 +1,2 @@
-'use strict';
-
-var lodashEs = require('lodash-es');
-require('core-js/modules/es.array.push.js');
-var graphql = require('graphql');
-
-const connectionInputOptions = new Set(['after', 'before', 'first', 'last']);
-const removeConnectionInputOptions = args => lodashEs.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 [...lodashEs.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
-}) => lodashEs.isNumber(cachedEdgesByPage[0]?.pageNumber) && cachedEdgesByPage[0]?.pageNumber !== 1 || startIndex.relative > 0;
-const hasNextPage = ({
-  cachedEdgesByPage,
-  endIndex,
-  metadata: {
-    totalPages,
-    totalResults
-  },
-  resultsPerPage
-}) => lodashEs.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 graphql.GraphQLError('Invalid connection argument combination. `after` must be used in combination with `first`.', {
-      nodes: fieldNodes
-    });
-  }
-  if (after && last) {
-    return new graphql.GraphQLError('Invalid connection argument combination. `after` cannot be used in combination with `last`.', {
-      nodes: fieldNodes
-    });
-  }
-  if (before && !last && !first) {
-    return new graphql.GraphQLError('Invalid connection argument combination. `before` must be used in combination with `last`.', {
-      nodes: fieldNodes
-    });
-  }
-  if (before && first) {
-    return new graphql.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 graphql.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 graphql.GraphQLError(`The cursor ${cursor} could not be found.`, {
-      nodes: fieldNodes
-    });
-  }
-  const direction = getDirection(last);
-  if (isCursorLast({
-    direction,
-    entry,
-    resultsPerPage,
-    ...metadata
-  })) {
-    return new graphql.GraphQLError(`The cursor ${cursor} is the last, you cannot go forward any further.`, {
-      nodes: fieldNodes
-    });
-  }
-  if (isCursorFirst({
-    direction,
-    entry
-  })) {
-    return new graphql.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
-  }));
-};
-
-exports.makeConnectionResolver = makeConnectionResolver;
-exports.removeConnectionInputOptions = removeConnectionInputOptions;
+"use strict";var e=require("lodash-es");require("core-js/modules/es.array.push.js");var r=require("graphql");const t=new Set(["after","before","first","last"]),a=async(e,{cursorCache:r,getters:t,groupCursor:a,makeIDCursor:s,resourceResolver:o})=>{const n=[],u=await Promise.all(e.map((async e=>{const{data:u,errors:g,headers:l}=await o({page:e});if(u&&!g?.length){const o=(c=t.nodes(u),d=e=>s(e.id),c.map((e=>({cursor:d(e),node:e}))));return await(async(e,{edges:r,group:t,headers:a,page:s,totalPages:o,totalResults:n})=>{const u=a.get("cache-control"),g=u?{cacheHeaders:{cacheControl:u}}:void 0;await Promise.all(r.map((async({cursor:r,node:a},o)=>e.set(r,{group:t,index:o,node:a,page:s},g)))),await e.set(`${t}-metadata`,{totalPages:o,totalResults:n},g)})(r,{edges:o,group:a,headers:l,page:e,totalPages:t.totalPages(u),totalResults:t.totalResults(u)}),{edges:o,pageNumber:e}}var c,d;return g?.length&&n.push(...g),{edges:[],pageNumber:e}})));return{cachedEdges:u,errors:n}},s=e=>e.reduce(((e,r)=>[...e,...r.edges]),[]),o=e=>e.map((e=>e.node)),n=(e,{endIndex:r,resultsPerPage:t,startIndex:a})=>e.reduce(((s,o,n)=>{const u=(({pageIndex:e,startIndex:r})=>0===e?r.relative:0)({pageIndex:n,startIndex:a}),g=(({endIndex:e,pageIndex:r,resultsPerPage:t,totalCachedPages:a})=>r===a-1?e.relative:t-1)({endIndex:r,pageIndex:n,resultsPerPage:t,totalCachedPages:e.length}),l=o.edges.slice(u,g+1);return s.push({edges:l,pageNumber:o.pageNumber}),s}),[]),u=e=>e[0]?.cursor,g=e=>{const r=e[e.length-1];return r?.cursor},l=e=>e?"backward":"forward",c=({page:e,totalPages:r})=>e===r,d=(r,{endIndex:t,entry:{page:a},metadata:s,resultsPerPage:o,startIndex:n})=>{const u=((e,{page:r,resultsPerPage:t,startIndex:a})=>{if("forward"===l(e.last)||a.absolute>=0)return r;const s=r-Math.ceil(Math.abs(a.absolute)/t);return s<=1?1:s})(r,{page:a,resultsPerPage:o,startIndex:n}),g=((e,{endIndex:r,metadata:{totalPages:t},page:a,resultsPerPage:s})=>{const o=s-1;if("backward"===l(e.last)||c({page:a,totalPages:t})||r.absolute<=o)return a;const n=a+Math.ceil((r.absolute-o)/s);return n>=t?t:n})(r,{endIndex:t,metadata:s,page:a,resultsPerPage:o});return u===g?[a]:[...e.range(u,g),g]},i=({first:e,last:r})=>e??r,P=({resultsPerPage:e,totalResults:r})=>(({resultsPerPage:e,totalResults:r})=>{const t=r%e;return 0===t?e:t})({resultsPerPage:e,totalResults:r})-1,p=({cachedEdgesByPage:r,startIndex:t})=>e.isNumber(r[0]?.pageNumber)&&1!==r[0]?.pageNumber||t.relative>0,h=({cachedEdgesByPage:r,endIndex:t,metadata:{totalPages:a,totalResults:s},resultsPerPage:o})=>e.isNumber(r[r.length-1]?.pageNumber)&&r[r.length-1]?.pageNumber!==a||t.relative<P({resultsPerPage:o,totalResults:s}),m=async(e,{groupCursor:r,pageNumber:t})=>{const{entries:a,metadata:s}=await e.export({filterByValue:[{comparator:t,keyChain:"page"},{comparator:r,keyChain:"group"}]});return{edges:a.reduce(((e,[r,{index:t,node:a}])=>(s[t]?.cacheability.checkTTL()&&(e[t]={cursor:r,node:a}),e)),[]),pageNumber:t}},b=({after:e,before:r})=>r??e,f=async(e,r,{cursorCache:t,resultsPerPage:a})=>{const s=b(e);if(s){const e=await t.get(s);if(e)return e}return((e,{metadata:{totalPages:r,totalResults:t},resultsPerPage:a})=>"backward"===l(e.last)?{index:P({resultsPerPage:a,totalResults:t})+1,page:r}:{index:-1,page:1})(e,{metadata:r,resultsPerPage:a})},C=async(e,{cursorCache:r,groupCursor:t,resultsPerPage:a})=>{const s=await r.get(`${t}-metadata`),o=await f(e,s,{cursorCache:r,resultsPerPage:a}),u=((e,{entry:{index:r,page:t},resultsPerPage:a})=>{const s=i(e);return"forward"===l(e.last)?{absolute:r+1,relative:r+1}:(e=>1===e)(t)&&r-s<0?{absolute:0,relative:0}:(()=>{const e=r-s;if(e>=0)return{absolute:e,relative:e};const o=Math.abs(e),n=o%a;return{absolute:e,relative:0===n||t-(o/a+1)<0?0:a-n}})()})(e,{entry:o,resultsPerPage:a}),g=((e,{entry:{index:r,page:t},metadata:{totalPages:a,totalResults:s},resultsPerPage:o})=>{const n=i(e),u=P({resultsPerPage:o,totalResults:s});return"backward"===l(e.last)?{absolute:r-1,relative:r-1}:c({page:t,totalPages:a})&&r+n>u?{absolute:u,relative:u}:(()=>{const e=r+n,s=o-1;if(e<=s)return{absolute:e,relative:e};const g=e-s,l=g%o;return{absolute:e,relative:0===l?s:t+g/o>a?u:l-1}})()})(e,{entry:o,metadata:s,resultsPerPage:a}),b=[],C=d(e,{endIndex:g,entry:o,metadata:s,resultsPerPage:a,startIndex:u});for(const e of C)b.push(m(r,{groupCursor:t,pageNumber:e}));const w=await Promise.all(b),x=(e=>e.reduce(((e,r)=>(0===r.edges.length&&e.push(r.pageNumber),e)),[]))(w);return{cachedEdges:0===x.length?n(w,{endIndex:g,resultsPerPage:a,startIndex:u}):w,hasNextPage:h({cachedEdgesByPage:w,endIndex:g,metadata:s,resultsPerPage:a}),hasPreviousPage:p({cachedEdgesByPage:w,startIndex:u}),indexes:{end:g,start:u},missingPages:x,totalResults:s.totalResults}},w=async(e,{cursorCache:r,getters:t,groupCursor:l,makeIDCursor:c,resourceResolver:d,resultsPerPage:i})=>{const{cachedEdges:P,hasNextPage:p,hasPreviousPage:h,indexes:m,missingPages:b,totalResults:f}=await C(e,{cursorCache:r,groupCursor:l,resultsPerPage:i});if(0===b.length){const e=s(P);return{edges:e,errors:[],nodes:o(e),pageInfo:{endCursor:g(e),hasNextPage:p,hasPreviousPage:h,startCursor:u(e)},totalCount:f}}const{cachedEdges:w,errors:x}=await a(b,{cursorCache:r,getters:t,groupCursor:l,makeIDCursor:c,resourceResolver:d}),I=n(((e,r)=>e.reduce(((e,t)=>{if(0===t.edges.length){const a=r.find((e=>e.pageNumber===t.pageNumber));if(a)return[...e,a]}return[...e,t]}),[]))(P,w),{endIndex:m.end,resultsPerPage:i,startIndex:m.start}),v=s(I);return{edges:v,errors:x,nodes:o(v),pageInfo:{endCursor:g(v),hasNextPage:p,hasPreviousPage:h,startCursor:u(v)},totalCount:f}},x=async({after:e,before:t,first:a,last:s},{fieldNodes:o},{cursorCache:n,groupCursor:u,resultsPerPage:g})=>{if(e&&!a&&!s)return new r.GraphQLError("Invalid connection argument combination. `after` must be used in combination with `first`.",{nodes:o});if(e&&s)return new r.GraphQLError("Invalid connection argument combination. `after` cannot be used in combination with `last`.",{nodes:o});if(t&&!s&&!a)return new r.GraphQLError("Invalid connection argument combination. `before` must be used in combination with `last`.",{nodes:o});if(t&&a)return new r.GraphQLError("Invalid connection argument combination. `before` cannot be used in combination with `first`.",{nodes:o});const c=await n.get(`${u}-metadata`);if(!c)return new r.GraphQLError("Curser cannot be supplied without previously being provided.",{nodes:o});const d=b({after:e,before:t}),i=await n.get(d);if(!i)return new r.GraphQLError(`The cursor ${d} could not be found.`,{nodes:o});const p=l(s);return(({direction:e,entry:{index:r,page:t},resultsPerPage:a,totalPages:s,totalResults:o})=>"forward"===e&&t===s&&r===P({resultsPerPage:a,totalResults:o}))({direction:p,entry:i,resultsPerPage:g,...c})?new r.GraphQLError(`The cursor ${d} is the last, you cannot go forward any further.`,{nodes:o}):(({direction:e,entry:{index:r,page:t}})=>"backward"===e&&1===t&&0===r)({direction:p,entry:i})?new r.GraphQLError(`The cursor ${d} is the first, you cannot go backward any further.`,{nodes:o}):void 0};exports.makeConnectionResolver=({createMakeCursors:e,createResourceResolver:r,cursorCache:t,getters:s,resolver:o=(e=>e),resultsPerPage:n})=>async(u,g,l,c)=>{const{makeGroupCursor:d,makeIDCursor:i}=e(u,g,l,c),P=r(u,g,l,c),p=d();if((({after:e,before:r})=>!!(e??r))(g)){const e=await x(g,c,{cursorCache:t,groupCursor:p,resultsPerPage:n});return o(e?{edges:[],errors:[e],nodes:[],pageInfo:{hasNextPage:!1,hasPreviousPage:!1},totalCount:0}:await w(g,{cursorCache:t,getters:s,groupCursor:p,makeIDCursor:i,resourceResolver:P,resultsPerPage:n}))}return await t.has(`${p}-metadata`)||await a([1],{cursorCache:t,getters:s,groupCursor:p,makeIDCursor:i,resourceResolver:P}),o(await w(g,{cursorCache:t,getters:s,groupCursor:p,makeIDCursor:i,resourceResolver:P,resultsPerPage:n}))},exports.removeConnectionInputOptions=r=>e.pickBy(r,((e,r)=>!t.has(r)));
 //# sourceMappingURL=index.cjs.map