@budibase/worker 1.0.199 → 1.0.200-alpha.2

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

@@ -1,35 +1,22 @@
-const {
-  getGlobalUserParams,
-  StaticDatabases,
-} = require("@budibase/backend-core/db")
-const { getGlobalUserByEmail } = require("@budibase/backend-core/utils")
-const { user: userCache } = require("@budibase/backend-core/cache")
-const { invalidateSessions } = require("@budibase/backend-core/sessions")
-const accounts = require("@budibase/backend-core/accounts")
-const {
-  getGlobalDB,
-  doWithGlobalDB,
-  getTenantId,
-  getTenantUser,
-  doesTenantExist,
-  doInTenant,
-} = require("@budibase/backend-core/tenancy")
-const { removeUserFromInfoDB } = require("@budibase/backend-core/deprovision")
-const { errors } = require("@budibase/backend-core")
-const { CacheKeys, bustCache } = require("@budibase/backend-core/cache")
-import env from "../../../environment"
-import { syncUserInApps } from "../../../utilities/appService"
-import { quotas, users } from "@budibase/pro"
-import { allUsers, getUser } from "../../utilities"
 import { EmailTemplatePurpose } from "../../../constants"
 import { checkInviteCode } from "../../../utilities/redis"
 import { sendEmail } from "../../../utilities/email"
+import { users } from "../../../sdk"
+import env from "../../../environment"
+import { User, CloudAccount } from "@budibase/types"
+import {
+  events,
+  errors,
+  accounts,
+  db as dbUtils,
+  users as usersCore,
+  tenancy,
+  cache,
+} from "@budibase/backend-core"
 
 export const save = async (ctx: any) => {
   try {
-    const user: any = await users.save(ctx.request.body, getTenantId())
-    // let server know to sync user
-    await syncUserInApps(user._id)
+    const user = await users.save(ctx.request.body)
     ctx.body = user
   } catch (err: any) {
     ctx.throw(err.status || 400, err)
@@ -42,38 +29,22 @@ const parseBooleanParam = (param: any) => {
 
 export const adminUser = async (ctx: any) => {
   const { email, password, tenantId } = ctx.request.body
-  await doInTenant(tenantId, async () => {
+  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)
     // account portal sends no password for SSO users
     const requirePassword = parseBooleanParam(ctx.request.query.requirePassword)
 
-    if (await doesTenantExist(tenantId)) {
+    if (await tenancy.doesTenantExist(tenantId)) {
       ctx.throw(403, "Organisation already exists.")
     }
 
-    const response = await doWithGlobalDB(tenantId, async (db: any) => {
-      const response = await db.allDocs(
-        getGlobalUserParams(null, {
+    const response = await tenancy.doWithGlobalDB(tenantId, async (db: any) => {
+      return db.allDocs(
+        dbUtils.getGlobalUserParams(null, {
           include_docs: true,
         })
       )
-      // write usage quotas for cloud
-      if (!env.SELF_HOSTED) {
-        // could be a scenario where it exists, make sure its clean
-        try {
-          const usageQuota = await db.get(
-            StaticDatabases.GLOBAL.docs.usageQuota
-          )
-          if (usageQuota) {
-            await db.remove(usageQuota._id, usageQuota._rev)
-          }
-        } catch (err) {
-          // don't worry about errors
-        }
-        await db.put(quotas.generateNewQuotaUsage())
-      }
-      return response
     })
 
     if (response.rows.some((row: any) => row.doc.admin)) {
@@ -83,7 +54,7 @@ export const adminUser = async (ctx: any) => {
       )
     }
 
-    const user = {
+    const user: User = {
       email: email,
       password: password,
       createdAt: Date.now(),
@@ -97,13 +68,19 @@ export const adminUser = async (ctx: any) => {
       tenantId,
     }
     try {
-      const finalUser = await users.save(
-        user,
-        tenantId,
+      const finalUser = await users.save(user, {
         hashPassword,
-        requirePassword
-      )
-      await bustCache(CacheKeys.CHECKLIST)
+        requirePassword,
+      })
+      await cache.bustCache(cache.CacheKeys.CHECKLIST)
+
+      // events
+      let account: CloudAccount | undefined
+      if (!env.SELF_HOSTED && !env.DISABLE_ACCOUNT_PORTAL) {
+        account = await accounts.getAccountByTenantId(tenantId)
+      }
+      await events.identification.identifyTenantGroup(tenantId, account)
+
       ctx.body = finalUser
     } catch (err: any) {
       ctx.throw(err.status || 400, err)
@@ -112,37 +89,16 @@ export const adminUser = async (ctx: any) => {
 }
 
 export const destroy = async (ctx: any) => {
-  const db = getGlobalDB()
-  const dbUser = await db.get(ctx.params.id)
-
-  if (!env.SELF_HOSTED && !env.DISABLE_ACCOUNT_PORTAL) {
-    // root account holder can't be deleted from inside budibase
-    const email = dbUser.email
-    const account = await accounts.getAccount(email)
-    if (account) {
-      if (email === ctx.user.email) {
-        ctx.throw(400, 'Please visit "Account" to delete this user')
-      } else {
-        ctx.throw(400, "Account holder cannot be deleted")
-      }
-    }
-  }
-
-  await removeUserFromInfoDB(dbUser)
-  await db.remove(dbUser._id, dbUser._rev)
-  await quotas.removeUser(dbUser)
-  await userCache.invalidateUser(dbUser._id)
-  await invalidateSessions(dbUser._id)
-  // let server know to sync user
-  await syncUserInApps(dbUser._id)
+  const id = ctx.params.id
+  await users.destroy(id, ctx.user)
   ctx.body = {
-    message: `User ${ctx.params.id} deleted.`,
+    message: `User ${id} deleted.`,
   }
 }
 
 // called internally by app server user fetch
 export const fetch = async (ctx: any) => {
-  const all = await allUsers()
+  const all = await users.allUsers()
   // user hashed password shouldn't ever be returned
   for (let user of all) {
     if (user) {
@@ -154,12 +110,12 @@ export const fetch = async (ctx: any) => {
 
 // called internally by app server user find
 export const find = async (ctx: any) => {
-  ctx.body = await getUser(ctx.params.id)
+  ctx.body = await users.getUser(ctx.params.id)
 }
 
 export const tenantUserLookup = async (ctx: any) => {
   const id = ctx.params.id
-  const user = await getTenantUser(id)
+  const user = await tenancy.getTenantUser(id)
   if (user) {
     ctx.body = user
   } else {
@@ -169,14 +125,14 @@ export const tenantUserLookup = async (ctx: any) => {
 
 export const invite = async (ctx: any) => {
   let { email, userInfo } = ctx.request.body
-  const existing = await getGlobalUserByEmail(email)
+  const existing = await usersCore.getGlobalUserByEmail(email)
   if (existing) {
     ctx.throw(400, "Email address already in use.")
   }
   if (!userInfo) {
     userInfo = {}
   }
-  userInfo.tenantId = getTenantId()
+  userInfo.tenantId = tenancy.getTenantId()
   const opts: any = {
     subject: "{{ company }} platform invitation",
     info: userInfo,
@@ -185,6 +141,7 @@ export const invite = async (ctx: any) => {
   ctx.body = {
     message: "Invitation has been sent.",
   }
+  await events.user.invited()
 }
 
 export const inviteAccept = async (ctx: any) => {
@@ -192,16 +149,19 @@ export const inviteAccept = async (ctx: any) => {
   try {
     // info is an extension of the user object that was stored by global
     const { email, info }: any = await checkInviteCode(inviteCode)
-    ctx.body = await users.save(
-      {
+    ctx.body = await tenancy.doInTenant(info.tenantId, async () => {
+      const saved = await users.save({
         firstName,
         lastName,
         password,
         email,
         ...info,
-      },
-      info.tenantId
-    )
+      })
+      const db = tenancy.getGlobalDB()
+      const user = await db.get(saved._id)
+      await events.user.inviteAccepted(user)
+      return saved
+    })
   } catch (err: any) {
     if (err.code === errors.codes.USAGE_LIMIT_EXCEEDED) {
       // explicitly re-throw limit exceeded errors

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

@@ -1,7 +1,7 @@
 const Router = require("@koa/router")
 const controller = require("../../controllers/global/self")
 const builderOnly = require("../../../middleware/builderOnly")
-const { buildUserSaveValidation } = require("../../utilities/validation")
+const { users } = require("../validation")
 
 const router = Router()
 
@@ -11,7 +11,7 @@ router
   .get("/api/global/self", controller.getSelf)
   .post(
     "/api/global/self",
-    buildUserSaveValidation(true),
+    users.buildUserSaveValidation(true),
     controller.updateSelf
   )
 

package/src/api/routes/global/users.js

@@ -4,7 +4,7 @@ const joiValidator = require("../../../middleware/joi-validator")
 const adminOnly = require("../../../middleware/adminOnly")
 const Joi = require("joi")
 const cloudRestricted = require("../../../middleware/cloudRestricted")
-const { buildUserSaveValidation } = require("../../utilities/validation")
+const { users } = require("../validation")
 const selfController = require("../../controllers/global/self")
 const builderOrAdmin = require("../../../middleware/builderOrAdmin")
 
@@ -42,7 +42,7 @@ router
   .post(
     "/api/global/users",
     adminOnly,
-    buildUserSaveValidation(),
+    users.buildUserSaveValidation(),
     controller.save
   )
   .get("/api/global/users", builderOrAdmin, controller.fetch)
@@ -73,7 +73,7 @@ router
   .get("/api/global/users/self", selfController.getSelf)
   .post(
     "/api/global/users/self",
-    buildUserSaveValidation(true),
+    users.buildUserSaveValidation(true),
     selfController.updateSelf
   )
 

package/src/api/routes/tests/auth.spec.js

@@ -1,26 +1,25 @@
 jest.mock("nodemailer")
-const setup = require("./utilities")
-const sendMailMock = setup.emailMock()
+const { config, request, mocks, structures } = require("../../../tests")
+const sendMailMock = mocks.email.mock()
+const { events } = require("@budibase/backend-core")
 
-const TENANT_ID = "default"
+const TENANT_ID = structures.TENANT_ID
 
 describe("/api/global/auth", () => {
-  let request = setup.getRequest()
-  let config = setup.getConfig()
-  let code
 
   beforeAll(async () => {
-    await config.init()
+    await config.beforeAll()
   })
 
-  afterAll(setup.afterAll)
+  afterAll(async () => {
+    await config.afterAll()
+  })
 
   afterEach(() => {
     jest.clearAllMocks()
   })
 
-  it("should be able to generate password reset email", async () => {
-    // initially configure settings
+  const requestPasswordReset = async () => {
     await config.saveSmtpConfig()
     await config.saveSettingsConfig()
     await config.createUser()
@@ -31,16 +30,37 @@ describe("/api/global/auth", () => {
       })
       .expect("Content-Type", /json/)
       .expect(200)
-    expect(res.body).toEqual({ message: "Please check your email for a reset link." })
-    expect(sendMailMock).toHaveBeenCalled()
     const emailCall = sendMailMock.mock.calls[0][0]
-    // after this URL there should be a code
     const parts = emailCall.html.split(`http://localhost:10000/builder/auth/reset?code=`)
-    code = parts[1].split("\"")[0].split("&")[0]
+    const code = parts[1].split("\"")[0].split("&")[0]
+    return { code, res }
+  }
+
+  it("should logout", async () => {
+    await request
+      .post("/api/global/auth/logout")
+      .set(config.defaultHeaders())
+      .expect(200)
+    expect(events.auth.logout).toBeCalledTimes(1)
+  })
+
+  it("should be able to generate password reset email", async () => {
+    const { res, code } = await requestPasswordReset()
+    const user = await config.getUser("test@test.com")
+
+    expect(res.body).toEqual({ message: "Please check your email for a reset link." })
+    expect(sendMailMock).toHaveBeenCalled()
+    
     expect(code).toBeDefined()
+    expect(events.user.passwordResetRequested).toBeCalledTimes(1)
+    expect(events.user.passwordResetRequested).toBeCalledWith(user)
   })
 
   it("should allow resetting user password with code", async () => {
+    const { code } = await requestPasswordReset()
+    const user = await config.getUser("test@test.com")
+    delete user.password 
+
     const res = await request
       .post(`/api/global/auth/${TENANT_ID}/reset/update`)
       .send({
@@ -50,14 +70,16 @@ describe("/api/global/auth", () => {
       .expect("Content-Type", /json/)
       .expect(200)
     expect(res.body).toEqual({ message: "password reset successfully." })
+    expect(events.user.passwordReset).toBeCalledTimes(1)
+    expect(events.user.passwordReset).toBeCalledWith(user)
   })
 
   describe("oidc", () => {
     const auth = require("@budibase/backend-core/auth")
 
     // mock the oidc strategy implementation and return value
-    strategyFactory = jest.fn()
-    mockStrategyReturn = jest.fn()
+    let strategyFactory = jest.fn()
+    let mockStrategyReturn = jest.fn()
     strategyFactory.mockReturnValue(mockStrategyReturn)
     auth.oidc.strategyFactory = strategyFactory
 

package/src/api/routes/tests/configs.spec.js

@@ -1,17 +1,233 @@
 // mock the email system
 jest.mock("nodemailer")
-const setup = require("./utilities")
-setup.emailMock()
+const { config, structures, mocks, request } = require("../../../tests")
+mocks.email.mock()
+const { Configs } = require("@budibase/backend-core/constants")
+const { events } = require("@budibase/backend-core")
 
-describe("/api/global/configs/checklist", () => {
-  let request = setup.getRequest()
-  let config = setup.getConfig()
+describe("configs", () => {
 
   beforeAll(async () => {
-    await config.init()
+    await config.beforeAll()
   })
 
-  afterAll(setup.afterAll)
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  afterAll(async () => {
+    await config.afterAll()
+  })
+
+  describe("post /api/global/configs", () => {
+
+    const saveConfig = async (conf, _id, _rev) => {
+      const data = {
+        ...conf,
+        _id,
+        _rev
+      }
+
+      const res = await request
+        .post(`/api/global/configs`)
+        .send(data)
+        .set(config.defaultHeaders())
+        .expect("Content-Type", /json/)
+        .expect(200)
+
+      return {
+        ...data,
+        ...res.body
+      }
+    }
+
+    describe("google", () => {
+      const saveGoogleConfig = async (conf, _id, _rev) => {
+        const googleConfig = structures.configs.google(conf)
+        return saveConfig(googleConfig, _id, _rev)
+      }
+  
+      describe("create", () => {
+        it ("should create activated google config", async () => {
+          await saveGoogleConfig()
+          expect(events.auth.SSOCreated).toBeCalledTimes(1)
+          expect(events.auth.SSOCreated).toBeCalledWith(Configs.GOOGLE)
+          expect(events.auth.SSODeactivated).not.toBeCalled()
+          expect(events.auth.SSOActivated).toBeCalledTimes(1)
+          expect(events.auth.SSOActivated).toBeCalledWith(Configs.GOOGLE)
+          await config.deleteConfig(Configs.GOOGLE)
+        })
+
+        it ("should create deactivated google config", async () => {
+          await saveGoogleConfig({ activated: false })
+          expect(events.auth.SSOCreated).toBeCalledTimes(1)
+          expect(events.auth.SSOCreated).toBeCalledWith(Configs.GOOGLE)
+          expect(events.auth.SSOActivated).not.toBeCalled()
+          expect(events.auth.SSODeactivated).not.toBeCalled()
+          await config.deleteConfig(Configs.GOOGLE)
+        })
+      })
+
+      describe("update", () => {
+        it ("should update google config to deactivated", async () => {
+          const googleConf = await saveGoogleConfig()
+          jest.clearAllMocks()
+          await saveGoogleConfig({ ...googleConf.config, activated: false }, googleConf._id, googleConf._rev)
+          expect(events.auth.SSOUpdated).toBeCalledTimes(1)
+          expect(events.auth.SSOUpdated).toBeCalledWith(Configs.GOOGLE)
+          expect(events.auth.SSOActivated).not.toBeCalled()
+          expect(events.auth.SSODeactivated).toBeCalledTimes(1)
+          expect(events.auth.SSODeactivated).toBeCalledWith(Configs.GOOGLE)
+          await config.deleteConfig(Configs.GOOGLE)
+        })
+
+        it ("should update google config to activated", async () => {
+          const googleConf = await saveGoogleConfig({ activated: false })
+          jest.clearAllMocks()
+          await saveGoogleConfig({ ...googleConf.config, activated: true}, googleConf._id, googleConf._rev)
+          expect(events.auth.SSOUpdated).toBeCalledTimes(1)
+          expect(events.auth.SSOUpdated).toBeCalledWith(Configs.GOOGLE)
+          expect(events.auth.SSODeactivated).not.toBeCalled()
+          expect(events.auth.SSOActivated).toBeCalledTimes(1)
+          expect(events.auth.SSOActivated).toBeCalledWith(Configs.GOOGLE)
+          await config.deleteConfig(Configs.GOOGLE)
+        })
+      })     
+    })
+
+    describe("oidc", () => {
+      const saveOIDCConfig = async (conf, _id, _rev) => {
+        const oidcConfig = structures.configs.oidc(conf)
+        return saveConfig(oidcConfig, _id, _rev)
+      }
+
+      describe("create", () => {
+        it ("should create activated OIDC config", async () => {
+          await saveOIDCConfig()
+          expect(events.auth.SSOCreated).toBeCalledTimes(1)
+          expect(events.auth.SSOCreated).toBeCalledWith(Configs.OIDC)
+          expect(events.auth.SSODeactivated).not.toBeCalled()
+          expect(events.auth.SSOActivated).toBeCalledTimes(1)
+          expect(events.auth.SSOActivated).toBeCalledWith(Configs.OIDC)
+          await config.deleteConfig(Configs.OIDC)
+        })
+
+        it ("should create deactivated OIDC config", async () => {
+          await saveOIDCConfig({ activated: false })
+          expect(events.auth.SSOCreated).toBeCalledTimes(1)
+          expect(events.auth.SSOCreated).toBeCalledWith(Configs.OIDC)
+          expect(events.auth.SSOActivated).not.toBeCalled()
+          expect(events.auth.SSODeactivated).not.toBeCalled()
+          await config.deleteConfig(Configs.OIDC)
+        })
+      })
+
+      describe("update", () => {
+        it ("should update OIDC config to deactivated", async () => {
+          const oidcConf = await saveOIDCConfig()
+          jest.clearAllMocks()
+          await saveOIDCConfig({ ...oidcConf.config.configs[0], activated: false }, oidcConf._id, oidcConf._rev)
+          expect(events.auth.SSOUpdated).toBeCalledTimes(1)
+          expect(events.auth.SSOUpdated).toBeCalledWith(Configs.OIDC)
+          expect(events.auth.SSOActivated).not.toBeCalled()
+          expect(events.auth.SSODeactivated).toBeCalledTimes(1)
+          expect(events.auth.SSODeactivated).toBeCalledWith(Configs.OIDC)
+          await config.deleteConfig(Configs.OIDC)
+        })
+
+        it ("should update OIDC config to activated", async () => {
+          const oidcConf = await saveOIDCConfig({ activated: false })
+          jest.clearAllMocks()
+          await saveOIDCConfig({ ...oidcConf.config.configs[0], activated: true}, oidcConf._id, oidcConf._rev)
+          expect(events.auth.SSOUpdated).toBeCalledTimes(1)
+          expect(events.auth.SSOUpdated).toBeCalledWith(Configs.OIDC)
+          expect(events.auth.SSODeactivated).not.toBeCalled()
+          expect(events.auth.SSOActivated).toBeCalledTimes(1)
+          expect(events.auth.SSOActivated).toBeCalledWith(Configs.OIDC)
+          await config.deleteConfig(Configs.OIDC)
+        })
+      })
+
+    })
+
+    describe("smtp", () => {
+      const saveSMTPConfig = async (conf, _id, _rev) => {
+        const smtpConfig = structures.configs.smtp(conf)
+        return saveConfig(smtpConfig, _id, _rev)
+      }
+
+      describe("create", () => {
+        it ("should create SMTP config", async () => {
+          await config.deleteConfig(Configs.SMTP)
+          await saveSMTPConfig()
+          expect(events.email.SMTPUpdated).not.toBeCalled()
+          expect(events.email.SMTPCreated).toBeCalledTimes(1)
+          await config.deleteConfig(Configs.SMTP)
+        })
+      })
+
+      describe("update", () => {
+        it ("should update SMTP config", async () => {
+          const smtpConf = await saveSMTPConfig()
+          jest.clearAllMocks()
+          await saveSMTPConfig(smtpConf.config, smtpConf._id, smtpConf._rev)
+          expect(events.email.SMTPCreated).not.toBeCalled()
+          expect(events.email.SMTPUpdated).toBeCalledTimes(1)
+          await config.deleteConfig(Configs.SMTP)
+        })
+      })
+    })
+
+    describe("settings", () => {
+      const saveSettingsConfig = async (conf, _id, _rev) => {
+        const settingsConfig = structures.configs.settings(conf)
+        return saveConfig(settingsConfig, _id, _rev)
+      }
+
+      describe("create", () => {
+        it ("should create settings config with default settings", async () => {
+          await config.deleteConfig(Configs.SETTINGS)
+          
+          await saveSettingsConfig()
+
+          expect(events.org.nameUpdated).not.toBeCalled()
+          expect(events.org.logoUpdated).not.toBeCalled()
+          expect(events.org.platformURLUpdated).not.toBeCalled()
+        })
+
+        it ("should create settings config with non-default settings", async () => {
+          await config.deleteConfig(Configs.SETTINGS)
+          const conf = {
+            company: "acme",
+            logoUrl: "http://example.com",
+            platformUrl: "http://example.com"
+          }
+
+          await saveSettingsConfig(conf)
+          
+          expect(events.org.nameUpdated).toBeCalledTimes(1)
+          expect(events.org.logoUpdated).toBeCalledTimes(1)
+          expect(events.org.platformURLUpdated).toBeCalledTimes(1)
+        })
+      })
+
+      describe("update", () => {
+        it ("should update settings config", async () => {
+          await config.deleteConfig(Configs.SETTINGS)
+          const settingsConfig = await saveSettingsConfig()
+          settingsConfig.config.company = "acme"
+          settingsConfig.config.logoUrl = "http://example.com"
+          settingsConfig.config.platformUrl = "http://example.com"
+
+          await saveSettingsConfig(settingsConfig.config, settingsConfig._id, settingsConfig._rev)
+
+          expect(events.org.nameUpdated).toBeCalledTimes(1)
+          expect(events.org.logoUpdated).toBeCalledTimes(1)
+          expect(events.org.platformURLUpdated).toBeCalledTimes(1)
+        })
+      })
+    })
+  })
 
   it("should return the correct checklist status based on the state of the budibase installation", async () => {
     await config.saveSmtpConfig()

package/src/api/routes/tests/email.spec.js

@@ -1,19 +1,20 @@
 jest.mock("nodemailer")
-const setup = require("./utilities")
-const sendMailMock = setup.emailMock()
+const { config, mocks, structures, request } = require("../../../tests")
+const sendMailMock = mocks.email.mock()
 
 const { EmailTemplatePurpose } = require("../../../constants")
-const { TENANT_ID } = require("./utilities/structures")
+
+const TENANT_ID = structures.TENANT_ID
 
 describe("/api/global/email", () => {
-  let request = setup.getRequest()
-  let config = setup.getConfig()
 
   beforeAll(async () => {
-    await config.init()
+    await config.beforeAll()
   })
 
-  afterAll(setup.afterAll)
+  afterAll(async () => {
+    await config.afterAll()
+  })
 
   it("should be able to send an email (with mocking)", async () => {
     // initially configure settings

package/src/api/routes/tests/realEmail.spec.js

@@ -1,4 +1,4 @@
-const setup = require("./utilities")
+const { config, request } = require("../../../tests")
 const { EmailTemplatePurpose } = require("../../../constants")
 const nodemailer = require("nodemailer")
 const fetch = require("node-fetch")
@@ -7,14 +7,14 @@ const fetch = require("node-fetch")
 jest.setTimeout(30000)
 
 describe("/api/global/email", () => {
-  let request = setup.getRequest()
-  let config = setup.getConfig()
 
   beforeAll(async () => {
-    await config.init()
+    await config.beforeAll()
   })
 
-  afterAll(setup.afterAll)
+  afterAll(async () => {
+    await config.afterAll()
+  })
 
   async function sendRealEmail(purpose) {
     let response, text