@budibase/backend-core 2.9.39-alpha.8 → 2.9.39

package/dist/src/db/lucene.js

@@ -1,595 +1,668 @@
 "use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var lucene_exports = {};
-__export(lucene_exports, {
-  QueryBuilder: () => QueryBuilder,
-  fullSearch: () => fullSearch,
-  paginatedSearch: () => paginatedSearch,
-  removeKeyNumbering: () => removeKeyNumbering
-});
-module.exports = __toCommonJS(lucene_exports);
-var import_node_fetch = __toESM(require("node-fetch"));
-var import_couch = require("./couch");
-var import_types = require("@budibase/types");
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _QueryBuilder_instances, _QueryBuilder_dbName, _QueryBuilder_index, _QueryBuilder_query, _QueryBuilder_limit, _QueryBuilder_sort, _QueryBuilder_bookmark, _QueryBuilder_sortOrder, _QueryBuilder_sortType, _QueryBuilder_includeDocs, _QueryBuilder_version, _QueryBuilder_indexBuilder, _QueryBuilder_noEscaping, _QueryBuilder_skip, _QueryBuilder_skipItems, _QueryBuilder_execute;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fullSearch = exports.paginatedSearch = exports.QueryBuilder = exports.removeKeyNumbering = void 0;
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const couch_1 = require("./couch");
+const types_1 = require("@budibase/types");
 const QUERY_START_REGEX = /\d[0-9]*:/g;
 function removeKeyNumbering(key) {
-  if (typeof key === "string" && key.match(QUERY_START_REGEX) != null) {
-    const parts = key.split(":");
-    parts.shift();
-    return parts.join(":");
-  } else {
-    return key;
-  }
+    if (typeof key === "string" && key.match(QUERY_START_REGEX) != null) {
+        const parts = key.split(":");
+        // remove the number
+        parts.shift();
+        return parts.join(":");
+    }
+    else {
+        return key;
+    }
 }
+exports.removeKeyNumbering = removeKeyNumbering;
+/**
+ * Class to build lucene query URLs.
+ * Optionally takes a base lucene query object.
+ */
 class QueryBuilder {
-  #dbName;
-  #index;
-  #query;
-  #limit;
-  #sort;
-  #bookmark;
-  #sortOrder;
-  #sortType;
-  #includeDocs;
-  #version;
-  #indexBuilder;
-  #noEscaping = false;
-  #skip;
-  static {
-    this.maxLimit = 200;
-  }
-  constructor(dbName, index, base) {
-    this.#dbName = dbName;
-    this.#index = index;
-    this.#query = {
-      allOr: false,
-      onEmptyFilter: import_types.EmptyFilterOption.RETURN_ALL,
-      string: {},
-      fuzzy: {},
-      range: {},
-      equal: {},
-      notEqual: {},
-      empty: {},
-      notEmpty: {},
-      oneOf: {},
-      contains: {},
-      notContains: {},
-      containsAny: {},
-      ...base
-    };
-    this.#limit = 50;
-    this.#sortOrder = "ascending";
-    this.#sortType = "string";
-    this.#includeDocs = true;
-  }
-  disableEscaping() {
-    this.#noEscaping = true;
-    return this;
-  }
-  setIndexBuilder(builderFn) {
-    this.#indexBuilder = builderFn;
-    return this;
-  }
-  setVersion(version) {
-    if (version != null) {
-      this.#version = version;
-    }
-    return this;
-  }
-  setTable(tableId) {
-    this.#query.equal.tableId = tableId;
-    return this;
-  }
-  setLimit(limit) {
-    if (limit != null) {
-      this.#limit = limit;
-    }
-    return this;
-  }
-  setSort(sort) {
-    if (sort != null) {
-      this.#sort = sort;
-    }
-    return this;
-  }
-  setSortOrder(sortOrder) {
-    if (sortOrder != null) {
-      this.#sortOrder = sortOrder;
-    }
-    return this;
-  }
-  setSortType(sortType) {
-    if (sortType != null) {
-      this.#sortType = sortType;
-    }
-    return this;
-  }
-  setBookmark(bookmark) {
-    if (bookmark != null) {
-      this.#bookmark = bookmark;
-    }
-    return this;
-  }
-  setSkip(skip) {
-    this.#skip = skip;
-    return this;
-  }
-  excludeDocs() {
-    this.#includeDocs = false;
-    return this;
-  }
-  includeDocs() {
-    this.#includeDocs = true;
-    return this;
-  }
-  addString(key, partial) {
-    this.#query.string[key] = partial;
-    return this;
-  }
-  addFuzzy(key, fuzzy) {
-    this.#query.fuzzy[key] = fuzzy;
-    return this;
-  }
-  addRange(key, low, high) {
-    this.#query.range[key] = {
-      low,
-      high
-    };
-    return this;
-  }
-  addEqual(key, value) {
-    this.#query.equal[key] = value;
-    return this;
-  }
-  addNotEqual(key, value) {
-    this.#query.notEqual[key] = value;
-    return this;
-  }
-  addEmpty(key, value) {
-    this.#query.empty[key] = value;
-    return this;
-  }
-  addNotEmpty(key, value) {
-    this.#query.notEmpty[key] = value;
-    return this;
-  }
-  addOneOf(key, value) {
-    this.#query.oneOf[key] = value;
-    return this;
-  }
-  addContains(key, value) {
-    this.#query.contains[key] = value;
-    return this;
-  }
-  addNotContains(key, value) {
-    this.#query.notContains[key] = value;
-    return this;
-  }
-  addContainsAny(key, value) {
-    this.#query.containsAny[key] = value;
-    return this;
-  }
-  setAllOr() {
-    this.#query.allOr = true;
-  }
-  setOnEmptyFilter(value) {
-    this.#query.onEmptyFilter = value;
-  }
-  handleSpaces(input) {
-    if (this.#noEscaping) {
-      return input;
-    } else {
-      return input.replace(/ /g, "_");
-    }
-  }
-  /**
-   * Preprocesses a value before going into a lucene search.
-   * Transforms strings to lowercase and wraps strings and bools in quotes.
-   * @param value The value to process
-   * @param options The preprocess options
-   * @returns {string|*}
-   */
-  preprocess(value, { escape, lowercase, wrap, type } = {}) {
-    const hasVersion = !!this.#version;
-    const originalType = typeof value;
-    if (value && lowercase) {
-      value = value.toLowerCase ? value.toLowerCase() : value;
-    }
-    if (!this.#noEscaping && escape && originalType === "string") {
-      value = `${value}`.replace(/[ \/#+\-&|!(){}\]^"~*?:\\]/g, "\\$&");
-    }
-    if (originalType === "string" && !isNaN(value) && !type) {
-      value = `"${value}"`;
-    } else if (hasVersion && wrap) {
-      value = originalType === "number" ? value : `"${value}"`;
-    }
-    return value;
-  }
-  isMultiCondition() {
-    let count = 0;
-    for (let filters of Object.values(this.#query)) {
-      if (typeof filters === "object") {
-        count += Object.keys(filters).length;
-      }
-    }
-    return count > 1;
-  }
-  compressFilters(filters) {
-    const compressed = {};
-    for (let key of Object.keys(filters)) {
-      const finalKey = removeKeyNumbering(key);
-      if (compressed[finalKey]) {
-        compressed[finalKey] = compressed[finalKey].concat(filters[key]);
-      } else {
-        compressed[finalKey] = filters[key];
-      }
-    }
-    const final = {};
-    let count = 1;
-    for (let [key, value] of Object.entries(compressed)) {
-      final[`${count++}:${key}`] = value;
-    }
-    return final;
-  }
-  buildSearchQuery() {
-    const builder = this;
-    let allOr = this.#query && this.#query.allOr;
-    let query = allOr ? "" : "*:*";
-    let allFiltersEmpty = true;
-    const allPreProcessingOpts = { escape: true, lowercase: true, wrap: true };
-    let tableId = "";
-    if (this.#query.equal.tableId) {
-      tableId = this.#query.equal.tableId;
-      delete this.#query.equal.tableId;
-    }
-    const equal = (key, value) => {
-      if (!value && value !== 0) {
-        return null;
-      }
-      return `${key}:${builder.preprocess(value, allPreProcessingOpts)}`;
-    };
-    const contains = (key, value, mode = "AND") => {
-      if (!value || Array.isArray(value) && value.length === 0) {
-        return null;
-      }
-      if (!Array.isArray(value)) {
-        return `${key}:${value}`;
-      }
-      let statement = `${builder.preprocess(value[0], { escape: true })}`;
-      for (let i = 1; i < value.length; i++) {
-        statement += ` ${mode} ${builder.preprocess(value[i], {
-          escape: true
-        })}`;
-      }
-      return `${key}:(${statement})`;
-    };
-    const fuzzy = (key, value) => {
-      if (!value) {
-        return null;
-      }
-      value = builder.preprocess(value, {
-        escape: true,
-        lowercase: true,
-        type: "fuzzy"
-      });
-      return `${key}:/.*${value}.*/`;
-    };
-    const notContains = (key, value) => {
-      const allPrefix = allOr ? "*:* AND " : "";
-      const mode = allOr ? "AND" : void 0;
-      return allPrefix + "NOT " + contains(key, value, mode);
-    };
-    const containsAny = (key, value) => {
-      return contains(key, value, "OR");
-    };
-    const oneOf = (key, value) => {
-      if (!value) {
-        return `*:*`;
-      }
-      if (!Array.isArray(value)) {
-        if (typeof value === "string") {
-          value = value.split(",");
-        } else {
-          return "";
-        }
-      }
-      let orStatement = `${builder.preprocess(value[0], allPreProcessingOpts)}`;
-      for (let i = 1; i < value.length; i++) {
-        orStatement += ` OR ${builder.preprocess(
-          value[i],
-          allPreProcessingOpts
-        )}`;
-      }
-      return `${key}:(${orStatement})`;
-    };
-    function build(structure, queryFn, opts) {
-      let built = "";
-      for (let [key, value] of Object.entries(structure)) {
-        key = removeKeyNumbering(key);
-        key = builder.preprocess(builder.handleSpaces(key), {
-          escape: true
-        });
-        let expression = queryFn(key, value);
-        if (expression == null) {
-          continue;
-        }
-        if (built.length > 0 || query.length > 0) {
-          const mode = opts?.mode ? opts.mode : allOr ? "OR" : "AND";
-          built += ` ${mode} `;
-        }
-        built += expression;
-        if (typeof value !== "string" && value != null || typeof value === "string" && value !== tableId && value !== "") {
-          allFiltersEmpty = false;
-        }
-      }
-      if (opts?.returnBuilt) {
-        return built;
-      } else {
-        query += built;
-      }
-    }
-    if (this.#query.string) {
-      build(this.#query.string, (key, value) => {
-        if (!value) {
-          return null;
-        }
-        value = builder.preprocess(value, {
-          escape: true,
-          lowercase: true,
-          type: "string"
+    constructor(dbName, index, base) {
+        _QueryBuilder_instances.add(this);
+        _QueryBuilder_dbName.set(this, void 0);
+        _QueryBuilder_index.set(this, void 0);
+        _QueryBuilder_query.set(this, void 0);
+        _QueryBuilder_limit.set(this, void 0);
+        _QueryBuilder_sort.set(this, void 0);
+        _QueryBuilder_bookmark.set(this, void 0);
+        _QueryBuilder_sortOrder.set(this, void 0);
+        _QueryBuilder_sortType.set(this, void 0);
+        _QueryBuilder_includeDocs.set(this, void 0);
+        _QueryBuilder_version.set(this, void 0);
+        _QueryBuilder_indexBuilder.set(this, void 0);
+        _QueryBuilder_noEscaping.set(this, false);
+        _QueryBuilder_skip.set(this, void 0);
+        __classPrivateFieldSet(this, _QueryBuilder_dbName, dbName, "f");
+        __classPrivateFieldSet(this, _QueryBuilder_index, index, "f");
+        __classPrivateFieldSet(this, _QueryBuilder_query, Object.assign({ allOr: false, onEmptyFilter: types_1.EmptyFilterOption.RETURN_ALL, string: {}, fuzzy: {}, range: {}, equal: {}, notEqual: {}, empty: {}, notEmpty: {}, oneOf: {}, contains: {}, notContains: {}, containsAny: {} }, base), "f");
+        __classPrivateFieldSet(this, _QueryBuilder_limit, 50, "f");
+        __classPrivateFieldSet(this, _QueryBuilder_sortOrder, "ascending", "f");
+        __classPrivateFieldSet(this, _QueryBuilder_sortType, "string", "f");
+        __classPrivateFieldSet(this, _QueryBuilder_includeDocs, true, "f");
+    }
+    disableEscaping() {
+        __classPrivateFieldSet(this, _QueryBuilder_noEscaping, true, "f");
+        return this;
+    }
+    setIndexBuilder(builderFn) {
+        __classPrivateFieldSet(this, _QueryBuilder_indexBuilder, builderFn, "f");
+        return this;
+    }
+    setVersion(version) {
+        if (version != null) {
+            __classPrivateFieldSet(this, _QueryBuilder_version, version, "f");
+        }
+        return this;
+    }
+    setTable(tableId) {
+        __classPrivateFieldGet(this, _QueryBuilder_query, "f").equal.tableId = tableId;
+        return this;
+    }
+    setLimit(limit) {
+        if (limit != null) {
+            __classPrivateFieldSet(this, _QueryBuilder_limit, limit, "f");
+        }
+        return this;
+    }
+    setSort(sort) {
+        if (sort != null) {
+            __classPrivateFieldSet(this, _QueryBuilder_sort, sort, "f");
+        }
+        return this;
+    }
+    setSortOrder(sortOrder) {
+        if (sortOrder != null) {
+            __classPrivateFieldSet(this, _QueryBuilder_sortOrder, sortOrder, "f");
+        }
+        return this;
+    }
+    setSortType(sortType) {
+        if (sortType != null) {
+            __classPrivateFieldSet(this, _QueryBuilder_sortType, sortType, "f");
+        }
+        return this;
+    }
+    setBookmark(bookmark) {
+        if (bookmark != null) {
+            __classPrivateFieldSet(this, _QueryBuilder_bookmark, bookmark, "f");
+        }
+        return this;
+    }
+    setSkip(skip) {
+        __classPrivateFieldSet(this, _QueryBuilder_skip, skip, "f");
+        return this;
+    }
+    excludeDocs() {
+        __classPrivateFieldSet(this, _QueryBuilder_includeDocs, false, "f");
+        return this;
+    }
+    includeDocs() {
+        __classPrivateFieldSet(this, _QueryBuilder_includeDocs, true, "f");
+        return this;
+    }
+    addString(key, partial) {
+        __classPrivateFieldGet(this, _QueryBuilder_query, "f").string[key] = partial;
+        return this;
+    }
+    addFuzzy(key, fuzzy) {
+        __classPrivateFieldGet(this, _QueryBuilder_query, "f").fuzzy[key] = fuzzy;
+        return this;
+    }
+    addRange(key, low, high) {
+        __classPrivateFieldGet(this, _QueryBuilder_query, "f").range[key] = {
+            low,
+            high,
+        };
+        return this;
+    }
+    addEqual(key, value) {
+        __classPrivateFieldGet(this, _QueryBuilder_query, "f").equal[key] = value;
+        return this;
+    }
+    addNotEqual(key, value) {
+        __classPrivateFieldGet(this, _QueryBuilder_query, "f").notEqual[key] = value;
+        return this;
+    }
+    addEmpty(key, value) {
+        __classPrivateFieldGet(this, _QueryBuilder_query, "f").empty[key] = value;
+        return this;
+    }
+    addNotEmpty(key, value) {
+        __classPrivateFieldGet(this, _QueryBuilder_query, "f").notEmpty[key] = value;
+        return this;
+    }
+    addOneOf(key, value) {
+        __classPrivateFieldGet(this, _QueryBuilder_query, "f").oneOf[key] = value;
+        return this;
+    }
+    addContains(key, value) {
+        __classPrivateFieldGet(this, _QueryBuilder_query, "f").contains[key] = value;
+        return this;
+    }
+    addNotContains(key, value) {
+        __classPrivateFieldGet(this, _QueryBuilder_query, "f").notContains[key] = value;
+        return this;
+    }
+    addContainsAny(key, value) {
+        __classPrivateFieldGet(this, _QueryBuilder_query, "f").containsAny[key] = value;
+        return this;
+    }
+    setAllOr() {
+        __classPrivateFieldGet(this, _QueryBuilder_query, "f").allOr = true;
+    }
+    setOnEmptyFilter(value) {
+        __classPrivateFieldGet(this, _QueryBuilder_query, "f").onEmptyFilter = value;
+    }
+    handleSpaces(input) {
+        if (__classPrivateFieldGet(this, _QueryBuilder_noEscaping, "f")) {
+            return input;
+        }
+        else {
+            return input.replace(/ /g, "_");
+        }
+    }
+    /**
+     * Preprocesses a value before going into a lucene search.
+     * Transforms strings to lowercase and wraps strings and bools in quotes.
+     * @param value The value to process
+     * @param options The preprocess options
+     * @returns {string|*}
+     */
+    preprocess(value, { escape, lowercase, wrap, type } = {}) {
+        const hasVersion = !!__classPrivateFieldGet(this, _QueryBuilder_version, "f");
+        // Determine if type needs wrapped
+        const originalType = typeof value;
+        // Convert to lowercase
+        if (value && lowercase) {
+            value = value.toLowerCase ? value.toLowerCase() : value;
+        }
+        // Escape characters
+        if (!__classPrivateFieldGet(this, _QueryBuilder_noEscaping, "f") && escape && originalType === "string") {
+            value = `${value}`.replace(/[ \/#+\-&|!(){}\]^"~*?:\\]/g, "\\$&");
+        }
+        // Wrap in quotes
+        if (originalType === "string" && !isNaN(value) && !type) {
+            value = `"${value}"`;
+        }
+        else if (hasVersion && wrap) {
+            value = originalType === "number" ? value : `"${value}"`;
+        }
+        return value;
+    }
+    isMultiCondition() {
+        let count = 0;
+        for (let filters of Object.values(__classPrivateFieldGet(this, _QueryBuilder_query, "f"))) {
+            // not contains is one massive filter in allOr mode
+            if (typeof filters === "object") {
+                count += Object.keys(filters).length;
+            }
+        }
+        return count > 1;
+    }
+    compressFilters(filters) {
+        const compressed = {};
+        for (let key of Object.keys(filters)) {
+            const finalKey = removeKeyNumbering(key);
+            if (compressed[finalKey]) {
+                compressed[finalKey] = compressed[finalKey].concat(filters[key]);
+            }
+            else {
+                compressed[finalKey] = filters[key];
+            }
+        }
+        // add prefixes back
+        const final = {};
+        let count = 1;
+        for (let [key, value] of Object.entries(compressed)) {
+            final[`${count++}:${key}`] = value;
+        }
+        return final;
+    }
+    buildSearchQuery() {
+        var _a;
+        const builder = this;
+        let allOr = __classPrivateFieldGet(this, _QueryBuilder_query, "f") && __classPrivateFieldGet(this, _QueryBuilder_query, "f").allOr;
+        let query = allOr ? "" : "*:*";
+        let allFiltersEmpty = true;
+        const allPreProcessingOpts = { escape: true, lowercase: true, wrap: true };
+        let tableId = "";
+        if (__classPrivateFieldGet(this, _QueryBuilder_query, "f").equal.tableId) {
+            tableId = __classPrivateFieldGet(this, _QueryBuilder_query, "f").equal.tableId;
+            delete __classPrivateFieldGet(this, _QueryBuilder_query, "f").equal.tableId;
+        }
+        const equal = (key, value) => {
+            // 0 evaluates to false, which means we would return all rows if we don't check it
+            if (!value && value !== 0) {
+                return null;
+            }
+            return `${key}:${builder.preprocess(value, allPreProcessingOpts)}`;
+        };
+        const contains = (key, value, mode = "AND") => {
+            if (!value || (Array.isArray(value) && value.length === 0)) {
+                return null;
+            }
+            if (!Array.isArray(value)) {
+                return `${key}:${value}`;
+            }
+            let statement = `${builder.preprocess(value[0], { escape: true })}`;
+            for (let i = 1; i < value.length; i++) {
+                statement += ` ${mode} ${builder.preprocess(value[i], {
+                    escape: true,
+                })}`;
+            }
+            return `${key}:(${statement})`;
+        };
+        const fuzzy = (key, value) => {
+            if (!value) {
+                return null;
+            }
+            value = builder.preprocess(value, {
+                escape: true,
+                lowercase: true,
+                type: "fuzzy",
+            });
+            return `${key}:/.*${value}.*/`;
+        };
+        const notContains = (key, value) => {
+            const allPrefix = allOr ? "*:* AND " : "";
+            const mode = allOr ? "AND" : undefined;
+            return allPrefix + "NOT " + contains(key, value, mode);
+        };
+        const containsAny = (key, value) => {
+            return contains(key, value, "OR");
+        };
+        const oneOf = (key, value) => {
+            if (!value) {
+                return `*:*`;
+            }
+            if (!Array.isArray(value)) {
+                if (typeof value === "string") {
+                    value = value.split(",");
+                }
+                else {
+                    return "";
+                }
+            }
+            let orStatement = `${builder.preprocess(value[0], allPreProcessingOpts)}`;
+            for (let i = 1; i < value.length; i++) {
+                orStatement += ` OR ${builder.preprocess(value[i], allPreProcessingOpts)}`;
+            }
+            return `${key}:(${orStatement})`;
+        };
+        function build(structure, queryFn, opts) {
+            let built = "";
+            for (let [key, value] of Object.entries(structure)) {
+                // check for new format - remove numbering if needed
+                key = removeKeyNumbering(key);
+                key = builder.preprocess(builder.handleSpaces(key), {
+                    escape: true,
+                });
+                let expression = queryFn(key, value);
+                if (expression == null) {
+                    continue;
+                }
+                if (built.length > 0 || query.length > 0) {
+                    const mode = (opts === null || opts === void 0 ? void 0 : opts.mode) ? opts.mode : allOr ? "OR" : "AND";
+                    built += ` ${mode} `;
+                }
+                built += expression;
+                if ((typeof value !== "string" && value != null) ||
+                    (typeof value === "string" && value !== tableId && value !== "")) {
+                    allFiltersEmpty = false;
+                }
+            }
+            if (opts === null || opts === void 0 ? void 0 : opts.returnBuilt) {
+                return built;
+            }
+            else {
+                query += built;
+            }
+        }
+        // Construct the actual lucene search query string from JSON structure
+        if (__classPrivateFieldGet(this, _QueryBuilder_query, "f").string) {
+            build(__classPrivateFieldGet(this, _QueryBuilder_query, "f").string, (key, value) => {
+                if (!value) {
+                    return null;
+                }
+                value = builder.preprocess(value, {
+                    escape: true,
+                    lowercase: true,
+                    type: "string",
+                });
+                return `${key}:${value}*`;
+            });
+        }
+        if (__classPrivateFieldGet(this, _QueryBuilder_query, "f").range) {
+            build(__classPrivateFieldGet(this, _QueryBuilder_query, "f").range, (key, value) => {
+                if (!value) {
+                    return null;
+                }
+                if (value.low == null || value.low === "") {
+                    return null;
+                }
+                if (value.high == null || value.high === "") {
+                    return null;
+                }
+                const low = builder.preprocess(value.low, allPreProcessingOpts);
+                const high = builder.preprocess(value.high, allPreProcessingOpts);
+                return `${key}:[${low} TO ${high}]`;
+            });
+        }
+        if (__classPrivateFieldGet(this, _QueryBuilder_query, "f").fuzzy) {
+            build(__classPrivateFieldGet(this, _QueryBuilder_query, "f").fuzzy, fuzzy);
+        }
+        if (__classPrivateFieldGet(this, _QueryBuilder_query, "f").equal) {
+            build(__classPrivateFieldGet(this, _QueryBuilder_query, "f").equal, equal);
+        }
+        if (__classPrivateFieldGet(this, _QueryBuilder_query, "f").notEqual) {
+            build(__classPrivateFieldGet(this, _QueryBuilder_query, "f").notEqual, (key, value) => {
+                if (!value) {
+                    return null;
+                }
+                if (typeof value === "boolean") {
+                    return `(*:* AND !${key}:${value})`;
+                }
+                return `!${key}:${builder.preprocess(value, allPreProcessingOpts)}`;
+            });
+        }
+        if (__classPrivateFieldGet(this, _QueryBuilder_query, "f").empty) {
+            build(__classPrivateFieldGet(this, _QueryBuilder_query, "f").empty, (key) => `(*:* -${key}:["" TO *])`);
+        }
+        if (__classPrivateFieldGet(this, _QueryBuilder_query, "f").notEmpty) {
+            build(__classPrivateFieldGet(this, _QueryBuilder_query, "f").notEmpty, (key) => `${key}:["" TO *]`);
+        }
+        if (__classPrivateFieldGet(this, _QueryBuilder_query, "f").oneOf) {
+            build(__classPrivateFieldGet(this, _QueryBuilder_query, "f").oneOf, oneOf);
+        }
+        if (__classPrivateFieldGet(this, _QueryBuilder_query, "f").contains) {
+            build(__classPrivateFieldGet(this, _QueryBuilder_query, "f").contains, contains);
+        }
+        if (__classPrivateFieldGet(this, _QueryBuilder_query, "f").notContains) {
+            build(this.compressFilters(__classPrivateFieldGet(this, _QueryBuilder_query, "f").notContains), notContains);
+        }
+        if (__classPrivateFieldGet(this, _QueryBuilder_query, "f").containsAny) {
+            build(__classPrivateFieldGet(this, _QueryBuilder_query, "f").containsAny, containsAny);
+        }
+        // make sure table ID is always added as an AND
+        if (tableId) {
+            query = this.isMultiCondition() ? `(${query})` : query;
+            allOr = false;
+            build({ tableId }, equal);
+        }
+        if (allFiltersEmpty) {
+            if (__classPrivateFieldGet(this, _QueryBuilder_query, "f").onEmptyFilter === types_1.EmptyFilterOption.RETURN_NONE) {
+                return "";
+            }
+            else if ((_a = __classPrivateFieldGet(this, _QueryBuilder_query, "f")) === null || _a === void 0 ? void 0 : _a.allOr) {
+                return query.replace("()", "(*:*)");
+            }
+        }
+        return query;
+    }
+    buildSearchBody() {
+        let body = {
+            q: this.buildSearchQuery(),
+            limit: Math.min(__classPrivateFieldGet(this, _QueryBuilder_limit, "f"), QueryBuilder.maxLimit),
+            include_docs: __classPrivateFieldGet(this, _QueryBuilder_includeDocs, "f"),
+        };
+        if (__classPrivateFieldGet(this, _QueryBuilder_bookmark, "f")) {
+            body.bookmark = __classPrivateFieldGet(this, _QueryBuilder_bookmark, "f");
+        }
+        if (__classPrivateFieldGet(this, _QueryBuilder_sort, "f")) {
+            const order = __classPrivateFieldGet(this, _QueryBuilder_sortOrder, "f") === "descending" ? "-" : "";
+            const type = `<${__classPrivateFieldGet(this, _QueryBuilder_sortType, "f")}>`;
+            body.sort = `${order}${this.handleSpaces(__classPrivateFieldGet(this, _QueryBuilder_sort, "f"))}${type}`;
+        }
+        return body;
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (__classPrivateFieldGet(this, _QueryBuilder_skip, "f")) {
+                yield __classPrivateFieldGet(this, _QueryBuilder_instances, "m", _QueryBuilder_skipItems).call(this, __classPrivateFieldGet(this, _QueryBuilder_skip, "f"));
+            }
+            return yield __classPrivateFieldGet(this, _QueryBuilder_instances, "m", _QueryBuilder_execute).call(this);
         });
-        return `${key}:${value}*`;
-      });
-    }
-    if (this.#query.range) {
-      build(this.#query.range, (key, value) => {
-        if (!value) {
-          return null;
-        }
-        if (value.low == null || value.low === "") {
-          return null;
-        }
-        if (value.high == null || value.high === "") {
-          return null;
-        }
-        const low = builder.preprocess(value.low, allPreProcessingOpts);
-        const high = builder.preprocess(value.high, allPreProcessingOpts);
-        return `${key}:[${low} TO ${high}]`;
-      });
-    }
-    if (this.#query.fuzzy) {
-      build(this.#query.fuzzy, fuzzy);
-    }
-    if (this.#query.equal) {
-      build(this.#query.equal, equal);
-    }
-    if (this.#query.notEqual) {
-      build(this.#query.notEqual, (key, value) => {
-        if (!value) {
-          return null;
-        }
-        if (typeof value === "boolean") {
-          return `(*:* AND !${key}:${value})`;
-        }
-        return `!${key}:${builder.preprocess(value, allPreProcessingOpts)}`;
-      });
-    }
-    if (this.#query.empty) {
-      build(this.#query.empty, (key) => `(*:* -${key}:["" TO *])`);
-    }
-    if (this.#query.notEmpty) {
-      build(this.#query.notEmpty, (key) => `${key}:["" TO *]`);
-    }
-    if (this.#query.oneOf) {
-      build(this.#query.oneOf, oneOf);
-    }
-    if (this.#query.contains) {
-      build(this.#query.contains, contains);
-    }
-    if (this.#query.notContains) {
-      build(this.compressFilters(this.#query.notContains), notContains);
-    }
-    if (this.#query.containsAny) {
-      build(this.#query.containsAny, containsAny);
-    }
-    if (tableId) {
-      query = this.isMultiCondition() ? `(${query})` : query;
-      allOr = false;
-      build({ tableId }, equal);
-    }
-    if (allFiltersEmpty) {
-      if (this.#query.onEmptyFilter === import_types.EmptyFilterOption.RETURN_NONE) {
-        return "";
-      } else if (this.#query?.allOr) {
-        return query.replace("()", "(*:*)");
-      }
-    }
-    return query;
-  }
-  buildSearchBody() {
-    let body = {
-      q: this.buildSearchQuery(),
-      limit: Math.min(this.#limit, QueryBuilder.maxLimit),
-      include_docs: this.#includeDocs
-    };
-    if (this.#bookmark) {
-      body.bookmark = this.#bookmark;
-    }
-    if (this.#sort) {
-      const order = this.#sortOrder === "descending" ? "-" : "";
-      const type = `<${this.#sortType}>`;
-      body.sort = `${order}${this.handleSpaces(this.#sort)}${type}`;
-    }
-    return body;
-  }
-  async run() {
-    if (this.#skip) {
-      await this.#skipItems(this.#skip);
-    }
-    return await this.#execute();
-  }
-  /**
-   * Lucene queries do not support pagination and use bookmarks instead.
-   * For the given builder, walk through pages using bookmarks until the desired
-   * page has been met.
-   */
-  async #skipItems(skip) {
-    const prevIncludeDocs = this.#includeDocs;
-    const prevLimit = this.#limit;
-    this.excludeDocs();
-    let skipRemaining = skip;
-    let iterationFetched = 0;
-    do {
-      const toSkip = Math.min(QueryBuilder.maxLimit, skipRemaining);
-      this.setLimit(toSkip);
-      const { bookmark, rows } = await this.#execute();
-      this.setBookmark(bookmark);
-      iterationFetched = rows.length;
-      skipRemaining -= rows.length;
-    } while (skipRemaining > 0 && iterationFetched > 0);
-    this.#includeDocs = prevIncludeDocs;
-    this.#limit = prevLimit;
-  }
-  async #execute() {
-    const { url, cookie } = (0, import_couch.getCouchInfo)();
-    const fullPath = `${url}/${this.#dbName}/_design/database/_search/${this.#index}`;
-    const body = this.buildSearchBody();
-    try {
-      return await runQuery(fullPath, body, cookie);
-    } catch (err) {
-      if (err.status === 404 && this.#indexBuilder) {
-        await this.#indexBuilder();
-        return await runQuery(fullPath, body, cookie);
-      } else {
-        throw err;
-      }
-    }
-  }
+    }
 }
-async function runQuery(url, body, cookie) {
-  const response = await (0, import_node_fetch.default)(url, {
-    body: JSON.stringify(body),
-    method: "POST",
-    headers: {
-      Authorization: cookie
-    }
-  });
-  if (response.status === 404) {
-    throw response;
-  }
-  const json = await response.json();
-  let output = {
-    rows: [],
-    totalRows: 0
-  };
-  if (json.rows != null && json.rows.length > 0) {
-    output.rows = json.rows.map((row) => row.doc);
-  }
-  if (json.bookmark) {
-    output.bookmark = json.bookmark;
-  }
-  if (json.total_rows) {
-    output.totalRows = json.total_rows;
-  }
-  return output;
+exports.QueryBuilder = QueryBuilder;
+_QueryBuilder_dbName = new WeakMap(), _QueryBuilder_index = new WeakMap(), _QueryBuilder_query = new WeakMap(), _QueryBuilder_limit = new WeakMap(), _QueryBuilder_sort = new WeakMap(), _QueryBuilder_bookmark = new WeakMap(), _QueryBuilder_sortOrder = new WeakMap(), _QueryBuilder_sortType = new WeakMap(), _QueryBuilder_includeDocs = new WeakMap(), _QueryBuilder_version = new WeakMap(), _QueryBuilder_indexBuilder = new WeakMap(), _QueryBuilder_noEscaping = new WeakMap(), _QueryBuilder_skip = new WeakMap(), _QueryBuilder_instances = new WeakSet(), _QueryBuilder_skipItems = function _QueryBuilder_skipItems(skip) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Lucene does not support pagination.
+        // Handle pagination by finding the right bookmark
+        const prevIncludeDocs = __classPrivateFieldGet(this, _QueryBuilder_includeDocs, "f");
+        const prevLimit = __classPrivateFieldGet(this, _QueryBuilder_limit, "f");
+        this.excludeDocs();
+        let skipRemaining = skip;
+        let iterationFetched = 0;
+        do {
+            const toSkip = Math.min(QueryBuilder.maxLimit, skipRemaining);
+            this.setLimit(toSkip);
+            const { bookmark, rows } = yield __classPrivateFieldGet(this, _QueryBuilder_instances, "m", _QueryBuilder_execute).call(this);
+            this.setBookmark(bookmark);
+            iterationFetched = rows.length;
+            skipRemaining -= rows.length;
+        } while (skipRemaining > 0 && iterationFetched > 0);
+        __classPrivateFieldSet(this, _QueryBuilder_includeDocs, prevIncludeDocs, "f");
+        __classPrivateFieldSet(this, _QueryBuilder_limit, prevLimit, "f");
+    });
+}, _QueryBuilder_execute = function _QueryBuilder_execute() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { url, cookie } = (0, couch_1.getCouchInfo)();
+        const fullPath = `${url}/${__classPrivateFieldGet(this, _QueryBuilder_dbName, "f")}/_design/database/_search/${__classPrivateFieldGet(this, _QueryBuilder_index, "f")}`;
+        const body = this.buildSearchBody();
+        try {
+            return yield runQuery(fullPath, body, cookie);
+        }
+        catch (err) {
+            if (err.status === 404 && __classPrivateFieldGet(this, _QueryBuilder_indexBuilder, "f")) {
+                yield __classPrivateFieldGet(this, _QueryBuilder_indexBuilder, "f").call(this);
+                return yield runQuery(fullPath, body, cookie);
+            }
+            else {
+                throw err;
+            }
+        }
+    });
+};
+QueryBuilder.maxLimit = 200;
+/**
+ * Executes a lucene search query.
+ * @param url The query URL
+ * @param body The request body defining search criteria
+ * @param cookie The auth cookie for CouchDB
+ * @returns {Promise<{rows: []}>}
+ */
+function runQuery(url, body, cookie) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield (0, node_fetch_1.default)(url, {
+            body: JSON.stringify(body),
+            method: "POST",
+            headers: {
+                Authorization: cookie,
+            },
+        });
+        if (response.status === 404) {
+            throw response;
+        }
+        const json = yield response.json();
+        let output = {
+            rows: [],
+            totalRows: 0,
+        };
+        if (json.rows != null && json.rows.length > 0) {
+            output.rows = json.rows.map((row) => row.doc);
+        }
+        if (json.bookmark) {
+            output.bookmark = json.bookmark;
+        }
+        if (json.total_rows) {
+            output.totalRows = json.total_rows;
+        }
+        return output;
+    });
 }
-async function recursiveSearch(dbName, index, query, params) {
-  const bookmark = params.bookmark;
-  const rows = params.rows || [];
-  if (rows.length >= params.limit) {
-    return rows;
-  }
-  let pageSize = QueryBuilder.maxLimit;
-  if (rows.length > params.limit - QueryBuilder.maxLimit) {
-    pageSize = params.limit - rows.length;
-  }
-  const page = await new QueryBuilder(dbName, index, query).setVersion(params.version).setTable(params.tableId).setBookmark(bookmark).setLimit(pageSize).setSort(params.sort).setSortOrder(params.sortOrder).setSortType(params.sortType).run();
-  if (!page.rows.length) {
-    return rows;
-  }
-  if (page.rows.length < QueryBuilder.maxLimit) {
-    return [...rows, ...page.rows];
-  }
-  const newParams = {
-    ...params,
-    bookmark: page.bookmark,
-    rows: [...rows, ...page.rows]
-  };
-  return await recursiveSearch(dbName, index, query, newParams);
+/**
+ * Gets round the fixed limit of 200 results from a query by fetching as many
+ * pages as required and concatenating the results. This recursively operates
+ * until enough results have been found.
+ * @param dbName {string} Which database to run a lucene query on
+ * @param index {string} Which search index to utilise
+ * @param query {object} The JSON query structure
+ * @param params {object} The search params including:
+ *   tableId {string} The table ID to search
+ *   sort {string} The sort column
+ *   sortOrder {string} The sort order ("ascending" or "descending")
+ *   sortType {string} Whether to treat sortable values as strings or
+ *     numbers. ("string" or "number")
+ *   limit {number} The number of results to fetch
+ *   bookmark {string|null} Current bookmark in the recursive search
+ *   rows {array|null} Current results in the recursive search
+ * @returns {Promise<*[]|*>}
+ */
+function recursiveSearch(dbName, index, query, params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const bookmark = params.bookmark;
+        const rows = params.rows || [];
+        if (rows.length >= params.limit) {
+            return rows;
+        }
+        let pageSize = QueryBuilder.maxLimit;
+        if (rows.length > params.limit - QueryBuilder.maxLimit) {
+            pageSize = params.limit - rows.length;
+        }
+        const page = yield new QueryBuilder(dbName, index, query)
+            .setVersion(params.version)
+            .setTable(params.tableId)
+            .setBookmark(bookmark)
+            .setLimit(pageSize)
+            .setSort(params.sort)
+            .setSortOrder(params.sortOrder)
+            .setSortType(params.sortType)
+            .run();
+        if (!page.rows.length) {
+            return rows;
+        }
+        if (page.rows.length < QueryBuilder.maxLimit) {
+            return [...rows, ...page.rows];
+        }
+        const newParams = Object.assign(Object.assign({}, params), { bookmark: page.bookmark, rows: [...rows, ...page.rows] });
+        return yield recursiveSearch(dbName, index, query, newParams);
+    });
 }
-async function paginatedSearch(dbName, index, query, params) {
-  let limit = params.limit;
-  if (limit == null || isNaN(limit) || limit < 0) {
-    limit = 50;
-  }
-  limit = Math.min(limit, QueryBuilder.maxLimit);
-  const search = new QueryBuilder(dbName, index, query);
-  if (params.version) {
-    search.setVersion(params.version);
-  }
-  if (params.tableId) {
-    search.setTable(params.tableId);
-  }
-  if (params.sort) {
-    search.setSort(params.sort).setSortOrder(params.sortOrder).setSortType(params.sortType);
-  }
-  if (params.indexer) {
-    search.setIndexBuilder(params.indexer);
-  }
-  if (params.disableEscaping) {
-    search.disableEscaping();
-  }
-  const searchResults = await search.setBookmark(params.bookmark).setLimit(limit).run();
-  search.setBookmark(searchResults.bookmark).setLimit(1);
-  if (params.tableId) {
-    search.setTable(params.tableId);
-  }
-  const nextResults = await search.run();
-  return {
-    ...searchResults,
-    hasNextPage: nextResults.rows && nextResults.rows.length > 0
-  };
+/**
+ * Performs a paginated search. A bookmark will be returned to allow the next
+ * page to be fetched. There is a max limit off 200 results per page in a
+ * paginated search.
+ * @param dbName {string} Which database to run a lucene query on
+ * @param index {string} Which search index to utilise
+ * @param query {object} The JSON query structure
+ * @param params {object} The search params including:
+ *   tableId {string} The table ID to search
+ *   sort {string} The sort column
+ *   sortOrder {string} The sort order ("ascending" or "descending")
+ *   sortType {string} Whether to treat sortable values as strings or
+ *     numbers. ("string" or "number")
+ *   limit {number} The desired page size
+ *   bookmark {string} The bookmark to resume from
+ * @returns {Promise<{hasNextPage: boolean, rows: *[]}>}
+ */
+function paginatedSearch(dbName, index, query, params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let limit = params.limit;
+        if (limit == null || isNaN(limit) || limit < 0) {
+            limit = 50;
+        }
+        limit = Math.min(limit, QueryBuilder.maxLimit);
+        const search = new QueryBuilder(dbName, index, query);
+        if (params.version) {
+            search.setVersion(params.version);
+        }
+        if (params.tableId) {
+            search.setTable(params.tableId);
+        }
+        if (params.sort) {
+            search
+                .setSort(params.sort)
+                .setSortOrder(params.sortOrder)
+                .setSortType(params.sortType);
+        }
+        if (params.indexer) {
+            search.setIndexBuilder(params.indexer);
+        }
+        if (params.disableEscaping) {
+            search.disableEscaping();
+        }
+        const searchResults = yield search
+            .setBookmark(params.bookmark)
+            .setLimit(limit)
+            .run();
+        // Try fetching 1 row in the next page to see if another page of results
+        // exists or not
+        search.setBookmark(searchResults.bookmark).setLimit(1);
+        if (params.tableId) {
+            search.setTable(params.tableId);
+        }
+        const nextResults = yield search.run();
+        return Object.assign(Object.assign({}, searchResults), { hasNextPage: nextResults.rows && nextResults.rows.length > 0 });
+    });
 }
-async function fullSearch(dbName, index, query, params) {
-  let limit = params.limit;
-  if (limit == null || isNaN(limit) || limit < 0) {
-    limit = 1e3;
-  }
-  params.limit = Math.min(limit, 1e3);
-  const rows = await recursiveSearch(dbName, index, query, params);
-  return { rows };
+exports.paginatedSearch = paginatedSearch;
+/**
+ * Performs a full search, fetching multiple pages if required to return the
+ * desired amount of results. There is a limit of 1000 results to avoid
+ * heavy performance hits, and to avoid client components breaking from
+ * handling too much data.
+ * @param dbName {string} Which database to run a lucene query on
+ * @param index {string} Which search index to utilise
+ * @param query {object} The JSON query structure
+ * @param params {object} The search params including:
+ *   tableId {string} The table ID to search
+ *   sort {string} The sort column
+ *   sortOrder {string} The sort order ("ascending" or "descending")
+ *   sortType {string} Whether to treat sortable values as strings or
+ *     numbers. ("string" or "number")
+ *   limit {number} The desired number of results
+ * @returns {Promise<{rows: *}>}
+ */
+function fullSearch(dbName, index, query, params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let limit = params.limit;
+        if (limit == null || isNaN(limit) || limit < 0) {
+            limit = 1000;
+        }
+        params.limit = Math.min(limit, 1000);
+        const rows = yield recursiveSearch(dbName, index, query, params);
+        return { rows };
+    });
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  QueryBuilder,
-  fullSearch,
-  paginatedSearch,
-  removeKeyNumbering
-});
-//# sourceMappingURL=lucene.js.map
+exports.fullSearch = fullSearch;
+//# sourceMappingURL=lucene.js.map