@budibase/server 2.1.43-alpha.2 → 2.1.43

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

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

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