@budibase/frontend-core 3.26.3 → 3.27.1

package/package.json

@@ -1,12 +1,14 @@
 {
   "name": "@budibase/frontend-core",
-  "version": "3.26.3",
+  "version": "3.27.1",
   "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": "69ab5e17bf9ccdac19b3bccd30352b936942129a"
+  "devDependencies": {
+    "vitest": "^3.2.4"
+  },
+  "gitHead": "e16e4f2acb1dbf82177c69b4cbfd23c3bdf16544"
 }

package/src/components/Chatbox/index.svelte

@@ -62,6 +62,22 @@
   let inputValue = $state("")
   let reasoningTimers = $state<Record<string, number>>({})
 
+  const getReasoningText = (message: UIMessage<AgentMessageMetadata>) =>
+    (message.parts ?? [])
+      .filter(isReasoningUIPart)
+      .map(p => p.text)
+      .join("")
+
+  const isReasoningStreaming = (message: UIMessage<AgentMessageMetadata>) =>
+    (message.parts ?? []).some(
+      part => isReasoningUIPart(part) && part.state === "streaming"
+    )
+
+  const hasToolError = (message: UIMessage<AgentMessageMetadata>) =>
+    (message.parts ?? []).some(
+      part => isToolUIPart(part) && part.state === "output-error"
+    )
+
   $effect(() => {
     const interval = setInterval(() => {
       let updated = false
@@ -71,24 +87,33 @@
         if (message.role !== "assistant") continue
         const createdAt = message.metadata?.createdAt
         const completedAt = message.metadata?.completedAt
+        const id = `${message.id}-reasoning`
+
+        if (!createdAt) continue
 
-        for (const [index, part] of (message.parts ?? []).entries()) {
-          if (!isReasoningUIPart(part)) continue
-
-          const id = `${message.id}-reasoning-${index}`
-
-          if (completedAt && createdAt) {
-            const finalElapsed = (completedAt - createdAt) / 1000
-            if (newTimers[id] !== finalElapsed) {
-              newTimers[id] = finalElapsed
-              updated = true
-            }
-          } else if (part.state === "streaming" && createdAt) {
-            const newElapsed = (Date.now() - createdAt) / 1000
-            if (newTimers[id] !== newElapsed) {
-              newTimers[id] = newElapsed
-              updated = true
-            }
+        if (completedAt) {
+          const finalElapsed = (completedAt - createdAt) / 1000
+          if (newTimers[id] !== finalElapsed) {
+            newTimers[id] = finalElapsed
+            updated = true
+          }
+          continue
+        }
+
+        const toolError = hasToolError(message)
+        if (toolError) {
+          if (newTimers[id] == null) {
+            newTimers[id] = (Date.now() - createdAt) / 1000
+            updated = true
+          }
+          continue
+        }
+
+        if (isReasoningStreaming(message)) {
+          const newElapsed = (Date.now() - createdAt) / 1000
+          if (newTimers[id] !== newElapsed) {
+            newTimers[id] = newElapsed
+            updated = true
           }
         }
       }
@@ -381,48 +406,48 @@
           <MarkdownViewer value={getUserMessageText(message)} />
         </div>
       {:else if message.role === "assistant"}
+        {@const reasoningText = getReasoningText(message)}
+        {@const reasoningId = `${message.id}-reasoning`}
+        {@const toolError = hasToolError(message)}
+        {@const reasoningStreaming = isReasoningStreaming(message)}
+        {@const isThinking =
+          reasoningStreaming && !toolError && !message.metadata?.completedAt}
         <div class="message assistant">
+          {#if reasoningText}
+            <div class="reasoning-part">
+              <button
+                class="reasoning-toggle"
+                type="button"
+                onclick={() =>
+                  (expandedTools = {
+                    ...expandedTools,
+                    [reasoningId]: !expandedTools[reasoningId],
+                  })}
+              >
+                <span class="reasoning-icon" class:shimmer={isThinking}>
+                  <Icon
+                    name="brain"
+                    size="M"
+                    color="var(--spectrum-global-color-gray-600)"
+                  />
+                </span>
+                <span class="reasoning-label" class:shimmer={isThinking}>
+                  {isThinking ? "Thinking" : "Thought for"}
+                  {#if reasoningTimers[reasoningId]}
+                    <span class="reasoning-timer"
+                      >{reasoningTimers[reasoningId].toFixed(1)}s</span
+                    >
+                  {/if}
+                </span>
+              </button>
+              {#if expandedTools[reasoningId]}
+                <div class="reasoning-content">{reasoningText}</div>
+              {/if}
+            </div>
+          {/if}
           {#each message.parts ?? [] as part, partIndex}
             {#if isTextUIPart(part)}
               <MarkdownViewer value={part.text} />
-            {:else if isReasoningUIPart(part)}
-              {@const reasoningId = `${message.id}-reasoning-${partIndex}`}
-              <div class="reasoning-part">
-                <button
-                  class="reasoning-toggle"
-                  type="button"
-                  onclick={() =>
-                    (expandedTools = {
-                      ...expandedTools,
-                      [reasoningId]: !expandedTools[reasoningId],
-                    })}
-                >
-                  <span
-                    class="reasoning-icon"
-                    class:shimmer={part.state === "streaming"}
-                  >
-                    <Icon
-                      name="brain"
-                      size="M"
-                      color="var(--spectrum-global-color-gray-600)"
-                    />
-                  </span>
-                  <span
-                    class="reasoning-label"
-                    class:shimmer={part.state === "streaming"}
-                  >
-                    {part.state === "streaming" ? "Thinking" : "Thought for"}
-                    {#if reasoningTimers[reasoningId]}
-                      <span class="reasoning-timer"
-                        >{reasoningTimers[reasoningId].toFixed(1)}s</span
-                      >
-                    {/if}
-                  </span>
-                </button>
-                {#if expandedTools[reasoningId]}
-                  <div class="reasoning-content">{part.text}</div>
-                {/if}
-              </div>
             {:else if isToolUIPart(part)}
               {@const toolId = `${message.id}-${getToolName(part)}-${partIndex}`}
               {@const isRunning =
@@ -639,12 +664,6 @@
     max-width: 100%;
   }
 
-  .message.system {
-    align-self: flex-start;
-    background: none;
-    padding-left: 0;
-  }
-
   .input-wrapper {
     position: sticky;
     bottom: 0;

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"),
+        },
+      ],
+    },
+  }
+})