Merge remote-tracking branch 'origin/feature/automation-branching-ux' into automation-branching-ux-updates

2024-10-31 16:39:43 +00:00 · 2024-10-31 16:39:43 +00:00 · 50beda83ed
parent 9674b7aaa0 472830c052
commit 50beda83ed
25 changed files with 384 additions and 112 deletions
--- a/packages/backend-core/src/sql/sql.ts
+++ b/packages/backend-core/src/sql/sql.ts
@ -1091,7 +1091,14 @@ class InternalBuilder {
            )
          }
        } else {
-          query = query.count(`* as ${aggregation.name}`)
+          if (this.client === SqlClient.ORACLE) {
+            const field = this.convertClobs(`${tableName}.${aggregation.field}`)
+            query = query.select(
+              this.knex.raw(`COUNT(??) as ??`, [field, aggregation.name])
+            )
+          } else {
+            query = query.count(`${aggregation.field} as ${aggregation.name}`)
+          }
        }
      } else {
        const fieldSchema = this.getFieldSchema(aggregation.field)
--- a/packages/builder/src/components/automation/AutomationBuilder/DraggableCanvas.svelte
+++ b/packages/builder/src/components/automation/AutomationBuilder/DraggableCanvas.svelte
@ -286,6 +286,10 @@

  // Optimization options
  const onViewMouseMove = async e => {
+    if (!viewPort) {
+      return
+    }
+
    const { x, y } = eleXY(e, viewPort)

    internalPos.update(() => ({
@ -427,6 +431,9 @@
  }

  const onMouseMove = async e => {
+    if (!viewPort) {
+      return
+    }
    // Update viewDims to get the latest viewport dimensions
    viewDims = viewPort.getBoundingClientRect()

@ -484,7 +491,7 @@
  }

  const onMoveContent = e => {
-    if (down) {
+    if (down || !viewPort) {
      return
    }
    const { x, y } = eleXY(e, viewPort)
--- a/packages/builder/src/components/automation/AutomationBuilder/FlowChart/BranchNode.svelte
+++ b/packages/builder/src/components/automation/AutomationBuilder/FlowChart/BranchNode.svelte
@ -11,6 +11,8 @@
    TooltipPosition,
    TooltipType,
    Button,
+    Modal,
+    ModalContent,
  } from "@budibase/bbui"
  import PropField from "components/automation/SetupPanel/PropField.svelte"
  import AutomationBindingPanel from "components/common/bindings/ServerBindingPanel.svelte"
@ -36,6 +38,7 @@
  let drawer
  let condition
  let open = true
+  let confirmDeleteModal

  $: branch = step.inputs?.branches?.[branchIdx]
  $: editableConditionUI = cloneDeep(branch.conditionUI || {})
@ -55,6 +58,22 @@
  }
 </script>

+<Modal bind:this={confirmDeleteModal}>
+  <ModalContent
+    size="M"
+    title={"Are you sure you want to delete?"}
+    confirmText="Delete"
+    onConfirm={async () => {
+      await automationStore.actions.deleteBranch(
+        branchBlockRef.pathTo,
+        $selectedAutomation.data
+      )
+    }}
+  >
+    <Body>By deleting this branch, you will delete all of its contents.</Body>
+  </ModalContent>
+</Modal>
+
 <Drawer bind:this={drawer} title="Branch condition" forceModal>
  <Button
    cta
@ -101,10 +120,15 @@
      itemName={branch.name}
      block={step}
      deleteStep={async () => {
-        await automationStore.actions.deleteBranch(
-          branchBlockRef.pathTo,
-          $selectedAutomation.data
-        )
+        const branchSteps = step.inputs?.children[branch.id]
+        if (branchSteps.length) {
+          confirmDeleteModal.show()
+        } else {
+          await automationStore.actions.deleteBranch(
+            branchBlockRef.pathTo,
+            $selectedAutomation.data
+          )
+        }
      }}
      on:update={async e => {
        let stepUpdate = cloneDeep(step)
--- a/packages/builder/src/components/automation/AutomationBuilder/FlowChart/FlowItem.svelte
+++ b/packages/builder/src/components/automation/AutomationBuilder/FlowChart/FlowItem.svelte
@ -13,7 +13,6 @@
    Modal,
    Label,
    AbsTooltip,
-    InlineAlert,
  } from "@budibase/bbui"
  import { sdk } from "@budibase/shared-core"
  import AutomationBlockSetup from "../../SetupPanel/AutomationBlockSetup.svelte"
@ -26,6 +25,7 @@
  import DragHandle from "components/design/settings/controls/DraggableList/drag-handle.svelte"
  import { getContext } from "svelte"
  import DragZone from "./DragZone.svelte"
+  import InfoDisplay from "pages/builder/app/[application]/design/[screenId]/[componentId]/_components/Component/InfoDisplay.svelte"

  export let block
  export let blockRef
@ -335,9 +335,10 @@
                  {bindings}
                />
                {#if isTrigger && triggerInfo}
-                  <InlineAlert
-                    header={triggerInfo.title}
-                    message={`This trigger is tied to your "${triggerInfo.tableName}" table`}
+                  <InfoDisplay
+                    title={triggerInfo.title}
+                    body="This trigger is tied to your '{triggerInfo.tableName}' table"
+                    icon="InfoOutline"
                  />
                {/if}
              </Layout>
--- a/packages/builder/src/components/automation/SetupPanel/CronBuilder.svelte
+++ b/packages/builder/src/components/automation/SetupPanel/CronBuilder.svelte
@ -9,7 +9,7 @@
  } from "@budibase/bbui"
  import { onMount, createEventDispatcher } from "svelte"
  import { flags } from "stores/builder"
-  import { licensing } from "stores/portal"
+  import { featureFlags } from "stores/portal"
  import { API } from "api"
  import MagicWand from "../../../../assets/MagicWand.svelte"

@ -26,8 +26,7 @@
  let aiCronPrompt = ""
  let loadingAICronExpression = false

-  $: aiEnabled =
-    $licensing.customAIConfigsEnabled || $licensing.budibaseAIEnabled
+  $: aiEnabled = $featureFlags.AI_CUSTOM_CONFIGS || $featureFlags.BUDIBASE_AI
  $: {
    if (cronExpression) {
      try {
--- a/packages/builder/src/components/backend/DataTable/formula.js
+++ b/packages/builder/src/components/backend/DataTable/formula.js
@ -8,6 +8,7 @@ const MAX_DEPTH = 1

 const TYPES_TO_SKIP = [
  FieldType.FORMULA,
+  FieldType.AI,
  FieldType.LONGFORM,
  FieldType.SIGNATURE_SINGLE,
  FieldType.ATTACHMENTS,
--- a/packages/builder/src/components/backend/DataTable/modals/CreateEditColumn.svelte
+++ b/packages/builder/src/components/backend/DataTable/modals/CreateEditColumn.svelte
@ -26,7 +26,7 @@
  import { createEventDispatcher, getContext, onMount } from "svelte"
  import { cloneDeep } from "lodash/fp"
  import { tables, datasources } from "stores/builder"
-  import { licensing } from "stores/portal"
+  import { featureFlags } from "stores/portal"
  import { TableNames, UNEDITABLE_USER_FIELDS } from "constants"
  import {
    FIELDS,
@ -101,8 +101,7 @@
  let optionsValid = true

  $: rowGoldenSample = RowUtils.generateGoldenSample($rows)
-  $: aiEnabled =
-    $licensing.customAIConfigsEnabled || $licensing.budibaseAIEnabled
+  $: aiEnabled = $featureFlags.BUDIBASE_AI || $featureFlags.AI_CUSTOM_CONFIGS
  $: if (primaryDisplay) {
    editableColumn.constraints.presence = { allowEmpty: false }
  }
--- a/packages/builder/src/components/design/settings/controls/Explanation/lines/Column.svelte
+++ b/packages/builder/src/components/design/settings/controls/Explanation/lines/Column.svelte
@ -80,6 +80,9 @@
    if (columnType === FieldType.FORMULA) {
      return "https://docs.budibase.com/docs/formula"
    }
+    if (columnType === FieldType.AI) {
+      return "https://docs.budibase.com/docs/ai"
+    }
    if (columnType === FieldType.OPTIONS) {
      return "https://docs.budibase.com/docs/options"
    }
--- a/packages/builder/src/pages/builder/app/[application]/data/table/[tableId]/[viewId]/index.svelte
+++ b/packages/builder/src/pages/builder/app/[application]/data/table/[tableId]/[viewId]/index.svelte
@ -1,6 +1,6 @@
 <script>
  import { viewsV2, rowActions } from "stores/builder"
-  import { admin, themeStore, licensing } from "stores/portal"
+  import { admin, themeStore, featureFlags } from "stores/portal"
  import { Grid } from "@budibase/frontend-core"
  import { API } from "api"
  import { notifications } from "@budibase/bbui"
@ -53,7 +53,7 @@
  {buttons}
  allowAddRows
  allowDeleteRows
-  aiEnabled={$licensing.budibaseAIEnabled || $licensing.customAIConfigsEnabled}
+  aiEnabled={$featureFlags.BUDIBASE_AI || $featureFlags.AI_CUSTOM_CONFIGS}
  showAvatars={false}
  on:updatedatasource={handleGridViewUpdate}
  isCloud={$admin.cloud}
--- a/packages/builder/src/pages/builder/app/[application]/data/table/[tableId]/index.svelte
+++ b/packages/builder/src/pages/builder/app/[application]/data/table/[tableId]/index.svelte
@ -8,7 +8,7 @@
    rowActions,
    roles,
  } from "stores/builder"
-  import { themeStore, admin, licensing } from "stores/portal"
+  import { themeStore, admin, featureFlags } from "stores/portal"
  import { TableNames } from "constants"
  import { Grid } from "@budibase/frontend-core"
  import { API } from "api"
@ -130,8 +130,7 @@
    schemaOverrides={isUsersTable ? userSchemaOverrides : null}
    showAvatars={false}
    isCloud={$admin.cloud}
-    aiEnabled={$licensing.budibaseAIEnabled ||
-      $licensing.customAIConfigsEnabled}
+    aiEnabled={$featureFlags.BUDIBASE_AI || $featureFlags.AI_CUSTOM_CONFIGS}
    {buttons}
    buttonsCollapsed
    on:updatedatasource={handleGridTableUpdate}
--- a/packages/builder/src/stores/portal/featureFlags.js
+++ b/packages/builder/src/stores/portal/featureFlags.js
@ -4,6 +4,8 @@ import { auth } from "stores/portal"
 export const INITIAL_FEATUREFLAG_STATE = {
  SQS: false,
  DEFAULT_VALUES: false,
+  BUDIBASE_AI: false,
+  AI_CUSTOM_CONFIGS: false,
 }

 export const featureFlags = derived([auth], ([$auth]) => {
--- a/packages/server/src/api/controllers/table/tests/utils.spec.ts
+++ b/packages/server/src/api/controllers/table/tests/utils.spec.ts
@ -1,4 +1,4 @@
-import { AutoFieldSubType, FieldType } from "@budibase/types"
+import { AIOperationEnum, AutoFieldSubType, FieldType } from "@budibase/types"
 import TestConfiguration from "../../../../tests/utilities/TestConfiguration"
 import { importToRows } from "../utils"

@ -92,5 +92,65 @@ describe("utils", () => {
        expect(result).toHaveLength(3)
      })
    })
+
+    it("Imports write as expected with AI columns", async () => {
+      await config.doInContext(config.appId, async () => {
+        const table = await config.createTable({
+          name: "table",
+          type: "table",
+          schema: {
+            autoId: {
+              name: "autoId",
+              type: FieldType.NUMBER,
+              subtype: AutoFieldSubType.AUTO_ID,
+              autocolumn: true,
+              constraints: {
+                type: FieldType.NUMBER,
+                presence: true,
+              },
+            },
+            name: {
+              name: "name",
+              type: FieldType.STRING,
+              constraints: {
+                type: FieldType.STRING,
+                presence: true,
+              },
+            },
+            aicol: {
+              name: "aicol",
+              type: FieldType.AI,
+              operation: AIOperationEnum.PROMPT,
+              prompt: "Test prompt",
+            },
+          },
+        })
+
+        const data = [
+          { name: "Alice", aicol: "test" },
+          { name: "Bob", aicol: "test" },
+          { name: "Claire", aicol: "test" },
+        ]
+
+        const result = await importToRows(data, table, config.user?._id)
+        expect(result).toEqual([
+          expect.objectContaining({
+            autoId: 1,
+            name: "Alice",
+            aicol: "test",
+          }),
+          expect.objectContaining({
+            autoId: 2,
+            name: "Bob",
+            aicol: "test",
+          }),
+          expect.objectContaining({
+            autoId: 3,
+            name: "Claire",
+            aicol: "test",
+          }),
+        ])
+      })
+    })
  })
 })
--- a/packages/server/src/api/controllers/table/utils.ts
+++ b/packages/server/src/api/controllers/table/utils.ts
@ -15,7 +15,7 @@ import { getViews, saveView } from "../view/utils"
 import viewTemplate from "../view/viewBuilder"
 import { cloneDeep } from "lodash/fp"
 import { quotas } from "@budibase/pro"
-import { context, events, features } from "@budibase/backend-core"
+import { context, events, features, HTTPError } from "@budibase/backend-core"
 import {
  AutoFieldSubType,
  Database,
@ -145,14 +145,21 @@ export async function importToRows(
    // the real schema of the table passed in, not the clone used for
    // incrementing auto IDs
    for (const [fieldName, schema] of Object.entries(originalTable.schema)) {
-      const rowVal = Array.isArray(row[fieldName])
-        ? row[fieldName]
-        : [row[fieldName]]
+      if (schema.type === FieldType.LINK) {
+        throw new HTTPError(
+          `Can't bulk import relationship fields for internal databases, found value in field "${fieldName}"`,
+          400
+        )
+      }
+
      if (
        (schema.type === FieldType.OPTIONS ||
          schema.type === FieldType.ARRAY) &&
        row[fieldName]
      ) {
+        const rowVal = Array.isArray(row[fieldName])
+          ? row[fieldName]
+          : [row[fieldName]]
        let merged = [...schema.constraints!.inclusion!, ...rowVal]
        let superSet = new Set(merged)
        schema.constraints!.inclusion = Array.from(superSet)
--- a/packages/server/src/api/controllers/view/viewsV2.ts
+++ b/packages/server/src/api/controllers/view/viewsV2.ts
@ -12,6 +12,8 @@ import {
  RelationSchemaField,
  ViewFieldMetadata,
  CalculationType,
+  CountDistinctCalculationFieldMetadata,
+  CountCalculationFieldMetadata,
 } from "@budibase/types"
 import { builderSocket, gridSocket } from "../../../websockets"
 import { helpers } from "@budibase/shared-core"
@ -22,27 +24,31 @@ function stripUnknownFields(
  if (helpers.views.isCalculationField(field)) {
    if (field.calculationType === CalculationType.COUNT) {
      if ("distinct" in field && field.distinct) {
-        return {
+        const strippedField: RequiredKeys<CountDistinctCalculationFieldMetadata> =
+          {
+            order: field.order,
+            width: field.width,
+            visible: field.visible,
+            readonly: field.readonly,
+            icon: field.icon,
+            distinct: field.distinct,
+            calculationType: field.calculationType,
+            field: field.field,
+            columns: field.columns,
+          }
+        return strippedField
+      } else {
+        const strippedField: RequiredKeys<CountCalculationFieldMetadata> = {
          order: field.order,
          width: field.width,
          visible: field.visible,
          readonly: field.readonly,
          icon: field.icon,
-          distinct: field.distinct,
          calculationType: field.calculationType,
          field: field.field,
          columns: field.columns,
        }
-      } else {
-        return {
-          order: field.order,
-          width: field.width,
-          visible: field.visible,
-          readonly: field.readonly,
-          icon: field.icon,
-          calculationType: field.calculationType,
-          columns: field.columns,
-        }
+        return strippedField
      }
    }
    const strippedField: RequiredKeys<ViewCalculationFieldMetadata> = {
--- a/packages/server/src/api/routes/tests/row.spec.ts
+++ b/packages/server/src/api/routes/tests/row.spec.ts
@ -1823,6 +1823,39 @@ describe.each([
        expect(row.autoId).toEqual(3)
      })

+    isInternal &&
+      it("should reject bulkImporting relationship fields", async () => {
+        const table1 = await config.api.table.save(saveTableRequest())
+        const table2 = await config.api.table.save(
+          saveTableRequest({
+            schema: {
+              relationship: {
+                name: "relationship",
+                type: FieldType.LINK,
+                tableId: table1._id!,
+                relationshipType: RelationshipType.ONE_TO_MANY,
+                fieldName: "relationship",
+              },
+            },
+          })
+        )
+
+        const table1Row1 = await config.api.row.save(table1._id!, {})
+        await config.api.row.bulkImport(
+          table2._id!,
+          {
+            rows: [{ relationship: [table1Row1._id!] }],
+          },
+          {
+            status: 400,
+            body: {
+              message:
+                'Can\'t bulk import relationship fields for internal databases, found value in field "relationship"',
+            },
+          }
+        )
+      })
+
    it("should be able to bulkImport rows", async () => {
      const table = await config.api.table.save(
        saveTableRequest({
@ -2462,7 +2495,7 @@ describe.each([
          [FieldType.ATTACHMENT_SINGLE]: setup.structures.basicAttachment(),
          [FieldType.FORMULA]: undefined, // generated field
          [FieldType.AUTO]: undefined, // generated field
-          [FieldType.AI]: undefined, // generated field
+          [FieldType.AI]: "LLM Output",
          [FieldType.JSON]: { name: generator.guid() },
          [FieldType.INTERNAL]: generator.guid(),
          [FieldType.BARCODEQR]: generator.guid(),
@ -2494,6 +2527,7 @@ describe.each([
          }),
          [FieldType.FORMULA]: fullSchema[FieldType.FORMULA].formula,
          [FieldType.AUTO]: expect.any(Number),
+          [FieldType.AI]: expect.any(String),
          [FieldType.JSON]: rowValues[FieldType.JSON],
          [FieldType.INTERNAL]: rowValues[FieldType.INTERNAL],
          [FieldType.BARCODEQR]: rowValues[FieldType.BARCODEQR],
@ -2566,7 +2600,7 @@ describe.each([
              expectedRowData["bb_reference_single"].sample,
              false
            ),
-            ai: null,
+            ai: "LLM Output",
          },
        ])
      })
--- a/packages/server/src/api/routes/tests/viewV2.spec.ts
+++ b/packages/server/src/api/routes/tests/viewV2.spec.ts
@ -693,6 +693,12 @@ describe.each([
                calculationType: CalculationType.COUNT,
                field: "Price",
              },
+              countDistinct: {
+                visible: true,
+                calculationType: CalculationType.COUNT,
+                distinct: true,
+                field: "Price",
+              },
              min: {
                visible: true,
                calculationType: CalculationType.MIN,
@ -708,11 +714,6 @@ describe.each([
                calculationType: CalculationType.AVG,
                field: "Price",
              },
-              sum2: {
-                visible: true,
-                calculationType: CalculationType.SUM,
-                field: "Price",
-              },
            },
          },
          {
@ -763,10 +764,12 @@ describe.each([
              count: {
                visible: true,
                calculationType: CalculationType.COUNT,
+                field: "Price",
              },
              count2: {
                visible: true,
                calculationType: CalculationType.COUNT,
+                field: "Price",
              },
            },
          },
@ -774,7 +777,7 @@ describe.each([
            status: 400,
            body: {
              message:
-                'Duplicate calculation on field "*", calculation type "count"',
+                'Duplicate calculation on field "Price", calculation type "count"',
            },
          }
        )
@ -805,7 +808,7 @@ describe.each([
            status: 400,
            body: {
              message:
-                'Duplicate calculation on field "Price", calculation type "count"',
+                'Duplicate calculation on field "Price", calculation type "count distinct"',
            },
          }
        )
@ -820,6 +823,7 @@ describe.each([
            count: {
              visible: true,
              calculationType: CalculationType.COUNT,
+              field: "Price",
            },
            count2: {
              visible: true,
@ -831,6 +835,26 @@ describe.each([
        })
      })

+      it("does not confuse counts on different fields in the duplicate check", async () => {
+        await config.api.viewV2.create({
+          tableId: table._id!,
+          name: generator.guid(),
+          type: ViewV2Type.CALCULATION,
+          schema: {
+            count: {
+              visible: true,
+              calculationType: CalculationType.COUNT,
+              field: "Price",
+            },
+            count2: {
+              visible: true,
+              calculationType: CalculationType.COUNT,
+              field: "Category",
+            },
+          },
+        })
+      })
+
      !isLucene &&
        it("does not get confused when a calculation field shadows a basic one", async () => {
          const table = await config.api.table.save(
@ -1607,6 +1631,7 @@ describe.each([
            view.schema!.count = {
              visible: true,
              calculationType: CalculationType.COUNT,
+              field: "age",
            }
            await config.api.viewV2.update(view)

@ -3761,6 +3786,51 @@ describe.each([
              expect(rows[0].sum).toEqual(55)
            })

+            it("should be able to count non-numeric fields", async () => {
+              const table = await config.api.table.save(
+                saveTableRequest({
+                  schema: {
+                    firstName: {
+                      type: FieldType.STRING,
+                      name: "firstName",
+                    },
+                    lastName: {
+                      type: FieldType.STRING,
+                      name: "lastName",
+                    },
+                  },
+                })
+              )
+
+              const view = await config.api.viewV2.create({
+                tableId: table._id!,
+                name: generator.guid(),
+                type: ViewV2Type.CALCULATION,
+                schema: {
+                  count: {
+                    visible: true,
+                    calculationType: CalculationType.COUNT,
+                    field: "firstName",
+                  },
+                },
+              })
+
+              await config.api.row.bulkImport(table._id!, {
+                rows: [
+                  { firstName: "Jane", lastName: "Smith" },
+                  { firstName: "Jane", lastName: "Doe" },
+                  { firstName: "Alice", lastName: "Smith" },
+                ],
+              })
+
+              const { rows } = await config.api.viewV2.search(view.id, {
+                query: {},
+              })
+
+              expect(rows).toHaveLength(1)
+              expect(rows[0].count).toEqual(3)
+            })
+
            it("should be able to filter rows on the view itself", async () => {
              const table = await config.api.table.save(
                saveTableRequest({
--- a/packages/server/src/sdk/app/rows/search/internal/sqs.ts
+++ b/packages/server/src/sdk/app/rows/search/internal/sqs.ts
@ -351,6 +351,7 @@ export async function search(
          aggregations.push({
            name: key,
            calculationType: field.calculationType,
+            field: mapToUserColumn(field.field),
          })
        }
      } else {
--- a/packages/server/src/sdk/app/views/index.ts
+++ b/packages/server/src/sdk/app/views/index.ts
@ -61,12 +61,68 @@ export function isView(view: any): view is ViewV2 {
  return view.id && docIds.isViewId(view.id) && view.version === 2
 }

+function guardDuplicateCalculationFields(view: Omit<ViewV2, "id" | "version">) {
+  const seen: Record<string, Record<CalculationType, boolean>> = {}
+  const calculationFields = helpers.views.calculationFields(view)
+  for (const name of Object.keys(calculationFields)) {
+    const schema = calculationFields[name]
+    const isCount = schema.calculationType === CalculationType.COUNT
+    const isDistinct = "distinct" in schema
+
+    if (isCount && isDistinct) {
+      // We do these separately.
+      continue
+    }
+
+    if (seen[schema.field]?.[schema.calculationType]) {
+      throw new HTTPError(
+        `Duplicate calculation on field "${schema.field}", calculation type "${schema.calculationType}"`,
+        400
+      )
+    }
+    seen[schema.field] ??= {} as Record<CalculationType, boolean>
+    seen[schema.field][schema.calculationType] = true
+  }
+}
+
+function guardDuplicateCountDistinctFields(
+  view: Omit<ViewV2, "id" | "version">
+) {
+  const seen: Record<string, Record<CalculationType, boolean>> = {}
+  const calculationFields = helpers.views.calculationFields(view)
+  for (const name of Object.keys(calculationFields)) {
+    const schema = calculationFields[name]
+    const isCount = schema.calculationType === CalculationType.COUNT
+    if (!isCount) {
+      continue
+    }
+
+    const isDistinct = "distinct" in schema
+    if (!isDistinct) {
+      // We do these separately.
+      continue
+    }
+
+    if (seen[schema.field]?.[schema.calculationType]) {
+      throw new HTTPError(
+        `Duplicate calculation on field "${schema.field}", calculation type "${schema.calculationType} distinct"`,
+        400
+      )
+    }
+    seen[schema.field] ??= {} as Record<CalculationType, boolean>
+    seen[schema.field][schema.calculationType] = true
+  }
+}
+
 async function guardCalculationViewSchema(
  table: Table,
  view: Omit<ViewV2, "id" | "version">
 ) {
  const calculationFields = helpers.views.calculationFields(view)

+  guardDuplicateCalculationFields(view)
+  guardDuplicateCountDistinctFields(view)
+
  if (Object.keys(calculationFields).length > 5) {
    throw new HTTPError(
      "Calculation views can only have a maximum of 5 fields",
@ -74,29 +130,8 @@ async function guardCalculationViewSchema(
    )
  }

-  const seen: Record<string, Record<CalculationType, boolean>> = {}
-
  for (const name of Object.keys(calculationFields)) {
    const schema = calculationFields[name]
-    const isCount = schema.calculationType === CalculationType.COUNT
-    const isDistinct = isCount && "distinct" in schema && schema.distinct
-
-    const field = isCount && !isDistinct ? "*" : schema.field
-    if (seen[field]?.[schema.calculationType]) {
-      throw new HTTPError(
-        `Duplicate calculation on field "${field}", calculation type "${schema.calculationType}"`,
-        400
-      )
-    }
-    seen[field] ??= {} as Record<CalculationType, boolean>
-    seen[field][schema.calculationType] = true
-
-    // Count fields that aren't distinct don't need to reference another field,
-    // so we don't validate it.
-    if (isCount && !isDistinct) {
-      continue
-    }
-
    if (!schema.field) {
      throw new HTTPError(
        `Calculation field "${name}" is missing a "field" property`,
@ -112,6 +147,7 @@ async function guardCalculationViewSchema(
      )
    }

+    const isCount = schema.calculationType === CalculationType.COUNT
    if (!isCount && !isNumeric(targetSchema.type)) {
      throw new HTTPError(
        `Calculation field "${name}" references field "${schema.field}" which is not a numeric field`,
--- a/packages/server/src/threads/automation.ts
+++ b/packages/server/src/threads/automation.ts
@ -8,7 +8,7 @@ import {
 import * as actions from "../automations/actions"
 import * as automationUtils from "../automations/automationUtils"
 import { replaceFakeBindings } from "../automations/loopUtils"
-import { dataFilters, helpers } from "@budibase/shared-core"
+import { dataFilters, helpers, utils } from "@budibase/shared-core"
 import { default as AutomationEmitter } from "../events/AutomationEmitter"
 import { generateAutomationMetadataID, isProdAppID } from "../db/utils"
 import { definitions as triggerDefs } from "../automations/triggerInfo"
@ -23,10 +23,12 @@ import {
  AutomationStatus,
  AutomationStep,
  AutomationStepStatus,
+  BranchSearchFilters,
  BranchStep,
+  isLogicalSearchOperator,
  LoopStep,
-  SearchFilters,
  UserBindings,
+  isBasicSearchOperator,
 } from "@budibase/types"
 import { AutomationContext, TriggerOutput } from "../definitions/automations"
 import { WorkerCallback } from "./definitions"
@ -547,34 +549,51 @@ class Orchestrator {
  }

  private async evaluateBranchCondition(
-    conditions: SearchFilters
+    conditions: BranchSearchFilters
  ): Promise<boolean> {
    const toFilter: Record<string, any> = {}

-    const processedConditions = dataFilters.recurseSearchFilters(
-      conditions,
-      filter => {
-        Object.entries(filter).forEach(([_, value]) => {
-          Object.entries(value).forEach(([field, val]) => {
+    const recurseSearchFilters = (
+      filters: BranchSearchFilters
+    ): BranchSearchFilters => {
+      for (const filterKey of Object.keys(
+        filters
+      ) as (keyof typeof filters)[]) {
+        if (!filters[filterKey]) {
+          continue
+        }
+
+        if (isLogicalSearchOperator(filterKey)) {
+          filters[filterKey].conditions = filters[filterKey].conditions.map(
+            condition => recurseSearchFilters(condition)
+          )
+        } else if (isBasicSearchOperator(filterKey)) {
+          for (const [field, value] of Object.entries(filters[filterKey])) {
            const fromContext = processStringSync(
              field,
              this.processContext(this.context)
            )
            toFilter[field] = fromContext

-            if (typeof val === "string" && findHBSBlocks(val).length > 0) {
+            if (typeof value === "string" && findHBSBlocks(value).length > 0) {
              const processedVal = processStringSync(
-                val,
+                value,
                this.processContext(this.context)
              )

-              value[field] = processedVal
+              filters[filterKey][field] = processedVal
            }
-          })
-        })
-        return filter
+          }
+        } else {
+          // We want to types to complain if we extend BranchSearchFilters, but not to throw if the request comes with some extra data. It will just be ignored
+          utils.unreachable(filterKey, { doNotThrow: true })
+        }
      }
-    )
+
+      return filters
+    }
+
+    const processedConditions = recurseSearchFilters(conditions)

    const result = dataFilters.runQuery([toFilter], processedConditions)
    return result.length > 0
--- a/packages/server/src/utilities/rowProcessor/index.ts
+++ b/packages/server/src/utilities/rowProcessor/index.ts
@ -216,10 +216,6 @@ export async function inputProcessing(
    if (field.type === FieldType.FORMULA) {
      delete clonedRow[key]
    }
-    // remove any AI values, they are to be generated
-    if (field.type === FieldType.AI) {
-      delete clonedRow[key]
-    }
    // otherwise coerce what is there to correct types
    else {
      clonedRow[key] = coerce(value, field.type)
--- a/packages/shared-core/src/filters.ts
+++ b/packages/shared-core/src/filters.ts
@ -142,25 +142,6 @@ export function recurseLogicalOperators(
  return filters
 }

-export function recurseSearchFilters(
-  filters: SearchFilters,
-  processFn: (filter: SearchFilters) => SearchFilters
-): SearchFilters {
-  // Process the current level
-  filters = processFn(filters)
-
-  // Recurse through logical operators
-  for (const logical of LOGICAL_OPERATORS) {
-    if (filters[logical]) {
-      filters[logical]!.conditions = filters[logical]!.conditions.map(
-        condition => recurseSearchFilters(condition, processFn)
-      )
-    }
-  }
-
-  return filters
-}
-
 /**
 * Removes any fields that contain empty strings that would cause inconsistent
 * behaviour with how backend tables are filtered (no value means no filter).
--- a/packages/shared-core/src/utils.ts
+++ b/packages/shared-core/src/utils.ts
@ -26,9 +26,16 @@ const FILTER_ALLOWED_KEYS: (keyof SearchFilter)[] = [

 export function unreachable(
  value: never,
-  message = `No such case in exhaustive switch: ${value}`
+  opts?: {
+    message?: string
+    doNotThrow?: boolean
+  }
 ) {
-  throw new Error(message)
+  const message = opts?.message || `No such case in exhaustive switch: ${value}`
+  const doNotThrow = !!opts?.doNotThrow
+  if (!doNotThrow) {
+    throw new Error(message)
+  }
 }

 export async function parallelForeach<T>(
--- a/packages/types/src/documents/app/automation/StepInputsOutputs.ts
+++ b/packages/types/src/documents/app/automation/StepInputsOutputs.ts
@ -1,5 +1,10 @@
 import { SortOrder } from "../../../api"
-import { SearchFilters, EmptyFilterOption } from "../../../sdk"
+import {
+  SearchFilters,
+  EmptyFilterOption,
+  BasicOperator,
+  LogicalOperator,
+} from "../../../sdk"
 import { HttpMethod } from "../query"
 import { Row } from "../row"
 import { LoopStepType, EmailAttachment, AutomationResults } from "./automation"
@ -118,9 +123,17 @@ export type BranchStepInputs = {
 export type Branch = {
  id: any
  name: string
-  condition: SearchFilters
+  condition: BranchSearchFilters
 }

+export type BranchSearchFilters = Pick<
+  SearchFilters,
+  | BasicOperator.EQUAL
+  | BasicOperator.NOT_EQUAL
+  | LogicalOperator.AND
+  | LogicalOperator.OR
+>
+
 export type MakeIntegrationInputs = {
  url: string
  body: any
--- a/packages/types/src/documents/app/view.ts
+++ b/packages/types/src/documents/app/view.ts
@ -54,12 +54,12 @@ export interface NumericCalculationFieldMetadata

 export interface CountCalculationFieldMetadata extends BasicViewFieldMetadata {
  calculationType: CalculationType.COUNT
+  field: string
 }

 export interface CountDistinctCalculationFieldMetadata
  extends CountCalculationFieldMetadata {
  distinct: true
-  field: string
 }

 export type ViewCalculationFieldMetadata =
--- a/packages/types/src/sdk/row.ts
+++ b/packages/types/src/sdk/row.ts
@ -18,11 +18,11 @@ export interface NumericAggregation extends BaseAggregation {

 export interface CountAggregation extends BaseAggregation {
  calculationType: CalculationType.COUNT
+  field: string
 }

 export interface CountDistinctAggregation extends CountAggregation {
  distinct: true
-  field: string
 }

 export type Aggregation =