@budibase/backend-core 3.2.4 → 3.2.6

package/src/docIds/params.ts

@@ -1,189 +0,0 @@
-import {
-  DocumentType,
-  InternalTable,
-  SEPARATOR,
-  UNICODE_MAX,
-  ViewName,
-} from "../constants"
-import { getProdAppID } from "./conversions"
-import { DatabaseQueryOpts, VirtualDocumentType } from "@budibase/types"
-
-/**
- * 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 docType The type of document which input params are being built for, e.g. user,
- * link, app, table and so on.
- * @param docId The ID of the document minus its type - this is only needed if looking
- * for a singular document.
- * @param otherProps Add any other properties onto the request, e.g. include_docs.
- * @returns Parameters which can then be used with an allDocs request.
- */
-export function getDocParams(
-  docType: string,
-  docId?: string | null,
-  otherProps: Partial<DatabaseQueryOpts> = {}
-): DatabaseQueryOpts {
-  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 tableId The table in which the rows have been stored.
- * @param 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 otherProps Any other properties to add to the request.
- * @returns Parameters which can then be used with an allDocs request.
- */
-export function getRowParams(
-  tableId?: string | null,
-  rowId?: string | null,
-  otherProps: Partial<DatabaseQueryOpts> = {}
-): DatabaseQueryOpts {
-  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.
- */
-export const isTableId = (id: string): boolean => {
-  // this includes datasource plus tables
-  return (
-    !!id &&
-    (id.startsWith(`${DocumentType.TABLE}${SEPARATOR}`) ||
-      id.startsWith(`${DocumentType.DATASOURCE_PLUS}${SEPARATOR}`))
-  )
-}
-
-export function isViewId(id: string): boolean {
-  return !!id && id.startsWith(`${VirtualDocumentType.VIEW}${SEPARATOR}`)
-}
-
-/**
- * Check if a given ID is that of a datasource or datasource plus.
- */
-export const isDatasourceId = (id: string): boolean => {
-  // this covers both datasources and datasource plus
-  return !!id && id.startsWith(`${DocumentType.DATASOURCE}${SEPARATOR}`)
-}
-
-/**
- * Gets parameters for retrieving workspaces.
- */
-export function getWorkspaceParams(
-  id = "",
-  otherProps: Partial<DatabaseQueryOpts> = {}
-): DatabaseQueryOpts {
-  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: Partial<DatabaseQueryOpts> = {}
-): DatabaseQueryOpts {
-  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: Partial<DatabaseQueryOpts> = {}
-): DatabaseQueryOpts {
-  return getRowParams(InternalTable.USER_METADATA, userId, otherProps)
-}
-
-export function getUsersByAppParams(
-  appId: any,
-  otherProps: Partial<DatabaseQueryOpts> = {}
-): DatabaseQueryOpts {
-  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,24 +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 } = job.data
-      await documentProcessor.processEvent(event, identity, properties)
-    })
-  }
-}

package/src/environment.ts

@@ -1,293 +0,0 @@
-import { existsSync, readFileSync } from "fs"
-import { ServiceType } from "@budibase/types"
-import { cloneDeep } from "lodash"
-import { createSecretKey } from "crypto"
-
-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
-    ? createSecretKey(Buffer.from(process.env.JWT_SECRET))
-    : undefined,
-  JWT_SECRET_FALLBACK: process.env.JWT_SECRET_FALLBACK
-    ? createSecretKey(Buffer.from(process.env.JWT_SECRET_FALLBACK))
-    : undefined,
-  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",
-  DISABLE_CONTENT_SECURITY_POLICY: process.env.DISABLE_CONTENT_SECURITY_POLICY,
-}
-
-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

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()
-  }
-}