@budibase/worker 1.2.58-alpha.4 → 1.2.58

package/src/sdk/users/users.ts

@@ -14,23 +14,8 @@ import {
   HTTPError,
   accounts,
   migrations,
-  StaticDatabases,
-  ViewName,
 } from "@budibase/backend-core"
-import {
-  MigrationType,
-  PlatformUserByEmail,
-  User,
-  Account,
-  BulkCreateUsersResponse,
-  CreateUserResponse,
-  BulkDeleteUsersResponse,
-  CloudAccount,
-  AllDocsResponse,
-  RowResponse,
-  BulkDocsResponse,
-  AccountMetadata,
-} from "@budibase/types"
+import { MigrationType, User } from "@budibase/types"
 import { groups as groupUtils } from "@budibase/pro"
 
 const PAGE_LIMIT = 8
@@ -113,6 +98,7 @@ export const getUser = async (userId: string) => {
 interface SaveUserOpts {
   hashPassword?: boolean
   requirePassword?: boolean
+  bulkCreate?: boolean
 }
 
 const buildUser = async (
@@ -123,7 +109,7 @@ const buildUser = async (
   },
   tenantId: string,
   dbUser?: any
-): Promise<User> => {
+) => {
   let { password, _id } = user
 
   let hashedPassword
@@ -157,63 +143,62 @@ const buildUser = async (
   return user
 }
 
-const validateUniqueUser = async (email: string, tenantId: string) => {
-  // check budibase users in other tenants
-  if (env.MULTI_TENANCY) {
-    const tenantUser = await tenancy.getTenantUser(email)
-    if (tenantUser != null && tenantUser.tenantId !== tenantId) {
-      throw `Unavailable`
-    }
-  }
-
-  // check root account users in account portal
-  if (!env.SELF_HOSTED && !env.DISABLE_ACCOUNT_PORTAL) {
-    const account = await accounts.getAccount(email)
-    if (account && account.verified && account.tenantId !== tenantId) {
-      throw `Unavailable`
-    }
-  }
-}
-
 export const save = async (
-  user: User,
+  user: any,
   opts: SaveUserOpts = {
     hashPassword: true,
     requirePassword: true,
+    bulkCreate: false,
   }
-): Promise<CreateUserResponse> => {
+) => {
   const tenantId = tenancy.getTenantId()
   const db = tenancy.getGlobalDB()
   let { email, _id } = user
-
-  let dbUser: User | undefined
-  if (_id) {
-    // try to get existing user from db
-    dbUser = (await db.get(_id)) as User
-    if (email && dbUser.email !== email) {
-      throw "Email address cannot be changed"
-    }
-    email = dbUser.email
+  // make sure another user isn't using the same email
+  let dbUser: any
+  if (opts.bulkCreate) {
+    dbUser = null
   } else if (email) {
-    // no id was specified - load from email instead
+    // check budibase users inside the tenant
     dbUser = await usersCore.getGlobalUserByEmail(email)
-    if (dbUser && dbUser._id !== _id) {
-      throw `Unavailable`
+    if (dbUser != null && (dbUser._id !== _id || Array.isArray(dbUser))) {
+      throw `Email address ${email} already in use.`
     }
-  } else {
-    throw new Error("_id or email is required")
-  }
 
-  await validateUniqueUser(email, tenantId)
+    // check budibase users in other tenants
+    if (env.MULTI_TENANCY) {
+      const tenantUser = await tenancy.getTenantUser(email)
+      if (tenantUser != null && tenantUser.tenantId !== tenantId) {
+        throw `Email address ${email} already in use.`
+      }
+    }
+
+    // check root account users in account portal
+    if (!env.SELF_HOSTED && !env.DISABLE_ACCOUNT_PORTAL) {
+      const account = await accounts.getAccount(email)
+      if (account && account.verified && account.tenantId !== tenantId) {
+        throw `Email address ${email} already in use.`
+      }
+    }
+  } else if (_id) {
+    dbUser = await db.get(_id)
+  }
 
   let builtUser = await buildUser(user, opts, tenantId, dbUser)
 
   // make sure we set the _id field for a new user
   if (!_id) {
-    _id = builtUser._id!
+    _id = builtUser._id
   }
 
   try {
+    const putOpts = {
+      password: builtUser.password,
+      ...user,
+    }
+    if (opts.bulkCreate) {
+      return putOpts
+    }
     // save the user to db
     let response
     const putUserFn = () => {
@@ -262,87 +247,29 @@ export const addTenant = async (
   }
 }
 
-const getExistingTenantUsers = async (emails: string[]): Promise<User[]> => {
-  return dbUtils.queryGlobalView(ViewName.USER_BY_EMAIL, {
-    keys: emails,
-    include_docs: true,
-    arrayResponse: true,
-  })
-}
-
-const getExistingPlatformUsers = async (
-  emails: string[]
-): Promise<PlatformUserByEmail[]> => {
-  return dbUtils.doWithDB(
-    StaticDatabases.PLATFORM_INFO.name,
-    async (infoDb: any) => {
-      const response: AllDocsResponse<PlatformUserByEmail> =
-        await infoDb.allDocs({
-          keys: emails,
-          include_docs: true,
-        })
-      return response.rows
-        .filter(row => row.doc && (row.error !== "not_found") !== null)
-        .map((row: any) => row.doc)
-    }
-  )
-}
-
-const getExistingAccounts = async (
-  emails: string[]
-): Promise<AccountMetadata[]> => {
-  return dbUtils.queryPlatformView(ViewName.ACCOUNT_BY_EMAIL, {
-    keys: emails,
-    include_docs: true,
-    arrayResponse: true,
-  })
-}
-
-/**
- * Apply a system-wide search on emails:
- * - in tenant
- * - cross tenant
- * - accounts
- * return an array of emails that match the supplied emails.
- */
-const searchExistingEmails = async (emails: string[]) => {
-  let matchedEmails: string[] = []
-
-  const existingTenantUsers = await getExistingTenantUsers(emails)
-  matchedEmails.push(...existingTenantUsers.map(user => user.email))
-
-  const existingPlatformUsers = await getExistingPlatformUsers(emails)
-  matchedEmails.push(...existingPlatformUsers.map(user => user._id!))
-
-  const existingAccounts = await getExistingAccounts(emails)
-  matchedEmails.push(...existingAccounts.map(account => account.email))
-
-  return [...new Set(matchedEmails)]
-}
-
 export const bulkCreate = async (
   newUsersRequested: User[],
   groups: string[]
-): Promise<BulkCreateUsersResponse> => {
+) => {
   const db = tenancy.getGlobalDB()
   const tenantId = tenancy.getTenantId()
 
   let usersToSave: any[] = []
   let newUsers: any[] = []
 
-  const emails = newUsersRequested.map((user: User) => user.email)
-  const existingEmails = await searchExistingEmails(emails)
-  const unsuccessful: { email: string; reason: string }[] = []
+  const allUsers = await db.allDocs(
+    dbUtils.getGlobalUserParams(null, {
+      include_docs: true,
+    })
+  )
+  let mapped = allUsers.rows.map((row: any) => row.id)
 
+  const currentUserEmails = mapped.map((x: any) => x.email) || []
   for (const newUser of newUsersRequested) {
     if (
       newUsers.find((x: any) => x.email === newUser.email) ||
-      existingEmails.includes(newUser.email)
+      currentUserEmails.includes(newUser.email)
     ) {
-      unsuccessful.push({
-        email: newUser.email,
-        reason: `Unavailable`,
-      })
       continue
     }
     newUser.userGroups = groups
@@ -380,129 +307,62 @@ export const bulkCreate = async (
     await apps.syncUserInApps(user._id)
   }
 
-  const saved = usersToBulkSave.map(user => {
+  return usersToBulkSave.map(user => {
     return {
       _id: user._id,
       email: user.email,
     }
   })
-
-  return {
-    successful: saved,
-    unsuccessful,
-  }
 }
 
-/**
- * For the given user id's, return the account holder if it is in the ids.
- */
-const getAccountHolderFromUserIds = async (
-  userIds: string[]
-): Promise<CloudAccount | undefined> => {
-  if (!env.SELF_HOSTED && !env.DISABLE_ACCOUNT_PORTAL) {
-    const tenantId = tenancy.getTenantId()
-    const account = await accounts.getAccountByTenantId(tenantId)
-    if (!account) {
-      throw new Error(`Account not found for tenantId=${tenantId}`)
-    }
-
-    const budibaseUserId = account.budibaseUserId
-    if (userIds.includes(budibaseUserId)) {
-      return account
-    }
-  }
-}
-
-export const bulkDelete = async (
-  userIds: string[]
-): Promise<BulkDeleteUsersResponse> => {
+export const bulkDelete = async (userIds: any) => {
   const db = tenancy.getGlobalDB()
 
-  const response: BulkDeleteUsersResponse = {
-    successful: [],
-    unsuccessful: [],
-  }
-
-  // remove the account holder from the delete request if present
-  const account = await getAccountHolderFromUserIds(userIds)
-  if (account) {
-    userIds = userIds.filter(u => u !== account.budibaseUserId)
-    // mark user as unsuccessful
-    response.unsuccessful.push({
-      _id: account.budibaseUserId,
-      email: account.email,
-      reason: "Account holder cannot be deleted",
-    })
-  }
-
   let groupsToModify: any = {}
   let builderCount = 0
-
   // Get users and delete
-  const allDocsResponse: AllDocsResponse<User> = await db.allDocs({
-    include_docs: true,
-    keys: userIds,
-  })
-  const usersToDelete: User[] = allDocsResponse.rows.map(
-    (user: RowResponse<User>) => {
-      // if we find a user that has an associated group, add it to
-      // an array so we can easily use allDocs on them later.
-      // This prevents us having to re-loop over all the users
-      if (user.doc.userGroups) {
-        for (let groupId of user.doc.userGroups) {
-          if (!Object.keys(groupsToModify).includes(groupId)) {
-            groupsToModify[groupId] = [user.id]
-          } else {
-            groupsToModify[groupId] = [...groupsToModify[groupId], user.id]
-          }
+  let usersToDelete = (
+    await db.allDocs({
+      include_docs: true,
+      keys: userIds,
+    })
+  ).rows.map((user: any) => {
+    // if we find a user that has an associated group, add it to
+    // an array so we can easily use allDocs on them later.
+    // This prevents us having to re-loop over all the users
+    if (user.doc.userGroups) {
+      for (let groupId of user.doc.userGroups) {
+        if (!Object.keys(groupsToModify).includes(groupId)) {
+          groupsToModify[groupId] = [user.id]
+        } else {
+          groupsToModify[groupId] = [...groupsToModify[groupId], user.id]
         }
       }
+    }
 
-      // Also figure out how many builders are being deleted
-      if (eventHelpers.isAddingBuilder(user.doc, null)) {
-        builderCount++
-      }
-
-      return user.doc
+    // Also figure out how many builders are being deleted
+    if (eventHelpers.isAddingBuilder(user.doc, null)) {
+      builderCount++
     }
-  )
 
-  // Delete from DB
-  const dbResponse: BulkDocsResponse = await db.bulkDocs(
-    usersToDelete.map(user => ({
+    return user.doc
+  })
+
+  const response = await db.bulkDocs(
+    usersToDelete.map((user: any) => ({
       ...user,
       _deleted: true,
     }))
   )
 
-  // Deletion post processing
   await groupUtils.bulkDeleteGroupUsers(groupsToModify)
+
+  //Deletion post processing
   for (let user of usersToDelete) {
     await bulkDeleteProcessing(user)
   }
-  await quotas.removeDevelopers(builderCount)
 
-  // Build Response
-  // index users by id
-  const userIndex: { [key: string]: User } = {}
-  usersToDelete.reduce((prev, current) => {
-    prev[current._id!] = current
-    return prev
-  }, userIndex)
-
-  // add the successful and unsuccessful users to response
-  dbResponse.forEach(item => {
-    const email = userIndex[item.id].email
-    if (item.ok) {
-      response.successful.push({ _id: item.id, email })
-    } else {
-      response.unsuccessful.push({
-        _id: item.id,
-        email,
-        reason: "Database error",
-      })
-    }
-  })
+  await quotas.removeDevelopers(builderCount)
 
   return response
 }

package/src/tests/TestConfiguration.js

@@ -0,0 +1,231 @@
+require("./mocks")
+require("../db").init()
+const env = require("../environment")
+const controllers = require("./controllers")
+const supertest = require("supertest")
+const { jwt } = require("@budibase/backend-core/auth")
+const { Cookies, Headers } = require("@budibase/backend-core/constants")
+const { Configs } = require("../constants")
+const { users } = require("@budibase/backend-core")
+const { createASession } = require("@budibase/backend-core/sessions")
+const { TENANT_ID, CSRF_TOKEN } = require("./structures")
+const structures = require("./structures")
+const { doInTenant } = require("@budibase/backend-core/tenancy")
+const { groups } = require("@budibase/pro")
+class TestConfiguration {
+  constructor(openServer = true) {
+    if (openServer) {
+      env.PORT = "0" // random port
+      this.server = require("../index")
+      // we need the request for logging in, involves cookies, hard to fake
+      this.request = supertest(this.server)
+    }
+  }
+
+  getRequest() {
+    return this.request
+  }
+
+  // UTILS
+
+  async _req(config, params, controlFunc) {
+    const request = {}
+    // fake cookies, we don't need them
+    request.cookies = { set: () => {}, get: () => {} }
+    request.config = { jwtSecret: env.JWT_SECRET }
+    request.appId = this.appId
+    request.user = { appId: this.appId, tenantId: TENANT_ID }
+    request.query = {}
+    request.request = {
+      body: config,
+    }
+    request.throw = (status, err) => {
+      throw { status, message: err }
+    }
+    if (params) {
+      request.params = params
+    }
+    await doInTenant(TENANT_ID, () => {
+      return controlFunc(request)
+    })
+    return request.body
+  }
+
+  // SETUP / TEARDOWN
+
+  async beforeAll() {
+    await this.login()
+  }
+
+  async afterAll() {
+    if (this.server) {
+      await this.server.close()
+    }
+  }
+
+  // USER / AUTH
+
+  async login() {
+    // create a test user
+    await this._req(
+      {
+        email: "test@test.com",
+        password: "test",
+        _id: "us_uuid1",
+        builder: {
+          global: true,
+        },
+        admin: {
+          global: true,
+        },
+      },
+      null,
+      controllers.users.save
+    )
+    await createASession("us_uuid1", {
+      sessionId: "sessionid",
+      tenantId: TENANT_ID,
+      csrfToken: CSRF_TOKEN,
+    })
+  }
+
+  cookieHeader(cookies) {
+    return {
+      Cookie: [cookies],
+    }
+  }
+
+  defaultHeaders() {
+    const user = {
+      _id: "us_uuid1",
+      userId: "us_uuid1",
+      sessionId: "sessionid",
+      tenantId: TENANT_ID,
+    }
+    const authToken = jwt.sign(user, env.JWT_SECRET)
+    return {
+      Accept: "application/json",
+      ...this.cookieHeader([`${Cookies.Auth}=${authToken}`]),
+      [Headers.CSRF_TOKEN]: CSRF_TOKEN,
+    }
+  }
+
+  async getUser(email) {
+    return doInTenant(TENANT_ID, () => {
+      return users.getGlobalUserByEmail(email)
+    })
+  }
+
+  async getGroup(id) {
+    return doInTenant(TENANT_ID, () => {
+      return groups.get(id)
+    })
+  }
+
+  async saveGroup(group) {
+    const res = await this.getRequest()
+      .post(`/api/global/groups`)
+      .send(group)
+      .set(this.defaultHeaders())
+      .expect("Content-Type", /json/)
+      .expect(200)
+    return res.body
+  }
+
+  async createUser(email, password) {
+    const user = await this.getUser(structures.users.email)
+    if (user) {
+      return user
+    }
+    await this._req(
+      structures.users.user({ email, password }),
+      null,
+      controllers.users.save
+    )
+  }
+
+  async saveAdminUser() {
+    await this._req(
+      structures.users.user({ tenantId: TENANT_ID }),
+      null,
+      controllers.users.adminUser
+    )
+  }
+
+  // CONFIGS
+
+  async deleteConfig(type) {
+    try {
+      const cfg = await this._req(
+        null,
+        {
+          type,
+        },
+        controllers.config.find
+      )
+      if (cfg) {
+        await this._req(
+          null,
+          {
+            id: cfg._id,
+            rev: cfg._rev,
+          },
+          controllers.config.destroy
+        )
+      }
+    } catch (err) {
+      // don't need to handle error
+    }
+  }
+
+  // CONFIGS - SETTINGS
+
+  async saveSettingsConfig() {
+    await this.deleteConfig(Configs.SETTINGS)
+    await this._req(
+      structures.configs.settings(),
+      null,
+      controllers.config.save
+    )
+  }
+
+  // CONFIGS - GOOGLE
+
+  async saveGoogleConfig() {
+    await this.deleteConfig(Configs.GOOGLE)
+    await this._req(structures.configs.google(), null, controllers.config.save)
+  }
+
+  // CONFIGS - OIDC
+
+  getOIDConfigCookie(configId) {
+    const token = jwt.sign(configId, env.JWT_SECRET)
+    return this.cookieHeader([[`${Cookies.OIDC_CONFIG}=${token}`]])
+  }
+
+  async saveOIDCConfig() {
+    await this.deleteConfig(Configs.OIDC)
+    const config = structures.configs.oidc()
+
+    await this._req(config, null, controllers.config.save)
+    return config
+  }
+
+  // CONFIGS - SMTP
+
+  async saveSmtpConfig() {
+    await this.deleteConfig(Configs.SMTP)
+    await this._req(structures.configs.smtp(), null, controllers.config.save)
+  }
+
+  async saveEtherealSmtpConfig() {
+    await this.deleteConfig(Configs.SMTP)
+    await this._req(
+      structures.configs.smtpEthereal(),
+      null,
+      controllers.config.save
+    )
+  }
+}
+
+module.exports = TestConfiguration

package/src/tests/index.js

@@ -0,0 +1,12 @@
+const TestConfiguration = require("./TestConfiguration")
+const structures = require("./structures")
+const mocks = require("./mocks")
+const config = new TestConfiguration()
+const request = config.getRequest()
+
+module.exports = {
+  structures,
+  mocks,
+  config,
+  request,
+}

package/src/tests/mocks/index.js

@@ -0,0 +1,5 @@
+const email = require("./email")
+
+module.exports = {
+  email,
+}

package/src/tests/structures/index.js

@@ -0,0 +1,14 @@
+const configs = require("./configs")
+const users = require("./users")
+const groups = require("./groups")
+
+const TENANT_ID = "default"
+const CSRF_TOKEN = "e3727778-7af0-4226-b5eb-f43cbe60a306"
+
+module.exports = {
+  configs,
+  users,
+  TENANT_ID,
+  CSRF_TOKEN,
+  groups,
+}

package/src/tests/structures/users.ts

@@ -1,32 +1,24 @@
 export const email = "test@test.com"
-import { AdminUser, BuilderUser, User } from "@budibase/types"
-import { v4 as uuid } from "uuid"
 
-export const newEmail = () => {
-  return `${uuid()}@test.com`
-}
-export const user = (userProps?: any): User => {
+export const user = (userProps: any) => {
   return {
-    email: newEmail(),
+    email: "test@test.com",
     password: "test",
     roles: {},
     ...userProps,
   }
 }
 
-export const adminUser = (userProps?: any): AdminUser => {
+export const adminUser = (userProps: any) => {
   return {
     ...user(userProps),
     admin: {
       global: true,
     },
-    builder: {
-      global: true,
-    },
   }
 }
 
-export const builderUser = (userProps?: any): BuilderUser => {
+export const builderUser = (userProps: any) => {
   return {
     ...user(userProps),
     builder: {

package/src/utilities/redis.js

@@ -55,7 +55,6 @@ exports.init = async () => {
 exports.shutdown = async () => {
   if (pwResetClient) await pwResetClient.finish()
   if (invitationClient) await invitationClient.finish()
-  console.log("Redis shutdown")
 }
 
 /**