@budibase/frontend-core 2.0.39 → 2.0.40-alpha.1

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@budibase/frontend-core",
-  "version": "2.0.39",
+  "version": "2.0.40-alpha.1",
   "description": "Budibase frontend core libraries used in builder and client",
   "author": "Budibase",
   "license": "MPL-2.0",
   "svelte": "src/index.js",
   "dependencies": {
-    "@budibase/bbui": "^2.0.39",
+    "@budibase/bbui": "2.0.40-alpha.1",
     "lodash": "^4.17.21",
     "svelte": "^3.46.2"
   },
-  "gitHead": "dce0d52b0ad22c3214c348154a7090f872a82ecf"
+  "gitHead": "d7ab0afac13397f1dcc34fe581a270287c17c177"
 }

package/src/api/backups.js

@@ -0,0 +1,50 @@
+export const buildBackupsEndpoints = API => ({
+  /**
+   * Gets a list of users in the current tenant.
+   */
+  searchBackups: async ({ appId, trigger, type, page, startDate, endDate }) => {
+    const opts = {}
+    if (page) {
+      opts.page = page
+    }
+    if (trigger && type) {
+      opts.trigger = trigger.toLowerCase()
+      opts.type = type.toLowerCase()
+    }
+    if (startDate && endDate) {
+      opts.startDate = startDate
+      opts.endDate = endDate
+    }
+    return await API.post({
+      url: `/api/apps/${appId}/backups/search`,
+      body: opts,
+    })
+  },
+
+  createManualBackup: async ({ appId, name }) => {
+    return await API.post({
+      url: `/api/apps/${appId}/backups`,
+      body: { name },
+    })
+  },
+
+  deleteBackup: async ({ appId, backupId }) => {
+    return await API.delete({
+      url: `/api/apps/${appId}/backups/${backupId}`,
+    })
+  },
+
+  updateBackup: async ({ appId, backupId, name }) => {
+    return await API.patch({
+      url: `/api/apps/${appId}/backups/${backupId}`,
+      body: { name },
+    })
+  },
+
+  restoreBackup: async ({ appId, backupId, name }) => {
+    return await API.post({
+      url: `/api/apps/${appId}/backups/${backupId}/import`,
+      body: { name },
+    })
+  },
+})

package/src/api/index.js

@@ -25,6 +25,7 @@ import { buildViewEndpoints } from "./views"
 import { buildLicensingEndpoints } from "./licensing"
 import { buildGroupsEndpoints } from "./groups"
 import { buildPluginEndpoints } from "./plugins"
+import { buildBackupsEndpoints } from "./backups"
 
 const defaultAPIClientConfig = {
   /**
@@ -245,5 +246,6 @@ export const createAPIClient = config => {
     ...buildLicensingEndpoints(API),
     ...buildGroupsEndpoints(API),
     ...buildPluginEndpoints(API),
+    ...buildBackupsEndpoints(API),
   }
 }

package/src/constants.js

@@ -98,6 +98,7 @@ export const BuilderRoleDescriptions = [
 export const PlanType = {
   FREE: "free",
   TEAM: "team",
+  PRO: "pro",
   BUSINESS: "business",
   ENTERPRISE: "enterprise",
 }
@@ -112,6 +113,7 @@ export const ApiVersion = "1"
 
 export const Features = {
   USER_GROUPS: "userGroups",
+  BACKUPS: "appBackups",
 }
 
 // Role IDs

package/src/utils/utils.js

@@ -6,17 +6,29 @@
  */
 export const sequential = fn => {
   let queue = []
-  return async (...params) => {
-    queue.push(async () => {
-      await fn(...params)
-      queue.shift()
-      if (queue.length) {
-        await queue[0]()
+  return (...params) => {
+    return new Promise((resolve, reject) => {
+      queue.push(async () => {
+        let data, error
+        try {
+          data = await fn(...params)
+        } catch (err) {
+          error = err
+        }
+        queue.shift()
+        if (queue.length) {
+          queue[0]()
+        }
+        if (error) {
+          reject(error)
+        } else {
+          resolve(data)
+        }
+      })
+      if (queue.length === 1) {
+        queue[0]()
       }
     })
-    if (queue.length === 1) {
-      await queue[0]()
-    }
   }
 }
 
@@ -40,3 +52,37 @@ export const debounce = (callback, minDelay = 1000) => {
     })
   }
 }
+
+/**
+ * Utility to throttle invocations of a synchronous function. This is better
+ * than a simple debounce invocation for a number of reasons. Features include:
+ * - First invocation is immediate (no initial delay)
+ * - Every invocation has the latest params (no stale params)
+ * - There will always be a final invocation with the last params (no missing
+ *   final update)
+ * @param callback
+ * @param minDelay
+ * @returns {Function} a throttled version function
+ */
+export const throttle = (callback, minDelay = 1000) => {
+  let lastParams
+  let stalled = false
+  let pending = false
+  const invoke = (...params) => {
+    lastParams = params
+    if (stalled) {
+      pending = true
+      return
+    }
+    callback(...lastParams)
+    stalled = true
+    setTimeout(() => {
+      stalled = false
+      if (pending) {
+        pending = false
+        invoke(...lastParams)
+      }
+    }, minDelay)
+  }
+  return invoke
+}