@budibase/worker 1.0.199 → 1.0.200-alpha.2

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

@@ -0,0 +1,58 @@
+jest.mock("nodemailer")
+const { config, request } = require("../../../tests")
+const { events } = require("@budibase/backend-core")
+
+describe("/api/global/self", () => {
+
+  beforeAll(async () => {
+    await config.beforeAll()
+  })
+
+  afterAll(async () => {
+    await config.afterAll()
+  })
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  const updateSelf = async (user) => {
+    const res = await request
+      .post(`/api/global/self`)
+      .send(user)
+      .set(config.defaultHeaders())
+      .expect("Content-Type", /json/)
+      .expect(200)
+    return res
+  }
+
+  describe("update", () => {
+
+    it("should update self", async () => {
+      const user = await config.createUser()
+
+      delete user.password
+      const res = await updateSelf(user)
+
+      expect(res.body._id).toBe(user._id)
+      expect(events.user.updated).toBeCalledTimes(1)
+      expect(events.user.updated).toBeCalledWith(user)
+      expect(events.user.passwordUpdated).not.toBeCalled()
+    })
+
+    it("should update password", async () => {
+      const user = await config.createUser()
+      const password = "newPassword" 
+      user.password = password
+
+      const res = await updateSelf(user)
+
+      delete user.password
+      expect(res.body._id).toBe(user._id)
+      expect(events.user.updated).toBeCalledTimes(1)
+      expect(events.user.updated).toBeCalledWith(user)
+      expect(events.user.passwordUpdated).toBeCalledTimes(1)
+      expect(events.user.passwordUpdated).toBeCalledWith(user)
+    })
+  })
+})

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

@@ -1,20 +1,19 @@
 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")
 
 describe("/api/global/users", () => {
-  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()
+  })
 
-  it("should be able to generate an invitation", async () => {
-    // initially configure settings
+  const sendUserInvite = async () => {
     await config.saveSmtpConfig()
     await config.saveSettingsConfig()
     const res = await request
@@ -25,16 +24,26 @@ describe("/api/global/users", () => {
       .set(config.defaultHeaders())
       .expect("Content-Type", /json/)
       .expect(200)
+    
+      const emailCall = sendMailMock.mock.calls[0][0]
+      // after this URL there should be a code
+    const parts = emailCall.html.split("http://localhost:10000/builder/invite?code=")
+    const code = parts[1].split("\"")[0].split("&")[0]
+    return { code, res }
+  }
+
+  it("should be able to generate an invitation", async () => {
+    const { code, res } = await sendUserInvite()
+
     expect(res.body).toEqual({ message: "Invitation has been sent." })
     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/invite?code=")
-    code = parts[1].split("\"")[0].split("&")[0]
     expect(code).toBeDefined()
+    expect(events.user.invited).toBeCalledTimes(1)
   })
 
   it("should be able to create new user from invite", async () => {
+    const { code } = await sendUserInvite()
+
     const res = await request
       .post(`/api/global/users/invite/accept`)
       .send({
@@ -47,5 +56,282 @@ describe("/api/global/users", () => {
     const user = await config.getUser("invite@test.com")
     expect(user).toBeDefined()
     expect(user._id).toEqual(res.body._id)
+    expect(events.user.inviteAccepted).toBeCalledTimes(1)
+    expect(events.user.inviteAccepted).toBeCalledWith(user)
+  })
+
+  const createUser = async (user) => { 
+    const existing = await config.getUser(user.email)
+    if (existing) {
+      await deleteUser(existing._id)
+    }
+    return saveUser(user)
+  }
+
+  const updateUser = async (user) => {
+    const existing = await config.getUser(user.email)
+    user._id = existing._id
+    return saveUser(user)
+  }
+
+  const saveUser = async (user) => {
+    const res = await request
+      .post(`/api/global/users`)
+      .send(user)
+      .set(config.defaultHeaders())
+      .expect("Content-Type", /json/)
+      .expect(200)
+    return res.body
+  }
+
+  const deleteUser = async (email) => {
+    const user = await config.getUser(email)
+    if (user) {
+      await request
+      .delete(`/api/global/users/${user._id}`)
+      .set(config.defaultHeaders())
+      .expect("Content-Type", /json/)
+      .expect(200)
+    }
+  }
+
+  describe("create", () => {
+    it("should be able to create a basic user", async () => {
+      jest.clearAllMocks()
+      const user = structures.users.user({ email: "basic@test.com" })
+      await createUser(user)
+
+      expect(events.user.created).toBeCalledTimes(1)
+      expect(events.user.updated).not.toBeCalled()
+      expect(events.user.permissionBuilderAssigned).not.toBeCalled()
+      expect(events.user.permissionAdminAssigned).not.toBeCalled()
+    })
+
+    it("should be able to create an admin user", async () => {
+      jest.clearAllMocks()
+      const user = structures.users.adminUser({ email: "admin@test.com" })
+      await createUser(user)      
+
+      expect(events.user.created).toBeCalledTimes(1)
+      expect(events.user.updated).not.toBeCalled()
+      expect(events.user.permissionBuilderAssigned).not.toBeCalled()
+      expect(events.user.permissionAdminAssigned).toBeCalledTimes(1)
+    })
+
+    it("should be able to create a builder user", async () => {
+      jest.clearAllMocks()
+      const user = structures.users.builderUser({ email: "builder@test.com" })
+      await createUser(user)
+
+      expect(events.user.created).toBeCalledTimes(1)
+      expect(events.user.updated).not.toBeCalled()
+      expect(events.user.permissionBuilderAssigned).toBeCalledTimes(1)
+      expect(events.user.permissionAdminAssigned).not.toBeCalled()
+    })
+
+    it("should be able to assign app roles", async () => {
+      jest.clearAllMocks()
+      const user = structures.users.user({ email: "assign-roles@test.com" })
+      user.roles = {
+        "app_123": "role1",
+        "app_456": "role2",
+      }
+
+      await createUser(user)
+      const savedUser = await config.getUser(user.email)
+
+      expect(events.user.created).toBeCalledTimes(1)
+      expect(events.user.updated).not.toBeCalled()
+      expect(events.role.assigned).toBeCalledTimes(2)
+      expect(events.role.assigned).toBeCalledWith(savedUser, "role1")
+      expect(events.role.assigned).toBeCalledWith(savedUser, "role2")
+    })
+  })
+
+  describe("update", () => {
+    it("should be able to update a basic user", async () => {
+      let user = structures.users.user({ email: "basic-update@test.com" })
+      await createUser(user)
+      jest.clearAllMocks()
+
+      await updateUser(user)
+
+      expect(events.user.created).not.toBeCalled()
+      expect(events.user.updated).toBeCalledTimes(1)
+      expect(events.user.permissionBuilderAssigned).not.toBeCalled()
+      expect(events.user.permissionAdminAssigned).not.toBeCalled()
+      expect(events.user.passwordForceReset).not.toBeCalled()
+    })
+
+    it("should be able to force reset password", async () => {
+      let user = structures.users.user({ email: "basic-password-update@test.com" })
+      await createUser(user)
+      jest.clearAllMocks()
+
+      user.forceResetPassword = true
+      user.password = "tempPassword"
+      await updateUser(user)
+
+      expect(events.user.created).not.toBeCalled()
+      expect(events.user.updated).toBeCalledTimes(1)
+      expect(events.user.permissionBuilderAssigned).not.toBeCalled()
+      expect(events.user.permissionAdminAssigned).not.toBeCalled()
+      expect(events.user.passwordForceReset).toBeCalledTimes(1)
+    })
+
+    it("should be able to update a basic user to an admin user", async () => {
+      let user = structures.users.user({ email: "basic-update-admin@test.com" })
+      await createUser(user)
+      jest.clearAllMocks()
+
+      await updateUser(structures.users.adminUser(user))
+
+      expect(events.user.created).not.toBeCalled()
+      expect(events.user.updated).toBeCalledTimes(1)
+      expect(events.user.permissionBuilderAssigned).not.toBeCalled()
+      expect(events.user.permissionAdminAssigned).toBeCalledTimes(1)
+    })
+
+    it("should be able to update a basic user to a builder user", async () => {
+      let user = structures.users.user({ email: "basic-update-builder@test.com" })
+      await createUser(user)
+      jest.clearAllMocks()
+
+      await updateUser(structures.users.builderUser(user))
+
+      expect(events.user.created).not.toBeCalled()
+      expect(events.user.updated).toBeCalledTimes(1)
+      expect(events.user.permissionBuilderAssigned).toBeCalledTimes(1)
+      expect(events.user.permissionAdminAssigned).not.toBeCalled()
+    })
+
+    it("should be able to update an admin user to a basic user", async () => {
+      let user = structures.users.adminUser({ email: "admin-update-basic@test.com" })
+      await createUser(user)
+      jest.clearAllMocks()
+
+      user.admin.global = false
+      await updateUser(user)
+
+      expect(events.user.created).not.toBeCalled()
+      expect(events.user.updated).toBeCalledTimes(1)
+      expect(events.user.permissionAdminRemoved).toBeCalledTimes(1)
+      expect(events.user.permissionBuilderRemoved).not.toBeCalled()
+    })
+
+    it("should be able to update an builder user to a basic user", async () => {
+      let user = structures.users.builderUser({ email: "builder-update-basic@test.com" })
+      await createUser(user)
+      jest.clearAllMocks()
+
+      user.builder.global = false
+      await updateUser(user)
+
+      expect(events.user.created).not.toBeCalled()
+      expect(events.user.updated).toBeCalledTimes(1)
+      expect(events.user.permissionBuilderRemoved).toBeCalledTimes(1)
+      expect(events.user.permissionAdminRemoved).not.toBeCalled()
+    })
+
+    it("should be able to assign app roles", async () => {
+      const user = structures.users.user({ email: "assign-roles-update@test.com" })
+      await createUser(user)
+      jest.clearAllMocks()
+
+      user.roles = {
+        "app_123": "role1",
+        "app_456": "role2",
+      }
+      await updateUser(user)
+      const savedUser = await config.getUser(user.email)
+
+      expect(events.user.created).not.toBeCalled()
+      expect(events.user.updated).toBeCalledTimes(1)
+      expect(events.role.assigned).toBeCalledTimes(2)
+      expect(events.role.assigned).toBeCalledWith(savedUser, "role1")
+      expect(events.role.assigned).toBeCalledWith(savedUser, "role2")
+    })
+
+    it("should be able to unassign app roles", async () => {
+      const user = structures.users.user({ email: "unassign-roles@test.com" })
+      user.roles = {
+        "app_123": "role1",
+        "app_456": "role2",
+      }
+      await createUser(user)
+      jest.clearAllMocks()
+
+      user.roles = {}
+      await updateUser(user)
+      const savedUser = await config.getUser(user.email)
+
+      expect(events.user.created).not.toBeCalled()
+      expect(events.user.updated).toBeCalledTimes(1)
+      expect(events.role.unassigned).toBeCalledTimes(2)
+      expect(events.role.unassigned).toBeCalledWith(savedUser, "role1")
+      expect(events.role.unassigned).toBeCalledWith(savedUser, "role2")
+    })
+
+    it("should be able to update existing app roles", async () => {
+      const user = structures.users.user({ email: "update-roles@test.com" })
+      user.roles = {
+        "app_123": "role1",
+        "app_456": "role2",
+      }
+      await createUser(user)
+      jest.clearAllMocks()
+
+      user.roles = {
+        "app_123": "role1",
+        "app_456": "role2-edit",
+      }
+      await updateUser(user)
+      const savedUser = await config.getUser(user.email)
+
+      expect(events.user.created).not.toBeCalled()
+      expect(events.user.updated).toBeCalledTimes(1)
+      expect(events.role.unassigned).toBeCalledTimes(1)
+      expect(events.role.unassigned).toBeCalledWith(savedUser, "role2")
+      expect(events.role.assigned).toBeCalledTimes(1)
+      expect(events.role.assigned).toBeCalledWith(savedUser, "role2-edit")
+    })
+  })
+
+  describe("destroy", () => {
+    it("should be able to destroy a basic user", async () => {
+      let user = structures.users.user({ email: "destroy@test.com" })
+      await createUser(user)
+      jest.clearAllMocks()
+
+      await deleteUser(user.email)
+
+      expect(events.user.deleted).toBeCalledTimes(1)
+      expect(events.user.permissionBuilderRemoved).not.toBeCalled()
+      expect(events.user.permissionAdminRemoved).not.toBeCalled()
+    })
+
+    it("should be able to destroy an admin user", async () => {
+      let user = structures.users.adminUser({ email: "destroy-admin@test.com" })
+      await createUser(user)
+      jest.clearAllMocks()
+
+      await deleteUser(user.email)
+
+      expect(events.user.deleted).toBeCalledTimes(1)
+      expect(events.user.permissionBuilderRemoved).not.toBeCalled()
+      expect(events.user.permissionAdminRemoved).toBeCalledTimes(1)
+    })
+
+    it("should be able to destroy a builder user", async () => {
+      let user = structures.users.builderUser({ email: "destroy-admin@test.com" })
+      await createUser(user)
+      jest.clearAllMocks()
+
+      await deleteUser(user.email)
+
+      expect(events.user.deleted).toBeCalledTimes(1)
+      expect(events.user.permissionBuilderRemoved).toBeCalledTimes(1)
+      expect(events.user.permissionAdminRemoved).not.toBeCalled()
+    })
   })
 })

package/src/api/routes/validation/index.ts

@@ -0,0 +1 @@
+export * as users from "./users"

package/src/api/{utilities/validation.js → routes/validation/users.ts}

@@ -1,8 +1,8 @@
-const joiValidator = require("../../middleware/joi-validator")
-const Joi = require("joi")
+import joiValidator from "../../../middleware/joi-validator"
+import Joi from "joi"
 
-exports.buildUserSaveValidation = (isSelf = false) => {
-  let schema = {
+export const buildUserSaveValidation = (isSelf = false) => {
+  let schema: any = {
     email: Joi.string().allow(null, ""),
     password: Joi.string().allow(null, ""),
     forceResetPassword: Joi.boolean().optional(),

package/src/index.ts

@@ -18,6 +18,7 @@ const http = require("http")
 const api = require("./api")
 const redis = require("./utilities/redis")
 const Sentry = require("@sentry/node")
+import { events } from "@budibase/backend-core"
 
 // this will setup http and https proxies form env variables
 bootstrap()
@@ -73,6 +74,7 @@ server.on("close", async () => {
     console.log("Server Closed")
   }
   await redis.shutdown()
+  await events.shutdown()
   if (!env.isTest()) {
     process.exit(errCode)
   }

package/src/sdk/index.ts

@@ -0,0 +1 @@
+export * as users from "./users"

package/src/sdk/users/events.ts

@@ -0,0 +1,161 @@
+import env from "../../environment"
+import { events, accounts, tenancy } from "@budibase/backend-core"
+import { User, UserRoles, CloudAccount } from "@budibase/types"
+
+export const handleDeleteEvents = async (user: any) => {
+  await events.user.deleted(user)
+
+  if (isBuilder(user)) {
+    await events.user.permissionBuilderRemoved(user)
+  }
+
+  if (isAdmin(user)) {
+    await events.user.permissionAdminRemoved(user)
+  }
+}
+
+const assignAppRoleEvents = async (
+  user: User,
+  roles: UserRoles,
+  existingRoles: UserRoles
+) => {
+  for (const [appId, role] of Object.entries(roles)) {
+    // app role in existing is not same as new
+    if (!existingRoles || existingRoles[appId] !== role) {
+      await events.role.assigned(user, role)
+    }
+  }
+}
+
+const unassignAppRoleEvents = async (
+  user: User,
+  roles: UserRoles,
+  existingRoles: UserRoles
+) => {
+  if (!existingRoles) {
+    return
+  }
+  for (const [appId, role] of Object.entries(existingRoles)) {
+    // app role in new is not same as existing
+    if (!roles || roles[appId] !== role) {
+      await events.role.unassigned(user, role)
+    }
+  }
+}
+
+const handleAppRoleEvents = async (user: any, existingUser: any) => {
+  const roles = user.roles
+  const existingRoles = existingUser?.roles
+
+  await assignAppRoleEvents(user, roles, existingRoles)
+  await unassignAppRoleEvents(user, roles, existingRoles)
+}
+
+export const handleSaveEvents = async (user: any, existingUser: any) => {
+  const tenantId = tenancy.getTenantId()
+  let tenantAccount: CloudAccount | undefined
+  if (!env.SELF_HOSTED && !env.DISABLE_ACCOUNT_PORTAL) {
+    tenantAccount = await accounts.getAccountByTenantId(tenantId)
+  }
+  await events.identification.identifyUser(user, tenantAccount)
+
+  if (existingUser) {
+    await events.user.updated(user)
+
+    if (isRemovingBuilder(user, existingUser)) {
+      await events.user.permissionBuilderRemoved(user)
+    }
+
+    if (isRemovingAdmin(user, existingUser)) {
+      await events.user.permissionAdminRemoved(user)
+    }
+
+    if (
+      !existingUser.forceResetPassword &&
+      user.forceResetPassword &&
+      user.password
+    ) {
+      await events.user.passwordForceReset(user)
+    }
+  } else {
+    await events.user.created(user)
+  }
+
+  if (isAddingBuilder(user, existingUser)) {
+    await events.user.permissionBuilderAssigned(user)
+  }
+
+  if (isAddingAdmin(user, existingUser)) {
+    await events.user.permissionAdminAssigned(user)
+  }
+
+  await handleAppRoleEvents(user, existingUser)
+}
+
+const isBuilder = (user: any) => user.builder && user.builder.global
+const isAdmin = (user: any) => user.admin && user.admin.global
+
+export const isAddingBuilder = (user: any, existingUser: any) => {
+  return isAddingPermission(user, existingUser, isBuilder)
+}
+
+export const isRemovingBuilder = (user: any, existingUser: any) => {
+  return isRemovingPermission(user, existingUser, isBuilder)
+}
+
+const isAddingAdmin = (user: any, existingUser: any) => {
+  return isAddingPermission(user, existingUser, isAdmin)
+}
+
+const isRemovingAdmin = (user: any, existingUser: any) => {
+  return isRemovingPermission(user, existingUser, isAdmin)
+}
+
+/**
+ * Check if a permission is being added to a new or existing user.
+ */
+const isAddingPermission = (
+  user: any,
+  existingUser: any,
+  hasPermission: any
+) => {
+  // new user doesn't have the permission
+  if (!hasPermission(user)) {
+    return false
+  }
+
+  // existing user has the permission
+  if (existingUser && hasPermission(existingUser)) {
+    return false
+  }
+
+  // permission is being added
+  return true
+}
+
+/**
+ * Check if a permission is being removed from an existing user.
+ */
+const isRemovingPermission = (
+  user: any,
+  existingUser: any,
+  hasPermission: any
+) => {
+  // new user has the permission
+  if (hasPermission(user)) {
+    return false
+  }
+
+  // no existing user or existing user doesn't have the permission
+  if (!existingUser) {
+    return false
+  }
+
+  // existing user doesn't have the permission
+  if (!hasPermission(existingUser)) {
+    return false
+  }
+
+  // permission is being removed
+  return true
+}

package/src/sdk/users/index.ts

@@ -0,0 +1 @@
+export * from "./users"