@depup/gatsby 5.16.1-depup.0

package/dist/datastore/common/iterable.js

@@ -0,0 +1,217 @@
+"use strict";
+
+exports.__esModule = true;
+exports.GatsbyIterable = void 0;
+exports.isIterable = isIterable;
+exports.isNonArrayIterable = isNonArrayIterable;
+var _lmdb = require("lmdb");
+/**
+ * Wrapper for any iterable providing chainable interface and convenience methods
+ * similar to array.
+ *
+ * Additionally provides convenience methods for sorted iterables.
+ *
+ * Note: avoiding async iterables because of perf reasons, see https://github.com/nodejs/node/issues/31979
+ * (fortunately lmdb can traverse stuff in sync manner very fast)
+ */
+class GatsbyIterable {
+  constructor(source) {
+    this.source = source;
+  }
+  *[Symbol.iterator]() {
+    const source = typeof this.source === `function` ? this.source() : this.source;
+    let i = 0;
+    for (const val of source) {
+      yield val;
+
+      // clearKeptObjects just make it possible for WeakRefs used in any way during current
+      // sync execution tick to be garbage collected. It doesn't force GC, just remove
+      // internal strong references in V8.
+      // see https://github.com/kriszyp/weak-lru-cache/issues/4
+      if (++i % 100 === 0) {
+        (0, _lmdb.clearKeptObjects)();
+      }
+    }
+  }
+  concat(other) {
+    return new GatsbyIterable(() => concatSequence(this, other));
+  }
+  map(fn) {
+    return new GatsbyIterable(() => mapSequence(this, fn));
+  }
+  filter(predicate) {
+    return new GatsbyIterable(() => filterSequence(this, predicate));
+  }
+  slice(start, end) {
+    if (typeof end !== `undefined` && end < start || start < 0) throw new Error(`Both arguments must not be negative and end must be greater than start`);
+    return new GatsbyIterable(() => sliceSequence(this, start, end));
+  }
+  deduplicate(keyFn) {
+    return new GatsbyIterable(() => deduplicateSequence(this, keyFn));
+  }
+  forEach(callback) {
+    let i = 0;
+    for (const value of this) {
+      callback(value, i++);
+    }
+  }
+
+  /**
+   * Assuming both this and the other iterable are sorted
+   * produces the new sorted iterable with interleaved values.
+   *
+   * Note: this method is not removing duplicates
+   */
+  mergeSorted(other, comparator) {
+    return new GatsbyIterable(() => mergeSorted(this, other, comparator));
+  }
+
+  /**
+   * Assuming both this and the other iterable are sorted
+   * produces the new sorted iterable with values from this iterable
+   * that also exist in the other iterable.
+   */
+  intersectSorted(other, comparator) {
+    return new GatsbyIterable(() => intersectSorted(this, other, comparator));
+  }
+
+  /**
+   * Assuming this iterable is sorted, removes duplicates from it
+   * by applying comparator(prev, current) to sibling iterable values.
+   *
+   * Comparator function is expected to return 0 when items are equal,
+   * similar to Array.prototype.sort() argument.
+   *
+   * If comparator is not set, uses strict === comparison
+   */
+  deduplicateSorted(comparator) {
+    return new GatsbyIterable(() => deduplicateSorted(this, comparator));
+  }
+}
+
+/**
+ * Returns true when passed value is iterable
+ */
+exports.GatsbyIterable = GatsbyIterable;
+function isIterable(obj) {
+  if (typeof obj !== `object` || obj === null) {
+    return false;
+  }
+  return typeof obj[Symbol.iterator] === `function`;
+}
+function isNonArrayIterable(value) {
+  return isIterable(value) && !Array.isArray(value);
+}
+function* mapSequence(source, fn) {
+  let i = 0;
+  for (const value of source) {
+    yield fn(value, i++);
+  }
+}
+function* sliceSequence(source, start, end) {
+  let index = -1;
+  for (const item of source) {
+    index++;
+    if (index < start) continue;
+    if (typeof end !== `undefined` && index >= end) break;
+    yield item;
+  }
+}
+function* filterSequence(source, predicate) {
+  for (const value of source) {
+    if (predicate(value)) {
+      yield value;
+    }
+  }
+}
+function* concatSequence(first, second) {
+  for (const value of first) {
+    yield value;
+  }
+  for (const value of second) {
+    yield value;
+  }
+}
+function* deduplicateSequence(source, keyFn) {
+  // TODO: this can be potentially improved by using bloom filters?
+  const registered = new Set();
+  for (const current of source) {
+    const key = keyFn ? keyFn(current) : current;
+    if (!registered.has(key)) {
+      registered.add(key);
+      yield current;
+    }
+  }
+}
+function* deduplicateSorted(source, comparator = defaultComparator) {
+  let prev;
+  for (const current of source) {
+    if (typeof prev === `undefined` || comparator(prev, current) !== 0) {
+      yield current;
+    }
+    prev = current;
+  }
+}
+
+// Merge two originally sorted iterables:
+function* mergeSorted(firstSorted, secondSorted, comparator = defaultComparator) {
+  const iter1 = firstSorted[Symbol.iterator]();
+  const iter2 = secondSorted[Symbol.iterator]();
+  try {
+    let a = iter1.next();
+    let b = iter2.next();
+    while (!a.done && !b.done) {
+      if (comparator(a.value, b.value) <= 0) {
+        yield a.value;
+        a = iter1.next();
+      } else {
+        yield b.value;
+        b = iter2.next();
+      }
+    }
+    while (!a.done) {
+      yield a.value;
+      a = iter1.next();
+    }
+    while (!b.done) {
+      yield b.value;
+      b = iter2.next();
+    }
+  } finally {
+    // If generator is exited early, make sure to close iterators too
+    // See https://raganwald.com/2017/07/22/closing-iterables-is-a-leaky-abstraction.html#more-about-closing-iterators-explicitly
+    if (typeof iter1.return === `function`) iter1.return();
+    if (typeof iter2.return === `function`) iter2.return();
+  }
+}
+function* intersectSorted(firstSorted, secondSorted, comparator = defaultComparator) {
+  const iter1 = firstSorted[Symbol.iterator]();
+  const iter2 = secondSorted[Symbol.iterator]();
+  try {
+    let a = iter1.next();
+    let b = iter2.next();
+    while (!a.done && !b.done) {
+      const eq = comparator(a.value, b.value);
+      if (eq < 0) {
+        // a < b
+        a = iter1.next();
+      } else if (eq > 0) {
+        // a > b
+        b = iter2.next();
+      } else {
+        yield a.value;
+        a = iter1.next();
+      }
+    }
+  } finally {
+    if (typeof iter1.return === `function`) iter1.return();
+    if (typeof iter2.return === `function`) iter2.return();
+  }
+}
+function defaultComparator(a, b) {
+  if (a === b) {
+    return 0;
+  }
+  return a > b ? 1 : -1;
+}
+//# sourceMappingURL=iterable.js.map

package/dist/datastore/common/iterable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"iterable.js","names":["GatsbyIterable","constructor","source","Symbol","iterator","i","val","clearKeptObjects","concat","other","concatSequence","map","fn","mapSequence","filter","predicate","filterSequence","slice","start","end","Error","sliceSequence","deduplicate","keyFn","deduplicateSequence","forEach","callback","value","mergeSorted","comparator","intersectSorted","deduplicateSorted","isIterable","obj","isNonArrayIterable","Array","isArray","index","item","first","second","registered","Set","current","key","has","add","defaultComparator","prev","firstSorted","secondSorted","iter1","iter2","a","next","b","done","return","eq"],"sources":["../../../src/datastore/common/iterable.ts"],"sourcesContent":["declare module \"lmdb\" {\n  // currently lmdb doesn't have typings for this export\n  export function clearKeptObjects(): void\n}\n\nimport { clearKeptObjects } from \"lmdb\"\n/**\n * Wrapper for any iterable providing chainable interface and convenience methods\n * similar to array.\n *\n * Additionally provides convenience methods for sorted iterables.\n *\n * Note: avoiding async iterables because of perf reasons, see https://github.com/nodejs/node/issues/31979\n * (fortunately lmdb can traverse stuff in sync manner very fast)\n */\nexport class GatsbyIterable<T> {\n  constructor(private source: Iterable<T> | (() => Iterable<T>)) {}\n\n  *[Symbol.iterator](): Iterator<T> {\n    const source =\n      typeof this.source === `function` ? this.source() : this.source\n\n    let i = 0\n    for (const val of source) {\n      yield val\n\n      // clearKeptObjects just make it possible for WeakRefs used in any way during current\n      // sync execution tick to be garbage collected. It doesn't force GC, just remove\n      // internal strong references in V8.\n      // see https://github.com/kriszyp/weak-lru-cache/issues/4\n      if (++i % 100 === 0) {\n        clearKeptObjects()\n      }\n    }\n  }\n\n  concat<U>(other: Iterable<U>): GatsbyIterable<T | U> {\n    return new GatsbyIterable(() => concatSequence(this, other))\n  }\n\n  map<U>(fn: (entry: T, index: number) => U): GatsbyIterable<U> {\n    return new GatsbyIterable(() => mapSequence(this, fn))\n  }\n\n  filter(predicate: (entry: T) => unknown): GatsbyIterable<T> {\n    return new GatsbyIterable(() => filterSequence(this, predicate))\n  }\n\n  slice(start: number, end?: number): GatsbyIterable<T> {\n    if ((typeof end !== `undefined` && end < start) || start < 0)\n      throw new Error(\n        `Both arguments must not be negative and end must be greater than start`\n      )\n    return new GatsbyIterable<T>(() => sliceSequence(this, start, end))\n  }\n\n  deduplicate(keyFn?: (entry: T) => unknown): GatsbyIterable<T> {\n    return new GatsbyIterable<T>(() => deduplicateSequence(this, keyFn))\n  }\n\n  forEach(callback: (entry: T, index: number) => unknown): void {\n    let i = 0\n    for (const value of this) {\n      callback(value, i++)\n    }\n  }\n\n  /**\n   * Assuming both this and the other iterable are sorted\n   * produces the new sorted iterable with interleaved values.\n   *\n   * Note: this method is not removing duplicates\n   */\n  mergeSorted<U = T>(\n    other: Iterable<U>,\n    comparator?: (a: T | U, b: T | U) => number\n  ): GatsbyIterable<T | U> {\n    return new GatsbyIterable(() => mergeSorted(this, other, comparator))\n  }\n\n  /**\n   * Assuming both this and the other iterable are sorted\n   * produces the new sorted iterable with values from this iterable\n   * that also exist in the other iterable.\n   */\n  intersectSorted<U = T>(\n    other: Iterable<U>,\n    comparator?: (a: T | U, b: T | U) => number\n  ): GatsbyIterable<T | U> {\n    return new GatsbyIterable(() => intersectSorted(this, other, comparator))\n  }\n\n  /**\n   * Assuming this iterable is sorted, removes duplicates from it\n   * by applying comparator(prev, current) to sibling iterable values.\n   *\n   * Comparator function is expected to return 0 when items are equal,\n   * similar to Array.prototype.sort() argument.\n   *\n   * If comparator is not set, uses strict === comparison\n   */\n  deduplicateSorted(comparator?: (a: T, b: T) => number): GatsbyIterable<T> {\n    return new GatsbyIterable<T>(() => deduplicateSorted(this, comparator))\n  }\n}\n\n/**\n * Returns true when passed value is iterable\n */\nexport function isIterable(obj: unknown): obj is Iterable<any> {\n  if (typeof obj !== `object` || obj === null) {\n    return false\n  }\n  return typeof obj[Symbol.iterator] === `function`\n}\n\nexport function isNonArrayIterable<T>(value: unknown): value is Iterable<T> {\n  return isIterable(value) && !Array.isArray(value)\n}\n\nfunction* mapSequence<T, U>(\n  source: Iterable<T>,\n  fn: (arg: T, index: number) => U\n): Generator<U> {\n  let i = 0\n  for (const value of source) {\n    yield fn(value, i++)\n  }\n}\n\nfunction* sliceSequence<T>(\n  source: Iterable<T>,\n  start: number,\n  end: number | undefined\n): Generator<T> {\n  let index = -1\n  for (const item of source) {\n    index++\n    if (index < start) continue\n    if (typeof end !== `undefined` && index >= end) break\n    yield item\n  }\n}\n\nfunction* filterSequence<T>(\n  source: Iterable<T>,\n  predicate: (arg: T) => unknown\n): Generator<T> {\n  for (const value of source) {\n    if (predicate(value)) {\n      yield value\n    }\n  }\n}\n\nfunction* concatSequence<T, U>(\n  first: Iterable<T>,\n  second: Iterable<U>\n): Generator<U | T> {\n  for (const value of first) {\n    yield value\n  }\n  for (const value of second) {\n    yield value\n  }\n}\n\nfunction* deduplicateSequence<T>(\n  source: Iterable<T>,\n  keyFn?: (entry: T) => unknown\n): Generator<T> {\n  // TODO: this can be potentially improved by using bloom filters?\n  const registered = new Set<unknown>()\n\n  for (const current of source) {\n    const key = keyFn ? keyFn(current) : current\n    if (!registered.has(key)) {\n      registered.add(key)\n      yield current\n    }\n  }\n}\n\nfunction* deduplicateSorted<T>(\n  source: Iterable<T>,\n  comparator: (a: T, b: T) => number = defaultComparator\n): Generator<T> {\n  let prev\n  for (const current of source) {\n    if (typeof prev === `undefined` || comparator(prev, current) !== 0) {\n      yield current\n    }\n    prev = current\n  }\n}\n\n// Merge two originally sorted iterables:\nfunction* mergeSorted<T, U = T>(\n  firstSorted: Iterable<T>,\n  secondSorted: Iterable<U>,\n  comparator: (a: T | U, b: T | U) => number = defaultComparator\n): Generator<T | U> {\n  const iter1 = firstSorted[Symbol.iterator]()\n  const iter2 = secondSorted[Symbol.iterator]()\n  try {\n    let a = iter1.next()\n    let b = iter2.next()\n    while (!a.done && !b.done) {\n      if (comparator(a.value, b.value) <= 0) {\n        yield a.value\n        a = iter1.next()\n      } else {\n        yield b.value\n        b = iter2.next()\n      }\n    }\n    while (!a.done) {\n      yield a.value\n      a = iter1.next()\n    }\n    while (!b.done) {\n      yield b.value\n      b = iter2.next()\n    }\n  } finally {\n    // If generator is exited early, make sure to close iterators too\n    // See https://raganwald.com/2017/07/22/closing-iterables-is-a-leaky-abstraction.html#more-about-closing-iterators-explicitly\n    if (typeof iter1.return === `function`) iter1.return()\n    if (typeof iter2.return === `function`) iter2.return()\n  }\n}\n\nfunction* intersectSorted<T, U = T>(\n  firstSorted: Iterable<T>,\n  secondSorted: Iterable<U>,\n  comparator: (a: T | U, b: T | U) => number = defaultComparator\n): Generator<T> {\n  const iter1 = firstSorted[Symbol.iterator]()\n  const iter2 = secondSorted[Symbol.iterator]()\n  try {\n    let a = iter1.next()\n    let b = iter2.next()\n\n    while (!a.done && !b.done) {\n      const eq = comparator(a.value, b.value)\n\n      if (eq < 0) {\n        // a < b\n        a = iter1.next()\n      } else if (eq > 0) {\n        // a > b\n        b = iter2.next()\n      } else {\n        yield a.value\n        a = iter1.next()\n      }\n    }\n  } finally {\n    if (typeof iter1.return === `function`) iter1.return()\n    if (typeof iter2.return === `function`) iter2.return()\n  }\n}\n\nfunction defaultComparator<T, U = T>(a: T | U, b: T | U): number {\n  if (a === b) {\n    return 0\n  }\n  return a > b ? 1 : -1\n}\n"],"mappings":"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"}

package/dist/datastore/common/query.d.ts

@@ -0,0 +1,69 @@
+export interface IDbQueryQuery {
+    type: "query";
+    path: Array<string>;
+    query: IDbFilterStatement;
+}
+export interface IDbQueryElemMatch {
+    type: "elemMatch";
+    path: Array<string>;
+    nestedQuery: DbQuery;
+}
+export type DbQuery = IDbQueryQuery | IDbQueryElemMatch;
+export declare enum DbComparator {
+    EQ = "$eq",
+    NE = "$ne",
+    GT = "$gt",
+    GTE = "$gte",
+    LT = "$lt",
+    LTE = "$lte",
+    IN = "$in",
+    NIN = "$nin",
+    REGEX = "$regex",
+    GLOB = "$glob"
+}
+export type FilterValueNullable = string | number | boolean | null | undefined | RegExp | Array<string | number | boolean | null | undefined>;
+export type FilterValue = string | number | boolean | RegExp | Array<string | number | boolean>;
+export interface IInputQuery {
+    [key: string]: FilterValueNullable | IInputQuery;
+}
+export interface IPreparedQueryArg {
+    [key: string]: FilterValueNullable | IPreparedQueryArg;
+}
+export type DbComparatorValue = string | number | boolean | RegExp | null;
+export interface IDbFilterStatement {
+    comparator: DbComparator;
+    value: DbComparatorValue | Array<DbComparatorValue>;
+}
+/**
+ * Converts a nested mongo args object into array of DbQuery objects,
+ * structured representation of each distinct path of the query. We convert
+ * nested objects with multiple keys to separate instances.
+ */
+export declare function createDbQueriesFromObject(filter: Record<string, any>): Array<DbQuery>;
+/**
+ * Takes a DbQuery structure and returns a dotted representation of a field referenced in this query.
+ *
+ * Example:
+ * ```js
+ *   const query = createDbQueriesFromObject({
+ *     foo: { $elemMatch: { id: { $eq: 5 }, test: { $gt: 42 } } },
+ *     bar: { $in: [`bar`] }
+ *   })
+ *   const result = query.map(dbQueryToDottedField)
+ * ```
+ * Returns:
+ *   [`foo.id`, `foo.test`, `bar`]
+ */
+export declare function dbQueryToDottedField(query: DbQuery): string;
+export declare function getFilterStatement(dbQuery: DbQuery): IDbFilterStatement;
+export declare function prefixResolvedFields(queries: Array<DbQuery>, resolvedFields: Record<string, unknown>): Array<DbQuery>;
+/**
+ * Transforms filters coming from input GraphQL query to mongodb-compatible format
+ * (by prefixing comparators with "$").
+ *
+ * Example:
+ *   { foo: { eq: 5 } } -> { foo: { $eq: 5 }}
+ */
+export declare function prepareQueryArgs(filterFields?: Array<IInputQuery> | IInputQuery): IPreparedQueryArg;
+export declare function objectToDottedField(obj: Record<string, unknown>, path?: Array<string>): Record<string, unknown>;
+export declare function sortBySpecificity(all: Array<DbQuery>): Array<DbQuery>;

package/dist/datastore/common/query.js

@@ -0,0 +1,219 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+exports.__esModule = true;
+exports.DbComparator = void 0;
+exports.createDbQueriesFromObject = createDbQueriesFromObject;
+exports.dbQueryToDottedField = dbQueryToDottedField;
+exports.getFilterStatement = getFilterStatement;
+exports.objectToDottedField = objectToDottedField;
+exports.prefixResolvedFields = prefixResolvedFields;
+exports.prepareQueryArgs = prepareQueryArgs;
+exports.sortBySpecificity = sortBySpecificity;
+var _isPlainObject2 = _interopRequireDefault(require("lodash/isPlainObject"));
+var _flatMap2 = _interopRequireDefault(require("lodash/flatMap"));
+var _prepareRegex = require("../../utils/prepare-regex");
+var _micromatch = require("micromatch");
+let DbComparator; // TODO: merge with DbComparatorValue
+exports.DbComparator = DbComparator;
+(function (DbComparator) {
+  DbComparator["EQ"] = "$eq";
+  DbComparator["NE"] = "$ne";
+  DbComparator["GT"] = "$gt";
+  DbComparator["GTE"] = "$gte";
+  DbComparator["LT"] = "$lt";
+  DbComparator["LTE"] = "$lte";
+  DbComparator["IN"] = "$in";
+  DbComparator["NIN"] = "$nin";
+  DbComparator["REGEX"] = "$regex";
+  DbComparator["GLOB"] = "$glob";
+})(DbComparator || (exports.DbComparator = DbComparator = {}));
+const DB_COMPARATOR_VALUES = new Set(Object.values(DbComparator));
+function isDbComparator(value) {
+  return DB_COMPARATOR_VALUES.has(value);
+}
+/**
+ * Converts a nested mongo args object into array of DbQuery objects,
+ * structured representation of each distinct path of the query. We convert
+ * nested objects with multiple keys to separate instances.
+ */
+function createDbQueriesFromObject(filter) {
+  return createDbQueriesFromObjectNested(filter);
+}
+function createDbQueriesFromObjectNested(filter, path = []) {
+  const keys = Object.getOwnPropertyNames(filter);
+  return (0, _flatMap2.default)(keys, key => {
+    if (key === `$elemMatch`) {
+      const queries = createDbQueriesFromObjectNested(filter[key]);
+      return queries.map(query => {
+        return {
+          type: `elemMatch`,
+          path: path,
+          nestedQuery: query
+        };
+      });
+    } else if (isDbComparator(key)) {
+      return [{
+        type: `query`,
+        path,
+        query: {
+          comparator: key,
+          value: filter[key]
+        }
+      }];
+    } else {
+      return createDbQueriesFromObjectNested(filter[key], path.concat([key]));
+    }
+  });
+}
+
+/**
+ * Takes a DbQuery structure and returns a dotted representation of a field referenced in this query.
+ *
+ * Example:
+ * ```js
+ *   const query = createDbQueriesFromObject({
+ *     foo: { $elemMatch: { id: { $eq: 5 }, test: { $gt: 42 } } },
+ *     bar: { $in: [`bar`] }
+ *   })
+ *   const result = query.map(dbQueryToDottedField)
+ * ```
+ * Returns:
+ *   [`foo.id`, `foo.test`, `bar`]
+ */
+function dbQueryToDottedField(query) {
+  const path = [...query.path];
+  let currentQuery = query;
+  while (currentQuery.type === `elemMatch`) {
+    currentQuery = currentQuery.nestedQuery;
+    path.push(...currentQuery.path);
+  }
+  return path.join(`.`);
+}
+function getFilterStatement(dbQuery) {
+  let currentQuery = dbQuery;
+  while (currentQuery.type !== `query`) {
+    currentQuery = currentQuery.nestedQuery;
+  }
+  return currentQuery.query;
+}
+function prefixResolvedFields(queries, resolvedFields) {
+  const dottedFields = objectToDottedField(resolvedFields);
+  const dottedFieldKeys = Object.getOwnPropertyNames(dottedFields);
+  queries.forEach(query => {
+    const prefixPath = query.path.join(`.`);
+    if (dottedFields[prefixPath] || dottedFieldKeys.some(dottedKey => dottedKey.startsWith(prefixPath)) && query.type === `elemMatch` || dottedFieldKeys.some(dottedKey => prefixPath.startsWith(dottedKey))) {
+      query.path.unshift(`__gatsby_resolved`);
+    }
+  });
+  return queries;
+}
+
+/**
+ * Transforms filters coming from input GraphQL query to mongodb-compatible format
+ * (by prefixing comparators with "$").
+ *
+ * Example:
+ *   { foo: { eq: 5 } } -> { foo: { $eq: 5 }}
+ */
+function prepareQueryArgs(filterFields = {}) {
+  const filters = {};
+  Object.keys(filterFields).forEach(key => {
+    const value = filterFields[key];
+    if ((0, _isPlainObject2.default)(value)) {
+      filters[key === `elemMatch` ? `$elemMatch` : key] = prepareQueryArgs(value);
+    } else {
+      switch (key) {
+        case `regex`:
+          if (typeof value !== `string`) {
+            throw new Error(`The $regex comparator is expecting the regex as a string, not an actual regex or anything else`);
+          }
+          filters[`$regex`] = (0, _prepareRegex.prepareRegex)(value);
+          break;
+        case `glob`:
+          filters[`$regex`] = (0, _micromatch.makeRe)(value);
+          break;
+        default:
+          filters[`$${key}`] = value;
+      }
+    }
+  });
+  return filters;
+}
+
+// Converts a nested mongo args object into a dotted notation. acc
+// (accumulator) must be a reference to an empty object. The converted
+// fields will be added to it. E.g
+//
+// {
+//   internal: {
+//     type: {
+//       $eq: "TestNode"
+//     },
+//     content: {
+//       $regex: new MiniMatch(v)
+//     }
+//   },
+//   id: {
+//     $regex: newMiniMatch(v)
+//   }
+// }
+//
+// After execution, acc would be:
+//
+// {
+//   "internal.type": {
+//     $eq: "TestNode"
+//   },
+//   "internal.content": {
+//     $regex: new MiniMatch(v)
+//   },
+//   "id": {
+//     $regex: // as above
+//   }
+// }
+
+// Like above, but doesn't handle $elemMatch
+function objectToDottedField(obj, path = []) {
+  let result = {};
+  Object.keys(obj).forEach(key => {
+    const value = obj[key];
+    if ((0, _isPlainObject2.default)(value)) {
+      const pathResult = objectToDottedField(value, path.concat(key));
+      result = {
+        ...result,
+        ...pathResult
+      };
+    } else {
+      result[path.concat(key).join(`.`)] = value;
+    }
+  });
+  return result;
+}
+const comparatorSpecificity = {
+  [DbComparator.EQ]: 80,
+  [DbComparator.IN]: 70,
+  [DbComparator.GTE]: 60,
+  [DbComparator.LTE]: 50,
+  [DbComparator.GT]: 40,
+  [DbComparator.LT]: 30,
+  [DbComparator.NIN]: 20,
+  [DbComparator.NE]: 10
+};
+function sortBySpecificity(all) {
+  return [...all].sort(compareBySpecificityDesc);
+}
+function compareBySpecificityDesc(a, b) {
+  const aComparator = getFilterStatement(a).comparator;
+  const bComparator = getFilterStatement(b).comparator;
+  if (aComparator === bComparator) {
+    return 0;
+  }
+  const aSpecificity = comparatorSpecificity[aComparator];
+  const bSpecificity = comparatorSpecificity[bComparator];
+  if (!aSpecificity || !bSpecificity) {
+    throw new Error(`Unexpected comparator pair: ${aComparator}, ${bComparator}`);
+  }
+  return aSpecificity > bSpecificity ? -1 : 1;
+}
+//# sourceMappingURL=query.js.map

package/dist/datastore/common/query.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.js","names":["DbComparator","DB_COMPARATOR_VALUES","Set","Object","values","isDbComparator","value","has","createDbQueriesFromObject","filter","createDbQueriesFromObjectNested","path","keys","getOwnPropertyNames","key","queries","map","query","type","nestedQuery","comparator","concat","dbQueryToDottedField","currentQuery","push","join","getFilterStatement","dbQuery","prefixResolvedFields","resolvedFields","dottedFields","objectToDottedField","dottedFieldKeys","forEach","prefixPath","some","dottedKey","startsWith","unshift","prepareQueryArgs","filterFields","filters","Error","prepareRegex","makeRe","obj","result","pathResult","comparatorSpecificity","EQ","IN","GTE","LTE","GT","LT","NIN","NE","sortBySpecificity","all","sort","compareBySpecificityDesc","a","b","aComparator","bComparator","aSpecificity","bSpecificity"],"sources":["../../../src/datastore/common/query.ts"],"sourcesContent":["import * as _ from \"lodash\"\nimport { prepareRegex } from \"../../utils/prepare-regex\"\nimport { makeRe } from \"micromatch\"\n\nexport interface IDbQueryQuery {\n  type: \"query\"\n  path: Array<string>\n  query: IDbFilterStatement\n}\n\nexport interface IDbQueryElemMatch {\n  type: \"elemMatch\"\n  path: Array<string>\n  nestedQuery: DbQuery\n}\n\nexport type DbQuery = IDbQueryQuery | IDbQueryElemMatch\n\nexport enum DbComparator {\n  EQ = `$eq`,\n  NE = `$ne`,\n  GT = `$gt`,\n  GTE = `$gte`,\n  LT = `$lt`,\n  LTE = `$lte`,\n  IN = `$in`,\n  NIN = `$nin`,\n  REGEX = `$regex`,\n  GLOB = `$glob`,\n}\n\n// TODO: merge with DbComparatorValue\nexport type FilterValueNullable =\n  | string\n  | number\n  | boolean\n  | null\n  | undefined\n  | RegExp // Only valid for $regex\n  | Array<string | number | boolean | null | undefined>\n\n// This is filter value in most cases\nexport type FilterValue =\n  | string\n  | number\n  | boolean\n  | RegExp // Only valid for $regex\n  | Array<string | number | boolean>\n\n// The value is an object with arbitrary keys that are either filter values or,\n// recursively, an object with the same struct. Ie. `{a: {a: {a: 2}}}`\nexport interface IInputQuery {\n  [key: string]: FilterValueNullable | IInputQuery\n}\n// Similar to IInputQuery except the comparator leaf nodes will have their\n// key prefixed with `$` and their value, in some cases, normalized.\nexport interface IPreparedQueryArg {\n  [key: string]: FilterValueNullable | IPreparedQueryArg\n}\n\nconst DB_COMPARATOR_VALUES: Set<string> = new Set(Object.values(DbComparator))\n\nfunction isDbComparator(value: string): value is DbComparator {\n  return DB_COMPARATOR_VALUES.has(value)\n}\n\nexport type DbComparatorValue = string | number | boolean | RegExp | null\n\nexport interface IDbFilterStatement {\n  comparator: DbComparator\n  value: DbComparatorValue | Array<DbComparatorValue>\n}\n\n/**\n * Converts a nested mongo args object into array of DbQuery objects,\n * structured representation of each distinct path of the query. We convert\n * nested objects with multiple keys to separate instances.\n */\nexport function createDbQueriesFromObject(\n  filter: Record<string, any>\n): Array<DbQuery> {\n  return createDbQueriesFromObjectNested(filter)\n}\n\nfunction createDbQueriesFromObjectNested(\n  filter: Record<string, any>,\n  path: Array<string> = []\n): Array<DbQuery> {\n  const keys = Object.getOwnPropertyNames(filter)\n  return _.flatMap(keys, (key: string): Array<DbQuery> => {\n    if (key === `$elemMatch`) {\n      const queries = createDbQueriesFromObjectNested(filter[key])\n      return queries.map(query => {\n        return {\n          type: `elemMatch`,\n          path: path,\n          nestedQuery: query,\n        }\n      })\n    } else if (isDbComparator(key)) {\n      return [\n        {\n          type: `query`,\n          path,\n          query: {\n            comparator: key,\n            value: filter[key],\n          },\n        },\n      ]\n    } else {\n      return createDbQueriesFromObjectNested(filter[key], path.concat([key]))\n    }\n  })\n}\n\n/**\n * Takes a DbQuery structure and returns a dotted representation of a field referenced in this query.\n *\n * Example:\n * ```js\n *   const query = createDbQueriesFromObject({\n *     foo: { $elemMatch: { id: { $eq: 5 }, test: { $gt: 42 } } },\n *     bar: { $in: [`bar`] }\n *   })\n *   const result = query.map(dbQueryToDottedField)\n * ```\n * Returns:\n *   [`foo.id`, `foo.test`, `bar`]\n */\nexport function dbQueryToDottedField(query: DbQuery): string {\n  const path: Array<string> = [...query.path]\n  let currentQuery = query\n  while (currentQuery.type === `elemMatch`) {\n    currentQuery = currentQuery.nestedQuery\n    path.push(...currentQuery.path)\n  }\n  return path.join(`.`)\n}\n\nexport function getFilterStatement(dbQuery: DbQuery): IDbFilterStatement {\n  let currentQuery = dbQuery\n  while (currentQuery.type !== `query`) {\n    currentQuery = currentQuery.nestedQuery\n  }\n  return currentQuery.query\n}\n\nexport function prefixResolvedFields(\n  queries: Array<DbQuery>,\n  resolvedFields: Record<string, unknown>\n): Array<DbQuery> {\n  const dottedFields = objectToDottedField(resolvedFields)\n  const dottedFieldKeys = Object.getOwnPropertyNames(dottedFields)\n  queries.forEach(query => {\n    const prefixPath = query.path.join(`.`)\n    if (\n      dottedFields[prefixPath] ||\n      (dottedFieldKeys.some(dottedKey => dottedKey.startsWith(prefixPath)) &&\n        query.type === `elemMatch`) ||\n      dottedFieldKeys.some(dottedKey => prefixPath.startsWith(dottedKey))\n    ) {\n      query.path.unshift(`__gatsby_resolved`)\n    }\n  })\n  return queries\n}\n\n/**\n * Transforms filters coming from input GraphQL query to mongodb-compatible format\n * (by prefixing comparators with \"$\").\n *\n * Example:\n *   { foo: { eq: 5 } } -> { foo: { $eq: 5 }}\n */\nexport function prepareQueryArgs(\n  filterFields: Array<IInputQuery> | IInputQuery = {}\n): IPreparedQueryArg {\n  const filters = {}\n  Object.keys(filterFields).forEach(key => {\n    const value = filterFields[key]\n    if (_.isPlainObject(value)) {\n      filters[key === `elemMatch` ? `$elemMatch` : key] = prepareQueryArgs(\n        value as IInputQuery\n      )\n    } else {\n      switch (key) {\n        case `regex`:\n          if (typeof value !== `string`) {\n            throw new Error(\n              `The $regex comparator is expecting the regex as a string, not an actual regex or anything else`\n            )\n          }\n          filters[`$regex`] = prepareRegex(value)\n          break\n        case `glob`:\n          filters[`$regex`] = makeRe(value)\n          break\n        default:\n          filters[`$${key}`] = value\n      }\n    }\n  })\n  return filters\n}\n\n// Converts a nested mongo args object into a dotted notation. acc\n// (accumulator) must be a reference to an empty object. The converted\n// fields will be added to it. E.g\n//\n// {\n//   internal: {\n//     type: {\n//       $eq: \"TestNode\"\n//     },\n//     content: {\n//       $regex: new MiniMatch(v)\n//     }\n//   },\n//   id: {\n//     $regex: newMiniMatch(v)\n//   }\n// }\n//\n// After execution, acc would be:\n//\n// {\n//   \"internal.type\": {\n//     $eq: \"TestNode\"\n//   },\n//   \"internal.content\": {\n//     $regex: new MiniMatch(v)\n//   },\n//   \"id\": {\n//     $regex: // as above\n//   }\n// }\n\n// Like above, but doesn't handle $elemMatch\nexport function objectToDottedField(\n  obj: Record<string, unknown>,\n  path: Array<string> = []\n): Record<string, unknown> {\n  let result = {}\n  Object.keys(obj).forEach(key => {\n    const value = obj[key]\n    if (_.isPlainObject(value)) {\n      const pathResult = objectToDottedField(\n        value as Record<string, unknown>,\n        path.concat(key)\n      )\n      result = {\n        ...result,\n        ...pathResult,\n      }\n    } else {\n      result[path.concat(key).join(`.`)] = value\n    }\n  })\n  return result\n}\n\nconst comparatorSpecificity = {\n  [DbComparator.EQ]: 80,\n  [DbComparator.IN]: 70,\n  [DbComparator.GTE]: 60,\n  [DbComparator.LTE]: 50,\n  [DbComparator.GT]: 40,\n  [DbComparator.LT]: 30,\n  [DbComparator.NIN]: 20,\n  [DbComparator.NE]: 10,\n}\n\nexport function sortBySpecificity(all: Array<DbQuery>): Array<DbQuery> {\n  return [...all].sort(compareBySpecificityDesc)\n}\n\nfunction compareBySpecificityDesc(a: DbQuery, b: DbQuery): number {\n  const aComparator = getFilterStatement(a).comparator\n  const bComparator = getFilterStatement(b).comparator\n  if (aComparator === bComparator) {\n    return 0\n  }\n  const aSpecificity = comparatorSpecificity[aComparator]\n  const bSpecificity = comparatorSpecificity[bComparator]\n  if (!aSpecificity || !bSpecificity) {\n    throw new Error(\n      `Unexpected comparator pair: ${aComparator}, ${bComparator}`\n    )\n  }\n  return aSpecificity > bSpecificity ? -1 : 1\n}\n"],"mappings":"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"}

package/dist/datastore/datastore.d.ts

@@ -0,0 +1,2 @@
+import { IDataStore } from "./types";
+export declare function getDataStore(): IDataStore;

package/dist/datastore/datastore.js

@@ -0,0 +1,23 @@
+"use strict";
+
+exports.__esModule = true;
+exports.getDataStore = getDataStore;
+var _redux = require("../redux");
+let dataStore;
+function getDataStore() {
+  if (!dataStore) {
+    const {
+      setupLmdbStore
+    } = require(`./lmdb/lmdb-datastore`);
+    dataStore = setupLmdbStore();
+  }
+  return dataStore;
+}
+
+// It is possible that the store is not initialized yet when calling `DELETE_CACHE`.
+//  The code below ensures we wipe cache from the proper store
+//  (mostly relevant for tests)
+_redux.emitter.on(`DELETE_CACHE`, () => {
+  getDataStore();
+});
+//# sourceMappingURL=datastore.js.map

package/dist/datastore/datastore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"datastore.js","names":["dataStore","getDataStore","setupLmdbStore","require","emitter","on"],"sources":["../../src/datastore/datastore.ts"],"sourcesContent":["import { IDataStore } from \"./types\"\nimport { emitter } from \"../redux\"\n\nlet dataStore: IDataStore\n\nexport function getDataStore(): IDataStore {\n  if (!dataStore) {\n    const { setupLmdbStore } = require(`./lmdb/lmdb-datastore`)\n    dataStore = setupLmdbStore()\n  }\n  return dataStore\n}\n\n// It is possible that the store is not initialized yet when calling `DELETE_CACHE`.\n//  The code below ensures we wipe cache from the proper store\n//  (mostly relevant for tests)\nemitter.on(`DELETE_CACHE`, () => {\n  getDataStore()\n})\n"],"mappings":";;;;AACA;AAEA,IAAIA,SAAqB;AAElB,SAASC,YAAY,GAAe;EACzC,IAAI,CAACD,SAAS,EAAE;IACd,MAAM;MAAEE;IAAe,CAAC,GAAGC,OAAO,CAAE,uBAAsB,CAAC;IAC3DH,SAAS,GAAGE,cAAc,EAAE;EAC9B;EACA,OAAOF,SAAS;AAClB;;AAEA;AACA;AACA;AACAI,cAAO,CAACC,EAAE,CAAE,cAAa,EAAE,MAAM;EAC/BJ,YAAY,EAAE;AAChB,CAAC,CAAC"}

package/dist/datastore/in-memory/in-memory-datastore.d.ts

@@ -0,0 +1,2 @@
+import { IDataStore } from "../types";
+export declare function setupInMemoryStore(): IDataStore;