@budibase/server 2.1.45 → 2.1.46-alpha.1

package/src/utilities/fileSystem/{index.js → index.ts}

@@ -1,26 +1,17 @@
-const { budibaseTempDir } = require("../budibaseDir")
-const fs = require("fs")
-const { join } = require("path")
+import { budibaseTempDir } from "../budibaseDir"
+import fs from "fs"
+import { join } from "path"
+import { context, objectStore } from "@budibase/backend-core"
+import { ObjectStoreBuckets } from "../../constants"
+import { updateClientLibrary } from "./clientLibrary"
+import { checkSlashesInUrl } from "../"
+import env from "../../environment"
+import fetch from "node-fetch"
 const uuid = require("uuid/v4")
-const { ObjectStoreBuckets } = require("../../constants")
-const {
-  upload,
-  retrieve,
-  retrieveToTmp,
-  deleteFolder,
-  downloadTarball,
-  downloadTarballDirect,
-  deleteFiles,
-} = require("./utilities")
-const { updateClientLibrary } = require("./clientLibrary")
-const { checkSlashesInUrl } = require("../")
-const env = require("../../environment")
-const { getAppId } = require("@budibase/backend-core/context")
 const tar = require("tar")
-const fetch = require("node-fetch")
 
-const TOP_LEVEL_PATH = join(__dirname, "..", "..", "..")
-const NODE_MODULES_PATH = join(TOP_LEVEL_PATH, "node_modules")
+export const TOP_LEVEL_PATH = join(__dirname, "..", "..", "..")
+export const NODE_MODULES_PATH = join(TOP_LEVEL_PATH, "node_modules")
 const DATASOURCE_PATH = join(budibaseTempDir(), "datasource")
 
 /**
@@ -34,14 +25,14 @@ const DATASOURCE_PATH = join(budibaseTempDir(), "datasource")
 /**
  * Upon first startup of instance there may not be everything we need in tmp directory, set it up.
  */
-exports.init = () => {
+export function init() {
   const tempDir = budibaseTempDir()
   if (!fs.existsSync(tempDir)) {
     // some test cases fire this quickly enough that
     // synchronous cases can end up here at the same time
     try {
       fs.mkdirSync(tempDir)
-    } catch (err) {
+    } catch (err: any) {
       if (!err || err.code !== "EEXIST") {
         throw err
       }
@@ -81,7 +72,7 @@ exports.checkDevelopmentEnvironment = () => {
  * @param {string} path The path to the handlebars file which is to be loaded.
  * @returns {string} The loaded handlebars file as a string - loaded as utf8.
  */
-exports.loadHandlebarsFile = path => {
+export function loadHandlebarsFile(path: string) {
   return fs.readFileSync(path, "utf8")
 }
 
@@ -89,15 +80,19 @@ exports.loadHandlebarsFile = path => {
  * When return a file from the API need to write the file to the system temporarily so we
  * can create a read stream to send.
  * @param {string} contents the contents of the file which is to be returned from the API.
+ * @param {string} encoding the encoding of the file to return (utf8 default)
  * @return {Object} the read stream which can be put into the koa context body.
  */
-exports.apiFileReturn = contents => {
+export function apiFileReturn(
+  contents: string,
+  encoding: BufferEncoding = "utf8"
+) {
   const path = join(budibaseTempDir(), uuid())
-  fs.writeFileSync(path, contents)
-  return fs.createReadStream(path)
+  fs.writeFileSync(path, contents, { encoding })
+  return fs.createReadStream(path, { encoding })
 }
 
-exports.streamFile = path => {
+export function streamFile(path: string) {
   return fs.createReadStream(path)
 }
 
@@ -106,7 +101,7 @@ exports.streamFile = path => {
  * @param {string} fileContents contents which will be written to a temp file.
  * @return {string} the path to the temp file.
  */
-exports.storeTempFile = fileContents => {
+export function storeTempFile(fileContents: string) {
   const path = join(budibaseTempDir(), uuid())
   fs.writeFileSync(path, fileContents)
   return path
@@ -116,7 +111,7 @@ exports.storeTempFile = fileContents => {
  * Utility function for getting a file read stream - a simple in memory buffered read
  * stream doesn't work for pouchdb.
  */
-exports.stringToFileStream = contents => {
+export function stringToFileStream(contents: string) {
   const path = exports.storeTempFile(contents)
   return fs.createReadStream(path)
 }
@@ -125,7 +120,7 @@ exports.stringToFileStream = contents => {
  * Creates a temp file and returns it from the API.
  * @param {string} fileContents the contents to be returned in file.
  */
-exports.sendTempFile = fileContents => {
+export function sendTempFile(fileContents: string) {
   const path = exports.storeTempFile(fileContents)
   return fs.createReadStream(path)
 }
@@ -135,7 +130,7 @@ exports.sendTempFile = fileContents => {
  * @param {string} appId The ID of the app which is being created.
  * @return {Promise<void>} once promise completes app resources should be ready in object store.
  */
-exports.createApp = async appId => {
+export async function createApp(appId: string) {
   await updateClientLibrary(appId)
 }
 
@@ -144,8 +139,8 @@ exports.createApp = async appId => {
  * @param {string} appId The ID of the app which is being deleted.
  * @return {Promise<void>} once promise completes the app resources will be removed from object store.
  */
-exports.deleteApp = async appId => {
-  await deleteFolder(ObjectStoreBuckets.APPS, `${appId}/`)
+export async function deleteApp(appId: string) {
+  await objectStore.deleteFolder(ObjectStoreBuckets.APPS, `${appId}/`)
 }
 
 /**
@@ -154,18 +149,22 @@ exports.deleteApp = async appId => {
  * @param name
  * @return {Promise<*>}
  */
-exports.downloadTemplate = async (type, name) => {
+export async function downloadTemplate(type: string, name: string) {
   const DEFAULT_TEMPLATES_BUCKET =
     "prod-budi-templates.s3-eu-west-1.amazonaws.com"
   const templateUrl = `https://${DEFAULT_TEMPLATES_BUCKET}/templates/${type}/${name}.tar.gz`
-  return downloadTarball(templateUrl, ObjectStoreBuckets.TEMPLATES, type)
+  return objectStore.downloadTarball(
+    templateUrl,
+    ObjectStoreBuckets.TEMPLATES,
+    type
+  )
 }
 
 /**
  * Retrieves component libraries from object store (or tmp symlink if in local)
  */
-exports.getComponentLibraryManifest = async library => {
-  const appId = getAppId()
+export async function getComponentLibraryManifest(library: string) {
+  const appId = context.getAppId()
   const filename = "manifest.json"
   /* istanbul ignore next */
   // when testing in cypress and so on we need to get the package
@@ -182,12 +181,16 @@ exports.getComponentLibraryManifest = async library => {
     return require(path)
   }
 
+  if (!appId) {
+    throw new Error("No app ID found - cannot get component libraries")
+  }
+
   let resp
   let path
   try {
     // Try to load the manifest from the new file location
     path = join(appId, filename)
-    resp = await retrieve(ObjectStoreBuckets.APPS, path)
+    resp = await objectStore.retrieve(ObjectStoreBuckets.APPS, path)
   } catch (error) {
     console.error(
       `component-manifest-objectstore=failed appId=${appId} path=${path}`,
@@ -195,7 +198,7 @@ exports.getComponentLibraryManifest = async library => {
     )
     // Fallback to loading it from the old location for old apps
     path = join(appId, "node_modules", library, "package", filename)
-    resp = await retrieve(ObjectStoreBuckets.APPS, path)
+    resp = await objectStore.retrieve(ObjectStoreBuckets.APPS, path)
   }
   if (typeof resp !== "string") {
     resp = resp.toString("utf8")
@@ -207,14 +210,17 @@ exports.getComponentLibraryManifest = async library => {
  * All file reads come through here just to make sure all of them make sense
  * allows a centralised location to check logic is all good.
  */
-exports.readFileSync = (filepath, options = "utf8") => {
-  return fs.readFileSync(filepath, options)
+export function readFileSync(
+  filepath: string,
+  options: BufferEncoding = "utf8"
+) {
+  return fs.readFileSync(filepath, { encoding: options })
 }
 
 /**
  * Given a set of app IDs makes sure file system is cleared of any of their temp info.
  */
-exports.cleanup = appIds => {
+export function cleanup(appIds: string[]) {
   for (let appId of appIds) {
     const path = join(budibaseTempDir(), appId)
     if (fs.existsSync(path)) {
@@ -223,7 +229,7 @@ exports.cleanup = appIds => {
   }
 }
 
-const createTempFolder = item => {
+export function createTempFolder(item: string) {
   const path = join(budibaseTempDir(), item)
   try {
     // remove old tmp directories automatically - don't combine
@@ -231,24 +237,22 @@ const createTempFolder = item => {
       fs.rmSync(path, { recursive: true, force: true })
     }
     fs.mkdirSync(path)
-  } catch (err) {
+  } catch (err: any) {
     throw new Error(`Path cannot be created: ${err.message}`)
   }
 
   return path
 }
-exports.createTempFolder = createTempFolder
 
-const extractTarball = async (fromFilePath, toPath) => {
+export async function extractTarball(fromFilePath: string, toPath: string) {
   await tar.extract({
     file: fromFilePath,
     C: toPath,
   })
 }
-exports.extractTarball = extractTarball
 
-const getPluginMetadata = async path => {
-  let metadata = {}
+export async function getPluginMetadata(path: string) {
+  let metadata: { schema?: any; package?: any } = {}
   try {
     const pkg = fs.readFileSync(join(path, "package.json"), "utf8")
     const schema = fs.readFileSync(join(path, "schema.json"), "utf8")
@@ -265,7 +269,7 @@ const getPluginMetadata = async path => {
         "package.json is missing one of 'name', 'version' or 'description'."
       )
     }
-  } catch (err) {
+  } catch (err: any) {
     throw new Error(
       `Unable to process schema.json/package.json in plugin. ${err.message}`
     )
@@ -273,9 +277,12 @@ const getPluginMetadata = async path => {
 
   return { metadata, directory: path }
 }
-exports.getPluginMetadata = getPluginMetadata
 
-exports.getDatasourcePlugin = async (name, url, hash) => {
+export async function getDatasourcePlugin(
+  name: string,
+  url: string,
+  hash: string
+) {
   if (!fs.existsSync(DATASOURCE_PATH)) {
     fs.mkdirSync(DATASOURCE_PATH)
   }
@@ -311,7 +318,7 @@ exports.getDatasourcePlugin = async (name, url, hash) => {
 /**
  * Find for a file recursively from start path applying filter, return first match
  */
-exports.findFileRec = (startPath, filter) => {
+export function findFileRec(startPath: string, filter: any) {
   if (!fs.existsSync(startPath)) {
     return
   }
@@ -332,21 +339,10 @@ exports.findFileRec = (startPath, filter) => {
 /**
  * Remove a folder which is not empty from the file system
  */
-exports.deleteFolderFileSystem = path => {
+export function deleteFolderFileSystem(path: string) {
   if (!fs.existsSync(path)) {
     return
   }
 
   fs.rmSync(path, { recursive: true, force: true })
 }
-
-/**
- * Full function definition for below can be found in the utilities.
- */
-exports.upload = upload
-exports.retrieve = retrieve
-exports.retrieveToTmp = retrieveToTmp
-exports.deleteFiles = deleteFiles
-exports.downloadTarballDirect = downloadTarballDirect
-exports.TOP_LEVEL_PATH = TOP_LEVEL_PATH
-exports.NODE_MODULES_PATH = NODE_MODULES_PATH

package/src/utilities/fileSystem/{processor.js → processor.ts}

@@ -1,21 +1,19 @@
-const jimp = require("jimp")
+import jimp from "jimp"
 
 const FORMATS = {
   IMAGES: ["png", "jpg", "jpeg", "gif", "bmp", "tiff"],
 }
 
-function processImage(file) {
+function processImage(file: { path: string }) {
   // this will overwrite the temp file
   return jimp.read(file.path).then(img => {
     return img.resize(300, jimp.AUTO).write(file.path)
   })
 }
 
-async function process(file) {
+export async function process(file: { extension: string; path: string }) {
   if (FORMATS.IMAGES.includes(file.extension.toLowerCase())) {
     await processImage(file)
   }
   return file
 }
-
-exports.process = process

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/{index.js → index.ts}

@@ -1,17 +1,20 @@
-const env = require("../environment")
-const { OBJ_STORE_DIRECTORY } = require("../constants")
-const { sanitizeKey } = require("@budibase/backend-core/objectStore")
-const { generateMetadataID } = require("../db/utils")
-const Readable = require("stream").Readable
-const { getAppDB } = require("@budibase/backend-core/context")
-
-exports.wait = ms => new Promise(resolve => setTimeout(resolve, ms))
+import env from "../environment"
+import { OBJ_STORE_DIRECTORY } from "../constants"
+import { objectStore, context } from "@budibase/backend-core"
+import { generateMetadataID } from "../db/utils"
+import { Document } from "@budibase/types"
+import stream from "stream"
+const Readable = stream.Readable
+
+export function wait(ms: number) {
+  return new Promise(resolve => setTimeout(resolve, ms))
+}
 
-exports.isDev = env.isDev
+export const isDev = env.isDev
 
-exports.NUMBER_REGEX = /^[+-]?([0-9]*[.])?[0-9]+$/g
+export const NUMBER_REGEX = /^[+-]?([0-9]*[.])?[0-9]+$/g
 
-exports.removeFromArray = (array, element) => {
+export function removeFromArray(array: any[], element: any) {
   const index = array.indexOf(element)
   if (index !== -1) {
     array.splice(index, 1)
@@ -25,7 +28,7 @@ exports.removeFromArray = (array, element) => {
  * @param {string} url The URL to test and remove any extra double slashes.
  * @return {string} The updated url.
  */
-exports.checkSlashesInUrl = url => {
+export function checkSlashesInUrl(url: string) {
   return url.replace(/(https?:\/\/)|(\/)+/g, "$1$2")
 }
 
@@ -33,7 +36,7 @@ exports.checkSlashesInUrl = url => {
  * Gets the address of the object store, depending on whether self hosted or in cloud.
  * @return {string} The base URL of the object store (MinIO or S3).
  */
-exports.objectStoreUrl = () => {
+export function objectStoreUrl() {
   if (env.SELF_HOSTED || env.MINIO_URL) {
     // can use a relative url for this as all goes through the proxy (this is hosted in minio)
     return OBJ_STORE_DIRECTORY
@@ -52,9 +55,9 @@ exports.objectStoreUrl = () => {
  * @return {string} The URL to be inserted into appPackage response or server rendered
  * app index file.
  */
-exports.clientLibraryPath = (appId, version) => {
+export function clientLibraryPath(appId: string, version: string) {
   if (env.isProd()) {
-    let url = `${exports.objectStoreUrl()}/${sanitizeKey(
+    let url = `${objectStoreUrl()}/${objectStore.sanitizeKey(
       appId
     )}/budibase-client.js`
 
@@ -68,18 +71,19 @@ exports.clientLibraryPath = (appId, version) => {
   }
 }
 
-exports.attachmentsRelativeURL = attachmentKey => {
-  return exports.checkSlashesInUrl(
-    `${exports.objectStoreUrl()}/${attachmentKey}`
-  )
+export function attachmentsRelativeURL(attachmentKey: string) {
+  return checkSlashesInUrl(`${objectStoreUrl()}/${attachmentKey}`)
 }
 
-exports.updateEntityMetadata = async (type, entityId, updateFn) => {
-  const db = getAppDB()
+export async function updateEntityMetadata(
+  type: string,
+  entityId: string,
+  updateFn: any
+) {
+  const db = context.getAppDB()
   const id = generateMetadataID(type, entityId)
   // read it to see if it exists, we'll overwrite it no matter what
-  let rev,
-    metadata = {}
+  let rev, metadata: Document
   try {
     const oldMetadata = await db.get(id)
     rev = oldMetadata._rev
@@ -100,14 +104,18 @@ exports.updateEntityMetadata = async (type, entityId, updateFn) => {
   }
 }
 
-exports.saveEntityMetadata = async (type, entityId, metadata) => {
-  return exports.updateEntityMetadata(type, entityId, () => {
+export async function saveEntityMetadata(
+  type: string,
+  entityId: string,
+  metadata: Document
+) {
+  return updateEntityMetadata(type, entityId, () => {
     return metadata
   })
 }
 
-exports.deleteEntityMetadata = async (type, entityId) => {
-  const db = getAppDB()
+export async function deleteEntityMetadata(type: string, entityId: string) {
+  const db = context.getAppDB()
   const id = generateMetadataID(type, entityId)
   let rev
   try {
@@ -123,7 +131,7 @@ exports.deleteEntityMetadata = async (type, entityId) => {
   }
 }
 
-exports.escapeDangerousCharacters = string => {
+export function escapeDangerousCharacters(string: string) {
   return string
     .replace(/[\\]/g, "\\\\")
     .replace(/[\b]/g, "\\b")
@@ -133,7 +141,7 @@ exports.escapeDangerousCharacters = string => {
     .replace(/[\t]/g, "\\t")
 }
 
-exports.stringToReadStream = string => {
+export function stringToReadStream(string: string) {
   return new Readable({
     read() {
       this.push(string)
@@ -142,7 +150,7 @@ exports.stringToReadStream = string => {
   })
 }
 
-exports.formatBytes = bytes => {
+export function formatBytes(bytes: string) {
   const units = ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"]
   const byteIncrements = 1024
   let unit = 0
@@ -153,7 +161,7 @@ exports.formatBytes = bytes => {
   return `${size.toFixed(size < 10 && unit > 0 ? 1 : 0)}${units[unit]}`
 }
 
-exports.convertBookmark = bookmark => {
+export function convertBookmark(bookmark: string) {
   const IS_NUMBER = /^\d+\.?\d*$/
   if (typeof bookmark === "string" && bookmark.match(IS_NUMBER)) {
     return parseFloat(bookmark)
@@ -161,7 +169,7 @@ exports.convertBookmark = bookmark => {
   return bookmark
 }
 
-exports.isQsTrue = param => {
+export function isQsTrue(param: string) {
   if (typeof param === "string") {
     return param.toLowerCase() === "true"
   } else {

package/src/utilities/{plugins.js → plugins.ts}

@@ -1,8 +1,9 @@
-const env = require("../environment")
-const { plugins: ProPlugins } = require("@budibase/pro")
-const { objectStore } = require("@budibase/backend-core")
+import env from "../environment"
+import { plugins as ProPlugins } from "@budibase/pro"
+import { objectStore } from "@budibase/backend-core"
+import { Plugin } from "@budibase/types"
 
-exports.enrichPluginURLs = plugins => {
+export function enrichPluginURLs(plugins: Plugin[]) {
   if (!plugins || !plugins.length) {
     return []
   }