@budibase/worker 1.0.199 → 1.0.200-alpha.2

package/src/sdk/users/users.ts

@@ -0,0 +1,201 @@
+import env from "../../environment"
+import { quotas } from "@budibase/pro"
+import * as apps from "../../utilities/appService"
+import * as eventHelpers from "./events"
+import {
+  tenancy,
+  utils,
+  db as dbUtils,
+  constants,
+  cache,
+  users as usersCore,
+  deprovisioning,
+  sessions,
+  HTTPError,
+  accounts,
+  migrations,
+} from "@budibase/backend-core"
+import { MigrationType } from "@budibase/types"
+
+/**
+ * Retrieves all users from the current tenancy.
+ */
+export const allUsers = async () => {
+  const db = tenancy.getGlobalDB()
+  const response = await db.allDocs(
+    dbUtils.getGlobalUserParams(null, {
+      include_docs: true,
+    })
+  )
+  return response.rows.map((row: any) => row.doc)
+}
+
+/**
+ * Gets a user by ID from the global database, based on the current tenancy.
+ */
+export const getUser = async (userId: string) => {
+  const db = tenancy.getGlobalDB()
+  let user
+  try {
+    user = await db.get(userId)
+  } catch (err: any) {
+    // no user found, just return nothing
+    if (err.status === 404) {
+      return {}
+    }
+    throw err
+  }
+  if (user) {
+    delete user.password
+  }
+  return user
+}
+
+interface SaveUserOpts {
+  hashPassword?: boolean
+  requirePassword?: boolean
+  bulkCreate?: boolean
+}
+
+export const save = async (
+  user: any,
+  opts: SaveUserOpts = {
+    hashPassword: true,
+    requirePassword: true,
+    bulkCreate: false,
+  }
+) => {
+  const tenantId = tenancy.getTenantId()
+  const db = tenancy.getGlobalDB()
+  let { email, password, _id } = user
+  // make sure another user isn't using the same email
+  let dbUser: any
+  if (opts.bulkCreate) {
+    dbUser = null
+  } else if (email) {
+    // check budibase users inside the tenant
+    dbUser = await usersCore.getGlobalUserByEmail(email)
+    if (dbUser != null && (dbUser._id !== _id || Array.isArray(dbUser))) {
+      throw `Email address ${email} already in use.`
+    }
+
+    // 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)
+  }
+
+  // get the password, make sure one is defined
+  let hashedPassword
+  if (password) {
+    hashedPassword = opts.hashPassword ? await utils.hash(password) : password
+  } else if (dbUser) {
+    hashedPassword = dbUser.password
+  } else if (opts.requirePassword) {
+    throw "Password must be specified."
+  }
+
+  _id = _id || dbUtils.generateGlobalUserID(email)
+  user = {
+    createdAt: Date.now(),
+    ...dbUser,
+    ...user,
+    _id,
+    password: hashedPassword,
+    tenantId,
+  }
+  // make sure the roles object is always present
+  if (!user.roles) {
+    user.roles = {}
+  }
+  // add the active status to a user if its not provided
+  if (user.status == null) {
+    user.status = constants.UserStatus.ACTIVE
+  }
+  try {
+    const putOpts = {
+      password: hashedPassword,
+      ...user,
+    }
+    if (opts.bulkCreate) {
+      return putOpts
+    }
+    // save the user to db
+    let response
+    const putUserFn = () => {
+      return db.put(user)
+    }
+    if (eventHelpers.isAddingBuilder(user, dbUser)) {
+      response = await quotas.addDeveloper(putUserFn)
+    } else {
+      response = await putUserFn()
+    }
+    user._rev = response.rev
+
+    await eventHelpers.handleSaveEvents(user, dbUser)
+
+    if (env.MULTI_TENANCY) {
+      const afterCreateTenant = () =>
+        migrations.backPopulateMigrations({
+          type: MigrationType.GLOBAL,
+          tenantId,
+        })
+      await tenancy.tryAddTenant(tenantId, _id, email, afterCreateTenant)
+    }
+    await cache.user.invalidateUser(response.id)
+    // let server know to sync user
+    await apps.syncUserInApps(user._id)
+
+    return {
+      _id: response.id,
+      _rev: response.rev,
+      email,
+    }
+  } catch (err: any) {
+    if (err.status === 409) {
+      throw "User exists already"
+    } else {
+      throw err
+    }
+  }
+}
+
+export const destroy = async (id: string, currentUser: any) => {
+  const db = tenancy.getGlobalDB()
+  const dbUser = await db.get(id)
+
+  if (!env.SELF_HOSTED && !env.DISABLE_ACCOUNT_PORTAL) {
+    // root account holder can't be deleted from inside budibase
+    const email = dbUser.email
+    const account = await accounts.getAccount(email)
+    if (account) {
+      if (email === currentUser.email) {
+        throw new HTTPError('Please visit "Account" to delete this user', 400)
+      } else {
+        throw new HTTPError("Account holder cannot be deleted", 400)
+      }
+    }
+  }
+
+  await deprovisioning.removeUserFromInfoDB(dbUser)
+  await db.remove(dbUser._id, dbUser._rev)
+  await eventHelpers.handleDeleteEvents(dbUser)
+  await quotas.removeUser(dbUser)
+  await cache.user.invalidateUser(dbUser._id)
+  await sessions.invalidateSessions(dbUser._id)
+  // let server know to sync user
+  await apps.syncUserInApps(dbUser._id)
+}

package/src/{api/routes/tests/utilities → tests}/TestConfiguration.js

@@ -1,21 +1,22 @@
-require("../../../../db").init()
-const env = require("../../../../environment")
+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, LOGO_URL } = require("../../../../constants")
-const { getGlobalUserByEmail } = require("@budibase/backend-core/utils")
+const { Configs } = require("../constants")
+const { users } = require("@budibase/backend-core")
 const { createASession } = require("@budibase/backend-core/sessions")
-const { newid } = require("@budibase/backend-core/src/hashing")
 const { TENANT_ID, CSRF_TOKEN } = require("./structures")
+const structures = require("./structures")
 const { doInTenant } = require("@budibase/backend-core/tenancy")
 
 class TestConfiguration {
   constructor(openServer = true) {
     if (openServer) {
-      env.PORT = 4012
-      this.server = require("../../../../index")
+      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)
     }
@@ -25,6 +26,8 @@ class TestConfiguration {
     return this.request
   }
 
+  // UTILS
+
   async _req(config, params, controlFunc) {
     const request = {}
     // fake cookies, we don't need them
@@ -48,25 +51,37 @@ class TestConfiguration {
     return request.body
   }
 
-  async init(createUser = true) {
-    if (createUser) {
-      // 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
-      )
+  // 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,
@@ -74,12 +89,6 @@ class TestConfiguration {
     })
   }
 
-  async end() {
-    if (this.server) {
-      await this.server.close()
-    }
-  }
-
   cookieHeader(cookies) {
     return {
       Cookie: [cookies],
@@ -103,25 +112,32 @@ class TestConfiguration {
 
   async getUser(email) {
     return doInTenant(TENANT_ID, () => {
-      return getGlobalUserByEmail(email)
+      return users.getGlobalUserByEmail(email)
     })
   }
 
-  async createUser(email = "test@test.com", password = "test") {
-    const user = await this.getUser(email)
+  async createUser(email, password) {
+    const user = await this.getUser(structures.users.email)
     if (user) {
       return user
     }
     await this._req(
-      {
-        email,
-        password,
-      },
+      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(
@@ -146,37 +162,26 @@ class TestConfiguration {
     }
   }
 
+  // CONFIGS - SETTINGS
+
   async saveSettingsConfig() {
     await this.deleteConfig(Configs.SETTINGS)
     await this._req(
-      {
-        type: Configs.SETTINGS,
-        config: {
-          platformUrl: "http://localhost:10000",
-          logoUrl: LOGO_URL,
-          company: "Budibase",
-        },
-      },
+      structures.configs.settings(),
       null,
       controllers.config.save
     )
   }
 
-  async saveOAuthConfig() {
+  // CONFIGS - GOOGLE
+
+  async saveGoogleConfig() {
     await this.deleteConfig(Configs.GOOGLE)
-    await this._req(
-      {
-        type: Configs.GOOGLE,
-        config: {
-          clientID: "clientId",
-          clientSecret: "clientSecret",
-        },
-      },
-      null,
-      controllers.config.save
-    )
+    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}`]])
@@ -184,75 +189,27 @@ class TestConfiguration {
 
   async saveOIDCConfig() {
     await this.deleteConfig(Configs.OIDC)
-    const config = {
-      type: Configs.OIDC,
-      config: {
-        configs: [
-          {
-            configUrl: "http://someconfigurl",
-            clientID: "clientId",
-            clientSecret: "clientSecret",
-            logo: "Microsoft",
-            name: "Active Directory",
-            uuid: newid(),
-          },
-        ],
-      },
-    }
+    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(
-      {
-        type: Configs.SMTP,
-        config: {
-          port: 12345,
-          host: "smtptesthost.com",
-          from: "testfrom@test.com",
-          subject: "Hello!",
-        },
-      },
-      null,
-      controllers.config.save
-    )
+    await this._req(structures.configs.smtp(), null, controllers.config.save)
   }
 
   async saveEtherealSmtpConfig() {
     await this.deleteConfig(Configs.SMTP)
     await this._req(
-      {
-        type: Configs.SMTP,
-        config: {
-          port: 587,
-          host: "smtp.ethereal.email",
-          secure: false,
-          auth: {
-            user: "don.bahringer@ethereal.email",
-            pass: "yCKSH8rWyUPbnhGYk9",
-          },
-          connectionTimeout: 1000, // must be less than the jest default of 5000
-        },
-      },
+      structures.configs.smtpEthereal(),
       null,
       controllers.config.save
     )
   }
-
-  async saveAdminUser() {
-    await this._req(
-      {
-        email: "testuser@test.com",
-        password: "test@test.com",
-        tenantId: TENANT_ID,
-      },
-      null,
-      controllers.users.adminUser
-    )
-  }
 }
 
 module.exports = TestConfiguration

package/src/tests/controllers.js

@@ -0,0 +1,7 @@
+module.exports = {
+  email: require("../api/controllers/global/email"),
+  workspaces: require("../api/controllers/global/workspaces"),
+  config: require("../api/controllers/global/configs"),
+  templates: require("../api/controllers/global/templates"),
+  users: require("../api/controllers/global/users"),
+}

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/email.js

@@ -0,0 +1,10 @@
+exports.mock = () => {
+  // mock the email system
+  const sendMailMock = jest.fn()
+  const nodemailer = require("nodemailer")
+  nodemailer.createTransport.mockReturnValue({
+    sendMail: sendMailMock,
+    verify: jest.fn(),
+  })
+  return sendMailMock
+}

package/src/tests/mocks/index.js

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

package/src/tests/structures/configs.js

@@ -0,0 +1,76 @@
+const { Configs } = require("../../constants")
+const { utils } = require("@budibase/backend-core")
+
+exports.oidc = conf => {
+  return {
+    type: Configs.OIDC,
+    config: {
+      configs: [
+        {
+          configUrl: "http://someconfigurl",
+          clientID: "clientId",
+          clientSecret: "clientSecret",
+          logo: "Microsoft",
+          name: "Active Directory",
+          uuid: utils.newid(),
+          activated: true,
+          ...conf,
+        },
+      ],
+    },
+  }
+}
+
+exports.google = conf => {
+  return {
+    type: Configs.GOOGLE,
+    config: {
+      clientID: "clientId",
+      clientSecret: "clientSecret",
+      activated: true,
+      ...conf,
+    },
+  }
+}
+
+exports.smtp = conf => {
+  return {
+    type: Configs.SMTP,
+    config: {
+      port: 12345,
+      host: "smtptesthost.com",
+      from: "testfrom@test.com",
+      subject: "Hello!",
+      secure: false,
+      ...conf,
+    },
+  }
+}
+
+exports.smtpEthereal = () => {
+  return {
+    type: Configs.SMTP,
+    config: {
+      port: 587,
+      host: "smtp.ethereal.email",
+      secure: false,
+      auth: {
+        user: "don.bahringer@ethereal.email",
+        pass: "yCKSH8rWyUPbnhGYk9",
+      },
+      connectionTimeout: 1000, // must be less than the jest default of 5000
+    },
+  }
+}
+
+exports.settings = conf => {
+  return {
+    type: Configs.SETTINGS,
+    config: {
+      platformUrl: "http://localhost:10000",
+      logoUrl: "",
+      company: "Budibase",
+      ...conf,
+    },
+  }
+}

package/src/tests/structures/index.js

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

package/src/tests/structures/users.ts

@@ -0,0 +1,28 @@
+export const email = "test@test.com"
+
+export const user = (userProps: any) => {
+  return {
+    email: "test@test.com",
+    password: "test",
+    roles: {},
+    ...userProps,
+  }
+}
+
+export const adminUser = (userProps: any) => {
+  return {
+    ...user(userProps),
+    admin: {
+      global: true,
+    },
+  }
+}
+
+export const builderUser = (userProps: any) => {
+  return {
+    ...user(userProps),
+    builder: {
+      global: true,
+    },
+  }
+}

package/tsconfig.build.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "target": "es6",
+    "module": "commonjs",
+    "lib": ["es2020"],
+    "allowJs": true,
+    "strict": true,
+    "noImplicitAny": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "incremental": true,
+    "types": [ "node", "jest" ],
+    "outDir": "dist",
+    "skipLibCheck": true
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "**/*.spec.ts",
+    "**/*.spec.js"
+  ]
+}

package/tsconfig.json

@@ -1,23 +1,29 @@
 {
+  "extends": "./tsconfig.build.json",
   "compilerOptions": {
-    "target": "es6",
-    "module": "commonjs",
-    "lib": ["es2019"],
-    "allowJs": true,
-    "outDir": "dist",
-    "strict": true,
-    "noImplicitAny": true,
-    "esModuleInterop": true,
-    "resolveJsonModule": true,
-    "incremental": true
+    "composite": true,
+    "declaration": true,
+    "sourceMap": true,
+    "baseUrl": ".",
+    "paths": {
+      "@budibase/types": ["../types/src"],
+      "@budibase/backend-core": ["../backend-core/src"],
+      "@budibase/backend-core/*": ["../backend-core/*"]
+    }
   },
+  "ts-node": {
+    "require": ["tsconfig-paths/register"]
+  },
+  "references": [
+    { "path": "../types" },
+    { "path": "../backend-core" },
+  ],
   "include": [
-    "./src/**/*"
+    "src/**/*",
+    "package.json"
   ],
   "exclude": [
     "node_modules",
-    "**/*.json",
-    "**/*.spec.ts",
-    "**/*.spec.js"
+    "dist"
   ]
-}
+}