budibase/packages/backend-core/src/environment.ts

import { existsSync, readFileSync } from "fs"
import { ServiceType } from "@budibase/types"
import { cloneDeep } from "lodash"

function isTest() {
  return isJest()
}

function isJest() {
  return (
    process.env.NODE_ENV === "jest" ||
    (process.env.JEST_WORKER_ID != null &&
      process.env.JEST_WORKER_ID !== "null")
  )
}

function isDev() {
  return process.env.NODE_ENV !== "production"
}

let LOADED = false
if (!LOADED && isDev() && !isTest()) {
  require("dotenv").config()
  LOADED = true
}

const DefaultBucketName = {
  BACKUPS: "backups",
  APPS: "prod-budi-app-assets",
  TEMPLATES: "templates",
  GLOBAL: "global",
  PLUGINS: "plugins",
  TEMP: "tmp-file-attachments",
}

const selfHosted = !!parseInt(process.env.SELF_HOSTED || "")

function getAPIEncryptionKey() {
  return process.env.API_ENCRYPTION_KEY
    ? process.env.API_ENCRYPTION_KEY
    : process.env.JWT_SECRET // fallback to the JWT_SECRET used historically
}

function httpLogging() {
  if (process.env.HTTP_LOGGING === undefined) {
    // on by default unless otherwise specified
    return true
  }

  return process.env.HTTP_LOGGING
}

function getPackageJsonFields(): {
  VERSION: string
  SERVICE_NAME: string
} {
  function getParentFile(file: string) {
    function findFileInAncestors(
      fileName: string,
      currentDir: string
    ): string | null {
      const filePath = `${currentDir}/${fileName}`
      if (existsSync(filePath)) {
        return filePath
      }

      const parentDir = `${currentDir}/..`
      if (parentDir === currentDir) {
        // reached root directory
        return null
      }

      return findFileInAncestors(fileName, parentDir)
    }

    const packageJsonFile = findFileInAncestors(file, process.cwd())
    const content = readFileSync(packageJsonFile!, "utf-8")
    const parsedContent = JSON.parse(content)
    return parsedContent
  }

  let localVersion: string | undefined
  if (isDev() && !isTest()) {
    try {
      const lerna = getParentFile("lerna.json")
      localVersion = `${lerna.version}+local`
    } catch {
      //
    }
  }

  try {
    const parsedContent = getParentFile("package.json")
    return {
      VERSION:
        localVersion || process.env.BUDIBASE_VERSION || parsedContent.version,
      SERVICE_NAME: parsedContent.name,
    }
  } catch {
    // throwing an error here is confusing/causes backend-core to be hard to import
    return { VERSION: process.env.BUDIBASE_VERSION || "", SERVICE_NAME: "" }
  }
}

function isWorker() {
  return environment.SERVICE_TYPE === ServiceType.WORKER
}

function isApps() {
  return environment.SERVICE_TYPE === ServiceType.APPS
}

function isQA() {
  return environment.BUDIBASE_ENVIRONMENT === "QA"
}

const environment = {
  isTest,
  isJest,
  isDev,
  isWorker,
  isApps,
  isQA,
  isProd: () => {
    return !isDev()
  },
  BUDIBASE_ENVIRONMENT: process.env.BUDIBASE_ENVIRONMENT,
  JS_BCRYPT: process.env.JS_BCRYPT,
  JWT_SECRET: process.env.JWT_SECRET,
  JWT_SECRET_FALLBACK: process.env.JWT_SECRET_FALLBACK,
  ENCRYPTION_KEY: process.env.ENCRYPTION_KEY,
  API_ENCRYPTION_KEY: getAPIEncryptionKey(),
  COUCH_DB_URL: process.env.COUCH_DB_URL || "http://localhost:4005",
  COUCH_DB_SQL_URL: process.env.COUCH_DB_SQL_URL,
  COUCH_DB_USERNAME: process.env.COUCH_DB_USER,
  COUCH_DB_PASSWORD: process.env.COUCH_DB_PASSWORD,
  GOOGLE_CLIENT_ID: process.env.GOOGLE_CLIENT_ID,
  GOOGLE_CLIENT_SECRET: process.env.GOOGLE_CLIENT_SECRET,
  SALT_ROUNDS: process.env.SALT_ROUNDS,
  REDIS_URL: process.env.REDIS_URL || "localhost:6379",
  REDIS_PASSWORD: process.env.REDIS_PASSWORD,
  REDIS_CLUSTERED: process.env.REDIS_CLUSTERED,
  MINIO_ACCESS_KEY: process.env.MINIO_ACCESS_KEY,
  MINIO_SECRET_KEY: process.env.MINIO_SECRET_KEY,
  AWS_SESSION_TOKEN: process.env.AWS_SESSION_TOKEN,
  AWS_REGION: process.env.AWS_REGION,
  MINIO_URL: process.env.MINIO_URL,
  MINIO_ENABLED: process.env.MINIO_ENABLED || 1,
  INTERNAL_API_KEY: process.env.INTERNAL_API_KEY,
  INTERNAL_API_KEY_FALLBACK: process.env.INTERNAL_API_KEY_FALLBACK,
  MULTI_TENANCY: process.env.MULTI_TENANCY,
  ACCOUNT_PORTAL_URL:
    process.env.ACCOUNT_PORTAL_URL || "https://account.budibase.app",
  ACCOUNT_PORTAL_API_KEY: process.env.ACCOUNT_PORTAL_API_KEY || "",
  DISABLE_ACCOUNT_PORTAL: process.env.DISABLE_ACCOUNT_PORTAL,
  SELF_HOSTED: selfHosted,
  COOKIE_DOMAIN: process.env.COOKIE_DOMAIN,
  PLATFORM_URL: process.env.PLATFORM_URL || "",
  POSTHOG_TOKEN: process.env.POSTHOG_TOKEN,
  POSTHOG_PERSONAL_TOKEN: process.env.POSTHOG_PERSONAL_TOKEN,
  POSTHOG_API_HOST: process.env.POSTHOG_API_HOST || "https://us.i.posthog.com",
  POSTHOG_FEATURE_FLAGS_ENABLED: process.env.POSTHOG_FEATURE_FLAGS_ENABLED,
  ENABLE_ANALYTICS: process.env.ENABLE_ANALYTICS,
  TENANT_FEATURE_FLAGS: process.env.TENANT_FEATURE_FLAGS,
  CLOUDFRONT_CDN: process.env.CLOUDFRONT_CDN,
  CLOUDFRONT_PRIVATE_KEY_64: process.env.CLOUDFRONT_PRIVATE_KEY_64,
  CLOUDFRONT_PUBLIC_KEY_ID: process.env.CLOUDFRONT_PUBLIC_KEY_ID,
  BACKUPS_BUCKET_NAME:
    process.env.BACKUPS_BUCKET_NAME || DefaultBucketName.BACKUPS,
  APPS_BUCKET_NAME: process.env.APPS_BUCKET_NAME || DefaultBucketName.APPS,
  TEMPLATES_BUCKET_NAME:
    process.env.TEMPLATES_BUCKET_NAME || DefaultBucketName.TEMPLATES,
  GLOBAL_BUCKET_NAME:
    process.env.GLOBAL_BUCKET_NAME || DefaultBucketName.GLOBAL,
  PLUGIN_BUCKET_NAME:
    process.env.PLUGIN_BUCKET_NAME || DefaultBucketName.PLUGINS,
  TEMP_BUCKET_NAME: process.env.TEMP_BUCKET_NAME || DefaultBucketName.TEMP,
  USE_COUCH: process.env.USE_COUCH || true,
  MOCK_REDIS: process.env.MOCK_REDIS,
  DEFAULT_LICENSE: process.env.DEFAULT_LICENSE,
  SERVICE: process.env.SERVICE || "budibase",
  LOG_LEVEL: process.env.LOG_LEVEL || "info",
  SESSION_UPDATE_PERIOD: process.env.SESSION_UPDATE_PERIOD,
  DEPLOYMENT_ENVIRONMENT:
    process.env.DEPLOYMENT_ENVIRONMENT || "docker-compose",
  HTTP_LOGGING: httpLogging(),
  ENABLE_AUDIT_LOG_IP_ADDR: process.env.ENABLE_AUDIT_LOG_IP_ADDR,
  // Couch/search
  SQL_LOGGING_ENABLE: process.env.SQL_LOGGING_ENABLE,
  SQL_MAX_ROWS: process.env.SQL_MAX_ROWS,
  SQL_MAX_RELATED_ROWS: process.env.MAX_RELATED_ROWS,
  // smtp
  SMTP_FALLBACK_ENABLED: process.env.SMTP_FALLBACK_ENABLED,
  SMTP_USER: process.env.SMTP_USER,
  SMTP_PASSWORD: process.env.SMTP_PASSWORD,
  SMTP_HOST: process.env.SMTP_HOST,
  SMTP_PORT: parseInt(process.env.SMTP_PORT || ""),
  SMTP_FROM_ADDRESS: process.env.SMTP_FROM_ADDRESS,
  DISABLE_JWT_WARNING: process.env.DISABLE_JWT_WARNING,
  BLACKLIST_IPS: process.env.BLACKLIST_IPS,
  SERVICE_TYPE: "unknown",
  PASSWORD_MIN_LENGTH: process.env.PASSWORD_MIN_LENGTH,
  PASSWORD_MAX_LENGTH: process.env.PASSWORD_MAX_LENGTH,
  /**
   * Enable to allow an admin user to login using a password.
   * This can be useful to prevent lockout when configuring SSO.
   * However, this should be turned OFF by default for security purposes.
   */
  ENABLE_SSO_MAINTENANCE_MODE: selfHosted
    ? process.env.ENABLE_SSO_MAINTENANCE_MODE
    : false,
  ...getPackageJsonFields(),
  DISABLE_PINO_LOGGER: process.env.DISABLE_PINO_LOGGER,
  OFFLINE_MODE: process.env.OFFLINE_MODE,
  SESSION_EXPIRY_SECONDS: process.env.SESSION_EXPIRY_SECONDS,
  _set(key: any, value: any) {
    process.env[key] = value
    // @ts-ignore
    environment[key] = value
  },
  ROLLING_LOG_MAX_SIZE: process.env.ROLLING_LOG_MAX_SIZE || "10M",
  DISABLE_SCIM_CALLS: process.env.DISABLE_SCIM_CALLS,
  BB_ADMIN_USER_EMAIL: process.env.BB_ADMIN_USER_EMAIL,
  BB_ADMIN_USER_PASSWORD: process.env.BB_ADMIN_USER_PASSWORD,
  OPENAI_API_KEY: process.env.OPENAI_API_KEY,
  MIN_VERSION_WITHOUT_POWER_ROLE:
    process.env.MIN_VERSION_WITHOUT_POWER_ROLE || "3.0.0",
}

export function setEnv(newEnvVars: Partial<typeof environment>): () => void {
  const oldEnv = cloneDeep(environment)

  let key: keyof typeof newEnvVars
  for (key in newEnvVars) {
    environment._set(key, newEnvVars[key])
  }

  return () => {
    for (const [key, value] of Object.entries(oldEnv)) {
      environment._set(key, value)
    }
  }
}

export function withEnv<T>(envVars: Partial<typeof environment>, f: () => T) {
  const cleanup = setEnv(envVars)
  const result = f()
  if (result instanceof Promise) {
    return result.finally(cleanup)
  } else {
    cleanup()
    return result
  }
}

type EnvironmentKey = keyof typeof environment
export const SECRETS: EnvironmentKey[] = [
  "API_ENCRYPTION_KEY",
  "BB_ADMIN_USER_PASSWORD",
  "COUCH_DB_PASSWORD",
  "COUCH_DB_SQL_URL",
  "COUCH_DB_URL",
  "GOOGLE_CLIENT_SECRET",
  "INTERNAL_API_KEY_FALLBACK",
  "INTERNAL_API_KEY",
  "JWT_SECRET",
  "MINIO_ACCESS_KEY",
  "MINIO_SECRET_KEY",
  "OPENAI_API_KEY",
  "REDIS_PASSWORD",
]

// clean up any environment variable edge cases
for (let [key, value] of Object.entries(environment)) {
  // handle the edge case of "0" to disable an environment variable
  if (value === "0") {
    // @ts-ignore
    environment[key] = 0
  }
  // handle the edge case of "false" to disable an environment variable
  if (value === "false") {
    // @ts-ignore
    environment[key] = 0
  }
}

export default environment