First PR comments.

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

@@ -176,24 +176,13 @@ export class ExternalRequest<T extends Operation> {
     const relationshipColumns = sdk.rows.filters.getRelationshipColumns(table)
     filters = sdk.rows.filters.updateFilterKeys(
       filters,
-      relationshipColumns
+      relationshipColumns.map(({ name, definition }) => {
-        .map(({ name, definition }) => {
+        const { tableName } = breakExternalTableId(definition.tableId)
-          const { tableName } = breakExternalTableId(definition.tableId)
+        return {
-          return {
+          original: name,
-            original: name,
+          updated: tableName!,
-            updated: tableName!,
+        }
-          }
+      })
-        })
-        // don't update table names - include this for context incase a column would be replaced
-        .concat(
-          tables.map(table => {
-            const tableName = table.originalName || table.name
-            return {
-              original: tableName,
-              updated: tableName,
-            }
-          })
-        )
     )
     const primary = table.primary
     // if passed in array need to copy for shifting etc

packages/server/src/api/routes/tests/search.spec.ts

@@ -1954,6 +1954,7 @@ describe.each([
   !isLucene &&
     // It also can't work for in-memory searching because the related table name
     // isn't available.
+    !isInMemory &&
     describe("relations", () => {
       let productCategoryTable: Table, productCatRows: Row[]
 

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

@@ -4,24 +4,32 @@ import {
   SearchFilters,
   Table,
 } from "@budibase/types"
+import { isPlainObject } from "lodash"
 
 export function getRelationshipColumns(table: Table): {
   name: string
   definition: RelationshipFieldMetadata
 }[] {
-  return Object.entries(table.schema)
+  // performing this with a for loop rather than an array filter improves
-    .filter(entry => entry[1].type === FieldType.LINK)
+  // type guarding, as no casts are required
-    .map(entry => ({
+  const linkEntries: [string, RelationshipFieldMetadata][] = []
-      name: entry[0],
+  for (let entry of Object.entries(table.schema)) {
-      definition: entry[1] as RelationshipFieldMetadata,
+    if (entry[1].type === FieldType.LINK) {
-    }))
+      const linkColumn: RelationshipFieldMetadata = entry[1]
+      linkEntries.push([entry[0], linkColumn])
+    }
+  }
+  return linkEntries.map(entry => ({
+    name: entry[0],
+    definition: entry[1],
+  }))
 }
 
 export function getTableIDList(
   tables: Table[]
 ): { name: string; id: string }[] {
   return tables
-    .filter(table => table.originalName)
+    .filter(table => table.originalName && table._id)
     .map(table => ({ id: table._id!, name: table.originalName! }))
 }
 
@@ -32,7 +40,7 @@ export function updateFilterKeys(
   const makeFilterKeyRegex = (str: string) =>
     new RegExp(`^${str}\\.|:${str}\\.`)
   for (let filter of Object.values(filters)) {
-    if (typeof filter !== "object") {
+    if (!isPlainObject(filter)) {
       continue
     }
     for (let [key, keyFilter] of Object.entries(filter)) {