@budibase/worker 1.0.200-alpha.3 → 1.0.200

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

@@ -1,22 +1,35 @@
+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 = await users.save(ctx.request.body)
+    const user: any = await users.save(ctx.request.body, getTenantId())
+    // let server know to sync user
+    await syncUserInApps(user._id)
     ctx.body = user
   } catch (err: any) {
     ctx.throw(err.status || 400, err)
@@ -29,22 +42,38 @@ const parseBooleanParam = (param: any) => {
 
 export const adminUser = async (ctx: any) => {
   const { email, password, tenantId } = ctx.request.body
-  await tenancy.doInTenant(tenantId, async () => {
+  await 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 tenancy.doesTenantExist(tenantId)) {
+    if (await doesTenantExist(tenantId)) {
       ctx.throw(403, "Organisation already exists.")
     }
 
-    const response = await tenancy.doWithGlobalDB(tenantId, async (db: any) => {
-      return db.allDocs(
-        dbUtils.getGlobalUserParams(null, {
+    const response = await doWithGlobalDB(tenantId, async (db: any) => {
+      const response = await db.allDocs(
+        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)) {
@@ -54,7 +83,7 @@ export const adminUser = async (ctx: any) => {
       )
     }
 
-    const user: User = {
+    const user = {
       email: email,
       password: password,
       createdAt: Date.now(),
@@ -68,19 +97,13 @@ export const adminUser = async (ctx: any) => {
       tenantId,
     }
     try {
-      const finalUser = await users.save(user, {
+      const finalUser = await users.save(
+        user,
+        tenantId,
         hashPassword,
-        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)
-
+        requirePassword
+      )
+      await bustCache(CacheKeys.CHECKLIST)
       ctx.body = finalUser
     } catch (err: any) {
       ctx.throw(err.status || 400, err)
@@ -89,16 +112,37 @@ export const adminUser = async (ctx: any) => {
 }
 
 export const destroy = async (ctx: any) => {
-  const id = ctx.params.id
-  await users.destroy(id, ctx.user)
+  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)
   ctx.body = {
-    message: `User ${id} deleted.`,
+    message: `User ${ctx.params.id} deleted.`,
   }
 }
 
 // called internally by app server user fetch
 export const fetch = async (ctx: any) => {
-  const all = await users.allUsers()
+  const all = await allUsers()
   // user hashed password shouldn't ever be returned
   for (let user of all) {
     if (user) {
@@ -110,12 +154,12 @@ export const fetch = async (ctx: any) => {
 
 // called internally by app server user find
 export const find = async (ctx: any) => {
-  ctx.body = await users.getUser(ctx.params.id)
+  ctx.body = await getUser(ctx.params.id)
 }
 
 export const tenantUserLookup = async (ctx: any) => {
   const id = ctx.params.id
-  const user = await tenancy.getTenantUser(id)
+  const user = await getTenantUser(id)
   if (user) {
     ctx.body = user
   } else {
@@ -125,14 +169,14 @@ export const tenantUserLookup = async (ctx: any) => {
 
 export const invite = async (ctx: any) => {
   let { email, userInfo } = ctx.request.body
-  const existing = await usersCore.getGlobalUserByEmail(email)
+  const existing = await getGlobalUserByEmail(email)
   if (existing) {
     ctx.throw(400, "Email address already in use.")
   }
   if (!userInfo) {
     userInfo = {}
   }
-  userInfo.tenantId = tenancy.getTenantId()
+  userInfo.tenantId = getTenantId()
   const opts: any = {
     subject: "{{ company }} platform invitation",
     info: userInfo,
@@ -141,7 +185,6 @@ export const invite = async (ctx: any) => {
   ctx.body = {
     message: "Invitation has been sent.",
   }
-  await events.user.invited()
 }
 
 export const inviteAccept = async (ctx: any) => {
@@ -149,19 +192,16 @@ 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 tenancy.doInTenant(info.tenantId, async () => {
-      const saved = await users.save({
+    ctx.body = await users.save(
+      {
         firstName,
         lastName,
         password,
         email,
         ...info,
-      })
-      const db = tenancy.getGlobalDB()
-      const user = await db.get(saved._id)
-      await events.user.inviteAccepted(user)
-      return saved
-    })
+      },
+      info.tenantId
+    )
   } 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 { users } = require("../validation")
+const { buildUserSaveValidation } = require("../../utilities/validation")
 
 const router = Router()
 
@@ -11,7 +11,7 @@ router
   .get("/api/global/self", controller.getSelf)
   .post(
     "/api/global/self",
-    users.buildUserSaveValidation(true),
+    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 { users } = require("../validation")
+const { buildUserSaveValidation } = require("../../utilities/validation")
 const selfController = require("../../controllers/global/self")
 const builderOrAdmin = require("../../../middleware/builderOrAdmin")
 
@@ -42,7 +42,7 @@ router
   .post(
     "/api/global/users",
     adminOnly,
-    users.buildUserSaveValidation(),
+    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",
-    users.buildUserSaveValidation(true),
+    buildUserSaveValidation(true),
     selfController.updateSelf
   )
 

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

@@ -1,25 +1,26 @@
 jest.mock("nodemailer")
-const { config, request, mocks, structures } = require("../../../tests")
-const sendMailMock = mocks.email.mock()
-const { events } = require("@budibase/backend-core")
+const setup = require("./utilities")
+const sendMailMock = setup.emailMock()
 
-const TENANT_ID = structures.TENANT_ID
+const TENANT_ID = "default"
 
 describe("/api/global/auth", () => {
+  let request = setup.getRequest()
+  let config = setup.getConfig()
+  let code
 
   beforeAll(async () => {
-    await config.beforeAll()
+    await config.init()
   })
 
-  afterAll(async () => {
-    await config.afterAll()
-  })
+  afterAll(setup.afterAll)
 
   afterEach(() => {
     jest.clearAllMocks()
   })
 
-  const requestPasswordReset = async () => {
+  it("should be able to generate password reset email", async () => {
+    // initially configure settings
     await config.saveSmtpConfig()
     await config.saveSettingsConfig()
     await config.createUser()
@@ -30,37 +31,16 @@ describe("/api/global/auth", () => {
       })
       .expect("Content-Type", /json/)
       .expect(200)
-    const emailCall = sendMailMock.mock.calls[0][0]
-    const parts = emailCall.html.split(`http://localhost:10000/builder/auth/reset?code=`)
-    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()
-    
+    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]
     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({
@@ -70,16 +50,14 @@ 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
-    let strategyFactory = jest.fn()
-    let mockStrategyReturn = jest.fn()
+    strategyFactory = jest.fn()
+    mockStrategyReturn = jest.fn()
     strategyFactory.mockReturnValue(mockStrategyReturn)
     auth.oidc.strategyFactory = strategyFactory
 

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

@@ -1,233 +1,17 @@
 // mock the email system
 jest.mock("nodemailer")
-const { config, structures, mocks, request } = require("../../../tests")
-mocks.email.mock()
-const { Configs } = require("@budibase/backend-core/constants")
-const { events } = require("@budibase/backend-core")
+const setup = require("./utilities")
+setup.emailMock()
 
-describe("configs", () => {
+describe("/api/global/configs/checklist", () => {
+  let request = setup.getRequest()
+  let config = setup.getConfig()
 
   beforeAll(async () => {
-    await config.beforeAll()
+    await config.init()
   })
 
-  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)
-        })
-      })
-    })
-  })
+  afterAll(setup.afterAll)
 
   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,20 +1,19 @@
 jest.mock("nodemailer")
-const { config, mocks, structures, request } = require("../../../tests")
-const sendMailMock = mocks.email.mock()
+const setup = require("./utilities")
+const sendMailMock = setup.emailMock()
 
 const { EmailTemplatePurpose } = require("../../../constants")
-
-const TENANT_ID = structures.TENANT_ID
+const { TENANT_ID } = require("./utilities/structures")
 
 describe("/api/global/email", () => {
+  let request = setup.getRequest()
+  let config = setup.getConfig()
 
   beforeAll(async () => {
-    await config.beforeAll()
+    await config.init()
   })
 
-  afterAll(async () => {
-    await config.afterAll()
-  })
+  afterAll(setup.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 { config, request } = require("../../../tests")
+const setup = require("./utilities")
 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.beforeAll()
+    await config.init()
   })
 
-  afterAll(async () => {
-    await config.afterAll()
-  })
+  afterAll(setup.afterAll)
 
   async function sendRealEmail(purpose) {
     let response, text