@depup/gatsby 5.16.1-depup.0

package/dist/datastore/lmdb/query/run-query.js

@@ -0,0 +1,285 @@
+"use strict";
+
+exports.__esModule = true;
+exports.compareByKeySuffix = compareByKeySuffix;
+exports.doRunQuery = doRunQuery;
+var _iterable = require("../../common/iterable");
+var _query = require("../../common/query");
+var _createIndex = require("./create-index");
+var _filterUsingIndex = require("./filter-using-index");
+var _redux = require("../../../redux");
+var _common = require("./common");
+var _suggestIndex = require("./suggest-index");
+async function doRunQuery(args) {
+  // Note: Keeping doRunQuery method the only async method in chain for perf
+  const context = createQueryContext(args);
+  const totalCount = async () => runCountOnce({
+    ...context,
+    limit: undefined,
+    skip: 0
+  });
+  if (canUseIndex(context)) {
+    await Promise.all(context.nodeTypeNames.map(typeName => (0, _createIndex.createIndex)(context, typeName, context.suggestedIndexFields)));
+    return {
+      entries: performIndexScan(context),
+      totalCount
+    };
+  }
+  return {
+    entries: performFullTableScan(context),
+    totalCount
+  };
+}
+function performIndexScan(context) {
+  const {
+    suggestedIndexFields,
+    sortFields
+  } = context;
+  const filterContext = context.nodeTypeNames.length === 1 ? context : {
+    ...context,
+    skip: 0,
+    limit: typeof context.limit === `undefined` ? undefined : context.skip + context.limit
+  };
+  let result = new _iterable.GatsbyIterable([]);
+  let resultOffset = filterContext.skip;
+  for (const typeName of context.nodeTypeNames) {
+    const indexMetadata = (0, _createIndex.getIndexMetadata)(context, typeName, suggestedIndexFields);
+    if (!needsSorting(context)) {
+      const {
+        nodes,
+        usedSkip
+      } = filterNodes(filterContext, indexMetadata);
+      result = result.concat(nodes);
+      resultOffset = usedSkip;
+      continue;
+    }
+    if (canUseIndexForSorting(indexMetadata, sortFields)) {
+      const {
+        nodes,
+        usedSkip
+      } = filterNodes(filterContext, indexMetadata);
+      // Interleave nodes of different types (not expensive for already sorted chunks)
+      result = result.mergeSorted(nodes, createNodeSortComparator(sortFields));
+      resultOffset = usedSkip;
+      continue;
+    }
+    // The sad part - unlimited filter + in-memory sort
+    const unlimited = {
+      ...context,
+      skip: 0,
+      limit: undefined
+    };
+    const {
+      nodes,
+      usedSkip
+    } = filterNodes(unlimited, indexMetadata);
+    const sortedNodes = sortNodesInMemory(context, nodes);
+    resultOffset = usedSkip;
+    result = result.mergeSorted(sortedNodes, createNodeSortComparator(sortFields));
+  }
+  const {
+    limit,
+    skip = 0
+  } = context;
+  const actualSkip = skip - resultOffset;
+  if (limit || actualSkip) {
+    result = result.slice(actualSkip, limit ? actualSkip + limit : undefined);
+  }
+  return result;
+}
+function runCountOnce(context) {
+  if (typeof context.totalCount === `undefined`) {
+    context.totalCount = runCount(context);
+  }
+  return context.totalCount;
+}
+function runCount(context) {
+  let count = 0;
+  if (!needsFiltering(context)) {
+    for (const typeName of context.nodeTypeNames) {
+      count += context.datastore.countNodes(typeName);
+    }
+    return count;
+  }
+  if (!canUseIndex(context)) {
+    for (const typeName of context.nodeTypeNames) {
+      const nodes = completeFiltering(context, new _iterable.GatsbyIterable(context.datastore.iterateNodesByType(typeName)));
+      for (const _ of nodes) count++;
+    }
+    return count;
+  }
+  for (const typeName of context.nodeTypeNames) {
+    const indexMetadata = (0, _createIndex.getIndexMetadata)(context, typeName, context.suggestedIndexFields);
+    try {
+      count += (0, _filterUsingIndex.countUsingIndexOnly)({
+        ...context,
+        indexMetadata
+      });
+    } catch (e) {
+      // We cannot reliably count using index - fallback to full iteration :/
+      for (const _ of filterNodes(context, indexMetadata).nodes) count++;
+    }
+  }
+  return count;
+}
+function performFullTableScan(context) {
+  // console.warn(`Fallback to full table scan :/`)
+
+  const {
+    datastore,
+    nodeTypeNames
+  } = context;
+  let result = new _iterable.GatsbyIterable([]);
+  for (const typeName of nodeTypeNames) {
+    let nodes = new _iterable.GatsbyIterable(datastore.iterateNodesByType(typeName));
+    nodes = completeFiltering(context, nodes);
+    if (needsSorting(context)) {
+      nodes = sortNodesInMemory(context, nodes);
+      result = result.mergeSorted(nodes, createNodeSortComparator(context.sortFields));
+    } else {
+      result = result.concat(nodes);
+    }
+  }
+  const {
+    limit,
+    skip = 0
+  } = context;
+  if (limit || skip) {
+    result = result.slice(skip, limit ? skip + limit : undefined);
+  }
+  return result;
+}
+function filterNodes(context, indexMetadata) {
+  const {
+    entries,
+    usedQueries,
+    usedSkip
+  } = (0, _filterUsingIndex.filterUsingIndex)({
+    ...context,
+    indexMetadata,
+    reverse: Array.from(context.sortFields.values())[0] === -1
+  });
+  const nodes = entries.map(({
+    value
+  }) => context.datastore.getNode(value)).filter(Boolean);
+  return {
+    nodes: completeFiltering(context, nodes, usedQueries),
+    usedSkip
+  };
+}
+
+/**
+ * Takes intermediate result and applies any remaining filterQueries.
+ *
+ * If result is already fully filtered - simply returns.
+ */
+function completeFiltering(context, intermediateResult, usedQueries = new Set()) {
+  const {
+    dbQueries
+  } = context;
+  if (isFullyFiltered(dbQueries, usedQueries)) {
+    return intermediateResult;
+  }
+  // Apply remaining filter operations directly (last resort: slow)
+  const resolvedNodes = _redux.store.getState().resolvedNodesCache;
+  const filtersToApply = dbQueries.filter(q => !usedQueries.has(q)).map(q => [(0, _query.dbQueryToDottedField)(q), (0, _query.getFilterStatement)(q)]);
+  return intermediateResult.filter(node => {
+    var _resolvedNodes$get;
+    const resolvedFields = resolvedNodes === null || resolvedNodes === void 0 ? void 0 : (_resolvedNodes$get = resolvedNodes.get(node.internal.type)) === null || _resolvedNodes$get === void 0 ? void 0 : _resolvedNodes$get.get(node.id);
+    for (const [dottedField, filter] of filtersToApply) {
+      const tmp = (0, _common.resolveFieldValue)(dottedField, node, resolvedFields);
+      const value = Array.isArray(tmp) ? tmp : [tmp];
+      if (value.some(v => !(0, _common.matchesFilter)(filter, v))) {
+        // Mimic AND semantics
+        return false;
+      }
+    }
+    return true;
+  });
+}
+function sortNodesInMemory(context, nodes) {
+  // TODO: Sort using index data whenever possible (maybe store data needed for sorting in index values)
+  // TODO: Nodes can be partially sorted by index prefix - we can (and should) exploit this
+  return new _iterable.GatsbyIterable(() => {
+    const arr = Array.from(nodes);
+    arr.sort(createNodeSortComparator(context.sortFields));
+    return arr;
+  });
+}
+function createQueryContext(args) {
+  const {
+    queryArgs: {
+      filter,
+      sort,
+      limit,
+      skip = 0
+    } = {},
+    firstOnly
+  } = args;
+  return {
+    datastore: args.datastore,
+    databases: args.databases,
+    nodeTypeNames: args.nodeTypeNames,
+    dbQueries: (0, _query.createDbQueriesFromObject)((0, _query.prepareQueryArgs)(filter)),
+    sortFields: new Map(sort === null || sort === void 0 ? void 0 : sort.fields.map((field, i) => [field, (0, _common.isDesc)(sort === null || sort === void 0 ? void 0 : sort.order[i]) ? -1 : 1])),
+    suggestedIndexFields: new Map((0, _suggestIndex.suggestIndex)({
+      filter,
+      sort
+    })),
+    limit: firstOnly ? 1 : limit,
+    skip
+  };
+}
+function canUseIndex(context) {
+  return context.suggestedIndexFields.size > 0;
+}
+function needsFiltering(context) {
+  return context.dbQueries.length > 0;
+}
+function needsSorting(context) {
+  return context.sortFields.size > 0;
+}
+
+/**
+ * Based on assumption that if all sort fields exist in index
+ * then any result received from this index is fully sorted
+ */
+function canUseIndexForSorting(index, sortFields) {
+  const indexKeyFields = new Map(index.keyFields);
+  for (const [field, sortOrder] of sortFields) {
+    if (indexKeyFields.get(field) !== sortOrder) {
+      return false;
+    }
+  }
+  return true;
+}
+function isFullyFiltered(dbQueries, usedQueries) {
+  return dbQueries.length === usedQueries.size;
+}
+function createNodeSortComparator(sortFields) {
+  const resolvedNodesCache = _redux.store.getState().resolvedNodesCache;
+  return function nodeComparator(a, b) {
+    var _resolvedNodesCache$g, _resolvedNodesCache$g2;
+    const resolvedAFields = resolvedNodesCache === null || resolvedNodesCache === void 0 ? void 0 : (_resolvedNodesCache$g = resolvedNodesCache.get(a.internal.type)) === null || _resolvedNodesCache$g === void 0 ? void 0 : _resolvedNodesCache$g.get(a.id);
+    const resolvedBFields = resolvedNodesCache === null || resolvedNodesCache === void 0 ? void 0 : (_resolvedNodesCache$g2 = resolvedNodesCache.get(b.internal.type)) === null || _resolvedNodesCache$g2 === void 0 ? void 0 : _resolvedNodesCache$g2.get(b.id);
+    for (const [field, direction] of sortFields) {
+      const valueA = (0, _common.resolveFieldValue)(field, a, resolvedAFields);
+      const valueB = (0, _common.resolveFieldValue)(field, b, resolvedBFields);
+      if (valueA > valueB) {
+        return direction === 1 ? 1 : -1;
+      } else if (valueA < valueB) {
+        return direction === 1 ? -1 : 1;
+      }
+    }
+    return 0;
+  };
+}
+function compareByKeySuffix(prefixLength) {
+  return function (a, b) {
+    const aSuffix = a.key.slice(prefixLength);
+    const bSuffix = b.key.slice(prefixLength);
+    // @ts-ignore
+    return (0, _common.compareKey)(aSuffix, bSuffix);
+  };
+}
+//# sourceMappingURL=run-query.js.map

package/dist/datastore/lmdb/query/run-query.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-query.js","names":["doRunQuery","args","context","createQueryContext","totalCount","runCountOnce","limit","undefined","skip","canUseIndex","Promise","all","nodeTypeNames","map","typeName","createIndex","suggestedIndexFields","entries","performIndexScan","performFullTableScan","sortFields","filterContext","length","result","GatsbyIterable","resultOffset","indexMetadata","getIndexMetadata","needsSorting","nodes","usedSkip","filterNodes","concat","canUseIndexForSorting","mergeSorted","createNodeSortComparator","unlimited","sortedNodes","sortNodesInMemory","actualSkip","slice","runCount","count","needsFiltering","datastore","countNodes","completeFiltering","iterateNodesByType","_","countUsingIndexOnly","e","usedQueries","filterUsingIndex","reverse","Array","from","values","value","getNode","filter","Boolean","intermediateResult","Set","dbQueries","isFullyFiltered","resolvedNodes","store","getState","resolvedNodesCache","filtersToApply","q","has","dbQueryToDottedField","getFilterStatement","node","resolvedFields","get","internal","type","id","dottedField","tmp","resolveFieldValue","isArray","some","v","matchesFilter","arr","sort","queryArgs","firstOnly","databases","createDbQueriesFromObject","prepareQueryArgs","Map","fields","field","i","isDesc","order","suggestIndex","size","index","indexKeyFields","keyFields","sortOrder","nodeComparator","a","b","resolvedAFields","resolvedBFields","direction","valueA","valueB","compareByKeySuffix","prefixLength","aSuffix","key","bSuffix","compareKey"],"sources":["../../../../src/datastore/lmdb/query/run-query.ts"],"sourcesContent":["import {\n  IDataStore,\n  ILmdbDatabases,\n  IQueryResult,\n  IRunQueryArgs,\n} from \"../../types\"\nimport { IGatsbyNode } from \"../../../redux/types\"\nimport { GatsbyIterable } from \"../../common/iterable\"\nimport {\n  createDbQueriesFromObject,\n  DbQuery,\n  dbQueryToDottedField,\n  getFilterStatement,\n  IDbFilterStatement,\n  prepareQueryArgs,\n} from \"../../common/query\"\nimport {\n  createIndex,\n  getIndexMetadata,\n  IIndexMetadata,\n  IndexFields,\n} from \"./create-index\"\nimport {\n  countUsingIndexOnly,\n  filterUsingIndex,\n  IIndexEntry,\n} from \"./filter-using-index\"\nimport { store } from \"../../../redux\"\nimport { isDesc, resolveFieldValue, matchesFilter, compareKey } from \"./common\"\nimport { suggestIndex } from \"./suggest-index\"\n\ninterface IDoRunQueryArgs extends IRunQueryArgs {\n  databases: ILmdbDatabases\n  datastore: IDataStore\n}\n\ntype SortFields = Map<string, number>\n\ninterface IQueryContext {\n  datastore: IDataStore\n  databases: ILmdbDatabases\n  dbQueries: Array<DbQuery>\n  sortFields: SortFields\n  nodeTypeNames: Array<string>\n  suggestedIndexFields: IndexFields\n  indexMetadata?: IIndexMetadata\n  limit?: number\n  skip: number\n  totalCount?: number\n}\n\nexport async function doRunQuery(args: IDoRunQueryArgs): Promise<IQueryResult> {\n  // Note: Keeping doRunQuery method the only async method in chain for perf\n  const context = createQueryContext(args)\n\n  const totalCount = async (): Promise<number> =>\n    runCountOnce({ ...context, limit: undefined, skip: 0 })\n\n  if (canUseIndex(context)) {\n    await Promise.all(\n      context.nodeTypeNames.map(typeName =>\n        createIndex(context, typeName, context.suggestedIndexFields)\n      )\n    )\n    return { entries: performIndexScan(context), totalCount }\n  }\n  return { entries: performFullTableScan(context), totalCount }\n}\n\nfunction performIndexScan(context: IQueryContext): GatsbyIterable<IGatsbyNode> {\n  const { suggestedIndexFields, sortFields } = context\n\n  const filterContext =\n    context.nodeTypeNames.length === 1\n      ? context\n      : {\n          ...context,\n          skip: 0,\n          limit:\n            typeof context.limit === `undefined`\n              ? undefined\n              : context.skip + context.limit,\n        }\n\n  let result = new GatsbyIterable<IGatsbyNode>([])\n  let resultOffset = filterContext.skip\n  for (const typeName of context.nodeTypeNames) {\n    const indexMetadata = getIndexMetadata(\n      context,\n      typeName,\n      suggestedIndexFields\n    )\n    if (!needsSorting(context)) {\n      const { nodes, usedSkip } = filterNodes(filterContext, indexMetadata)\n      result = result.concat(nodes)\n      resultOffset = usedSkip\n      continue\n    }\n    if (canUseIndexForSorting(indexMetadata, sortFields)) {\n      const { nodes, usedSkip } = filterNodes(filterContext, indexMetadata)\n      // Interleave nodes of different types (not expensive for already sorted chunks)\n      result = result.mergeSorted(nodes, createNodeSortComparator(sortFields))\n      resultOffset = usedSkip\n      continue\n    }\n    // The sad part - unlimited filter + in-memory sort\n    const unlimited = { ...context, skip: 0, limit: undefined }\n    const { nodes, usedSkip } = filterNodes(unlimited, indexMetadata)\n    const sortedNodes = sortNodesInMemory(context, nodes)\n    resultOffset = usedSkip\n\n    result = result.mergeSorted(\n      sortedNodes,\n      createNodeSortComparator(sortFields)\n    )\n  }\n  const { limit, skip = 0 } = context\n  const actualSkip = skip - resultOffset\n\n  if (limit || actualSkip) {\n    result = result.slice(actualSkip, limit ? actualSkip + limit : undefined)\n  }\n  return result\n}\n\nfunction runCountOnce(context: IQueryContext): number {\n  if (typeof context.totalCount === `undefined`) {\n    context.totalCount = runCount(context)\n  }\n  return context.totalCount\n}\n\nfunction runCount(context: IQueryContext): number {\n  let count = 0\n\n  if (!needsFiltering(context)) {\n    for (const typeName of context.nodeTypeNames) {\n      count += context.datastore.countNodes(typeName)\n    }\n    return count\n  }\n\n  if (!canUseIndex(context)) {\n    for (const typeName of context.nodeTypeNames) {\n      const nodes = completeFiltering(\n        context,\n        new GatsbyIterable(context.datastore.iterateNodesByType(typeName))\n      )\n      for (const _ of nodes) count++\n    }\n    return count\n  }\n\n  for (const typeName of context.nodeTypeNames) {\n    const indexMetadata = getIndexMetadata(\n      context,\n      typeName,\n      context.suggestedIndexFields\n    )\n    try {\n      count += countUsingIndexOnly({ ...context, indexMetadata })\n    } catch (e) {\n      // We cannot reliably count using index - fallback to full iteration :/\n      for (const _ of filterNodes(context, indexMetadata).nodes) count++\n    }\n  }\n  return count\n}\n\nfunction performFullTableScan(\n  context: IQueryContext\n): GatsbyIterable<IGatsbyNode> {\n  // console.warn(`Fallback to full table scan :/`)\n\n  const { datastore, nodeTypeNames } = context\n\n  let result = new GatsbyIterable<IGatsbyNode>([])\n  for (const typeName of nodeTypeNames) {\n    let nodes = new GatsbyIterable(datastore.iterateNodesByType(typeName))\n    nodes = completeFiltering(context, nodes)\n\n    if (needsSorting(context)) {\n      nodes = sortNodesInMemory(context, nodes)\n      result = result.mergeSorted(\n        nodes,\n        createNodeSortComparator(context.sortFields)\n      )\n    } else {\n      result = result.concat(nodes)\n    }\n  }\n  const { limit, skip = 0 } = context\n\n  if (limit || skip) {\n    result = result.slice(skip, limit ? skip + limit : undefined)\n  }\n  return result\n}\n\nfunction filterNodes(\n  context: IQueryContext,\n  indexMetadata: IIndexMetadata\n): { nodes: GatsbyIterable<IGatsbyNode>; usedSkip: number } {\n  const { entries, usedQueries, usedSkip } = filterUsingIndex({\n    ...context,\n    indexMetadata,\n    reverse: Array.from(context.sortFields.values())[0] === -1,\n  })\n  const nodes = entries\n    .map(({ value }) => context.datastore.getNode(value))\n    .filter(Boolean)\n\n  return {\n    nodes: completeFiltering(\n      context,\n      nodes as GatsbyIterable<IGatsbyNode>,\n      usedQueries\n    ),\n    usedSkip,\n  }\n}\n\n/**\n * Takes intermediate result and applies any remaining filterQueries.\n *\n * If result is already fully filtered - simply returns.\n */\nfunction completeFiltering(\n  context: IQueryContext,\n  intermediateResult: GatsbyIterable<IGatsbyNode>,\n  usedQueries: Set<DbQuery> = new Set()\n): GatsbyIterable<IGatsbyNode> {\n  const { dbQueries } = context\n  if (isFullyFiltered(dbQueries, usedQueries)) {\n    return intermediateResult\n  }\n  // Apply remaining filter operations directly (last resort: slow)\n  const resolvedNodes = store.getState().resolvedNodesCache\n\n  const filtersToApply: Array<[string, IDbFilterStatement]> = dbQueries\n    .filter(q => !usedQueries.has(q))\n    .map(q => [dbQueryToDottedField(q), getFilterStatement(q)])\n\n  return intermediateResult.filter(node => {\n    const resolvedFields = resolvedNodes?.get(node.internal.type)?.get(node.id)\n\n    for (const [dottedField, filter] of filtersToApply) {\n      const tmp = resolveFieldValue(dottedField, node, resolvedFields)\n      const value = Array.isArray(tmp) ? tmp : [tmp]\n      if (value.some(v => !matchesFilter(filter, v))) {\n        // Mimic AND semantics\n        return false\n      }\n    }\n    return true\n  })\n}\n\nfunction sortNodesInMemory(\n  context: IQueryContext,\n  nodes: GatsbyIterable<IGatsbyNode>\n): GatsbyIterable<IGatsbyNode> {\n  // TODO: Sort using index data whenever possible (maybe store data needed for sorting in index values)\n  // TODO: Nodes can be partially sorted by index prefix - we can (and should) exploit this\n  return new GatsbyIterable(() => {\n    const arr = Array.from(nodes)\n    arr.sort(createNodeSortComparator(context.sortFields))\n    return arr\n  })\n}\n\nfunction createQueryContext(args: IDoRunQueryArgs): IQueryContext {\n  const { queryArgs: { filter, sort, limit, skip = 0 } = {}, firstOnly } = args\n\n  return {\n    datastore: args.datastore,\n    databases: args.databases,\n    nodeTypeNames: args.nodeTypeNames,\n    dbQueries: createDbQueriesFromObject(prepareQueryArgs(filter)),\n    sortFields: new Map<string, number>(\n      sort?.fields.map((field, i) => [field, isDesc(sort?.order[i]) ? -1 : 1])\n    ),\n    suggestedIndexFields: new Map(suggestIndex({ filter, sort })),\n    limit: firstOnly ? 1 : limit,\n    skip,\n  }\n}\n\nfunction canUseIndex(context: IQueryContext): boolean {\n  return context.suggestedIndexFields.size > 0\n}\n\nfunction needsFiltering(context: IQueryContext): boolean {\n  return context.dbQueries.length > 0\n}\n\nfunction needsSorting(context: IQueryContext): boolean {\n  return context.sortFields.size > 0\n}\n\n/**\n * Based on assumption that if all sort fields exist in index\n * then any result received from this index is fully sorted\n */\nfunction canUseIndexForSorting(\n  index: IIndexMetadata,\n  sortFields: SortFields\n): boolean {\n  const indexKeyFields = new Map(index.keyFields)\n  for (const [field, sortOrder] of sortFields) {\n    if (indexKeyFields.get(field) !== sortOrder) {\n      return false\n    }\n  }\n  return true\n}\n\nfunction isFullyFiltered(\n  dbQueries: Array<DbQuery>,\n  usedQueries: Set<DbQuery>\n): boolean {\n  return dbQueries.length === usedQueries.size\n}\n\nfunction createNodeSortComparator(sortFields: SortFields): (a, b) => number {\n  const resolvedNodesCache = store.getState().resolvedNodesCache\n\n  return function nodeComparator(a: IGatsbyNode, b: IGatsbyNode): number {\n    const resolvedAFields = resolvedNodesCache?.get(a.internal.type)?.get(a.id)\n    const resolvedBFields = resolvedNodesCache?.get(b.internal.type)?.get(b.id)\n\n    for (const [field, direction] of sortFields) {\n      const valueA: any = resolveFieldValue(field, a, resolvedAFields)\n      const valueB: any = resolveFieldValue(field, b, resolvedBFields)\n\n      if (valueA > valueB) {\n        return direction === 1 ? 1 : -1\n      } else if (valueA < valueB) {\n        return direction === 1 ? -1 : 1\n      }\n    }\n    return 0\n  }\n}\n\nexport function compareByKeySuffix(prefixLength: number) {\n  return function (a: IIndexEntry, b: IIndexEntry): number {\n    const aSuffix = a.key.slice(prefixLength)\n    const bSuffix = b.key.slice(prefixLength)\n    // @ts-ignore\n    return compareKey(aSuffix, bSuffix)\n  }\n}\n"],"mappings":"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"}

package/dist/datastore/lmdb/query/suggest-index.d.ts

@@ -0,0 +1,15 @@
+import { IRunQueryArgs } from "../../types";
+interface ISelectIndexArgs {
+    filter: IRunQueryArgs["queryArgs"]["filter"];
+    sort: IRunQueryArgs["queryArgs"]["sort"];
+    maxFields?: number;
+}
+type IndexField = [fieldName: string, orderDirection: number];
+/**
+ * Suggest index fields for this combination of filter and sort.
+ *
+ * Prioritizes sort fields over filter fields when can't use index
+ * for both because sorting is expensive both CPU and memory-wise.
+ */
+export declare function suggestIndex({ filter, sort, maxFields, }: ISelectIndexArgs): Array<IndexField>;
+export {};

package/dist/datastore/lmdb/query/suggest-index.js

@@ -0,0 +1,93 @@
+"use strict";
+
+exports.__esModule = true;
+exports.suggestIndex = suggestIndex;
+var _query = require("../../common/query");
+var _common = require("./common");
+/**
+ * Suggest index fields for this combination of filter and sort.
+ *
+ * Prioritizes sort fields over filter fields when can't use index
+ * for both because sorting is expensive both CPU and memory-wise.
+ */
+function suggestIndex({
+  filter,
+  sort,
+  maxFields = 6
+}) {
+  const filterQueries = (0, _query.createDbQueriesFromObject)((0, _query.prepareQueryArgs)(filter));
+  const filterQueriesThatCanUseIndex = getQueriesThatCanUseIndex(filterQueries);
+  const sortFields = getSortFieldsThatCanUseIndex(sort);
+  if (!sortFields.length && !filterQueriesThatCanUseIndex.length) {
+    return [];
+  }
+  if (!filterQueriesThatCanUseIndex.length) {
+    return dedupeAndTrim(sortFields, maxFields);
+  }
+  if (!sortFields.length) {
+    return dedupeAndTrim(toIndexFields(filterQueriesThatCanUseIndex), maxFields);
+  }
+
+  // Combined index for filter+sort only makes sense when all prefix fields have `eq` predicate
+  // Same as https://docs.mongodb.com/manual/tutorial/sort-results-with-indexes/#sort-and-non-prefix-subset-of-an-index
+  const sortDirection = sortFields[0][1];
+  const eqFilterQueries = getEqQueries(filterQueriesThatCanUseIndex);
+  const eqFilterFields = toIndexFields(eqFilterQueries, sortDirection);
+
+  // Index prefix should not contain eq filters overlapping with sort fields
+  const overlap = findOverlappingFields(eqFilterQueries, sortFields);
+  return dedupeAndTrim([...eqFilterFields.filter(([name]) => !overlap.has(name)), ...sortFields,
+  // Still append other filter fields to the tail of the index to leverage additional filtering
+  //  of results using data stored in the index (without loading full node object)
+  //  Note: fields previously listed in eqFilterFields and sortFields will be removed in dedupeAndTrim
+  ...toIndexFields(filterQueriesThatCanUseIndex, sortDirection)], maxFields);
+}
+const canUseIndex = new Set([_query.DbComparator.EQ, _query.DbComparator.IN, _query.DbComparator.GTE, _query.DbComparator.LTE, _query.DbComparator.GT, _query.DbComparator.LT, _query.DbComparator.NIN, _query.DbComparator.NE]);
+
+/**
+ * Returns queries that can potentially use index.
+ * Returned list is sorted by query specificity
+ */
+function getQueriesThatCanUseIndex(all) {
+  return (0, _query.sortBySpecificity)(all.filter(q => canUseIndex.has((0, _query.getFilterStatement)(q).comparator)));
+}
+function getSortFieldsThatCanUseIndex(querySortArg) {
+  const sort = querySortArg || {
+    fields: [],
+    order: []
+  };
+  const initialOrder = (0, _common.isDesc)(sort === null || sort === void 0 ? void 0 : sort.order[0]) ? -1 : 1;
+  const sortFields = [];
+  for (let i = 0; i < sort.fields.length; i++) {
+    const field = sort.fields[i];
+    const order = (0, _common.isDesc)(sort.order[i]) ? -1 : 1;
+    if (order !== initialOrder) {
+      // Mixed sort order is not supported by our indexes yet :/
+      // See https://github.com/DoctorEvidence/lmdb-store/discussions/62#discussioncomment-898949
+      break;
+    }
+    sortFields.push([field, order]);
+  }
+  return sortFields;
+}
+function findOverlappingFields(filterQueries, sortFields) {
+  const overlap = new Set();
+  for (const [fieldName] of sortFields) {
+    const filterQuery = filterQueries.find(q => (0, _query.dbQueryToDottedField)(q) === fieldName);
+    if (!filterQuery) {
+      break;
+    }
+    overlap.add(fieldName);
+  }
+  return overlap;
+}
+function getEqQueries(filterQueries) {
+  return filterQueries.filter(filterQuery => (0, _query.getFilterStatement)(filterQuery).comparator === _query.DbComparator.EQ);
+}
+function toIndexFields(queries, sortDirection = 1) {
+  return queries.map(q => [(0, _query.dbQueryToDottedField)(q), sortDirection]);
+}
+function dedupeAndTrim(fields, maxFields) {
+  return [...new Map(fields)].slice(0, maxFields);
+}
+//# sourceMappingURL=suggest-index.js.map

package/dist/datastore/lmdb/query/suggest-index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"suggest-index.js","names":["suggestIndex","filter","sort","maxFields","filterQueries","createDbQueriesFromObject","prepareQueryArgs","filterQueriesThatCanUseIndex","getQueriesThatCanUseIndex","sortFields","getSortFieldsThatCanUseIndex","length","dedupeAndTrim","toIndexFields","sortDirection","eqFilterQueries","getEqQueries","eqFilterFields","overlap","findOverlappingFields","name","has","canUseIndex","Set","DbComparator","EQ","IN","GTE","LTE","GT","LT","NIN","NE","all","sortBySpecificity","q","getFilterStatement","comparator","querySortArg","fields","order","initialOrder","isDesc","i","field","push","fieldName","filterQuery","find","dbQueryToDottedField","add","queries","map","Map","slice"],"sources":["../../../../src/datastore/lmdb/query/suggest-index.ts"],"sourcesContent":["import { IRunQueryArgs } from \"../../types\"\nimport {\n  createDbQueriesFromObject,\n  DbComparator,\n  DbQuery,\n  dbQueryToDottedField,\n  getFilterStatement,\n  prepareQueryArgs,\n  sortBySpecificity,\n} from \"../../common/query\"\nimport { isDesc } from \"./common\"\n\ninterface ISelectIndexArgs {\n  filter: IRunQueryArgs[\"queryArgs\"][\"filter\"]\n  sort: IRunQueryArgs[\"queryArgs\"][\"sort\"]\n  maxFields?: number\n}\n\ntype IndexField = [fieldName: string, orderDirection: number]\ntype IndexFields = Array<IndexField>\n\n/**\n * Suggest index fields for this combination of filter and sort.\n *\n * Prioritizes sort fields over filter fields when can't use index\n * for both because sorting is expensive both CPU and memory-wise.\n */\nexport function suggestIndex({\n  filter,\n  sort,\n  maxFields = 6,\n}: ISelectIndexArgs): Array<IndexField> {\n  const filterQueries = createDbQueriesFromObject(prepareQueryArgs(filter))\n  const filterQueriesThatCanUseIndex = getQueriesThatCanUseIndex(filterQueries)\n  const sortFields: Array<IndexField> = getSortFieldsThatCanUseIndex(sort)\n\n  if (!sortFields.length && !filterQueriesThatCanUseIndex.length) {\n    return []\n  }\n  if (!filterQueriesThatCanUseIndex.length) {\n    return dedupeAndTrim(sortFields, maxFields)\n  }\n  if (!sortFields.length) {\n    return dedupeAndTrim(toIndexFields(filterQueriesThatCanUseIndex), maxFields)\n  }\n\n  // Combined index for filter+sort only makes sense when all prefix fields have `eq` predicate\n  // Same as https://docs.mongodb.com/manual/tutorial/sort-results-with-indexes/#sort-and-non-prefix-subset-of-an-index\n  const sortDirection = sortFields[0][1]\n  const eqFilterQueries = getEqQueries(filterQueriesThatCanUseIndex)\n  const eqFilterFields = toIndexFields(eqFilterQueries, sortDirection)\n\n  // Index prefix should not contain eq filters overlapping with sort fields\n  const overlap = findOverlappingFields(eqFilterQueries, sortFields)\n\n  return dedupeAndTrim(\n    [\n      ...eqFilterFields.filter(([name]) => !overlap.has(name)),\n      ...sortFields,\n      // Still append other filter fields to the tail of the index to leverage additional filtering\n      //  of results using data stored in the index (without loading full node object)\n      //  Note: fields previously listed in eqFilterFields and sortFields will be removed in dedupeAndTrim\n      ...toIndexFields(filterQueriesThatCanUseIndex, sortDirection),\n    ],\n    maxFields\n  )\n}\n\nconst canUseIndex = new Set([\n  DbComparator.EQ,\n  DbComparator.IN,\n  DbComparator.GTE,\n  DbComparator.LTE,\n  DbComparator.GT,\n  DbComparator.LT,\n  DbComparator.NIN,\n  DbComparator.NE,\n])\n\n/**\n * Returns queries that can potentially use index.\n * Returned list is sorted by query specificity\n */\nfunction getQueriesThatCanUseIndex(all: Array<DbQuery>): Array<DbQuery> {\n  return sortBySpecificity(\n    all.filter(q => canUseIndex.has(getFilterStatement(q).comparator))\n  )\n}\n\nfunction getSortFieldsThatCanUseIndex(\n  querySortArg: IRunQueryArgs[\"queryArgs\"][\"sort\"]\n): Array<IndexField> {\n  const sort = querySortArg || { fields: [], order: [] }\n  const initialOrder = isDesc(sort?.order[0]) ? -1 : 1\n\n  const sortFields: Array<IndexField> = []\n  for (let i = 0; i < sort.fields.length; i++) {\n    const field = sort.fields[i]\n    const order = isDesc(sort.order[i]) ? -1 : 1\n    if (order !== initialOrder) {\n      // Mixed sort order is not supported by our indexes yet :/\n      // See https://github.com/DoctorEvidence/lmdb-store/discussions/62#discussioncomment-898949\n      break\n    }\n    sortFields.push([field, order])\n  }\n  return sortFields\n}\n\nfunction findOverlappingFields(\n  filterQueries: Array<DbQuery>,\n  sortFields: Array<IndexField>\n): Set<string> {\n  const overlap = new Set<string>()\n\n  for (const [fieldName] of sortFields) {\n    const filterQuery = filterQueries.find(\n      q => dbQueryToDottedField(q) === fieldName\n    )\n    if (!filterQuery) {\n      break\n    }\n    overlap.add(fieldName)\n  }\n  return overlap\n}\n\nfunction getEqQueries(filterQueries: Array<DbQuery>): Array<DbQuery> {\n  return filterQueries.filter(\n    filterQuery =>\n      getFilterStatement(filterQuery).comparator === DbComparator.EQ\n  )\n}\n\nfunction toIndexFields(\n  queries: Array<DbQuery>,\n  sortDirection: number = 1\n): IndexFields {\n  return queries.map(\n    (q): IndexField => [dbQueryToDottedField(q), sortDirection]\n  )\n}\n\nfunction dedupeAndTrim(fields: IndexFields, maxFields: number): IndexFields {\n  return [...new Map(fields)].slice(0, maxFields)\n}\n"],"mappings":"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"}

package/dist/datastore/lmdb/updates/nodes-by-type.d.ts

@@ -0,0 +1,3 @@
+import { ActionsUnion } from "../../../redux/types";
+import { ILmdbDatabases } from "../../types";
+export declare function updateNodesByType(nodesByTypeDb: ILmdbDatabases["nodesByType"], action: ActionsUnion): Promise<boolean> | boolean;

package/dist/datastore/lmdb/updates/nodes-by-type.js

@@ -0,0 +1,21 @@
+"use strict";
+
+exports.__esModule = true;
+exports.updateNodesByType = updateNodesByType;
+function updateNodesByType(nodesByTypeDb, action) {
+  switch (action.type) {
+    case `CREATE_NODE`:
+    case `ADD_FIELD_TO_NODE`:
+    case `ADD_CHILD_NODE_TO_PARENT_NODE`:
+      {
+        // nodesByType db uses dupSort, so `put` will effectively append an id
+        return nodesByTypeDb.put(action.payload.internal.type, action.payload.id);
+      }
+    case `DELETE_NODE`:
+      {
+        return action.payload ? nodesByTypeDb.remove(action.payload.internal.type, action.payload.id) : false;
+      }
+  }
+  return false;
+}
+//# sourceMappingURL=nodes-by-type.js.map

package/dist/datastore/lmdb/updates/nodes-by-type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodes-by-type.js","names":["updateNodesByType","nodesByTypeDb","action","type","put","payload","internal","id","remove"],"sources":["../../../../src/datastore/lmdb/updates/nodes-by-type.ts"],"sourcesContent":["import { ActionsUnion } from \"../../../redux/types\"\nimport { ILmdbDatabases } from \"../../types\"\n\nexport function updateNodesByType(\n  nodesByTypeDb: ILmdbDatabases[\"nodesByType\"],\n  action: ActionsUnion\n): Promise<boolean> | boolean {\n  switch (action.type) {\n    case `CREATE_NODE`:\n    case `ADD_FIELD_TO_NODE`:\n    case `ADD_CHILD_NODE_TO_PARENT_NODE`: {\n      // nodesByType db uses dupSort, so `put` will effectively append an id\n      return nodesByTypeDb.put(action.payload.internal.type, action.payload.id)\n    }\n    case `DELETE_NODE`: {\n      return action.payload\n        ? nodesByTypeDb.remove(action.payload.internal.type, action.payload.id)\n        : false\n    }\n  }\n  return false\n}\n"],"mappings":";;;;AAGO,SAASA,iBAAiB,CAC/BC,aAA4C,EAC5CC,MAAoB,EACQ;EAC5B,QAAQA,MAAM,CAACC,IAAI;IACjB,KAAM,aAAY;IAClB,KAAM,mBAAkB;IACxB,KAAM,+BAA8B;MAAE;QACpC;QACA,OAAOF,aAAa,CAACG,GAAG,CAACF,MAAM,CAACG,OAAO,CAACC,QAAQ,CAACH,IAAI,EAAED,MAAM,CAACG,OAAO,CAACE,EAAE,CAAC;MAC3E;IACA,KAAM,aAAY;MAAE;QAClB,OAAOL,MAAM,CAACG,OAAO,GACjBJ,aAAa,CAACO,MAAM,CAACN,MAAM,CAACG,OAAO,CAACC,QAAQ,CAACH,IAAI,EAAED,MAAM,CAACG,OAAO,CAACE,EAAE,CAAC,GACrE,KAAK;MACX;EAAC;EAEH,OAAO,KAAK;AACd"}

package/dist/datastore/lmdb/updates/nodes.d.ts

@@ -0,0 +1,5 @@
+import { ActionsUnion, IGatsbyNode } from "../../../redux/types";
+import type { Database } from "lmdb";
+type NodeId = string;
+export declare function updateNodes(nodesDb: Database<IGatsbyNode, NodeId>, action: ActionsUnion): Promise<boolean> | boolean;
+export {};

package/dist/datastore/lmdb/updates/nodes.js

@@ -0,0 +1,33 @@
+"use strict";
+
+exports.__esModule = true;
+exports.updateNodes = updateNodes;
+function updateNodes(nodesDb, action) {
+  switch (action.type) {
+    case `CREATE_NODE`:
+    case `ADD_FIELD_TO_NODE`:
+    case `ADD_CHILD_NODE_TO_PARENT_NODE`:
+      {
+        return nodesDb.put(action.payload.id, action.payload);
+      }
+    case `DELETE_NODE`:
+      {
+        if (action.payload) {
+          return nodesDb.remove(action.payload.id);
+        }
+        return false;
+      }
+    case `MATERIALIZE_PAGE_MODE`:
+      {
+        const id = `SitePage ${action.payload.path}`;
+        const node = nodesDb.get(id);
+        if (!node) {
+          throw new Error(`Could not find SitePage node by id: ${id}`);
+        }
+        node.mode = action.payload.pageMode;
+        return nodesDb.put(id, node);
+      }
+  }
+  return false;
+}
+//# sourceMappingURL=nodes.js.map

package/dist/datastore/lmdb/updates/nodes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodes.js","names":["updateNodes","nodesDb","action","type","put","payload","id","remove","path","node","get","Error","mode","pageMode"],"sources":["../../../../src/datastore/lmdb/updates/nodes.ts"],"sourcesContent":["import { ActionsUnion, IGatsbyNode } from \"../../../redux/types\"\nimport type { Database } from \"lmdb\"\n\ntype NodeId = string\n\nexport function updateNodes(\n  nodesDb: Database<IGatsbyNode, NodeId>,\n  action: ActionsUnion\n): Promise<boolean> | boolean {\n  switch (action.type) {\n    case `CREATE_NODE`:\n    case `ADD_FIELD_TO_NODE`:\n    case `ADD_CHILD_NODE_TO_PARENT_NODE`: {\n      return nodesDb.put(action.payload.id, action.payload)\n    }\n    case `DELETE_NODE`: {\n      if (action.payload) {\n        return nodesDb.remove(action.payload.id)\n      }\n\n      return false\n    }\n    case `MATERIALIZE_PAGE_MODE`: {\n      const id = `SitePage ${action.payload.path}`\n      const node = nodesDb.get(id)\n      if (!node) {\n        throw new Error(`Could not find SitePage node by id: ${id}`)\n      }\n      node.mode = action.payload.pageMode\n      return nodesDb.put(id, node)\n    }\n  }\n  return false\n}\n"],"mappings":";;;;AAKO,SAASA,WAAW,CACzBC,OAAsC,EACtCC,MAAoB,EACQ;EAC5B,QAAQA,MAAM,CAACC,IAAI;IACjB,KAAM,aAAY;IAClB,KAAM,mBAAkB;IACxB,KAAM,+BAA8B;MAAE;QACpC,OAAOF,OAAO,CAACG,GAAG,CAACF,MAAM,CAACG,OAAO,CAACC,EAAE,EAAEJ,MAAM,CAACG,OAAO,CAAC;MACvD;IACA,KAAM,aAAY;MAAE;QAClB,IAAIH,MAAM,CAACG,OAAO,EAAE;UAClB,OAAOJ,OAAO,CAACM,MAAM,CAACL,MAAM,CAACG,OAAO,CAACC,EAAE,CAAC;QAC1C;QAEA,OAAO,KAAK;MACd;IACA,KAAM,uBAAsB;MAAE;QAC5B,MAAMA,EAAE,GAAI,YAAWJ,MAAM,CAACG,OAAO,CAACG,IAAK,EAAC;QAC5C,MAAMC,IAAI,GAAGR,OAAO,CAACS,GAAG,CAACJ,EAAE,CAAC;QAC5B,IAAI,CAACG,IAAI,EAAE;UACT,MAAM,IAAIE,KAAK,CAAE,uCAAsCL,EAAG,EAAC,CAAC;QAC9D;QACAG,IAAI,CAACG,IAAI,GAAGV,MAAM,CAACG,OAAO,CAACQ,QAAQ;QACnC,OAAOZ,OAAO,CAACG,GAAG,CAACE,EAAE,EAAEG,IAAI,CAAC;MAC9B;EAAC;EAEH,OAAO,KAAK;AACd"}

package/dist/datastore/types.d.ts

@@ -0,0 +1,47 @@
+import { Database } from "lmdb";
+import { IGatsbyNode } from "../redux/types";
+import { GatsbyGraphQLType } from "../../index";
+import { IInputQuery } from "./common/query";
+import { IGraphQLRunnerStats } from "../query/types";
+import { GatsbyIterable } from "./common/iterable";
+export type NodeId = string;
+export type NodeType = string;
+export interface ILmdbDatabases {
+    nodes: Database<IGatsbyNode, NodeId>;
+    nodesByType: Database<NodeId, NodeType>;
+    indexes: Database<NodeId, Array<any>>;
+    metadata: Database<any, string>;
+}
+export interface IQueryResult {
+    entries: GatsbyIterable<IGatsbyNode>;
+    totalCount: () => Promise<number>;
+}
+export interface IRunQueryArgs {
+    gqlType: GatsbyGraphQLType;
+    queryArgs: {
+        filter: IInputQuery | undefined;
+        sort: {
+            fields: Array<string>;
+            order: Array<boolean | "asc" | "desc" | "ASC" | "DESC">;
+        } | undefined;
+        limit?: number;
+        skip?: number;
+    };
+    firstOnly: boolean;
+    resolvedFields: Record<string, any>;
+    nodeTypeNames: Array<string>;
+    stats: IGraphQLRunnerStats;
+}
+export interface IDataStore {
+    getNode(id: string): IGatsbyNode | undefined;
+    getTypes(): Array<string>;
+    countNodes(typeName?: string): number;
+    ready(): Promise<void>;
+    iterateNodes(): GatsbyIterable<IGatsbyNode>;
+    iterateNodesByType(type: string): GatsbyIterable<IGatsbyNode>;
+    runQuery(args: IRunQueryArgs): Promise<IQueryResult>;
+    /** @deprecated */
+    getNodes(): Array<IGatsbyNode>;
+    /** @deprecated */
+    getNodesByType(type: string): Array<IGatsbyNode>;
+}

package/dist/datastore/types.js

@@ -0,0 +1,4 @@
+"use strict";
+
+exports.__esModule = true;
+//# sourceMappingURL=types.js.map

package/dist/datastore/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../src/datastore/types.ts"],"sourcesContent":["import { Database } from \"lmdb\"\nimport { IGatsbyNode } from \"../redux/types\"\nimport { GatsbyGraphQLType } from \"../../index\"\nimport { IInputQuery } from \"./common/query\"\nimport { IGraphQLRunnerStats } from \"../query/types\"\nimport { GatsbyIterable } from \"./common/iterable\"\n\nexport type NodeId = string\nexport type NodeType = string\n\nexport interface ILmdbDatabases {\n  nodes: Database<IGatsbyNode, NodeId>\n  nodesByType: Database<NodeId, NodeType>\n  indexes: Database<NodeId, Array<any>>\n  metadata: Database<any, string>\n}\n\nexport interface IQueryResult {\n  entries: GatsbyIterable<IGatsbyNode>\n  totalCount: () => Promise<number>\n}\n\nexport interface IRunQueryArgs {\n  gqlType: GatsbyGraphQLType\n  queryArgs: {\n    filter: IInputQuery | undefined\n    sort:\n      | {\n          fields: Array<string>\n          order: Array<boolean | \"asc\" | \"desc\" | \"ASC\" | \"DESC\">\n        }\n      | undefined\n    limit?: number\n    skip?: number\n  }\n  firstOnly: boolean\n  resolvedFields: Record<string, any>\n  nodeTypeNames: Array<string>\n  stats: IGraphQLRunnerStats\n}\n\nexport interface IDataStore {\n  getNode(id: string): IGatsbyNode | undefined\n  getTypes(): Array<string>\n  countNodes(typeName?: string): number\n  ready(): Promise<void>\n  iterateNodes(): GatsbyIterable<IGatsbyNode>\n  iterateNodesByType(type: string): GatsbyIterable<IGatsbyNode>\n  runQuery(args: IRunQueryArgs): Promise<IQueryResult>\n\n  /** @deprecated */\n  getNodes(): Array<IGatsbyNode>\n  /** @deprecated */\n  getNodesByType(type: string): Array<IGatsbyNode>\n}\n"],"mappings":""}

package/dist/internal-plugins/bundle-optimisations/gatsby-node.js

@@ -0,0 +1,42 @@
+"use strict";
+
+const path = require(`path`);
+exports.onCreateBabelConfig = ({
+  actions
+}) => {
+  // rewrites import { get }from 'lodash' into import get from 'lodash/get';
+  actions.setBabelPlugin({
+    name: `@sigmacomputing/babel-plugin-lodash`
+  });
+};
+exports.onCreateWebpackConfig = function onCreateWebpackConfig({
+  stage,
+  actions
+}) {
+  const objectAssignStub = path.join(__dirname, `polyfills/object-assign.js`);
+  const noOp = path.join(__dirname, `polyfills/no-op.js`);
+  const fetchStub = path.join(__dirname, `polyfills/fetch.js`);
+  const whatwgFetchStub = path.join(__dirname, `polyfills/whatwg-fetch.js`);
+  const alias = {
+    // These files are already polyfilled so these should return in a no-op
+    // Stub Package: object.assign & object-assign
+    "object.assign": objectAssignStub,
+    "object-assign$": objectAssignStub,
+    "@babel/runtime/helpers/extends.js$": objectAssignStub,
+    // Stub package: fetch
+    unfetch$: fetchStub,
+    "unfetch/polyfill$": noOp,
+    "isomorphic-unfetch$": fetchStub,
+    "isomorphic-fetch$": fetchStub,
+    "whatwg-fetch$": whatwgFetchStub
+  };
+  if (stage === `build-javascript` || stage === `develop`) {
+    alias[`url-polyfill$`] = noOp;
+  }
+  actions.setWebpackConfig({
+    resolve: {
+      alias
+    }
+  });
+};
+//# sourceMappingURL=gatsby-node.js.map

package/dist/internal-plugins/bundle-optimisations/gatsby-node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gatsby-node.js","names":["path","require","exports","onCreateBabelConfig","actions","setBabelPlugin","name","onCreateWebpackConfig","stage","objectAssignStub","join","__dirname","noOp","fetchStub","whatwgFetchStub","alias","unfetch$","setWebpackConfig","resolve"],"sources":["../../../src/internal-plugins/bundle-optimisations/gatsby-node.js"],"sourcesContent":["const path = require(`path`)\n\nexports.onCreateBabelConfig = ({ actions }) => {\n  // rewrites import { get }from 'lodash' into import get from 'lodash/get';\n  actions.setBabelPlugin({\n    name: `@sigmacomputing/babel-plugin-lodash`,\n  })\n}\n\nexports.onCreateWebpackConfig = function onCreateWebpackConfig({\n  stage,\n  actions,\n}) {\n  const objectAssignStub = path.join(__dirname, `polyfills/object-assign.js`)\n  const noOp = path.join(__dirname, `polyfills/no-op.js`)\n  const fetchStub = path.join(__dirname, `polyfills/fetch.js`)\n  const whatwgFetchStub = path.join(__dirname, `polyfills/whatwg-fetch.js`)\n\n  const alias = {\n    // These files are already polyfilled so these should return in a no-op\n    // Stub Package: object.assign & object-assign\n    \"object.assign\": objectAssignStub,\n    \"object-assign$\": objectAssignStub,\n    \"@babel/runtime/helpers/extends.js$\": objectAssignStub,\n    // Stub package: fetch\n    unfetch$: fetchStub,\n    \"unfetch/polyfill$\": noOp,\n    \"isomorphic-unfetch$\": fetchStub,\n    \"isomorphic-fetch$\": fetchStub,\n    \"whatwg-fetch$\": whatwgFetchStub,\n  }\n\n  if (stage === `build-javascript` || stage === `develop`) {\n    alias[`url-polyfill$`] = noOp\n  }\n\n  actions.setWebpackConfig({\n    resolve: {\n      alias,\n    },\n  })\n}\n"],"mappings":";;AAAA,MAAMA,IAAI,GAAGC,OAAO,CAAE,MAAK,CAAC;AAE5BC,OAAO,CAACC,mBAAmB,GAAG,CAAC;EAAEC;AAAQ,CAAC,KAAK;EAC7C;EACAA,OAAO,CAACC,cAAc,CAAC;IACrBC,IAAI,EAAG;EACT,CAAC,CAAC;AACJ,CAAC;AAEDJ,OAAO,CAACK,qBAAqB,GAAG,SAASA,qBAAqB,CAAC;EAC7DC,KAAK;EACLJ;AACF,CAAC,EAAE;EACD,MAAMK,gBAAgB,GAAGT,IAAI,CAACU,IAAI,CAACC,SAAS,EAAG,4BAA2B,CAAC;EAC3E,MAAMC,IAAI,GAAGZ,IAAI,CAACU,IAAI,CAACC,SAAS,EAAG,oBAAmB,CAAC;EACvD,MAAME,SAAS,GAAGb,IAAI,CAACU,IAAI,CAACC,SAAS,EAAG,oBAAmB,CAAC;EAC5D,MAAMG,eAAe,GAAGd,IAAI,CAACU,IAAI,CAACC,SAAS,EAAG,2BAA0B,CAAC;EAEzE,MAAMI,KAAK,GAAG;IACZ;IACA;IACA,eAAe,EAAEN,gBAAgB;IACjC,gBAAgB,EAAEA,gBAAgB;IAClC,oCAAoC,EAAEA,gBAAgB;IACtD;IACAO,QAAQ,EAAEH,SAAS;IACnB,mBAAmB,EAAED,IAAI;IACzB,qBAAqB,EAAEC,SAAS;IAChC,mBAAmB,EAAEA,SAAS;IAC9B,eAAe,EAAEC;EACnB,CAAC;EAED,IAAIN,KAAK,KAAM,kBAAiB,IAAIA,KAAK,KAAM,SAAQ,EAAE;IACvDO,KAAK,CAAE,eAAc,CAAC,GAAGH,IAAI;EAC/B;EAEAR,OAAO,CAACa,gBAAgB,CAAC;IACvBC,OAAO,EAAE;MACPH;IACF;EACF,CAAC,CAAC;AACJ,CAAC"}