@budibase/worker 2.31.8 → 2.32.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@budibase/worker",
   "email": "hi@budibase.com",
-  "version": "2.31.8",
+  "version": "2.32.1",
   "description": "Budibase background service",
   "main": "src/index.ts",
   "repository": {
@@ -37,10 +37,10 @@
   "author": "Budibase",
   "license": "GPL-3.0",
   "dependencies": {
-    "@budibase/backend-core": "2.31.8",
-    "@budibase/pro": "2.31.8",
-    "@budibase/string-templates": "2.31.8",
-    "@budibase/types": "2.31.8",
+    "@budibase/backend-core": "2.32.1",
+    "@budibase/pro": "2.32.1",
+    "@budibase/string-templates": "2.32.1",
+    "@budibase/types": "2.32.1",
     "@koa/router": "8.0.8",
     "@techpass/passport-openidconnect": "0.3.3",
     "@types/global-agent": "2.1.1",
@@ -107,5 +107,5 @@
       }
     }
   },
-  "gitHead": "773a06abcdbf7b7bed843f909afc5ca2b11e7ce2"
+  "gitHead": "1f7af4b4e8be41c46f2c1e00cf6c0a14dc6bced5"
 }

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

@@ -29,6 +29,10 @@ import {
   SSOConfigType,
   UserCtx,
   OIDCLogosConfig,
+  AIConfig,
+  PASSWORD_REPLACEMENT,
+  isAIConfig,
+  AIInnerConfig,
 } from "@budibase/types"
 import * as pro from "@budibase/pro"
 
@@ -38,6 +42,11 @@ const getEventFns = async (config: Config, existing?: Config) => {
   if (!existing) {
     if (isSMTPConfig(config)) {
       fns.push(events.email.SMTPCreated)
+    } else if (isAIConfig(config)) {
+      fns.push(() => events.ai.AIConfigCreated)
+      fns.push(() =>
+        pro.quotas.updateCustomAIConfigCount(Object.keys(config.config).length)
+      )
     } else if (isGoogleConfig(config)) {
       fns.push(() => events.auth.SSOCreated(ConfigType.GOOGLE))
       if (config.config.activated) {
@@ -74,6 +83,11 @@ const getEventFns = async (config: Config, existing?: Config) => {
   } else {
     if (isSMTPConfig(config)) {
       fns.push(events.email.SMTPUpdated)
+    } else if (isAIConfig(config)) {
+      fns.push(() => events.ai.AIConfigUpdated)
+      fns.push(() =>
+        pro.quotas.updateCustomAIConfigCount(Object.keys(config.config).length)
+      )
     } else if (isGoogleConfig(config)) {
       fns.push(() => events.auth.SSOUpdated(ConfigType.GOOGLE))
       if (!existing.config.activated && config.config.activated) {
@@ -122,7 +136,6 @@ const getEventFns = async (config: Config, existing?: Config) => {
       }
     }
   }
-
   return fns
 }
 
@@ -197,6 +210,18 @@ async function verifyOIDCConfig(config: OIDCConfigs) {
   await verifySSOConfig(ConfigType.OIDC, config.configs[0])
 }
 
+export async function verifyAIConfig(
+  configToSave: AIInnerConfig,
+  existingConfig: AIConfig
+) {
+  // ensure that the redacted API keys are not overwritten in the DB
+  for (const uuid in existingConfig.config) {
+    if (configToSave[uuid]?.apiKey === PASSWORD_REPLACEMENT) {
+      configToSave[uuid].apiKey = existingConfig.config[uuid].apiKey
+    }
+  }
+}
+
 export async function save(ctx: UserCtx<Config>) {
   const body = ctx.request.body
   const type = body.type
@@ -224,6 +249,11 @@ export async function save(ctx: UserCtx<Config>) {
       case ConfigType.OIDC:
         await verifyOIDCConfig(config)
         break
+      case ConfigType.AI:
+        if (existingConfig) {
+          await verifyAIConfig(config, existingConfig)
+        }
+        break
     }
   } catch (err: any) {
     ctx.throw(400, err)
@@ -304,6 +334,32 @@ function enrichOIDCLogos(oidcLogos: OIDCLogosConfig) {
   )
 }
 
+async function enrichAIConfig(aiConfig: AIConfig) {
+  // Strip out the API Keys from the response so they don't show in the UI
+  for (const key in aiConfig.config) {
+    if (aiConfig.config[key].apiKey) {
+      aiConfig.config[key].apiKey = PASSWORD_REPLACEMENT
+    }
+  }
+
+  // Return the Budibase AI data source as part of the response if licensing allows
+  const budibaseAIEnabled = await pro.features.isBudibaseAIEnabled()
+  const defaultConfigExists = Object.keys(aiConfig.config).some(
+    key => aiConfig.config[key].isDefault
+  )
+  if (budibaseAIEnabled) {
+    aiConfig.config["budibase_ai"] = {
+      provider: "OpenAI",
+      active: true,
+      isDefault: !defaultConfigExists,
+      defaultModel: env.BUDIBASE_AI_DEFAULT_MODEL || "",
+      name: "Budibase AI",
+    }
+  }
+
+  return aiConfig
+}
+
 export async function find(ctx: UserCtx) {
   try {
     // Find the config with the most granular scope based on context
@@ -314,6 +370,10 @@ export async function find(ctx: UserCtx) {
       if (type === ConfigType.OIDC_LOGOS) {
         enrichOIDCLogos(scopedConfig)
       }
+
+      if (type === ConfigType.AI) {
+        await enrichAIConfig(scopedConfig)
+      }
       ctx.body = scopedConfig
     } else {
       // don't throw an error, there simply is nothing to return

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

@@ -0,0 +1,106 @@
+import * as pro from "@budibase/pro"
+import { verifyAIConfig } from "../configs"
+import { TestConfiguration, structures } from "../../../../tests"
+import { AIInnerConfig } from "@budibase/types"
+
+describe("Global configs controller", () => {
+  const config = new TestConfiguration()
+
+  beforeAll(async () => {
+    await config.beforeAll()
+  })
+
+  afterAll(async () => {
+    await config.afterAll()
+  })
+
+  afterEach(() => {
+    jest.resetAllMocks()
+  })
+
+  it("Should strip secrets when pulling AI config", async () => {
+    const data = structures.configs.ai()
+    await config.api.configs.saveConfig(data)
+    const response = await config.api.configs.getAIConfig()
+    expect(response.body.config).toEqual({
+      ai: {
+        active: true,
+        apiKey: "--secret-value--",
+        baseUrl: "https://api.example.com",
+        defaultModel: "gpt4",
+        isDefault: false,
+        name: "Test",
+        provider: "OpenAI",
+      },
+    })
+  })
+
+  it("Should return the default BB AI config when the feature is turned on", async () => {
+    jest
+      .spyOn(pro.features, "isBudibaseAIEnabled")
+      .mockImplementation(() => Promise.resolve(true))
+    const data = structures.configs.ai()
+    await config.api.configs.saveConfig(data)
+    const response = await config.api.configs.getAIConfig()
+
+    expect(response.body.config).toEqual({
+      budibase_ai: {
+        provider: "OpenAI",
+        active: true,
+        isDefault: true,
+        name: "Budibase AI",
+        defaultModel: "",
+      },
+      ai: {
+        active: true,
+        apiKey: "--secret-value--",
+        baseUrl: "https://api.example.com",
+        defaultModel: "gpt4",
+        isDefault: false,
+        name: "Test",
+        provider: "OpenAI",
+      },
+    })
+  })
+
+  it("Should not not return the default Budibase AI config when on self host", async () => {
+    jest
+      .spyOn(pro.features, "isBudibaseAIEnabled")
+      .mockImplementation(() => Promise.resolve(false))
+    const data = structures.configs.ai()
+    await config.api.configs.saveConfig(data)
+    const response = await config.api.configs.getAIConfig()
+
+    expect(response.body.config).toEqual({
+      ai: {
+        active: true,
+        apiKey: "--secret-value--",
+        baseUrl: "https://api.example.com",
+        defaultModel: "gpt4",
+        isDefault: false,
+        name: "Test",
+        provider: "OpenAI",
+      },
+    })
+  })
+
+  it("Should not update existing secrets when updating an existing AI Config", async () => {
+    const data = structures.configs.ai()
+    await config.api.configs.saveConfig(data)
+
+    const newConfig: AIInnerConfig = {
+      ai: {
+        provider: "OpenAI",
+        isDefault: true,
+        apiKey: "--secret-value--",
+        name: "MyConfig",
+        active: true,
+        defaultModel: "gpt4",
+      },
+    }
+
+    await verifyAIConfig(newConfig, data)
+    // should be unchanged
+    expect(newConfig.ai.apiKey).toEqual("myapikey")
+  })
+})

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

@@ -65,6 +65,22 @@ function scimValidation() {
   }).unknown(true)
 }
 
+function aiValidation() {
+  // prettier-ignore
+  return Joi.object().pattern(
+     Joi.string(),
+     Joi.object({
+       provider: Joi.string().required(),
+       isDefault: Joi.boolean().required(),
+       name: Joi.string().required(),
+       active: Joi.boolean().required(),
+       baseUrl: Joi.string().optional().allow("", null),
+       apiKey: Joi.string().required(),
+       defaultModel: Joi.string().optional(),
+     }).required()
+  )
+}
+
 function buildConfigSaveValidation() {
   // prettier-ignore
   return auth.joiValidator.body(Joi.object({
@@ -82,7 +98,8 @@ function buildConfigSaveValidation() {
           { is: ConfigType.ACCOUNT, then: Joi.object().unknown(true) },
           { is: ConfigType.GOOGLE, then: googleValidation() },
           { is: ConfigType.OIDC, then: oidcValidation() },
-          { is: ConfigType.SCIM, then: scimValidation() }
+          { is: ConfigType.SCIM, then: scimValidation() },
+          { is: ConfigType.AI, then: aiValidation() }
         ],
       }),
   }).required().unknown(true),

package/src/environment.ts

@@ -70,6 +70,9 @@ const environment = {
   PASSPORT_OIDCAUTH_FAILURE_REDIRECT:
     process.env.PASSPORT_OIDCAUTH_FAILURE_REDIRECT || "/error",
 
+  // Budibase AI
+  BUDIBASE_AI_API_KEY: process.env.BUDIBASE_AI_API_KEY,
+  BUDIBASE_AI_DEFAULT_MODEL: process.env.BUDIBASE_AI_DEFAULT_MODEL,
   _set(key: any, value: any) {
     process.env[key] = value
     // @ts-ignore

package/src/sdk/auth/auth.ts

@@ -19,12 +19,17 @@ import { EmailTemplatePurpose } from "../../constants"
 export async function loginUser(user: User) {
   const sessionId = coreUtils.newid()
   const tenantId = tenancy.getTenantId()
-  await sessions.createASession(user._id!, { sessionId, tenantId })
+  await sessions.createASession(user._id!, {
+    sessionId,
+    tenantId,
+    email: user.email,
+  })
   return jwt.sign(
     {
       userId: user._id,
       sessionId,
       tenantId,
+      email: user.email,
     },
     coreEnv.JWT_SECRET!
   )

package/src/tests/TestConfiguration.ts

@@ -170,19 +170,26 @@ class TestConfiguration {
   async _createSession({
     userId,
     tenantId,
+    email,
   }: {
     userId: string
     tenantId: string
+    email: string
   }) {
     await sessions.createASession(userId!, {
       sessionId: "sessionid",
-      tenantId: tenantId,
+      tenantId,
       csrfToken: CSRF_TOKEN,
+      email,
     })
   }
 
   async createSession(user: User) {
-    return this._createSession({ userId: user._id!, tenantId: user.tenantId })
+    return this._createSession({
+      userId: user._id!,
+      tenantId: user.tenantId,
+      email: user.email,
+    })
   }
 
   cookieHeader(cookies: any) {

package/src/tests/api/configs.ts

@@ -22,6 +22,14 @@ export class ConfigAPI extends TestAPI {
       .expect("Content-Type", /json/)
   }
 
+  getAIConfig = () => {
+    return this.request
+      .get(`/api/global/configs/ai`)
+      .set(this.config.defaultHeaders())
+      .expect(200)
+      .expect("Content-Type", /json/)
+  }
+
   saveConfig = (data: any) => {
     return this.request
       .post(`/api/global/configs`)

package/src/tests/structures/configs.ts

@@ -5,6 +5,7 @@ import {
   SMTPConfig,
   GoogleConfig,
   OIDCConfig,
+  AIConfig,
 } from "@budibase/types"
 
 export function oidc(conf?: any): OIDCConfig {
@@ -81,3 +82,20 @@ export function settings(conf?: any): SettingsConfig {
     },
   }
 }
+
+export function ai(): AIConfig {
+  return {
+    type: ConfigType.AI,
+    config: {
+      ai: {
+        provider: "OpenAI",
+        isDefault: false,
+        name: "Test",
+        active: true,
+        defaultModel: "gpt4",
+        apiKey: "myapikey",
+        baseUrl: "https://api.example.com",
+      },
+    },
+  }
+}