@budibase/server 2.1.30 → 2.1.32-alpha.0

package/src/threads/automation.ts

@@ -120,7 +120,7 @@ class Orchestrator {
   }
 
   async getMetadata(): Promise<AutomationMetadata> {
-    const metadataId = generateAutomationMetadataID(this._automation._id)
+    const metadataId = generateAutomationMetadataID(this._automation._id!)
     const db = getAppDB()
     let metadata: AutomationMetadata
     try {

package/src/utilities/global.ts

@@ -0,0 +1,138 @@
+import { getMultiIDParams, getGlobalIDFromUserMetadataID } from "../db/utils"
+import {
+  roles,
+  db as dbCore,
+  cache,
+  tenancy,
+  context,
+} from "@budibase/backend-core"
+import env from "../environment"
+import { groups } from "@budibase/pro"
+import { BBContext, ContextUser, User } from "@budibase/types"
+
+export function updateAppRole(
+  user: ContextUser,
+  { appId }: { appId?: string } = {}
+) {
+  appId = appId || context.getAppId()
+
+  if (!user || !user.roles) {
+    return user
+  }
+  // if in an multi-tenancy environment make sure roles are never updated
+  if (env.MULTI_TENANCY && appId && !tenancy.isUserInAppTenant(appId, user)) {
+    delete user.builder
+    delete user.admin
+    user.roleId = roles.BUILTIN_ROLE_IDS.PUBLIC
+    return user
+  }
+  // always use the deployed app
+  if (appId) {
+    user.roleId = user.roles[dbCore.getProdAppID(appId)]
+  }
+  // if a role wasn't found then either set as admin (builder) or public (everyone else)
+  if (!user.roleId && user.builder && user.builder.global) {
+    user.roleId = roles.BUILTIN_ROLE_IDS.ADMIN
+  } else if (!user.roleId && !user?.userGroups?.length) {
+    user.roleId = roles.BUILTIN_ROLE_IDS.PUBLIC
+  } else if (user?.userGroups?.length) {
+    user.roleId = undefined
+  }
+
+  delete user.roles
+  return user
+}
+
+async function checkGroupRoles(
+  user: ContextUser,
+  { appId }: { appId?: string } = {}
+) {
+  if (user.roleId && user.roleId !== roles.BUILTIN_ROLE_IDS.PUBLIC) {
+    return user
+  }
+  if (appId) {
+    user.roleId = await groups.getGroupRoleId(user as User, appId)
+  }
+  return user
+}
+
+async function processUser(
+  user: ContextUser,
+  { appId }: { appId?: string } = {}
+) {
+  if (user) {
+    delete user.password
+  }
+  user = await updateAppRole(user, { appId })
+  if (!user.roleId && user?.userGroups?.length) {
+    user = await checkGroupRoles(user, { appId })
+  }
+
+  return user
+}
+
+export async function getCachedSelf(ctx: BBContext, appId: string) {
+  // this has to be tenant aware, can't depend on the context to find it out
+  // running some middlewares before the tenancy causes context to break
+  const user = await cache.user.getUser(ctx.user?._id!)
+  return processUser(user, { appId })
+}
+
+export async function getRawGlobalUser(userId: string) {
+  const db = tenancy.getGlobalDB()
+  return db.get(getGlobalIDFromUserMetadataID(userId))
+}
+
+export async function getGlobalUser(userId: string) {
+  const appId = context.getAppId()
+  let user = await getRawGlobalUser(userId)
+  return processUser(user, { appId })
+}
+
+export async function getGlobalUsers(users?: ContextUser[]) {
+  const appId = context.getAppId()
+  const db = tenancy.getGlobalDB()
+  let globalUsers
+  if (users) {
+    const globalIds = users.map(user =>
+      getGlobalIDFromUserMetadataID(user._id!)
+    )
+    globalUsers = (await db.allDocs(getMultiIDParams(globalIds))).rows.map(
+      row => row.doc
+    )
+  } else {
+    globalUsers = (
+      await db.allDocs(
+        dbCore.getGlobalUserParams(null, {
+          include_docs: true,
+        })
+      )
+    ).rows.map(row => row.doc)
+  }
+  globalUsers = globalUsers
+    .filter(user => user != null)
+    .map(user => {
+      delete user.password
+      delete user.forceResetPassword
+      return user
+    })
+  if (!appId) {
+    return globalUsers
+  }
+
+  return globalUsers.map(user => updateAppRole(user))
+}
+
+export async function getGlobalUsersFromMetadata(users: ContextUser[]) {
+  const globalUsers = await getGlobalUsers(users)
+  return users.map(user => {
+    const globalUser = globalUsers.find(
+      globalUser => globalUser && user._id?.includes(globalUser._id)
+    )
+    return {
+      ...globalUser,
+      // doing user second overwrites the id and rev (always metadata)
+      ...user,
+    }
+  })
+}

package/src/utilities/security.js

@@ -1,6 +1,6 @@
 const {
-  PermissionLevels,
-  PermissionTypes,
+  PermissionLevel,
+  PermissionType,
   getBuiltinPermissionByID,
   isPermissionLevelHigherThanRead,
 } = require("@budibase/backend-core/permissions")
@@ -11,9 +11,9 @@ const {
 const { DocumentType } = require("../db/utils")
 
 const CURRENTLY_SUPPORTED_LEVELS = [
-  PermissionLevels.WRITE,
-  PermissionLevels.READ,
-  PermissionLevels.EXECUTE,
+  PermissionLevel.WRITE,
+  PermissionLevel.READ,
+  PermissionLevel.EXECUTE,
 ]
 
 exports.getPermissionType = resourceId => {
@@ -23,17 +23,17 @@ exports.getPermissionType = resourceId => {
   switch (docType) {
     case DocumentType.TABLE:
     case DocumentType.ROW:
-      return PermissionTypes.TABLE
+      return PermissionType.TABLE
     case DocumentType.AUTOMATION:
-      return PermissionTypes.AUTOMATION
+      return PermissionType.AUTOMATION
     case DocumentType.WEBHOOK:
-      return PermissionTypes.WEBHOOK
+      return PermissionType.WEBHOOK
     case DocumentType.QUERY:
     case DocumentType.DATASOURCE:
-      return PermissionTypes.QUERY
+      return PermissionType.QUERY
     default:
       // views don't have an ID, will end up here
-      return PermissionTypes.VIEW
+      return PermissionType.VIEW
   }
 }
 
@@ -58,8 +58,8 @@ exports.getBasePermissions = resourceId => {
       const level = typedPermission.level
       permissions[level] = lowerBuiltinRoleID(permissions[level], roleId)
       if (isPermissionLevelHigherThanRead(level)) {
-        permissions[PermissionLevels.READ] = lowerBuiltinRoleID(
-          permissions[PermissionLevels.READ],
+        permissions[PermissionLevel.READ] = lowerBuiltinRoleID(
+          permissions[PermissionLevel.READ],
           roleId
         )
       }

package/src/utilities/workerRequests.js

@@ -3,7 +3,7 @@ const env = require("../environment")
 const { checkSlashesInUrl } = require("./index")
 const { getProdAppID } = require("@budibase/backend-core/db")
 const { updateAppRole } = require("./global")
-const { Headers } = require("@budibase/backend-core/constants")
+const { Header } = require("@budibase/backend-core/constants")
 const { getTenantId, isTenantIdSet } = require("@budibase/backend-core/tenancy")
 
 function request(ctx, request) {
@@ -11,9 +11,9 @@ function request(ctx, request) {
     request.headers = {}
   }
   if (!ctx) {
-    request.headers[Headers.API_KEY] = env.INTERNAL_API_KEY
+    request.headers[Header.API_KEY] = env.INTERNAL_API_KEY
     if (isTenantIdSet()) {
-      request.headers[Headers.TENANT_ID] = getTenantId()
+      request.headers[Header.TENANT_ID] = getTenantId()
     }
   }
   if (request.body && Object.keys(request.body).length > 0) {

package/tsconfig.json

@@ -8,7 +8,8 @@
     "paths": {
       "@budibase/types": ["../types/src"],
       "@budibase/backend-core": ["../backend-core/src"],
-      "@budibase/backend-core/*": ["../backend-core/*"]
+      "@budibase/backend-core/*": ["../backend-core/*"],
+      "@budibase/pro": ["../../../budibase-pro/packages/pro/src"]
     }
   },
   "ts-node": {
@@ -17,6 +18,7 @@
   "references": [
     { "path": "../types" },
     { "path": "../backend-core" },
+    { "path": "../../../budibase-pro/packages/pro" }
   ],
   "include": [
     "src/**/*",

package/src/middleware/appInfo.js

@@ -1,19 +0,0 @@
-const { isDevAppID, isProdAppID } = require("../db/utils")
-
-exports.AppType = {
-  DEV: "dev",
-  PROD: "prod",
-}
-
-exports.middleware =
-  ({ appType } = {}) =>
-  (ctx, next) => {
-    const appId = ctx.appId
-    if (appType === exports.AppType.DEV && appId && !isDevAppID(appId)) {
-      ctx.throw(400, "Only apps in development support this endpoint")
-    }
-    if (appType === exports.AppType.PROD && appId && !isProdAppID(appId)) {
-      ctx.throw(400, "Only apps in production support this endpoint")
-    }
-    return next()
-  }

package/src/middleware/publicApi.js

@@ -1,21 +0,0 @@
-const { Headers } = require("@budibase/backend-core/constants")
-const { getAppIdFromCtx } = require("@budibase/backend-core/utils")
-
-module.exports = function ({ requiresAppId } = {}) {
-  return async (ctx, next) => {
-    const appId = await getAppIdFromCtx(ctx)
-    if (requiresAppId && !appId) {
-      ctx.throw(
-        400,
-        `Invalid app ID provided, please check the ${Headers.APP_ID} header.`
-      )
-    }
-    if (!ctx.headers[Headers.API_KEY]) {
-      ctx.throw(
-        400,
-        `Invalid API key provided, please check the ${Headers.API_KEY} header.`
-      )
-    }
-    return next()
-  }
-}

package/src/utilities/global.js

@@ -1,127 +0,0 @@
-const {
-  getMultiIDParams,
-  getGlobalIDFromUserMetadataID,
-} = require("../db/utils")
-const { BUILTIN_ROLE_IDS } = require("@budibase/backend-core/roles")
-const { getProdAppID } = require("@budibase/backend-core/db")
-const { getGlobalUserParams } = require("@budibase/backend-core/db")
-const { user: userCache } = require("@budibase/backend-core/cache")
-const {
-  getGlobalDB,
-  isUserInAppTenant,
-} = require("@budibase/backend-core/tenancy")
-const env = require("../environment")
-const { getAppId } = require("@budibase/backend-core/context")
-const { groups } = require("@budibase/pro")
-
-exports.updateAppRole = (user, { appId } = {}) => {
-  appId = appId || getAppId()
-
-  if (!user || !user.roles) {
-    return user
-  }
-  // if in an multi-tenancy environment make sure roles are never updated
-  if (env.MULTI_TENANCY && !isUserInAppTenant(appId, user)) {
-    delete user.builder
-    delete user.admin
-    user.roleId = BUILTIN_ROLE_IDS.PUBLIC
-    return user
-  }
-  // always use the deployed app
-  user.roleId = user.roles[getProdAppID(appId)]
-  // if a role wasn't found then either set as admin (builder) or public (everyone else)
-  if (!user.roleId && user.builder && user.builder.global) {
-    user.roleId = BUILTIN_ROLE_IDS.ADMIN
-  } else if (!user.roleId && !user?.userGroups?.length) {
-    user.roleId = BUILTIN_ROLE_IDS.PUBLIC
-  } else if (user?.userGroups?.length) {
-    user.roleId = null
-  }
-
-  delete user.roles
-  return user
-}
-
-async function checkGroupRoles(user, { appId } = {}) {
-  if (user.roleId && user.roleId !== BUILTIN_ROLE_IDS.PUBLIC) {
-    return user
-  }
-  user.roleId = await groups.getGroupRoleId(user, appId)
-  return user
-}
-
-async function processUser(user, { appId } = {}) {
-  if (user) {
-    delete user.password
-  }
-  user = await exports.updateAppRole(user, { appId })
-  if (!user.roleId && user?.userGroups?.length) {
-    user = await checkGroupRoles(user, { appId })
-  }
-
-  return user
-}
-
-exports.getCachedSelf = async (ctx, appId) => {
-  // this has to be tenant aware, can't depend on the context to find it out
-  // running some middlewares before the tenancy causes context to break
-  const user = await userCache.getUser(ctx.user._id)
-  return processUser(user, { appId })
-}
-
-exports.getRawGlobalUser = async userId => {
-  const db = getGlobalDB()
-  return db.get(getGlobalIDFromUserMetadataID(userId))
-}
-
-exports.getGlobalUser = async userId => {
-  const appId = getAppId()
-  let user = await exports.getRawGlobalUser(userId)
-  return processUser(user, { appId })
-}
-
-exports.getGlobalUsers = async (users = null) => {
-  const appId = getAppId()
-  const db = getGlobalDB()
-  let globalUsers
-  if (users) {
-    const globalIds = users.map(user => getGlobalIDFromUserMetadataID(user._id))
-    globalUsers = (await db.allDocs(getMultiIDParams(globalIds))).rows.map(
-      row => row.doc
-    )
-  } else {
-    globalUsers = (
-      await db.allDocs(
-        getGlobalUserParams(null, {
-          include_docs: true,
-        })
-      )
-    ).rows.map(row => row.doc)
-  }
-  globalUsers = globalUsers
-    .filter(user => user != null)
-    .map(user => {
-      delete user.password
-      delete user.forceResetPassword
-      return user
-    })
-  if (!appId) {
-    return globalUsers
-  }
-
-  return globalUsers.map(user => exports.updateAppRole(user))
-}
-
-exports.getGlobalUsersFromMetadata = async users => {
-  const globalUsers = await exports.getGlobalUsers(users)
-  return users.map(user => {
-    const globalUser = globalUsers.find(
-      globalUser => globalUser && user._id.includes(globalUser._id)
-    )
-    return {
-      ...globalUser,
-      // doing user second overwrites the id and rev (always metadata)
-      ...user,
-    }
-  })
-}