@budibase/server 2.0.39 → 2.0.40

package/src/api/controllers/row/index.ts

@@ -30,18 +30,16 @@ export async function patch(ctx: any): Promise<any> {
   if (body && !body._id) {
     return save(ctx)
   }
-  try {
-    const { row, table } = await quotas.addQuery(() =>
-      pickApi(tableId).patch(ctx)
-    )
-    ctx.status = 200
-    ctx.eventEmitter &&
-      ctx.eventEmitter.emitRow(`row:update`, appId, row, table)
-    ctx.message = `${table.name} updated successfully.`
-    ctx.body = row
-  } catch (err) {
-    ctx.throw(400, err)
-  }
+  const { row, table } = await quotas.addQuery(
+    () => pickApi(tableId).patch(ctx),
+    {
+      datasourceId: tableId,
+    }
+  )
+  ctx.status = 200
+  ctx.eventEmitter && ctx.eventEmitter.emitRow(`row:update`, appId, row, table)
+  ctx.message = `${table.name} updated successfully.`
+  ctx.body = row
 }
 
 export const save = async (ctx: any) => {
@@ -52,44 +50,35 @@ export const save = async (ctx: any) => {
   if (body && body._id) {
     return patch(ctx)
   }
-  try {
-    const { row, table } = await quotas.addRow(() =>
-      quotas.addQuery(() => pickApi(tableId).save(ctx))
-    )
-    ctx.status = 200
-    ctx.eventEmitter && ctx.eventEmitter.emitRow(`row:save`, appId, row, table)
-    ctx.message = `${table.name} saved successfully`
-    ctx.body = row
-  } catch (err) {
-    ctx.throw(400, err)
-  }
+  const { row, table } = await quotas.addRow(() =>
+    quotas.addQuery(() => pickApi(tableId).save(ctx), {
+      datasourceId: tableId,
+    })
+  )
+  ctx.status = 200
+  ctx.eventEmitter && ctx.eventEmitter.emitRow(`row:save`, appId, row, table)
+  ctx.message = `${table.name} saved successfully`
+  ctx.body = row
 }
-
 export async function fetchView(ctx: any) {
   const tableId = getTableId(ctx)
-  try {
-    ctx.body = await quotas.addQuery(() => pickApi(tableId).fetchView(ctx))
-  } catch (err) {
-    ctx.throw(400, err)
-  }
+  ctx.body = await quotas.addQuery(() => pickApi(tableId).fetchView(ctx), {
+    datasourceId: tableId,
+  })
 }
 
 export async function fetch(ctx: any) {
   const tableId = getTableId(ctx)
-  try {
-    ctx.body = await quotas.addQuery(() => pickApi(tableId).fetch(ctx))
-  } catch (err) {
-    ctx.throw(400, err)
-  }
+  ctx.body = await quotas.addQuery(() => pickApi(tableId).fetch(ctx), {
+    datasourceId: tableId,
+  })
 }
 
 export async function find(ctx: any) {
   const tableId = getTableId(ctx)
-  try {
-    ctx.body = await quotas.addQuery(() => pickApi(tableId).find(ctx))
-  } catch (err) {
-    ctx.throw(400, err)
-  }
+  ctx.body = await quotas.addQuery(() => pickApi(tableId).find(ctx), {
+    datasourceId: tableId,
+  })
 }
 
 export async function destroy(ctx: any) {
@@ -98,8 +87,11 @@ export async function destroy(ctx: any) {
   const tableId = getTableId(ctx)
   let response, row
   if (inputs.rows) {
-    let { rows } = await quotas.addQuery(() =>
-      pickApi(tableId).bulkDestroy(ctx)
+    let { rows } = await quotas.addQuery(
+      () => pickApi(tableId).bulkDestroy(ctx),
+      {
+        datasourceId: tableId,
+      }
     )
     await quotas.removeRows(rows.length)
     response = rows
@@ -107,7 +99,9 @@ export async function destroy(ctx: any) {
       ctx.eventEmitter && ctx.eventEmitter.emitRow(`row:delete`, appId, row)
     }
   } else {
-    let resp = await quotas.addQuery(() => pickApi(tableId).destroy(ctx))
+    let resp = await quotas.addQuery(() => pickApi(tableId).destroy(ctx), {
+      datasourceId: tableId,
+    })
     await quotas.removeRow()
     response = resp.response
     row = resp.row
@@ -121,39 +115,30 @@ export async function destroy(ctx: any) {
 
 export async function search(ctx: any) {
   const tableId = getTableId(ctx)
-  try {
-    ctx.status = 200
-    ctx.body = await quotas.addQuery(() => pickApi(tableId).search(ctx))
-  } catch (err) {
-    ctx.throw(400, err)
-  }
+  ctx.status = 200
+  ctx.body = await quotas.addQuery(() => pickApi(tableId).search(ctx), {
+    datasourceId: tableId,
+  })
 }
 
 export async function validate(ctx: any) {
   const tableId = getTableId(ctx)
-  try {
-    ctx.body = await pickApi(tableId).validate(ctx)
-  } catch (err) {
-    ctx.throw(400, err)
-  }
+  ctx.body = await pickApi(tableId).validate(ctx)
 }
 
 export async function fetchEnrichedRow(ctx: any) {
   const tableId = getTableId(ctx)
-  try {
-    ctx.body = await quotas.addQuery(() =>
-      pickApi(tableId).fetchEnrichedRow(ctx)
-    )
-  } catch (err) {
-    ctx.throw(400, err)
-  }
+  ctx.body = await quotas.addQuery(
+    () => pickApi(tableId).fetchEnrichedRow(ctx),
+    {
+      datasourceId: tableId,
+    }
+  )
 }
 
 export const exportRows = async (ctx: any) => {
   const tableId = getTableId(ctx)
-  try {
-    ctx.body = await quotas.addQuery(() => pickApi(tableId).exportRows(ctx))
-  } catch (err) {
-    ctx.throw(400, err)
-  }
+  ctx.body = await quotas.addQuery(() => pickApi(tableId).exportRows(ctx), {
+    datasourceId: tableId,
+  })
 }

package/src/api/controllers/row/internal.js

@@ -118,7 +118,7 @@ exports.patch = async ctx => {
   })
 
   if (!validateResult.valid) {
-    throw { validation: validateResult.errors }
+    ctx.throw(400, { validation: validateResult.errors })
   }
 
   // returned row is cleaned and prepared for writing to DB

package/src/api/controllers/static/index.ts

@@ -5,7 +5,7 @@ require("svelte/register")
 const send = require("koa-send")
 const { resolve, join } = require("../../../utilities/centralPath")
 const uuid = require("uuid")
-const { ObjectStoreBuckets } = require("../../../constants")
+const { ObjectStoreBuckets, ATTACHMENT_DIR } = require("../../../constants")
 const { processString } = require("@budibase/string-templates")
 const {
   loadHandlebarsFile,
@@ -90,7 +90,7 @@ export const uploadFile = async function (ctx: any) {
 
     return prepareUpload({
       file,
-      s3Key: `${ctx.appId}/attachments/${processedFileName}`,
+      s3Key: `${ctx.appId}/${ATTACHMENT_DIR}/${processedFileName}`,
       bucket: ObjectStoreBuckets.APPS,
     })
   })
@@ -111,6 +111,8 @@ export const serveApp = async function (ctx: any) {
     const App = require("./templates/BudibaseApp.svelte").default
     const plugins = enrichPluginURLs(appInfo.usedPlugins)
     const { head, html, css } = App.render({
+      metaImage:
+        "https://res.cloudinary.com/daog6scxm/image/upload/v1666109324/meta-images/budibase-meta-image_uukc1m.png",
       title: appInfo.name,
       production: env.isProd(),
       appId,

package/src/api/controllers/static/templates/BudibaseApp.svelte

@@ -1,6 +1,8 @@
 <script>
   export let title = ""
   export let favicon = ""
+  export let metaImage = ""
+  export let url = ""
 
   export let clientLibPath
   export let usedPlugins
@@ -12,6 +14,15 @@
     name="viewport"
     content="width=device-width, initial-scale=1.0, viewport-fit=cover"
   />
+  <!-- Opengraph Meta Tags -->
+  <meta name="twitter:card" content="summary_large_image" />
+  <meta name="twitter:site" content="@budibase" />
+  <meta name="twitter:image" content={metaImage} />
+  <meta name="twitter:title" content="{title} - built with Budibase" />
+  <meta property="og:site_name" content="Budibase" />
+  <meta property="og:title" content="{title} - built with Budibase" />
+  <meta property="og:type" content="website" />
+  <meta property="og:image" content={metaImage} />
 
   <title>{title}</title>
   <link rel="icon" type="image/png" href={favicon} />

package/src/api/controllers/static/templates/preview.hbs

@@ -56,6 +56,16 @@
         return
       }
 
+      // If this is a custom event, try and handle it
+      if (parsed.runtimeEvent) {
+        const { name, payload } = parsed
+        if (window.handleBuilderRuntimeEvent) {
+          window.handleBuilderRuntimeEvent(name, payload)
+        }
+        return
+      }
+
+      // Otherwise this is a full reload message
       // Extract data from message
       const {
         selectedComponentId,

package/src/api/controllers/table/bulkFormula.js

@@ -1,10 +1,11 @@
 const { FieldTypes, FormulaTypes } = require("../../../constants")
-const { getAllInternalTables, clearColumns } = require("./utils")
+const { clearColumns } = require("./utils")
 const { doesContainStrings } = require("@budibase/string-templates")
 const { cloneDeep } = require("lodash/fp")
 const { isEqual, uniq } = require("lodash")
 const { updateAllFormulasInTable } = require("../row/staticFormula")
 const { getAppDB } = require("@budibase/backend-core/context")
+const sdk = require("../../../sdk")
 
 function isStaticFormula(column) {
   return (
@@ -39,7 +40,7 @@ function getFormulaThatUseColumn(table, columnNames) {
  */
 async function checkIfFormulaNeedsCleared(table, { oldTable, deletion }) {
   // start by retrieving all tables, remove the current table from the list
-  const tables = (await getAllInternalTables()).filter(
+  const tables = (await sdk.tables.getAllInternalTables()).filter(
     tbl => tbl._id !== table._id
   )
   const schemaToUse = oldTable ? oldTable.schema : table.schema
@@ -99,7 +100,7 @@ async function updateRelatedFormulaLinksOnTables(
 ) {
   const db = getAppDB()
   // start by retrieving all tables, remove the current table from the list
-  const tables = (await getAllInternalTables()).filter(
+  const tables = (await sdk.tables.getAllInternalTables()).filter(
     tbl => tbl._id !== table._id
   )
   // clone the tables, so we can compare at end

package/src/api/controllers/table/external.js

@@ -3,7 +3,6 @@ const {
   breakExternalTableId,
 } = require("../../../integrations/utils")
 const {
-  getTable,
   generateForeignKey,
   generateJunctionTableName,
   foreignKeyStructure,
@@ -20,6 +19,7 @@ const csvParser = require("../../../utilities/csvParser")
 const { handleRequest } = require("../row/external")
 const { getAppDB } = require("@budibase/backend-core/context")
 const { events } = require("@budibase/backend-core")
+const sdk = require("../../../sdk")
 
 async function makeTableRequest(
   datasource,
@@ -181,7 +181,7 @@ exports.save = async function (ctx) {
 
   let oldTable
   if (ctx.request.body && ctx.request.body._id) {
-    oldTable = await getTable(ctx.request.body._id)
+    oldTable = await sdk.tables.getTable(ctx.request.body._id)
   }
 
   if (hasTypeChanged(tableToSave, oldTable)) {
@@ -281,7 +281,7 @@ exports.save = async function (ctx) {
 }
 
 exports.destroy = async function (ctx) {
-  const tableToDelete = await getTable(ctx.params.tableId)
+  const tableToDelete = await sdk.tables.getTable(ctx.params.tableId)
   if (!tableToDelete || !tableToDelete.created) {
     ctx.throw(400, "Cannot delete tables which weren't created in Budibase.")
   }
@@ -303,7 +303,7 @@ exports.destroy = async function (ctx) {
 }
 
 exports.bulkImport = async function (ctx) {
-  const table = await getTable(ctx.params.tableId)
+  const table = await sdk.tables.getTable(ctx.params.tableId)
   const { dataImport } = ctx.request.body
   if (!dataImport || !dataImport.schema || !dataImport.csvString) {
     ctx.throw(400, "Provided data import information is invalid.")

package/src/api/controllers/table/index.js

@@ -4,8 +4,8 @@ const csvParser = require("../../../utilities/csvParser")
 const { isExternalTable, isSQL } = require("../../../integrations/utils")
 const { getDatasourceParams } = require("../../../db/utils")
 const { getAppDB } = require("@budibase/backend-core/context")
-const { getTable, getAllInternalTables } = require("./utils")
 const { events } = require("@budibase/backend-core")
+const sdk = require("../../../sdk")
 
 function pickApi({ tableId, table }) {
   if (table && !tableId) {
@@ -23,7 +23,7 @@ function pickApi({ tableId, table }) {
 exports.fetch = async function (ctx) {
   const db = getAppDB()
 
-  const internal = await getAllInternalTables()
+  const internal = await sdk.tables.getAllInternalTables()
 
   const externalTables = await db.allDocs(
     getDatasourceParams("plus", {
@@ -50,7 +50,7 @@ exports.fetch = async function (ctx) {
 
 exports.find = async function (ctx) {
   const tableId = ctx.params.tableId
-  ctx.body = await getTable(tableId)
+  ctx.body = await sdk.tables.getTable(tableId)
 }
 
 exports.save = async function (ctx) {
@@ -101,7 +101,7 @@ exports.validateCSVSchema = async function (ctx) {
   const { csvString, schema = {}, tableId } = ctx.request.body
   let existingTable
   if (tableId) {
-    existingTable = await getTable(tableId)
+    existingTable = await sdk.tables.getTable(tableId)
   }
   let result = await csvParser.parse(csvString, schema)
   if (existingTable) {

package/src/api/controllers/table/internal.ts

@@ -1,12 +1,7 @@
 import { updateLinks, EventType } from "../../../db/linkedRows"
 import { getRowParams, generateTableID } from "../../../db/utils"
 import { FieldTypes } from "../../../constants"
-import {
-  TableSaveFunctions,
-  hasTypeChanged,
-  getTable,
-  handleDataImport,
-} from "./utils"
+import { TableSaveFunctions, hasTypeChanged, handleDataImport } from "./utils"
 const { getAppDB } = require("@budibase/backend-core/context")
 import { isTest } from "../../../environment"
 import {
@@ -18,6 +13,8 @@ import { Table } from "@budibase/types"
 import { quotas } from "@budibase/pro"
 import { isEqual } from "lodash"
 import { cloneDeep } from "lodash/fp"
+import env from "../../../environment"
+import sdk from "../../../sdk"
 
 function checkAutoColumns(table: Table, oldTable: Table) {
   if (!table.schema) {
@@ -153,7 +150,9 @@ export async function destroy(ctx: any) {
   await db.bulkDocs(
     rows.rows.map((row: any) => ({ ...row.doc, _deleted: true }))
   )
-  await quotas.removeRows(rows.rows.length)
+  await quotas.removeRows(rows.rows.length, {
+    tableId: ctx.params.tableId,
+  })
 
   // update linked rows
   await updateLinks({
@@ -165,7 +164,7 @@ export async function destroy(ctx: any) {
   await db.remove(tableToDelete)
 
   // remove table search index
-  if (!isTest()) {
+  if (!isTest() || env.COUCH_DB_URL) {
     const currentIndexes = await db.getIndexes()
     const existingIndex = currentIndexes.indexes.find(
       (existing: any) => existing.name === `search:${ctx.params.tableId}`
@@ -185,7 +184,7 @@ export async function destroy(ctx: any) {
 }
 
 export async function bulkImport(ctx: any) {
-  const table = await getTable(ctx.params.tableId)
+  const table = await sdk.tables.getTable(ctx.params.tableId)
   const { dataImport } = ctx.request.body
   await handleDataImport(ctx.user, table, dataImport)
   return table

package/src/api/controllers/table/utils.ts

@@ -1,11 +1,5 @@
 import { transform } from "../../../utilities/csvParser"
-import {
-  getRowParams,
-  generateRowID,
-  InternalTables,
-  getTableParams,
-  BudibaseInternalDB,
-} from "../../../db/utils"
+import { getRowParams, generateRowID, InternalTables } from "../../../db/utils"
 import { isEqual } from "lodash"
 import { AutoFieldSubTypes, FieldTypes } from "../../../constants"
 import {
@@ -17,11 +11,6 @@ import {
   SwitchableTypes,
   CanSwitchTypes,
 } from "../../../constants"
-import {
-  isExternalTable,
-  breakExternalTableId,
-  isSQL,
-} from "../../../integrations/utils"
 import { getViews, saveView } from "../view/utils"
 import viewTemplate from "../view/viewBuilder"
 const { getAppDB } = require("@budibase/backend-core/context")
@@ -148,7 +137,9 @@ export async function handleDataImport(user: any, table: any, dataImport: any) {
     finalData.push(row)
   }
 
-  await quotas.addRows(finalData.length, () => db.bulkDocs(finalData))
+  await quotas.addRows(finalData.length, () => db.bulkDocs(finalData), {
+    tableId: table._id,
+  })
   await events.rows.imported(table, "csv", finalData.length)
   return table
 }
@@ -254,46 +245,6 @@ class TableSaveFunctions {
   }
 }
 
-export async function getAllInternalTables() {
-  const db = getAppDB()
-  const internalTables = await db.allDocs(
-    getTableParams(null, {
-      include_docs: true,
-    })
-  )
-  return internalTables.rows.map((tableDoc: any) => ({
-    ...tableDoc.doc,
-    type: "internal",
-    sourceId: BudibaseInternalDB._id,
-  }))
-}
-
-export async function getAllExternalTables(datasourceId: any) {
-  const db = getAppDB()
-  const datasource = await db.get(datasourceId)
-  if (!datasource || !datasource.entities) {
-    throw "Datasource is not configured fully."
-  }
-  return datasource.entities
-}
-
-export async function getExternalTable(datasourceId: any, tableName: any) {
-  const entities = await getAllExternalTables(datasourceId)
-  return entities[tableName]
-}
-
-export async function getTable(tableId: any) {
-  const db = getAppDB()
-  if (isExternalTable(tableId)) {
-    let { datasourceId, tableName } = breakExternalTableId(tableId)
-    const datasource = await db.get(datasourceId)
-    const table = await getExternalTable(datasourceId, tableName)
-    return { ...table, sql: isSQL(datasource) }
-  } else {
-    return db.get(tableId)
-  }
-}
-
 export async function checkForViewUpdates(
   table: any,
   rename: any,

package/src/api/controllers/view/index.js

@@ -3,12 +3,12 @@ const { apiFileReturn } = require("../../../utilities/fileSystem")
 const exporters = require("./exporters")
 const { saveView, getView, getViews, deleteView } = require("./utils")
 const { fetchView } = require("../row")
-const { getTable } = require("../table/utils")
 const { FieldTypes } = require("../../../constants")
 const { getAppDB } = require("@budibase/backend-core/context")
 const { events } = require("@budibase/backend-core")
 const { DocumentType } = require("../../../db/utils")
 const { cloneDeep, isEqual } = require("lodash")
+const sdk = require("../../../sdk")
 
 exports.fetch = async ctx => {
   ctx.body = await getViews()
@@ -144,7 +144,7 @@ exports.exportView = async ctx => {
 
   let schema = view && view.meta && view.meta.schema
   const tableId = ctx.params.tableId || view.meta.tableId
-  const table = await getTable(tableId)
+  const table = await sdk.tables.getTable(tableId)
   if (!schema) {
     schema = table.schema
   }

package/src/api/controllers/{webhook.js → webhook.ts}

@@ -1,66 +1,51 @@
-const { generateWebhookID, getWebhookParams } = require("../../db/utils")
+import { getWebhookParams } from "../../db/utils"
+import triggers from "../../automations/triggers"
+import { db as dbCore, context } from "@budibase/backend-core"
+import {
+  Webhook,
+  WebhookActionType,
+  BBContext,
+  Automation,
+} from "@budibase/types"
+import sdk from "../../sdk"
 const toJsonSchema = require("to-json-schema")
 const validate = require("jsonschema").validate
-const { WebhookType } = require("../../constants")
-const triggers = require("../../automations/triggers")
-const { getProdAppID } = require("@budibase/backend-core/db")
-const { getAppDB, updateAppId } = require("@budibase/backend-core/context")
 
 const AUTOMATION_DESCRIPTION = "Generated from Webhook Schema"
 
-function Webhook(name, type, target) {
-  this.live = true
-  this.name = name
-  this.action = {
-    type,
-    target,
-  }
-}
-
-exports.Webhook = Webhook
-
-exports.fetch = async ctx => {
-  const db = getAppDB()
+export async function fetch(ctx: BBContext) {
+  const db = context.getAppDB()
   const response = await db.allDocs(
     getWebhookParams(null, {
       include_docs: true,
     })
   )
-  ctx.body = response.rows.map(row => row.doc)
+  ctx.body = response.rows.map((row: any) => row.doc)
 }
 
-exports.save = async ctx => {
-  const db = getAppDB()
-  const webhook = ctx.request.body
-  webhook.appId = ctx.appId
-
-  // check that the webhook exists
-  if (webhook._id) {
-    await db.get(webhook._id)
-  } else {
-    webhook._id = generateWebhookID()
-  }
-  const response = await db.put(webhook)
-  webhook._rev = response.rev
+export async function save(ctx: BBContext) {
+  const webhook = await sdk.automations.webhook.save(ctx.request.body)
   ctx.body = {
     message: "Webhook created successfully",
     webhook,
   }
 }
 
-exports.destroy = async ctx => {
-  const db = getAppDB()
-  ctx.body = await db.remove(ctx.params.id, ctx.params.rev)
+export async function destroy(ctx: BBContext) {
+  ctx.body = await sdk.automations.webhook.destroy(
+    ctx.params.id,
+    ctx.params.rev
+  )
 }
 
-exports.buildSchema = async ctx => {
-  await updateAppId(ctx.params.instance)
-  const db = getAppDB()
-  const webhook = await db.get(ctx.params.id)
+export async function buildSchema(ctx: BBContext) {
+  await context.updateAppId(ctx.params.instance)
+  const db = context.getAppDB()
+  const webhook = (await db.get(ctx.params.id)) as Webhook
   webhook.bodySchema = toJsonSchema(ctx.request.body)
   // update the automation outputs
-  if (webhook.action.type === WebhookType.AUTOMATION) {
-    let automation = await db.get(webhook.action.target)
+  if (webhook.action.type === WebhookActionType.AUTOMATION) {
+    let automation = (await db.get(webhook.action.target)) as Automation
     const autoOutputs = automation.definition.trigger.schema.outputs
     let properties = webhook.bodySchema.properties
     // reset webhook outputs
@@ -78,18 +63,18 @@ exports.buildSchema = async ctx => {
   ctx.body = await db.put(webhook)
 }
 
-exports.trigger = async ctx => {
-  const prodAppId = getProdAppID(ctx.params.instance)
-  await updateAppId(prodAppId)
+export async function trigger(ctx: BBContext) {
+  const prodAppId = dbCore.getProdAppID(ctx.params.instance)
+  await context.updateAppId(prodAppId)
   try {
-    const db = getAppDB()
-    const webhook = await db.get(ctx.params.id)
+    const db = context.getAppDB()
+    const webhook = (await db.get(ctx.params.id)) as Webhook
     // validate against the schema
     if (webhook.bodySchema) {
       validate(ctx.request.body, webhook.bodySchema)
     }
     const target = await db.get(webhook.action.target)
-    if (webhook.action.type === WebhookType.AUTOMATION) {
+    if (webhook.action.type === WebhookActionType.AUTOMATION) {
       // trigger with both the pure request and then expand it
       // incase the user has produced a schema to bind to
       await triggers.externalTrigger(target, {
@@ -102,7 +87,7 @@ exports.trigger = async ctx => {
     ctx.body = {
       message: "Webhook trigger fired successfully",
     }
-  } catch (err) {
+  } catch (err: any) {
     if (err.status === 404) {
       ctx.status = 200
       ctx.body = {

package/src/api/routes/backup.ts

@@ -0,0 +1,10 @@
+import Router from "@koa/router"
+import * as controller from "../controllers/backup"
+import authorized from "../../middleware/authorized"
+import { BUILDER } from "@budibase/backend-core/permissions"
+
+const router = new Router()
+
+router.get("/api/backups/export", authorized(BUILDER), controller.exportAppDump)
+
+export default router