From d4f9822c748244152434608f236a41157e513837 Mon Sep 17 00:00:00 2001
From: Sam Rose <hello@samwho.dev>
Date: Fri, 15 Mar 2024 17:03:47 +0000
Subject: [PATCH 01/24] Move viewV2 tests out of row.spec.ts and into
 viewV2.spec.ts.

---
 .../server/src/api/routes/tests/row.spec.ts   | 653 +-----------------
 .../src/api/routes/tests/viewV2.spec.ts       | 491 ++++++++++++-
 2 files changed, 507 insertions(+), 637 deletions(-)

diff --git a/packages/server/src/api/routes/tests/row.spec.ts b/packages/server/src/api/routes/tests/row.spec.ts
index 854410dcf6..64a156b15a 100644
--- a/packages/server/src/api/routes/tests/row.spec.ts
+++ b/packages/server/src/api/routes/tests/row.spec.ts
@@ -392,6 +392,23 @@ describe.each([
         expect(row.arrayFieldArrayStrKnown).toEqual(["One"])
         expect(row.optsFieldStrKnown).toEqual("Alpha")
       })
+
+    isInternal &&
+      it("doesn't allow creating in user table", async () => {
+        const userTableId = InternalTable.USER_METADATA
+        const response = await config.api.row.save(
+          userTableId,
+          {
+            tableId: userTableId,
+            firstName: "Joe",
+            lastName: "Joe",
+            email: "joe@joe.com",
+            roles: {},
+          },
+          { status: 400 }
+        )
+        expect(response.message).toBe("Cannot create new user entry.")
+      })
   })
 
   describe("get", () => {
@@ -890,642 +907,6 @@ describe.each([
     })
   })
 
-  describe("view 2.0", () => {
-    async function userTable(): Promise<Table> {
-      return saveTableRequest({
-        name: `users_${uuid.v4()}`,
-        type: "table",
-        schema: {
-          name: {
-            type: FieldType.STRING,
-            name: "name",
-          },
-          surname: {
-            type: FieldType.STRING,
-            name: "surname",
-          },
-          age: {
-            type: FieldType.NUMBER,
-            name: "age",
-          },
-          address: {
-            type: FieldType.STRING,
-            name: "address",
-          },
-          jobTitle: {
-            type: FieldType.STRING,
-            name: "jobTitle",
-          },
-        },
-      })
-    }
-
-    const randomRowData = () => ({
-      name: generator.first(),
-      surname: generator.last(),
-      age: generator.age(),
-      address: generator.address(),
-      jobTitle: generator.word(),
-    })
-
-    describe("create", () => {
-      it("should persist a new row with only the provided view fields", async () => {
-        const table = await config.api.table.save(await userTable())
-        const view = await config.api.viewV2.create({
-          tableId: table._id!,
-          name: generator.guid(),
-          schema: {
-            name: { visible: true },
-            surname: { visible: true },
-            address: { visible: true },
-          },
-        })
-
-        const data = randomRowData()
-        const newRow = await config.api.row.save(view.id, {
-          tableId: table!._id,
-          _viewId: view.id,
-          ...data,
-        })
-
-        const row = await config.api.row.get(table._id!, newRow._id!)
-        expect(row).toEqual({
-          name: data.name,
-          surname: data.surname,
-          address: data.address,
-          tableId: table!._id,
-          _id: newRow._id,
-          _rev: newRow._rev,
-          id: newRow.id,
-          ...defaultRowFields,
-        })
-        expect(row._viewId).toBeUndefined()
-        expect(row.age).toBeUndefined()
-        expect(row.jobTitle).toBeUndefined()
-      })
-    })
-
-    describe("patch", () => {
-      it("should update only the view fields for a row", async () => {
-        const table = await config.api.table.save(await userTable())
-        const tableId = table._id!
-        const view = await config.api.viewV2.create({
-          tableId: tableId,
-          name: generator.guid(),
-          schema: {
-            name: { visible: true },
-            address: { visible: true },
-          },
-        })
-
-        const newRow = await config.api.row.save(view.id, {
-          tableId,
-          _viewId: view.id,
-          ...randomRowData(),
-        })
-        const newData = randomRowData()
-        await config.api.row.patch(view.id, {
-          tableId,
-          _viewId: view.id,
-          _id: newRow._id!,
-          _rev: newRow._rev!,
-          ...newData,
-        })
-
-        const row = await config.api.row.get(tableId, newRow._id!)
-        expect(row).toEqual({
-          ...newRow,
-          name: newData.name,
-          address: newData.address,
-          _id: newRow._id,
-          _rev: expect.any(String),
-          id: newRow.id,
-          ...defaultRowFields,
-        })
-        expect(row._viewId).toBeUndefined()
-        expect(row.age).toBeUndefined()
-        expect(row.jobTitle).toBeUndefined()
-      })
-    })
-
-    describe("destroy", () => {
-      it("should be able to delete a row", async () => {
-        const table = await config.api.table.save(await userTable())
-        const tableId = table._id!
-        const view = await config.api.viewV2.create({
-          tableId: tableId,
-          name: generator.guid(),
-          schema: {
-            name: { visible: true },
-            address: { visible: true },
-          },
-        })
-
-        const createdRow = await config.api.row.save(table._id!, {})
-        const rowUsage = await getRowUsage()
-
-        await config.api.row.bulkDelete(view.id, { rows: [createdRow] })
-
-        await assertRowUsage(rowUsage - 1)
-
-        await config.api.row.get(tableId, createdRow._id!, {
-          status: 404,
-        })
-      })
-
-      it("should be able to delete multiple rows", async () => {
-        const table = await config.api.table.save(await userTable())
-        const tableId = table._id!
-        const view = await config.api.viewV2.create({
-          tableId: tableId,
-          name: generator.guid(),
-          schema: {
-            name: { visible: true },
-            address: { visible: true },
-          },
-        })
-
-        const rows = await Promise.all([
-          config.api.row.save(table._id!, {}),
-          config.api.row.save(table._id!, {}),
-          config.api.row.save(table._id!, {}),
-        ])
-        const rowUsage = await getRowUsage()
-
-        await config.api.row.bulkDelete(view.id, { rows: [rows[0], rows[2]] })
-
-        await assertRowUsage(rowUsage - 2)
-
-        await config.api.row.get(tableId, rows[0]._id!, {
-          status: 404,
-        })
-        await config.api.row.get(tableId, rows[2]._id!, {
-          status: 404,
-        })
-        await config.api.row.get(tableId, rows[1]._id!, { status: 200 })
-      })
-    })
-
-    describe("view search", () => {
-      let table: Table
-      const viewSchema = { age: { visible: true }, name: { visible: true } }
-
-      beforeAll(async () => {
-        table = await config.api.table.save(
-          saveTableRequest({
-            name: `users_${uuid.v4()}`,
-            schema: {
-              name: {
-                type: FieldType.STRING,
-                name: "name",
-                constraints: { type: "string" },
-              },
-              age: {
-                type: FieldType.NUMBER,
-                name: "age",
-                constraints: {},
-              },
-            },
-          })
-        )
-      })
-
-      it("returns empty rows from view when no schema is passed", async () => {
-        const rows = await Promise.all(
-          Array.from({ length: 10 }, () =>
-            config.api.row.save(table._id!, { tableId: table._id })
-          )
-        )
-
-        const createViewResponse = await config.api.viewV2.create({
-          tableId: table._id!,
-          name: generator.guid(),
-        })
-        const response = await config.api.viewV2.search(createViewResponse.id)
-
-        expect(response.rows).toHaveLength(10)
-        expect(response).toEqual({
-          rows: expect.arrayContaining(
-            rows.map(r => ({
-              _viewId: createViewResponse.id,
-              tableId: table._id,
-              _id: r._id,
-              _rev: r._rev,
-              ...defaultRowFields,
-            }))
-          ),
-          ...(isInternal
-            ? {}
-            : {
-                hasNextPage: false,
-                bookmark: null,
-              }),
-        })
-      })
-
-      it("searching respects the view filters", async () => {
-        await Promise.all(
-          Array.from({ length: 10 }, () =>
-            config.api.row.save(table._id!, {
-              tableId: table._id,
-              name: generator.name(),
-              age: generator.integer({ min: 10, max: 30 }),
-            })
-          )
-        )
-
-        const expectedRows = await Promise.all(
-          Array.from({ length: 5 }, () =>
-            config.api.row.save(table._id!, {
-              tableId: table._id,
-              name: generator.name(),
-              age: 40,
-            })
-          )
-        )
-
-        const createViewResponse = await config.api.viewV2.create({
-          tableId: table._id!,
-          name: generator.guid(),
-          query: [
-            { operator: SearchQueryOperators.EQUAL, field: "age", value: 40 },
-          ],
-          schema: viewSchema,
-        })
-
-        const response = await config.api.viewV2.search(createViewResponse.id)
-
-        expect(response.rows).toHaveLength(5)
-        expect(response).toEqual({
-          rows: expect.arrayContaining(
-            expectedRows.map(r => ({
-              _viewId: createViewResponse.id,
-              tableId: table._id,
-              name: r.name,
-              age: r.age,
-              _id: r._id,
-              _rev: r._rev,
-              ...defaultRowFields,
-            }))
-          ),
-          ...(isInternal
-            ? {}
-            : {
-                hasNextPage: false,
-                bookmark: null,
-              }),
-        })
-      })
-
-      const sortTestOptions: [
-        {
-          field: string
-          order?: SortOrder
-          type?: SortType
-        },
-        string[]
-      ][] = [
-        [
-          {
-            field: "name",
-            order: SortOrder.ASCENDING,
-            type: SortType.STRING,
-          },
-          ["Alice", "Bob", "Charly", "Danny"],
-        ],
-        [
-          {
-            field: "name",
-          },
-          ["Alice", "Bob", "Charly", "Danny"],
-        ],
-        [
-          {
-            field: "name",
-            order: SortOrder.DESCENDING,
-          },
-          ["Danny", "Charly", "Bob", "Alice"],
-        ],
-        [
-          {
-            field: "name",
-            order: SortOrder.DESCENDING,
-            type: SortType.STRING,
-          },
-          ["Danny", "Charly", "Bob", "Alice"],
-        ],
-        [
-          {
-            field: "age",
-            order: SortOrder.ASCENDING,
-            type: SortType.number,
-          },
-          ["Danny", "Alice", "Charly", "Bob"],
-        ],
-        [
-          {
-            field: "age",
-            order: SortOrder.ASCENDING,
-          },
-          ["Danny", "Alice", "Charly", "Bob"],
-        ],
-        [
-          {
-            field: "age",
-            order: SortOrder.DESCENDING,
-          },
-          ["Bob", "Charly", "Alice", "Danny"],
-        ],
-        [
-          {
-            field: "age",
-            order: SortOrder.DESCENDING,
-            type: SortType.number,
-          },
-          ["Bob", "Charly", "Alice", "Danny"],
-        ],
-      ]
-
-      describe("sorting", () => {
-        let table: Table
-        beforeAll(async () => {
-          table = await config.api.table.save(await userTable())
-          const users = [
-            { name: "Alice", age: 25 },
-            { name: "Bob", age: 30 },
-            { name: "Charly", age: 27 },
-            { name: "Danny", age: 15 },
-          ]
-          await Promise.all(
-            users.map(u =>
-              config.api.row.save(table._id!, {
-                tableId: table._id,
-                ...u,
-              })
-            )
-          )
-        })
-
-        it.each(sortTestOptions)(
-          "allow sorting (%s)",
-          async (sortParams, expected) => {
-            const createViewResponse = await config.api.viewV2.create({
-              tableId: table._id!,
-              name: generator.guid(),
-              sort: sortParams,
-              schema: viewSchema,
-            })
-
-            const response = await config.api.viewV2.search(
-              createViewResponse.id
-            )
-
-            expect(response.rows).toHaveLength(4)
-            expect(response.rows).toEqual(
-              expected.map(name => expect.objectContaining({ name }))
-            )
-          }
-        )
-
-        it.each(sortTestOptions)(
-          "allow override the default view sorting (%s)",
-          async (sortParams, expected) => {
-            const createViewResponse = await config.api.viewV2.create({
-              tableId: table._id!,
-              name: generator.guid(),
-              sort: {
-                field: "name",
-                order: SortOrder.ASCENDING,
-                type: SortType.STRING,
-              },
-              schema: viewSchema,
-            })
-
-            const response = await config.api.viewV2.search(
-              createViewResponse.id,
-              {
-                sort: sortParams.field,
-                sortOrder: sortParams.order,
-                sortType: sortParams.type,
-                query: {},
-              }
-            )
-
-            expect(response.rows).toHaveLength(4)
-            expect(response.rows).toEqual(
-              expected.map(name => expect.objectContaining({ name }))
-            )
-          }
-        )
-      })
-
-      it("when schema is defined, defined columns and row attributes are returned", async () => {
-        const table = await config.api.table.save(await userTable())
-        const rows = await Promise.all(
-          Array.from({ length: 10 }, () =>
-            config.api.row.save(table._id!, {
-              tableId: table._id,
-              name: generator.name(),
-              age: generator.age(),
-            })
-          )
-        )
-
-        const view = await config.api.viewV2.create({
-          tableId: table._id!,
-          name: generator.guid(),
-          schema: { name: { visible: true } },
-        })
-        const response = await config.api.viewV2.search(view.id)
-
-        expect(response.rows).toHaveLength(10)
-        expect(response.rows).toEqual(
-          expect.arrayContaining(
-            rows.map(r => ({
-              ...(isInternal
-                ? expectAnyInternalColsAttributes
-                : expectAnyExternalColsAttributes),
-              _viewId: view.id,
-              name: r.name,
-            }))
-          )
-        )
-      })
-
-      it("views without data can be returned", async () => {
-        const table = await config.api.table.save(await userTable())
-        const createViewResponse = await config.api.viewV2.create({
-          tableId: table._id!,
-          name: generator.guid(),
-        })
-        const response = await config.api.viewV2.search(createViewResponse.id)
-        expect(response.rows).toHaveLength(0)
-      })
-
-      it("respects the limit parameter", async () => {
-        const table = await config.api.table.save(await userTable())
-        await Promise.all(
-          Array.from({ length: 10 }, () => config.api.row.save(table._id!, {}))
-        )
-
-        const limit = generator.integer({ min: 1, max: 8 })
-
-        const createViewResponse = await config.api.viewV2.create({
-          tableId: table._id!,
-          name: generator.guid(),
-        })
-        const response = await config.api.viewV2.search(createViewResponse.id, {
-          limit,
-          query: {},
-        })
-
-        expect(response.rows).toHaveLength(limit)
-      })
-
-      it("can handle pagination", async () => {
-        const table = await config.api.table.save(await userTable())
-        await Promise.all(
-          Array.from({ length: 10 }, () => config.api.row.save(table._id!, {}))
-        )
-        const view = await config.api.viewV2.create({
-          tableId: table._id!,
-          name: generator.guid(),
-        })
-        const rows = (await config.api.viewV2.search(view.id)).rows
-
-        const page1 = await config.api.viewV2.search(view.id, {
-          paginate: true,
-          limit: 4,
-          query: {},
-        })
-        expect(page1).toEqual({
-          rows: expect.arrayContaining(rows.slice(0, 4)),
-          totalRows: isInternal ? 10 : undefined,
-          hasNextPage: true,
-          bookmark: expect.anything(),
-        })
-
-        const page2 = await config.api.viewV2.search(view.id, {
-          paginate: true,
-          limit: 4,
-          bookmark: page1.bookmark,
-
-          query: {},
-        })
-        expect(page2).toEqual({
-          rows: expect.arrayContaining(rows.slice(4, 8)),
-          totalRows: isInternal ? 10 : undefined,
-          hasNextPage: true,
-          bookmark: expect.anything(),
-        })
-
-        const page3 = await config.api.viewV2.search(view.id, {
-          paginate: true,
-          limit: 4,
-          bookmark: page2.bookmark,
-          query: {},
-        })
-        expect(page3).toEqual({
-          rows: expect.arrayContaining(rows.slice(8)),
-          totalRows: isInternal ? 10 : undefined,
-          hasNextPage: false,
-          bookmark: expect.anything(),
-        })
-      })
-
-      isInternal &&
-        it("doesn't allow creating in user table", async () => {
-          const userTableId = InternalTable.USER_METADATA
-          const response = await config.api.row.save(
-            userTableId,
-            {
-              tableId: userTableId,
-              firstName: "Joe",
-              lastName: "Joe",
-              email: "joe@joe.com",
-              roles: {},
-            },
-            { status: 400 }
-          )
-          expect(response.message).toBe("Cannot create new user entry.")
-        })
-
-      describe("permissions", () => {
-        let table: Table
-        let view: ViewV2
-
-        beforeAll(async () => {
-          table = await config.api.table.save(await userTable())
-          await Promise.all(
-            Array.from({ length: 10 }, () =>
-              config.api.row.save(table._id!, {})
-            )
-          )
-
-          view = await config.api.viewV2.create({
-            tableId: table._id!,
-            name: generator.guid(),
-          })
-        })
-
-        beforeEach(() => {
-          mocks.licenses.useViewPermissions()
-        })
-
-        it("does not allow public users to fetch by default", async () => {
-          await config.publish()
-          await config.api.viewV2.publicSearch(view.id, undefined, {
-            status: 403,
-          })
-        })
-
-        it("allow public users to fetch when permissions are explicit", async () => {
-          await config.api.permission.add({
-            roleId: roles.BUILTIN_ROLE_IDS.PUBLIC,
-            level: PermissionLevel.READ,
-            resourceId: view.id,
-          })
-          await config.publish()
-
-          const response = await config.api.viewV2.publicSearch(view.id)
-
-          expect(response.rows).toHaveLength(10)
-        })
-
-        it("allow public users to fetch when permissions are inherited", async () => {
-          await config.api.permission.add({
-            roleId: roles.BUILTIN_ROLE_IDS.PUBLIC,
-            level: PermissionLevel.READ,
-            resourceId: table._id!,
-          })
-          await config.publish()
-
-          const response = await config.api.viewV2.publicSearch(view.id)
-
-          expect(response.rows).toHaveLength(10)
-        })
-
-        it("respects inherited permissions, not allowing not public views from public tables", async () => {
-          await config.api.permission.add({
-            roleId: roles.BUILTIN_ROLE_IDS.PUBLIC,
-            level: PermissionLevel.READ,
-            resourceId: table._id!,
-          })
-          await config.api.permission.add({
-            roleId: roles.BUILTIN_ROLE_IDS.POWER,
-            level: PermissionLevel.READ,
-            resourceId: view.id,
-          })
-          await config.publish()
-
-          await config.api.viewV2.publicSearch(view.id, undefined, {
-            status: 403,
-          })
-        })
-      })
-    })
-  })
-
   let o2mTable: Table
   let m2mTable: Table
   beforeAll(async () => {
diff --git a/packages/server/src/api/routes/tests/viewV2.spec.ts b/packages/server/src/api/routes/tests/viewV2.spec.ts
index ded5e08d29..9c53ade52e 100644
--- a/packages/server/src/api/routes/tests/viewV2.spec.ts
+++ b/packages/server/src/api/routes/tests/viewV2.spec.ts
@@ -5,20 +5,25 @@ import {
   FieldSchema,
   FieldType,
   INTERNAL_TABLE_SOURCE_ID,
+  PermissionLevel,
+  QuotaUsageType,
   SaveTableRequest,
   SearchQueryOperators,
   SortOrder,
   SortType,
+  StaticQuotaName,
   Table,
   TableSourceType,
   UIFieldMetadata,
   UpdateViewRequest,
   ViewV2,
 } from "@budibase/types"
-import { generator } from "@budibase/backend-core/tests"
+import { generator, mocks } from "@budibase/backend-core/tests"
 import * as uuid from "uuid"
 import { databaseTestProviders } from "../../../integrations/tests/utils"
 import merge from "lodash/merge"
+import { quotas } from "@budibase/pro"
+import { roles } from "@budibase/backend-core"
 
 jest.unmock("mysql2")
 jest.unmock("mysql2/promise")
@@ -33,6 +38,7 @@ describe.each([
   ["mariadb", databaseTestProviders.mariadb],
 ])("/v2/views (%s)", (_, dsProvider) => {
   const config = setup.getConfig()
+  const isInternal = !dsProvider
 
   let table: Table
   let datasource: Datasource
@@ -99,6 +105,18 @@ describe.each([
     setup.afterAll()
   })
 
+  const getRowUsage = async () => {
+    const { total } = await config.doInContext(undefined, () =>
+      quotas.getCurrentUsageValues(QuotaUsageType.STATIC, StaticQuotaName.ROWS)
+    )
+    return total
+  }
+
+  const assertRowUsage = async (expected: number) => {
+    const usage = await getRowUsage()
+    expect(usage).toBe(expected)
+  }
+
   describe("create", () => {
     it("persist the view when the view is successfully created", async () => {
       const newView: CreateViewRequest = {
@@ -525,4 +543,475 @@ describe.each([
       expect(row.Country).toEqual("Aussy")
     })
   })
+
+  describe.only("row operations", () => {
+    let table: Table, view: ViewV2
+    beforeEach(async () => {
+      table = await config.api.table.save(
+        saveTableRequest({
+          schema: {
+            one: { type: FieldType.STRING, name: "one" },
+            two: { type: FieldType.STRING, name: "two" },
+          },
+        })
+      )
+      view = await config.api.viewV2.create({
+        tableId: table._id!,
+        name: generator.guid(),
+        schema: {
+          two: { visible: true },
+        },
+      })
+    })
+
+    describe("create", () => {
+      it("should persist a new row with only the provided view fields", async () => {
+        const newRow = await config.api.row.save(view.id, {
+          tableId: table!._id,
+          _viewId: view.id,
+          one: "foo",
+          two: "bar",
+        })
+
+        const row = await config.api.row.get(table._id!, newRow._id!)
+        expect(row.one).toBeUndefined()
+        expect(row.two).toEqual("bar")
+      })
+    })
+
+    describe("patch", () => {
+      it("should update only the view fields for a row", async () => {
+        const newRow = await config.api.row.save(table._id!, {
+          one: "foo",
+          two: "bar",
+        })
+        await config.api.row.patch(view.id, {
+          tableId: table._id!,
+          _id: newRow._id!,
+          _rev: newRow._rev!,
+          one: "newFoo",
+          two: "newBar",
+        })
+
+        const row = await config.api.row.get(table._id!, newRow._id!)
+        expect(row.one).toEqual("foo")
+        expect(row.two).toEqual("newBar")
+      })
+    })
+
+    describe("destroy", () => {
+      it("should be able to delete a row", async () => {
+        const createdRow = await config.api.row.save(table._id!, {})
+        const rowUsage = await getRowUsage()
+        await config.api.row.bulkDelete(view.id, { rows: [createdRow] })
+        await assertRowUsage(rowUsage - 1)
+        await config.api.row.get(table._id!, createdRow._id!, {
+          status: 404,
+        })
+      })
+
+      it("should be able to delete multiple rows", async () => {
+        const rows = await Promise.all([
+          config.api.row.save(table._id!, {}),
+          config.api.row.save(table._id!, {}),
+          config.api.row.save(table._id!, {}),
+        ])
+        const rowUsage = await getRowUsage()
+
+        await config.api.row.bulkDelete(view.id, { rows: [rows[0], rows[2]] })
+
+        await assertRowUsage(rowUsage - 2)
+
+        await config.api.row.get(table._id!, rows[0]._id!, {
+          status: 404,
+        })
+        await config.api.row.get(table._id!, rows[2]._id!, {
+          status: 404,
+        })
+        await config.api.row.get(table._id!, rows[1]._id!, { status: 200 })
+      })
+    })
+
+    describe("search", () => {
+      it("returns empty rows from view when no schema is passed", async () => {
+        const rows = await Promise.all(
+          Array.from({ length: 10 }, () => config.api.row.save(table._id!, {}))
+        )
+        const response = await config.api.viewV2.search(view.id)
+        expect(response.rows).toHaveLength(10)
+        expect(response).toEqual({
+          rows: expect.arrayContaining(
+            rows.map(r => ({
+              _viewId: view.id,
+              tableId: table._id,
+              _id: r._id,
+              _rev: r._rev,
+              ...(isInternal
+                ? {
+                    type: "row",
+                    updatedAt: expect.any(String),
+                    createdAt: expect.any(String),
+                  }
+                : {}),
+            }))
+          ),
+          ...(isInternal
+            ? {}
+            : {
+                hasNextPage: false,
+                bookmark: null,
+              }),
+        })
+      })
+
+      it("searching respects the view filters", async () => {
+        await config.api.row.save(table._id!, {
+          one: "foo",
+          two: "bar",
+        })
+        const two = await config.api.row.save(table._id!, {
+          one: "foo2",
+          two: "bar2",
+        })
+
+        const view = await config.api.viewV2.create({
+          tableId: table._id!,
+          name: generator.guid(),
+          query: [
+            {
+              operator: SearchQueryOperators.EQUAL,
+              field: "two",
+              value: "bar2",
+            },
+          ],
+          schema: {
+            two: { visible: true },
+          },
+        })
+
+        const response = await config.api.viewV2.search(view.id)
+        expect(response.rows).toHaveLength(1)
+        expect(response).toEqual({
+          rows: expect.arrayContaining([
+            {
+              _viewId: view.id,
+              tableId: table._id,
+              two: two.two,
+              _id: two._id,
+              _rev: two._rev,
+              ...(isInternal
+                ? {
+                    type: "row",
+                    createdAt: expect.any(String),
+                    updatedAt: expect.any(String),
+                  }
+                : {}),
+            },
+          ]),
+          ...(isInternal
+            ? {}
+            : {
+                hasNextPage: false,
+                bookmark: null,
+              }),
+        })
+      })
+
+      it("views without data can be returned", async () => {
+        const response = await config.api.viewV2.search(view.id)
+        expect(response.rows).toHaveLength(0)
+      })
+
+      it("respects the limit parameter", async () => {
+        await Promise.all(
+          Array.from({ length: 10 }, () => config.api.row.save(table._id!, {}))
+        )
+        const limit = generator.integer({ min: 1, max: 8 })
+        const response = await config.api.viewV2.search(view.id, {
+          limit,
+          query: {},
+        })
+        expect(response.rows).toHaveLength(limit)
+      })
+
+      it("can handle pagination", async () => {
+        await Promise.all(
+          Array.from({ length: 10 }, () => config.api.row.save(table._id!, {}))
+        )
+        const rows = (await config.api.viewV2.search(view.id)).rows
+
+        const page1 = await config.api.viewV2.search(view.id, {
+          paginate: true,
+          limit: 4,
+          query: {},
+        })
+        expect(page1).toEqual({
+          rows: expect.arrayContaining(rows.slice(0, 4)),
+          totalRows: isInternal ? 10 : undefined,
+          hasNextPage: true,
+          bookmark: expect.anything(),
+        })
+
+        const page2 = await config.api.viewV2.search(view.id, {
+          paginate: true,
+          limit: 4,
+          bookmark: page1.bookmark,
+          query: {},
+        })
+        expect(page2).toEqual({
+          rows: expect.arrayContaining(rows.slice(4, 8)),
+          totalRows: isInternal ? 10 : undefined,
+          hasNextPage: true,
+          bookmark: expect.anything(),
+        })
+
+        const page3 = await config.api.viewV2.search(view.id, {
+          paginate: true,
+          limit: 4,
+          bookmark: page2.bookmark,
+          query: {},
+        })
+        expect(page3).toEqual({
+          rows: expect.arrayContaining(rows.slice(8)),
+          totalRows: isInternal ? 10 : undefined,
+          hasNextPage: false,
+          bookmark: expect.anything(),
+        })
+      })
+
+      const sortTestOptions: [
+        {
+          field: string
+          order?: SortOrder
+          type?: SortType
+        },
+        string[]
+      ][] = [
+        [
+          {
+            field: "name",
+            order: SortOrder.ASCENDING,
+            type: SortType.STRING,
+          },
+          ["Alice", "Bob", "Charly", "Danny"],
+        ],
+        [
+          {
+            field: "name",
+          },
+          ["Alice", "Bob", "Charly", "Danny"],
+        ],
+        [
+          {
+            field: "name",
+            order: SortOrder.DESCENDING,
+          },
+          ["Danny", "Charly", "Bob", "Alice"],
+        ],
+        [
+          {
+            field: "name",
+            order: SortOrder.DESCENDING,
+            type: SortType.STRING,
+          },
+          ["Danny", "Charly", "Bob", "Alice"],
+        ],
+        [
+          {
+            field: "age",
+            order: SortOrder.ASCENDING,
+            type: SortType.number,
+          },
+          ["Danny", "Alice", "Charly", "Bob"],
+        ],
+        [
+          {
+            field: "age",
+            order: SortOrder.ASCENDING,
+          },
+          ["Danny", "Alice", "Charly", "Bob"],
+        ],
+        [
+          {
+            field: "age",
+            order: SortOrder.DESCENDING,
+          },
+          ["Bob", "Charly", "Alice", "Danny"],
+        ],
+        [
+          {
+            field: "age",
+            order: SortOrder.DESCENDING,
+            type: SortType.number,
+          },
+          ["Bob", "Charly", "Alice", "Danny"],
+        ],
+      ]
+
+      describe("sorting", () => {
+        let table: Table
+        const viewSchema = { age: { visible: true }, name: { visible: true } }
+
+        beforeAll(async () => {
+          table = await config.api.table.save(
+            saveTableRequest({
+              name: `users_${uuid.v4()}`,
+              type: "table",
+              schema: {
+                name: {
+                  type: FieldType.STRING,
+                  name: "name",
+                },
+                surname: {
+                  type: FieldType.STRING,
+                  name: "surname",
+                },
+                age: {
+                  type: FieldType.NUMBER,
+                  name: "age",
+                },
+                address: {
+                  type: FieldType.STRING,
+                  name: "address",
+                },
+                jobTitle: {
+                  type: FieldType.STRING,
+                  name: "jobTitle",
+                },
+              },
+            })
+          )
+
+          const users = [
+            { name: "Alice", age: 25 },
+            { name: "Bob", age: 30 },
+            { name: "Charly", age: 27 },
+            { name: "Danny", age: 15 },
+          ]
+          await Promise.all(
+            users.map(u =>
+              config.api.row.save(table._id!, {
+                tableId: table._id,
+                ...u,
+              })
+            )
+          )
+        })
+
+        it.each(sortTestOptions)(
+          "allow sorting (%s)",
+          async (sortParams, expected) => {
+            const view = await config.api.viewV2.create({
+              tableId: table._id!,
+              name: generator.guid(),
+              sort: sortParams,
+              schema: viewSchema,
+            })
+
+            const response = await config.api.viewV2.search(view.id)
+
+            expect(response.rows).toHaveLength(4)
+            expect(response.rows).toEqual(
+              expected.map(name => expect.objectContaining({ name }))
+            )
+          }
+        )
+
+        it.each(sortTestOptions)(
+          "allow override the default view sorting (%s)",
+          async (sortParams, expected) => {
+            const view = await config.api.viewV2.create({
+              tableId: table._id!,
+              name: generator.guid(),
+              sort: {
+                field: "name",
+                order: SortOrder.ASCENDING,
+                type: SortType.STRING,
+              },
+              schema: viewSchema,
+            })
+
+            const response = await config.api.viewV2.search(view.id, {
+              sort: sortParams.field,
+              sortOrder: sortParams.order,
+              sortType: sortParams.type,
+              query: {},
+            })
+
+            expect(response.rows).toHaveLength(4)
+            expect(response.rows).toEqual(
+              expected.map(name => expect.objectContaining({ name }))
+            )
+          }
+        )
+      })
+    })
+
+    describe("permissions", () => {
+      beforeEach(async () => {
+        mocks.licenses.useViewPermissions()
+        await Promise.all(
+          Array.from({ length: 10 }, () => config.api.row.save(table._id!, {}))
+        )
+      })
+
+      it("does not allow public users to fetch by default", async () => {
+        await config.publish()
+        await config.api.viewV2.publicSearch(view.id, undefined, {
+          status: 403,
+        })
+      })
+
+      it("does not allow public users to fetch by default", async () => {
+        await config.publish()
+        await config.api.viewV2.publicSearch(view.id, undefined, {
+          status: 403,
+        })
+      })
+
+      it("allow public users to fetch when permissions are explicit", async () => {
+        await config.api.permission.add({
+          roleId: roles.BUILTIN_ROLE_IDS.PUBLIC,
+          level: PermissionLevel.READ,
+          resourceId: view.id,
+        })
+        await config.publish()
+
+        const response = await config.api.viewV2.publicSearch(view.id)
+
+        expect(response.rows).toHaveLength(10)
+      })
+
+      it("allow public users to fetch when permissions are inherited", async () => {
+        await config.api.permission.add({
+          roleId: roles.BUILTIN_ROLE_IDS.PUBLIC,
+          level: PermissionLevel.READ,
+          resourceId: table._id!,
+        })
+        await config.publish()
+
+        const response = await config.api.viewV2.publicSearch(view.id)
+
+        expect(response.rows).toHaveLength(10)
+      })
+
+      it("respects inherited permissions, not allowing not public views from public tables", async () => {
+        await config.api.permission.add({
+          roleId: roles.BUILTIN_ROLE_IDS.PUBLIC,
+          level: PermissionLevel.READ,
+          resourceId: table._id!,
+        })
+        await config.api.permission.add({
+          roleId: roles.BUILTIN_ROLE_IDS.POWER,
+          level: PermissionLevel.READ,
+          resourceId: view.id,
+        })
+        await config.publish()
+
+        await config.api.viewV2.publicSearch(view.id, undefined, {
+          status: 403,
+        })
+      })
+    })
+  })
 })

From 6d7712fbdc15b74fa0387bd088eefb97a0bace0e Mon Sep 17 00:00:00 2001
From: Adria Navarro <adria@budibase.com>
Date: Mon, 18 Mar 2024 10:18:45 +0100
Subject: [PATCH 02/24] Remove .only

---
 packages/server/src/api/routes/tests/viewV2.spec.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/server/src/api/routes/tests/viewV2.spec.ts b/packages/server/src/api/routes/tests/viewV2.spec.ts
index 9c53ade52e..c0b8b33a9a 100644
--- a/packages/server/src/api/routes/tests/viewV2.spec.ts
+++ b/packages/server/src/api/routes/tests/viewV2.spec.ts
@@ -544,7 +544,7 @@ describe.each([
     })
   })
 
-  describe.only("row operations", () => {
+  describe("row operations", () => {
     let table: Table, view: ViewV2
     beforeEach(async () => {
       table = await config.api.table.save(

From 362705793c6e3a63da7fe17729716dcf1fe6f627 Mon Sep 17 00:00:00 2001
From: Andrew Kingston <andrew@kingston.dev>
Date: Tue, 19 Mar 2024 16:21:46 +0000
Subject: [PATCH 03/24] Add event context for live eval to table blocks

---
 .../components/app/blocks/TableBlock.svelte   | 42 ++++++++++++-------
 1 file changed, 27 insertions(+), 15 deletions(-)

diff --git a/packages/client/src/components/app/blocks/TableBlock.svelte b/packages/client/src/components/app/blocks/TableBlock.svelte
index 7c58f90508..45ef4e4d3d 100644
--- a/packages/client/src/components/app/blocks/TableBlock.svelte
+++ b/packages/client/src/components/app/blocks/TableBlock.svelte
@@ -1,5 +1,6 @@
 <script>
   import { getContext } from "svelte"
+  import { get } from "svelte/store"
   import { generate } from "shortid"
   import Block from "components/Block.svelte"
   import BlockComponent from "components/BlockComponent.svelte"
@@ -33,8 +34,9 @@
   export let sidePanelDeleteLabel
   export let notificationOverride
 
-  const { fetchDatasourceSchema, API } = getContext("sdk")
+  const { fetchDatasourceSchema, API, generateGoldenSample } = getContext("sdk")
   const component = getContext("component")
+  const context = getContext("context")
   const stateKey = `ID_${generate()}`
 
   let formId
@@ -48,20 +50,6 @@
   let schemaLoaded = false
 
   $: deleteLabel = setDeleteLabel(sidePanelDeleteLabel, sidePanelShowDelete)
-
-  const setDeleteLabel = sidePanelDeleteLabel => {
-    // Accommodate old config to ensure delete button does not reappear
-    let labelText = sidePanelShowDelete === false ? "" : sidePanelDeleteLabel
-
-    // Empty text is considered hidden.
-    if (labelText?.trim() === "") {
-      return ""
-    }
-
-    // Default to "Delete" if the value is unset
-    return labelText || "Delete"
-  }
-
   $: isDSPlus = dataSource?.type === "table" || dataSource?.type === "viewV2"
   $: fetchSchema(dataSource)
   $: enrichSearchColumns(searchColumns, schema).then(
@@ -105,6 +93,30 @@
           },
         ]
 
+  // Provide additional data context for live binding eval
+  export const getAdditionalDataContext = () => {
+    const rows = get(context)[dataProviderId]?.rows
+    const goldenRow = generateGoldenSample(rows)
+    return {
+      eventContext: {
+        row: goldenRow,
+      },
+    }
+  }
+
+  const setDeleteLabel = sidePanelDeleteLabel => {
+    // Accommodate old config to ensure delete button does not reappear
+    let labelText = sidePanelShowDelete === false ? "" : sidePanelDeleteLabel
+
+    // Empty text is considered hidden.
+    if (labelText?.trim() === "") {
+      return ""
+    }
+
+    // Default to "Delete" if the value is unset
+    return labelText || "Delete"
+  }
+
   // Load the datasource schema so we can determine column types
   const fetchSchema = async dataSource => {
     if (dataSource?.type === "table") {

From 23ac11ad6b6dddd91f8c936da82d9ea7c57af79d Mon Sep 17 00:00:00 2001
From: Adria Navarro <adria@budibase.com>
Date: Wed, 20 Mar 2024 13:18:22 +0100
Subject: [PATCH 04/24] Add single subtype

---
 packages/types/src/documents/app/row.ts | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/packages/types/src/documents/app/row.ts b/packages/types/src/documents/app/row.ts
index b37412398d..0b4c6cd295 100644
--- a/packages/types/src/documents/app/row.ts
+++ b/packages/types/src/documents/app/row.ts
@@ -38,6 +38,7 @@ export interface Row extends Document {
 export enum FieldSubtype {
   USER = "user",
   USERS = "users",
+  SINGLE = "single",
 }
 
 export const FieldTypeSubtypes = {
@@ -45,4 +46,7 @@ export const FieldTypeSubtypes = {
     USER: FieldSubtype.USER,
     USERS: FieldSubtype.USERS,
   },
+  ATTACHMENT: {
+    SINGLE: FieldSubtype.SINGLE,
+  },
 }

From 59a7d8052ace1c737e10be982d7b89a4c0e1ec69 Mon Sep 17 00:00:00 2001
From: Adria Navarro <adria@budibase.com>
Date: Wed, 20 Mar 2024 13:35:09 +0100
Subject: [PATCH 05/24] Single attachment subtype

---
 .../DataTable/modals/CreateEditColumn.svelte  | 22 ++++++++++---------
 .../server/src/api/controllers/table/utils.ts | 19 ++++++++++++++++
 .../types/src/documents/app/table/schema.ts   |  1 +
 3 files changed, 32 insertions(+), 10 deletions(-)

diff --git a/packages/builder/src/components/backend/DataTable/modals/CreateEditColumn.svelte b/packages/builder/src/components/backend/DataTable/modals/CreateEditColumn.svelte
index f6a4f29a06..d3eaaa5d6a 100644
--- a/packages/builder/src/components/backend/DataTable/modals/CreateEditColumn.svelte
+++ b/packages/builder/src/components/backend/DataTable/modals/CreateEditColumn.svelte
@@ -34,7 +34,12 @@
   import { getBindings } from "components/backend/DataTable/formula"
   import JSONSchemaModal from "./JSONSchemaModal.svelte"
   import { ValidColumnNameRegex } from "@budibase/shared-core"
-  import { FieldType, FieldSubtype, SourceName } from "@budibase/types"
+  import {
+    FieldType,
+    FieldSubtype,
+    SourceName,
+    FieldTypeSubtypes,
+  } from "@budibase/types"
   import RelationshipSelector from "components/common/RelationshipSelector.svelte"
   import { RowUtils } from "@budibase/frontend-core"
   import ServerBindingPanel from "components/common/bindings/ServerBindingPanel.svelte"
@@ -191,8 +196,10 @@
     // don't make field IDs for auto types
     if (type === AUTO_TYPE || autocolumn) {
       return type.toUpperCase()
-    } else {
+    } else if (type === FieldType.BB_REFERENCE) {
       return `${type}${subtype || ""}`.toUpperCase()
+    } else {
+      return type.toUpperCase()
     }
   }
 
@@ -705,17 +712,12 @@
     />
   {:else if editableColumn.type === FieldType.ATTACHMENT}
     <Toggle
-      value={editableColumn.constraints?.length?.maximum !== 1}
+      value={editableColumn.subtype !== FieldTypeSubtypes.ATTACHMENT.SINGLE}
       on:change={e => {
         if (!e.detail) {
-          editableColumn.constraints ??= { length: {} }
-          editableColumn.constraints.length ??= {}
-          editableColumn.constraints.length.maximum = 1
-          editableColumn.constraints.length.message =
-            "cannot contain multiple files"
+          editableColumn.subtype = FieldTypeSubtypes.ATTACHMENT.SINGLE
         } else {
-          delete editableColumn.constraints?.length?.maximum
-          delete editableColumn.constraints?.length?.message
+          delete editableColumn.subtype
         }
       }}
       thin
diff --git a/packages/server/src/api/controllers/table/utils.ts b/packages/server/src/api/controllers/table/utils.ts
index 9e1bb59e9d..ac13617869 100644
--- a/packages/server/src/api/controllers/table/utils.ts
+++ b/packages/server/src/api/controllers/table/utils.ts
@@ -30,6 +30,7 @@ import {
   View,
   RelationshipFieldMetadata,
   FieldType,
+  FieldTypeSubtypes,
 } from "@budibase/types"
 
 export async function clearColumns(table: Table, columnNames: string[]) {
@@ -88,6 +89,24 @@ export async function checkForColumnUpdates(
     // Update views
     await checkForViewUpdates(updatedTable, deletedColumns, columnRename)
   }
+
+  for (const attachmentColumn of Object.values(updatedTable.schema).filter(
+    column =>
+      column.type === FieldType.ATTACHMENT &&
+      column.subtype !== oldTable?.schema[column.name]?.subtype
+  )) {
+    if (attachmentColumn.subtype === FieldTypeSubtypes.ATTACHMENT.SINGLE) {
+      attachmentColumn.constraints ??= { length: {} }
+      attachmentColumn.constraints.length ??= {}
+      attachmentColumn.constraints.length.maximum = 1
+      attachmentColumn.constraints.length.message =
+        "cannot contain multiple files"
+    } else {
+      delete attachmentColumn.constraints?.length?.maximum
+      delete attachmentColumn.constraints?.length?.message
+    }
+  }
+
   return { rows: updatedRows, table: updatedTable }
 }
 
diff --git a/packages/types/src/documents/app/table/schema.ts b/packages/types/src/documents/app/table/schema.ts
index 17abf747b2..0e5bec134c 100644
--- a/packages/types/src/documents/app/table/schema.ts
+++ b/packages/types/src/documents/app/table/schema.ts
@@ -119,6 +119,7 @@ export interface FieldConstraints {
   length?: {
     minimum?: string | number | null
     maximum?: string | number | null
+    message?: string
   }
   numericality?: {
     greaterThanOrEqualTo: string | null

From f458ae20a982e921c6762b25476b725aa00d7aa0 Mon Sep 17 00:00:00 2001
From: Andrew Kingston <andrew@kingston.dev>
Date: Wed, 20 Mar 2024 13:46:52 +0000
Subject: [PATCH 06/24] Fix requiring double keypress to create new rows

---
 .../components/grid/overlays/KeyboardManager.svelte  | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/packages/frontend-core/src/components/grid/overlays/KeyboardManager.svelte b/packages/frontend-core/src/components/grid/overlays/KeyboardManager.svelte
index 5e3a035d89..ed09301bb9 100644
--- a/packages/frontend-core/src/components/grid/overlays/KeyboardManager.svelte
+++ b/packages/frontend-core/src/components/grid/overlays/KeyboardManager.svelte
@@ -40,16 +40,18 @@
       }
     }
 
+    // Handle certain key presses regardless of selection state
+    if (e.key === "Enter" && (e.ctrlKey || e.metaKey) && $config.canAddRows) {
+      e.preventDefault()
+      dispatch("add-row-inline")
+      return
+    }
+
     // If nothing selected avoid processing further key presses
     if (!$focusedCellId) {
       if (e.key === "Tab" || e.key?.startsWith("Arrow")) {
         e.preventDefault()
         focusFirstCell()
-      } else if (e.key === "Enter" && (e.ctrlKey || e.metaKey)) {
-        if ($config.canAddRows) {
-          e.preventDefault()
-          dispatch("add-row-inline")
-        }
       } else if (e.key === "Delete" || e.key === "Backspace") {
         if (Object.keys($selectedRows).length && $config.canDeleteRows) {
           dispatch("request-bulk-delete")

From e4e6447cf6986252ffbd82262a917fd5927c8e0d Mon Sep 17 00:00:00 2001
From: melohagan <101575380+melohagan@users.noreply.github.com>
Date: Wed, 20 Mar 2024 15:16:19 +0000
Subject: [PATCH 07/24] Use clickoutside library to stop mouseup closing side
 panel (#13193)

* Use clickoutside library to stop mouseup closing side panel

* Revert "Use clickoutside library to stop mouseup closing side panel"

This reverts commit fbe574812e90491556183c157a254ecbf0953b01.

* Use mousedown

* Add allowedType for clickoutside event

* Remove contextmenu listener

---------

Co-authored-by: Martin McKeaveney <martin@budibase.com>
---
 packages/bbui/src/Actions/click_outside.js       | 13 +++++++++----
 packages/client/src/components/app/Layout.svelte |  5 ++++-
 2 files changed, 13 insertions(+), 5 deletions(-)

diff --git a/packages/bbui/src/Actions/click_outside.js b/packages/bbui/src/Actions/click_outside.js
index 12c4c4d002..2c54427b3a 100644
--- a/packages/bbui/src/Actions/click_outside.js
+++ b/packages/bbui/src/Actions/click_outside.js
@@ -39,19 +39,23 @@ const handleClick = event => {
       return
     }
 
+    if (handler.allowedType && event.type !== handler.allowedType) {
+      return
+    }
+
     handler.callback?.(event)
   })
 }
 document.documentElement.addEventListener("click", handleClick, true)
-document.documentElement.addEventListener("contextmenu", handleClick, true)
+document.documentElement.addEventListener("mousedown", handleClick, true)
 
 /**
  * Adds or updates a click handler
  */
-const updateHandler = (id, element, anchor, callback) => {
+const updateHandler = (id, element, anchor, callback, allowedType) => {
   let existingHandler = clickHandlers.find(x => x.id === id)
   if (!existingHandler) {
-    clickHandlers.push({ id, element, anchor, callback })
+    clickHandlers.push({ id, element, anchor, callback, allowedType })
   } else {
     existingHandler.callback = callback
   }
@@ -77,7 +81,8 @@ export default (element, opts) => {
   const update = newOpts => {
     const callback = newOpts?.callback || newOpts
     const anchor = newOpts?.anchor || element
-    updateHandler(id, element, anchor, callback)
+    const allowedType = newOpts?.allowedType || "click"
+    updateHandler(id, element, anchor, callback, allowedType)
   }
   update(opts)
   return {
diff --git a/packages/client/src/components/app/Layout.svelte b/packages/client/src/components/app/Layout.svelte
index 1b92c0fefc..992a166143 100644
--- a/packages/client/src/components/app/Layout.svelte
+++ b/packages/client/src/components/app/Layout.svelte
@@ -291,7 +291,10 @@
   <div
     id="side-panel-container"
     class:open={$sidePanelStore.open}
-    use:clickOutside={autoCloseSidePanel ? sidePanelStore.actions.close : null}
+    use:clickOutside={{
+      callback: autoCloseSidePanel ? sidePanelStore.actions.close : null,
+      allowedType: "mousedown",
+    }}
     class:builder={$builderStore.inBuilder}
   >
     <div class="side-panel-header">

From 3749f198f9e015429dcffdfbed8dbedfef55fd42 Mon Sep 17 00:00:00 2001
From: Budibase Staging Release Bot <>
Date: Wed, 20 Mar 2024 15:23:07 +0000
Subject: [PATCH 08/24] Bump version to 2.22.7

---
 lerna.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lerna.json b/lerna.json
index dfd2aac356..3a92bc6d9a 100644
--- a/lerna.json
+++ b/lerna.json
@@ -1,5 +1,5 @@
 {
-  "version": "2.22.6",
+  "version": "2.22.7",
   "npmClient": "yarn",
   "packages": [
     "packages/*",

From 6da84d2941b87adcf1f8bfc6be4dd19f0bfa797b Mon Sep 17 00:00:00 2001
From: Sam Rose <hello@samwho.dev>
Date: Wed, 20 Mar 2024 16:06:22 +0000
Subject: [PATCH 09/24] Fix lint errors.

---
 packages/server/src/api/routes/tests/row.spec.ts   | 14 ++------------
 .../server/src/api/routes/tests/viewV2.spec.ts     |  7 -------
 2 files changed, 2 insertions(+), 19 deletions(-)

diff --git a/packages/server/src/api/routes/tests/row.spec.ts b/packages/server/src/api/routes/tests/row.spec.ts
index 64a156b15a..aff85b4d0e 100644
--- a/packages/server/src/api/routes/tests/row.spec.ts
+++ b/packages/server/src/api/routes/tests/row.spec.ts
@@ -3,7 +3,7 @@ import { databaseTestProviders } from "../../../integrations/tests/utils"
 import tk from "timekeeper"
 import { outputProcessing } from "../../../utilities/rowProcessor"
 import * as setup from "./utilities"
-import { context, InternalTable, roles, tenancy } from "@budibase/backend-core"
+import { context, InternalTable, tenancy } from "@budibase/backend-core"
 import { quotas } from "@budibase/pro"
 import {
   AutoFieldSubType,
@@ -14,25 +14,15 @@ import {
   FieldTypeSubtypes,
   FormulaType,
   INTERNAL_TABLE_SOURCE_ID,
-  PermissionLevel,
   QuotaUsageType,
   RelationshipType,
   Row,
   SaveTableRequest,
-  SearchQueryOperators,
-  SortOrder,
-  SortType,
   StaticQuotaName,
   Table,
   TableSourceType,
-  ViewV2,
 } from "@budibase/types"
-import {
-  expectAnyExternalColsAttributes,
-  expectAnyInternalColsAttributes,
-  generator,
-  mocks,
-} from "@budibase/backend-core/tests"
+import { generator, mocks } from "@budibase/backend-core/tests"
 import _, { merge } from "lodash"
 import * as uuid from "uuid"
 
diff --git a/packages/server/src/api/routes/tests/viewV2.spec.ts b/packages/server/src/api/routes/tests/viewV2.spec.ts
index c0b8b33a9a..778d9d6e5a 100644
--- a/packages/server/src/api/routes/tests/viewV2.spec.ts
+++ b/packages/server/src/api/routes/tests/viewV2.spec.ts
@@ -962,13 +962,6 @@ describe.each([
         })
       })
 
-      it("does not allow public users to fetch by default", async () => {
-        await config.publish()
-        await config.api.viewV2.publicSearch(view.id, undefined, {
-          status: 403,
-        })
-      })
-
       it("allow public users to fetch when permissions are explicit", async () => {
         await config.api.permission.add({
           roleId: roles.BUILTIN_ROLE_IDS.PUBLIC,

From c70b50277f0c0d5f4fe7150bb6a559d1434a0c3f Mon Sep 17 00:00:00 2001
From: Adria Navarro <adria@budibase.com>
Date: Wed, 20 Mar 2024 17:37:27 +0100
Subject: [PATCH 10/24] Fix tsconfig.json

---
 packages/shared-core/tsconfig.json | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/packages/shared-core/tsconfig.json b/packages/shared-core/tsconfig.json
index ad028931e4..d0c5134f1c 100644
--- a/packages/shared-core/tsconfig.json
+++ b/packages/shared-core/tsconfig.json
@@ -1,6 +1,8 @@
 {
   "extends": "./tsconfig.build.json",
   "compilerOptions": {
+    "baseUrl": "..",
+    "rootDir": "src",
     "composite": true,
     "types": ["node", "jest"]
   },

From a81a1b13ceeda7a1e235c6263307f3e374872c04 Mon Sep 17 00:00:00 2001
From: Sam Rose <hello@samwho.dev>
Date: Wed, 20 Mar 2024 16:55:34 +0000
Subject: [PATCH 11/24] Remove mysql mocks.

---
 packages/server/__mocks__/mysql2.ts           |  11 -
 packages/server/__mocks__/mysql2/promise.ts   |  18 -
 .../server/src/api/routes/tests/debug.spec.ts |  41 +-
 .../api/routes/tests/queries/mysql.spec.ts    | 404 ++++++++++++------
 .../server/src/api/routes/tests/row.spec.ts   |   2 -
 .../src/api/routes/tests/viewV2.spec.ts       |   2 -
 .../server/src/integration-test/mysql.spec.ts |   1 -
 .../src/integrations/tests/mysql.spec.ts      | 152 -------
 .../app/rows/search/tests/external.spec.ts    |   2 -
 .../external-schema/mysql.integration.spec.ts |   2 -
 .../validators/mysql.integration.spec.ts      |   2 -
 11 files changed, 282 insertions(+), 355 deletions(-)
 delete mode 100644 packages/server/__mocks__/mysql2.ts
 delete mode 100644 packages/server/__mocks__/mysql2/promise.ts
 delete mode 100644 packages/server/src/integrations/tests/mysql.spec.ts

diff --git a/packages/server/__mocks__/mysql2.ts b/packages/server/__mocks__/mysql2.ts
deleted file mode 100644
index 67ff897811..0000000000
--- a/packages/server/__mocks__/mysql2.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-const client = {
-  connect: jest.fn(),
-  query: jest.fn((query, bindings, fn) => {
-    fn(null, [])
-  }),
-}
-
-module.exports = {
-  createConnection: jest.fn(() => client),
-  client,
-}
diff --git a/packages/server/__mocks__/mysql2/promise.ts b/packages/server/__mocks__/mysql2/promise.ts
deleted file mode 100644
index f8a4c7b2d6..0000000000
--- a/packages/server/__mocks__/mysql2/promise.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-module MySQLMock {
-  const mysql: any = {}
-
-  const client = {
-    connect: jest.fn(),
-    end: jest.fn(),
-    query: jest.fn(async () => {
-      return [[]]
-    }),
-  }
-
-  mysql.createConnection = jest.fn(async () => {
-    return client
-  })
-
-  module.exports = mysql
-}
diff --git a/packages/server/src/api/routes/tests/debug.spec.ts b/packages/server/src/api/routes/tests/debug.spec.ts
index 53e1f67823..c89f5f8cf0 100644
--- a/packages/server/src/api/routes/tests/debug.spec.ts
+++ b/packages/server/src/api/routes/tests/debug.spec.ts
@@ -1,13 +1,5 @@
-const { checkBuilderEndpoint } = require("./utilities/TestFunctions")
-const setup = require("./utilities")
-
-import os from "os"
-
-jest.mock("process", () => ({
-  arch: "arm64",
-  version: "v14.20.1",
-  platform: "darwin",
-}))
+import * as setup from "./utilities"
+import { checkBuilderEndpoint } from "./utilities/TestFunctions"
 
 describe("/component", () => {
   let request = setup.getRequest()
@@ -17,21 +9,6 @@ describe("/component", () => {
 
   beforeAll(async () => {
     await config.init()
-    os.cpus = () => [
-      {
-        model: "test",
-        speed: 12323,
-        times: {
-          user: 0,
-          nice: 0,
-          sys: 0,
-          idle: 0,
-          irq: 0,
-        },
-      },
-    ]
-    os.uptime = () => 123123123123
-    os.totalmem = () => 10000000000
   })
 
   describe("/api/debug", () => {
@@ -43,14 +20,16 @@ describe("/component", () => {
         .expect(200)
       expect(res.body).toEqual({
         budibaseVersion: "0.0.0+jest",
-        cpuArch: "arm64",
-        cpuCores: 1,
-        cpuInfo: "test",
+        cpuArch: expect.any(String),
+        cpuCores: expect.any(Number),
+        cpuInfo: expect.any(String),
         hosting: "docker-compose",
-        nodeVersion: "v14.20.1",
+        nodeVersion: expect.stringMatching(/^v\d+\.\d+\.\d+$/),
         platform: "darwin",
-        totalMemory: "9.313225746154785GB",
-        uptime: "1425036 day(s), 3 hour(s), 32 minute(s)",
+        totalMemory: expect.stringMatching(/^\d+GB$/),
+        uptime: expect.stringMatching(
+          /^\d+ day\(s\), \d+ hour\(s\), \d+ minute\(s\)$/
+        ),
       })
     })
 
diff --git a/packages/server/src/api/routes/tests/queries/mysql.spec.ts b/packages/server/src/api/routes/tests/queries/mysql.spec.ts
index 6c97ab5835..d04e53971d 100644
--- a/packages/server/src/api/routes/tests/queries/mysql.spec.ts
+++ b/packages/server/src/api/routes/tests/queries/mysql.spec.ts
@@ -2,9 +2,7 @@ import { Datasource, Query } from "@budibase/types"
 import * as setup from "../utilities"
 import { databaseTestProviders } from "../../../../integrations/tests/utils"
 import mysql from "mysql2/promise"
-
-jest.unmock("mysql2")
-jest.unmock("mysql2/promise")
+import { generator } from "@budibase/backend-core/tests"
 
 const createTableSQL = `
 CREATE TABLE test_table (
@@ -76,164 +74,306 @@ describe("/queries", () => {
     })
   })
 
-  it("should execute a query", async () => {
-    const query = await createQuery({
-      fields: {
-        sql: "SELECT * FROM test_table ORDER BY id",
-      },
+  describe("read", () => {
+    it("should execute a query", async () => {
+      const query = await createQuery({
+        fields: {
+          sql: "SELECT * FROM test_table ORDER BY id",
+        },
+      })
+
+      const result = await config.api.query.execute(query._id!)
+
+      expect(result.data).toEqual([
+        {
+          id: 1,
+          name: "one",
+        },
+        {
+          id: 2,
+          name: "two",
+        },
+        {
+          id: 3,
+          name: "three",
+        },
+        {
+          id: 4,
+          name: "four",
+        },
+        {
+          id: 5,
+          name: "five",
+        },
+      ])
     })
 
-    const result = await config.api.query.execute(query._id!)
-
-    expect(result.data).toEqual([
-      {
-        id: 1,
-        name: "one",
-      },
-      {
-        id: 2,
-        name: "two",
-      },
-      {
-        id: 3,
-        name: "three",
-      },
-      {
-        id: 4,
-        name: "four",
-      },
-      {
-        id: 5,
-        name: "five",
-      },
-    ])
-  })
-
-  it("should be able to transform a query", async () => {
-    const query = await createQuery({
-      fields: {
-        sql: "SELECT * FROM test_table WHERE id = 1",
-      },
-      transformer: `
+    it("should be able to transform a query", async () => {
+      const query = await createQuery({
+        fields: {
+          sql: "SELECT * FROM test_table WHERE id = 1",
+        },
+        transformer: `
         data[0].id = data[0].id + 1;
         return data;
       `,
+      })
+
+      const result = await config.api.query.execute(query._id!)
+
+      expect(result.data).toEqual([
+        {
+          id: 2,
+          name: "one",
+        },
+      ])
     })
 
-    const result = await config.api.query.execute(query._id!)
+    it("should coerce numeric bindings", async () => {
+      const query = await createQuery({
+        fields: {
+          sql: "SELECT * FROM test_table WHERE id = {{ id }}",
+        },
+        parameters: [
+          {
+            name: "id",
+            default: "",
+          },
+        ],
+      })
 
-    expect(result.data).toEqual([
-      {
-        id: 2,
-        name: "one",
-      },
-    ])
+      const result = await config.api.query.execute(query._id!, {
+        parameters: {
+          id: "1",
+        },
+      })
+
+      expect(result.data).toEqual([
+        {
+          id: 1,
+          name: "one",
+        },
+      ])
+    })
   })
 
-  it("should be able to insert with bindings", async () => {
-    const query = await createQuery({
-      fields: {
-        sql: "INSERT INTO test_table (name) VALUES ({{ foo }})",
-      },
-      parameters: [
+  describe("create", () => {
+    it("should be able to insert with bindings", async () => {
+      const query = await createQuery({
+        fields: {
+          sql: "INSERT INTO test_table (name) VALUES ({{ foo }})",
+        },
+        parameters: [
+          {
+            name: "foo",
+            default: "bar",
+          },
+        ],
+        queryVerb: "create",
+      })
+
+      const result = await config.api.query.execute(query._id!, {
+        parameters: {
+          foo: "baz",
+        },
+      })
+
+      expect(result.data).toEqual([
         {
+          created: true,
+        },
+      ])
+
+      await withConnection(async connection => {
+        const [rows] = await connection.query(
+          "SELECT * FROM test_table WHERE name = 'baz'"
+        )
+        expect(rows).toHaveLength(1)
+      })
+    })
+
+    it.each(["2021-02-05T12:01:00.000Z", "2021-02-05"])(
+      "should coerce %s into a date",
+      async dateStr => {
+        const date = new Date(dateStr)
+        const tableName = `\`${generator.guid()}\``
+        await withConnection(async connection => {
+          await connection.query(`CREATE TABLE ${tableName} (
+            id INT AUTO_INCREMENT PRIMARY KEY,
+            date DATETIME NOT NULL
+        )`)
+        })
+
+        const query = await createQuery({
+          fields: {
+            sql: `INSERT INTO ${tableName} (date) VALUES ({{ date }})`,
+          },
+          parameters: [
+            {
+              name: "date",
+              default: "",
+            },
+          ],
+          queryVerb: "create",
+        })
+
+        const result = await config.api.query.execute(query._id!, {
+          parameters: { date: dateStr },
+        })
+
+        expect(result.data).toEqual([{ created: true }])
+
+        await withConnection(async connection => {
+          const [rows] = await connection.query(
+            `SELECT * FROM ${tableName} WHERE date = '${date.toISOString()}'`
+          )
+          expect(rows).toHaveLength(1)
+        })
+      }
+    )
+
+    it.each(["2021,02,05", "202205-1500"])(
+      "should not coerce %s as a date",
+      async date => {
+        const query = await createQuery({
+          fields: {
+            sql: "INSERT INTO test_table (name) VALUES ({{ name }})",
+          },
+          parameters: [
+            {
+              name: "name",
+              default: "",
+            },
+          ],
+          queryVerb: "create",
+        })
+
+        const result = await config.api.query.execute(query._id!, {
+          parameters: {
+            name: date,
+          },
+        })
+
+        expect(result.data).toEqual([{ created: true }])
+
+        await withConnection(async connection => {
+          const [rows] = await connection.query(
+            `SELECT * FROM test_table WHERE name = '${date}'`
+          )
+          expect(rows).toHaveLength(1)
+        })
+      }
+    )
+  })
+
+  describe("update", () => {
+    it("should be able to update rows", async () => {
+      const query = await createQuery({
+        fields: {
+          sql: "UPDATE test_table SET name = {{ name }} WHERE id = {{ id }}",
+        },
+        parameters: [
+          {
+            name: "id",
+            default: "",
+          },
+          {
+            name: "name",
+            default: "updated",
+          },
+        ],
+        queryVerb: "update",
+      })
+
+      const result = await config.api.query.execute(query._id!, {
+        parameters: {
+          id: "1",
           name: "foo",
-          default: "bar",
         },
-      ],
-      queryVerb: "create",
+      })
+
+      expect(result.data).toEqual([
+        {
+          updated: true,
+        },
+      ])
+
+      await withConnection(async connection => {
+        const [rows] = await connection.query(
+          "SELECT * FROM test_table WHERE id = 1"
+        )
+        expect(rows).toEqual([{ id: 1, name: "foo" }])
+      })
     })
 
-    const result = await config.api.query.execute(query._id!, {
-      parameters: {
-        foo: "baz",
-      },
-    })
+    it("should be able to execute an update that updates no rows", async () => {
+      const query = await createQuery({
+        fields: {
+          sql: "UPDATE test_table SET name = 'updated' WHERE id = 100",
+        },
+        queryVerb: "update",
+      })
 
-    expect(result.data).toEqual([
-      {
-        created: true,
-      },
-    ])
+      const result = await config.api.query.execute(query._id!)
 
-    await withConnection(async connection => {
-      const [rows] = await connection.query(
-        "SELECT * FROM test_table WHERE name = 'baz'"
-      )
-      expect(rows).toHaveLength(1)
+      expect(result.data).toEqual([
+        {
+          updated: true,
+        },
+      ])
     })
   })
 
-  it("should be able to update rows", async () => {
-    const query = await createQuery({
-      fields: {
-        sql: "UPDATE test_table SET name = {{ name }} WHERE id = {{ id }}",
-      },
-      parameters: [
-        {
-          name: "id",
-          default: "",
+  describe("delete", () => {
+    it("should be able to delete rows", async () => {
+      const query = await createQuery({
+        fields: {
+          sql: "DELETE FROM test_table WHERE id = {{ id }}",
         },
-        {
-          name: "name",
-          default: "updated",
+        parameters: [
+          {
+            name: "id",
+            default: "",
+          },
+        ],
+        queryVerb: "delete",
+      })
+
+      const result = await config.api.query.execute(query._id!, {
+        parameters: {
+          id: "1",
         },
-      ],
-      queryVerb: "update",
-    })
+      })
 
-    const result = await config.api.query.execute(query._id!, {
-      parameters: {
-        id: "1",
-        name: "foo",
-      },
-    })
-
-    expect(result.data).toEqual([
-      {
-        updated: true,
-      },
-    ])
-
-    await withConnection(async connection => {
-      const [rows] = await connection.query(
-        "SELECT * FROM test_table WHERE id = 1"
-      )
-      expect(rows).toEqual([{ id: 1, name: "foo" }])
-    })
-  })
-
-  it("should be able to delete rows", async () => {
-    const query = await createQuery({
-      fields: {
-        sql: "DELETE FROM test_table WHERE id = {{ id }}",
-      },
-      parameters: [
+      expect(result.data).toEqual([
         {
-          name: "id",
-          default: "",
+          deleted: true,
         },
-      ],
-      queryVerb: "delete",
+      ])
+
+      await withConnection(async connection => {
+        const [rows] = await connection.query(
+          "SELECT * FROM test_table WHERE id = 1"
+        )
+        expect(rows).toHaveLength(0)
+      })
     })
 
-    const result = await config.api.query.execute(query._id!, {
-      parameters: {
-        id: "1",
-      },
-    })
+    it("should be able to execute a delete that deletes no rows", async () => {
+      const query = await createQuery({
+        fields: {
+          sql: "DELETE FROM test_table WHERE id = 100",
+        },
+        queryVerb: "delete",
+      })
 
-    expect(result.data).toEqual([
-      {
-        deleted: true,
-      },
-    ])
+      const result = await config.api.query.execute(query._id!)
 
-    await withConnection(async connection => {
-      const [rows] = await connection.query(
-        "SELECT * FROM test_table WHERE id = 1"
-      )
-      expect(rows).toHaveLength(0)
+      expect(result.data).toEqual([
+        {
+          deleted: true,
+        },
+      ])
     })
   })
 })
diff --git a/packages/server/src/api/routes/tests/row.spec.ts b/packages/server/src/api/routes/tests/row.spec.ts
index 854410dcf6..4d46bbe2a9 100644
--- a/packages/server/src/api/routes/tests/row.spec.ts
+++ b/packages/server/src/api/routes/tests/row.spec.ts
@@ -39,8 +39,6 @@ import * as uuid from "uuid"
 const timestamp = new Date("2023-01-26T11:48:57.597Z").toISOString()
 tk.freeze(timestamp)
 
-jest.unmock("mysql2")
-jest.unmock("mysql2/promise")
 jest.unmock("mssql")
 jest.unmock("pg")
 
diff --git a/packages/server/src/api/routes/tests/viewV2.spec.ts b/packages/server/src/api/routes/tests/viewV2.spec.ts
index ded5e08d29..8652778467 100644
--- a/packages/server/src/api/routes/tests/viewV2.spec.ts
+++ b/packages/server/src/api/routes/tests/viewV2.spec.ts
@@ -20,8 +20,6 @@ import * as uuid from "uuid"
 import { databaseTestProviders } from "../../../integrations/tests/utils"
 import merge from "lodash/merge"
 
-jest.unmock("mysql2")
-jest.unmock("mysql2/promise")
 jest.unmock("mssql")
 jest.unmock("pg")
 
diff --git a/packages/server/src/integration-test/mysql.spec.ts b/packages/server/src/integration-test/mysql.spec.ts
index a22410b812..92420fb336 100644
--- a/packages/server/src/integration-test/mysql.spec.ts
+++ b/packages/server/src/integration-test/mysql.spec.ts
@@ -20,7 +20,6 @@ fetch.mockSearch()
 
 const config = setup.getConfig()!
 
-jest.unmock("mysql2/promise")
 jest.mock("../websockets", () => ({
   clientAppSocket: jest.fn(),
   gridAppSocket: jest.fn(),
diff --git a/packages/server/src/integrations/tests/mysql.spec.ts b/packages/server/src/integrations/tests/mysql.spec.ts
deleted file mode 100644
index 5180645885..0000000000
--- a/packages/server/src/integrations/tests/mysql.spec.ts
+++ /dev/null
@@ -1,152 +0,0 @@
-import { default as MySQLIntegration, bindingTypeCoerce } from "../mysql"
-
-jest.mock("mysql2")
-
-class TestConfiguration {
-  integration: any
-
-  constructor(config: any = { ssl: {} }) {
-    this.integration = new MySQLIntegration.integration(config)
-  }
-}
-
-describe("MySQL Integration", () => {
-  let config: any
-
-  beforeEach(() => {
-    config = new TestConfiguration()
-  })
-
-  it("calls the create method with the correct params", async () => {
-    const sql = "insert into users (name, age) values ('Joe', 123);"
-    await config.integration.create({
-      sql,
-    })
-    expect(config.integration.client.query).toHaveBeenCalledWith(sql, [])
-  })
-
-  it("calls the read method with the correct params", async () => {
-    const sql = "select * from users;"
-    await config.integration.read({
-      sql,
-    })
-    expect(config.integration.client.query).toHaveBeenCalledWith(sql, [])
-  })
-
-  it("calls the update method with the correct params", async () => {
-    const sql = "update table users set name = 'test';"
-    await config.integration.update({
-      sql,
-    })
-    expect(config.integration.client.query).toHaveBeenCalledWith(sql, [])
-  })
-
-  it("calls the delete method with the correct params", async () => {
-    const sql = "delete from users where name = 'todelete';"
-    await config.integration.delete({
-      sql,
-    })
-    expect(config.integration.client.query).toHaveBeenCalledWith(sql, [])
-  })
-
-  describe("no rows returned", () => {
-    it("returns the correct response when the create response has no rows", async () => {
-      const sql = "insert into users (name, age) values ('Joe', 123);"
-      const response = await config.integration.create({
-        sql,
-      })
-      expect(response).toEqual([{ created: true }])
-    })
-
-    it("returns the correct response when the update response has no rows", async () => {
-      const sql = "update table users set name = 'test';"
-      const response = await config.integration.update({
-        sql,
-      })
-      expect(response).toEqual([{ updated: true }])
-    })
-
-    it("returns the correct response when the delete response has no rows", async () => {
-      const sql = "delete from users where name = 'todelete';"
-      const response = await config.integration.delete({
-        sql,
-      })
-      expect(response).toEqual([{ deleted: true }])
-    })
-  })
-
-  describe("binding type coerce", () => {
-    it("ignores non-string types", async () => {
-      const sql = "select * from users;"
-      const date = new Date()
-      await config.integration.read({
-        sql,
-        bindings: [11, date, ["a", "b", "c"], { id: 1 }],
-      })
-      expect(config.integration.client.query).toHaveBeenCalledWith(sql, [
-        11,
-        date,
-        ["a", "b", "c"],
-        { id: 1 },
-      ])
-    })
-
-    it("parses strings matching a number regex", async () => {
-      const sql = "select * from users;"
-      await config.integration.read({
-        sql,
-        bindings: ["101", "3.14"],
-      })
-      expect(config.integration.client.query).toHaveBeenCalledWith(
-        sql,
-        [101, 3.14]
-      )
-    })
-
-    it("parses strings matching a valid date format", async () => {
-      const sql = "select * from users;"
-      await config.integration.read({
-        sql,
-        bindings: [
-          "2001-10-30",
-          "2010-09-01T13:30:59.123Z",
-          "2021-02-05 12:01 PM",
-        ],
-      })
-      expect(config.integration.client.query).toHaveBeenCalledWith(sql, [
-        new Date("2001-10-30T00:00:00.000Z"),
-        new Date("2010-09-01T13:30:59.123Z"),
-        new Date("2021-02-05T12:01:00.000Z"),
-      ])
-    })
-
-    it("does not parse string matching a valid array of numbers as date", async () => {
-      const sql = "select * from users;"
-      await config.integration.read({
-        sql,
-        bindings: ["1,2,2017"],
-      })
-      expect(config.integration.client.query).toHaveBeenCalledWith(sql, [
-        "1,2,2017",
-      ])
-    })
-  })
-})
-
-describe("bindingTypeCoercion", () => {
-  it("shouldn't coerce something that looks like a date", () => {
-    const response = bindingTypeCoerce(["202205-1500"])
-    expect(response[0]).toBe("202205-1500")
-  })
-
-  it("should coerce an actual date", () => {
-    const date = new Date("2023-06-13T14:24:22.620Z")
-    const response = bindingTypeCoerce(["2023-06-13T14:24:22.620Z"])
-    expect(response[0]).toEqual(date)
-  })
-
-  it("should coerce numbers", () => {
-    const response = bindingTypeCoerce(["0"])
-    expect(response[0]).toEqual(0)
-  })
-})
diff --git a/packages/server/src/sdk/app/rows/search/tests/external.spec.ts b/packages/server/src/sdk/app/rows/search/tests/external.spec.ts
index bae84592ca..8ecec784dd 100644
--- a/packages/server/src/sdk/app/rows/search/tests/external.spec.ts
+++ b/packages/server/src/sdk/app/rows/search/tests/external.spec.ts
@@ -17,8 +17,6 @@ import {
   generator,
 } from "@budibase/backend-core/tests"
 
-jest.unmock("mysql2/promise")
-
 jest.setTimeout(30000)
 
 describe("external search", () => {
diff --git a/qa-core/src/integrations/external-schema/mysql.integration.spec.ts b/qa-core/src/integrations/external-schema/mysql.integration.spec.ts
index c34651ea0e..5a7e1989d2 100644
--- a/qa-core/src/integrations/external-schema/mysql.integration.spec.ts
+++ b/qa-core/src/integrations/external-schema/mysql.integration.spec.ts
@@ -1,8 +1,6 @@
 import { GenericContainer } from "testcontainers"
 import mysql from "../../../../packages/server/src/integrations/mysql"
 
-jest.unmock("mysql2/promise")
-
 describe("datasource validators", () => {
   describe("mysql", () => {
     let config: any
diff --git a/qa-core/src/integrations/validators/mysql.integration.spec.ts b/qa-core/src/integrations/validators/mysql.integration.spec.ts
index 0f0de132fe..e828d192af 100644
--- a/qa-core/src/integrations/validators/mysql.integration.spec.ts
+++ b/qa-core/src/integrations/validators/mysql.integration.spec.ts
@@ -1,8 +1,6 @@
 import { GenericContainer } from "testcontainers"
 import mysql from "../../../../packages/server/src/integrations/mysql"
 
-jest.unmock("mysql2/promise")
-
 describe("datasource validators", () => {
   describe("mysql", () => {
     let host: string

From 756970319ad059a2d42f3f899d88899abf09c988 Mon Sep 17 00:00:00 2001
From: Adria Navarro <adria@budibase.com>
Date: Wed, 20 Mar 2024 18:41:55 +0100
Subject: [PATCH 12/24] Don't add breaking changes

---
 .../backend/DataTable/modals/CreateEditColumn.svelte          | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/packages/builder/src/components/backend/DataTable/modals/CreateEditColumn.svelte b/packages/builder/src/components/backend/DataTable/modals/CreateEditColumn.svelte
index d3eaaa5d6a..d39a6a92a7 100644
--- a/packages/builder/src/components/backend/DataTable/modals/CreateEditColumn.svelte
+++ b/packages/builder/src/components/backend/DataTable/modals/CreateEditColumn.svelte
@@ -712,7 +712,9 @@
     />
   {:else if editableColumn.type === FieldType.ATTACHMENT}
     <Toggle
-      value={editableColumn.subtype !== FieldTypeSubtypes.ATTACHMENT.SINGLE}
+      value={editableColumn.subtype !== FieldTypeSubtypes.ATTACHMENT.SINGLE &&
+        // Checking config before the subtype was added
+        editableColumn.constraints?.length?.maximum !== 1}
       on:change={e => {
         if (!e.detail) {
           editableColumn.subtype = FieldTypeSubtypes.ATTACHMENT.SINGLE

From 545c67eac685e530b1cf41f6412580d676b358e2 Mon Sep 17 00:00:00 2001
From: Sam Rose <hello@samwho.dev>
Date: Wed, 20 Mar 2024 17:59:35 +0000
Subject: [PATCH 13/24] Remove mssql mock, unify SQL-based query tests.

---
 packages/server/__mocks__/mssql.ts            |  17 -
 .../{mysql.spec.ts => generic-sql.spec.ts}    | 384 +++++++++---------
 .../api/routes/tests/queries/postgres.spec.ts | 243 -----------
 .../tests/microsoftSqlServer.spec.ts          |  57 ---
 .../src/integrations/tests/postgres.spec.ts   |  83 ----
 .../src/integrations/tests/utils/mssql.ts     |   3 +
 6 files changed, 206 insertions(+), 581 deletions(-)
 delete mode 100644 packages/server/__mocks__/mssql.ts
 rename packages/server/src/api/routes/tests/queries/{mysql.spec.ts => generic-sql.spec.ts} (64%)
 delete mode 100644 packages/server/src/api/routes/tests/queries/postgres.spec.ts
 delete mode 100644 packages/server/src/integrations/tests/microsoftSqlServer.spec.ts
 delete mode 100644 packages/server/src/integrations/tests/postgres.spec.ts

diff --git a/packages/server/__mocks__/mssql.ts b/packages/server/__mocks__/mssql.ts
deleted file mode 100644
index 6a34e1e9d7..0000000000
--- a/packages/server/__mocks__/mssql.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-module.exports = {
-  ConnectionPool: jest.fn(() => ({
-    connect: jest.fn(() => ({
-      request: jest.fn(() => ({
-        query: jest.fn(sql => ({ recordset: [sql] })),
-      })),
-    })),
-  })),
-  query: jest.fn(() => ({
-    recordset: [
-      {
-        a: "string",
-        b: 1,
-      },
-    ],
-  })),
-}
diff --git a/packages/server/src/api/routes/tests/queries/mysql.spec.ts b/packages/server/src/api/routes/tests/queries/generic-sql.spec.ts
similarity index 64%
rename from packages/server/src/api/routes/tests/queries/mysql.spec.ts
rename to packages/server/src/api/routes/tests/queries/generic-sql.spec.ts
index d04e53971d..1fc0ecb382 100644
--- a/packages/server/src/api/routes/tests/queries/mysql.spec.ts
+++ b/packages/server/src/api/routes/tests/queries/generic-sql.spec.ts
@@ -1,26 +1,43 @@
-import { Datasource, Query } from "@budibase/types"
+import { Datasource, Query, SourceName } from "@budibase/types"
 import * as setup from "../utilities"
 import { databaseTestProviders } from "../../../../integrations/tests/utils"
+import pg from "pg"
 import mysql from "mysql2/promise"
-import { generator } from "@budibase/backend-core/tests"
+import mssql from "mssql"
 
-const createTableSQL = `
-CREATE TABLE test_table (
-    id INT AUTO_INCREMENT PRIMARY KEY,
-    name VARCHAR(50) NOT NULL
-)
-`
+jest.unmock("pg")
 
-const insertSQL = `
-INSERT INTO test_table (name) VALUES ('one'), ('two'), ('three'), ('four'), ('five')
-`
+const createTableSQL: Record<string, string> = {
+  [SourceName.POSTGRES]: `
+    CREATE TABLE test_table (
+        id serial PRIMARY KEY,
+        name VARCHAR ( 50 ) NOT NULL,
+        birthday TIMESTAMP
+    );`,
+  [SourceName.MYSQL]: `
+    CREATE TABLE test_table (
+        id INT AUTO_INCREMENT PRIMARY KEY,
+        name VARCHAR(50) NOT NULL,
+        birthday TIMESTAMP
+    );`,
+  [SourceName.SQL_SERVER]: `
+    CREATE TABLE test_table (
+        id INT IDENTITY(1,1) PRIMARY KEY,
+        name NVARCHAR(50) NOT NULL,
+        birthday DATETIME
+    );`,
+}
 
-const dropTableSQL = `
-DROP TABLE test_table
-`
+const insertSQL = `INSERT INTO test_table (name) VALUES ('one'), ('two'), ('three'), ('four'), ('five')`
+const dropTableSQL = `DROP TABLE test_table;`
 
-describe("/queries", () => {
-  let config = setup.getConfig()
+describe.each([
+  ["postgres", databaseTestProviders.postgres],
+  ["mysql", databaseTestProviders.mysql],
+  ["mssql", databaseTestProviders.mssql],
+  ["mariadb", databaseTestProviders.mariadb],
+])("queries (%s)", (__, dsProvider) => {
+  const config = setup.getConfig()
   let datasource: Datasource
 
   async function createQuery(query: Partial<Query>): Promise<Query> {
@@ -37,124 +54,63 @@ describe("/queries", () => {
     return await config.api.query.create({ ...defaultQuery, ...query })
   }
 
-  async function withConnection(
-    callback: (client: mysql.Connection) => Promise<void>
-  ): Promise<void> {
-    const ds = await databaseTestProviders.mysql.datasource()
-    const con = await mysql.createConnection(ds.config!)
-    try {
-      await callback(con)
-    } finally {
-      con.end()
+  async function rawQuery(sql: string): Promise<any> {
+    // We re-fetch the datasource here because the one returned by
+    // config.api.datasource.create has the password field blanked out, and we
+    // need the password to connect to the database.
+    const ds = await dsProvider.datasource()
+    switch (ds.source) {
+      case SourceName.POSTGRES: {
+        const client = new pg.Client(ds.config!)
+        await client.connect()
+        try {
+          const { rows } = await client.query(sql)
+          return rows
+        } finally {
+          await client.end()
+        }
+      }
+      case SourceName.MYSQL: {
+        const con = await mysql.createConnection(ds.config!)
+        try {
+          const [rows] = await con.query(sql)
+          return rows
+        } finally {
+          con.end()
+        }
+      }
+      case SourceName.SQL_SERVER: {
+        const pool = new mssql.ConnectionPool(ds.config! as mssql.config)
+        const client = await pool.connect()
+        try {
+          const { recordset } = await client.query(sql)
+          return recordset
+        } finally {
+          await pool.close()
+        }
+      }
     }
   }
 
-  afterAll(async () => {
-    await databaseTestProviders.mysql.stop()
-    setup.afterAll()
-  })
-
   beforeAll(async () => {
     await config.init()
     datasource = await config.api.datasource.create(
-      await databaseTestProviders.mysql.datasource()
+      await dsProvider.datasource()
     )
   })
 
   beforeEach(async () => {
-    await withConnection(async connection => {
-      await connection.query(createTableSQL)
-      await connection.query(insertSQL)
-    })
+    await rawQuery(createTableSQL[datasource.source])
+    await rawQuery(insertSQL)
   })
 
   afterEach(async () => {
-    await withConnection(async connection => {
-      await connection.query(dropTableSQL)
-    })
+    await rawQuery(dropTableSQL)
   })
 
-  describe("read", () => {
-    it("should execute a query", async () => {
-      const query = await createQuery({
-        fields: {
-          sql: "SELECT * FROM test_table ORDER BY id",
-        },
-      })
-
-      const result = await config.api.query.execute(query._id!)
-
-      expect(result.data).toEqual([
-        {
-          id: 1,
-          name: "one",
-        },
-        {
-          id: 2,
-          name: "two",
-        },
-        {
-          id: 3,
-          name: "three",
-        },
-        {
-          id: 4,
-          name: "four",
-        },
-        {
-          id: 5,
-          name: "five",
-        },
-      ])
-    })
-
-    it("should be able to transform a query", async () => {
-      const query = await createQuery({
-        fields: {
-          sql: "SELECT * FROM test_table WHERE id = 1",
-        },
-        transformer: `
-        data[0].id = data[0].id + 1;
-        return data;
-      `,
-      })
-
-      const result = await config.api.query.execute(query._id!)
-
-      expect(result.data).toEqual([
-        {
-          id: 2,
-          name: "one",
-        },
-      ])
-    })
-
-    it("should coerce numeric bindings", async () => {
-      const query = await createQuery({
-        fields: {
-          sql: "SELECT * FROM test_table WHERE id = {{ id }}",
-        },
-        parameters: [
-          {
-            name: "id",
-            default: "",
-          },
-        ],
-      })
-
-      const result = await config.api.query.execute(query._id!, {
-        parameters: {
-          id: "1",
-        },
-      })
-
-      expect(result.data).toEqual([
-        {
-          id: 1,
-          name: "one",
-        },
-      ])
-    })
+  afterAll(async () => {
+    await dsProvider.stop()
+    setup.afterAll()
   })
 
   describe("create", () => {
@@ -184,33 +140,21 @@ describe("/queries", () => {
         },
       ])
 
-      await withConnection(async connection => {
-        const [rows] = await connection.query(
-          "SELECT * FROM test_table WHERE name = 'baz'"
-        )
-        expect(rows).toHaveLength(1)
-      })
+      const rows = await rawQuery("SELECT * FROM test_table WHERE name = 'baz'")
+      expect(rows).toHaveLength(1)
     })
 
     it.each(["2021-02-05T12:01:00.000Z", "2021-02-05"])(
       "should coerce %s into a date",
-      async dateStr => {
-        const date = new Date(dateStr)
-        const tableName = `\`${generator.guid()}\``
-        await withConnection(async connection => {
-          await connection.query(`CREATE TABLE ${tableName} (
-            id INT AUTO_INCREMENT PRIMARY KEY,
-            date DATETIME NOT NULL
-        )`)
-        })
-
+      async datetimeStr => {
+        const date = new Date(datetimeStr)
         const query = await createQuery({
           fields: {
-            sql: `INSERT INTO ${tableName} (date) VALUES ({{ date }})`,
+            sql: `INSERT INTO test_table (name, birthday) VALUES ('foo', {{ birthday }})`,
           },
           parameters: [
             {
-              name: "date",
+              name: "birthday",
               default: "",
             },
           ],
@@ -218,23 +162,21 @@ describe("/queries", () => {
         })
 
         const result = await config.api.query.execute(query._id!, {
-          parameters: { date: dateStr },
+          parameters: { birthday: datetimeStr },
         })
 
         expect(result.data).toEqual([{ created: true }])
 
-        await withConnection(async connection => {
-          const [rows] = await connection.query(
-            `SELECT * FROM ${tableName} WHERE date = '${date.toISOString()}'`
-          )
-          expect(rows).toHaveLength(1)
-        })
+        const rows = await rawQuery(
+          `SELECT * FROM test_table WHERE birthday = '${date.toISOString()}'`
+        )
+        expect(rows).toHaveLength(1)
       }
     )
 
     it.each(["2021,02,05", "202205-1500"])(
       "should not coerce %s as a date",
-      async date => {
+      async notDateStr => {
         const query = await createQuery({
           fields: {
             sql: "INSERT INTO test_table (name) VALUES ({{ name }})",
@@ -250,22 +192,110 @@ describe("/queries", () => {
 
         const result = await config.api.query.execute(query._id!, {
           parameters: {
-            name: date,
+            name: notDateStr,
           },
         })
 
         expect(result.data).toEqual([{ created: true }])
 
-        await withConnection(async connection => {
-          const [rows] = await connection.query(
-            `SELECT * FROM test_table WHERE name = '${date}'`
-          )
-          expect(rows).toHaveLength(1)
-        })
+        const rows = await rawQuery(
+          `SELECT * FROM test_table WHERE name = '${notDateStr}'`
+        )
+        expect(rows).toHaveLength(1)
       }
     )
   })
 
+  describe("read", () => {
+    it("should execute a query", async () => {
+      const query = await createQuery({
+        fields: {
+          sql: "SELECT * FROM test_table ORDER BY id",
+        },
+      })
+
+      const result = await config.api.query.execute(query._id!)
+
+      expect(result.data).toEqual([
+        {
+          id: 1,
+          name: "one",
+          birthday: null,
+        },
+        {
+          id: 2,
+          name: "two",
+          birthday: null,
+        },
+        {
+          id: 3,
+          name: "three",
+          birthday: null,
+        },
+        {
+          id: 4,
+          name: "four",
+          birthday: null,
+        },
+        {
+          id: 5,
+          name: "five",
+          birthday: null,
+        },
+      ])
+    })
+
+    it("should be able to transform a query", async () => {
+      const query = await createQuery({
+        fields: {
+          sql: "SELECT * FROM test_table WHERE id = 1",
+        },
+        transformer: `
+        data[0].id = data[0].id + 1;
+        return data;
+      `,
+      })
+
+      const result = await config.api.query.execute(query._id!)
+
+      expect(result.data).toEqual([
+        {
+          id: 2,
+          name: "one",
+          birthday: null,
+        },
+      ])
+    })
+
+    it("should coerce numeric bindings", async () => {
+      const query = await createQuery({
+        fields: {
+          sql: "SELECT * FROM test_table WHERE id = {{ id }}",
+        },
+        parameters: [
+          {
+            name: "id",
+            default: "",
+          },
+        ],
+      })
+
+      const result = await config.api.query.execute(query._id!, {
+        parameters: {
+          id: "1",
+        },
+      })
+
+      expect(result.data).toEqual([
+        {
+          id: 1,
+          name: "one",
+          birthday: null,
+        },
+      ])
+    })
+  })
+
   describe("update", () => {
     it("should be able to update rows", async () => {
       const query = await createQuery({
@@ -298,12 +328,8 @@ describe("/queries", () => {
         },
       ])
 
-      await withConnection(async connection => {
-        const [rows] = await connection.query(
-          "SELECT * FROM test_table WHERE id = 1"
-        )
-        expect(rows).toEqual([{ id: 1, name: "foo" }])
-      })
+      const rows = await rawQuery("SELECT * FROM test_table WHERE id = 1")
+      expect(rows).toEqual([{ id: 1, name: "foo", birthday: null }])
     })
 
     it("should be able to execute an update that updates no rows", async () => {
@@ -322,6 +348,23 @@ describe("/queries", () => {
         },
       ])
     })
+
+    it("should be able to execute a delete that deletes no rows", async () => {
+      const query = await createQuery({
+        fields: {
+          sql: "DELETE FROM test_table WHERE id = 100",
+        },
+        queryVerb: "delete",
+      })
+
+      const result = await config.api.query.execute(query._id!)
+
+      expect(result.data).toEqual([
+        {
+          deleted: true,
+        },
+      ])
+    })
   })
 
   describe("delete", () => {
@@ -351,29 +394,8 @@ describe("/queries", () => {
         },
       ])
 
-      await withConnection(async connection => {
-        const [rows] = await connection.query(
-          "SELECT * FROM test_table WHERE id = 1"
-        )
-        expect(rows).toHaveLength(0)
-      })
-    })
-
-    it("should be able to execute a delete that deletes no rows", async () => {
-      const query = await createQuery({
-        fields: {
-          sql: "DELETE FROM test_table WHERE id = 100",
-        },
-        queryVerb: "delete",
-      })
-
-      const result = await config.api.query.execute(query._id!)
-
-      expect(result.data).toEqual([
-        {
-          deleted: true,
-        },
-      ])
+      const rows = await rawQuery("SELECT * FROM test_table WHERE id = 1")
+      expect(rows).toHaveLength(0)
     })
   })
 })
diff --git a/packages/server/src/api/routes/tests/queries/postgres.spec.ts b/packages/server/src/api/routes/tests/queries/postgres.spec.ts
deleted file mode 100644
index fd6a2b7d3c..0000000000
--- a/packages/server/src/api/routes/tests/queries/postgres.spec.ts
+++ /dev/null
@@ -1,243 +0,0 @@
-import { Datasource, Query } from "@budibase/types"
-import * as setup from "../utilities"
-import { databaseTestProviders } from "../../../../integrations/tests/utils"
-import { Client } from "pg"
-
-jest.unmock("pg")
-
-const createTableSQL = `
-CREATE TABLE test_table (
-    id serial PRIMARY KEY,
-    name VARCHAR ( 50 ) NOT NULL
-);
-`
-
-const insertSQL = `
-INSERT INTO test_table (name) VALUES ('one');
-INSERT INTO test_table (name) VALUES ('two');
-INSERT INTO test_table (name) VALUES ('three');
-INSERT INTO test_table (name) VALUES ('four');
-INSERT INTO test_table (name) VALUES ('five');
-`
-
-const dropTableSQL = `
-DROP TABLE test_table;
-`
-
-describe("/queries", () => {
-  let config = setup.getConfig()
-  let datasource: Datasource
-
-  async function createQuery(query: Partial<Query>): Promise<Query> {
-    const defaultQuery: Query = {
-      datasourceId: datasource._id!,
-      name: "New Query",
-      parameters: [],
-      fields: {},
-      schema: {},
-      queryVerb: "read",
-      transformer: "return data",
-      readable: true,
-    }
-    return await config.api.query.create({ ...defaultQuery, ...query })
-  }
-
-  async function withClient(
-    callback: (client: Client) => Promise<void>
-  ): Promise<void> {
-    const ds = await databaseTestProviders.postgres.datasource()
-    const client = new Client(ds.config!)
-    await client.connect()
-    try {
-      await callback(client)
-    } finally {
-      await client.end()
-    }
-  }
-
-  afterAll(async () => {
-    await databaseTestProviders.postgres.stop()
-    setup.afterAll()
-  })
-
-  beforeAll(async () => {
-    await config.init()
-    datasource = await config.api.datasource.create(
-      await databaseTestProviders.postgres.datasource()
-    )
-  })
-
-  beforeEach(async () => {
-    await withClient(async client => {
-      await client.query(createTableSQL)
-      await client.query(insertSQL)
-    })
-  })
-
-  afterEach(async () => {
-    await withClient(async client => {
-      await client.query(dropTableSQL)
-    })
-  })
-
-  it("should execute a query", async () => {
-    const query = await createQuery({
-      fields: {
-        sql: "SELECT * FROM test_table ORDER BY id",
-      },
-    })
-
-    const result = await config.api.query.execute(query._id!)
-
-    expect(result.data).toEqual([
-      {
-        id: 1,
-        name: "one",
-      },
-      {
-        id: 2,
-        name: "two",
-      },
-      {
-        id: 3,
-        name: "three",
-      },
-      {
-        id: 4,
-        name: "four",
-      },
-      {
-        id: 5,
-        name: "five",
-      },
-    ])
-  })
-
-  it("should be able to transform a query", async () => {
-    const query = await createQuery({
-      fields: {
-        sql: "SELECT * FROM test_table WHERE id = 1",
-      },
-      transformer: `
-        data[0].id = data[0].id + 1;
-        return data;
-      `,
-    })
-
-    const result = await config.api.query.execute(query._id!)
-
-    expect(result.data).toEqual([
-      {
-        id: 2,
-        name: "one",
-      },
-    ])
-  })
-
-  it("should be able to insert with bindings", async () => {
-    const query = await createQuery({
-      fields: {
-        sql: "INSERT INTO test_table (name) VALUES ({{ foo }})",
-      },
-      parameters: [
-        {
-          name: "foo",
-          default: "bar",
-        },
-      ],
-      queryVerb: "create",
-    })
-
-    const result = await config.api.query.execute(query._id!, {
-      parameters: {
-        foo: "baz",
-      },
-    })
-
-    expect(result.data).toEqual([
-      {
-        created: true,
-      },
-    ])
-
-    await withClient(async client => {
-      const { rows } = await client.query(
-        "SELECT * FROM test_table WHERE name = 'baz'"
-      )
-      expect(rows).toHaveLength(1)
-    })
-  })
-
-  it("should be able to update rows", async () => {
-    const query = await createQuery({
-      fields: {
-        sql: "UPDATE test_table SET name = {{ name }} WHERE id = {{ id }}",
-      },
-      parameters: [
-        {
-          name: "id",
-          default: "",
-        },
-        {
-          name: "name",
-          default: "updated",
-        },
-      ],
-      queryVerb: "update",
-    })
-
-    const result = await config.api.query.execute(query._id!, {
-      parameters: {
-        id: "1",
-        name: "foo",
-      },
-    })
-
-    expect(result.data).toEqual([
-      {
-        updated: true,
-      },
-    ])
-
-    await withClient(async client => {
-      const { rows } = await client.query(
-        "SELECT * FROM test_table WHERE id = 1"
-      )
-      expect(rows).toEqual([{ id: 1, name: "foo" }])
-    })
-  })
-
-  it("should be able to delete rows", async () => {
-    const query = await createQuery({
-      fields: {
-        sql: "DELETE FROM test_table WHERE id = {{ id }}",
-      },
-      parameters: [
-        {
-          name: "id",
-          default: "",
-        },
-      ],
-      queryVerb: "delete",
-    })
-
-    const result = await config.api.query.execute(query._id!, {
-      parameters: {
-        id: "1",
-      },
-    })
-
-    expect(result.data).toEqual([
-      {
-        deleted: true,
-      },
-    ])
-
-    await withClient(async client => {
-      const { rows } = await client.query(
-        "SELECT * FROM test_table WHERE id = 1"
-      )
-      expect(rows).toHaveLength(0)
-    })
-  })
-})
diff --git a/packages/server/src/integrations/tests/microsoftSqlServer.spec.ts b/packages/server/src/integrations/tests/microsoftSqlServer.spec.ts
deleted file mode 100644
index eaaa79f7c9..0000000000
--- a/packages/server/src/integrations/tests/microsoftSqlServer.spec.ts
+++ /dev/null
@@ -1,57 +0,0 @@
-import { default as MSSQLIntegration } from "../microsoftSqlServer"
-
-jest.mock("mssql")
-
-class TestConfiguration {
-  integration: any
-
-  constructor(config: any = {}) {
-    this.integration = new MSSQLIntegration.integration(config)
-  }
-}
-
-describe("MS SQL Server Integration", () => {
-  let config: any
-
-  beforeEach(async () => {
-    config = new TestConfiguration()
-  })
-
-  describe("check sql used", () => {
-    beforeEach(async () => {
-      await config.integration.connect()
-    })
-
-    it("calls the create method with the correct params", async () => {
-      const sql = "insert into users (name, age) values ('Joe', 123);"
-      const response = await config.integration.create({
-        sql,
-      })
-      expect(config.integration.client.request).toHaveBeenCalledWith()
-      expect(response[0]).toEqual(sql)
-    })
-
-    it("calls the read method with the correct params", async () => {
-      const sql = "select * from users;"
-      const response = await config.integration.read({
-        sql,
-      })
-      expect(config.integration.client.request).toHaveBeenCalledWith()
-      expect(response[0]).toEqual(sql)
-    })
-  })
-
-  describe("no rows returned", () => {
-    beforeEach(async () => {
-      await config.integration.connect()
-    })
-
-    it("returns the correct response when the create response has no rows", async () => {
-      const sql = "insert into users (name, age) values ('Joe', 123);"
-      const response = await config.integration.create({
-        sql,
-      })
-      expect(response[0]).toEqual(sql)
-    })
-  })
-})
diff --git a/packages/server/src/integrations/tests/postgres.spec.ts b/packages/server/src/integrations/tests/postgres.spec.ts
deleted file mode 100644
index cbce86acd0..0000000000
--- a/packages/server/src/integrations/tests/postgres.spec.ts
+++ /dev/null
@@ -1,83 +0,0 @@
-const pg = require("pg")
-
-import { default as PostgresIntegration } from "../postgres"
-
-jest.mock("pg")
-
-class TestConfiguration {
-  integration: any
-
-  constructor(config: any = {}) {
-    this.integration = new PostgresIntegration.integration(config)
-  }
-}
-
-describe("Postgres Integration", () => {
-  let config: any
-
-  beforeEach(() => {
-    config = new TestConfiguration()
-  })
-
-  it("calls the create method with the correct params", async () => {
-    const sql = "insert into users (name, age) values ('Joe', 123);"
-    await config.integration.create({
-      sql,
-    })
-    expect(pg.queryMock).toHaveBeenCalledWith(sql, [])
-  })
-
-  it("calls the read method with the correct params", async () => {
-    const sql = "select * from users;"
-    await config.integration.read({
-      sql,
-    })
-    expect(pg.queryMock).toHaveBeenCalledWith(sql, [])
-  })
-
-  it("calls the update method with the correct params", async () => {
-    const sql = "update table users set name = 'test';"
-    await config.integration.update({
-      sql,
-    })
-    expect(pg.queryMock).toHaveBeenCalledWith(sql, [])
-  })
-
-  it("calls the delete method with the correct params", async () => {
-    const sql = "delete from users where name = 'todelete';"
-    await config.integration.delete({
-      sql,
-    })
-    expect(pg.queryMock).toHaveBeenCalledWith(sql, [])
-  })
-
-  describe("no rows returned", () => {
-    beforeEach(() => {
-      pg.queryMock.mockImplementation(() => ({ rows: [] }))
-    })
-
-    it("returns the correct response when the create response has no rows", async () => {
-      const sql = "insert into users (name, age) values ('Joe', 123);"
-      const response = await config.integration.create({
-        sql,
-      })
-      expect(response).toEqual([{ created: true }])
-    })
-
-    it("returns the correct response when the update response has no rows", async () => {
-      const sql = "update table users set name = 'test';"
-      const response = await config.integration.update({
-        sql,
-      })
-      expect(response).toEqual([{ updated: true }])
-    })
-
-    it("returns the correct response when the delete response has no rows", async () => {
-      const sql = "delete from users where name = 'todelete';"
-      const response = await config.integration.delete({
-        sql,
-      })
-      expect(response).toEqual([{ deleted: true }])
-    })
-  })
-})
diff --git a/packages/server/src/integrations/tests/utils/mssql.ts b/packages/server/src/integrations/tests/utils/mssql.ts
index f548f0c42c..6bd4290a90 100644
--- a/packages/server/src/integrations/tests/utils/mssql.ts
+++ b/packages/server/src/integrations/tests/utils/mssql.ts
@@ -41,6 +41,9 @@ export async function datasource(): Promise<Datasource> {
       port,
       user: "sa",
       password: "Password_123",
+      options: {
+        encrypt: false,
+      },
     },
   }
 }

From 30a8a89f60542f916b1d6c0dddbaf400df3eef32 Mon Sep 17 00:00:00 2001
From: Sam Rose <hello@samwho.dev>
Date: Wed, 20 Mar 2024 18:03:02 +0000
Subject: [PATCH 14/24] Fix debug spec assertions.

---
 packages/server/src/api/routes/tests/debug.spec.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/server/src/api/routes/tests/debug.spec.ts b/packages/server/src/api/routes/tests/debug.spec.ts
index c89f5f8cf0..546344a646 100644
--- a/packages/server/src/api/routes/tests/debug.spec.ts
+++ b/packages/server/src/api/routes/tests/debug.spec.ts
@@ -25,8 +25,8 @@ describe("/component", () => {
         cpuInfo: expect.any(String),
         hosting: "docker-compose",
         nodeVersion: expect.stringMatching(/^v\d+\.\d+\.\d+$/),
-        platform: "darwin",
-        totalMemory: expect.stringMatching(/^\d+GB$/),
+        platform: expect.any(String),
+        totalMemory: expect.stringMatching(/^[0-9\\.]+GB$/),
         uptime: expect.stringMatching(
           /^\d+ day\(s\), \d+ hour\(s\), \d+ minute\(s\)$/
         ),

From 0b3a48b2b74abf40a496dad34331da381f74557d Mon Sep 17 00:00:00 2001
From: Adria Navarro <adria@budibase.com>
Date: Wed, 20 Mar 2024 19:11:02 +0100
Subject: [PATCH 15/24] Add attachment schema type

---
 packages/types/src/documents/app/table/schema.ts | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/packages/types/src/documents/app/table/schema.ts b/packages/types/src/documents/app/table/schema.ts
index 0e5bec134c..5da87883f4 100644
--- a/packages/types/src/documents/app/table/schema.ts
+++ b/packages/types/src/documents/app/table/schema.ts
@@ -147,6 +147,10 @@ interface BaseFieldSchema extends UIFieldMetadata {
   autoReason?: AutoReason.FOREIGN_KEY
   subtype?: never
 }
+interface AttachmentFieldMetadata extends Omit<BaseFieldSchema, "subtype"> {
+  type: FieldType.ATTACHMENT
+  subtype?: FieldSubtype.SINGLE
+}
 
 interface OtherFieldMetadata extends BaseFieldSchema {
   type: Exclude<
@@ -157,6 +161,7 @@ interface OtherFieldMetadata extends BaseFieldSchema {
     | FieldType.FORMULA
     | FieldType.NUMBER
     | FieldType.LONGFORM
+    | FieldType.ATTACHMENT
   >
 }
 
@@ -168,6 +173,7 @@ export type FieldSchema =
   | FormulaFieldMetadata
   | NumberFieldMetadata
   | LongFormFieldMetadata
+  | AttachmentFieldMetadata
   | BBReferenceFieldMetadata
   | JsonFieldMetadata
 

From b3bc092ee00afa18e98e293effe83b385fa946c9 Mon Sep 17 00:00:00 2001
From: mike12345567 <me@michaeldrury.co.uk>
Date: Wed, 20 Mar 2024 18:25:23 +0000
Subject: [PATCH 16/24] Allowing deletion of external tables, whether they were
 createrd in Budibase or not.

---
 .../popovers/EditTablePopover.svelte          | 23 ++++++++-----------
 .../src/api/controllers/table/external.ts     |  3 ---
 2 files changed, 10 insertions(+), 16 deletions(-)

diff --git a/packages/builder/src/components/backend/TableNavigator/popovers/EditTablePopover.svelte b/packages/builder/src/components/backend/TableNavigator/popovers/EditTablePopover.svelte
index c2cda1f2d8..f2c726c8bf 100644
--- a/packages/builder/src/components/backend/TableNavigator/popovers/EditTablePopover.svelte
+++ b/packages/builder/src/components/backend/TableNavigator/popovers/EditTablePopover.svelte
@@ -28,7 +28,6 @@
   let deleteTableName
 
   $: externalTable = table?.sourceType === DB_TYPE_EXTERNAL
-  $: allowDeletion = !externalTable || table?.created
 
   function showDeleteModal() {
     templateScreens = $screenStore.screens.filter(
@@ -56,7 +55,7 @@
         $goto(`./datasource/${table.datasourceId}`)
       }
     } catch (error) {
-      notifications.error("Error deleting table")
+      notifications.error(`Error deleting table - ${error.message}`)
     }
   }
 
@@ -86,17 +85,15 @@
   }
 </script>
 
-{#if allowDeletion}
-  <ActionMenu>
-    <div slot="control" class="icon">
-      <Icon s hoverable name="MoreSmallList" />
-    </div>
-    {#if !externalTable}
-      <MenuItem icon="Edit" on:click={editorModal.show}>Edit</MenuItem>
-    {/if}
-    <MenuItem icon="Delete" on:click={showDeleteModal}>Delete</MenuItem>
-  </ActionMenu>
-{/if}
+<ActionMenu>
+  <div slot="control" class="icon">
+    <Icon s hoverable name="MoreSmallList" />
+  </div>
+  {#if !externalTable}
+    <MenuItem icon="Edit" on:click={editorModal.show}>Edit</MenuItem>
+  {/if}
+  <MenuItem icon="Delete" on:click={showDeleteModal}>Delete</MenuItem>
+</ActionMenu>
 
 <Modal bind:this={editorModal} on:show={initForm}>
   <ModalContent
diff --git a/packages/server/src/api/controllers/table/external.ts b/packages/server/src/api/controllers/table/external.ts
index c85b46a95c..7c036bec9d 100644
--- a/packages/server/src/api/controllers/table/external.ts
+++ b/packages/server/src/api/controllers/table/external.ts
@@ -61,9 +61,6 @@ export async function destroy(ctx: UserCtx) {
   const tableToDelete: TableRequest = await sdk.tables.getTable(
     ctx.params.tableId
   )
-  if (!tableToDelete || !tableToDelete.created) {
-    ctx.throw(400, "Cannot delete tables which weren't created in Budibase.")
-  }
   const datasourceId = getDatasourceId(tableToDelete)
   try {
     const { datasource, table } = await sdk.tables.external.destroy(

From 0827cc6bda56d99ab342d11e815215d77ca3507e Mon Sep 17 00:00:00 2001
From: Adria Navarro <adria@budibase.com>
Date: Wed, 20 Mar 2024 19:33:39 +0100
Subject: [PATCH 17/24] Type everywhere!

---
 .../server/src/integrations/base/sqlTable.ts  |  2 +-
 .../server/src/sdk/app/rows/search/utils.ts   |  2 +-
 .../rowProcessor/bbReferenceProcessor.ts      |  4 +-
 .../src/utilities/rowProcessor/index.ts       |  7 +--
 packages/server/src/utilities/schema.ts       | 50 +++++++------------
 packages/types/src/documents/app/row.ts       |  7 +--
 .../types/src/documents/app/table/schema.ts   | 39 ++++++++-------
 7 files changed, 49 insertions(+), 62 deletions(-)

diff --git a/packages/server/src/integrations/base/sqlTable.ts b/packages/server/src/integrations/base/sqlTable.ts
index 06c2184549..0feecefb89 100644
--- a/packages/server/src/integrations/base/sqlTable.ts
+++ b/packages/server/src/integrations/base/sqlTable.ts
@@ -60,7 +60,7 @@ function generateSchema(
         schema.text(key)
         break
       case FieldType.BB_REFERENCE: {
-        const subtype = column.subtype as FieldSubtype
+        const subtype = column.subtype
         switch (subtype) {
           case FieldSubtype.USER:
             schema.text(key)
diff --git a/packages/server/src/sdk/app/rows/search/utils.ts b/packages/server/src/sdk/app/rows/search/utils.ts
index d300fdbef0..086599665b 100644
--- a/packages/server/src/sdk/app/rows/search/utils.ts
+++ b/packages/server/src/sdk/app/rows/search/utils.ts
@@ -67,7 +67,7 @@ export function searchInputMapping(table: Table, options: SearchParams) {
   for (let [key, column] of Object.entries(table.schema)) {
     switch (column.type) {
       case FieldType.BB_REFERENCE: {
-        const subtype = column.subtype as FieldSubtype
+        const subtype = column.subtype
         switch (subtype) {
           case FieldSubtype.USER:
           case FieldSubtype.USERS:
diff --git a/packages/server/src/utilities/rowProcessor/bbReferenceProcessor.ts b/packages/server/src/utilities/rowProcessor/bbReferenceProcessor.ts
index 31f1f5e575..a5fbfa981d 100644
--- a/packages/server/src/utilities/rowProcessor/bbReferenceProcessor.ts
+++ b/packages/server/src/utilities/rowProcessor/bbReferenceProcessor.ts
@@ -7,7 +7,7 @@ const ROW_PREFIX = DocumentType.ROW + SEPARATOR
 
 export async function processInputBBReferences(
   value: string | string[] | { _id: string } | { _id: string }[],
-  subtype: FieldSubtype
+  subtype: FieldSubtype.USER | FieldSubtype.USERS
 ): Promise<string | string[] | null> {
   let referenceIds: string[] = []
 
@@ -61,7 +61,7 @@ export async function processInputBBReferences(
 
 export async function processOutputBBReferences(
   value: string | string[],
-  subtype: FieldSubtype
+  subtype: FieldSubtype.USER | FieldSubtype.USERS
 ) {
   if (value === null || value === undefined) {
     // Already processed or nothing to process
diff --git a/packages/server/src/utilities/rowProcessor/index.ts b/packages/server/src/utilities/rowProcessor/index.ts
index d956a94d0b..3ed4c5d903 100644
--- a/packages/server/src/utilities/rowProcessor/index.ts
+++ b/packages/server/src/utilities/rowProcessor/index.ts
@@ -159,10 +159,7 @@ export async function inputProcessing(
     }
 
     if (field.type === FieldType.BB_REFERENCE && value) {
-      clonedRow[key] = await processInputBBReferences(
-        value,
-        field.subtype as FieldSubtype
-      )
+      clonedRow[key] = await processInputBBReferences(value, field.subtype)
     }
   }
 
@@ -238,7 +235,7 @@ export async function outputProcessing<T extends Row[] | Row>(
       for (let row of enriched) {
         row[property] = await processOutputBBReferences(
           row[property],
-          column.subtype as FieldSubtype
+          column.subtype
         )
       }
     }
diff --git a/packages/server/src/utilities/schema.ts b/packages/server/src/utilities/schema.ts
index 5c466ec510..85dfdd3506 100644
--- a/packages/server/src/utilities/schema.ts
+++ b/packages/server/src/utilities/schema.ts
@@ -1,26 +1,14 @@
-import { FieldType, FieldSubtype } from "@budibase/types"
+import {
+  FieldType,
+  FieldSubtype,
+  TableSchema,
+  FieldSchema,
+  Row,
+} from "@budibase/types"
 import { ValidColumnNameRegex, utils } from "@budibase/shared-core"
 import { db } from "@budibase/backend-core"
 import { parseCsvExport } from "../api/controllers/view/exporters"
 
-interface SchemaColumn {
-  readonly name: string
-  readonly type: FieldType
-  readonly subtype: FieldSubtype
-  readonly autocolumn?: boolean
-  readonly constraints?: {
-    presence: boolean
-  }
-}
-
-interface Schema {
-  readonly [index: string]: SchemaColumn
-}
-
-interface Row {
-  [index: string]: any
-}
-
 type Rows = Array<Row>
 
 interface SchemaValidation {
@@ -34,12 +22,10 @@ interface ValidationResults {
   errors: Record<string, string>
 }
 
-export function isSchema(schema: any): schema is Schema {
+export function isSchema(schema: any): schema is TableSchema {
   return (
     typeof schema === "object" &&
-    Object.values(schema).every(rawColumn => {
-      const column = rawColumn as SchemaColumn
-
+    Object.values<FieldSchema>(schema).every(column => {
       return (
         column !== null &&
         typeof column === "object" &&
@@ -54,7 +40,7 @@ export function isRows(rows: any): rows is Rows {
   return Array.isArray(rows) && rows.every(row => typeof row === "object")
 }
 
-export function validate(rows: Rows, schema: Schema): ValidationResults {
+export function validate(rows: Rows, schema: TableSchema): ValidationResults {
   const results: ValidationResults = {
     schemaValidation: {},
     allValid: false,
@@ -64,9 +50,11 @@ export function validate(rows: Rows, schema: Schema): ValidationResults {
 
   rows.forEach(row => {
     Object.entries(row).forEach(([columnName, columnData]) => {
-      const columnType = schema[columnName]?.type
-      const columnSubtype = schema[columnName]?.subtype
-      const isAutoColumn = schema[columnName]?.autocolumn
+      const {
+        type: columnType,
+        subtype: columnSubtype,
+        autocolumn: isAutoColumn,
+      } = schema[columnName]
 
       // If the column had an invalid value we don't want to override it
       if (results.schemaValidation[columnName] === false) {
@@ -123,7 +111,7 @@ export function validate(rows: Rows, schema: Schema): ValidationResults {
   return results
 }
 
-export function parse(rows: Rows, schema: Schema): Rows {
+export function parse(rows: Rows, schema: TableSchema): Rows {
   return rows.map(row => {
     const parsedRow: Row = {}
 
@@ -133,9 +121,7 @@ export function parse(rows: Rows, schema: Schema): Rows {
         return
       }
 
-      const columnType = schema[columnName].type
-      const columnSubtype = schema[columnName].subtype
-
+      const { type: columnType, subtype: columnSubtype } = schema[columnName]
       if (columnType === FieldType.NUMBER) {
         // If provided must be a valid number
         parsedRow[columnName] = columnData ? Number(columnData) : columnData
@@ -172,7 +158,7 @@ export function parse(rows: Rows, schema: Schema): Rows {
 
 function isValidBBReference(
   columnData: any,
-  columnSubtype: FieldSubtype
+  columnSubtype: FieldSubtype.USER | FieldSubtype.USERS
 ): boolean {
   switch (columnSubtype) {
     case FieldSubtype.USER:
diff --git a/packages/types/src/documents/app/row.ts b/packages/types/src/documents/app/row.ts
index 0b4c6cd295..aa8f50d4a8 100644
--- a/packages/types/src/documents/app/row.ts
+++ b/packages/types/src/documents/app/row.ts
@@ -41,12 +41,13 @@ export enum FieldSubtype {
   SINGLE = "single",
 }
 
+// The 'as' are required for typescript not to type the outputs as generic FieldSubtype
 export const FieldTypeSubtypes = {
   BB_REFERENCE: {
-    USER: FieldSubtype.USER,
-    USERS: FieldSubtype.USERS,
+    USER: FieldSubtype.USER as FieldSubtype.USER,
+    USERS: FieldSubtype.USERS as FieldSubtype.USERS,
   },
   ATTACHMENT: {
-    SINGLE: FieldSubtype.SINGLE,
+    SINGLE: FieldSubtype.SINGLE as FieldSubtype.SINGLE,
   },
 }
diff --git a/packages/types/src/documents/app/table/schema.ts b/packages/types/src/documents/app/table/schema.ts
index 5da87883f4..3a74134ddd 100644
--- a/packages/types/src/documents/app/table/schema.ts
+++ b/packages/types/src/documents/app/table/schema.ts
@@ -17,13 +17,14 @@ export interface UIFieldMetadata {
 }
 
 interface BaseRelationshipFieldMetadata
-  extends Omit<BaseFieldSchema, "subtype"> {
+  extends BaseFieldSchema<
+    AutoFieldSubType.CREATED_BY | AutoFieldSubType.UPDATED_BY | undefined
+  > {
   type: FieldType.LINK
   main?: boolean
   fieldName: string
   tableId: string
   tableRev?: string
-  subtype?: AutoFieldSubType.CREATED_BY | AutoFieldSubType.UPDATED_BY
 }
 
 // External tables use junction tables, internal tables don't require them
@@ -60,18 +61,17 @@ export type RelationshipFieldMetadata =
   | ManyToOneRelationshipFieldMetadata
 
 export interface AutoColumnFieldMetadata
-  extends Omit<BaseFieldSchema, "subtype"> {
+  extends BaseFieldSchema<AutoFieldSubType | undefined> {
   type: FieldType.AUTO
   autocolumn: true
-  subtype?: AutoFieldSubType
   lastID?: number
   // if the column was turned to an auto-column for SQL, explains why (primary, foreign etc)
   autoReason?: AutoReason
 }
 
-export interface NumberFieldMetadata extends Omit<BaseFieldSchema, "subtype"> {
+export interface NumberFieldMetadata
+  extends BaseFieldSchema<AutoFieldSubType.AUTO_ID | undefined> {
   type: FieldType.NUMBER
-  subtype?: AutoFieldSubType.AUTO_ID
   lastID?: number
   autoReason?: AutoReason.FOREIGN_KEY
   // used specifically when Budibase generates external tables, this denotes if a number field
@@ -82,16 +82,18 @@ export interface NumberFieldMetadata extends Omit<BaseFieldSchema, "subtype"> {
   }
 }
 
-export interface JsonFieldMetadata extends Omit<BaseFieldSchema, "subtype"> {
+export interface JsonFieldMetadata
+  extends BaseFieldSchema<JsonFieldSubType.ARRAY | undefined> {
   type: FieldType.JSON
-  subtype?: JsonFieldSubType.ARRAY
 }
 
-export interface DateFieldMetadata extends Omit<BaseFieldSchema, "subtype"> {
+export interface DateFieldMetadata
+  extends BaseFieldSchema<
+    AutoFieldSubType.CREATED_AT | AutoFieldSubType.UPDATED_AT | undefined
+  > {
   type: FieldType.DATETIME
   ignoreTimezones?: boolean
   timeOnly?: boolean
-  subtype?: AutoFieldSubType.CREATED_AT | AutoFieldSubType.UPDATED_AT
 }
 
 export interface LongFormFieldMetadata extends BaseFieldSchema {
@@ -106,12 +108,17 @@ export interface FormulaFieldMetadata extends BaseFieldSchema {
 }
 
 export interface BBReferenceFieldMetadata
-  extends Omit<BaseFieldSchema, "subtype"> {
+  extends BaseFieldSchema<FieldSubtype.USER | FieldSubtype.USERS> {
   type: FieldType.BB_REFERENCE
-  subtype: FieldSubtype.USER | FieldSubtype.USERS
+
   relationshipType?: RelationshipType
 }
 
+export interface AttachmentFieldMetadata
+  extends BaseFieldSchema<FieldSubtype.SINGLE | undefined> {
+  type: FieldType.ATTACHMENT
+}
+
 export interface FieldConstraints {
   type?: string
   email?: boolean
@@ -136,7 +143,7 @@ export interface FieldConstraints {
   }
 }
 
-interface BaseFieldSchema extends UIFieldMetadata {
+interface BaseFieldSchema<TSubtype = never> extends UIFieldMetadata {
   type: FieldType
   name: string
   sortable?: boolean
@@ -145,11 +152,7 @@ interface BaseFieldSchema extends UIFieldMetadata {
   constraints?: FieldConstraints
   autocolumn?: boolean
   autoReason?: AutoReason.FOREIGN_KEY
-  subtype?: never
-}
-interface AttachmentFieldMetadata extends Omit<BaseFieldSchema, "subtype"> {
-  type: FieldType.ATTACHMENT
-  subtype?: FieldSubtype.SINGLE
+  subtype: TSubtype
 }
 
 interface OtherFieldMetadata extends BaseFieldSchema {

From 4def299172347496cd4e35c8c7a4afe3e55542a9 Mon Sep 17 00:00:00 2001
From: Adria Navarro <adria@budibase.com>
Date: Wed, 20 Mar 2024 23:16:41 +0100
Subject: [PATCH 18/24] Undo type changes

---
 .../types/src/documents/app/table/schema.ts   | 42 +++++++++++--------
 1 file changed, 24 insertions(+), 18 deletions(-)

diff --git a/packages/types/src/documents/app/table/schema.ts b/packages/types/src/documents/app/table/schema.ts
index 3a74134ddd..45e39268ac 100644
--- a/packages/types/src/documents/app/table/schema.ts
+++ b/packages/types/src/documents/app/table/schema.ts
@@ -17,14 +17,13 @@ export interface UIFieldMetadata {
 }
 
 interface BaseRelationshipFieldMetadata
-  extends BaseFieldSchema<
-    AutoFieldSubType.CREATED_BY | AutoFieldSubType.UPDATED_BY | undefined
-  > {
+  extends Omit<BaseFieldSchema, "subtype"> {
   type: FieldType.LINK
   main?: boolean
   fieldName: string
   tableId: string
   tableRev?: string
+  subtype?: AutoFieldSubType.CREATED_BY | AutoFieldSubType.UPDATED_BY
 }
 
 // External tables use junction tables, internal tables don't require them
@@ -61,17 +60,18 @@ export type RelationshipFieldMetadata =
   | ManyToOneRelationshipFieldMetadata
 
 export interface AutoColumnFieldMetadata
-  extends BaseFieldSchema<AutoFieldSubType | undefined> {
+  extends Omit<BaseFieldSchema, "subtype"> {
   type: FieldType.AUTO
   autocolumn: true
+  subtype?: AutoFieldSubType
   lastID?: number
   // if the column was turned to an auto-column for SQL, explains why (primary, foreign etc)
   autoReason?: AutoReason
 }
 
-export interface NumberFieldMetadata
-  extends BaseFieldSchema<AutoFieldSubType.AUTO_ID | undefined> {
+export interface NumberFieldMetadata extends Omit<BaseFieldSchema, "subtype"> {
   type: FieldType.NUMBER
+  subtype?: AutoFieldSubType.AUTO_ID
   lastID?: number
   autoReason?: AutoReason.FOREIGN_KEY
   // used specifically when Budibase generates external tables, this denotes if a number field
@@ -82,18 +82,16 @@ export interface NumberFieldMetadata
   }
 }
 
-export interface JsonFieldMetadata
-  extends BaseFieldSchema<JsonFieldSubType.ARRAY | undefined> {
+export interface JsonFieldMetadata extends Omit<BaseFieldSchema, "subtype"> {
   type: FieldType.JSON
+  subtype?: JsonFieldSubType.ARRAY
 }
 
-export interface DateFieldMetadata
-  extends BaseFieldSchema<
-    AutoFieldSubType.CREATED_AT | AutoFieldSubType.UPDATED_AT | undefined
-  > {
+export interface DateFieldMetadata extends Omit<BaseFieldSchema, "subtype"> {
   type: FieldType.DATETIME
   ignoreTimezones?: boolean
   timeOnly?: boolean
+  subtype?: AutoFieldSubType.CREATED_AT | AutoFieldSubType.UPDATED_AT
 }
 
 export interface LongFormFieldMetadata extends BaseFieldSchema {
@@ -108,15 +106,16 @@ export interface FormulaFieldMetadata extends BaseFieldSchema {
 }
 
 export interface BBReferenceFieldMetadata
-  extends BaseFieldSchema<FieldSubtype.USER | FieldSubtype.USERS> {
+  extends Omit<BaseFieldSchema, "subtype"> {
   type: FieldType.BB_REFERENCE
-
+  subtype: FieldSubtype.USER | FieldSubtype.USERS
   relationshipType?: RelationshipType
 }
 
 export interface AttachmentFieldMetadata
-  extends BaseFieldSchema<FieldSubtype.SINGLE | undefined> {
+  extends Omit<BaseFieldSchema, "subtype"> {
   type: FieldType.ATTACHMENT
+  subtype?: FieldSubtype.SINGLE
 }
 
 export interface FieldConstraints {
@@ -143,7 +142,7 @@ export interface FieldConstraints {
   }
 }
 
-interface BaseFieldSchema<TSubtype = never> extends UIFieldMetadata {
+interface BaseFieldSchema extends UIFieldMetadata {
   type: FieldType
   name: string
   sortable?: boolean
@@ -152,7 +151,7 @@ interface BaseFieldSchema<TSubtype = never> extends UIFieldMetadata {
   constraints?: FieldConstraints
   autocolumn?: boolean
   autoReason?: AutoReason.FOREIGN_KEY
-  subtype: TSubtype
+  subtype?: never
 }
 
 interface OtherFieldMetadata extends BaseFieldSchema {
@@ -164,6 +163,7 @@ interface OtherFieldMetadata extends BaseFieldSchema {
     | FieldType.FORMULA
     | FieldType.NUMBER
     | FieldType.LONGFORM
+    | FieldType.BB_REFERENCE
     | FieldType.ATTACHMENT
   >
 }
@@ -176,9 +176,9 @@ export type FieldSchema =
   | FormulaFieldMetadata
   | NumberFieldMetadata
   | LongFormFieldMetadata
-  | AttachmentFieldMetadata
   | BBReferenceFieldMetadata
   | JsonFieldMetadata
+  | AttachmentFieldMetadata
 
 export interface TableSchema {
   [key: string]: FieldSchema
@@ -213,3 +213,9 @@ export function isBBReferenceField(
 ): field is BBReferenceFieldMetadata {
   return field.type === FieldType.BB_REFERENCE
 }
+
+export function isAttachmentField(
+  field: FieldSchema
+): field is AttachmentFieldMetadata {
+  return field.type === FieldType.ATTACHMENT
+}

From 0859e79b1ed153870432104d4a4ff1bd8abd5a58 Mon Sep 17 00:00:00 2001
From: Adria Navarro <adria@budibase.com>
Date: Wed, 20 Mar 2024 23:19:42 +0100
Subject: [PATCH 19/24] Lint

---
 packages/server/src/utilities/rowProcessor/index.ts | 1 -
 1 file changed, 1 deletion(-)

diff --git a/packages/server/src/utilities/rowProcessor/index.ts b/packages/server/src/utilities/rowProcessor/index.ts
index 3ed4c5d903..0015680e77 100644
--- a/packages/server/src/utilities/rowProcessor/index.ts
+++ b/packages/server/src/utilities/rowProcessor/index.ts
@@ -6,7 +6,6 @@ import { TYPE_TRANSFORM_MAP } from "./map"
 import {
   FieldType,
   AutoFieldSubType,
-  FieldSubtype,
   Row,
   RowAttachment,
   Table,

From a6d38401414953a72ee42b0bd40826ea7a256cfa Mon Sep 17 00:00:00 2001
From: Adria Navarro <adria@budibase.com>
Date: Thu, 21 Mar 2024 11:28:06 +0100
Subject: [PATCH 20/24] Fix bundling

---
 packages/string-templates/src/helpers/list.ts | 39 ++++++++++++-------
 1 file changed, 26 insertions(+), 13 deletions(-)

diff --git a/packages/string-templates/src/helpers/list.ts b/packages/string-templates/src/helpers/list.ts
index 361558e04d..082d0e255b 100644
--- a/packages/string-templates/src/helpers/list.ts
+++ b/packages/string-templates/src/helpers/list.ts
@@ -1,17 +1,30 @@
 import { date, duration } from "./date"
 
+import {
+  math,
+  array,
+  number,
+  url,
+  string,
+  comparison,
+  object,
+  regex,
+  uuid,
+  // @ts-expect-error
+} from "@budibase/handlebars-helpers"
+
 // https://github.com/evanw/esbuild/issues/56
-const getExternalCollections = (): Record<string, () => any> => ({
-  math: require("@budibase/handlebars-helpers/lib/math"),
-  array: require("@budibase/handlebars-helpers/lib/array"),
-  number: require("@budibase/handlebars-helpers/lib/number"),
-  url: require("@budibase/handlebars-helpers/lib/url"),
-  string: require("@budibase/handlebars-helpers/lib/string"),
-  comparison: require("@budibase/handlebars-helpers/lib/comparison"),
-  object: require("@budibase/handlebars-helpers/lib/object"),
-  regex: require("@budibase/handlebars-helpers/lib/regex"),
-  uuid: require("@budibase/handlebars-helpers/lib/uuid"),
-})
+const externalCollections = {
+  math,
+  array,
+  number,
+  url,
+  string,
+  comparison,
+  object,
+  regex,
+  uuid,
+}
 
 export const helpersToRemoveForJs = ["sortBy"]
 
@@ -28,8 +41,8 @@ export function getJsHelperList() {
   }
 
   helpers = {}
-  for (let collection of Object.values(getExternalCollections())) {
-    for (let [key, func] of Object.entries(collection)) {
+  for (let collection of Object.values(externalCollections)) {
+    for (let [key, func] of Object.entries<any>(collection)) {
       // Handlebars injects the hbs options to the helpers by default. We are adding an empty {} as a last parameter to simulate it
       helpers[key] = (...props: any) => func(...props, {})
     }

From 1a8510358b80835809eea3529c0519c51cc28690 Mon Sep 17 00:00:00 2001
From: Adria Navarro <adria@budibase.com>
Date: Thu, 21 Mar 2024 11:43:50 +0100
Subject: [PATCH 21/24] Fix test

---
 packages/string-templates/src/helpers/list.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/string-templates/src/helpers/list.ts b/packages/string-templates/src/helpers/list.ts
index 082d0e255b..5852bc9127 100644
--- a/packages/string-templates/src/helpers/list.ts
+++ b/packages/string-templates/src/helpers/list.ts
@@ -42,7 +42,7 @@ export function getJsHelperList() {
 
   helpers = {}
   for (let collection of Object.values(externalCollections)) {
-    for (let [key, func] of Object.entries<any>(collection)) {
+    for (let [key, func] of Object.entries<any>(collection())) {
       // Handlebars injects the hbs options to the helpers by default. We are adding an empty {} as a last parameter to simulate it
       helpers[key] = (...props: any) => func(...props, {})
     }

From 08cf877565ee8f46a62b538af7a9340e93460049 Mon Sep 17 00:00:00 2001
From: Budibase Staging Release Bot <>
Date: Thu, 21 Mar 2024 11:02:04 +0000
Subject: [PATCH 22/24] Bump version to 2.22.8

---
 lerna.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lerna.json b/lerna.json
index 3a92bc6d9a..ec64523dff 100644
--- a/lerna.json
+++ b/lerna.json
@@ -1,5 +1,5 @@
 {
-  "version": "2.22.7",
+  "version": "2.22.8",
   "npmClient": "yarn",
   "packages": [
     "packages/*",

From a85d4460b1426629391159d41945057da8e842b0 Mon Sep 17 00:00:00 2001
From: Adria Navarro <adria@budibase.com>
Date: Thu, 21 Mar 2024 14:18:45 +0100
Subject: [PATCH 23/24] Clean code

---
 packages/server/src/api/controllers/table/utils.ts | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/packages/server/src/api/controllers/table/utils.ts b/packages/server/src/api/controllers/table/utils.ts
index ac13617869..0c9933a4cf 100644
--- a/packages/server/src/api/controllers/table/utils.ts
+++ b/packages/server/src/api/controllers/table/utils.ts
@@ -31,6 +31,7 @@ import {
   RelationshipFieldMetadata,
   FieldType,
   FieldTypeSubtypes,
+  AttachmentFieldMetadata,
 } from "@budibase/types"
 
 export async function clearColumns(table: Table, columnNames: string[]) {
@@ -90,11 +91,14 @@ export async function checkForColumnUpdates(
     await checkForViewUpdates(updatedTable, deletedColumns, columnRename)
   }
 
-  for (const attachmentColumn of Object.values(updatedTable.schema).filter(
-    column =>
+  const changedAttachmentSubtypeColumns = Object.values(
+    updatedTable.schema
+  ).filter(
+    (column): column is AttachmentFieldMetadata =>
       column.type === FieldType.ATTACHMENT &&
       column.subtype !== oldTable?.schema[column.name]?.subtype
-  )) {
+  )
+  for (const attachmentColumn of changedAttachmentSubtypeColumns) {
     if (attachmentColumn.subtype === FieldTypeSubtypes.ATTACHMENT.SINGLE) {
       attachmentColumn.constraints ??= { length: {} }
       attachmentColumn.constraints.length ??= {}

From ed94459fd8101d267729cf414c6b6eb829573cb3 Mon Sep 17 00:00:00 2001
From: Budibase Staging Release Bot <>
Date: Thu, 21 Mar 2024 13:31:53 +0000
Subject: [PATCH 24/24] Bump version to 2.22.9

---
 lerna.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lerna.json b/lerna.json
index ec64523dff..5a561bec04 100644
--- a/lerna.json
+++ b/lerna.json
@@ -1,5 +1,5 @@
 {
-  "version": "2.22.8",
+  "version": "2.22.9",
   "npmClient": "yarn",
   "packages": [
     "packages/*",