@budibase/server 2.1.22-alpha.6 → 2.1.22-alpha.7

package/src/sdk/app/backups/statistics.ts

@@ -1,13 +1,13 @@
 import { context, db as dbCore } from "@budibase/backend-core"
+import { Database } from "@budibase/types"
 import {
   getDatasourceParams,
   getTableParams,
   getAutomationParams,
   getScreenParams,
 } from "../../../db/utils"
-import PouchDB from "pouchdb"
 
-async function runInContext(appId: string, cb: any, db?: PouchDB.Database) {
+async function runInContext(appId: string, cb: any, db?: Database) {
   if (db) {
     return cb(db)
   } else {
@@ -19,13 +19,10 @@ async function runInContext(appId: string, cb: any, db?: PouchDB.Database) {
   }
 }
 
-export async function calculateDatasourceCount(
-  appId: string,
-  db?: PouchDB.Database
-) {
+export async function calculateDatasourceCount(appId: string, db?: Database) {
   return runInContext(
     appId,
-    async (db: PouchDB.Database) => {
+    async (db: Database) => {
       const datasourceList = await db.allDocs(getDatasourceParams())
       const tableList = await db.allDocs(getTableParams())
       return datasourceList.rows.length + tableList.rows.length
@@ -34,13 +31,10 @@ export async function calculateDatasourceCount(
   )
 }
 
-export async function calculateAutomationCount(
-  appId: string,
-  db?: PouchDB.Database
-) {
+export async function calculateAutomationCount(appId: string, db?: Database) {
   return runInContext(
     appId,
-    async (db: PouchDB.Database) => {
+    async (db: Database) => {
       const automationList = await db.allDocs(getAutomationParams())
       return automationList.rows.length
     },
@@ -48,13 +42,10 @@ export async function calculateAutomationCount(
   )
 }
 
-export async function calculateScreenCount(
-  appId: string,
-  db?: PouchDB.Database
-) {
+export async function calculateScreenCount(appId: string, db?: Database) {
   return runInContext(
     appId,
-    async (db: PouchDB.Database) => {
+    async (db: Database) => {
       const screenList = await db.allDocs(getScreenParams())
       return screenList.rows.length
     },
@@ -63,7 +54,7 @@ export async function calculateScreenCount(
 }
 
 export async function calculateBackupStats(appId: string) {
-  return runInContext(appId, async (db: PouchDB.Database) => {
+  return runInContext(appId, async (db: Database) => {
     const promises = []
     promises.push(calculateDatasourceCount(appId, db))
     promises.push(calculateAutomationCount(appId, db))

package/src/sdk/app/tables/index.ts

@@ -1,16 +1,15 @@
-import { getAppDB } from "@budibase/backend-core/context"
+import { context } from "@budibase/backend-core"
 import { BudibaseInternalDB, getTableParams } from "../../../db/utils"
 import {
   breakExternalTableId,
   isExternalTable,
   isSQL,
 } from "../../../integrations/utils"
-import { Table } from "@budibase/types"
-import PouchDB from "pouchdb"
+import { Table, Database } from "@budibase/types"
 
-async function getAllInternalTables(db?: PouchDB.Database): Promise<Table[]> {
+async function getAllInternalTables(db?: Database): Promise<Table[]> {
   if (!db) {
-    db = getAppDB() as PouchDB.Database
+    db = context.getAppDB()
   }
   const internalTables = await db.allDocs(
     getTableParams(null, {
@@ -25,7 +24,7 @@ async function getAllInternalTables(db?: PouchDB.Database): Promise<Table[]> {
 }
 
 async function getAllExternalTables(datasourceId: any): Promise<Table[]> {
-  const db = getAppDB()
+  const db = context.getAppDB()
   const datasource = await db.get(datasourceId)
   if (!datasource || !datasource.entities) {
     throw "Datasource is not configured fully."
@@ -42,7 +41,7 @@ async function getExternalTable(
 }
 
 async function getTable(tableId: any): Promise<Table> {
-  const db = getAppDB()
+  const db = context.getAppDB()
   if (isExternalTable(tableId)) {
     let { datasourceId, tableName } = breakExternalTableId(tableId)
     const datasource = await db.get(datasourceId)

package/src/tests/utilities/TestConfiguration.js

@@ -16,7 +16,7 @@ const {
 const controllers = require("./controllers")
 const supertest = require("supertest")
 const { cleanup } = require("../../utilities/fileSystem")
-const { Cookies, Headers } = require("@budibase/backend-core/constants")
+const { Cookie, Header } = require("@budibase/backend-core/constants")
 const { jwt } = require("@budibase/backend-core/auth")
 const { doInTenant, doWithGlobalDB } = require("@budibase/backend-core/tenancy")
 const { createASession } = require("@budibase/backend-core/sessions")
@@ -256,10 +256,10 @@ class TestConfiguration {
       return {
         Accept: "application/json",
         Cookie: [
-          `${Cookies.Auth}=${authToken}`,
-          `${Cookies.CurrentApp}=${appToken}`,
+          `${Cookie.Auth}=${authToken}`,
+          `${Cookie.CurrentApp}=${appToken}`,
         ],
-        [Headers.APP_ID]: appId,
+        [Header.APP_ID]: appId,
       }
     })
   }
@@ -279,14 +279,14 @@ class TestConfiguration {
     const headers = {
       Accept: "application/json",
       Cookie: [
-        `${Cookies.Auth}=${authToken}`,
-        `${Cookies.CurrentApp}=${appToken}`,
+        `${Cookie.Auth}=${authToken}`,
+        `${Cookie.CurrentApp}=${appToken}`,
       ],
-      [Headers.CSRF_TOKEN]: CSRF_TOKEN,
+      [Header.CSRF_TOKEN]: CSRF_TOKEN,
       ...extras,
     }
     if (this.appId) {
-      headers[Headers.APP_ID] = this.appId
+      headers[Header.APP_ID] = this.appId
     }
     return headers
   }
@@ -298,7 +298,7 @@ class TestConfiguration {
       Accept: "application/json",
     }
     if (appId) {
-      headers[Headers.APP_ID] = appId
+      headers[Header.APP_ID] = appId
     }
     return headers
   }

package/src/tests/utilities/structures.js

@@ -1,5 +1,5 @@
 const { BUILTIN_ROLE_IDS } = require("@budibase/backend-core/roles")
-const { BUILTIN_PERMISSION_IDS } = require("@budibase/backend-core/permissions")
+const { BuiltinPermissionID } = require("@budibase/backend-core/permissions")
 const { createHomeScreen } = require("../../constants/screens")
 const { EMPTY_LAYOUT } = require("../../constants/layouts")
 const { cloneDeep } = require("lodash/fp")
@@ -135,7 +135,7 @@ exports.basicRole = () => {
   return {
     name: "NewRole",
     inherits: BUILTIN_ROLE_IDS.BASIC,
-    permissionId: BUILTIN_PERMISSION_IDS.READ_ONLY,
+    permissionId: BuiltinPermissionID.READ_ONLY,
   }
 }
 

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