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

package/src/docIds/params.ts

@@ -1,174 +0,0 @@
-import {
-  DocumentType,
-  InternalTable,
-  SEPARATOR,
-  UNICODE_MAX,
-  ViewName,
-} from "../constants"
-import { getProdAppID } from "./conversions"
-
-/**
- * If creating DB allDocs/query params with only a single top level ID this can be used, this
- * is usually the case as most of our docs are top level e.g. tables, automations, users and so on.
- * More complex cases such as link docs and rows which have multiple levels of IDs that their
- * ID consists of need their own functions to build the allDocs parameters.
- * @param {string} docType The type of document which input params are being built for, e.g. user,
- * link, app, table and so on.
- * @param {string|null} docId The ID of the document minus its type - this is only needed if looking
- * for a singular document.
- * @param {object} otherProps Add any other properties onto the request, e.g. include_docs.
- * @returns {object} Parameters which can then be used with an allDocs request.
- */
-export function getDocParams(
-  docType: string,
-  docId?: string | null,
-  otherProps: any = {}
-) {
-  if (docId == null) {
-    docId = ""
-  }
-  return {
-    ...otherProps,
-    startkey: `${docType}${SEPARATOR}${docId}`,
-    endkey: `${docType}${SEPARATOR}${docId}${UNICODE_MAX}`,
-  }
-}
-
-/**
- * Gets the DB allDocs/query params for retrieving a row.
- * @param {string|null} tableId The table in which the rows have been stored.
- * @param {string|null} rowId The ID of the row which is being specifically queried for. This can be
- * left null to get all the rows in the table.
- * @param {object} otherProps Any other properties to add to the request.
- * @returns {object} Parameters which can then be used with an allDocs request.
- */
-export function getRowParams(
-  tableId?: string | null,
-  rowId?: string | null,
-  otherProps = {}
-) {
-  if (tableId == null) {
-    return getDocParams(DocumentType.ROW, null, otherProps)
-  }
-
-  const endOfKey = rowId == null ? `${tableId}${SEPARATOR}` : rowId
-
-  return getDocParams(DocumentType.ROW, endOfKey, otherProps)
-}
-
-/**
- * Retrieve the correct index for a view based on default design DB.
- */
-export function getQueryIndex(viewName: ViewName) {
-  return `database/${viewName}`
-}
-
-/**
- * Check if a given ID is that of a table.
- * @returns {boolean}
- */
-export const isTableId = (id: string) => {
-  // this includes datasource plus tables
-  return (
-    id &&
-    (id.startsWith(`${DocumentType.TABLE}${SEPARATOR}`) ||
-      id.startsWith(`${DocumentType.DATASOURCE_PLUS}${SEPARATOR}`))
-  )
-}
-
-/**
- * Check if a given ID is that of a datasource or datasource plus.
- * @returns {boolean}
- */
-export const isDatasourceId = (id: string) => {
-  // this covers both datasources and datasource plus
-  return id && id.startsWith(`${DocumentType.DATASOURCE}${SEPARATOR}`)
-}
-
-/**
- * Gets parameters for retrieving workspaces.
- */
-export function getWorkspaceParams(id = "", otherProps = {}) {
-  return {
-    ...otherProps,
-    startkey: `${DocumentType.WORKSPACE}${SEPARATOR}${id}`,
-    endkey: `${DocumentType.WORKSPACE}${SEPARATOR}${id}${UNICODE_MAX}`,
-  }
-}
-
-/**
- * Gets parameters for retrieving users.
- */
-export function getGlobalUserParams(globalId: any, otherProps: any = {}) {
-  if (!globalId) {
-    globalId = ""
-  }
-  const startkey = otherProps?.startkey
-  return {
-    ...otherProps,
-    // need to include this incase pagination
-    startkey: startkey
-      ? startkey
-      : `${DocumentType.USER}${SEPARATOR}${globalId}`,
-    endkey: `${DocumentType.USER}${SEPARATOR}${globalId}${UNICODE_MAX}`,
-  }
-}
-
-/**
- * Gets parameters for retrieving users, this is a utility function for the getDocParams function.
- */
-export function getUserMetadataParams(userId?: string | null, otherProps = {}) {
-  return getRowParams(InternalTable.USER_METADATA, userId, otherProps)
-}
-
-export function getUsersByAppParams(appId: any, otherProps: any = {}) {
-  const prodAppId = getProdAppID(appId)
-  return {
-    ...otherProps,
-    startkey: prodAppId,
-    endkey: `${prodAppId}${UNICODE_MAX}`,
-  }
-}
-
-/**
- * Gets parameters for retrieving templates. Owner ID must be specified, either global or a workspace level.
- */
-export function getTemplateParams(
-  ownerId: any,
-  templateId: any,
-  otherProps = {}
-) {
-  if (!templateId) {
-    templateId = ""
-  }
-  let final
-  if (templateId) {
-    final = templateId
-  } else {
-    final = `${DocumentType.TEMPLATE}${SEPARATOR}${ownerId}${SEPARATOR}`
-  }
-  return {
-    ...otherProps,
-    startkey: final,
-    endkey: `${final}${UNICODE_MAX}`,
-  }
-}
-
-/**
- * Gets parameters for retrieving a role, this is a utility function for the getDocParams function.
- */
-export function getRoleParams(roleId?: string | null, otherProps = {}) {
-  return getDocParams(DocumentType.ROLE, roleId, otherProps)
-}
-
-export function getStartEndKeyURL(baseKey: any, tenantId?: string) {
-  const tenancy = tenantId ? `${SEPARATOR}${tenantId}` : ""
-  return `startkey="${baseKey}${tenancy}"&endkey="${baseKey}${tenancy}${UNICODE_MAX}"`
-}
-
-/**
- * Gets parameters for retrieving automations, this is a utility function for the getDocParams function.
- */
-export const getPluginParams = (pluginId?: string | null, otherProps = {}) => {
-  return getDocParams(DocumentType.PLUGIN, pluginId, otherProps)
-}

package/src/docUpdates/index.ts

@@ -1,29 +0,0 @@
-import { asyncEventQueue, init as initQueue } from "../events/asyncEvents"
-import {
-  ProcessorMap,
-  default as DocumentUpdateProcessor,
-} from "../events/processors/async/DocumentUpdateProcessor"
-
-let processingPromise: Promise<void>
-let documentProcessor: DocumentUpdateProcessor
-
-export function init(processors: ProcessorMap) {
-  if (!asyncEventQueue) {
-    initQueue()
-  }
-  if (!documentProcessor) {
-    documentProcessor = new DocumentUpdateProcessor(processors)
-  }
-  // if not processing in this instance, kick it off
-  if (!processingPromise) {
-    processingPromise = asyncEventQueue.process(async job => {
-      const { event, identity, properties, timestamp } = job.data
-      await documentProcessor.processEvent(
-        event,
-        identity,
-        properties,
-        timestamp
-      )
-    })
-  }
-}

package/src/environment.ts

@@ -1,201 +0,0 @@
-import { existsSync, readFileSync } from "fs"
-import { ServiceType } from "@budibase/types"
-
-function isTest() {
-  return isCypress() || isJest()
-}
-
-function isJest() {
-  return !!(process.env.NODE_ENV === "jest" || process.env.JEST_WORKER_ID)
-}
-
-function isCypress() {
-  return process.env.NODE_ENV === "cypress"
-}
-
-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",
-}
-
-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 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)
-  }
-
-  try {
-    const packageJsonFile = findFileInAncestors("package.json", process.cwd())
-    const content = readFileSync(packageJsonFile!, "utf-8")
-    const parsedContent = JSON.parse(content)
-    return {
-      VERSION: parsedContent.version,
-      SERVICE_NAME: parsedContent.name,
-    }
-  } catch {
-    // throwing an error here is confusing/causes backend-core to be hard to import
-    return { VERSION: "", SERVICE_NAME: "" }
-  }
-}
-
-function isWorker() {
-  return environment.SERVICE_TYPE === ServiceType.WORKER
-}
-
-function isApps() {
-  return environment.SERVICE_TYPE === ServiceType.APPS
-}
-
-const environment = {
-  isTest,
-  isJest,
-  isDev,
-  isWorker,
-  isApps,
-  isProd: () => {
-    return !isDev()
-  },
-  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_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_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,
-  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,
-  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,
-  // 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",
-  /**
-   * 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,
-  _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",
-}
-
-// 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

package/src/errors/errors.ts

@@ -1,119 +0,0 @@
-// BASE
-
-export abstract class BudibaseError extends Error {
-  code: string
-
-  constructor(message: string, code: ErrorCode) {
-    super(message)
-    this.code = code
-  }
-
-  protected getPublicError?(): any
-}
-
-// ERROR HANDLING
-
-export enum ErrorCode {
-  USAGE_LIMIT_EXCEEDED = "usage_limit_exceeded",
-  FEATURE_DISABLED = "feature_disabled",
-  INVALID_API_KEY = "invalid_api_key",
-  HTTP = "http",
-}
-
-/**
- * For the given error, build the public representation that is safe
- * to be exposed over an api.
- */
-export const getPublicError = (err: any) => {
-  let error
-  if (err.code) {
-    // add generic error information
-    error = {
-      code: err.code,
-    }
-
-    if (err.getPublicError) {
-      error = {
-        ...error,
-        // get any additional context from this error
-        ...err.getPublicError(),
-      }
-    }
-  }
-
-  return error
-}
-
-// HTTP
-
-export class HTTPError extends BudibaseError {
-  status: number
-
-  constructor(message: string, httpStatus: number, code = ErrorCode.HTTP) {
-    super(message, code)
-    this.status = httpStatus
-  }
-}
-
-export class NotFoundError extends HTTPError {
-  constructor(message: string) {
-    super(message, 404)
-  }
-}
-
-export class BadRequestError extends HTTPError {
-  constructor(message: string) {
-    super(message, 400)
-  }
-}
-
-// LICENSING
-
-export class UsageLimitError extends HTTPError {
-  limitName: string
-
-  constructor(message: string, limitName: string) {
-    super(message, 400, ErrorCode.USAGE_LIMIT_EXCEEDED)
-    this.limitName = limitName
-  }
-
-  getPublicError() {
-    return {
-      limitName: this.limitName,
-    }
-  }
-}
-
-export class FeatureDisabledError extends HTTPError {
-  featureName: string
-
-  constructor(message: string, featureName: string) {
-    super(message, 400, ErrorCode.FEATURE_DISABLED)
-    this.featureName = featureName
-  }
-
-  getPublicError() {
-    return {
-      featureName: this.featureName,
-    }
-  }
-}
-
-// AUTH
-
-export class InvalidAPIKeyError extends BudibaseError {
-  constructor() {
-    super(
-      "Invalid API key - may need re-generated, or user doesn't exist",
-      ErrorCode.INVALID_API_KEY
-    )
-  }
-}
-
-// USERS
-
-export class EmailUnavailableError extends Error {
-  constructor(email: string) {
-    super(`Email already in use: '${email}'`)
-  }
-}

package/src/errors/index.ts

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

package/src/events/analytics.ts

@@ -1,6 +0,0 @@
-import * as configs from "../configs"
-
-// wrapper utility function
-export const enabled = async () => {
-  return configs.analyticsEnabled()
-}

package/src/events/asyncEvents/index.ts

@@ -1,2 +0,0 @@
-export * from "./queue"
-export * from "./publisher"

package/src/events/asyncEvents/publisher.ts

@@ -1,12 +0,0 @@
-import { AsyncEvents } from "@budibase/types"
-import { EventPayload, asyncEventQueue, init } from "./queue"
-
-export async function publishAsyncEvent(payload: EventPayload) {
-  if (!asyncEventQueue) {
-    init()
-  }
-  const { event, identity } = payload
-  if (AsyncEvents.indexOf(event) !== -1 && identity.tenantId) {
-    await asyncEventQueue.add(payload)
-  }
-}

package/src/events/asyncEvents/queue.ts

@@ -1,22 +0,0 @@
-import BullQueue from "bull"
-import { createQueue, JobQueue } from "../../queue"
-import { Event, Identity } from "@budibase/types"
-
-export interface EventPayload {
-  event: Event
-  identity: Identity
-  properties: any
-  timestamp?: string | number
-}
-
-export let asyncEventQueue: BullQueue.Queue
-
-export function init() {
-  asyncEventQueue = createQueue<EventPayload>(JobQueue.SYSTEM_EVENT_QUEUE)
-}
-
-export async function shutdown() {
-  if (asyncEventQueue) {
-    await asyncEventQueue.close()
-  }
-}