@budibase/worker 3.24.1 → 3.24.3

package/__mocks__/@budibase/pro.ts

@@ -4,6 +4,7 @@ const pro = {
   features: {
     ...actual.features,
     isSSOEnforced: jest.fn(),
+    isTranslationsEnabled: jest.fn(() => Promise.resolve(true)),
   },
   licensing: {
     keys: {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@budibase/worker",
   "email": "hi@budibase.com",
-  "version": "3.24.1",
+  "version": "3.24.3",
   "description": "Budibase background service",
   "main": "src/index.ts",
   "repository": {
@@ -70,7 +70,7 @@
     "server-destroy": "1.0.1",
     "undici": "^7.16.0",
     "uuid": "^8.3.2",
-    "yaml": "^2.8.0"
+    "yaml": "^2.8.2"
   },
   "devDependencies": {
     "@types/jsonwebtoken": "9.0.3",
@@ -109,5 +109,5 @@
       }
     }
   },
-  "gitHead": "6838c955ce1adef31581d699de2c9a6c81d37de5"
+  "gitHead": "a85e0ba10b7d19e204062fb63dc306953284e277"
 }

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

@@ -10,7 +10,10 @@ import {
   tenancy,
 } from "@budibase/backend-core"
 import * as pro from "@budibase/pro"
-import { BUILDER_URLS } from "@budibase/shared-core"
+import {
+  BUILDER_URLS,
+  filterValidTranslationOverrides,
+} from "@budibase/shared-core"
 import {
   AIInnerConfig,
   Config,
@@ -21,13 +24,16 @@ import {
   FindConfigResponse,
   GetPublicOIDCConfigResponse,
   GetPublicSettingsResponse,
+  GetPublicTranslationsResponse,
   GoogleInnerConfig,
+  TranslationOverrides,
   isAIConfig,
   isGoogleConfig,
   isOIDCConfig,
   isRecaptchaConfig,
   isSettingsConfig,
   isSMTPConfig,
+  isTranslationsConfig,
   OIDCConfigs,
   OIDCLogosConfig,
   PASSWORD_REPLACEMENT,
@@ -39,9 +45,12 @@ import {
   SMTPInnerConfig,
   SSOConfig,
   SSOConfigType,
+  TranslationsConfigInner,
   UploadConfigFileResponse,
   UserCtx,
 } from "@budibase/types"
+
+const PUBLIC_TRANSLATION_PREFIXES = ["login.", "forgotPassword."]
 import env from "../../../environment"
 import * as email from "../../../utilities/email"
 import { checkAnyUserExists } from "../../../utilities/users"
@@ -299,6 +308,77 @@ export async function processRecaptchaConfig(
   }
 }
 
+function prepareTranslationsConfig(
+  ctx: UserCtx,
+  config?: TranslationsConfigInner
+): TranslationsConfigInner {
+  const defaultLocale = config?.defaultLocale || "en"
+  const locales: TranslationsConfigInner["locales"] = {}
+  const now = new Date().toISOString()
+  const updatedBy = ctx.user?._id
+
+  Object.entries(config?.locales || {}).forEach(([locale, localeConfig]) => {
+    locales[locale] = {
+      label: localeConfig?.label,
+      overrides: filterValidTranslationOverrides(localeConfig?.overrides),
+      updatedAt: localeConfig?.updatedAt || now,
+      updatedBy: localeConfig?.updatedBy || updatedBy,
+    }
+  })
+
+  if (!locales[defaultLocale]) {
+    locales[defaultLocale] = {
+      label: defaultLocale === "en" ? "English" : defaultLocale,
+      overrides: {},
+      updatedAt: now,
+      updatedBy,
+    }
+  }
+
+  return {
+    defaultLocale,
+    locales,
+  }
+}
+
+function filterPublicTranslations(
+  config: TranslationsConfigInner
+): TranslationsConfigInner {
+  const locales: TranslationsConfigInner["locales"] = {}
+  for (const [locale, localeConfig] of Object.entries(config.locales || {})) {
+    const overrides = Object.entries(localeConfig?.overrides || {}).reduce(
+      (acc, [key, value]) => {
+        if (
+          PUBLIC_TRANSLATION_PREFIXES.some(prefix => key.startsWith(prefix))
+        ) {
+          acc[key] = value
+        }
+        return acc
+      },
+      {} as TranslationOverrides
+    )
+    locales[locale] = {
+      ...localeConfig,
+      overrides,
+    }
+  }
+  return {
+    defaultLocale: config.defaultLocale,
+    locales,
+  }
+}
+
+async function processTranslationsConfig(
+  ctx: UserCtx,
+  config: TranslationsConfigInner
+) {
+  const enabled = await pro.features.isTranslationsEnabled()
+  if (!enabled) {
+    throw new ForbiddenError("License does not allow translations")
+  }
+  ctx.request.body.config = prepareTranslationsConfig(ctx, config)
+}
+
 export async function save(
   ctx: UserCtx<SaveConfigRequest, SaveConfigResponse>
 ) {
@@ -335,6 +415,9 @@ export async function save(
       case ConfigType.RECAPTCHA:
         await processRecaptchaConfig(config, existingConfig?.config)
         break
+      case ConfigType.TRANSLATIONS:
+        await processTranslationsConfig(ctx, config)
+        break
     }
   } catch (err: any) {
     ctx.throw(400, err)
@@ -436,11 +519,11 @@ export async function find(ctx: UserCtx<void, FindConfigResponse>) {
       break
   }
 
-  stripSecrets(config)
+  stripSecrets(config, ctx)
   ctx.body = config
 }
 
-function stripSecrets(config: Config) {
+function stripSecrets(config: Config, ctx?: UserCtx) {
   if (isAIConfig(config)) {
     for (const key in config.config) {
       if (config.config[key].apiKey) {
@@ -459,6 +542,11 @@ function stripSecrets(config: Config) {
     }
   } else if (isRecaptchaConfig(config)) {
     config.config.secretKey = PASSWORD_REPLACEMENT
+  } else if (isTranslationsConfig(config)) {
+    config.config = prepareTranslationsConfig(
+      ctx || ({} as UserCtx),
+      config.config
+    )
   }
 }
 
@@ -582,6 +670,17 @@ export async function publicSettings(
   }
 }
 
+export async function publicTranslations(
+  ctx: Ctx<void, GetPublicTranslationsResponse>
+) {
+  try {
+    const configDoc = await configs.getTranslationsConfigDoc()
+    ctx.body = filterPublicTranslations(configDoc.config)
+  } catch (err: any) {
+    ctx.throw(err.status, err)
+  }
+}
+
 export async function upload(ctx: UserCtx<void, UploadConfigFileResponse>) {
   if (ctx.request.files == null || Array.isArray(ctx.request.files.file)) {
     ctx.throw(400, "One file must be uploaded.")

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

@@ -87,6 +87,25 @@ function recaptchaValidation() {
   }).required()
 }
 
+function translationsValidation() {
+  return Joi.object({
+    defaultLocale: Joi.string().required(),
+    locales: Joi.object()
+      .pattern(
+        Joi.string(),
+        Joi.object({
+          label: Joi.string().optional().allow("", null),
+          overrides: Joi.object()
+            .pattern(Joi.string(), Joi.string().allow(""))
+            .default({}),
+          updatedAt: Joi.string().optional(),
+          updatedBy: Joi.string().optional(),
+        }).required()
+      )
+      .required(),
+  })
+}
+
 function buildConfigSaveValidation() {
   // prettier-ignore
   return auth.joiValidator.body(Joi.object({
@@ -107,6 +126,7 @@ function buildConfigSaveValidation() {
           { is: ConfigType.SCIM, then: scimValidation() },
           { is: ConfigType.AI, then: aiValidation() },
           { is: ConfigType.RECAPTCHA, then: recaptchaValidation() },
+          { is: ConfigType.TRANSLATIONS, then: translationsValidation() },
         ],
       }),
   }).required().unknown(true),
@@ -141,4 +161,5 @@ loggedInRoutes
   .get("/api/global/configs/checklist", controller.configChecklist)
   .get("/api/global/configs/public", controller.publicSettings)
   .get("/api/global/configs/public/oidc", controller.publicOidc)
+  .get("/api/global/configs/public/translations", controller.publicTranslations)
   .get("/api/global/configs/:type", buildConfigGetValidation(), controller.find)

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

@@ -5,12 +5,15 @@ import {
   ConfigType,
   GetPublicSettingsResponse,
   PKCEMethod,
+  TranslationsConfig,
 } from "@budibase/types"
 import { TestConfiguration, mocks, structures } from "../../../../tests"
+import { resolveTranslationGroup } from "@budibase/shared-core"
+import { processStringSync } from "@budibase/string-templates"
 
 mocks.email.mock()
 
-const { google, smtp, settings, oidc } = structures.configs
+const { google, smtp, settings, oidc, translations } = structures.configs
 
 describe("configs", () => {
   const config = new TestConfiguration()
@@ -321,6 +324,84 @@ describe("configs", () => {
     })
   })
 
+  describe("translations", () => {
+    beforeEach(async () => {
+      await config.deleteConfig(ConfigType.TRANSLATIONS)
+      mocks.licenses.useTranslations()
+      mocks.pro.features.isTranslationsEnabled.mockResolvedValue(true)
+    })
+
+    afterEach(async () => {
+      await config.deleteConfig(ConfigType.TRANSLATIONS)
+      mocks.pro.features.isTranslationsEnabled.mockReset()
+    })
+
+    it("should save translations when feature enabled", async () => {
+      await saveConfig(translations({ "login.emailLabel": "Profile test" }))
+      const saved = await config.api.configs.getConfig(ConfigType.TRANSLATIONS)
+      expect(saved.config.locales.en.overrides["login.emailLabel"]).toEqual(
+        "Profile test"
+      )
+    })
+
+    it("should support non-default locales", async () => {
+      const spanishConfig: TranslationsConfig = {
+        type: ConfigType.TRANSLATIONS,
+        config: {
+          defaultLocale: "es",
+          locales: {
+            es: {
+              label: "Spanish",
+              overrides: {
+                "login.emailLabel": "Correo",
+              },
+            },
+            en: {
+              label: "English",
+              overrides: {
+                "login.emailLabel": "Email",
+              },
+            },
+          },
+        },
+      }
+
+      await saveConfig(spanishConfig)
+      const saved = await config.api.configs.getConfig(ConfigType.TRANSLATIONS)
+      expect(saved.config.locales.es.overrides["login.emailLabel"]).toEqual(
+        "Correo"
+      )
+    })
+
+    it("should filter invalid override keys", async () => {
+      await saveConfig(translations({ invalid: "value" }))
+      const saved = await config.api.configs.getConfig(ConfigType.TRANSLATIONS)
+      expect(saved.config.locales.en.overrides).toEqual({})
+    })
+
+    it("should reject when translations feature disabled", async () => {
+      mocks.pro.features.isTranslationsEnabled.mockResolvedValue(false)
+      await expect(
+        saveConfig(translations({ "login.emailLabel": "Profile test" }))
+      ).rejects.toThrow("License does not allow translations")
+    })
+
+    it("should resolve bindings inside translation overrides", async () => {
+      await saveConfig(
+        translations({ "portal.greeting": "Welcome {{ name }}" })
+      )
+      const saved = await config.api.configs.getConfig(ConfigType.TRANSLATIONS)
+      const portalLabels = resolveTranslationGroup(
+        "portal",
+        saved.config.locales.en.overrides
+      )
+      const boundValue = processStringSync(portalLabels.greeting, {
+        name: "Budibuddy",
+      })
+      expect(boundValue).toEqual("Welcome Budibuddy")
+    })
+  })
+
   describe("GET /api/global/configs/checklist", () => {
     it("should return the correct checklist", async () => {
       await config.saveSmtpConfig()
@@ -372,4 +453,44 @@ describe("configs", () => {
       expect(body).toEqual(expected)
     })
   })
+
+  describe("GET /api/global/configs/public/translations", () => {
+    beforeEach(async () => {
+      await config.deleteConfig(ConfigType.TRANSLATIONS)
+      mocks.licenses.useTranslations()
+      mocks.pro.features.isTranslationsEnabled.mockResolvedValue(true)
+    })
+
+    afterEach(async () => {
+      await config.deleteConfig(ConfigType.TRANSLATIONS)
+      mocks.pro.features.isTranslationsEnabled.mockReset()
+    })
+
+    it("should return translation overrides", async () => {
+      await saveConfig(translations({ "login.emailLabel": "Hello" }))
+      const res = await config.api.configs.getPublicTranslations()
+      expect(res.body.defaultLocale).toEqual("en")
+      expect(res.body.locales.en.overrides["login.emailLabel"]).toEqual("Hello")
+    })
+
+    it("should expose login and forgot labels without authentication", async () => {
+      await saveConfig(
+        translations({
+          "login.emailLabel": "Public email",
+          "forgotPassword.heading": "Reset password",
+        })
+      )
+      const res = await config
+        .getRequest()
+        .get(
+          `/api/global/configs/public/translations?tenantId=${config.getTenantId()}`
+        )
+        .expect(200)
+        .expect("Content-Type", /json/)
+
+      const overrides = res.body.locales.en.overrides
+      expect(overrides["login.emailLabel"]).toEqual("Public email")
+      expect(overrides["forgotPassword.heading"]).toEqual("Reset password")
+    })
+  })
 })

package/src/tests/api/configs.ts

@@ -23,6 +23,15 @@ export class ConfigAPI extends TestAPI {
       .expect("Content-Type", /json/)
   }
 
+  getPublicTranslations = (tenantId?: string) => {
+    const query = tenantId ? `?tenantId=${tenantId}` : ""
+    return this.request
+      .get(`/api/global/configs/public/translations${query}`)
+      .set(this.config.defaultHeaders())
+      .expect(200)
+      .expect("Content-Type", /json/)
+  }
+
   getAIConfig = async () => {
     return await this.getConfig(ConfigType.AI)
   }

package/src/tests/structures/configs.ts

@@ -9,6 +9,7 @@ import {
   OIDCInnerConfig,
   SMTPInnerConfig,
   SettingsInnerConfig,
+  TranslationsConfig,
 } from "@budibase/types"
 
 export function oidc(conf?: Partial<OIDCInnerConfig>): OIDCConfig {
@@ -86,3 +87,20 @@ export function settings(conf?: Partial<SettingsInnerConfig>): SettingsConfig {
     },
   }
 }
+
+export function translations(
+  overrides: Record<string, string> = {}
+): TranslationsConfig {
+  return {
+    type: ConfigType.TRANSLATIONS,
+    config: {
+      defaultLocale: "en",
+      locales: {
+        en: {
+          label: "English",
+          overrides,
+        },
+      },
+    },
+  }
+}