diff --git a/lerna.json b/lerna.json
index 10e7b8cdee..a0de97dc7a 100644
--- a/lerna.json
+++ b/lerna.json
@@ -1,6 +1,6 @@
 {
   "$schema": "node_modules/lerna/schemas/lerna-schema.json",
-  "version": "3.4.24",
+  "version": "3.5.0",
   "npmClient": "yarn",
   "concurrency": 20,
   "command": {
diff --git a/package.json b/package.json
index 1475abadf9..d083dbad90 100644
--- a/package.json
+++ b/package.json
@@ -18,7 +18,6 @@
     "eslint-plugin-jest": "28.9.0",
     "eslint-plugin-local-rules": "3.0.2",
     "eslint-plugin-svelte": "2.46.1",
-    "svelte-preprocess": "^6.0.3",
     "husky": "^8.0.3",
     "kill-port": "^1.6.1",
     "lerna": "7.4.2",
@@ -29,7 +28,9 @@
     "prettier-plugin-svelte": "^2.3.0",
     "proper-lockfile": "^4.1.2",
     "svelte": "4.2.19",
+    "svelte-check": "^4.1.5",
     "svelte-eslint-parser": "0.43.0",
+    "svelte-preprocess": "^6.0.3",
     "typescript": "5.7.2",
     "typescript-eslint": "8.17.0",
     "yargs": "^17.7.2"
diff --git a/packages/bbui/src/Form/Core/TextArea.svelte b/packages/bbui/src/Form/Core/TextArea.svelte
index 9b49f54f58..8e20f5828e 100644
--- a/packages/bbui/src/Form/Core/TextArea.svelte
+++ b/packages/bbui/src/Form/Core/TextArea.svelte
@@ -1,14 +1,14 @@
-<script>
+<script lang="ts">
   import "@spectrum-css/textfield/dist/index-vars.css"
   import { createEventDispatcher } from "svelte"
 
   export let value = ""
-  export let placeholder = null
+  export let placeholder: string | undefined = undefined
   export let disabled = false
   export let readonly = false
-  export let id = null
-  export let height = null
-  export let minHeight = null
+  export let id: string | undefined = undefined
+  export let height: string | number | undefined = undefined
+  export let minHeight: string | number | undefined = undefined
   export const getCaretPosition = () => ({
     start: textarea.selectionStart,
     end: textarea.selectionEnd,
@@ -16,18 +16,21 @@
   export let align = null
 
   let focus = false
-  let textarea
+  let textarea: any
   const dispatch = createEventDispatcher()
-  const onChange = event => {
+  const onChange = (event: any) => {
     dispatch("change", event.target.value)
     focus = false
   }
 
-  const getStyleString = (attribute, value) => {
+  const getStyleString = (
+    attribute: string,
+    value: string | number | undefined
+  ) => {
     if (!attribute || value == null) {
       return ""
     }
-    if (isNaN(value)) {
+    if (typeof value === "number" && isNaN(value)) {
       return `${attribute}:${value};`
     }
     return `${attribute}:${value}px;`
diff --git a/packages/bbui/src/Form/TextArea.svelte b/packages/bbui/src/Form/TextArea.svelte
index 15e91d72c1..c803643e6e 100644
--- a/packages/bbui/src/Form/TextArea.svelte
+++ b/packages/bbui/src/Form/TextArea.svelte
@@ -1,21 +1,21 @@
-<script>
+<script lang="ts">
   import Field from "./Field.svelte"
   import TextArea from "./Core/TextArea.svelte"
   import { createEventDispatcher } from "svelte"
 
-  export let value = null
-  export let label = null
-  export let labelPosition = "above"
-  export let placeholder = null
+  export let value: string | undefined = undefined
+  export let label: string | undefined = undefined
+  export let labelPosition: string = "above"
+  export let placeholder: string | undefined = undefined
   export let disabled = false
-  export let error = null
-  export let getCaretPosition = null
-  export let height = null
-  export let minHeight = null
-  export let helpText = null
+  export let error: string | undefined = undefined
+  export let getCaretPosition: any = undefined
+  export let height: string | number | undefined = undefined
+  export let minHeight: string | number | undefined = undefined
+  export let helpText: string | undefined = undefined
 
   const dispatch = createEventDispatcher()
-  const onChange = e => {
+  const onChange = (e: any) => {
     value = e.detail
     dispatch("change", e.detail)
   }
@@ -24,7 +24,6 @@
 <Field {helpText} {label} {labelPosition} {error}>
   <TextArea
     bind:getCaretPosition
-    {error}
     {disabled}
     {value}
     {placeholder}
diff --git a/packages/bbui/src/InlineAlert/InlineAlert.svelte b/packages/bbui/src/InlineAlert/InlineAlert.svelte
index edfa760eb8..34a286e670 100644
--- a/packages/bbui/src/InlineAlert/InlineAlert.svelte
+++ b/packages/bbui/src/InlineAlert/InlineAlert.svelte
@@ -1,6 +1,7 @@
 <script>
   import "@spectrum-css/inlinealert/dist/index-vars.css"
   import Button from "../Button/Button.svelte"
+  import Icon from "../Icon/Icon.svelte"
 
   export let type = "info"
   export let header = ""
@@ -8,6 +9,8 @@
   export let onConfirm = undefined
   export let buttonText = ""
   export let cta = false
+  export let link = ""
+  export let linkText = ""
 
   $: icon = selectIcon(type)
   // if newlines used, convert them to different elements
@@ -49,6 +52,19 @@
       >
     </div>
   {/if}
+  {#if link && linkText}
+    <div id="docs-link">
+      <a
+        href={link}
+        target="_blank"
+        rel="noopener noreferrer"
+        class="docs-link"
+      >
+        {linkText}
+        <Icon name="LinkOut" size="XS" />
+      </a>
+    </div>
+  {/if}
 </div>
 
 <style>
@@ -64,4 +80,21 @@
     margin: 0;
     border-width: 1px;
   }
+
+  a {
+    color: white;
+  }
+
+  #docs-link {
+    padding-top: 10px;
+    display: flex;
+    align-items: center;
+    gap: 5px;
+  }
+
+  #docs-link > * {
+    display: flex;
+    align-items: center;
+    gap: 5px;
+  }
 </style>
diff --git a/packages/bbui/src/Tabs/Tab.svelte b/packages/bbui/src/Tabs/Tab.svelte
index 3ae6adfac4..9310abdd3b 100644
--- a/packages/bbui/src/Tabs/Tab.svelte
+++ b/packages/bbui/src/Tabs/Tab.svelte
@@ -4,7 +4,7 @@
 
   export let title
   export let icon = ""
-  export let id
+  export let id = undefined
   export let href = "#"
   export let link = false
 
diff --git a/packages/builder/package.json b/packages/builder/package.json
index a70d19209e..ee121cdf14 100644
--- a/packages/builder/package.json
+++ b/packages/builder/package.json
@@ -100,7 +100,6 @@
     "jest": "29.7.0",
     "jsdom": "^21.1.1",
     "resize-observer-polyfill": "^1.5.1",
-    "svelte-check": "^4.1.0",
     "svelte-jester": "^1.3.2",
     "vite": "^4.5.0",
     "vite-plugin-static-copy": "^0.17.0",
diff --git a/packages/builder/src/components/backend/DatasourceNavigator/modals/ImportRestQueriesModal.svelte b/packages/builder/src/components/backend/DatasourceNavigator/modals/ImportRestQueriesModal.svelte
deleted file mode 100644
index 37610061ac..0000000000
--- a/packages/builder/src/components/backend/DatasourceNavigator/modals/ImportRestQueriesModal.svelte
+++ /dev/null
@@ -1,132 +0,0 @@
-<script>
-  import { goto } from "@roxi/routify"
-  import {
-    keepOpen,
-    ModalContent,
-    notifications,
-    Body,
-    Layout,
-    Tabs,
-    Tab,
-    Heading,
-    TextArea,
-    Dropzone,
-  } from "@budibase/bbui"
-  import { datasources, queries } from "@/stores/builder"
-  import { writable } from "svelte/store"
-
-  export let navigateDatasource = false
-  export let datasourceId
-  export let createDatasource = false
-  export let onCancel
-
-  const data = writable({
-    url: "",
-    raw: "",
-    file: undefined,
-  })
-
-  let lastTouched = "url"
-
-  const getData = async () => {
-    let dataString
-
-    // parse the file into memory and send as string
-    if (lastTouched === "file") {
-      dataString = await $data.file.text()
-    } else if (lastTouched === "url") {
-      const response = await fetch($data.url)
-      dataString = await response.text()
-    } else if (lastTouched === "raw") {
-      dataString = $data.raw
-    }
-
-    return dataString
-  }
-
-  async function importQueries() {
-    try {
-      const dataString = await getData()
-
-      if (!datasourceId && !createDatasource) {
-        throw new Error("No datasource id")
-      }
-
-      const body = {
-        data: dataString,
-        datasourceId,
-      }
-
-      const importResult = await queries.import(body)
-      if (!datasourceId) {
-        datasourceId = importResult.datasourceId
-      }
-
-      // reload
-      await datasources.fetch()
-      await queries.fetch()
-
-      if (navigateDatasource) {
-        $goto(`./datasource/${datasourceId}`)
-      }
-
-      notifications.success(`Imported successfully.`)
-    } catch (error) {
-      notifications.error("Error importing queries")
-      return keepOpen
-    }
-  }
-</script>
-
-<ModalContent
-  onConfirm={() => importQueries()}
-  {onCancel}
-  confirmText={"Import"}
-  cancelText="Back"
-  size="L"
->
-  <Layout noPadding>
-    <Heading size="S">Import</Heading>
-    <Body size="XS"
-      >Import your rest collection using one of the options below</Body
-    >
-    <Tabs selected="File">
-      <!-- Commenting until nginx csp issue resolved -->
-      <!-- <Tab title="Link">
-        <Input
-          bind:value={$data.url}
-          on:change={() => (lastTouched = "url")}
-          label="Enter a URL"
-          placeholder="e.g. https://petstore.swagger.io/v2/swagger.json"
-        />
-      </Tab> -->
-      <Tab title="File">
-        <Dropzone
-          gallery={false}
-          value={$data.file ? [$data.file] : []}
-          on:change={e => {
-            $data.file = e.detail?.[0]
-            lastTouched = "file"
-          }}
-          fileTags={[
-            "OpenAPI 3.0",
-            "OpenAPI 2.0",
-            "Swagger 2.0",
-            "cURL",
-            "YAML",
-            "JSON",
-          ]}
-          maximum={1}
-        />
-      </Tab>
-      <Tab title="Raw Text">
-        <TextArea
-          bind:value={$data.raw}
-          on:change={() => (lastTouched = "raw")}
-          label={"Paste raw text"}
-          placeholder={'e.g. curl --location --request GET "https://example.com"'}
-        />
-      </Tab>
-    </Tabs>
-  </Layout>
-</ModalContent>
diff --git a/packages/builder/src/components/common/CodeEditor/CodeEditor.svelte b/packages/builder/src/components/common/CodeEditor/CodeEditor.svelte
index d22cda52ad..0127e31def 100644
--- a/packages/builder/src/components/common/CodeEditor/CodeEditor.svelte
+++ b/packages/builder/src/components/common/CodeEditor/CodeEditor.svelte
@@ -280,16 +280,15 @@
         EditorView.inputHandler.of((view, from, to, insert) => {
           if (jsBindingWrapping && insert === "$") {
             let { text } = view.state.doc.lineAt(from)
-
             const left = from ? text.substring(0, from) : ""
             const right = to ? text.substring(to) : ""
-            const wrap = !left.includes('$("') || !right.includes('")')
+            const wrap =
+              (!left.includes('$("') || !right.includes('")')) &&
+              !(left.includes("`") && right.includes("`"))
+            const anchor = from + (wrap ? 3 : 1)
             const tr = view.state.update(
               {
                 changes: [{ from, insert: wrap ? '$("")' : "$" }],
-                selection: {
-                  anchor: from + (wrap ? 3 : 1),
-                },
               },
               {
                 scrollIntoView: true,
@@ -297,6 +296,19 @@
               }
             )
             view.dispatch(tr)
+            // the selection needs to fired after the dispatch - this seems
+            // to fix an issue with the cursor not moving when the editor is
+            // first loaded, the first usage of the editor is not ready
+            // for the anchor to move as well as perform a change
+            setTimeout(() => {
+              view.dispatch(
+                view.state.update({
+                  selection: {
+                    anchor,
+                  },
+                })
+              )
+            }, 1)
             return true
           }
           return false
@@ -421,6 +433,7 @@
   .code-editor {
     font-size: 12px;
     height: 100%;
+    cursor: text;
   }
   .code-editor :global(.cm-editor) {
     height: 100%;
diff --git a/packages/builder/src/components/design/settings/controls/ButtonActionEditor/actions/ClearRowSelection.svelte b/packages/builder/src/components/design/settings/controls/ButtonActionEditor/actions/ClearRowSelection.svelte
index cd289e3f61..758cf0dab8 100644
--- a/packages/builder/src/components/design/settings/controls/ButtonActionEditor/actions/ClearRowSelection.svelte
+++ b/packages/builder/src/components/design/settings/controls/ButtonActionEditor/actions/ClearRowSelection.svelte
@@ -2,6 +2,7 @@
   import { Label, Select, Body } from "@budibase/bbui"
   import { findAllMatchingComponents } from "@/helpers/components"
   import { selectedScreen } from "@/stores/builder"
+  import { InlineAlert } from "@budibase/bbui"
 
   export let parameters
 
@@ -27,6 +28,12 @@
     <Label small>Table</Label>
     <Select bind:value={parameters.componentId} options={componentOptions} />
   </div>
+  <InlineAlert
+    header="Legacy action"
+    message="This action is only compatible with the (deprecated) Table Block. Please see the documentation for further info."
+    link="https://docs.budibase.com/docs/data-actions#clear-row-selection"
+    linkText="Budibase Documentation"
+  />
 </div>
 
 <style>
diff --git a/packages/builder/src/pages/builder/app/[application]/data/datasource/[datasourceId]/_components/panels/Queries/RestImportQueriesModal.svelte b/packages/builder/src/pages/builder/app/[application]/data/datasource/[datasourceId]/_components/panels/Queries/RestImportQueriesModal.svelte
index dd90acf367..b144ed64b9 100644
--- a/packages/builder/src/pages/builder/app/[application]/data/datasource/[datasourceId]/_components/panels/Queries/RestImportQueriesModal.svelte
+++ b/packages/builder/src/pages/builder/app/[application]/data/datasource/[datasourceId]/_components/panels/Queries/RestImportQueriesModal.svelte
@@ -1,4 +1,4 @@
-<script>
+<script lang="ts">
   import { goto } from "@roxi/routify"
   import {
     keepOpen,
@@ -14,13 +14,14 @@
   } from "@budibase/bbui"
   import { datasources, queries } from "@/stores/builder"
   import { writable } from "svelte/store"
+  import type { Datasource } from "@budibase/types"
 
   export let navigateDatasource = false
-  export let datasourceId
+  export let datasourceId: string | undefined = undefined
   export let createDatasource = false
-  export let onCancel
+  export let onCancel: (() => void) | undefined = undefined
 
-  const data = writable({
+  const data = writable<{ url: string; raw: string; file?: any }>({
     url: "",
     raw: "",
     file: undefined,
@@ -28,12 +29,14 @@
 
   let lastTouched = "url"
 
-  const getData = async () => {
+  $: datasource = $datasources.selected as Datasource
+
+  const getData = async (): Promise<string> => {
     let dataString
 
     // parse the file into memory and send as string
     if (lastTouched === "file") {
-      dataString = await $data.file.text()
+      dataString = await $data.file?.text()
     } else if (lastTouched === "url") {
       const response = await fetch($data.url)
       dataString = await response.text()
@@ -55,9 +58,9 @@
       const body = {
         data: dataString,
         datasourceId,
+        datasource,
       }
-
-      const importResult = await queries.import(body)
+      const importResult = await queries.importQueries(body)
       if (!datasourceId) {
         datasourceId = importResult.datasourceId
       }
@@ -71,8 +74,8 @@
       }
 
       notifications.success("Imported successfully")
-    } catch (error) {
-      notifications.error("Error importing queries")
+    } catch (error: any) {
+      notifications.error(`Error importing queries - ${error.message}`)
 
       return keepOpen
     }
diff --git a/packages/client/package.json b/packages/client/package.json
index a7ea04fd0b..daaf0ca433 100644
--- a/packages/client/package.json
+++ b/packages/client/package.json
@@ -16,7 +16,8 @@
   },
   "scripts": {
     "build": "vite build",
-    "dev": "vite build --watch --mode=dev"
+    "dev": "vite build --watch --mode=dev",
+    "check:types": "yarn svelte-check"
   },
   "dependencies": {
     "@budibase/bbui": "*",
diff --git a/packages/client/src/api/api.ts b/packages/client/src/api/api.ts
index 564f401164..85194f6ac7 100644
--- a/packages/client/src/api/api.ts
+++ b/packages/client/src/api/api.ts
@@ -10,7 +10,9 @@ export const API = createAPIClient({
   // Attach client specific headers
   attachHeaders: headers => {
     // Attach app ID header
-    headers["x-budibase-app-id"] = window["##BUDIBASE_APP_ID##"]
+    if (window["##BUDIBASE_APP_ID##"]) {
+      headers["x-budibase-app-id"] = window["##BUDIBASE_APP_ID##"]
+    }
 
     // Attach client header if not inside the builder preview
     if (!window["##BUDIBASE_IN_BUILDER##"]) {
diff --git a/packages/client/src/components/app/SpectrumCard.svelte b/packages/client/src/components/app/SpectrumCard.svelte
index 9cc8e81891..f5d4c7b217 100644
--- a/packages/client/src/components/app/SpectrumCard.svelte
+++ b/packages/client/src/components/app/SpectrumCard.svelte
@@ -141,6 +141,7 @@
       var(--spectrum-global-dimension-size-300)
     );
     display: -webkit-box;
+    line-clamp: 2;
     -webkit-line-clamp: 2;
     -webkit-box-orient: vertical;
     overflow: hidden;
diff --git a/packages/client/src/components/preview/DNDHandler.svelte b/packages/client/src/components/preview/DNDHandler.svelte
index abb5925eed..6ab58b84fa 100644
--- a/packages/client/src/components/preview/DNDHandler.svelte
+++ b/packages/client/src/components/preview/DNDHandler.svelte
@@ -7,6 +7,7 @@
   import { isGridEvent } from "@/utils/grid"
   import { DNDPlaceholderID } from "@/constants"
   import type { Component } from "@budibase/types"
+  import { DropPosition } from "@budibase/types"
 
   type ChildCoords = {
     placeholder: boolean
@@ -287,7 +288,7 @@
     }
 
     // Convert parent + index into target + mode
-    let legacyDropTarget, legacyDropMode
+    let legacyDropTarget, legacyDropMode: DropPosition
     const parent: Component | null = findComponentById(
       get(screenStore).activeScreen?.props,
       drop.parent
@@ -309,16 +310,16 @@
     // Use inside if no existing children
     if (!children?.length) {
       legacyDropTarget = parent._id
-      legacyDropMode = "inside"
+      legacyDropMode = DropPosition.INSIDE
     } else if (drop.index === 0) {
       legacyDropTarget = children[0]?._id
-      legacyDropMode = "above"
+      legacyDropMode = DropPosition.ABOVE
     } else {
       legacyDropTarget = children[drop.index - 1]?._id
-      legacyDropMode = "below"
+      legacyDropMode = DropPosition.BELOW
     }
 
-    if (legacyDropTarget && legacyDropMode) {
+    if (legacyDropTarget && legacyDropMode && source.id) {
       dropping = true
       await builderStore.actions.moveComponent(
         source.id,
diff --git a/packages/client/src/components/preview/GridDNDHandler.svelte b/packages/client/src/components/preview/GridDNDHandler.svelte
index e5297e9208..73a55b8ab3 100644
--- a/packages/client/src/components/preview/GridDNDHandler.svelte
+++ b/packages/client/src/components/preview/GridDNDHandler.svelte
@@ -17,6 +17,7 @@
     Devices,
     GridDragMode,
   } from "@/utils/grid"
+  import { DropPosition } from "@budibase/types"
 
   type GridDragSide =
     | "top"
@@ -222,7 +223,7 @@
 
     // If holding ctrl/cmd then leave behind a duplicate of this component
     if (mode === GridDragMode.Move && (e.ctrlKey || e.metaKey)) {
-      builderStore.actions.duplicateComponent(id, "above", false)
+      builderStore.actions.duplicateComponent(id, DropPosition.ABOVE, false)
     }
 
     // Find grid parent and read from DOM
diff --git a/packages/client/src/stores/builder.ts b/packages/client/src/stores/builder.ts
index 36ba7fffb8..9c23395cf6 100644
--- a/packages/client/src/stores/builder.ts
+++ b/packages/client/src/stores/builder.ts
@@ -115,7 +115,7 @@ const createBuilderStore = () => {
       component: string,
       parent: string,
       index: number,
-      props: Record<string, any>
+      props?: Record<string, any>
     ) => {
       eventStore.actions.dispatchEvent("drop-new-component", {
         component,
diff --git a/packages/client/tsconfig.json b/packages/client/tsconfig.json
index ab07343525..f5bffcf04d 100644
--- a/packages/client/tsconfig.json
+++ b/packages/client/tsconfig.json
@@ -7,6 +7,7 @@
     "target": "ESNext",
     "moduleResolution": "bundler",
     "resolveJsonModule": true,
+    "skipLibCheck": true,
     "paths": {
       "@budibase/*": [
         "../*/src/index.ts",
diff --git a/packages/frontend-core/package.json b/packages/frontend-core/package.json
index b1f311183a..25c464d49c 100644
--- a/packages/frontend-core/package.json
+++ b/packages/frontend-core/package.json
@@ -16,8 +16,5 @@
     "lodash": "4.17.21",
     "shortid": "2.2.15",
     "socket.io-client": "^4.7.5"
-  },
-  "devDependencies": {
-    "svelte-check": "^4.1.0"
   }
 }
diff --git a/packages/frontend-core/src/fetch/DataFetch.ts b/packages/frontend-core/src/fetch/DataFetch.ts
index 298413b1e8..cbc9972484 100644
--- a/packages/frontend-core/src/fetch/DataFetch.ts
+++ b/packages/frontend-core/src/fetch/DataFetch.ts
@@ -8,7 +8,6 @@ import {
   Row,
   SearchFilters,
   SortOrder,
-  SortType,
   TableSchema,
 } from "@budibase/types"
 import { APIClient } from "../api/types"
@@ -72,8 +71,6 @@ export default abstract class BaseDataFetch<
   options: DataFetchOptions<TQuery> & {
     datasource: TDatasource
 
-    sortType: SortType | null
-
     // Client side feature customisation
     clientSideSearching: boolean
     clientSideSorting: boolean
@@ -106,7 +103,6 @@ export default abstract class BaseDataFetch<
       // Sorting config
       sortColumn: null,
       sortOrder: SortOrder.ASCENDING,
-      sortType: null,
 
       // Pagination config
       paginate: true,
@@ -227,31 +223,12 @@ export default abstract class BaseDataFetch<
       this.options.sortColumn = this.getDefaultSortColumn(definition, schema)
     }
 
-    // If we don't have a sort column specified then just ensure we don't set
-    // any sorting params
-    if (!this.options.sortColumn) {
+    // If no sort order, default to ascending
+    if (!this.options.sortOrder) {
       this.options.sortOrder = SortOrder.ASCENDING
-      this.options.sortType = null
     } else {
-      // Otherwise determine what sort type to use base on sort column
-      this.options.sortType = SortType.STRING
-      const fieldSchema = schema?.[this.options.sortColumn]
-      if (
-        fieldSchema?.type === FieldType.NUMBER ||
-        fieldSchema?.type === FieldType.BIGINT ||
-        ("calculationType" in fieldSchema && fieldSchema?.calculationType)
-      ) {
-        this.options.sortType = SortType.NUMBER
-      }
-
-      // If no sort order, default to ascending
-      if (!this.options.sortOrder) {
-        this.options.sortOrder = SortOrder.ASCENDING
-      } else {
-        // Ensure sortOrder matches the enum
-        this.options.sortOrder =
-          this.options.sortOrder.toLowerCase() as SortOrder
-      }
+      // Ensure sortOrder matches the enum
+      this.options.sortOrder = this.options.sortOrder.toLowerCase() as SortOrder
     }
 
     // Build the query
@@ -294,7 +271,6 @@ export default abstract class BaseDataFetch<
     const {
       sortColumn,
       sortOrder,
-      sortType,
       limit,
       clientSideSearching,
       clientSideSorting,
@@ -311,8 +287,8 @@ export default abstract class BaseDataFetch<
     }
 
     // If we don't support sorting, do a client-side sort
-    if (!this.features.supportsSort && clientSideSorting && sortType) {
-      rows = sort(rows, sortColumn as any, sortOrder, sortType)
+    if (!this.features.supportsSort && clientSideSorting && sortColumn) {
+      rows = sort(rows, sortColumn, sortOrder)
     }
 
     // If we don't support pagination, do a client-side limit
diff --git a/packages/frontend-core/src/fetch/TableFetch.ts b/packages/frontend-core/src/fetch/TableFetch.ts
index a6f92c0ab3..59bfc588f5 100644
--- a/packages/frontend-core/src/fetch/TableFetch.ts
+++ b/packages/frontend-core/src/fetch/TableFetch.ts
@@ -29,8 +29,7 @@ export default class TableFetch extends BaseDataFetch<TableDatasource, Table> {
   }
 
   async getData() {
-    const { datasource, limit, sortColumn, sortOrder, sortType, paginate } =
-      this.options
+    const { datasource, limit, sortColumn, sortOrder, paginate } = this.options
     const { tableId } = datasource
     const { cursor, query } = get(this.store)
 
@@ -41,7 +40,6 @@ export default class TableFetch extends BaseDataFetch<TableDatasource, Table> {
         limit,
         sort: sortColumn,
         sortOrder: sortOrder ?? SortOrder.ASCENDING,
-        sortType,
         paginate,
         bookmark: cursor,
       })
diff --git a/packages/frontend-core/src/fetch/ViewV2Fetch.ts b/packages/frontend-core/src/fetch/ViewV2Fetch.ts
index fd2eab2d53..4495450a23 100644
--- a/packages/frontend-core/src/fetch/ViewV2Fetch.ts
+++ b/packages/frontend-core/src/fetch/ViewV2Fetch.ts
@@ -1,4 +1,5 @@
 import {
+  SearchViewRowRequest,
   SortOrder,
   ViewDatasource,
   ViewV2Enriched,
@@ -40,8 +41,7 @@ export default class ViewV2Fetch extends BaseDataFetch<
   }
 
   async getData() {
-    const { datasource, limit, sortColumn, sortOrder, sortType, paginate } =
-      this.options
+    const { datasource, limit, sortColumn, sortOrder, paginate } = this.options
     const { cursor, query, definition } = get(this.store)
 
     // If this is a calculation view and we have no calculations, return nothing
@@ -68,14 +68,13 @@ export default class ViewV2Fetch extends BaseDataFetch<
     }
 
     try {
-      const request = {
+      const request: SearchViewRowRequest = {
         query,
         paginate,
         limit,
         bookmark: cursor,
         sort: sortColumn,
         sortOrder: sortOrder,
-        sortType,
       }
       if (paginate) {
         const res = await this.API.viewV2.fetch(datasource.id, {
diff --git a/packages/frontend-core/src/index.ts b/packages/frontend-core/src/index.ts
index cd668b77e7..768bd7b70a 100644
--- a/packages/frontend-core/src/index.ts
+++ b/packages/frontend-core/src/index.ts
@@ -1,6 +1,6 @@
 export { createAPIClient } from "./api"
 export type { APIClient } from "./api"
-export { fetchData, DataFetchMap } from "./fetch"
+export { fetchData, DataFetchMap, type DataFetchType } from "./fetch"
 export * as Constants from "./constants"
 export * from "./stores"
 export * from "./utils"
diff --git a/packages/frontend-core/svelte.config.mjs b/packages/frontend-core/svelte.config.mjs
new file mode 100644
index 0000000000..af7d74ea4b
--- /dev/null
+++ b/packages/frontend-core/svelte.config.mjs
@@ -0,0 +1,7 @@
+import { vitePreprocess } from "@sveltejs/vite-plugin-svelte"
+
+const config = {
+  preprocess: vitePreprocess(),
+}
+
+export default config
diff --git a/packages/server/src/api/controllers/row/index.ts b/packages/server/src/api/controllers/row/index.ts
index 8f4629a5b0..07ed4172ab 100644
--- a/packages/server/src/api/controllers/row/index.ts
+++ b/packages/server/src/api/controllers/row/index.ts
@@ -263,7 +263,6 @@ export async function search(ctx: Ctx<SearchRowRequest, SearchRowResponse>) {
     limit: searchRequest.limit,
     sort: searchRequest.sort ?? undefined,
     sortOrder: searchRequest.sortOrder,
-    sortType: searchRequest.sortType ?? undefined,
     countRows: searchRequest.countRows,
     version: searchRequest.version,
     disableEscaping: searchRequest.disableEscaping,
diff --git a/packages/server/src/api/controllers/row/views.ts b/packages/server/src/api/controllers/row/views.ts
index 418aa462c4..78931c5d4d 100644
--- a/packages/server/src/api/controllers/row/views.ts
+++ b/packages/server/src/api/controllers/row/views.ts
@@ -63,14 +63,12 @@ function getSortOptions(request: SearchViewRowRequest, view: ViewV2) {
     return {
       sort: request.sort,
       sortOrder: request.sortOrder,
-      sortType: request.sortType ?? undefined,
     }
   }
   if (view.sort) {
     return {
       sort: view.sort.field,
       sortOrder: view.sort.order,
-      sortType: view.sort.type,
     }
   }
 
diff --git a/packages/server/src/api/routes/tests/search.spec.ts b/packages/server/src/api/routes/tests/search.spec.ts
index e115297ee9..cf7c7cf9fa 100644
--- a/packages/server/src/api/routes/tests/search.spec.ts
+++ b/packages/server/src/api/routes/tests/search.spec.ts
@@ -38,7 +38,7 @@ import {
 import _ from "lodash"
 import tk from "timekeeper"
 import { encodeJSBinding } from "@budibase/string-templates"
-import { dataFilters } from "@budibase/shared-core"
+import { dataFilters, InMemorySearchQuery } from "@budibase/shared-core"
 import { Knex } from "knex"
 import { generator, structures, mocks } from "@budibase/backend-core/tests"
 import { DEFAULT_EMPLOYEE_TABLE_SCHEMA } from "../../../db/defaultData/datasource_bb_default"
@@ -200,31 +200,26 @@ if (descriptions.length) {
             const isView = sourceType === "view"
 
             class SearchAssertion {
-              constructor(private readonly query: SearchRowRequest) {}
+              constructor(
+                private readonly query: SearchRowRequest & {
+                  sortType?: SortType
+                }
+              ) {}
 
               private async performSearch(): Promise<SearchResponse<Row>> {
                 if (isInMemory) {
-                  const inMemoryQuery: RequiredKeys<
-                    Omit<RowSearchParams, "tableId">
-                  > = {
+                  const inMemoryQuery: RequiredKeys<InMemorySearchQuery> = {
                     sort: this.query.sort ?? undefined,
                     query: { ...this.query.query },
-                    paginate: this.query.paginate,
-                    bookmark: this.query.bookmark ?? undefined,
                     limit: this.query.limit,
                     sortOrder: this.query.sortOrder,
                     sortType: this.query.sortType ?? undefined,
-                    version: this.query.version,
-                    disableEscaping: this.query.disableEscaping,
                     countRows: this.query.countRows,
-                    viewId: undefined,
-                    fields: undefined,
-                    indexer: undefined,
-                    rows: undefined,
                   }
                   return dataFilters.search(_.cloneDeep(rows), inMemoryQuery)
                 } else {
-                  return config.api.row.search(tableOrViewId, this.query)
+                  const { sortType, ...query } = this.query
+                  return config.api.row.search(tableOrViewId, query)
                 }
               }
 
@@ -400,7 +395,9 @@ if (descriptions.length) {
               }
             }
 
-            function expectSearch(query: SearchRowRequest) {
+            function expectSearch(
+              query: SearchRowRequest & { sortType?: SortType }
+            ) {
               return new SearchAssertion(query)
             }
 
@@ -1119,25 +1116,26 @@ if (descriptions.length) {
                   }).toMatchExactly([{ name: "foo" }, { name: "bar" }])
                 })
 
-                describe("sortType STRING", () => {
-                  it("sorts ascending", async () => {
-                    await expectSearch({
-                      query: {},
-                      sort: "name",
-                      sortType: SortType.STRING,
-                      sortOrder: SortOrder.ASCENDING,
-                    }).toMatchExactly([{ name: "bar" }, { name: "foo" }])
-                  })
+                isInMemory &&
+                  describe("sortType STRING", () => {
+                    it("sorts ascending", async () => {
+                      await expectSearch({
+                        query: {},
+                        sort: "name",
+                        sortType: SortType.STRING,
+                        sortOrder: SortOrder.ASCENDING,
+                      }).toMatchExactly([{ name: "bar" }, { name: "foo" }])
+                    })
 
-                  it("sorts descending", async () => {
-                    await expectSearch({
-                      query: {},
-                      sort: "name",
-                      sortType: SortType.STRING,
-                      sortOrder: SortOrder.DESCENDING,
-                    }).toMatchExactly([{ name: "foo" }, { name: "bar" }])
+                    it("sorts descending", async () => {
+                      await expectSearch({
+                        query: {},
+                        sort: "name",
+                        sortType: SortType.STRING,
+                        sortOrder: SortOrder.DESCENDING,
+                      }).toMatchExactly([{ name: "foo" }, { name: "bar" }])
+                    })
                   })
-                })
 
                 !isInternal &&
                   !isInMemory &&
@@ -1319,25 +1317,26 @@ if (descriptions.length) {
                 })
               })
 
-              describe("sortType NUMBER", () => {
-                it("sorts ascending", async () => {
-                  await expectSearch({
-                    query: {},
-                    sort: "age",
-                    sortType: SortType.NUMBER,
-                    sortOrder: SortOrder.ASCENDING,
-                  }).toMatchExactly([{ age: 1 }, { age: 10 }])
-                })
+              isInMemory &&
+                describe("sortType NUMBER", () => {
+                  it("sorts ascending", async () => {
+                    await expectSearch({
+                      query: {},
+                      sort: "age",
+                      sortType: SortType.NUMBER,
+                      sortOrder: SortOrder.ASCENDING,
+                    }).toMatchExactly([{ age: 1 }, { age: 10 }])
+                  })
 
-                it("sorts descending", async () => {
-                  await expectSearch({
-                    query: {},
-                    sort: "age",
-                    sortType: SortType.NUMBER,
-                    sortOrder: SortOrder.DESCENDING,
-                  }).toMatchExactly([{ age: 10 }, { age: 1 }])
+                  it("sorts descending", async () => {
+                    await expectSearch({
+                      query: {},
+                      sort: "age",
+                      sortType: SortType.NUMBER,
+                      sortOrder: SortOrder.DESCENDING,
+                    }).toMatchExactly([{ age: 10 }, { age: 1 }])
+                  })
                 })
-              })
             })
 
             describe("dates", () => {
@@ -1473,25 +1472,26 @@ if (descriptions.length) {
                   }).toMatchExactly([{ dob: JAN_10TH }, { dob: JAN_1ST }])
                 })
 
-                describe("sortType STRING", () => {
-                  it("sorts ascending", async () => {
-                    await expectSearch({
-                      query: {},
-                      sort: "dob",
-                      sortType: SortType.STRING,
-                      sortOrder: SortOrder.ASCENDING,
-                    }).toMatchExactly([{ dob: JAN_1ST }, { dob: JAN_10TH }])
-                  })
+                isInMemory &&
+                  describe("sortType STRING", () => {
+                    it("sorts ascending", async () => {
+                      await expectSearch({
+                        query: {},
+                        sort: "dob",
+                        sortType: SortType.STRING,
+                        sortOrder: SortOrder.ASCENDING,
+                      }).toMatchExactly([{ dob: JAN_1ST }, { dob: JAN_10TH }])
+                    })
 
-                  it("sorts descending", async () => {
-                    await expectSearch({
-                      query: {},
-                      sort: "dob",
-                      sortType: SortType.STRING,
-                      sortOrder: SortOrder.DESCENDING,
-                    }).toMatchExactly([{ dob: JAN_10TH }, { dob: JAN_1ST }])
+                    it("sorts descending", async () => {
+                      await expectSearch({
+                        query: {},
+                        sort: "dob",
+                        sortType: SortType.STRING,
+                        sortOrder: SortOrder.DESCENDING,
+                      }).toMatchExactly([{ dob: JAN_10TH }, { dob: JAN_1ST }])
+                    })
                   })
-                })
               })
             })
 
@@ -1639,220 +1639,196 @@ if (descriptions.length) {
                     ])
                   })
 
-                  describe("sortType STRING", () => {
-                    it("sorts ascending", async () => {
-                      await expectSearch({
-                        query: {},
-                        sort: "time",
-                        sortType: SortType.STRING,
-                        sortOrder: SortOrder.ASCENDING,
-                      }).toMatchExactly([
-                        { timeid: NULL_TIME__ID },
-                        { time: "00:00:00" },
-                        { time: "10:00:00" },
-                        { time: "10:45:00" },
-                        { time: "12:00:00" },
-                        { time: "15:30:00" },
-                      ])
-                    })
-
-                    it("sorts descending", async () => {
-                      await expectSearch({
-                        query: {},
-                        sort: "time",
-                        sortType: SortType.STRING,
-                        sortOrder: SortOrder.DESCENDING,
-                      }).toMatchExactly([
-                        { time: "15:30:00" },
-                        { time: "12:00:00" },
-                        { time: "10:45:00" },
-                        { time: "10:00:00" },
-                        { time: "00:00:00" },
-                        { timeid: NULL_TIME__ID },
-                      ])
-                    })
-                  })
-                })
-              })
-
-            describe("datetime - date only", () => {
-              describe.each([true, false])(
-                "saved with timestamp: %s",
-                saveWithTimestamp => {
-                  describe.each([true, false])(
-                    "search with timestamp: %s",
-                    searchWithTimestamp => {
-                      const SAVE_SUFFIX = saveWithTimestamp
-                        ? "T00:00:00.000Z"
-                        : ""
-                      const SEARCH_SUFFIX = searchWithTimestamp
-                        ? "T00:00:00.000Z"
-                        : ""
-
-                      const JAN_1ST = `2020-01-01`
-                      const JAN_10TH = `2020-01-10`
-                      const JAN_30TH = `2020-01-30`
-                      const UNEXISTING_DATE = `2020-01-03`
-                      const NULL_DATE__ID = `null_date__id`
-
-                      beforeAll(async () => {
-                        tableOrViewId = await createTableOrView({
-                          dateid: {
-                            name: "dateid",
-                            type: FieldType.STRING,
-                          },
-                          date: {
-                            name: "date",
-                            type: FieldType.DATETIME,
-                            dateOnly: true,
-                          },
-                        })
-
-                        await createRows([
-                          { dateid: NULL_DATE__ID, date: null },
-                          { date: `${JAN_1ST}${SAVE_SUFFIX}` },
-                          { date: `${JAN_10TH}${SAVE_SUFFIX}` },
+                  isInMemory &&
+                    describe("sortType STRING", () => {
+                      it("sorts ascending", async () => {
+                        await expectSearch({
+                          query: {},
+                          sort: "time",
+                          sortType: SortType.STRING,
+                          sortOrder: SortOrder.ASCENDING,
+                        }).toMatchExactly([
+                          { timeid: NULL_TIME__ID },
+                          { time: "00:00:00" },
+                          { time: "10:00:00" },
+                          { time: "10:45:00" },
+                          { time: "12:00:00" },
+                          { time: "15:30:00" },
                         ])
                       })
 
-                      describe("equal", () => {
-                        it("successfully finds a row", async () => {
-                          await expectQuery({
-                            equal: { date: `${JAN_1ST}${SEARCH_SUFFIX}` },
-                          }).toContainExactly([{ date: JAN_1ST }])
-                        })
-
-                        it("successfully finds an ISO8601 row", async () => {
-                          await expectQuery({
-                            equal: { date: `${JAN_10TH}${SEARCH_SUFFIX}` },
-                          }).toContainExactly([{ date: JAN_10TH }])
-                        })
-
-                        it("finds a row with ISO8601 timestamp", async () => {
-                          await expectQuery({
-                            equal: { date: `${JAN_1ST}${SEARCH_SUFFIX}` },
-                          }).toContainExactly([{ date: JAN_1ST }])
-                        })
-
-                        it("fails to find nonexistent row", async () => {
-                          await expectQuery({
-                            equal: {
-                              date: `${UNEXISTING_DATE}${SEARCH_SUFFIX}`,
-                            },
-                          }).toFindNothing()
-                        })
+                      it("sorts descending", async () => {
+                        await expectSearch({
+                          query: {},
+                          sort: "time",
+                          sortType: SortType.STRING,
+                          sortOrder: SortOrder.DESCENDING,
+                        }).toMatchExactly([
+                          { time: "15:30:00" },
+                          { time: "12:00:00" },
+                          { time: "10:45:00" },
+                          { time: "10:00:00" },
+                          { time: "00:00:00" },
+                          { timeid: NULL_TIME__ID },
+                        ])
                       })
+                    })
+                })
+              })
 
-                      describe("notEqual", () => {
-                        it("successfully finds a row", async () => {
-                          await expectQuery({
-                            notEqual: {
-                              date: `${JAN_1ST}${SEARCH_SUFFIX}`,
+            !isInMemory &&
+              describe("datetime - date only", () => {
+                describe.each([true, false])(
+                  "saved with timestamp: %s",
+                  saveWithTimestamp => {
+                    describe.each([true, false])(
+                      "search with timestamp: %s",
+                      searchWithTimestamp => {
+                        const SAVE_SUFFIX = saveWithTimestamp
+                          ? "T00:00:00.000Z"
+                          : ""
+                        const SEARCH_SUFFIX = searchWithTimestamp
+                          ? "T00:00:00.000Z"
+                          : ""
+
+                        const JAN_1ST = `2020-01-01`
+                        const JAN_10TH = `2020-01-10`
+                        const JAN_30TH = `2020-01-30`
+                        const UNEXISTING_DATE = `2020-01-03`
+                        const NULL_DATE__ID = `null_date__id`
+
+                        beforeAll(async () => {
+                          tableOrViewId = await createTableOrView({
+                            dateid: {
+                              name: "dateid",
+                              type: FieldType.STRING,
                             },
-                          }).toContainExactly([
-                            { date: JAN_10TH },
-                            { dateid: NULL_DATE__ID },
+                            date: {
+                              name: "date",
+                              type: FieldType.DATETIME,
+                              dateOnly: true,
+                            },
+                          })
+
+                          await createRows([
+                            { dateid: NULL_DATE__ID, date: null },
+                            { date: `${JAN_1ST}${SAVE_SUFFIX}` },
+                            { date: `${JAN_10TH}${SAVE_SUFFIX}` },
                           ])
                         })
 
-                        it("fails to find nonexistent row", async () => {
-                          await expectQuery({
-                            notEqual: {
-                              date: `${JAN_30TH}${SEARCH_SUFFIX}`,
-                            },
-                          }).toContainExactly([
-                            { date: JAN_1ST },
-                            { date: JAN_10TH },
-                            { dateid: NULL_DATE__ID },
-                          ])
-                        })
-                      })
+                        describe("equal", () => {
+                          it("successfully finds a row", async () => {
+                            await expectQuery({
+                              equal: { date: `${JAN_1ST}${SEARCH_SUFFIX}` },
+                            }).toContainExactly([{ date: JAN_1ST }])
+                          })
 
-                      describe("oneOf", () => {
-                        it("successfully finds a row", async () => {
-                          await expectQuery({
-                            oneOf: { date: [`${JAN_1ST}${SEARCH_SUFFIX}`] },
-                          }).toContainExactly([{ date: JAN_1ST }])
-                        })
+                          it("successfully finds an ISO8601 row", async () => {
+                            await expectQuery({
+                              equal: { date: `${JAN_10TH}${SEARCH_SUFFIX}` },
+                            }).toContainExactly([{ date: JAN_10TH }])
+                          })
 
-                        it("fails to find nonexistent row", async () => {
-                          await expectQuery({
-                            oneOf: {
-                              date: [`${UNEXISTING_DATE}${SEARCH_SUFFIX}`],
-                            },
-                          }).toFindNothing()
-                        })
-                      })
+                          it("finds a row with ISO8601 timestamp", async () => {
+                            await expectQuery({
+                              equal: { date: `${JAN_1ST}${SEARCH_SUFFIX}` },
+                            }).toContainExactly([{ date: JAN_1ST }])
+                          })
 
-                      describe("range", () => {
-                        it("successfully finds a row", async () => {
-                          await expectQuery({
-                            range: {
-                              date: {
-                                low: `${JAN_1ST}${SEARCH_SUFFIX}`,
-                                high: `${JAN_1ST}${SEARCH_SUFFIX}`,
+                          it("fails to find nonexistent row", async () => {
+                            await expectQuery({
+                              equal: {
+                                date: `${UNEXISTING_DATE}${SEARCH_SUFFIX}`,
                               },
-                            },
-                          }).toContainExactly([{ date: JAN_1ST }])
+                            }).toFindNothing()
+                          })
                         })
 
-                        it("successfully finds multiple rows", async () => {
-                          await expectQuery({
-                            range: {
-                              date: {
-                                low: `${JAN_1ST}${SEARCH_SUFFIX}`,
-                                high: `${JAN_10TH}${SEARCH_SUFFIX}`,
+                        describe("notEqual", () => {
+                          it("successfully finds a row", async () => {
+                            await expectQuery({
+                              notEqual: {
+                                date: `${JAN_1ST}${SEARCH_SUFFIX}`,
                               },
-                            },
-                          }).toContainExactly([
-                            { date: JAN_1ST },
-                            { date: JAN_10TH },
-                          ])
-                        })
+                            }).toContainExactly([
+                              { date: JAN_10TH },
+                              { dateid: NULL_DATE__ID },
+                            ])
+                          })
 
-                        it("successfully finds no rows", async () => {
-                          await expectQuery({
-                            range: {
-                              date: {
-                                low: `${JAN_30TH}${SEARCH_SUFFIX}`,
-                                high: `${JAN_30TH}${SEARCH_SUFFIX}`,
+                          it("fails to find nonexistent row", async () => {
+                            await expectQuery({
+                              notEqual: {
+                                date: `${JAN_30TH}${SEARCH_SUFFIX}`,
                               },
-                            },
-                          }).toFindNothing()
-                        })
-                      })
-
-                      describe("sort", () => {
-                        it("sorts ascending", async () => {
-                          await expectSearch({
-                            query: {},
-                            sort: "date",
-                            sortOrder: SortOrder.ASCENDING,
-                          }).toMatchExactly([
-                            { dateid: NULL_DATE__ID },
-                            { date: JAN_1ST },
-                            { date: JAN_10TH },
-                          ])
+                            }).toContainExactly([
+                              { date: JAN_1ST },
+                              { date: JAN_10TH },
+                              { dateid: NULL_DATE__ID },
+                            ])
+                          })
                         })
 
-                        it("sorts descending", async () => {
-                          await expectSearch({
-                            query: {},
-                            sort: "date",
-                            sortOrder: SortOrder.DESCENDING,
-                          }).toMatchExactly([
-                            { date: JAN_10TH },
-                            { date: JAN_1ST },
-                            { dateid: NULL_DATE__ID },
-                          ])
+                        describe("oneOf", () => {
+                          it("successfully finds a row", async () => {
+                            await expectQuery({
+                              oneOf: { date: [`${JAN_1ST}${SEARCH_SUFFIX}`] },
+                            }).toContainExactly([{ date: JAN_1ST }])
+                          })
+
+                          it("fails to find nonexistent row", async () => {
+                            await expectQuery({
+                              oneOf: {
+                                date: [`${UNEXISTING_DATE}${SEARCH_SUFFIX}`],
+                              },
+                            }).toFindNothing()
+                          })
                         })
 
-                        describe("sortType STRING", () => {
+                        describe("range", () => {
+                          it("successfully finds a row", async () => {
+                            await expectQuery({
+                              range: {
+                                date: {
+                                  low: `${JAN_1ST}${SEARCH_SUFFIX}`,
+                                  high: `${JAN_1ST}${SEARCH_SUFFIX}`,
+                                },
+                              },
+                            }).toContainExactly([{ date: JAN_1ST }])
+                          })
+
+                          it("successfully finds multiple rows", async () => {
+                            await expectQuery({
+                              range: {
+                                date: {
+                                  low: `${JAN_1ST}${SEARCH_SUFFIX}`,
+                                  high: `${JAN_10TH}${SEARCH_SUFFIX}`,
+                                },
+                              },
+                            }).toContainExactly([
+                              { date: JAN_1ST },
+                              { date: JAN_10TH },
+                            ])
+                          })
+
+                          it("successfully finds no rows", async () => {
+                            await expectQuery({
+                              range: {
+                                date: {
+                                  low: `${JAN_30TH}${SEARCH_SUFFIX}`,
+                                  high: `${JAN_30TH}${SEARCH_SUFFIX}`,
+                                },
+                              },
+                            }).toFindNothing()
+                          })
+                        })
+
+                        describe("sort", () => {
                           it("sorts ascending", async () => {
                             await expectSearch({
                               query: {},
                               sort: "date",
-                              sortType: SortType.STRING,
                               sortOrder: SortOrder.ASCENDING,
                             }).toMatchExactly([
                               { dateid: NULL_DATE__ID },
@@ -1865,7 +1841,6 @@ if (descriptions.length) {
                             await expectSearch({
                               query: {},
                               sort: "date",
-                              sortType: SortType.STRING,
                               sortOrder: SortOrder.DESCENDING,
                             }).toMatchExactly([
                               { date: JAN_10TH },
@@ -1873,13 +1848,41 @@ if (descriptions.length) {
                               { dateid: NULL_DATE__ID },
                             ])
                           })
+
+                          isInMemory &&
+                            describe("sortType STRING", () => {
+                              it("sorts ascending", async () => {
+                                await expectSearch({
+                                  query: {},
+                                  sort: "date",
+                                  sortType: SortType.STRING,
+                                  sortOrder: SortOrder.ASCENDING,
+                                }).toMatchExactly([
+                                  { dateid: NULL_DATE__ID },
+                                  { date: JAN_1ST },
+                                  { date: JAN_10TH },
+                                ])
+                              })
+
+                              it("sorts descending", async () => {
+                                await expectSearch({
+                                  query: {},
+                                  sort: "date",
+                                  sortType: SortType.STRING,
+                                  sortOrder: SortOrder.DESCENDING,
+                                }).toMatchExactly([
+                                  { date: JAN_10TH },
+                                  { date: JAN_1ST },
+                                  { dateid: NULL_DATE__ID },
+                                ])
+                              })
+                            })
                         })
-                      })
-                    }
-                  )
-                }
-              )
-            })
+                      }
+                    )
+                  }
+                )
+              })
 
             isInternal &&
               !isInMemory &&
diff --git a/packages/server/src/api/routes/tests/viewV2.spec.ts b/packages/server/src/api/routes/tests/viewV2.spec.ts
index ad41aa618c..3f1bb43016 100644
--- a/packages/server/src/api/routes/tests/viewV2.spec.ts
+++ b/packages/server/src/api/routes/tests/viewV2.spec.ts
@@ -24,7 +24,6 @@ import {
   SearchResponse,
   SearchViewRowRequest,
   SortOrder,
-  SortType,
   StaticQuotaName,
   Table,
   TableSchema,
@@ -154,7 +153,6 @@ if (descriptions.length) {
                 sort: {
                   field: "fieldToSort",
                   order: SortOrder.DESCENDING,
-                  type: SortType.STRING,
                 },
                 schema: {
                   id: { visible: true },
@@ -217,7 +215,6 @@ if (descriptions.length) {
               sort: {
                 field: "fieldToSort",
                 order: SortOrder.DESCENDING,
-                type: SortType.STRING,
               },
               schema: {
                 id: { visible: true },
@@ -1147,7 +1144,6 @@ if (descriptions.length) {
               sort: {
                 field: generator.word(),
                 order: SortOrder.DESCENDING,
-                type: SortType.STRING,
               },
               schema: {
                 id: { visible: true },
@@ -3153,7 +3149,6 @@ if (descriptions.length) {
             {
               field: string
               order?: SortOrder
-              type?: SortType
             },
             string[]
           ][] = [
@@ -3161,7 +3156,6 @@ if (descriptions.length) {
               {
                 field: "name",
                 order: SortOrder.ASCENDING,
-                type: SortType.STRING,
               },
               ["Alice", "Bob", "Charly", "Danny"],
             ],
@@ -3178,22 +3172,6 @@ if (descriptions.length) {
               },
               ["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",
@@ -3204,15 +3182,13 @@ if (descriptions.length) {
             [
               {
                 field: "age",
-                order: SortOrder.DESCENDING,
               },
-              ["Bob", "Charly", "Alice", "Danny"],
+              ["Danny", "Alice", "Charly", "Bob"],
             ],
             [
               {
                 field: "age",
                 order: SortOrder.DESCENDING,
-                type: SortType.NUMBER,
               },
               ["Bob", "Charly", "Alice", "Danny"],
             ],
@@ -3299,7 +3275,6 @@ if (descriptions.length) {
                   sort: {
                     field: "name",
                     order: SortOrder.ASCENDING,
-                    type: SortType.STRING,
                   },
                   schema: viewSchema,
                 })
@@ -3307,7 +3282,6 @@ if (descriptions.length) {
                 const response = await config.api.viewV2.search(view.id, {
                   sort: sortParams.field,
                   sortOrder: sortParams.order,
-                  sortType: sortParams.type,
                   query: {},
                 })
 
diff --git a/packages/server/src/integrations/s3.ts b/packages/server/src/integrations/s3.ts
index 88d00724f1..32a44c838b 100644
--- a/packages/server/src/integrations/s3.ts
+++ b/packages/server/src/integrations/s3.ts
@@ -168,6 +168,7 @@ class S3Integration implements IntegrationBase {
         secretAccessKey: config.secretAccessKey,
       },
       region: config.region,
+      endpoint: config.endpoint,
     }
     if (config.endpoint) {
       this.config.forcePathStyle = true
diff --git a/packages/server/src/sdk/app/rows/search.ts b/packages/server/src/sdk/app/rows/search.ts
index 3a582a46ea..8de46dc9fe 100644
--- a/packages/server/src/sdk/app/rows/search.ts
+++ b/packages/server/src/sdk/app/rows/search.ts
@@ -46,7 +46,6 @@ export async function search(
       query: options.query,
       sort: options.sort,
       sortOrder: options.sortOrder,
-      sortType: options.sortType,
       limit: options.limit,
       bookmark: options.bookmark,
       paginate: options.paginate,
diff --git a/packages/server/src/sdk/app/rows/search/internal/sqs.ts b/packages/server/src/sdk/app/rows/search/internal/sqs.ts
index 84162a67af..76b496f92a 100644
--- a/packages/server/src/sdk/app/rows/search/internal/sqs.ts
+++ b/packages/server/src/sdk/app/rows/search/internal/sqs.ts
@@ -1,5 +1,6 @@
 import {
   Aggregation,
+  AutoFieldSubType,
   CalculationType,
   DocumentType,
   EnrichedQueryJson,
@@ -420,7 +421,11 @@ export async function search(
       }
     } else if (sortField) {
       const sortType =
-        sortField.type === FieldType.NUMBER ? SortType.NUMBER : SortType.STRING
+        sortField.type === FieldType.NUMBER ||
+        (sortField.type === FieldType.AUTO &&
+          sortField.subtype === AutoFieldSubType.AUTO_ID)
+          ? SortType.NUMBER
+          : SortType.STRING
       request.sort = {
         [mapToUserColumn(sortField.name)]: {
           direction: params.sortOrder || SortOrder.ASCENDING,
diff --git a/packages/shared-core/src/filters.ts b/packages/shared-core/src/filters.ts
index afe99d9565..5da5c34a4f 100644
--- a/packages/shared-core/src/filters.ts
+++ b/packages/shared-core/src/filters.ts
@@ -11,7 +11,6 @@ import {
   SortType,
   FieldConstraints,
   SortOrder,
-  RowSearchParams,
   EmptyFilterOption,
   SearchResponse,
   Table,
@@ -25,6 +24,8 @@ import {
   isArraySearchOperator,
   isRangeSearchOperator,
   SearchFilter,
+  WithRequired,
+  SearchParams,
 } from "@budibase/types"
 import dayjs from "dayjs"
 import { OperatorOptions, SqlNumberTypeRangeMap } from "./constants"
@@ -521,9 +522,19 @@ export function fixupFilterArrays(filters: SearchFilters) {
   return filters
 }
 
+type SearchQuery = WithRequired<
+  Pick<
+    SearchParams,
+    "query" | "sort" | "sortOrder" | "sortType" | "limit" | "countRows"
+  >,
+  "query"
+>
+
+export type InMemorySearchQuery = SearchQuery
+
 export function search<T extends Record<string, any>>(
   docs: T[],
-  query: Omit<RowSearchParams, "tableId">
+  query: SearchQuery
 ): SearchResponse<T> {
   let result = runQuery(docs, query.query)
   if (query.sort) {
diff --git a/packages/shared-core/src/index.ts b/packages/shared-core/src/index.ts
index a4f4208f4a..daf4601c03 100644
--- a/packages/shared-core/src/index.ts
+++ b/packages/shared-core/src/index.ts
@@ -1,5 +1,6 @@
 export * from "./constants"
 export * as dataFilters from "./filters"
+export type * from "./filters"
 export * as helpers from "./helpers"
 export * as utils from "./utils"
 export * as sdk from "./sdk"
diff --git a/packages/shared-core/src/tests/cron.test.ts b/packages/shared-core/src/tests/cron.spec.ts
similarity index 100%
rename from packages/shared-core/src/tests/cron.test.ts
rename to packages/shared-core/src/tests/cron.spec.ts
diff --git a/packages/shared-core/src/tests/themes.ts b/packages/shared-core/src/tests/themes.spec.ts
similarity index 100%
rename from packages/shared-core/src/tests/themes.ts
rename to packages/shared-core/src/tests/themes.spec.ts
diff --git a/packages/types/src/api/web/app/query.ts b/packages/types/src/api/web/app/query.ts
index 75cc37e1a9..14f39ba267 100644
--- a/packages/types/src/api/web/app/query.ts
+++ b/packages/types/src/api/web/app/query.ts
@@ -11,7 +11,7 @@ export interface SaveQueryRequest extends Query {}
 export interface SaveQueryResponse extends Query {}
 
 export interface ImportRestQueryRequest {
-  datasourceId: string
+  datasourceId?: string
   data: string
   datasource: Datasource
 }
diff --git a/packages/types/src/api/web/app/rows/search.ts b/packages/types/src/api/web/app/rows/search.ts
index 7ba23bceca..4d903d44b6 100644
--- a/packages/types/src/api/web/app/rows/search.ts
+++ b/packages/types/src/api/web/app/rows/search.ts
@@ -8,11 +8,7 @@ import {
   SearchFilterKey,
 } from "../../../../sdk"
 import { Row } from "../../../../documents"
-import {
-  PaginationResponse,
-  SortOrder,
-  SortType,
-} from "../../../../api/web/pagination"
+import { PaginationResponse, SortOrder } from "../../../../api/web/pagination"
 import { z } from "zod"
 
 const fieldKey = z
@@ -70,7 +66,6 @@ const searchRowRequest = z.object({
   limit: z.number().optional(),
   sort: z.string().nullish(),
   sortOrder: z.nativeEnum(SortOrder).optional(),
-  sortType: z.nativeEnum(SortType).nullish(),
   version: z.string().optional(),
   disableEscaping: z.boolean().optional(),
   countRows: z.boolean().optional(),
@@ -83,7 +78,6 @@ export type SearchViewRowRequest = Pick<
   SearchRowRequest,
   | "sort"
   | "sortOrder"
-  | "sortType"
   | "limit"
   | "bookmark"
   | "paginate"
diff --git a/packages/types/src/sdk/row.ts b/packages/types/src/sdk/row.ts
index 6328a80ba1..da5eb0b041 100644
--- a/packages/types/src/sdk/row.ts
+++ b/packages/types/src/sdk/row.ts
@@ -50,7 +50,7 @@ export interface SearchParams {
 
 // when searching for rows we want a more extensive search type that requires certain properties
 export interface RowSearchParams
-  extends WithRequired<SearchParams, "tableId" | "query"> {}
+  extends WithRequired<Omit<SearchParams, "sortType">, "tableId" | "query"> {}
 
 export interface SearchResponse<T> {
   rows: T[]
diff --git a/yarn.lock b/yarn.lock
index 5173e81408..7b855ecf15 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -20499,10 +20499,10 @@ supports-preserve-symlinks-flag@^1.0.0:
   resolved "https://registry.yarnpkg.com/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz#6eda4bd344a3c94aea376d4cc31bc77311039e09"
   integrity sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==
 
-svelte-check@^4.1.0:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/svelte-check/-/svelte-check-4.1.0.tgz#4389c1c88aa24f3d06fe0df94f9075a55017256d"
-  integrity sha512-AflEZYqI578KuDZcpcorPSf597LStxlkN7XqXi38u09zlHODVKd7c+7OuubGzbhgGRUqNTdQCZ+Ga96iRXEf2g==
+svelte-check@^4.1.5:
+  version "4.1.5"
+  resolved "https://registry.yarnpkg.com/svelte-check/-/svelte-check-4.1.5.tgz#afdb3f8050c123064124d5aa7821365c7befa7a4"
+  integrity sha512-Gb0T2IqBNe1tLB9EB1Qh+LOe+JB8wt2/rNBDGvkxQVvk8vNeAoG+vZgFB/3P5+zC7RWlyBlzm9dVjZFph/maIg==
   dependencies:
     "@jridgewell/trace-mapping" "^0.3.25"
     chokidar "^4.0.1"