@budibase/backend-core 3.2.5 → 3.2.7

package/src/configs/configs.ts

@@ -1,263 +0,0 @@
-import {
-  AIConfig,
-  Config,
-  ConfigType,
-  GoogleConfig,
-  GoogleInnerConfig,
-  OIDCConfig,
-  OIDCInnerConfig,
-  OIDCLogosConfig,
-  SCIMConfig,
-  SCIMInnerConfig,
-  SettingsConfig,
-  SettingsInnerConfig,
-  SMTPConfig,
-  SMTPInnerConfig,
-} from "@budibase/types"
-import { DocumentType, SEPARATOR } from "../constants"
-import { CacheKey, TTL, withCache } from "../cache"
-import * as context from "../context"
-import env from "../environment"
-
-// UTILS
-
-/**
- * Generates a new configuration ID.
- * @returns The new configuration ID which the config doc can be stored under.
- */
-export function generateConfigID(type: ConfigType) {
-  return `${DocumentType.CONFIG}${SEPARATOR}${type}`
-}
-
-export async function getConfig<T extends Config>(
-  type: ConfigType
-): Promise<T | undefined> {
-  const db = context.getGlobalDB()
-  try {
-    // await to catch error
-    return (await db.get(generateConfigID(type))) as T
-  } catch (e: any) {
-    if (e.status === 404) {
-      return
-    }
-    throw e
-  }
-}
-
-export async function save(
-  config: Config
-): Promise<{ id: string; rev: string }> {
-  const db = context.getGlobalDB()
-  return db.put(config)
-}
-
-// SETTINGS
-
-export async function getSettingsConfigDoc(): Promise<SettingsConfig> {
-  let config = await getConfig<SettingsConfig>(ConfigType.SETTINGS)
-
-  if (!config) {
-    config = {
-      _id: generateConfigID(ConfigType.SETTINGS),
-      type: ConfigType.SETTINGS,
-      config: {},
-    }
-  }
-
-  // overridden fields
-  config.config.platformUrl = await getPlatformUrl({
-    tenantAware: true,
-    config: config.config,
-  })
-  config.config.analyticsEnabled = await analyticsEnabled({
-    config: config.config,
-  })
-
-  return config
-}
-
-export async function getSettingsConfig(): Promise<SettingsInnerConfig> {
-  return (await getSettingsConfigDoc()).config
-}
-
-export async function getPlatformUrl(
-  opts: { tenantAware: boolean; config?: SettingsInnerConfig } = {
-    tenantAware: true,
-  }
-) {
-  let platformUrl = env.PLATFORM_URL || "http://localhost:10000"
-
-  if (!env.SELF_HOSTED && env.MULTI_TENANCY && opts.tenantAware) {
-    // cloud and multi tenant - add the tenant to the default platform url
-    const tenantId = context.getTenantId()
-    if (!platformUrl.includes("localhost:")) {
-      platformUrl = platformUrl.replace("://", `://${tenantId}.`)
-    }
-  } else if (env.SELF_HOSTED) {
-    const config = opts?.config
-      ? opts.config
-      : // direct to db to prevent infinite loop
-        (await getConfig<SettingsConfig>(ConfigType.SETTINGS))?.config
-    if (config?.platformUrl) {
-      platformUrl = config.platformUrl
-    }
-  }
-
-  return platformUrl
-}
-
-export const analyticsEnabled = async (opts?: {
-  config?: SettingsInnerConfig
-}) => {
-  // cloud - always use the environment variable
-  if (!env.SELF_HOSTED) {
-    return !!env.ENABLE_ANALYTICS
-  }
-
-  // self host - prefer the settings doc
-  // use cache as events have high throughput
-  const enabledInDB = await withCache(
-    CacheKey.ANALYTICS_ENABLED,
-    TTL.ONE_DAY,
-    async () => {
-      const config = opts?.config
-        ? opts.config
-        : // direct to db to prevent infinite loop
-          (await getConfig<SettingsConfig>(ConfigType.SETTINGS))?.config
-
-      // need to do explicit checks in case the field is not set
-      if (config?.analyticsEnabled === false) {
-        return false
-      } else if (config?.analyticsEnabled === true) {
-        return true
-      }
-    }
-  )
-
-  if (enabledInDB !== undefined) {
-    return enabledInDB
-  }
-
-  // fallback to the environment variable
-  // explicitly check for 0 or false here, undefined or otherwise is treated as true
-  const envEnabled: any = env.ENABLE_ANALYTICS
-  if (envEnabled === 0 || envEnabled === false) {
-    return false
-  } else {
-    return true
-  }
-}
-
-// GOOGLE
-
-async function getGoogleConfigDoc(): Promise<GoogleConfig | undefined> {
-  return await getConfig<GoogleConfig>(ConfigType.GOOGLE)
-}
-
-export async function getGoogleConfig(): Promise<
-  GoogleInnerConfig | undefined
-> {
-  const config = await getGoogleConfigDoc()
-  return config?.config
-}
-
-export async function getGoogleDatasourceConfig(): Promise<
-  GoogleInnerConfig | undefined
-> {
-  if (!env.SELF_HOSTED) {
-    // always use the env vars in cloud
-    return getDefaultGoogleConfig()
-  }
-
-  // prefer the config in self-host
-  let config = await getGoogleConfig()
-
-  // fallback to env vars
-  if (!config || !config.activated) {
-    config = getDefaultGoogleConfig()
-  }
-
-  return config
-}
-
-export function getDefaultGoogleConfig(): GoogleInnerConfig | undefined {
-  if (env.GOOGLE_CLIENT_ID && env.GOOGLE_CLIENT_SECRET) {
-    return {
-      clientID: env.GOOGLE_CLIENT_ID!,
-      clientSecret: env.GOOGLE_CLIENT_SECRET!,
-      activated: true,
-    }
-  }
-}
-
-// OIDC
-
-export async function getOIDCLogosDoc(): Promise<OIDCLogosConfig | undefined> {
-  return getConfig<OIDCLogosConfig>(ConfigType.OIDC_LOGOS)
-}
-
-async function getOIDCConfigDoc(): Promise<OIDCConfig | undefined> {
-  return getConfig<OIDCConfig>(ConfigType.OIDC)
-}
-
-export async function getOIDCConfig(): Promise<OIDCInnerConfig | undefined> {
-  const config = (await getOIDCConfigDoc())?.config
-  // default to the 0th config
-  return config?.configs && config.configs[0]
-}
-
-/**
- * @param configId The config id of the inner config to retrieve
- */
-export async function getOIDCConfigById(
-  configId: string
-): Promise<OIDCInnerConfig | undefined> {
-  const config = (await getConfig<OIDCConfig>(ConfigType.OIDC))?.config
-  return config && config.configs.filter((c: any) => c.uuid === configId)[0]
-}
-
-// SMTP
-
-export async function getSMTPConfigDoc(): Promise<SMTPConfig | undefined> {
-  return getConfig<SMTPConfig>(ConfigType.SMTP)
-}
-
-export async function getSMTPConfig(
-  isAutomation?: boolean
-): Promise<SMTPInnerConfig | undefined> {
-  const config = await getSMTPConfigDoc()
-  if (config) {
-    return config.config
-  }
-
-  // always allow fallback in self host
-  // in cloud don't allow for automations
-  const allowFallback = env.SELF_HOSTED || !isAutomation
-
-  // Use an SMTP fallback configuration from env variables
-  if (env.SMTP_FALLBACK_ENABLED && allowFallback) {
-    return {
-      port: env.SMTP_PORT,
-      host: env.SMTP_HOST!,
-      secure: false,
-      from: env.SMTP_FROM_ADDRESS!,
-      auth: {
-        user: env.SMTP_USER!,
-        pass: env.SMTP_PASSWORD!,
-      },
-    }
-  }
-}
-
-// SCIM
-
-export async function getSCIMConfig(): Promise<SCIMInnerConfig | undefined> {
-  const config = await getConfig<SCIMConfig>(ConfigType.SCIM)
-  return config?.config
-}
-
-// AI
-
-export async function getAIConfig(): Promise<AIConfig | undefined> {
-  return getConfig<AIConfig>(ConfigType.AI)
-}

package/src/configs/index.ts

@@ -1 +0,0 @@
-export * from "./configs"

package/src/configs/tests/configs.spec.ts

@@ -1,184 +0,0 @@
-import { generator, structures } from "../../../tests"
-import { DBTestConfiguration, testEnv } from "../../../tests/extra"
-import { ConfigType } from "@budibase/types"
-import env from "../../environment"
-import * as configs from "../configs"
-
-const DEFAULT_URL = "http://localhost:10000"
-const ENV_URL = "http://env.com"
-
-describe("configs", () => {
-  const config = new DBTestConfiguration()
-
-  const setDbPlatformUrl = async (dbUrl: string) => {
-    const settingsConfig = {
-      _id: configs.generateConfigID(ConfigType.SETTINGS),
-      type: ConfigType.SETTINGS,
-      config: {
-        platformUrl: dbUrl,
-      },
-    }
-    await configs.save(settingsConfig)
-  }
-
-  beforeEach(async () => {
-    config.newTenant()
-  })
-
-  describe("getPlatformUrl", () => {
-    describe("self host", () => {
-      beforeEach(async () => {
-        testEnv.selfHosted()
-      })
-
-      it("gets the default url", async () => {
-        await config.doInTenant(async () => {
-          const url = await configs.getPlatformUrl()
-          expect(url).toBe(DEFAULT_URL)
-        })
-      })
-
-      it("gets the platform url from the environment", async () => {
-        await config.doInTenant(async () => {
-          env._set("PLATFORM_URL", ENV_URL)
-          const url = await configs.getPlatformUrl()
-          expect(url).toBe(ENV_URL)
-        })
-      })
-
-      it("gets the platform url from the database", async () => {
-        await config.doInTenant(async () => {
-          const dbUrl = generator.url()
-          await setDbPlatformUrl(dbUrl)
-          const url = await configs.getPlatformUrl()
-          expect(url).toBe(dbUrl)
-        })
-      })
-    })
-
-    describe("cloud", () => {
-      function getTenantAwareUrl() {
-        return `http://${config.tenantId}.env.com`
-      }
-
-      beforeEach(async () => {
-        testEnv.cloudHosted()
-        testEnv.multiTenant()
-
-        env._set("PLATFORM_URL", ENV_URL)
-      })
-
-      it("gets the platform url from the environment without tenancy", async () => {
-        await config.doInTenant(async () => {
-          const url = await configs.getPlatformUrl({ tenantAware: false })
-          expect(url).toBe(ENV_URL)
-        })
-      })
-
-      it("gets the platform url from the environment with tenancy", async () => {
-        await config.doInTenant(async () => {
-          const url = await configs.getPlatformUrl()
-          expect(url).toBe(getTenantAwareUrl())
-        })
-      })
-
-      it("never gets the platform url from the database", async () => {
-        await config.doInTenant(async () => {
-          await setDbPlatformUrl(generator.url())
-          const url = await configs.getPlatformUrl()
-          expect(url).toBe(getTenantAwareUrl())
-        })
-      })
-    })
-  })
-
-  describe("getSettingsConfig", () => {
-    beforeAll(async () => {
-      testEnv.selfHosted()
-      env._set("PLATFORM_URL", "")
-    })
-
-    it("returns the platform url with an existing config", async () => {
-      await config.doInTenant(async () => {
-        const dbUrl = generator.url()
-        await setDbPlatformUrl(dbUrl)
-        const config = await configs.getSettingsConfig()
-        expect(config.platformUrl).toBe(dbUrl)
-      })
-    })
-
-    it("returns the platform url without an existing config", async () => {
-      await config.doInTenant(async () => {
-        const config = await configs.getSettingsConfig()
-        expect(config.platformUrl).toBe(DEFAULT_URL)
-      })
-    })
-  })
-
-  describe("getGoogleDatasourceConfig", () => {
-    function setEnvVars() {
-      env.GOOGLE_CLIENT_SECRET = "test"
-      env.GOOGLE_CLIENT_ID = "test"
-    }
-
-    function unsetEnvVars() {
-      env.GOOGLE_CLIENT_SECRET = undefined
-      env.GOOGLE_CLIENT_ID = undefined
-    }
-
-    describe("cloud", () => {
-      beforeEach(() => {
-        testEnv.cloudHosted()
-      })
-
-      it("returns from env vars", async () => {
-        await config.doInTenant(async () => {
-          setEnvVars()
-          const config = await configs.getGoogleDatasourceConfig()
-          unsetEnvVars()
-
-          expect(config).toEqual({
-            activated: true,
-            clientID: "test",
-            clientSecret: "test",
-          })
-        })
-      })
-
-      it("returns undefined when no env vars are configured", async () => {
-        await config.doInTenant(async () => {
-          const config = await configs.getGoogleDatasourceConfig()
-          expect(config).toBeUndefined()
-        })
-      })
-    })
-
-    describe("self host", () => {
-      beforeEach(() => {
-        testEnv.selfHosted()
-      })
-
-      it("returns from config", async () => {
-        await config.doInTenant(async () => {
-          const googleDoc = structures.sso.googleConfigDoc()
-          await configs.save(googleDoc)
-          const config = await configs.getGoogleDatasourceConfig()
-          expect(config).toEqual(googleDoc.config)
-        })
-      })
-
-      it("falls back to env vars when config is disabled", async () => {
-        await config.doInTenant(async () => {
-          setEnvVars()
-          const config = await configs.getGoogleDatasourceConfig()
-          unsetEnvVars()
-          expect(config).toEqual({
-            activated: true,
-            clientID: "test",
-            clientSecret: "test",
-          })
-        })
-      })
-    })
-  })
-})

package/src/constants/db.ts

@@ -1,75 +0,0 @@
-import { prefixed, DocumentType } from "@budibase/types"
-
-export {
-  SEPARATOR,
-  UNICODE_MAX,
-  DocumentType,
-  InternalTable,
-} from "@budibase/types"
-
-/**
- * Can be used to create a few different forms of querying a view.
- */
-export enum AutomationViewMode {
-  ALL = "all",
-  AUTOMATION = "automation",
-  STATUS = "status",
-}
-
-export enum ViewName {
-  USER_BY_APP = "by_app",
-  USER_BY_EMAIL = "by_email2",
-  BY_API_KEY = "by_api_key",
-  LINK = "by_link",
-  ROUTING = "screen_routes",
-  AUTOMATION_LOGS = "automation_logs",
-  ACCOUNT_BY_EMAIL = "account_by_email",
-  PLATFORM_USERS_LOWERCASE = "platform_users_lowercase_2",
-  USER_BY_GROUP = "user_by_group",
-  APP_BACKUP_BY_TRIGGER = "by_trigger",
-}
-
-export const DeprecatedViews: Record<string, string[]> = {
-  [ViewName.USER_BY_EMAIL]: [
-    // removed due to inaccuracy in view doc filter logic
-    "by_email",
-  ],
-}
-
-export const StaticDatabases = {
-  GLOBAL: {
-    name: "global-db",
-    docs: {
-      apiKeys: "apikeys",
-      usageQuota: "usage_quota",
-      licenseInfo: "license_info",
-      environmentVariables: "environmentvariables",
-    },
-  },
-  // contains information about tenancy and so on
-  PLATFORM_INFO: {
-    name: "global-info",
-    docs: {
-      tenants: "tenants",
-      install: "install",
-    },
-  },
-  AUDIT_LOGS: {
-    name: "audit-logs",
-  },
-  SCIM_LOGS: {
-    name: "scim-logs",
-  },
-}
-
-export const APP_PREFIX = prefixed(DocumentType.APP)
-export const APP_DEV = prefixed(DocumentType.APP_DEV)
-export const APP_DEV_PREFIX = APP_DEV
-export const SQS_DATASOURCE_INTERNAL = "internal"
-export const BUDIBASE_DATASOURCE_TYPE = "budibase"
-export const SQLITE_DESIGN_DOC_ID = "_design/sqlite"
-export const DEFAULT_JOBS_TABLE_ID = "ta_bb_jobs"
-export const DEFAULT_INVENTORY_TABLE_ID = "ta_bb_inventory"
-export const DEFAULT_EXPENSES_TABLE_ID = "ta_bb_expenses"
-export const DEFAULT_EMPLOYEE_TABLE_ID = "ta_bb_employee"
-export { DEFAULT_BB_DATASOURCE_ID } from "@budibase/shared-core"

package/src/constants/index.ts

@@ -1,2 +0,0 @@
-export * from "./db"
-export * from "./misc"

package/src/constants/misc.ts

@@ -1,36 +0,0 @@
-export enum UserStatus {
-  ACTIVE = "active",
-  INACTIVE = "inactive",
-}
-
-export enum Cookie {
-  Auth = "budibase:auth",
-  Init = "budibase:init",
-  ACCOUNT_RETURN_URL = "budibase:account:returnurl",
-  DatasourceAuth = "budibase:datasourceauth",
-  OIDC_CONFIG = "budibase:oidc:config",
-}
-
-export { Header } from "@budibase/shared-core"
-
-export enum GlobalRole {
-  OWNER = "owner",
-  ADMIN = "admin",
-  BUILDER = "builder",
-  WORKSPACE_MANAGER = "workspace_manager",
-}
-
-export enum Config {
-  SETTINGS = "settings",
-  ACCOUNT = "account",
-  SMTP = "smtp",
-  GOOGLE = "google",
-  OIDC = "oidc",
-  OIDC_LOGOS = "logos_oidc",
-  SCIM = "scim",
-  AI = "AI",
-}
-
-export const MIN_VALID_DATE = new Date(-2147483647000)
-export const MAX_VALID_DATE = new Date(2147483647000)
-export const DEFAULT_TENANT_ID = "default"

package/src/context/Context.ts

@@ -1,14 +0,0 @@
-import { AsyncLocalStorage } from "async_hooks"
-import { ContextMap } from "./types"
-
-export default class Context {
-  static storage = new AsyncLocalStorage<ContextMap>()
-
-  static run<T>(context: ContextMap, func: () => T) {
-    return Context.storage.run(context, () => func())
-  }
-
-  static get(): ContextMap {
-    return Context.storage.getStore() as ContextMap
-  }
-}

package/src/context/identity.ts

@@ -1,58 +0,0 @@
-import {
-  IdentityContext,
-  IdentityType,
-  User,
-  isCloudAccount,
-  Account,
-  AccountUserContext,
-  UserContext,
-  Ctx,
-} from "@budibase/types"
-import * as context from "."
-
-export function getIdentity(): IdentityContext | undefined {
-  return context.getIdentity()
-}
-
-export function doInIdentityContext(identity: IdentityContext, task: any) {
-  return context.doInIdentityContext(identity, task)
-}
-
-// used in server/worker
-export function doInUserContext(user: User, ctx: Ctx, task: any) {
-  const userContext: UserContext = {
-    ...user,
-    _id: user._id as string,
-    type: IdentityType.USER,
-    hostInfo: {
-      ipAddress: ctx.request.ip,
-      // filled in by koa-useragent package
-      userAgent: ctx.userAgent.source,
-    },
-  }
-  return doInIdentityContext(userContext, task)
-}
-
-// used in account portal
-export function doInAccountContext(account: Account, task: any) {
-  const _id = getAccountUserId(account)
-  const tenantId = account.tenantId
-  const accountContext: AccountUserContext = {
-    _id,
-    type: IdentityType.USER,
-    tenantId,
-    account,
-  }
-  return doInIdentityContext(accountContext, task)
-}
-
-export function getAccountUserId(account: Account) {
-  let userId: string
-  if (isCloudAccount(account)) {
-    userId = account.budibaseUserId
-  } else {
-    // use account id as user id for self-hosting
-    userId = account.accountId
-  }
-  return userId
-}

package/src/context/index.ts

@@ -1,3 +0,0 @@
-export { DEFAULT_TENANT_ID } from "../constants"
-export * as identity from "./identity"
-export * from "./mainContext"