Quick re-jig based on test failure, seems the base sql.ts is depended on fairly heavily, importing the SDK can create a lot of cycles.

packages/server/src/api/controllers/row/external.ts

@@ -18,7 +18,6 @@ import {
 import sdk from "../../../sdk"
 import * as utils from "./utils"
 import { dataFilters } from "@budibase/shared-core"
-import { removeEmptyFilters } from "./utils"
 
 export async function handleRequest(
   operation: Operation,
@@ -27,7 +26,7 @@ export async function handleRequest(
 ) {
   // make sure the filters are cleaned up, no empty strings for equals, fuzzy or string
   if (opts && opts.filters) {
-    opts.filters = utils.removeEmptyFilters(opts.filters)
+    opts.filters = sdk.rows.removeEmptyFilters(opts.filters)
   }
   if (
     !dataFilters.hasFilters(opts?.filters) &&

packages/server/src/api/controllers/row/utils.ts

@@ -146,36 +146,3 @@ export async function validate({
   }
   return { valid: Object.keys(errors).length === 0, errors }
 }
-
-export function isValidFilter(value: any) {
-  return value != null && value !== ""
-}
-
-// don't do a pure falsy check, as 0 is included
-// https://github.com/Budibase/budibase/issues/10118
-export function removeEmptyFilters(filters: SearchFilters) {
-  for (let filterField of NoEmptyFilterStrings) {
-    if (!filters[filterField]) {
-      continue
-    }
-
-    for (let filterType of Object.keys(filters)) {
-      if (filterType !== filterField) {
-        continue
-      }
-      // don't know which one we're checking, type could be anything
-      const value = filters[filterType] as unknown
-      if (typeof value === "object") {
-        for (let [key, value] of Object.entries(
-          filters[filterType] as object
-        )) {
-          if (value == null || value === "") {
-            // @ts-ignore
-            delete filters[filterField][key]
-          }
-        }
-      }
-    }
-  }
-  return filters
-}

packages/server/src/integrations/base/sql.ts

@@ -1,4 +1,8 @@
 import { Knex, knex } from "knex"
+import { db as dbCore } from "@budibase/backend-core"
+import { QueryOptions } from "../../definitions/datasource"
+import { isIsoDateString, SqlClient } from "../utils"
+import SqlTableQueryBuilder from "./sqlTable"
 import {
   Operation,
   QueryJson,
@@ -6,12 +10,8 @@ import {
   SearchFilters,
   SortDirection,
 } from "@budibase/types"
-import { db as dbCore } from "@budibase/backend-core"
-import { QueryOptions } from "../../definitions/datasource"
-import { isIsoDateString, SqlClient } from "../utils"
-import SqlTableQueryBuilder from "./sqlTable"
 import environment from "../../environment"
-import { isValidFilter } from "../../api/controllers/row/utils"
+import { isValidFilter } from "../utils"
 
 const envLimit = environment.SQL_MAX_ROWS
   ? parseInt(environment.SQL_MAX_ROWS)
@@ -262,15 +262,17 @@ class InternalBuilder {
         if (isEmptyObject(value.high)) {
           value.high = ""
         }
-        if (isValidFilter(value.low) && isValidFilter(value.high)) {
+        const lowValid = isValidFilter(value.low),
+          highValid = isValidFilter(value.high)
+        if (lowValid && highValid) {
           // Use a between operator if we have 2 valid range values
           const fnc = allOr ? "orWhereBetween" : "whereBetween"
           query = query[fnc](key, [value.low, value.high])
-        } else if (isValidFilter(value.low)) {
+        } else if (lowValid) {
           // Use just a single greater than operator if we only have a low
           const fnc = allOr ? "orWhere" : "where"
           query = query[fnc](key, ">", value.low)
-        } else if (isValidFilter(value.high)) {
+        } else if (highValid) {
           // Use just a single less than operator if we only have a high
           const fnc = allOr ? "orWhere" : "where"
           query = query[fnc](key, "<", value.high)

packages/server/src/integrations/utils.ts

@@ -1,6 +1,11 @@
-import { SourceName, SqlQuery, Datasource, Table } from "@budibase/types"
+import { SqlQuery, Table, SearchFilters } from "@budibase/types"
 import { DocumentType, SEPARATOR } from "../db/utils"
-import { FieldTypes, BuildSchemaErrors, InvalidColumns } from "../constants"
+import {
+  FieldTypes,
+  BuildSchemaErrors,
+  InvalidColumns,
+  NoEmptyFilterStrings,
+} from "../constants"
 import { helpers } from "@budibase/shared-core"
 
 const DOUBLE_SEPARATOR = `${SEPARATOR}${SEPARATOR}`
@@ -343,3 +348,36 @@ export function getPrimaryDisplay(testValue: unknown): string | undefined {
   }
   return testValue as string
 }
+
+export function isValidFilter(value: any) {
+  return value != null && value !== ""
+}
+
+// don't do a pure falsy check, as 0 is included
+// https://github.com/Budibase/budibase/issues/10118
+export function removeEmptyFilters(filters: SearchFilters) {
+  for (let filterField of NoEmptyFilterStrings) {
+    if (!filters[filterField]) {
+      continue
+    }
+
+    for (let filterType of Object.keys(filters)) {
+      if (filterType !== filterField) {
+        continue
+      }
+      // don't know which one we're checking, type could be anything
+      const value = filters[filterType] as unknown
+      if (typeof value === "object") {
+        for (let [key, value] of Object.entries(
+          filters[filterType] as object
+        )) {
+          if (value == null || value === "") {
+            // @ts-ignore
+            delete filters[filterField][key]
+          }
+        }
+      }
+    }
+  }
+  return filters
+}

packages/server/src/sdk/app/rows/search.ts

@@ -3,6 +3,7 @@ import { isExternalTable } from "../../../integrations/utils"
 import * as internal from "./search/internal"
 import * as external from "./search/external"
 import { Format } from "../../../api/controllers/view/exporters"
+export { isValidFilter, removeEmptyFilters } from "../../../integrations/utils"
 
 export interface ViewParams {
   calculation: string