@budibase/server 1.0.49 → 1.0.50-alpha.0

package/src/db/linkedRows/index.js

@@ -9,12 +9,12 @@ const {
   getLinkedTable,
 } = require("./linkUtils")
 const { flatten } = require("lodash")
-const CouchDB = require("../../db")
 const { FieldTypes } = require("../../constants")
 const { getMultiIDParams, USER_METDATA_PREFIX } = require("../../db/utils")
 const { partition } = require("lodash")
 const { getGlobalUsersFromMetadata } = require("../../utilities/global")
 const { processFormulas } = require("../../utilities/rowProcessor/utils")
+const { getAppDB } = require("@budibase/backend-core/context")
 
 /**
  * This functionality makes sure that when rows with links are created, updated or deleted they are processed
@@ -48,14 +48,13 @@ function clearRelationshipFields(table, rows) {
   return rows
 }
 
-async function getLinksForRows(appId, rows) {
+async function getLinksForRows(rows) {
   const tableIds = [...new Set(rows.map(el => el.tableId))]
   // start by getting all the link values for performance reasons
   const responses = flatten(
     await Promise.all(
       tableIds.map(tableId =>
         getLinkDocuments({
-          appId,
           tableId: tableId,
           includeDocs: IncludeDocs.EXCLUDE,
         })
@@ -72,9 +71,9 @@ async function getLinksForRows(appId, rows) {
   )
 }
 
-async function getFullLinkedDocs(ctx, appId, links) {
+async function getFullLinkedDocs(links) {
   // create DBs
-  const db = new CouchDB(appId)
+  const db = getAppDB()
   const linkedRowIds = links.map(link => link.id)
   const uniqueRowIds = [...new Set(linkedRowIds)]
   let dbRows = (await db.allDocs(getMultiIDParams(uniqueRowIds))).rows.map(
@@ -88,7 +87,7 @@ async function getFullLinkedDocs(ctx, appId, links) {
   let [users, other] = partition(linked, linkRow =>
     linkRow._id.startsWith(USER_METDATA_PREFIX)
   )
-  users = await getGlobalUsersFromMetadata(appId, users)
+  users = await getGlobalUsersFromMetadata(users)
   return [...other, ...users]
 }
 
@@ -96,20 +95,16 @@ async function getFullLinkedDocs(ctx, appId, links) {
  * Update link documents for a row or table - this is to be called by the API controller when a change is occurring.
  * @param {string} args.eventType states what type of change which is occurring, means this can be expanded upon in the
  * future quite easily (all updates go through one function).
- * @param {string} args.appId The ID of the instance in which the change is occurring.
  * @param {string} args.tableId The ID of the of the table which is being changed.
- * @param {object|null} args.row The row which is changing, e.g. created, updated or deleted.
- * @param {object|null} args.table If the table has already been retrieved this can be used to reduce database gets.
- * @param {object|null} args.oldTable If the table is being updated then the old table can be provided for differencing.
+ * @param {object|undefined} args.row The row which is changing, e.g. created, updated or deleted.
+ * @param {object|undefined} args.table If the table has already been retrieved this can be used to reduce database gets.
+ * @param {object|undefined} args.oldTable If the table is being updated then the old table can be provided for differencing.
  * @returns {Promise<object>} When the update is complete this will respond successfully. Returns the row for
  * row operations and the table for table operations.
  */
 exports.updateLinks = async function (args) {
-  const { eventType, appId, row, tableId, table, oldTable } = args
+  const { eventType, row, tableId, table, oldTable } = args
   const baseReturnObj = row == null ? table : row
-  if (appId == null) {
-    throw "Cannot operate without an instance ID."
-  }
   // make sure table ID is set
   if (tableId == null && table != null) {
     args.tableId = table._id
@@ -146,27 +141,23 @@ exports.updateLinks = async function (args) {
 /**
  * Given a table and a list of rows this will retrieve all of the attached docs and enrich them into the row.
  * This is required for formula fields, this may only be utilised internally (for now).
- * @param {object} ctx The request which is looking for rows.
  * @param {object} table The table from which the rows originated.
  * @param {array<object>} rows The rows which are to be enriched.
  * @return {Promise<*>} returns the rows with all of the enriched relationships on it.
  */
-exports.attachFullLinkedDocs = async (ctx, table, rows) => {
-  const appId = ctx.appId
+exports.attachFullLinkedDocs = async (table, rows) => {
   const linkedTableIds = getLinkedTableIDs(table)
   if (linkedTableIds.length === 0) {
     return rows
   }
-  // create DBs
-  const db = new CouchDB(appId)
   // get all the links
-  const links = (await getLinksForRows(appId, rows)).filter(link =>
+  const links = (await getLinksForRows(rows)).filter(link =>
     rows.some(row => row._id === link.thisId)
   )
   // clear any existing links that could be dupe'd
   rows = clearRelationshipFields(table, rows)
   // now get the docs and combine into the rows
-  let linked = await getFullLinkedDocs(ctx, appId, links)
+  let linked = await getFullLinkedDocs(links)
   const linkedTables = []
   for (let row of rows) {
     for (let link of links.filter(link => link.thisId === row._id)) {
@@ -177,11 +168,7 @@ exports.attachFullLinkedDocs = async (ctx, table, rows) => {
       if (linkedRow) {
         const linkedTableId =
           linkedRow.tableId || getRelatedTableForField(table, link.fieldName)
-        const linkedTable = await getLinkedTable(
-          db,
-          linkedTableId,
-          linkedTables
-        )
+        const linkedTable = await getLinkedTable(linkedTableId, linkedTables)
         if (linkedTable) {
           row[link.fieldName].push(processFormulas(linkedTable, linkedRow))
         }
@@ -193,18 +180,16 @@ exports.attachFullLinkedDocs = async (ctx, table, rows) => {
 
 /**
  * This function will take the given enriched rows and squash the links to only contain the primary display field.
- * @param {string} appId The app in which the tables/rows/links exist.
  * @param {object} table The table from which the rows originated.
  * @param {array<object>} enriched The pre-enriched rows (full docs) which are to be squashed.
  * @returns {Promise<Array>} The rows after having their links squashed to only contain the ID and primary display.
  */
-exports.squashLinksToPrimaryDisplay = async (appId, table, enriched) => {
-  const db = new CouchDB(appId)
+exports.squashLinksToPrimaryDisplay = async (table, enriched) => {
   // will populate this as we find them
   const linkedTables = [table]
   for (let row of enriched) {
     // this only fetches the table if its not already in array
-    const rowTable = await getLinkedTable(db, row.tableId, linkedTables)
+    const rowTable = await getLinkedTable(row.tableId, linkedTables)
     for (let [column, schema] of Object.entries(rowTable.schema)) {
       if (schema.type !== FieldTypes.LINK || !Array.isArray(row[column])) {
         continue
@@ -212,7 +197,7 @@ exports.squashLinksToPrimaryDisplay = async (appId, table, enriched) => {
       const newLinks = []
       for (let link of row[column]) {
         const linkTblId = link.tableId || getRelatedTableForField(table, column)
-        const linkedTable = await getLinkedTable(db, linkTblId, linkedTables)
+        const linkedTable = await getLinkedTable(linkTblId, linkedTables)
         const obj = { _id: link._id }
         if (link[linkedTable.primaryDisplay]) {
           obj.primaryDisplay = link[linkedTable.primaryDisplay]

package/src/db/linkedRows/linkUtils.js

@@ -1,8 +1,8 @@
-const CouchDB = require("../index")
 const Sentry = require("@sentry/node")
 const { ViewNames, getQueryIndex } = require("../utils")
 const { FieldTypes } = require("../../constants")
 const { createLinkView } = require("../views/staticViews")
+const { getAppDB } = require("@budibase/backend-core/context")
 
 /**
  * Only needed so that boolean parameters are being used for includeDocs
@@ -17,7 +17,6 @@ exports.createLinkView = createLinkView
 
 /**
  * Gets the linking documents, not the linked documents themselves.
- * @param {string} args.appId The instance in which we are searching for linked rows.
  * @param {string} args.tableId The table which we are searching for linked rows against.
  * @param {string|null} args.fieldName The name of column/field which is being altered, only looking for
  * linking documents that are related to it. If this is not specified then the table level will be assumed.
@@ -30,8 +29,8 @@ exports.createLinkView = createLinkView
  * (if any).
  */
 exports.getLinkDocuments = async function (args) {
-  const { appId, tableId, rowId, includeDocs } = args
-  const db = new CouchDB(appId)
+  const { tableId, rowId, includeDocs } = args
+  const db = getAppDB()
   let params
   if (rowId != null) {
     params = { key: [tableId, rowId] }
@@ -68,7 +67,7 @@ exports.getLinkDocuments = async function (args) {
   } catch (err) {
     // check if the view doesn't exist, it should for all new instances
     if (err != null && err.name === "not_found") {
-      await exports.createLinkView(appId)
+      await exports.createLinkView()
       return exports.getLinkDocuments(arguments[0])
     } else {
       /* istanbul ignore next */
@@ -89,7 +88,8 @@ exports.getLinkedTableIDs = table => {
     .map(column => column.tableId)
 }
 
-exports.getLinkedTable = async (db, id, tables) => {
+exports.getLinkedTable = async (id, tables) => {
+  const db = getAppDB()
   let linkedTable = tables.find(table => table._id === id)
   if (linkedTable) {
     return linkedTable

package/src/db/tests/linkController.spec.js

@@ -20,7 +20,6 @@ describe("test the link controller", () => {
 
   function createLinkController(table, row = null, oldTable = null) {
     const linkConfig = {
-      appId: config.getAppId(),
       tableId: table._id,
       table,
     }

package/src/db/tests/linkTests.spec.js

@@ -1,8 +1,8 @@
 const TestConfig = require("../../tests/utilities/TestConfiguration")
-const { basicTable, basicLinkedRow } = require("../../tests/utilities/structures")
+const { basicTable } = require("../../tests/utilities/structures")
 const linkUtils = require("../linkedRows/linkUtils")
-const links = require("../linkedRows")
 const CouchDB = require("../index")
+const { getAppDB } = require("@budibase/backend-core/context")
 
 describe("test link functionality", () => {
   const config = new TestConfig(false)
@@ -11,18 +11,18 @@ describe("test link functionality", () => {
     let db, table
     beforeEach(async () => {
       await config.init()
-      db = new CouchDB(config.getAppId())
+      db = getAppDB()
       table = await config.createTable()
     })
 
     it("should be able to retrieve a linked table from a list", async () => {
-      const retrieved = await linkUtils.getLinkedTable(db, table._id, [table])
+      const retrieved = await linkUtils.getLinkedTable(table._id, [table])
       expect(retrieved._id).toBe(table._id)
     })
 
     it("should be able to retrieve a table from DB and update list", async () => {
       const tables = []
-      const retrieved = await linkUtils.getLinkedTable(db, table._id, tables)
+      const retrieved = await linkUtils.getLinkedTable(table._id, tables)
       expect(retrieved._id).toBe(table._id)
       expect(tables[0]).toBeDefined()
     })
@@ -51,7 +51,6 @@ describe("test link functionality", () => {
       const db = new CouchDB("test")
       await db.put({ _id: "_design/database", views: {} })
       const output = await linkUtils.getLinkDocuments({
-        appId: "test",
         tableId: "test",
         rowId: "test",
         includeDocs: false,

package/src/db/views/staticViews.js

@@ -1,4 +1,4 @@
-const CouchDB = require("../index")
+const { getAppDB } = require("@budibase/backend-core/context")
 const {
   DocumentTypes,
   SEPARATOR,
@@ -21,12 +21,11 @@ const SCREEN_PREFIX = DocumentTypes.SCREEN + SEPARATOR
 /**
  * Creates the link view for the instance, this will overwrite the existing one, but this should only
  * be called if it is found that the view does not exist.
- * @param {string} appId The instance to which the view should be added.
  * @returns {Promise<void>} The view now exists, please note that the next view of this query will actually build it,
  * so it may be slow.
  */
-exports.createLinkView = async appId => {
-  const db = new CouchDB(appId)
+exports.createLinkView = async () => {
+  const db = getAppDB()
   const designDoc = await db.get("_design/database")
   const view = {
     map: function (doc) {
@@ -57,8 +56,8 @@ exports.createLinkView = async appId => {
   await db.put(designDoc)
 }
 
-exports.createRoutingView = async appId => {
-  const db = new CouchDB(appId)
+exports.createRoutingView = async () => {
+  const db = getAppDB()
   const designDoc = await db.get("_design/database")
   const view = {
     // if using variables in a map function need to inject them before use
@@ -78,8 +77,8 @@ exports.createRoutingView = async appId => {
   await db.put(designDoc)
 }
 
-async function searchIndex(appId, indexName, fnString) {
-  const db = new CouchDB(appId)
+async function searchIndex(indexName, fnString) {
+  const db = getAppDB()
   const designDoc = await db.get("_design/database")
   designDoc.indexes = {
     [indexName]: {
@@ -90,9 +89,8 @@ async function searchIndex(appId, indexName, fnString) {
   await db.put(designDoc)
 }
 
-exports.createAllSearchIndex = async appId => {
+exports.createAllSearchIndex = async () => {
   await searchIndex(
-    appId,
     SearchIndexes.ROWS,
     function (doc) {
       function idx(input, prev) {

package/src/definitions/common.ts

@@ -17,6 +17,8 @@ export interface FieldSchema {
   autocolumn?: boolean
   throughFrom?: string
   throughTo?: string
+  formula?: string
+  formulaType?: string
   main?: boolean
   meta?: {
     toTable: string
@@ -46,6 +48,7 @@ export interface Table extends Base {
   schema: TableSchema
   primaryDisplay?: string
   sourceId?: string
+  relatedFormula?: string[]
   constrained?: string[]
 }
 

package/src/definitions/datasource.ts

@@ -47,6 +47,7 @@ export enum SourceNames {
   ARANGODB = "ARANGODB",
   REST = "REST",
   ORACLE = "ORACLE",
+  GOOGLE_SHEETS = "GOOGLE_SHEETS",
 }
 
 export enum IncludeRelationships {
@@ -86,6 +87,8 @@ export interface ExtraQueryConfig {
 export interface Integration {
   docs: string
   plus?: boolean
+  auth?: { type: string }
+  relationships?: boolean
   description: string
   friendlyName: string
   datasource: {}

package/src/environment.js

@@ -2,7 +2,8 @@ function isTest() {
   return (
     process.env.NODE_ENV === "jest" ||
     process.env.NODE_ENV === "cypress" ||
-    process.env.JEST_WORKER_ID != null
+    (process.env.JEST_WORKER_ID != null &&
+      process.env.JEST_WORKER_ID !== "null")
   )
 }
 
@@ -38,10 +39,12 @@ module.exports = {
   MINIO_ACCESS_KEY: process.env.MINIO_ACCESS_KEY,
   MINIO_SECRET_KEY: process.env.MINIO_SECRET_KEY,
   USE_QUOTAS: process.env.USE_QUOTAS,
+  EXCLUDE_QUOTAS_TENANTS: process.env.EXCLUDE_QUOTAS_TENANTS,
   REDIS_URL: process.env.REDIS_URL,
   REDIS_PASSWORD: process.env.REDIS_PASSWORD,
   INTERNAL_API_KEY: process.env.INTERNAL_API_KEY,
   MULTI_TENANCY: process.env.MULTI_TENANCY,
+  HTTP_MIGRATIONS: process.env.HTTP_MIGRATIONS,
   // environment
   NODE_ENV: process.env.NODE_ENV,
   JEST_WORKER_ID: process.env.JEST_WORKER_ID,

package/src/integrations/base/sql.ts

@@ -72,16 +72,22 @@ class InternalBuilder {
 
   // right now we only do filters on the specific table being queried
   addFilters(
-    tableName: string,
     query: KnexQuery,
-    filters: SearchFilters | undefined
+    filters: SearchFilters | undefined,
+    opts: { relationship?: boolean; tableName?: string }
   ): KnexQuery {
     function iterate(
       structure: { [key: string]: any },
       fn: (key: string, value: any) => void
     ) {
       for (let [key, value] of Object.entries(structure)) {
-        fn(`${tableName}.${key}`, value)
+        const isRelationshipField = key.includes(".")
+        if (!opts.relationship && !isRelationshipField) {
+          fn(`${opts.tableName}.${key}`, value)
+        }
+        if (opts.relationship && isRelationshipField) {
+          fn(key, value)
+        }
       }
     }
     if (!filters) {
@@ -160,15 +166,13 @@ class InternalBuilder {
 
   addSorting(query: KnexQuery, json: QueryJson): KnexQuery {
     let { sort, paginate } = json
-    if (!sort) {
-      return query
-    }
     const table = json.meta?.table
-    for (let [key, value] of Object.entries(sort)) {
-      const direction = value === SortDirection.ASCENDING ? "asc" : "desc"
-      query = query.orderBy(`${table?.name}.${key}`, direction)
-    }
-    if (this.client === SqlClients.MS_SQL && !sort && paginate?.limit) {
+    if (sort) {
+      for (let [key, value] of Object.entries(sort)) {
+        const direction = value === SortDirection.ASCENDING ? "asc" : "desc"
+        query = query.orderBy(`${table?.name}.${key}`, direction)
+      }
+    } else if (this.client === SqlClients.MS_SQL && paginate?.limit) {
       // @ts-ignore
       query = query.orderBy(`${table?.name}.${table?.primary[0]}`)
     }
@@ -185,29 +189,70 @@ class InternalBuilder {
     if (!relationships) {
       return query
     }
+    const tableSets: Record<string, [any]> = {}
+    // aggregate into table sets (all the same to tables)
     for (let relationship of relationships) {
-      const from = relationship.from,
-        to = relationship.to,
-        toTable = relationship.tableName
-      if (!relationship.through) {
+      const keyObj: { toTable: string; throughTable: string | undefined } = {
+        toTable: relationship.tableName,
+        throughTable: undefined,
+      }
+      if (relationship.through) {
+        keyObj.throughTable = relationship.through
+      }
+      const key = JSON.stringify(keyObj)
+      if (tableSets[key]) {
+        tableSets[key].push(relationship)
+      } else {
+        tableSets[key] = [relationship]
+      }
+    }
+    for (let [key, relationships] of Object.entries(tableSets)) {
+      const { toTable, throughTable } = JSON.parse(key)
+      if (!throughTable) {
         // @ts-ignore
-        query = query.leftJoin(
+        query = query.join(
           toTable,
-          `${fromTable}.${from}`,
-          `${toTable}.${to}`
+          function () {
+            for (let relationship of relationships) {
+              const from = relationship.from,
+                to = relationship.to
+              // @ts-ignore
+              this.orOn(`${fromTable}.${from}`, "=", `${toTable}.${to}`)
+            }
+          },
+          "left"
         )
       } else {
-        const throughTable = relationship.through
-        const fromPrimary = relationship.fromPrimary
-        const toPrimary = relationship.toPrimary
         query = query
           // @ts-ignore
-          .leftJoin(
+          .join(
             throughTable,
-            `${fromTable}.${fromPrimary}`,
-            `${throughTable}.${from}`
+            function () {
+              for (let relationship of relationships) {
+                const fromPrimary = relationship.fromPrimary
+                const from = relationship.from
+                // @ts-ignore
+                this.orOn(
+                  `${fromTable}.${fromPrimary}`,
+                  "=",
+                  `${throughTable}.${from}`
+                )
+              }
+            },
+            "left"
+          )
+          .join(
+            toTable,
+            function () {
+              for (let relationship of relationships) {
+                const toPrimary = relationship.toPrimary
+                const to = relationship.to
+                // @ts-ignore
+                this.orOn(`${toTable}.${toPrimary}`, `${throughTable}.${to}`)
+              }
+            },
+            "left"
           )
-          .leftJoin(toTable, `${toTable}.${toPrimary}`, `${throughTable}.${to}`)
       }
     }
     return query.limit(BASE_LIMIT)
@@ -272,7 +317,7 @@ class InternalBuilder {
     if (foundOffset) {
       query = query.offset(foundOffset)
     }
-    query = this.addFilters(tableName, query, filters)
+    query = this.addFilters(query, filters, { tableName })
     // add sorting to pre-query
     query = this.addSorting(query, json)
     // @ts-ignore
@@ -285,20 +330,21 @@ class InternalBuilder {
       preQuery = this.addSorting(preQuery, json)
     }
     // handle joins
-    return this.addRelationships(
+    query = this.addRelationships(
       knex,
       preQuery,
       selectStatement,
       tableName,
       relationships
     )
+    return this.addFilters(query, filters, { relationship: true })
   }
 
   update(knex: Knex, json: QueryJson, opts: QueryOptions): KnexQuery {
     const { endpoint, body, filters } = json
     let query: KnexQuery = knex(endpoint.entityId)
     const parsedBody = parseBody(body)
-    query = this.addFilters(endpoint.entityId, query, filters)
+    query = this.addFilters(query, filters, { tableName: endpoint.entityId })
     // mysql can't use returning
     if (opts.disableReturning) {
       return query.update(parsedBody)
@@ -310,7 +356,7 @@ class InternalBuilder {
   delete(knex: Knex, json: QueryJson, opts: QueryOptions): KnexQuery {
     const { endpoint, filters } = json
     let query: KnexQuery = knex(endpoint.entityId)
-    query = this.addFilters(endpoint.entityId, query, filters)
+    query = this.addFilters(query, filters, { tableName: endpoint.entityId })
     // mysql can't use returning
     if (opts.disableReturning) {
       return query.delete()