@budibase/backend-core 3.2.4 → 3.2.6

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"