@budibase/frontend-core 3.12.13 → 3.12.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@budibase/frontend-core",
-  "version": "3.12.13",
+  "version": "3.12.15",
   "description": "Budibase frontend core libraries used in builder and client",
   "author": "Budibase",
   "license": "MPL-2.0",
@@ -17,5 +17,5 @@
     "shortid": "2.2.15",
     "socket.io-client": "^4.7.5"
   },
-  "gitHead": "3b8f23325e52fad7328a51218d61c171232d9e02"
+  "gitHead": "e773b5a964aab33ff99a5fea0aa40f16dbfaa2ea"
 }

package/src/api/agents.ts

@@ -6,11 +6,18 @@ import {
   ChatAgentResponse,
   CreateToolSourceRequest,
   FetchAgentHistoryResponse,
+  LLMStreamChunk,
 } from "@budibase/types"
+
 import { BaseAPIClient } from "./types"
 
 export interface AgentEndpoints {
   agentChat: (chat: AgentChat) => Promise<ChatAgentResponse>
+  agentChatStream: (
+    chat: AgentChat,
+    onChunk: (chunk: LLMStreamChunk) => void,
+    onError?: (error: Error) => void
+  ) => Promise<void>
 
   removeChat: (historyId: string) => Promise<void>
   fetchChats: () => Promise<FetchAgentHistoryResponse>
@@ -32,6 +39,67 @@ export const buildAgentEndpoints = (API: BaseAPIClient): AgentEndpoints => ({
     })
   },
 
+  agentChatStream: async (chat, onChunk, onError) => {
+    const body: ChatAgentRequest = chat
+
+    try {
+      // TODO: add support for streaming into the frontend-core API object
+      const response = await fetch("/api/agent/chat/stream", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json",
+        },
+        body: JSON.stringify(body),
+        credentials: "same-origin",
+      })
+
+      if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`)
+      }
+
+      const reader = response.body?.getReader()
+      if (!reader) {
+        throw new Error("Failed to get response reader")
+      }
+
+      const decoder = new TextDecoder()
+      let buffer = ""
+
+      while (true) {
+        const { done, value } = await reader.read()
+
+        if (done) break
+
+        buffer += decoder.decode(value, { stream: true })
+
+        // Process complete lines
+        const lines = buffer.split("\n")
+        buffer = lines.pop() || "" // Keep incomplete line in buffer
+
+        for (const line of lines) {
+          if (line.startsWith("data: ")) {
+            try {
+              const data = line.slice(6) // Remove 'data: ' prefix
+              if (data.trim()) {
+                const chunk: LLMStreamChunk = JSON.parse(data)
+                onChunk(chunk)
+              }
+            } catch (parseError) {
+              console.error("Failed to parse SSE data:", parseError)
+            }
+          }
+        }
+      }
+    } catch (error: any) {
+      if (onError) {
+        onError(error)
+      } else {
+        throw error
+      }
+    }
+  },
+
   removeChat: async (historyId: string) => {
     return await API.delete({
       url: `/api/agent/history/${historyId}`,

package/src/api/app.ts

@@ -12,9 +12,11 @@ import {
   FetchAppPackageResponse,
   FetchAppsResponse,
   FetchDeploymentResponse,
+  FetchPublishedAppsResponse,
   GetDiagnosticsResponse,
   ImportToUpdateAppRequest,
   ImportToUpdateAppResponse,
+  PublishAppRequest,
   PublishAppResponse,
   RevertAppClientResponse,
   RevertAppResponse,
@@ -32,7 +34,10 @@ export interface AppEndpoints {
     metadata: UpdateAppRequest
   ) => Promise<UpdateAppResponse>
   unpublishApp: (appId: string) => Promise<UnpublishAppResponse>
-  publishAppChanges: (appId: string) => Promise<PublishAppResponse>
+  publishAppChanges: (
+    appId: string,
+    opts?: PublishAppRequest
+  ) => Promise<PublishAppResponse>
   revertAppChanges: (appId: string) => Promise<RevertAppResponse>
   updateAppClientVersion: (appId: string) => Promise<UpdateAppClientResponse>
   revertAppClientVersion: (appId: string) => Promise<RevertAppClientResponse>
@@ -55,6 +60,7 @@ export interface AppEndpoints {
     appId: string
   ) => Promise<FetchAppDefinitionResponse>
   addSampleData: (appId: string) => Promise<AddAppSampleDataResponse>
+  getPublishedApps: () => Promise<FetchPublishedAppsResponse["apps"]>
 
   // Missing request or response types
   importApps: (apps: any) => Promise<any>
@@ -86,9 +92,10 @@ export const buildAppEndpoints = (API: BaseAPIClient): AppEndpoints => ({
   /**
    * Publishes the current app.
    */
-  publishAppChanges: async appId => {
+  publishAppChanges: async (appId, opts) => {
     return await API.post({
       url: `/api/applications/${appId}/publish`,
+      body: opts,
     })
   },
 
@@ -267,4 +274,11 @@ export const buildAppEndpoints = (API: BaseAPIClient): AppEndpoints => ({
       url: `/api/applications/${appId}/sample`,
     })
   },
+
+  getPublishedApps: async () => {
+    const response = await API.get<FetchPublishedAppsResponse>({
+      url: `/api/client/applications`,
+    })
+    return response.apps
+  },
 })

package/src/api/auth.ts

@@ -12,12 +12,16 @@ import {
 } from "@budibase/types"
 import { BaseAPIClient } from "./types"
 
+export interface ExtendedLoginResponse extends LoginResponse {
+  invalidatedSessionCount?: number
+}
+
 export interface AuthEndpoints {
   logIn: (
     tenantId: string,
     username: string,
     password: string
-  ) => Promise<LoginResponse>
+  ) => Promise<ExtendedLoginResponse>
   logOut: () => Promise<LogoutResponse>
   requestForgotPassword: (
     tenantId: string,
@@ -46,6 +50,18 @@ export const buildAuthEndpoints = (API: BaseAPIClient): AuthEndpoints => ({
         username,
         password,
       },
+      parseResponse: async response => {
+        const data = (await response.json()) as LoginResponse
+        const invalidatedSessionCount = response.headers.get(
+          "X-Session-Invalidated-Count"
+        )
+        return {
+          ...data,
+          invalidatedSessionCount: invalidatedSessionCount
+            ? parseInt(invalidatedSessionCount)
+            : 0,
+        } as ExtendedLoginResponse
+      },
     })
   },
 

package/src/api/index.ts

@@ -50,6 +50,7 @@ import { buildAgentEndpoints } from "./agents"
 import { buildFeatureFlagEndpoints } from "./features"
 import { buildNavigationEndpoints } from "./navigation"
 import { buildWorkspaceAppEndpoints } from "./workspaceApps"
+import { buildResourceEndpoints } from "./resource"
 
 export type { APIClient } from "./types"
 
@@ -300,5 +301,6 @@ export const createAPIClient = (config: APIClientConfig = {}): APIClient => {
     oauth2: buildOAuth2Endpoints(API),
     navigation: buildNavigationEndpoints(API),
     workspaceApp: buildWorkspaceAppEndpoints(API),
+    resource: buildResourceEndpoints(API),
   }
 }

package/src/api/resource.ts

@@ -0,0 +1,23 @@
+import { ResourceUsageRequest, ResourceUsageResponse } from "@budibase/types"
+import { BaseAPIClient } from "./types"
+
+export interface ResourceEndpoints {
+  searchForUsage: (body: {
+    automationIds?: string[]
+    workspaceAppIds?: string[]
+  }) => Promise<ResourceUsageResponse>
+}
+
+export const buildResourceEndpoints = (
+  API: BaseAPIClient
+): ResourceEndpoints => ({
+  searchForUsage: async (body: {
+    automationIds?: string[]
+    workspaceAppIds?: string[]
+  }) => {
+    return await API.post<ResourceUsageRequest, ResourceUsageResponse>({
+      url: `/api/resources/usage`,
+      body,
+    })
+  },
+})

package/src/api/types.ts

@@ -37,6 +37,7 @@ import { ViewV2Endpoints } from "./viewsV2"
 import { AgentEndpoints } from "./agents"
 import { NavigationEndpoints } from "./navigation"
 import { WorkspaceAppEndpoints } from "./workspaceApps"
+import { ResourceEndpoints } from "./resource"
 
 export enum HTTPMethod {
   POST = "POST",
@@ -140,6 +141,7 @@ export type APIClient = BaseAPIClient &
   UserEndpoints &
   FeatureFlagEndpoints &
   ViewEndpoints & {
+    resource: ResourceEndpoints
     rowActions: RowActionEndpoints
     viewV2: ViewV2Endpoints
     oauth2: OAuth2Endpoints

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

@@ -12,7 +12,7 @@
   export let schema
   export let maximum
 
-  const { API, notifications, props } = getContext("grid")
+  const { API, notifications, props, datasource } = getContext("grid")
   const imageExtensions = ["png", "tiff", "gif", "raw", "jpg", "jpeg"]
 
   let isOpen = false
@@ -55,7 +55,13 @@
       data.append("file", fileList[i])
     }
     try {
-      return await API.uploadBuilderAttachment(data)
+      const tableId = $datasource?.tableId || $datasource?.id
+      if (tableId) {
+        return await API.uploadAttachment(tableId, data)
+      } else {
+        // Fallback to builder endpoint if no table context
+        return await API.uploadBuilderAttachment(data)
+      }
     } catch (error) {
       $notifications.error(error.message || "Failed to upload attachment")
       return []

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

@@ -5,6 +5,7 @@ import {
   EmptyFilterOption,
   UIRow,
   UICondition,
+  EXTERNAL_ROW_REV,
 } from "@budibase/types"
 import { Store as StoreContext } from "."
 
@@ -72,9 +73,19 @@ export const initialise = (context: StoreContext) => {
     const $metadata = get(metadata)
     let metadataUpdates: Record<string, any> = {}
     for (let row of $rows) {
-      if (!row._rev || $metadata[row._id]?.version !== row._rev) {
-        metadataUpdates[row._id] = evaluateConditions(row, $conditions)
+      const changed =
+        // No _rev indicates a new row
+        !row._rev ||
+        // _rev changed since last evaluation
+        $metadata[row._id].version !== row._rev ||
+        // this is an external row, we have no way to know if it has changed, so
+        // we always re-evaluate
+        row._rev === EXTERNAL_ROW_REV
+      if (!changed) {
+        continue
       }
+
+      $metadata[row._id] = evaluateConditions(row, $conditions)
     }
     if (Object.keys(metadataUpdates).length) {
       metadata.update(state => ({

package/src/utils/index.ts

@@ -16,3 +16,4 @@ export * from "./table"
 export * from "./components"
 export * from "./validation"
 export * from "./formatting"
+export * from "./login"

package/src/utils/login.ts

@@ -0,0 +1,29 @@
+import { MAX_SESSIONS_PER_USER } from "@budibase/shared-core"
+
+const SESSIONS_INVALIDATED_KEY = "bb-sessions-invalidated"
+
+// export function checkIfSessionsInvalidatedAndNotify() {
+export function popNumSessionsInvalidated() {
+  const invalidatedCount = parseInt(
+    localStorage.getItem(SESSIONS_INVALIDATED_KEY) || "0",
+    10
+  )
+  localStorage.removeItem(SESSIONS_INVALIDATED_KEY)
+  return invalidatedCount
+}
+
+export function pushNumSessionsInvalidated(num: number) {
+  const currentCount = parseInt(
+    localStorage.getItem(SESSIONS_INVALIDATED_KEY) || "0",
+    10
+  )
+  localStorage.setItem(
+    SESSIONS_INVALIDATED_KEY,
+    (currentCount + num).toString()
+  )
+}
+
+export function invalidationMessage(num: number) {
+  const sessionText = num === 1 ? "session" : "sessions"
+  return `You've been logged out of ${num} other ${sessionText} because users are only allowed ${MAX_SESSIONS_PER_USER} active sessions at any one time.`
+}