@budibase/worker 2.1.42 → 2.1.43-alpha.1

package/src/api/controllers/global/{configs.js → configs.ts}

@@ -1,28 +1,26 @@
-const {
-  generateConfigID,
-  getConfigParams,
-  getScopedFullConfig,
-  getAllApps,
-} = require("@budibase/backend-core/db")
-const { Configs } = require("../../../constants")
-const email = require("../../../utilities/email")
-const {
-  upload,
-  ObjectStoreBuckets,
-} = require("@budibase/backend-core/objectStore")
-const { getGlobalDB, getTenantId } = require("@budibase/backend-core/tenancy")
-const env = require("../../../environment")
-const { googleCallbackUrl, oidcCallbackUrl } = require("./auth")
-const {
-  withCache,
-  CacheKeys,
-  bustCache,
+import * as email from "../../../utilities/email"
+import env from "../../../environment"
+import { googleCallbackUrl, oidcCallbackUrl } from "./auth"
+import {
+  events,
   cache,
-} = require("@budibase/backend-core/cache")
-const { events } = require("@budibase/backend-core")
-const { checkAnyUserExists } = require("../../../utilities/users")
-
-const getEventFns = async (db, config) => {
+  objectStore,
+  tenancy,
+  db as dbCore,
+} from "@budibase/backend-core"
+import { checkAnyUserExists } from "../../../utilities/users"
+import {
+  Database,
+  Config as ConfigDoc,
+  ConfigType,
+  SSOType,
+  GoogleConfig,
+  OIDCConfig,
+  SettingsConfig,
+  BBContext,
+} from "@budibase/types"
+
+const getEventFns = async (db: Database, config: ConfigDoc) => {
   const fns = []
   const type = config.type
 
@@ -31,41 +29,45 @@ const getEventFns = async (db, config) => {
     existing = await db.get(config._id)
   }
 
+  const ssoType = type as SSOType
   if (!existing) {
     switch (config.type) {
-      case Configs.SMTP: {
+      case ConfigType.SMTP: {
         fns.push(events.email.SMTPCreated)
         break
       }
-      case Configs.GOOGLE: {
-        fns.push(() => events.auth.SSOCreated(type))
-        if (config.config.activated) {
-          fns.push(() => events.auth.SSOActivated(type))
+      case ConfigType.GOOGLE: {
+        const googleCfg = config as GoogleConfig
+        fns.push(() => events.auth.SSOCreated(ssoType))
+        if (googleCfg.config.activated) {
+          fns.push(() => events.auth.SSOActivated(ssoType))
         }
         break
       }
-      case Configs.OIDC: {
-        fns.push(() => events.auth.SSOCreated(type))
-        if (config.config.configs[0].activated) {
-          fns.push(() => events.auth.SSOActivated(type))
+      case ConfigType.OIDC: {
+        const oidcCfg = config as OIDCConfig
+        fns.push(() => events.auth.SSOCreated(ssoType))
+        if (oidcCfg.config.configs[0].activated) {
+          fns.push(() => events.auth.SSOActivated(ssoType))
         }
         break
       }
-      case Configs.SETTINGS: {
+      case ConfigType.SETTINGS: {
         // company
-        const company = config.config.company
+        const settingsCfg = config as SettingsConfig
+        const company = settingsCfg.config.company
         if (company && company !== "Budibase") {
           fns.push(events.org.nameUpdated)
         }
 
         // logo
-        const logoUrl = config.config.logoUrl
+        const logoUrl = settingsCfg.config.logoUrl
         if (logoUrl) {
           fns.push(events.org.logoUpdated)
         }
 
         // platform url
-        const platformUrl = config.config.platformUrl
+        const platformUrl = settingsCfg.config.platformUrl
         if (
           platformUrl &&
           platformUrl !== "http://localhost:10000" &&
@@ -78,52 +80,55 @@ const getEventFns = async (db, config) => {
     }
   } else {
     switch (config.type) {
-      case Configs.SMTP: {
+      case ConfigType.SMTP: {
         fns.push(events.email.SMTPUpdated)
         break
       }
-      case Configs.GOOGLE: {
-        fns.push(() => events.auth.SSOUpdated(type))
-        if (!existing.config.activated && config.config.activated) {
-          fns.push(() => events.auth.SSOActivated(type))
-        } else if (existing.config.activated && !config.config.activated) {
-          fns.push(() => events.auth.SSODeactivated(type))
+      case ConfigType.GOOGLE: {
+        const googleCfg = config as GoogleConfig
+        fns.push(() => events.auth.SSOUpdated(ssoType))
+        if (!existing.config.activated && googleCfg.config.activated) {
+          fns.push(() => events.auth.SSOActivated(ssoType))
+        } else if (existing.config.activated && !googleCfg.config.activated) {
+          fns.push(() => events.auth.SSODeactivated(ssoType))
         }
         break
       }
-      case Configs.OIDC: {
-        fns.push(() => events.auth.SSOUpdated(type))
+      case ConfigType.OIDC: {
+        const oidcCfg = config as OIDCConfig
+        fns.push(() => events.auth.SSOUpdated(ssoType))
         if (
           !existing.config.configs[0].activated &&
-          config.config.configs[0].activated
+          oidcCfg.config.configs[0].activated
         ) {
-          fns.push(() => events.auth.SSOActivated(type))
+          fns.push(() => events.auth.SSOActivated(ssoType))
         } else if (
           existing.config.configs[0].activated &&
-          !config.config.configs[0].activated
+          !oidcCfg.config.configs[0].activated
         ) {
-          fns.push(() => events.auth.SSODeactivated(type))
+          fns.push(() => events.auth.SSODeactivated(ssoType))
         }
         break
       }
-      case Configs.SETTINGS: {
+      case ConfigType.SETTINGS: {
         // company
+        const settingsCfg = config as SettingsConfig
         const existingCompany = existing.config.company
-        const company = config.config.company
+        const company = settingsCfg.config.company
         if (company && company !== "Budibase" && existingCompany !== company) {
           fns.push(events.org.nameUpdated)
         }
 
         // logo
         const existingLogoUrl = existing.config.logoUrl
-        const logoUrl = config.config.logoUrl
+        const logoUrl = settingsCfg.config.logoUrl
         if (logoUrl && existingLogoUrl !== logoUrl) {
           fns.push(events.org.logoUpdated)
         }
 
         // platform url
         const existingPlatformUrl = existing.config.platformUrl
-        const platformUrl = config.config.platformUrl
+        const platformUrl = settingsCfg.config.platformUrl
         if (
           platformUrl &&
           platformUrl !== "http://localhost:10000" &&
@@ -140,13 +145,13 @@ const getEventFns = async (db, config) => {
   return fns
 }
 
-exports.save = async function (ctx) {
-  const db = getGlobalDB()
+export async function save(ctx: BBContext) {
+  const db = tenancy.getGlobalDB()
   const { type, workspace, user, config } = ctx.request.body
   let eventFns = await getEventFns(db, ctx.request.body)
   // Config does not exist yet
   if (!ctx.request.body._id) {
-    ctx.request.body._id = generateConfigID({
+    ctx.request.body._id = dbCore.generateConfigID({
       type,
       workspace,
       user,
@@ -155,18 +160,18 @@ exports.save = async function (ctx) {
   try {
     // verify the configuration
     switch (type) {
-      case Configs.SMTP:
+      case ConfigType.SMTP:
         await email.verifyConfig(config)
         break
     }
-  } catch (err) {
+  } catch (err: any) {
     ctx.throw(400, err)
   }
 
   try {
     const response = await db.put(ctx.request.body)
-    await bustCache(CacheKeys.CHECKLIST)
-    await bustCache(CacheKeys.ANALYTICS_ENABLED)
+    await cache.bustCache(cache.CacheKey.CHECKLIST)
+    await cache.bustCache(cache.CacheKey.ANALYTICS_ENABLED)
 
     for (const fn of eventFns) {
       await fn()
@@ -177,15 +182,15 @@ exports.save = async function (ctx) {
       _id: response.id,
       _rev: response.rev,
     }
-  } catch (err) {
+  } catch (err: any) {
     ctx.throw(400, err)
   }
 }
 
-exports.fetch = async function (ctx) {
-  const db = getGlobalDB()
+export async function fetch(ctx: BBContext) {
+  const db = tenancy.getGlobalDB()
   const response = await db.allDocs(
-    getConfigParams(
+    dbCore.getConfigParams(
       { type: ctx.params.type },
       {
         include_docs: true,
@@ -199,23 +204,23 @@ exports.fetch = async function (ctx) {
  * Gets the most granular config for a particular configuration type.
  * The hierarchy is type -> workspace -> user.
  */
-exports.find = async function (ctx) {
-  const db = getGlobalDB()
+export async function find(ctx: BBContext) {
+  const db = tenancy.getGlobalDB()
 
   const { userId, workspaceId } = ctx.query
   if (workspaceId && userId) {
-    const workspace = await db.get(workspaceId)
+    const workspace = await db.get(workspaceId as string)
     const userInWorkspace = workspace.users.some(
-      workspaceUser => workspaceUser === userId
+      (workspaceUser: any) => workspaceUser === userId
     )
-    if (!ctx.user.admin && !userInWorkspace) {
+    if (!ctx.user!.admin && !userInWorkspace) {
       ctx.throw(400, `User is not in specified workspace: ${workspace}.`)
     }
   }
 
   try {
     // Find the config with the most granular scope based on context
-    const scopedConfig = await getScopedFullConfig(db, {
+    const scopedConfig = await dbCore.getScopedFullConfig(db, {
       type: ctx.params.type,
       user: userId,
       workspace: workspaceId,
@@ -227,48 +232,48 @@ exports.find = async function (ctx) {
       // don't throw an error, there simply is nothing to return
       ctx.body = {}
     }
-  } catch (err) {
-    ctx.throw(err.status, err)
+  } catch (err: any) {
+    ctx.throw(err?.status || 400, err)
   }
 }
 
-exports.publicOidc = async function (ctx) {
-  const db = getGlobalDB()
+export async function publicOidc(ctx: BBContext) {
+  const db = tenancy.getGlobalDB()
   try {
     // Find the config with the most granular scope based on context
-    const oidcConfig = await getScopedFullConfig(db, {
-      type: Configs.OIDC,
+    const oidcConfig = await dbCore.getScopedFullConfig(db, {
+      type: ConfigType.OIDC,
     })
 
     if (!oidcConfig) {
       ctx.body = {}
     } else {
-      ctx.body = oidcConfig.config.configs.map(config => ({
+      ctx.body = oidcConfig.config.configs.map((config: any) => ({
         logo: config.logo,
         name: config.name,
         uuid: config.uuid,
       }))
     }
-  } catch (err) {
+  } catch (err: any) {
     ctx.throw(err.status, err)
   }
 }
 
-exports.publicSettings = async function (ctx) {
-  const db = getGlobalDB()
+export async function publicSettings(ctx: BBContext) {
+  const db = tenancy.getGlobalDB()
 
   try {
     // Find the config with the most granular scope based on context
-    const publicConfig = await getScopedFullConfig(db, {
-      type: Configs.SETTINGS,
+    const publicConfig = await dbCore.getScopedFullConfig(db, {
+      type: ConfigType.SETTINGS,
     })
 
-    const googleConfig = await getScopedFullConfig(db, {
-      type: Configs.GOOGLE,
+    const googleConfig = await dbCore.getScopedFullConfig(db, {
+      type: ConfigType.GOOGLE,
     })
 
-    const oidcConfig = await getScopedFullConfig(db, {
-      type: Configs.OIDC,
+    const oidcConfig = await dbCore.getScopedFullConfig(db, {
+      type: ConfigType.OIDC,
     })
 
     let config
@@ -301,12 +306,12 @@ exports.publicSettings = async function (ctx) {
     }
 
     ctx.body = config
-  } catch (err) {
+  } catch (err: any) {
     ctx.throw(err.status, err)
   }
 }
 
-exports.upload = async function (ctx) {
+export async function upload(ctx: BBContext) {
   if (ctx.request.files == null || ctx.request.files.file.length > 1) {
     ctx.throw(400, "One file must be uploaded.")
   }
@@ -315,19 +320,19 @@ exports.upload = async function (ctx) {
 
   let bucket
   if (env.SELF_HOSTED) {
-    bucket = ObjectStoreBuckets.GLOBAL
+    bucket = objectStore.ObjectStoreBuckets.GLOBAL
   } else {
-    bucket = ObjectStoreBuckets.GLOBAL_CLOUD
+    bucket = objectStore.ObjectStoreBuckets.GLOBAL_CLOUD
   }
 
   let key
   if (env.MULTI_TENANCY) {
-    key = `${getTenantId()}/${type}/${name}`
+    key = `${tenancy.getTenantId()}/${type}/${name}`
   } else {
     key = `${type}/${name}`
   }
 
-  await upload({
+  await objectStore.upload({
     bucket,
     filename: key,
     path: file.path,
@@ -336,11 +341,11 @@ exports.upload = async function (ctx) {
 
   // add to configuration structure
   // TODO: right now this only does a global level
-  const db = getGlobalDB()
-  let cfgStructure = await getScopedFullConfig(db, { type })
+  const db = tenancy.getGlobalDB()
+  let cfgStructure = await dbCore.getScopedFullConfig(db, { type })
   if (!cfgStructure) {
     cfgStructure = {
-      _id: generateConfigID({ type }),
+      _id: dbCore.generateConfigID({ type }),
       config: {},
     }
   }
@@ -361,49 +366,49 @@ exports.upload = async function (ctx) {
   }
 }
 
-exports.destroy = async function (ctx) {
-  const db = getGlobalDB()
+export async function destroy(ctx: BBContext) {
+  const db = tenancy.getGlobalDB()
   const { id, rev } = ctx.params
   try {
     await db.remove(id, rev)
-    await cache.delete(CacheKeys.CHECKLIST)
+    await cache.destroy(cache.CacheKey.CHECKLIST)
     ctx.body = { message: "Config deleted successfully" }
-  } catch (err) {
+  } catch (err: any) {
     ctx.throw(err.status, err)
   }
 }
 
-exports.configChecklist = async function (ctx) {
-  const db = getGlobalDB()
-  const tenantId = getTenantId()
+export async function configChecklist(ctx: BBContext) {
+  const db = tenancy.getGlobalDB()
+  const tenantId = tenancy.getTenantId()
 
   try {
-    ctx.body = await withCache(
-      CacheKeys.CHECKLIST,
+    ctx.body = await cache.withCache(
+      cache.CacheKey.CHECKLIST,
       env.CHECKLIST_CACHE_TTL,
       async () => {
         let apps = []
         if (!env.MULTI_TENANCY || tenantId) {
           // Apps exist
-          apps = await getAllApps({ idsOnly: true, efficient: true })
+          apps = await dbCore.getAllApps({ idsOnly: true, efficient: true })
         }
 
         // They have set up SMTP
-        const smtpConfig = await getScopedFullConfig(db, {
-          type: Configs.SMTP,
+        const smtpConfig = await dbCore.getScopedFullConfig(db, {
+          type: ConfigType.SMTP,
         })
 
         // They have set up Google Auth
-        const googleConfig = await getScopedFullConfig(db, {
-          type: Configs.GOOGLE,
+        const googleConfig = await dbCore.getScopedFullConfig(db, {
+          type: ConfigType.GOOGLE,
         })
 
         // They have set up OIDC
-        const oidcConfig = await getScopedFullConfig(db, {
-          type: Configs.OIDC,
+        const oidcConfig = await dbCore.getScopedFullConfig(db, {
+          type: ConfigType.OIDC,
         })
 
-        // They have set up an global user
+        // They have set up a global user
         const userExists = await checkAnyUserExists()
         return {
           apps: {
@@ -429,7 +434,7 @@ exports.configChecklist = async function (ctx) {
         }
       }
     )
-  } catch (err) {
+  } catch (err: any) {
     ctx.throw(err.status, err)
   }
 }

package/src/api/controllers/global/{email.js → email.ts}

@@ -1,7 +1,8 @@
-const { sendEmail } = require("../../../utilities/email")
-const { getGlobalDB } = require("@budibase/backend-core/tenancy")
+import { sendEmail as sendEmailFn } from "../../../utilities/email"
+import { tenancy } from "@budibase/backend-core"
+import { BBContext } from "@budibase/types"
 
-exports.sendEmail = async ctx => {
+export async function sendEmail(ctx: BBContext) {
   let {
     workspaceId,
     email,
@@ -16,10 +17,10 @@ exports.sendEmail = async ctx => {
   } = ctx.request.body
   let user
   if (userId) {
-    const db = getGlobalDB()
+    const db = tenancy.getGlobalDB()
     user = await db.get(userId)
   }
-  const response = await sendEmail(email, purpose, {
+  const response = await sendEmailFn(email, purpose, {
     workspaceId,
     user,
     contents,

package/src/api/controllers/global/roles.ts

@@ -0,0 +1,66 @@
+import {
+  db as dbCore,
+  roles,
+  context,
+  cache,
+  tenancy,
+} from "@budibase/backend-core"
+import { BBContext, App } from "@budibase/types"
+import { allUsers } from "../../../sdk/users"
+
+export async function fetch(ctx: BBContext) {
+  const tenantId = ctx.user!.tenantId
+  // always use the dev apps as they'll be most up to date (true)
+  const apps = (await dbCore.getAllApps({ tenantId, all: true })) as App[]
+  const promises = []
+  for (let app of apps) {
+    // use dev app IDs
+    promises.push(roles.getAllRoles(app.appId))
+  }
+  const roleList = await Promise.all(promises)
+  const response: any = {}
+  for (let app of apps) {
+    const deployedAppId = dbCore.getProdAppID(app.appId)
+    response[deployedAppId] = {
+      roles: roleList.shift(),
+      name: app.name,
+      version: app.version,
+      url: app.url,
+    }
+  }
+  ctx.body = response
+}
+
+export async function find(ctx: BBContext) {
+  const appId = ctx.params.appId
+  await context.doInAppContext(dbCore.getDevAppID(appId), async () => {
+    const db = context.getAppDB()
+    const app = await db.get(dbCore.DocumentType.APP_METADATA)
+    ctx.body = {
+      roles: await roles.getAllRoles(),
+      name: app.name,
+      version: app.version,
+      url: app.url,
+    }
+  })
+}
+
+export async function removeAppRole(ctx: BBContext) {
+  const { appId } = ctx.params
+  const db = tenancy.getGlobalDB()
+  const users = await allUsers()
+  const bulk = []
+  const cacheInvalidations = []
+  for (let user of users) {
+    if (user.roles[appId]) {
+      cacheInvalidations.push(cache.user.invalidateUser(user._id))
+      delete user.roles[appId]
+      bulk.push(user)
+    }
+  }
+  await db.bulkDocs(bulk)
+  await Promise.all(cacheInvalidations)
+  ctx.body = {
+    message: "App role removed from all users",
+  }
+}

package/src/api/controllers/global/self.ts

@@ -73,12 +73,12 @@ export async function fetchAPIKey(ctx: any) {
 }
 
 const checkCurrentApp = (ctx: any) => {
-  const appCookie = getCookie(ctx, constants.Cookies.CurrentApp)
+  const appCookie = getCookie(ctx, constants.Cookie.CurrentApp)
   if (appCookie && !tenancy.isUserInAppTenant(appCookie.appId)) {
     // there is a currentapp cookie from another tenant
     // remove the cookie as this is incompatible with the builder
     // due to builder and admin permissions being removed
-    clearCookie(ctx, constants.Cookies.CurrentApp)
+    clearCookie(ctx, constants.Cookie.CurrentApp)
   }
 }
 

package/src/api/controllers/global/users.ts

@@ -5,6 +5,7 @@ import {
   BulkUserRequest,
   BulkUserResponse,
   CloudAccount,
+  CreateAdminUserRequest,
   InviteUserRequest,
   InviteUsersRequest,
   SearchUsersRequest,
@@ -67,7 +68,8 @@ const parseBooleanParam = (param: any) => {
 }
 
 export const adminUser = async (ctx: any) => {
-  const { email, password, tenantId } = ctx.request.body
+  const { email, password, tenantId } = ctx.request
+    .body as CreateAdminUserRequest
   await tenancy.doInTenant(tenantId, async () => {
     // account portal sends a pre-hashed password - honour param to prevent double hashing
     const hashPassword = parseBooleanParam(ctx.request.query.hashPassword)
@@ -102,7 +104,7 @@ export const adminUser = async (ctx: any) => {
     try {
       // always bust checklist beforehand, if an error occurs but can proceed, don't get
       // stuck in a cycle
-      await cache.bustCache(cache.CacheKeys.CHECKLIST)
+      await cache.bustCache(cache.CacheKey.CHECKLIST)
       const finalUser = await sdk.users.save(user, {
         hashPassword,
         requirePassword,

package/src/api/controllers/global/{workspaces.js → workspaces.ts}

@@ -1,16 +1,13 @@
-const {
-  getWorkspaceParams,
-  generateWorkspaceID,
-} = require("@budibase/backend-core/db")
-const { getGlobalDB } = require("@budibase/backend-core/tenancy")
+import { tenancy, db as dbCore } from "@budibase/backend-core"
+import { BBContext } from "@budibase/types"
 
-exports.save = async function (ctx) {
-  const db = getGlobalDB()
+export async function save(ctx: BBContext) {
+  const db = tenancy.getGlobalDB()
   const workspaceDoc = ctx.request.body
 
   // workspace does not exist yet
   if (!workspaceDoc._id) {
-    workspaceDoc._id = generateWorkspaceID()
+    workspaceDoc._id = dbCore.generateWorkspaceID()
   }
 
   try {
@@ -19,38 +16,38 @@ exports.save = async function (ctx) {
       _id: response.id,
       _rev: response.rev,
     }
-  } catch (err) {
+  } catch (err: any) {
     ctx.throw(err.status, err)
   }
 }
 
-exports.fetch = async function (ctx) {
-  const db = getGlobalDB()
+export async function fetch(ctx: BBContext) {
+  const db = tenancy.getGlobalDB()
   const response = await db.allDocs(
-    getWorkspaceParams(undefined, {
+    dbCore.getWorkspaceParams(undefined, {
       include_docs: true,
     })
   )
   ctx.body = response.rows.map(row => row.doc)
 }
 
-exports.find = async function (ctx) {
-  const db = getGlobalDB()
+export async function find(ctx: BBContext) {
+  const db = tenancy.getGlobalDB()
   try {
     ctx.body = await db.get(ctx.params.id)
-  } catch (err) {
+  } catch (err: any) {
     ctx.throw(err.status, err)
   }
 }
 
-exports.destroy = async function (ctx) {
-  const db = getGlobalDB()
+export async function destroy(ctx: BBContext) {
+  const db = tenancy.getGlobalDB()
   const { id, rev } = ctx.params
 
   try {
     await db.remove(id, rev)
     ctx.body = { message: "Workspace deleted successfully" }
-  } catch (err) {
+  } catch (err: any) {
     ctx.throw(err.status, err)
   }
 }

package/src/api/controllers/system/{environment.js → environment.ts}

@@ -1,6 +1,7 @@
-const env = require("../../../environment")
+import { BBContext } from "@budibase/types"
+import env from "../../../environment"
 
-exports.fetch = async ctx => {
+export const fetch = async (ctx: BBContext) => {
   ctx.body = {
     multiTenancy: !!env.MULTI_TENANCY,
     cloud: !env.SELF_HOSTED,