@budibase/server 2.1.32-alpha.5 → 2.1.32-alpha.7

package/src/api/controllers/deploy/{Deployment.js → Deployment.ts}

@@ -1,15 +1,20 @@
-const newid = require("../../../db/newid")
-const { getAppId } = require("@budibase/backend-core/context")
+import newid from "../../../db/newid"
+import { context } from "@budibase/backend-core"
 
 /**
  * This is used to pass around information about the deployment that is occurring
  */
-class Deployment {
+export default class Deployment {
+  _id: string
+  verification: any
+  status?: string
+  err?: any
+
   constructor(id = null) {
     this._id = id || newid()
   }
 
-  setVerification(verification) {
+  setVerification(verification: any) {
     if (!verification) {
       return
     }
@@ -20,14 +25,14 @@ class Deployment {
     return this.verification
   }
 
-  setStatus(status, err = null) {
+  setStatus(status: string, err?: any) {
     this.status = status
     if (err) {
       this.err = err
     }
   }
 
-  fromJSON(json) {
+  fromJSON(json: any) {
     if (json.verification) {
       this.setVerification(json.verification)
     }
@@ -37,9 +42,9 @@ class Deployment {
   }
 
   getJSON() {
-    const obj = {
+    const obj: any = {
       _id: this._id,
-      appId: getAppId(),
+      appId: context.getAppId(),
       status: this.status,
     }
     if (this.err) {
@@ -51,5 +56,3 @@ class Deployment {
     return obj
   }
 }
-
-module.exports = Deployment

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

@@ -1,10 +1,10 @@
-const { EMPTY_LAYOUT } = require("../../constants/layouts")
-const { generateLayoutID, getScreenParams } = require("../../db/utils")
-const { getAppDB } = require("@budibase/backend-core/context")
-const { events } = require("@budibase/backend-core")
+import { EMPTY_LAYOUT } from "../../constants/layouts"
+import { generateLayoutID, getScreenParams } from "../../db/utils"
+import { events, context } from "@budibase/backend-core"
+import { BBContext } from "@budibase/types"
 
-exports.save = async function (ctx) {
-  const db = getAppDB()
+export async function save(ctx: BBContext) {
+  const db = context.getAppDB()
   let layout = ctx.request.body
 
   if (!layout.props) {
@@ -24,8 +24,8 @@ exports.save = async function (ctx) {
   ctx.status = 200
 }
 
-exports.destroy = async function (ctx) {
-  const db = getAppDB()
+export async function destroy(ctx: BBContext) {
+  const db = context.getAppDB()
   const layoutId = ctx.params.layoutId,
     layoutRev = ctx.params.layoutRev
 

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

@@ -1,15 +1,16 @@
-const { MetadataTypes } = require("../../constants")
-const { generateMetadataID } = require("../../db/utils")
-const { saveEntityMetadata, deleteEntityMetadata } = require("../../utilities")
-const { getAppDB } = require("@budibase/backend-core/context")
+import { MetadataTypes } from "../../constants"
+import { generateMetadataID } from "../../db/utils"
+import { saveEntityMetadata, deleteEntityMetadata } from "../../utilities"
+import { context } from "@budibase/backend-core"
+import { BBContext } from "@budibase/types"
 
-exports.getTypes = async ctx => {
+export async function getTypes(ctx: BBContext) {
   ctx.body = {
     types: MetadataTypes,
   }
 }
 
-exports.saveMetadata = async ctx => {
+export async function saveMetadata(ctx: BBContext) {
   const { type, entityId } = ctx.params
   if (type === MetadataTypes.AUTOMATION_TEST_HISTORY) {
     ctx.throw(400, "Cannot save automation history type")
@@ -17,7 +18,7 @@ exports.saveMetadata = async ctx => {
   ctx.body = await saveEntityMetadata(type, entityId, ctx.request.body)
 }
 
-exports.deleteMetadata = async ctx => {
+export async function deleteMetadata(ctx: BBContext) {
   const { type, entityId } = ctx.params
   await deleteEntityMetadata(type, entityId)
   ctx.body = {
@@ -25,13 +26,13 @@ exports.deleteMetadata = async ctx => {
   }
 }
 
-exports.getMetadata = async ctx => {
+export async function getMetadata(ctx: BBContext) {
   const { type, entityId } = ctx.params
-  const db = getAppDB()
+  const db = context.getAppDB()
   const id = generateMetadataID(type, entityId)
   try {
     ctx.body = await db.get(id)
-  } catch (err) {
+  } catch (err: any) {
     if (err.status === 404) {
       ctx.body = {}
     } else {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -27,12 +27,8 @@ 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/utils"
-// @ts-ignore
-import { getAppDB } from "@budibase/backend-core/context"
+import { processFormulas, processDates } from "../../../utilities/rowProcessor"
+import { context } from "@budibase/backend-core"
 
 interface ManyRelationship {
   tableId?: string
@@ -444,7 +440,7 @@ module External {
       // Process some additional data types
       let finalRowArray = Object.values(finalRows)
       finalRowArray = processDates(table, finalRowArray)
-      finalRowArray = processFormulas(table, finalRowArray)
+      finalRowArray = processFormulas(table, finalRowArray) as Row[]
 
       return finalRowArray.map((row: Row) =>
         this.squashRelationshipColumns(table, row, relationships)
@@ -673,7 +669,7 @@ module External {
         throw "Unable to run without a table name"
       }
       if (!this.datasource) {
-        const db = getAppDB()
+        const db = context.getAppDB()
         this.datasource = await db.get(datasourceId)
         if (!this.datasource || !this.datasource.entities) {
           throw "No tables found, fetch tables before query."

package/src/api/controllers/row/external.js

@@ -9,7 +9,7 @@ const {
   breakRowIdField,
 } = require("../../../integrations/utils")
 const ExternalRequest = require("./ExternalRequest")
-const { getAppDB } = require("@budibase/backend-core/context")
+const { context } = require("@budibase/backend-core")
 const exporters = require("../view/exporters")
 const { apiFileReturn } = require("../../../utilities/fileSystem")
 
@@ -166,7 +166,7 @@ exports.validate = async () => {
 
 exports.exportRows = async ctx => {
   const { datasourceId } = breakExternalTableId(ctx.params.tableId)
-  const db = getAppDB()
+  const db = context.getAppDB()
   const format = ctx.query.format
   const { columns } = ctx.request.body
   const datasource = await db.get(datasourceId)
@@ -209,7 +209,7 @@ exports.fetchEnrichedRow = async ctx => {
   const id = ctx.params.rowId
   const tableId = ctx.params.tableId
   const { datasourceId, tableName } = breakExternalTableId(tableId)
-  const db = getAppDB()
+  const db = context.getAppDB()
   const datasource = await db.get(datasourceId)
   if (!datasource || !datasource.entities) {
     ctx.throw(400, "Datasource has not been configured for plus API.")