diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 0000000000..85b026dd08
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1 @@
+scripts/resources/minio filter=lfs diff=lfs merge=lfs -text
diff --git a/hosting/nginx.dev.conf b/hosting/nginx.dev.conf
index a8cefe9ccc..747235e8ef 100644
--- a/hosting/nginx.dev.conf
+++ b/hosting/nginx.dev.conf
@@ -62,12 +62,6 @@ http {
       proxy_connect_timeout 120s;
       proxy_send_timeout 120s;
       proxy_http_version 1.1;
-
-      # Enable buffering for potentially large OIDC configs
-      proxy_buffering on;
-      proxy_buffer_size 16k;
-      proxy_buffers 4 32k;
-
       proxy_set_header Host $host;
       proxy_set_header Connection "";
 
diff --git a/hosting/single/Dockerfile b/hosting/single/Dockerfile
index e4858d4af0..1f449e7376 100644
--- a/hosting/single/Dockerfile
+++ b/hosting/single/Dockerfile
@@ -1,5 +1,5 @@
 ARG BASEIMG=budibase/couchdb:v3.3.3-sqs-v2.1.1
-FROM node:20-slim as build
+FROM node:20-slim AS build
 
 # install node-gyp dependencies
 RUN apt-get update && apt-get install -y --no-install-recommends g++ make python3 jq
@@ -34,13 +34,13 @@ COPY packages/worker/dist packages/worker/dist
 COPY packages/worker/pm2.config.js packages/worker/pm2.config.js
 
 
-FROM $BASEIMG as runner
+FROM $BASEIMG AS runner
 ARG TARGETARCH
-ENV TARGETARCH $TARGETARCH
+ENV TARGETARCH=$TARGETARCH
 #TARGETBUILD can be set to single (for single docker image) or aas (for azure app service)
 # e.g. docker build --build-arg TARGETBUILD=aas ....
 ARG TARGETBUILD=single
-ENV TARGETBUILD $TARGETBUILD
+ENV TARGETBUILD=$TARGETBUILD
 
 # install base dependencies
 RUN apt-get update && \
@@ -67,6 +67,12 @@ RUN mkdir -p /var/log/nginx && \
 
 # setup minio
 WORKDIR /minio
+
+# a 2022 version of minio that supports gateway mode
+COPY scripts/resources/minio /minio
+RUN chmod +x minio
+
+# handles the installation of minio in non-aas environments
 COPY scripts/install-minio.sh ./install.sh
 RUN chmod +x install.sh && ./install.sh
 
diff --git a/hosting/single/runner.sh b/hosting/single/runner.sh
index e06a197ad5..1a81515d31 100644
--- a/hosting/single/runner.sh
+++ b/hosting/single/runner.sh
@@ -1,53 +1,61 @@
 #!/bin/bash
-declare -a ENV_VARS=("COUCHDB_USER" "COUCHDB_PASSWORD" "DATA_DIR" "MINIO_ACCESS_KEY" "MINIO_SECRET_KEY" "INTERNAL_API_KEY" "JWT_SECRET" "REDIS_PASSWORD")
-declare -a DOCKER_VARS=("APP_PORT" "APPS_URL" "ARCHITECTURE" "BUDIBASE_ENVIRONMENT" "CLUSTER_PORT" "DEPLOYMENT_ENVIRONMENT" "MINIO_URL" "NODE_ENV" "POSTHOG_TOKEN" "REDIS_URL" "SELF_HOSTED" "WORKER_PORT" "WORKER_URL" "TENANT_FEATURE_FLAGS" "ACCOUNT_PORTAL_URL")
-# Check the env vars set in Dockerfile have come through, AAS seems to drop them
-[[ -z "${APP_PORT}" ]] && export APP_PORT=4001
-[[ -z "${ARCHITECTURE}" ]] && export ARCHITECTURE=amd
-[[ -z "${BUDIBASE_ENVIRONMENT}" ]] && export BUDIBASE_ENVIRONMENT=PRODUCTION
-[[ -z "${CLUSTER_PORT}" ]] && export CLUSTER_PORT=80
-[[ -z "${DEPLOYMENT_ENVIRONMENT}" ]] && export DEPLOYMENT_ENVIRONMENT=docker
-[[ -z "${MINIO_URL}" ]] && [[ -z "${USE_S3}" ]] && export MINIO_URL=http://127.0.0.1:9000
-[[ -z "${NODE_ENV}" ]] && export NODE_ENV=production
-[[ -z "${POSTHOG_TOKEN}" ]] && export POSTHOG_TOKEN=phc_bIjZL7oh2GEUd2vqvTBH8WvrX0fWTFQMs6H5KQxiUxU
-[[ -z "${ACCOUNT_PORTAL_URL}" ]] && export ACCOUNT_PORTAL_URL=https://account.budibase.app
-[[ -z "${REDIS_URL}" ]] && export REDIS_URL=127.0.0.1:6379
-[[ -z "${SELF_HOSTED}" ]] && export SELF_HOSTED=1
-[[ -z "${WORKER_PORT}" ]] && export WORKER_PORT=4002
-[[ -z "${WORKER_URL}" ]] && export WORKER_URL=http://127.0.0.1:4002
-[[ -z "${APPS_URL}" ]] && export APPS_URL=http://127.0.0.1:4001
-[[ -z "${SERVER_TOP_LEVEL_PATH}" ]] && export SERVER_TOP_LEVEL_PATH=/app
-#  export CUSTOM_DOMAIN=budi001.custom.com
 
-# Azure App Service customisations
-if [[ "${TARGETBUILD}" = "aas" ]]; then
-    export DATA_DIR="${DATA_DIR:-/home}"
-    WEBSITES_ENABLE_APP_SERVICE_STORAGE=true
-    /etc/init.d/ssh start
-else
-    export DATA_DIR=${DATA_DIR:-/data}
+echo "Starting runner.sh..."
+
+# set defaults for Docker-related variables
+export APP_PORT="${APP_PORT:-4001}"
+export ARCHITECTURE="${ARCHITECTURE:-amd}"
+export BUDIBASE_ENVIRONMENT="${BUDIBASE_ENVIRONMENT:-PRODUCTION}"
+export CLUSTER_PORT="${CLUSTER_PORT:-80}"
+export DEPLOYMENT_ENVIRONMENT="${DEPLOYMENT_ENVIRONMENT:-docker}"
+
+# only set MINIO_URL if neither MINIO_URL nor USE_S3 is set
+if [[ -z "${MINIO_URL}" && -z "${USE_S3}" ]]; then
+  export MINIO_URL="http://127.0.0.1:9000"
 fi
-mkdir -p ${DATA_DIR}
-# Mount NFS or GCP Filestore if env vars exist for it
-if [[ ! -z ${FILESHARE_IP} && ! -z ${FILESHARE_NAME} ]]; then
+
+export NODE_ENV="${NODE_ENV:-production}"
+export POSTHOG_TOKEN="${POSTHOG_TOKEN:-phc_bIjZL7oh2GEUd2vqvTBH8WvrX0fWTFQMs6H5KQxiUxU}"
+export ACCOUNT_PORTAL_URL="${ACCOUNT_PORTAL_URL:-https://account.budibase.app}"
+export REDIS_URL="${REDIS_URL:-127.0.0.1:6379}"
+export SELF_HOSTED="${SELF_HOSTED:-1}"
+export WORKER_PORT="${WORKER_PORT:-4002}"
+export WORKER_URL="${WORKER_URL:-http://127.0.0.1:4002}"
+export APPS_URL="${APPS_URL:-http://127.0.0.1:4001}"
+export SERVER_TOP_LEVEL_PATH="${SERVER_TOP_LEVEL_PATH:-/app}"
+
+# set DATA_DIR and ensure the directory exists
+if [[ ${TARGETBUILD} == "aas" ]]; then
+    export DATA_DIR="/home"
+else
+    export DATA_DIR="${DATA_DIR:-/data}"
+fi
+mkdir -p "${DATA_DIR}"
+
+# mount NFS or GCP Filestore if FILESHARE_IP and FILESHARE_NAME are set
+if [[ -n "${FILESHARE_IP}" && -n "${FILESHARE_NAME}" ]]; then
     echo "Mounting NFS share"
     apt update && apt install -y nfs-common nfs-kernel-server
     echo "Mount file share ${FILESHARE_IP}:/${FILESHARE_NAME} to ${DATA_DIR}"
-    mount -o nolock ${FILESHARE_IP}:/${FILESHARE_NAME} ${DATA_DIR}
+    mount -o nolock "${FILESHARE_IP}:/${FILESHARE_NAME}" "${DATA_DIR}"
     echo "Mounting result: $?"
 fi
 
-if [ -f "${DATA_DIR}/.env" ]; then
-    # Read in the .env file and export the variables
-    for LINE in $(cat ${DATA_DIR}/.env); do export $LINE; done
+# source environment variables from a .env file if it exists in DATA_DIR
+if [[ -f "${DATA_DIR}/.env" ]]; then
+    set -a  # Automatically export all variables loaded from .env
+    source "${DATA_DIR}/.env"
+    set +a
 fi
-# randomise any unset environment variables
-for ENV_VAR in "${ENV_VARS[@]}"
-do
-    if [[ -z "${!ENV_VAR}" ]]; then
-        eval "export $ENV_VAR=$(uuidgen | sed -e 's/-//g')"
+
+# randomize any unset sensitive environment variables using uuidgen
+env_vars=(COUCHDB_USER COUCHDB_PASSWORD MINIO_ACCESS_KEY MINIO_SECRET_KEY INTERNAL_API_KEY JWT_SECRET REDIS_PASSWORD)
+for var in "${env_vars[@]}"; do
+    if [[ -z "${!var}" ]]; then
+        export "$var"="$(uuidgen | tr -d '-')"
     fi
 done
+
 if [[ -z "${COUCH_DB_URL}" ]]; then
     export COUCH_DB_URL=http://$COUCHDB_USER:$COUCHDB_PASSWORD@127.0.0.1:5984
 fi
@@ -58,17 +66,15 @@ fi
 
 if [ ! -f "${DATA_DIR}/.env" ]; then
     touch ${DATA_DIR}/.env
-    for ENV_VAR in "${ENV_VARS[@]}"
-    do
+    for ENV_VAR in "${ENV_VARS[@]}"; do
         temp=$(eval "echo \$$ENV_VAR")
-        echo "$ENV_VAR=$temp" >> ${DATA_DIR}/.env
+        echo "$ENV_VAR=$temp" >>${DATA_DIR}/.env
     done
-    for ENV_VAR in "${DOCKER_VARS[@]}"
-    do
+    for ENV_VAR in "${DOCKER_VARS[@]}"; do
         temp=$(eval "echo \$$ENV_VAR")
-        echo "$ENV_VAR=$temp" >> ${DATA_DIR}/.env
+        echo "$ENV_VAR=$temp" >>${DATA_DIR}/.env
     done
-    echo "COUCH_DB_URL=${COUCH_DB_URL}" >> ${DATA_DIR}/.env
+    echo "COUCH_DB_URL=${COUCH_DB_URL}" >>${DATA_DIR}/.env
 fi
 
 # Read in the .env file and export the variables
@@ -79,31 +85,44 @@ ln -s ${DATA_DIR}/.env /worker/.env
 # make these directories in runner, incase of mount
 mkdir -p ${DATA_DIR}/minio
 mkdir -p ${DATA_DIR}/redis
+mkdir -p ${DATA_DIR}/couch
 chown -R couchdb:couchdb ${DATA_DIR}/couch
 
 REDIS_CONFIG="/etc/redis/redis.conf"
 sed -i "s#DATA_DIR#${DATA_DIR}#g" "${REDIS_CONFIG}"
 
 if [[ -n "${USE_DEFAULT_REDIS_CONFIG}" ]]; then
-  REDIS_CONFIG=""
+    REDIS_CONFIG=""
 fi
 
 if [[ -n "${REDIS_PASSWORD}" ]]; then
-  redis-server "${REDIS_CONFIG}" --requirepass $REDIS_PASSWORD > /dev/stdout 2>&1 &
+    redis-server "${REDIS_CONFIG}" --requirepass $REDIS_PASSWORD >/dev/stdout 2>&1 &
 else
-  redis-server "${REDIS_CONFIG}" > /dev/stdout 2>&1 &
+    redis-server "${REDIS_CONFIG}" >/dev/stdout 2>&1 &
 fi
-/bbcouch-runner.sh &
+
+echo "Starting callback CouchDB runner..."
+./bbcouch-runner.sh &
 
 # only start minio if use s3 isn't passed
 if [[ -z "${USE_S3}" ]]; then
-  /minio/minio server --console-address ":9001" ${DATA_DIR}/minio > /dev/stdout 2>&1 &
+    if [[ ${TARGETBUILD} == aas ]]; then
+        echo "Starting MinIO in Azure Gateway mode"
+        if [[ -z "${AZURE_STORAGE_ACCOUNT}" || -z "${AZURE_STORAGE_KEY}" || -z "${MINIO_ACCESS_KEY}" || -z "${MINIO_SECRET_KEY}" ]]; then
+            echo "The following environment variables must be set: AZURE_STORAGE_ACCOUNT, AZURE_STORAGE_KEY, MINIO_ACCESS_KEY, MINIO_SECRET_KEY"
+            exit 1
+        fi
+        /minio/minio gateway azure --console-address ":9001" >/dev/stdout 2>&1 &
+    else
+        echo "Starting MinIO in standalone mode"
+        /minio/minio server --console-address ":9001" ${DATA_DIR}/minio >/dev/stdout 2>&1 &
+    fi
 fi
 
 /etc/init.d/nginx restart
 if [[ ! -z "${CUSTOM_DOMAIN}" ]]; then
     # Add monthly cron job to renew certbot certificate
-    echo -n "* * 2 * * root exec /app/letsencrypt/certificate-renew.sh ${CUSTOM_DOMAIN}" >> /etc/cron.d/certificate-renew
+    echo -n "* * 2 * * root exec /app/letsencrypt/certificate-renew.sh ${CUSTOM_DOMAIN}" >>/etc/cron.d/certificate-renew
     chmod +x /etc/cron.d/certificate-renew
     # Request the certbot certificate
     /app/letsencrypt/certificate-request.sh ${CUSTOM_DOMAIN}
diff --git a/lerna.json b/lerna.json
index b6eb31f2b0..bb71d10f41 100644
--- a/lerna.json
+++ b/lerna.json
@@ -1,6 +1,6 @@
 {
   "$schema": "node_modules/lerna/schemas/lerna-schema.json",
-  "version": "3.4.13",
+  "version": "3.4.16",
   "npmClient": "yarn",
   "concurrency": 20,
   "command": {
diff --git a/packages/builder/src/components/common/CodeEditor/CodeEditor.svelte b/packages/builder/src/components/common/CodeEditor/CodeEditor.svelte
index fbf74d1e9b..0f4bc64e2a 100644
--- a/packages/builder/src/components/common/CodeEditor/CodeEditor.svelte
+++ b/packages/builder/src/components/common/CodeEditor/CodeEditor.svelte
@@ -49,6 +49,7 @@
   import type { EditorMode } from "@budibase/types"
   import type { BindingCompletion, CodeValidator } from "@/types"
   import { validateHbsTemplate } from "./validator/hbs"
+  import { validateJsTemplate } from "./validator/js"
 
   export let label: string | undefined = undefined
   export let completions: BindingCompletion[] = []
@@ -356,6 +357,9 @@
     if (mode === EditorModes.Handlebars) {
       const diagnostics = validateHbsTemplate(value, validations)
       editor.dispatch(setDiagnostics(editor.state, diagnostics))
+    } else if (mode === EditorModes.JS) {
+      const diagnostics = validateJsTemplate(value, validations)
+      editor.dispatch(setDiagnostics(editor.state, diagnostics))
     }
   }
 
diff --git a/packages/builder/src/components/common/CodeEditor/validator/js.ts b/packages/builder/src/components/common/CodeEditor/validator/js.ts
new file mode 100644
index 0000000000..20fb5abd07
--- /dev/null
+++ b/packages/builder/src/components/common/CodeEditor/validator/js.ts
@@ -0,0 +1,101 @@
+import { Parser } from "acorn"
+import * as walk from "acorn-walk"
+
+import type { Diagnostic } from "@codemirror/lint"
+import { CodeValidator } from "@/types"
+
+export function validateJsTemplate(
+  code: string,
+  validations: CodeValidator
+): Diagnostic[] {
+  const diagnostics: Diagnostic[] = []
+
+  try {
+    const ast = Parser.parse(code, {
+      ecmaVersion: "latest",
+      locations: true,
+      allowReturnOutsideFunction: true,
+    })
+
+    const lineOffsets: number[] = []
+    let offset = 0
+    for (const line of code.split("\n")) {
+      lineOffsets.push(offset)
+      offset += line.length + 1 // +1 for newline character
+    }
+
+    let hasReturnStatement = false
+    walk.ancestor(ast, {
+      ReturnStatement(node, _state, ancestors) {
+        if (
+          // it returns a value
+          node.argument &&
+          // and it is top level
+          ancestors.length === 2 &&
+          ancestors[0].type === "Program" &&
+          ancestors[1].type === "ReturnStatement"
+        ) {
+          hasReturnStatement = true
+        }
+      },
+      CallExpression(node) {
+        const callee: any = node.callee
+        if (
+          node.type === "CallExpression" &&
+          callee.object?.name === "helpers" &&
+          node.loc
+        ) {
+          const functionName = callee.property.name
+          const from =
+            lineOffsets[node.loc.start.line - 1] + node.loc.start.column
+          const to = lineOffsets[node.loc.end.line - 1] + node.loc.end.column
+
+          if (!(functionName in validations)) {
+            diagnostics.push({
+              from,
+              to,
+              severity: "warning",
+              message: `"${functionName}" function does not exist.`,
+            })
+            return
+          }
+
+          const { arguments: expectedArguments } = validations[functionName]
+          if (
+            expectedArguments &&
+            node.arguments.length !== expectedArguments.length
+          ) {
+            diagnostics.push({
+              from,
+              to,
+              severity: "error",
+              message: `Function "${functionName}" expects ${
+                expectedArguments.length
+              } parameters (${expectedArguments.join(", ")}), but got ${
+                node.arguments.length
+              }.`,
+            })
+          }
+        }
+      },
+    })
+
+    if (!hasReturnStatement) {
+      diagnostics.push({
+        from: 0,
+        to: code.length,
+        severity: "error",
+        message: "Your code must return a value.",
+      })
+    }
+  } catch (e: any) {
+    diagnostics.push({
+      from: 0,
+      to: code.length,
+      severity: "error",
+      message: `Syntax error: ${e.message}`,
+    })
+  }
+
+  return diagnostics
+}
diff --git a/packages/builder/src/components/common/CodeEditor/validator/tests/js.spec.ts b/packages/builder/src/components/common/CodeEditor/validator/tests/js.spec.ts
new file mode 100644
index 0000000000..cd9fe4684c
--- /dev/null
+++ b/packages/builder/src/components/common/CodeEditor/validator/tests/js.spec.ts
@@ -0,0 +1,156 @@
+import { validateJsTemplate } from "../js"
+import { CodeValidator } from "@/types"
+
+describe("js validator", () => {
+  it("validates valid code", () => {
+    const text = "return 7"
+    const validators = {}
+
+    const result = validateJsTemplate(text, validators)
+    expect(result).toEqual([])
+  })
+
+  it("does not validate runtime errors", () => {
+    const text = "return a"
+    const validators = {}
+
+    const result = validateJsTemplate(text, validators)
+    expect(result).toEqual([])
+  })
+
+  it("validates multiline code", () => {
+    const text = "const foo='bar'\nreturn 123"
+    const validators = {}
+
+    const result = validateJsTemplate(text, validators)
+    expect(result).toEqual([])
+  })
+
+  it("allows return not being on the last line", () => {
+    const text = "const foo='bar'\nreturn 123\nconsole.log(foo)"
+    const validators = {}
+
+    const result = validateJsTemplate(text, validators)
+    expect(result).toEqual([])
+  })
+
+  it("throws on missing return", () => {
+    const text = "const foo='bar'\nbar='foo'"
+    const validators = {}
+
+    const result = validateJsTemplate(text, validators)
+    expect(result).toEqual([
+      {
+        from: 0,
+        message: "Your code must return a value.",
+        severity: "error",
+        to: 25,
+      },
+    ])
+  })
+
+  it("checks that returns are at top level", () => {
+    const text = `
+    function call(){
+      return 1
+    }`
+    const validators = {}
+
+    const result = validateJsTemplate(text, validators)
+    expect(result).toEqual([
+      {
+        from: 0,
+        message: "Your code must return a value.",
+        severity: "error",
+        to: text.length,
+      },
+    ])
+  })
+
+  describe("helpers", () => {
+    const validators: CodeValidator = {
+      helperFunction: {
+        arguments: ["a", "b", "c"],
+      },
+    }
+
+    it("validates helpers with valid params", () => {
+      const text = "return helpers.helperFunction(1, 99, 'a')"
+
+      const result = validateJsTemplate(text, validators)
+      expect(result).toEqual([])
+    })
+
+    it("throws on too few params", () => {
+      const text = "return helpers.helperFunction(100)"
+
+      const result = validateJsTemplate(text, validators)
+      expect(result).toEqual([
+        {
+          from: 7,
+          message: `Function "helperFunction" expects 3 parameters (a, b, c), but got 1.`,
+          severity: "error",
+          to: 34,
+        },
+      ])
+    })
+
+    it("throws on too many params", () => {
+      const text = "return helpers.helperFunction( 1, 99, 'a', 100)"
+
+      const result = validateJsTemplate(text, validators)
+      expect(result).toEqual([
+        {
+          from: 7,
+          message: `Function "helperFunction" expects 3 parameters (a, b, c), but got 4.`,
+          severity: "error",
+          to: 47,
+        },
+      ])
+    })
+
+    it("validates helpers on inner functions", () => {
+      const text = `function call(){
+                      return helpers.helperFunction(1, 99)
+                    }
+                    return call()`
+
+      const result = validateJsTemplate(text, validators)
+      expect(result).toEqual([
+        {
+          from: 46,
+          message: `Function "helperFunction" expects 3 parameters (a, b, c), but got 2.`,
+          severity: "error",
+          to: 75,
+        },
+      ])
+    })
+
+    it("validates multiple helpers", () => {
+      const text =
+        "return helpers.helperFunction(1, 99, 'a') + helpers.helperFunction(1) + helpers.another(1) + helpers.another()"
+      const validators: CodeValidator = {
+        helperFunction: {
+          arguments: ["a", "b", "c"],
+        },
+        another: { arguments: [] },
+      }
+
+      const result = validateJsTemplate(text, validators)
+      expect(result).toEqual([
+        {
+          from: 44,
+          message: `Function "helperFunction" expects 3 parameters (a, b, c), but got 1.`,
+          severity: "error",
+          to: 69,
+        },
+        {
+          from: 72,
+          message: `Function "another" expects 0 parameters (), but got 1.`,
+          severity: "error",
+          to: 90,
+        },
+      ])
+    })
+  })
+})
diff --git a/packages/builder/src/components/common/bindings/BindingPanel.svelte b/packages/builder/src/components/common/bindings/BindingPanel.svelte
index 2c35acdf2d..9ebbc91309 100644
--- a/packages/builder/src/components/common/bindings/BindingPanel.svelte
+++ b/packages/builder/src/components/common/bindings/BindingPanel.svelte
@@ -377,6 +377,7 @@
               value={jsValue ? decodeJSBinding(jsValue) : jsValue}
               on:change={onChangeJSValue}
               {completions}
+              {validations}
               mode={EditorModes.JS}
               bind:getCaretPosition
               bind:insertAtPos
diff --git a/packages/server/src/api/controllers/row/utils/tests/sqlUtils.spec.ts b/packages/server/src/api/controllers/row/utils/tests/sqlUtils.spec.ts
index 365f571fcf..cf14ba9b42 100644
--- a/packages/server/src/api/controllers/row/utils/tests/sqlUtils.spec.ts
+++ b/packages/server/src/api/controllers/row/utils/tests/sqlUtils.spec.ts
@@ -1,511 +1,532 @@
 import {
   AIOperationEnum,
   CalculationType,
+  Datasource,
   FieldType,
   RelationshipType,
-  SourceName,
   Table,
   ViewV2,
   ViewV2Type,
 } from "@budibase/types"
 import { buildSqlFieldList } from "../sqlUtils"
 import { structures } from "../../../../routes/tests/utilities"
-import { sql } from "@budibase/backend-core"
 import { generator } from "@budibase/backend-core/tests"
 import { generateViewID } from "../../../../../db/utils"
 
-import sdk from "../../../../../sdk"
-import { cloneDeep } from "lodash"
 import { utils } from "@budibase/shared-core"
+import {
+  DatabaseName,
+  datasourceDescribe,
+} from "../../../../../integrations/tests/utils"
+import { context } from "@budibase/backend-core"
 
-jest.mock("../../../../../sdk/app/views", () => ({
-  ...jest.requireActual("../../../../../sdk/app/views"),
-  getTable: jest.fn(),
-}))
-const getTableMock = sdk.views.getTable as jest.MockedFunction<
-  typeof sdk.views.getTable
->
-
-describe("buildSqlFieldList", () => {
-  let allTables: Record<string, Table>
-
-  class TableConfig {
-    private _table: Table & { _id: string }
-
-    constructor(name: string) {
-      this._table = {
-        ...structures.tableForDatasource({
-          type: "datasource",
-          source: SourceName.POSTGRES,
-        }),
-        name,
-        _id: sql.utils.buildExternalTableId("ds_id", name),
-        schema: {
-          name: {
-            name: "name",
-            type: FieldType.STRING,
-          },
-          description: {
-            name: "description",
-            type: FieldType.STRING,
-          },
-          amount: {
-            name: "amount",
-            type: FieldType.NUMBER,
-          },
-        },
-      }
-
-      allTables[name] = this._table
-    }
-
-    withHiddenField(field: string) {
-      this._table.schema[field].visible = false
-      return this
-    }
-
-    withField(
-      name: string,
-      type:
-        | FieldType.STRING
-        | FieldType.NUMBER
-        | FieldType.FORMULA
-        | FieldType.AI,
-      options?: { visible: boolean }
-    ) {
-      switch (type) {
-        case FieldType.NUMBER:
-        case FieldType.STRING:
-          this._table.schema[name] = {
-            name,
-            type,
-            ...options,
-          }
-          break
-        case FieldType.FORMULA:
-          this._table.schema[name] = {
-            name,
-            type,
-            formula: "any",
-            ...options,
-          }
-          break
-        case FieldType.AI:
-          this._table.schema[name] = {
-            name,
-            type,
-            operation: AIOperationEnum.PROMPT,
-            ...options,
-          }
-          break
-        default:
-          utils.unreachable(type)
-      }
-      return this
-    }
-
-    withRelation(name: string, toTableId: string) {
-      this._table.schema[name] = {
-        name,
-        type: FieldType.LINK,
-        relationshipType: RelationshipType.ONE_TO_MANY,
-        fieldName: "link",
-        tableId: toTableId,
-      }
-      return this
-    }
-
-    withPrimary(field: string) {
-      this._table.primary = [field]
-      return this
-    }
-
-    withDisplay(field: string) {
-      this._table.primaryDisplay = field
-      return this
-    }
-
-    create() {
-      return cloneDeep(this._table)
-    }
-  }
-
-  class ViewConfig {
-    private _table: Table
-    private _view: ViewV2
-
-    constructor(table: Table) {
-      this._table = table
-      this._view = {
-        version: 2,
-        id: generateViewID(table._id!),
-        name: generator.word(),
-        tableId: table._id!,
-      }
-    }
-
-    withVisible(field: string) {
-      this._view.schema ??= {}
-      this._view.schema[field] ??= {}
-      this._view.schema[field].visible = true
-      return this
-    }
-
-    withHidden(field: string) {
-      this._view.schema ??= {}
-      this._view.schema[field] ??= {}
-      this._view.schema[field].visible = false
-      return this
-    }
-
-    withRelationshipColumns(
-      field: string,
-      columns: Record<string, { visible: boolean }>
-    ) {
-      this._view.schema ??= {}
-      this._view.schema[field] ??= {}
-      this._view.schema[field].columns = columns
-      return this
-    }
-
-    withCalculation(
-      name: string,
-      field: string,
-      calculationType: CalculationType
-    ) {
-      this._view.type = ViewV2Type.CALCULATION
-      this._view.schema ??= {}
-      this._view.schema[name] = {
-        field,
-        calculationType,
-        visible: true,
-      }
-      return this
-    }
-
-    create() {
-      getTableMock.mockResolvedValueOnce(this._table)
-      return cloneDeep(this._view)
-    }
-  }
-
-  beforeEach(() => {
-    jest.clearAllMocks()
-    allTables = {}
-  })
-
-  describe("table", () => {
-    it("extracts fields from table schema", async () => {
-      const table = new TableConfig("table").create()
-      const result = await buildSqlFieldList(table, {})
-      expect(result).toEqual([
-        "table.name",
-        "table.description",
-        "table.amount",
-      ])
-    })
-
-    it("excludes hidden fields", async () => {
-      const table = new TableConfig("table")
-        .withHiddenField("description")
-        .create()
-      const result = await buildSqlFieldList(table, {})
-      expect(result).toEqual(["table.name", "table.amount"])
-    })
-
-    it("excludes non-sql fields fields", async () => {
-      const table = new TableConfig("table")
-        .withField("formula", FieldType.FORMULA)
-        .withField("ai", FieldType.AI)
-        .withRelation("link", "otherTableId")
-        .create()
-
-      const result = await buildSqlFieldList(table, {})
-      expect(result).toEqual([
-        "table.name",
-        "table.description",
-        "table.amount",
-      ])
-    })
-
-    it("includes hidden fields if there is a formula column", async () => {
-      const table = new TableConfig("table")
-        .withHiddenField("description")
-        .withField("formula", FieldType.FORMULA)
-        .create()
-
-      const result = await buildSqlFieldList(table, {})
-      expect(result).toEqual([
-        "table.name",
-        "table.description",
-        "table.amount",
-      ])
-    })
-
-    it("includes relationships fields when flagged", async () => {
-      const otherTable = new TableConfig("linkedTable")
-        .withField("id", FieldType.NUMBER)
-        .withPrimary("id")
-        .withDisplay("name")
-        .create()
-
-      const table = new TableConfig("table")
-        .withRelation("link", otherTable._id)
-        .create()
-
-      const result = await buildSqlFieldList(table, allTables, {
-        relationships: true,
-      })
-      expect(result).toEqual([
-        "table.name",
-        "table.description",
-        "table.amount",
-        "linkedTable.id",
-        "linkedTable.name",
-      ])
-    })
-
-    it("includes all relationship fields if there is a formula column", async () => {
-      const otherTable = new TableConfig("linkedTable")
-        .withField("hidden", FieldType.STRING, { visible: false })
-        .create()
-
-      const table = new TableConfig("table")
-        .withRelation("link", otherTable._id)
-        .withField("formula", FieldType.FORMULA)
-        .create()
-
-      const result = await buildSqlFieldList(table, allTables, {
-        relationships: true,
-      })
-      expect(result).toEqual([
-        "table.name",
-        "table.description",
-        "table.amount",
-        "linkedTable.name",
-        "linkedTable.description",
-        "linkedTable.amount",
-        "linkedTable.hidden",
-      ])
-    })
-
-    it("never includes non-sql columns from relationships", async () => {
-      const otherTable = new TableConfig("linkedTable")
-        .withField("id", FieldType.NUMBER)
-        .withField("hidden", FieldType.STRING, { visible: false })
-        .withField("formula", FieldType.FORMULA)
-        .withField("ai", FieldType.AI)
-        .withRelation("link", "otherTableId")
-        .create()
-
-      const table = new TableConfig("table")
-        .withRelation("link", otherTable._id)
-        .withField("formula", FieldType.FORMULA)
-        .create()
-
-      const result = await buildSqlFieldList(table, allTables, {
-        relationships: true,
-      })
-      expect(result).toEqual([
-        "table.name",
-        "table.description",
-        "table.amount",
-        "linkedTable.name",
-        "linkedTable.description",
-        "linkedTable.amount",
-        "linkedTable.id",
-        "linkedTable.hidden",
-      ])
-    })
-  })
-
-  describe("view", () => {
-    it("extracts fields from table schema", async () => {
-      const view = new ViewConfig(new TableConfig("table").create())
-        .withVisible("amount")
-        .withHidden("name")
-        .create()
-
-      const result = await buildSqlFieldList(view, {})
-      expect(result).toEqual(["table.amount"])
-    })
-
-    it("includes all fields if there is a formula column", async () => {
-      const table = new TableConfig("table")
-        .withField("formula", FieldType.FORMULA)
-        .create()
-      const view = new ViewConfig(table)
-        .withHidden("name")
-        .withVisible("amount")
-        .withVisible("formula")
-        .create()
-
-      const result = await buildSqlFieldList(view, {})
-      expect(result).toEqual([
-        "table.name",
-        "table.description",
-        "table.amount",
-      ])
-    })
-
-    it("does not includes all fields if the formula column is not included", async () => {
-      const table = new TableConfig("table")
-        .withField("formula", FieldType.FORMULA)
-        .create()
-      const view = new ViewConfig(table)
-        .withHidden("name")
-        .withVisible("amount")
-        .withHidden("formula")
-        .create()
-
-      const result = await buildSqlFieldList(view, {})
-      expect(result).toEqual(["table.amount"])
-    })
-
-    it("includes relationships columns", async () => {
-      const otherTable = new TableConfig("linkedTable")
-        .withField("id", FieldType.NUMBER)
-        .withField("formula", FieldType.FORMULA)
-        .withPrimary("id")
-        .create()
-
-      const table = new TableConfig("table")
-        .withRelation("link", otherTable._id)
-        .create()
-
-      const view = new ViewConfig(table)
-        .withVisible("name")
-        .withVisible("link")
-        .withRelationshipColumns("link", {
-          name: { visible: false },
-          amount: { visible: true },
-          formula: { visible: false },
-        })
-        .create()
-
-      const result = await buildSqlFieldList(view, allTables, {
-        relationships: true,
-      })
-      expect(result).toEqual([
-        "table.name",
-        "linkedTable.id",
-        "linkedTable.amount",
-      ])
-    })
-
-    it("excludes relationships fields when view is not included in the view", async () => {
-      const otherTable = new TableConfig("linkedTable")
-        .withField("id", FieldType.NUMBER)
-        .withPrimary("id")
-        .withDisplay("name")
-        .create()
-
-      const table = new TableConfig("table")
-        .withRelation("link", otherTable._id)
-        .withField("formula", FieldType.FORMULA)
-        .create()
-
-      const view = new ViewConfig(table)
-        .withVisible("name")
-        .withHidden("amount")
-        .create()
-
-      const result = await buildSqlFieldList(view, allTables, {
-        relationships: true,
-      })
-      expect(result).toEqual(["table.name"])
-    })
-
-    it("does not include relationships columns for hidden links", async () => {
-      const otherTable = new TableConfig("linkedTable")
-        .withField("id", FieldType.NUMBER)
-        .withField("formula", FieldType.FORMULA)
-        .withPrimary("id")
-        .create()
-
-      const table = new TableConfig("table")
-        .withRelation("link", otherTable._id)
-        .create()
-
-      const view = new ViewConfig(table)
-        .withVisible("name")
-        .withHidden("link")
-        .withRelationshipColumns("link", {
-          name: { visible: false },
-          amount: { visible: true },
-          formula: { visible: false },
-        })
-        .create()
-
-      const result = await buildSqlFieldList(view, allTables, {
-        relationships: true,
-      })
-      expect(result).toEqual(["table.name"])
-    })
-
-    it("includes all relationship fields if there is a formula column", async () => {
-      const otherTable = new TableConfig("linkedTable")
-        .withField("id", FieldType.NUMBER)
-        .withField("hidden", FieldType.STRING, { visible: false })
-        .withField("formula", FieldType.FORMULA)
-        .withField("ai", FieldType.AI)
-        .withRelation("link", "otherTableId")
-        .withPrimary("id")
-        .create()
-
-      const table = new TableConfig("table")
-        .withRelation("link", otherTable._id)
-        .withField("formula", FieldType.FORMULA)
-        .create()
-
-      const view = new ViewConfig(table)
-        .withVisible("name")
-        .withVisible("formula")
-        .withHidden("link")
-        .withRelationshipColumns("link", {
-          name: { visible: false },
-          amount: { visible: true },
-          formula: { visible: false },
-        })
-        .create()
-
-      const result = await buildSqlFieldList(view, allTables, {
-        relationships: true,
-      })
-      expect(result).toEqual([
-        "table.name",
-        "table.description",
-        "table.amount",
-        "linkedTable.name",
-        "linkedTable.description",
-        "linkedTable.amount",
-        "linkedTable.id",
-        "linkedTable.hidden",
-      ])
-    })
-  })
-
-  describe("calculation view", () => {
-    it("does not include calculation fields", async () => {
-      const view = new ViewConfig(new TableConfig("table").create())
-        .withCalculation("average", "amount", CalculationType.AVG)
-
-        .create()
-
-      const result = await buildSqlFieldList(view, {})
-      expect(result).toEqual([])
-    })
-
-    it("includes visible fields calculation fields", async () => {
-      const view = new ViewConfig(new TableConfig("table").create())
-        .withCalculation("average", "amount", CalculationType.AVG)
-        .withHidden("name")
-        .withVisible("amount")
-
-        .create()
-
-      const result = await buildSqlFieldList(view, {})
-      expect(result).toEqual(["table.amount"])
-    })
-  })
+const descriptions = datasourceDescribe({
+  only: [DatabaseName.POSTGRES],
 })
+
+if (descriptions.length) {
+  describe.each(descriptions)(
+    "buildSqlFieldList ($dbName)",
+    ({ config, dsProvider }) => {
+      let allTables: Record<string, Table>
+      let datasource: Datasource
+
+      beforeEach(async () => {
+        const ds = await dsProvider()
+        datasource = ds.datasource!
+        allTables = {}
+      })
+
+      class TableConfig {
+        private _table: Table
+
+        constructor(name: string) {
+          this._table = {
+            ...structures.tableForDatasource(datasource),
+            name,
+            schema: {
+              name: {
+                name: "name",
+                type: FieldType.STRING,
+              },
+              description: {
+                name: "description",
+                type: FieldType.STRING,
+              },
+              amount: {
+                name: "amount",
+                type: FieldType.NUMBER,
+              },
+            },
+          }
+        }
+
+        withHiddenField(field: string) {
+          this._table.schema[field].visible = false
+          return this
+        }
+
+        withField(
+          name: string,
+          type:
+            | FieldType.STRING
+            | FieldType.NUMBER
+            | FieldType.FORMULA
+            | FieldType.AI,
+          options?: { visible: boolean }
+        ) {
+          switch (type) {
+            case FieldType.NUMBER:
+            case FieldType.STRING:
+              this._table.schema[name] = {
+                name,
+                type,
+                ...options,
+              }
+              break
+            case FieldType.FORMULA:
+              this._table.schema[name] = {
+                name,
+                type,
+                formula: "any",
+                ...options,
+              }
+              break
+            case FieldType.AI:
+              this._table.schema[name] = {
+                name,
+                type,
+                operation: AIOperationEnum.PROMPT,
+                ...options,
+              }
+              break
+            default:
+              utils.unreachable(type)
+          }
+          return this
+        }
+
+        withRelation(name: string, toTableId: string) {
+          this._table.schema[name] = {
+            name,
+            type: FieldType.LINK,
+            relationshipType: RelationshipType.ONE_TO_MANY,
+            fieldName: "link",
+            foreignKey: "link",
+            tableId: toTableId,
+          }
+          return this
+        }
+
+        withPrimary(field: string) {
+          this._table.primary = [field]
+          return this
+        }
+
+        withDisplay(field: string) {
+          this._table.primaryDisplay = field
+          return this
+        }
+
+        async create() {
+          const table = await config.api.table.save(this._table)
+          allTables[table.name] = table
+          return table
+        }
+      }
+
+      class ViewConfig {
+        private _view: ViewV2
+
+        constructor(table: Table) {
+          this._view = {
+            version: 2,
+            id: generateViewID(table._id!),
+            name: generator.word(),
+            tableId: table._id!,
+          }
+        }
+
+        withVisible(field: string) {
+          this._view.schema ??= {}
+          this._view.schema[field] ??= {}
+          this._view.schema[field].visible = true
+          return this
+        }
+
+        withHidden(field: string) {
+          this._view.schema ??= {}
+          this._view.schema[field] ??= {}
+          this._view.schema[field].visible = false
+          return this
+        }
+
+        withRelationshipColumns(
+          field: string,
+          columns: Record<string, { visible: boolean }>
+        ) {
+          this._view.schema ??= {}
+          this._view.schema[field] ??= {}
+          this._view.schema[field].columns = columns
+          return this
+        }
+
+        withCalculation(
+          name: string,
+          field: string,
+          calculationType: CalculationType
+        ) {
+          this._view.type = ViewV2Type.CALCULATION
+          this._view.schema ??= {}
+          this._view.schema[name] = {
+            field,
+            calculationType,
+            visible: true,
+          }
+          return this
+        }
+
+        async create() {
+          return await config.api.viewV2.create(this._view)
+        }
+      }
+
+      const buildSqlFieldListInApp: typeof buildSqlFieldList = async (
+        table,
+        allTables,
+        opts
+      ) => {
+        return context.doInAppContext(config.getAppId(), () =>
+          buildSqlFieldList(table, allTables, opts)
+        )
+      }
+
+      describe("table", () => {
+        it("extracts fields from table schema", async () => {
+          const table = await new TableConfig("table").create()
+          const result = await buildSqlFieldListInApp(table, {})
+          expect(result).toEqual([
+            "table.name",
+            "table.description",
+            "table.amount",
+            "table.id",
+          ])
+        })
+
+        it("excludes hidden fields", async () => {
+          const table = await new TableConfig("table")
+            .withHiddenField("description")
+            .create()
+          const result = await buildSqlFieldListInApp(table, {})
+          expect(result).toEqual(["table.name", "table.amount", "table.id"])
+        })
+
+        it("excludes non-sql fields fields", async () => {
+          const table = await new TableConfig("table")
+            .withField("formula", FieldType.FORMULA)
+            .withField("ai", FieldType.AI)
+            .create()
+
+          const result = await buildSqlFieldListInApp(table, {})
+          expect(result).toEqual([
+            "table.name",
+            "table.description",
+            "table.amount",
+            "table.id",
+          ])
+        })
+
+        it("includes hidden fields if there is a formula column", async () => {
+          const table = await new TableConfig("table")
+            .withHiddenField("description")
+            .withField("formula", FieldType.FORMULA)
+            .create()
+
+          const result = await buildSqlFieldListInApp(table, {})
+          expect(result).toEqual([
+            "table.name",
+            "table.description",
+            "table.amount",
+            "table.id",
+          ])
+        })
+
+        it("includes relationships fields when flagged", async () => {
+          const otherTable = await new TableConfig("linkedTable")
+            .withField("id", FieldType.NUMBER)
+            .withPrimary("id")
+            .withDisplay("name")
+            .create()
+
+          const table = await new TableConfig("table")
+            .withRelation("link", otherTable._id!)
+            .create()
+
+          const result = await buildSqlFieldListInApp(table, allTables, {
+            relationships: true,
+          })
+          expect(result).toEqual([
+            "table.name",
+            "table.description",
+            "table.amount",
+            "table.id",
+            "linkedTable.id",
+            "linkedTable.name",
+          ])
+        })
+
+        it("includes all relationship fields if there is a formula column", async () => {
+          const otherTable = await new TableConfig("linkedTable")
+            .withField("hidden", FieldType.STRING, { visible: false })
+            .create()
+
+          const table = await new TableConfig("table")
+            .withRelation("link", otherTable._id!)
+            .withField("formula", FieldType.FORMULA)
+            .create()
+
+          const result = await buildSqlFieldListInApp(table, allTables, {
+            relationships: true,
+          })
+          expect(result).toEqual([
+            "table.name",
+            "table.description",
+            "table.amount",
+            "table.id",
+            "linkedTable.name",
+            "linkedTable.description",
+            "linkedTable.amount",
+            "linkedTable.hidden",
+            "linkedTable.id",
+          ])
+        })
+
+        it("never includes non-sql columns from relationships", async () => {
+          const otherTable = await new TableConfig("linkedTable")
+            .withField("hidden", FieldType.STRING, { visible: false })
+            .withField("formula", FieldType.FORMULA)
+            .withField("ai", FieldType.AI)
+            .create()
+
+          const table = await new TableConfig("table")
+            .withRelation("link", otherTable._id!)
+            .withField("formula", FieldType.FORMULA)
+            .create()
+
+          const result = await buildSqlFieldListInApp(table, allTables, {
+            relationships: true,
+          })
+          expect(result).toEqual([
+            "table.name",
+            "table.description",
+            "table.amount",
+            "table.id",
+            "linkedTable.name",
+            "linkedTable.description",
+            "linkedTable.amount",
+            "linkedTable.hidden",
+            "linkedTable.id",
+          ])
+        })
+      })
+
+      describe("view", () => {
+        it("extracts fields from table schema", async () => {
+          const view = await new ViewConfig(
+            await new TableConfig("table").create()
+          )
+            .withVisible("amount")
+            .withHidden("name")
+            .create()
+
+          const result = await buildSqlFieldListInApp(view, {})
+          expect(result).toEqual(["table.amount", "table.id"])
+        })
+
+        it("includes all fields if there is a formula column", async () => {
+          const table = await new TableConfig("table")
+            .withField("formula", FieldType.FORMULA)
+            .create()
+          const view = await new ViewConfig(table)
+            .withHidden("name")
+            .withVisible("amount")
+            .withVisible("formula")
+            .create()
+
+          const result = await buildSqlFieldListInApp(view, {})
+          expect(result).toEqual([
+            "table.name",
+            "table.description",
+            "table.amount",
+            "table.id",
+          ])
+        })
+
+        it("does not includes all fields if the formula column is not included", async () => {
+          const table = await new TableConfig("table")
+            .withField("formula", FieldType.FORMULA)
+            .create()
+          const view = await new ViewConfig(table)
+            .withHidden("name")
+            .withVisible("amount")
+            .withHidden("formula")
+            .create()
+
+          const result = await buildSqlFieldListInApp(view, {})
+          expect(result).toEqual(["table.amount", "table.id"])
+        })
+
+        it("includes relationships columns", async () => {
+          const otherTable = await new TableConfig("linkedTable")
+            .withField("id", FieldType.NUMBER)
+            .withField("formula", FieldType.FORMULA)
+            .withPrimary("id")
+            .create()
+
+          const table = await new TableConfig("table")
+            .withRelation("link", otherTable._id!)
+            .create()
+
+          const view = await new ViewConfig(table)
+            .withVisible("name")
+            .withVisible("link")
+            .withRelationshipColumns("link", {
+              name: { visible: false },
+              amount: { visible: true },
+              formula: { visible: false },
+            })
+            .create()
+
+          const result = await buildSqlFieldListInApp(view, allTables, {
+            relationships: true,
+          })
+          expect(result).toEqual([
+            "table.name",
+            "table.id",
+            "linkedTable.id",
+            "linkedTable.amount",
+          ])
+        })
+
+        it("excludes relationships fields when view is not included in the view", async () => {
+          const otherTable = await new TableConfig("linkedTable")
+            .withField("id", FieldType.NUMBER)
+            .withPrimary("id")
+            .withDisplay("name")
+            .create()
+
+          const table = await new TableConfig("table")
+            .withRelation("link", otherTable._id!)
+            .withField("formula", FieldType.FORMULA)
+            .create()
+
+          const view = await new ViewConfig(table)
+            .withVisible("name")
+            .withHidden("amount")
+            .create()
+
+          const result = await buildSqlFieldListInApp(view, allTables, {
+            relationships: true,
+          })
+          expect(result).toEqual(["table.name", "table.id"])
+        })
+
+        it("does not include relationships columns for hidden links", async () => {
+          const otherTable = await new TableConfig("linkedTable")
+            .withField("id", FieldType.NUMBER)
+            .withField("formula", FieldType.FORMULA)
+            .withPrimary("id")
+            .create()
+
+          const table = await new TableConfig("table")
+            .withRelation("link", otherTable._id!)
+            .create()
+
+          const view = await new ViewConfig(table)
+            .withVisible("name")
+            .withHidden("link")
+            .withRelationshipColumns("link", {
+              name: { visible: false },
+              amount: { visible: true },
+              formula: { visible: false },
+            })
+            .create()
+
+          const result = await buildSqlFieldListInApp(view, allTables, {
+            relationships: true,
+          })
+          expect(result).toEqual(["table.name", "table.id"])
+        })
+
+        it("includes all relationship fields if there is a formula column", async () => {
+          const otherTable = await new TableConfig("linkedTable")
+            .withField("id", FieldType.NUMBER)
+            .withField("hidden", FieldType.STRING, { visible: false })
+            .withField("formula", FieldType.FORMULA)
+            .withField("ai", FieldType.AI)
+            .withPrimary("id")
+            .create()
+
+          const table = await new TableConfig("table")
+            .withRelation("link", otherTable._id!)
+            .withField("formula", FieldType.FORMULA)
+            .create()
+
+          const view = await new ViewConfig(table)
+            .withVisible("name")
+            .withVisible("formula")
+            .withHidden("link")
+            .withRelationshipColumns("link", {
+              name: { visible: false },
+              amount: { visible: true },
+              formula: { visible: false },
+            })
+            .create()
+
+          const result = await buildSqlFieldListInApp(view, allTables, {
+            relationships: true,
+          })
+          expect(result).toEqual([
+            "table.name",
+            "table.description",
+            "table.amount",
+            "table.id",
+            "linkedTable.name",
+            "linkedTable.description",
+            "linkedTable.amount",
+            "linkedTable.id",
+            "linkedTable.hidden",
+          ])
+        })
+      })
+
+      describe("calculation view", () => {
+        it("does not include calculation fields", async () => {
+          const view = await new ViewConfig(
+            await new TableConfig("table").create()
+          )
+            .withCalculation("average", "amount", CalculationType.AVG)
+
+            .create()
+
+          const result = await buildSqlFieldListInApp(view, {})
+          expect(result).toEqual([])
+        })
+
+        it("includes visible fields calculation fields", async () => {
+          const view = await new ViewConfig(
+            await new TableConfig("table").create()
+          )
+            .withCalculation("average", "amount", CalculationType.AVG)
+            .withHidden("name")
+            .withVisible("amount")
+
+            .create()
+
+          const result = await buildSqlFieldListInApp(view, {})
+          expect(result).toEqual(["table.amount"])
+        })
+      })
+    }
+  )
+}
diff --git a/packages/server/src/automations/tests/steps/loop.spec.ts b/packages/server/src/automations/tests/steps/loop.spec.ts
index 883732330f..2bdf33b253 100644
--- a/packages/server/src/automations/tests/steps/loop.spec.ts
+++ b/packages/server/src/automations/tests/steps/loop.spec.ts
@@ -7,6 +7,7 @@ import {
   CreateRowStepOutputs,
   FieldType,
   FilterCondition,
+  AutomationStepStatus,
 } from "@budibase/types"
 import { createAutomationBuilder } from "../utilities/AutomationTestBuilder"
 import TestConfiguration from "../../../tests/utilities/TestConfiguration"
@@ -560,5 +561,25 @@ describe("Attempt to run a basic loop automation", () => {
         status: "stopped",
       })
     })
+
+    it("should not fail if queryRows returns nothing", async () => {
+      const table = await config.api.table.save(basicTable())
+      const results = await createAutomationBuilder(config)
+        .onAppAction()
+        .queryRows({
+          tableId: table._id!,
+        })
+        .loop({
+          option: LoopStepType.ARRAY,
+          binding: "{{ steps.1.rows }}",
+        })
+        .serverLog({ text: "Message {{loop.currentItem}}" })
+        .test({ fields: {} })
+
+      expect(results.steps[1].outputs.success).toBe(true)
+      expect(results.steps[1].outputs.status).toBe(
+        AutomationStepStatus.NO_ITERATIONS
+      )
+    })
   })
 })
diff --git a/packages/server/src/threads/automation.ts b/packages/server/src/threads/automation.ts
index 8b2aac662c..762da1cbc1 100644
--- a/packages/server/src/threads/automation.ts
+++ b/packages/server/src/threads/automation.ts
@@ -68,7 +68,11 @@ function getLoopIterable(step: LoopStep): any[] {
   let input = step.inputs.binding
 
   if (option === LoopStepType.ARRAY && typeof input === "string") {
-    input = JSON.parse(input)
+    if (input === "") {
+      input = []
+    } else {
+      input = JSON.parse(input)
+    }
   }
 
   if (option === LoopStepType.STRING && Array.isArray(input)) {
@@ -492,7 +496,7 @@ class Orchestrator {
       }
 
       const status =
-        iterations === 0 ? AutomationStatus.NO_CONDITION_MET : undefined
+        iterations === 0 ? AutomationStepStatus.NO_ITERATIONS : undefined
       return stepSuccess(stepToLoop, { status, iterations, items })
     })
   }
diff --git a/packages/worker/package.json b/packages/worker/package.json
index 28728272ca..53d14dacee 100644
--- a/packages/worker/package.json
+++ b/packages/worker/package.json
@@ -62,7 +62,6 @@
     "koa-body": "4.2.0",
     "koa-compress": "4.0.1",
     "koa-passport": "4.1.4",
-    "koa-redis": "^4.0.1",
     "koa-send": "5.0.1",
     "koa-session": "5.13.1",
     "koa-static": "5.0.0",
diff --git a/packages/worker/src/api/routes/global/tests/auth.spec.ts b/packages/worker/src/api/routes/global/tests/auth.spec.ts
index f89cb4a027..bff959469e 100644
--- a/packages/worker/src/api/routes/global/tests/auth.spec.ts
+++ b/packages/worker/src/api/routes/global/tests/auth.spec.ts
@@ -311,7 +311,7 @@ describe("/api/global/auth", () => {
       })
     })
 
-    describe.skip("GET /api/global/auth/:tenantId/oidc/callback", () => {
+    describe("GET /api/global/auth/:tenantId/oidc/callback", () => {
       it("logs in", async () => {
         const email = `${generator.guid()}@example.com`
 
diff --git a/packages/worker/src/index.ts b/packages/worker/src/index.ts
index f382aa8a20..0547afab38 100644
--- a/packages/worker/src/index.ts
+++ b/packages/worker/src/index.ts
@@ -4,7 +4,7 @@ if (process.env.DD_APM_ENABLED) {
 
 // need to load environment first
 import env from "./environment"
-import Application, { Middleware } from "koa"
+import Application from "koa"
 import { bootstrap } from "global-agent"
 import * as db from "./db"
 import { sdk as proSdk } from "@budibase/pro"
@@ -20,7 +20,6 @@ import {
   cache,
   features,
 } from "@budibase/backend-core"
-import RedisStore from "koa-redis"
 
 db.init()
 import koaBody from "koa-body"
@@ -53,28 +52,7 @@ app.proxy = true
 app.use(handleScimBody)
 app.use(koaBody({ multipart: true }))
 
-const sessionMiddleware: Middleware = async (ctx: any, next: any) => {
-  const redisClient = await new redis.Client(
-    redis.utils.Databases.SESSIONS
-  ).init()
-  return koaSession(
-    {
-      // @ts-ignore
-      store: new RedisStore({ client: redisClient.getClient() }),
-      key: "koa:sess",
-      maxAge: 86400000, // one day
-      httpOnly: true,
-      secure: process.env.NODE_ENV === "production",
-      sameSite: "strict",
-      rolling: true,
-      renew: true,
-    },
-    app
-  )(ctx, next)
-}
-
-app.use(sessionMiddleware)
-
+app.use(koaSession(app))
 app.use(middleware.correlation)
 app.use(middleware.pino)
 app.use(middleware.ip)
diff --git a/packages/worker/src/koa-redis.d.ts b/packages/worker/src/koa-redis.d.ts
deleted file mode 100644
index ad1b7a46f1..0000000000
--- a/packages/worker/src/koa-redis.d.ts
+++ /dev/null
@@ -1 +0,0 @@
-declare module "koa-redis" {}
diff --git a/scripts/install-minio.sh b/scripts/install-minio.sh
index fede984377..b885453f2a 100755
--- a/scripts/install-minio.sh
+++ b/scripts/install-minio.sh
@@ -1,10 +1,18 @@
 #!/bin/bash
-if [[ $TARGETARCH == arm* ]] ;
-then
+
+if [[ $TARGETBUILD == "aas" ]]; then
+  echo "A aas-compatible version of Minio is already installed."
+  exit 0
+fi
+
+if [[ $TARGETARCH == arm* ]]; then
   echo "INSTALLING ARM64 MINIO"
+  rm -f minio
   wget https://dl.min.io/server/minio/release/linux-arm64/minio
 else
   echo "INSTALLING AMD64 MINIO"
+  rm -f minio
   wget https://dl.min.io/server/minio/release/linux-amd64/minio
 fi
-chmod +x minio
\ No newline at end of file
+
+chmod +x minio
diff --git a/scripts/resources/minio b/scripts/resources/minio
new file mode 100644
index 0000000000..c121cc0963
--- /dev/null
+++ b/scripts/resources/minio
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:63db3aa3c2299ebaf13b46c64523a589bd5bf272f9e971d17f1eaa55f6f1fd79
+size 118595584
diff --git a/yarn.lock b/yarn.lock
index 8f611e224c..ceae41458c 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -2695,13 +2695,6 @@
   dependencies:
     regenerator-runtime "^0.14.0"
 
-"@babel/runtime@^7.8.3":
-  version "7.26.9"
-  resolved "https://registry.yarnpkg.com/@babel/runtime/-/runtime-7.26.9.tgz#aa4c6facc65b9cb3f87d75125ffd47781b475433"
-  integrity sha512-aA63XwOkcl4xxQa3HjPMqOP6LiK0ZDv3mUPYEFXkpHbaFjtGggE1A61FjFzJnB+p7/oy2gA8E+rcBNl/zC1tMg==
-  dependencies:
-    regenerator-runtime "^0.14.0"
-
 "@babel/template@^7.22.15", "@babel/template@^7.22.5", "@babel/template@^7.25.9", "@babel/template@^7.3.3":
   version "7.25.9"
   resolved "https://registry.yarnpkg.com/@babel/template/-/template-7.25.9.tgz#ecb62d81a8a6f5dc5fe8abfc3901fc52ddf15016"
@@ -9048,14 +9041,7 @@ co-body@^5.1.1:
     raw-body "^2.2.0"
     type-is "^1.6.14"
 
-co-wrap-all@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/co-wrap-all/-/co-wrap-all-1.0.0.tgz#370ae3e8333510a53f6b2f7fdfbe4568a11b7ecf"
-  integrity sha512-aru6gLi2vTUazr+MxVm3Rv6ST7/EKtFj9BrfkcOrbCO2Qv6LqJdE71m88HhHiBEviKw/ucVrwoGLrq2xHpOsJA==
-  dependencies:
-    co "^4.0.0"
-
-co@^4.0.0, co@^4.6.0:
+co@^4.6.0:
   version "4.6.0"
   resolved "https://registry.yarnpkg.com/co/-/co-4.6.0.tgz#6ea6bdf3d853ae54ccb8e47bfa0bf3f9031fb184"
   integrity sha512-QVb0dM5HvG+uaxitm8wONl7jltx8dqhfU33DcqtOZcLSVIKSDDLDi7+0LbAKiyI8hD9u42m2YxXSkMGWThaecQ==
@@ -13191,7 +13177,7 @@ ioredis@5.3.2:
     redis-parser "^3.0.0"
     standard-as-callback "^2.1.0"
 
-ioredis@^4.14.1, ioredis@^4.28.5:
+ioredis@^4.28.5:
   version "4.28.5"
   resolved "https://registry.yarnpkg.com/ioredis/-/ioredis-4.28.5.tgz#5c149e6a8d76a7f8fa8a504ffc85b7d5b6797f9f"
   integrity sha512-3GYo0GJtLqgNXj4YhrisLaNNvWSNwSS2wS4OELGfGxH8I69+XfNdnmV1AyN+ZqMh0i7eX+SWjrwFKDBDgfBC1A==
@@ -14691,16 +14677,6 @@ koa-pino-logger@4.0.0:
   dependencies:
     pino-http "^6.5.0"
 
-koa-redis@^4.0.1:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/koa-redis/-/koa-redis-4.0.1.tgz#57ac1b46d9ab851221a9f4952c1e8d4bf289db40"
-  integrity sha512-o2eTVNo1NBnloeUGhHed5Q2ZvJSLpUEj/+E1/7oH5EmH8WuQ+QLdl/VawkshxdFQ47W1p6V09lM3hCTu7D0YnQ==
-  dependencies:
-    "@babel/runtime" "^7.8.3"
-    co-wrap-all "^1.0.0"
-    debug "^4.1.1"
-    ioredis "^4.14.1"
-
 koa-router@^10.0.0:
   version "10.1.1"
   resolved "https://registry.yarnpkg.com/koa-router/-/koa-router-10.1.1.tgz#20809f82648518b84726cd445037813cd99f17ff"