@budibase/server 1.0.49-alpha.6 → 1.0.49

package/src/api/routes/tests/routing.spec.js

@@ -1,15 +1,10 @@
 const setup = require("./utilities")
 const { basicScreen } = setup.structures
-const { checkBuilderEndpoint, runInProd } = require("./utilities/TestFunctions")
+const { checkBuilderEndpoint } = require("./utilities/TestFunctions")
 const { BUILTIN_ROLE_IDS } = require("@budibase/backend-core/roles")
-const { doInAppContext } = require("@budibase/backend-core/context")
 
 const route = "/test"
 
-// there are checks which are disabled in test env,
-// these checks need to be enabled for this test
-
-
 describe("/routing", () => {
   let request = setup.getRequest()
   let config = setup.getConfig()
@@ -31,24 +26,20 @@ describe("/routing", () => {
 
   describe("fetch", () => {
     it("prevents a public user from accessing development app", async () => {
-      await runInProd(() => {
-        return request
-          .get(`/api/routing/client`)
-          .set(config.publicHeaders({ prodApp: false }))
-          .expect(302)
-      })
+      await request
+        .get(`/api/routing/client`)
+        .set(config.publicHeaders({ prodApp: false }))
+        .expect(302)
     })
 
     it("prevents a non builder from accessing development app", async () => {
-      await runInProd(async () => {
-        return request
-          .get(`/api/routing/client`)
-          .set(await config.roleHeaders({
-            roleId: BUILTIN_ROLE_IDS.BASIC,
-            prodApp: false
-          }))
-          .expect(302)
-      })
+      await request
+        .get(`/api/routing/client`)
+        .set(await config.roleHeaders({
+          roleId: BUILTIN_ROLE_IDS.BASIC,
+          prodApp: false
+        }))
+        .expect(302)
     })
     it("returns the correct routing for basic user", async () => {
       const res = await request

package/src/api/routes/tests/row.spec.js

@@ -1,7 +1,6 @@
 const { outputProcessing } = require("../../../utilities/rowProcessor")
 const setup = require("./utilities")
 const { basicRow } = setup.structures
-const { doInAppContext } = require("@budibase/backend-core/context")
 
 // mock the fetch for the search system
 jest.mock("node-fetch")
@@ -388,12 +387,10 @@ describe("/rows", () => {
       })
       // the environment needs configured for this
       await setup.switchToSelfHosted(async () => {
-        doInAppContext(config.getAppId(), async () => {
-          const enriched = await outputProcessing(table, [row])
-          expect(enriched[0].attachment[0].url).toBe(
-            `/prod-budi-app-assets/${config.getAppId()}/attachments/test/thing.csv`
-          )
-        })
+        const enriched = await outputProcessing({ appId: config.getAppId() }, table, [row])
+        expect(enriched[0].attachment[0].url).toBe(
+          `/prod-budi-app-assets/${config.getAppId()}/attachments/test/thing.csv`
+        )
       })
     })
   })

package/src/api/routes/tests/utilities/TestFunctions.js

@@ -1,10 +1,9 @@
 const rowController = require("../../../controllers/row")
 const appController = require("../../../controllers/application")
+const CouchDB = require("../../../../db")
 const { AppStatus } = require("../../../../db/utils")
 const { BUILTIN_ROLE_IDS } = require("@budibase/backend-core/roles")
 const { TENANT_ID } = require("../../../../tests/utilities/structures")
-const { getAppDB, doInAppContext } = require("@budibase/backend-core/context")
-const env = require("../../../../environment")
 
 function Request(appId, params) {
   this.appId = appId
@@ -12,15 +11,9 @@ function Request(appId, params) {
   this.request = {}
 }
 
-function runRequest(appId, controlFunc, request) {
-  return doInAppContext(appId, async () => {
-    return controlFunc(request)
-  })
-}
-
 exports.getAllTableRows = async config => {
   const req = new Request(config.appId, { tableId: config.table._id })
-  await runRequest(config.appId, rowController.fetch, req)
+  await rowController.fetch(req)
   return req.body
 }
 
@@ -33,17 +26,14 @@ exports.clearAllApps = async (tenantId = TENANT_ID) => {
   }
   for (let app of apps) {
     const { appId } = app
-    const req = new Request(null, { appId })
-    await runRequest(appId, appController.delete, req)
+    await appController.delete(new Request(null, { appId }))
   }
 }
 
 exports.clearAllAutomations = async config => {
   const automations = await config.getAllAutomations()
   for (let auto of automations) {
-    await doInAppContext(config.appId, async () => {
-      await config.deleteAutomation(auto)
-    })
+    await config.deleteAutomation(auto)
   }
 }
 
@@ -106,32 +96,20 @@ exports.checkPermissionsEndpoint = async ({
     .expect(403)
 }
 
-exports.getDB = () => {
-  return getAppDB()
+exports.getDB = config => {
+  return new CouchDB(config.getAppId())
 }
 
 exports.testAutomation = async (config, automation) => {
-  return runRequest(automation.appId, async () => {
-    return await config.request
-      .post(`/api/automations/${automation._id}/test`)
-      .send({
-        row: {
-          name: "Test",
-          description: "TEST",
-        },
-      })
-      .set(config.defaultHeaders())
-      .expect("Content-Type", /json/)
-      .expect(200)
-  })
-}
-
-exports.runInProd = async func => {
-  const nodeEnv = env.NODE_ENV
-  const workerId = env.JEST_WORKER_ID
-  env._set("NODE_ENV", "PRODUCTION")
-  env._set("JEST_WORKER_ID", null)
-  await func()
-  env._set("NODE_ENV", nodeEnv)
-  env._set("JEST_WORKER_ID", workerId)
+  return await config.request
+    .post(`/api/automations/${automation._id}/test`)
+    .send({
+      row: {
+        name: "Test",
+        description: "TEST",
+      },
+    })
+    .set(config.defaultHeaders())
+    .expect("Content-Type", /json/)
+    .expect(200)
 }

package/src/app.ts

@@ -1,7 +1,7 @@
 // need to load environment first
 import { ExtendableContext } from "koa"
 
-import * as env from "./environment"
+const env = require("./environment")
 const CouchDB = require("./db")
 require("@budibase/backend-core").init(CouchDB)
 const Koa = require("koa")
@@ -16,7 +16,6 @@ const Sentry = require("@sentry/node")
 const fileSystem = require("./utilities/fileSystem")
 const bullboard = require("./automations/bullboard")
 const redis = require("./utilities/redis")
-import * as migrations from "./migrations"
 
 const app = new Koa()
 
@@ -85,25 +84,13 @@ module.exports = server.listen(env.PORT || 0, async () => {
   await automations.init()
 })
 
-const shutdown = () => {
-  server.close()
-  server.destroy()
-}
-
 process.on("uncaughtException", err => {
   console.error(err)
-  shutdown()
+  server.close()
+  server.destroy()
 })
 
 process.on("SIGTERM", () => {
-  shutdown()
+  server.close()
+  server.destroy()
 })
-
-// run migrations on startup if not done via http
-// not recommended in a clustered environment
-if (!env.HTTP_MIGRATIONS) {
-  migrations.migrate().catch(err => {
-    console.error("Error performing migrations. Exiting.\n", err)
-    shutdown()
-  })
-}

package/src/automations/automationUtils.js

@@ -53,12 +53,13 @@ exports.cleanInputValues = (inputs, schema) => {
  * the automation but is instead part of the Table/Table. This function will get the table schema and use it to instead
  * perform the cleanInputValues function on the input row.
  *
+ * @param {string} appId The instance which the Table/Table is contained under.
  * @param {string} tableId The ID of the Table/Table which the schema is to be retrieved for.
  * @param {object} row The input row structure which requires clean-up after having been through template statements.
  * @returns {Promise<Object>} The cleaned up rows object, will should now have all the required primitive types.
  */
-exports.cleanUpRow = async (tableId, row) => {
-  let table = await getTable(tableId)
+exports.cleanUpRow = async (appId, tableId, row) => {
+  let table = await getTable(appId, tableId)
   return exports.cleanInputValues(row, { properties: table.schema })
 }
 

package/src/automations/steps/createRow.js

@@ -1,5 +1,6 @@
 const rowController = require("../../api/controllers/row")
 const automationUtils = require("../automationUtils")
+const env = require("../../environment")
 const usage = require("../../utilities/usageQuota")
 const { buildCtx } = require("./utils")
 
@@ -78,12 +79,14 @@ exports.run = async function ({ inputs, appId, emitter }) {
 
   try {
     inputs.row = await automationUtils.cleanUpRow(
+      appId,
       inputs.row.tableId,
       inputs.row
     )
-    await usage.update(usage.Properties.ROW, 1, { dryRun: true })
+    if (env.USE_QUOTAS) {
+      await usage.update(usage.Properties.ROW, 1)
+    }
     await rowController.save(ctx)
-    await usage.update(usage.Properties.ROW, 1)
     return {
       row: inputs.row,
       response: ctx.body,

package/src/automations/steps/deleteRow.js

@@ -1,4 +1,5 @@
 const rowController = require("../../api/controllers/row")
+const env = require("../../environment")
 const usage = require("../../utilities/usageQuota")
 const { buildCtx } = require("./utils")
 const automationUtils = require("../automationUtils")
@@ -73,7 +74,9 @@ exports.run = async function ({ inputs, appId, emitter }) {
   })
 
   try {
-    await usage.update(usage.Properties.ROW, -1)
+    if (env.isProd()) {
+      await usage.update(usage.Properties.ROW, -1)
+    }
     await rowController.destroy(ctx)
     return {
       response: ctx.body,

package/src/automations/steps/updateRow.js

@@ -87,7 +87,7 @@ exports.run = async function ({ inputs, appId, emitter }) {
 
   try {
     if (tableId) {
-      inputs.row = await automationUtils.cleanUpRow(tableId, inputs.row)
+      inputs.row = await automationUtils.cleanUpRow(appId, tableId, inputs.row)
     }
     await rowController.patch(ctx)
     return {

package/src/automations/triggers.js

@@ -1,3 +1,4 @@
+const CouchDB = require("../db")
 const emitter = require("../events/index")
 const { getAutomationParams } = require("../db/utils")
 const { coerce } = require("../utilities/rowProcessor")
@@ -8,7 +9,6 @@ const { queue } = require("./bullboard")
 const { checkTestFlag } = require("../utilities/redis")
 const utils = require("./utils")
 const env = require("../environment")
-const { doInAppContext, getAppDB } = require("@budibase/backend-core/context")
 
 const TRIGGER_DEFINITIONS = definitions
 const JOB_OPTS = {
@@ -21,41 +21,39 @@ async function queueRelevantRowAutomations(event, eventType) {
     throw `No appId specified for ${eventType} - check event emitters.`
   }
 
-  doInAppContext(event.appId, async () => {
-    const db = getAppDB()
-    let automations = await db.allDocs(
-      getAutomationParams(null, { include_docs: true })
-    )
+  const db = new CouchDB(event.appId)
+  let automations = await db.allDocs(
+    getAutomationParams(null, { include_docs: true })
+  )
 
-    // filter down to the correct event type
-    automations = automations.rows
-      .map(automation => automation.doc)
-      .filter(automation => {
-        const trigger = automation.definition.trigger
-        return trigger && trigger.event === eventType
-      })
+  // filter down to the correct event type
+  automations = automations.rows
+    .map(automation => automation.doc)
+    .filter(automation => {
+      const trigger = automation.definition.trigger
+      return trigger && trigger.event === eventType
+    })
 
-    for (let automation of automations) {
-      let automationDef = automation.definition
-      let automationTrigger = automationDef ? automationDef.trigger : {}
-      // don't queue events which are for dev apps, only way to test automations is
-      // running tests on them, in production the test flag will never
-      // be checked due to lazy evaluation (first always false)
-      if (
-        !env.ALLOW_DEV_AUTOMATIONS &&
-        isDevAppID(event.appId) &&
-        !(await checkTestFlag(automation._id))
-      ) {
-        continue
-      }
-      if (
-        automationTrigger.inputs &&
-        automationTrigger.inputs.tableId === event.row.tableId
-      ) {
-        await queue.add({ automation, event }, JOB_OPTS)
-      }
+  for (let automation of automations) {
+    let automationDef = automation.definition
+    let automationTrigger = automationDef ? automationDef.trigger : {}
+    // don't queue events which are for dev apps, only way to test automations is
+    // running tests on them, in production the test flag will never
+    // be checked due to lazy evaluation (first always false)
+    if (
+      !env.ALLOW_DEV_AUTOMATIONS &&
+      isDevAppID(event.appId) &&
+      !(await checkTestFlag(automation._id))
+    ) {
+      continue
     }
-  })
+    if (
+      automationTrigger.inputs &&
+      automationTrigger.inputs.tableId === event.row.tableId
+    ) {
+      await queue.add({ automation, event }, JOB_OPTS)
+    }
+  }
 }
 
 emitter.on("row:save", async function (event) {

package/src/automations/utils.js

@@ -6,9 +6,8 @@ const { queue } = require("./bullboard")
 const newid = require("../db/newid")
 const { updateEntityMetadata } = require("../utilities")
 const { MetadataTypes } = require("../constants")
-const { getProdAppID } = require("@budibase/backend-core/db")
+const { getDeployedAppID } = require("@budibase/backend-core/db")
 const { cloneDeep } = require("lodash/fp")
-const { getAppDB, getAppId } = require("@budibase/backend-core/context")
 
 const WH_STEP_ID = definitions.WEBHOOK.stepId
 const CRON_STEP_ID = definitions.CRON.stepId
@@ -28,6 +27,7 @@ exports.processEvent = async job => {
 
 exports.updateTestHistory = async (appId, automation, history) => {
   return updateEntityMetadata(
+    appId,
     MetadataTypes.AUTOMATION_TEST_HISTORY,
     automation._id,
     metadata => {
@@ -93,9 +93,6 @@ exports.enableCronTrigger = async (appId, automation) => {
     )
     // Assign cron job ID from bull so we can remove it later if the cron trigger is removed
     trigger.cronJobId = job.id
-    // can't use getAppDB here as this is likely to be called from dev app,
-    // but this call could be for dev app or prod app, need to just use what
-    // was passed in
     const db = new CouchDB(appId)
     const response = await db.put(automation)
     automation._id = response.id
@@ -112,8 +109,7 @@ exports.enableCronTrigger = async (appId, automation) => {
  * @returns {Promise<object|undefined>} After this is complete the new automation object may have been updated and should be
  * written to DB (this does not write to DB as it would be wasteful to repeat).
  */
-exports.checkForWebhooks = async ({ oldAuto, newAuto }) => {
-  const appId = getAppId()
+exports.checkForWebhooks = async ({ appId, oldAuto, newAuto }) => {
   const oldTrigger = oldAuto ? oldAuto.definition.trigger : null
   const newTrigger = newAuto ? newAuto.definition.trigger : null
   const triggerChanged =
@@ -132,7 +128,7 @@ exports.checkForWebhooks = async ({ oldAuto, newAuto }) => {
     oldTrigger.webhookId
   ) {
     try {
-      let db = getAppDB()
+      let db = new CouchDB(appId)
       // need to get the webhook to get the rev
       const webhook = await db.get(oldTrigger.webhookId)
       const ctx = {
@@ -170,7 +166,7 @@ exports.checkForWebhooks = async ({ oldAuto, newAuto }) => {
     // the app ID has to be development for this endpoint
     // it can only be used when building the app
     // but the trigger endpoint will always be used in production
-    const prodAppId = getProdAppID(appId)
+    const prodAppId = getDeployedAppID(appId)
     newTrigger.inputs = {
       schemaUrl: `api/webhooks/schema/${appId}/${id}`,
       triggerUrl: `api/webhooks/trigger/${prodAppId}/${id}`,

package/src/constants/index.js

@@ -61,11 +61,6 @@ exports.RelationshipTypes = {
   MANY_TO_MANY: "many-to-many",
 }
 
-exports.FormulaTypes = {
-  STATIC: "static",
-  DYNAMIC: "dynamic",
-}
-
 exports.AuthTypes = {
   APP: "app",
   BUILDER: "builder",
@@ -83,10 +78,6 @@ exports.DataSourceOperation = {
   DELETE_TABLE: "DELETE_TABLE",
 }
 
-exports.DatasourceAuthTypes = {
-  GOOGLE: "google",
-}
-
 exports.SortDirection = {
   ASCENDING: "ASCENDING",
   DESCENDING: "DESCENDING",

package/src/db/linkedRows/LinkController.js

@@ -1,3 +1,4 @@
+const CouchDB = require("../index")
 const { IncludeDocs, getLinkDocuments } = require("./linkUtils")
 const {
   generateLinkID,
@@ -6,7 +7,6 @@ const {
 } = require("../utils")
 const Sentry = require("@sentry/node")
 const { FieldTypes, RelationshipTypes } = require("../../constants")
-const { getAppDB } = require("@budibase/backend-core/context")
 
 /**
  * Creates a new link document structure which can be put to the database. It is important to
@@ -52,8 +52,9 @@ function LinkDocument(
 }
 
 class LinkController {
-  constructor({ tableId, row, table, oldTable }) {
-    this._db = getAppDB()
+  constructor({ appId, tableId, row, table, oldTable }) {
+    this._appId = appId
+    this._db = new CouchDB(appId)
     this._tableId = tableId
     this._row = row
     this._table = table
@@ -98,6 +99,7 @@ class LinkController {
    */
   getRowLinkDocs(rowId) {
     return getLinkDocuments({
+      appId: this._appId,
       tableId: this._tableId,
       rowId,
       includeDocs: IncludeDocs.INCLUDE,
@@ -109,6 +111,7 @@ class LinkController {
    */
   getTableLinkDocs() {
     return getLinkDocuments({
+      appId: this._appId,
       tableId: this._tableId,
       includeDocs: IncludeDocs.INCLUDE,
     })
@@ -227,6 +230,7 @@ class LinkController {
           if (linkedSchema.relationshipType === RelationshipTypes.ONE_TO_MANY) {
             let links = (
               await getLinkDocuments({
+                appId: this._appId,
                 tableId: field.tableId,
                 rowId: linkId,
                 includeDocs: IncludeDocs.EXCLUDE,

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,13 +48,14 @@ function clearRelationshipFields(table, rows) {
   return rows
 }
 
-async function getLinksForRows(rows) {
+async function getLinksForRows(appId, 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,
         })
@@ -71,9 +72,9 @@ async function getLinksForRows(rows) {
   )
 }
 
-async function getFullLinkedDocs(links) {
+async function getFullLinkedDocs(ctx, appId, links) {
   // create DBs
-  const db = getAppDB()
+  const db = new CouchDB(appId)
   const linkedRowIds = links.map(link => link.id)
   const uniqueRowIds = [...new Set(linkedRowIds)]
   let dbRows = (await db.allDocs(getMultiIDParams(uniqueRowIds))).rows.map(
@@ -87,7 +88,7 @@ async function getFullLinkedDocs(links) {
   let [users, other] = partition(linked, linkRow =>
     linkRow._id.startsWith(USER_METDATA_PREFIX)
   )
-  users = await getGlobalUsersFromMetadata(users)
+  users = await getGlobalUsersFromMetadata(appId, users)
   return [...other, ...users]
 }
 
@@ -95,16 +96,20 @@ async function getFullLinkedDocs(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|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.
+ * @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.
  * @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, row, tableId, table, oldTable } = args
+  const { eventType, appId, 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
@@ -141,23 +146,27 @@ 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 (table, rows) => {
+exports.attachFullLinkedDocs = async (ctx, table, rows) => {
+  const appId = ctx.appId
   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(rows)).filter(link =>
+  const links = (await getLinksForRows(appId, 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(links)
+  let linked = await getFullLinkedDocs(ctx, appId, links)
   const linkedTables = []
   for (let row of rows) {
     for (let link of links.filter(link => link.thisId === row._id)) {
@@ -168,7 +177,11 @@ exports.attachFullLinkedDocs = async (table, rows) => {
       if (linkedRow) {
         const linkedTableId =
           linkedRow.tableId || getRelatedTableForField(table, link.fieldName)
-        const linkedTable = await getLinkedTable(linkedTableId, linkedTables)
+        const linkedTable = await getLinkedTable(
+          db,
+          linkedTableId,
+          linkedTables
+        )
         if (linkedTable) {
           row[link.fieldName].push(processFormulas(linkedTable, linkedRow))
         }
@@ -180,16 +193,18 @@ exports.attachFullLinkedDocs = async (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 (table, enriched) => {
+exports.squashLinksToPrimaryDisplay = async (appId, table, enriched) => {
+  const db = new CouchDB(appId)
   // 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(row.tableId, linkedTables)
+    const rowTable = await getLinkedTable(db, row.tableId, linkedTables)
     for (let [column, schema] of Object.entries(rowTable.schema)) {
       if (schema.type !== FieldTypes.LINK || !Array.isArray(row[column])) {
         continue
@@ -197,7 +212,7 @@ exports.squashLinksToPrimaryDisplay = async (table, enriched) => {
       const newLinks = []
       for (let link of row[column]) {
         const linkTblId = link.tableId || getRelatedTableForField(table, column)
-        const linkedTable = await getLinkedTable(linkTblId, linkedTables)
+        const linkedTable = await getLinkedTable(db, linkTblId, linkedTables)
         const obj = { _id: link._id }
         if (link[linkedTable.primaryDisplay]) {
           obj.primaryDisplay = link[linkedTable.primaryDisplay]