diff --git a/.eslintrc.json b/.eslintrc.json
index 79f7e56712..917443014b 100644
--- a/.eslintrc.json
+++ b/.eslintrc.json
@@ -45,6 +45,16 @@
         "no-prototype-builtins": "off",
         "local-rules/no-budibase-imports": "error"
       }
+    },
+    {
+      "files": [
+        "packages/builder/**/*",
+        "packages/client/**/*",
+        "packages/frontend-core/**/*"
+      ],
+      "rules": {
+        "no-console": ["error", { "allow": ["warn", "error", "debug"] } ]
+      }
     }
   ],
   "rules": {
diff --git a/lerna.json b/lerna.json
index f91c51d4bb..9d0593bead 100644
--- a/lerna.json
+++ b/lerna.json
@@ -1,5 +1,5 @@
 {
-  "version": "2.16.0",
+  "version": "2.17.7",
   "npmClient": "yarn",
   "packages": [
     "packages/*",
diff --git a/packages/account-portal b/packages/account-portal
index 485ec16a9e..cc12291732 160000
--- a/packages/account-portal
+++ b/packages/account-portal
@@ -1 +1 @@
-Subproject commit 485ec16a9eed48c548a5f1239772139f3319f028
+Subproject commit cc12291732ee902dc832bc7d93cf2086ffdf0cff
diff --git a/packages/backend-core/package.json b/packages/backend-core/package.json
index d6325e1de9..85644488f5 100644
--- a/packages/backend-core/package.json
+++ b/packages/backend-core/package.json
@@ -21,7 +21,7 @@
     "test:watch": "jest --watchAll"
   },
   "dependencies": {
-    "@budibase/nano": "10.1.4",
+    "@budibase/nano": "10.1.5",
     "@budibase/pouchdb-replication-stream": "1.2.10",
     "@budibase/shared-core": "0.0.0",
     "@budibase/types": "0.0.0",
diff --git a/packages/backend-core/src/objectStore/cloudfront.ts b/packages/backend-core/src/objectStore/cloudfront.ts
index 866fe9e880..3bca97d11e 100644
--- a/packages/backend-core/src/objectStore/cloudfront.ts
+++ b/packages/backend-core/src/objectStore/cloudfront.ts
@@ -23,7 +23,7 @@ const getCloudfrontSignParams = () => {
   return {
     keypairId: env.CLOUDFRONT_PUBLIC_KEY_ID!,
     privateKeyString: getPrivateKey(),
-    expireTime: new Date().getTime() + 1000 * 60 * 60, // 1 hour
+    expireTime: new Date().getTime() + 1000 * 60 * 60 * 24, // 1 day
   }
 }
 
diff --git a/packages/backend-core/src/objectStore/objectStore.ts b/packages/backend-core/src/objectStore/objectStore.ts
index 57ead0e809..3a3b9cdaab 100644
--- a/packages/backend-core/src/objectStore/objectStore.ts
+++ b/packages/backend-core/src/objectStore/objectStore.ts
@@ -7,7 +7,7 @@ import tar from "tar-fs"
 import zlib from "zlib"
 import { promisify } from "util"
 import { join } from "path"
-import fs from "fs"
+import fs, { ReadStream } from "fs"
 import env from "../environment"
 import { budibaseTempDir } from "./utils"
 import { v4 } from "uuid"
@@ -184,7 +184,7 @@ export async function upload({
 export async function streamUpload(
   bucketName: string,
   filename: string,
-  stream: any,
+  stream: ReadStream | ReadableStream,
   extra = {}
 ) {
   const objectStore = ObjectStore(bucketName)
diff --git a/packages/builder/src/builderStore/store/frontend.js b/packages/builder/src/builderStore/store/frontend.js
new file mode 100644
index 0000000000..55208bb97e
--- /dev/null
+++ b/packages/builder/src/builderStore/store/frontend.js
@@ -0,0 +1,1507 @@
+import { get, writable } from "svelte/store"
+import { cloneDeep } from "lodash/fp"
+import {
+  selectedScreen,
+  selectedComponent,
+  screenHistoryStore,
+  automationHistoryStore,
+} from "builderStore"
+import {
+  datasources,
+  integrations,
+  queries,
+  database,
+  tables,
+} from "stores/backend"
+import { API } from "api"
+import analytics, { Events } from "analytics"
+import {
+  findComponentParent,
+  findClosestMatchingComponent,
+  findAllMatchingComponents,
+  findComponent,
+  getComponentSettings,
+  makeComponentUnique,
+  findComponentPath,
+} from "../componentUtils"
+import { Helpers } from "@budibase/bbui"
+import { Utils } from "@budibase/frontend-core"
+import {
+  BUDIBASE_INTERNAL_DB_ID,
+  DB_TYPE_INTERNAL,
+  DB_TYPE_EXTERNAL,
+} from "constants/backend"
+import {
+  buildFormSchema,
+  getSchemaForDatasource,
+} from "builderStore/dataBinding"
+import { makePropSafe as safe } from "@budibase/string-templates"
+import { getComponentFieldOptions } from "helpers/formFields"
+import { createBuilderWebsocket } from "builderStore/websocket"
+import { BuilderSocketEvent } from "@budibase/shared-core"
+
+const INITIAL_FRONTEND_STATE = {
+  initialised: false,
+  apps: [],
+  name: "",
+  url: "",
+  description: "",
+  layouts: [],
+  screens: [],
+  components: [],
+  clientFeatures: {
+    spectrumThemes: false,
+    intelligentLoading: false,
+    deviceAwareness: false,
+    state: false,
+    rowSelection: false,
+    customThemes: false,
+    devicePreview: false,
+    messagePassing: false,
+    continueIfAction: false,
+    showNotificationAction: false,
+    sidePanel: false,
+  },
+  features: {
+    componentValidation: false,
+    disableUserMetadata: false,
+  },
+  errors: [],
+  hasAppPackage: false,
+  libraries: null,
+  appId: "",
+  routes: {},
+  clientLibPath: "",
+  theme: "",
+  customTheme: {},
+  previewDevice: "desktop",
+  highlightedSettingKey: null,
+  propertyFocus: null,
+  builderSidePanel: false,
+  hasLock: true,
+  showPreview: false,
+
+  // URL params
+  selectedScreenId: null,
+  selectedComponentId: null,
+  selectedLayoutId: null,
+
+  // Client state
+  selectedComponentInstance: null,
+
+  // Onboarding
+  onboarding: false,
+  tourNodes: null,
+}
+
+export const getFrontendStore = () => {
+  const store = writable({ ...INITIAL_FRONTEND_STATE })
+  let websocket
+
+  // This is a fake implementation of a "patch" API endpoint to try and prevent
+  // 409s. All screen doc mutations (aside from creation) use this function,
+  // which queues up invocations sequentially and ensures pending mutations are
+  // always applied to the most up-to-date doc revision.
+  // This is slightly better than just a traditional "patch" endpoint and this
+  // supports deeply mutating the current doc rather than just appending data.
+  const sequentialScreenPatch = Utils.sequential(async (patchFn, screenId) => {
+    const state = get(store)
+    const screen = state.screens.find(screen => screen._id === screenId)
+    if (!screen) {
+      return
+    }
+    let clone = cloneDeep(screen)
+    const result = patchFn(clone)
+    // An explicit false result means skip this change
+    if (result === false) {
+      return
+    }
+    return await store.actions.screens.save(clone)
+  })
+
+  store.actions = {
+    reset: () => {
+      store.set({ ...INITIAL_FRONTEND_STATE })
+      websocket?.disconnect()
+      websocket = null
+    },
+    initialise: async pkg => {
+      const { layouts, screens, application, clientLibPath, hasLock } = pkg
+      if (!websocket) {
+        websocket = createBuilderWebsocket(application.appId)
+      }
+      await store.actions.components.refreshDefinitions(application.appId)
+
+      // Reset store state
+      store.update(state => ({
+        ...state,
+        libraries: application.componentLibraries,
+        name: application.name,
+        description: application.description,
+        appId: application.appId,
+        url: application.url,
+        layouts: layouts || [],
+        screens: screens || [],
+        theme: application.theme || "spectrum--light",
+        customTheme: application.customTheme,
+        hasAppPackage: true,
+        appInstance: application.instance,
+        clientLibPath,
+        previousTopNavPath: {},
+        version: application.version,
+        revertableVersion: application.revertableVersion,
+        upgradableVersion: application.upgradableVersion,
+        navigation: application.navigation || {},
+        usedPlugins: application.usedPlugins || [],
+        hasLock,
+        features: {
+          ...INITIAL_FRONTEND_STATE.features,
+          ...application.features,
+        },
+        automations: application.automations || {},
+        icon: application.icon || {},
+        initialised: true,
+      }))
+      screenHistoryStore.reset()
+      automationHistoryStore.reset()
+
+      // Initialise backend stores
+      database.set(application.instance)
+      await datasources.init()
+      await integrations.init()
+      await queries.init()
+      await tables.init()
+    },
+    theme: {
+      save: async theme => {
+        const appId = get(store).appId
+        const app = await API.saveAppMetadata({
+          appId,
+          metadata: { theme },
+        })
+        store.update(state => {
+          state.theme = app.theme
+          return state
+        })
+      },
+    },
+    customTheme: {
+      save: async customTheme => {
+        const appId = get(store).appId
+        const app = await API.saveAppMetadata({
+          appId,
+          metadata: { customTheme },
+        })
+        store.update(state => {
+          state.customTheme = app.customTheme
+          return state
+        })
+      },
+    },
+    navigation: {
+      save: async navigation => {
+        const appId = get(store).appId
+        const app = await API.saveAppMetadata({
+          appId,
+          metadata: { navigation },
+        })
+        store.update(state => {
+          state.navigation = app.navigation
+          return state
+        })
+      },
+    },
+    screens: {
+      select: screenId => {
+        // Check this screen exists
+        const state = get(store)
+        const screen = state.screens.find(screen => screen._id === screenId)
+        if (!screen) {
+          return
+        }
+
+        // Check screen isn't already selected
+        if (state.selectedScreenId === screen._id) {
+          return
+        }
+
+        // Select new screen
+        store.update(state => {
+          state.selectedScreenId = screen._id
+          return state
+        })
+      },
+      validate: screen => {
+        // Recursive function to find any illegal children in component trees
+        const findIllegalChild = (
+          component,
+          illegalChildren = [],
+          legalDirectChildren = []
+        ) => {
+          const type = component._component
+
+          if (illegalChildren.includes(type)) {
+            return type
+          }
+          if (
+            legalDirectChildren.length &&
+            !legalDirectChildren.includes(type)
+          ) {
+            return type
+          }
+          if (!component?._children?.length) {
+            return
+          }
+
+          if (type === "@budibase/standard-components/sidepanel") {
+            illegalChildren = []
+          }
+
+          const definition = store.actions.components.getDefinition(
+            component._component
+          )
+          // Reset whitelist for direct children
+          legalDirectChildren = []
+          if (definition?.legalDirectChildren?.length) {
+            legalDirectChildren = definition.legalDirectChildren.map(x => {
+              return `@budibase/standard-components/${x}`
+            })
+          }
+
+          // Append blacklisted components and remove duplicates
+          if (definition?.illegalChildren?.length) {
+            const blacklist = definition.illegalChildren.map(x => {
+              return `@budibase/standard-components/${x}`
+            })
+            illegalChildren = [...new Set([...illegalChildren, ...blacklist])]
+          }
+
+          // Recurse on all children
+          for (let child of component._children) {
+            const illegalChild = findIllegalChild(
+              child,
+              illegalChildren,
+              legalDirectChildren
+            )
+            if (illegalChild) {
+              return illegalChild
+            }
+          }
+        }
+
+        // Validate the entire tree and throw an error if an illegal child is
+        // found anywhere
+        const illegalChild = findIllegalChild(screen.props)
+        if (illegalChild) {
+          const def = store.actions.components.getDefinition(illegalChild)
+          throw `You can't place a ${def.name} here`
+        }
+      },
+      save: async screen => {
+        const state = get(store)
+
+        // Validate screen structure if the app supports it
+        if (state.features?.componentValidation) {
+          store.actions.screens.validate(screen)
+        }
+
+        // Check screen definition for any component settings which need updated
+        store.actions.screens.enrichEmptySettings(screen)
+
+        // Save screen
+        const creatingNewScreen = screen._id === undefined
+        const savedScreen = await API.saveScreen(screen)
+        const routesResponse = await API.fetchAppRoutes()
+
+        // If plugins changed we need to fetch the latest app metadata
+        let usedPlugins = state.usedPlugins
+        if (savedScreen.pluginAdded) {
+          const { application } = await API.fetchAppPackage(state.appId)
+          usedPlugins = application.usedPlugins || []
+        }
+
+        // Update state
+        store.update(state => {
+          // Update screen object
+          const idx = state.screens.findIndex(x => x._id === savedScreen._id)
+          if (idx !== -1) {
+            state.screens.splice(idx, 1, savedScreen)
+          } else {
+            state.screens.push(savedScreen)
+          }
+
+          // Select the new screen if creating a new one
+          if (creatingNewScreen) {
+            state.selectedScreenId = savedScreen._id
+            state.selectedComponentId = savedScreen.props._id
+          }
+
+          // Update routes
+          state.routes = routesResponse.routes
+
+          // Update used plugins
+          state.usedPlugins = usedPlugins
+          return state
+        })
+        return savedScreen
+      },
+      patch: async (patchFn, screenId) => {
+        // Default to the currently selected screen
+        if (!screenId) {
+          const state = get(store)
+          screenId = state.selectedScreenId
+        }
+        if (!screenId || !patchFn) {
+          return
+        }
+        return await sequentialScreenPatch(patchFn, screenId)
+      },
+      replace: async (screenId, screen) => {
+        if (!screenId) {
+          return
+        }
+        if (!screen) {
+          // Screen deletion
+          store.update(state => ({
+            ...state,
+            screens: state.screens.filter(x => x._id !== screenId),
+          }))
+        } else {
+          const index = get(store).screens.findIndex(x => x._id === screen._id)
+          if (index === -1) {
+            // Screen addition
+            store.update(state => ({
+              ...state,
+              screens: [...state.screens, screen],
+            }))
+          } else {
+            // Screen update
+            store.update(state => {
+              state.screens[index] = screen
+              return state
+            })
+          }
+        }
+      },
+      delete: async screens => {
+        const screensToDelete = Array.isArray(screens) ? screens : [screens]
+
+        // Build array of promises to speed up bulk deletions
+        let promises = []
+        let deleteUrls = []
+        screensToDelete.forEach(screen => {
+          // Delete the screen
+          promises.push(
+            API.deleteScreen({
+              screenId: screen._id,
+              screenRev: screen._rev,
+            })
+          )
+          // Remove links to this screen
+          deleteUrls.push(screen.routing.route)
+        })
+
+        await Promise.all(promises)
+        await store.actions.links.delete(deleteUrls)
+        const deletedIds = screensToDelete.map(screen => screen._id)
+        const routesResponse = await API.fetchAppRoutes()
+        store.update(state => {
+          // Remove deleted screens from state
+          state.screens = state.screens.filter(screen => {
+            return !deletedIds.includes(screen._id)
+          })
+
+          // Deselect the current screen if it was deleted
+          if (deletedIds.includes(state.selectedScreenId)) {
+            state.selectedScreenId = null
+            state.selectedComponentId = null
+          }
+
+          // Update routing
+          state.routes = routesResponse.routes
+
+          return state
+        })
+        return null
+      },
+      updateSetting: async (screen, name, value) => {
+        if (!screen || !name) {
+          return
+        }
+
+        // Apply setting update
+        const patch = screen => {
+          if (!screen) {
+            return false
+          }
+          // Skip update if the value is the same
+          if (Helpers.deepGet(screen, name) === value) {
+            return false
+          }
+          Helpers.deepSet(screen, name, value)
+        }
+        await store.actions.screens.patch(patch, screen._id)
+
+        // Ensure we don't have more than one home screen for this new role.
+        // This could happen after updating multiple different settings.
+        const state = get(store)
+        const updatedScreen = state.screens.find(s => s._id === screen._id)
+        if (!updatedScreen) {
+          return
+        }
+        const otherHomeScreens = state.screens.filter(s => {
+          return (
+            s.routing.roleId === updatedScreen.routing.roleId &&
+            s.routing.homeScreen &&
+            s._id !== screen._id
+          )
+        })
+        if (otherHomeScreens.length && updatedScreen.routing.homeScreen) {
+          const patch = screen => {
+            screen.routing.homeScreen = false
+          }
+          for (let otherHomeScreen of otherHomeScreens) {
+            await store.actions.screens.patch(patch, otherHomeScreen._id)
+          }
+        }
+      },
+      removeCustomLayout: async screen => {
+        // Pull relevant settings from old layout, if required
+        const layout = get(store).layouts.find(x => x._id === screen.layoutId)
+        const patch = screen => {
+          screen.layoutId = null
+          screen.showNavigation = layout?.props.navigation !== "None"
+          screen.width = layout?.props.width || "Large"
+        }
+        await store.actions.screens.patch(patch, screen._id)
+      },
+      enrichEmptySettings: screen => {
+        // Flatten the recursive component tree
+        const components = findAllMatchingComponents(screen.props, x => x)
+
+        // Iterate over all components and run checks
+        components.forEach(component => {
+          store.actions.components.enrichEmptySettings(component, {
+            screen,
+          })
+        })
+      },
+    },
+    preview: {
+      setDevice: device => {
+        store.update(state => {
+          state.previewDevice = device
+          return state
+        })
+      },
+      sendEvent: (name, payload) => {
+        const { previewEventHandler } = get(store)
+        previewEventHandler?.(name, payload)
+      },
+      registerEventHandler: handler => {
+        store.update(state => {
+          state.previewEventHandler = handler
+          return state
+        })
+      },
+    },
+    layouts: {
+      select: layoutId => {
+        // Check this layout exists
+        const state = get(store)
+        const layout = state.layouts.find(layout => layout._id === layoutId)
+        if (!layout) {
+          return
+        }
+
+        // Check layout isn't already selected
+        if (
+          state.selectedLayoutId === layout._id &&
+          state.selectedComponentId === layout.props?._id
+        ) {
+          return
+        }
+
+        // Select new layout
+        store.update(state => {
+          state.selectedLayoutId = layout._id
+          state.selectedComponentId = layout.props?._id
+          return state
+        })
+      },
+      delete: async layout => {
+        if (!layout?._id) {
+          return
+        }
+        await API.deleteLayout({
+          layoutId: layout._id,
+          layoutRev: layout._rev,
+        })
+        store.update(state => {
+          state.layouts = state.layouts.filter(x => x._id !== layout._id)
+          return state
+        })
+      },
+    },
+    components: {
+      refreshDefinitions: async appId => {
+        if (!appId) {
+          appId = get(store).appId
+        }
+
+        // Fetch definitions and filter out custom component definitions so we
+        // can flag them
+        const components = await API.fetchComponentLibDefinitions(appId)
+        const customComponents = Object.keys(components).filter(name =>
+          name.startsWith("plugin/")
+        )
+
+        // Update store
+        store.update(state => ({
+          ...state,
+          components,
+          customComponents,
+          clientFeatures: {
+            ...INITIAL_FRONTEND_STATE.clientFeatures,
+            ...components.features,
+          },
+        }))
+      },
+      getDefinition: componentName => {
+        if (!componentName) {
+          return null
+        }
+        return get(store).components[componentName]
+      },
+      getDefaultDatasource: () => {
+        // Ignore users table
+        const validTables = get(tables).list.filter(x => x._id !== "ta_users")
+
+        // Try to use their own internal table first
+        let table = validTables.find(table => {
+          return (
+            table.sourceId !== BUDIBASE_INTERNAL_DB_ID &&
+            table.sourceType === DB_TYPE_INTERNAL
+          )
+        })
+        if (table) {
+          return table
+        }
+
+        // Then try sample data
+        table = validTables.find(table => {
+          return (
+            table.sourceId === BUDIBASE_INTERNAL_DB_ID &&
+            table.sourceType === DB_TYPE_INTERNAL
+          )
+        })
+        if (table) {
+          return table
+        }
+
+        // Finally try an external table
+        return validTables.find(table => table.sourceType === DB_TYPE_EXTERNAL)
+      },
+      migrateSettings: enrichedComponent => {
+        const componentPrefix = "@budibase/standard-components"
+        let migrated = false
+
+        if (enrichedComponent?._component == `${componentPrefix}/formblock`) {
+          // Use default config if the 'buttons' prop has never been initialised
+          if (!("buttons" in enrichedComponent)) {
+            enrichedComponent["buttons"] =
+              Utils.buildFormBlockButtonConfig(enrichedComponent)
+            migrated = true
+          } else if (enrichedComponent["buttons"] == null) {
+            // Ignore legacy config if 'buttons' has been reset by 'resetOn'
+            const { _id, actionType, dataSource } = enrichedComponent
+            enrichedComponent["buttons"] = Utils.buildFormBlockButtonConfig({
+              _id,
+              actionType,
+              dataSource,
+            })
+            migrated = true
+          }
+
+          // Ensure existing Formblocks position their buttons at the top.
+          if (!("buttonPosition" in enrichedComponent)) {
+            enrichedComponent["buttonPosition"] = "top"
+            migrated = true
+          }
+        }
+
+        return migrated
+      },
+      enrichEmptySettings: (component, opts) => {
+        if (!component?._component) {
+          return
+        }
+        const defaultDS = store.actions.components.getDefaultDatasource()
+        const settings = getComponentSettings(component._component)
+        const { parent, screen, useDefaultValues } = opts || {}
+        const treeId = parent?._id || component._id
+        if (!screen) {
+          return
+        }
+        settings.forEach(setting => {
+          const value = component[setting.key]
+
+          // Fill empty settings
+          if (value == null || value === "") {
+            if (setting.type === "multifield" && setting.selectAllFields) {
+              // Select all schema fields where required
+              component[setting.key] = Object.keys(defaultDS?.schema || {})
+            } else if (
+              (setting.type === "dataSource" || setting.type === "table") &&
+              defaultDS
+            ) {
+              // Select default datasource where required
+              component[setting.key] = {
+                label: defaultDS.name,
+                tableId: defaultDS._id,
+                resourceId: defaultDS._id,
+                type: "table",
+              }
+            } else if (setting.type === "dataProvider") {
+              // Pick closest data provider where required
+              const path = findComponentPath(screen.props, treeId)
+              const providers = path.filter(component =>
+                component._component?.endsWith("/dataprovider")
+              )
+              if (providers.length) {
+                const id = providers[providers.length - 1]?._id
+                component[setting.key] = `{{ literal ${safe(id)} }}`
+              }
+            } else if (setting.type.startsWith("field/")) {
+              // Autofill form field names
+              // Get all available field names in this form schema
+              let fieldOptions = getComponentFieldOptions(
+                screen.props,
+                treeId,
+                setting.type,
+                false
+              )
+
+              // Get all currently used fields
+              const form = findClosestMatchingComponent(
+                screen.props,
+                treeId,
+                x => x._component === "@budibase/standard-components/form"
+              )
+              const usedFields = Object.keys(buildFormSchema(form) || {})
+
+              // Filter out already used fields
+              fieldOptions = fieldOptions.filter(x => !usedFields.includes(x))
+
+              // Set field name and also assume we have a label setting
+              if (fieldOptions[0]) {
+                component[setting.key] = fieldOptions[0]
+                component.label = fieldOptions[0]
+              }
+            } else if (useDefaultValues && setting.defaultValue !== undefined) {
+              // Use default value where required
+              component[setting.key] = setting.defaultValue
+            }
+          }
+          // Validate non-empty settings
+          else {
+            if (setting.type === "dataProvider") {
+              // Validate data provider exists, or else clear it
+              const providers = findAllMatchingComponents(
+                screen?.props,
+                component => component._component?.endsWith("/dataprovider")
+              )
+              // Validate non-empty values
+              const valid = providers?.some(dp => value.includes?.(dp._id))
+              if (!valid) {
+                if (providers.length) {
+                  const id = providers[providers.length - 1]?._id
+                  component[setting.key] = `{{ literal ${safe(id)} }}`
+                } else {
+                  delete component[setting.key]
+                }
+              }
+            }
+          }
+        })
+      },
+      createInstance: (componentName, presetProps, parent) => {
+        const definition = store.actions.components.getDefinition(componentName)
+        if (!definition) {
+          return null
+        }
+
+        // Find all existing components of this type so that we can give this
+        // component a unique name
+        const screen = get(selectedScreen).props
+        const otherComponents = findAllMatchingComponents(
+          screen,
+          x => x._component === definition.component && x._id !== screen._id
+        )
+        let name = definition.friendlyName || definition.name
+        name = `${name} ${otherComponents.length + 1}`
+
+        // Generate basic component structure
+        let instance = {
+          _id: Helpers.uuid(),
+          _component: definition.component,
+          _styles: {
+            normal: {},
+            hover: {},
+            active: {},
+          },
+          _instanceName: name,
+          ...presetProps,
+        }
+
+        // Enrich empty settings
+        store.actions.components.enrichEmptySettings(instance, {
+          parent,
+          screen: get(selectedScreen),
+          useDefaultValues: true,
+        })
+
+        // Migrate nested component settings
+        store.actions.components.migrateSettings(instance)
+
+        // Add any extra properties the component needs
+        let extras = {}
+        if (definition.hasChildren) {
+          extras._children = []
+        }
+        if (componentName.endsWith("/formstep")) {
+          const parentForm = findClosestMatchingComponent(
+            get(selectedScreen).props,
+            get(selectedComponent)._id,
+            component => component._component.endsWith("/form")
+          )
+          const formSteps = findAllMatchingComponents(parentForm, component =>
+            component._component.endsWith("/formstep")
+          )
+          extras.step = formSteps.length + 1
+          extras._instanceName = `Step ${formSteps.length + 1}`
+        }
+        return {
+          ...cloneDeep(instance),
+          ...extras,
+        }
+      },
+      create: async (componentName, presetProps, parent, index) => {
+        const state = get(store)
+        const componentInstance = store.actions.components.createInstance(
+          componentName,
+          presetProps,
+          parent
+        )
+        if (!componentInstance) {
+          return
+        }
+
+        // Insert in position if specified
+        if (parent && index != null) {
+          await store.actions.screens.patch(screen => {
+            let parentComponent = findComponent(screen.props, parent)
+            if (!parentComponent._children?.length) {
+              parentComponent._children = [componentInstance]
+            } else {
+              parentComponent._children.splice(index, 0, componentInstance)
+            }
+          })
+        }
+
+        // Otherwise we work out where this component should be inserted
+        else {
+          await store.actions.screens.patch(screen => {
+            // Find the selected component
+            let selectedComponentId = state.selectedComponentId
+            if (selectedComponentId.startsWith(`${screen._id}-`)) {
+              selectedComponentId = screen?.props._id
+            }
+            const currentComponent = findComponent(
+              screen.props,
+              selectedComponentId
+            )
+            if (!currentComponent) {
+              return false
+            }
+
+            // Find parent node to attach this component to
+            let parentComponent
+            if (currentComponent) {
+              // Use selected component as parent if one is selected
+              const definition = store.actions.components.getDefinition(
+                currentComponent._component
+              )
+              if (definition?.hasChildren) {
+                // Use selected component if it allows children
+                parentComponent = currentComponent
+              } else {
+                // Otherwise we need to use the parent of this component
+                parentComponent = findComponentParent(
+                  screen.props,
+                  currentComponent._id
+                )
+              }
+            } else {
+              // Use screen or layout if no component is selected
+              parentComponent = screen.props
+            }
+
+            // Attach new component
+            if (!parentComponent) {
+              return false
+            }
+            if (!parentComponent._children) {
+              parentComponent._children = []
+            }
+            parentComponent._children.push(componentInstance)
+          })
+        }
+
+        // Select new component
+        store.update(state => {
+          state.selectedComponentId = componentInstance._id
+          return state
+        })
+
+        // Log event
+        analytics.captureEvent(Events.COMPONENT_CREATED, {
+          name: componentInstance._component,
+        })
+
+        return componentInstance
+      },
+      patch: async (patchFn, componentId, screenId) => {
+        // Use selected component by default
+        if (!componentId || !screenId) {
+          const state = get(store)
+          componentId = componentId || state.selectedComponentId
+          screenId = screenId || state.selectedScreenId
+        }
+        if (!componentId || !screenId || !patchFn) {
+          return
+        }
+        const patchScreen = screen => {
+          // findComponent looks in the tree not comp.settings[0]
+          let component = findComponent(screen.props, componentId)
+          if (!component) {
+            return false
+          }
+
+          // Mutates the fetched component with updates
+          const patchResult = patchFn(component, screen)
+
+          // Mutates the component with any required settings updates
+          const migrated = store.actions.components.migrateSettings(component)
+
+          // Returning an explicit false signifies that we should skip this
+          // update. If we migrated something, ensure we never skip.
+          return migrated ? null : patchResult
+        }
+        await store.actions.screens.patch(patchScreen, screenId)
+      },
+      delete: async component => {
+        if (!component) {
+          return
+        }
+
+        // Determine the next component to select after deletion
+        const state = get(store)
+        let nextSelectedComponentId
+        if (state.selectedComponentId === component._id) {
+          nextSelectedComponentId = store.actions.components.getNext()
+          if (!nextSelectedComponentId) {
+            nextSelectedComponentId = store.actions.components.getPrevious()
+          }
+        }
+
+        // Patch screen
+        await store.actions.screens.patch(screen => {
+          // Check component exists
+          component = findComponent(screen.props, component._id)
+          if (!component) {
+            return false
+          }
+
+          // Check component has a valid parent
+          const parent = findComponentParent(screen.props, component._id)
+          if (!parent) {
+            return false
+          }
+          parent._children = parent._children.filter(
+            child => child._id !== component._id
+          )
+        })
+
+        // Update selected component if required
+        if (nextSelectedComponentId) {
+          store.update(state => {
+            state.selectedComponentId = nextSelectedComponentId
+            return state
+          })
+        }
+      },
+      copy: (component, cut = false, selectParent = true) => {
+        // Update store with copied component
+        store.update(state => {
+          state.componentToPaste = cloneDeep(component)
+          state.componentToPaste.isCut = cut
+          return state
+        })
+
+        // Select the parent if cutting
+        if (cut && selectParent) {
+          const screen = get(selectedScreen)
+          const parent = findComponentParent(screen?.props, component._id)
+          if (parent) {
+            store.update(state => {
+              state.selectedComponentId = parent._id
+              return state
+            })
+          }
+        }
+      },
+      paste: async (targetComponent, mode, targetScreen) => {
+        const state = get(store)
+        if (!state.componentToPaste) {
+          return
+        }
+        let newComponentId
+
+        // Remove copied component if cutting, regardless if pasting works
+        let componentToPaste = cloneDeep(state.componentToPaste)
+        if (componentToPaste.isCut) {
+          store.update(state => {
+            delete state.componentToPaste
+            return state
+          })
+        }
+
+        // Patch screen
+        const patch = screen => {
+          // Get up to date ref to target
+          targetComponent = findComponent(screen.props, targetComponent._id)
+          if (!targetComponent) {
+            return false
+          }
+          const cut = componentToPaste.isCut
+          const originalId = componentToPaste._id
+          delete componentToPaste.isCut
+
+          // Make new component unique if copying
+          if (!cut) {
+            componentToPaste = makeComponentUnique(componentToPaste)
+          }
+          newComponentId = componentToPaste._id
+
+          // Delete old component if cutting
+          if (cut) {
+            const parent = findComponentParent(screen.props, originalId)
+            if (parent?._children) {
+              parent._children = parent._children.filter(
+                component => component._id !== originalId
+              )
+            }
+          }
+
+          // Check inside is valid
+          if (mode === "inside") {
+            const definition = store.actions.components.getDefinition(
+              targetComponent._component
+            )
+            if (!definition.hasChildren) {
+              mode = "below"
+            }
+          }
+
+          // Paste new component
+          if (mode === "inside") {
+            // Paste inside target component if chosen
+            if (!targetComponent._children) {
+              targetComponent._children = []
+            }
+            targetComponent._children.push(componentToPaste)
+          } else {
+            // Otherwise paste in the correct order in the parent's children
+            const parent = findComponentParent(
+              screen.props,
+              targetComponent._id
+            )
+            if (!parent?._children) {
+              return false
+            }
+            const targetIndex = parent._children.findIndex(component => {
+              return component._id === targetComponent._id
+            })
+            const index = mode === "above" ? targetIndex : targetIndex + 1
+            parent._children.splice(index, 0, componentToPaste)
+          }
+        }
+        const targetScreenId = targetScreen?._id || state.selectedScreenId
+        await store.actions.screens.patch(patch, targetScreenId)
+
+        // Select the new component
+        store.update(state => {
+          state.selectedScreenId = targetScreenId
+          state.selectedComponentId = newComponentId
+          return state
+        })
+      },
+      getPrevious: () => {
+        const state = get(store)
+        const componentId = state.selectedComponentId
+        const screen = get(selectedScreen)
+        const parent = findComponentParent(screen.props, componentId)
+        const index = parent?._children.findIndex(x => x._id === componentId)
+
+        // Check for screen and navigation component edge cases
+        const screenComponentId = `${screen._id}-screen`
+        const navComponentId = `${screen._id}-navigation`
+        if (componentId === screenComponentId) {
+          return null
+        }
+        if (componentId === navComponentId) {
+          return screenComponentId
+        }
+        if (parent._id === screen.props._id && index === 0) {
+          return navComponentId
+        }
+
+        // If we have siblings above us, choose the sibling or a descendant
+        if (index > 0) {
+          // If sibling before us accepts children, select a descendant
+          const previousSibling = parent._children[index - 1]
+          if (previousSibling._children?.length) {
+            let target = previousSibling
+            while (target._children?.length) {
+              target = target._children[target._children.length - 1]
+            }
+            return target._id
+          }
+
+          // Otherwise just select sibling
+          return previousSibling._id
+        }
+
+        // If no siblings above us, select the parent
+        return parent._id
+      },
+      getNext: () => {
+        const state = get(store)
+        const component = get(selectedComponent)
+        const componentId = component?._id
+        const screen = get(selectedScreen)
+        const parent = findComponentParent(screen.props, componentId)
+        const index = parent?._children.findIndex(x => x._id === componentId)
+
+        // Check for screen and navigation component edge cases
+        const screenComponentId = `${screen._id}-screen`
+        const navComponentId = `${screen._id}-navigation`
+        if (state.selectedComponentId === screenComponentId) {
+          return navComponentId
+        }
+
+        // If we have children, select first child
+        if (component._children?.length) {
+          return component._children[0]._id
+        } else if (!parent) {
+          return null
+        }
+
+        // Otherwise select the next sibling if we have one
+        if (index < parent._children.length - 1) {
+          const nextSibling = parent._children[index + 1]
+          return nextSibling._id
+        }
+
+        // Last child, select our parents next sibling
+        let target = parent
+        let targetParent = findComponentParent(screen.props, target._id)
+        let targetIndex = targetParent?._children.findIndex(
+          child => child._id === target._id
+        )
+        while (
+          targetParent != null &&
+          targetIndex === targetParent._children?.length - 1
+        ) {
+          target = targetParent
+          targetParent = findComponentParent(screen.props, target._id)
+          targetIndex = targetParent?._children.findIndex(
+            child => child._id === target._id
+          )
+        }
+        if (targetParent) {
+          return targetParent._children[targetIndex + 1]._id
+        } else {
+          return null
+        }
+      },
+      selectPrevious: () => {
+        const previousId = store.actions.components.getPrevious()
+        if (previousId) {
+          store.update(state => {
+            state.selectedComponentId = previousId
+            return state
+          })
+        }
+      },
+      selectNext: () => {
+        const nextId = store.actions.components.getNext()
+        if (nextId) {
+          store.update(state => {
+            state.selectedComponentId = nextId
+            return state
+          })
+        }
+      },
+      moveUp: async component => {
+        await store.actions.screens.patch(screen => {
+          const componentId = component?._id
+          const parent = findComponentParent(screen.props, componentId)
+
+          // Check we aren't right at the top of the tree
+          const index = parent?._children.findIndex(x => x._id === componentId)
+          if (!parent || (index === 0 && parent._id === screen.props._id)) {
+            return
+          }
+
+          // Copy original component and remove it from the parent
+          const originalComponent = cloneDeep(parent._children[index])
+          parent._children = parent._children.filter(
+            component => component._id !== componentId
+          )
+
+          // If we have siblings above us, move up
+          if (index > 0) {
+            // If sibling before us accepts children, move to last child of
+            // sibling
+            const previousSibling = parent._children[index - 1]
+            const definition = store.actions.components.getDefinition(
+              previousSibling._component
+            )
+            if (definition.hasChildren) {
+              previousSibling._children.push(originalComponent)
+            }
+
+            // Otherwise just move component above sibling
+            else {
+              parent._children.splice(index - 1, 0, originalComponent)
+            }
+          }
+
+          // If no siblings above us, go above the parent as long as it isn't
+          // the screen
+          else if (parent._id !== screen.props._id) {
+            const grandParent = findComponentParent(screen.props, parent._id)
+            const parentIndex = grandParent._children.findIndex(
+              child => child._id === parent._id
+            )
+            grandParent._children.splice(parentIndex, 0, originalComponent)
+          }
+        })
+      },
+      moveDown: async component => {
+        await store.actions.screens.patch(screen => {
+          const componentId = component?._id
+          const parent = findComponentParent(screen.props, componentId)
+
+          // Sanity check parent is found
+          if (!parent?._children?.length) {
+            return false
+          }
+
+          // Check we aren't right at the bottom of the tree
+          const index = parent._children.findIndex(x => x._id === componentId)
+          if (
+            index === parent._children.length - 1 &&
+            parent._id === screen.props._id
+          ) {
+            return
+          }
+
+          // Copy the original component and remove from parent
+          const originalComponent = cloneDeep(parent._children[index])
+          parent._children = parent._children.filter(
+            component => component._id !== componentId
+          )
+
+          // Move below the next sibling if we are not the last sibling
+          if (index < parent._children.length) {
+            // If the next sibling has children, become the first child
+            const nextSibling = parent._children[index]
+            const definition = store.actions.components.getDefinition(
+              nextSibling._component
+            )
+            if (definition.hasChildren) {
+              nextSibling._children.splice(0, 0, originalComponent)
+            }
+
+            // Otherwise move below next sibling
+            else {
+              parent._children.splice(index + 1, 0, originalComponent)
+            }
+          }
+
+          // Last child, so move below our parent
+          else {
+            const grandParent = findComponentParent(screen.props, parent._id)
+            const parentIndex = grandParent._children.findIndex(
+              child => child._id === parent._id
+            )
+            grandParent._children.splice(parentIndex + 1, 0, originalComponent)
+          }
+        })
+      },
+      updateStyle: async (name, value) => {
+        await store.actions.components.patch(component => {
+          if (value == null || value === "") {
+            delete component._styles.normal[name]
+          } else {
+            component._styles.normal[name] = value
+          }
+        })
+      },
+      updateStyles: async (styles, id) => {
+        const patchFn = component => {
+          component._styles.normal = {
+            ...component._styles.normal,
+            ...styles,
+          }
+        }
+        await store.actions.components.patch(patchFn, id)
+      },
+      updateCustomStyle: async style => {
+        await store.actions.components.patch(component => {
+          component._styles.custom = style
+        })
+      },
+      updateConditions: async conditions => {
+        await store.actions.components.patch(component => {
+          component._conditions = conditions
+        })
+      },
+      updateSetting: async (name, value) => {
+        await store.actions.components.patch(
+          store.actions.components.updateComponentSetting(name, value)
+        )
+      },
+      updateComponentSetting: (name, value) => {
+        return component => {
+          if (!name || !component) {
+            return false
+          }
+          // Skip update if the value is the same
+          if (component[name] === value) {
+            return false
+          }
+
+          const settings = getComponentSettings(component._component)
+          const updatedSetting = settings.find(setting => setting.key === name)
+
+          // Reset dependent fields
+          settings.forEach(setting => {
+            const needsReset =
+              name === setting.resetOn ||
+              (Array.isArray(setting.resetOn) && setting.resetOn.includes(name))
+            if (needsReset) {
+              component[setting.key] = setting.defaultValue || null
+            }
+          })
+
+          if (
+            updatedSetting?.type === "dataSource" ||
+            updatedSetting?.type === "table"
+          ) {
+            const { schema } = getSchemaForDatasource(null, value)
+            const columnNames = Object.keys(schema || {})
+            const multifieldKeysToSelectAll = settings
+              .filter(setting => {
+                return setting.type === "multifield" && setting.selectAllFields
+              })
+              .map(setting => setting.key)
+
+            multifieldKeysToSelectAll.forEach(key => {
+              component[key] = columnNames
+            })
+          }
+          component[name] = value
+          return true
+        }
+      },
+      requestEjectBlock: componentId => {
+        store.actions.preview.sendEvent("eject-block", componentId)
+      },
+      handleEjectBlock: async (componentId, ejectedDefinition) => {
+        let nextSelectedComponentId
+        await store.actions.screens.patch(screen => {
+          const block = findComponent(screen.props, componentId)
+          const parent = findComponentParent(screen.props, componentId)
+
+          // Sanity check
+          if (!block || !parent?._children?.length) {
+            return false
+          }
+
+          // Log event
+          analytics.captureEvent(Events.BLOCK_EJECTED, {
+            block: block._component,
+          })
+
+          // Attach block children back into ejected definition, using the
+          // _containsSlot flag to know where to insert them
+          const slotContainer = findAllMatchingComponents(
+            ejectedDefinition,
+            x => x._containsSlot
+          )[0]
+          if (slotContainer) {
+            delete slotContainer._containsSlot
+            slotContainer._children = [
+              ...(slotContainer._children || []),
+              ...(block._children || []),
+            ]
+          }
+
+          // Replace block with ejected definition
+          ejectedDefinition = makeComponentUnique(ejectedDefinition)
+          const index = parent._children.findIndex(x => x._id === componentId)
+          parent._children[index] = ejectedDefinition
+          nextSelectedComponentId = ejectedDefinition._id
+        })
+
+        // Select new root component
+        if (nextSelectedComponentId) {
+          store.update(state => {
+            state.selectedComponentId = nextSelectedComponentId
+            return state
+          })
+        }
+      },
+      addParent: async (componentId, parentType) => {
+        if (!componentId || !parentType) {
+          return
+        }
+
+        // Create new parent instance
+        const newParentDefinition = store.actions.components.createInstance(
+          parentType,
+          null,
+          parent
+        )
+        if (!newParentDefinition) {
+          return
+        }
+
+        // Replace component with a version wrapped in a new parent
+        await store.actions.screens.patch(screen => {
+          // Get this component definition and parent definition
+          let definition = findComponent(screen.props, componentId)
+          let oldParentDefinition = findComponentParent(
+            screen.props,
+            componentId
+          )
+          if (!definition || !oldParentDefinition) {
+            return false
+          }
+
+          // Replace component with parent
+          const index = oldParentDefinition._children.findIndex(
+            component => component._id === componentId
+          )
+          if (index === -1) {
+            return false
+          }
+          oldParentDefinition._children[index] = {
+            ...newParentDefinition,
+            _children: [definition],
+          }
+        })
+
+        // Select the new parent
+        store.update(state => {
+          state.selectedComponentId = newParentDefinition._id
+          return state
+        })
+      },
+    },
+    links: {
+      save: async (url, title) => {
+        const navigation = get(store).navigation
+        let links = [...(navigation?.links ?? [])]
+
+        // Skip if we have an identical link
+        if (links.find(link => link.url === url && link.text === title)) {
+          return
+        }
+
+        links.push({
+          text: title,
+          url,
+        })
+        await store.actions.navigation.save({
+          ...navigation,
+          links: [...links],
+        })
+      },
+      delete: async urls => {
+        const navigation = get(store).navigation
+        let links = navigation?.links
+        if (!links?.length) {
+          return
+        }
+
+        // Filter out the URLs to delete
+        urls = Array.isArray(urls) ? urls : [urls]
+        links = links.filter(link => !urls.includes(link.url))
+
+        await store.actions.navigation.save({
+          ...navigation,
+          links,
+        })
+      },
+    },
+    settings: {
+      highlight: key => {
+        store.update(state => ({
+          ...state,
+          highlightedSettingKey: key,
+        }))
+      },
+      propertyFocus: key => {
+        store.update(state => ({
+          ...state,
+          propertyFocus: key,
+        }))
+      },
+    },
+    dnd: {
+      start: component => {
+        store.actions.preview.sendEvent("dragging-new-component", {
+          dragging: true,
+          component,
+        })
+      },
+      stop: () => {
+        store.actions.preview.sendEvent("dragging-new-component", {
+          dragging: false,
+        })
+      },
+    },
+    websocket: {
+      selectResource: id => {
+        websocket.emit(BuilderSocketEvent.SelectResource, {
+          resourceId: id,
+        })
+      },
+    },
+    metadata: {
+      replace: metadata => {
+        store.update(state => ({
+          ...state,
+          ...metadata,
+        }))
+      },
+    },
+  }
+
+  return store
+}
diff --git a/packages/builder/src/components/automation/SetupPanel/AutomationBlockSetup.svelte b/packages/builder/src/components/automation/SetupPanel/AutomationBlockSetup.svelte
index 2ba5b0025c..7ba1c8a4b1 100644
--- a/packages/builder/src/components/automation/SetupPanel/AutomationBlockSetup.svelte
+++ b/packages/builder/src/components/automation/SetupPanel/AutomationBlockSetup.svelte
@@ -15,7 +15,6 @@
     Icon,
     Checkbox,
     DatePicker,
-    Detail,
   } from "@budibase/bbui"
   import CreateWebhookModal from "components/automation/Shared/CreateWebhookModal.svelte"
   import { automationStore, selectedAutomation, tables } from "stores/builder"
@@ -32,6 +31,8 @@
   import Editor from "components/integration/QueryEditor.svelte"
   import ModalBindableInput from "components/common/bindings/ModalBindableInput.svelte"
   import CodeEditor from "components/common/CodeEditor/CodeEditor.svelte"
+  import BindingPicker from "components/common/bindings/BindingPicker.svelte"
+  import { BindingHelpers } from "components/common/bindings/utils"
   import {
     bindingsToCompletions,
     hbAutocomplete,
@@ -55,7 +56,7 @@
   let drawer
   let fillWidth = true
   let inputData
-  let codeBindingOpen = false
+  let insertAtPos, getCaretPosition
   $: filters = lookForFilters(schemaProperties) || []
   $: tempFilters = filters
   $: stepId = block.stepId
@@ -74,6 +75,10 @@
   $: isUpdateRow = stepId === ActionStepID.UPDATE_ROW
   $: codeMode =
     stepId === "EXECUTE_BASH" ? EditorModes.Handlebars : EditorModes.JS
+  $: bindingsHelpers = new BindingHelpers(getCaretPosition, insertAtPos, {
+    disableWrapping: true,
+  })
+  $: editingJs = codeMode === EditorModes.JS
 
   $: stepCompletions =
     codeMode === EditorModes.Handlebars
@@ -156,6 +161,7 @@
     let bindings = []
     let loopBlockCount = 0
     const addBinding = (name, value, icon, idx, isLoopBlock, bindingName) => {
+      if (!name) return
       const runtimeBinding = determineRuntimeBinding(name, idx, isLoopBlock)
       const categoryName = determineCategoryName(idx, isLoopBlock, bindingName)
 
@@ -290,7 +296,6 @@
         loopBlockCount++
         continue
       }
-
       Object.entries(schema).forEach(([name, value]) =>
         addBinding(name, value, icon, idx, isLoopBlock, bindingName)
       )
@@ -538,39 +543,51 @@
             />
           {:else if value.customType === "code"}
             <CodeEditorModal>
-              {#if codeMode == EditorModes.JS}
-                <ActionButton
-                  on:click={() => (codeBindingOpen = !codeBindingOpen)}
-                  quiet
-                  icon={codeBindingOpen ? "ChevronDown" : "ChevronRight"}
-                >
-                  <Detail size="S">Bindings</Detail>
-                </ActionButton>
-                {#if codeBindingOpen}
-                  <pre>{JSON.stringify(bindings, null, 2)}</pre>
-                {/if}
-              {/if}
-              <CodeEditor
-                value={inputData[key]}
-                on:change={e => {
-                  // need to pass without the value inside
-                  onChange({ detail: e.detail }, key)
-                  inputData[key] = e.detail
-                }}
-                completions={stepCompletions}
-                mode={codeMode}
-                autocompleteEnabled={codeMode != EditorModes.JS}
-                height={500}
-              />
-              <div class="messaging">
-                {#if codeMode == EditorModes.Handlebars}
-                  <Icon name="FlashOn" />
-                  <div class="messaging-wrap">
-                    <div>
-                      Add available bindings by typing <strong>
-                        &#125;&#125;
-                      </strong>
-                    </div>
+              <div class:js-editor={editingJs}>
+                <div class:js-code={editingJs} style="width: 100%">
+                  <CodeEditor
+                    value={inputData[key]}
+                    on:change={e => {
+                      // need to pass without the value inside
+                      onChange({ detail: e.detail }, key)
+                      inputData[key] = e.detail
+                    }}
+                    completions={stepCompletions}
+                    mode={codeMode}
+                    autocompleteEnabled={codeMode !== EditorModes.JS}
+                    bind:getCaretPosition
+                    bind:insertAtPos
+                    height={500}
+                  />
+                  <div class="messaging">
+                    {#if codeMode === EditorModes.Handlebars}
+                      <Icon name="FlashOn" />
+                      <div class="messaging-wrap">
+                        <div>
+                          Add available bindings by typing <strong>
+                            &#125;&#125;
+                          </strong>
+                        </div>
+                      </div>
+                    {/if}
+                  </div>
+                </div>
+                {#if editingJs}
+                  <div class="js-binding-picker">
+                    <BindingPicker
+                      {bindings}
+                      allowHelpers={false}
+                      addBinding={binding =>
+                        bindingsHelpers.onSelectBinding(
+                          inputData[key],
+                          binding,
+                          {
+                            js: true,
+                            dontDecode: true,
+                          }
+                        )}
+                      mode="javascript"
+                    />
                   </div>
                 {/if}
               </div>
@@ -657,4 +674,20 @@
   .test :global(.drawer) {
     width: 10000px !important;
   }
+
+  .js-editor {
+    display: flex;
+    flex-direction: row;
+    flex-grow: 1;
+    width: 100%;
+  }
+
+  .js-code {
+    flex: 7;
+  }
+
+  .js-binding-picker {
+    flex: 3;
+    margin-top: calc((var(--spacing-xl) * -1) + 1px);
+  }
 </style>
diff --git a/packages/builder/src/components/backend/Datasources/CreateEditRelationship.svelte b/packages/builder/src/components/backend/Datasources/CreateEditRelationship.svelte
index 6978516012..6b9524776c 100644
--- a/packages/builder/src/components/backend/Datasources/CreateEditRelationship.svelte
+++ b/packages/builder/src/components/backend/Datasources/CreateEditRelationship.svelte
@@ -373,6 +373,7 @@
   confirmText="Save"
   onConfirm={saveRelationship}
   disabled={!valid}
+  size="L"
 >
   <div class="headings">
     <Detail>Tables</Detail>
diff --git a/packages/builder/src/components/common/CodeEditor/CodeEditor.svelte b/packages/builder/src/components/common/CodeEditor/CodeEditor.svelte
index f8eb6c1732..f4fa762bce 100644
--- a/packages/builder/src/components/common/CodeEditor/CodeEditor.svelte
+++ b/packages/builder/src/components/common/CodeEditor/CodeEditor.svelte
@@ -54,6 +54,7 @@
   export let placeholder = null
   export let autocompleteEnabled = true
   export let autofocus = false
+  export let jsBindingWrapping = true
 
   // Export a function to expose caret position
   export const getCaretPosition = () => {
@@ -187,7 +188,7 @@
       )
       complete.push(
         EditorView.inputHandler.of((view, from, to, insert) => {
-          if (insert === "$") {
+          if (jsBindingWrapping && insert === "$") {
             let { text } = view.state.doc.lineAt(from)
 
             const left = from ? text.substring(0, from) : ""
diff --git a/packages/builder/src/components/common/CodeEditor/index.js b/packages/builder/src/components/common/CodeEditor/index.js
index 7987deff52..0d71a475f0 100644
--- a/packages/builder/src/components/common/CodeEditor/index.js
+++ b/packages/builder/src/components/common/CodeEditor/index.js
@@ -286,13 +286,20 @@ export const hbInsert = (value, from, to, text) => {
   return parsedInsert
 }
 
-export function jsInsert(value, from, to, text, { helper } = {}) {
+export function jsInsert(
+  value,
+  from,
+  to,
+  text,
+  { helper, disableWrapping } = {}
+) {
   let parsedInsert = ""
 
   const left = from ? value.substring(0, from) : ""
   const right = to ? value.substring(to) : ""
-
-  if (helper) {
+  if (disableWrapping) {
+    parsedInsert = text
+  } else if (helper) {
     parsedInsert = `helpers.${text}()`
   } else if (!left.includes('$("') || !right.includes('")')) {
     parsedInsert = `$("${text}")`
@@ -312,7 +319,7 @@ export const insertBinding = (view, from, to, text, mode) => {
   } else if (mode.name == "handlebars") {
     parsedInsert = hbInsert(view.state.doc?.toString(), from, to, text)
   } else {
-    console.log("Unsupported")
+    console.warn("Unsupported")
     return
   }
 
diff --git a/packages/builder/src/components/common/RelationshipSelector.svelte b/packages/builder/src/components/common/RelationshipSelector.svelte
index 0636deaf08..63f0357a8f 100644
--- a/packages/builder/src/components/common/RelationshipSelector.svelte
+++ b/packages/builder/src/components/common/RelationshipSelector.svelte
@@ -17,7 +17,7 @@
 </script>
 
 <div class="relationship-container">
-  <div class="relationship-part">
+  <div class="relationship-type">
     <Select
       disabled={linkEditDisabled}
       bind:value={relationshipPart1}
@@ -39,7 +39,7 @@
   </div>
 </div>
 <div class="relationship-container">
-  <div class="relationship-part">
+  <div class="relationship-type">
     <Select
       disabled={linkEditDisabled}
       bind:value={relationshipPart2}
@@ -79,6 +79,10 @@
   }
 
   .relationship-part {
-    flex-basis: 60%;
+    flex-basis: 70%;
+  }
+
+  .relationship-type {
+    flex-basis: 30%;
   }
 </style>
diff --git a/packages/builder/src/components/common/bindings/BindingPanel.svelte b/packages/builder/src/components/common/bindings/BindingPanel.svelte
index 798803b735..7b567e052b 100644
--- a/packages/builder/src/components/common/bindings/BindingPanel.svelte
+++ b/packages/builder/src/components/common/bindings/BindingPanel.svelte
@@ -29,10 +29,9 @@
     hbAutocomplete,
     EditorModes,
     bindingsToCompletions,
-    hbInsert,
-    jsInsert,
   } from "../CodeEditor"
   import BindingPicker from "./BindingPicker.svelte"
+  import { BindingHelpers } from "./utils"
 
   const dispatch = createEventDispatcher()
 
@@ -60,8 +59,10 @@
   let targetMode = null
 
   $: usingJS = mode === "JavaScript"
-  $: editorMode = mode == "JavaScript" ? EditorModes.JS : EditorModes.Handlebars
+  $: editorMode =
+    mode === "JavaScript" ? EditorModes.JS : EditorModes.Handlebars
   $: bindingCompletions = bindingsToCompletions(bindings, editorMode)
+  $: bindingHelpers = new BindingHelpers(getCaretPosition, insertAtPos)
 
   const updateValue = val => {
     valid = isValid(readableToRuntimeBinding(bindings, val))
@@ -70,31 +71,13 @@
     }
   }
 
-  // Adds a JS/HBS helper to the expression
   const onSelectHelper = (helper, js) => {
-    const pos = getCaretPosition()
-    const { start, end } = pos
-    if (js) {
-      let js = decodeJSBinding(jsValue)
-      const insertVal = jsInsert(js, start, end, helper.text, { helper: true })
-      insertAtPos({ start, end, value: insertVal })
-    } else {
-      const insertVal = hbInsert(hbsValue, start, end, helper.text)
-      insertAtPos({ start, end, value: insertVal })
-    }
+    bindingHelpers.onSelectHelper(js ? jsValue : hbsValue, helper, { js })
   }
 
-  // Adds a data binding to the expression
   const onSelectBinding = (binding, { forceJS } = {}) => {
-    const { start, end } = getCaretPosition()
-    if (usingJS || forceJS) {
-      let js = decodeJSBinding(jsValue)
-      const insertVal = jsInsert(js, start, end, binding.readableBinding)
-      insertAtPos({ start, end, value: insertVal })
-    } else {
-      const insertVal = hbInsert(hbsValue, start, end, binding.readableBinding)
-      insertAtPos({ start, end, value: insertVal })
-    }
+    const js = usingJS || forceJS
+    bindingHelpers.onSelectBinding(js ? jsValue : hbsValue, binding, { js })
   }
 
   const onChangeMode = e => {
diff --git a/packages/builder/src/components/common/bindings/BindingPicker.svelte b/packages/builder/src/components/common/bindings/BindingPicker.svelte
index 93d9d62021..9daed00324 100644
--- a/packages/builder/src/components/common/bindings/BindingPicker.svelte
+++ b/packages/builder/src/components/common/bindings/BindingPicker.svelte
@@ -9,6 +9,7 @@
   export let bindings
   export let mode
   export let allowHelpers
+  export let noPaddingTop = false
 
   let search = ""
   let popover
@@ -47,9 +48,10 @@
     })
   $: filteredHelpers = helpers?.filter(helper => {
     return (
-      !search ||
-      helper.label.match(searchRgx) ||
-      helper.description.match(searchRgx)
+      (!search ||
+        helper.label.match(searchRgx) ||
+        helper.description.match(searchRgx)) &&
+      (mode.name !== "javascript" || helper.allowsJs)
     )
   })
 
diff --git a/packages/builder/src/components/common/bindings/utils.js b/packages/builder/src/components/common/bindings/utils.js
index 8d414ffed3..a086cd0394 100644
--- a/packages/builder/src/components/common/bindings/utils.js
+++ b/packages/builder/src/components/common/bindings/utils.js
@@ -1,38 +1,41 @@
-export function addHBSBinding(value, caretPos, binding) {
-  binding = typeof binding === "string" ? binding : binding.path
-  value = value == null ? "" : value
+import { decodeJSBinding } from "@budibase/string-templates"
+import { hbInsert, jsInsert } from "components/common/CodeEditor"
 
-  const left = caretPos?.start ? value.substring(0, caretPos.start) : ""
-  const right = caretPos?.end ? value.substring(caretPos.end) : ""
-  if (!left.includes("{{") || !right.includes("}}")) {
-    binding = `{{ ${binding} }}`
+export class BindingHelpers {
+  constructor(getCaretPosition, insertAtPos, { disableWrapping } = {}) {
+    this.getCaretPosition = getCaretPosition
+    this.insertAtPos = insertAtPos
+    this.disableWrapping = disableWrapping
   }
-  if (caretPos.start) {
-    value =
-      value.substring(0, caretPos.start) +
-      binding +
-      value.substring(caretPos.end, value.length)
-  } else {
-    value += binding
-  }
-  return value
-}
 
-export function addJSBinding(value, caretPos, binding, { helper } = {}) {
-  binding = typeof binding === "string" ? binding : binding.path
-  value = value == null ? "" : value
-  if (!helper) {
-    binding = `$("${binding}")`
-  } else {
-    binding = `helpers.${binding}()`
+  // Adds a JS/HBS helper to the expression
+  onSelectHelper(value, helper, { js, dontDecode }) {
+    const pos = this.getCaretPosition()
+    const { start, end } = pos
+    if (js) {
+      const jsVal = dontDecode ? value : decodeJSBinding(value)
+      const insertVal = jsInsert(jsVal, start, end, helper.text, {
+        helper: true,
+      })
+      this.insertAtPos({ start, end, value: insertVal })
+    } else {
+      const insertVal = hbInsert(value, start, end, helper.text)
+      this.insertAtPos({ start, end, value: insertVal })
+    }
   }
-  if (caretPos.start) {
-    value =
-      value.substring(0, caretPos.start) +
-      binding +
-      value.substring(caretPos.end, value.length)
-  } else {
-    value += binding
+
+  // Adds a data binding to the expression
+  onSelectBinding(value, binding, { js, dontDecode }) {
+    const { start, end } = this.getCaretPosition()
+    if (js) {
+      const jsVal = dontDecode ? value : decodeJSBinding(value)
+      const insertVal = jsInsert(jsVal, start, end, binding.readableBinding, {
+        disableWrapping: this.disableWrapping,
+      })
+      this.insertAtPos({ start, end, value: insertVal })
+    } else {
+      const insertVal = hbInsert(value, start, end, binding.readableBinding)
+      this.insertAtPos({ start, end, value: insertVal })
+    }
   }
-  return value
 }
diff --git a/packages/builder/src/components/integration/QueryViewer.svelte b/packages/builder/src/components/integration/QueryViewer.svelte
index e0d7013459..5025e1eec8 100644
--- a/packages/builder/src/components/integration/QueryViewer.svelte
+++ b/packages/builder/src/components/integration/QueryViewer.svelte
@@ -93,7 +93,13 @@
 
       notifications.success("Query executed successfully")
     } catch (error) {
-      notifications.error(`Query Error: ${error.message}`)
+      if (typeof error.message === "string") {
+        notifications.error(`Query Error: ${error.message}`)
+      } else if (typeof error.message?.code === "string") {
+        notifications.error(`Query Error: ${error.message.code}`)
+      } else {
+        notifications.error(`Query Error: ${JSON.stringify(error.message)}`)
+      }
 
       if (!suppressErrors) {
         throw error
diff --git a/packages/builder/src/components/portal/onboarding/TourPopover.svelte b/packages/builder/src/components/portal/onboarding/TourPopover.svelte
index 34beccda6f..23821d73a3 100644
--- a/packages/builder/src/components/portal/onboarding/TourPopover.svelte
+++ b/packages/builder/src/components/portal/onboarding/TourPopover.svelte
@@ -66,7 +66,7 @@
         }))
         navigateStep(target)
       } else {
-        console.log("Could not retrieve step")
+        console.warn("Could not retrieve step")
       }
     } else {
       if (typeof tourStep.onComplete === "function") {
diff --git a/packages/builder/src/components/portal/onboarding/tourHandler.js b/packages/builder/src/components/portal/onboarding/tourHandler.js
index acac21478e..42d35e6d45 100644
--- a/packages/builder/src/components/portal/onboarding/tourHandler.js
+++ b/packages/builder/src/components/portal/onboarding/tourHandler.js
@@ -3,7 +3,7 @@ import { get } from "svelte/store"
 
 const registerNode = async (node, tourStepKey) => {
   if (!node) {
-    console.log("Tour Handler - an anchor node is required")
+    console.warn("Tour Handler - an anchor node is required")
   }
 
   if (!get(builderStore).tourKey) {
diff --git a/packages/builder/src/components/portal/onboarding/tours.js b/packages/builder/src/components/portal/onboarding/tours.js
index d589a68a83..623a00fcc2 100644
--- a/packages/builder/src/components/portal/onboarding/tours.js
+++ b/packages/builder/src/components/portal/onboarding/tours.js
@@ -45,7 +45,7 @@ const endUserOnboarding = async ({ skipped = false } = {}) => {
         onboarding: false,
       }))
     } catch (e) {
-      console.log("Onboarding failed", e)
+      console.error("Onboarding failed", e)
       return false
     }
     return true
diff --git a/packages/builder/src/constants/completions.js b/packages/builder/src/constants/completions.js
index 32de934324..e539a8084a 100644
--- a/packages/builder/src/constants/completions.js
+++ b/packages/builder/src/constants/completions.js
@@ -1,4 +1,4 @@
-import { getManifest } from "@budibase/string-templates"
+import { getManifest, helpersToRemoveForJs } from "@budibase/string-templates"
 
 export function handlebarsCompletions() {
   const manifest = getManifest()
@@ -11,6 +11,9 @@ export function handlebarsCompletions() {
       label: helperName,
       displayText: helperName,
       description: helperConfig.description,
+      allowsJs:
+        !helperConfig.requiresBlock &&
+        !helpersToRemoveForJs.includes(helperName),
     }))
   )
 }
diff --git a/packages/builder/src/dataBinding.js b/packages/builder/src/dataBinding.js
index 589d3b3170..6ec6774b34 100644
--- a/packages/builder/src/dataBinding.js
+++ b/packages/builder/src/dataBinding.js
@@ -1,6 +1,7 @@
 import { cloneDeep } from "lodash/fp"
 import { get } from "svelte/store"
 import {
+  buildContextTreeLookupMap,
   findAllComponents,
   findAllMatchingComponents,
   findComponent,
@@ -22,12 +23,14 @@ import {
   decodeJSBinding,
   encodeJSBinding,
 } from "@budibase/string-templates"
-import { TableNames } from "constants"
-import { JSONUtils } from "@budibase/frontend-core"
+import { TableNames } from "../constants"
+import { JSONUtils, Constants } from "@budibase/frontend-core"
 import ActionDefinitions from "components/design/settings/controls/ButtonActionEditor/manifest.json"
 import { environment, licensing } from "stores/portal"
 import { convertOldFieldFormat } from "components/design/settings/controls/FieldConfiguration/utils"
 
+const { ContextScopes } = Constants
+
 // Regex to match all instances of template strings
 const CAPTURE_VAR_INSIDE_TEMPLATE = /{{([^}]+)}}/g
 const CAPTURE_VAR_INSIDE_JS = /\$\("([^")]+)"\)/g
@@ -217,6 +220,9 @@ export const getComponentContexts = (
     return []
   }
   let map = {}
+  const componentPath = findComponentPath(asset.props, componentId)
+  const componentPathIds = componentPath.map(component => component._id)
+  const contextTreeLookupMap = buildContextTreeLookupMap(asset.props)
 
   // Processes all contexts exposed by a component
   const processContexts = scope => component => {
@@ -224,13 +230,16 @@ export const getComponentContexts = (
     if (!def?.context) {
       return
     }
-    if (!map[component._id]) {
-      map[component._id] = {
-        component,
-        definition: def,
-        contexts: [],
-      }
+
+    // Filter out global contexts not in the same branch.
+    // Global contexts are only valid if their branch root is an ancestor of
+    // this component.
+    const branch = contextTreeLookupMap[component._id]
+    if (branch !== "root" && !componentPathIds.includes(branch)) {
+      return
     }
+
+    // Process all contexts provided by this component
     const contexts = Array.isArray(def.context) ? def.context : [def.context]
     contexts.forEach(context => {
       // Ensure type matches
@@ -238,7 +247,7 @@ export const getComponentContexts = (
         return
       }
       // Ensure scope matches
-      let contextScope = context.scope || "global"
+      let contextScope = context.scope || ContextScopes.Global
       if (contextScope !== scope) {
         return
       }
@@ -246,17 +255,23 @@ export const getComponentContexts = (
       if (!isContextCompatibleWithComponent(context, component)) {
         return
       }
+      if (!map[component._id]) {
+        map[component._id] = {
+          component,
+          definition: def,
+          contexts: [],
+        }
+      }
       map[component._id].contexts.push(context)
     })
   }
 
   // Process all global contexts
   const allComponents = findAllComponents(asset.props)
-  allComponents.forEach(processContexts("global"))
+  allComponents.forEach(processContexts(ContextScopes.Global))
 
-  // Process all local contexts
-  const localComponents = findComponentPath(asset.props, componentId)
-  localComponents.forEach(processContexts("local"))
+  // Process all local contexts in the immediate tree
+  componentPath.forEach(processContexts(ContextScopes.Local))
 
   // Exclude self if required
   if (!options?.includeSelf) {
diff --git a/packages/builder/src/helpers/components.js b/packages/builder/src/helpers/components.js
index a5ca1c1694..65e4f921e1 100644
--- a/packages/builder/src/helpers/components.js
+++ b/packages/builder/src/helpers/components.js
@@ -6,7 +6,10 @@ import {
   encodeJSBinding,
   findHBSBlocks,
 } from "@budibase/string-templates"
-import { capitalise } from "./index"
+import { capitalise } from "helpers"
+import { Constants } from "@budibase/frontend-core"
+
+const { ContextScopes } = Constants
 
 /**
  * Recursively searches for a specific component ID
@@ -222,8 +225,57 @@ export const getComponentName = component => {
 
   const components = get(componentStore)?.components || {}
   const componentDefinition = components[component._component] || {}
-  const name =
-    componentDefinition.friendlyName || componentDefinition.name || ""
-
-  return name
+  return componentDefinition.friendlyName || componentDefinition.name || ""
+}
+
+/**
+ * Recurses through the component tree and builds a tree of contexts provided
+ * by components.
+ */
+export const buildContextTree = (
+  rootComponent,
+  tree = { root: [] },
+  currentBranch = "root"
+) => {
+  // Sanity check
+  if (!rootComponent) {
+    return tree
+  }
+
+  // Process this component's contexts
+  const def = store.actions.components.getDefinition(rootComponent._component)
+  if (def?.context) {
+    tree[currentBranch].push(rootComponent._id)
+    const contexts = Array.isArray(def.context) ? def.context : [def.context]
+
+    // If we provide local context, start a new branch for our children
+    if (contexts.some(context => context.scope === ContextScopes.Local)) {
+      currentBranch = rootComponent._id
+      tree[rootComponent._id] = []
+    }
+  }
+
+  // Process children
+  if (rootComponent._children) {
+    rootComponent._children.forEach(child => {
+      buildContextTree(child, tree, currentBranch)
+    })
+  }
+
+  return tree
+}
+
+/**
+ * Generates a lookup map of which context branch all components in a component
+ * tree are inside.
+ */
+export const buildContextTreeLookupMap = rootComponent => {
+  const tree = buildContextTree(rootComponent)
+  let map = {}
+  Object.entries(tree).forEach(([branch, ids]) => {
+    ids.forEach(id => {
+      map[id] = branch
+    })
+  })
+  return map
 }
diff --git a/packages/builder/src/helpers/urlStateSync.js b/packages/builder/src/helpers/urlStateSync.js
index 2408dde2f1..9337393f06 100644
--- a/packages/builder/src/helpers/urlStateSync.js
+++ b/packages/builder/src/helpers/urlStateSync.js
@@ -52,7 +52,7 @@ export const syncURLToState = options => {
   let cachedPage = get(routify.page)
   let previousParamsHash = null
   let debug = false
-  const log = (...params) => debug && console.log(`[${urlParam}]`, ...params)
+  const log = (...params) => debug && console.debug(`[${urlParam}]`, ...params)
 
   // Navigate to a certain URL
   const gotoUrl = (url, params) => {
diff --git a/packages/builder/src/pages/builder/app/[application]/_components/BuilderSidePanel.svelte b/packages/builder/src/pages/builder/app/[application]/_components/BuilderSidePanel.svelte
index 3b07bde394..77f1ed55b5 100644
--- a/packages/builder/src/pages/builder/app/[application]/_components/BuilderSidePanel.svelte
+++ b/packages/builder/src/pages/builder/app/[application]/_components/BuilderSidePanel.svelte
@@ -106,7 +106,7 @@
       return
     }
     if (!prodAppId) {
-      console.log("Application id required")
+      console.error("Application id required")
       return
     }
     await usersFetch.update({
diff --git a/packages/builder/src/pages/builder/app/[application]/data/datasource/[datasourceId]/index.svelte b/packages/builder/src/pages/builder/app/[application]/data/datasource/[datasourceId]/index.svelte
index 338d45d3de..b723788695 100644
--- a/packages/builder/src/pages/builder/app/[application]/data/datasource/[datasourceId]/index.svelte
+++ b/packages/builder/src/pages/builder/app/[application]/data/datasource/[datasourceId]/index.svelte
@@ -12,12 +12,16 @@
   import PromptQueryModal from "./_components/PromptQueryModal.svelte"
   import SettingsPanel from "./_components/panels/Settings.svelte"
   import { helpers } from "@budibase/shared-core"
+  import { admin } from "stores/portal"
+  import { IntegrationTypes } from "constants/backend"
 
   let selectedPanel = null
   let panelOptions = []
 
   $: datasource = $datasources.selected
 
+  $: isCloud = $admin.cloud
+  $: isPostgres = datasource?.source === IntegrationTypes.POSTGRES
   $: getOptions(datasource)
 
   const getOptions = datasource => {
@@ -41,7 +45,13 @@
     }
     // always the last option for SQL
     if (helpers.isSQL(datasource)) {
-      panelOptions.push("Settings")
+      if (isCloud && isPostgres) {
+        // We don't show the settings panel for Postgres on Budicloud because
+        // it requires pg_dump to work and we don't want to enable shell injection
+        // attacks.
+      } else {
+        panelOptions.push("Settings")
+      }
     }
   }
 </script>
diff --git a/packages/builder/src/pages/builder/app/[application]/design/[screenId]/[componentId]/_components/Navigation/index.svelte b/packages/builder/src/pages/builder/app/[application]/design/[screenId]/[componentId]/_components/Navigation/index.svelte
index 7f118fb034..0aebfc97bd 100644
--- a/packages/builder/src/pages/builder/app/[application]/design/[screenId]/[componentId]/_components/Navigation/index.svelte
+++ b/packages/builder/src/pages/builder/app/[application]/design/[screenId]/[componentId]/_components/Navigation/index.svelte
@@ -15,6 +15,7 @@
     Checkbox,
     notifications,
     Select,
+    Combobox,
   } from "@budibase/bbui"
   import {
     themeStore,
@@ -24,6 +25,10 @@
   } from "stores/builder"
   import { DefaultAppTheme } from "constants"
 
+  $: screenRouteOptions = $store.screens
+    .map(screen => screen.routing?.route)
+    .filter(x => x != null)
+
   const updateShowNavigation = async e => {
     await screenStore.updateSetting(
       get(selectedScreen),
@@ -112,23 +117,6 @@
             on:change={e => update("navWidth", e.detail)}
           />
         {/if}
-        <div class="label">
-          <Label size="M">Show logo</Label>
-        </div>
-        <Checkbox
-          value={!$navigationStore.hideLogo}
-          on:change={e => update("hideLogo", !e.detail)}
-        />
-        {#if !$navigationStore.hideLogo}
-          <div class="label">
-            <Label size="M">Logo URL</Label>
-          </div>
-          <Input
-            value={$navigationStore.logoUrl}
-            on:change={e => update("logoUrl", e.detail)}
-            updateOnChange={false}
-          />
-        {/if}
         <div class="label">
           <Label size="M">Show title</Label>
         </div>
@@ -165,6 +153,47 @@
         />
       </div>
     </div>
+
+    <div class="divider" />
+    <div class="customizeSection">
+      <div class="subheading">
+        <Detail>Logo</Detail>
+      </div>
+      <div class="controls">
+        <div class="label">
+          <Label size="M">Show logo</Label>
+        </div>
+        <Checkbox
+          value={!$store.navigation.hideLogo}
+          on:change={e => update("hideLogo", !e.detail)}
+        />
+        {#if !$store.navigation.hideLogo}
+          <div class="label">
+            <Label size="M">Logo image URL</Label>
+          </div>
+          <Input
+            value={$store.navigation.logoUrl}
+            on:change={e => update("logoUrl", e.detail)}
+            updateOnChange={false}
+          />
+          <div class="label">
+            <Label size="M">Logo link URL</Label>
+          </div>
+          <Combobox
+            value={$store.navigation.logoLinkUrl}
+            on:change={e => update("logoLinkUrl", e.detail)}
+            options={screenRouteOptions}
+          />
+          <div class="label">
+            <Label size="M">New tab</Label>
+          </div>
+          <Checkbox
+            value={!!$store.navigation.openLogoLinkInNewTab}
+            on:change={e => update("openLogoLinkInNewTab", !!e.detail)}
+          />
+        {/if}
+      </div>
+    </div>
   {/if}
 </Panel>
 
diff --git a/packages/builder/src/pages/builder/app/[application]/design/[screenId]/[componentId]/_components/Screen/GeneralPanel.svelte b/packages/builder/src/pages/builder/app/[application]/design/[screenId]/[componentId]/_components/Screen/GeneralPanel.svelte
index 332289f42e..cecfdba858 100644
--- a/packages/builder/src/pages/builder/app/[application]/design/[screenId]/[componentId]/_components/Screen/GeneralPanel.svelte
+++ b/packages/builder/src/pages/builder/app/[application]/design/[screenId]/[componentId]/_components/Screen/GeneralPanel.svelte
@@ -66,7 +66,7 @@
     try {
       await screenStore.updateSetting(get(selectedScreen), key, value)
     } catch (error) {
-      console.log(error)
+      console.error(error)
       notifications.error("Error saving screen settings")
     }
   }
diff --git a/packages/builder/src/pages/builder/app/[application]/design/_components/NewScreen/CreateScreenModal.svelte b/packages/builder/src/pages/builder/app/[application]/design/_components/NewScreen/CreateScreenModal.svelte
index ca0c247b3b..eadd9d4257 100644
--- a/packages/builder/src/pages/builder/app/[application]/design/_components/NewScreen/CreateScreenModal.svelte
+++ b/packages/builder/src/pages/builder/app/[application]/design/_components/NewScreen/CreateScreenModal.svelte
@@ -70,7 +70,7 @@
       $goto(`./${screenId}`)
       screenStore.select(screenId)
     } catch (error) {
-      console.log(error)
+      console.error(error)
       notifications.error("Error creating screens")
     }
   }
diff --git a/packages/builder/src/pages/builder/app/[application]/settings/automations/index.svelte b/packages/builder/src/pages/builder/app/[application]/settings/automations/index.svelte
index 715c154155..d421645ede 100644
--- a/packages/builder/src/pages/builder/app/[application]/settings/automations/index.svelte
+++ b/packages/builder/src/pages/builder/app/[application]/settings/automations/index.svelte
@@ -36,15 +36,12 @@
   let status = null
   let timeRange = null
   let loaded = false
-
-  $: app = $apps.find(app => app.devId === $appStore.appId?.includes(app.appId))
+  $: app = $apps.find(app => $appStore.appId?.includes(app.appId))
   $: licensePlan = $auth.user?.license?.plan
   $: page = $pageInfo.page
   $: fetchLogs(automationId, status, page, timeRange)
   $: isCloud = $admin.cloud
-
   $: chainAutomations = app?.automations?.chainAutomations ?? !isCloud
-
   const timeOptions = [
     { value: "90-d", label: "Past 90 days" },
     { value: "30-d", label: "Past 30 days" },
diff --git a/packages/builder/src/pages/builder/app/[application]/settings/backups/_components/ActionsRenderer.svelte b/packages/builder/src/pages/builder/app/[application]/settings/backups/_components/ActionsRenderer.svelte
index b23cda548f..ffdf14fdce 100644
--- a/packages/builder/src/pages/builder/app/[application]/settings/backups/_components/ActionsRenderer.svelte
+++ b/packages/builder/src/pages/builder/app/[application]/settings/backups/_components/ActionsRenderer.svelte
@@ -12,7 +12,8 @@
   import ConfirmDialog from "components/common/ConfirmDialog.svelte"
   import CreateRestoreModal from "./CreateRestoreModal.svelte"
   import { createEventDispatcher } from "svelte"
-  import { isOnlyUser } from "stores/builder"
+  import { isOnlyUser } from "builderStore"
+  import { BackupType } from "constants/backend/backups"
 
   export let row
 
@@ -42,12 +43,11 @@
 </script>
 
 <div class="cell">
-  <ActionMenu align="right">
-    <div slot="control">
-      <Icon size="M" hoverable name="MoreSmallList" />
-    </div>
-
-    {#if row.type !== "restore"}
+  {#if row.type !== BackupType.RESTORE}
+    <ActionMenu align="right">
+      <div slot="control">
+        <Icon size="M" hoverable name="MoreSmallList" />
+      </div>
       <AbsTooltip
         position={TooltipPosition.Left}
         text="Unavailable - another user is editing this app"
@@ -62,8 +62,8 @@
       </AbsTooltip>
       <MenuItem on:click={deleteDialog.show} icon="Delete">Delete</MenuItem>
       <MenuItem on:click={downloadExport} icon="Download">Download</MenuItem>
-    {/if}
-  </ActionMenu>
+    </ActionMenu>
+  {/if}
 </div>
 
 <Modal bind:this={restoreBackupModal}>
diff --git a/packages/builder/src/pages/builder/auth/login.svelte b/packages/builder/src/pages/builder/auth/login.svelte
index 0ba7e6448b..7bb2a3ad49 100644
--- a/packages/builder/src/pages/builder/auth/login.svelte
+++ b/packages/builder/src/pages/builder/auth/login.svelte
@@ -31,7 +31,7 @@
   async function login() {
     form.validate()
     if (Object.keys(errors).length > 0) {
-      console.log("errors", errors)
+      console.error("errors", errors)
       return
     }
     try {
diff --git a/packages/builder/src/stores/builder/websocket.js b/packages/builder/src/stores/builder/websocket.js
index 4b6874a602..bbdf7b6d63 100644
--- a/packages/builder/src/stores/builder/websocket.js
+++ b/packages/builder/src/stores/builder/websocket.js
@@ -25,7 +25,7 @@ export const createBuilderWebsocket = appId => {
     })
   })
   socket.on("connect_error", err => {
-    console.log("Failed to connect to builder websocket:", err.message)
+    console.error("Failed to connect to builder websocket:", err.message)
   })
   socket.on("disconnect", () => {
     userStore.actions.reset()
diff --git a/packages/client/manifest.json b/packages/client/manifest.json
index 5bbf465766..64d9366423 100644
--- a/packages/client/manifest.json
+++ b/packages/client/manifest.json
@@ -4720,7 +4720,8 @@
       }
     ],
     "context": {
-      "type": "schema"
+      "type": "schema",
+      "scope": "local"
     }
   },
   "daterangepicker": {
@@ -6742,6 +6743,17 @@
         "key": "disabled",
         "defaultValue": false
       },
+      {
+        "type": "boolean",
+        "label": "Read only",
+        "key": "readonly",
+        "defaultValue": false,
+        "dependsOn": {
+          "setting": "disabled",
+          "value": true,
+          "invert": true
+        }
+      },
       {
         "type": "select",
         "label": "Layout",
diff --git a/packages/client/src/components/app/Layout.svelte b/packages/client/src/components/app/Layout.svelte
index 68767c9bfd..903eb23ae6 100644
--- a/packages/client/src/components/app/Layout.svelte
+++ b/packages/client/src/components/app/Layout.svelte
@@ -34,6 +34,8 @@
   export let navTextColor
   export let navWidth
   export let pageWidth
+  export let logoLinkUrl
+  export let openLogoLinkInNewTab
 
   export let embedded = false
 
@@ -151,6 +153,16 @@
     }
     return style
   }
+
+  const getSanitizedUrl = (url, openInNewTab) => {
+    if (!isInternal(url)) {
+      return ensureExternal(url)
+    }
+    if (openInNewTab) {
+      return `#${url}`
+    }
+    return url
+  }
 </script>
 
 <div
@@ -193,7 +205,23 @@
               {/if}
               <div class="logo">
                 {#if !hideLogo}
-                  <img src={logoUrl || "/builder/bblogo.png"} alt={title} />
+                  {#if logoLinkUrl && isInternal(logoLinkUrl) && !openLogoLinkInNewTab}
+                    <a
+                      href={getSanitizedUrl(logoLinkUrl, openLogoLinkInNewTab)}
+                      use:linkable
+                    >
+                      <img src={logoUrl || "/builder/bblogo.png"} alt={title} />
+                    </a>
+                  {:else if logoLinkUrl}
+                    <a
+                      target={openLogoLinkInNewTab ? "_blank" : "_self"}
+                      href={getSanitizedUrl(logoLinkUrl, openLogoLinkInNewTab)}
+                    >
+                      <img src={logoUrl || "/builder/bblogo.png"} alt={title} />
+                    </a>
+                  {:else}
+                    <img src={logoUrl || "/builder/bblogo.png"} alt={title} />
+                  {/if}
                 {/if}
                 {#if !hideTitle && title}
                   <Heading size="S">{title}</Heading>
diff --git a/packages/client/src/components/app/Repeater.svelte b/packages/client/src/components/app/Repeater.svelte
index 8796078311..2d07342cf5 100644
--- a/packages/client/src/components/app/Repeater.svelte
+++ b/packages/client/src/components/app/Repeater.svelte
@@ -2,7 +2,9 @@
   import { getContext } from "svelte"
   import Placeholder from "./Placeholder.svelte"
   import Container from "./Container.svelte"
-  import { ContextScopes } from "constants"
+
+  const { Provider, ContextScopes } = getContext("sdk")
+  const component = getContext("component")
 
   export let dataProvider
   export let noRowsMessage
@@ -12,9 +14,6 @@
   export let gap
   export let scope = ContextScopes.Local
 
-  const { Provider } = getContext("sdk")
-  const component = getContext("component")
-
   $: rows = dataProvider?.rows ?? []
   $: loaded = dataProvider?.loaded ?? true
 </script>
diff --git a/packages/client/src/components/app/embedded-map/EmbeddedMap.svelte b/packages/client/src/components/app/embedded-map/EmbeddedMap.svelte
index 3bb7d5606d..979cb0e085 100644
--- a/packages/client/src/components/app/embedded-map/EmbeddedMap.svelte
+++ b/packages/client/src/components/app/embedded-map/EmbeddedMap.svelte
@@ -307,7 +307,7 @@
       // Reset view
       resetView()
     } catch (e) {
-      console.log("There was a problem with the map", e)
+      console.error("There was a problem with the map", e)
     }
   }
 
diff --git a/packages/client/src/components/app/forms/CodeScanner.svelte b/packages/client/src/components/app/forms/CodeScanner.svelte
index 2a546eb64c..008c0f5727 100644
--- a/packages/client/src/components/app/forms/CodeScanner.svelte
+++ b/packages/client/src/components/app/forms/CodeScanner.svelte
@@ -61,7 +61,7 @@
           resolve({ initialised: true })
         })
         .catch(err => {
-          console.log("There was a problem scanning the image", err)
+          console.error("There was a problem scanning the image", err)
           resolve({ initialised: false })
         })
     })
diff --git a/packages/client/src/components/app/table/SlotRenderer.svelte b/packages/client/src/components/app/table/SlotRenderer.svelte
index dc24f4249c..5d841bab29 100644
--- a/packages/client/src/components/app/table/SlotRenderer.svelte
+++ b/packages/client/src/components/app/table/SlotRenderer.svelte
@@ -3,9 +3,9 @@
 
   export let row
 
-  const { Provider } = getContext("sdk")
+  const { Provider, ContextScopes } = getContext("sdk")
 </script>
 
-<Provider data={row}>
+<Provider data={row} scope={ContextScopes.Local}>
   <slot />
 </Provider>
diff --git a/packages/client/src/components/context/Provider.svelte b/packages/client/src/components/context/Provider.svelte
index 1b6a073512..fe4463821e 100644
--- a/packages/client/src/components/context/Provider.svelte
+++ b/packages/client/src/components/context/Provider.svelte
@@ -1,9 +1,11 @@
 <script>
   import { getContext, setContext, onDestroy } from "svelte"
   import { dataSourceStore, createContextStore } from "stores"
-  import { ActionTypes, ContextScopes } from "constants"
+  import { ActionTypes } from "constants"
   import { generate } from "shortid"
 
+  const { ContextScopes } = getContext("sdk")
+
   export let data
   export let actions
   export let key
@@ -33,7 +35,7 @@
   const provideData = newData => {
     const dataKey = JSON.stringify(newData)
     if (dataKey !== lastDataKey) {
-      context.actions.provideData(providerKey, newData, scope)
+      context.actions.provideData(providerKey, newData)
       lastDataKey = dataKey
     }
   }
@@ -43,7 +45,7 @@
     if (actionsKey !== lastActionsKey) {
       lastActionsKey = actionsKey
       newActions?.forEach(({ type, callback, metadata }) => {
-        context.actions.provideAction(providerKey, type, callback, scope)
+        context.actions.provideAction(providerKey, type, callback)
 
         // Register any "refresh datasource" actions with a singleton store
         // so we can easily refresh data at all levels for any datasource
diff --git a/packages/client/src/constants.js b/packages/client/src/constants.js
index 4c9df42809..a4d7411bbd 100644
--- a/packages/client/src/constants.js
+++ b/packages/client/src/constants.js
@@ -12,10 +12,5 @@ export const ActionTypes = {
   ScrollTo: "ScrollTo",
 }
 
-export const ContextScopes = {
-  Local: "local",
-  Global: "global",
-}
-
 export const DNDPlaceholderID = "dnd-placeholder"
 export const ScreenslotType = "screenslot"
diff --git a/packages/client/src/sdk.js b/packages/client/src/sdk.js
index 0305930ad5..557d5ca8da 100644
--- a/packages/client/src/sdk.js
+++ b/packages/client/src/sdk.js
@@ -24,11 +24,12 @@ import { getAction } from "utils/getAction"
 import Provider from "components/context/Provider.svelte"
 import Block from "components/Block.svelte"
 import BlockComponent from "components/BlockComponent.svelte"
-import { ActionTypes, ContextScopes } from "./constants"
+import { ActionTypes } from "./constants"
 import { fetchDatasourceSchema } from "./utils/schema.js"
 import { getAPIKey } from "./utils/api.js"
 import { enrichButtonActions } from "./utils/buttonActions.js"
 import { processStringSync, makePropSafe } from "@budibase/string-templates"
+import { fetchData, LuceneUtils, Constants } from "@budibase/frontend-core"
 
 export default {
   API,
@@ -56,7 +57,9 @@ export default {
   linkable,
   getAction,
   fetchDatasourceSchema,
-  ContextScopes,
+  fetchData,
+  LuceneUtils,
+  ContextScopes: Constants.ContextScopes,
   getAPIKey,
   enrichButtonActions,
   processStringSync,
diff --git a/packages/client/src/stores/context.js b/packages/client/src/stores/context.js
index e54c773591..c1ec18ef13 100644
--- a/packages/client/src/stores/context.js
+++ b/packages/client/src/stores/context.js
@@ -1,5 +1,4 @@
 import { writable, derived } from "svelte/store"
-import { ContextScopes } from "constants"
 
 export const createContextStore = parentContext => {
   const context = writable({})
@@ -20,60 +19,34 @@ export const createContextStore = parentContext => {
   }
 
   // Provide some data in context
-  const provideData = (providerId, data, scope = ContextScopes.Global) => {
+  const provideData = (providerId, data) => {
     if (!providerId || data === undefined) {
       return
     }
 
-    // Proxy message up the chain if we have a parent and are providing global
-    // context
-    if (scope === ContextScopes.Global && parentContext) {
-      parentContext.actions.provideData(providerId, data, scope)
-    }
-
     // Otherwise this is either the context root, or we're providing a local
     // context override, so we need to update the local context instead
-    else {
-      context.update(state => {
-        state[providerId] = data
-        return state
-      })
-      broadcastChange(providerId)
-    }
+    context.update(state => {
+      state[providerId] = data
+      return state
+    })
+    broadcastChange(providerId)
   }
 
   // Provides some action in context
-  const provideAction = (
-    providerId,
-    actionType,
-    callback,
-    scope = ContextScopes.Global
-  ) => {
+  const provideAction = (providerId, actionType, callback) => {
     if (!providerId || !actionType) {
       return
     }
 
-    // Proxy message up the chain if we have a parent and are providing global
-    // context
-    if (scope === ContextScopes.Global && parentContext) {
-      parentContext.actions.provideAction(
-        providerId,
-        actionType,
-        callback,
-        scope
-      )
-    }
-
     // Otherwise this is either the context root, or we're providing a local
     // context override, so we need to update the local context instead
-    else {
-      const key = `${providerId}_${actionType}`
-      context.update(state => {
-        state[key] = callback
-        return state
-      })
-      broadcastChange(key)
-    }
+    const key = `${providerId}_${actionType}`
+    context.update(state => {
+      state[key] = callback
+      return state
+    })
+    broadcastChange(key)
   }
 
   const observeChanges = callback => {
diff --git a/packages/client/src/stores/org.js b/packages/client/src/stores/org.js
index af0fc955f9..d8a17f7c32 100644
--- a/packages/client/src/stores/org.js
+++ b/packages/client/src/stores/org.js
@@ -14,7 +14,7 @@ const createOrgStore = () => {
       const settingsConfigDoc = await API.getTenantConfig(tenantId)
       set({ logoUrl: settingsConfigDoc.config.logoUrl })
     } catch (e) {
-      console.log("Could not init org ", e)
+      console.error("Could not init org ", e)
     }
   }
 
diff --git a/packages/client/src/utils/buttonActions.js b/packages/client/src/utils/buttonActions.js
index 68b7c84878..ef529985b2 100644
--- a/packages/client/src/utils/buttonActions.js
+++ b/packages/client/src/utils/buttonActions.js
@@ -211,29 +211,27 @@ const deleteRowHandler = async action => {
 
 const triggerAutomationHandler = async action => {
   const { fields, notificationOverride, timeout } = action.parameters
-  if (fields) {
-    try {
-      const result = await API.triggerAutomation({
-        automationId: action.parameters.automationId,
-        fields,
-        timeout,
-      })
-
-      // Value will exist if automation is synchronous, so return it.
-      if (result.value) {
-        if (!notificationOverride) {
-          notificationStore.actions.success("Automation ran successfully")
-        }
-        return { result }
-      }
+  try {
+    const result = await API.triggerAutomation({
+      automationId: action.parameters.automationId,
+      fields,
+      timeout,
+    })
 
+    // Value will exist if automation is synchronous, so return it.
+    if (result.value) {
       if (!notificationOverride) {
-        notificationStore.actions.success("Automation triggered")
+        notificationStore.actions.success("Automation ran successfully")
       }
-    } catch (error) {
-      // Abort next actions
-      return false
+      return { result }
     }
+
+    if (!notificationOverride) {
+      notificationStore.actions.success("Automation triggered")
+    }
+  } catch (error) {
+    // Abort next actions
+    return false
   }
 }
 const navigationHandler = action => {
diff --git a/packages/frontend-core/src/components/grid/lib/websocket.js b/packages/frontend-core/src/components/grid/lib/websocket.js
index af34acd530..b0fd236989 100644
--- a/packages/frontend-core/src/components/grid/lib/websocket.js
+++ b/packages/frontend-core/src/components/grid/lib/websocket.js
@@ -29,7 +29,7 @@ export const createGridWebsocket = context => {
     connectToDatasource(get(datasource))
   })
   socket.on("connect_error", err => {
-    console.log("Failed to connect to grid websocket:", err.message)
+    console.error("Failed to connect to grid websocket:", err.message)
   })
 
   // User events
diff --git a/packages/frontend-core/src/constants.js b/packages/frontend-core/src/constants.js
index 44199ae891..edfdb1c5ef 100644
--- a/packages/frontend-core/src/constants.js
+++ b/packages/frontend-core/src/constants.js
@@ -106,3 +106,8 @@ export const Themes = [
 export const EventPublishType = {
   ENV_VAR_UPGRADE_PANEL_OPENED: "environment_variable_upgrade_panel_opened",
 }
+
+export const ContextScopes = {
+  Local: "local",
+  Global: "global",
+}
diff --git a/packages/pro b/packages/pro
index eb9565f568..aaf7101cd1 160000
--- a/packages/pro
+++ b/packages/pro
@@ -1 +1 @@
-Subproject commit eb9565f568cfef14b336b14eee753119acfdd43b
+Subproject commit aaf7101cd1493215155cc8f83124c70d53eb1be4
diff --git a/packages/server/__mocks__/aws-sdk.ts b/packages/server/__mocks__/aws-sdk.ts
index fa6d099f56..e6a624c83e 100644
--- a/packages/server/__mocks__/aws-sdk.ts
+++ b/packages/server/__mocks__/aws-sdk.ts
@@ -1,7 +1,13 @@
+import fs from "fs"
+import { join } from "path"
+
 module AwsMock {
   const aws: any = {}
 
-  const response = (body: any) => () => ({ promise: () => body })
+  const response = (body: any, extra?: any) => () => ({
+    promise: () => body,
+    ...extra,
+  })
 
   function DocumentClient() {
     // @ts-ignore
@@ -73,9 +79,18 @@ module AwsMock {
 
     // @ts-ignore
     this.getObject = jest.fn(
-      response({
-        Body: "",
-      })
+      response(
+        {
+          Body: "",
+        },
+        {
+          createReadStream: jest
+            .fn()
+            .mockReturnValue(
+              fs.createReadStream(join(__dirname, "aws-sdk.ts"))
+            ),
+        }
+      )
     )
   }
 
diff --git a/packages/server/src/api/controllers/application.ts b/packages/server/src/api/controllers/application.ts
index 70298c7172..33582cf656 100644
--- a/packages/server/src/api/controllers/application.ts
+++ b/packages/server/src/api/controllers/application.ts
@@ -445,6 +445,9 @@ export async function update(ctx: UserCtx) {
     name: app.name,
     url: app.url,
     icon: app.icon,
+    automations: {
+      chainAutomations: app.automations?.chainAutomations,
+    },
   })
 }
 
diff --git a/packages/server/src/api/controllers/query/index.ts b/packages/server/src/api/controllers/query/index.ts
index d38df00443..1be836b169 100644
--- a/packages/server/src/api/controllers/query/index.ts
+++ b/packages/server/src/api/controllers/query/index.ts
@@ -15,6 +15,9 @@ import {
   SessionCookie,
   QuerySchema,
   FieldType,
+  type ExecuteQueryRequest,
+  type ExecuteQueryResponse,
+  type Row,
 } from "@budibase/types"
 import { ValidQueryNameRegex } from "@budibase/shared-core"
 
@@ -223,7 +226,7 @@ export async function preview(ctx: UserCtx) {
 }
 
 async function execute(
-  ctx: UserCtx,
+  ctx: UserCtx<ExecuteQueryRequest, ExecuteQueryResponse | Row[]>,
   opts: any = { rowsOnly: false, isAutomation: false }
 ) {
   const db = context.getAppDB()
diff --git a/packages/server/src/api/routes/tests/queries/mongodb.spec.ts b/packages/server/src/api/routes/tests/queries/mongodb.spec.ts
new file mode 100644
index 0000000000..b61f905bef
--- /dev/null
+++ b/packages/server/src/api/routes/tests/queries/mongodb.spec.ts
@@ -0,0 +1,393 @@
+import { Datasource, Query } from "@budibase/types"
+import * as setup from "../utilities"
+import { databaseTestProviders } from "../../../../integrations/tests/utils"
+import { MongoClient, type Collection, BSON } from "mongodb"
+
+jest.unmock("mongodb")
+
+const collection = "test_collection"
+
+const expectValidId = expect.stringMatching(/^\w{24}$/)
+const expectValidBsonObjectId = expect.any(BSON.ObjectId)
+
+describe("/queries", () => {
+  let config = setup.getConfig()
+  let datasource: Datasource
+
+  async function createQuery(query: Partial<Query>): Promise<Query> {
+    const defaultQuery: Query = {
+      datasourceId: datasource._id!,
+      name: "New Query",
+      parameters: [],
+      fields: {},
+      schema: {},
+      queryVerb: "read",
+      transformer: "return data",
+      readable: true,
+    }
+    const combinedQuery = { ...defaultQuery, ...query }
+    if (
+      combinedQuery.fields &&
+      combinedQuery.fields.extra &&
+      !combinedQuery.fields.extra.collection
+    ) {
+      combinedQuery.fields.extra.collection = collection
+    }
+    return await config.api.query.create(combinedQuery)
+  }
+
+  async function withClient(
+    callback: (client: MongoClient) => Promise<void>
+  ): Promise<void> {
+    const ds = await databaseTestProviders.mongodb.datasource()
+    const client = new MongoClient(ds.config!.connectionString)
+    await client.connect()
+    try {
+      await callback(client)
+    } finally {
+      await client.close()
+    }
+  }
+
+  async function withCollection(
+    callback: (collection: Collection) => Promise<void>
+  ): Promise<void> {
+    await withClient(async client => {
+      const db = client.db(
+        (await databaseTestProviders.mongodb.datasource()).config!.db
+      )
+      await callback(db.collection(collection))
+    })
+  }
+
+  afterAll(async () => {
+    await databaseTestProviders.mongodb.stop()
+    setup.afterAll()
+  })
+
+  beforeAll(async () => {
+    await config.init()
+    datasource = await config.api.datasource.create(
+      await databaseTestProviders.mongodb.datasource()
+    )
+  })
+
+  beforeEach(async () => {
+    await withCollection(async collection => {
+      await collection.insertMany([
+        { name: "one" },
+        { name: "two" },
+        { name: "three" },
+        { name: "four" },
+        { name: "five" },
+      ])
+    })
+  })
+
+  afterEach(async () => {
+    await withCollection(async collection => {
+      await collection.drop()
+    })
+  })
+
+  it("should execute a count query", async () => {
+    const query = await createQuery({
+      fields: {
+        json: {},
+        extra: {
+          actionType: "count",
+        },
+      },
+    })
+
+    const result = await config.api.query.execute(query._id!)
+
+    expect(result.data).toEqual([{ value: 5 }])
+  })
+
+  it("should execute a count query with a transformer", async () => {
+    const query = await createQuery({
+      fields: {
+        json: {},
+        extra: {
+          actionType: "count",
+        },
+      },
+      transformer: "return data + 1",
+    })
+
+    const result = await config.api.query.execute(query._id!)
+
+    expect(result.data).toEqual([{ value: 6 }])
+  })
+
+  it("should execute a find query", async () => {
+    const query = await createQuery({
+      fields: {
+        json: {},
+        extra: {
+          actionType: "find",
+        },
+      },
+    })
+
+    const result = await config.api.query.execute(query._id!)
+
+    expect(result.data).toEqual([
+      { _id: expectValidId, name: "one" },
+      { _id: expectValidId, name: "two" },
+      { _id: expectValidId, name: "three" },
+      { _id: expectValidId, name: "four" },
+      { _id: expectValidId, name: "five" },
+    ])
+  })
+
+  it("should execute a findOne query", async () => {
+    const query = await createQuery({
+      fields: {
+        json: {},
+        extra: {
+          actionType: "findOne",
+        },
+      },
+    })
+
+    const result = await config.api.query.execute(query._id!)
+
+    expect(result.data).toEqual([{ _id: expectValidId, name: "one" }])
+  })
+
+  it("should execute a findOneAndUpdate query", async () => {
+    const query = await createQuery({
+      fields: {
+        json: {
+          filter: { name: { $eq: "one" } },
+          update: { $set: { name: "newName" } },
+        },
+        extra: {
+          actionType: "findOneAndUpdate",
+        },
+      },
+    })
+
+    const result = await config.api.query.execute(query._id!)
+
+    expect(result.data).toEqual([
+      {
+        lastErrorObject: { n: 1, updatedExisting: true },
+        ok: 1,
+        value: { _id: expectValidId, name: "one" },
+      },
+    ])
+
+    await withCollection(async collection => {
+      expect(await collection.countDocuments()).toBe(5)
+
+      const doc = await collection.findOne({ name: { $eq: "newName" } })
+      expect(doc).toEqual({
+        _id: expectValidBsonObjectId,
+        name: "newName",
+      })
+    })
+  })
+
+  it("should execute a distinct query", async () => {
+    const query = await createQuery({
+      fields: {
+        json: "name",
+        extra: {
+          actionType: "distinct",
+        },
+      },
+    })
+
+    const result = await config.api.query.execute(query._id!)
+    const values = result.data.map(o => o.value).sort()
+    expect(values).toEqual(["five", "four", "one", "three", "two"])
+  })
+
+  it("should execute a create query with parameters", async () => {
+    const query = await createQuery({
+      fields: {
+        json: { foo: "{{ foo }}" },
+        extra: {
+          actionType: "insertOne",
+        },
+      },
+      queryVerb: "create",
+      parameters: [
+        {
+          name: "foo",
+          default: "default",
+        },
+      ],
+    })
+
+    const result = await config.api.query.execute(query._id!, {
+      parameters: { foo: "bar" },
+    })
+
+    expect(result.data).toEqual([
+      {
+        acknowledged: true,
+        insertedId: expectValidId,
+      },
+    ])
+
+    await withCollection(async collection => {
+      const doc = await collection.findOne({ foo: { $eq: "bar" } })
+      expect(doc).toEqual({
+        _id: expectValidBsonObjectId,
+        foo: "bar",
+      })
+    })
+  })
+
+  it("should execute a delete query with parameters", async () => {
+    const query = await createQuery({
+      fields: {
+        json: { name: { $eq: "{{ name }}" } },
+        extra: {
+          actionType: "deleteOne",
+        },
+      },
+      queryVerb: "delete",
+      parameters: [
+        {
+          name: "name",
+          default: "",
+        },
+      ],
+    })
+
+    const result = await config.api.query.execute(query._id!, {
+      parameters: { name: "one" },
+    })
+
+    expect(result.data).toEqual([
+      {
+        acknowledged: true,
+        deletedCount: 1,
+      },
+    ])
+
+    await withCollection(async collection => {
+      const doc = await collection.findOne({ name: { $eq: "one" } })
+      expect(doc).toBeNull()
+    })
+  })
+
+  it("should execute an update query with parameters", async () => {
+    const query = await createQuery({
+      fields: {
+        json: {
+          filter: { name: { $eq: "{{ name }}" } },
+          update: { $set: { name: "{{ newName }}" } },
+        },
+        extra: {
+          actionType: "updateOne",
+        },
+      },
+      queryVerb: "update",
+      parameters: [
+        {
+          name: "name",
+          default: "",
+        },
+        {
+          name: "newName",
+          default: "",
+        },
+      ],
+    })
+
+    const result = await config.api.query.execute(query._id!, {
+      parameters: { name: "one", newName: "newOne" },
+    })
+
+    expect(result.data).toEqual([
+      {
+        acknowledged: true,
+        matchedCount: 1,
+        modifiedCount: 1,
+        upsertedCount: 0,
+        upsertedId: null,
+      },
+    ])
+
+    await withCollection(async collection => {
+      const doc = await collection.findOne({ name: { $eq: "newOne" } })
+      expect(doc).toEqual({
+        _id: expectValidBsonObjectId,
+        name: "newOne",
+      })
+
+      const oldDoc = await collection.findOne({ name: { $eq: "one" } })
+      expect(oldDoc).toBeNull()
+    })
+  })
+
+  it("should be able to delete all records", async () => {
+    const query = await createQuery({
+      fields: {
+        json: {},
+        extra: {
+          actionType: "deleteMany",
+        },
+      },
+      queryVerb: "delete",
+    })
+
+    const result = await config.api.query.execute(query._id!)
+
+    expect(result.data).toEqual([
+      {
+        acknowledged: true,
+        deletedCount: 5,
+      },
+    ])
+
+    await withCollection(async collection => {
+      const docs = await collection.find().toArray()
+      expect(docs).toHaveLength(0)
+    })
+  })
+
+  it("should be able to update all documents", async () => {
+    const query = await createQuery({
+      fields: {
+        json: {
+          filter: {},
+          update: { $set: { name: "newName" } },
+        },
+        extra: {
+          actionType: "updateMany",
+        },
+      },
+      queryVerb: "update",
+    })
+
+    const result = await config.api.query.execute(query._id!)
+
+    expect(result.data).toEqual([
+      {
+        acknowledged: true,
+        matchedCount: 5,
+        modifiedCount: 5,
+        upsertedCount: 0,
+        upsertedId: null,
+      },
+    ])
+
+    await withCollection(async collection => {
+      const docs = await collection.find().toArray()
+      expect(docs).toHaveLength(5)
+      for (const doc of docs) {
+        expect(doc).toEqual({
+          _id: expectValidBsonObjectId,
+          name: "newName",
+        })
+      }
+    })
+  })
+})
diff --git a/packages/server/src/api/routes/tests/queries/postgres.spec.ts b/packages/server/src/api/routes/tests/queries/postgres.spec.ts
new file mode 100644
index 0000000000..487644e787
--- /dev/null
+++ b/packages/server/src/api/routes/tests/queries/postgres.spec.ts
@@ -0,0 +1,170 @@
+import { Datasource, Query } from "@budibase/types"
+import * as setup from "../utilities"
+import { databaseTestProviders } from "../../../../integrations/tests/utils"
+import { Client } from "pg"
+
+jest.unmock("pg")
+
+const createTableSQL = `
+CREATE TABLE test_table (
+    id serial PRIMARY KEY,
+    name VARCHAR ( 50 ) NOT NULL
+);
+`
+
+const insertSQL = `
+INSERT INTO test_table (name) VALUES ('one');
+INSERT INTO test_table (name) VALUES ('two');
+INSERT INTO test_table (name) VALUES ('three');
+INSERT INTO test_table (name) VALUES ('four');
+INSERT INTO test_table (name) VALUES ('five');
+`
+
+const dropTableSQL = `
+DROP TABLE test_table;
+`
+
+describe("/queries", () => {
+  let config = setup.getConfig()
+  let datasource: Datasource
+
+  async function createQuery(query: Partial<Query>): Promise<Query> {
+    const defaultQuery: Query = {
+      datasourceId: datasource._id!,
+      name: "New Query",
+      parameters: [],
+      fields: {},
+      schema: {},
+      queryVerb: "read",
+      transformer: "return data",
+      readable: true,
+    }
+    return await config.api.query.create({ ...defaultQuery, ...query })
+  }
+
+  async function withClient(
+    callback: (client: Client) => Promise<void>
+  ): Promise<void> {
+    const ds = await databaseTestProviders.postgres.datasource()
+    const client = new Client(ds.config!)
+    await client.connect()
+    try {
+      await callback(client)
+    } finally {
+      await client.end()
+    }
+  }
+
+  afterAll(async () => {
+    await databaseTestProviders.postgres.stop()
+    setup.afterAll()
+  })
+
+  beforeAll(async () => {
+    await config.init()
+    datasource = await config.api.datasource.create(
+      await databaseTestProviders.postgres.datasource()
+    )
+  })
+
+  beforeEach(async () => {
+    await withClient(async client => {
+      await client.query(createTableSQL)
+      await client.query(insertSQL)
+    })
+  })
+
+  afterEach(async () => {
+    await withClient(async client => {
+      await client.query(dropTableSQL)
+    })
+  })
+
+  it("should execute a query", async () => {
+    const query = await createQuery({
+      fields: {
+        sql: "SELECT * FROM test_table ORDER BY id",
+      },
+    })
+
+    const result = await config.api.query.execute(query._id!)
+
+    expect(result.data).toEqual([
+      {
+        id: 1,
+        name: "one",
+      },
+      {
+        id: 2,
+        name: "two",
+      },
+      {
+        id: 3,
+        name: "three",
+      },
+      {
+        id: 4,
+        name: "four",
+      },
+      {
+        id: 5,
+        name: "five",
+      },
+    ])
+  })
+
+  it("should be able to transform a query", async () => {
+    const query = await createQuery({
+      fields: {
+        sql: "SELECT * FROM test_table WHERE id = 1",
+      },
+      transformer: `
+        data[0].id = data[0].id + 1;
+        return data;
+      `,
+    })
+
+    const result = await config.api.query.execute(query._id!)
+
+    expect(result.data).toEqual([
+      {
+        id: 2,
+        name: "one",
+      },
+    ])
+  })
+
+  it("should be able to insert with bindings", async () => {
+    const query = await createQuery({
+      fields: {
+        sql: "INSERT INTO test_table (name) VALUES ({{ foo }})",
+      },
+      parameters: [
+        {
+          name: "foo",
+          default: "bar",
+        },
+      ],
+      queryVerb: "create",
+    })
+
+    const result = await config.api.query.execute(query._id!, {
+      parameters: {
+        foo: "baz",
+      },
+    })
+
+    expect(result.data).toEqual([
+      {
+        created: true,
+      },
+    ])
+
+    await withClient(async client => {
+      const { rows } = await client.query(
+        "SELECT * FROM test_table WHERE name = 'baz'"
+      )
+      expect(rows).toHaveLength(1)
+    })
+  })
+})
diff --git a/packages/server/src/api/routes/tests/query.seq.spec.ts b/packages/server/src/api/routes/tests/queries/query.seq.spec.ts
similarity index 99%
rename from packages/server/src/api/routes/tests/query.seq.spec.ts
rename to packages/server/src/api/routes/tests/queries/query.seq.spec.ts
index 2790a9d8bf..ba41ba3d16 100644
--- a/packages/server/src/api/routes/tests/query.seq.spec.ts
+++ b/packages/server/src/api/routes/tests/queries/query.seq.spec.ts
@@ -16,9 +16,9 @@ jest.mock("@budibase/backend-core", () => {
     },
   }
 })
-import * as setup from "./utilities"
-import { checkBuilderEndpoint } from "./utilities/TestFunctions"
-import { checkCacheForDynamicVariable } from "../../../threads/utils"
+import * as setup from "../utilities"
+import { checkBuilderEndpoint } from "../utilities/TestFunctions"
+import { checkCacheForDynamicVariable } from "../../../../threads/utils"
 
 const { basicQuery, basicDatasource } = setup.structures
 import { events, db as dbCore } from "@budibase/backend-core"
diff --git a/packages/server/src/api/routes/tests/row.spec.ts b/packages/server/src/api/routes/tests/row.spec.ts
index f481fa8068..637033c1d0 100644
--- a/packages/server/src/api/routes/tests/row.spec.ts
+++ b/packages/server/src/api/routes/tests/row.spec.ts
@@ -12,7 +12,6 @@ import {
   FieldTypeSubtypes,
   FormulaType,
   INTERNAL_TABLE_SOURCE_ID,
-  MonthlyQuotaName,
   PermissionLevel,
   QuotaUsageType,
   RelationshipType,
@@ -53,7 +52,7 @@ describe.each([
 
   afterAll(async () => {
     if (dsProvider) {
-      await dsProvider.stopContainer()
+      await dsProvider.stop()
     }
     setup.afterAll()
   })
@@ -63,7 +62,7 @@ describe.each([
 
     if (dsProvider) {
       await config.createDatasource({
-        datasource: await dsProvider.getDsConfig(),
+        datasource: await dsProvider.datasource(),
       })
     }
   })
@@ -117,16 +116,6 @@ describe.each([
     return total
   }
 
-  const getQueryUsage = async () => {
-    const { total } = await config.doInContext(null, () =>
-      quotas.getCurrentUsageValues(
-        QuotaUsageType.MONTHLY,
-        MonthlyQuotaName.QUERIES
-      )
-    )
-    return total
-  }
-
   const assertRowUsage = async (expected: number) => {
     const usage = await getRowUsage()
     expect(usage).toBe(expected)
@@ -162,7 +151,6 @@ describe.each([
   describe("save, load, update", () => {
     it("returns a success message when the row is created", async () => {
       const rowUsage = await getRowUsage()
-      const queryUsage = await getQueryUsage()
 
       const res = await request
         .post(`/api/${tableId}/rows`)
@@ -180,7 +168,6 @@ describe.each([
 
     it("Increment row autoId per create row request", async () => {
       const rowUsage = await getRowUsage()
-      const queryUsage = await getQueryUsage()
 
       const tableConfig = generateTableConfig()
       const newTable = await createTable(
@@ -231,7 +218,6 @@ describe.each([
     it("updates a row successfully", async () => {
       const existing = await config.createRow()
       const rowUsage = await getRowUsage()
-      const queryUsage = await getQueryUsage()
 
       const res = await config.api.row.save(tableId, {
         _id: existing._id,
@@ -246,7 +232,6 @@ describe.each([
 
     it("should load a row", async () => {
       const existing = await config.createRow()
-      const queryUsage = await getQueryUsage()
 
       const res = await config.api.row.get(tableId, existing._id!)
 
@@ -268,7 +253,6 @@ describe.each([
       }
       const firstRow = await config.createRow({ tableId })
       await config.createRow(newRow)
-      const queryUsage = await getQueryUsage()
 
       const res = await config.api.row.fetch(tableId)
 
@@ -279,7 +263,6 @@ describe.each([
 
     it("load should return 404 when row does not exist", async () => {
       await config.createRow()
-      const queryUsage = await getQueryUsage()
 
       await config.api.row.get(tableId, "1234567", {
         expectStatus: 404,
@@ -530,7 +513,6 @@ describe.each([
       const existing = await config.createRow()
 
       const rowUsage = await getRowUsage()
-      const queryUsage = await getQueryUsage()
 
       const row = await config.api.row.patch(table._id!, {
         _id: existing._id!,
@@ -552,7 +534,6 @@ describe.each([
     it("should throw an error when given improper types", async () => {
       const existing = await config.createRow()
       const rowUsage = await getRowUsage()
-      const queryUsage = await getQueryUsage()
 
       await config.api.row.patch(
         table._id!,
@@ -650,7 +631,6 @@ describe.each([
     it("should be able to delete a row", async () => {
       const createdRow = await config.createRow()
       const rowUsage = await getRowUsage()
-      const queryUsage = await getQueryUsage()
 
       const res = await config.api.row.delete(table._id!, [createdRow])
       expect(res.body[0]._id).toEqual(createdRow._id)
@@ -666,7 +646,6 @@ describe.each([
 
     it("should return no errors on valid row", async () => {
       const rowUsage = await getRowUsage()
-      const queryUsage = await getQueryUsage()
 
       const res = await config.api.row.validate(table._id!, { name: "ivan" })
 
@@ -677,7 +656,6 @@ describe.each([
 
     it("should errors on invalid row", async () => {
       const rowUsage = await getRowUsage()
-      const queryUsage = await getQueryUsage()
 
       const res = await config.api.row.validate(table._id!, { name: 1 })
 
@@ -703,7 +681,6 @@ describe.each([
       const row1 = await config.createRow()
       const row2 = await config.createRow()
       const rowUsage = await getRowUsage()
-      const queryUsage = await getQueryUsage()
 
       const res = await config.api.row.delete(table._id!, [row1, row2])
 
@@ -719,7 +696,6 @@ describe.each([
         config.createRow(),
       ])
       const rowUsage = await getRowUsage()
-      const queryUsage = await getQueryUsage()
 
       const res = await config.api.row.delete(table._id!, [
         row1,
@@ -735,7 +711,6 @@ describe.each([
     it("should accept a valid row object and delete the row", async () => {
       const row1 = await config.createRow()
       const rowUsage = await getRowUsage()
-      const queryUsage = await getQueryUsage()
 
       const res = await config.api.row.delete(table._id!, row1)
 
@@ -746,7 +721,6 @@ describe.each([
 
     it("Should ignore malformed/invalid delete requests", async () => {
       const rowUsage = await getRowUsage()
-      const queryUsage = await getQueryUsage()
 
       const res = await config.api.row.delete(
         table._id!,
@@ -782,7 +756,6 @@ describe.each([
       it("should be able to fetch tables contents via 'view'", async () => {
         const row = await config.createRow()
         const rowUsage = await getRowUsage()
-        const queryUsage = await getQueryUsage()
 
         const res = await config.api.legacyView.get(table._id!)
         expect(res.body.length).toEqual(1)
@@ -792,7 +765,6 @@ describe.each([
 
       it("should throw an error if view doesn't exist", async () => {
         const rowUsage = await getRowUsage()
-        const queryUsage = await getQueryUsage()
 
         await config.api.legacyView.get("derp", { expectStatus: 404 })
 
@@ -808,7 +780,6 @@ describe.each([
         })
         const row = await config.createRow()
         const rowUsage = await getRowUsage()
-        const queryUsage = await getQueryUsage()
 
         const res = await config.api.legacyView.get(view.name)
         expect(res.body.length).toEqual(1)
@@ -864,7 +835,6 @@ describe.each([
         }
       )
       const rowUsage = await getRowUsage()
-      const queryUsage = await getQueryUsage()
 
       // test basic enrichment
       const resBasic = await config.api.row.get(
@@ -1100,7 +1070,6 @@ describe.each([
 
         const createdRow = await config.createRow()
         const rowUsage = await getRowUsage()
-        const queryUsage = await getQueryUsage()
 
         await config.api.row.delete(view.id, [createdRow])
 
@@ -1127,7 +1096,6 @@ describe.each([
           config.createRow(),
         ])
         const rowUsage = await getRowUsage()
-        const queryUsage = await getQueryUsage()
 
         await config.api.row.delete(view.id, [rows[0], rows[2]])
 
diff --git a/packages/server/src/integration-test/postgres.spec.ts b/packages/server/src/integration-test/postgres.spec.ts
index 600566c813..0031fe1136 100644
--- a/packages/server/src/integration-test/postgres.spec.ts
+++ b/packages/server/src/integration-test/postgres.spec.ts
@@ -41,12 +41,12 @@ describe("postgres integrations", () => {
     makeRequest = generateMakeRequest(apiKey, true)
 
     postgresDatasource = await config.api.datasource.create(
-      await databaseTestProviders.postgres.getDsConfig()
+      await databaseTestProviders.postgres.datasource()
     )
   })
 
   afterAll(async () => {
-    await databaseTestProviders.postgres.stopContainer()
+    await databaseTestProviders.postgres.stop()
   })
 
   beforeEach(async () => {
@@ -1041,14 +1041,14 @@ describe("postgres integrations", () => {
   describe("POST /api/datasources/verify", () => {
     it("should be able to verify the connection", async () => {
       const response = await config.api.datasource.verify({
-        datasource: await databaseTestProviders.postgres.getDsConfig(),
+        datasource: await databaseTestProviders.postgres.datasource(),
       })
       expect(response.status).toBe(200)
       expect(response.body.connected).toBe(true)
     })
 
     it("should state an invalid datasource cannot connect", async () => {
-      const dbConfig = await databaseTestProviders.postgres.getDsConfig()
+      const dbConfig = await databaseTestProviders.postgres.datasource()
       const response = await config.api.datasource.verify({
         datasource: {
           ...dbConfig,
@@ -1082,7 +1082,7 @@ describe("postgres integrations", () => {
 
     beforeEach(async () => {
       client = new Client(
-        (await databaseTestProviders.postgres.getDsConfig()).config!
+        (await databaseTestProviders.postgres.datasource()).config!
       )
       await client.connect()
     })
@@ -1125,7 +1125,7 @@ describe("postgres integrations", () => {
       schema2 = "test-2"
 
     beforeAll(async () => {
-      const dsConfig = await databaseTestProviders.postgres.getDsConfig()
+      const dsConfig = await databaseTestProviders.postgres.datasource()
       const dbConfig = dsConfig.config!
 
       client = new Client(dbConfig)
diff --git a/packages/server/src/integrations/postgres.ts b/packages/server/src/integrations/postgres.ts
index 78955c06dc..9949dee6bb 100644
--- a/packages/server/src/integrations/postgres.ts
+++ b/packages/server/src/integrations/postgres.ts
@@ -29,6 +29,7 @@ import { Client, ClientConfig, types } from "pg"
 import { getReadableErrorMessage } from "./base/errorMapping"
 import { exec } from "child_process"
 import { storeTempFile } from "../utilities/fileSystem"
+import { env } from "@budibase/backend-core"
 
 // Return "date" and "timestamp" types as plain strings.
 // This lets us reference the original stored timezone.
@@ -202,8 +203,13 @@ class PostgresIntegration extends Sql implements DatasourcePlus {
       await this.openConnection()
       response.connected = true
     } catch (e: any) {
-      console.log(e)
-      response.error = e.message as string
+      if (typeof e.message === "string" && e.message !== "") {
+        response.error = e.message as string
+      } else if (typeof e.code === "string" && e.code !== "") {
+        response.error = e.code
+      } else {
+        response.error = "Unknown error"
+      }
     } finally {
       await this.closeConnection()
     }
@@ -428,6 +434,14 @@ class PostgresIntegration extends Sql implements DatasourcePlus {
   }
 
   async getExternalSchema() {
+    if (!env.SELF_HOSTED) {
+      // This is because it relies on shelling out to pg_dump and we don't want
+      // to enable shell injection attacks.
+      throw new Error(
+        "schema export for Postgres is not supported in Budibase Cloud"
+      )
+    }
+
     const dumpCommandParts = [
       `user=${this.config.user}`,
       `host=${this.config.host}`,
diff --git a/packages/server/src/integrations/tests/utils/index.ts b/packages/server/src/integrations/tests/utils/index.ts
index a28141db08..77fb5d7128 100644
--- a/packages/server/src/integrations/tests/utils/index.ts
+++ b/packages/server/src/integrations/tests/utils/index.ts
@@ -1,14 +1,16 @@
 jest.unmock("pg")
 
 import { Datasource } from "@budibase/types"
-import * as pg from "./postgres"
+import * as postgres from "./postgres"
+import * as mongodb from "./mongodb"
+import { StartedTestContainer } from "testcontainers"
 
 jest.setTimeout(30000)
 
-export interface DatabasePlusTestProvider {
-  getDsConfig(): Promise<Datasource>
+export interface DatabaseProvider {
+  start(): Promise<StartedTestContainer>
+  stop(): Promise<void>
+  datasource(): Promise<Datasource>
 }
 
-export const databaseTestProviders = {
-  postgres: pg,
-}
+export const databaseTestProviders = { postgres, mongodb }
diff --git a/packages/server/src/integrations/tests/utils/mongodb.ts b/packages/server/src/integrations/tests/utils/mongodb.ts
new file mode 100644
index 0000000000..ebd76e4baf
--- /dev/null
+++ b/packages/server/src/integrations/tests/utils/mongodb.ts
@@ -0,0 +1,41 @@
+import { Datasource, SourceName } from "@budibase/types"
+import { GenericContainer, Wait, StartedTestContainer } from "testcontainers"
+
+let container: StartedTestContainer | undefined
+
+export async function start(): Promise<StartedTestContainer> {
+  return await new GenericContainer("mongo:7.0-jammy")
+    .withExposedPorts(27017)
+    .withEnvironment({
+      MONGO_INITDB_ROOT_USERNAME: "mongo",
+      MONGO_INITDB_ROOT_PASSWORD: "password",
+    })
+    .withWaitStrategy(
+      Wait.forSuccessfulCommand(`mongosh --eval "db.version()"`)
+    )
+    .start()
+}
+
+export async function datasource(): Promise<Datasource> {
+  if (!container) {
+    container = await start()
+  }
+  const host = container.getHost()
+  const port = container.getMappedPort(27017)
+  return {
+    type: "datasource",
+    source: SourceName.MONGODB,
+    plus: false,
+    config: {
+      connectionString: `mongodb://mongo:password@${host}:${port}`,
+      db: "mongo",
+    },
+  }
+}
+
+export async function stop() {
+  if (container) {
+    await container.stop()
+    container = undefined
+  }
+}
diff --git a/packages/server/src/integrations/tests/utils/postgres.ts b/packages/server/src/integrations/tests/utils/postgres.ts
index 8e66ef02d6..82a62e3916 100644
--- a/packages/server/src/integrations/tests/utils/postgres.ts
+++ b/packages/server/src/integrations/tests/utils/postgres.ts
@@ -3,45 +3,44 @@ import { GenericContainer, Wait, StartedTestContainer } from "testcontainers"
 
 let container: StartedTestContainer | undefined
 
-export async function getDsConfig(): Promise<Datasource> {
-  try {
-    if (!container) {
-      container = await new GenericContainer("postgres:16.1-bullseye")
-        .withExposedPorts(5432)
-        .withEnvironment({ POSTGRES_PASSWORD: "password" })
-        .withWaitStrategy(
-          Wait.forLogMessage(
-            "database system is ready to accept connections",
-            2
-          )
-        )
-        .start()
-    }
-    const host = container.getHost()
-    const port = container.getMappedPort(5432)
+export async function start(): Promise<StartedTestContainer> {
+  return await new GenericContainer("postgres:16.1-bullseye")
+    .withExposedPorts(5432)
+    .withEnvironment({ POSTGRES_PASSWORD: "password" })
+    .withWaitStrategy(
+      Wait.forSuccessfulCommand(
+        "pg_isready -h localhost -p 5432"
+      ).withStartupTimeout(10000)
+    )
+    .start()
+}
 
-    return {
-      type: "datasource_plus",
-      source: SourceName.POSTGRES,
-      plus: true,
-      config: {
-        host,
-        port,
-        database: "postgres",
-        user: "postgres",
-        password: "password",
-        schema: "public",
-        ssl: false,
-        rejectUnauthorized: false,
-        ca: false,
-      },
-    }
-  } catch (err) {
-    throw new Error("**UNABLE TO CREATE TO POSTGRES CONTAINER**")
+export async function datasource(): Promise<Datasource> {
+  if (!container) {
+    container = await start()
+  }
+  const host = container.getHost()
+  const port = container.getMappedPort(5432)
+
+  return {
+    type: "datasource_plus",
+    source: SourceName.POSTGRES,
+    plus: true,
+    config: {
+      host,
+      port,
+      database: "postgres",
+      user: "postgres",
+      password: "password",
+      schema: "public",
+      ssl: false,
+      rejectUnauthorized: false,
+      ca: false,
+    },
   }
 }
 
-export async function stopContainer() {
+export async function stop() {
   if (container) {
     await container.stop()
     container = undefined
diff --git a/packages/server/src/sdk/app/backups/imports.ts b/packages/server/src/sdk/app/backups/imports.ts
index 7f76945107..4c5c1e659d 100644
--- a/packages/server/src/sdk/app/backups/imports.ts
+++ b/packages/server/src/sdk/app/backups/imports.ts
@@ -165,8 +165,9 @@ export async function importApp(
   const isTar = template.file && template?.file?.type?.endsWith("gzip")
   const isDirectory =
     template.file && fs.lstatSync(template.file.path).isDirectory()
+  let tmpPath: string | undefined = undefined
   if (template.file && (isTar || isDirectory)) {
-    const tmpPath = isTar ? await untarFile(template.file) : template.file.path
+    tmpPath = isTar ? await untarFile(template.file) : template.file.path
     if (isTar && template.file.password) {
       await decryptFiles(tmpPath, template.file.password)
     }
@@ -208,5 +209,9 @@ export async function importApp(
   }
   await updateAttachmentColumns(prodAppId, db)
   await updateAutomations(prodAppId, db)
+  // clear up afterward
+  if (tmpPath) {
+    fs.rmSync(tmpPath, { recursive: true, force: true })
+  }
   return ok
 }
diff --git a/packages/server/src/tests/utilities/api/index.ts b/packages/server/src/tests/utilities/api/index.ts
index 20b96f7a99..fdcec3098d 100644
--- a/packages/server/src/tests/utilities/api/index.ts
+++ b/packages/server/src/tests/utilities/api/index.ts
@@ -10,6 +10,7 @@ import { ApplicationAPI } from "./application"
 import { BackupAPI } from "./backup"
 import { AttachmentAPI } from "./attachment"
 import { UserAPI } from "./user"
+import { QueryAPI } from "./query"
 
 export default class API {
   table: TableAPI
@@ -23,6 +24,7 @@ export default class API {
   backup: BackupAPI
   attachment: AttachmentAPI
   user: UserAPI
+  query: QueryAPI
 
   constructor(config: TestConfiguration) {
     this.table = new TableAPI(config)
@@ -36,5 +38,6 @@ export default class API {
     this.backup = new BackupAPI(config)
     this.attachment = new AttachmentAPI(config)
     this.user = new UserAPI(config)
+    this.query = new QueryAPI(config)
   }
 }
diff --git a/packages/server/src/tests/utilities/api/query.ts b/packages/server/src/tests/utilities/api/query.ts
new file mode 100644
index 0000000000..350fe03c74
--- /dev/null
+++ b/packages/server/src/tests/utilities/api/query.ts
@@ -0,0 +1,44 @@
+import TestConfiguration from "../TestConfiguration"
+import {
+  Query,
+  type ExecuteQueryRequest,
+  type ExecuteQueryResponse,
+} from "@budibase/types"
+import { TestAPI } from "./base"
+
+export class QueryAPI extends TestAPI {
+  constructor(config: TestConfiguration) {
+    super(config)
+  }
+
+  create = async (body: Query): Promise<Query> => {
+    const res = await this.request
+      .post(`/api/queries`)
+      .set(this.config.defaultHeaders())
+      .send(body)
+      .expect("Content-Type", /json/)
+
+    if (res.status !== 200) {
+      throw new Error(JSON.stringify(res.body))
+    }
+
+    return res.body as Query
+  }
+
+  execute = async (
+    queryId: string,
+    body?: ExecuteQueryRequest
+  ): Promise<ExecuteQueryResponse> => {
+    const res = await this.request
+      .post(`/api/v2/queries/${queryId}`)
+      .set(this.config.defaultHeaders())
+      .send(body)
+      .expect("Content-Type", /json/)
+
+    if (res.status !== 200) {
+      throw new Error(JSON.stringify(res.body))
+    }
+
+    return res.body
+  }
+}
diff --git a/packages/server/src/utilities/workerRequests.ts b/packages/server/src/utilities/workerRequests.ts
index 1604a724d2..69ce58c8a9 100644
--- a/packages/server/src/utilities/workerRequests.ts
+++ b/packages/server/src/utilities/workerRequests.ts
@@ -1,4 +1,4 @@
-import fetch from "node-fetch"
+import { Response, default as fetch } from "node-fetch"
 import env from "../environment"
 import { checkSlashesInUrl } from "./index"
 import {
@@ -40,25 +40,21 @@ export function request(ctx?: Ctx, request?: any) {
 }
 
 async function checkResponse(
-  response: any,
+  response: Response,
   errorMsg: string,
   { ctx }: { ctx?: Ctx } = {}
 ) {
-  if (response.status !== 200) {
-    let error
-    try {
-      error = await response.json()
-      if (!error.message) {
-        error = JSON.stringify(error)
-      }
-    } catch (err) {
-      error = await response.text()
+  if (response.status >= 300) {
+    let responseErrorMessage
+    if (response.headers.get("content-type")?.includes("json")) {
+      const error = await response.json()
+      responseErrorMessage = error.message ?? JSON.stringify(error)
+    } else {
+      responseErrorMessage = await response.text()
     }
-    const msg = `Unable to ${errorMsg} - ${
-      error.message ? error.message : error
-    }`
+    const msg = `Unable to ${errorMsg} - ${responseErrorMessage}`
     if (ctx) {
-      ctx.throw(400, msg)
+      ctx.throw(msg, response.status)
     } else {
       throw msg
     }
diff --git a/packages/string-templates/manifest.json b/packages/string-templates/manifest.json
index 9dd8260350..dce4af8665 100644
--- a/packages/string-templates/manifest.json
+++ b/packages/string-templates/manifest.json
@@ -6,7 +6,8 @@
       ],
       "numArgs": 1,
       "example": "{{ abs 12012.1000 }} -> 12012.1",
-      "description": "<p>Return the magnitude of <code>a</code>.</p>\n"
+      "description": "<p>Return the magnitude of <code>a</code>.</p>\n",
+      "requiresBlock": false
     },
     "add": {
       "args": [
@@ -15,7 +16,8 @@
       ],
       "numArgs": 2,
       "example": "{{ add 1 2 }} -> 3",
-      "description": "<p>Return the sum of <code>a</code> plus <code>b</code>.</p>\n"
+      "description": "<p>Return the sum of <code>a</code> plus <code>b</code>.</p>\n",
+      "requiresBlock": false
     },
     "avg": {
       "args": [
@@ -23,7 +25,8 @@
       ],
       "numArgs": 1,
       "example": "{{ avg 1 2 3 4 5 }} -> 3",
-      "description": "<p>Returns the average of all numbers in the given array.</p>\n"
+      "description": "<p>Returns the average of all numbers in the given array.</p>\n",
+      "requiresBlock": false
     },
     "ceil": {
       "args": [
@@ -31,7 +34,8 @@
       ],
       "numArgs": 1,
       "example": "{{ ceil 1.2 }} -> 2",
-      "description": "<p>Get the <code>Math.ceil()</code> of the given value.</p>\n"
+      "description": "<p>Get the <code>Math.ceil()</code> of the given value.</p>\n",
+      "requiresBlock": false
     },
     "divide": {
       "args": [
@@ -40,7 +44,8 @@
       ],
       "numArgs": 2,
       "example": "{{ divide 10 5 }} -> 2",
-      "description": "<p>Divide <code>a</code> by <code>b</code></p>\n"
+      "description": "<p>Divide <code>a</code> by <code>b</code></p>\n",
+      "requiresBlock": false
     },
     "floor": {
       "args": [
@@ -48,7 +53,8 @@
       ],
       "numArgs": 1,
       "example": "{{ floor 1.2 }} -> 1",
-      "description": "<p>Get the <code>Math.floor()</code> of the given value.</p>\n"
+      "description": "<p>Get the <code>Math.floor()</code> of the given value.</p>\n",
+      "requiresBlock": false
     },
     "minus": {
       "args": [
@@ -57,7 +63,8 @@
       ],
       "numArgs": 2,
       "example": "{{ subtract 10 5 }} -> 5",
-      "description": "<p>Return the product of <code>a</code> minus <code>b</code>.</p>\n"
+      "description": "<p>Return the product of <code>a</code> minus <code>b</code>.</p>\n",
+      "requiresBlock": false
     },
     "modulo": {
       "args": [
@@ -66,7 +73,8 @@
       ],
       "numArgs": 2,
       "example": "{{ modulo 10 5 }} -> 0",
-      "description": "<p>Get the remainder of a division operation.</p>\n"
+      "description": "<p>Get the remainder of a division operation.</p>\n",
+      "requiresBlock": false
     },
     "multiply": {
       "args": [
@@ -75,7 +83,8 @@
       ],
       "numArgs": 2,
       "example": "{{ multiply 10 5 }} -> 50",
-      "description": "<p>Multiply number <code>a</code> by number <code>b</code>.</p>\n"
+      "description": "<p>Multiply number <code>a</code> by number <code>b</code>.</p>\n",
+      "requiresBlock": false
     },
     "plus": {
       "args": [
@@ -84,7 +93,8 @@
       ],
       "numArgs": 2,
       "example": "{{ plus 10 5 }} -> 15",
-      "description": "<p>Add <code>a</code> by <code>b</code>.</p>\n"
+      "description": "<p>Add <code>a</code> by <code>b</code>.</p>\n",
+      "requiresBlock": false
     },
     "random": {
       "args": [
@@ -93,7 +103,8 @@
       ],
       "numArgs": 2,
       "example": "{{ random 0 20 }} -> 10",
-      "description": "<p>Generate a random number between two values</p>\n"
+      "description": "<p>Generate a random number between two values</p>\n",
+      "requiresBlock": false
     },
     "remainder": {
       "args": [
@@ -102,7 +113,8 @@
       ],
       "numArgs": 2,
       "example": "{{ remainder 10 6 }} -> 4",
-      "description": "<p>Get the remainder when <code>a</code> is divided by <code>b</code>.</p>\n"
+      "description": "<p>Get the remainder when <code>a</code> is divided by <code>b</code>.</p>\n",
+      "requiresBlock": false
     },
     "round": {
       "args": [
@@ -110,7 +122,8 @@
       ],
       "numArgs": 1,
       "example": "{{ round 10.3 }} -> 10",
-      "description": "<p>Round the given number.</p>\n"
+      "description": "<p>Round the given number.</p>\n",
+      "requiresBlock": false
     },
     "subtract": {
       "args": [
@@ -119,7 +132,8 @@
       ],
       "numArgs": 2,
       "example": "{{ subtract 10 5 }} -> 5",
-      "description": "<p>Return the product of <code>a</code> minus <code>b</code>.</p>\n"
+      "description": "<p>Return the product of <code>a</code> minus <code>b</code>.</p>\n",
+      "requiresBlock": false
     },
     "sum": {
       "args": [
@@ -127,7 +141,8 @@
       ],
       "numArgs": 1,
       "example": "{{ sum [1, 2, 3] }} -> 6",
-      "description": "<p>Returns the sum of all numbers in the given array.</p>\n"
+      "description": "<p>Returns the sum of all numbers in the given array.</p>\n",
+      "requiresBlock": false
     }
   },
   "array": {
@@ -138,7 +153,8 @@
       ],
       "numArgs": 2,
       "example": "{{ after ['a', 'b', 'c', 'd'] 2}} -> ['c', 'd']",
-      "description": "<p>Returns all of the items in an array after the specified index. Opposite of <a href=\"#before\">before</a>.</p>\n"
+      "description": "<p>Returns all of the items in an array after the specified index. Opposite of <a href=\"#before\">before</a>.</p>\n",
+      "requiresBlock": false
     },
     "arrayify": {
       "args": [
@@ -146,7 +162,8 @@
       ],
       "numArgs": 1,
       "example": "{{ arrayify 'foo' }} -> ['foo']",
-      "description": "<p>Cast the given <code>value</code> to an array.</p>\n"
+      "description": "<p>Cast the given <code>value</code> to an array.</p>\n",
+      "requiresBlock": false
     },
     "before": {
       "args": [
@@ -155,7 +172,8 @@
       ],
       "numArgs": 2,
       "example": "{{ before ['a', 'b', 'c', 'd'] 3}} -> ['a', 'b']",
-      "description": "<p>Return all of the items in the collection before the specified count. Opposite of <a href=\"#after\">after</a>.</p>\n"
+      "description": "<p>Return all of the items in the collection before the specified count. Opposite of <a href=\"#after\">after</a>.</p>\n",
+      "requiresBlock": false
     },
     "eachIndex": {
       "args": [
@@ -163,8 +181,9 @@
         "options"
       ],
       "numArgs": 2,
-      "example": "{{#eachIndex [1, 2, 3]}} {{item}} is {{index}} {{/eachIndex}}",
-      "description": "<p>Iterates the array, listing an item and the index of it.</p>\n"
+      "example": "{{#eachIndex [1, 2, 3]}} {{item}} is {{index}} {{/eachIndex}} -> ' 1 is 0  2 is 1  3 is 2 '",
+      "description": "<p>Iterates the array, listing an item and the index of it.</p>\n",
+      "requiresBlock": true
     },
     "filter": {
       "args": [
@@ -173,8 +192,9 @@
         "options"
       ],
       "numArgs": 3,
-      "example": "{{#filter [1, 2, 3] 2}}2 Found{{else}}2 not found{{/filter}}",
-      "description": "<p>Block helper that filters the given array and renders the block for values that evaluate to <code>true</code>, otherwise the inverse block is returned.</p>\n"
+      "example": "{{#filter [1, 2, 3] 2}}2 Found{{else}}2 not found{{/filter}} -> 2 Found",
+      "description": "<p>Block helper that filters the given array and renders the block for values that evaluate to <code>true</code>, otherwise the inverse block is returned.</p>\n",
+      "requiresBlock": true
     },
     "first": {
       "args": [
@@ -183,15 +203,18 @@
       ],
       "numArgs": 2,
       "example": "{{first [1, 2, 3, 4] 2}} -> 1,2",
-      "description": "<p>Returns the first item, or first <code>n</code> items of an array.</p>\n"
+      "description": "<p>Returns the first item, or first <code>n</code> items of an array.</p>\n",
+      "requiresBlock": false
     },
     "forEach": {
       "args": [
-        "array"
+        "array",
+        "options"
       ],
-      "numArgs": 1,
-      "example": "{{#forEach [{ 'name': 'John' }] }} {{ name }} {{/forEach}}",
-      "description": "<p>Iterates over each item in an array and exposes the current item in the array as context to the inner block. In addition to the current array item, the helper exposes the following variables to the inner block: - <code>index</code> - <code>total</code> - <code>isFirst</code> - <code>isLast</code> Also, <code>@index</code> is exposed as a private variable, and additional private variables may be defined as hash arguments.</p>\n"
+      "numArgs": 2,
+      "example": "{{#forEach [{ 'name': 'John' }] }} {{ name }} {{/forEach}} -> ' John '",
+      "description": "<p>Iterates over each item in an array and exposes the current item in the array as context to the inner block. In addition to the current array item, the helper exposes the following variables to the inner block: - <code>index</code> - <code>total</code> - <code>isFirst</code> - <code>isLast</code> Also, <code>@index</code> is exposed as a private variable, and additional private variables may be defined as hash arguments.</p>\n",
+      "requiresBlock": true
     },
     "inArray": {
       "args": [
@@ -201,7 +224,8 @@
       ],
       "numArgs": 3,
       "example": "{{#inArray [1, 2, 3] 2}} 2 exists {{else}} 2 does not exist {{/inArray}} -> ' 2 exists '",
-      "description": "<p>Block helper that renders the block if an array has the given <code>value</code>. Optionally specify an inverse block to render when the array does not have the given value.</p>\n"
+      "description": "<p>Block helper that renders the block if an array has the given <code>value</code>. Optionally specify an inverse block to render when the array does not have the given value.</p>\n",
+      "requiresBlock": true
     },
     "isArray": {
       "args": [
@@ -209,7 +233,8 @@
       ],
       "numArgs": 1,
       "example": "{{isArray [1, 2]}} -> true",
-      "description": "<p>Returns true if <code>value</code> is an es5 array.</p>\n"
+      "description": "<p>Returns true if <code>value</code> is an es5 array.</p>\n",
+      "requiresBlock": false
     },
     "itemAt": {
       "args": [
@@ -218,7 +243,8 @@
       ],
       "numArgs": 2,
       "example": "{{itemAt [1, 2, 3] 1}} -> 2",
-      "description": "<p>Returns the item from <code>array</code> at index <code>idx</code>.</p>\n"
+      "description": "<p>Returns the item from <code>array</code> at index <code>idx</code>.</p>\n",
+      "requiresBlock": false
     },
     "join": {
       "args": [
@@ -227,17 +253,18 @@
       ],
       "numArgs": 2,
       "example": "{{join [1, 2, 3]}} -> 1, 2, 3",
-      "description": "<p>Join all elements of array into a string, optionally using a given separator.</p>\n"
+      "description": "<p>Join all elements of array into a string, optionally using a given separator.</p>\n",
+      "requiresBlock": false
     },
     "equalsLength": {
       "args": [
         "value",
-        "length",
-        "options"
+        "length"
       ],
-      "numArgs": 3,
+      "numArgs": 2,
       "example": "{{equalsLength [1, 2, 3] 3}} -> true",
-      "description": "<p>Returns true if the the length of the given <code>value</code> is equal to the given <code>length</code>. Can be used as a block or inline helper.</p>\n"
+      "description": "<p>Returns true if the the length of the given <code>value</code> is equal to the given <code>length</code>. Can be used as a block or inline helper.</p>\n",
+      "requiresBlock": false
     },
     "last": {
       "args": [
@@ -246,7 +273,8 @@
       ],
       "numArgs": 2,
       "example": "{{last [1, 2, 3]}} -> 3",
-      "description": "<p>Returns the last item, or last <code>n</code> items of an array or string. Opposite of <a href=\"#first\">first</a>.</p>\n"
+      "description": "<p>Returns the last item, or last <code>n</code> items of an array or string. Opposite of <a href=\"#first\">first</a>.</p>\n",
+      "requiresBlock": false
     },
     "length": {
       "args": [
@@ -254,17 +282,18 @@
       ],
       "numArgs": 1,
       "example": "{{length [1, 2, 3]}} -> 3",
-      "description": "<p>Returns the length of the given string or array.</p>\n"
+      "description": "<p>Returns the length of the given string or array.</p>\n",
+      "requiresBlock": false
     },
     "lengthEqual": {
       "args": [
         "value",
-        "length",
-        "options"
+        "length"
       ],
-      "numArgs": 3,
+      "numArgs": 2,
       "example": "{{equalsLength [1, 2, 3] 3}} -> true",
-      "description": "<p>Returns true if the the length of the given <code>value</code> is equal to the given <code>length</code>. Can be used as a block or inline helper.</p>\n"
+      "description": "<p>Returns true if the the length of the given <code>value</code> is equal to the given <code>length</code>. Can be used as a block or inline helper.</p>\n",
+      "requiresBlock": false
     },
     "map": {
       "args": [
@@ -273,7 +302,8 @@
       ],
       "numArgs": 2,
       "example": "{{map [1, 2, 3] double}} -> [2, 4, 6]",
-      "description": "<p>Returns a new array, created by calling <code>function</code> on each element of the given <code>array</code>. For example,</p>\n"
+      "description": "<p>Returns a new array, created by calling <code>function</code> on each element of the given <code>array</code>. For example,</p>\n",
+      "requiresBlock": false
     },
     "pluck": {
       "args": [
@@ -282,7 +312,8 @@
       ],
       "numArgs": 2,
       "example": "{{pluck [{ 'name': 'Bob' }] 'name' }} -> ['Bob']",
-      "description": "<p>Map over the given object or array or objects and create an array of values from the given <code>prop</code>. Dot-notation may be used (as a string) to get nested properties.</p>\n"
+      "description": "<p>Map over the given object or array or objects and create an array of values from the given <code>prop</code>. Dot-notation may be used (as a string) to get nested properties.</p>\n",
+      "requiresBlock": false
     },
     "reverse": {
       "args": [
@@ -290,7 +321,8 @@
       ],
       "numArgs": 1,
       "example": "{{reverse [1, 2, 3]}} -> [3, 2, 1]",
-      "description": "<p>Reverse the elements in an array, or the characters in a string.</p>\n"
+      "description": "<p>Reverse the elements in an array, or the characters in a string.</p>\n",
+      "requiresBlock": false
     },
     "some": {
       "args": [
@@ -300,7 +332,8 @@
       ],
       "numArgs": 3,
       "example": "{{#some [1, \"b\", 3] isString}} string found {{else}} No string found {{/some}} -> ' string found '",
-      "description": "<p>Block helper that returns the block if the callback returns true for some value in the given array.</p>\n"
+      "description": "<p>Block helper that returns the block if the callback returns true for some value in the given array.</p>\n",
+      "requiresBlock": true
     },
     "sort": {
       "args": [
@@ -309,7 +342,8 @@
       ],
       "numArgs": 2,
       "example": "{{ sort ['b', 'a', 'c'] }} -> ['a', 'b', 'c']",
-      "description": "<p>Sort the given <code>array</code>. If an array of objects is passed, you may optionally pass a <code>key</code> to sort on as the second argument. You may alternatively pass a sorting function as the second argument.</p>\n"
+      "description": "<p>Sort the given <code>array</code>. If an array of objects is passed, you may optionally pass a <code>key</code> to sort on as the second argument. You may alternatively pass a sorting function as the second argument.</p>\n",
+      "requiresBlock": false
     },
     "sortBy": {
       "args": [
@@ -318,7 +352,8 @@
       ],
       "numArgs": 2,
       "example": "{{ sortBy [{'a': 'zzz'}, {'a': 'aaa'}] 'a' }} -> [{'a':'aaa'},{'a':'zzz'}]",
-      "description": "<p>Sort an <code>array</code>. If an array of objects is passed, you may optionally pass a <code>key</code> to sort on as the second argument. You may alternatively pass a sorting function as the second argument.</p>\n"
+      "description": "<p>Sort an <code>array</code>. If an array of objects is passed, you may optionally pass a <code>key</code> to sort on as the second argument. You may alternatively pass a sorting function as the second argument.</p>\n",
+      "requiresBlock": false
     },
     "withAfter": {
       "args": [
@@ -327,8 +362,9 @@
         "options"
       ],
       "numArgs": 3,
-      "example": "{{ withAfter [1, 2, 3] 1 }} {{this}} {{/withAfter}}",
-      "description": "<p>Use the items in the array <em>after</em> the specified index as context inside a block. Opposite of <a href=\"#withBefore\">withBefore</a>.</p>\n"
+      "example": "{{#withAfter [1, 2, 3] 1 }} {{this}} {{/withAfter}} -> ' 2  3 '",
+      "description": "<p>Use the items in the array <em>after</em> the specified index as context inside a block. Opposite of <a href=\"#withBefore\">withBefore</a>.</p>\n",
+      "requiresBlock": true
     },
     "withBefore": {
       "args": [
@@ -337,8 +373,9 @@
         "options"
       ],
       "numArgs": 3,
-      "example": "{{ withBefore [1, 2, 3] 2 }} {{this}} {{/withBefore}}",
-      "description": "<p>Use the items in the array <em>before</em> the specified index as context inside a block. Opposite of <a href=\"#withAfter\">withAfter</a>.</p>\n"
+      "example": "{{#withBefore [1, 2, 3] 2 }} {{this}} {{/withBefore}} -> ' 1 '",
+      "description": "<p>Use the items in the array <em>before</em> the specified index as context inside a block. Opposite of <a href=\"#withAfter\">withAfter</a>.</p>\n",
+      "requiresBlock": true
     },
     "withFirst": {
       "args": [
@@ -348,7 +385,8 @@
       ],
       "numArgs": 3,
       "example": "{{#withFirst [1, 2, 3] }}{{this}}{{/withFirst}} -> 1",
-      "description": "<p>Use the first item in a collection inside a handlebars block expression. Opposite of <a href=\"#withLast\">withLast</a>.</p>\n"
+      "description": "<p>Use the first item in a collection inside a handlebars block expression. Opposite of <a href=\"#withLast\">withLast</a>.</p>\n",
+      "requiresBlock": true
     },
     "withGroup": {
       "args": [
@@ -358,7 +396,8 @@
       ],
       "numArgs": 3,
       "example": "{{#withGroup [1, 2, 3, 4] 2}}{{#each this}}{{.}}{{/each}}<br>{{/withGroup}} -> 12<br>34<br>",
-      "description": "<p>Block helper that groups array elements by given group <code>size</code>.</p>\n"
+      "description": "<p>Block helper that groups array elements by given group <code>size</code>.</p>\n",
+      "requiresBlock": true
     },
     "withLast": {
       "args": [
@@ -368,7 +407,8 @@
       ],
       "numArgs": 3,
       "example": "{{#withLast [1, 2, 3, 4]}}{{this}}{{/withLast}} -> 4",
-      "description": "<p>Use the last item or <code>n</code> items in an array as context inside a block. Opposite of <a href=\"#withFirst\">withFirst</a>.</p>\n"
+      "description": "<p>Use the last item or <code>n</code> items in an array as context inside a block. Opposite of <a href=\"#withFirst\">withFirst</a>.</p>\n",
+      "requiresBlock": true
     },
     "withSort": {
       "args": [
@@ -378,7 +418,8 @@
       ],
       "numArgs": 3,
       "example": "{{#withSort ['b', 'a', 'c']}}{{this}}{{/withSort}} -> abc",
-      "description": "<p>Block helper that sorts a collection and exposes the sorted collection as context inside the block.</p>\n"
+      "description": "<p>Block helper that sorts a collection and exposes the sorted collection as context inside the block.</p>\n",
+      "requiresBlock": true
     },
     "unique": {
       "args": [
@@ -387,7 +428,8 @@
       ],
       "numArgs": 2,
       "example": "{{#each (unique ['a', 'a', 'c', 'b', 'e', 'e']) }}{{.}}{{/each}} -> acbe",
-      "description": "<p>Block helper that return an array with all duplicate values removed. Best used along with a <a href=\"#each\">each</a> helper.</p>\n"
+      "description": "<p>Block helper that return an array with all duplicate values removed. Best used along with a <a href=\"#each\">each</a> helper.</p>\n",
+      "requiresBlock": true
     }
   },
   "number": {
@@ -397,7 +439,8 @@
       ],
       "numArgs": 1,
       "example": "{{ bytes 1386 1 }} -> 1.4 kB",
-      "description": "<p>Format a number to it&#39;s equivalent in bytes. If a string is passed, it&#39;s length will be formatted and returned. <strong>Examples:</strong> - <code>&#39;foo&#39; =&gt; 3 B</code> - <code>13661855 =&gt; 13.66 MB</code> - <code>825399 =&gt; 825.39 kB</code> - <code>1396 =&gt; 1.4 kB</code></p>\n"
+      "description": "<p>Format a number to it&#39;s equivalent in bytes. If a string is passed, it&#39;s length will be formatted and returned. <strong>Examples:</strong> - <code>&#39;foo&#39; =&gt; 3 B</code> - <code>13661855 =&gt; 13.66 MB</code> - <code>825399 =&gt; 825.39 kB</code> - <code>1396 =&gt; 1.4 kB</code></p>\n",
+      "requiresBlock": false
     },
     "addCommas": {
       "args": [
@@ -405,7 +448,8 @@
       ],
       "numArgs": 1,
       "example": "{{ addCommas 1000000 }} -> 1,000,000",
-      "description": "<p>Add commas to numbers</p>\n"
+      "description": "<p>Add commas to numbers</p>\n",
+      "requiresBlock": false
     },
     "phoneNumber": {
       "args": [
@@ -413,7 +457,8 @@
       ],
       "numArgs": 1,
       "example": "{{ phoneNumber 8005551212 }} -> (800) 555-1212",
-      "description": "<p>Convert a string or number to a formatted phone number.</p>\n"
+      "description": "<p>Convert a string or number to a formatted phone number.</p>\n",
+      "requiresBlock": false
     },
     "toAbbr": {
       "args": [
@@ -422,7 +467,8 @@
       ],
       "numArgs": 2,
       "example": "{{ toAbbr 10123 2 }} -> 10.12k",
-      "description": "<p>Abbreviate numbers to the given number of <code>precision</code>. This for general numbers, not size in bytes.</p>\n"
+      "description": "<p>Abbreviate numbers to the given number of <code>precision</code>. This for general numbers, not size in bytes.</p>\n",
+      "requiresBlock": false
     },
     "toExponential": {
       "args": [
@@ -431,7 +477,8 @@
       ],
       "numArgs": 2,
       "example": "{{ toExponential 10123 2 }} -> 1.01e+4",
-      "description": "<p>Returns a string representing the given number in exponential notation.</p>\n"
+      "description": "<p>Returns a string representing the given number in exponential notation.</p>\n",
+      "requiresBlock": false
     },
     "toFixed": {
       "args": [
@@ -440,21 +487,24 @@
       ],
       "numArgs": 2,
       "example": "{{ toFixed 1.1234 2 }} -> 1.12",
-      "description": "<p>Formats the given number using fixed-point notation.</p>\n"
+      "description": "<p>Formats the given number using fixed-point notation.</p>\n",
+      "requiresBlock": false
     },
     "toFloat": {
       "args": [
         "number"
       ],
       "numArgs": 1,
-      "description": "<p>Convert input to a float.</p>\n"
+      "description": "<p>Convert input to a float.</p>\n",
+      "requiresBlock": false
     },
     "toInt": {
       "args": [
         "number"
       ],
       "numArgs": 1,
-      "description": "<p>Convert input to an integer.</p>\n"
+      "description": "<p>Convert input to an integer.</p>\n",
+      "requiresBlock": false
     },
     "toPrecision": {
       "args": [
@@ -462,8 +512,9 @@
         "precision"
       ],
       "numArgs": 2,
-      "example": "{{toPrecision '1.1234' 2}}",
-      "description": "<p>Returns a string representing the <code>Number</code> object to the specified precision.</p>\n"
+      "example": "{{toPrecision '1.1234' 2}} -> 1.1",
+      "description": "<p>Returns a string representing the <code>Number</code> object to the specified precision.</p>\n",
+      "requiresBlock": false
     }
   },
   "url": {
@@ -473,7 +524,8 @@
       ],
       "numArgs": 1,
       "example": "{{ encodeURI 'https://myurl?Hello There' }} -> https%3A%2F%2Fmyurl%3FHello%20There",
-      "description": "<p>Encodes a Uniform Resource Identifier (URI) component by replacing each instance of certain characters by one, two, three, or four escape sequences representing the UTF-8 encoding of the character.</p>\n"
+      "description": "<p>Encodes a Uniform Resource Identifier (URI) component by replacing each instance of certain characters by one, two, three, or four escape sequences representing the UTF-8 encoding of the character.</p>\n",
+      "requiresBlock": false
     },
     "escape": {
       "args": [
@@ -481,7 +533,8 @@
       ],
       "numArgs": 1,
       "example": "{{ escape 'https://myurl?Hello+There' }} -> https%3A%2F%2Fmyurl%3FHello%2BThere",
-      "description": "<p>Escape the given string by replacing characters with escape sequences. Useful for allowing the string to be used in a URL, etc.</p>\n"
+      "description": "<p>Escape the given string by replacing characters with escape sequences. Useful for allowing the string to be used in a URL, etc.</p>\n",
+      "requiresBlock": false
     },
     "decodeURI": {
       "args": [
@@ -489,7 +542,8 @@
       ],
       "numArgs": 1,
       "example": "{{ decodeURI 'https://myurl?Hello%20There' }} -> https://myurl?Hello There",
-      "description": "<p>Decode a Uniform Resource Identifier (URI) component.</p>\n"
+      "description": "<p>Decode a Uniform Resource Identifier (URI) component.</p>\n",
+      "requiresBlock": false
     },
     "urlResolve": {
       "args": [
@@ -498,7 +552,8 @@
       ],
       "numArgs": 2,
       "example": "{{ urlResolve 'https://myurl' '/api/test' }} -> https://myurl/api/test",
-      "description": "<p>Take a base URL, and a href URL, and resolve them as a browser would for an anchor tag.</p>\n"
+      "description": "<p>Take a base URL, and a href URL, and resolve them as a browser would for an anchor tag.</p>\n",
+      "requiresBlock": false
     },
     "urlParse": {
       "args": [
@@ -506,7 +561,8 @@
       ],
       "numArgs": 1,
       "example": "{{ urlParse 'https://myurl/api/test' }}",
-      "description": "<p>Parses a <code>url</code> string into an object.</p>\n"
+      "description": "<p>Parses a <code>url</code> string into an object.</p>\n",
+      "requiresBlock": false
     },
     "stripQuerystring": {
       "args": [
@@ -514,7 +570,8 @@
       ],
       "numArgs": 1,
       "example": "{{ stripQuerystring 'https://myurl/api/test?foo=bar' }} -> 'https://myurl/api/test'",
-      "description": "<p>Strip the query string from the given <code>url</code>.</p>\n"
+      "description": "<p>Strip the query string from the given <code>url</code>.</p>\n",
+      "requiresBlock": false
     },
     "stripProtocol": {
       "args": [
@@ -522,7 +579,8 @@
       ],
       "numArgs": 1,
       "example": "{{ stripProtocol 'https://myurl/api/test' }} -> '//myurl/api/test'",
-      "description": "<p>Strip protocol from a <code>url</code>. Useful for displaying media that may have an &#39;http&#39; protocol on secure connections.</p>\n"
+      "description": "<p>Strip protocol from a <code>url</code>. Useful for displaying media that may have an &#39;http&#39; protocol on secure connections.</p>\n",
+      "requiresBlock": false
     }
   },
   "string": {
@@ -533,7 +591,8 @@
       ],
       "numArgs": 2,
       "example": "{{append 'index' '.html'}} -> index.html",
-      "description": "<p>Append the specified <code>suffix</code> to the given string.</p>\n"
+      "description": "<p>Append the specified <code>suffix</code> to the given string.</p>\n",
+      "requiresBlock": false
     },
     "camelcase": {
       "args": [
@@ -541,7 +600,8 @@
       ],
       "numArgs": 1,
       "example": "{{camelcase 'foo bar baz'}} ->  fooBarBaz",
-      "description": "<p>camelCase the characters in the given <code>string</code>.</p>\n"
+      "description": "<p>camelCase the characters in the given <code>string</code>.</p>\n",
+      "requiresBlock": false
     },
     "capitalize": {
       "args": [
@@ -549,7 +609,8 @@
       ],
       "numArgs": 1,
       "example": "{{capitalize 'foo bar baz'}} ->  Foo bar baz",
-      "description": "<p>Capitalize the first word in a sentence.</p>\n"
+      "description": "<p>Capitalize the first word in a sentence.</p>\n",
+      "requiresBlock": false
     },
     "capitalizeAll": {
       "args": [
@@ -557,7 +618,8 @@
       ],
       "numArgs": 1,
       "example": "{{ capitalizeAll 'foo bar baz'}} ->  Foo Bar Baz",
-      "description": "<p>Capitalize all words in a string.</p>\n"
+      "description": "<p>Capitalize all words in a string.</p>\n",
+      "requiresBlock": false
     },
     "center": {
       "args": [
@@ -566,7 +628,8 @@
       ],
       "numArgs": 2,
       "example": "{{ center 'test' 1}} -> ' test '",
-      "description": "<p>Center a string using non-breaking spaces</p>\n"
+      "description": "<p>Center a string using non-breaking spaces</p>\n",
+      "requiresBlock": false
     },
     "chop": {
       "args": [
@@ -574,7 +637,8 @@
       ],
       "numArgs": 1,
       "example": "{{ chop ' ABC '}} -> ABC",
-      "description": "<p>Like trim, but removes both extraneous whitespace <strong>and non-word characters</strong> from the beginning and end of a string.</p>\n"
+      "description": "<p>Like trim, but removes both extraneous whitespace <strong>and non-word characters</strong> from the beginning and end of a string.</p>\n",
+      "requiresBlock": false
     },
     "dashcase": {
       "args": [
@@ -582,7 +646,8 @@
       ],
       "numArgs": 1,
       "example": "{{dashcase 'a-b-c d_e'}} -> a-b-c-d-e",
-      "description": "<p>dash-case the characters in <code>string</code>. Replaces non-word characters and periods with hyphens.</p>\n"
+      "description": "<p>dash-case the characters in <code>string</code>. Replaces non-word characters and periods with hyphens.</p>\n",
+      "requiresBlock": false
     },
     "dotcase": {
       "args": [
@@ -590,7 +655,8 @@
       ],
       "numArgs": 1,
       "example": "{{dotcase 'a-b-c d_e'}} -> a.b.c.d.e",
-      "description": "<p>dot.case the characters in <code>string</code>.</p>\n"
+      "description": "<p>dot.case the characters in <code>string</code>.</p>\n",
+      "requiresBlock": false
     },
     "downcase": {
       "args": [
@@ -598,7 +664,8 @@
       ],
       "numArgs": 1,
       "example": "{{downcase 'aBcDeF'}} -> abcdef",
-      "description": "<p>Lowercase all of the characters in the given string. Alias for <a href=\"#lowercase\">lowercase</a>.</p>\n"
+      "description": "<p>Lowercase all of the characters in the given string. Alias for <a href=\"#lowercase\">lowercase</a>.</p>\n",
+      "requiresBlock": false
     },
     "ellipsis": {
       "args": [
@@ -607,7 +674,8 @@
       ],
       "numArgs": 2,
       "example": "{{ellipsis 'foo bar baz' 7}} -> foo bar…",
-      "description": "<p>Truncates a string to the specified <code>length</code>, and appends it with an elipsis, <code>…</code>.</p>\n"
+      "description": "<p>Truncates a string to the specified <code>length</code>, and appends it with an elipsis, <code>…</code>.</p>\n",
+      "requiresBlock": false
     },
     "hyphenate": {
       "args": [
@@ -615,7 +683,8 @@
       ],
       "numArgs": 1,
       "example": "{{hyphenate 'foo bar baz qux'}} -> foo-bar-baz-qux",
-      "description": "<p>Replace spaces in a string with hyphens.</p>\n"
+      "description": "<p>Replace spaces in a string with hyphens.</p>\n",
+      "requiresBlock": false
     },
     "isString": {
       "args": [
@@ -623,7 +692,8 @@
       ],
       "numArgs": 1,
       "example": "{{isString 'foo'}} -> true",
-      "description": "<p>Return true if <code>value</code> is a string.</p>\n"
+      "description": "<p>Return true if <code>value</code> is a string.</p>\n",
+      "requiresBlock": false
     },
     "lowercase": {
       "args": [
@@ -631,7 +701,8 @@
       ],
       "numArgs": 1,
       "example": "{{lowercase 'Foo BAR baZ'}} -> foo bar baz",
-      "description": "<p>Lowercase all characters in the given string.</p>\n"
+      "description": "<p>Lowercase all characters in the given string.</p>\n",
+      "requiresBlock": false
     },
     "occurrences": {
       "args": [
@@ -640,7 +711,8 @@
       ],
       "numArgs": 2,
       "example": "{{occurrences 'foo bar foo bar baz' 'foo'}} -> 2",
-      "description": "<p>Return the number of occurrences of <code>substring</code> within the given <code>string</code>.</p>\n"
+      "description": "<p>Return the number of occurrences of <code>substring</code> within the given <code>string</code>.</p>\n",
+      "requiresBlock": false
     },
     "pascalcase": {
       "args": [
@@ -648,7 +720,8 @@
       ],
       "numArgs": 1,
       "example": "{{pascalcase 'foo bar baz'}} -> FooBarBaz",
-      "description": "<p>PascalCase the characters in <code>string</code>.</p>\n"
+      "description": "<p>PascalCase the characters in <code>string</code>.</p>\n",
+      "requiresBlock": false
     },
     "pathcase": {
       "args": [
@@ -656,7 +729,8 @@
       ],
       "numArgs": 1,
       "example": "{{pathcase 'a-b-c d_e'}} -> a/b/c/d/e",
-      "description": "<p>path/case the characters in <code>string</code>.</p>\n"
+      "description": "<p>path/case the characters in <code>string</code>.</p>\n",
+      "requiresBlock": false
     },
     "plusify": {
       "args": [
@@ -664,7 +738,8 @@
       ],
       "numArgs": 1,
       "example": "{{plusify 'foo bar baz'}} -> foo+bar+baz",
-      "description": "<p>Replace spaces in the given string with pluses.</p>\n"
+      "description": "<p>Replace spaces in the given string with pluses.</p>\n",
+      "requiresBlock": false
     },
     "prepend": {
       "args": [
@@ -673,7 +748,8 @@
       ],
       "numArgs": 2,
       "example": "{{prepend 'bar' 'foo-'}} -> foo-bar",
-      "description": "<p>Prepends the given <code>string</code> with the specified <code>prefix</code>.</p>\n"
+      "description": "<p>Prepends the given <code>string</code> with the specified <code>prefix</code>.</p>\n",
+      "requiresBlock": false
     },
     "remove": {
       "args": [
@@ -682,7 +758,8 @@
       ],
       "numArgs": 2,
       "example": "{{remove 'a b a b a b' 'a '}} -> b b b",
-      "description": "<p>Remove all occurrences of <code>substring</code> from the given <code>str</code>.</p>\n"
+      "description": "<p>Remove all occurrences of <code>substring</code> from the given <code>str</code>.</p>\n",
+      "requiresBlock": false
     },
     "removeFirst": {
       "args": [
@@ -691,7 +768,8 @@
       ],
       "numArgs": 2,
       "example": "{{removeFirst 'a b a b a b' 'a'}} -> ' b a b a b'",
-      "description": "<p>Remove the first occurrence of <code>substring</code> from the given <code>str</code>.</p>\n"
+      "description": "<p>Remove the first occurrence of <code>substring</code> from the given <code>str</code>.</p>\n",
+      "requiresBlock": false
     },
     "replace": {
       "args": [
@@ -701,7 +779,8 @@
       ],
       "numArgs": 3,
       "example": "{{replace 'a b a b a b' 'a' 'z'}} -> z b z b z b",
-      "description": "<p>Replace all occurrences of substring <code>a</code> with substring <code>b</code>.</p>\n"
+      "description": "<p>Replace all occurrences of substring <code>a</code> with substring <code>b</code>.</p>\n",
+      "requiresBlock": false
     },
     "replaceFirst": {
       "args": [
@@ -711,7 +790,8 @@
       ],
       "numArgs": 3,
       "example": "{{replaceFirst 'a b a b a b' 'a' 'z'}} -> z b a b a b",
-      "description": "<p>Replace the first occurrence of substring <code>a</code> with substring <code>b</code>.</p>\n"
+      "description": "<p>Replace the first occurrence of substring <code>a</code> with substring <code>b</code>.</p>\n",
+      "requiresBlock": false
     },
     "sentence": {
       "args": [
@@ -719,7 +799,8 @@
       ],
       "numArgs": 1,
       "example": "{{sentence 'hello world. goodbye world.'}} -> Hello world. Goodbye world.",
-      "description": "<p>Sentence case the given string</p>\n"
+      "description": "<p>Sentence case the given string</p>\n",
+      "requiresBlock": false
     },
     "snakecase": {
       "args": [
@@ -727,7 +808,8 @@
       ],
       "numArgs": 1,
       "example": "{{snakecase 'a-b-c d_e'}} -> a_b_c_d_e",
-      "description": "<p>snake_case the characters in the given <code>string</code>.</p>\n"
+      "description": "<p>snake_case the characters in the given <code>string</code>.</p>\n",
+      "requiresBlock": false
     },
     "split": {
       "args": [
@@ -735,7 +817,8 @@
       ],
       "numArgs": 1,
       "example": "{{split 'a,b,c'}} -> ['a', 'b', 'c']",
-      "description": "<p>Split <code>string</code> by the given <code>character</code>.</p>\n"
+      "description": "<p>Split <code>string</code> by the given <code>character</code>.</p>\n",
+      "requiresBlock": false
     },
     "startsWith": {
       "args": [
@@ -745,7 +828,8 @@
       ],
       "numArgs": 3,
       "example": "{{#startsWith 'Goodbye' 'Hello, world!'}}Yep{{else}}Nope{{/startsWith}} -> Nope",
-      "description": "<p>Tests whether a string begins with the given prefix.</p>\n"
+      "description": "<p>Tests whether a string begins with the given prefix.</p>\n",
+      "requiresBlock": true
     },
     "titleize": {
       "args": [
@@ -753,7 +837,8 @@
       ],
       "numArgs": 1,
       "example": "{{titleize 'this is title case' }} -> This Is Title Case",
-      "description": "<p>Title case the given string.</p>\n"
+      "description": "<p>Title case the given string.</p>\n",
+      "requiresBlock": false
     },
     "trim": {
       "args": [
@@ -761,7 +846,8 @@
       ],
       "numArgs": 1,
       "example": "{{trim '  ABC  ' }} -> ABC",
-      "description": "<p>Removes extraneous whitespace from the beginning and end of a string.</p>\n"
+      "description": "<p>Removes extraneous whitespace from the beginning and end of a string.</p>\n",
+      "requiresBlock": false
     },
     "trimLeft": {
       "args": [
@@ -769,7 +855,8 @@
       ],
       "numArgs": 1,
       "example": "{{trimLeft '  ABC ' }} -> 'ABC '",
-      "description": "<p>Removes extraneous whitespace from the beginning of a string.</p>\n"
+      "description": "<p>Removes extraneous whitespace from the beginning of a string.</p>\n",
+      "requiresBlock": false
     },
     "trimRight": {
       "args": [
@@ -777,7 +864,8 @@
       ],
       "numArgs": 1,
       "example": "{{trimRight '  ABC ' }} ->  '  ABC'",
-      "description": "<p>Removes extraneous whitespace from the end of a string.</p>\n"
+      "description": "<p>Removes extraneous whitespace from the end of a string.</p>\n",
+      "requiresBlock": false
     },
     "truncate": {
       "args": [
@@ -787,7 +875,8 @@
       ],
       "numArgs": 3,
       "example": "{{truncate 'foo bar baz' 7 }} -> foo bar",
-      "description": "<p>Truncate a string to the specified <code>length</code>. Also see <a href=\"#ellipsis\">ellipsis</a>.</p>\n"
+      "description": "<p>Truncate a string to the specified <code>length</code>. Also see <a href=\"#ellipsis\">ellipsis</a>.</p>\n",
+      "requiresBlock": false
     },
     "truncateWords": {
       "args": [
@@ -797,7 +886,8 @@
       ],
       "numArgs": 3,
       "example": "{{truncateWords 'foo bar baz' 1 }} -> foo…",
-      "description": "<p>Truncate a string to have the specified number of words. Also see <a href=\"#truncate\">truncate</a>.</p>\n"
+      "description": "<p>Truncate a string to have the specified number of words. Also see <a href=\"#truncate\">truncate</a>.</p>\n",
+      "requiresBlock": false
     },
     "upcase": {
       "args": [
@@ -805,7 +895,8 @@
       ],
       "numArgs": 1,
       "example": "{{upcase 'aBcDef'}} -> ABCDEF",
-      "description": "<p>Uppercase all of the characters in the given string. Alias for <a href=\"#uppercase\">uppercase</a>.</p>\n"
+      "description": "<p>Uppercase all of the characters in the given string. Alias for <a href=\"#uppercase\">uppercase</a>.</p>\n",
+      "requiresBlock": false
     },
     "uppercase": {
       "args": [
@@ -814,7 +905,8 @@
       ],
       "numArgs": 2,
       "example": "{{uppercase 'aBcDef'}} -> ABCDEF",
-      "description": "<p>Uppercase all of the characters in the given string. If used as a block helper it will uppercase the entire block. This helper does not support inverse blocks.</p>\n"
+      "description": "<p>Uppercase all of the characters in the given string. If used as a block helper it will uppercase the entire block. This helper does not support inverse blocks.</p>\n",
+      "requiresBlock": false
     }
   },
   "comparison": {
@@ -825,8 +917,9 @@
         "options"
       ],
       "numArgs": 3,
-      "example": "{{#and great magnificent}}both{{else}}no{{/and}}",
-      "description": "<p>Helper that renders the block if <strong>both</strong> of the given values are truthy. If an inverse block is specified it will be rendered when falsy. Works as a block helper, inline helper or subexpression.</p>\n"
+      "example": "{{#and great magnificent}}both{{else}}no{{/and}} -> no",
+      "description": "<p>Helper that renders the block if <strong>both</strong> of the given values are truthy. If an inverse block is specified it will be rendered when falsy. Works as a block helper, inline helper or subexpression.</p>\n",
+      "requiresBlock": true
     },
     "compare": {
       "args": [
@@ -837,7 +930,8 @@
       ],
       "numArgs": 4,
       "example": "{{compare 10 '<' 5 }} -> false",
-      "description": "<p>Render a block when a comparison of the first and third arguments returns true. The second argument is the [arithemetic operator][operators] to use. You may also optionally specify an inverse block to render when falsy.</p>\n"
+      "description": "<p>Render a block when a comparison of the first and third arguments returns true. The second argument is the [arithemetic operator][operators] to use. You may also optionally specify an inverse block to render when falsy.</p>\n",
+      "requiresBlock": false
     },
     "contains": {
       "args": [
@@ -847,8 +941,9 @@
         "options"
       ],
       "numArgs": 4,
-      "example": "{{#contains ['a', 'b', 'c'] 'd'}} This will not be rendered. {{else}} This will be rendered. {{/contains}}",
-      "description": "<p>Block helper that renders the block if <code>collection</code> has the given <code>value</code>, using strict equality (<code>===</code>) for comparison, otherwise the inverse block is rendered (if specified). If a <code>startIndex</code> is specified and is negative, it is used as the offset from the end of the collection.</p>\n"
+      "example": "{{#contains ['a', 'b', 'c'] 'd'}} This will not be rendered. {{else}} This will be rendered. {{/contains}} -> ' This will be rendered. '",
+      "description": "<p>Block helper that renders the block if <code>collection</code> has the given <code>value</code>, using strict equality (<code>===</code>) for comparison, otherwise the inverse block is rendered (if specified). If a <code>startIndex</code> is specified and is negative, it is used as the offset from the end of the collection.</p>\n",
+      "requiresBlock": true
     },
     "default": {
       "args": [
@@ -857,7 +952,8 @@
       ],
       "numArgs": 2,
       "example": "{{default null null 'default'}} -> default",
-      "description": "<p>Returns the first value that is not undefined, otherwise the &#39;default&#39; value is returned.</p>\n"
+      "description": "<p>Returns the first value that is not undefined, otherwise the &#39;default&#39; value is returned.</p>\n",
+      "requiresBlock": false
     },
     "eq": {
       "args": [
@@ -867,7 +963,8 @@
       ],
       "numArgs": 3,
       "example": "{{#eq 3 3}}equal{{else}}not equal{{/eq}} -> equal",
-      "description": "<p>Block helper that renders a block if <code>a</code> is <strong>equal to</strong> <code>b</code>. If an inverse block is specified it will be rendered when falsy. You may optionally use the <code>compare=&#39;&#39;</code> hash argument for the second value.</p>\n"
+      "description": "<p>Block helper that renders a block if <code>a</code> is <strong>equal to</strong> <code>b</code>. If an inverse block is specified it will be rendered when falsy. You may optionally use the <code>compare=&#39;&#39;</code> hash argument for the second value.</p>\n",
+      "requiresBlock": true
     },
     "gt": {
       "args": [
@@ -877,7 +974,8 @@
       ],
       "numArgs": 3,
       "example": "{{#gt 4 3}} greater than{{else}} not greater than{{/gt}} -> ' greater than'",
-      "description": "<p>Block helper that renders a block if <code>a</code> is <strong>greater than</strong> <code>b</code>. If an inverse block is specified it will be rendered when falsy. You may optionally use the <code>compare=&#39;&#39;</code> hash argument for the second value.</p>\n"
+      "description": "<p>Block helper that renders a block if <code>a</code> is <strong>greater than</strong> <code>b</code>. If an inverse block is specified it will be rendered when falsy. You may optionally use the <code>compare=&#39;&#39;</code> hash argument for the second value.</p>\n",
+      "requiresBlock": true
     },
     "gte": {
       "args": [
@@ -887,7 +985,8 @@
       ],
       "numArgs": 3,
       "example": "{{#gte 4 3}} greater than or equal{{else}} not greater than{{/gte}} -> ' greater than or equal'",
-      "description": "<p>Block helper that renders a block if <code>a</code> is <strong>greater than or equal to</strong> <code>b</code>. If an inverse block is specified it will be rendered when falsy. You may optionally use the <code>compare=&#39;&#39;</code> hash argument for the second value.</p>\n"
+      "description": "<p>Block helper that renders a block if <code>a</code> is <strong>greater than or equal to</strong> <code>b</code>. If an inverse block is specified it will be rendered when falsy. You may optionally use the <code>compare=&#39;&#39;</code> hash argument for the second value.</p>\n",
+      "requiresBlock": true
     },
     "has": {
       "args": [
@@ -897,7 +996,8 @@
       ],
       "numArgs": 3,
       "example": "{{#has 'foobar' 'foo'}}has it{{else}}doesn't{{/has}} -> has it",
-      "description": "<p>Block helper that renders a block if <code>value</code> has <code>pattern</code>. If an inverse block is specified it will be rendered when falsy.</p>\n"
+      "description": "<p>Block helper that renders a block if <code>value</code> has <code>pattern</code>. If an inverse block is specified it will be rendered when falsy.</p>\n",
+      "requiresBlock": true
     },
     "isFalsey": {
       "args": [
@@ -906,7 +1006,8 @@
       ],
       "numArgs": 2,
       "example": "{{isFalsey '' }} -> true",
-      "description": "<p>Returns true if the given <code>value</code> is falsey. Uses the [falsey][] library for comparisons. Please see that library for more information or to report bugs with this helper.</p>\n"
+      "description": "<p>Returns true if the given <code>value</code> is falsey. Uses the [falsey][] library for comparisons. Please see that library for more information or to report bugs with this helper.</p>\n",
+      "requiresBlock": false
     },
     "isTruthy": {
       "args": [
@@ -915,7 +1016,8 @@
       ],
       "numArgs": 2,
       "example": "{{isTruthy '12' }} -> true",
-      "description": "<p>Returns true if the given <code>value</code> is truthy. Uses the [falsey][] library for comparisons. Please see that library for more information or to report bugs with this helper.</p>\n"
+      "description": "<p>Returns true if the given <code>value</code> is truthy. Uses the [falsey][] library for comparisons. Please see that library for more information or to report bugs with this helper.</p>\n",
+      "requiresBlock": false
     },
     "ifEven": {
       "args": [
@@ -924,7 +1026,8 @@
       ],
       "numArgs": 2,
       "example": "{{#ifEven 2}} even {{else}} odd {{/ifEven}} -> ' even '",
-      "description": "<p>Return true if the given value is an even number.</p>\n"
+      "description": "<p>Return true if the given value is an even number.</p>\n",
+      "requiresBlock": true
     },
     "ifNth": {
       "args": [
@@ -934,7 +1037,8 @@
       ],
       "numArgs": 3,
       "example": "{{#ifNth 2 10}}remainder{{else}}no remainder{{/ifNth}} -> remainder",
-      "description": "<p>Conditionally renders a block if the remainder is zero when <code>b</code> operand is divided by <code>a</code>. If an inverse block is specified it will be rendered when the remainder is <strong>not zero</strong>.</p>\n"
+      "description": "<p>Conditionally renders a block if the remainder is zero when <code>b</code> operand is divided by <code>a</code>. If an inverse block is specified it will be rendered when the remainder is <strong>not zero</strong>.</p>\n",
+      "requiresBlock": true
     },
     "ifOdd": {
       "args": [
@@ -943,7 +1047,8 @@
       ],
       "numArgs": 2,
       "example": "{{#ifOdd 3}}odd{{else}}even{{/ifOdd}} -> odd",
-      "description": "<p>Block helper that renders a block if <code>value</code> is <strong>an odd number</strong>. If an inverse block is specified it will be rendered when falsy.</p>\n"
+      "description": "<p>Block helper that renders a block if <code>value</code> is <strong>an odd number</strong>. If an inverse block is specified it will be rendered when falsy.</p>\n",
+      "requiresBlock": true
     },
     "is": {
       "args": [
@@ -953,7 +1058,8 @@
       ],
       "numArgs": 3,
       "example": "{{#is 3 3}} is {{else}} is not {{/is}} -> ' is '",
-      "description": "<p>Block helper that renders a block if <code>a</code> is <strong>equal to</strong> <code>b</code>. If an inverse block is specified it will be rendered when falsy. Similar to <a href=\"#eq\">eq</a> but does not do strict equality.</p>\n"
+      "description": "<p>Block helper that renders a block if <code>a</code> is <strong>equal to</strong> <code>b</code>. If an inverse block is specified it will be rendered when falsy. Similar to <a href=\"#eq\">eq</a> but does not do strict equality.</p>\n",
+      "requiresBlock": true
     },
     "isnt": {
       "args": [
@@ -963,7 +1069,8 @@
       ],
       "numArgs": 3,
       "example": "{{#isnt 3 3}} isnt {{else}} is {{/isnt}} -> ' is '",
-      "description": "<p>Block helper that renders a block if <code>a</code> is <strong>not equal to</strong> <code>b</code>. If an inverse block is specified it will be rendered when falsy. Similar to <a href=\"#unlesseq\">unlessEq</a> but does not use strict equality for comparisons.</p>\n"
+      "description": "<p>Block helper that renders a block if <code>a</code> is <strong>not equal to</strong> <code>b</code>. If an inverse block is specified it will be rendered when falsy. Similar to <a href=\"#unlesseq\">unlessEq</a> but does not use strict equality for comparisons.</p>\n",
+      "requiresBlock": true
     },
     "lt": {
       "args": [
@@ -972,7 +1079,8 @@
       ],
       "numArgs": 2,
       "example": "{{#lt 2 3}} less than {{else}} more than or equal {{/lt}} -> ' less than '",
-      "description": "<p>Block helper that renders a block if <code>a</code> is <strong>less than</strong> <code>b</code>. If an inverse block is specified it will be rendered when falsy. You may optionally use the <code>compare=&#39;&#39;</code> hash argument for the second value.</p>\n"
+      "description": "<p>Block helper that renders a block if <code>a</code> is <strong>less than</strong> <code>b</code>. If an inverse block is specified it will be rendered when falsy. You may optionally use the <code>compare=&#39;&#39;</code> hash argument for the second value.</p>\n",
+      "requiresBlock": true
     },
     "lte": {
       "args": [
@@ -982,7 +1090,8 @@
       ],
       "numArgs": 3,
       "example": "{{#lte 2 3}} less than or equal {{else}} more than {{/lte}} -> ' less than or equal '",
-      "description": "<p>Block helper that renders a block if <code>a</code> is <strong>less than or equal to</strong> <code>b</code>. If an inverse block is specified it will be rendered when falsy. You may optionally use the <code>compare=&#39;&#39;</code> hash argument for the second value.</p>\n"
+      "description": "<p>Block helper that renders a block if <code>a</code> is <strong>less than or equal to</strong> <code>b</code>. If an inverse block is specified it will be rendered when falsy. You may optionally use the <code>compare=&#39;&#39;</code> hash argument for the second value.</p>\n",
+      "requiresBlock": true
     },
     "neither": {
       "args": [
@@ -992,7 +1101,8 @@
       ],
       "numArgs": 3,
       "example": "{{#neither null null}}both falsey{{else}}both not falsey{{/neither}} -> both falsey",
-      "description": "<p>Block helper that renders a block if <strong>neither of</strong> the given values are truthy. If an inverse block is specified it will be rendered when falsy.</p>\n"
+      "description": "<p>Block helper that renders a block if <strong>neither of</strong> the given values are truthy. If an inverse block is specified it will be rendered when falsy.</p>\n",
+      "requiresBlock": true
     },
     "not": {
       "args": [
@@ -1001,7 +1111,8 @@
       ],
       "numArgs": 2,
       "example": "{{#not undefined }}falsey{{else}}not falsey{{/not}} -> falsey",
-      "description": "<p>Returns true if <code>val</code> is falsey. Works as a block or inline helper.</p>\n"
+      "description": "<p>Returns true if <code>val</code> is falsey. Works as a block or inline helper.</p>\n",
+      "requiresBlock": true
     },
     "or": {
       "args": [
@@ -1010,7 +1121,8 @@
       ],
       "numArgs": 2,
       "example": "{{#or 1 2 undefined }} at least one truthy {{else}} all falsey {{/or}} -> ' at least one truthy '",
-      "description": "<p>Block helper that renders a block if <strong>any of</strong> the given values is truthy. If an inverse block is specified it will be rendered when falsy.</p>\n"
+      "description": "<p>Block helper that renders a block if <strong>any of</strong> the given values is truthy. If an inverse block is specified it will be rendered when falsy.</p>\n",
+      "requiresBlock": true
     },
     "unlessEq": {
       "args": [
@@ -1020,7 +1132,8 @@
       ],
       "numArgs": 3,
       "example": "{{#unlessEq 2 1 }} not equal {{else}} equal {{/unlessEq}} -> ' not equal '",
-      "description": "<p>Block helper that always renders the inverse block <strong>unless <code>a</code> is equal to <code>b</code></strong>.</p>\n"
+      "description": "<p>Block helper that always renders the inverse block <strong>unless <code>a</code> is equal to <code>b</code></strong>.</p>\n",
+      "requiresBlock": true
     },
     "unlessGt": {
       "args": [
@@ -1030,7 +1143,8 @@
       ],
       "numArgs": 3,
       "example": "{{#unlessGt 20 1 }} not greater than {{else}} greater than {{/unlessGt}} -> ' greater than '",
-      "description": "<p>Block helper that always renders the inverse block <strong>unless <code>a</code> is greater than <code>b</code></strong>.</p>\n"
+      "description": "<p>Block helper that always renders the inverse block <strong>unless <code>a</code> is greater than <code>b</code></strong>.</p>\n",
+      "requiresBlock": true
     },
     "unlessLt": {
       "args": [
@@ -1040,7 +1154,8 @@
       ],
       "numArgs": 3,
       "example": "{{#unlessLt 20 1 }}greater than or equal{{else}}less than{{/unlessLt}} -> greater than or equal",
-      "description": "<p>Block helper that always renders the inverse block <strong>unless <code>a</code> is less than <code>b</code></strong>.</p>\n"
+      "description": "<p>Block helper that always renders the inverse block <strong>unless <code>a</code> is less than <code>b</code></strong>.</p>\n",
+      "requiresBlock": true
     },
     "unlessGteq": {
       "args": [
@@ -1050,7 +1165,8 @@
       ],
       "numArgs": 3,
       "example": "{{#unlessGteq 20 1 }} less than {{else}}greater than or equal to{{/unlessGteq}} -> greater than or equal to",
-      "description": "<p>Block helper that always renders the inverse block <strong>unless <code>a</code> is greater than or equal to <code>b</code></strong>.</p>\n"
+      "description": "<p>Block helper that always renders the inverse block <strong>unless <code>a</code> is greater than or equal to <code>b</code></strong>.</p>\n",
+      "requiresBlock": true
     },
     "unlessLteq": {
       "args": [
@@ -1060,7 +1176,8 @@
       ],
       "numArgs": 3,
       "example": "{{#unlessLteq 20 1 }} greater than {{else}} less than or equal to {{/unlessLteq}} -> ' greater than '",
-      "description": "<p>Block helper that always renders the inverse block <strong>unless <code>a</code> is less than or equal to <code>b</code></strong>.</p>\n"
+      "description": "<p>Block helper that always renders the inverse block <strong>unless <code>a</code> is less than or equal to <code>b</code></strong>.</p>\n",
+      "requiresBlock": true
     }
   },
   "object": {
@@ -1069,7 +1186,8 @@
         "objects"
       ],
       "numArgs": 1,
-      "description": "<p>Extend the context with the properties of other objects. A shallow merge is performed to avoid mutating the context.</p>\n"
+      "description": "<p>Extend the context with the properties of other objects. A shallow merge is performed to avoid mutating the context.</p>\n",
+      "requiresBlock": false
     },
     "forIn": {
       "args": [
@@ -1077,7 +1195,8 @@
         "options"
       ],
       "numArgs": 2,
-      "description": "<p>Block helper that iterates over the properties of an object, exposing each key and value on the context.</p>\n"
+      "description": "<p>Block helper that iterates over the properties of an object, exposing each key and value on the context.</p>\n",
+      "requiresBlock": true
     },
     "forOwn": {
       "args": [
@@ -1085,14 +1204,16 @@
         "options"
       ],
       "numArgs": 2,
-      "description": "<p>Block helper that iterates over the <strong>own</strong> properties of an object, exposing each key and value on the context.</p>\n"
+      "description": "<p>Block helper that iterates over the <strong>own</strong> properties of an object, exposing each key and value on the context.</p>\n",
+      "requiresBlock": true
     },
     "toPath": {
       "args": [
         "prop"
       ],
       "numArgs": 1,
-      "description": "<p>Take arguments and, if they are string or number, convert them to a dot-delineated object property path.</p>\n"
+      "description": "<p>Take arguments and, if they are string or number, convert them to a dot-delineated object property path.</p>\n",
+      "requiresBlock": false
     },
     "get": {
       "args": [
@@ -1101,7 +1222,8 @@
         "options"
       ],
       "numArgs": 3,
-      "description": "<p>Use property paths (<code>a.b.c</code>) to get a value or nested value from the context. Works as a regular helper or block helper.</p>\n"
+      "description": "<p>Use property paths (<code>a.b.c</code>) to get a value or nested value from the context. Works as a regular helper or block helper.</p>\n",
+      "requiresBlock": true
     },
     "getObject": {
       "args": [
@@ -1109,7 +1231,8 @@
         "context"
       ],
       "numArgs": 2,
-      "description": "<p>Use property paths (<code>a.b.c</code>) to get an object from the context. Differs from the <code>get</code> helper in that this helper will return the actual object, including the given property key. Also, this helper does not work as a block helper.</p>\n"
+      "description": "<p>Use property paths (<code>a.b.c</code>) to get an object from the context. Differs from the <code>get</code> helper in that this helper will return the actual object, including the given property key. Also, this helper does not work as a block helper.</p>\n",
+      "requiresBlock": false
     },
     "hasOwn": {
       "args": [
@@ -1117,28 +1240,32 @@
         "context"
       ],
       "numArgs": 2,
-      "description": "<p>Return true if <code>key</code> is an own, enumerable property of the given <code>context</code> object.</p>\n"
+      "description": "<p>Return true if <code>key</code> is an own, enumerable property of the given <code>context</code> object.</p>\n",
+      "requiresBlock": false
     },
     "isObject": {
       "args": [
         "value"
       ],
       "numArgs": 1,
-      "description": "<p>Return true if <code>value</code> is an object.</p>\n"
+      "description": "<p>Return true if <code>value</code> is an object.</p>\n",
+      "requiresBlock": false
     },
     "JSONparse": {
       "args": [
         "string"
       ],
       "numArgs": 1,
-      "description": "<p>Parses the given string using <code>JSON.parse</code>.</p>\n"
+      "description": "<p>Parses the given string using <code>JSON.parse</code>.</p>\n",
+      "requiresBlock": true
     },
     "JSONstringify": {
       "args": [
         "obj"
       ],
       "numArgs": 1,
-      "description": "<p>Stringify an object using <code>JSON.stringify</code>.</p>\n"
+      "description": "<p>Stringify an object using <code>JSON.stringify</code>.</p>\n",
+      "requiresBlock": false
     },
     "merge": {
       "args": [
@@ -1146,14 +1273,16 @@
         "objects"
       ],
       "numArgs": 2,
-      "description": "<p>Deeply merge the properties of the given <code>objects</code> with the context object.</p>\n"
+      "description": "<p>Deeply merge the properties of the given <code>objects</code> with the context object.</p>\n",
+      "requiresBlock": false
     },
     "parseJSON": {
       "args": [
         "string"
       ],
       "numArgs": 1,
-      "description": "<p>Parses the given string using <code>JSON.parse</code>.</p>\n"
+      "description": "<p>Parses the given string using <code>JSON.parse</code>.</p>\n",
+      "requiresBlock": true
     },
     "pick": {
       "args": [
@@ -1162,14 +1291,16 @@
         "options"
       ],
       "numArgs": 3,
-      "description": "<p>Pick properties from the context object.</p>\n"
+      "description": "<p>Pick properties from the context object.</p>\n",
+      "requiresBlock": true
     },
     "stringify": {
       "args": [
         "obj"
       ],
       "numArgs": 1,
-      "description": "<p>Stringify an object using <code>JSON.stringify</code>.</p>\n"
+      "description": "<p>Stringify an object using <code>JSON.stringify</code>.</p>\n",
+      "requiresBlock": false
     }
   },
   "uuid": {
@@ -1177,7 +1308,8 @@
       "args": [],
       "numArgs": 0,
       "example": "{{ uuid }} -> f34ebc66-93bd-4f7c-b79b-92b5569138bc",
-      "description": "<p>Generates a UUID, using the V4 method (identical to the browser crypto.randomUUID function).</p>\n"
+      "description": "<p>Generates a UUID, using the V4 method (identical to the browser crypto.randomUUID function).</p>\n",
+      "requiresBlock": false
     }
   },
   "date": {
diff --git a/packages/string-templates/package.json b/packages/string-templates/package.json
index dfbff1a24b..36f95060b4 100644
--- a/packages/string-templates/package.json
+++ b/packages/string-templates/package.json
@@ -25,7 +25,7 @@
     "manifest": "node ./scripts/gen-collection-info.js"
   },
   "dependencies": {
-    "@budibase/handlebars-helpers": "^0.13.0",
+    "@budibase/handlebars-helpers": "^0.13.1",
     "dayjs": "^1.10.8",
     "handlebars": "^4.7.6",
     "lodash.clonedeep": "^4.5.0",
diff --git a/packages/string-templates/scripts/gen-collection-info.js b/packages/string-templates/scripts/gen-collection-info.js
index b487c4dde4..ed57fe7fae 100644
--- a/packages/string-templates/scripts/gen-collection-info.js
+++ b/packages/string-templates/scripts/gen-collection-info.js
@@ -10,8 +10,8 @@ const marked = require("marked")
  * https://github.com/budibase/handlebars-helpers
  */
 const { join } = require("path")
+const path = require("path")
 
-const DIRECTORY = join(__dirname, "..", "..", "..")
 const COLLECTIONS = [
   "math",
   "array",
@@ -115,6 +115,8 @@ function getCommentInfo(file, func) {
     docs.example = docs.example.replace("product", "multiply")
   }
   docs.description = blocks[0].trim()
+  docs.acceptsBlock = docs.tags.some(el => el.title === "block")
+  docs.acceptsInline = docs.tags.some(el => el.title === "inline")
   return docs
 }
 
@@ -127,7 +129,7 @@ function run() {
   const foundNames = []
   for (let collection of COLLECTIONS) {
     const collectionFile = fs.readFileSync(
-      `${DIRECTORY}/node_modules/${HELPER_LIBRARY}/lib/${collection}.js`,
+      `${path.dirname(require.resolve(HELPER_LIBRARY))}/lib/${collection}.js`,
       "utf8"
     )
     const collectionInfo = {}
@@ -159,6 +161,7 @@ function run() {
         numArgs: args.length,
         example: jsDocInfo.example || undefined,
         description: jsDocInfo.description,
+        requiresBlock: jsDocInfo.acceptsBlock && !jsDocInfo.acceptsInline,
       })
     }
     outputJSON[collection] = collectionInfo
diff --git a/packages/string-templates/src/conversion/index.js b/packages/string-templates/src/conversion/index.js
index 30e2510b55..10aaef0d2f 100644
--- a/packages/string-templates/src/conversion/index.js
+++ b/packages/string-templates/src/conversion/index.js
@@ -1,4 +1,4 @@
-const { getHelperList } = require("../helpers")
+const { getJsHelperList } = require("../helpers")
 
 function getLayers(fullBlock) {
   let layers = []
@@ -109,7 +109,7 @@ module.exports.convertHBSBlock = (block, blockNumber) => {
   const layers = getLayers(block)
 
   let value = null
-  const list = getHelperList()
+  const list = getJsHelperList()
   for (let layer of layers) {
     const parts = splitBySpace(layer)
     if (value || parts.length > 1 || list[parts[0]]) {
diff --git a/packages/string-templates/src/helpers/date.js b/packages/string-templates/src/helpers/date.js
index 27554d1d9e..6fe8b288d6 100644
--- a/packages/string-templates/src/helpers/date.js
+++ b/packages/string-templates/src/helpers/date.js
@@ -115,7 +115,7 @@ module.exports.duration = (str, pattern, format) => {
   setLocale(config.str, config.pattern)
 
   const duration = dayjs.duration(config.str, config.pattern)
-  if (!isOptions(format)) {
+  if (format && !isOptions(format)) {
     return duration.format(format)
   } else {
     return duration.humanize()
diff --git a/packages/string-templates/src/helpers/index.js b/packages/string-templates/src/helpers/index.js
index bed3d0c3e3..5e6dcbd2b9 100644
--- a/packages/string-templates/src/helpers/index.js
+++ b/packages/string-templates/src/helpers/index.js
@@ -7,7 +7,7 @@ const {
   HelperFunctionBuiltin,
   LITERAL_MARKER,
 } = require("./constants")
-const { getHelperList } = require("./list")
+const { getJsHelperList } = require("./list")
 
 const HTML_SWAPS = {
   "<": "&lt;",
@@ -97,4 +97,4 @@ module.exports.unregisterAll = handlebars => {
   externalHandlebars.unregisterAll(handlebars)
 }
 
-module.exports.getHelperList = getHelperList
+module.exports.getJsHelperList = getJsHelperList
diff --git a/packages/string-templates/src/helpers/javascript.js b/packages/string-templates/src/helpers/javascript.js
index 0b63400deb..eff125dd72 100644
--- a/packages/string-templates/src/helpers/javascript.js
+++ b/packages/string-templates/src/helpers/javascript.js
@@ -1,7 +1,7 @@
 const { atob } = require("../utilities")
 const cloneDeep = require("lodash.clonedeep")
 const { LITERAL_MARKER } = require("../helpers/constants")
-const { getHelperList } = require("./list")
+const { getJsHelperList } = require("./list")
 
 // The method of executing JS scripts depends on the bundle being built.
 // This setter is used in the entrypoint (either index.cjs or index.mjs).
@@ -49,7 +49,7 @@ module.exports.processJS = (handlebars, context) => {
     // app context.
     const sandboxContext = {
       $: path => getContextValue(path, cloneDeep(context)),
-      helpers: getHelperList(),
+      helpers: getJsHelperList(),
     }
 
     // Create a sandbox with our context and run the JS
diff --git a/packages/string-templates/src/helpers/list.js b/packages/string-templates/src/helpers/list.js
index b59efb1ef3..e956958865 100644
--- a/packages/string-templates/src/helpers/list.js
+++ b/packages/string-templates/src/helpers/list.js
@@ -3,7 +3,10 @@ const helperList = require("@budibase/handlebars-helpers")
 
 let helpers = undefined
 
-module.exports.getHelperList = () => {
+const helpersToRemoveForJs = ["sortBy"]
+module.exports.helpersToRemoveForJs = helpersToRemoveForJs
+
+module.exports.getJsHelperList = () => {
   if (helpers) {
     return helpers
   }
@@ -15,12 +18,17 @@ module.exports.getHelperList = () => {
   }
   for (let collection of constructed) {
     for (let [key, func] of Object.entries(collection)) {
-      helpers[key] = func
+      // Handlebars injects the hbs options to the helpers by default. We are adding an empty {} as a last parameter to simulate it
+      helpers[key] = (...props) => func(...props, {})
     }
   }
   for (let key of Object.keys(externalHandlebars.addedHelpers)) {
     helpers[key] = externalHandlebars.addedHelpers[key]
   }
+
+  for (const toRemove of helpersToRemoveForJs) {
+    delete helpers[toRemove]
+  }
   Object.freeze(helpers)
   return helpers
 }
diff --git a/packages/string-templates/src/index.cjs b/packages/string-templates/src/index.cjs
index aedb7fc052..7d3aa02be8 100644
--- a/packages/string-templates/src/index.cjs
+++ b/packages/string-templates/src/index.cjs
@@ -20,6 +20,7 @@ module.exports.findHBSBlocks = templates.findHBSBlocks
 module.exports.convertToJS = templates.convertToJS
 module.exports.setJSRunner = templates.setJSRunner
 module.exports.FIND_ANY_HBS_REGEX = templates.FIND_ANY_HBS_REGEX
+module.exports.helpersToRemoveForJs = templates.helpersToRemoveForJs
 
 if (!process.env.NO_JS) {
   const { VM } = require("vm2")
diff --git a/packages/string-templates/src/index.js b/packages/string-templates/src/index.js
index 63da7fde4d..eb9a8ac81d 100644
--- a/packages/string-templates/src/index.js
+++ b/packages/string-templates/src/index.js
@@ -10,6 +10,7 @@ const {
 } = require("./utilities")
 const { convertHBSBlock } = require("./conversion")
 const javascript = require("./helpers/javascript")
+const { helpersToRemoveForJs } = require("./helpers/list")
 
 const hbsInstance = handlebars.create()
 registerAll(hbsInstance)
@@ -394,3 +395,4 @@ module.exports.convertToJS = hbs => {
 }
 
 module.exports.FIND_ANY_HBS_REGEX = FIND_ANY_HBS_REGEX
+module.exports.helpersToRemoveForJs = helpersToRemoveForJs
diff --git a/packages/string-templates/src/index.mjs b/packages/string-templates/src/index.mjs
index 43cda8183f..ad93a7bed4 100644
--- a/packages/string-templates/src/index.mjs
+++ b/packages/string-templates/src/index.mjs
@@ -21,6 +21,7 @@ export const findHBSBlocks = templates.findHBSBlocks
 export const convertToJS = templates.convertToJS
 export const setJSRunner = templates.setJSRunner
 export const FIND_ANY_HBS_REGEX = templates.FIND_ANY_HBS_REGEX
+export const helpersToRemoveForJs = templates.helpersToRemoveForJs
 
 if (process && !process.env.NO_JS) {
   /**
diff --git a/packages/string-templates/test/manifest.spec.js b/packages/string-templates/test/manifest.spec.js
index 506f2eb6f7..3e39d775f5 100644
--- a/packages/string-templates/test/manifest.spec.js
+++ b/packages/string-templates/test/manifest.spec.js
@@ -16,21 +16,55 @@ jest.mock("@budibase/handlebars-helpers/lib/uuid", () => {
 })
 
 const fs = require("fs")
-const { processString } = require("../src/index.cjs")
+const {
+  processString,
+  convertToJS,
+  processStringSync,
+  encodeJSBinding,
+} = require("../src/index.cjs")
 
 const tk = require("timekeeper")
+const { getJsHelperList } = require("../src/helpers")
+
 tk.freeze("2021-01-21T12:00:00")
 
+const processJS = (js, context) => {
+  return processStringSync(encodeJSBinding(js), context)
+}
+
 const manifest = JSON.parse(
   fs.readFileSync(require.resolve("../manifest.json"), "utf8")
 )
 
 const collections = Object.keys(manifest)
 const examples = collections.reduce((acc, collection) => {
-  const functions = Object.keys(manifest[collection]).filter(
-    fnc => manifest[collection][fnc].example
-  )
-  if (functions.length) {
+  const functions = Object.entries(manifest[collection])
+    .filter(([_, details]) => details.example)
+    .map(([name, details]) => {
+      const example = details.example
+      let [hbs, js] = example.split("->").map(x => x.trim())
+      if (!js) {
+        // The function has no return value
+        return
+      }
+
+      // Trim 's
+      js = js.replace(/^\'|\'$/g, "")
+      if ((parsedExpected = tryParseJson(js))) {
+        if (Array.isArray(parsedExpected)) {
+          if (typeof parsedExpected[0] === "object") {
+            js = JSON.stringify(parsedExpected)
+          } else {
+            js = parsedExpected.join(",")
+          }
+        }
+      }
+      const requiresHbsBody = details.requiresBlock
+      return [name, { hbs, js, requiresHbsBody }]
+    })
+    .filter(x => !!x)
+
+  if (Object.keys(functions).length) {
     acc[collection] = functions
   }
   return acc
@@ -55,11 +89,7 @@ function tryParseJson(str) {
 describe("manifest", () => {
   describe("examples are valid", () => {
     describe.each(Object.keys(examples))("%s", collection => {
-      it.each(examples[collection])("%s", async func => {
-        const example = manifest[collection][func].example
-
-        let [hbs, js] = example.split("->").map(x => x.trim())
-
+      it.each(examples[collection])("%s", async (_, { hbs, js }) => {
         const context = {
           double: i => i * 2,
           isString: x => typeof x === "string",
@@ -71,23 +101,40 @@ describe("manifest", () => {
           context[`array${i}`] = JSON.parse(arrayString.replace(/\'/g, '"'))
         })
 
-        if (js === undefined) {
-          // The function has no return value
-          return
+        let result = await processString(hbs, context)
+        result = result.replace(/&nbsp;/g, " ")
+        expect(result).toEqual(js)
+      })
+    })
+  })
+
+  describe("can be parsed and run as js", () => {
+    const jsHelpers = getJsHelperList()
+    const jsExamples = Object.keys(examples).reduce((acc, v) => {
+      acc[v] = examples[v].filter(([key]) => jsHelpers[key])
+      return acc
+    }, {})
+
+    describe.each(Object.keys(jsExamples))("%s", collection => {
+      it.each(
+        jsExamples[collection].filter(
+          ([_, { requiresHbsBody }]) => !requiresHbsBody
+        )
+      )("%s", async (_, { hbs, js }) => {
+        const context = {
+          double: i => i * 2,
+          isString: x => typeof x === "string",
         }
 
-        let result = await processString(hbs, context)
-        // Trim 's
-        js = js.replace(/^\'|\'$/g, "")
-        if ((parsedExpected = tryParseJson(js))) {
-          if (Array.isArray(parsedExpected)) {
-            if (typeof parsedExpected[0] === "object") {
-              js = JSON.stringify(parsedExpected)
-            } else {
-              js = parsedExpected.join(",")
-            }
-          }
-        }
+        const arrays = hbs.match(/\[[^/\]]+\]/)
+        arrays?.forEach((arrayString, i) => {
+          hbs = hbs.replace(new RegExp(escapeRegExp(arrayString)), `array${i}`)
+          context[`array${i}`] = JSON.parse(arrayString.replace(/\'/g, '"'))
+        })
+
+        let convertedJs = convertToJS(hbs)
+
+        let result = processJS(convertedJs, context)
         result = result.replace(/&nbsp;/g, " ")
         expect(result).toEqual(js)
       })
diff --git a/packages/types/package.json b/packages/types/package.json
index 5111339c7b..ce4fce95fb 100644
--- a/packages/types/package.json
+++ b/packages/types/package.json
@@ -15,7 +15,7 @@
   },
   "jest": {},
   "devDependencies": {
-    "@budibase/nano": "10.1.4",
+    "@budibase/nano": "10.1.5",
     "@types/koa": "2.13.4",
     "@types/pouchdb": "6.4.0",
     "@types/redlock": "4.0.3",
diff --git a/packages/types/src/documents/app/query.ts b/packages/types/src/documents/app/query.ts
index 473449bffb..790c297813 100644
--- a/packages/types/src/documents/app/query.ts
+++ b/packages/types/src/documents/app/query.ts
@@ -1,4 +1,5 @@
 import { Document } from "../document"
+import type { Row } from "./row"
 
 export interface QuerySchema {
   name?: string
@@ -54,3 +55,12 @@ export interface PreviewQueryRequest extends Omit<Query, "parameters"> {
     urlName?: boolean
   }
 }
+
+export interface ExecuteQueryRequest {
+  parameters?: { [key: string]: string }
+  pagination?: any
+}
+
+export interface ExecuteQueryResponse {
+  data: Row[]
+}
diff --git a/packages/worker/package.json b/packages/worker/package.json
index 2e3200fda5..6c4cc6fe5b 100644
--- a/packages/worker/package.json
+++ b/packages/worker/package.json
@@ -63,7 +63,7 @@
     "koa-useragent": "^4.1.0",
     "lodash": "4.17.21",
     "node-fetch": "2.6.7",
-    "nodemailer": "6.7.2",
+    "nodemailer": "6.9.9",
     "passport-google-oauth": "2.0.0",
     "passport-local": "1.0.0",
     "pouchdb": "7.3.0",
diff --git a/yarn.lock b/yarn.lock
index d2fb6f5236..2c12097fb5 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -2031,10 +2031,10 @@
   resolved "https://registry.yarnpkg.com/@bcoe/v8-coverage/-/v8-coverage-0.2.3.tgz#75a2e8b51cb758a7553d6804a5932d7aace75c39"
   integrity sha512-0hYQ8SB4Db5zvZB4axdMHGwEaQjkZzFjQiN9LVYvIFB2nSUHW9tYpxWriPrWDASIxiaXax83REcLxuSdnGPZtw==
 
-"@budibase/handlebars-helpers@^0.13.0":
-  version "0.13.0"
-  resolved "https://registry.yarnpkg.com/@budibase/handlebars-helpers/-/handlebars-helpers-0.13.0.tgz#224333d14e3900b7dacf48286af1e624a9fd62ea"
-  integrity sha512-g8+sFrMNxsIDnK+MmdUICTVGr6ReUFtnPp9hJX0VZwz1pN3Ynolpk/Qbu6rEWAvoU1sEqY1mXr9uo/+kEfeGbQ==
+"@budibase/handlebars-helpers@^0.13.1":
+  version "0.13.1"
+  resolved "https://registry.yarnpkg.com/@budibase/handlebars-helpers/-/handlebars-helpers-0.13.1.tgz#d02e73c0df8305cd675e70dc37f8427eb0842080"
+  integrity sha512-v4RbXhr3igvK3i2pj5cNltu/4NMxdPIzcUt/o0RoInhesNH1VSLRdweSFr6/Y34fsCR5jHZ6vltdcz2RgrTKgw==
   dependencies:
     get-object "^0.2.0"
     get-value "^3.0.1"
@@ -2050,10 +2050,10 @@
     to-gfm-code-block "^0.1.1"
     uuid "^9.0.1"
 
-"@budibase/nano@10.1.4":
-  version "10.1.4"
-  resolved "https://registry.yarnpkg.com/@budibase/nano/-/nano-10.1.4.tgz#5c2670d0b4c12d736ddd6581c57d47c0aa45efad"
-  integrity sha512-J+IVaAljGideDvJss/AUxXA1599HEIUJo5c0LLlmc1KMA3GZWZjyX+w2fxAw3qF7hqFvX+qAStQgdcD3+/GPMA==
+"@budibase/nano@10.1.5":
+  version "10.1.5"
+  resolved "https://registry.yarnpkg.com/@budibase/nano/-/nano-10.1.5.tgz#eeaded7bfc707ecabf8fde604425b865a90c06ec"
+  integrity sha512-q1eKIsYKo+iK17zsJYd3VBl+5ufQMPpHYLec0wVsid8wnJVrTQk7RNpBlBUn/EDgXM7t8XNNHlERqHu+CxJu8Q==
   dependencies:
     "@types/tough-cookie" "^4.0.2"
     axios "^1.1.3"