@budibase/shared-core 2.32.7 → 2.32.9

package/dist/helpers/index.d.ts

@@ -2,3 +2,4 @@ export * from "./helpers";
 export * from "./integrations";
 export * as cron from "./cron";
 export * as schema from "./schema";
+export * as views from "./views";

package/dist/helpers/schema.d.ts

@@ -6,3 +6,4 @@ export declare function isDeprecatedSingleUserColumn(schema: Pick<FieldSchema, "
 export declare function isRequired(constraints: FieldConstraints | undefined): boolean;
 export declare function encodeNonAscii(str: string): string;
 export declare function decodeNonAscii(str: string): string;
+export declare function isNumeric(field: FieldSchema): boolean;

package/dist/helpers/views.d.ts

@@ -0,0 +1,8 @@
+import { BasicViewFieldMetadata, ViewCalculationFieldMetadata, ViewFieldMetadata, ViewV2 } from "@budibase/types";
+export declare function isCalculationField(field: ViewFieldMetadata): field is ViewCalculationFieldMetadata;
+export declare function isBasicViewField(field: ViewFieldMetadata): field is BasicViewFieldMetadata;
+type UnsavedViewV2 = Omit<ViewV2, "id" | "version">;
+export declare function isCalculationView(view: UnsavedViewV2): boolean;
+export declare function calculationFields(view: UnsavedViewV2): import("lodash").Dictionary<ViewCalculationFieldMetadata>;
+export declare function basicFields(view: UnsavedViewV2): import("lodash").Dictionary<ViewFieldMetadata>;
+export {};

package/dist/index.js

@@ -4720,12 +4720,12 @@ var require_lodash = __commonJS({
           return result2;
         });
         function omitBy(object, predicate) {
-          return pickBy(object, negate(getIteratee(predicate)));
+          return pickBy2(object, negate(getIteratee(predicate)));
         }
         var pick = flatRest(function(object, paths) {
           return object == null ? {} : basePick(object, paths);
         });
-        function pickBy(object, predicate) {
+        function pickBy2(object, predicate) {
           if (object == null) {
             return {};
           }
@@ -5401,7 +5401,7 @@ var require_lodash = __commonJS({
         lodash.partialRight = partialRight;
         lodash.partition = partition;
         lodash.pick = pick;
-        lodash.pickBy = pickBy;
+        lodash.pickBy = pickBy2;
         lodash.property = property;
         lodash.propertyOf = propertyOf;
         lodash.pull = pull;
@@ -10453,6 +10453,7 @@ __export(helpers_exports, {
   isGoogleSheets: () => isGoogleSheets,
   isSQL: () => isSQL,
   schema: () => schema_exports,
+  views: () => views_exports,
   withTimeout: () => withTimeout
 });
 
@@ -10603,6 +10604,7 @@ __export(schema_exports, {
   decodeNonAscii: () => decodeNonAscii,
   encodeNonAscii: () => encodeNonAscii,
   isDeprecatedSingleUserColumn: () => isDeprecatedSingleUserColumn,
+  isNumeric: () => isNumeric,
   isRequired: () => isRequired
 });
 function isDeprecatedSingleUserColumn(schema) {
@@ -10624,9 +10626,38 @@ function decodeNonAscii(str) {
     (match, p1) => String.fromCharCode(parseInt(p1, 16))
   );
 }
+function isNumeric(field) {
+  return field.type === "number" /* NUMBER */ || field.type === "bigint" /* BIGINT */;
+}
 
-// src/filters.ts
+// src/helpers/views.ts
+var views_exports = {};
+__export(views_exports, {
+  basicFields: () => basicFields,
+  calculationFields: () => calculationFields,
+  isBasicViewField: () => isBasicViewField,
+  isCalculationField: () => isCalculationField,
+  isCalculationView: () => isCalculationView
+});
 var import_lodash = __toESM(require_lodash());
+function isCalculationField(field) {
+  return "calculationType" in field;
+}
+function isBasicViewField(field) {
+  return !isCalculationField(field);
+}
+function isCalculationView(view) {
+  return Object.values(view.schema || {}).some(isCalculationField);
+}
+function calculationFields(view) {
+  return (0, import_lodash.pickBy)(view.schema || {}, isCalculationField);
+}
+function basicFields(view) {
+  return (0, import_lodash.pickBy)(view.schema || {}, (field) => !isCalculationField(field));
+}
+
+// src/filters.ts
+var import_lodash2 = __toESM(require_lodash());
 var HBS_REGEX = /{{([^{].*?)}}/g;
 var LOGICAL_OPERATORS = Object.values(LogicalOperator);
 var SEARCH_OPERATORS = [
@@ -10695,7 +10726,7 @@ var NoEmptyFilterStrings = [
 ];
 function recurseLogicalOperators(filters, fn) {
   for (const logical of LOGICAL_OPERATORS) {
-    if (filters[logical]) {
+    if (filters?.[logical]) {
       filters[logical].conditions = filters[logical].conditions.map(
         (condition) => fn(condition)
       );
@@ -10904,7 +10935,7 @@ var buildQuery = (filter) => {
 function fixupFilterArrays(filters) {
   for (const searchField of Object.values(ArrayOperator)) {
     const field = filters[searchField];
-    if (field == null || !(0, import_lodash.isPlainObject)(field)) {
+    if (field == null || !(0, import_lodash2.isPlainObject)(field)) {
       continue;
     }
     for (const key of Object.keys(field)) {
@@ -10991,10 +11022,10 @@ function runQuery(docs, query) {
       if (docValue == null || docValue === "") {
         return false;
       }
-      if ((0, import_lodash.isPlainObject)(testValue.low) && (0, import_lodash.isEmpty)(testValue.low)) {
+      if ((0, import_lodash2.isPlainObject)(testValue.low) && (0, import_lodash2.isEmpty)(testValue.low)) {
         testValue.low = void 0;
       }
-      if ((0, import_lodash.isPlainObject)(testValue.high) && (0, import_lodash.isEmpty)(testValue.high)) {
+      if ((0, import_lodash2.isPlainObject)(testValue.high) && (0, import_lodash2.isEmpty)(testValue.high)) {
         testValue.high = void 0;
       }
       if (testValue.low == null && testValue.high == null) {
@@ -11246,6 +11277,7 @@ var utils_exports = {};
 __export(utils_exports, {
   filterValueToLabel: () => filterValueToLabel,
   hasSchema: () => hasSchema,
+  isSupportedUserSearch: () => isSupportedUserSearch,
   parallelForeach: () => parallelForeach,
   trimOtherProps: () => trimOtherProps,
   unreachable: () => unreachable
@@ -11301,6 +11333,29 @@ function trimOtherProps(object, allowedProps) {
   );
   return result;
 }
+function isSupportedUserSearch(query) {
+  const allowed = [
+    { op: "string" /* STRING */, key: "email" },
+    { op: "equal" /* EQUAL */, key: "_id" },
+    { op: "oneOf" /* ONE_OF */, key: "_id" }
+  ];
+  for (let [key, operation] of Object.entries(query)) {
+    if (typeof operation !== "object") {
+      return false;
+    }
+    const fields = Object.keys(operation || {});
+    if (fields.length === 0) {
+      continue;
+    }
+    const allowedOperation = allowed.find(
+      (allow) => allow.op === key && fields.length === 1 && fields[0] === allow.key
+    );
+    if (!allowedOperation) {
+      return false;
+    }
+  }
+  return true;
+}
 
 // src/sdk/index.ts
 var sdk_exports = {};