@budibase/backend-core 2.9.19 → 2.9.21-alpha.0

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,63 +0,0 @@
-import { prefixed, DocumentType } from "@budibase/types"
-export { SEPARATOR, UNICODE_MAX, DocumentType } 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",
-  USER_BY_GROUP = "user_by_group",
-  APP_BACKUP_BY_TRIGGER = "by_trigger",
-}
-
-export const DeprecatedViews = {
-  [ViewName.USER_BY_EMAIL]: [
-    // removed due to inaccuracy in view doc filter logic
-    "by_email",
-  ],
-}
-
-export enum InternalTable {
-  USER_METADATA = "ta_users",
-}
-
-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",
-  },
-}
-
-export const APP_PREFIX = prefixed(DocumentType.APP)
-export const APP_DEV = prefixed(DocumentType.APP_DEV)
-export const APP_DEV_PREFIX = APP_DEV
-export const BUDIBASE_DATASOURCE_TYPE = "budibase"

package/src/constants/index.ts

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

package/src/constants/misc.ts

@@ -1,50 +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 enum Header {
-  API_KEY = "x-budibase-api-key",
-  LICENSE_KEY = "x-budibase-license-key",
-  API_VER = "x-budibase-api-version",
-  APP_ID = "x-budibase-app-id",
-  SESSION_ID = "x-budibase-session-id",
-  TYPE = "x-budibase-type",
-  PREVIEW_ROLE = "x-budibase-role",
-  TENANT_ID = "x-budibase-tenant-id",
-  VERIFICATION_CODE = "x-budibase-verification-code",
-  RETURN_VERIFICATION_CODE = "x-budibase-return-verification-code",
-  TOKEN = "x-budibase-token",
-  CSRF_TOKEN = "x-csrf-token",
-  CORRELATION_ID = "x-budibase-correlation-id",
-  AUTHORIZATION = "authorization",
-}
-
-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",
-}
-
-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(context: ContextMap, func: any) {
-    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._agent.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"

package/src/context/mainContext.ts

@@ -1,310 +0,0 @@
-// some test cases call functions directly, need to
-// store an app ID to pretend there is a context
-import env from "../environment"
-import Context from "./Context"
-import * as conversions from "../docIds/conversions"
-import { getDB } from "../db/db"
-import {
-  DocumentType,
-  SEPARATOR,
-  StaticDatabases,
-  DEFAULT_TENANT_ID,
-} from "../constants"
-import { Database, IdentityContext } from "@budibase/types"
-import { ContextMap } from "./types"
-
-let TEST_APP_ID: string | null = null
-
-export function getGlobalDBName(tenantId?: string) {
-  // tenant ID can be set externally, for example user API where
-  // new tenants are being created, this may be the case
-  if (!tenantId) {
-    tenantId = getTenantId()
-  }
-  return baseGlobalDBName(tenantId)
-}
-
-export function getAuditLogDBName(tenantId?: string) {
-  if (!tenantId) {
-    tenantId = getTenantId()
-  }
-  if (tenantId === DEFAULT_TENANT_ID) {
-    return StaticDatabases.AUDIT_LOGS.name
-  } else {
-    return `${tenantId}${SEPARATOR}${StaticDatabases.AUDIT_LOGS.name}`
-  }
-}
-
-export function baseGlobalDBName(tenantId: string | undefined | null) {
-  if (!tenantId || tenantId === DEFAULT_TENANT_ID) {
-    return StaticDatabases.GLOBAL.name
-  } else {
-    return `${tenantId}${SEPARATOR}${StaticDatabases.GLOBAL.name}`
-  }
-}
-
-export function getPlatformURL() {
-  return env.PLATFORM_URL
-}
-
-export function isMultiTenant() {
-  return !!env.MULTI_TENANCY
-}
-
-export function isTenantIdSet() {
-  const context = Context.get()
-  return !!context?.tenantId
-}
-
-export function isTenancyEnabled() {
-  return env.MULTI_TENANCY
-}
-
-/**
- * Given an app ID this will attempt to retrieve the tenant ID from it.
- * @return {null|string} The tenant ID found within the app ID.
- */
-export function getTenantIDFromAppID(appId: string) {
-  if (!appId) {
-    return undefined
-  }
-  if (!isMultiTenant()) {
-    return DEFAULT_TENANT_ID
-  }
-  const split = appId.split(SEPARATOR)
-  const hasDev = split[1] === DocumentType.DEV
-  if ((hasDev && split.length === 3) || (!hasDev && split.length === 2)) {
-    return undefined
-  }
-  if (hasDev) {
-    return split[2]
-  } else {
-    return split[1]
-  }
-}
-
-function updateContext(updates: ContextMap): ContextMap {
-  let context: ContextMap
-  try {
-    context = Context.get()
-  } catch (err) {
-    // no context, start empty
-    context = {}
-  }
-  context = {
-    ...context,
-    ...updates,
-  }
-  return context
-}
-
-async function newContext(updates: ContextMap, task: any) {
-  // see if there already is a context setup
-  let context: ContextMap = updateContext(updates)
-  return Context.run(context, task)
-}
-
-export async function doInAutomationContext(params: {
-  appId: string
-  automationId: string
-  task: any
-}): Promise<any> {
-  const tenantId = getTenantIDFromAppID(params.appId)
-  return newContext(
-    {
-      tenantId,
-      appId: params.appId,
-      automationId: params.automationId,
-    },
-    params.task
-  )
-}
-
-export async function doInContext(appId: string, task: any): Promise<any> {
-  const tenantId = getTenantIDFromAppID(appId)
-  return newContext(
-    {
-      tenantId,
-      appId,
-    },
-    task
-  )
-}
-
-export async function doInTenant<T>(
-  tenantId: string | null,
-  task: () => T
-): Promise<T> {
-  // make sure default always selected in single tenancy
-  if (!env.MULTI_TENANCY) {
-    tenantId = tenantId || DEFAULT_TENANT_ID
-  }
-
-  const updates = tenantId ? { tenantId } : {}
-  return newContext(updates, task)
-}
-
-export async function doInAppContext(
-  appId: string | null,
-  task: any
-): Promise<any> {
-  if (!appId && !env.isTest()) {
-    throw new Error("appId is required")
-  }
-
-  let updates: ContextMap
-  if (!appId) {
-    updates = { appId: "" }
-  } else {
-    const tenantId = getTenantIDFromAppID(appId)
-    updates = { appId }
-    if (tenantId) {
-      updates.tenantId = tenantId
-    }
-  }
-  return newContext(updates, task)
-}
-
-export async function doInIdentityContext(
-  identity: IdentityContext,
-  task: any
-): Promise<any> {
-  if (!identity) {
-    throw new Error("identity is required")
-  }
-
-  const context: ContextMap = {
-    identity,
-  }
-  if (identity.tenantId) {
-    context.tenantId = identity.tenantId
-  }
-  return newContext(context, task)
-}
-
-export function getIdentity(): IdentityContext | undefined {
-  try {
-    const context = Context.get()
-    return context?.identity
-  } catch (e) {
-    // do nothing - identity is not in context
-  }
-}
-
-export function getTenantId(): string {
-  if (!isMultiTenant()) {
-    return DEFAULT_TENANT_ID
-  }
-  const context = Context.get()
-  const tenantId = context?.tenantId
-  if (!tenantId) {
-    throw new Error("Tenant id not found")
-  }
-  return tenantId
-}
-
-export function getAutomationId(): string | undefined {
-  const context = Context.get()
-  return context?.automationId
-}
-
-export function getAppId(): string | undefined {
-  const context = Context.get()
-  const foundId = context?.appId
-  if (!foundId && env.isTest() && TEST_APP_ID) {
-    return TEST_APP_ID
-  } else {
-    return foundId
-  }
-}
-
-export const getProdAppId = () => {
-  const appId = getAppId()
-  if (!appId) {
-    throw new Error("Could not get appId")
-  }
-  return conversions.getProdAppID(appId)
-}
-
-export function doInEnvironmentContext(
-  values: Record<string, string>,
-  task: any
-) {
-  if (!values) {
-    throw new Error("Must supply environment variables.")
-  }
-  const updates = {
-    environmentVariables: values,
-  }
-  return newContext(updates, task)
-}
-
-export function doInScimContext(task: any) {
-  const updates: ContextMap = {
-    isScim: true,
-  }
-  return newContext(updates, task)
-}
-
-export function getEnvironmentVariables() {
-  const context = Context.get()
-  if (!context.environmentVariables) {
-    return null
-  } else {
-    return context.environmentVariables
-  }
-}
-
-export function getGlobalDB(): Database {
-  const context = Context.get()
-  if (!context || (env.MULTI_TENANCY && !context.tenantId)) {
-    throw new Error("Global DB not found")
-  }
-  return getDB(baseGlobalDBName(context?.tenantId))
-}
-
-export function getAuditLogsDB(): Database {
-  if (!getTenantId()) {
-    throw new Error("No tenant ID found - cannot open audit log DB")
-  }
-  return getDB(getAuditLogDBName())
-}
-
-/**
- * Gets the app database based on whatever the request
- * contained, dev or prod.
- */
-export function getAppDB(opts?: any): Database {
-  const appId = getAppId()
-  return getDB(appId, opts)
-}
-
-/**
- * This specifically gets the prod app ID, if the request
- * contained a development app ID, this will get the prod one.
- */
-export function getProdAppDB(opts?: any): Database {
-  const appId = getAppId()
-  if (!appId) {
-    throw new Error("Unable to retrieve prod DB - no app ID.")
-  }
-  return getDB(conversions.getProdAppID(appId), opts)
-}
-
-/**
- * This specifically gets the dev app ID, if the request
- * contained a prod app ID, this will get the dev one.
- */
-export function getDevAppDB(opts?: any): Database {
-  const appId = getAppId()
-  if (!appId) {
-    throw new Error("Unable to retrieve dev DB - no app ID.")
-  }
-  return getDB(conversions.getDevelopmentAppID(appId), opts)
-}
-
-export function isScim(): boolean {
-  const context = Context.get()
-  const scimCall = context?.isScim
-  return !!scimCall
-}