@budibase/server 2.1.32-alpha.7 → 2.1.32

package/src/db/linkedRows/LinkController.js

@@ -1,13 +1,59 @@
 const { IncludeDocs, getLinkDocuments } = require("./linkUtils")
-const { InternalTables, getUserMetadataParams } = require("../utils")
+const {
+  generateLinkID,
+  InternalTables,
+  getUserMetadataParams,
+} = require("../utils")
 const Sentry = require("@sentry/node")
 const { FieldTypes, RelationshipTypes } = require("../../constants")
-const { context } = require("@budibase/backend-core")
-const LinkDocument = require("./LinkDocument")
+const { getAppDB } = require("@budibase/backend-core/context")
+
+/**
+ * Creates a new link document structure which can be put to the database. It is important to
+ * note that while this talks about linker/linked the link is bi-directional and for all intent
+ * and purposes it does not matter from which direction the link was initiated.
+ * @param {string} tableId1 The ID of the first table (the linker).
+ * @param {string} tableId2 The ID of the second table (the linked).
+ * @param {string} fieldName1 The name of the field in the linker table.
+ * @param {string} fieldName2 The name of the field in the linked table.
+ * @param {string} rowId1 The ID of the row which is acting as the linker.
+ * @param {string} rowId2 The ID of the row which is acting as the linked.
+ * @constructor
+ */
+function LinkDocument(
+  tableId1,
+  fieldName1,
+  rowId1,
+  tableId2,
+  fieldName2,
+  rowId2
+) {
+  // build the ID out of unique references to this link document
+  this._id = generateLinkID(
+    tableId1,
+    tableId2,
+    rowId1,
+    rowId2,
+    fieldName1,
+    fieldName2
+  )
+  // required for referencing in view
+  this.type = FieldTypes.LINK
+  this.doc1 = {
+    tableId: tableId1,
+    fieldName: fieldName1,
+    rowId: rowId1,
+  }
+  this.doc2 = {
+    tableId: tableId2,
+    fieldName: fieldName2,
+    rowId: rowId2,
+  }
+}
 
 class LinkController {
   constructor({ tableId, row, table, oldTable }) {
-    this._db = context.getAppDB()
+    this._db = getAppDB()
     this._tableId = tableId
     this._row = row
     this._table = table

package/src/db/linkedRows/index.js

@@ -14,7 +14,7 @@ const { getMultiIDParams, USER_METDATA_PREFIX } = require("../../db/utils")
 const { partition } = require("lodash")
 const { getGlobalUsersFromMetadata } = require("../../utilities/global")
 const { processFormulas } = require("../../utilities/rowProcessor/utils")
-const { context } = require("@budibase/backend-core")
+const { getAppDB } = require("@budibase/backend-core/context")
 
 /**
  * This functionality makes sure that when rows with links are created, updated or deleted they are processed
@@ -74,7 +74,7 @@ async function getLinksForRows(rows) {
 
 async function getFullLinkedDocs(links) {
   // create DBs
-  const db = context.getAppDB()
+  const db = getAppDB()
   const linkedRowIds = links.map(link => link.id)
   const uniqueRowIds = [...new Set(linkedRowIds)]
   let dbRows = (await db.allDocs(getMultiIDParams(uniqueRowIds))).rows.map(

package/src/db/linkedRows/linkUtils.js

@@ -2,7 +2,7 @@ const Sentry = require("@sentry/node")
 const { ViewName, getQueryIndex } = require("../utils")
 const { FieldTypes } = require("../../constants")
 const { createLinkView } = require("../views/staticViews")
-const { context } = require("@budibase/backend-core")
+const { getAppDB } = require("@budibase/backend-core/context")
 
 /**
  * Only needed so that boolean parameters are being used for includeDocs
@@ -30,7 +30,7 @@ exports.createLinkView = createLinkView
  */
 exports.getLinkDocuments = async function (args) {
   const { tableId, rowId, includeDocs } = args
-  const db = context.getAppDB()
+  const db = getAppDB()
   let params
   if (rowId != null) {
     params = { key: [tableId, rowId] }
@@ -89,7 +89,7 @@ exports.getLinkedTableIDs = table => {
 }
 
 exports.getLinkedTable = async (id, tables) => {
-  const db = context.getAppDB()
+  const db = getAppDB()
   let linkedTable = tables.find(table => table._id === id)
   if (linkedTable) {
     return linkedTable

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

@@ -1,17 +1,15 @@
 const TestConfig = require("../../tests/utilities/TestConfiguration")
 const { basicRow, basicLinkedRow, basicTable } = require("../../tests/utilities/structures")
 const LinkController = require("../linkedRows/LinkController")
-const { context } = require("@budibase/backend-core")
 const { RelationshipTypes } = require("../../constants")
 const { cloneDeep } = require("lodash/fp")
 
 describe("test the link controller", () => {
   let config = new TestConfig(false)
-  let table1, table2, appId
+  let table1, table2
 
   beforeEach(async () => {
-    const app = await config.init()
-    appId = app.appId
+    await config.init()
     const { _id } = await config.createTable()
     table2 = await config.createLinkedTable(RelationshipTypes.MANY_TO_MANY, ["link", "link2"])
     // update table after creating link
@@ -20,20 +18,18 @@ describe("test the link controller", () => {
 
   afterAll(config.end)
 
-  async function createLinkController(table, row = null, oldTable = null) {
-    return context.doInAppContext(appId, () => {
-      const linkConfig = {
-        tableId: table._id,
-        table,
-      }
-      if (row) {
-        linkConfig.row = row
-      }
-      if (oldTable) {
-        linkConfig.oldTable = oldTable
-      }
-      return new LinkController(linkConfig)
-    })
+  function createLinkController(table, row = null, oldTable = null) {
+    const linkConfig = {
+      tableId: table._id,
+      table,
+    }
+    if (row) {
+      linkConfig.row = row
+    }
+    if (oldTable) {
+      linkConfig.oldTable = oldTable
+    }
+    return new LinkController(linkConfig)
   }
 
   async function createLinkedRow(linkField = "link", t1 = table1, t2 = table2) {
@@ -42,16 +38,16 @@ describe("test the link controller", () => {
     return config.getRow(t1._id, _id)
   }
 
-  it("should be able to confirm if two table schemas are equal", async () => {
-    const controller = await createLinkController(table1)
+  it("should be able to confirm if two table schemas are equal", () => {
+    const controller = createLinkController(table1)
     let equal = controller.areLinkSchemasEqual(table2.schema.link, table2.schema.link)
     expect(equal).toEqual(true)
     equal = controller.areLinkSchemasEqual(table1.schema.link, table2.schema.link)
     expect(equal).toEqual(false)
   })
 
-  it("should be able to check the relationship types across two fields", async () => {
-    const controller = await createLinkController(table1)
+  it("should be able to check the relationship types across two fields", () => {
+    const controller = createLinkController(table1)
     // empty case
     let output = controller.handleRelationshipType({}, {})
     expect(output.linkedField.relationshipType).toEqual(RelationshipTypes.MANY_TO_MANY)
@@ -69,33 +65,29 @@ describe("test the link controller", () => {
 
   it("should be able to delete a row", async () => {
     const row = await createLinkedRow()
-    const controller = await createLinkController(table1, row)
-    await context.doInAppContext(appId, async () => {
-      // get initial count
-      const beforeLinks = await controller.getRowLinkDocs(row._id)
-      await controller.rowDeleted()
-      let afterLinks = await controller.getRowLinkDocs(row._id)
-      expect(beforeLinks.length).toEqual(1)
-      expect(afterLinks.length).toEqual(0)
-    })
+    const controller = createLinkController(table1, row)
+    // get initial count
+    const beforeLinks = await controller.getRowLinkDocs(row._id)
+    await controller.rowDeleted()
+    let afterLinks = await controller.getRowLinkDocs(row._id)
+    expect(beforeLinks.length).toEqual(1)
+    expect(afterLinks.length).toEqual(0)
   })
 
   it("shouldn't throw an error when deleting a row with no links", async () => {
     const row = await config.createRow(basicRow(table1._id))
-    const controller = await createLinkController(table1, row)
-    await context.doInAppContext(appId, async () => {
-      let error
-      try {
-        await controller.rowDeleted()
-      } catch (err) {
-        error = err
-      }
-      expect(error).toBeUndefined()
-    })
+    const controller = createLinkController(table1, row)
+    let error
+    try {
+      await controller.rowDeleted()
+    } catch (err) {
+      error = err
+    }
+    expect(error).toBeUndefined()
   })
 
-  it("should throw an error when validating a table which is invalid", async () => {
-    const controller = await createLinkController(table1)
+  it("should throw an error when validating a table which is invalid", () => {
+    const controller = createLinkController(table1)
     const copyTable = {
       ...table1
     }
@@ -118,38 +110,32 @@ describe("test the link controller", () => {
     const row = await createLinkedRow()
     // remove the link from the row
     row.link = []
-    const controller = await createLinkController(table1, row)
-    await context.doInAppContext(appId, async () => {
-      await controller.rowSaved()
-      let links = await controller.getRowLinkDocs(row._id)
-      expect(links.length).toEqual(0)
-    })
+    const controller = createLinkController(table1, row)
+    await controller.rowSaved()
+    let links = await controller.getRowLinkDocs(row._id)
+    expect(links.length).toEqual(0)
   })
 
   it("should be able to delete a table and have links deleted", async () => {
     await createLinkedRow()
-    const controller = await createLinkController(table1)
-    await context.doInAppContext(appId, async () => {
-      let before = await controller.getTableLinkDocs()
-      await controller.tableDeleted()
-      let after = await controller.getTableLinkDocs()
-      expect(before.length).toEqual(1)
-      expect(after.length).toEqual(0)
-    })
+    const controller = createLinkController(table1)
+    let before = await controller.getTableLinkDocs()
+    await controller.tableDeleted()
+    let after = await controller.getTableLinkDocs()
+    expect(before.length).toEqual(1)
+    expect(after.length).toEqual(0)
   })
 
   it("should be able to remove a linked field from a table", async () => {
     await createLinkedRow()
     await createLinkedRow("link2")
-    const controller = await createLinkController(table1, null, table1)
-    await context.doInAppContext(appId, async () => {
-      let before = await controller.getTableLinkDocs()
-      await controller.removeFieldFromTable("link")
-      let after = await controller.getTableLinkDocs()
-      expect(before.length).toEqual(2)
-      // shouldn't delete the other field
-      expect(after.length).toEqual(1)
-    })
+    const controller = createLinkController(table1, null, table1)
+    let before = await controller.getTableLinkDocs()
+    await controller.removeFieldFromTable("link")
+    let after = await controller.getTableLinkDocs()
+    expect(before.length).toEqual(2)
+    // shouldn't delete the other field
+    expect(after.length).toEqual(1)
   })
 
   it("should throw an error when overwriting a link column", async () => {
@@ -157,7 +143,7 @@ describe("test the link controller", () => {
     update.schema.link.relationshipType = RelationshipTypes.MANY_TO_ONE
     let error
     try {
-      const controller = await createLinkController(update)
+      const controller = createLinkController(update)
       await controller.tableSaved()
     } catch (err) {
       error = err
@@ -170,12 +156,10 @@ describe("test the link controller", () => {
     await createLinkedRow()
     const newTable = cloneDeep(table1)
     delete newTable.schema.link
-    const controller = await createLinkController(newTable, null, table1)
-    await context.doInAppContext(appId, async () => {
-      await controller.tableUpdated()
-      const links = await controller.getTableLinkDocs()
-      expect(links.length).toEqual(0)
-    })
+    const controller = createLinkController(newTable, null, table1)
+    await controller.tableUpdated()
+    const links = await controller.getTableLinkDocs()
+    expect(links.length).toEqual(0)
   })
 
   it("shouldn't allow one to many having many relationships against it", async () => {

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

@@ -1,34 +1,30 @@
 const TestConfig = require("../../tests/utilities/TestConfiguration")
 const { basicTable } = require("../../tests/utilities/structures")
 const linkUtils = require("../linkedRows/linkUtils")
-const { context } = require("@budibase/backend-core")
+const { getAppDB } = require("@budibase/backend-core/context")
+const { doWithDB } = require("@budibase/backend-core/db")
 
 describe("test link functionality", () => {
   const config = new TestConfig(false)
-  let appId
 
   describe("getLinkedTable", () => {
-    let table
+    let db, table
     beforeEach(async () => {
-      const app = await config.init()
-      appId = app.appId
+      await config.init()
+      db = getAppDB()
       table = await config.createTable()
     })
 
     it("should be able to retrieve a linked table from a list", async () => {
-      await context.doInAppContext(appId, async () => {
-        const retrieved = await linkUtils.getLinkedTable(table._id, [table])
-        expect(retrieved._id).toBe(table._id)
-      })
+      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 = []
-      await context.doInAppContext(appId, async () => {
-        const retrieved = await linkUtils.getLinkedTable(table._id, tables)
-        expect(retrieved._id).toBe(table._id)
-        expect(tables[0]).toBeDefined()
-      })
+      const retrieved = await linkUtils.getLinkedTable(table._id, tables)
+      expect(retrieved._id).toBe(table._id)
+      expect(tables[0]).toBeDefined()
     })
   })
 
@@ -52,14 +48,15 @@ describe("test link functionality", () => {
   describe("getLinkDocuments", () => {
     it("should create the link view when it doesn't exist", async () => {
       // create the DB and a very basic app design DB
-      await context.doInAppContext(appId, async () => {
-        const output = await linkUtils.getLinkDocuments({
+      const output = await doWithDB("test", async db => {
+        await db.put({ _id: "_design/database", views: {} })
+        return await linkUtils.getLinkDocuments({
           tableId: "test",
           rowId: "test",
           includeDocs: false,
         })
-        expect(Array.isArray(output)).toBe(true)
       })
+      expect(Array.isArray(output)).toBe(true)
     })
   })
 })