@budibase/frontend-core 3.23.38 → 3.23.47

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@budibase/frontend-core",
-  "version": "3.23.38",
+  "version": "3.23.47",
   "description": "Budibase frontend core libraries used in builder and client",
   "author": "Budibase",
   "license": "MPL-2.0",
@@ -18,5 +18,5 @@
     "shortid": "2.2.15",
     "socket.io-client": "^4.7.5"
   },
-  "gitHead": "83fecbd6e6b9e5f5d26369ce51d2173801925e3a"
+  "gitHead": "534845c38ed0fe209406ebe45fd87f3de79f1da5"
 }

package/src/api/agents.ts

@@ -1,14 +1,11 @@
 import {
   AgentChat,
-  AgentToolSource,
-  AgentToolSourceWithTools,
   ChatAgentRequest,
   CreateAgentRequest,
   CreateAgentResponse,
-  CreateToolSourceRequest,
   FetchAgentHistoryResponse,
   FetchAgentsResponse,
-  Tool,
+  ToolMetadata,
   UpdateAgentRequest,
   UpdateAgentResponse,
 } from "@budibase/types"
@@ -27,13 +24,7 @@ export interface AgentEndpoints {
   removeChat: (chatId: string) => Promise<void>
   fetchChats: (agentId: string) => Promise<FetchAgentHistoryResponse>
 
-  fetchToolSources: (agentId: string) => Promise<AgentToolSourceWithTools[]>
-  fetchAvailableTools: (toolSourceType: string) => Promise<Tool[]>
-  createToolSource: (
-    toolSource: CreateToolSourceRequest
-  ) => Promise<{ created: true }>
-  updateToolSource: (toolSource: AgentToolSource) => Promise<AgentToolSource>
-  deleteToolSource: (toolSourceId: string) => Promise<{ deleted: true }>
+  fetchTools: () => Promise<ToolMetadata[]>
   fetchAgents: () => Promise<FetchAgentsResponse>
   createAgent: (agent: CreateAgentRequest) => Promise<CreateAgentResponse>
   updateAgent: (agent: UpdateAgentRequest) => Promise<UpdateAgentResponse>
@@ -99,35 +90,9 @@ export const buildAgentEndpoints = (API: BaseAPIClient): AgentEndpoints => ({
     })
   },
 
-  fetchToolSources: async (agentId: string) => {
+  fetchTools: async () => {
     return await API.get({
-      url: `/api/agent/${agentId}/toolsource`,
-    })
-  },
-
-  fetchAvailableTools: async (toolSourceType: string) => {
-    return await API.get({
-      url: `/api/agent/toolsource/${toolSourceType}/tools`,
-    })
-  },
-
-  createToolSource: async (toolSource: CreateToolSourceRequest) => {
-    return await API.post({
-      url: "/api/agent/toolsource",
-      body: toolSource as any,
-    })
-  },
-
-  updateToolSource: async (toolSource: AgentToolSource) => {
-    return await API.put({
-      url: "/api/agent/toolsource",
-      body: toolSource as any,
-    })
-  },
-
-  deleteToolSource: async (toolSourceId: string) => {
-    return await API.delete({
-      url: `/api/agent/toolsource/${toolSourceId}`,
+      url: `/api/agent/tools`,
     })
   },
 

package/src/api/automations.ts

@@ -10,6 +10,7 @@ import {
   SearchAutomationLogsResponse,
   TestAutomationRequest,
   TestAutomationResponse,
+  TestProgressState,
   TriggerAutomationRequest,
   TriggerAutomationResponse,
   UpdateAutomationRequest,
@@ -40,8 +41,10 @@ export interface AutomationEndpoints {
   ) => Promise<TriggerAutomationResponse>
   testAutomation: (
     automationdId: string,
-    data: TestAutomationRequest
+    data: TestAutomationRequest,
+    options?: { async?: boolean }
   ) => Promise<TestAutomationResponse>
+  getAutomationTestStatus: (automationId: string) => Promise<TestProgressState>
   getAutomationDefinitions: () => Promise<GetAutomationStepDefinitionsResponse>
   getAutomationLogs: (
     options: SearchAutomationLogsRequest
@@ -69,13 +72,25 @@ export const buildAutomationEndpoints = (
    * @param automationId the ID of the automation to test
    * @param data the test data to run against the automation
    */
-  testAutomation: async (automationId, data) => {
+  testAutomation: async (automationId, data, options = {}) => {
+    const params = new URLSearchParams()
+    if (options.async) {
+      params.set("async", "true")
+    }
+    const qs = params.toString()
+    const url = `/api/automations/${automationId}/test${qs ? `?${qs}` : ""}`
     return await API.post({
-      url: `/api/automations/${automationId}/test`,
+      url,
       body: data,
     })
   },
 
+  getAutomationTestStatus: async automationId => {
+    return await API.get({
+      url: `/api/automations/${automationId}/test/status`,
+    })
+  },
+
   /**
    * Gets a list of all automations.
    */

package/src/api/datasources.ts

@@ -7,6 +7,8 @@ import {
   DeleteDatasourceResponse,
   FetchDatasourceInfoRequest,
   FetchDatasourceInfoResponse,
+  FetchDatasourceRelationshipInfoRequest,
+  FetchDatasourceRelationshipInfoResponse,
   FetchDatasourceViewInfoRequest,
   FetchDatasourceViewInfoResponse,
   UpdateDatasourceRequest,
@@ -41,6 +43,9 @@ export interface DatasourceEndpoints {
   fetchViewInfoForDatasource: (
     datasource: Datasource
   ) => Promise<FetchDatasourceViewInfoResponse>
+  fetchRelationshipInfoForDatasource: (
+    datasource: Datasource
+  ) => Promise<FetchDatasourceRelationshipInfoResponse>
 }
 
 export const buildDatasourceEndpoints = (
@@ -134,4 +139,17 @@ export const buildDatasourceEndpoints = (
       body: { datasource },
     })
   },
+
+  /**
+   * Fetch relationship names available within the datasource
+   */
+  fetchRelationshipInfoForDatasource: async (datasource: Datasource) => {
+    return await API.post<
+      FetchDatasourceRelationshipInfoRequest,
+      FetchDatasourceRelationshipInfoResponse
+    >({
+      url: `/api/datasources/relationships`,
+      body: { datasource },
+    })
+  },
 })

package/src/api/tables.ts

@@ -18,6 +18,8 @@ import {
   MigrateTableResponse,
   MigrateTableRequest,
   DeleteTableResponse,
+  PublishTableRequest,
+  PublishTableResponse,
 } from "@budibase/types"
 import { BaseAPIClient } from "./types"
 
@@ -52,6 +54,10 @@ export interface TableEndpoints {
     oldColumn: string,
     newColumn: string
   ) => Promise<MigrateTableResponse>
+  publishTable: (
+    tableId: string,
+    opts?: PublishTableRequest
+  ) => Promise<PublishTableResponse>
 }
 
 export const buildTableEndpoints = (API: BaseAPIClient): TableEndpoints => ({
@@ -191,6 +197,13 @@ export const buildTableEndpoints = (API: BaseAPIClient): TableEndpoints => ({
     })
   },
 
+  publishTable: async (tableId, opts) => {
+    return await API.post<PublishTableRequest, PublishTableResponse>({
+      url: `/api/tables/${tableId}/publish`,
+      body: opts,
+    })
+  },
+
   /**
    * Duplicates a table without its data.
    * @param tableId the ID of the table to duplicate

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

@@ -6,7 +6,12 @@
   import { getColumnIcon } from "../../../utils/schema"
   import MigrationModal from "../controls/MigrationModal.svelte"
   import { debounce } from "../../../utils/utils"
-  import { FieldType, FormulaType, SortOrder } from "@budibase/types"
+  import {
+    FieldType,
+    FormulaType,
+    SortOrder,
+    isStaticFormula,
+  } from "@budibase/types"
   import { TableNames } from "../../../constants"
   import GridPopover from "../overlays/GridPopover.svelte"
 
@@ -73,7 +78,11 @@
         descending: "high-low",
       }
     }
-    switch (column?.schema?.type) {
+    let schemaType = column.schema?.type
+    if (isStaticFormula(column.schema)) {
+      schemaType = column.schema.responseType
+    }
+    switch (schemaType) {
       case FieldType.NUMBER:
       case FieldType.BIGINT:
         return {

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

@@ -11,10 +11,19 @@
 
   let input
   let active = false
+  let isComposing = false
 
   $: editable = focused && !readonly
   $: displayValue = format?.(value) ?? value ?? ""
 
+  const handleCompositionStart = () => {
+    isComposing = true
+  }
+
+  const handleCompositionEnd = () => {
+    isComposing = false
+  }
+
   const handleChange = e => {
     onChange(e.target.value)
   }
@@ -23,6 +32,9 @@
     if (!active) {
       return false
     }
+    if (e.key === "Enter" && (isComposing || e.isComposing)) {
+      return true
+    }
     if (e.key === "Enter") {
       input?.blur()
       const event = new KeyboardEvent("keydown", { key: "ArrowDown" })
@@ -46,6 +58,8 @@
     bind:this={input}
     on:focus={() => (active = true)}
     on:blur={() => (active = false)}
+    on:compositionstart={handleCompositionStart}
+    on:compositionend={handleCompositionEnd}
     {type}
     value={value ?? ""}
     on:change={handleChange}

package/src/components/grid/overlays/KeyboardManager.svelte

@@ -46,6 +46,10 @@
       }
     }
 
+    if (e.key === "Enter" && e.isComposing) {
+      return
+    }
+
     // Sugar for preventing default
     const handle = fn => {
       e.preventDefault()

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

@@ -35,6 +35,7 @@ interface RowStore {
 interface RowDerivedStore {
   rows: RowStore["rows"]
   rowLookupMap: Readable<Record<string, IndexedUIRow>>
+  rowCount: Readable<number>
 }
 
 interface RowActionStore {
@@ -168,12 +169,15 @@ export const deriveStores = (context: StoreContext): RowDerivedStore => {
     return map
   })
 
+  const rowCount = derived(rows, $rows => $rows.length)
+
   return {
     rows: {
       ...rows,
       subscribe: enrichedRows.subscribe,
     },
     rowLookupMap,
+    rowCount,
   }
 }
 

package/src/fetch/DataFetch.ts

@@ -241,6 +241,7 @@ export default abstract class BaseDataFetch<
       if (
         fieldSchema?.type === FieldType.NUMBER ||
         fieldSchema?.type === FieldType.BIGINT ||
+        fieldSchema?.responseType === FieldType.NUMBER ||
         ("calculationType" in fieldSchema && fieldSchema?.calculationType)
       ) {
         this.options.sortType = SortType.NUMBER

package/src/utils/{table.js → table.ts}

@@ -1,6 +1,7 @@
 import * as sharedCore from "@budibase/shared-core"
+import { UIFieldSchema, isStaticFormula } from "@budibase/types"
 
-export function canBeDisplayColumn(column) {
+export function canBeDisplayColumn(column: UIFieldSchema) {
   if (!sharedCore.canBeDisplayColumn(column.type)) {
     return false
   }
@@ -11,16 +12,20 @@ export function canBeDisplayColumn(column) {
   return true
 }
 
-export function canBeSortColumn(column) {
+export function canBeSortColumn(columnSchema: UIFieldSchema) {
   // Allow sorting by calculation columns
-  if (column.calculationType) {
+  if (columnSchema.calculationType) {
     return true
   }
-  if (!sharedCore.canBeSortColumn(column.type)) {
+  // Allow static-only formula columns to be sorted
+  if (isStaticFormula(columnSchema)) {
+    return true
+  }
+  if (!sharedCore.canBeSortColumn(columnSchema.type)) {
     return false
   }
   // If it's a related column (only available in the frontend), don't allow using it as display column
-  if (column.related) {
+  if (columnSchema.related) {
     return false
   }
   return true