@budibase/server 2.1.44 → 2.1.46-alpha.0

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

@@ -1,15 +1,17 @@
 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
+  let table1, table2, appId
 
   beforeEach(async () => {
-    await config.init()
+    const app = await config.init()
+    appId = app.appId
     const { _id } = await config.createTable()
     table2 = await config.createLinkedTable(RelationshipTypes.MANY_TO_MANY, ["link", "link2"])
     // update table after creating link
@@ -18,18 +20,20 @@ describe("test the link controller", () => {
 
   afterAll(config.end)
 
-  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 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)
+    })
   }
 
   async function createLinkedRow(linkField = "link", t1 = table1, t2 = table2) {
@@ -38,16 +42,16 @@ describe("test the link controller", () => {
     return config.getRow(t1._id, _id)
   }
 
-  it("should be able to confirm if two table schemas are equal", () => {
-    const controller = createLinkController(table1)
+  it("should be able to confirm if two table schemas are equal", async () => {
+    const controller = await 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", () => {
-    const controller = createLinkController(table1)
+  it("should be able to check the relationship types across two fields", async () => {
+    const controller = await createLinkController(table1)
     // empty case
     let output = controller.handleRelationshipType({}, {})
     expect(output.linkedField.relationshipType).toEqual(RelationshipTypes.MANY_TO_MANY)
@@ -65,29 +69,33 @@ describe("test the link controller", () => {
 
   it("should be able to delete a row", async () => {
     const row = await createLinkedRow()
-    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)
+    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)
+    })
   })
 
   it("shouldn't throw an error when deleting a row with no links", async () => {
     const row = await config.createRow(basicRow(table1._id))
-    const controller = createLinkController(table1, row)
-    let error
-    try {
-      await controller.rowDeleted()
-    } catch (err) {
-      error = err
-    }
-    expect(error).toBeUndefined()
+    const controller = await createLinkController(table1, row)
+    await context.doInAppContext(appId, async () => {
+      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", () => {
-    const controller = createLinkController(table1)
+  it("should throw an error when validating a table which is invalid", async () => {
+    const controller = await createLinkController(table1)
     const copyTable = {
       ...table1
     }
@@ -110,32 +118,38 @@ describe("test the link controller", () => {
     const row = await createLinkedRow()
     // remove the link from the row
     row.link = []
-    const controller = createLinkController(table1, row)
-    await controller.rowSaved()
-    let links = await controller.getRowLinkDocs(row._id)
-    expect(links.length).toEqual(0)
+    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)
+    })
   })
 
   it("should be able to delete a table and have links deleted", async () => {
     await createLinkedRow()
-    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)
+    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)
+    })
   })
 
   it("should be able to remove a linked field from a table", async () => {
     await createLinkedRow()
     await createLinkedRow("link2")
-    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)
+    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)
+    })
   })
 
   it("should throw an error when overwriting a link column", async () => {
@@ -143,7 +157,7 @@ describe("test the link controller", () => {
     update.schema.link.relationshipType = RelationshipTypes.MANY_TO_ONE
     let error
     try {
-      const controller = createLinkController(update)
+      const controller = await createLinkController(update)
       await controller.tableSaved()
     } catch (err) {
       error = err
@@ -156,10 +170,12 @@ describe("test the link controller", () => {
     await createLinkedRow()
     const newTable = cloneDeep(table1)
     delete newTable.schema.link
-    const controller = createLinkController(newTable, null, table1)
-    await controller.tableUpdated()
-    const links = await controller.getTableLinkDocs()
-    expect(links.length).toEqual(0)
+    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)
+    })
   })
 
   it("shouldn't allow one to many having many relationships against it", async () => {

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

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

package/src/db/{utils.js → utils.ts}

@@ -1,82 +1,56 @@
-const newid = require("./newid")
-const {
-  DocumentType: CoreDocType,
-  InternalTable,
-  getRoleParams,
-  generateRoleID,
-  APP_DEV_PREFIX,
-  APP_PREFIX,
-  SEPARATOR,
-  StaticDatabases,
-  isDevAppID,
-  isProdAppID,
-  getDevelopmentAppID,
-  generateAppID,
-  getQueryIndex,
-  ViewName,
-  getDocParams,
-  getRowParams,
-  generateRowID,
-  getUserMetadataParams,
-  generateUserMetadataID,
-  getGlobalIDFromUserMetadataID,
-} = require("@budibase/backend-core/db")
-
-const UNICODE_MAX = "\ufff0"
-
-const AppStatus = {
+import newid from "./newid"
+import { db as dbCore } from "@budibase/backend-core"
+
+type Optional = string | null
+
+export const AppStatus = {
   DEV: "development",
   ALL: "all",
   DEPLOYED: "published",
 }
 
-const DocumentType = CoreDocType
-
-const SearchIndexes = {
+export const SearchIndexes = {
   ROWS: "rows",
 }
 
-exports.StaticDatabases = StaticDatabases
-
-const BudibaseInternalDB = {
+export const BudibaseInternalDB = {
   _id: "bb_internal",
-  type: "budibase",
+  type: dbCore.BUDIBASE_DATASOURCE_TYPE,
   name: "Budibase DB",
   source: "BUDIBASE",
   config: {},
 }
 
-exports.APP_PREFIX = APP_PREFIX
-exports.APP_DEV_PREFIX = APP_DEV_PREFIX
-exports.isDevAppID = isDevAppID
-exports.isProdAppID = isProdAppID
-exports.USER_METDATA_PREFIX = `${DocumentType.ROW}${SEPARATOR}${InternalTable.USER_METADATA}${SEPARATOR}`
-exports.LINK_USER_METADATA_PREFIX = `${DocumentType.LINK}${SEPARATOR}${InternalTable.USER_METADATA}${SEPARATOR}`
-exports.TABLE_ROW_PREFIX = `${DocumentType.ROW}${SEPARATOR}${DocumentType.TABLE}`
-exports.ViewName = ViewName
-exports.InternalTables = InternalTable
-exports.DocumentType = DocumentType
-exports.SEPARATOR = SEPARATOR
-exports.UNICODE_MAX = UNICODE_MAX
-exports.SearchIndexes = SearchIndexes
-exports.AppStatus = AppStatus
-exports.BudibaseInternalDB = BudibaseInternalDB
-exports.generateAppID = generateAppID
-exports.generateDevAppID = getDevelopmentAppID
-exports.generateRoleID = generateRoleID
-exports.getRoleParams = getRoleParams
-exports.getQueryIndex = getQueryIndex
-exports.getDocParams = getDocParams
-exports.getRowParams = getRowParams
-exports.generateRowID = generateRowID
-exports.getUserMetadataParams = getUserMetadataParams
-exports.generateUserMetadataID = generateUserMetadataID
-exports.getGlobalIDFromUserMetadataID = getGlobalIDFromUserMetadataID
+export const SEPARATOR = dbCore.SEPARATOR
+export const StaticDatabases = dbCore.StaticDatabases
+export const DocumentType = dbCore.DocumentType
+export const APP_PREFIX = dbCore.APP_PREFIX
+export const APP_DEV_PREFIX = dbCore.APP_DEV_PREFIX
+export const isDevAppID = dbCore.isDevAppID
+export const isProdAppID = dbCore.isProdAppID
+export const USER_METDATA_PREFIX = `${DocumentType.ROW}${SEPARATOR}${dbCore.InternalTable.USER_METADATA}${SEPARATOR}`
+export const LINK_USER_METADATA_PREFIX = `${DocumentType.LINK}${SEPARATOR}${dbCore.InternalTable.USER_METADATA}${SEPARATOR}`
+export const TABLE_ROW_PREFIX = `${DocumentType.ROW}${SEPARATOR}${DocumentType.TABLE}`
+export const ViewName = dbCore.ViewName
+export const InternalTables = dbCore.InternalTable
+export const UNICODE_MAX = dbCore.UNICODE_MAX
+export const generateAppID = dbCore.generateAppID
+export const generateDevAppID = dbCore.getDevelopmentAppID
+export const generateRoleID = dbCore.generateRoleID
+export const getRoleParams = dbCore.getRoleParams
+export const getQueryIndex = dbCore.getQueryIndex
+export const getDocParams = dbCore.getDocParams
+export const getRowParams = dbCore.getRowParams
+export const generateRowID = dbCore.generateRowID
+export const getUserMetadataParams = dbCore.getUserMetadataParams
+export const generateUserMetadataID = dbCore.generateUserMetadataID
+export const getGlobalIDFromUserMetadataID =
+  dbCore.getGlobalIDFromUserMetadataID
 
 /**
  * Gets parameters for retrieving tables, this is a utility function for the getDocParams function.
  */
-exports.getTableParams = (tableId = null, otherProps = {}) => {
+export function getTableParams(tableId?: Optional, otherProps = {}) {
   return getDocParams(DocumentType.TABLE, tableId, otherProps)
 }
 
@@ -84,7 +58,7 @@ exports.getTableParams = (tableId = null, otherProps = {}) => {
  * Generates a new table ID.
  * @returns {string} The new table ID which the table doc can be stored under.
  */
-exports.generateTableID = () => {
+export function generateTableID() {
   return `${DocumentType.TABLE}${SEPARATOR}${newid()}`
 }
 
@@ -93,7 +67,7 @@ exports.generateTableID = () => {
  * @param {string} rowId The ID of the row.
  * @returns {string} The table ID.
  */
-exports.getTableIDFromRowID = rowId => {
+export function getTableIDFromRowID(rowId: string) {
   const components = rowId
     .split(DocumentType.TABLE + SEPARATOR)[1]
     .split(SEPARATOR)
@@ -103,7 +77,10 @@ exports.getTableIDFromRowID = rowId => {
 /**
  * Gets parameters for retrieving automations, this is a utility function for the getDocParams function.
  */
-exports.getAutomationParams = (automationId = null, otherProps = {}) => {
+export function getAutomationParams(
+  automationId?: Optional,
+  otherProps: any = {}
+) {
   return getDocParams(DocumentType.AUTOMATION, automationId, otherProps)
 }
 
@@ -111,7 +88,7 @@ exports.getAutomationParams = (automationId = null, otherProps = {}) => {
  * Generates a new automation ID.
  * @returns {string} The new automation ID which the automation doc can be stored under.
  */
-exports.generateAutomationID = () => {
+export function generateAutomationID() {
   return `${DocumentType.AUTOMATION}${SEPARATOR}${newid()}`
 }
 
@@ -126,14 +103,14 @@ exports.generateAutomationID = () => {
  * @param {string} fieldName2 the name of the field in the linked row.
  * @returns {string} The new link doc ID which the automation doc can be stored under.
  */
-exports.generateLinkID = (
-  tableId1,
-  tableId2,
-  rowId1,
-  rowId2,
-  fieldName1,
-  fieldName2
-) => {
+export function generateLinkID(
+  tableId1: string,
+  tableId2: string,
+  rowId1: string,
+  rowId2: string,
+  fieldName1: string,
+  fieldName2: string
+) {
   const tables = `${SEPARATOR}${tableId1}${SEPARATOR}${tableId2}`
   const rows = `${SEPARATOR}${rowId1}${SEPARATOR}${rowId2}`
   const fields = `${SEPARATOR}${fieldName1}${SEPARATOR}${fieldName2}`
@@ -143,7 +120,7 @@ exports.generateLinkID = (
 /**
  * Gets parameters for retrieving link docs, this is a utility function for the getDocParams function.
  */
-exports.getLinkParams = (otherProps = {}) => {
+export function getLinkParams(otherProps: any = {}) {
   return getDocParams(DocumentType.LINK, null, otherProps)
 }
 
@@ -151,14 +128,14 @@ exports.getLinkParams = (otherProps = {}) => {
  * Generates a new layout ID.
  * @returns {string} The new layout ID which the layout doc can be stored under.
  */
-exports.generateLayoutID = id => {
+export function generateLayoutID(id?: string) {
   return `${DocumentType.LAYOUT}${SEPARATOR}${id || newid()}`
 }
 
 /**
  * Gets parameters for retrieving layout, this is a utility function for the getDocParams function.
  */
-exports.getLayoutParams = (layoutId = null, otherProps = {}) => {
+export function getLayoutParams(layoutId?: Optional, otherProps: any = {}) {
   return getDocParams(DocumentType.LAYOUT, layoutId, otherProps)
 }
 
@@ -166,14 +143,14 @@ exports.getLayoutParams = (layoutId = null, otherProps = {}) => {
  * Generates a new screen ID.
  * @returns {string} The new screen ID which the screen doc can be stored under.
  */
-exports.generateScreenID = () => {
+export function generateScreenID() {
   return `${DocumentType.SCREEN}${SEPARATOR}${newid()}`
 }
 
 /**
  * Gets parameters for retrieving screens, this is a utility function for the getDocParams function.
  */
-exports.getScreenParams = (screenId = null, otherProps = {}) => {
+export function getScreenParams(screenId?: Optional, otherProps: any = {}) {
   return getDocParams(DocumentType.SCREEN, screenId, otherProps)
 }
 
@@ -181,14 +158,14 @@ exports.getScreenParams = (screenId = null, otherProps = {}) => {
  * Generates a new webhook ID.
  * @returns {string} The new webhook ID which the webhook doc can be stored under.
  */
-exports.generateWebhookID = () => {
+export function generateWebhookID() {
   return `${DocumentType.WEBHOOK}${SEPARATOR}${newid()}`
 }
 
 /**
  * Gets parameters for retrieving a webhook, this is a utility function for the getDocParams function.
  */
-exports.getWebhookParams = (webhookId = null, otherProps = {}) => {
+export function getWebhookParams(webhookId?: Optional, otherProps: any = {}) {
   return getDocParams(DocumentType.WEBHOOK, webhookId, otherProps)
 }
 
@@ -196,7 +173,7 @@ exports.getWebhookParams = (webhookId = null, otherProps = {}) => {
  * Generates a new datasource ID.
  * @returns {string} The new datasource ID which the webhook doc can be stored under.
  */
-exports.generateDatasourceID = ({ plus = false } = {}) => {
+export function generateDatasourceID({ plus = false } = {}) {
   return `${
     plus ? DocumentType.DATASOURCE_PLUS : DocumentType.DATASOURCE
   }${SEPARATOR}${newid()}`
@@ -205,7 +182,10 @@ exports.generateDatasourceID = ({ plus = false } = {}) => {
 /**
  * Gets parameters for retrieving a datasource, this is a utility function for the getDocParams function.
  */
-exports.getDatasourceParams = (datasourceId = null, otherProps = {}) => {
+export function getDatasourceParams(
+  datasourceId?: Optional,
+  otherProps: any = {}
+) {
   return getDocParams(DocumentType.DATASOURCE, datasourceId, otherProps)
 }
 
@@ -213,7 +193,7 @@ exports.getDatasourceParams = (datasourceId = null, otherProps = {}) => {
  * Generates a new query ID.
  * @returns {string} The new query ID which the query doc can be stored under.
  */
-exports.generateQueryID = datasourceId => {
+export function generateQueryID(datasourceId: string) {
   return `${
     DocumentType.QUERY
   }${SEPARATOR}${datasourceId}${SEPARATOR}${newid()}`
@@ -223,21 +203,21 @@ exports.generateQueryID = datasourceId => {
  * Generates a metadata ID for automations, used to track errors in recurring
  * automations etc.
  */
-exports.generateAutomationMetadataID = automationId => {
+export function generateAutomationMetadataID(automationId: string) {
   return `${DocumentType.AUTOMATION_METADATA}${SEPARATOR}${automationId}`
 }
 
 /**
  * Retrieve all automation metadata in an app database.
  */
-exports.getAutomationMetadataParams = (otherProps = {}) => {
+export function getAutomationMetadataParams(otherProps: any = {}) {
   return getDocParams(DocumentType.AUTOMATION_METADATA, null, otherProps)
 }
 
 /**
  * Gets parameters for retrieving a query, this is a utility function for the getDocParams function.
  */
-exports.getQueryParams = (datasourceId = null, otherProps = {}) => {
+export function getQueryParams(datasourceId?: Optional, otherProps: any = {}) {
   if (datasourceId == null) {
     return getDocParams(DocumentType.QUERY, null, otherProps)
   }
@@ -253,15 +233,19 @@ exports.getQueryParams = (datasourceId = null, otherProps = {}) => {
  * Generates a new flag document ID.
  * @returns {string} The ID of the flag document that was generated.
  */
-exports.generateUserFlagID = userId => {
+export function generateUserFlagID(userId: string) {
   return `${DocumentType.USER_FLAG}${SEPARATOR}${userId}`
 }
 
-exports.generateMetadataID = (type, entityId) => {
+export function generateMetadataID(type: string, entityId: string) {
   return `${DocumentType.METADATA}${SEPARATOR}${type}${SEPARATOR}${entityId}`
 }
 
-exports.getMetadataParams = (type, entityId = null, otherProps = {}) => {
+export function getMetadataParams(
+  type: string,
+  entityId?: Optional,
+  otherProps: any = {}
+) {
   let docId = `${type}${SEPARATOR}`
   if (entityId != null) {
     docId += entityId
@@ -269,22 +253,22 @@ exports.getMetadataParams = (type, entityId = null, otherProps = {}) => {
   return getDocParams(DocumentType.METADATA, docId, otherProps)
 }
 
-exports.generateMemoryViewID = viewName => {
+export function generateMemoryViewID(viewName: string) {
   return `${DocumentType.MEM_VIEW}${SEPARATOR}${viewName}`
 }
 
-exports.getMemoryViewParams = (otherProps = {}) => {
+export function getMemoryViewParams(otherProps: any = {}) {
   return getDocParams(DocumentType.MEM_VIEW, null, otherProps)
 }
 
-exports.generatePluginID = name => {
+export function generatePluginID(name: string) {
   return `${DocumentType.PLUGIN}${SEPARATOR}${name}`
 }
 
 /**
  * This can be used with the db.allDocs to get a list of IDs
  */
-exports.getMultiIDParams = ids => {
+export function getMultiIDParams(ids: string[]) {
   return {
     keys: ids,
     include_docs: true,