Merge branch 'master' of github.com:Budibase/budibase into feature/role-multi-inheritance

2024-09-27 13:33:27 +01:00 · 2024-09-27 13:33:27 +01:00 · 61c28154fb
parent fa9bb030c9 78733da79b
commit 61c28154fb
39 changed files with 913 additions and 202 deletions
--- a/packages/backend-core/src/features/index.ts
+++ b/packages/backend-core/src/features/index.ts
@ -277,5 +277,5 @@ export const flags = new FlagSet({
  AUTOMATION_BRANCHING: Flag.boolean(env.isDev()),
  SQS: Flag.boolean(env.isDev()),
  [FeatureFlag.AI_CUSTOM_CONFIGS]: Flag.boolean(env.isDev()),
-  [FeatureFlag.ENRICHED_RELATIONSHIPS]: Flag.boolean(false),
+  [FeatureFlag.ENRICHED_RELATIONSHIPS]: Flag.boolean(env.isDev()),
 })
--- a/packages/builder/src/components/backend/DataTable/Table.svelte
+++ b/packages/builder/src/components/backend/DataTable/Table.svelte
@ -6,7 +6,7 @@
  import { TableNames, UNEDITABLE_USER_FIELDS } from "constants"
  import RoleCell from "./cells/RoleCell.svelte"
  import { createEventDispatcher } from "svelte"
-  import { canBeSortColumn } from "@budibase/shared-core"
+  import { canBeSortColumn } from "@budibase/frontend-core"

  export let schema = {}
  export let data = []
@ -31,7 +31,7 @@
      acc[key] =
        typeof schema[key] === "string" ? { type: schema[key] } : schema[key]

-      if (!canBeSortColumn(acc[key].type)) {
+      if (!canBeSortColumn(acc[key])) {
        acc[key].sortable = false
      }
      return acc
--- a/packages/builder/src/components/backend/DataTable/ViewV2DataTable.svelte
+++ b/packages/builder/src/components/backend/DataTable/ViewV2DataTable.svelte
@ -1,6 +1,6 @@
 <script>
  import { viewsV2 } from "stores/builder"
-  import { admin } from "stores/portal"
+  import { admin, themeStore } from "stores/portal"
  import { Grid } from "@budibase/frontend-core"
  import { API } from "api"
  import GridCreateEditRowModal from "components/backend/DataTable/modals/grid/GridCreateEditRowModal.svelte"
@ -16,6 +16,9 @@
    tableId: $viewsV2.selected?.tableId,
  }

+  $: currentTheme = $themeStore?.theme
+  $: darkMode = !currentTheme.includes("light")
+
  const handleGridViewUpdate = async e => {
    viewsV2.replaceView(id, e.detail)
  }
@ -25,6 +28,7 @@
  <Grid
    {API}
    {datasource}
+    {darkMode}
    allowAddRows
    allowDeleteRows
    showAvatars={false}
--- a/packages/builder/src/components/backend/DataTable/modals/CreateEditColumn.svelte
+++ b/packages/builder/src/components/backend/DataTable/modals/CreateEditColumn.svelte
@ -19,7 +19,6 @@
    helpers,
    PROTECTED_INTERNAL_COLUMNS,
    PROTECTED_EXTERNAL_COLUMNS,
-    canBeDisplayColumn,
    canHaveDefaultColumn,
  } from "@budibase/shared-core"
  import { createEventDispatcher, getContext, onMount } from "svelte"
@ -43,7 +42,7 @@
    SourceName,
  } from "@budibase/types"
  import RelationshipSelector from "components/common/RelationshipSelector.svelte"
-  import { RowUtils } from "@budibase/frontend-core"
+  import { RowUtils, canBeDisplayColumn } from "@budibase/frontend-core"
  import ServerBindingPanel from "components/common/bindings/ServerBindingPanel.svelte"
  import OptionsEditor from "./OptionsEditor.svelte"
  import { isEnabled } from "helpers/featureFlags"
@ -166,7 +165,7 @@
    : availableAutoColumns
  // used to select what different options can be displayed for column type
  $: canBeDisplay =
-    canBeDisplayColumn(editableColumn.type) && !editableColumn.autocolumn
+    canBeDisplayColumn(editableColumn) && !editableColumn.autocolumn
  $: canHaveDefault =
    isEnabled("DEFAULT_VALUES") && canHaveDefaultColumn(editableColumn.type)
  $: canBeRequired =
--- a/packages/builder/src/components/backend/TableNavigator/TableDataImport.svelte
+++ b/packages/builder/src/components/backend/TableNavigator/TableDataImport.svelte
@ -1,7 +1,8 @@
 <script>
  import { Select, Icon } from "@budibase/bbui"
  import { FIELDS } from "constants/backend"
-  import { canBeDisplayColumn, utils } from "@budibase/shared-core"
+  import { utils } from "@budibase/shared-core"
+  import { canBeDisplayColumn } from "@budibase/frontend-core"
  import { API } from "api"
  import { parseFile } from "./utils"

@ -100,10 +101,10 @@
  let rawRows = []

  $: displayColumnOptions = Object.keys(schema || {}).filter(column => {
-    return validation[column] && canBeDisplayColumn(schema[column].type)
+    return validation[column] && canBeDisplayColumn(schema[column])
  })

-  $: if (displayColumn && !canBeDisplayColumn(schema[displayColumn].type)) {
+  $: if (displayColumn && !canBeDisplayColumn(schema[displayColumn])) {
    displayColumn = null
  }

--- a/packages/builder/src/components/design/settings/controls/GridColumnConfiguration/GridColumnConfiguration.svelte
+++ b/packages/builder/src/components/design/settings/controls/GridColumnConfiguration/GridColumnConfiguration.svelte
@ -1,4 +1,5 @@
 <script>
+  import { enrichSchemaWithRelColumns } from "@budibase/frontend-core"
  import { getDatasourceForProvider, getSchemaForDatasource } from "dataBinding"
  import { selectedScreen, componentStore } from "stores/builder"
  import DraggableList from "../DraggableList/DraggableList.svelte"
@ -27,7 +28,8 @@
      delete schema._rev
    }

-    return schema
+    const result = enrichSchemaWithRelColumns(schema)
+    return result
  }

  $: datasource = getDatasourceForProvider($selectedScreen, componentInstance)
--- a/packages/builder/src/components/design/settings/controls/GridColumnConfiguration/getColumns.js
+++ b/packages/builder/src/components/design/settings/controls/GridColumnConfiguration/getColumns.js
@ -82,7 +82,7 @@ const toDraggableListFormat = (gridFormatColumns, createComponent, schema) => {
        active: column.active,
        field: column.field,
        label: column.label,
-        columnType: schema[column.field].type,
+        columnType: column.columnType || schema[column.field].type,
        width: column.width,
        conditions: column.conditions,
      },
--- a/packages/builder/src/components/design/settings/controls/SortableFieldSelect.svelte
+++ b/packages/builder/src/components/design/settings/controls/SortableFieldSelect.svelte
@ -3,7 +3,7 @@
  import { getDatasourceForProvider, getSchemaForDatasource } from "dataBinding"
  import { selectedScreen } from "stores/builder"
  import { createEventDispatcher } from "svelte"
-  import { canBeSortColumn } from "@budibase/shared-core"
+  import { canBeSortColumn } from "@budibase/frontend-core"

  export let componentInstance = {}
  export let value = ""
@ -17,7 +17,7 @@

  const getSortableFields = schema => {
    return Object.entries(schema || {})
-      .filter(entry => canBeSortColumn(entry[1].type))
+      .filter(entry => canBeSortColumn(entry[1]))
      .map(entry => entry[0])
  }

--- a/packages/builder/src/pages/builder/portal/settings/ai/AIConfigTile.svelte
+++ b/packages/builder/src/pages/builder/portal/settings/ai/AIConfigTile.svelte
@ -4,6 +4,7 @@
  import OpenAILogo from "./logos/OpenAI.svelte"
  import AnthropicLogo from "./logos/Anthropic.svelte"
  import TogetherAILogo from "./logos/TogetherAI.svelte"
+  import AzureOpenAILogo from "./logos/AzureOpenAI.svelte"
  import { Providers } from "./constants"

  const logos = {
@ -11,6 +12,7 @@
    [Providers.OpenAI.name]: OpenAILogo,
    [Providers.Anthropic.name]: AnthropicLogo,
    [Providers.TogetherAI.name]: TogetherAILogo,
+    [Providers.AzureOpenAI.name]: AzureOpenAILogo,
  }

  export let config
@ -26,8 +28,8 @@
  <div class="icon">
    <svelte:component
      this={logos[config.name || config.provider]}
-      height="30"
-      width="30"
+      height="18"
+      width="18"
    />
  </div>
  <div class="header">
@ -110,7 +112,7 @@

  .tag {
    display: flex;
-    color: var(--spectrum-body-m-text-color);
+    color: #ffffff;
    padding: 4px 8px;
    justify-content: center;
    align-items: center;
--- a/packages/builder/src/pages/builder/portal/settings/ai/AISettings.spec.js
+++ b/packages/builder/src/pages/builder/portal/settings/ai/AISettings.spec.js
@ -1,6 +1,6 @@
 import { it, expect, describe, vi } from "vitest"
 import AISettings from "./index.svelte"
-import { render } from "@testing-library/svelte"
+import { render, fireEvent } from "@testing-library/svelte"
 import { admin, licensing } from "stores/portal"
 import { notifications } from "@budibase/bbui"

@ -55,39 +55,43 @@ describe("AISettings", () => {
      expect(enterpriseTag).toBeInTheDocument()
    })

-    it("should show the premium label on cloud when Budibase AI isn't enabled", async () => {
-      setupEnv(Hosting.Cloud)
-      instance = render(AISettings, {})
-      const premiumTag = instance.queryByText("Premium")
-      expect(premiumTag).toBeInTheDocument()
-    })
-
-    it("should not show the add configuration button if the user doesn't have the correct license on cloud", async () => {
+    it("the add configuration button should not do anything the user doesn't have the correct license on cloud", async () => {
      let addConfigurationButton
+      let configModal

      setupEnv(Hosting.Cloud)
      instance = render(AISettings)
      addConfigurationButton = instance.queryByText("Add configuration")
-      expect(addConfigurationButton).not.toBeInTheDocument()
+      expect(addConfigurationButton).toBeInTheDocument()
+      await fireEvent.click(addConfigurationButton)
+      configModal = instance.queryByText("Custom AI Configuration")
+      expect(configModal).not.toBeInTheDocument()
+    })
+
+    it("the add configuration button should open the config modal if the user has the correct license on cloud", async () => {
+      let addConfigurationButton
+      let configModal

      setupEnv(Hosting.Cloud, { customAIConfigsEnabled: true })
      instance = render(AISettings)
      addConfigurationButton = instance.queryByText("Add configuration")
      expect(addConfigurationButton).toBeInTheDocument()
+      await fireEvent.click(addConfigurationButton)
+      configModal = instance.queryByText("Custom AI Configuration")
+      expect(configModal).toBeInTheDocument()
    })

-    it("should not show the add configuration button if the user doesn't have the correct license on self host", async () => {
+    it("the add configuration button should open the config modal if the user has the correct license on self host", async () => {
      let addConfigurationButton
-
-      setupEnv(Hosting.Self)
-      instance = render(AISettings)
-      addConfigurationButton = instance.queryByText("Add configuration")
-      expect(addConfigurationButton).not.toBeInTheDocument()
+      let configModal

      setupEnv(Hosting.Self, { customAIConfigsEnabled: true })
-      instance = render(AISettings, {})
+      instance = render(AISettings)
      addConfigurationButton = instance.queryByText("Add configuration")
      expect(addConfigurationButton).toBeInTheDocument()
+      await fireEvent.click(addConfigurationButton)
+      configModal = instance.queryByText("Custom AI Configuration")
+      expect(configModal).toBeInTheDocument()
    })
  })
 })
--- a/packages/builder/src/pages/builder/portal/settings/ai/ConfigModal.svelte
+++ b/packages/builder/src/pages/builder/portal/settings/ai/ConfigModal.svelte
@ -84,8 +84,10 @@
    <Label size="M">API Key</Label>
    <Input type="password" bind:value={config.apiKey} />
  </div>
+  <div class="form-row">
    <Toggle text="Active" bind:value={config.active} />
    <Toggle text="Set as default" bind:value={config.isDefault} />
+  </div>
 </ModalContent>

 <style>
--- a/packages/builder/src/pages/builder/portal/settings/ai/constants.js
+++ b/packages/builder/src/pages/builder/portal/settings/ai/constants.js
@ -23,7 +23,7 @@ export const Providers = {
    models: [{ label: "Llama 3 8B", value: "meta-llama/Meta-Llama-3-8B" }],
  },
  AzureOpenAI: {
-    name: "Azure Open AI",
+    name: "Azure OpenAI",
    models: [
      { label: "GPT 4o Mini", value: "gpt-4o-mini" },
      { label: "GPT 4o", value: "gpt-4o" },
--- a/packages/builder/src/pages/builder/portal/settings/ai/index.svelte
+++ b/packages/builder/src/pages/builder/portal/settings/ai/index.svelte
@ -27,7 +27,6 @@
  let editingUuid

  $: isCloud = $admin.cloud
-  $: budibaseAIEnabled = $licensing.budibaseAIEnabled
  $: customAIConfigsEnabled = $licensing.customAIConfigsEnabled

  async function fetchAIConfig() {
@ -127,18 +126,8 @@
 </Modal>
 <Layout noPadding>
  <Layout gap="XS" noPadding>
+    <div class="header">
      <Heading size="M">AI</Heading>
-    {#if isCloud && !budibaseAIEnabled}
-      <Tags>
-        <Tag icon="LockClosed">Premium</Tag>
-      </Tags>
-    {/if}
-    <Body>Configure your AI settings within this section:</Body>
-  </Layout>
-  <Divider />
-  <Layout noPadding>
-    <div class="config-heading">
-      <Heading size="S">AI Configurations</Heading>
      {#if !isCloud && !customAIConfigsEnabled}
        <Tags>
          <Tag icon="LockClosed">Premium</Tag>
@ -147,24 +136,43 @@
        <Tags>
          <Tag icon="LockClosed">Enterprise</Tag>
        </Tags>
-      {:else}
-        <Button size="S" cta on:click={newConfig}>Add configuration</Button>
      {/if}
    </div>
+    <Body>Configure your AI settings within this section:</Body>
+  </Layout>
+  <Divider />
+  <div style={`opacity: ${customAIConfigsEnabled ? 1 : 0.5}`}>
+    <Layout noPadding>
+      <div class="config-heading">
+        <Heading size="S">AI Configurations</Heading>
+        <Button
+          size="S"
+          cta={customAIConfigsEnabled}
+          secondary={!customAIConfigsEnabled}
+          on:click={customAIConfigsEnabled ? newConfig : null}
+        >
+          Add configuration
+        </Button>
+      </div>
      <Body size="S"
        >Use the following interface to select your preferred AI configuration.</Body
      >
+      {#if customAIConfigsEnabled}
        <Body size="S">Select your AI Model:</Body>
+      {/if}
      {#if fullAIConfig?.config}
        {#each Object.keys(fullAIConfig.config) as key}
          <AIConfigTile
            config={fullAIConfig.config[key]}
-          editHandler={() => editConfig(key)}
-          deleteHandler={() => deleteConfig(key)}
+            editHandler={customAIConfigsEnabled ? () => editConfig(key) : null}
+            deleteHandler={customAIConfigsEnabled
+              ? () => deleteConfig(key)
+              : null}
          />
        {/each}
      {/if}
    </Layout>
+  </div>
 </Layout>

 <style>
@ -172,5 +180,12 @@
    display: flex;
    justify-content: space-between;
    align-items: center;
+    margin-bottom: -18px;
+  }
+
+  .header {
+    display: flex;
+    align-items: center;
+    gap: 12px;
  }
 </style>
--- a/packages/builder/src/pages/builder/portal/settings/ai/logos/AzureOpenAI.svelte
+++ b/packages/builder/src/pages/builder/portal/settings/ai/logos/AzureOpenAI.svelte
@ -0,0 +1,64 @@
+<script>
+  export let width
+  export let height
+</script>
+
+<svg xmlns="http://www.w3.org/2000/svg" {width} {height} viewBox="0 0 96 96">
+  <defs>
+    <linearGradient
+      id="e399c19f-b68f-429d-b176-18c2117ff73c"
+      x1="-1032.172"
+      x2="-1059.213"
+      y1="145.312"
+      y2="65.426"
+      gradientTransform="matrix(1 0 0 -1 1075 158)"
+      gradientUnits="userSpaceOnUse"
+    >
+      <stop offset="0" stop-color="#114a8b" />
+      <stop offset="1" stop-color="#0669bc" />
+    </linearGradient>
+    <linearGradient
+      id="ac2a6fc2-ca48-4327-9a3c-d4dcc3256e15"
+      x1="-1023.725"
+      x2="-1029.98"
+      y1="108.083"
+      y2="105.968"
+      gradientTransform="matrix(1 0 0 -1 1075 158)"
+      gradientUnits="userSpaceOnUse"
+    >
+      <stop offset="0" stop-opacity=".3" />
+      <stop offset=".071" stop-opacity=".2" />
+      <stop offset=".321" stop-opacity=".1" />
+      <stop offset=".623" stop-opacity=".05" />
+      <stop offset="1" stop-opacity="0" />
+    </linearGradient>
+    <linearGradient
+      id="a7fee970-a784-4bb1-af8d-63d18e5f7db9"
+      x1="-1027.165"
+      x2="-997.482"
+      y1="147.642"
+      y2="68.561"
+      gradientTransform="matrix(1 0 0 -1 1075 158)"
+      gradientUnits="userSpaceOnUse"
+    >
+      <stop offset="0" stop-color="#3ccbf4" />
+      <stop offset="1" stop-color="#2892df" />
+    </linearGradient>
+  </defs>
+  <path
+    fill="url(#e399c19f-b68f-429d-b176-18c2117ff73c)"
+    d="M33.338 6.544h26.038l-27.03 80.087a4.152 4.152 0 0 1-3.933 2.824H8.149a4.145 4.145 0 0 1-3.928-5.47L29.404 9.368a4.152 4.152 0 0 1 3.934-2.825z"
+  />
+  <path
+    fill="#0078d4"
+    d="M71.175 60.261h-41.29a1.911 1.911 0 0 0-1.305 3.309l26.532 24.764a4.171 4.171 0 0 0 2.846 1.121h23.38z"
+  />
+  <path
+    fill="url(#ac2a6fc2-ca48-4327-9a3c-d4dcc3256e15)"
+    d="M33.338 6.544a4.118 4.118 0 0 0-3.943 2.879L4.252 83.917a4.14 4.14 0 0 0 3.908 5.538h20.787a4.443 4.443 0 0 0 3.41-2.9l5.014-14.777 17.91 16.705a4.237 4.237 0 0 0 2.666.972H81.24L71.024 60.261l-29.781.007L59.47 6.544z"
+  />
+  <path
+    fill="url(#a7fee970-a784-4bb1-af8d-63d18e5f7db9)"
+    d="M66.595 9.364a4.145 4.145 0 0 0-3.928-2.82H33.648a4.146 4.146 0 0 1 3.928 2.82l25.184 74.62a4.146 4.146 0 0 1-3.928 5.472h29.02a4.146 4.146 0 0 0 3.927-5.472z"
+  />
+</svg>
--- a/packages/builder/src/pages/builder/portal/settings/index.svelte
+++ b/packages/builder/src/pages/builder/portal/settings/index.svelte
@ -1,5 +1,10 @@
 <script>
  import { redirect } from "@roxi/routify"
+  import { licensing } from "stores/portal"

+  if ($licensing.customAIConfigsEnabled) {
+    $redirect("./ai")
+  } else {
    $redirect("./auth")
+  }
 </script>
--- a/packages/client/src/components/app/deprecated/table/Table.svelte
+++ b/packages/client/src/components/app/deprecated/table/Table.svelte
@ -2,7 +2,7 @@
  import { getContext, onDestroy } from "svelte"
  import { Table } from "@budibase/bbui"
  import SlotRenderer from "./SlotRenderer.svelte"
-  import { canBeSortColumn } from "@budibase/shared-core"
+  import { canBeSortColumn } from "@budibase/frontend-core"
  import Provider from "components/context/Provider.svelte"

  export let dataProvider
@ -146,7 +146,7 @@
        return
      }
      newSchema[columnName] = schema[columnName]
-      if (!canBeSortColumn(schema[columnName].type)) {
+      if (!canBeSortColumn(schema[columnName])) {
        newSchema[columnName].sortable = false
      }

--- a/packages/frontend-core/src/components/grid/cells/AttachmentCell.svelte
+++ b/packages/frontend-core/src/components/grid/cells/AttachmentCell.svelte
@ -2,6 +2,7 @@
  import { onMount, getContext } from "svelte"
  import { Dropzone } from "@budibase/bbui"
  import GridPopover from "../overlays/GridPopover.svelte"
+  import { FieldType } from "@budibase/types"

  export let value
  export let focused = false
@ -81,7 +82,12 @@
 >
  {#each value || [] as attachment}
    {#if isImage(attachment.extension)}
-      <img src={attachment.url} alt={attachment.extension} />
+      <img
+        class:light={!$props?.darkMode &&
+          schema.type === FieldType.SIGNATURE_SINGLE}
+        src={attachment.url}
+        alt={attachment.extension}
+      />
    {:else}
      <div class="file" title={attachment.name}>
        {attachment.extension}
@ -140,4 +146,9 @@
    width: 320px;
    padding: var(--cell-padding);
  }
+
+  .attachment-cell img.light {
+    -webkit-filter: invert(100%);
+    filter: invert(100%);
+  }
 </style>
--- a/packages/frontend-core/src/components/grid/cells/HeaderCell.svelte
+++ b/packages/frontend-core/src/components/grid/cells/HeaderCell.svelte
@ -1,6 +1,6 @@
 <script>
  import { getContext, onMount, tick } from "svelte"
-  import { canBeDisplayColumn, canBeSortColumn } from "@budibase/shared-core"
+  import { canBeSortColumn, canBeDisplayColumn } from "@budibase/frontend-core"
  import { Icon, Menu, MenuItem, Modal } from "@budibase/bbui"
  import GridCell from "./GridCell.svelte"
  import { getColumnIcon } from "../lib/utils"
@ -165,7 +165,17 @@
  }

  const hideColumn = () => {
-    datasource.actions.addSchemaMutation(column.name, { visible: false })
+    const { related } = column
+    const mutation = { visible: false }
+    if (!related) {
+      datasource.actions.addSchemaMutation(column.name, mutation)
+    } else {
+      datasource.actions.addSubSchemaMutation(
+        related.subField,
+        related.field,
+        mutation
+      )
+    }
    datasource.actions.saveSchemaMutations()
    open = false
  }
@ -347,15 +357,14 @@
        <MenuItem
          icon="Label"
          on:click={makeDisplayColumn}
-          disabled={column.primaryDisplay ||
-            !canBeDisplayColumn(column.schema.type)}
+          disabled={column.primaryDisplay || !canBeDisplayColumn(column.schema)}
        >
          Use as display column
        </MenuItem>
        <MenuItem
          icon="SortOrderUp"
          on:click={sortAscending}
-          disabled={!canBeSortColumn(column.schema.type) ||
+          disabled={!canBeSortColumn(column.schema) ||
            (column.name === $sort.column && $sort.order === "ascending")}
        >
          Sort {sortingLabels.ascending}
@ -363,7 +372,7 @@
        <MenuItem
          icon="SortOrderDown"
          on:click={sortDescending}
-          disabled={!canBeSortColumn(column.schema.type) ||
+          disabled={!canBeSortColumn(column.schema) ||
            (column.name === $sort.column && $sort.order === "descending")}
        >
          Sort {sortingLabels.descending}
--- a/packages/frontend-core/src/components/grid/controls/ColumnsSettingButton.svelte
+++ b/packages/frontend-core/src/components/grid/controls/ColumnsSettingButton.svelte
@ -4,13 +4,15 @@
  import ColumnsSettingContent from "./ColumnsSettingContent.svelte"
  import { FieldPermissions } from "../../../constants"

-  const { columns, datasource } = getContext("grid")
+  const { tableColumns, datasource } = getContext("grid")

  let open = false
  let anchor

-  $: anyRestricted = $columns.filter(col => !col.visible || col.readonly).length
-  $: text = anyRestricted ? `Columns: (${anyRestricted} restricted)` : "Columns"
+  $: anyRestricted = $tableColumns.filter(
+    col => !col.visible || col.readonly
+  ).length
+  $: text = anyRestricted ? `Columns (${anyRestricted} restricted)` : "Columns"
  $: permissions =
    $datasource.type === "viewV2"
      ? [
@ -28,12 +30,12 @@
    size="M"
    on:click={() => (open = !open)}
    selected={open || anyRestricted}
-    disabled={!$columns.length}
+    disabled={!$tableColumns.length}
  >
    {text}
  </ActionButton>
 </div>

 <Popover bind:open {anchor} align="left">
-  <ColumnsSettingContent columns={$columns} {permissions} />
+  <ColumnsSettingContent columns={$tableColumns} {permissions} />
 </Popover>
--- a/packages/frontend-core/src/components/grid/controls/ColumnsSettingContent.svelte
+++ b/packages/frontend-core/src/components/grid/controls/ColumnsSettingContent.svelte
@ -122,8 +122,10 @@
      label: name,
      schema: {
        type: column.type,
+        subtype: column.subtype,
        visible: column.visible,
        readonly: column.readonly,
+        constraints: column.constraints, // This is needed to properly display "users" column
      },
    }
  })
--- a/packages/frontend-core/src/components/grid/controls/SortButton.svelte
+++ b/packages/frontend-core/src/components/grid/controls/SortButton.svelte
@ -1,7 +1,7 @@
 <script>
  import { getContext } from "svelte"
  import { ActionButton, Popover, Select } from "@budibase/bbui"
-  import { canBeSortColumn } from "@budibase/shared-core"
+  import { canBeSortColumn } from "@budibase/frontend-core"

  const { sort, columns } = getContext("grid")

@ -13,8 +13,9 @@
      label: col.label || col.name,
      value: col.name,
      type: col.schema?.type,
+      related: col.related,
    }))
-    .filter(col => canBeSortColumn(col.type))
+    .filter(col => canBeSortColumn(col))
  $: orderOptions = getOrderOptions($sort.column, columnOptions)

  const getOrderOptions = (column, columnOptions) => {
--- a/packages/frontend-core/src/components/grid/lib/renderers.js
+++ b/packages/frontend-core/src/components/grid/lib/renderers.js
@ -35,5 +35,9 @@ const TypeComponentMap = {
  [FieldType.BB_REFERENCE_SINGLE]: BBReferenceSingleCell,
 }
 export const getCellRenderer = column => {
-  return TypeComponentMap[column?.schema?.type] || TextCell
+  return (
+    TypeComponentMap[column?.schema?.cellRenderType] ||
+    TypeComponentMap[column?.schema?.type] ||
+    TextCell
+  )
 }
--- a/packages/frontend-core/src/components/grid/stores/columns.js
+++ b/packages/frontend-core/src/components/grid/stores/columns.js
@ -42,6 +42,11 @@ export const deriveStores = context => {
    return map
  })

+  // Derived list of columns which are direct part of the table
+  const tableColumns = derived(columns, $columns => {
+    return $columns.filter(col => !col.related)
+  })
+
  // Derived list of columns which have not been explicitly hidden
  const visibleColumns = derived(columns, $columns => {
    return $columns.filter(col => col.visible)
@ -64,6 +69,7 @@ export const deriveStores = context => {
  })

  return {
+    tableColumns,
    displayColumn,
    columnLookupMap,
    visibleColumns,
@ -73,16 +79,24 @@ export const deriveStores = context => {
 }

 export const createActions = context => {
-  const { columns, datasource, schema } = context
+  const { columns, datasource } = context

  // Updates the width of all columns
  const changeAllColumnWidths = async width => {
-    const $schema = get(schema)
-    let mutations = {}
-    Object.keys($schema).forEach(field => {
-      mutations[field] = { width }
+    const $columns = get(columns)
+    $columns.forEach(column => {
+      const { related } = column
+      const mutation = { width }
+      if (!related) {
+        datasource.actions.addSchemaMutation(column.name, mutation)
+      } else {
+        datasource.actions.addSubSchemaMutation(
+          related.subField,
+          related.field,
+          mutation
+        )
+      }
    })
-    datasource.actions.addSchemaMutations(mutations)
    await datasource.actions.saveSchemaMutations()
  }

@ -136,7 +150,7 @@ export const initialise = context => {
        .map(field => {
          const fieldSchema = $enrichedSchema[field]
          const oldColumn = $columns?.find(col => col.name === field)
-          let column = {
+          const column = {
            name: field,
            label: fieldSchema.displayName || field,
            schema: fieldSchema,
@ -145,6 +159,7 @@ export const initialise = context => {
            readonly: fieldSchema.readonly,
            order: fieldSchema.order ?? oldColumn?.order,
            conditions: fieldSchema.conditions,
+            related: fieldSchema.related,
          }
          // Override a few properties for primary display
          if (field === primaryDisplay) {
--- a/packages/frontend-core/src/components/grid/stores/datasource.js
+++ b/packages/frontend-core/src/components/grid/stores/datasource.js
@ -1,6 +1,6 @@
 import { derived, get } from "svelte/store"
 import { getDatasourceDefinition, getDatasourceSchema } from "../../../fetch"
-import { memo } from "../../../utils"
+import { enrichSchemaWithRelColumns, memo } from "../../../utils"

 export const createStores = () => {
  const definition = memo(null)
@ -53,10 +53,13 @@ export const deriveStores = context => {
      if (!$schema) {
        return null
      }
-      let enrichedSchema = {}
-      Object.keys($schema).forEach(field => {
+
+      const schemaWithRelatedColumns = enrichSchemaWithRelColumns($schema)
+
+      const enrichedSchema = {}
+      Object.keys(schemaWithRelatedColumns).forEach(field => {
        enrichedSchema[field] = {
-          ...$schema[field],
+          ...schemaWithRelatedColumns[field],
          ...$schemaOverrides?.[field],
          ...$schemaMutations[field],
        }
@ -202,24 +205,6 @@ export const createActions = context => {
    })
  }

-  // Adds schema mutations for multiple fields at once
-  const addSchemaMutations = mutations => {
-    const fields = Object.keys(mutations || {})
-    if (!fields.length) {
-      return
-    }
-    schemaMutations.update($schemaMutations => {
-      let newSchemaMutations = { ...$schemaMutations }
-      fields.forEach(field => {
-        newSchemaMutations[field] = {
-          ...newSchemaMutations[field],
-          ...mutations[field],
-        }
-      })
-      return newSchemaMutations
-    })
-  }
-
  // Saves schema changes to the server, if possible
  const saveSchemaMutations = async () => {
    // If we can't save schema changes then we just want to keep this in memory
@ -309,7 +294,6 @@ export const createActions = context => {
        changePrimaryDisplay,
        addSchemaMutation,
        addSubSchemaMutation,
-        addSchemaMutations,
        saveSchemaMutations,
        resetSchemaMutations,
      },
--- a/packages/frontend-core/src/components/grid/stores/datasources/viewV2.js
+++ b/packages/frontend-core/src/components/grid/stores/datasources/viewV2.js
@ -120,17 +120,22 @@ export const initialise = context => {
    // When sorting changes, ensure view definition is kept up to date
    unsubscribers.push(
      sort.subscribe(async $sort => {
-        // If we can mutate schema then update the view definition
-        if (get(config).canSaveSchema) {
        // Ensure we're updating the correct view
        const $view = get(definition)
        if ($view?.id !== $datasource.id) {
          return
        }
+
+        // Skip if nothing actually changed
        if (
-            $sort?.column !== $view.sort?.field ||
-            $sort?.order !== $view.sort?.order
+          $sort?.column === $view.sort?.field &&
+          $sort?.order === $view.sort?.order
        ) {
+          return
+        }
+
+        // If we can mutate schema then update the view definition
+        if (get(config).canSaveSchema) {
          await datasource.actions.saveDefinition({
            ...$view,
            sort: {
@ -139,7 +144,6 @@ export const initialise = context => {
            },
          })
        }
-        }

        // Also update the fetch to ensure the new sort is respected.
        // Ensure we're updating the correct fetch.
--- a/packages/frontend-core/src/components/grid/stores/reorder.js
+++ b/packages/frontend-core/src/components/grid/stores/reorder.js
@ -214,11 +214,20 @@ export const createActions = context => {
    })

    // Extract new orders as schema mutations
-    let mutations = {}
    get(columns).forEach((column, idx) => {
-      mutations[column.name] = { order: idx }
+      const { related } = column
+      const mutation = { order: idx }
+      if (!related) {
+        datasource.actions.addSchemaMutation(column.name, mutation)
+      } else {
+        datasource.actions.addSubSchemaMutation(
+          related.subField,
+          related.field,
+          mutation
+        )
+      }
    })
-    datasource.actions.addSchemaMutations(mutations)
+
    await datasource.actions.saveSchemaMutations()
  }

--- a/packages/frontend-core/src/components/grid/stores/resize.js
+++ b/packages/frontend-core/src/components/grid/stores/resize.js
@ -38,6 +38,7 @@ export const createActions = context => {
      initialWidth: column.width,
      initialMouseX: x,
      column: column.name,
+      related: column.related,
    })

    // Add mouse event listeners to handle resizing
@ -50,7 +51,7 @@ export const createActions = context => {

  // Handler for moving the mouse to resize columns
  const onResizeMouseMove = e => {
-    const { initialMouseX, initialWidth, width, column } = get(resize)
+    const { initialMouseX, initialWidth, width, column, related } = get(resize)
    const { x } = parseEventLocation(e)
    const dx = x - initialMouseX
    const newWidth = Math.round(Math.max(MinColumnWidth, initialWidth + dx))
@ -61,7 +62,13 @@ export const createActions = context => {
    }

    // Update column state
+    if (!related) {
      datasource.actions.addSchemaMutation(column, { width })
+    } else {
+      datasource.actions.addSubSchemaMutation(related.subField, related.field, {
+        width,
+      })
+    }

    // Update state
    resize.update(state => ({
--- a/packages/frontend-core/src/components/grid/stores/rows.js
+++ b/packages/frontend-core/src/components/grid/stores/rows.js
@ -6,6 +6,7 @@ import { tick } from "svelte"
 import { Helpers } from "@budibase/bbui"
 import { sleep } from "../../../utils/utils"
 import { FieldType } from "@budibase/types"
+import { getRelatedTableValues } from "../../../utils"

 export const createStores = () => {
  const rows = writable([])
@ -42,15 +43,26 @@ export const createStores = () => {
 }

 export const deriveStores = context => {
-  const { rows } = context
+  const { rows, enrichedSchema } = context

  // Enrich rows with an index property and any pending changes
-  const enrichedRows = derived(rows, $rows => {
+  const enrichedRows = derived(
+    [rows, enrichedSchema],
+    ([$rows, $enrichedSchema]) => {
+      const customColumns = Object.values($enrichedSchema || {}).filter(
+        f => f.related
+      )
      return $rows.map((row, idx) => ({
        ...row,
        __idx: idx,
+        ...customColumns.reduce((map, column) => {
+          const fromField = $enrichedSchema[column.related.field]
+          map[column.name] = getRelatedTableValues(row, column, fromField)
+          return map
+        }, {}),
      }))
-  })
+    }
+  )

  // Generate a lookup map to quick find a row by ID
  const rowLookupMap = derived(enrichedRows, $enrichedRows => {
--- a/packages/frontend-core/src/utils/index.js
+++ b/packages/frontend-core/src/utils/index.js
@ -10,3 +10,5 @@ export { createWebsocket } from "./websocket"
 export * from "./download"
 export * from "./theme"
 export * from "./settings"
+export * from "./relatedColumns"
+export * from "./table"
--- a/packages/frontend-core/src/utils/relatedColumns.js
+++ b/packages/frontend-core/src/utils/relatedColumns.js
@ -0,0 +1,107 @@
+import { FieldType, RelationshipType } from "@budibase/types"
+import { Helpers } from "@budibase/bbui"
+
+const columnTypeManyTypeOverrides = {
+  [FieldType.DATETIME]: FieldType.STRING,
+  [FieldType.BOOLEAN]: FieldType.STRING,
+  [FieldType.SIGNATURE_SINGLE]: FieldType.ATTACHMENTS,
+}
+
+const columnTypeManyParser = {
+  [FieldType.DATETIME]: (value, field) => {
+    function parseDate(value) {
+      const { timeOnly, dateOnly, ignoreTimezones } = field || {}
+      const enableTime = !dateOnly
+      const parsedValue = Helpers.parseDate(value, {
+        timeOnly,
+        enableTime,
+        ignoreTimezones,
+      })
+      const parsed = Helpers.getDateDisplayValue(parsedValue, {
+        enableTime,
+        timeOnly,
+      })
+      return parsed
+    }
+
+    return value?.map(v => parseDate(v))
+  },
+  [FieldType.BOOLEAN]: value => value?.map(v => !!v),
+  [FieldType.BB_REFERENCE_SINGLE]: value => [
+    ...new Map(value.map(i => [i._id, i])).values(),
+  ],
+  [FieldType.BB_REFERENCE]: value => [
+    ...new Map(value.map(i => [i._id, i])).values(),
+  ],
+  [FieldType.ARRAY]: value => Array.from(new Set(value)),
+}
+
+export function enrichSchemaWithRelColumns(schema) {
+  if (!schema) {
+    return
+  }
+  const result = Object.keys(schema).reduce((result, fieldName) => {
+    const field = schema[fieldName]
+    result[fieldName] = field
+
+    if (field.visible !== false && field.columns) {
+      const fromSingle =
+        field?.relationshipType === RelationshipType.ONE_TO_MANY
+
+      for (const relColumn of Object.keys(field.columns)) {
+        const relField = field.columns[relColumn]
+        if (!relField.visible) {
+          continue
+        }
+        const name = `${field.name}.${relColumn}`
+        result[name] = {
+          ...relField,
+          name,
+          related: { field: fieldName, subField: relColumn },
+          cellRenderType:
+            (!fromSingle && columnTypeManyTypeOverrides[relField.type]) ||
+            relField.type,
+        }
+      }
+    }
+    return result
+  }, {})
+
+  return result
+}
+
+export function getRelatedTableValues(row, field, fromField) {
+  const fromSingle =
+    fromField?.relationshipType === RelationshipType.ONE_TO_MANY
+
+  let result = ""
+
+  if (fromSingle) {
+    result = row[field.related.field]?.[0]?.[field.related.subField]
+  } else {
+    const parser = columnTypeManyParser[field.type] || (value => value)
+
+    result = parser(
+      row[field.related.field]
+        ?.flatMap(r => r[field.related.subField])
+        ?.filter(i => i !== undefined && i !== null),
+      field
+    )
+
+    if (
+      [
+        FieldType.STRING,
+        FieldType.NUMBER,
+        FieldType.BIGINT,
+        FieldType.BOOLEAN,
+        FieldType.DATETIME,
+        FieldType.LONGFORM,
+        FieldType.BARCODEQR,
+      ].includes(field.type)
+    ) {
+      result = result?.join(", ")
+    }
+  }
+
+  return result
+}
--- a/packages/frontend-core/src/utils/table.js
+++ b/packages/frontend-core/src/utils/table.js
@ -0,0 +1,27 @@
+import * as sharedCore from "@budibase/shared-core"
+
+export function canBeDisplayColumn(column) {
+  if (!sharedCore.canBeDisplayColumn(column.type)) {
+    return false
+  }
+
+  if (column.related) {
+    // If it's a related column (only available in the frontend), don't allow using it as display column
+    return false
+  }
+
+  return true
+}
+
+export function canBeSortColumn(column) {
+  if (!sharedCore.canBeSortColumn(column.type)) {
+    return false
+  }
+
+  if (column.related) {
+    // If it's a related column (only available in the frontend), don't allow using it as display column
+    return false
+  }
+
+  return true
+}
--- a/packages/server/src/api/routes/tests/row.spec.ts
+++ b/packages/server/src/api/routes/tests/row.spec.ts
@ -2684,7 +2684,7 @@ describe.each([
        async (__, retrieveDelegate) => {
          await withCoreEnv(
            {
-              TENANT_FEATURE_FLAGS: ``,
+              TENANT_FEATURE_FLAGS: `*:!${FeatureFlag.ENRICHED_RELATIONSHIPS}`,
            },
            async () => {
              const otherRows = _.sampleSize(auxData, 5)
--- a/packages/server/src/automations/tests/scenarios/branching.spec.ts
+++ b/packages/server/src/automations/tests/scenarios/branching.spec.ts
@ -32,25 +32,25 @@ describe("Branching automations", () => {
                steps: stepBuilder =>
                  stepBuilder.serverLog({ text: "Branch 1.1" }),
                condition: {
-                  equal: { "steps.1.success": true },
+                  equal: { "{{steps.1.success}}": true },
                },
              },
              branch2: {
                steps: stepBuilder =>
                  stepBuilder.serverLog({ text: "Branch 1.2" }),
                condition: {
-                  equal: { "steps.1.success": false },
+                  equal: { "{{steps.1.success}}": false },
                },
              },
            }),
          condition: {
-            equal: { "steps.1.success": true },
+            equal: { "{{steps.1.success}}": true },
          },
        },
        topLevelBranch2: {
          steps: stepBuilder => stepBuilder.serverLog({ text: "Branch 2" }),
          condition: {
-            equal: { "steps.1.success": false },
+            equal: { "{{steps.1.success}}": false },
          },
        },
      })
@ -70,14 +70,14 @@ describe("Branching automations", () => {
        activeBranch: {
          steps: stepBuilder => stepBuilder.serverLog({ text: "Active user" }),
          condition: {
-            equal: { "trigger.fields.status": "active" },
+            equal: { "{{trigger.fields.status}}": "active" },
          },
        },
        inactiveBranch: {
          steps: stepBuilder =>
            stepBuilder.serverLog({ text: "Inactive user" }),
          condition: {
-            equal: { "trigger.fields.status": "inactive" },
+            equal: { "{{trigger.fields.status}}": "inactive" },
          },
        },
      })
@ -102,8 +102,8 @@ describe("Branching automations", () => {
          condition: {
            $and: {
              conditions: [
-                { equal: { "trigger.fields.status": "active" } },
-                { equal: { "trigger.fields.role": "admin" } },
+                { equal: { "{{trigger.fields.status}}": "active" } },
+                { equal: { "{{trigger.fields.role}}": "admin" } },
              ],
            },
          },
@ -111,7 +111,7 @@ describe("Branching automations", () => {
        otherBranch: {
          steps: stepBuilder => stepBuilder.serverLog({ text: "Other user" }),
          condition: {
-            notEqual: { "trigger.fields.status": "active" },
+            notEqual: { "{{trigger.fields.status}}": "active" },
          },
        },
      })
@ -133,8 +133,8 @@ describe("Branching automations", () => {
          condition: {
            $or: {
              conditions: [
-                { equal: { "trigger.fields.status": "test" } },
-                { equal: { "trigger.fields.role": "admin" } },
+                { equal: { "{{trigger.fields.status}}": "test" } },
+                { equal: { "{{trigger.fields.role}}": "admin" } },
              ],
            },
          },
@ -144,8 +144,8 @@ describe("Branching automations", () => {
          condition: {
            $and: {
              conditions: [
-                { notEqual: { "trigger.fields.status": "active" } },
-                { notEqual: { "trigger.fields.role": "admin" } },
+                { notEqual: { "{{trigger.fields.status}}": "active" } },
+                { notEqual: { "{{trigger.fields.role}}": "admin" } },
              ],
            },
          },
@ -170,8 +170,8 @@ describe("Branching automations", () => {
          condition: {
            $or: {
              conditions: [
-                { equal: { "trigger.fields.status": "new" } },
-                { equal: { "trigger.fields.role": "admin" } },
+                { equal: { "{{trigger.fields.status}}": "new" } },
+                { equal: { "{{trigger.fields.role}}": "admin" } },
              ],
            },
          },
@ -181,8 +181,8 @@ describe("Branching automations", () => {
          condition: {
            $and: {
              conditions: [
-                { equal: { "trigger.fields.status": "active" } },
-                { equal: { "trigger.fields.role": "admin" } },
+                { equal: { "{{trigger.fields.status}}": "active" } },
+                { equal: { "{{trigger.fields.role}}": "admin" } },
              ],
            },
          },
--- a/packages/server/src/automations/tests/scenarios/looping.spec.ts
+++ b/packages/server/src/automations/tests/scenarios/looping.spec.ts
@ -5,6 +5,7 @@ import {
  LoopStepType,
  CreateRowStepOutputs,
  ServerLogStepOutputs,
+  FieldType,
 } from "@budibase/types"
 import { createAutomationBuilder } from "../utilities/AutomationTestBuilder"

@ -269,4 +270,145 @@ describe("Loop automations", () => {

    expect(results.steps[1].outputs.message).toContain("- 3")
  })
+
+  it("should run an automation with a loop and update row step", async () => {
+    const table = await config.createTable({
+      name: "TestTable",
+      type: "table",
+      schema: {
+        name: {
+          name: "name",
+          type: FieldType.STRING,
+          constraints: {
+            presence: true,
+          },
+        },
+        value: {
+          name: "value",
+          type: FieldType.NUMBER,
+          constraints: {
+            presence: true,
+          },
+        },
+      },
+    })
+
+    const rows = [
+      { name: "Row 1", value: 1, tableId: table._id },
+      { name: "Row 2", value: 2, tableId: table._id },
+      { name: "Row 3", value: 3, tableId: table._id },
+    ]
+
+    await config.api.row.bulkImport(table._id!, { rows })
+
+    const builder = createAutomationBuilder({
+      name: "Test Loop and Update Row",
+    })
+
+    const results = await builder
+      .appAction({ fields: {} })
+      .queryRows({
+        tableId: table._id!,
+      })
+      .loop({
+        option: LoopStepType.ARRAY,
+        binding: "{{ steps.1.rows }}",
+      })
+      .updateRow({
+        rowId: "{{ loop.currentItem._id }}",
+        row: {
+          name: "Updated {{ loop.currentItem.name }}",
+          value: "{{ loop.currentItem.value }}",
+          tableId: table._id,
+        },
+        meta: {},
+      })
+      .queryRows({
+        tableId: table._id!,
+      })
+      .run()
+
+    const expectedRows = [
+      { name: "Updated Row 1", value: 1 },
+      { name: "Updated Row 2", value: 2 },
+      { name: "Updated Row 3", value: 3 },
+    ]
+
+    expect(results.steps[1].outputs.items).toEqual(
+      expect.arrayContaining(
+        expectedRows.map(row =>
+          expect.objectContaining({
+            success: true,
+            row: expect.objectContaining(row),
+          })
+        )
+      )
+    )
+
+    expect(results.steps[2].outputs.rows).toEqual(
+      expect.arrayContaining(
+        expectedRows.map(row => expect.objectContaining(row))
+      )
+    )
+
+    expect(results.steps[1].outputs.items).toHaveLength(expectedRows.length)
+    expect(results.steps[2].outputs.rows).toHaveLength(expectedRows.length)
+  })
+
+  it("should run an automation with a loop and delete row step", async () => {
+    const table = await config.createTable({
+      name: "TestTable",
+      type: "table",
+      schema: {
+        name: {
+          name: "name",
+          type: FieldType.STRING,
+          constraints: {
+            presence: true,
+          },
+        },
+        value: {
+          name: "value",
+          type: FieldType.NUMBER,
+          constraints: {
+            presence: true,
+          },
+        },
+      },
+    })
+
+    const rows = [
+      { name: "Row 1", value: 1, tableId: table._id },
+      { name: "Row 2", value: 2, tableId: table._id },
+      { name: "Row 3", value: 3, tableId: table._id },
+    ]
+
+    await config.api.row.bulkImport(table._id!, { rows })
+
+    const builder = createAutomationBuilder({
+      name: "Test Loop and Delete Row",
+    })
+
+    const results = await builder
+      .appAction({ fields: {} })
+      .queryRows({
+        tableId: table._id!,
+      })
+      .loop({
+        option: LoopStepType.ARRAY,
+        binding: "{{ steps.1.rows }}",
+      })
+      .deleteRow({
+        tableId: table._id!,
+        id: "{{ loop.currentItem._id }}",
+      })
+      .queryRows({
+        tableId: table._id!,
+      })
+      .run()
+
+    expect(results.steps).toHaveLength(3)
+
+    expect(results.steps[2].outputs.rows).toHaveLength(0)
+  })
 })
--- a/packages/server/src/automations/tests/scenarios/scenarios.spec.ts
+++ b/packages/server/src/automations/tests/scenarios/scenarios.spec.ts
@ -1,8 +1,9 @@
 import * as automation from "../../index"
 import * as setup from "../utilities"
-import { LoopStepType, FieldType } from "@budibase/types"
+import { LoopStepType, FieldType, Table } from "@budibase/types"
 import { createAutomationBuilder } from "../utilities/AutomationTestBuilder"
 import { DatabaseName } from "../../../integrations/tests/utils"
+import { FilterConditions } from "../../../automations/steps/filter"

 describe("Automation Scenarios", () => {
  let config = setup.getConfig()
@ -195,6 +196,91 @@ describe("Automation Scenarios", () => {
        )
      })
    })
+
+    it("should trigger an automation which creates and then updates a row", async () => {
+      const table = await config.createTable({
+        name: "TestTable",
+        type: "table",
+        schema: {
+          name: {
+            name: "name",
+            type: FieldType.STRING,
+            constraints: {
+              presence: true,
+            },
+          },
+          value: {
+            name: "value",
+            type: FieldType.NUMBER,
+            constraints: {
+              presence: true,
+            },
+          },
+        },
+      })
+
+      const builder = createAutomationBuilder({
+        name: "Test Create and Update Row",
+      })
+
+      const results = await builder
+        .appAction({ fields: {} })
+        .createRow(
+          {
+            row: {
+              name: "Initial Row",
+              value: 1,
+              tableId: table._id,
+            },
+          },
+          { stepName: "CreateRowStep" }
+        )
+        .updateRow(
+          {
+            rowId: "{{ steps.CreateRowStep.row._id }}",
+            row: {
+              name: "Updated Row",
+              value: 2,
+              tableId: table._id,
+            },
+            meta: {},
+          },
+          { stepName: "UpdateRowStep" }
+        )
+        .queryRows(
+          {
+            tableId: table._id!,
+          },
+          { stepName: "QueryRowsStep" }
+        )
+        .run()
+
+      expect(results.steps).toHaveLength(3)
+
+      expect(results.steps[0].outputs).toMatchObject({
+        success: true,
+        row: {
+          name: "Initial Row",
+          value: 1,
+        },
+      })
+
+      expect(results.steps[1].outputs).toMatchObject({
+        success: true,
+        row: {
+          name: "Updated Row",
+          value: 2,
+        },
+      })
+
+      const expectedRows = [{ name: "Updated Row", value: 2 }]
+
+      expect(results.steps[2].outputs.rows).toEqual(
+        expect.arrayContaining(
+          expectedRows.map(row => expect.objectContaining(row))
+        )
+      )
+    })
  })

  describe("Name Based Automations", () => {
@ -233,4 +319,167 @@ describe("Automation Scenarios", () => {
      expect(results.steps[2].outputs.rows).toHaveLength(1)
    })
  })
+  describe("Automations with filter", () => {
+    let table: Table
+
+    beforeEach(async () => {
+      table = await config.createTable({
+        name: "TestTable",
+        type: "table",
+        schema: {
+          name: {
+            name: "name",
+            type: FieldType.STRING,
+            constraints: {
+              presence: true,
+            },
+          },
+          value: {
+            name: "value",
+            type: FieldType.NUMBER,
+            constraints: {
+              presence: true,
+            },
+          },
+        },
+      })
+    })
+
+    it("should stop an automation if the condition is not met", async () => {
+      const builder = createAutomationBuilder({
+        name: "Test Equal",
+      })
+
+      const results = await builder
+        .appAction({ fields: {} })
+        .createRow({
+          row: {
+            name: "Equal Test",
+            value: 10,
+            tableId: table._id,
+          },
+        })
+        .queryRows({
+          tableId: table._id!,
+        })
+        .filter({
+          field: "{{ steps.2.rows.0.value }}",
+          condition: FilterConditions.EQUAL,
+          value: 20,
+        })
+        .serverLog({ text: "Equal condition met" })
+        .run()
+
+      expect(results.steps[2].outputs.success).toBeTrue()
+      expect(results.steps[2].outputs.result).toBeFalse()
+      expect(results.steps[3]).toBeUndefined()
+    })
+
+    it("should continue the automation if the condition is met", async () => {
+      const builder = createAutomationBuilder({
+        name: "Test Not Equal",
+      })
+
+      const results = await builder
+        .appAction({ fields: {} })
+        .createRow({
+          row: {
+            name: "Not Equal Test",
+            value: 10,
+            tableId: table._id,
+          },
+        })
+        .queryRows({
+          tableId: table._id!,
+        })
+        .filter({
+          field: "{{ steps.2.rows.0.value }}",
+          condition: FilterConditions.NOT_EQUAL,
+          value: 20,
+        })
+        .serverLog({ text: "Not Equal condition met" })
+        .run()
+
+      expect(results.steps[2].outputs.success).toBeTrue()
+      expect(results.steps[2].outputs.result).toBeTrue()
+      expect(results.steps[3].outputs.success).toBeTrue()
+    })
+
+    const testCases = [
+      {
+        condition: FilterConditions.EQUAL,
+        value: 10,
+        rowValue: 10,
+        expectPass: true,
+      },
+      {
+        condition: FilterConditions.NOT_EQUAL,
+        value: 10,
+        rowValue: 20,
+        expectPass: true,
+      },
+      {
+        condition: FilterConditions.GREATER_THAN,
+        value: 10,
+        rowValue: 15,
+        expectPass: true,
+      },
+      {
+        condition: FilterConditions.LESS_THAN,
+        value: 10,
+        rowValue: 5,
+        expectPass: true,
+      },
+      {
+        condition: FilterConditions.GREATER_THAN,
+        value: 10,
+        rowValue: 5,
+        expectPass: false,
+      },
+      {
+        condition: FilterConditions.LESS_THAN,
+        value: 10,
+        rowValue: 15,
+        expectPass: false,
+      },
+    ]
+
+    it.each(testCases)(
+      "should pass the filter when condition is $condition",
+      async ({ condition, value, rowValue, expectPass }) => {
+        const builder = createAutomationBuilder({
+          name: `Test ${condition}`,
+        })
+
+        const results = await builder
+          .appAction({ fields: {} })
+          .createRow({
+            row: {
+              name: `${condition} Test`,
+              value: rowValue,
+              tableId: table._id,
+            },
+          })
+          .queryRows({
+            tableId: table._id!,
+          })
+          .filter({
+            field: "{{ steps.2.rows.0.value }}",
+            condition,
+            value,
+          })
+          .serverLog({
+            text: `${condition} condition ${expectPass ? "passed" : "failed"}`,
+          })
+          .run()
+
+        expect(results.steps[2].outputs.result).toBe(expectPass)
+        if (expectPass) {
+          expect(results.steps[3].outputs.success).toBeTrue()
+        } else {
+          expect(results.steps[3]).toBeUndefined()
+        }
+      }
+    )
+  })
 })
--- a/packages/server/src/automations/tests/utilities/AutomationTestBuilder.ts
+++ b/packages/server/src/automations/tests/utilities/AutomationTestBuilder.ts
@ -33,6 +33,7 @@ import {
  BranchStepInputs,
  SearchFilters,
  Branch,
+  FilterStepInputs,
 } from "@budibase/types"
 import TestConfiguration from "../../../tests/utilities/TestConfiguration"
 import * as setup from "../utilities"
@ -181,6 +182,14 @@ class BaseStepBuilder {
      opts?.stepName
    )
  }
+
+  filter(input: FilterStepInputs): this {
+    return this.step(
+      AutomationActionStepId.FILTER,
+      BUILTIN_ACTION_DEFINITIONS.FILTER,
+      input
+    )
+  }
 }
 class StepBuilder extends BaseStepBuilder {
  build(): AutomationStep[] {
--- a/packages/server/src/db/linkedRows/index.ts
+++ b/packages/server/src/db/linkedRows/index.ts
@ -10,7 +10,10 @@ import flatten from "lodash/flatten"
 import { USER_METDATA_PREFIX } from "../utils"
 import partition from "lodash/partition"
 import { getGlobalUsersFromMetadata } from "../../utilities/global"
-import { outputProcessing, processFormulas } from "../../utilities/rowProcessor"
+import {
+  coreOutputProcessing,
+  processFormulas,
+} from "../../utilities/rowProcessor"
 import { context, features } from "@budibase/backend-core"
 import {
  ContextUser,
@ -156,9 +159,6 @@ export async function updateLinks(args: {
 /**
 * Given a table and a list of rows this will retrieve all of the attached docs and enrich them into the row.
 * This is required for formula fields, this may only be utilised internally (for now).
- * @param table The table from which the rows originated.
- * @param rows The rows which are to be enriched.
- * @param opts optional - options like passing in a base row to use for enrichment.
 * @return returns the rows with all of the enriched relationships on it.
 */
 export async function attachFullLinkedDocs(
@ -248,9 +248,6 @@ export type SquashTableFields = Record<string, { visibleFieldNames: string[] }>

 /**
 * This function will take the given enriched rows and squash the links to only contain the primary display field.
- * @param table The table from which the rows originated.
- * @param enriched The pre-enriched rows (full docs) which are to be squashed.
- * @param squashFields Per link column (key) define which columns are allowed while squashing.
 * @returns The rows after having their links squashed to only contain the ID and primary display.
 */
 export async function squashLinks<T = Row[] | Row>(
@ -283,21 +280,18 @@ export async function squashLinks<T = Row[] | Row>(
      if (schema.type !== FieldType.LINK || !Array.isArray(row[column])) {
        continue
      }
-      const newLinks = []
-      for (const link of row[column]) {
-        const linkTblId =
-          link.tableId || getRelatedTableForField(table.schema, column)
-        const linkedTable = await getLinkedTable(linkTblId!, linkedTables)
+      const relatedTable = await getLinkedTable(schema.tableId, linkedTables)
+      if (viewSchema[column]?.columns) {
+        row[column] = await coreOutputProcessing(relatedTable, row[column])
+      }
+      row[column] = row[column].map((link: Row) => {
        const obj: any = { _id: link._id }
-        obj.primaryDisplay = getPrimaryDisplayValue(link, linkedTable)
+        obj.primaryDisplay = getPrimaryDisplayValue(link, relatedTable)

        if (viewSchema[column]?.columns) {
-          const enrichedLink = await outputProcessing(linkedTable, link, {
-            squash: false,
-          })
-          const squashFields = Object.entries(viewSchema[column].columns)
+          const squashFields = Object.entries(viewSchema[column].columns || {})
            .filter(([columnName, viewColumnConfig]) => {
-              const tableColumn = linkedTable.schema[columnName]
+              const tableColumn = relatedTable.schema[columnName]
              if (!tableColumn) {
                return false
              }
@ -315,13 +309,14 @@ export async function squashLinks<T = Row[] | Row>(
            .map(([columnName]) => columnName)

          for (const relField of squashFields) {
-            obj[relField] = enrichedLink[relField]
+            if (link[relField] != null) {
+              obj[relField] = link[relField]
+            }
          }
        }

-        newLinks.push(obj)
-      }
-      row[column] = newLinks
+        return obj
+      })
    }
  }
  return (isArray ? enrichedArray : enrichedArray[0]) as T
--- a/packages/server/src/threads/automation.ts
+++ b/packages/server/src/threads/automation.ts
@ -516,10 +516,8 @@ class Orchestrator {
      filter => {
        Object.entries(filter).forEach(([_, value]) => {
          Object.entries(value).forEach(([field, _]) => {
-            const fromContext = processStringSync(
-              `{{ literal ${field} }}`,
-              this.context
-            )
+            const updatedField = field.replace("{{", "{{ literal ")
+            const fromContext = processStringSync(updatedField, this.context)
            toFilter[field] = fromContext
          })
        })
--- a/packages/server/src/utilities/rowProcessor/index.ts
+++ b/packages/server/src/utilities/rowProcessor/index.ts
@ -264,6 +264,7 @@ export async function outputProcessing<T extends Row[] | Row>(
  } else {
    safeRows = rows
  }
+  // SQS returns the rows with full relationship contents
  // attach any linked row information
  let enriched = !opts.preserveLinks
    ? await linkRows.attachFullLinkedDocs(table.schema, safeRows, {
@ -271,11 +272,39 @@ export async function outputProcessing<T extends Row[] | Row>(
      })
    : safeRows

-  // make sure squash is enabled if needed
  if (!opts.squash && utils.hasCircularStructure(rows)) {
    opts.squash = true
  }

+  enriched = await coreOutputProcessing(table, enriched, opts)
+
+  if (opts.squash) {
+    enriched = await linkRows.squashLinks(table, enriched, {
+      fromViewId: opts?.fromViewId,
+    })
+  }
+
+  return (wasArray ? enriched : enriched[0]) as T
+}
+
+/**
+ * This function is similar to the outputProcessing function above, it makes sure that all the provided
+ * rows are ready for output, but does not have enrichment for squash capabilities which can cause performance issues.
+ * outputProcessing should be used when responding from the API, while this should be used when internally processing
+ * rows for any reason (like part of view operations).
+ */
+export async function coreOutputProcessing(
+  table: Table,
+  rows: Row[],
+  opts: {
+    preserveLinks?: boolean
+    skipBBReferences?: boolean
+    fromViewId?: string
+  } = {
+    preserveLinks: false,
+    skipBBReferences: false,
+  }
+): Promise<Row[]> {
  // process complex types: attachments, bb references...
  for (const [property, column] of Object.entries(table.schema)) {
    if (
@ -283,7 +312,7 @@ export async function outputProcessing<T extends Row[] | Row>(
      column.type === FieldType.ATTACHMENT_SINGLE ||
      column.type === FieldType.SIGNATURE_SINGLE
    ) {
-      for (const row of enriched) {
+      for (const row of rows) {
        if (row[property] == null) {
          continue
        }
@ -308,7 +337,7 @@ export async function outputProcessing<T extends Row[] | Row>(
      !opts.skipBBReferences &&
      column.type == FieldType.BB_REFERENCE
    ) {
-      for (const row of enriched) {
+      for (const row of rows) {
        row[property] = await processOutputBBReferences(
          row[property],
          column.subtype
@ -318,14 +347,14 @@ export async function outputProcessing<T extends Row[] | Row>(
      !opts.skipBBReferences &&
      column.type == FieldType.BB_REFERENCE_SINGLE
    ) {
-      for (const row of enriched) {
+      for (const row of rows) {
        row[property] = await processOutputBBReference(
          row[property],
          column.subtype
        )
      }
    } else if (column.type === FieldType.DATETIME && column.timeOnly) {
-      for (const row of enriched) {
+      for (const row of rows) {
        if (row[property] instanceof Date) {
          const hours = row[property].getUTCHours().toString().padStart(2, "0")
          const minutes = row[property]
@ -340,7 +369,7 @@ export async function outputProcessing<T extends Row[] | Row>(
        }
      }
    } else if (column.type === FieldType.LINK) {
-      for (let row of enriched) {
+      for (let row of rows) {
        // if relationship is empty - remove the array, this has been part of the API for some time
        if (Array.isArray(row[property]) && row[property].length === 0) {
          delete row[property]
@ -350,17 +379,12 @@ export async function outputProcessing<T extends Row[] | Row>(
  }

  // process formulas after the complex types had been processed
-  enriched = await processFormulas(table, enriched, { dynamic: true })
+  rows = await processFormulas(table, rows, { dynamic: true })

-  if (opts.squash) {
-    enriched = await linkRows.squashLinks(table, enriched, {
-      fromViewId: opts?.fromViewId,
-    })
-  }
  // remove null properties to match internal API
  const isExternal = isExternalTableID(table._id!)
  if (isExternal || (await features.flags.isEnabled("SQS"))) {
-    for (const row of enriched) {
+    for (const row of rows) {
      for (const key of Object.keys(row)) {
        if (row[key] === null) {
          delete row[key]
@ -388,7 +412,7 @@ export async function outputProcessing<T extends Row[] | Row>(
    const fields = [...tableFields, ...protectedColumns].map(f =>
      f.toLowerCase()
    )
-    for (const row of enriched) {
+    for (const row of rows) {
      for (const key of Object.keys(row)) {
        if (!fields.includes(key.toLowerCase())) {
          delete row[key]
@ -397,5 +421,5 @@ export async function outputProcessing<T extends Row[] | Row>(
    }
  }

-  return (wasArray ? enriched : enriched[0]) as T
+  return rows
 }