Merge branch 'master' into new-datepicker

package.json

@@ -56,6 +56,7 @@
     "dev:noserver": "yarn run kill-builder && lerna run --stream dev:stack:up --ignore @budibase/account-portal-server && lerna run --stream dev --ignore @budibase/backend-core --ignore @budibase/server --ignore @budibase/worker --ignore=@budibase/account-portal-ui --ignore @budibase/account-portal-server",
     "dev:server": "yarn run kill-server && lerna run --stream dev --scope @budibase/worker --scope @budibase/server",
     "dev:accountportal": "yarn kill-accountportal && lerna run dev --stream --scope @budibase/account-portal-ui --scope @budibase/account-portal-server",
+    "dev:camunda": "./scripts/deploy-camunda.sh",
     "dev:all": "yarn run kill-all && lerna run --stream dev",
     "dev:built": "yarn run kill-all && cd packages/server && yarn dev:stack:up && cd ../../ && lerna run --stream dev:built",
     "dev:docker": "yarn build --scope @budibase/server --scope @budibase/worker && docker-compose -f hosting/docker-compose.build.yaml -f hosting/docker-compose.dev.yaml --env-file hosting/.env up --build --scale proxy-service=0",

packages/bbui/src/Layout/Page.svelte

@@ -7,11 +7,11 @@
   export let narrower = false
   export let noPadding = false
 
-  let sidePanelVisible = false
+  let sidePanelVisble = false
 
   setContext("side-panel", {
-    open: () => (sidePanelVisible = true),
-    close: () => (sidePanelVisible = false),
+    open: () => (sidePanelVisble = true),
+    close: () => (sidePanelVisble = false),
   })
 </script>
 
@@ -24,9 +24,9 @@
   </div>
   <div
     id="side-panel"
-    class:visible={sidePanelVisible}
+    class:visible={sidePanelVisble}
     use:clickOutside={() => {
-      sidePanelVisible = false
+      sidePanelVisble = false
     }}
   >
     <slot name="side-panel" />

packages/client/manifest.json

@@ -6723,21 +6723,7 @@
     "illegalChildren": ["section", "sidepanel"],
     "showEmptyState": false,
     "draggable": false,
-    "info": "Side panels are hidden by default. They will only be revealed when triggered by the 'Open Side Panel' action.",
-    "sendEvents": true,
-    "settings": [
-      {
-        "type": "boolean",
-        "key": "clickOutsideToClose",
-        "label": "Click outside to close",
-        "defaultValue": true
-      },
-      {
-        "type": "event",
-        "key": "onSidePanelClose",
-        "label": "On side panel close"
-      }
-    ]
+    "info": "Side panels are hidden by default. They will only be revealed when triggered by the 'Open Side Panel' action."
   },
   "rowexplorer": {
     "block": true,

packages/client/src/components/app/Layout.svelte

@@ -73,10 +73,7 @@
     $context.device.width,
     $context.device.height
   )
-  $: autoCloseSidePanel =
-    !$builderStore.inBuilder &&
-    $sidePanelStore.open &&
-    $sidePanelStore.clickOutsideToClose
+  $: autoCloseSidePanel = !$builderStore.inBuilder && $sidePanelStore.open
   $: screenId = $builderStore.inBuilder
     ? `${$builderStore.screen?._id}-screen`
     : "screen"

packages/client/src/components/app/SidePanel.svelte

@@ -5,9 +5,6 @@
   const { styleable, sidePanelStore, builderStore, dndIsDragging } =
     getContext("sdk")
 
-  export let sidePanelClose
-  export let clickOutsideToClose
-
   // Automatically show and hide the side panel when inside the builder.
   // For some unknown reason, svelte reactivity breaks if we reference the
   // reactive variable "open" inside the following expression, or if we define
@@ -29,10 +26,6 @@
     }
   }
 
-  $: {
-    sidePanelStore.actions.setSidepanelState(clickOutsideToClose)
-  }
-
   // Derive visibility
   $: open = $sidePanelStore.contentId === $component.id
 
@@ -47,12 +40,6 @@
     }
   }
 
-  const handleSidePanelClose = async () => {
-    if (sidePanelClose) {
-      await sidePanelClose()
-    }
-  }
-
   const showInSidePanel = (el, visible) => {
     const update = visible => {
       const target = document.getElementById("side-panel-container")
@@ -64,7 +51,6 @@
       } else {
         if (target.contains(node)) {
           target.removeChild(node)
-          handleSidePanelClose()
         }
       }
     }

packages/client/src/stores/sidePanel.js

@@ -3,7 +3,6 @@ import { writable, derived } from "svelte/store"
 export const createSidePanelStore = () => {
   const initialState = {
     contentId: null,
-    clickOutsideToClose: true,
   }
   const store = writable(initialState)
   const derivedStore = derived(store, $store => {
@@ -33,19 +32,11 @@ export const createSidePanelStore = () => {
     }, 50)
   }
 
-  const setSidepanelState = bool => {
-    clearTimeout(timeout)
-    store.update(state => {
-      state.clickOutsideToClose = bool
-      return state
-    })
-  }
   return {
     subscribe: derivedStore.subscribe,
     actions: {
       open,
       close,
-      setSidepanelState,
     },
   }
 }

packages/server/src/api/controllers/application.ts

@@ -320,6 +320,7 @@ async function performAppCreate(ctx: UserCtx<CreateAppRequest, App>) {
         "theme",
         "customTheme",
         "icon",
+        "snippets",
       ]
       keys.forEach(key => {
         if (existing[key]) {

packages/server/src/api/routes/tests/search.spec.ts

@@ -227,6 +227,28 @@ describe.each([
         expectQuery({ fuzzy: { name: "none" } }).toFindNothing())
     })
 
+    describe("range", () => {
+      it("successfully finds multiple rows", () =>
+        expectQuery({
+          range: { name: { low: "a", high: "z" } },
+        }).toContainExactly([{ name: "bar" }, { name: "foo" }]))
+
+      it("successfully finds a row with a high bound", () =>
+        expectQuery({
+          range: { name: { low: "a", high: "c" } },
+        }).toContainExactly([{ name: "bar" }]))
+
+      it("successfully finds a row with a low bound", () =>
+        expectQuery({
+          range: { name: { low: "f", high: "z" } },
+        }).toContainExactly([{ name: "foo" }]))
+
+      it("successfully finds no rows", () =>
+        expectQuery({
+          range: { name: { low: "g", high: "h" } },
+        }).toFindNothing())
+    })
+
     describe("sort", () => {
       it("sorts ascending", () =>
         expectSearch({
@@ -309,6 +331,11 @@ describe.each([
         expectQuery({
           range: { age: { low: 5, high: 10 } },
         }).toContainExactly([{ age: 10 }]))
+
+      it("successfully finds no rows", () =>
+        expectQuery({
+          range: { age: { low: 5, high: 9 } },
+        }).toFindNothing())
     })
 
     describe("sort", () => {
@@ -350,6 +377,7 @@ describe.each([
     const JAN_1ST = "2020-01-01T00:00:00.000Z"
     const JAN_2ND = "2020-01-02T00:00:00.000Z"
     const JAN_5TH = "2020-01-05T00:00:00.000Z"
+    const JAN_9TH = "2020-01-09T00:00:00.000Z"
     const JAN_10TH = "2020-01-10T00:00:00.000Z"
 
     beforeAll(async () => {
@@ -407,6 +435,11 @@ describe.each([
         expectQuery({
           range: { dob: { low: JAN_5TH, high: JAN_10TH } },
         }).toContainExactly([{ dob: JAN_10TH }]))
+
+      it("successfully finds no rows", () =>
+        expectQuery({
+          range: { dob: { low: JAN_5TH, high: JAN_9TH } },
+        }).toFindNothing())
     })
 
     describe("sort", () => {
@@ -443,4 +476,78 @@ describe.each([
       })
     })
   })
+
+  describe("array of strings", () => {
+    beforeAll(async () => {
+      await createTable({
+        numbers: {
+          name: "numbers",
+          type: FieldType.ARRAY,
+          constraints: { inclusion: ["one", "two", "three"] },
+        },
+      })
+      await createRows([{ numbers: ["one", "two"] }, { numbers: ["three"] }])
+    })
+
+    describe("contains", () => {
+      it("successfully finds a row", () =>
+        expectQuery({ contains: { numbers: ["one"] } }).toContainExactly([
+          { numbers: ["one", "two"] },
+        ]))
+
+      it("fails to find nonexistent row", () =>
+        expectQuery({ contains: { numbers: ["none"] } }).toFindNothing())
+
+      it("fails to find row containing all", () =>
+        expectQuery({
+          contains: { numbers: ["one", "two", "three"] },
+        }).toFindNothing())
+
+      it("finds all with empty list", () =>
+        expectQuery({ contains: { numbers: [] } }).toContainExactly([
+          { numbers: ["one", "two"] },
+          { numbers: ["three"] },
+        ]))
+    })
+
+    describe("notContains", () => {
+      it("successfully finds a row", () =>
+        expectQuery({ notContains: { numbers: ["one"] } }).toContainExactly([
+          { numbers: ["three"] },
+        ]))
+
+      it("fails to find nonexistent row", () =>
+        expectQuery({
+          notContains: { numbers: ["one", "two", "three"] },
+        }).toContainExactly([
+          { numbers: ["one", "two"] },
+          { numbers: ["three"] },
+        ]))
+
+      it("finds all with empty list", () =>
+        expectQuery({ notContains: { numbers: [] } }).toContainExactly([
+          { numbers: ["one", "two"] },
+          { numbers: ["three"] },
+        ]))
+    })
+
+    describe("containsAny", () => {
+      it("successfully finds rows", () =>
+        expectQuery({
+          containsAny: { numbers: ["one", "two", "three"] },
+        }).toContainExactly([
+          { numbers: ["one", "two"] },
+          { numbers: ["three"] },
+        ]))
+
+      it("fails to find nonexistent row", () =>
+        expectQuery({ containsAny: { numbers: ["none"] } }).toFindNothing())
+
+      it("finds all with empty list", () =>
+        expectQuery({ containsAny: { numbers: [] } }).toContainExactly([
+          { numbers: ["one", "two"] },
+          { numbers: ["three"] },
+        ]))
+    })
+  })
 })

packages/server/src/constants/index.ts

@@ -20,6 +20,7 @@ export enum FilterTypes {
   NOT_EMPTY = "notEmpty",
   CONTAINS = "contains",
   NOT_CONTAINS = "notContains",
+  CONTAINS_ANY = "containsAny",
   ONE_OF = "oneOf",
 }
 
@@ -30,6 +31,7 @@ export const NoEmptyFilterStrings = [
   FilterTypes.NOT_EQUAL,
   FilterTypes.CONTAINS,
   FilterTypes.NOT_CONTAINS,
+  FilterTypes.CONTAINS_ANY,
 ]
 
 export const CanSwitchTypes = [

packages/server/src/integrations/base/sql.ts

@@ -233,6 +233,11 @@ class InternalBuilder {
               (statement ? andOr : "") +
               `LOWER(${likeKey(this.client, key)}) LIKE ?`
           }
+
+          if (statement === "") {
+            return
+          }
+
           // @ts-ignore
           query = query[rawFnc](`${not}(${statement})`, value)
         })

packages/server/src/sdk/app/rows/search.ts

@@ -29,6 +29,10 @@ function pickApi(tableId: any) {
   return internal
 }
 
+function isEmptyArray(value: any) {
+  return Array.isArray(value) && value.length === 0
+}
+
 // don't do a pure falsy check, as 0 is included
 // https://github.com/Budibase/budibase/issues/10118
 export function removeEmptyFilters(filters: SearchFilters) {
@@ -47,7 +51,7 @@ export function removeEmptyFilters(filters: SearchFilters) {
         for (let [key, value] of Object.entries(
           filters[filterType] as object
         )) {
-          if (value == null || value === "") {
+          if (value == null || value === "" || isEmptyArray(value)) {
             // @ts-ignore
             delete filters[filterField][key]
           }

packages/types/src/documents/app/row.ts

@@ -1,22 +1,111 @@
 import { Document } from "../document"
 
 export enum FieldType {
+  /**
+   * a primitive type, stores a string, called Text within Budibase. This is one of the default
+   * types of Budibase, if an external type is not fully understood, we will treat it as text.
+   */
   STRING = "string",
+  /**
+   * similar to string type, called Long Form Text within Budibase. This is mainly a frontend
+   * orientated type which enables a larger text input area. This can also be used
+   * in conjunction with the 'useRichText' option to support a markdown editor/viewer.
+   */
   LONGFORM = "longform",
+  /**
+   * similar to string type, called Options within Budibase. This works very similarly to
+   * the string type within the backend, but is validated to a list of options. This will
+   * display a <select> input within the builder/client.
+   */
   OPTIONS = "options",
+  /**
+   * a primitive type, stores a number, as a floating point, called Number within Budibase.
+   * this type will always represent numbers as reals/floating point - there is no integer only
+   * type within Budibase.
+   */
   NUMBER = "number",
+  /**
+   * a primitive type, stores a boolean, called Boolean within Budibase. This is often represented
+   * as a toggle or checkbox within forms/grids.
+   */
   BOOLEAN = "boolean",
+  /**
+   * a JSON type, this type is always an array of strings, called Multi-select within Budibase.
+   * This type can be compared to the options type, as it functions similarly, but allows picking
+   * multiple options rather than a single option.
+   */
   ARRAY = "array",
+  /**
+   * a string type, this is always a string when input/returned from the API, called Date/Time within
+   * Budibase. We utilise ISO date strings for representing dates, this type has a range of subtypes
+   * to restrict it to date only, time only and ignore timezone capabilities.
+   */
   DATETIME = "datetime",
+  /**
+   * a JSON type, an array of metadata about files held in object storage, called Attachment List within
+   * Budibase. To utilise this type there is an API for uploading files to Budibase, which returns metadata
+   * that can be stored against columns of this type. Currently this is not supported on external databases.
+   */
   ATTACHMENTS = "attachment",
+  /**
+   * a JSON type, similar to the attachments type, called Attachment within Budibase. This type functions
+   * much the same as the attachment list, but only holds a single attachment metadata as an object.
+   * This simplifies the binding experience of using this column type.
+   */
   ATTACHMENT_SINGLE = "attachment_single",
+  /**
+   * a complex type, called Relationships within Budibase. This is the most complex type of Budibase,
+   * nothing should be stored against rows under link columns; this type simply represents the
+   * relationship between tables as part of the table schema. When rows are input to the Budibase API
+   * relationships to be made are represented as a list of row IDs to link. When rows are returned
+   * from the Budibase API it will contain a list of row IDs and display column values of the related rows.
+   */
   LINK = "link",
+  /**
+   * a complex type, called Formulas within Budibase. This type has two variants, static and dynamic, with
+   * static only being supported against internal tables. Dynamic formulas calculate a provided HBS/JS binding
+   * based on the row context and enrich it when rows are being returned from the API. Static bindings calculate
+   * this when rows are being stored, so that the formula output can be searched upon within the DB.
+   */
   FORMULA = "formula",
+  /**
+   * a complex type, called Auto Column within Budibase. This type has a few variants, with options such as a
+   * date for created at/updated at, an auto ID column with auto-increments as rows are saved and a user
+   * relationship type which stores the created by/updated by user details. These subtypes all depend on the
+   * date, number of link types respectively. There is one case where these will be executed in the browser,
+   * that is part of the initial formula definition, the formula will be live evaluated in the browser.
+   */
   AUTO = "auto",
+  /**
+   * a JSON type, called JSON within Budibase. This type allows any arbitrary JSON to be input to this column
+   * type, which will be represented as a JSON object in the row. This type depends on a schema being
+   * provided to make the JSON searchable/bindable, the JSON cannot be fully dynamic.
+   */
   JSON = "json",
+  /**
+   * @deprecated an internal type, this is an old deprecated type which is no longer used - still represented to note it
+   * could appear in very old tables.
+   */
   INTERNAL = "internal",
+  /**
+   * a string type, called Barcode/QR within Budibase. This type is used to denote to forms to that this column
+   * should be filled in using a camera to read a barcode, there is a form component which will be used when this
+   * type is found. The column will contain the contents of any barcode scanned.
+   */
   BARCODEQR = "barcodeqr",
+  /**
+   * a string type, this allows representing very large integers, but they are held/managed within Budibase as
+   * strings. When stored in external databases Budibase will attempt to use a real big integer type and depend
+   * on the database parsing the string to this type as part of saving.
+   */
   BIGINT = "bigint",
+  /**
+   * a JSON type, called User within Budibase. This type is used to represent a link to an internal Budibase
+   * resource, like a user or group, today only users are supported. This type will be represented as an
+   * array of internal resource IDs (e.g. user IDs) within the row - this ID list will be enriched with
+   * the full resources when rows are returned from the API. The full resources can be input to the API, or
+   * an array of resource IDs, the API will squash these down and validate them before saving the row.
+   */
   BB_REFERENCE = "bb_reference",
 }
 

scripts/deploy-camunda.sh

@@ -0,0 +1,31 @@
+#!/bin/bash
+yarn global add zbctl
+export ZEEBE_ADDRESS='localhost:26500'
+
+cd ../budibase-bpm
+
+is_camunda_ready() {
+    if (zbctl --insecure status 2>/dev/null) | grep -q 'Healthy'; then
+        return 1
+    else
+        return 0
+    fi
+}
+
+docker-compose up -d
+echo "waiting for Camunda to be ready..."
+
+while is_camunda_ready -eq 0; do sleep 1; done
+
+cd src/main/resources/models
+
+echo "deploy processes..."
+zbctl deploy resource offboarding.bpmn --insecure
+zbctl deploy resource onboarding.bpmn --insecure
+
+cd ../../../../../budibase/packages/account-portal/packages/server 
+
+yarn worker:run & cd ../../../.. && yarn dev:accountportal
+
+
+