@budibase/server 1.0.49-alpha.6 → 1.0.49

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

@@ -19,19 +19,6 @@ import {
   isRowId,
   convertRowId,
 } from "../../../integrations/utils"
-import { getDatasourceAndQuery } from "./utils"
-import {
-  DataSourceOperation,
-  FieldTypes,
-  RelationshipTypes,
-} from "../../../constants"
-import { breakExternalTableId, isSQL } from "../../../integrations/utils"
-import { processObjectSync } from "@budibase/string-templates"
-// @ts-ignore
-import { cloneDeep } from "lodash/fp"
-import { processFormulas } from "../../../utilities/rowProcessor/utils"
-// @ts-ignore
-import { getAppDB } from "@budibase/backend-core/context"
 
 interface ManyRelationship {
   tableId?: string
@@ -51,6 +38,18 @@ interface RunConfig {
 }
 
 module External {
+  const { getDatasourceAndQuery } = require("./utils")
+  const {
+    DataSourceOperation,
+    FieldTypes,
+    RelationshipTypes,
+  } = require("../../../constants")
+  const { breakExternalTableId, isSQL } = require("../../../integrations/utils")
+  const { processObjectSync } = require("@budibase/string-templates")
+  const { cloneDeep } = require("lodash/fp")
+  const CouchDB = require("../../../db")
+  const { processFormulas } = require("../../../utilities/rowProcessor/utils")
+
   function buildFilters(
     id: string | undefined,
     filters: SearchFilters,
@@ -211,12 +210,19 @@ module External {
   }
 
   class ExternalRequest {
+    private readonly appId: string
     private operation: Operation
     private tableId: string
     private datasource: Datasource
     private tables: { [key: string]: Table } = {}
 
-    constructor(operation: Operation, tableId: string, datasource: Datasource) {
+    constructor(
+      appId: string,
+      operation: Operation,
+      tableId: string,
+      datasource: Datasource
+    ) {
+      this.appId = appId
       this.operation = operation
       this.tableId = tableId
       this.datasource = datasource
@@ -225,14 +231,12 @@ module External {
       }
     }
 
-    getTable(tableId: string | undefined): Table | undefined {
+    getTable(tableId: string | undefined): Table {
       if (!tableId) {
         throw "Table ID is unknown, cannot find table"
       }
       const { tableName } = breakExternalTableId(tableId)
-      if (tableName) {
-        return this.tables[tableName]
-      }
+      return this.tables[tableName]
     }
 
     inputProcessing(row: Row | undefined, table: Table) {
@@ -268,11 +272,9 @@ module External {
           newRow[key] = row[key]
           continue
         }
-        const { tableName: linkTableName } = breakExternalTableId(
-          field?.tableId
-        )
+        const { tableName: linkTableName } = breakExternalTableId(field.tableId)
         // table has to exist for many to many
-        if (!linkTableName || !this.tables[linkTableName]) {
+        if (!this.tables[linkTableName]) {
           continue
         }
         const linkTable = this.tables[linkTableName]
@@ -420,7 +422,7 @@ module External {
         }
         const { tableName: linkTableName } = breakExternalTableId(field.tableId)
         // no table to link to, this is not a valid relationships
-        if (!linkTableName || !this.tables[linkTableName]) {
+        if (!this.tables[linkTableName]) {
           continue
         }
         const linkTable = this.tables[linkTableName]
@@ -458,9 +460,6 @@ module External {
     async lookupRelations(tableId: string, row: Row) {
       const related: { [key: string]: any } = {}
       const { tableName } = breakExternalTableId(tableId)
-      if (!tableName) {
-        return related
-      }
       const table = this.tables[tableName]
       // @ts-ignore
       const primaryKey = table.primary[0]
@@ -485,7 +484,7 @@ module External {
         if (!lookupField || !row[lookupField]) {
           continue
         }
-        const response = await getDatasourceAndQuery({
+        const response = await getDatasourceAndQuery(this.appId, {
           endpoint: getEndpoint(tableId, DataSourceOperation.READ),
           filters: {
             equal: {
@@ -516,30 +515,28 @@ module External {
       row: Row,
       relationships: ManyRelationship[]
     ) {
+      const { appId } = this
       // if we're creating (in a through table) need to wipe the existing ones first
       const promises = []
       const related = await this.lookupRelations(mainTableId, row)
       for (let relationship of relationships) {
         const { key, tableId, isUpdate, id, ...rest } = relationship
-        const body: { [key: string]: any } = processObjectSync(rest, row, {})
+        const body = processObjectSync(rest, row)
         const linkTable = this.getTable(tableId)
         // @ts-ignore
-        const linkPrimary = linkTable?.primary[0]
-        if (!linkTable || !linkPrimary) {
-          return
-        }
-        const rows = related[key].rows || []
+        const linkPrimary = linkTable.primary[0]
+        const rows = related[key]?.rows || []
         const found = rows.find(
           (row: { [key: string]: any }) =>
             row[linkPrimary] === relationship.id ||
-            row[linkPrimary] === body?.[linkPrimary]
+            row[linkPrimary] === body[linkPrimary]
         )
         const operation = isUpdate
           ? DataSourceOperation.UPDATE
           : DataSourceOperation.CREATE
         if (!found) {
           promises.push(
-            getDatasourceAndQuery({
+            getDatasourceAndQuery(appId, {
               endpoint: getEndpoint(tableId, operation),
               // if we're doing many relationships then we're writing, only one response
               body,
@@ -555,12 +552,9 @@ module External {
       for (let [colName, { isMany, rows, tableId }] of Object.entries(
         related
       )) {
-        const table: Table | undefined = this.getTable(tableId)
+        const table: Table = this.getTable(tableId)
         // if its not the foreign key skip it, nothing to do
-        if (
-          !table ||
-          (table.primary && table.primary.indexOf(colName) !== -1)
-        ) {
+        if (table.primary && table.primary.indexOf(colName) !== -1) {
           continue
         }
         for (let row of rows) {
@@ -572,7 +566,7 @@ module External {
               : DataSourceOperation.UPDATE
             const body = isMany ? null : { [colName]: null }
             promises.push(
-              getDatasourceAndQuery({
+              getDatasourceAndQuery(this.appId, {
                 endpoint: getEndpoint(tableId, op),
                 body,
                 filters,
@@ -611,25 +605,20 @@ module External {
           continue
         }
         const { tableName: linkTableName } = breakExternalTableId(field.tableId)
-        if (linkTableName) {
-          const linkTable = this.tables[linkTableName]
-          if (linkTable) {
-            const linkedFields = extractRealFields(linkTable, fields)
-            fields = fields.concat(linkedFields)
-          }
+        const linkTable = this.tables[linkTableName]
+        if (linkTable) {
+          const linkedFields = extractRealFields(linkTable, fields)
+          fields = fields.concat(linkedFields)
         }
       }
       return fields
     }
 
     async run(config: RunConfig) {
-      const { operation, tableId } = this
+      const { appId, operation, tableId } = this
       let { datasourceId, tableName } = breakExternalTableId(tableId)
-      if (!tableName) {
-        throw "Unable to run without a table name"
-      }
       if (!this.datasource) {
-        const db = getAppDB()
+        const db = new CouchDB(appId)
         this.datasource = await db.get(datasourceId)
         if (!this.datasource || !this.datasource.entities) {
           throw "No tables found, fetch tables before query."
@@ -681,7 +670,7 @@ module External {
         },
       }
       // can't really use response right now
-      const response = await getDatasourceAndQuery(json)
+      const response = await getDatasourceAndQuery(appId, json)
       // handle many to many relationships now if we know the ID (could be auto increment)
       if (
         operation !== DataSourceOperation.READ &&

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

@@ -9,9 +9,9 @@ const {
   breakRowIdField,
 } = require("../../../integrations/utils")
 const ExternalRequest = require("./ExternalRequest")
-const { getAppDB } = require("@budibase/backend-core/context")
+const CouchDB = require("../../../db")
 
-async function handleRequest(operation, tableId, opts = {}) {
+async function handleRequest(appId, operation, tableId, opts = {}) {
   // make sure the filters are cleaned up, no empty strings for equals, fuzzy or string
   if (opts && opts.filters) {
     for (let filterField of NoEmptyFilterStrings) {
@@ -25,7 +25,9 @@ async function handleRequest(operation, tableId, opts = {}) {
       }
     }
   }
-  return new ExternalRequest(operation, tableId, opts.datasource).run(opts)
+  return new ExternalRequest(appId, operation, tableId, opts.datasource).run(
+    opts
+  )
 }
 
 exports.handleRequest = handleRequest
@@ -179,7 +181,7 @@ exports.fetchEnrichedRow = async ctx => {
   const id = ctx.params.rowId
   const tableId = ctx.params.tableId
   const { datasourceId, tableName } = breakExternalTableId(tableId)
-  const db = getAppDB()
+  const db = new CouchDB(appId)
   const datasource = await db.get(datasourceId)
   if (!datasource || !datasource.entities) {
     ctx.throw(400, "Datasource has not been configured for plus API.")

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)
     )
   }