@budibase/worker 2.1.22-alpha.6 → 2.1.22-alpha.8

package/jest.config.ts

@@ -15,6 +15,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.1.22-alpha.6",
+  "version": "2.1.22-alpha.8",
   "description": "Budibase background service",
   "main": "src/index.ts",
   "repository": {
@@ -36,10 +36,10 @@
   "author": "Budibase",
   "license": "GPL-3.0",
   "dependencies": {
-    "@budibase/backend-core": "2.1.22-alpha.6",
-    "@budibase/pro": "2.1.22-alpha.5",
-    "@budibase/string-templates": "2.1.22-alpha.6",
-    "@budibase/types": "2.1.22-alpha.6",
+    "@budibase/backend-core": "2.1.22-alpha.8",
+    "@budibase/pro": "2.1.22-alpha.7",
+    "@budibase/string-templates": "2.1.22-alpha.8",
+    "@budibase/types": "2.1.22-alpha.8",
     "@koa/router": "8.0.8",
     "@sentry/node": "6.17.7",
     "@techpass/passport-openidconnect": "0.3.2",
@@ -94,5 +94,5 @@
     "typescript": "4.7.3",
     "update-dotenv": "1.1.1"
   },
-  "gitHead": "395a9a21c27c534fd2b4297f5d0d19a341089993"
+  "gitHead": "d9dff5c7adfbef3147b2fa5370894efd1e40a7e5"
 }

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

@@ -1,22 +1,26 @@
 import core from "@budibase/backend-core"
-const { Configs, EmailTemplatePurpose } = require("../../../constants")
-const { sendEmail, isEmailConfigured } = require("../../../utilities/email")
-const { setCookie, getCookie, clearCookie, hash, platformLogout } = core.utils
-const { Cookies, Headers } = core.constants
-const { passport, ssoCallbackUrl, google, oidc } = core.auth
-const { checkResetPasswordCode } = require("../../../utilities/redis")
-const { getGlobalDB } = require("@budibase/backend-core/tenancy")
-const env = require("../../../environment")
-import { events, users as usersCore, context } from "@budibase/backend-core"
+import {
+  events,
+  users as usersCore,
+  context,
+  tenancy,
+} from "@budibase/backend-core"
+import { Config, EmailTemplatePurpose } from "../../../constants"
+import { sendEmail, isEmailConfigured } from "../../../utilities/email"
+import { checkResetPasswordCode } from "../../../utilities/redis"
+import env from "../../../environment"
 import sdk from "../../../sdk"
 import { User } from "@budibase/types"
+const { setCookie, getCookie, clearCookie, hash, platformLogout } = core.utils
+const { Cookie, Header } = core.constants
+const { passport, ssoCallbackUrl, google, oidc } = core.auth
 
 export const googleCallbackUrl = async (config: any) => {
-  return ssoCallbackUrl(getGlobalDB(), config, "google")
+  return ssoCallbackUrl(tenancy.getGlobalDB(), config, "google")
 }
 
 export const oidcCallbackUrl = async (config: any) => {
-  return ssoCallbackUrl(getGlobalDB(), config, "oidc")
+  return ssoCallbackUrl(tenancy.getGlobalDB(), config, "oidc")
 }
 
 async function authInternal(ctx: any, user: any, err = null, info = null) {
@@ -30,13 +34,13 @@ async function authInternal(ctx: any, user: any, err = null, info = null) {
   }
 
   // set a cookie for browser access
-  setCookie(ctx, user.token, Cookies.Auth, { sign: false })
+  setCookie(ctx, user.token, Cookie.Auth, { sign: false })
   // set the token in a header as well for APIs
-  ctx.set(Headers.TOKEN, user.token)
+  ctx.set(Header.TOKEN, user.token)
   // get rid of any app cookies on login
   // have to check test because this breaks cypress
   if (!env.isTest()) {
-    clearCookie(ctx, Cookies.CurrentApp)
+    clearCookie(ctx, Cookie.CurrentApp)
   }
 }
 
@@ -55,15 +59,15 @@ export const authenticate = async (ctx: any, next: any) => {
 
 export const setInitInfo = (ctx: any) => {
   const initInfo = ctx.request.body
-  setCookie(ctx, initInfo, Cookies.Init)
+  setCookie(ctx, initInfo, Cookie.Init)
   ctx.status = 200
 }
 
 export const getInitInfo = (ctx: any) => {
   try {
-    ctx.body = getCookie(ctx, Cookies.Init) || {}
+    ctx.body = getCookie(ctx, Cookie.Init) || {}
   } catch (err) {
-    clearCookie(ctx, Cookies.Init)
+    clearCookie(ctx, Cookie.Init)
     ctx.body = {}
   }
 }
@@ -106,7 +110,7 @@ export const resetUpdate = async (ctx: any) => {
   const { resetCode, password } = ctx.request.body
   try {
     const { userId } = await checkResetPasswordCode(resetCode)
-    const db = getGlobalDB()
+    const db = tenancy.getGlobalDB()
     const user = await db.get(userId)
     user.password = await hash(password)
     await db.put(user)
@@ -141,14 +145,14 @@ export const datasourcePreAuth = async (ctx: any, next: any) => {
       appId: ctx.query.appId,
       datasourceId: ctx.query.datasourceId,
     },
-    Cookies.DatasourceAuth
+    Cookie.DatasourceAuth
   )
 
   return handler.preAuth(passport, ctx, next)
 }
 
 export const datasourceAuth = async (ctx: any, next: any) => {
-  const authStateCookie = getCookie(ctx, Cookies.DatasourceAuth)
+  const authStateCookie = getCookie(ctx, Cookie.DatasourceAuth)
   const provider = authStateCookie.provider
   const middleware = require(`@budibase/backend-core/middleware`)
   const handler = middleware.datasource[provider]
@@ -160,10 +164,10 @@ export const datasourceAuth = async (ctx: any, next: any) => {
  * On a successful login, you will be redirected to the googleAuth callback route.
  */
 export const googlePreAuth = async (ctx: any, next: any) => {
-  const db = getGlobalDB()
+  const db = tenancy.getGlobalDB()
 
   const config = await core.db.getScopedConfig(db, {
-    type: Configs.GOOGLE,
+    type: Config.GOOGLE,
     workspace: ctx.query.workspace,
   })
   let callbackUrl = await exports.googleCallbackUrl(config)
@@ -181,10 +185,10 @@ export const googlePreAuth = async (ctx: any, next: any) => {
 }
 
 export const googleAuth = async (ctx: any, next: any) => {
-  const db = getGlobalDB()
+  const db = tenancy.getGlobalDB()
 
   const config = await core.db.getScopedConfig(db, {
-    type: Configs.GOOGLE,
+    type: Config.GOOGLE,
     workspace: ctx.query.workspace,
   })
   const callbackUrl = await exports.googleCallbackUrl(config)
@@ -208,9 +212,9 @@ export const googleAuth = async (ctx: any, next: any) => {
 }
 
 export const oidcStrategyFactory = async (ctx: any, configId: any) => {
-  const db = getGlobalDB()
+  const db = tenancy.getGlobalDB()
   const config = await core.db.getScopedConfig(db, {
-    type: Configs.OIDC,
+    type: Config.OIDC,
     group: ctx.query.group,
   })
 
@@ -233,11 +237,11 @@ export const oidcPreAuth = async (ctx: any, next: any) => {
   const { configId } = ctx.params
   const strategy = await oidcStrategyFactory(ctx, configId)
 
-  setCookie(ctx, configId, Cookies.OIDC_CONFIG)
+  setCookie(ctx, configId, Cookie.OIDC_CONFIG)
 
-  const db = getGlobalDB()
+  const db = tenancy.getGlobalDB()
   const config = await core.db.getScopedConfig(db, {
-    type: Configs.OIDC,
+    type: Config.OIDC,
     group: ctx.query.group,
   })
 
@@ -255,7 +259,7 @@ export const oidcPreAuth = async (ctx: any, next: any) => {
 }
 
 export const oidcAuth = async (ctx: any, next: any) => {
-  const configId = getCookie(ctx, Cookies.OIDC_CONFIG)
+  const configId = getCookie(ctx, Cookie.OIDC_CONFIG)
   const strategy = await oidcStrategyFactory(ctx, configId)
 
   return passport.authenticate(

package/src/api/controllers/global/configs.js

@@ -4,7 +4,7 @@ const {
   getScopedFullConfig,
   getAllApps,
 } = require("@budibase/backend-core/db")
-const { Configs } = require("../../../constants")
+const { Config } = require("../../../constants")
 const email = require("../../../utilities/email")
 const {
   upload,
@@ -33,25 +33,25 @@ const getEventFns = async (db, config) => {
 
   if (!existing) {
     switch (config.type) {
-      case Configs.SMTP: {
+      case Config.SMTP: {
         fns.push(events.email.SMTPCreated)
         break
       }
-      case Configs.GOOGLE: {
+      case Config.GOOGLE: {
         fns.push(() => events.auth.SSOCreated(type))
         if (config.config.activated) {
           fns.push(() => events.auth.SSOActivated(type))
         }
         break
       }
-      case Configs.OIDC: {
+      case Config.OIDC: {
         fns.push(() => events.auth.SSOCreated(type))
         if (config.config.configs[0].activated) {
           fns.push(() => events.auth.SSOActivated(type))
         }
         break
       }
-      case Configs.SETTINGS: {
+      case Config.SETTINGS: {
         // company
         const company = config.config.company
         if (company && company !== "Budibase") {
@@ -78,11 +78,11 @@ const getEventFns = async (db, config) => {
     }
   } else {
     switch (config.type) {
-      case Configs.SMTP: {
+      case Config.SMTP: {
         fns.push(events.email.SMTPUpdated)
         break
       }
-      case Configs.GOOGLE: {
+      case Config.GOOGLE: {
         fns.push(() => events.auth.SSOUpdated(type))
         if (!existing.config.activated && config.config.activated) {
           fns.push(() => events.auth.SSOActivated(type))
@@ -91,7 +91,7 @@ const getEventFns = async (db, config) => {
         }
         break
       }
-      case Configs.OIDC: {
+      case Config.OIDC: {
         fns.push(() => events.auth.SSOUpdated(type))
         if (
           !existing.config.configs[0].activated &&
@@ -106,7 +106,7 @@ const getEventFns = async (db, config) => {
         }
         break
       }
-      case Configs.SETTINGS: {
+      case Config.SETTINGS: {
         // company
         const existingCompany = existing.config.company
         const company = config.config.company
@@ -155,7 +155,7 @@ exports.save = async function (ctx) {
   try {
     // verify the configuration
     switch (type) {
-      case Configs.SMTP:
+      case Config.SMTP:
         await email.verifyConfig(config)
         break
     }
@@ -237,7 +237,7 @@ exports.publicOidc = async function (ctx) {
   try {
     // Find the config with the most granular scope based on context
     const oidcConfig = await getScopedFullConfig(db, {
-      type: Configs.OIDC,
+      type: Config.OIDC,
     })
 
     if (!oidcConfig) {
@@ -260,15 +260,15 @@ exports.publicSettings = async function (ctx) {
   try {
     // Find the config with the most granular scope based on context
     const publicConfig = await getScopedFullConfig(db, {
-      type: Configs.SETTINGS,
+      type: Config.SETTINGS,
     })
 
     const googleConfig = await getScopedFullConfig(db, {
-      type: Configs.GOOGLE,
+      type: Config.GOOGLE,
     })
 
     const oidcConfig = await getScopedFullConfig(db, {
-      type: Configs.OIDC,
+      type: Config.OIDC,
     })
 
     let config
@@ -390,17 +390,17 @@ exports.configChecklist = async function (ctx) {
 
         // They have set up SMTP
         const smtpConfig = await getScopedFullConfig(db, {
-          type: Configs.SMTP,
+          type: Config.SMTP,
         })
 
         // They have set up Google Auth
         const googleConfig = await getScopedFullConfig(db, {
-          type: Configs.GOOGLE,
+          type: Config.GOOGLE,
         })
 
         // They have set up OIDC
         const oidcConfig = await getScopedFullConfig(db, {
-          type: Configs.OIDC,
+          type: Config.OIDC,
         })
 
         // They have set up an global user

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

@@ -73,12 +73,12 @@ export async function fetchAPIKey(ctx: any) {
 }
 
 const checkCurrentApp = (ctx: any) => {
-  const appCookie = getCookie(ctx, constants.Cookies.CurrentApp)
+  const appCookie = getCookie(ctx, constants.Cookie.CurrentApp)
   if (appCookie && !tenancy.isUserInAppTenant(appCookie.appId)) {
     // there is a currentapp cookie from another tenant
     // remove the cookie as this is incompatible with the builder
     // due to builder and admin permissions being removed
-    clearCookie(ctx, constants.Cookies.CurrentApp)
+    clearCookie(ctx, constants.Cookie.CurrentApp)
   }
 }
 

package/src/api/routes/global/configs.js

@@ -3,7 +3,7 @@ const controller = require("../../controllers/global/configs")
 const { joiValidator } = require("@budibase/backend-core/auth")
 const { adminOnly } = require("@budibase/backend-core/auth")
 const Joi = require("joi")
-const { Configs } = require("../../../constants")
+const { Config } = require("../../../constants")
 
 const router = new Router()
 
@@ -65,17 +65,17 @@ function buildConfigSaveValidation() {
     _id: Joi.string().optional(),
     _rev: Joi.string().optional(),
     workspace: Joi.string().optional(),
-    type: Joi.string().valid(...Object.values(Configs)).required(),
+    type: Joi.string().valid(...Object.values(Config)).required(),
     createdAt: Joi.string().optional(),
     updatedAt: Joi.string().optional(),
     config: Joi.alternatives()
       .conditional("type", {
         switch: [
-          { is: Configs.SMTP, then: smtpValidation() },
-          { is: Configs.SETTINGS, then: settingValidation() },
-          { is: Configs.ACCOUNT, then: Joi.object().unknown(true) },
-          { is: Configs.GOOGLE, then: googleValidation() },
-          { is: Configs.OIDC, then: oidcValidation() }
+          { is: Config.SMTP, then: smtpValidation() },
+          { is: Config.SETTINGS, then: settingValidation() },
+          { is: Config.ACCOUNT, then: Joi.object().unknown(true) },
+          { is: Config.GOOGLE, then: googleValidation() },
+          { is: Config.OIDC, then: oidcValidation() }
         ],
       }),
   }).required().unknown(true),
@@ -85,7 +85,7 @@ function buildConfigSaveValidation() {
 function buildUploadValidation() {
   // prettier-ignore
   return joiValidator.params(Joi.object({
-    type: Joi.string().valid(...Object.values(Configs)).required(),
+    type: Joi.string().valid(...Object.values(Config)).required(),
     name: Joi.string().required(),
   }).required().unknown(true))
 }
@@ -93,7 +93,7 @@ function buildUploadValidation() {
 function buildConfigGetValidation() {
   // prettier-ignore
   return joiValidator.params(Joi.object({
-    type: Joi.string().valid(...Object.values(Configs)).required()
+    type: Joi.string().valid(...Object.values(Config)).required()
   }).required().unknown(true))
 }
 

package/src/api/routes/global/templates.ts

@@ -1,6 +1,6 @@
 import Router from "@koa/router"
 import * as controller from "../../controllers/global/templates"
-import { TemplatePurpose, TemplateTypes } from "../../../constants"
+import { TemplatePurpose, TemplateType } from "../../../constants"
 import { auth as authCore } from "@budibase/backend-core"
 import Joi from "joi"
 const { adminOnly, joiValidator } = authCore
@@ -16,7 +16,7 @@ function buildTemplateSaveValidation() {
     name: Joi.string().allow(null, ""),
     contents: Joi.string().required(),
     purpose: Joi.string().required().valid(...Object.values(TemplatePurpose)),
-    type: Joi.string().required().valid(...Object.values(TemplateTypes)),
+    type: Joi.string().required().valid(...Object.values(TemplateType)),
   }).required().unknown(true).optional())
 }
 

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

@@ -2,7 +2,7 @@
 jest.mock("nodemailer")
 import { TestConfiguration, structures, mocks } from "../../../../tests"
 mocks.email.mock()
-import { Configs, events } from "@budibase/backend-core"
+import { Config, events } from "@budibase/backend-core"
 
 describe("configs", () => {
   const config = new TestConfiguration()
@@ -49,20 +49,20 @@ describe("configs", () => {
         it("should create activated google config", async () => {
           await saveGoogleConfig()
           expect(events.auth.SSOCreated).toBeCalledTimes(1)
-          expect(events.auth.SSOCreated).toBeCalledWith(Configs.GOOGLE)
+          expect(events.auth.SSOCreated).toBeCalledWith(Config.GOOGLE)
           expect(events.auth.SSODeactivated).not.toBeCalled()
           expect(events.auth.SSOActivated).toBeCalledTimes(1)
-          expect(events.auth.SSOActivated).toBeCalledWith(Configs.GOOGLE)
-          await config.deleteConfig(Configs.GOOGLE)
+          expect(events.auth.SSOActivated).toBeCalledWith(Config.GOOGLE)
+          await config.deleteConfig(Config.GOOGLE)
         })
 
         it("should create deactivated google config", async () => {
           await saveGoogleConfig({ activated: false })
           expect(events.auth.SSOCreated).toBeCalledTimes(1)
-          expect(events.auth.SSOCreated).toBeCalledWith(Configs.GOOGLE)
+          expect(events.auth.SSOCreated).toBeCalledWith(Config.GOOGLE)
           expect(events.auth.SSOActivated).not.toBeCalled()
           expect(events.auth.SSODeactivated).not.toBeCalled()
-          await config.deleteConfig(Configs.GOOGLE)
+          await config.deleteConfig(Config.GOOGLE)
         })
       })
 
@@ -76,11 +76,11 @@ describe("configs", () => {
             googleConf._rev
           )
           expect(events.auth.SSOUpdated).toBeCalledTimes(1)
-          expect(events.auth.SSOUpdated).toBeCalledWith(Configs.GOOGLE)
+          expect(events.auth.SSOUpdated).toBeCalledWith(Config.GOOGLE)
           expect(events.auth.SSOActivated).not.toBeCalled()
           expect(events.auth.SSODeactivated).toBeCalledTimes(1)
-          expect(events.auth.SSODeactivated).toBeCalledWith(Configs.GOOGLE)
-          await config.deleteConfig(Configs.GOOGLE)
+          expect(events.auth.SSODeactivated).toBeCalledWith(Config.GOOGLE)
+          await config.deleteConfig(Config.GOOGLE)
         })
 
         it("should update google config to activated", async () => {
@@ -92,11 +92,11 @@ describe("configs", () => {
             googleConf._rev
           )
           expect(events.auth.SSOUpdated).toBeCalledTimes(1)
-          expect(events.auth.SSOUpdated).toBeCalledWith(Configs.GOOGLE)
+          expect(events.auth.SSOUpdated).toBeCalledWith(Config.GOOGLE)
           expect(events.auth.SSODeactivated).not.toBeCalled()
           expect(events.auth.SSOActivated).toBeCalledTimes(1)
-          expect(events.auth.SSOActivated).toBeCalledWith(Configs.GOOGLE)
-          await config.deleteConfig(Configs.GOOGLE)
+          expect(events.auth.SSOActivated).toBeCalledWith(Config.GOOGLE)
+          await config.deleteConfig(Config.GOOGLE)
         })
       })
     })
@@ -115,20 +115,20 @@ describe("configs", () => {
         it("should create activated OIDC config", async () => {
           await saveOIDCConfig()
           expect(events.auth.SSOCreated).toBeCalledTimes(1)
-          expect(events.auth.SSOCreated).toBeCalledWith(Configs.OIDC)
+          expect(events.auth.SSOCreated).toBeCalledWith(Config.OIDC)
           expect(events.auth.SSODeactivated).not.toBeCalled()
           expect(events.auth.SSOActivated).toBeCalledTimes(1)
-          expect(events.auth.SSOActivated).toBeCalledWith(Configs.OIDC)
-          await config.deleteConfig(Configs.OIDC)
+          expect(events.auth.SSOActivated).toBeCalledWith(Config.OIDC)
+          await config.deleteConfig(Config.OIDC)
         })
 
         it("should create deactivated OIDC config", async () => {
           await saveOIDCConfig({ activated: false })
           expect(events.auth.SSOCreated).toBeCalledTimes(1)
-          expect(events.auth.SSOCreated).toBeCalledWith(Configs.OIDC)
+          expect(events.auth.SSOCreated).toBeCalledWith(Config.OIDC)
           expect(events.auth.SSOActivated).not.toBeCalled()
           expect(events.auth.SSODeactivated).not.toBeCalled()
-          await config.deleteConfig(Configs.OIDC)
+          await config.deleteConfig(Config.OIDC)
         })
       })
 
@@ -142,11 +142,11 @@ describe("configs", () => {
             oidcConf._rev
           )
           expect(events.auth.SSOUpdated).toBeCalledTimes(1)
-          expect(events.auth.SSOUpdated).toBeCalledWith(Configs.OIDC)
+          expect(events.auth.SSOUpdated).toBeCalledWith(Config.OIDC)
           expect(events.auth.SSOActivated).not.toBeCalled()
           expect(events.auth.SSODeactivated).toBeCalledTimes(1)
-          expect(events.auth.SSODeactivated).toBeCalledWith(Configs.OIDC)
-          await config.deleteConfig(Configs.OIDC)
+          expect(events.auth.SSODeactivated).toBeCalledWith(Config.OIDC)
+          await config.deleteConfig(Config.OIDC)
         })
 
         it("should update OIDC config to activated", async () => {
@@ -158,11 +158,11 @@ describe("configs", () => {
             oidcConf._rev
           )
           expect(events.auth.SSOUpdated).toBeCalledTimes(1)
-          expect(events.auth.SSOUpdated).toBeCalledWith(Configs.OIDC)
+          expect(events.auth.SSOUpdated).toBeCalledWith(Config.OIDC)
           expect(events.auth.SSODeactivated).not.toBeCalled()
           expect(events.auth.SSOActivated).toBeCalledTimes(1)
-          expect(events.auth.SSOActivated).toBeCalledWith(Configs.OIDC)
-          await config.deleteConfig(Configs.OIDC)
+          expect(events.auth.SSOActivated).toBeCalledWith(Config.OIDC)
+          await config.deleteConfig(Config.OIDC)
         })
       })
     })
@@ -179,11 +179,11 @@ describe("configs", () => {
 
       describe("create", () => {
         it("should create SMTP config", async () => {
-          await config.deleteConfig(Configs.SMTP)
+          await config.deleteConfig(Config.SMTP)
           await saveSMTPConfig()
           expect(events.email.SMTPUpdated).not.toBeCalled()
           expect(events.email.SMTPCreated).toBeCalledTimes(1)
-          await config.deleteConfig(Configs.SMTP)
+          await config.deleteConfig(Config.SMTP)
         })
       })
 
@@ -194,7 +194,7 @@ describe("configs", () => {
           await saveSMTPConfig(smtpConf.config, smtpConf._id, smtpConf._rev)
           expect(events.email.SMTPCreated).not.toBeCalled()
           expect(events.email.SMTPUpdated).toBeCalledTimes(1)
-          await config.deleteConfig(Configs.SMTP)
+          await config.deleteConfig(Config.SMTP)
         })
       })
     })
@@ -211,7 +211,7 @@ describe("configs", () => {
 
       describe("create", () => {
         it("should create settings config with default settings", async () => {
-          await config.deleteConfig(Configs.SETTINGS)
+          await config.deleteConfig(Config.SETTINGS)
 
           await saveSettingsConfig()
 
@@ -222,7 +222,7 @@ describe("configs", () => {
 
         it("should create settings config with non-default settings", async () => {
           config.modeSelf()
-          await config.deleteConfig(Configs.SETTINGS)
+          await config.deleteConfig(Config.SETTINGS)
           const conf = {
             company: "acme",
             logoUrl: "http://example.com",
@@ -241,7 +241,7 @@ describe("configs", () => {
       describe("update", () => {
         it("should update settings config", async () => {
           config.modeSelf()
-          await config.deleteConfig(Configs.SETTINGS)
+          await config.deleteConfig(Config.SETTINGS)
           const settingsConfig = await saveSettingsConfig()
           settingsConfig.config.company = "acme"
           settingsConfig.config.logoUrl = "http://example.com"