@budibase/backend-core 2.5.6-alpha.9 → 2.5.7

package/src/events/processors/async/DocumentUpdateProcessor.ts

@@ -1,43 +0,0 @@
-import { EventProcessor } from "../types"
-import { Event, Identity, DocUpdateEvent } from "@budibase/types"
-import { doInTenant } from "../../../context"
-import { getDocumentId } from "../../documentId"
-import { shutdown } from "../../asyncEvents"
-
-export type Processor = (update: DocUpdateEvent) => Promise<void>
-export type ProcessorMap = { events: Event[]; processor: Processor }[]
-
-export default class DocumentUpdateProcessor implements EventProcessor {
-  processors: ProcessorMap = []
-
-  constructor(processors: ProcessorMap) {
-    this.processors = processors
-  }
-
-  async processEvent(
-    event: Event,
-    identity: Identity,
-    properties: any,
-    timestamp?: string | number
-  ) {
-    const tenantId = identity.realTenantId
-    const docId = getDocumentId(event, properties)
-    if (!tenantId || !docId) {
-      return
-    }
-    for (let { events, processor } of this.processors) {
-      if (events.includes(event)) {
-        await doInTenant(tenantId, async () => {
-          await processor({
-            id: docId,
-            tenantId,
-          })
-        })
-      }
-    }
-  }
-
-  shutdown() {
-    return shutdown()
-  }
-}

package/src/logging/alerts.ts

@@ -1,26 +0,0 @@
-const NonErrors = ["AccountError"]
-
-function isSuppressed(e?: any) {
-  return e && e["suppressAlert"]
-}
-
-export function logAlert(message: string, e?: any) {
-  if (e && NonErrors.includes(e.name) && isSuppressed(e)) {
-    return
-  }
-  console.error(`bb-alert: ${message}`, e)
-}
-
-export function logAlertWithInfo(
-  message: string,
-  db: string,
-  id: string,
-  error: any
-) {
-  message = `${message} - db: ${db} - doc: ${id} - error: `
-  logAlert(message, error)
-}
-
-export function logWarn(message: string) {
-  console.warn(`bb-warn: ${message}`)
-}

package/src/logging/correlation/correlation.ts

@@ -1,13 +0,0 @@
-import { Header } from "../../constants"
-const correlator = require("correlation-id")
-
-export const setHeader = (headers: any) => {
-  const correlationId = correlator.getId()
-  if (correlationId) {
-    headers[Header.CORRELATION_ID] = correlationId
-  }
-}
-
-export function getId() {
-  return correlator.getId()
-}

package/src/logging/correlation/index.ts

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

package/src/logging/correlation/middleware.ts

@@ -1,17 +0,0 @@
-import { Header } from "../../constants"
-import { v4 as uuid } from "uuid"
-const correlator = require("correlation-id")
-
-const correlation = (ctx: any, next: any) => {
-  // use the provided correlation id header if present
-  let correlationId = ctx.headers[Header.CORRELATION_ID]
-  if (!correlationId) {
-    correlationId = uuid()
-  }
-
-  return correlator.withId(correlationId, () => {
-    return next()
-  })
-}
-
-export default correlation

package/src/logging/index.ts

@@ -1,6 +0,0 @@
-export * as correlation from "./correlation/correlation"
-export { logger, disableLogger } from "./pino/logger"
-export * from "./alerts"
-
-// turn off or on context logging i.e. tenantId, appId etc
-export let LOG_CONTEXT = true

package/src/logging/pino/logger.ts

@@ -1,188 +0,0 @@
-import env from "../../environment"
-import pino, { LoggerOptions } from "pino"
-import * as context from "../../context"
-import * as correlation from "../correlation"
-import { IdentityType } from "@budibase/types"
-import { LOG_CONTEXT } from "../index"
-
-// CORE LOGGERS - for disabling
-
-const BUILT_INS = {
-  log: console.log,
-  error: console.error,
-  info: console.info,
-  warn: console.warn,
-  trace: console.trace,
-  debug: console.debug,
-}
-
-// LOGGER
-
-const pinoOptions: LoggerOptions = {
-  level: env.LOG_LEVEL,
-  formatters: {
-    level: label => {
-      return { level: label.toUpperCase() }
-    },
-    bindings: () => {
-      return {}
-    },
-  },
-  timestamp: () => `,"timestamp":"${new Date(Date.now()).toISOString()}"`,
-}
-
-if (env.isDev()) {
-  pinoOptions.transport = {
-    target: "pino-pretty",
-    options: {
-      singleLine: true,
-    },
-  }
-}
-
-export const logger = pino(pinoOptions)
-
-export function disableLogger() {
-  console.log = BUILT_INS.log
-  console.error = BUILT_INS.error
-  console.info = BUILT_INS.info
-  console.warn = BUILT_INS.warn
-  console.trace = BUILT_INS.trace
-  console.debug = BUILT_INS.debug
-}
-
-// CONSOLE OVERRIDES
-
-interface MergingObject {
-  objects?: any[]
-  tenantId?: string
-  appId?: string
-  identityId?: string
-  identityType?: IdentityType
-  correlationId?: string
-  err?: Error
-}
-
-function isPlainObject(obj: any) {
-  return typeof obj === "object" && obj !== null && !(obj instanceof Error)
-}
-
-function isError(obj: any) {
-  return obj instanceof Error
-}
-
-function isMessage(obj: any) {
-  return typeof obj === "string"
-}
-
-/**
- * Backwards compatibility between console logging statements
- * and pino logging requirements.
- */
-function getLogParams(args: any[]): [MergingObject, string] {
-  let error = undefined
-  let objects: any[] = []
-  let message = ""
-
-  args.forEach(arg => {
-    if (isMessage(arg)) {
-      message = `${message} ${arg}`.trimStart()
-    }
-    if (isPlainObject(arg)) {
-      objects.push(arg)
-    }
-    if (isError(arg)) {
-      error = arg
-    }
-  })
-
-  const identity = getIdentity()
-
-  let contextObject = {}
-
-  if (LOG_CONTEXT) {
-    contextObject = {
-      tenantId: getTenantId(),
-      appId: getAppId(),
-      identityId: identity?._id,
-      identityType: identity?.type,
-      correlationId: correlation.getId(),
-    }
-  }
-
-  const mergingObject = {
-    objects: objects.length ? objects : undefined,
-    err: error,
-    ...contextObject,
-  }
-
-  return [mergingObject, message]
-}
-
-console.log = (...arg: any[]) => {
-  const [obj, msg] = getLogParams(arg)
-  logger.info(obj, msg)
-}
-console.info = (...arg: any[]) => {
-  const [obj, msg] = getLogParams(arg)
-  logger.info(obj, msg)
-}
-console.warn = (...arg: any[]) => {
-  const [obj, msg] = getLogParams(arg)
-  logger.warn(obj, msg)
-}
-console.error = (...arg: any[]) => {
-  const [obj, msg] = getLogParams(arg)
-  logger.error(obj, msg)
-}
-
-/**
- * custom trace impl - this resembles the node trace behaviour rather
- * than traditional trace logging
- * @param arg
- */
-console.trace = (...arg: any[]) => {
-  const [obj, msg] = getLogParams(arg)
-  if (!obj.err) {
-    // to get stack trace
-    obj.err = new Error()
-  }
-  logger.trace(obj, msg)
-}
-
-console.debug = (...arg: any) => {
-  const [obj, msg] = getLogParams(arg)
-  logger.debug(obj, msg)
-}
-
-// CONTEXT
-
-const getTenantId = () => {
-  let tenantId
-  try {
-    tenantId = context.getTenantId()
-  } catch (e: any) {
-    // do nothing
-  }
-  return tenantId
-}
-
-const getAppId = () => {
-  let appId
-  try {
-    appId = context.getAppId()
-  } catch (e) {
-    // do nothing
-  }
-  return appId
-}
-
-const getIdentity = () => {
-  let identity
-  try {
-    identity = context.getIdentity()
-  } catch (e) {
-    // do nothing
-  }
-  return identity
-}

package/src/logging/pino/middleware.ts

@@ -1,45 +0,0 @@
-import env from "../../environment"
-import { logger } from "./logger"
-import { IncomingMessage } from "http"
-const pino = require("koa-pino-logger")
-import { Options } from "pino-http"
-import { Ctx } from "@budibase/types"
-const correlator = require("correlation-id")
-
-export function pinoSettings(): Options {
-  return {
-    logger,
-    genReqId: correlator.getId,
-    autoLogging: {
-      ignore: (req: IncomingMessage) => !!req.url?.includes("/health"),
-    },
-    serializers: {
-      req: req => {
-        return {
-          method: req.method,
-          url: req.url,
-          correlationId: req.id,
-        }
-      },
-      res: res => {
-        return {
-          status: res.statusCode,
-        }
-      },
-    },
-  }
-}
-
-function getMiddleware() {
-  if (env.HTTP_LOGGING) {
-    return pino(pinoSettings())
-  } else {
-    return (ctx: Ctx, next: any) => {
-      return next()
-    }
-  }
-}
-
-const pinoMiddleware = getMiddleware()
-
-export default pinoMiddleware

package/src/plugin/tests/validation.spec.ts

@@ -1,83 +0,0 @@
-import { validate } from "../utils"
-import fetch from "node-fetch"
-import { PluginType } from "@budibase/types"
-
-const repoUrl =
-  "https://raw.githubusercontent.com/Budibase/budibase-skeleton/master"
-const automationLink = `${repoUrl}/automation/schema.json.hbs`
-const componentLink = `${repoUrl}/component/schema.json.hbs`
-const datasourceLink = `${repoUrl}/datasource/schema.json.hbs`
-
-async function getSchema(link: string) {
-  const response = await fetch(link)
-  if (response.status > 300) {
-    return
-  }
-  const text = await response.text()
-  return JSON.parse(text)
-}
-
-async function runTest(opts: { link?: string; schema?: any }) {
-  let error
-  try {
-    let schema = opts.schema
-    if (opts.link) {
-      schema = await getSchema(opts.link)
-    }
-    validate(schema)
-  } catch (err) {
-    error = err
-  }
-  return error
-}
-
-describe("it should be able to validate an automation schema", () => {
-  it("should return automation skeleton schema is valid", async () => {
-    const error = await runTest({ link: automationLink })
-    expect(error).toBeUndefined()
-  })
-
-  it("should fail given invalid automation schema", async () => {
-    const error = await runTest({
-      schema: {
-        type: PluginType.AUTOMATION,
-        schema: {},
-      },
-    })
-    expect(error).toBeDefined()
-  })
-})
-
-describe("it should be able to validate a component schema", () => {
-  it("should return component skeleton schema is valid", async () => {
-    const error = await runTest({ link: componentLink })
-    expect(error).toBeUndefined()
-  })
-
-  it("should fail given invalid component schema", async () => {
-    const error = await runTest({
-      schema: {
-        type: PluginType.COMPONENT,
-        schema: {},
-      },
-    })
-    expect(error).toBeDefined()
-  })
-})
-
-describe("it should be able to validate a datasource schema", () => {
-  it("should return datasource skeleton schema is valid", async () => {
-    const error = await runTest({ link: datasourceLink })
-    expect(error).toBeUndefined()
-  })
-
-  it("should fail given invalid datasource schema", async () => {
-    const error = await runTest({
-      schema: {
-        type: PluginType.DATASOURCE,
-        schema: {},
-      },
-    })
-    expect(error).toBeDefined()
-  })
-})

package/src/security/tests/encryption.spec.ts

@@ -1,31 +0,0 @@
-import { encrypt, decrypt, SecretOption, getSecret } from "../encryption"
-import env from "../../environment"
-
-describe("encryption", () => {
-  it("should throw an error if API encryption key is not set", () => {
-    const jwt = getSecret(SecretOption.API)
-    expect(jwt).toBe(env.JWT_SECRET)
-  })
-
-  it("should throw an error if encryption key is not set", () => {
-    expect(() => getSecret(SecretOption.ENCRYPTION)).toThrow(
-      'Secret "ENCRYPTION_KEY" has not been set in environment.'
-    )
-  })
-
-  it("should encrypt and decrypt a string using API encryption key", () => {
-    env._set("API_ENCRYPTION_KEY", "api_secret")
-    const plaintext = "budibase"
-    const apiEncrypted = encrypt(plaintext, SecretOption.API)
-    const decrypted = decrypt(apiEncrypted, SecretOption.API)
-    expect(decrypted).toEqual(plaintext)
-  })
-
-  it("should encrypt and decrypt a string using encryption key", () => {
-    env._set("ENCRYPTION_KEY", "normal_secret")
-    const plaintext = "budibase"
-    const encryptionEncrypted = encrypt(plaintext, SecretOption.ENCRYPTION)
-    const decrypted = decrypt(encryptionEncrypted, SecretOption.ENCRYPTION)
-    expect(decrypted).toEqual(plaintext)
-  })
-})

package/src/security/tests/permissions.spec.ts

@@ -1,145 +0,0 @@
-import { cloneDeep } from "lodash"
-import * as permissions from "../permissions"
-import { BUILTIN_ROLE_IDS } from "../roles"
-
-describe("levelToNumber", () => {
-  it("should return 0 for EXECUTE", () => {
-    expect(permissions.levelToNumber(permissions.PermissionLevel.EXECUTE)).toBe(
-      0
-    )
-  })
-
-  it("should return 1 for READ", () => {
-    expect(permissions.levelToNumber(permissions.PermissionLevel.READ)).toBe(1)
-  })
-
-  it("should return 2 for WRITE", () => {
-    expect(permissions.levelToNumber(permissions.PermissionLevel.WRITE)).toBe(2)
-  })
-
-  it("should return 3 for ADMIN", () => {
-    expect(permissions.levelToNumber(permissions.PermissionLevel.ADMIN)).toBe(3)
-  })
-
-  it("should return -1 for an unknown permission level", () => {
-    expect(
-      permissions.levelToNumber("unknown" as permissions.PermissionLevel)
-    ).toBe(-1)
-  })
-})
-describe("getAllowedLevels", () => {
-  it('should return ["execute"] for EXECUTE', () => {
-    expect(
-      permissions.getAllowedLevels(permissions.PermissionLevel.EXECUTE)
-    ).toEqual([permissions.PermissionLevel.EXECUTE])
-  })
-
-  it('should return ["execute", "read"] for READ', () => {
-    expect(
-      permissions.getAllowedLevels(permissions.PermissionLevel.READ)
-    ).toEqual([
-      permissions.PermissionLevel.EXECUTE,
-      permissions.PermissionLevel.READ,
-    ])
-  })
-
-  it('should return ["execute", "read", "write"] for WRITE', () => {
-    expect(
-      permissions.getAllowedLevels(permissions.PermissionLevel.WRITE)
-    ).toEqual([
-      permissions.PermissionLevel.EXECUTE,
-      permissions.PermissionLevel.READ,
-      permissions.PermissionLevel.WRITE,
-    ])
-  })
-
-  it('should return ["execute", "read", "write"] for ADMIN', () => {
-    expect(
-      permissions.getAllowedLevels(permissions.PermissionLevel.ADMIN)
-    ).toEqual([
-      permissions.PermissionLevel.EXECUTE,
-      permissions.PermissionLevel.READ,
-      permissions.PermissionLevel.WRITE,
-    ])
-  })
-
-  it("should return [] for an unknown permission level", () => {
-    expect(
-      permissions.getAllowedLevels("unknown" as permissions.PermissionLevel)
-    ).toEqual([])
-  })
-})
-
-describe("doesHaveBasePermission", () => {
-  it("should return true if base permission has the required level", () => {
-    const permType = permissions.PermissionType.USER
-    const permLevel = permissions.PermissionLevel.READ
-    const rolesHierarchy = [
-      {
-        roleId: BUILTIN_ROLE_IDS.ADMIN,
-        permissionId: permissions.BuiltinPermissionID.ADMIN,
-      },
-    ]
-    expect(
-      permissions.doesHaveBasePermission(permType, permLevel, rolesHierarchy)
-    ).toBe(true)
-  })
-
-  it("should return false if base permission does not have the required level", () => {
-    const permType = permissions.PermissionType.APP
-    const permLevel = permissions.PermissionLevel.READ
-    const rolesHierarchy = [
-      {
-        roleId: BUILTIN_ROLE_IDS.PUBLIC,
-        permissionId: permissions.BuiltinPermissionID.PUBLIC,
-      },
-    ]
-    expect(
-      permissions.doesHaveBasePermission(permType, permLevel, rolesHierarchy)
-    ).toBe(false)
-  })
-})
-
-describe("isPermissionLevelHigherThanRead", () => {
-  it("should return true if level is higher than read", () => {
-    expect(
-      permissions.isPermissionLevelHigherThanRead(
-        permissions.PermissionLevel.WRITE
-      )
-    ).toBe(true)
-  })
-
-  it("should return false if level is read or lower", () => {
-    expect(
-      permissions.isPermissionLevelHigherThanRead(
-        permissions.PermissionLevel.READ
-      )
-    ).toBe(false)
-  })
-})
-
-describe("getBuiltinPermissions", () => {
-  it("returns a clone of the builtin permissions", () => {
-    const builtins = permissions.getBuiltinPermissions()
-    expect(builtins).toEqual(cloneDeep(permissions.BUILTIN_PERMISSIONS))
-    expect(builtins).not.toBe(permissions.BUILTIN_PERMISSIONS)
-  })
-})
-
-describe("getBuiltinPermissionByID", () => {
-  it("returns correct permission object for valid ID", () => {
-    const expectedPermission = {
-      _id: permissions.BuiltinPermissionID.PUBLIC,
-      name: "Public",
-      permissions: [
-        new permissions.Permission(
-          permissions.PermissionType.WEBHOOK,
-          permissions.PermissionLevel.EXECUTE
-        ),
-      ],
-    }
-    expect(permissions.getBuiltinPermissionByID("public")).toEqual(
-      expectedPermission
-    )
-  })
-})