@budibase/worker 2.1.43-alpha.1 → 2.1.43

package/src/tests/TestConfiguration.ts

@@ -1,42 +1,41 @@
 import "./mocks"
-import * as dbConfig from "../db"
+import dbConfig from "../db"
 dbConfig.init()
 import env from "../environment"
-import * as controllers from "./controllers"
+import controllers from "./controllers"
 const supertest = require("supertest")
-import { Config } from "../constants"
+import { Configs } from "../constants"
 import {
   users,
   tenancy,
+  Cookies,
+  Headers,
   sessions,
   auth,
-  constants,
-  env as coreEnv,
 } from "@budibase/backend-core"
-import structures, { TENANT_ID, TENANT_1, CSRF_TOKEN } from "./structures"
+import { TENANT_ID, TENANT_1, CSRF_TOKEN } from "./structures"
+import structures from "./structures"
 import { CreateUserResponse, User, AuthToken } from "@budibase/types"
-import API from "./api"
 
 enum Mode {
-  CLOUD = "cloud",
+  ACCOUNT = "account",
   SELF = "self",
 }
 
 class TestConfiguration {
   server: any
   request: any
-  api: API
   defaultUser?: User
   tenant1User?: User
 
   constructor(
     opts: { openServer: boolean; mode: Mode } = {
       openServer: true,
-      mode: Mode.CLOUD,
+      mode: Mode.ACCOUNT,
     }
   ) {
-    if (opts.mode === Mode.CLOUD) {
-      this.modeCloud()
+    if (opts.mode === Mode.ACCOUNT) {
+      this.modeAccount()
     } else if (opts.mode === Mode.SELF) {
       this.modeSelf()
     }
@@ -47,8 +46,6 @@ class TestConfiguration {
       // we need the request for logging in, involves cookies, hard to fake
       this.request = supertest(this.server)
     }
-
-    this.api = new API(this)
   }
 
   getRequest() {
@@ -57,24 +54,20 @@ class TestConfiguration {
 
   // MODES
 
-  setMultiTenancy = (value: boolean) => {
-    env._set("MULTI_TENANCY", value)
-    coreEnv._set("MULTI_TENANCY", value)
-  }
-
-  setSelfHosted = (value: boolean) => {
-    env._set("SELF_HOSTED", value)
-    coreEnv._set("SELF_HOSTED", value)
-  }
-
-  modeCloud = () => {
-    this.setSelfHosted(false)
-    this.setMultiTenancy(true)
+  modeAccount = () => {
+    env.SELF_HOSTED = false
+    // @ts-ignore
+    env.MULTI_TENANCY = true
+    // @ts-ignore
+    env.DISABLE_ACCOUNT_PORTAL = false
   }
 
   modeSelf = () => {
-    this.setSelfHosted(true)
-    this.setMultiTenancy(false)
+    env.SELF_HOSTED = true
+    // @ts-ignore
+    env.MULTI_TENANCY = false
+    // @ts-ignore
+    env.DISABLE_ACCOUNT_PORTAL = true
   }
 
   // UTILS
@@ -121,25 +114,6 @@ class TestConfiguration {
 
   // TENANCY
 
-  createTenant = async (): Promise<User> => {
-    // create user / new tenant
-    const res = await this.api.users.createAdminUser()
-
-    // return the created user
-    const userRes = await this.api.users.getUser(res.userId, {
-      headers: {
-        ...this.internalAPIHeaders(),
-        [constants.Header.TENANT_ID]: res.tenantId,
-      },
-    })
-
-    // create a session for the new user
-    const user = userRes.body
-    await this.createSession(user)
-
-    return user
-  }
-
   getTenantId() {
     try {
       return tenancy.getTenantId()
@@ -148,32 +122,35 @@ class TestConfiguration {
     }
   }
 
-  // AUTH
+  // USER / AUTH
 
-  async _createSession({
-    userId,
-    tenantId,
-  }: {
-    userId: string
-    tenantId: string
-  }) {
-    await sessions.createASession(userId!, {
-      sessionId: "sessionid",
-      tenantId: tenantId,
-      csrfToken: CSRF_TOKEN,
+  async createDefaultUser() {
+    const user = structures.users.adminUser({
+      email: "test@test.com",
+      password: "test",
     })
+    this.defaultUser = await this.createUser(user)
+  }
+
+  async createTenant1User() {
+    const user = structures.users.adminUser({
+      email: "tenant1@test.com",
+      password: "test",
+    })
+    this.tenant1User = await this.createUser(user)
   }
 
   async createSession(user: User) {
-    return this._createSession({ userId: user._id!, tenantId: user.tenantId })
+    await sessions.createASession(user._id!, {
+      sessionId: "sessionid",
+      tenantId: user.tenantId,
+      csrfToken: CSRF_TOKEN,
+    })
   }
 
   cookieHeader(cookies: any) {
-    if (!Array.isArray(cookies)) {
-      cookies = [cookies]
-    }
     return {
-      Cookie: cookies,
+      Cookie: [cookies],
     }
   }
 
@@ -186,8 +163,8 @@ class TestConfiguration {
     const authCookie = auth.jwt.sign(authToken, env.JWT_SECRET)
     return {
       Accept: "application/json",
-      ...this.cookieHeader([`${constants.Cookie.Auth}=${authCookie}`]),
-      [constants.Header.CSRF_TOKEN]: CSRF_TOKEN,
+      ...this.cookieHeader([`${Cookies.Auth}=${authCookie}`]),
+      [Headers.CSRF_TOKEN]: CSRF_TOKEN,
     }
   }
 
@@ -202,32 +179,6 @@ class TestConfiguration {
     }
   }
 
-  internalAPIHeaders() {
-    return { [constants.Header.API_KEY]: env.INTERNAL_API_KEY }
-  }
-
-  adminOnlyResponse = () => {
-    return { message: "Admin user only endpoint.", status: 403 }
-  }
-
-  // USERS
-
-  async createDefaultUser() {
-    const user = structures.users.adminUser({
-      email: "test@test.com",
-      password: "test",
-    })
-    this.defaultUser = await this.createUser(user)
-  }
-
-  async createTenant1User() {
-    const user = structures.users.adminUser({
-      email: "tenant1@test.com",
-      password: "test",
-    })
-    this.tenant1User = await this.createUser(user)
-  }
-
   async getUser(email: string): Promise<User> {
     return tenancy.doInTenant(this.getTenantId(), () => {
       return users.getGlobalUserByEmail(email)
@@ -272,7 +223,7 @@ class TestConfiguration {
   // CONFIGS - SETTINGS
 
   async saveSettingsConfig() {
-    await this.deleteConfig(Config.SETTINGS)
+    await this.deleteConfig(Configs.SETTINGS)
     await this._req(
       structures.configs.settings(),
       null,
@@ -283,7 +234,7 @@ class TestConfiguration {
   // CONFIGS - GOOGLE
 
   async saveGoogleConfig() {
-    await this.deleteConfig(Config.GOOGLE)
+    await this.deleteConfig(Configs.GOOGLE)
     await this._req(structures.configs.google(), null, controllers.config.save)
   }
 
@@ -291,11 +242,11 @@ class TestConfiguration {
 
   getOIDConfigCookie(configId: string) {
     const token = auth.jwt.sign(configId, env.JWT_SECRET)
-    return this.cookieHeader([[`${constants.Cookie.OIDC_CONFIG}=${token}`]])
+    return this.cookieHeader([[`${Cookies.OIDC_CONFIG}=${token}`]])
   }
 
   async saveOIDCConfig() {
-    await this.deleteConfig(Config.OIDC)
+    await this.deleteConfig(Configs.OIDC)
     const config = structures.configs.oidc()
 
     await this._req(config, null, controllers.config.save)
@@ -305,12 +256,12 @@ class TestConfiguration {
   // CONFIGS - SMTP
 
   async saveSmtpConfig() {
-    await this.deleteConfig(Config.SMTP)
+    await this.deleteConfig(Configs.SMTP)
     await this._req(structures.configs.smtp(), null, controllers.config.save)
   }
 
   async saveEtherealSmtpConfig() {
-    await this.deleteConfig(Config.SMTP)
+    await this.deleteConfig(Configs.SMTP)
     await this._req(
       structures.configs.smtpEthereal(),
       null,

package/src/tests/api/accounts.ts

@@ -1,17 +1,20 @@
 import { Account, AccountMetadata } from "@budibase/types"
 import TestConfiguration from "../TestConfiguration"
-import { TestAPI } from "./base"
 
-export class AccountAPI extends TestAPI {
+export class AccountAPI {
+  config: TestConfiguration
+  request: any
+
   constructor(config: TestConfiguration) {
-    super(config)
+    this.config = config
+    this.request = config.request
   }
 
   saveMetadata = async (account: Account) => {
     const res = await this.request
       .put(`/api/system/accounts/${account.accountId}/metadata`)
       .send(account)
-      .set(this.config.internalAPIHeaders())
+      .set(this.config.defaultHeaders())
       .expect("Content-Type", /json/)
       .expect(200)
     return res.body as AccountMetadata
@@ -20,6 +23,6 @@ export class AccountAPI extends TestAPI {
   destroyMetadata = (accountId: string) => {
     return this.request
       .del(`/api/system/accounts/${accountId}/metadata`)
-      .set(this.config.internalAPIHeaders())
+      .set(this.config.defaultHeaders())
   }
 }

package/src/tests/api/auth.ts

@@ -1,9 +1,12 @@
 import TestConfiguration from "../TestConfiguration"
-import { TestAPI } from "./base"
 
-export class AuthAPI extends TestAPI {
+export class AuthAPI {
+  config: TestConfiguration
+  request: any
+
   constructor(config: TestConfiguration) {
-    super(config)
+    this.config = config
+    this.request = config.request
   }
 
   updatePassword = (code: string) => {

package/src/tests/api/configs.ts

@@ -1,9 +1,12 @@
 import TestConfiguration from "../TestConfiguration"
-import { TestAPI } from "./base"
 
-export class ConfigAPI extends TestAPI {
+export class ConfigAPI {
+  config: TestConfiguration
+  request: any
+
   constructor(config: TestConfiguration) {
-    super(config)
+    this.config = config
+    this.request = config.request
   }
 
   getConfigChecklist = () => {
@@ -23,20 +26,10 @@ export class ConfigAPI extends TestAPI {
       .expect(200)
   }
 
-  OIDCCallback = (configId: string, preAuthRes: any) => {
-    const cookie = this.config.cookieHeader(preAuthRes.get("set-cookie"))
-    const setKoaSession = cookie.Cookie.find((c: string) =>
-      c.includes("koa:sess")
-    )
-    const koaSession = setKoaSession.split("=")[1] + "=="
-    const sessionContent = JSON.parse(
-      Buffer.from(koaSession, "base64").toString("utf-8")
-    )
-    const handle = sessionContent["openidconnect:localhost"].state.handle
+  OIDCCallback = (configId: string) => {
     return this.request
       .get(`/api/global/auth/${this.config.getTenantId()}/oidc/callback`)
-      .query({ code: "test", state: handle })
-      .set(cookie)
+      .set(this.config.getOIDConfigCookie(configId))
   }
 
   getOIDCConfig = (configId: string) => {

package/src/tests/api/email.ts

@@ -1,9 +1,12 @@
 import TestConfiguration from "../TestConfiguration"
-import { TestAPI } from "./base"
 
-export class EmailAPI extends TestAPI {
+export class EmailAPI {
+  config: TestConfiguration
+  request: any
+
   constructor(config: TestConfiguration) {
-    super(config)
+    this.config = config
+    this.request = config.request
   }
 
   sendEmail = (purpose: string) => {

package/src/tests/api/index.ts

@@ -5,11 +5,6 @@ import { ConfigAPI } from "./configs"
 import { EmailAPI } from "./email"
 import { SelfAPI } from "./self"
 import { UserAPI } from "./users"
-import { EnvironmentAPI } from "./environment"
-import { MigrationAPI } from "./migrations"
-import { StatusAPI } from "./status"
-import { RestoreAPI } from "./restore"
-import { TenantAPI } from "./tenants"
 
 export default class API {
   accounts: AccountAPI
@@ -18,11 +13,6 @@ export default class API {
   emails: EmailAPI
   self: SelfAPI
   users: UserAPI
-  environment: EnvironmentAPI
-  migrations: MigrationAPI
-  status: StatusAPI
-  restore: RestoreAPI
-  tenants: TenantAPI
 
   constructor(config: TestConfiguration) {
     this.accounts = new AccountAPI(config)
@@ -31,10 +21,5 @@ export default class API {
     this.emails = new EmailAPI(config)
     this.self = new SelfAPI(config)
     this.users = new UserAPI(config)
-    this.environment = new EnvironmentAPI(config)
-    this.migrations = new MigrationAPI(config)
-    this.status = new StatusAPI(config)
-    this.restore = new RestoreAPI(config)
-    this.tenants = new TenantAPI(config)
   }
 }

package/src/tests/api/self.ts

@@ -1,10 +1,13 @@
 import TestConfiguration from "../TestConfiguration"
 import { User } from "@budibase/types"
-import { TestAPI } from "./base"
 
-export class SelfAPI extends TestAPI {
+export class SelfAPI {
+  config: TestConfiguration
+  request: any
+
   constructor(config: TestConfiguration) {
-    super(config)
+    this.config = config
+    this.request = config.request
   }
 
   updateSelf = (user: User) => {
@@ -15,12 +18,4 @@ export class SelfAPI extends TestAPI {
       .expect("Content-Type", /json/)
       .expect(200)
   }
-
-  getSelf = (user: User) => {
-    return this.request
-      .get(`/api/global/self`)
-      .set(this.config.authHeaders(user))
-      .expect("Content-Type", /json/)
-      .expect(200)
-  }
 }

package/src/tests/api/users.ts

@@ -3,16 +3,16 @@ import {
   BulkUserRequest,
   InviteUsersRequest,
   User,
-  CreateAdminUserRequest,
 } from "@budibase/types"
-import * as structures from "../structures"
-import { generator } from "@budibase/backend-core/tests"
 import TestConfiguration from "../TestConfiguration"
-import { TestAPI, TestAPIOpts } from "./base"
 
-export class UserAPI extends TestAPI {
+export class UserAPI {
+  config: TestConfiguration
+  request: any
+
   constructor(config: TestConfiguration) {
-    super(config)
+    this.config = config
+    this.request = config.request
   }
 
   // INVITE
@@ -91,30 +91,6 @@ export class UserAPI extends TestAPI {
 
   // USER
 
-  createAdminUser = async (
-    request?: CreateAdminUserRequest,
-    opts?: TestAPIOpts
-  ) => {
-    if (!request) {
-      request = {
-        email: structures.email(),
-        password: generator.string(),
-        tenantId: structures.uuid(),
-      }
-    }
-    const res = await this.request
-      .post(`/api/global/users/init`)
-      .send(request)
-      .set(this.config.internalAPIHeaders())
-      .expect("Content-Type", /json/)
-      .expect(opts?.status ? opts.status : 200)
-
-    return {
-      ...request,
-      userId: res.body._id,
-    }
-  }
-
   saveUser = (user: User, status?: number, headers?: any) => {
     return this.request
       .post(`/api/global/users`)
@@ -131,12 +107,4 @@ export class UserAPI extends TestAPI {
       .expect("Content-Type", /json/)
       .expect(status ? status : 200)
   }
-
-  getUser = (userId: string, opts?: TestAPIOpts) => {
-    return this.request
-      .get(`/api/global/users/${userId}`)
-      .set(opts?.headers ? opts.headers : this.config.defaultHeaders())
-      .expect("Content-Type", /json/)
-      .expect(opts?.status ? opts.status : 200)
-  }
 }

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.ts

@@ -1,14 +1,10 @@
-import mocks from "./mocks"
-import { generator } from "@budibase/backend-core/tests"
 import TestConfiguration from "./TestConfiguration"
 import structures from "./structures"
+import mocks from "./mocks"
 import API from "./api"
-import { v4 as uuid } from "uuid"
 
 const pkg = {
   structures,
-  generator,
-  uuid,
   TENANT_1: structures.TENANT_1,
   mocks,
   TestConfiguration,

package/src/tests/structures/accounts.ts

@@ -0,0 +1,24 @@
+import { Account, AuthType, Hosting, CloudAccount } from "@budibase/types"
+import { v4 as uuid } from "uuid"
+import { utils } from "@budibase/backend-core"
+
+export const account = (): Account => {
+  return {
+    email: `${uuid()}@test.com`,
+    tenantId: utils.newid(),
+    hosting: Hosting.SELF,
+    authType: AuthType.SSO,
+    accountId: uuid(),
+    createdAt: Date.now(),
+    verified: true,
+    verificationSent: true,
+    tier: "FREE",
+  }
+}
+
+export const cloudAccount = (): CloudAccount => {
+  return {
+    ...account(),
+    budibaseUserId: uuid(),
+  }
+}

package/src/tests/structures/{configs.ts → configs.js}

@@ -1,9 +1,9 @@
-const { Config } = require("../../constants")
+const { Configs } = require("../../constants")
 const { utils } = require("@budibase/backend-core")
 
-export function oidc(conf?: any) {
+exports.oidc = conf => {
   return {
-    type: Config.OIDC,
+    type: Configs.OIDC,
     config: {
       configs: [
         {
@@ -21,9 +21,9 @@ export function oidc(conf?: any) {
   }
 }
 
-export function google(conf?: any) {
+exports.google = conf => {
   return {
-    type: Config.GOOGLE,
+    type: Configs.GOOGLE,
     config: {
       clientID: "clientId",
       clientSecret: "clientSecret",
@@ -33,9 +33,9 @@ export function google(conf?: any) {
   }
 }
 
-export function smtp(conf?: any) {
+exports.smtp = conf => {
   return {
-    type: Config.SMTP,
+    type: Configs.SMTP,
     config: {
       port: 12345,
       host: "smtptesthost.com",
@@ -47,9 +47,9 @@ export function smtp(conf?: any) {
   }
 }
 
-export function smtpEthereal() {
+exports.smtpEthereal = () => {
   return {
-    type: Config.SMTP,
+    type: Configs.SMTP,
     config: {
       port: 587,
       host: "smtp.ethereal.email",
@@ -63,9 +63,9 @@ export function smtpEthereal() {
   }
 }
 
-export function settings(conf?: any) {
+exports.settings = conf => {
   return {
-    type: Config.SETTINGS,
+    type: Configs.SETTINGS,
     config: {
       platformUrl: "http://localhost:10000",
       logoUrl: "",

package/src/tests/structures/index.ts

@@ -1,18 +1,16 @@
-import { structures } from "@budibase/backend-core/tests"
-import * as configs from "./configs"
+import configs from "./configs"
 import * as users from "./users"
 import * as groups from "./groups"
-import { v4 as uuid } from "uuid"
+import * as accounts from "./accounts"
 
 const TENANT_ID = "default"
 const TENANT_1 = "tenant1"
 const CSRF_TOKEN = "e3727778-7af0-4226-b5eb-f43cbe60a306"
 
 const pkg = {
-  ...structures,
-  uuid,
   configs,
   users,
+  accounts,
   TENANT_ID,
   TENANT_1,
   CSRF_TOKEN,

package/src/tests/structures/users.ts

@@ -5,7 +5,6 @@ import { v4 as uuid } from "uuid"
 export const newEmail = () => {
   return `${uuid()}@test.com`
 }
-
 export const user = (userProps?: any): User => {
   return {
     email: newEmail(),

package/src/utilities/appService.js

@@ -0,0 +1,33 @@
+const fetch = require("node-fetch")
+const { Headers } = require("@budibase/backend-core/constants")
+const { getTenantId, isTenantIdSet } = require("@budibase/backend-core/tenancy")
+const { checkSlashesInUrl } = require("../utilities")
+const env = require("../environment")
+
+async function makeAppRequest(url, method, body) {
+  if (env.isTest()) {
+    return
+  }
+  const request = { headers: {} }
+  request.headers[Headers.API_KEY] = env.INTERNAL_API_KEY
+  if (isTenantIdSet()) {
+    request.headers[Headers.TENANT_ID] = getTenantId()
+  }
+  if (body) {
+    request.headers["Content-Type"] = "application/json"
+    request.body = JSON.stringify(body)
+  }
+  request.method = method
+  return fetch(checkSlashesInUrl(env.APPS_URL + url), request)
+}
+
+exports.syncUserInApps = async userId => {
+  const response = await makeAppRequest(
+    `/api/users/metadata/sync/${userId}`,
+    "POST",
+    {}
+  )
+  if (response && response.status !== 200) {
+    throw "Unable to sync user."
+  }
+}