@budibase/worker 2.2.26 → 2.2.27

package/jest.config.ts

@@ -2,11 +2,14 @@ import { Config } from "@jest/types"
 import * as fs from "fs"
 
 const config: Config.InitialOptions = {
-  preset: "ts-jest",
   testEnvironment: "node",
-  setupFiles: ["./src/tests/jestSetup.ts"],
+  setupFiles: ["./src/tests/jestEnv.ts"],
+  setupFilesAfterEnv: ["./src/tests/jestSetup.ts"],
   collectCoverageFrom: ["src/**/*.{js,ts}"],
   coverageReporters: ["lcov", "json", "clover"],
+  transform: {
+    "^.+\\.ts?$": "@swc/jest",
+  },
 }
 
 if (!process.env.CI) {
@@ -19,6 +22,8 @@ if (!process.env.CI) {
   }
   // add pro sources if they exist
   if (fs.existsSync("../../../budibase-pro")) {
+    config.moduleNameMapper["@budibase/pro/(.*)"] =
+      "<rootDir>/../../../budibase-pro/packages/pro/$1"
     config.moduleNameMapper["@budibase/pro"] =
       "<rootDir>/../../../budibase-pro/packages/pro/src"
   }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@budibase/worker",
   "email": "hi@budibase.com",
-  "version": "2.2.26",
+  "version": "2.2.27",
   "description": "Budibase background service",
   "main": "src/index.ts",
   "repository": {
@@ -36,10 +36,10 @@
   "author": "Budibase",
   "license": "GPL-3.0",
   "dependencies": {
-    "@budibase/backend-core": "^2.2.26",
-    "@budibase/pro": "2.2.25",
-    "@budibase/string-templates": "^2.2.26",
-    "@budibase/types": "^2.2.26",
+    "@budibase/backend-core": "^2.2.27",
+    "@budibase/pro": "2.2.27-alpha.0",
+    "@budibase/string-templates": "^2.2.27",
+    "@budibase/types": "^2.2.27",
     "@koa/router": "8.0.8",
     "@sentry/node": "6.17.7",
     "@techpass/passport-openidconnect": "0.3.2",
@@ -70,13 +70,16 @@
     "server-destroy": "1.0.1"
   },
   "devDependencies": {
+    "@swc/core": "^1.3.25",
+    "@swc/jest": "^0.2.24",
     "@types/jest": "26.0.23",
     "@types/jsonwebtoken": "8.5.1",
     "@types/koa": "2.13.4",
-    "@types/koa__router": "8.0.11",
+    "@types/koa__router": "8.0.8",
     "@types/node": "14.18.20",
     "@types/node-fetch": "2.6.1",
     "@types/pouchdb": "6.4.0",
+    "@types/server-destroy": "1.0.1",
     "@types/uuid": "8.3.4",
     "@typescript-eslint/parser": "5.45.0",
     "copyfiles": "2.4.1",
@@ -94,5 +97,5 @@
     "typescript": "4.7.3",
     "update-dotenv": "1.1.1"
   },
-  "gitHead": "a60084bc0ef21373d57e3d0d75872cdc2b3af5b4"
+  "gitHead": "d5e24cc25f7eff877eb808046f0069359fddeb74"
 }

package/scripts/dev/manage.js

@@ -21,14 +21,14 @@ async function init() {
       COUCH_DB_PASSWORD: "budibase",
       // empty string is false
       MULTI_TENANCY: "",
-      DISABLE_ACCOUNT_PORTAL: "",
+      DISABLE_ACCOUNT_PORTAL: 1,
       ACCOUNT_PORTAL_URL: "http://localhost:10001",
       ACCOUNT_PORTAL_API_KEY: "budibase",
       PLATFORM_URL: "http://localhost:10000",
       APPS_URL: "http://localhost:4001",
       SERVICE: "worker-service",
       DEPLOYMENT_ENVIRONMENT: "development",
-      TENANT_FEATURE_FLAGS: "*:LICENSING,*:USER_GROUPS",
+      TENANT_FEATURE_FLAGS: "*:LICENSING,*:USER_GROUPS,*:ONBOARDING_TOUR",
     }
     let envFile = ""
     Object.keys(envFileJson).forEach(key => {

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

@@ -13,7 +13,7 @@ import { isEmailConfigured, sendEmail } from "../../../utilities/email"
 import { checkResetPasswordCode } from "../../../utilities/redis"
 import env from "../../../environment"
 import sdk from "../../../sdk"
-import { Config, ConfigType, User } from "@budibase/types"
+import { ConfigType, User } from "@budibase/types"
 
 const { setCookie, getCookie, clearCookie, hash, platformLogout } = utils
 const { Cookie, Header } = constants

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

@@ -7,6 +7,7 @@ import {
   objectStore,
   tenancy,
   db as dbCore,
+  env as coreEnv,
 } from "@budibase/backend-core"
 import { checkAnyUserExists } from "../../../utilities/users"
 import {
@@ -17,127 +18,106 @@ import {
   GoogleConfig,
   OIDCConfig,
   SettingsConfig,
-  BBContext,
+  isGoogleConfig,
+  isOIDCConfig,
+  isSettingsConfig,
+  isSMTPConfig,
+  Ctx,
+  UserCtx,
 } from "@budibase/types"
 
 const getEventFns = async (db: Database, config: ConfigDoc) => {
   const fns = []
-  const type = config.type
 
   let existing
   if (config._id) {
     existing = await db.get(config._id)
   }
 
-  const ssoType = type as SSOType
   if (!existing) {
-    switch (config.type) {
-      case ConfigType.SMTP: {
-        fns.push(events.email.SMTPCreated)
-        break
+    if (isSMTPConfig(config)) {
+      fns.push(events.email.SMTPCreated)
+    } else if (isGoogleConfig(config)) {
+      fns.push(() => events.auth.SSOCreated(ConfigType.GOOGLE))
+      if (config.config.activated) {
+        fns.push(() => events.auth.SSOActivated(ConfigType.GOOGLE))
       }
-      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
+    } else if (isOIDCConfig(config)) {
+      fns.push(() => events.auth.SSOCreated(ConfigType.OIDC))
+      if (config.config.configs[0].activated) {
+        fns.push(() => events.auth.SSOActivated(ConfigType.OIDC))
       }
-      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
+    } else if (isSettingsConfig(config)) {
+      // company
+      const company = config.config.company
+      if (company && company !== "Budibase") {
+        fns.push(events.org.nameUpdated)
       }
-      case ConfigType.SETTINGS: {
-        // company
-        const settingsCfg = config as SettingsConfig
-        const company = settingsCfg.config.company
-        if (company && company !== "Budibase") {
-          fns.push(events.org.nameUpdated)
-        }
 
-        // logo
-        const logoUrl = settingsCfg.config.logoUrl
-        if (logoUrl) {
-          fns.push(events.org.logoUpdated)
-        }
+      // logo
+      const logoUrl = config.config.logoUrl
+      if (logoUrl) {
+        fns.push(events.org.logoUpdated)
+      }
 
-        // platform url
-        const platformUrl = settingsCfg.config.platformUrl
-        if (
-          platformUrl &&
-          platformUrl !== "http://localhost:10000" &&
-          env.SELF_HOSTED
-        ) {
-          fns.push(events.org.platformURLUpdated)
-        }
-        break
+      // platform url
+      const platformUrl = config.config.platformUrl
+      if (
+        platformUrl &&
+        platformUrl !== "http://localhost:10000" &&
+        env.SELF_HOSTED
+      ) {
+        fns.push(events.org.platformURLUpdated)
       }
     }
   } else {
-    switch (config.type) {
-      case ConfigType.SMTP: {
-        fns.push(events.email.SMTPUpdated)
-        break
+    if (isSMTPConfig(config)) {
+      fns.push(events.email.SMTPUpdated)
+    } else if (isGoogleConfig(config)) {
+      fns.push(() => events.auth.SSOUpdated(ConfigType.GOOGLE))
+      if (!existing.config.activated && config.config.activated) {
+        fns.push(() => events.auth.SSOActivated(ConfigType.GOOGLE))
+      } else if (existing.config.activated && !config.config.activated) {
+        fns.push(() => events.auth.SSODeactivated(ConfigType.GOOGLE))
       }
-      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
+    } else if (isOIDCConfig(config)) {
+      fns.push(() => events.auth.SSOUpdated(ConfigType.OIDC))
+      if (
+        !existing.config.configs[0].activated &&
+        config.config.configs[0].activated
+      ) {
+        fns.push(() => events.auth.SSOActivated(ConfigType.OIDC))
+      } else if (
+        existing.config.configs[0].activated &&
+        !config.config.configs[0].activated
+      ) {
+        fns.push(() => events.auth.SSODeactivated(ConfigType.OIDC))
       }
-      case ConfigType.OIDC: {
-        const oidcCfg = config as OIDCConfig
-        fns.push(() => events.auth.SSOUpdated(ssoType))
-        if (
-          !existing.config.configs[0].activated &&
-          oidcCfg.config.configs[0].activated
-        ) {
-          fns.push(() => events.auth.SSOActivated(ssoType))
-        } else if (
-          existing.config.configs[0].activated &&
-          !oidcCfg.config.configs[0].activated
-        ) {
-          fns.push(() => events.auth.SSODeactivated(ssoType))
-        }
-        break
+    } else if (isSettingsConfig(config)) {
+      // company
+      const existingCompany = existing.config.company
+      const company = config.config.company
+      if (company && company !== "Budibase" && existingCompany !== company) {
+        fns.push(events.org.nameUpdated)
       }
-      case ConfigType.SETTINGS: {
-        // company
-        const settingsCfg = config as SettingsConfig
-        const existingCompany = existing.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 = settingsCfg.config.logoUrl
-        if (logoUrl && existingLogoUrl !== logoUrl) {
-          fns.push(events.org.logoUpdated)
-        }
+      // logo
+      const existingLogoUrl = existing.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
-        if (
-          platformUrl &&
-          platformUrl !== "http://localhost:10000" &&
-          existingPlatformUrl !== platformUrl &&
-          env.SELF_HOSTED
-        ) {
-          fns.push(events.org.platformURLUpdated)
-        }
-        break
+      // platform url
+      const existingPlatformUrl = existing.config.platformUrl
+      const platformUrl = config.config.platformUrl
+      if (
+        platformUrl &&
+        platformUrl !== "http://localhost:10000" &&
+        existingPlatformUrl !== platformUrl &&
+        env.SELF_HOSTED
+      ) {
+        fns.push(events.org.platformURLUpdated)
       }
     }
   }
@@ -145,7 +125,7 @@ const getEventFns = async (db: Database, config: ConfigDoc) => {
   return fns
 }
 
-export async function save(ctx: BBContext) {
+export async function save(ctx: UserCtx) {
   const db = tenancy.getGlobalDB()
   const { type, workspace, user, config } = ctx.request.body
   let eventFns = await getEventFns(db, ctx.request.body)
@@ -187,7 +167,7 @@ export async function save(ctx: BBContext) {
   }
 }
 
-export async function fetch(ctx: BBContext) {
+export async function fetch(ctx: UserCtx) {
   const db = tenancy.getGlobalDB()
   const response = await db.allDocs(
     dbCore.getConfigParams(
@@ -204,7 +184,7 @@ 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) {
+export async function find(ctx: UserCtx) {
   const db = tenancy.getGlobalDB()
 
   const { userId, workspaceId } = ctx.query
@@ -237,18 +217,18 @@ export async function find(ctx: BBContext) {
   }
 }
 
-export async function publicOidc(ctx: BBContext) {
+export async function publicOidc(ctx: Ctx) {
   const db = tenancy.getGlobalDB()
   try {
     // Find the config with the most granular scope based on context
-    const oidcConfig = await dbCore.getScopedFullConfig(db, {
+    const oidcConfig: OIDCConfig = await dbCore.getScopedFullConfig(db, {
       type: ConfigType.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,
@@ -259,7 +239,7 @@ export async function publicOidc(ctx: BBContext) {
   }
 }
 
-export async function publicSettings(ctx: BBContext) {
+export async function publicSettings(ctx: Ctx) {
   const db = tenancy.getGlobalDB()
 
   try {
@@ -285,6 +265,16 @@ export async function publicSettings(ctx: BBContext) {
       config = publicConfig
     }
 
+    // enrich the logo url
+    // empty url means deleted
+    if (config.config.logoUrl && config.config.logoUrl !== "") {
+      config.config.logoUrl = objectStore.getGlobalFileUrl(
+        "settings",
+        "logoUrl",
+        config.config.logoUrlEtag
+      )
+    }
+
     // google button flag
     if (googleConfig && googleConfig.config) {
       // activated by default for configs pre-activated flag
@@ -311,28 +301,17 @@ export async function publicSettings(ctx: BBContext) {
   }
 }
 
-export async function upload(ctx: BBContext) {
-  if (ctx.request.files == null || ctx.request.files.file.length > 1) {
+export async function upload(ctx: UserCtx) {
+  if (ctx.request.files == null || Array.isArray(ctx.request.files.file)) {
     ctx.throw(400, "One file must be uploaded.")
   }
-  const file = ctx.request.files.file
+  const file = ctx.request.files.file as any
   const { type, name } = ctx.params
 
-  let bucket
-  if (env.SELF_HOSTED) {
-    bucket = objectStore.ObjectStoreBuckets.GLOBAL
-  } else {
-    bucket = objectStore.ObjectStoreBuckets.GLOBAL_CLOUD
-  }
-
-  let key
-  if (env.MULTI_TENANCY) {
-    key = `${tenancy.getTenantId()}/${type}/${name}`
-  } else {
-    key = `${type}/${name}`
-  }
+  let bucket = coreEnv.GLOBAL_BUCKET_NAME
+  const key = objectStore.getGlobalFileS3Key(type, name)
 
-  await objectStore.upload({
+  const result = await objectStore.upload({
     bucket,
     filename: key,
     path: file.path,
@@ -349,24 +328,26 @@ export async function upload(ctx: BBContext) {
       config: {},
     }
   }
-  let url
-  if (env.SELF_HOSTED) {
-    url = `/${bucket}/${key}`
-  } else {
-    url = `${env.CDN_URL}/${key}`
+
+  // save the Etag for cache bursting
+  const etag = result.ETag
+  if (etag) {
+    cfgStructure.config[`${name}Etag`] = etag.replace(/"/g, "")
   }
 
-  cfgStructure.config[`${name}`] = url
-  // write back to db with url updated
+  // save the file key
+  cfgStructure.config[`${name}`] = key
+
+  // write back to db
   await db.put(cfgStructure)
 
   ctx.body = {
     message: "File has been uploaded and url stored to config.",
-    url,
+    url: objectStore.getGlobalFileUrl(type, name, etag),
   }
 }
 
-export async function destroy(ctx: BBContext) {
+export async function destroy(ctx: UserCtx) {
   const db = tenancy.getGlobalDB()
   const { id, rev } = ctx.params
   try {
@@ -378,7 +359,7 @@ export async function destroy(ctx: BBContext) {
   }
 }
 
-export async function configChecklist(ctx: BBContext) {
+export async function configChecklist(ctx: Ctx) {
   const db = tenancy.getGlobalDB()
   const tenantId = tenancy.getTenantId()
 

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

@@ -0,0 +1,17 @@
+import {
+  UserCtx,
+  PostEventPublishRequest,
+  EventPublishType,
+} from "@budibase/types"
+import { events } from "@budibase/backend-core"
+
+export async function publish(ctx: UserCtx<PostEventPublishRequest, void>) {
+  switch (ctx.request.body.type) {
+    case EventPublishType.ENVIRONMENT_VARIABLE_UPGRADE_PANEL_OPENED:
+      await events.environmentVariable.upgradePanelOpened(ctx.user._id!)
+      break
+    default:
+      ctx.throw(400, "Invalid publish event type.")
+  }
+  ctx.status = 200
+}

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

@@ -178,7 +178,7 @@ export const find = async (ctx: any) => {
 
 export const tenantUserLookup = async (ctx: any) => {
   const id = ctx.params.id
-  const user = await tenancy.getTenantUser(id)
+  const user = await sdk.users.getPlatformUser(id)
   if (user) {
     ctx.body = user
   } else {
@@ -210,6 +210,19 @@ export const inviteMultiple = async (ctx: any) => {
   ctx.body = await sdk.users.invite(request)
 }
 
+export const checkInvite = async (ctx: any) => {
+  const { code } = ctx.params
+  let invite
+  try {
+    invite = await checkInviteCode(code, false)
+  } catch (e) {
+    ctx.throw(400, "There was a problem with the invite")
+  }
+  ctx.body = {
+    email: invite.email,
+  }
+}
+
 export const inviteAccept = async (ctx: any) => {
   const { inviteCode, password, firstName, lastName } = ctx.request.body
   try {

package/src/api/index.ts

@@ -62,6 +62,10 @@ const PUBLIC_ENDPOINTS = [
     route: "/api/system/restored",
     method: "POST",
   },
+  {
+    route: "/api/global/users/invite",
+    method: "GET",
+  },
 ]
 
 const NO_TENANCY_ENDPOINTS = [

package/src/api/routes/global/auth.ts

@@ -85,4 +85,4 @@ router
   .get("/api/global/auth/oidc/callback", authController.oidcAuth)
   .get("/api/admin/auth/oidc/callback", authController.oidcAuth)
 
-export = router
+export default router

package/src/api/routes/global/configs.ts

@@ -34,8 +34,8 @@ function settingValidation() {
 function googleValidation() {
   // prettier-ignore
   return Joi.object({
-    clientID: Joi.string().required(),
-    clientSecret: Joi.string().required(),
+    clientID: Joi.when('activated', { is: true, then: Joi.string().required() }),
+    clientSecret: Joi.when('activated', { is: true, then: Joi.string().required() }),
     activated: Joi.boolean().required(),
   }).unknown(true)
 }
@@ -45,12 +45,12 @@ function oidcValidation() {
   return Joi.object({
     configs: Joi.array().items(
       Joi.object({
-        clientID: Joi.string().required(),
-        clientSecret: Joi.string().required(),
-        configUrl: Joi.string().required(),
+        clientID: Joi.when('activated', { is: true, then: Joi.string().required() }),
+        clientSecret: Joi.when('activated', { is: true, then: Joi.string().required() }),
+        configUrl: Joi.when('activated', { is: true, then: Joi.string().required() }),
         logo: Joi.string().allow("", null),
         name: Joi.string().allow("", null),
-        uuid: Joi.string().required(),
+        uuid: Joi.when('activated', { is: true, then: Joi.string().required() }),
         activated: Joi.boolean().required(),
         scopes: Joi.array().optional()
       })
@@ -121,4 +121,4 @@ router
     controller.upload
   )
 
-export = router
+export default router

package/src/api/routes/global/email.ts

@@ -33,4 +33,4 @@ router.post(
   controller.sendEmail
 )
 
-export = router
+export default router

package/src/api/routes/global/events.ts

@@ -0,0 +1,8 @@
+import Router from "@koa/router"
+import * as controller from "../../controllers/global/events"
+
+const router: Router = new Router()
+
+router.post("/api/global/event/publish", controller.publish)
+
+export default router

package/src/api/routes/global/license.ts

@@ -10,4 +10,4 @@ router
   .delete("/api/global/license/info", controller.deleteInfo)
   .get("/api/global/license/usage", controller.getQuotaUsage)
 
-export = router
+export default router

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

@@ -13,4 +13,4 @@ router
     controller.removeAppRole
   )
 
-export = router
+export default router

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

@@ -15,4 +15,4 @@ router
     controller.updateSelf
   )
 
-export = router
+export default router

package/src/api/routes/global/templates.ts

@@ -34,4 +34,4 @@ router
   .get("/api/global/template/:id", controller.find)
   .delete("/api/global/template/:id/:rev", adminOnly, controller.destroy)
 
-export = router
+export default router

package/src/api/routes/global/tests/groups.spec.ts

@@ -0,0 +1,58 @@
+import { events } from "@budibase/backend-core"
+import { structures, TestConfiguration, mocks } from "../../../../tests"
+
+describe("/api/global/groups", () => {
+  const config = new TestConfiguration()
+
+  beforeAll(async () => {
+    await config.beforeAll()
+  })
+
+  afterAll(async () => {
+    await config.afterAll()
+  })
+
+  beforeEach(async () => {
+    mocks.licenses.useGroups()
+  })
+
+  describe("create", () => {
+    it("should be able to create a new group", async () => {
+      const group = structures.groups.UserGroup()
+      await config.api.groups.saveGroup(group)
+      expect(events.group.created).toBeCalledTimes(1)
+      expect(events.group.updated).not.toBeCalled()
+      expect(events.group.permissionsEdited).not.toBeCalled()
+    })
+  })
+
+  describe("update", () => {
+    it("should be able to update a basic group", async () => {
+      const group = structures.groups.UserGroup()
+      let oldGroup = await config.api.groups.saveGroup(group)
+
+      let updatedGroup = {
+        ...oldGroup.body,
+        ...group,
+        name: "New Name",
+      }
+      await config.api.groups.saveGroup(updatedGroup)
+
+      expect(events.group.updated).toBeCalledTimes(1)
+      expect(events.group.permissionsEdited).not.toBeCalled()
+    })
+
+    describe("destroy", () => {
+      it("should be able to delete a basic group", async () => {
+        const group = structures.groups.UserGroup()
+        let oldGroup = await config.api.groups.saveGroup(group)
+        await config.api.groups.deleteGroup(
+          oldGroup.body._id,
+          oldGroup.body._rev
+        )
+
+        expect(events.group.deleted).toBeCalledTimes(1)
+      })
+    })
+  })
+})