@budibase/server 2.1.40-alpha.5 → 2.1.41

package/src/middleware/appInfo.ts

@@ -1,20 +0,0 @@
-import { isDevAppID, isProdAppID } from "../db/utils"
-import { BBContext } from "@budibase/types"
-
-export enum AppType {
-  DEV = "dev",
-  PROD = "prod",
-}
-
-export function middleware({ appType }: { appType?: AppType } = {}) {
-  return (ctx: BBContext, next: any) => {
-    const appId = ctx.appId
-    if (appType === AppType.DEV && appId && !isDevAppID(appId)) {
-      ctx.throw(400, "Only apps in development support this endpoint")
-    }
-    if (appType === AppType.PROD && appId && !isProdAppID(appId)) {
-      ctx.throw(400, "Only apps in production support this endpoint")
-    }
-    return next()
-  }
-}

package/src/middleware/publicApi.ts

@@ -1,21 +0,0 @@
-import { constants, utils } from "@budibase/backend-core"
-import { BBContext } from "@budibase/types"
-
-export = function ({ requiresAppId }: { requiresAppId?: boolean } = {}) {
-  return async (ctx: BBContext, next: any) => {
-    const appId = await utils.getAppIdFromCtx(ctx)
-    if (requiresAppId && !appId) {
-      ctx.throw(
-        400,
-        `Invalid app ID provided, please check the ${constants.Header.APP_ID} header.`
-      )
-    }
-    if (!ctx.headers[constants.Header.API_KEY]) {
-      ctx.throw(
-        400,
-        `Invalid API key provided, please check the ${constants.Header.API_KEY} header.`
-      )
-    }
-    return next()
-  }
-}

package/src/tests/utilities/controllers.ts

@@ -1,14 +0,0 @@
-export * as table from "../../api/controllers/table"
-export * as row from "../../api/controllers/row"
-export * as role from "../../api/controllers/role"
-export * as perms from "../../api/controllers/permission"
-export * as view from "../../api/controllers/view"
-export * as app from "../../api/controllers/application"
-export * as user from "../../api/controllers/user"
-export * as automation from "../../api/controllers/automation"
-export * as datasource from "../../api/controllers/datasource"
-export * as query from "../../api/controllers/query"
-export * as screen from "../../api/controllers/screen"
-export * as webhook from "../../api/controllers/webhook"
-export * as layout from "../../api/controllers/layout"
-export * as deploy from "../../api/controllers/deploy"

package/src/utilities/budibaseDir.ts

@@ -1,3 +0,0 @@
-import { objectStore } from "@budibase/backend-core"
-
-export const budibaseTempDir = objectStore.budibaseTempDir

package/src/utilities/global.ts

@@ -1,138 +0,0 @@
-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/routing/index.ts

@@ -1,32 +0,0 @@
-import { createRoutingView } from "../../db/views/staticViews"
-import { ViewName, getQueryIndex, UNICODE_MAX } from "../../db/utils"
-import { context } from "@budibase/backend-core"
-import { ScreenRouting } from "@budibase/types"
-
-type ScreenRoutesView = {
-  id: string
-  routing: ScreenRouting
-}
-
-export async function getRoutingInfo(): Promise<ScreenRoutesView[]> {
-  const db = context.getAppDB()
-  try {
-    const allRouting = await db.query<ScreenRoutesView>(
-      getQueryIndex(ViewName.ROUTING),
-      {
-        startkey: "",
-        endkey: UNICODE_MAX,
-      }
-    )
-    return allRouting.rows.map(row => row.value as ScreenRoutesView)
-  } catch (err: any) {
-    // check if the view doesn't exist, it should for all new instances
-    /* istanbul ignore next */
-    if (err != null && err.name === "not_found") {
-      await createRoutingView()
-      return getRoutingInfo()
-    } else {
-      throw err
-    }
-  }
-}

package/src/utilities/rowProcessor/map.ts

@@ -1,96 +0,0 @@
-// @ts-nocheck
-import { FieldTypes } from "../../constants"
-
-/**
- * A map of how we convert various properties in rows to each other based on the row type.
- */
-export const TYPE_TRANSFORM_MAP: any = {
-  [FieldTypes.LINK]: {
-    "": [],
-    [null]: [],
-    [undefined]: undefined,
-    parse: link => {
-      if (Array.isArray(link) && typeof link[0] === "object") {
-        return link.map(el => (el && el._id ? el._id : el))
-      }
-      if (typeof link === "string") {
-        return [link]
-      }
-      return link
-    },
-  },
-  [FieldTypes.OPTIONS]: {
-    "": null,
-    [null]: null,
-    [undefined]: undefined,
-  },
-  [FieldTypes.ARRAY]: {
-    "": [],
-    [null]: [],
-    [undefined]: undefined,
-  },
-  [FieldTypes.STRING]: {
-    "": "",
-    [null]: "",
-    [undefined]: undefined,
-  },
-  [FieldTypes.BARCODEQR]: {
-    "": "",
-    [null]: "",
-    [undefined]: undefined,
-  },
-  [FieldTypes.FORMULA]: {
-    "": "",
-    [null]: "",
-    [undefined]: undefined,
-  },
-  [FieldTypes.LONGFORM]: {
-    "": "",
-    [null]: "",
-    [undefined]: undefined,
-  },
-  [FieldTypes.NUMBER]: {
-    "": null,
-    [null]: null,
-    [undefined]: undefined,
-    parse: n => parseFloat(n),
-  },
-  [FieldTypes.DATETIME]: {
-    "": null,
-    [undefined]: undefined,
-    [null]: null,
-    parse: date => {
-      if (date instanceof Date) {
-        return date.toISOString()
-      }
-      return date
-    },
-  },
-  [FieldTypes.ATTACHMENT]: {
-    "": [],
-    [null]: [],
-    [undefined]: undefined,
-  },
-  [FieldTypes.BOOLEAN]: {
-    "": null,
-    [null]: null,
-    [undefined]: undefined,
-    true: true,
-    false: false,
-  },
-  [FieldTypes.AUTO]: {
-    parse: () => undefined,
-  },
-  [FieldTypes.JSON]: {
-    parse: input => {
-      try {
-        if (input === "") {
-          return undefined
-        }
-        return JSON.parse(input)
-      } catch (err) {
-        return input
-      }
-    },
-  },
-}

package/src/utilities/security.ts

@@ -1,65 +0,0 @@
-import { permissions, roles } from "@budibase/backend-core"
-import { DocumentType } from "../db/utils"
-
-export const CURRENTLY_SUPPORTED_LEVELS: string[] = [
-  permissions.PermissionLevel.WRITE,
-  permissions.PermissionLevel.READ,
-  permissions.PermissionLevel.EXECUTE,
-]
-
-export function getPermissionType(resourceId: string) {
-  const docType = Object.values(DocumentType).filter(docType =>
-    resourceId.startsWith(docType)
-  )[0]
-  switch (docType) {
-    case DocumentType.TABLE:
-    case DocumentType.ROW:
-      return permissions.PermissionType.TABLE
-    case DocumentType.AUTOMATION:
-      return permissions.PermissionType.AUTOMATION
-    case DocumentType.WEBHOOK:
-      return permissions.PermissionType.WEBHOOK
-    case DocumentType.QUERY:
-    case DocumentType.DATASOURCE:
-      return permissions.PermissionType.QUERY
-    default:
-      // views don't have an ID, will end up here
-      return permissions.PermissionType.VIEW
-  }
-}
-
-/**
- *  works out the basic permissions based on builtin roles for a resource, using its ID
- */
-export function getBasePermissions(resourceId: string) {
-  const type = getPermissionType(resourceId)
-  const basePermissions: { [key: string]: string } = {}
-  for (let [roleId, role] of Object.entries(roles.getBuiltinRoles())) {
-    if (!role.permissionId) {
-      continue
-    }
-    const perms = permissions.getBuiltinPermissionByID(role.permissionId)
-    if (!perms) {
-      continue
-    }
-    const typedPermission = perms.permissions.find(perm => perm.type === type)
-    if (
-      typedPermission &&
-      CURRENTLY_SUPPORTED_LEVELS.indexOf(typedPermission.level) !== -1
-    ) {
-      const level = typedPermission.level
-      basePermissions[level] = roles.lowerBuiltinRoleID(
-        basePermissions[level],
-        roleId
-      )
-      if (permissions.isPermissionLevelHigherThanRead(level)) {
-        basePermissions[permissions.PermissionLevel.READ] =
-          roles.lowerBuiltinRoleID(
-            basePermissions[permissions.PermissionLevel.READ],
-            roleId
-          )
-      }
-    }
-  }
-  return basePermissions
-}