@budibase/server 2.1.32-alpha.8 → 2.1.32

package/src/api/controllers/{permission.ts → permission.js}

@@ -1,11 +1,18 @@
-import { permissions, roles, context } from "@budibase/backend-core"
-import { getRoleParams } from "../../db/utils"
-import {
+const { getBuiltinPermissions } = require("@budibase/backend-core/permissions")
+const {
+  isBuiltin,
+  getDBRoleID,
+  getExternalRoleID,
+  getBuiltinRoles,
+  checkForRoleResourceArray,
+} = require("@budibase/backend-core/roles")
+const { getRoleParams } = require("../../db/utils")
+const {
   CURRENTLY_SUPPORTED_LEVELS,
   getBasePermissions,
-} from "../../utilities/security"
-import { removeFromArray } from "../../utilities"
-import { BBContext, Database, Role } from "@budibase/types"
+} = require("../../utilities/security")
+const { removeFromArray } = require("../../utilities")
+const { getAppDB } = require("@budibase/backend-core/context")
 
 const PermissionUpdateType = {
   REMOVE: "remove",
@@ -15,7 +22,7 @@ const PermissionUpdateType = {
 const SUPPORTED_LEVELS = CURRENTLY_SUPPORTED_LEVELS
 
 // utility function to stop this repetition - permissions always stored under roles
-async function getAllDBRoles(db: Database) {
+async function getAllDBRoles(db) {
   const body = await db.allDocs(
     getRoleParams(null, {
       include_docs: true,
@@ -25,25 +32,21 @@ async function getAllDBRoles(db: Database) {
 }
 
 async function updatePermissionOnRole(
-  appId: string,
-  {
-    roleId,
-    resourceId,
-    level,
-  }: { roleId: string; resourceId: string; level: string },
-  updateType: string
+  appId,
+  { roleId, resourceId, level },
+  updateType
 ) {
-  const db = context.getAppDB()
+  const db = getAppDB()
   const remove = updateType === PermissionUpdateType.REMOVE
-  const isABuiltin = roles.isBuiltin(roleId)
-  const dbRoleId = roles.getDBRoleID(roleId)
+  const isABuiltin = isBuiltin(roleId)
+  const dbRoleId = getDBRoleID(roleId)
   const dbRoles = await getAllDBRoles(db)
   const docUpdates = []
 
   // the permission is for a built in, make sure it exists
   if (isABuiltin && !dbRoles.some(role => role._id === dbRoleId)) {
-    const builtin = roles.getBuiltinRoles()[roleId]
-    builtin._id = roles.getDBRoleID(builtin._id)
+    const builtin = getBuiltinRoles()[roleId]
+    builtin._id = getDBRoleID(builtin._id)
     dbRoles.push(builtin)
   }
 
@@ -87,44 +90,41 @@ async function updatePermissionOnRole(
   }
 
   const response = await db.bulkDocs(docUpdates)
-  return response.map((resp: any) => {
-    resp._id = roles.getExternalRoleID(resp.id)
+  return response.map(resp => {
+    resp._id = getExternalRoleID(resp.id)
     delete resp.id
     return resp
   })
 }
 
-export function fetchBuiltin(ctx: BBContext) {
-  ctx.body = Object.values(permissions.getBuiltinPermissions())
+exports.fetchBuiltin = function (ctx) {
+  ctx.body = Object.values(getBuiltinPermissions())
 }
 
-export function fetchLevels(ctx: BBContext) {
+exports.fetchLevels = function (ctx) {
   // for now only provide the read/write perms externally
   ctx.body = SUPPORTED_LEVELS
 }
 
-export async function fetch(ctx: BBContext) {
-  const db = context.getAppDB()
-  const dbRoles: Role[] = await getAllDBRoles(db)
-  let permissions: any = {}
+exports.fetch = async function (ctx) {
+  const db = getAppDB()
+  const roles = await getAllDBRoles(db)
+  let permissions = {}
   // create an object with structure role ID -> resource ID -> level
-  for (let role of dbRoles) {
+  for (let role of roles) {
     if (!role.permissions) {
       continue
     }
-    const roleId = roles.getExternalRoleID(role._id)
-    if (!roleId) {
-      ctx.throw(400, "Unable to retrieve role")
-    }
+    const roleId = getExternalRoleID(role._id)
     for (let [resource, levelArr] of Object.entries(role.permissions)) {
-      const levels: string[] = Array.isArray(levelArr) ? levelArr : [levelArr]
-      const perms: Record<string, string> = {}
-      levels.forEach(level => (perms[level] = roleId!))
+      const levels = Array.isArray(levelArr) ? [levelArr] : levelArr
+      const perms = {}
+      levels.forEach(level => (perms[level] = roleId))
       permissions[resource] = perms
     }
   }
   // apply the base permissions
-  const finalPermissions: Record<string, Record<string, string>> = {}
+  const finalPermissions = {}
   for (let [resource, permission] of Object.entries(permissions)) {
     const basePerms = getBasePermissions(resource)
     finalPermissions[resource] = Object.assign(basePerms, permission)
@@ -132,36 +132,33 @@ export async function fetch(ctx: BBContext) {
   ctx.body = finalPermissions
 }
 
-export async function getResourcePerms(ctx: BBContext) {
+exports.getResourcePerms = async function (ctx) {
   const resourceId = ctx.params.resourceId
-  const db = context.getAppDB()
+  const db = getAppDB()
   const body = await db.allDocs(
     getRoleParams(null, {
       include_docs: true,
     })
   )
-  const rolesList = body.rows.map(row => row.doc)
-  let permissions: Record<string, string> = {}
+  const roles = body.rows.map(row => row.doc)
+  let permissions = {}
   for (let level of SUPPORTED_LEVELS) {
     // update the various roleIds in the resource permissions
-    for (let role of rolesList) {
-      const rolePerms = roles.checkForRoleResourceArray(
-        role.permissions,
-        resourceId
-      )
+    for (let role of roles) {
+      const rolePerms = checkForRoleResourceArray(role.permissions, resourceId)
       if (
         rolePerms &&
         rolePerms[resourceId] &&
         rolePerms[resourceId].indexOf(level) !== -1
       ) {
-        permissions[level] = roles.getExternalRoleID(role._id)!
+        permissions[level] = getExternalRoleID(role._id)
       }
     }
   }
   ctx.body = Object.assign(getBasePermissions(resourceId), permissions)
 }
 
-export async function addPermission(ctx: BBContext) {
+exports.addPermission = async function (ctx) {
   ctx.body = await updatePermissionOnRole(
     ctx.appId,
     ctx.params,
@@ -169,7 +166,7 @@ export async function addPermission(ctx: BBContext) {
   )
 }
 
-export async function removePermission(ctx: BBContext) {
+exports.removePermission = async function (ctx) {
   ctx.body = await updatePermissionOnRole(
     ctx.appId,
     ctx.params,

package/src/api/controllers/plugin/index.ts

@@ -1,5 +1,6 @@
 import { npmUpload, urlUpload, githubUpload, fileUpload } from "./uploaders"
-import { plugins as pluginCore, tenancy } from "@budibase/backend-core"
+import { getGlobalDB } from "@budibase/backend-core/tenancy"
+import { validate } from "@budibase/backend-core/plugins"
 import { PluginType, FileType, PluginSource } from "@budibase/types"
 import env from "../../../environment"
 import { ClientAppSocket } from "../../../websocket"
@@ -7,7 +8,7 @@ import { db as dbCore } from "@budibase/backend-core"
 import { plugins } from "@budibase/pro"
 
 export async function getPlugins(type?: PluginType) {
-  const db = tenancy.getGlobalDB()
+  const db = getGlobalDB()
   const response = await db.allDocs(
     dbCore.getPluginParams(null, {
       include_docs: true,
@@ -75,7 +76,7 @@ export async function create(ctx: any) {
         break
     }
 
-    pluginCore.validate(metadata?.schema)
+    validate(metadata?.schema)
 
     // Only allow components in cloud
     if (!env.SELF_HOSTED && metadata?.schema?.type !== PluginType.COMPONENT) {
@@ -120,7 +121,7 @@ export async function processUploadedPlugin(
   source?: PluginSource
 ) {
   const { metadata, directory } = await fileUpload(plugin)
-  pluginCore.validate(metadata?.schema)
+  validate(metadata?.schema)
 
   // Only allow components in cloud
   if (!env.SELF_HOSTED && metadata?.schema?.type !== PluginType.COMPONENT) {

package/src/api/controllers/public/applications.ts

@@ -1,4 +1,5 @@
-import { db as dbCore, context } from "@budibase/backend-core"
+const { getAllApps } = require("@budibase/backend-core/db")
+const { doInAppContext } = require("@budibase/backend-core/context")
 import { search as stringSearch, addRev } from "./utils"
 import * as controller from "../application"
 import { Application } from "../../../definitions/common"
@@ -14,22 +15,15 @@ function fixAppID(app: Application, params: any) {
 }
 
 async function setResponseApp(ctx: any) {
-  const appId = ctx.body?.appId
-  if (appId && (!ctx.params || !ctx.params.appId)) {
-    ctx.params = { appId }
-  }
-  if (appId) {
-    await context.doInContext(appId, () => {
-      return controller.fetchAppPackage(ctx)
-    })
-  } else {
-    return controller.fetchAppPackage(ctx)
+  if (ctx.body && ctx.body.appId && (!ctx.params || !ctx.params.appId)) {
+    ctx.params = { appId: ctx.body.appId }
   }
+  await controller.fetchAppPackage(ctx)
 }
 
 export async function search(ctx: any, next: any) {
   const { name } = ctx.request.body
-  const apps = await dbCore.getAllApps({ all: true })
+  const apps = await getAllApps({ all: true })
   ctx.body = stringSearch(apps, name)
   await next()
 }
@@ -47,7 +41,7 @@ export async function create(ctx: any, next: any) {
 }
 
 export async function read(ctx: any, next: any) {
-  await context.doInAppContext(ctx.params.appId, async () => {
+  await doInAppContext(ctx.params.appId, async () => {
     await setResponseApp(ctx)
     await next()
   })
@@ -55,7 +49,7 @@ export async function read(ctx: any, next: any) {
 
 export async function update(ctx: any, next: any) {
   ctx.request.body = await addRev(fixAppID(ctx.request.body, ctx.params))
-  await context.doInAppContext(ctx.params.appId, async () => {
+  await doInAppContext(ctx.params.appId, async () => {
     await controller.update(ctx)
     await setResponseApp(ctx)
     await next()
@@ -63,7 +57,7 @@ export async function update(ctx: any, next: any) {
 }
 
 export async function destroy(ctx: any, next: any) {
-  await context.doInAppContext(ctx.params.appId, async () => {
+  await doInAppContext(ctx.params.appId, async () => {
     // get the app before deleting it
     await setResponseApp(ctx)
     const body = ctx.body

package/src/api/controllers/public/tables.ts

@@ -1,6 +1,6 @@
 import { search as stringSearch, addRev } from "./utils"
-import * as controller from "../table"
-import { Table } from "@budibase/types"
+import { default as controller } from "../table"
+import { Table } from "../../../definitions/common"
 
 function fixTable(table: Table, params: any) {
   if (!params || !table) {

package/src/api/controllers/query/import/index.ts

@@ -5,7 +5,8 @@ import { OpenAPI2 } from "./sources/openapi2"
 import { OpenAPI3 } from "./sources/openapi3"
 import { Curl } from "./sources/curl"
 // @ts-ignore
-import { events, context } from "@budibase/backend-core"
+import { getAppDB } from "@budibase/backend-core/context"
+import { events } from "@budibase/backend-core"
 import { Datasource, Query } from "@budibase/types"
 
 interface ImportResult {
@@ -58,7 +59,7 @@ export class RestImporter {
       })
 
     // persist queries
-    const db = context.getAppDB()
+    const db = getAppDB()
     const response = await db.bulkDocs(queries)
 
     // create index to seperate queries and errors

package/src/api/controllers/query/index.ts

@@ -5,8 +5,11 @@ import { save as saveDatasource } from "../datasource"
 import { RestImporter } from "./import"
 import { invalidateDynamicVariables } from "../../../threads/utils"
 import { QUERY_THREAD_TIMEOUT } from "../../../environment"
+import { getAppDB } from "@budibase/backend-core/context"
 import { quotas } from "@budibase/pro"
-import { events, context, utils, constants } from "@budibase/backend-core"
+import { events } from "@budibase/backend-core"
+import { getCookie } from "@budibase/backend-core/utils"
+import { Cookies, Configs } from "@budibase/backend-core/constants"
 
 const Runner = new Thread(ThreadType.QUERY, {
   timeoutMs: QUERY_THREAD_TIMEOUT || 10000,
@@ -25,7 +28,7 @@ function enrichQueries(input: any) {
 }
 
 export async function fetch(ctx: any) {
-  const db = context.getAppDB()
+  const db = getAppDB()
 
   const body = await db.allDocs(
     getQueryParams(null, {
@@ -78,7 +81,7 @@ const _import = async (ctx: any) => {
 export { _import as import }
 
 export async function save(ctx: any) {
-  const db = context.getAppDB()
+  const db = getAppDB()
   const query = ctx.request.body
 
   const datasource = await db.get(query.datasourceId)
@@ -100,7 +103,7 @@ export async function save(ctx: any) {
 }
 
 export async function find(ctx: any) {
-  const db = context.getAppDB()
+  const db = getAppDB()
   const query = enrichQueries(await db.get(ctx.params.queryId))
   // remove properties that could be dangerous in real app
   if (isProdAppID(ctx.appId)) {
@@ -112,13 +115,13 @@ export async function find(ctx: any) {
 
 //Required to discern between OIDC OAuth config entries
 function getOAuthConfigCookieId(ctx: any) {
-  if (ctx.user.providerType === constants.Config.OIDC) {
-    return utils.getCookie(ctx, constants.Cookie.OIDC_CONFIG)
+  if (ctx.user.providerType === Configs.OIDC) {
+    return getCookie(ctx, Cookies.OIDC_CONFIG)
   }
 }
 
 function getAuthConfig(ctx: any) {
-  const authCookie = utils.getCookie(ctx, constants.Cookie.Auth)
+  const authCookie = getCookie(ctx, Cookies.Auth)
   let authConfigCtx: any = {}
   authConfigCtx["configId"] = getOAuthConfigCookieId(ctx)
   authConfigCtx["sessionId"] = authCookie ? authCookie.sessionId : null
@@ -126,7 +129,7 @@ function getAuthConfig(ctx: any) {
 }
 
 export async function preview(ctx: any) {
-  const db = context.getAppDB()
+  const db = getAppDB()
 
   const datasource = await db.get(ctx.request.body.datasourceId)
   const query = ctx.request.body
@@ -198,7 +201,7 @@ async function execute(
   ctx: any,
   opts: any = { rowsOnly: false, isAutomation: false }
 ) {
-  const db = context.getAppDB()
+  const db = getAppDB()
 
   const query = await db.get(ctx.params.queryId)
   const datasource = await db.get(query.datasourceId)
@@ -264,7 +267,7 @@ export async function executeV2(
 }
 
 const removeDynamicVariables = async (queryId: any) => {
-  const db = context.getAppDB()
+  const db = getAppDB()
   const query = await db.get(queryId)
   const datasource = await db.get(query.datasourceId)
   const dynamicVariables = datasource.config.dynamicVariables
@@ -285,7 +288,7 @@ const removeDynamicVariables = async (queryId: any) => {
 }
 
 export async function destroy(ctx: any) {
-  const db = context.getAppDB()
+  const db = getAppDB()
   const queryId = ctx.params.queryId
   await removeDynamicVariables(queryId)
   const query = await db.get(queryId)

package/src/api/controllers/query/{validation.ts → validation.js}

@@ -1,9 +1,9 @@
-import { auth } from "@budibase/backend-core"
-import Joi from "joi"
+const { joiValidator } = require("@budibase/backend-core/auth")
+const Joi = require("joi")
 
 const OPTIONAL_STRING = Joi.string().optional().allow(null).allow("")
 
-export function queryValidation() {
+exports.queryValidation = () => {
   return Joi.object({
     _id: Joi.string(),
     _rev: Joi.string(),
@@ -25,14 +25,14 @@ export function queryValidation() {
   }).unknown(true)
 }
 
-export function generateQueryValidation() {
+exports.generateQueryValidation = () => {
   // prettier-ignore
-  return auth.joiValidator.body(queryValidation())
+  return joiValidator.body(exports.queryValidation())
 }
 
-export function generateQueryPreviewValidation() {
+exports.generateQueryPreviewValidation = () => {
   // prettier-ignore
-  return auth.joiValidator.body(Joi.object({
+  return joiValidator.body(Joi.object({
     _id: OPTIONAL_STRING,
     _rev: OPTIONAL_STRING,
     readable: Joi.boolean().optional(),

package/src/api/controllers/{role.ts → role.js}

@@ -1,21 +1,23 @@
-import { roles, context, events } from "@budibase/backend-core"
-import {
+const {
+  Role,
+  getRole,
+  isBuiltin,
+  getAllRoles,
+} = require("@budibase/backend-core/roles")
+const {
   generateRoleID,
   getUserMetadataParams,
   InternalTables,
-} from "../../db/utils"
-import { BBContext, Database } from "@budibase/types"
+} = require("../../db/utils")
+const { getAppDB } = require("@budibase/backend-core/context")
+const { events } = require("@budibase/backend-core")
 
 const UpdateRolesOptions = {
   CREATED: "created",
   REMOVED: "removed",
 }
 
-async function updateRolesOnUserTable(
-  db: Database,
-  roleId: string,
-  updateOption: string
-) {
+async function updateRolesOnUserTable(db, roleId, updateOption) {
   const table = await db.get(InternalTables.USER_METADATA)
   const schema = table.schema
   const remove = updateOption === UpdateRolesOptions.REMOVED
@@ -38,25 +40,27 @@ async function updateRolesOnUserTable(
   }
 }
 
-export async function fetch(ctx: BBContext) {
-  ctx.body = await roles.getAllRoles()
+exports.fetch = async function (ctx) {
+  ctx.body = await getAllRoles()
 }
 
-export async function find(ctx: BBContext) {
-  ctx.body = await roles.getRole(ctx.params.roleId)
+exports.find = async function (ctx) {
+  ctx.body = await getRole(ctx.params.roleId)
 }
 
-export async function save(ctx: BBContext) {
-  const db = context.getAppDB()
+exports.save = async function (ctx) {
+  const db = getAppDB()
   let { _id, name, inherits, permissionId } = ctx.request.body
   let isCreate = false
   if (!_id) {
     _id = generateRoleID()
     isCreate = true
-  } else if (roles.isBuiltin(_id)) {
+  } else if (isBuiltin(_id)) {
     ctx.throw(400, "Cannot update builtin roles.")
   }
-  const role = new roles.Role(_id, name, permissionId).addInheritance(inherits)
+  const role = new Role(_id, name)
+    .addPermission(permissionId)
+    .addInheritance(inherits)
   if (ctx.request.body._rev) {
     role._rev = ctx.request.body._rev
   }
@@ -72,17 +76,17 @@ export async function save(ctx: BBContext) {
   ctx.message = `Role '${role.name}' created successfully.`
 }
 
-export async function destroy(ctx: BBContext) {
-  const db = context.getAppDB()
+exports.destroy = async function (ctx) {
+  const db = getAppDB()
   const roleId = ctx.params.roleId
   const role = await db.get(roleId)
-  if (roles.isBuiltin(roleId)) {
+  if (isBuiltin(roleId)) {
     ctx.throw(400, "Cannot delete builtin role.")
   }
   // first check no users actively attached to role
   const users = (
     await db.allDocs(
-      getUserMetadataParams(undefined, {
+      getUserMetadataParams(null, {
         include_docs: true,
       })
     )

package/src/api/controllers/{routing.ts → routing.js}

@@ -1,41 +1,40 @@
-import { getRoutingInfo } from "../../utilities/routing"
-import { roles } from "@budibase/backend-core"
-import { BBContext } from "@budibase/types"
+const { getRoutingInfo } = require("../../utilities/routing")
+const {
+  getUserRoleHierarchy,
+  BUILTIN_ROLE_IDS,
+} = require("@budibase/backend-core/roles")
 
 const URL_SEPARATOR = "/"
 
-class Routing {
-  json: any
-  constructor() {
-    this.json = {}
-  }
+function Routing() {
+  this.json = {}
+}
 
-  getTopLevel(fullpath: string) {
-    if (fullpath.charAt(0) !== URL_SEPARATOR) {
-      fullpath = URL_SEPARATOR + fullpath
-    }
-    // replace the first value with the home route
-    return URL_SEPARATOR + fullpath.split(URL_SEPARATOR)[1]
+Routing.prototype.getTopLevel = function (fullpath) {
+  if (fullpath.charAt(0) !== URL_SEPARATOR) {
+    fullpath = URL_SEPARATOR + fullpath
   }
+  // replace the first value with the home route
+  return URL_SEPARATOR + fullpath.split(URL_SEPARATOR)[1]
+}
 
-  getScreensProp(fullpath: string) {
-    const topLevel = this.getTopLevel(fullpath)
-    if (!this.json[topLevel]) {
-      this.json[topLevel] = {
-        subpaths: {},
-      }
+Routing.prototype.getScreensProp = function (fullpath) {
+  const topLevel = this.getTopLevel(fullpath)
+  if (!this.json[topLevel]) {
+    this.json[topLevel] = {
+      subpaths: {},
     }
-    if (!this.json[topLevel].subpaths[fullpath]) {
-      this.json[topLevel].subpaths[fullpath] = {
-        screens: {},
-      }
+  }
+  if (!this.json[topLevel].subpaths[fullpath]) {
+    this.json[topLevel].subpaths[fullpath] = {
+      screens: {},
     }
-    return this.json[topLevel].subpaths[fullpath].screens
   }
+  return this.json[topLevel].subpaths[fullpath].screens
+}
 
-  addScreenId(fullpath: string, roleId: string, screenId: string) {
-    this.getScreensProp(fullpath)[roleId] = screenId
-  }
+Routing.prototype.addScreenId = function (fullpath, roleId, screenId) {
+  this.getScreensProp(fullpath)[roleId] = screenId
 }
 
 /**
@@ -56,28 +55,26 @@ async function getRoutingStructure() {
   return { routes: routing.json }
 }
 
-export async function fetch(ctx: BBContext) {
+exports.fetch = async ctx => {
   ctx.body = await getRoutingStructure()
 }
 
-export async function clientFetch(ctx: BBContext) {
+exports.clientFetch = async ctx => {
   const routing = await getRoutingStructure()
-  let roleId = ctx.user?.role?._id
-  const roleIds = (await roles.getUserRoleHierarchy(roleId, {
-    idOnly: true,
-  })) as string[]
-  for (let topLevel of Object.values(routing.routes) as any) {
+  let roleId = ctx.user.role._id
+  const roleIds = await getUserRoleHierarchy(roleId)
+  for (let topLevel of Object.values(routing.routes)) {
     for (let subpathKey of Object.keys(topLevel.subpaths)) {
       let found = false
       const subpath = topLevel.subpaths[subpathKey]
       const roleOptions = Object.keys(subpath.screens)
       if (roleOptions.length === 1 && !roleOptions[0]) {
         subpath.screenId = subpath.screens[roleOptions[0]]
-        subpath.roleId = roles.BUILTIN_ROLE_IDS.BASIC
+        subpath.roleId = BUILTIN_ROLE_IDS.BASIC
         found = true
       } else {
         for (let roleId of roleIds) {
-          if (roleId && roleOptions.indexOf(roleId) !== -1) {
+          if (roleOptions.indexOf(roleId) !== -1) {
             subpath.screenId = subpath.screens[roleId]
             subpath.roleId = roleId
             found = true

package/src/api/controllers/row/ExternalRequest.ts

@@ -27,8 +27,12 @@ import { breakExternalTableId, isSQL } from "../../../integrations/utils"
 import { processObjectSync } from "@budibase/string-templates"
 // @ts-ignore
 import { cloneDeep } from "lodash/fp"
-import { processFormulas, processDates } from "../../../utilities/rowProcessor"
-import { context } from "@budibase/backend-core"
+import {
+  processFormulas,
+  processDates,
+} from "../../../utilities/rowProcessor/utils"
+// @ts-ignore
+import { getAppDB } from "@budibase/backend-core/context"
 
 interface ManyRelationship {
   tableId?: string
@@ -278,11 +282,9 @@ module External {
         const linkTablePrimary = linkTable.primary[0]
         // one to many
         if (isOneSide(field)) {
-          let id = row[key][0]
-          if (typeof row[key] === "string") {
-            id = decodeURIComponent(row[key]).match(/\[(.*?)\]/)?.[1]
-          }
-          newRow[field.foreignKey || linkTablePrimary] = breakRowIdField(id)[0]
+          newRow[field.foreignKey || linkTablePrimary] = breakRowIdField(
+            row[key][0]
+          )[0]
         }
         // many to many
         else if (field.through) {
@@ -440,7 +442,7 @@ module External {
       // Process some additional data types
       let finalRowArray = Object.values(finalRows)
       finalRowArray = processDates(table, finalRowArray)
-      finalRowArray = processFormulas(table, finalRowArray) as Row[]
+      finalRowArray = processFormulas(table, finalRowArray)
 
       return finalRowArray.map((row: Row) =>
         this.squashRelationshipColumns(table, row, relationships)
@@ -669,7 +671,7 @@ module External {
         throw "Unable to run without a table name"
       }
       if (!this.datasource) {
-        const db = context.getAppDB()
+        const db = getAppDB()
         this.datasource = await db.get(datasourceId)
         if (!this.datasource || !this.datasource.entities) {
           throw "No tables found, fetch tables before query."