@budibase/backend-core 2.23.6 → 2.23.9

package/dist/index.js

@@ -54720,6 +54720,35 @@ var Header = /* @__PURE__ */ ((Header2) => {
   return Header2;
 })(Header || {});
 
+// ../shared-core/src/constants/fields.ts
+var SWITCHABLE_TYPES = {
+  ["string" /* STRING */]: [
+    "string" /* STRING */,
+    "options" /* OPTIONS */,
+    "longform" /* LONGFORM */,
+    "barcodeqr" /* BARCODEQR */
+  ],
+  ["options" /* OPTIONS */]: [
+    "options" /* OPTIONS */,
+    "string" /* STRING */,
+    "longform" /* LONGFORM */,
+    "barcodeqr" /* BARCODEQR */
+  ],
+  ["longform" /* LONGFORM */]: [
+    "longform" /* LONGFORM */,
+    "string" /* STRING */,
+    "options" /* OPTIONS */,
+    "barcodeqr" /* BARCODEQR */
+  ],
+  ["barcodeqr" /* BARCODEQR */]: [
+    "barcodeqr" /* BARCODEQR */,
+    "string" /* STRING */,
+    "options" /* OPTIONS */,
+    "longform" /* LONGFORM */
+  ],
+  ["number" /* NUMBER */]: ["number" /* NUMBER */, "boolean" /* BOOLEAN */]
+};
+
 // ../shared-core/src/constants/index.ts
 var OperatorOptions = {
   Equals: {
@@ -54771,14 +54800,108 @@ var OperatorOptions = {
     label: "Has any"
   }
 };
+var SqlNumberTypeRangeMap = {
+  integer: {
+    max: 2147483647,
+    min: -2147483648
+  },
+  int: {
+    max: 2147483647,
+    min: -2147483648
+  },
+  smallint: {
+    max: 32767,
+    min: -32768
+  },
+  mediumint: {
+    max: 8388607,
+    min: -8388608
+  }
+};
 
 // ../shared-core/src/filters.ts
+var filters_exports = {};
+__export(filters_exports, {
+  NoEmptyFilterStrings: () => NoEmptyFilterStrings,
+  buildLuceneQuery: () => buildLuceneQuery,
+  getValidOperatorsForType: () => getValidOperatorsForType,
+  hasFilters: () => hasFilters,
+  luceneLimit: () => luceneLimit,
+  luceneSort: () => luceneSort,
+  removeKeyNumbering: () => removeKeyNumbering,
+  runLuceneQuery: () => runLuceneQuery
+});
 var import_dayjs = __toESM(require_dayjs_min());
 
+// ../shared-core/src/helpers/helpers.ts
+var deepGet = (obj, key) => {
+  if (!obj || !key) {
+    return null;
+  }
+  if (Object.prototype.hasOwnProperty.call(obj, key)) {
+    return obj[key];
+  }
+  const split = key.split(".");
+  for (let i = 0; i < split.length; i++) {
+    obj = obj?.[split[i]];
+  }
+  return obj;
+};
+
 // ../shared-core/src/helpers/cron.ts
 var import_cron_validate = __toESM(require_lib2());
 
 // ../shared-core/src/filters.ts
+var HBS_REGEX = /{{([^{].*?)}}/g;
+var getValidOperatorsForType = (fieldType, field, datasource2) => {
+  const Op = OperatorOptions;
+  const stringOps = [
+    Op.Equals,
+    Op.NotEquals,
+    Op.StartsWith,
+    Op.Like,
+    Op.Empty,
+    Op.NotEmpty,
+    Op.In
+  ];
+  const numOps = [
+    Op.Equals,
+    Op.NotEquals,
+    Op.MoreThan,
+    Op.LessThan,
+    Op.Empty,
+    Op.NotEmpty,
+    Op.In
+  ];
+  let ops = [];
+  const { type, subtype, formulaType } = fieldType;
+  if (type === "string" /* STRING */) {
+    ops = stringOps;
+  } else if (type === "number" /* NUMBER */ || type === "bigint" /* BIGINT */) {
+    ops = numOps;
+  } else if (type === "options" /* OPTIONS */) {
+    ops = [Op.Equals, Op.NotEquals, Op.Empty, Op.NotEmpty, Op.In];
+  } else if (type === "array" /* ARRAY */) {
+    ops = [Op.Contains, Op.NotContains, Op.Empty, Op.NotEmpty, Op.ContainsAny];
+  } else if (type === "boolean" /* BOOLEAN */) {
+    ops = [Op.Equals, Op.NotEquals, Op.Empty, Op.NotEmpty];
+  } else if (type === "longform" /* LONGFORM */) {
+    ops = stringOps;
+  } else if (type === "datetime" /* DATETIME */) {
+    ops = numOps;
+  } else if (type === "formula" /* FORMULA */ && formulaType === "static" /* STATIC */) {
+    ops = stringOps.concat([Op.MoreThan, Op.LessThan]);
+  } else if (type === "bb_reference" /* BB_REFERENCE */ && subtype == "user" /* USER */) {
+    ops = [Op.Equals, Op.NotEquals, Op.Empty, Op.NotEmpty, Op.In];
+  } else if (type === "bb_reference" /* BB_REFERENCE */ && subtype == "users" /* USERS */) {
+    ops = [Op.Contains, Op.NotContains, Op.ContainsAny, Op.Empty, Op.NotEmpty];
+  }
+  const externalTable = datasource2?.tableId?.includes("datasource_plus");
+  if (field === "_id" && externalTable) {
+    ops = [Op.Equals, Op.NotEquals, Op.In];
+  }
+  return ops;
+};
 var NoEmptyFilterStrings = [
   OperatorOptions.StartsWith.value,
   OperatorOptions.Like.value,
@@ -54787,6 +54910,289 @@ var NoEmptyFilterStrings = [
   OperatorOptions.Contains.value,
   OperatorOptions.NotContains.value
 ];
+var cleanupQuery = (query) => {
+  if (!query) {
+    return query;
+  }
+  for (let filterField of NoEmptyFilterStrings) {
+    const operator = filterField;
+    if (!query[operator]) {
+      continue;
+    }
+    for (let [key, value] of Object.entries(query[operator])) {
+      if (value == null || value === "") {
+        delete query[operator][key];
+      }
+    }
+  }
+  return query;
+};
+var removeKeyNumbering = (key) => {
+  if (typeof key === "string" && key.match(/\d[0-9]*:/g) != null) {
+    const parts = key.split(":");
+    parts.shift();
+    return parts.join(":");
+  } else {
+    return key;
+  }
+};
+var buildLuceneQuery = (filter) => {
+  let query = {
+    string: {},
+    fuzzy: {},
+    range: {},
+    equal: {},
+    notEqual: {},
+    empty: {},
+    notEmpty: {},
+    contains: {},
+    notContains: {},
+    oneOf: {},
+    containsAny: {}
+  };
+  if (!Array.isArray(filter)) {
+    return query;
+  }
+  filter.forEach((expression) => {
+    let { operator, field, type, value, externalType, onEmptyFilter } = expression;
+    const queryOperator = operator;
+    const isHbs = typeof value === "string" && (value.match(HBS_REGEX) || []).length > 0;
+    if (operator === "allOr") {
+      query.allOr = true;
+      return;
+    }
+    if (onEmptyFilter) {
+      query.onEmptyFilter = onEmptyFilter;
+      return;
+    }
+    if (type === "datetime" && !isHbs && queryOperator !== "empty" && queryOperator !== "notEmpty") {
+      if (!value) {
+        return;
+      }
+      try {
+        value = new Date(value).toISOString();
+      } catch (error) {
+        return;
+      }
+    }
+    if (type === "number" && typeof value === "string" && !isHbs) {
+      if (queryOperator === "oneOf") {
+        value = value.split(",").map((item) => parseFloat(item));
+      } else {
+        value = parseFloat(value);
+      }
+    }
+    if (type === "boolean") {
+      value = `${value}`?.toLowerCase() === "true";
+    }
+    if (["contains", "notContains", "containsAny"].includes(operator) && type === "array" && typeof value === "string") {
+      value = value.split(",");
+    }
+    if (operator.startsWith("range") && query.range) {
+      const minint = SqlNumberTypeRangeMap[externalType]?.min || Number.MIN_SAFE_INTEGER;
+      const maxint = SqlNumberTypeRangeMap[externalType]?.max || Number.MAX_SAFE_INTEGER;
+      if (!query.range[field]) {
+        query.range[field] = {
+          low: type === "number" ? minint : "0000-00-00T00:00:00.000Z",
+          high: type === "number" ? maxint : "9999-00-00T00:00:00.000Z"
+        };
+      }
+      if (operator === "rangeLow" && value != null && value !== "") {
+        query.range[field] = {
+          ...query.range[field],
+          low: value
+        };
+      } else if (operator === "rangeHigh" && value != null && value !== "") {
+        query.range[field] = {
+          ...query.range[field],
+          high: value
+        };
+      }
+    } else if (query[queryOperator] && operator !== "onEmptyFilter") {
+      if (type === "boolean") {
+        if (queryOperator === "equal" && value === false) {
+          query.notEqual = query.notEqual || {};
+          query.notEqual[field] = true;
+        } else if (queryOperator === "notEqual" && value === false) {
+          query.equal = query.equal || {};
+          query.equal[field] = true;
+        } else {
+          query[queryOperator] = query[queryOperator] || {};
+          query[queryOperator][field] = value;
+        }
+      } else {
+        query[queryOperator] = query[queryOperator] || {};
+        query[queryOperator][field] = value;
+      }
+    }
+  });
+  return query;
+};
+var runLuceneQuery = (docs, query) => {
+  if (!docs || !Array.isArray(docs)) {
+    return [];
+  }
+  if (!query) {
+    return docs;
+  }
+  query = cleanupQuery(query);
+  const match = (type, failFn) => (doc) => {
+    const filters = Object.entries(query[type] || {});
+    for (let i = 0; i < filters.length; i++) {
+      const [key, testValue] = filters[i];
+      const docValue = deepGet(doc, removeKeyNumbering(key));
+      if (failFn(docValue, testValue)) {
+        return false;
+      }
+    }
+    return true;
+  };
+  const stringMatch = match(
+    "string" /* STRING */,
+    (docValue, testValue) => {
+      return !docValue || !docValue?.toLowerCase().startsWith(testValue?.toLowerCase());
+    }
+  );
+  const fuzzyMatch = match(
+    "fuzzy" /* FUZZY */,
+    (docValue, testValue) => {
+      return !docValue || !docValue?.toLowerCase().startsWith(testValue?.toLowerCase());
+    }
+  );
+  const rangeMatch = match(
+    "range" /* RANGE */,
+    (docValue, testValue) => {
+      if (docValue == null || docValue === "") {
+        return true;
+      }
+      if (!isNaN(+docValue)) {
+        return +docValue < testValue.low || +docValue > testValue.high;
+      }
+      if ((0, import_dayjs.default)(docValue).isValid()) {
+        return new Date(docValue).getTime() < new Date(testValue.low).getTime() || new Date(docValue).getTime() > new Date(testValue.high).getTime();
+      }
+      return false;
+    }
+  );
+  const equalMatch = match(
+    "equal" /* EQUAL */,
+    (docValue, testValue) => {
+      return testValue != null && testValue !== "" && docValue !== testValue;
+    }
+  );
+  const notEqualMatch = match(
+    "notEqual" /* NOT_EQUAL */,
+    (docValue, testValue) => {
+      return testValue != null && testValue !== "" && docValue === testValue;
+    }
+  );
+  const emptyMatch = match(
+    "empty" /* EMPTY */,
+    (docValue) => {
+      return docValue != null && docValue !== "";
+    }
+  );
+  const notEmptyMatch = match(
+    "notEmpty" /* NOT_EMPTY */,
+    (docValue) => {
+      return docValue == null || docValue === "";
+    }
+  );
+  const oneOf = match(
+    "oneOf" /* ONE_OF */,
+    (docValue, testValue) => {
+      if (typeof testValue === "string") {
+        testValue = testValue.split(",");
+        if (typeof docValue === "number") {
+          testValue = testValue.map((item) => parseFloat(item));
+        }
+      }
+      return !testValue?.includes(docValue);
+    }
+  );
+  const containsAny = match(
+    "containsAny" /* CONTAINS_ANY */,
+    (docValue, testValue) => {
+      return !docValue?.includes(...testValue);
+    }
+  );
+  const contains = match(
+    "contains" /* CONTAINS */,
+    (docValue, testValue) => {
+      return !testValue?.every((item) => docValue?.includes(item));
+    }
+  );
+  const notContains = match(
+    "notContains" /* NOT_CONTAINS */,
+    (docValue, testValue) => {
+      return testValue?.every((item) => docValue?.includes(item));
+    }
+  );
+  const docMatch = (doc) => {
+    const filterFunctions = {
+      string: stringMatch,
+      fuzzy: fuzzyMatch,
+      range: rangeMatch,
+      equal: equalMatch,
+      notEqual: notEqualMatch,
+      empty: emptyMatch,
+      notEmpty: notEmptyMatch,
+      oneOf,
+      contains,
+      containsAny,
+      notContains
+    };
+    const activeFilterKeys = Object.entries(query || {}).filter(
+      ([key, value]) => !["allOr", "onEmptyFilter"].includes(key) && value && Object.keys(value).length > 0
+    ).map(([key]) => key);
+    const results = activeFilterKeys.map((filterKey) => {
+      return filterFunctions[filterKey]?.(doc) ?? false;
+    });
+    if (query.allOr) {
+      return results.some((result) => result === true);
+    } else {
+      return results.every((result) => result === true);
+    }
+  };
+  return docs.filter(docMatch);
+};
+var luceneSort = (docs, sort, sortOrder, sortType = "string" /* STRING */) => {
+  if (!sort || !sortOrder || !sortType) {
+    return docs;
+  }
+  const parse = sortType === "string" ? (x) => `${x}` : (x) => parseFloat(x);
+  return docs.slice().sort((a, b) => {
+    const colA = parse(a[sort]);
+    const colB = parse(b[sort]);
+    if (sortOrder.toLowerCase() === "descending") {
+      return colA > colB ? -1 : 1;
+    } else {
+      return colA > colB ? 1 : -1;
+    }
+  });
+};
+var luceneLimit = (docs, limit) => {
+  const numLimit = parseFloat(limit);
+  if (isNaN(numLimit)) {
+    return docs;
+  }
+  return docs.slice(0, numLimit);
+};
+var hasFilters = (query) => {
+  if (!query) {
+    return false;
+  }
+  const skipped = ["allOr", "onEmptyFilter"];
+  for (let [key, value] of Object.entries(query)) {
+    if (skipped.includes(key) || typeof value !== "object") {
+      continue;
+    }
+    if (Object.keys(value || {}).length !== 0) {
+      return true;
+    }
+  }
+  return false;
+};
 
 // ../shared-core/src/utils.ts
 var utils_exports = {};
@@ -56602,7 +57008,7 @@ __export(db_exports, {
   queryPlatformView: () => queryPlatformView,
   queryView: () => queryView,
   queryViewRaw: () => queryViewRaw,
-  removeKeyNumbering: () => removeKeyNumbering,
+  removeKeyNumbering: () => removeKeyNumbering2,
   searchIndexes: () => searchIndexes_exports
 });
 
@@ -57191,16 +57597,7 @@ var Replication_default = Replication;
 
 // src/db/lucene.ts
 var import_node_fetch2 = __toESM(require("node-fetch"));
-var 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;
-  }
-}
+var removeKeyNumbering2 = filters_exports.removeKeyNumbering;
 var QueryBuilder = class _QueryBuilder {
   #dbName;
   #index;
@@ -57395,7 +57792,7 @@ var QueryBuilder = class _QueryBuilder {
   compressFilters(filters) {
     const compressed = {};
     for (let key of Object.keys(filters)) {
-      const finalKey = removeKeyNumbering(key);
+      const finalKey = removeKeyNumbering2(key);
       if (compressed[finalKey]) {
         compressed[finalKey] = compressed[finalKey].concat(filters[key]);
       } else {
@@ -57483,7 +57880,7 @@ var QueryBuilder = class _QueryBuilder {
     function build(structure, queryFn, opts) {
       let built = "";
       for (let [key, value] of Object.entries(structure)) {
-        key = removeKeyNumbering(key);
+        key = removeKeyNumbering2(key);
         key = builder.preprocess(builder.handleSpaces(key), {
           escape: true
         });
@@ -60998,7 +61395,6 @@ var InMemoryQueue = class {
    * a JSON message as this is required by Bull.
    * @param repeat serves no purpose for the import queue.
    */
-  // eslint-disable-next-line no-unused-vars
   async add(data, opts) {
     const jobId = opts?.jobId?.toString();
     if (jobId && this._queuedJobIds.has(jobId)) {
@@ -61042,8 +61438,7 @@ var InMemoryQueue = class {
   async getRepeatableJobs() {
     return [];
   }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  async removeJobs(pattern) {
+  async removeJobs(_pattern) {
   }
   /**
    * Implemented for tests
@@ -63669,7 +64064,9 @@ var UserDB = class _UserDB {
       admin: {
         global: true
       },
-      tenantId
+      tenantId,
+      firstName: opts?.firstName,
+      lastName: opts?.lastName
     };
     if (opts?.ssoId) {
       user.ssoId = opts.ssoId;