@budibase/frontend-core 3.26.2 → 3.27.0

package/package.json

@@ -1,12 +1,14 @@
 {
   "name": "@budibase/frontend-core",
-  "version": "3.26.2",
+  "version": "3.27.0",
   "description": "Budibase frontend core libraries used in builder and client",
   "author": "Budibase",
   "license": "MPL-2.0",
   "svelte": "./src/index.ts",
   "scripts": {
-    "check:types": "yarn svelte-check"
+    "check:types": "yarn svelte-check",
+    "test": "vitest run",
+    "test:watch": "vitest"
   },
   "dependencies": {
     "@ai-sdk/svelte": "^4.0.48",
@@ -19,5 +21,8 @@
     "shortid": "2.2.15",
     "socket.io-client": "^4.7.5"
   },
-  "gitHead": "908ec20f1124a11b0cbe3bed8d2bc4a04e856cfe"
+  "devDependencies": {
+    "vitest": "^3.2.4"
+  },
+  "gitHead": "7fc04647584c83a2d70f302fa88f2569580f7539"
 }

package/src/components/grid/cells/RelationshipCell.svelte

@@ -97,7 +97,7 @@
     }
 
     // Reset state if this search is invalid
-    if (!schema?.tableId || !isOpen) {
+    if (!schema?.tableId || !isOpen || !primaryDisplay) {
       lastSearchString = null
       candidateIndex = null
       searchResults = []
@@ -159,6 +159,7 @@
       primaryDisplay = await cache.actions.getPrimaryDisplayForTableId(
         schema.tableId
       )
+      searching = false
     }
 
     // Show initial list of results

package/src/components/grid/stores/cache.ts

@@ -38,7 +38,8 @@ export const createActions = (context: StoreContext): CacheActionStore => {
 
   const getPrimaryDisplayForTableId = async (tableId: string) => {
     const table = await fetchTable(tableId)
-    const display = table?.primaryDisplay || table?.schema?.[0]?.name
+    const firstSchemaKey = Object.keys(table?.schema || {})[0]
+    const display = table?.primaryDisplay || firstSchemaKey
     return display
   }
 

package/src/constants.ts

@@ -11,7 +11,6 @@ import { BpmCorrelationKey } from "@budibase/shared-core"
 import { BBReferenceFieldSubType, FieldType } from "@budibase/types"
 
 export const BannedSearchTypes = [
-  FieldType.LINK,
   FieldType.ATTACHMENT_SINGLE,
   FieldType.ATTACHMENTS,
   FieldType.FORMULA,

package/src/utils/searchFields.js

@@ -8,10 +8,12 @@ export function getTableFields(tables, linkField) {
   const linkFields = getFields(tables, Object.values(table.schema), {
     allowLinks: false,
   })
-  return linkFields.map(field => ({
-    ...field,
-    name: `${linkField.name}.${field.name}`,
-  }))
+  return linkFields
+    .sort((a, b) => a.name.localeCompare(b.name))
+    .map(field => ({
+      ...field,
+      name: `${linkField.name}.${field.name}`,
+    }))
 }
 
 export function getFields(
@@ -19,18 +21,22 @@ export function getFields(
   fields,
   { allowLinks } = { allowLinks: true }
 ) {
+  const result = []
   let filteredFields = fields.filter(
-    field => !BannedSearchTypes.includes(field.type)
+    field =>
+      !BannedSearchTypes.includes(field.type) &&
+      (allowLinks || field.type !== "link")
   )
-  if (allowLinks) {
-    const linkFields = fields.filter(field => field.type === "link")
-    for (let linkField of linkFields) {
+  for (const field of filteredFields) {
+    result.push(field)
+
+    if (allowLinks && field.type === "link") {
       // only allow one depth of SQL relationship filtering
-      filteredFields = filteredFields.concat(getTableFields(tables, linkField))
+      result.push(...getTableFields(tables, field))
     }
   }
   const staticFormulaFields = fields.filter(
     field => field.type === "formula" && field.formulaType === "static"
   )
-  return filteredFields.concat(staticFormulaFields)
+  return result.concat(staticFormulaFields)
 }

package/src/utils/searchFields.test.js

@@ -0,0 +1,93 @@
+import { describe, expect, it } from "vitest"
+import { getFields, getTableFields } from "./searchFields.js"
+
+const field = (name, type, extra = {}) => ({
+  name,
+  type,
+  ...extra,
+})
+
+const table = (id, schema) => ({
+  _id: id,
+  name: id,
+  sql: true,
+  schema,
+})
+
+describe("search fields", () => {
+  const relatedTable = table("t2", {
+    title: field("title", "string"),
+    otherLink: field("otherLink", "link", { tableId: "t3" }),
+  })
+  const baseTable = table("t1", {
+    name: field("name", "string"),
+    rel: field("rel", "link", { tableId: "t2" }),
+  })
+  const tables = [baseTable, relatedTable]
+
+  describe("getTableFields", () => {
+    it("excludes nested link fields when allowLinks is false", () => {
+      const fields = getTableFields(tables, baseTable.schema.rel)
+      expect(fields.map(field => field.name)).toEqual(["rel.title"])
+    })
+
+    it("returns empty for non-sql related tables", () => {
+      const nonSqlTable = {
+        ...relatedTable,
+        sql: false,
+      }
+      const fields = getTableFields([baseTable, nonSqlTable], {
+        ...baseTable.schema.rel,
+        tableId: nonSqlTable._id,
+      })
+      expect(fields).toEqual([])
+    })
+  })
+
+  describe("getFields", () => {
+    it("excludes link fields when allowLinks is false", () => {
+      const fields = getFields(tables, Object.values(baseTable.schema), {
+        allowLinks: false,
+      })
+      expect(fields.map(field => field.name)).toEqual(["name"])
+    })
+
+    it("includes one relationship depth when allowLinks is true", () => {
+      const fields = getFields(tables, Object.values(baseTable.schema), {
+        allowLinks: true,
+      })
+      const names = fields.map(field => field.name)
+      expect(names).toEqual(
+        expect.arrayContaining(["name", "rel", "rel.title"])
+      )
+      expect(names).not.toEqual(expect.arrayContaining(["rel.otherLink"]))
+    })
+
+    it("appends static formula fields even when allowLinks is false", () => {
+      const withFormula = table("t4", {
+        name: field("name", "string"),
+        calc: field("calc", "formula", { formulaType: "static" }),
+        rel: field("rel", "link", { tableId: "t2" }),
+      })
+      const fields = getFields(tables, Object.values(withFormula.schema), {
+        allowLinks: false,
+      })
+      expect(fields.map(field => field.name)).toEqual(
+        expect.arrayContaining(["name", "calc"])
+      )
+    })
+
+    it("filters out banned field types", () => {
+      const withBanned = table("t5", {
+        name: field("name", "string"),
+        meta: field("meta", "json"),
+        files: field("files", "attachment"),
+        file: field("file", "attachment_single"),
+      })
+      const fields = getFields(tables, Object.values(withBanned.schema), {
+        allowLinks: false,
+      })
+      expect(fields.map(field => field.name)).toEqual(["name"])
+    })
+  })
+})

package/vite.config.mjs

@@ -0,0 +1,23 @@
+import { defineConfig } from "vite"
+import path from "path"
+
+export default defineConfig(() => {
+  return {
+    test: {
+      globals: true,
+      include: ["src/**/*.test.*", "src/**/*.spec.*"],
+    },
+    resolve: {
+      alias: [
+        {
+          find: "@budibase/types",
+          replacement: path.resolve("../types/src"),
+        },
+        {
+          find: "@budibase/shared-core",
+          replacement: path.resolve("../shared-core/src"),
+        },
+      ],
+    },
+  }
+})