@budibase/worker 1.2.58-alpha.4 → 1.2.58

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

@@ -0,0 +1,390 @@
+jest.mock("nodemailer")
+const { config, request, mocks, structures } = require("../../../tests")
+const sendMailMock = mocks.email.mock()
+const { events } = require("@budibase/backend-core")
+describe("/api/global/users", () => {
+
+  beforeAll(async () => {
+    await config.beforeAll()
+  })
+
+  afterAll(async () => {
+    await config.afterAll()
+  })
+
+  const sendUserInvite = async () => {
+    await config.saveSmtpConfig()
+    await config.saveSettingsConfig()
+    const res = await request
+      .post(`/api/global/users/invite`)
+      .send({
+        email: "invite@test.com",
+      })
+      .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()
+    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({
+        password: "newpassword",
+        inviteCode: code,
+      })
+      .expect("Content-Type", /json/)
+      .expect(200)
+    expect(res.body._id).toBeDefined()
+    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 bulkCreateUsers = async (users) => {
+    const res = await request
+      .post(`/api/global/users/bulkCreate`)
+      .send(users)
+      .set(config.defaultHeaders())
+      .expect("Content-Type", /json/)
+      .expect(200)
+    return res.body
+  }
+
+  const bulkDeleteUsers = async (users) => {
+    const res = await request
+      .post(`/api/global/users/bulkDelete`)
+      .send(users)
+      .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 bulkCreate users with different permissions", async () => {
+      jest.clearAllMocks()
+      const builder = structures.users.builderUser({ email: "bulkbasic@test.com" })
+      const admin = structures.users.adminUser({ email: "bulkadmin@test.com" })
+      const user = structures.users.user({ email: "bulkuser@test.com" })
+
+      let toCreate = { users: [builder, admin, user], groups: [] }
+      await bulkCreateUsers(toCreate)
+
+      expect(events.user.created).toBeCalledTimes(3)
+      expect(events.user.permissionAdminAssigned).toBeCalledTimes(1)
+      expect(events.user.permissionBuilderAssigned).toBeCalledTimes(1)
+    })
+
+
+    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()
+    })
+
+    it("should be able to bulk delete users with different permissions", async () => {
+      jest.clearAllMocks()
+      const builder = structures.users.builderUser({ email: "basic@test.com" })
+      const admin = structures.users.adminUser({ email: "admin@test.com" })
+      const user = structures.users.user({ email: "user@test.com" })
+
+      let toCreate = { users: [builder, admin, user], groups: [] }
+      let createdUsers = await bulkCreateUsers(toCreate)
+      await bulkDeleteUsers({ userIds: [createdUsers[0]._id, createdUsers[1]._id, createdUsers[2]._id] })
+      expect(events.user.deleted).toBeCalledTimes(3)
+      expect(events.user.permissionAdminRemoved).toBeCalledTimes(1)
+      expect(events.user.permissionBuilderRemoved).toBeCalledTimes(1)
+
+    })
+
+  })
+})

package/src/{environment.ts → environment.js}

@@ -20,13 +20,13 @@ if (!LOADED && isDev() && !isTest()) {
   LOADED = true
 }
 
-function parseIntSafe(number: any) {
+function parseIntSafe(number) {
   if (number) {
     return parseInt(number)
   }
 }
 
-const env = {
+module.exports = {
   // auth
   MINIO_ACCESS_KEY: process.env.MINIO_ACCESS_KEY,
   MINIO_SECRET_KEY: process.env.MINIO_SECRET_KEY,
@@ -47,7 +47,7 @@ const env = {
   CLUSTER_PORT: process.env.CLUSTER_PORT,
   // flags
   NODE_ENV: process.env.NODE_ENV,
-  SELF_HOSTED: !!parseInt(process.env.SELF_HOSTED || ""),
+  SELF_HOSTED: !!parseInt(process.env.SELF_HOSTED),
   LOG_LEVEL: process.env.LOG_LEVEL,
   MULTI_TENANCY: process.env.MULTI_TENANCY,
   DISABLE_ACCOUNT_PORTAL: process.env.DISABLE_ACCOUNT_PORTAL,
@@ -62,7 +62,7 @@ const env = {
   // other
   CHECKLIST_CACHE_TTL: parseIntSafe(process.env.CHECKLIST_CACHE_TTL) || 3600,
   SESSION_UPDATE_PERIOD: process.env.SESSION_UPDATE_PERIOD,
-  _set(key: any, value: any) {
+  _set(key, value) {
     process.env[key] = value
     module.exports[key] = value
   },
@@ -74,17 +74,16 @@ const env = {
 }
 
 // if some var haven't been set, define them
-if (!env.APPS_URL) {
-  env.APPS_URL = isDev() ? "http://localhost:4001" : "http://app-service:4002"
+if (!module.exports.APPS_URL) {
+  module.exports.APPS_URL = isDev()
+    ? "http://localhost:4001"
+    : "http://app-service:4002"
 }
 
 // clean up any environment variable edge cases
 for (let [key, value] of Object.entries(module.exports)) {
   // handle the edge case of "0" to disable an environment variable
   if (value === "0") {
-    // @ts-ignore
-    env[key] = 0
+    module.exports[key] = 0
   }
 }
-
-export = env

package/src/index.ts

@@ -71,7 +71,9 @@ server.on("close", async () => {
     return
   }
   shuttingDown = true
-  console.log("Server Closed")
+  if (!env.isTest()) {
+    console.log("Server Closed")
+  }
   await redis.shutdown()
   await events.shutdown()
   if (!env.isTest()) {
@@ -84,7 +86,7 @@ const shutdown = () => {
   server.destroy()
 }
 
-export = server.listen(parseInt(env.PORT || 4002), async () => {
+module.exports = server.listen(parseInt(env.PORT || 4002), async () => {
   console.log(`Worker running on ${JSON.stringify(server.address())}`)
   await redis.init()
 })
@@ -98,7 +100,3 @@ process.on("uncaughtException", err => {
 process.on("SIGTERM", () => {
   shutdown()
 })
-
-process.on("SIGINT", () => {
-  shutdown()
-})

package/src/sdk/index.ts

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