@budibase/server 1.0.49-alpha.9 → 1.0.49

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

@@ -1,7 +1,8 @@
+const CouchDB = require("../../../db")
 const linkRows = require("../../../db/linkedRows")
 const {
-  generateRowID,
   getRowParams,
+  generateRowID,
   DocumentTypes,
   InternalTables,
 } = require("../../../db/utils")
@@ -9,9 +10,11 @@ const userController = require("../user")
 const {
   inputProcessing,
   outputProcessing,
+  processAutoColumn,
   cleanupAttachments,
 } = require("../../../utilities/rowProcessor")
 const { FieldTypes } = require("../../../constants")
+const { isEqual } = require("lodash")
 const { validate, findRow } = require("./utils")
 const { fullSearch, paginatedSearch } = require("./internalSearch")
 const { getGlobalUsersFromMetadata } = require("../../../utilities/global")
@@ -24,8 +27,6 @@ const {
   getFromMemoryDoc,
 } = require("../view/utils")
 const { cloneDeep } = require("lodash/fp")
-const { getAppDB } = require("@budibase/backend-core/context")
-const { finaliseRow, updateRelatedFormula } = require("./staticFormula")
 
 const CALCULATION_TYPES = {
   SUM: "sum",
@@ -33,6 +34,51 @@ const CALCULATION_TYPES = {
   STATS: "stats",
 }
 
+async function storeResponse(ctx, db, row, oldTable, table) {
+  row.type = "row"
+  // don't worry about rev, tables handle rev/lastID updates
+  // if another row has been written since processing this will
+  // handle the auto ID clash
+  if (!isEqual(oldTable, table)) {
+    try {
+      await db.put(table)
+    } catch (err) {
+      if (err.status === 409) {
+        const updatedTable = await db.get(table._id)
+        let response = processAutoColumn(null, updatedTable, row, {
+          reprocessing: true,
+        })
+        await db.put(response.table)
+        row = response.row
+      } else {
+        throw err
+      }
+    }
+  }
+  const response = await db.put(row)
+  row._rev = response.rev
+  // process the row before return, to include relationships
+  row = await outputProcessing(ctx, table, row, { squash: false })
+  return { row, table }
+}
+
+// doesn't do the outputProcessing
+async function getRawTableData(ctx, db, tableId) {
+  let rows
+  if (tableId === InternalTables.USER_METADATA) {
+    await userController.fetchMetadata(ctx)
+    rows = ctx.body
+  } else {
+    const response = await db.allDocs(
+      getRowParams(tableId, null, {
+        include_docs: true,
+      })
+    )
+    rows = response.rows.map(row => row.doc)
+  }
+  return rows
+}
+
 async function getView(db, viewName) {
   let mainGetter = env.SELF_HOSTED ? getFromDesignDoc : getFromMemoryDoc
   let secondaryGetter = env.SELF_HOSTED ? getFromMemoryDoc : getFromDesignDoc
@@ -59,24 +105,9 @@ async function getView(db, viewName) {
   return viewInfo
 }
 
-async function getRawTableData(ctx, db, tableId) {
-  let rows
-  if (tableId === InternalTables.USER_METADATA) {
-    await userController.fetchMetadata(ctx)
-    rows = ctx.body
-  } else {
-    const response = await db.allDocs(
-      getRowParams(tableId, null, {
-        include_docs: true,
-      })
-    )
-    rows = response.rows.map(row => row.doc)
-  }
-  return rows
-}
-
 exports.patch = async ctx => {
-  const db = getAppDB()
+  const appId = ctx.appId
+  const db = new CouchDB(appId)
   const inputs = ctx.request.body
   const tableId = inputs.tableId
   const isUserTable = tableId === InternalTables.USER_METADATA
@@ -115,13 +146,14 @@ exports.patch = async ctx => {
 
   // returned row is cleaned and prepared for writing to DB
   row = await linkRows.updateLinks({
+    appId,
     eventType: linkRows.EventType.ROW_UPDATE,
     row,
     tableId: row.tableId,
     table,
   })
   // check if any attachments removed
-  await cleanupAttachments(table, { oldRow, row })
+  await cleanupAttachments(appId, table, { oldRow, row })
 
   if (isUserTable) {
     // the row has been updated, need to put it into the ctx
@@ -130,14 +162,12 @@ exports.patch = async ctx => {
     return { row: ctx.body, table }
   }
 
-  return finaliseRow(table, row, {
-    oldTable: dbTable,
-    updateFormula: true,
-  })
+  return storeResponse(ctx, db, row, dbTable, table)
 }
 
 exports.save = async function (ctx) {
-  const db = getAppDB()
+  const appId = ctx.appId
+  const db = new CouchDB(appId)
   let inputs = ctx.request.body
   inputs.tableId = ctx.params.tableId
 
@@ -159,19 +189,18 @@ exports.save = async function (ctx) {
 
   // make sure link rows are up to date
   row = await linkRows.updateLinks({
+    appId,
     eventType: linkRows.EventType.ROW_SAVE,
     row,
     tableId: row.tableId,
     table,
   })
 
-  return finaliseRow(table, row, {
-    oldTable: dbTable,
-    updateFormula: true,
-  })
+  return storeResponse(ctx, db, row, dbTable, table)
 }
 
 exports.fetchView = async ctx => {
+  const appId = ctx.appId
   const viewName = ctx.params.viewName
 
   // if this is a table view being looked for just transfer to that
@@ -180,7 +209,7 @@ exports.fetchView = async ctx => {
     return exports.fetch(ctx)
   }
 
-  const db = getAppDB()
+  const db = new CouchDB(appId)
   const { calculation, group, field } = ctx.query
   const viewInfo = await getView(db, viewName)
   let response
@@ -207,7 +236,7 @@ exports.fetchView = async ctx => {
         schema: {},
       }
     }
-    rows = await outputProcessing(table, response.rows)
+    rows = await outputProcessing(ctx, table, response.rows)
   }
 
   if (calculation === CALCULATION_TYPES.STATS) {
@@ -234,24 +263,27 @@ exports.fetchView = async ctx => {
 }
 
 exports.fetch = async ctx => {
-  const db = getAppDB()
+  const appId = ctx.appId
+  const db = new CouchDB(appId)
 
   const tableId = ctx.params.tableId
   let table = await db.get(tableId)
   let rows = await getRawTableData(ctx, db, tableId)
-  return outputProcessing(table, rows)
+  return outputProcessing(ctx, table, rows)
 }
 
 exports.find = async ctx => {
-  const db = getAppDB()
+  const appId = ctx.appId
+  const db = new CouchDB(appId)
   const table = await db.get(ctx.params.tableId)
-  let row = await findRow(ctx, ctx.params.tableId, ctx.params.rowId)
-  row = await outputProcessing(table, row)
+  let row = await findRow(ctx, db, ctx.params.tableId, ctx.params.rowId)
+  row = await outputProcessing(ctx, table, row)
   return row
 }
 
 exports.destroy = async function (ctx) {
-  const db = getAppDB()
+  const appId = ctx.appId
+  const db = new CouchDB(appId)
   const { _id, _rev } = ctx.request.body
   let row = await db.get(_id)
 
@@ -260,17 +292,16 @@ exports.destroy = async function (ctx) {
   }
   const table = await db.get(row.tableId)
   // update the row to include full relationships before deleting them
-  row = await outputProcessing(table, row, { squash: false })
+  row = await outputProcessing(ctx, table, row, { squash: false })
   // now remove the relationships
   await linkRows.updateLinks({
+    appId,
     eventType: linkRows.EventType.ROW_DELETE,
     row,
     tableId: row.tableId,
   })
   // remove any attachments that were on the row from object storage
-  await cleanupAttachments(table, { row })
-  // remove any static formula
-  await updateRelatedFormula(table, row)
+  await cleanupAttachments(appId, table, { row })
 
   let response
   if (ctx.params.tableId === InternalTables.USER_METADATA) {
@@ -286,18 +317,20 @@ exports.destroy = async function (ctx) {
 }
 
 exports.bulkDestroy = async ctx => {
-  const db = getAppDB()
+  const appId = ctx.appId
+  const db = new CouchDB(appId)
   const tableId = ctx.params.tableId
   const table = await db.get(tableId)
   let { rows } = ctx.request.body
 
   // before carrying out any updates, make sure the rows are ready to be returned
   // they need to be the full rows (including previous relationships) for automations
-  rows = await outputProcessing(table, rows, { squash: false })
+  rows = await outputProcessing(ctx, table, rows, { squash: false })
 
   // remove the relationships first
   let updates = rows.map(row =>
     linkRows.updateLinks({
+      appId,
       eventType: linkRows.EventType.ROW_DELETE,
       row,
       tableId: row.tableId,
@@ -316,8 +349,7 @@ exports.bulkDestroy = async ctx => {
     await db.bulkDocs(rows.map(row => ({ ...row, _deleted: true })))
   }
   // remove any attachments that were on the rows from object storage
-  await cleanupAttachments(table, { rows })
-  await updateRelatedFormula(table, rows)
+  await cleanupAttachments(appId, table, { rows })
   await Promise.all(updates)
   return { response: { ok: true }, rows }
 }
@@ -328,27 +360,28 @@ exports.search = async ctx => {
     return { rows: await exports.fetch(ctx) }
   }
 
+  const appId = ctx.appId
   const { tableId } = ctx.params
-  const db = getAppDB()
+  const db = new CouchDB(appId)
   const { paginate, query, ...params } = ctx.request.body
   params.version = ctx.version
   params.tableId = tableId
 
   let response
   if (paginate) {
-    response = await paginatedSearch(query, params)
+    response = await paginatedSearch(appId, query, params)
   } else {
-    response = await fullSearch(query, params)
+    response = await fullSearch(appId, query, params)
   }
 
   // Enrich search results with relationships
   if (response.rows && response.rows.length) {
     // enrich with global users if from users table
     if (tableId === InternalTables.USER_METADATA) {
-      response.rows = await getGlobalUsersFromMetadata(response.rows)
+      response.rows = await getGlobalUsersFromMetadata(appId, response.rows)
     }
     const table = await db.get(tableId)
-    response.rows = await outputProcessing(table, response.rows)
+    response.rows = await outputProcessing(ctx, table, response.rows)
   }
 
   return response
@@ -356,22 +389,25 @@ exports.search = async ctx => {
 
 exports.validate = async ctx => {
   return validate({
+    appId: ctx.appId,
     tableId: ctx.params.tableId,
     row: ctx.request.body,
   })
 }
 
 exports.fetchEnrichedRow = async ctx => {
-  const db = getAppDB()
+  const appId = ctx.appId
+  const db = new CouchDB(appId)
   const tableId = ctx.params.tableId
   const rowId = ctx.params.rowId
   // need table to work out where links go in row
   let [table, row] = await Promise.all([
     db.get(tableId),
-    findRow(ctx, tableId, rowId),
+    findRow(ctx, db, tableId, rowId),
   ])
   // get the link docs
   const linkVals = await linkRows.getLinkDocuments({
+    appId,
     tableId,
     rowId,
   })
@@ -398,7 +434,7 @@ exports.fetchEnrichedRow = async ctx => {
   for (let [tableId, rows] of Object.entries(groups)) {
     // need to include the IDs in these rows for any links they may have
     linkedRows = linkedRows.concat(
-      await outputProcessing(tables[tableId], rows)
+      await outputProcessing(ctx, tables[tableId], rows)
     )
   }
 

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

@@ -1,14 +1,14 @@
 const { SearchIndexes } = require("../../../db/utils")
 const fetch = require("node-fetch")
 const { getCouchUrl } = require("@budibase/backend-core/db")
-const { getAppId } = require("@budibase/backend-core/context")
 
 /**
  * Class to build lucene query URLs.
  * Optionally takes a base lucene query object.
  */
 class QueryBuilder {
-  constructor(base) {
+  constructor(appId, base) {
+    this.appId = appId
     this.query = {
       string: {},
       fuzzy: {},
@@ -37,30 +37,22 @@ class QueryBuilder {
   }
 
   setLimit(limit) {
-    if (limit != null) {
-      this.limit = limit
-    }
+    this.limit = limit
     return this
   }
 
   setSort(sort) {
-    if (sort != null) {
-      this.sort = sort
-    }
+    this.sort = sort
     return this
   }
 
   setSortOrder(sortOrder) {
-    if (sortOrder != null) {
-      this.sortOrder = sortOrder
-    }
+    this.sortOrder = sortOrder
     return this
   }
 
   setSortType(sortType) {
-    if (sortType != null) {
-      this.sortType = sortType
-    }
+    this.sortType = sortType
     return this
   }
 
@@ -241,8 +233,7 @@ class QueryBuilder {
   }
 
   async run() {
-    const appId = getAppId()
-    const url = `${getCouchUrl()}/${appId}/_design/database/_search/${
+    const url = `${getCouchUrl()}/${this.appId}/_design/database/_search/${
       SearchIndexes.ROWS
     }`
     const body = this.buildSearchBody()
@@ -279,6 +270,7 @@ const runQuery = async (url, body) => {
  * Gets round the fixed limit of 200 results from a query by fetching as many
  * pages as required and concatenating the results. This recursively operates
  * until enough results have been found.
+ * @param appId {string} The app ID to search
  * @param query {object} The JSON query structure
  * @param params {object} The search params including:
  *   tableId {string} The table ID to search
@@ -291,7 +283,7 @@ const runQuery = async (url, body) => {
  *   rows {array|null} Current results in the recursive search
  * @returns {Promise<*[]|*>}
  */
-const recursiveSearch = async (query, params) => {
+const recursiveSearch = async (appId, query, params) => {
   const bookmark = params.bookmark
   const rows = params.rows || []
   if (rows.length >= params.limit) {
@@ -301,7 +293,7 @@ const recursiveSearch = async (query, params) => {
   if (rows.length > params.limit - 200) {
     pageSize = params.limit - rows.length
   }
-  const page = await new QueryBuilder(query)
+  const page = await new QueryBuilder(appId, query)
     .setVersion(params.version)
     .setTable(params.tableId)
     .setBookmark(bookmark)
@@ -321,13 +313,14 @@ const recursiveSearch = async (query, params) => {
     bookmark: page.bookmark,
     rows: [...rows, ...page.rows],
   }
-  return await recursiveSearch(query, newParams)
+  return await recursiveSearch(appId, query, newParams)
 }
 
 /**
  * Performs a paginated search. A bookmark will be returned to allow the next
  * page to be fetched. There is a max limit off 200 results per page in a
  * paginated search.
+ * @param appId {string} The app ID to search
  * @param query {object} The JSON query structure
  * @param params {object} The search params including:
  *   tableId {string} The table ID to search
@@ -339,13 +332,13 @@ const recursiveSearch = async (query, params) => {
  *   bookmark {string} The bookmark to resume from
  * @returns {Promise<{hasNextPage: boolean, rows: *[]}>}
  */
-exports.paginatedSearch = async (query, params) => {
+exports.paginatedSearch = async (appId, query, params) => {
   let limit = params.limit
   if (limit == null || isNaN(limit) || limit < 0) {
     limit = 50
   }
   limit = Math.min(limit, 200)
-  const search = new QueryBuilder(query)
+  const search = new QueryBuilder(appId, query)
     .setVersion(params.version)
     .setTable(params.tableId)
     .setSort(params.sort)
@@ -374,6 +367,7 @@ exports.paginatedSearch = async (query, params) => {
  * desired amount of results. There is a limit of 1000 results to avoid
  * heavy performance hits, and to avoid client components breaking from
  * handling too much data.
+ * @param appId {string} The app ID to search
  * @param query {object} The JSON query structure
  * @param params {object} The search params including:
  *   tableId {string} The table ID to search
@@ -384,12 +378,12 @@ exports.paginatedSearch = async (query, params) => {
  *   limit {number} The desired number of results
  * @returns {Promise<{rows: *}>}
  */
-exports.fullSearch = async (query, params) => {
+exports.fullSearch = async (appId, query, params) => {
   let limit = params.limit
   if (limit == null || isNaN(limit) || limit < 0) {
     limit = 1000
   }
   params.limit = Math.min(limit, 1000)
-  const rows = await recursiveSearch(query, params)
+  const rows = await recursiveSearch(appId, query, params)
   return { rows }
 }

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

@@ -1,11 +1,11 @@
 const validateJs = require("validate.js")
 const { cloneDeep } = require("lodash/fp")
+const CouchDB = require("../../../db")
 const { InternalTables } = require("../../../db/utils")
 const userController = require("../user")
 const { FieldTypes } = require("../../../constants")
 const { processStringSync } = require("@budibase/string-templates")
 const { makeExternalQuery } = require("../../../integrations/base/utils")
-const { getAppDB } = require("@budibase/backend-core/context")
 
 validateJs.extend(validateJs.validators.datetime, {
   parse: function (value) {
@@ -17,15 +17,14 @@ validateJs.extend(validateJs.validators.datetime, {
   },
 })
 
-exports.getDatasourceAndQuery = async json => {
+exports.getDatasourceAndQuery = async (appId, json) => {
   const datasourceId = json.endpoint.datasourceId
-  const db = getAppDB()
+  const db = new CouchDB(appId)
   const datasource = await db.get(datasourceId)
   return makeExternalQuery(datasource, json)
 }
 
-exports.findRow = async (ctx, tableId, rowId) => {
-  const db = getAppDB()
+exports.findRow = async (ctx, db, tableId, rowId) => {
   let row
   // TODO remove special user case in future
   if (tableId === InternalTables.USER_METADATA) {
@@ -43,9 +42,9 @@ exports.findRow = async (ctx, tableId, rowId) => {
   return row
 }
 
-exports.validate = async ({ tableId, row, table }) => {
+exports.validate = async ({ appId, tableId, row, table }) => {
   if (!table) {
-    const db = getAppDB()
+    const db = new CouchDB(appId)
     table = await db.get(tableId)
   }
   const errors = {}
@@ -59,16 +58,22 @@ exports.validate = async ({ tableId, row, table }) => {
     let res
 
     // Validate.js doesn't seem to handle array
-    if (type === FieldTypes.ARRAY && row[fieldName]) {
-      if (row[fieldName].length) {
+    if (type === FieldTypes.ARRAY) {
+      const hasValues =
+        Array.isArray(row[fieldName]) && row[fieldName].length > 0
+
+      // Check values are valid if values are specified
+      if (hasValues) {
         row[fieldName].map(val => {
           if (!constraints.inclusion.includes(val)) {
-            errors[fieldName] = "Field not in list"
+            errors[fieldName] = "Value not in list"
           }
         })
-      } else if (constraints.presence && row[fieldName].length === 0) {
-        // non required MultiSelect creates an empty array, which should not throw errors
-        errors[fieldName] = [`${fieldName} is required`]
+      }
+
+      // Check for required constraint
+      if (constraints.presence === true && !hasValues) {
+        errors[fieldName] = "Required field"
       }
     } else if (type === FieldTypes.JSON && typeof row[fieldName] === "string") {
       // this should only happen if there is an error

package/src/api/controllers/screen.js

@@ -1,9 +1,10 @@
+const CouchDB = require("../../db")
 const { getScreenParams, generateScreenID } = require("../../db/utils")
 const { AccessController } = require("@budibase/backend-core/roles")
-const { getAppDB } = require("@budibase/backend-core/context")
 
 exports.fetch = async ctx => {
-  const db = getAppDB()
+  const appId = ctx.appId
+  const db = new CouchDB(appId)
 
   const screens = (
     await db.allDocs(
@@ -13,14 +14,15 @@ exports.fetch = async ctx => {
     )
   ).rows.map(element => element.doc)
 
-  ctx.body = await new AccessController().checkScreensAccess(
+  ctx.body = await new AccessController(appId).checkScreensAccess(
     screens,
     ctx.user.role._id
   )
 }
 
 exports.save = async ctx => {
-  const db = getAppDB()
+  const appId = ctx.appId
+  const db = new CouchDB(appId)
   let screen = ctx.request.body
 
   if (!screen._id) {
@@ -37,7 +39,7 @@ exports.save = async ctx => {
 }
 
 exports.destroy = async ctx => {
-  const db = getAppDB()
+  const db = new CouchDB(ctx.appId)
   await db.remove(ctx.params.screenId, ctx.params.screenRev)
   ctx.body = {
     message: "Screen deleted successfully",