@budibase/worker 2.1.43-alpha.6 → 2.1.44

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

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

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

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

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

@@ -0,0 +1,68 @@
+const { getAllRoles } = require("@budibase/backend-core/roles")
+const {
+  getAllApps,
+  getProdAppID,
+  getDevAppID,
+  DocumentType,
+} = require("@budibase/backend-core/db")
+const { doInAppContext, getAppDB } = require("@budibase/backend-core/context")
+const { user: userCache } = require("@budibase/backend-core/cache")
+const { getGlobalDB } = require("@budibase/backend-core/tenancy")
+const { allUsers } = require("../../../sdk/users")
+
+exports.fetch = async ctx => {
+  const tenantId = ctx.user.tenantId
+  // always use the dev apps as they'll be most up to date (true)
+  const apps = await getAllApps({ tenantId, all: true })
+  const promises = []
+  for (let app of apps) {
+    // use dev app IDs
+    promises.push(getAllRoles(app.appId))
+  }
+  const roles = await Promise.all(promises)
+  const response = {}
+  for (let app of apps) {
+    const deployedAppId = getProdAppID(app.appId)
+    response[deployedAppId] = {
+      roles: roles.shift(),
+      name: app.name,
+      version: app.version,
+      url: app.url,
+    }
+  }
+  ctx.body = response
+}
+
+exports.find = async ctx => {
+  const appId = ctx.params.appId
+  await doInAppContext(getDevAppID(appId), async () => {
+    const db = getAppDB()
+    const app = await db.get(DocumentType.APP_METADATA)
+    ctx.body = {
+      roles: await getAllRoles(),
+      name: app.name,
+      version: app.version,
+      url: app.url,
+    }
+  })
+}
+
+exports.removeAppRole = async ctx => {
+  const { appId } = ctx.params
+  const db = getGlobalDB()
+  const users = await allUsers(ctx)
+  const bulk = []
+  const cacheInvalidations = []
+  for (let user of users) {
+    if (user.roles[appId]) {
+      cacheInvalidations.push(userCache.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.Cookie.CurrentApp)
+  const appCookie = getCookie(ctx, constants.Cookies.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.Cookie.CurrentApp)
+    clearCookie(ctx, constants.Cookies.CurrentApp)
   }
 }
 

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

@@ -5,7 +5,6 @@ import {
   BulkUserRequest,
   BulkUserResponse,
   CloudAccount,
-  CreateAdminUserRequest,
   InviteUserRequest,
   InviteUsersRequest,
   SearchUsersRequest,
@@ -68,8 +67,7 @@ const parseBooleanParam = (param: any) => {
 }
 
 export const adminUser = async (ctx: any) => {
-  const { email, password, tenantId } = ctx.request
-    .body as CreateAdminUserRequest
+  const { email, password, tenantId } = ctx.request.body
   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)
@@ -104,7 +102,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.CacheKey.CHECKLIST)
+      await cache.bustCache(cache.CacheKeys.CHECKLIST)
       const finalUser = await sdk.users.save(user, {
         hashPassword,
         requirePassword,

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

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

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

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