@budibase/worker 2.3.17-alpha.1 → 2.3.17

package/jest.config.ts

@@ -1,10 +1,8 @@
 import { Config } from "@jest/types"
 import * as fs from "fs"
-const preset = require("ts-jest/jest-preset")
 
 const config: Config.InitialOptions = {
-  ...preset,
-  preset: "@trendyol/jest-testcontainers",
+  testEnvironment: "node",
   setupFiles: ["./src/tests/jestEnv.ts"],
   setupFilesAfterEnv: ["./src/tests/jestSetup.ts"],
   collectCoverageFrom: ["src/**/*.{js,ts}"],
@@ -20,6 +18,7 @@ if (!process.env.CI) {
     "@budibase/backend-core/(.*)": "<rootDir>/../backend-core/$1",
     "@budibase/backend-core": "<rootDir>/../backend-core/src",
     "@budibase/types": "<rootDir>/../types/src",
+    "^axios.*$": "<rootDir>/node_modules/axios/lib/axios.js",
   }
   // add pro sources if they exist
   if (fs.existsSync("../../../budibase-pro")) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@budibase/worker",
   "email": "hi@budibase.com",
-  "version": "2.3.17-alpha.1",
+  "version": "2.3.17",
   "description": "Budibase background service",
   "main": "src/index.ts",
   "repository": {
@@ -36,17 +36,16 @@
   "author": "Budibase",
   "license": "GPL-3.0",
   "dependencies": {
-    "@budibase/backend-core": "2.3.17-alpha.1",
-    "@budibase/pro": "2.3.17-alpha.0",
-    "@budibase/string-templates": "2.3.17-alpha.1",
-    "@budibase/types": "2.3.17-alpha.1",
+    "@budibase/backend-core": "^2.3.17",
+    "@budibase/pro": "2.3.16",
+    "@budibase/string-templates": "^2.3.17",
+    "@budibase/types": "^2.3.17",
     "@koa/router": "8.0.8",
     "@sentry/node": "6.17.7",
     "@techpass/passport-openidconnect": "0.3.2",
     "@types/global-agent": "2.1.1",
     "aws-sdk": "2.1030.0",
     "bcryptjs": "2.4.3",
-    "dd-trace": "3.13.2",
     "dotenv": "8.6.0",
     "elastic-apm-node": "3.38.0",
     "global-agent": "3.0.0",
@@ -73,7 +72,6 @@
   "devDependencies": {
     "@swc/core": "^1.3.25",
     "@swc/jest": "^0.2.24",
-    "@trendyol/jest-testcontainers": "^2.1.1",
     "@types/jest": "26.0.23",
     "@types/jsonwebtoken": "8.5.1",
     "@types/koa": "2.13.4",
@@ -99,5 +97,5 @@
     "typescript": "4.7.3",
     "update-dotenv": "1.1.1"
   },
-  "gitHead": "5c22c75429f742b3e0e64c01fc3ad41b5fd55000"
+  "gitHead": "a57c922b91c1df8dc276588a5ad583a0c1aea52c"
 }

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

@@ -1,8 +1,7 @@
 jest.mock("nodemailer")
 import { TestConfiguration, mocks } from "../../../../tests"
 const sendMailMock = mocks.email.mock()
-import { events, tenancy } from "@budibase/backend-core"
-import { structures } from "@budibase/backend-core/tests"
+import { events } from "@budibase/backend-core"
 
 const expectSetAuthCookie = (res: any) => {
   expect(
@@ -41,43 +40,36 @@ describe("/api/global/auth", () => {
 
     describe("POST /api/global/auth/:tenantId/reset", () => {
       it("should generate password reset email", async () => {
-        await tenancy.doInTenant(config.tenant1User!.tenantId, async () => {
-          const userEmail = structures.email()
-          const { res, code } = await config.api.auth.requestPasswordReset(
-            sendMailMock,
-            userEmail
-          )
-          const user = await config.getUser(userEmail)
-
-          expect(res.body).toEqual({
-            message: "Please check your email for a reset link.",
-          })
-          expect(sendMailMock).toHaveBeenCalled()
+        const { res, code } = await config.api.auth.requestPasswordReset(
+          sendMailMock
+        )
+        const user = await config.getUser("test@test.com")
 
-          expect(code).toBeDefined()
-          expect(events.user.passwordResetRequested).toBeCalledTimes(1)
-          expect(events.user.passwordResetRequested).toBeCalledWith(user)
+        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)
       })
     })
 
     describe("POST /api/global/auth/:tenantId/reset/update", () => {
       it("should reset password", async () => {
-        await tenancy.doInTenant(config.tenant1User!.tenantId, async () => {
-          const userEmail = structures.email()
-          const { code } = await config.api.auth.requestPasswordReset(
-            sendMailMock,
-            userEmail
-          )
-          const user = await config.getUser(userEmail)
-          delete user.password
+        const { code } = await config.api.auth.requestPasswordReset(
+          sendMailMock
+        )
+        const user = await config.getUser("test@test.com")
+        delete user.password
 
-          const res = await config.api.auth.updatePassword(code)
+        const res = await config.api.auth.updatePassword(code)
+
+        expect(res.body).toEqual({ message: "password reset successfully." })
+        expect(events.user.passwordReset).toBeCalledTimes(1)
+        expect(events.user.passwordReset).toBeCalledWith(user)
 
-          expect(res.body).toEqual({ message: "password reset successfully." })
-          expect(events.user.passwordReset).toBeCalledTimes(1)
-          expect(events.user.passwordReset).toBeCalledWith(user)
-        })
         // TODO: Login using new password
       })
     })

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

@@ -2,12 +2,12 @@
 jest.mock("nodemailer")
 import { TestConfiguration, structures, mocks } from "../../../../tests"
 mocks.email.mock()
-import { Config, context, events } from "@budibase/backend-core"
+import { Config, events } from "@budibase/backend-core"
 
 describe("configs", () => {
   const config = new TestConfiguration()
 
-  beforeEach(async () => {
+  beforeAll(async () => {
     await config.beforeAll()
   })
 
@@ -113,64 +113,56 @@ describe("configs", () => {
 
       describe("create", () => {
         it("should create activated OIDC config", async () => {
-          await context.doInTenant(config.tenant1User!.tenantId, async () => {
-            await saveOIDCConfig()
-            expect(events.auth.SSOCreated).toBeCalledTimes(1)
-            expect(events.auth.SSOCreated).toBeCalledWith(Config.OIDC)
-            expect(events.auth.SSODeactivated).not.toBeCalled()
-            expect(events.auth.SSOActivated).toBeCalledTimes(1)
-            expect(events.auth.SSOActivated).toBeCalledWith(Config.OIDC)
-            await config.deleteConfig(Config.OIDC)
-          })
+          await saveOIDCConfig()
+          expect(events.auth.SSOCreated).toBeCalledTimes(1)
+          expect(events.auth.SSOCreated).toBeCalledWith(Config.OIDC)
+          expect(events.auth.SSODeactivated).not.toBeCalled()
+          expect(events.auth.SSOActivated).toBeCalledTimes(1)
+          expect(events.auth.SSOActivated).toBeCalledWith(Config.OIDC)
+          await config.deleteConfig(Config.OIDC)
         })
 
         it("should create deactivated OIDC config", async () => {
-          await context.doInTenant(config.tenant1User!.tenantId, async () => {
-            await saveOIDCConfig({ activated: false })
-            expect(events.auth.SSOCreated).toBeCalledTimes(1)
-            expect(events.auth.SSOCreated).toBeCalledWith(Config.OIDC)
-            expect(events.auth.SSOActivated).not.toBeCalled()
-            expect(events.auth.SSODeactivated).not.toBeCalled()
-            await config.deleteConfig(Config.OIDC)
-          })
+          await saveOIDCConfig({ activated: false })
+          expect(events.auth.SSOCreated).toBeCalledTimes(1)
+          expect(events.auth.SSOCreated).toBeCalledWith(Config.OIDC)
+          expect(events.auth.SSOActivated).not.toBeCalled()
+          expect(events.auth.SSODeactivated).not.toBeCalled()
+          await config.deleteConfig(Config.OIDC)
         })
       })
 
       describe("update", () => {
         it("should update OIDC config to deactivated", async () => {
-          await context.doInTenant(config.tenant1User!.tenantId, 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(Config.OIDC)
-            expect(events.auth.SSOActivated).not.toBeCalled()
-            expect(events.auth.SSODeactivated).toBeCalledTimes(1)
-            expect(events.auth.SSODeactivated).toBeCalledWith(Config.OIDC)
-            await config.deleteConfig(Config.OIDC)
-          })
+          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(Config.OIDC)
+          expect(events.auth.SSOActivated).not.toBeCalled()
+          expect(events.auth.SSODeactivated).toBeCalledTimes(1)
+          expect(events.auth.SSODeactivated).toBeCalledWith(Config.OIDC)
+          await config.deleteConfig(Config.OIDC)
         })
 
         it("should update OIDC config to activated", async () => {
-          await context.doInTenant(config.tenant1User!.tenantId, 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(Config.OIDC)
-            expect(events.auth.SSODeactivated).not.toBeCalled()
-            expect(events.auth.SSOActivated).toBeCalledTimes(1)
-            expect(events.auth.SSOActivated).toBeCalledWith(Config.OIDC)
-            await config.deleteConfig(Config.OIDC)
-          })
+          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(Config.OIDC)
+          expect(events.auth.SSODeactivated).not.toBeCalled()
+          expect(events.auth.SSOActivated).toBeCalledTimes(1)
+          expect(events.auth.SSOActivated).toBeCalledWith(Config.OIDC)
+          await config.deleteConfig(Config.OIDC)
         })
       })
     })
@@ -187,26 +179,22 @@ describe("configs", () => {
 
       describe("create", () => {
         it("should create SMTP config", async () => {
-          await context.doInTenant(config.tenant1User!.tenantId, async () => {
-            await config.deleteConfig(Config.SMTP)
-            await saveSMTPConfig()
-            expect(events.email.SMTPUpdated).not.toBeCalled()
-            expect(events.email.SMTPCreated).toBeCalledTimes(1)
-            await config.deleteConfig(Config.SMTP)
-          })
+          await config.deleteConfig(Config.SMTP)
+          await saveSMTPConfig()
+          expect(events.email.SMTPUpdated).not.toBeCalled()
+          expect(events.email.SMTPCreated).toBeCalledTimes(1)
+          await config.deleteConfig(Config.SMTP)
         })
       })
 
       describe("update", () => {
         it("should update SMTP config", async () => {
-          await context.doInTenant(config.tenant1User!.tenantId, 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(Config.SMTP)
-          })
+          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(Config.SMTP)
         })
       })
     })
@@ -223,73 +211,65 @@ describe("configs", () => {
 
       describe("create", () => {
         it("should create settings config with default settings", async () => {
-          await context.doInTenant(config.tenant1User!.tenantId, async () => {
-            await config.deleteConfig(Config.SETTINGS)
+          await config.deleteConfig(Config.SETTINGS)
 
-            await saveSettingsConfig()
+          await saveSettingsConfig()
 
-            expect(events.org.nameUpdated).not.toBeCalled()
-            expect(events.org.logoUpdated).not.toBeCalled()
-            expect(events.org.platformURLUpdated).not.toBeCalled()
-          })
+          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 context.doInTenant(config.tenant1User!.tenantId, async () => {
-            config.modeSelf()
-            await config.deleteConfig(Config.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)
-            config.modeCloud()
-          })
+          config.modeSelf()
+          await config.deleteConfig(Config.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)
+          config.modeCloud()
         })
       })
 
       describe("update", () => {
         it("should update settings config", async () => {
-          await context.doInTenant(config.tenant1User!.tenantId, async () => {
-            config.modeSelf()
-            await config.deleteConfig(Config.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)
-            config.modeCloud()
-          })
+          config.modeSelf()
+          await config.deleteConfig(Config.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)
+          config.modeCloud()
         })
       })
     })
   })
 
   it("should return the correct checklist status based on the state of the budibase installation", async () => {
-    await context.doInTenant(config.tenant1User!.tenantId, async () => {
-      await config.saveSmtpConfig()
+    await config.saveSmtpConfig()
 
-      const res = await config.api.configs.getConfigChecklist()
-      const checklist = res.body
+    const res = await config.api.configs.getConfigChecklist()
+    const checklist = res.body
 
-      expect(checklist.apps.checked).toBeFalsy()
-      expect(checklist.smtp.checked).toBeTruthy()
-      expect(checklist.adminUser.checked).toBeTruthy()
-    })
+    expect(checklist.apps.checked).toBeFalsy()
+    expect(checklist.smtp.checked).toBeTruthy()
+    expect(checklist.adminUser.checked).toBeTruthy()
   })
 })

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

@@ -1,7 +1,6 @@
 import { structures, TestConfiguration } from "../../../../tests"
 import { context, db, permissions, roles } from "@budibase/backend-core"
 import { Mock } from "jest-mock"
-import { Database } from "@budibase/types"
 
 jest.mock("@budibase/backend-core", () => {
   const core = jest.requireActual("@budibase/backend-core")
@@ -17,13 +16,14 @@ jest.mock("@budibase/backend-core", () => {
   }
 })
 
-let appId: string
-let appDb: Database
+const appDb = db.getDB("app_test")
+const mockAppDB = context.getAppDB as Mock
+mockAppDB.mockReturnValue(appDb)
 
 async function addAppMetadata() {
   await appDb.put({
     _id: "app_metadata",
-    appId: appId,
+    appId: "app_test",
     name: "New App",
     version: "version",
     url: "url",
@@ -39,17 +39,10 @@ describe("/api/global/roles", () => {
   )
 
   beforeAll(async () => {
-    await config.beforeAll()
-  })
-
-  beforeEach(async () => {
-    appId = db.generateAppID()
-    appDb = db.getDB(appId)
-    const mockAppDB = context.getAppDB as Mock
-    mockAppDB.mockReturnValue(appDb)
-
-    await addAppMetadata()
+    console.debug(role)
     appDb.put(role)
+    await addAppMetadata()
+    await config.beforeAll()
   })
 
   afterAll(async () => {
@@ -64,14 +57,16 @@ describe("/api/global/roles", () => {
     it("retrieves roles", async () => {
       const res = await config.api.roles.get()
       expect(res.body).toBeDefined()
-      expect(res.body[appId].roles.length).toEqual(5)
-      expect(res.body[appId].roles.map((r: any) => r._id)).toContain(role._id)
+      expect(res.body["app_test"].roles.length).toEqual(5)
+      expect(res.body["app_test"].roles.map((r: any) => r._id)).toContain(
+        role._id
+      )
     })
   })
 
   describe("GET api/global/roles/:appId", () => {
     it("finds a role by appId", async () => {
-      const res = await config.api.roles.find(appId)
+      const res = await config.api.roles.find("app_test")
       expect(res.body).toBeDefined()
       expect(res.body.name).toEqual("New App")
     })
@@ -84,9 +79,9 @@ describe("/api/global/roles", () => {
         app_test: "role1",
       }
       const userResponse = await config.createUser(user)
-      const res = await config.api.roles.remove(appId)
+      const res = await config.api.roles.remove("app_test")
       const updatedUser = await config.api.users.getUser(userResponse._id!)
-      expect(updatedUser.body.roles).not.toHaveProperty(appId)
+      expect(updatedUser.body.roles).not.toHaveProperty("app_test")
       expect(res.body.message).toEqual("App role removed from all users")
     })
   })

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

@@ -1,9 +1,14 @@
 import { InviteUsersResponse, User } from "@budibase/types"
 
 jest.mock("nodemailer")
-import { TestConfiguration, mocks, structures } from "../../../../tests"
+import {
+  TestConfiguration,
+  mocks,
+  structures,
+  TENANT_1,
+} from "../../../../tests"
 const sendMailMock = mocks.email.mock()
-import { context, events, tenancy } from "@budibase/backend-core"
+import { events, tenancy } from "@budibase/backend-core"
 
 describe("/api/global/users", () => {
   const config = new TestConfiguration()
@@ -22,18 +27,16 @@ describe("/api/global/users", () => {
 
   describe("invite", () => {
     it("should be able to generate an invitation", async () => {
-      await context.doInTenant(config.tenant1User!.tenantId, async () => {
-        const email = structures.users.newEmail()
-        const { code, res } = await config.api.users.sendUserInvite(
-          sendMailMock,
-          email
-        )
-
-        expect(res.body).toEqual({ message: "Invitation has been sent." })
-        expect(sendMailMock).toHaveBeenCalled()
-        expect(code).toBeDefined()
-        expect(events.user.invited).toBeCalledTimes(1)
-      })
+      const email = structures.users.newEmail()
+      const { code, res } = await config.api.users.sendUserInvite(
+        sendMailMock,
+        email
+      )
+
+      expect(res.body).toEqual({ message: "Invitation has been sent." })
+      expect(sendMailMock).toHaveBeenCalled()
+      expect(code).toBeDefined()
+      expect(events.user.invited).toBeCalledTimes(1)
     })
 
     it("should not be able to generate an invitation for existing user", async () => {
@@ -50,22 +53,20 @@ describe("/api/global/users", () => {
     })
 
     it("should be able to create new user from invite", async () => {
-      await context.doInTenant(config.tenant1User!.tenantId, async () => {
-        const email = structures.users.newEmail()
-        const { code } = await config.api.users.sendUserInvite(
-          sendMailMock,
-          email
-        )
-
-        const res = await config.api.users.acceptInvite(code)
-
-        expect(res.body._id).toBeDefined()
-        const user = await config.getUser(email)
-        expect(user).toBeDefined()
-        expect(user._id).toEqual(res.body._id)
-        expect(events.user.inviteAccepted).toBeCalledTimes(1)
-        expect(events.user.inviteAccepted).toBeCalledWith(user)
-      })
+      const email = structures.users.newEmail()
+      const { code } = await config.api.users.sendUserInvite(
+        sendMailMock,
+        email
+      )
+
+      const res = await config.api.users.acceptInvite(code)
+
+      expect(res.body._id).toBeDefined()
+      const user = await config.getUser(email)
+      expect(user).toBeDefined()
+      expect(user._id).toEqual(res.body._id)
+      expect(events.user.inviteAccepted).toBeCalledTimes(1)
+      expect(events.user.inviteAccepted).toBeCalledWith(user)
     })
   })
 
@@ -117,7 +118,7 @@ describe("/api/global/users", () => {
       const user = await config.createUser()
       jest.clearAllMocks()
 
-      await tenancy.doInTenant(config.getTenantId(), async () => {
+      await tenancy.doInTenant(TENANT_1, async () => {
         const response = await config.api.users.bulkCreateUsers([user])
 
         expect(response.created?.successful.length).toBe(0)
@@ -230,7 +231,7 @@ describe("/api/global/users", () => {
       const user = await config.createUser()
       jest.clearAllMocks()
 
-      await tenancy.doInTenant(config.getTenantId(), async () => {
+      await tenancy.doInTenant(TENANT_1, async () => {
         delete user._id
         const response = await config.api.users.saveUser(user, 400)
 
@@ -443,7 +444,7 @@ describe("/api/global/users", () => {
     })
 
     it("should not be able to update email address", async () => {
-      const email = structures.email()
+      const email = "email@test.com"
       const user = await config.createUser(structures.users.user({ email }))
       user.email = "new@test.com"
 

package/src/index.ts

@@ -1,13 +1,14 @@
-if (process.env.DD_APM_ENABLED) {
-  require("./ddApm")
-}
+// need to load environment first
+import env from "./environment"
 
+// enable APM if configured
 if (process.env.ELASTIC_APM_ENABLED) {
-  require("./elasticApm")
+  const apm = require("elastic-apm-node").start({
+    serviceName: process.env.SERVICE,
+    environment: process.env.BUDIBASE_ENVIRONMENT,
+  })
 }
 
-// need to load environment first
-import env from "./environment"
 import { Scope } from "@sentry/node"
 import { Event } from "@sentry/types/dist/event"
 import Application from "koa"

package/src/sdk/users/users.ts

@@ -264,6 +264,7 @@ export const save = async (
     builtUser._rev = response.rev
 
     await eventHelpers.handleSaveEvents(builtUser, dbUser)
+    await addTenant(tenantId, _id, email)
     await cache.user.invalidateUser(response.id)
 
     // let server know to sync user