@budibase/server 1.0.49 → 1.0.50-alpha.0

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

@@ -19,6 +19,19 @@ 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
@@ -38,18 +51,6 @@ 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,
@@ -183,7 +184,7 @@ module External {
     thisRow._id = generateIdForRow(row, table)
     thisRow.tableId = table._id
     thisRow._rev = "rev"
-    return thisRow
+    return processFormulas(table, thisRow)
   }
 
   function fixArrayTypes(row: Row, table: Table) {
@@ -210,19 +211,12 @@ module External {
   }
 
   class ExternalRequest {
-    private readonly appId: string
     private operation: Operation
     private tableId: string
     private datasource: Datasource
     private tables: { [key: string]: Table } = {}
 
-    constructor(
-      appId: string,
-      operation: Operation,
-      tableId: string,
-      datasource: Datasource
-    ) {
-      this.appId = appId
+    constructor(operation: Operation, tableId: string, datasource: Datasource) {
       this.operation = operation
       this.tableId = tableId
       this.datasource = datasource
@@ -231,12 +225,14 @@ module External {
       }
     }
 
-    getTable(tableId: string | undefined): Table {
+    getTable(tableId: string | undefined): Table | undefined {
       if (!tableId) {
         throw "Table ID is unknown, cannot find table"
       }
       const { tableName } = breakExternalTableId(tableId)
-      return this.tables[tableName]
+      if (tableName) {
+        return this.tables[tableName]
+      }
     }
 
     inputProcessing(row: Row | undefined, table: Table) {
@@ -272,9 +268,11 @@ 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 (!this.tables[linkTableName]) {
+        if (!linkTableName || !this.tables[linkTableName]) {
           continue
         }
         const linkTable = this.tables[linkTableName]
@@ -329,8 +327,12 @@ module External {
      * This iterates through the returned rows and works out what elements of the rows
      * actually match up to another row (based on primary keys) - this is pretty specific
      * to SQL and the way that SQL relationships are returned based on joins.
+     * This is complicated, but the idea is that when a SQL query returns all the relations
+     * will be separate rows, with all of the data in each row. We have to decipher what comes
+     * from where (which tables) and how to convert that into budibase columns.
      */
     updateRelationshipColumns(
+      table: Table,
       row: Row,
       rows: { [key: string]: Row },
       relationships: RelationshipsJson[]
@@ -341,6 +343,13 @@ module External {
         if (!linkedTable) {
           continue
         }
+        const fromColumn = `${table.name}.${relationship.from}`
+        const toColumn = `${linkedTable.name}.${relationship.to}`
+        // this is important when working with multiple relationships
+        // between the same tables, don't want to overlap/multiply the relations
+        if (!relationship.through && row[fromColumn] !== row[toColumn]) {
+          continue
+        }
         let linked = basicProcessing(row, linkedTable)
         if (!linked._id) {
           continue
@@ -388,6 +397,7 @@ module External {
         // this is a relationship of some sort
         if (finalRows[rowId]) {
           finalRows = this.updateRelationshipColumns(
+            table,
             row,
             finalRows,
             relationships
@@ -401,6 +411,7 @@ module External {
         finalRows[thisRow._id] = thisRow
         // do this at end once its been added to the final rows
         finalRows = this.updateRelationshipColumns(
+          table,
           row,
           finalRows,
           relationships
@@ -422,7 +433,7 @@ module External {
         }
         const { tableName: linkTableName } = breakExternalTableId(field.tableId)
         // no table to link to, this is not a valid relationships
-        if (!this.tables[linkTableName]) {
+        if (!linkTableName || !this.tables[linkTableName]) {
           continue
         }
         const linkTable = this.tables[linkTableName]
@@ -460,6 +471,9 @@ 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]
@@ -484,7 +498,7 @@ module External {
         if (!lookupField || !row[lookupField]) {
           continue
         }
-        const response = await getDatasourceAndQuery(this.appId, {
+        const response = await getDatasourceAndQuery({
           endpoint: getEndpoint(tableId, DataSourceOperation.READ),
           filters: {
             equal: {
@@ -515,28 +529,30 @@ 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 = processObjectSync(rest, row)
+        const body: { [key: string]: any } = processObjectSync(rest, row, {})
         const linkTable = this.getTable(tableId)
         // @ts-ignore
-        const linkPrimary = linkTable.primary[0]
-        const rows = related[key]?.rows || []
+        const linkPrimary = linkTable?.primary[0]
+        if (!linkTable || !linkPrimary) {
+          return
+        }
+        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(appId, {
+            getDatasourceAndQuery({
               endpoint: getEndpoint(tableId, operation),
               // if we're doing many relationships then we're writing, only one response
               body,
@@ -552,9 +568,12 @@ module External {
       for (let [colName, { isMany, rows, tableId }] of Object.entries(
         related
       )) {
-        const table: Table = this.getTable(tableId)
+        const table: Table | undefined = this.getTable(tableId)
         // if its not the foreign key skip it, nothing to do
-        if (table.primary && table.primary.indexOf(colName) !== -1) {
+        if (
+          !table ||
+          (table.primary && table.primary.indexOf(colName) !== -1)
+        ) {
           continue
         }
         for (let row of rows) {
@@ -566,7 +585,7 @@ module External {
               : DataSourceOperation.UPDATE
             const body = isMany ? null : { [colName]: null }
             promises.push(
-              getDatasourceAndQuery(this.appId, {
+              getDatasourceAndQuery({
                 endpoint: getEndpoint(tableId, op),
                 body,
                 filters,
@@ -605,20 +624,25 @@ module External {
           continue
         }
         const { tableName: linkTableName } = breakExternalTableId(field.tableId)
-        const linkTable = this.tables[linkTableName]
-        if (linkTable) {
-          const linkedFields = extractRealFields(linkTable, fields)
-          fields = fields.concat(linkedFields)
+        if (linkTableName) {
+          const linkTable = this.tables[linkTableName]
+          if (linkTable) {
+            const linkedFields = extractRealFields(linkTable, fields)
+            fields = fields.concat(linkedFields)
+          }
         }
       }
       return fields
     }
 
     async run(config: RunConfig) {
-      const { appId, operation, tableId } = this
+      const { operation, tableId } = this
       let { datasourceId, tableName } = breakExternalTableId(tableId)
+      if (!tableName) {
+        throw "Unable to run without a table name"
+      }
       if (!this.datasource) {
-        const db = new CouchDB(appId)
+        const db = getAppDB()
         this.datasource = await db.get(datasourceId)
         if (!this.datasource || !this.datasource.entities) {
           throw "No tables found, fetch tables before query."
@@ -670,7 +694,7 @@ module External {
         },
       }
       // can't really use response right now
-      const response = await getDatasourceAndQuery(appId, json)
+      const response = await getDatasourceAndQuery(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 CouchDB = require("../../../db")
+const { getAppDB } = require("@budibase/backend-core/context")
 
-async function handleRequest(appId, operation, tableId, opts = {}) {
+async function handleRequest(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,31 +25,27 @@ async function handleRequest(appId, operation, tableId, opts = {}) {
       }
     }
   }
-  return new ExternalRequest(appId, operation, tableId, opts.datasource).run(
-    opts
-  )
+  return new ExternalRequest(operation, tableId, opts.datasource).run(opts)
 }
 
 exports.handleRequest = handleRequest
 
 exports.patch = async ctx => {
-  const appId = ctx.appId
   const inputs = ctx.request.body
   const tableId = ctx.params.tableId
   const id = breakRowIdField(inputs._id)
   // don't save the ID to db
   delete inputs._id
-  return handleRequest(appId, DataSourceOperation.UPDATE, tableId, {
+  return handleRequest(DataSourceOperation.UPDATE, tableId, {
     id,
     row: inputs,
   })
 }
 
 exports.save = async ctx => {
-  const appId = ctx.appId
   const inputs = ctx.request.body
   const tableId = ctx.params.tableId
-  return handleRequest(appId, DataSourceOperation.CREATE, tableId, {
+  return handleRequest(DataSourceOperation.CREATE, tableId, {
     row: inputs,
   })
 }
@@ -63,49 +59,35 @@ exports.fetchView = async ctx => {
 }
 
 exports.fetch = async ctx => {
-  const appId = ctx.appId
   const tableId = ctx.params.tableId
-  return handleRequest(appId, DataSourceOperation.READ, tableId)
+  return handleRequest(DataSourceOperation.READ, tableId)
 }
 
 exports.find = async ctx => {
-  const appId = ctx.appId
   const id = ctx.params.rowId
   const tableId = ctx.params.tableId
-  const response = await handleRequest(
-    appId,
-    DataSourceOperation.READ,
-    tableId,
-    {
-      id,
-    }
-  )
+  const response = await handleRequest(DataSourceOperation.READ, tableId, {
+    id,
+  })
   return response ? response[0] : response
 }
 
 exports.destroy = async ctx => {
-  const appId = ctx.appId
   const tableId = ctx.params.tableId
   const id = ctx.request.body._id
-  const { row } = await handleRequest(
-    appId,
-    DataSourceOperation.DELETE,
-    tableId,
-    {
-      id,
-    }
-  )
+  const { row } = await handleRequest(DataSourceOperation.DELETE, tableId, {
+    id,
+  })
   return { response: { ok: true }, row }
 }
 
 exports.bulkDestroy = async ctx => {
-  const appId = ctx.appId
   const { rows } = ctx.request.body
   const tableId = ctx.params.tableId
   let promises = []
   for (let row of rows) {
     promises.push(
-      handleRequest(appId, DataSourceOperation.DELETE, tableId, {
+      handleRequest(DataSourceOperation.DELETE, tableId, {
         id: breakRowIdField(row._id),
       })
     )
@@ -115,7 +97,6 @@ exports.bulkDestroy = async ctx => {
 }
 
 exports.search = async ctx => {
-  const appId = ctx.appId
   const tableId = ctx.params.tableId
   const { paginate, query, ...params } = ctx.request.body
   let { bookmark, limit } = params
@@ -145,26 +126,21 @@ exports.search = async ctx => {
       [params.sort]: direction,
     }
   }
-  const rows = await handleRequest(appId, DataSourceOperation.READ, tableId, {
+  const rows = await handleRequest(DataSourceOperation.READ, tableId, {
     filters: query,
     sort,
     paginate: paginateObj,
   })
   let hasNextPage = false
   if (paginate && rows.length === limit) {
-    const nextRows = await handleRequest(
-      appId,
-      DataSourceOperation.READ,
-      tableId,
-      {
-        filters: query,
-        sort,
-        paginate: {
-          limit: 1,
-          page: bookmark * limit + 1,
-        },
-      }
-    )
+    const nextRows = await handleRequest(DataSourceOperation.READ, tableId, {
+      filters: query,
+      sort,
+      paginate: {
+        limit: 1,
+        page: bookmark * limit + 1,
+      },
+    })
     hasNextPage = nextRows.length > 0
   }
   // need wrapper object for bookmarks etc when paginating
@@ -177,25 +153,19 @@ exports.validate = async () => {
 }
 
 exports.fetchEnrichedRow = async ctx => {
-  const appId = ctx.appId
   const id = ctx.params.rowId
   const tableId = ctx.params.tableId
   const { datasourceId, tableName } = breakExternalTableId(tableId)
-  const db = new CouchDB(appId)
+  const db = getAppDB()
   const datasource = await db.get(datasourceId)
   if (!datasource || !datasource.entities) {
     ctx.throw(400, "Datasource has not been configured for plus API.")
   }
   const tables = datasource.entities
-  const response = await handleRequest(
-    appId,
-    DataSourceOperation.READ,
-    tableId,
-    {
-      id,
-      datasource,
-    }
-  )
+  const response = await handleRequest(DataSourceOperation.READ, tableId, {
+    id,
+    datasource,
+  })
   const table = tables[tableName]
   const row = response[0]
   // this seems like a lot of work, but basically we need to dig deeper for the enrich
@@ -214,7 +184,6 @@ exports.fetchEnrichedRow = async ctx => {
     // don't support composite keys right now
     const linkedIds = links.map(link => breakRowIdField(link._id)[0])
     row[fieldName] = await handleRequest(
-      appId,
       DataSourceOperation.READ,
       linkedTableId,
       {