@budibase/frontend-core 3.2.28 → 3.2.30

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "@budibase/frontend-core",
-  "version": "3.2.28",
+  "version": "3.2.30",
   "description": "Budibase frontend core libraries used in builder and client",
   "author": "Budibase",
   "license": "MPL-2.0",
-  "svelte": "src/index.js",
+  "svelte": "./src/index.ts",
+  "scripts": {
+    "check:types": "yarn svelte-check"
+  },
   "dependencies": {
     "@budibase/bbui": "*",
     "@budibase/shared-core": "*",
@@ -14,5 +17,8 @@
     "shortid": "2.2.15",
     "socket.io-client": "^4.7.5"
   },
-  "gitHead": "c45756b8f18fc7e36371a33149611f50748a662a"
+  "devDependencies": {
+    "svelte-check": "^4.1.0"
+  },
+  "gitHead": "674ee960a79856f998b71845c0c86c6955a41f80"
 }

package/src/api/ai.ts

@@ -0,0 +1,17 @@
+import { BaseAPIClient } from "./types"
+
+export interface AIEndpoints {
+  generateCronExpression: (prompt: string) => Promise<{ message: string }>
+}
+
+export const buildAIEndpoints = (API: BaseAPIClient): AIEndpoints => ({
+  /**
+   * Generates a cron expression from a prompt
+   */
+  generateCronExpression: async prompt => {
+    return await API.post({
+      url: "/api/ai/cron",
+      body: { prompt },
+    })
+  },
+})

package/src/api/analytics.ts

@@ -0,0 +1,39 @@
+import { BaseAPIClient } from "./types"
+import {
+  AnalyticsEnabledResponse,
+  AnalyticsPingRequest,
+  AnalyticsPingResponse,
+} from "@budibase/types"
+
+export interface AnalyticsEndpoints {
+  getAnalyticsStatus: () => Promise<AnalyticsEnabledResponse>
+  analyticsPing: (
+    payload: Omit<AnalyticsPingRequest, "timezone">
+  ) => Promise<AnalyticsPingResponse>
+}
+
+export const buildAnalyticsEndpoints = (
+  API: BaseAPIClient
+): AnalyticsEndpoints => ({
+  /**
+   * Gets the current status of analytics for this environment
+   */
+  getAnalyticsStatus: async () => {
+    return await API.get({
+      url: "/api/bbtel",
+    })
+  },
+
+  /**
+   * Notifies analytics of a certain environment
+   */
+  analyticsPing: async request => {
+    return await API.post<AnalyticsPingRequest, AnalyticsPingResponse>({
+      url: "/api/bbtel/ping",
+      body: {
+        ...request,
+        timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+      },
+    })
+  },
+})

package/src/api/{app.js → app.ts}

@@ -1,6 +1,72 @@
 import { sdk } from "@budibase/shared-core"
+import { BaseAPIClient } from "./types"
+import {
+  AddAppSampleDataResponse,
+  ClearDevLockResponse,
+  CreateAppRequest,
+  CreateAppResponse,
+  DeleteAppResponse,
+  DuplicateAppRequest,
+  DuplicateAppResponse,
+  FetchAppDefinitionResponse,
+  FetchAppPackageResponse,
+  FetchAppsResponse,
+  FetchDeploymentResponse,
+  GetDiagnosticsResponse,
+  ImportToUpdateAppRequest,
+  ImportToUpdateAppResponse,
+  PublishAppResponse,
+  RevertAppClientResponse,
+  RevertAppResponse,
+  SetRevertableAppVersionRequest,
+  SetRevertableAppVersionResponse,
+  SyncAppResponse,
+  UnpublishAppResponse,
+  UpdateAppClientResponse,
+  UpdateAppRequest,
+  UpdateAppResponse,
+} from "@budibase/types"
 
-export const buildAppEndpoints = API => ({
+export interface AppEndpoints {
+  fetchAppPackage: (appId: string) => Promise<FetchAppPackageResponse>
+  saveAppMetadata: (
+    appId: string,
+    metadata: UpdateAppRequest
+  ) => Promise<UpdateAppResponse>
+  unpublishApp: (appId: string) => Promise<UnpublishAppResponse>
+  publishAppChanges: (appId: string) => Promise<PublishAppResponse>
+  revertAppChanges: (appId: string) => Promise<RevertAppResponse>
+  updateAppClientVersion: (appId: string) => Promise<UpdateAppClientResponse>
+  revertAppClientVersion: (appId: string) => Promise<RevertAppClientResponse>
+  releaseAppLock: (appId: string) => Promise<ClearDevLockResponse>
+  getAppDeployments: () => Promise<FetchDeploymentResponse>
+  createApp: (app: CreateAppRequest) => Promise<CreateAppResponse>
+  deleteApp: (appId: string) => Promise<DeleteAppResponse>
+  duplicateApp: (
+    appId: string,
+    app: DuplicateAppRequest
+  ) => Promise<DuplicateAppResponse>
+  updateAppFromExport: (
+    appId: string,
+    body: ImportToUpdateAppRequest
+  ) => Promise<ImportToUpdateAppResponse>
+  fetchSystemDebugInfo: () => Promise<GetDiagnosticsResponse>
+  syncApp: (appId: string) => Promise<SyncAppResponse>
+  getApps: () => Promise<FetchAppsResponse>
+  fetchComponentLibDefinitions: (
+    appId: string
+  ) => Promise<FetchAppDefinitionResponse>
+  setRevertableVersion: (
+    appId: string,
+    revertableVersion: string
+  ) => Promise<SetRevertableAppVersionResponse>
+  addSampleData: (appId: string) => Promise<AddAppSampleDataResponse>
+
+  // Missing request or response types
+  importApps: (apps: any) => Promise<any>
+}
+
+export const buildAppEndpoints = (API: BaseAPIClient): AppEndpoints => ({
   /**
    * Fetches screen definition for an app.
    * @param appId the ID of the app to fetch from
@@ -16,7 +82,7 @@ export const buildAppEndpoints = API => ({
    * @param appId the ID of the app to update
    * @param metadata the app metadata to save
    */
-  saveAppMetadata: async ({ appId, metadata }) => {
+  saveAppMetadata: async (appId, metadata) => {
     return await API.put({
       url: `/api/applications/${appId}`,
       body: metadata,
@@ -87,7 +153,7 @@ export const buildAppEndpoints = API => ({
    * Duplicate an existing app
    * @param app the app to dupe
    */
-  duplicateApp: async (app, appId) => {
+  duplicateApp: async (appId, app) => {
     return await API.post({
       url: `/api/applications/${appId}/duplicate`,
       body: app,
@@ -184,7 +250,7 @@ export const buildAppEndpoints = API => ({
   /**
    * Fetches the definitions for component library components. This includes
    * their props and other metadata from components.json.
-   * @param {string} appId - ID of the currently running app
+   * @param appId ID of the currently running app
    */
   fetchComponentLibDefinitions: async appId => {
     return await API.get({
@@ -192,14 +258,27 @@ export const buildAppEndpoints = API => ({
     })
   },
 
+  /**
+   * Adds sample data to an app
+   * @param appId the app ID
+   */
   addSampleData: async appId => {
     return await API.post({
       url: `/api/applications/${appId}/sample`,
     })
   },
 
+  /**
+   * Sets the revertable version of an app.
+   * Used when manually reverting to older client versions.
+   * @param appId the app ID
+   * @param revertableVersion the version number
+   */
   setRevertableVersion: async (appId, revertableVersion) => {
-    return await API.post({
+    return await API.post<
+      SetRevertableAppVersionRequest,
+      SetRevertableAppVersionResponse
+    >({
       url: `/api/applications/${appId}/setRevertableVersion`,
       body: {
         revertableVersion,

package/src/api/attachments.ts

@@ -0,0 +1,121 @@
+import {
+  DownloadAttachmentResponse,
+  GetSignedUploadUrlRequest,
+  GetSignedUploadUrlResponse,
+  ProcessAttachmentResponse,
+} from "@budibase/types"
+import { BaseAPIClient } from "./types"
+
+export interface AttachmentEndpoints {
+  downloadAttachment: (
+    datasourceId: string,
+    rowId: string,
+    columnName: string
+  ) => Promise<DownloadAttachmentResponse>
+  getSignedDatasourceURL: (
+    datasourceId: string,
+    bucket: string,
+    key: string
+  ) => Promise<GetSignedUploadUrlResponse>
+  uploadAttachment: (
+    tableId: string,
+    data: any
+  ) => Promise<ProcessAttachmentResponse>
+  uploadBuilderAttachment: (data: any) => Promise<ProcessAttachmentResponse>
+  externalUpload: (
+    datasourceId: string,
+    bucket: string,
+    key: string,
+    data: any
+  ) => Promise<{ publicUrl: string | undefined }>
+}
+
+export const buildAttachmentEndpoints = (
+  API: BaseAPIClient
+): AttachmentEndpoints => {
+  const endpoints: Pick<AttachmentEndpoints, "getSignedDatasourceURL"> = {
+    /**
+     * Generates a signed URL to upload a file to an external datasource.
+     * @param datasourceId the ID of the datasource to upload to
+     * @param bucket the name of the bucket to upload to
+     * @param key the name of the file to upload to
+     */
+    getSignedDatasourceURL: async (datasourceId, bucket, key) => {
+      return await API.post<
+        GetSignedUploadUrlRequest,
+        GetSignedUploadUrlResponse
+      >({
+        url: `/api/attachments/${datasourceId}/url`,
+        body: { bucket, key },
+      })
+    },
+  }
+
+  return {
+    ...endpoints,
+
+    /**
+     * Uploads an attachment to the server.
+     * @param data the attachment to upload
+     * @param tableId the table ID to upload to
+     */
+    uploadAttachment: async (tableId, data) => {
+      return await API.post({
+        url: `/api/attachments/${tableId}/upload`,
+        body: data,
+        json: false,
+      })
+    },
+
+    /**
+     * Uploads an attachment to the server as a builder user from the builder.
+     * @param data the data to upload
+     */
+    uploadBuilderAttachment: async data => {
+      return await API.post({
+        url: "/api/attachments/process",
+        body: data,
+        json: false,
+      })
+    },
+
+    /**
+     * Uploads a file to an external datasource.
+     * @param datasourceId the ID of the datasource to upload to
+     * @param bucket the name of the bucket to upload to
+     * @param key the name of the file to upload to
+     * @param data the file to upload
+     */
+    externalUpload: async (datasourceId, bucket, key, data) => {
+      const { signedUrl, publicUrl } = await endpoints.getSignedDatasourceURL(
+        datasourceId,
+        bucket,
+        key
+      )
+      if (!signedUrl) {
+        return { publicUrl: undefined }
+      }
+      await API.put({
+        url: signedUrl,
+        body: data,
+        json: false,
+        external: true,
+      })
+      return { publicUrl }
+    },
+
+    /**
+     * Download an attachment from a row given its column name.
+     * @param datasourceId the ID of the datasource to download from
+     * @param rowId the ID of the row to download from
+     * @param columnName the column name to download
+     */
+    downloadAttachment: async (datasourceId, rowId, columnName) => {
+      return await API.get({
+        url: `/api/${datasourceId}/rows/${rowId}/attachment/${columnName}`,
+        parseResponse: response => response as any,
+        suppressErrors: true,
+      })
+    },
+  }
+}

package/src/api/auditLogs.ts

@@ -0,0 +1,35 @@
+import {
+  SearchAuditLogsRequest,
+  SearchAuditLogsResponse,
+  DefinitionsAuditLogsResponse,
+  DownloadAuditLogsRequest,
+} from "@budibase/types"
+import { BaseAPIClient } from "./types"
+
+export interface AuditLogEndpoints {
+  searchAuditLogs: (
+    opts: SearchAuditLogsRequest
+  ) => Promise<SearchAuditLogsResponse>
+  getEventDefinitions: () => Promise<DefinitionsAuditLogsResponse>
+  getDownloadUrl: (opts: DownloadAuditLogsRequest) => string
+}
+
+export const buildAuditLogEndpoints = (
+  API: BaseAPIClient
+): AuditLogEndpoints => ({
+  searchAuditLogs: async opts => {
+    return await API.post({
+      url: `/api/global/auditlogs/search`,
+      body: opts,
+    })
+  },
+  getEventDefinitions: async () => {
+    return await API.get({
+      url: `/api/global/auditlogs/definitions`,
+    })
+  },
+  getDownloadUrl: opts => {
+    const query = encodeURIComponent(JSON.stringify(opts))
+    return `/api/global/auditlogs/download?query=${query}`
+  },
+})

package/src/api/{auth.js → auth.ts}

@@ -1,12 +1,46 @@
-export const buildAuthEndpoints = API => ({
+import {
+  GetInitInfoResponse,
+  LoginRequest,
+  LoginResponse,
+  LogoutResponse,
+  PasswordResetRequest,
+  PasswordResetResponse,
+  PasswordResetUpdateRequest,
+  PasswordResetUpdateResponse,
+  SetInitInfoRequest,
+  SetInitInfoResponse,
+} from "@budibase/types"
+import { BaseAPIClient } from "./types"
+
+export interface AuthEndpoints {
+  logIn: (
+    tenantId: string,
+    username: string,
+    password: string
+  ) => Promise<LoginResponse>
+  logOut: () => Promise<LogoutResponse>
+  requestForgotPassword: (
+    tenantId: string,
+    email: string
+  ) => Promise<PasswordResetResponse>
+  resetPassword: (
+    tenantId: string,
+    password: string,
+    resetCode: string
+  ) => Promise<PasswordResetUpdateResponse>
+  setInitInfo: (info: SetInitInfoRequest) => Promise<SetInitInfoResponse>
+  getInitInfo: () => Promise<GetInitInfoResponse>
+}
+
+export const buildAuthEndpoints = (API: BaseAPIClient): AuthEndpoints => ({
   /**
    * Performs a login request.
    * @param tenantId the ID of the tenant to log in to
    * @param username the username (email)
    * @param password the password
    */
-  logIn: async ({ tenantId, username, password }) => {
-    return await API.post({
+  logIn: async (tenantId, username, password) => {
+    return await API.post<LoginRequest, LoginResponse>({
       url: `/api/global/auth/${tenantId}/login`,
       body: {
         username,
@@ -49,8 +83,8 @@ export const buildAuthEndpoints = API => ({
    * @param tenantId the ID of the tenant the user is in
    * @param email the email address of the user
    */
-  requestForgotPassword: async ({ tenantId, email }) => {
-    return await API.post({
+  requestForgotPassword: async (tenantId, email) => {
+    return await API.post<PasswordResetRequest, PasswordResetResponse>({
       url: `/api/global/auth/${tenantId}/reset`,
       body: {
         email,
@@ -64,8 +98,11 @@ export const buildAuthEndpoints = API => ({
    * @param password the new password to set
    * @param resetCode the reset code to authenticate the request
    */
-  resetPassword: async ({ tenantId, password, resetCode }) => {
-    return await API.post({
+  resetPassword: async (tenantId, password, resetCode) => {
+    return await API.post<
+      PasswordResetUpdateRequest,
+      PasswordResetUpdateResponse
+    >({
       url: `/api/global/auth/${tenantId}/reset/update`,
       body: {
         password,

package/src/api/automations.ts

@@ -0,0 +1,158 @@
+import {
+  ClearAutomationLogRequest,
+  ClearAutomationLogResponse,
+  CreateAutomationRequest,
+  CreateAutomationResponse,
+  DeleteAutomationResponse,
+  FetchAutomationResponse,
+  GetAutomationStepDefinitionsResponse,
+  SearchAutomationLogsRequest,
+  SearchAutomationLogsResponse,
+  TestAutomationRequest,
+  TestAutomationResponse,
+  TriggerAutomationRequest,
+  TriggerAutomationResponse,
+  UpdateAutomationRequest,
+  UpdateAutomationResponse,
+} from "@budibase/types"
+import { BaseAPIClient } from "./types"
+
+export interface AutomationEndpoints {
+  getAutomations: () => Promise<FetchAutomationResponse>
+  createAutomation: (
+    automation: CreateAutomationRequest
+  ) => Promise<CreateAutomationResponse>
+  updateAutomation: (
+    automation: UpdateAutomationRequest
+  ) => Promise<UpdateAutomationResponse>
+  deleteAutomation: (
+    automationId: string,
+    automationRev: string
+  ) => Promise<DeleteAutomationResponse>
+  clearAutomationLogErrors: (
+    automationId: string,
+    appId: string
+  ) => Promise<ClearAutomationLogResponse>
+  triggerAutomation: (
+    automationId: string,
+    fields: Record<string, any>,
+    timeout: number
+  ) => Promise<TriggerAutomationResponse>
+  testAutomation: (
+    automationdId: string,
+    data: TestAutomationRequest
+  ) => Promise<TestAutomationResponse>
+  getAutomationDefinitions: () => Promise<GetAutomationStepDefinitionsResponse>
+  getAutomationLogs: (
+    options: SearchAutomationLogsRequest
+  ) => Promise<SearchAutomationLogsResponse>
+}
+
+export const buildAutomationEndpoints = (
+  API: BaseAPIClient
+): AutomationEndpoints => ({
+  /**
+   * Executes an automation. Must have "App Action" trigger.
+   * @param automationId the ID of the automation to trigger
+   * @param fields the fields to trigger the automation with
+   * @param timeout a timeout override
+   */
+  triggerAutomation: async (automationId, fields, timeout) => {
+    return await API.post<TriggerAutomationRequest, TriggerAutomationResponse>({
+      url: `/api/automations/${automationId}/trigger`,
+      body: { fields, timeout },
+    })
+  },
+
+  /**
+   * Tests an automation with data.
+   * @param automationId the ID of the automation to test
+   * @param data the test data to run against the automation
+   */
+  testAutomation: async (automationId, data) => {
+    return await API.post({
+      url: `/api/automations/${automationId}/test`,
+      body: data,
+    })
+  },
+
+  /**
+   * Gets a list of all automations.
+   */
+  getAutomations: async () => {
+    return await API.get({
+      url: "/api/automations",
+    })
+  },
+
+  /**
+   * Gets a list of all the definitions for blocks in automations.
+   */
+  getAutomationDefinitions: async () => {
+    return await API.get({
+      url: "/api/automations/definitions/list",
+    })
+  },
+
+  /**
+   * Creates an automation.
+   * @param automation the automation to create
+   */
+  createAutomation: async automation => {
+    return await API.post({
+      url: "/api/automations",
+      body: automation,
+    })
+  },
+
+  /**
+   * Updates an automation.
+   * @param automation the automation to update
+   */
+  updateAutomation: async automation => {
+    return await API.put({
+      url: "/api/automations",
+      body: automation,
+    })
+  },
+
+  /**
+   * Deletes an automation
+   * @param automationId the ID of the automation to delete
+   * @param automationRev the rev of the automation to delete
+   */
+  deleteAutomation: async (automationId, automationRev) => {
+    return await API.delete({
+      url: `/api/automations/${automationId}/${automationRev}`,
+    })
+  },
+
+  /**
+   * Get the logs for the app, or by automation ID.
+   */
+  getAutomationLogs: async data => {
+    return await API.post({
+      url: "/api/automations/logs/search",
+      body: data,
+    })
+  },
+
+  /**
+   * Clears automation log errors (which are creating notification) for
+   * automation or the app.
+   * @param automationId optional - the ID of the automation to clear errors for.
+   * @param appId The app ID to clear errors for.
+   */
+  clearAutomationLogErrors: async (automationId, appId) => {
+    return await API.delete<
+      ClearAutomationLogRequest,
+      ClearAutomationLogResponse
+    >({
+      url: "/api/automations/logs",
+      body: {
+        appId,
+        automationId,
+      },
+    })
+  },
+})

package/src/api/backups.ts

@@ -0,0 +1,50 @@
+import {
+  CreateAppBackupResponse,
+  ImportAppBackupResponse,
+  SearchAppBackupsRequest,
+} from "@budibase/types"
+import { BaseAPIClient } from "./types"
+
+export interface BackupEndpoints {
+  createManualBackup: (appId: string) => Promise<CreateAppBackupResponse>
+  restoreBackup: (
+    appId: string,
+    backupId: string,
+    name?: string
+  ) => Promise<ImportAppBackupResponse>
+
+  // Missing request or response types
+  searchBackups: (appId: string, opts: SearchAppBackupsRequest) => Promise<any>
+  deleteBackup: (
+    appId: string,
+    backupId: string
+  ) => Promise<{ message: string }>
+}
+
+export const buildBackupEndpoints = (API: BaseAPIClient): BackupEndpoints => ({
+  createManualBackup: async appId => {
+    return await API.post({
+      url: `/api/apps/${appId}/backups`,
+    })
+  },
+  searchBackups: async (appId, opts) => {
+    return await API.post({
+      url: `/api/apps/${appId}/backups/search`,
+      body: opts,
+    })
+  },
+  deleteBackup: async (appId, backupId) => {
+    return await API.delete({
+      url: `/api/apps/${appId}/backups/${backupId}`,
+    })
+  },
+  restoreBackup: async (appId, backupId, name) => {
+    return await API.post({
+      url: `/api/apps/${appId}/backups/${backupId}/import`,
+      // Name is a legacy thing, but unsure if it is needed for restoring.
+      // Leaving this in just in case, but not type casting the body here
+      // as we won't normally have it, but it's required in the type.
+      body: { name },
+    })
+  },
+})