@budibase/worker 1.2.58-alpha.2 → 1.2.58-alpha.5

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@budibase/worker",
   "email": "hi@budibase.com",
-  "version": "1.2.58-alpha.2",
+  "version": "1.2.58-alpha.5",
   "description": "Budibase background service",
   "main": "src/index.ts",
   "repository": {
@@ -35,10 +35,10 @@
   "author": "Budibase",
   "license": "GPL-3.0",
   "dependencies": {
-    "@budibase/backend-core": "1.2.58-alpha.2",
-    "@budibase/pro": "1.2.58-alpha.1",
-    "@budibase/string-templates": "1.2.58-alpha.2",
-    "@budibase/types": "1.2.58-alpha.2",
+    "@budibase/backend-core": "1.2.58-alpha.5",
+    "@budibase/pro": "1.2.58-alpha.4",
+    "@budibase/string-templates": "1.2.58-alpha.5",
+    "@budibase/types": "1.2.58-alpha.5",
     "@koa/router": "8.0.8",
     "@sentry/node": "6.17.7",
     "@techpass/passport-openidconnect": "0.3.2",
@@ -103,5 +103,5 @@
       "./scripts/jestSetup.js"
     ]
   },
-  "gitHead": "675fdd4b88456e4a663f8e2efb148556e0a35aab"
+  "gitHead": "6de0352299284a56f8d1bdd351cd2447a5b4c286"
 }

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

@@ -1,9 +1,13 @@
-import { EmailTemplatePurpose } from "../../../constants"
 import { checkInviteCode } from "../../../utilities/redis"
-import { sendEmail } from "../../../utilities/email"
 import { users } from "../../../sdk"
 import env from "../../../environment"
-import { BulkDeleteUsersRequest, CloudAccount, User } from "@budibase/types"
+import {
+  BulkDeleteUsersRequest,
+  CloudAccount,
+  InviteUserRequest,
+  InviteUsersRequest,
+  User,
+} from "@budibase/types"
 import {
   accounts,
   cache,
@@ -191,58 +195,27 @@ export const tenantUserLookup = async (ctx: any) => {
 }
 
 export const invite = async (ctx: any) => {
-  let { email, userInfo } = ctx.request.body
-  const existing = await usersCore.getGlobalUserByEmail(email)
-  if (existing) {
-    ctx.throw(400, "Email address already in use.")
-  }
-  if (!userInfo) {
-    userInfo = {}
-  }
-  userInfo.tenantId = tenancy.getTenantId()
-  const opts: any = {
-    subject: "{{ company }} platform invitation",
-    info: userInfo,
+  const request = ctx.request.body as InviteUserRequest
+  const response = await users.invite([request])
+
+  // explicitly throw for single user invite
+  if (response.unsuccessful.length) {
+    const reason = response.unsuccessful[0].reason
+    if (reason === "Unavailable") {
+      ctx.throw(400, reason)
+    } else {
+      ctx.throw(500, reason)
+    }
   }
-  await sendEmail(email, EmailTemplatePurpose.INVITATION, opts)
+
   ctx.body = {
     message: "Invitation has been sent.",
   }
-  await events.user.invited()
 }
 
 export const inviteMultiple = async (ctx: any) => {
-  let users = ctx.request.body
-  let existing = false
-  let existingEmail
-  for (let user of users) {
-    if (await usersCore.getGlobalUserByEmail(user.email)) {
-      existing = true
-      existingEmail = user.email
-      break
-    }
-  }
-
-  if (existing) {
-    ctx.throw(400, `${existingEmail} already exists`)
-  }
-
-  for (let i = 0; i < users.length; i++) {
-    let userInfo = users[i].userInfo
-    if (!userInfo) {
-      userInfo = {}
-    }
-    userInfo.tenantId = tenancy.getTenantId()
-    const opts: any = {
-      subject: "{{ company }} platform invitation",
-      info: userInfo,
-    }
-    await sendEmail(users[i].email, EmailTemplatePurpose.INVITATION, opts)
-  }
-
-  ctx.body = {
-    message: "Invitations have been sent.",
-  }
+  const request = ctx.request.body as InviteUsersRequest
+  ctx.body = await users.invite(request)
 }
 
 export const inviteAccept = async (ctx: any) => {

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

@@ -1,3 +1,5 @@
+import { InviteUsersResponse } from "@budibase/types"
+
 jest.mock("nodemailer")
 import {
   TestConfiguration,
@@ -27,7 +29,8 @@ describe("/api/global/users", () => {
 
   describe("invite", () => {
     it("should be able to generate an invitation", async () => {
-      const { code, res } = await api.users.sendUserInvite(sendMailMock)
+      const email = structures.users.newEmail()
+      const { code, res } = await api.users.sendUserInvite(sendMailMock, email)
 
       expect(res.body).toEqual({ message: "Invitation has been sent." })
       expect(sendMailMock).toHaveBeenCalled()
@@ -35,13 +38,27 @@ describe("/api/global/users", () => {
       expect(events.user.invited).toBeCalledTimes(1)
     })
 
+    it("should not be able to generate an invitation for existing user", async () => {
+      const { code, res } = await api.users.sendUserInvite(
+        sendMailMock,
+        config.defaultUser!.email,
+        400
+      )
+
+      expect(res.body.message).toBe("Unavailable")
+      expect(sendMailMock).toHaveBeenCalledTimes(0)
+      expect(code).toBeUndefined()
+      expect(events.user.invited).toBeCalledTimes(0)
+    })
+
     it("should be able to create new user from invite", async () => {
-      const { code } = await api.users.sendUserInvite(sendMailMock)
+      const email = structures.users.newEmail()
+      const { code } = await api.users.sendUserInvite(sendMailMock, email)
 
       const res = await api.users.acceptInvite(code)
 
       expect(res.body._id).toBeDefined()
-      const user = await config.getUser("invite@test.com")
+      const user = await config.getUser(email)
       expect(user).toBeDefined()
       expect(user._id).toEqual(res.body._id)
       expect(events.user.inviteAccepted).toBeCalledTimes(1)
@@ -49,6 +66,37 @@ describe("/api/global/users", () => {
     })
   })
 
+  describe("inviteMultiple", () => {
+    it("should be able to generate an invitation", async () => {
+      const newUserInvite = () => ({
+        email: structures.users.newEmail(),
+        userInfo: {},
+      })
+      const request = [newUserInvite(), newUserInvite()]
+
+      const res = await api.users.sendMultiUserInvite(request)
+
+      const body = res.body as InviteUsersResponse
+      expect(body.successful.length).toBe(2)
+      expect(body.unsuccessful.length).toBe(0)
+      expect(sendMailMock).toHaveBeenCalledTimes(2)
+      expect(events.user.invited).toBeCalledTimes(2)
+    })
+
+    it("should not be able to generate an invitation for existing user", async () => {
+      const request = [{ email: config.defaultUser!.email, userInfo: {} }]
+
+      const res = await api.users.sendMultiUserInvite(request)
+
+      const body = res.body as InviteUsersResponse
+      expect(body.successful.length).toBe(0)
+      expect(body.unsuccessful.length).toBe(1)
+      expect(body.unsuccessful[0].reason).toBe("Unavailable")
+      expect(sendMailMock).toHaveBeenCalledTimes(0)
+      expect(events.user.invited).toBeCalledTimes(0)
+    })
+  })
+
   describe("bulkCreate", () => {
     it("should ignore users existing in the same tenant", async () => {
       const user = await config.createUser()

package/src/sdk/users/users.ts

@@ -16,12 +16,12 @@ import {
   migrations,
   StaticDatabases,
   ViewName,
+  events,
 } from "@budibase/backend-core"
 import {
   MigrationType,
   PlatformUserByEmail,
   User,
-  Account,
   BulkCreateUsersResponse,
   CreateUserResponse,
   BulkDeleteUsersResponse,
@@ -30,8 +30,12 @@ import {
   RowResponse,
   BulkDocsResponse,
   AccountMetadata,
+  InviteUsersRequest,
+  InviteUsersResponse,
 } from "@budibase/types"
 import { groups as groupUtils } from "@budibase/pro"
+import { sendEmail } from "../../utilities/email"
+import { EmailTemplatePurpose } from "../../constants"
 
 const PAGE_LIMIT = 8
 
@@ -551,3 +555,53 @@ const bulkDeleteProcessing = async (dbUser: User) => {
   // let server know to sync user
   await apps.syncUserInApps(userId)
 }
+
+export const invite = async (
+  users: InviteUsersRequest
+): Promise<InviteUsersResponse> => {
+  const response: InviteUsersResponse = {
+    successful: [],
+    unsuccessful: [],
+  }
+
+  const matchedEmails = await searchExistingEmails(users.map(u => u.email))
+  const newUsers = []
+
+  // separate duplicates from new users
+  for (let user of users) {
+    if (matchedEmails.includes(user.email)) {
+      response.unsuccessful.push({ email: user.email, reason: "Unavailable" })
+    } else {
+      newUsers.push(user)
+    }
+  }
+  // overwrite users with new only
+  users = newUsers
+
+  // send the emails for new users
+  const tenantId = tenancy.getTenantId()
+  for (let user of users) {
+    try {
+      let userInfo = user.userInfo
+      if (!userInfo) {
+        userInfo = {}
+      }
+      userInfo.tenantId = tenantId
+      const opts: any = {
+        subject: "{{ company }} platform invitation",
+        info: userInfo,
+      }
+      await sendEmail(user.email, EmailTemplatePurpose.INVITATION, opts)
+      response.successful.push({ email: user.email })
+      await events.user.invited()
+    } catch (e) {
+      console.error(`Failed to send email invitation email=${user.email}`, e)
+      response.unsuccessful.push({
+        email: user.email,
+        reason: "Failed to send email",
+      })
+    }
+  }
+
+  return response
+}

package/src/tests/api/users.ts

@@ -3,6 +3,7 @@ import {
   BulkCreateUsersResponse,
   BulkDeleteUsersRequest,
   CreateUserResponse,
+  InviteUsersRequest,
   User,
   UserDetails,
 } from "@budibase/types"
@@ -19,17 +20,21 @@ export class UserAPI {
 
   // INVITE
 
-  sendUserInvite = async (sendMailMock: any) => {
+  sendUserInvite = async (sendMailMock: any, email: string, status = 200) => {
     await this.config.saveSmtpConfig()
     await this.config.saveSettingsConfig()
     const res = await this.request
       .post(`/api/global/users/invite`)
       .send({
-        email: "invite@test.com",
+        email,
       })
       .set(this.config.defaultHeaders())
       .expect("Content-Type", /json/)
-      .expect(200)
+      .expect(status)
+
+    if (status !== 200) {
+      return { code: undefined, res }
+    }
 
     const emailCall = sendMailMock.mock.calls[0][0]
     // after this URL there should be a code
@@ -51,6 +56,17 @@ export class UserAPI {
       .expect(200)
   }
 
+  sendMultiUserInvite = async (request: InviteUsersRequest, status = 200) => {
+    await this.config.saveSmtpConfig()
+    await this.config.saveSettingsConfig()
+    return this.request
+      .post(`/api/global/users/multi/invite`)
+      .send(request)
+      .set(this.config.defaultHeaders())
+      .expect("Content-Type", /json/)
+      .expect(status)
+  }
+
   // BULK
 
   bulkCreateUsers = async (users: User[], groups: any[] = []) => {