@budibase/frontend-core 1.0.219 → 1.0.220-alpha.0

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@budibase/frontend-core",
-  "version": "1.0.219",
+  "version": "1.0.220-alpha.0",
   "description": "Budibase frontend core libraries used in builder and client",
   "author": "Budibase",
   "license": "MPL-2.0",
   "svelte": "src/index.js",
   "dependencies": {
-    "@budibase/bbui": "^1.0.219",
+    "@budibase/bbui": "^1.0.220-alpha.0",
     "lodash": "^4.17.21",
     "svelte": "^3.46.2"
   },
-  "gitHead": "231b038a3c99f730dd27a595f870663dd84b7837"
+  "gitHead": "00cefe45cc19f1151ad2a4590d6a5aed0afa0ea7"
 }

package/src/api/automations.js

@@ -73,4 +73,39 @@ export const buildAutomationEndpoints = API => ({
       url: `/api/automations/${automationId}/${automationRev}`,
     })
   },
+
+  /**
+   * Get the logs for the app, or by automation ID.
+   * @param automationId The ID of the automation to get logs for.
+   * @param startDate An ISO date string to state the start of the date range.
+   * @param status The status, error or success.
+   * @param page The page to retrieve.
+   */
+  getAutomationLogs: async ({ automationId, startDate, status, page }) => {
+    return await API.post({
+      url: "/api/automations/logs/search",
+      body: {
+        automationId,
+        startDate,
+        status,
+        page,
+      },
+    })
+  },
+
+  /**
+   * Clears automation log errors (which are creating notification) for
+   * automation or the app.
+   * @param automationId optional - the ID of the automation to clear errors for.
+   * @param appId The app ID to clear errors for.
+   */
+  clearAutomationLogErrors: async ({ automationId, appId }) => {
+    return await API.delete({
+      url: "/api/automations/logs",
+      body: {
+        appId,
+        automationId,
+      },
+    })
+  },
 })

package/src/api/other.js

@@ -61,6 +61,7 @@ export const buildOtherEndpoints = API => ({
   checkBetaAccess: async email => {
     return await API.get({
       url: `/api/beta/access?email=${email}`,
+      external: true,
     })
   },
 })

package/src/api/rows.js

@@ -65,12 +65,15 @@ export const buildRowEndpoints = API => ({
    * Exports rows.
    * @param tableId the table ID to export the rows from
    * @param rows the array of rows to export
+   * @param format the format to export (csv or json)
+   * @param columns which columns to export (all if undefined)
    */
-  exportRows: async ({ tableId, rows, format }) => {
+  exportRows: async ({ tableId, rows, format, columns }) => {
     return await API.post({
       url: `/api/${tableId}/rows/exportRows?format=${format}`,
       body: {
         rows,
+        columns,
       },
       parseResponse: async response => {
         return await response.text()

package/src/api/user.js

@@ -8,6 +8,34 @@ export const buildUserEndpoints = API => ({
     })
   },
 
+  /**
+   * Gets a list of users in the current tenant.
+   * @param {string} page The page to retrieve
+   * @param {string} search The starts with string to search username/email by.
+   */
+  searchUsers: async ({ page, search } = {}) => {
+    const opts = {}
+    if (page) {
+      opts.page = page
+    }
+    if (search) {
+      opts.search = search
+    }
+    return await API.post({
+      url: `/api/global/users/search`,
+      body: opts,
+    })
+  },
+
+  /**
+   * Get a single user by ID.
+   */
+  getUser: async userId => {
+    return await API.get({
+      url: `/api/global/users/${userId}`,
+    })
+  },
+
   /**
    * Creates a user for an app.
    * @param user the user to create

package/src/constants.js

@@ -42,6 +42,10 @@ export const OperatorOptions = {
     value: "notEqual",
     label: "Does Not Contain",
   },
+  In: {
+    value: "oneOf",
+    label: "Is in",
+  },
 }
 
 // Cookie names
@@ -63,3 +67,25 @@ export const TableNames = {
  *   - Coerce types for search endpoint
  */
 export const ApiVersion = "1"
+
+/**
+ * Maximum minimum range for SQL number values
+ */
+export const SqlNumberTypeRangeMap = {
+  integer: {
+    max: 2147483647,
+    min: -2147483648,
+  },
+  int: {
+    max: 2147483647,
+    min: -2147483648,
+  },
+  smallint: {
+    max: 32767,
+    min: -32768,
+  },
+  mediumint: {
+    max: 8388607,
+    min: -8388608,
+  },
+}

package/src/utils/lucene.js

@@ -1,5 +1,5 @@
 import { Helpers } from "@budibase/bbui"
-import { OperatorOptions } from "../constants"
+import { OperatorOptions, SqlNumberTypeRangeMap } from "../constants"
 
 /**
  * Returns the valid operator options for a certain data type
@@ -14,6 +14,7 @@ export const getValidOperatorsForType = type => {
     Op.Like,
     Op.Empty,
     Op.NotEmpty,
+    Op.In,
   ]
   const numOps = [
     Op.Equals,
@@ -22,6 +23,7 @@ export const getValidOperatorsForType = type => {
     Op.LessThan,
     Op.Empty,
     Op.NotEmpty,
+    Op.In,
   ]
   if (type === "string") {
     return stringOps
@@ -91,31 +93,34 @@ export const buildLuceneQuery = filter => {
     notEmpty: {},
     contains: {},
     notContains: {},
+    oneOf: {},
   }
   if (Array.isArray(filter)) {
     filter.forEach(expression => {
-      let { operator, field, type, value } = expression
+      let { operator, field, type, value, externalType } = expression
       // Parse all values into correct types
       if (type === "datetime" && value) {
         value = new Date(value).toISOString()
       }
-      if (type === "number") {
-        value = parseFloat(value)
+      if (type === "number" && !Array.isArray(value)) {
+        if (operator === "oneOf") {
+          value = value.split(",").map(item => parseFloat(item))
+        } else {
+          value = parseFloat(value)
+        }
       }
       if (type === "boolean") {
         value = `${value}`?.toLowerCase() === "true"
       }
       if (operator.startsWith("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"
-                ? Number.MIN_SAFE_INTEGER
-                : "0000-00-00T00:00:00.000Z",
-            high:
-              type === "number"
-                ? Number.MAX_SAFE_INTEGER
-                : "9999-00-00T00:00:00.000Z",
+            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 !== "") {
@@ -141,7 +146,6 @@ export const buildLuceneQuery = filter => {
       }
     })
   }
-
   return query
 }
 
@@ -213,6 +217,17 @@ export const runLuceneQuery = (docs, query) => {
     return docValue == null || docValue === ""
   })
 
+  // Process an includes match (fails if the value is not included)
+  const oneOf = match("oneOf", (docValue, testValue) => {
+    if (typeof testValue === "string") {
+      testValue = testValue.split(",")
+      if (typeof docValue === "number") {
+        testValue = testValue.map(item => parseFloat(item))
+      }
+    }
+    return !testValue?.includes(docValue)
+  })
+
   // Match a document against all criteria
   const docMatch = doc => {
     return (
@@ -222,7 +237,8 @@ export const runLuceneQuery = (docs, query) => {
       equalMatch(doc) &&
       notEqualMatch(doc) &&
       emptyMatch(doc) &&
-      notEmptyMatch(doc)
+      notEmptyMatch(doc) &&
+      oneOf(doc)
     )
   }