@budibase/server 1.0.49-alpha.9 → 1.0.49

package/src/utilities/index.js

@@ -1,9 +1,9 @@
 const env = require("../environment")
 const { OBJ_STORE_DIRECTORY } = require("../constants")
 const { sanitizeKey } = require("@budibase/backend-core/objectStore")
+const CouchDB = require("../db")
 const { generateMetadataID } = require("../db/utils")
 const Readable = require("stream").Readable
-const { getAppDB } = require("@budibase/backend-core/context")
 
 const BB_CDN = "https://cdn.budi.live"
 
@@ -73,8 +73,8 @@ exports.attachmentsRelativeURL = attachmentKey => {
   )
 }
 
-exports.updateEntityMetadata = async (type, entityId, updateFn) => {
-  const db = getAppDB()
+exports.updateEntityMetadata = async (appId, type, entityId, updateFn) => {
+  const db = new CouchDB(appId)
   const id = generateMetadataID(type, entityId)
   // read it to see if it exists, we'll overwrite it no matter what
   let rev,
@@ -99,14 +99,14 @@ exports.updateEntityMetadata = async (type, entityId, updateFn) => {
   }
 }
 
-exports.saveEntityMetadata = async (type, entityId, metadata) => {
-  return exports.updateEntityMetadata(type, entityId, () => {
+exports.saveEntityMetadata = async (appId, type, entityId, metadata) => {
+  return exports.updateEntityMetadata(appId, type, entityId, () => {
     return metadata
   })
 }
 
-exports.deleteEntityMetadata = async (type, entityId) => {
-  const db = getAppDB()
+exports.deleteEntityMetadata = async (appId, type, entityId) => {
+  const db = new CouchDB(appId)
   const id = generateMetadataID(type, entityId)
   let rev
   try {
@@ -141,6 +141,16 @@ exports.stringToReadStream = string => {
   })
 }
 
+exports.doesDatabaseExist = async dbName => {
+  try {
+    const db = new CouchDB(dbName, { skip_setup: true })
+    const info = await db.info()
+    return info && !info.error
+  } catch (err) {
+    return false
+  }
+}
+
 exports.formatBytes = bytes => {
   const units = ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"]
   const byteIncrements = 1024

package/src/utilities/routing/index.js

@@ -1,9 +1,9 @@
+const CouchDB = require("../../db")
 const { createRoutingView } = require("../../db/views/staticViews")
 const { ViewNames, getQueryIndex, UNICODE_MAX } = require("../../db/utils")
-const { getAppDB } = require("@budibase/backend-core/context")
 
-exports.getRoutingInfo = async () => {
-  const db = getAppDB()
+exports.getRoutingInfo = async appId => {
+  const db = new CouchDB(appId)
   try {
     const allRouting = await db.query(getQueryIndex(ViewNames.ROUTING), {
       startKey: "",
@@ -14,8 +14,8 @@ exports.getRoutingInfo = async () => {
     // check if the view doesn't exist, it should for all new instances
     /* istanbul ignore next */
     if (err != null && err.name === "not_found") {
-      await createRoutingView()
-      return exports.getRoutingInfo()
+      await createRoutingView(appId)
+      return exports.getRoutingInfo(appId)
     } else {
       throw err
     }

package/src/utilities/rowProcessor/index.js

@@ -7,10 +7,10 @@ const { deleteFiles } = require("../../utilities/fileSystem/utilities")
 const { ObjectStoreBuckets } = require("../../constants")
 const {
   isProdAppID,
-  getProdAppID,
+  getDeployedAppID,
   dbExists,
 } = require("@budibase/backend-core/db")
-const { getAppId } = require("@budibase/backend-core/context")
+const CouchDB = require("../../db")
 
 const BASE_AUTO_ID = 1
 
@@ -180,8 +180,6 @@ function processAutoColumn(
 }
 exports.processAutoColumn = processAutoColumn
 
-exports.processFormulas = processFormulas
-
 /**
  * This will coerce a value to the correct types based on the type transform map
  * @param {object} row The value to coerce
@@ -231,12 +229,11 @@ exports.inputProcessing = (
       }
       continue
     }
-    // remove any formula values, they are to be generated
+    // specific case to delete formula values if they get saved
+    // type coercion cannot completely remove the field, so have to do it here
     if (field.type === FieldTypes.FORMULA) {
       delete clonedRow[key]
-    }
-    // otherwise coerce what is there to correct types
-    else {
+    } else {
       clonedRow[key] = exports.coerce(value, field.type)
     }
   }
@@ -253,23 +250,30 @@ exports.inputProcessing = (
 /**
  * This function enriches the input rows with anything they are supposed to contain, for example
  * link records or attachment links.
+ * @param {object} ctx the request which is looking for enriched rows.
  * @param {object} table the table from which these rows came from originally, this is used to determine
  * the schema of the rows and then enrich.
  * @param {object[]|object} rows the rows which are to be enriched.
  * @param {object} opts used to set some options for the output, such as disabling relationship squashing.
  * @returns {object[]|object} the enriched rows will be returned.
  */
-exports.outputProcessing = async (table, rows, opts = { squash: true }) => {
+exports.outputProcessing = async (
+  ctx,
+  table,
+  rows,
+  opts = { squash: true }
+) => {
+  const appId = ctx.appId
   let wasArray = true
   if (!(rows instanceof Array)) {
     rows = [rows]
     wasArray = false
   }
   // attach any linked row information
-  let enriched = await linkRows.attachFullLinkedDocs(table, rows)
+  let enriched = await linkRows.attachFullLinkedDocs(ctx, table, rows)
 
   // process formulas
-  enriched = processFormulas(table, enriched, { dynamic: true })
+  enriched = processFormulas(table, enriched)
 
   // update the attachments URL depending on hosting
   for (let [property, column] of Object.entries(table.schema)) {
@@ -285,27 +289,29 @@ exports.outputProcessing = async (table, rows, opts = { squash: true }) => {
     }
   }
   if (opts.squash) {
-    enriched = await linkRows.squashLinksToPrimaryDisplay(table, enriched)
+    enriched = await linkRows.squashLinksToPrimaryDisplay(
+      appId,
+      table,
+      enriched
+    )
   }
   return wasArray ? enriched : enriched[0]
 }
 
 /**
  * Clean up any attachments that were attached to a row.
+ * @param {string} appId The ID of the app from which a row is being deleted.
  * @param {object} table The table from which a row is being removed.
  * @param {any} row optional - the row being removed.
  * @param {any} rows optional - if multiple rows being deleted can do this in bulk.
  * @param {any} oldRow optional - if updating a row this will determine the difference.
- * @param {any} oldTable optional - if updating a table, can supply the old table to look for
- * deleted attachment columns.
  * @return {Promise<void>} When all attachments have been removed this will return.
  */
-exports.cleanupAttachments = async (table, { row, rows, oldRow, oldTable }) => {
-  const appId = getAppId()
+exports.cleanupAttachments = async (appId, table, { row, rows, oldRow }) => {
   if (!isProdAppID(appId)) {
-    const prodAppId = getProdAppID(appId)
+    const prodAppId = getDeployedAppID(appId)
     // if prod exists, then don't allow deleting
-    const exists = await dbExists(prodAppId)
+    const exists = await dbExists(CouchDB, prodAppId)
     if (exists) {
       return
     }
@@ -316,16 +322,12 @@ exports.cleanupAttachments = async (table, { row, rows, oldRow, oldTable }) => {
       files = files.concat(row[key].map(attachment => attachment.key))
     }
   }
-  const schemaToUse = oldTable ? oldTable.schema : table.schema
-  for (let [key, schema] of Object.entries(schemaToUse)) {
+  for (let [key, schema] of Object.entries(table.schema)) {
     if (schema.type !== FieldTypes.ATTACHMENT) {
       continue
     }
-    // old table had this column, new table doesn't - delete it
-    if (oldTable && !table.schema[key]) {
-      rows.forEach(row => addFiles(row, key))
-    } else if (oldRow && row) {
-      // if updating, need to manage the differences
+    // if updating, need to manage the differences
+    if (oldRow && row) {
       files = files.concat(getRemovedAttachmentKeys(oldRow, row, key))
     } else if (row) {
       addFiles(row, key)

package/src/utilities/rowProcessor/utils.js

@@ -1,39 +1,23 @@
-const { FieldTypes, FormulaTypes } = require("../../constants")
+const { FieldTypes } = require("../../constants")
 const { processStringSync } = require("@budibase/string-templates")
 
 /**
  * Looks through the rows provided and finds formulas - which it then processes.
  */
-exports.processFormulas = (
-  table,
-  rows,
-  { dynamic, contextRows } = { dynamic: true }
-) => {
+exports.processFormulas = (table, rows) => {
   const single = !Array.isArray(rows)
   if (single) {
     rows = [rows]
-    contextRows = contextRows ? [contextRows] : contextRows
   }
   for (let [column, schema] of Object.entries(table.schema)) {
-    const isStatic = schema.formulaType === FormulaTypes.STATIC
-    if (
-      schema.type !== FieldTypes.FORMULA ||
-      (dynamic && isStatic) ||
-      (!dynamic && !isStatic)
-    ) {
+    if (schema.type !== FieldTypes.FORMULA) {
       continue
     }
     // iterate through rows and process formula
-    for (let i = 0; i < rows.length; i++) {
-      if (schema.formula) {
-        let row = rows[i]
-        let context = contextRows ? contextRows[i] : row
-        rows[i] = {
-          ...row,
-          [column]: processStringSync(schema.formula, context),
-        }
-      }
-    }
+    rows = rows.map(row => ({
+      ...row,
+      [column]: processStringSync(schema.formula, row),
+    }))
   }
   return single ? rows[0] : rows
 }

package/src/utilities/usageQuota.js

@@ -0,0 +1,73 @@
+const env = require("../environment")
+const { getGlobalDB } = require("@budibase/backend-core/tenancy")
+const {
+  StaticDatabases,
+  generateNewUsageQuotaDoc,
+} = require("@budibase/backend-core/db")
+
+function getNewQuotaReset() {
+  return Date.now() + 2592000000
+}
+
+exports.Properties = {
+  ROW: "rows",
+  UPLOAD: "storage",
+  VIEW: "views",
+  USER: "users",
+  AUTOMATION: "automationRuns",
+  APPS: "apps",
+  EMAILS: "emails",
+}
+
+async function getUsageQuotaDoc(db) {
+  let quota
+  try {
+    quota = await db.get(StaticDatabases.PLATFORM_INFO.docs.usageQuota)
+  } catch (err) {
+    // doc doesn't exist. Create it
+    quota = await db.post(generateNewUsageQuotaDoc())
+  }
+
+  return quota
+}
+
+/**
+ * Given a specified tenantId this will add to the usage object for the specified property.
+ * @param {string} property The property which is to be added to (within the nested usageQuota object).
+ * @param {number} usage The amount (this can be negative) to adjust the number by.
+ * @returns {Promise<void>} When this completes the API key will now be up to date - the quota period may have
+ * also been reset after this call.
+ */
+exports.update = async (property, usage) => {
+  if (!env.USE_QUOTAS) {
+    return
+  }
+
+  try {
+    const db = getGlobalDB()
+    const quota = await getUsageQuotaDoc(db)
+
+    // Check if the quota needs reset
+    if (Date.now() >= quota.quotaReset) {
+      quota.quotaReset = getNewQuotaReset()
+      for (let prop of Object.keys(quota.usageQuota)) {
+        quota.usageQuota[prop] = 0
+      }
+    }
+
+    // increment the quota
+    quota.usageQuota[property] += usage
+
+    if (quota.usageQuota[property] > quota.usageLimits[property]) {
+      throw new Error(
+        `You have exceeded your usage quota of ${quota.usageLimits[property]} ${property}.`
+      )
+    }
+
+    // update the usage quotas
+    await db.put(quota)
+  } catch (err) {
+    console.error(`Error updating usage quotas for ${property}`, err)
+    throw err
+  }
+}

package/src/utilities/users.js

@@ -1,13 +1,13 @@
+const CouchDB = require("../db")
 const { InternalTables } = require("../db/utils")
 const { getGlobalUser } = require("../utilities/global")
-const { getAppDB } = require("@budibase/backend-core/context")
 
 exports.getFullUser = async (ctx, userId) => {
-  const global = await getGlobalUser(userId)
+  const global = await getGlobalUser(ctx.appId, userId)
   let metadata
   try {
     // this will throw an error if the db doesn't exist, or there is no appId
-    const db = getAppDB()
+    const db = new CouchDB(ctx.appId)
     metadata = await db.get(userId)
   } catch (err) {
     // it is fine if there is no user metadata, just remove global db info

package/src/utilities/workerRequests.js

@@ -1,7 +1,7 @@
 const fetch = require("node-fetch")
 const env = require("../environment")
 const { checkSlashesInUrl } = require("./index")
-const { getProdAppID } = require("@budibase/backend-core/db")
+const { getDeployedAppID } = require("@budibase/backend-core/db")
 const { updateAppRole } = require("./global")
 const { Headers } = require("@budibase/backend-core/constants")
 const { getTenantId, isTenantIdSet } = require("@budibase/backend-core/tenancy")
@@ -58,6 +58,29 @@ exports.sendSmtpEmail = async (to, from, subject, contents, automation) => {
   return response.json()
 }
 
+exports.getDeployedApps = async () => {
+  try {
+    const response = await fetch(
+      checkSlashesInUrl(env.WORKER_URL + `/api/apps`),
+      request(null, {
+        method: "GET",
+      })
+    )
+    const json = await response.json()
+    const apps = {}
+    for (let [key, value] of Object.entries(json)) {
+      if (value.url) {
+        value.url = value.url.toLowerCase()
+        apps[key.toLowerCase()] = value
+      }
+    }
+    return apps
+  } catch (err) {
+    // error, cannot determine deployed apps, don't stop app creation - sort this later
+    return {}
+  }
+}
+
 exports.getGlobalSelf = async (ctx, appId = null) => {
   const endpoint = `/api/global/users/self`
   const response = await fetch(
@@ -70,15 +93,15 @@ exports.getGlobalSelf = async (ctx, appId = null) => {
   }
   let json = await response.json()
   if (appId) {
-    json = updateAppRole(json)
+    json = updateAppRole(appId, json)
   }
   return json
 }
 
 exports.removeAppFromUserRoles = async (ctx, appId) => {
-  const prodAppId = getProdAppID(appId)
+  const deployedAppId = getDeployedAppID(appId)
   const response = await fetch(
-    checkSlashesInUrl(env.WORKER_URL + `/api/global/roles/${prodAppId}`),
+    checkSlashesInUrl(env.WORKER_URL + `/api/global/roles/${deployedAppId}`),
     request(ctx, {
       method: "DELETE",
     })

package/tsconfig.json

@@ -12,8 +12,7 @@
     "incremental": true
   },
   "include": [
-    "./src/**/*",
-    "./src/module.d.ts"
+    "./src/**/*"
   ],
   "exclude": [
     "node_modules",