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

package/src/context/tests/index.spec.ts

@@ -1,147 +0,0 @@
-import { testEnv } from "../../../tests/extra"
-import * as context from "../"
-import { DEFAULT_TENANT_ID } from "../../constants"
-
-describe("context", () => {
-  describe("doInTenant", () => {
-    describe("single-tenancy", () => {
-      beforeAll(() => {
-        testEnv.singleTenant()
-      })
-
-      it("defaults to the default tenant", () => {
-        const tenantId = context.getTenantId()
-        expect(tenantId).toBe(DEFAULT_TENANT_ID)
-      })
-
-      it("defaults to the default tenant db", async () => {
-        await context.doInTenant(DEFAULT_TENANT_ID, () => {
-          const db = context.getGlobalDB()
-          expect(db.name).toBe("global-db")
-        })
-      })
-    })
-
-    describe("multi-tenancy", () => {
-      beforeAll(() => {
-        testEnv.multiTenant()
-      })
-
-      it("fails when no tenant id is set", () => {
-        const test = () => {
-          let error: any
-          try {
-            context.getTenantId()
-          } catch (e) {
-            error = e
-          }
-          expect(error.message).toBe("Tenant id not found")
-        }
-
-        // test under no tenancy
-        test()
-
-        // test after tenancy has been accessed to ensure cleanup
-        context.doInTenant("test", () => {})
-        test()
-      })
-
-      it("fails when no tenant db is set", () => {
-        const test = () => {
-          let error: any
-          try {
-            context.getGlobalDB()
-          } catch (e) {
-            error = e
-          }
-          expect(error.message).toBe("Global DB not found")
-        }
-
-        // test under no tenancy
-        test()
-
-        // test after tenancy has been accessed to ensure cleanup
-        context.doInTenant("test", () => {})
-        test()
-      })
-
-      it("sets tenant id", () => {
-        context.doInTenant("test", () => {
-          const tenantId = context.getTenantId()
-          expect(tenantId).toBe("test")
-        })
-      })
-
-      it("initialises the tenant db", async () => {
-        await context.doInTenant("test", () => {
-          const db = context.getGlobalDB()
-          expect(db.name).toBe("test_global-db")
-        })
-      })
-
-      it("sets the tenant id when nested with same tenant id", async () => {
-        await context.doInTenant("test", async () => {
-          const tenantId = context.getTenantId()
-          expect(tenantId).toBe("test")
-
-          await context.doInTenant("test", async () => {
-            const tenantId = context.getTenantId()
-            expect(tenantId).toBe("test")
-
-            await context.doInTenant("test", () => {
-              const tenantId = context.getTenantId()
-              expect(tenantId).toBe("test")
-            })
-          })
-        })
-      })
-
-      it("initialises the tenant db when nested with same tenant id", async () => {
-        await context.doInTenant("test", async () => {
-          const db = context.getGlobalDB()
-          expect(db.name).toBe("test_global-db")
-
-          await context.doInTenant("test", async () => {
-            const db = context.getGlobalDB()
-            expect(db.name).toBe("test_global-db")
-
-            await context.doInTenant("test", () => {
-              const db = context.getGlobalDB()
-              expect(db.name).toBe("test_global-db")
-            })
-          })
-        })
-      })
-
-      it("sets different tenant id inside another context", () => {
-        context.doInTenant("test", () => {
-          const tenantId = context.getTenantId()
-          expect(tenantId).toBe("test")
-
-          context.doInTenant("nested", () => {
-            const tenantId = context.getTenantId()
-            expect(tenantId).toBe("nested")
-
-            context.doInTenant("double-nested", () => {
-              const tenantId = context.getTenantId()
-              expect(tenantId).toBe("double-nested")
-            })
-          })
-        })
-      })
-    })
-  })
-
-  describe("doInScimContext", () => {
-    it("returns true when set", () => {
-      context.doInScimContext(() => {
-        const isScim = context.isScim()
-        expect(isScim).toBe(true)
-      })
-    })
-    it("returns false when not set", () => {
-      const isScim = context.isScim()
-      expect(isScim).toBe(false)
-    })
-  })
-})

package/src/context/types.ts

@@ -1,11 +0,0 @@
-import { IdentityContext } from "@budibase/types"
-
-// keep this out of Budibase types, don't want to expose context info
-export type ContextMap = {
-  tenantId?: string
-  appId?: string
-  identity?: IdentityContext
-  environmentVariables?: Record<string, string>
-  isScim?: boolean
-  automationId?: string
-}

package/src/db/Replication.ts

@@ -1,84 +0,0 @@
-import { getPouchDB, closePouchDB } from "./couch"
-import { DocumentType } from "../constants"
-
-class Replication {
-  source: any
-  target: any
-  replication: any
-
-  /**
-   *
-   * @param {String} source - the DB you want to replicate or rollback to
-   * @param {String} target - the DB you want to replicate to, or rollback from
-   */
-  constructor({ source, target }: any) {
-    this.source = getPouchDB(source)
-    this.target = getPouchDB(target)
-  }
-
-  close() {
-    return Promise.all([closePouchDB(this.source), closePouchDB(this.target)])
-  }
-
-  promisify(operation: any, opts = {}) {
-    return new Promise(resolve => {
-      operation(this.target, opts)
-        .on("denied", function (err: any) {
-          // a document failed to replicate (e.g. due to permissions)
-          throw new Error(`Denied: Document failed to replicate ${err}`)
-        })
-        .on("complete", function (info: any) {
-          return resolve(info)
-        })
-        .on("error", function (err: any) {
-          throw new Error(`Replication Error: ${err}`)
-        })
-    })
-  }
-
-  /**
-   * Two way replication operation, intended to be promise based.
-   * @param {Object} opts - PouchDB replication options
-   */
-  sync(opts = {}) {
-    this.replication = this.promisify(this.source.sync, opts)
-    return this.replication
-  }
-
-  /**
-   * One way replication operation, intended to be promise based.
-   * @param {Object} opts - PouchDB replication options
-   */
-  replicate(opts = {}) {
-    this.replication = this.promisify(this.source.replicate.to, opts)
-    return this.replication
-  }
-
-  appReplicateOpts() {
-    return {
-      filter: (doc: any) => {
-        if (doc._id && doc._id.startsWith(DocumentType.AUTOMATION_LOG)) {
-          return false
-        }
-        return doc._id !== DocumentType.APP_METADATA
-      },
-    }
-  }
-
-  /**
-   * Rollback the target DB back to the state of the source DB
-   */
-  async rollback() {
-    await this.target.destroy()
-    // Recreate the DB again
-    this.target = getPouchDB(this.target.name)
-    // take the opportunity to remove deleted tombstones
-    await this.replicate()
-  }
-
-  cancel() {
-    this.replication.cancel()
-  }
-}
-
-export default Replication

package/src/db/constants.ts

@@ -1,10 +0,0 @@
-export const CONSTANT_INTERNAL_ROW_COLS = [
-  "_id",
-  "_rev",
-  "type",
-  "createdAt",
-  "updatedAt",
-  "tableId",
-] as const
-
-export const CONSTANT_EXTERNAL_ROW_COLS = ["_id", "_rev", "tableId"] as const

package/src/db/couch/DatabaseImpl.ts

@@ -1,238 +0,0 @@
-import Nano from "@budibase/nano"
-import {
-  AllDocsResponse,
-  AnyDocument,
-  Database,
-  DatabaseOpts,
-  DatabaseQueryOpts,
-  DatabasePutOpts,
-  DatabaseCreateIndexOpts,
-  DatabaseDeleteIndexOpts,
-  Document,
-  isDocument,
-} from "@budibase/types"
-import { getCouchInfo } from "./connections"
-import { directCouchUrlCall } from "./utils"
-import { getPouchDB } from "./pouchDB"
-import { WriteStream, ReadStream } from "fs"
-import { newid } from "../../docIds/newid"
-
-function buildNano(couchInfo: { url: string; cookie: string }) {
-  return Nano({
-    url: couchInfo.url,
-    requestDefaults: {
-      headers: {
-        Authorization: couchInfo.cookie,
-      },
-    },
-    parseUrl: false,
-  })
-}
-
-export function DatabaseWithConnection(
-  dbName: string,
-  connection: string,
-  opts?: DatabaseOpts
-) {
-  if (!connection) {
-    throw new Error("Must provide connection details")
-  }
-  return new DatabaseImpl(dbName, opts, connection)
-}
-
-export class DatabaseImpl implements Database {
-  public readonly name: string
-  private static nano: Nano.ServerScope
-  private readonly instanceNano?: Nano.ServerScope
-  private readonly pouchOpts: DatabaseOpts
-
-  private readonly couchInfo = getCouchInfo()
-
-  constructor(dbName?: string, opts?: DatabaseOpts, connection?: string) {
-    if (dbName == null) {
-      throw new Error("Database name cannot be undefined.")
-    }
-    this.name = dbName
-    this.pouchOpts = opts || {}
-    if (connection) {
-      this.couchInfo = getCouchInfo(connection)
-      this.instanceNano = buildNano(this.couchInfo)
-    }
-    if (!DatabaseImpl.nano) {
-      DatabaseImpl.init()
-    }
-  }
-
-  static init() {
-    const couchInfo = getCouchInfo()
-    DatabaseImpl.nano = buildNano(couchInfo)
-  }
-
-  async exists() {
-    const response = await directCouchUrlCall({
-      url: `${this.couchInfo.url}/${this.name}`,
-      method: "HEAD",
-      cookie: this.couchInfo.cookie,
-    })
-    return response.status === 200
-  }
-
-  private nano() {
-    return this.instanceNano || DatabaseImpl.nano
-  }
-
-  async checkSetup() {
-    let shouldCreate = !this.pouchOpts?.skip_setup
-    // check exists in a lightweight fashion
-    let exists = await this.exists()
-    if (!shouldCreate && !exists) {
-      throw new Error("DB does not exist")
-    }
-    if (!exists) {
-      try {
-        await this.nano().db.create(this.name)
-      } catch (err: any) {
-        // Handling race conditions
-        if (err.statusCode !== 412) {
-          throw err
-        }
-      }
-    }
-    return this.nano().db.use(this.name)
-  }
-
-  private async updateOutput(fnc: any) {
-    try {
-      return await fnc()
-    } catch (err: any) {
-      if (err.statusCode) {
-        err.status = err.statusCode
-      }
-      throw err
-    }
-  }
-
-  async get<T>(id?: string): Promise<T | any> {
-    const db = await this.checkSetup()
-    if (!id) {
-      throw new Error("Unable to get doc without a valid _id.")
-    }
-    return this.updateOutput(() => db.get(id))
-  }
-
-  async remove(idOrDoc: string | Document, rev?: string) {
-    const db = await this.checkSetup()
-    let _id: string
-    let _rev: string
-
-    if (isDocument(idOrDoc)) {
-      _id = idOrDoc._id!
-      _rev = idOrDoc._rev!
-    } else {
-      _id = idOrDoc
-      _rev = rev!
-    }
-
-    if (!_id || !_rev) {
-      throw new Error("Unable to remove doc without a valid _id and _rev.")
-    }
-    return this.updateOutput(() => db.destroy(_id, _rev))
-  }
-
-  async post(document: AnyDocument, opts?: DatabasePutOpts) {
-    if (!document._id) {
-      document._id = newid()
-    }
-    return this.put(document, opts)
-  }
-
-  async put(document: AnyDocument, opts?: DatabasePutOpts) {
-    if (!document._id) {
-      throw new Error("Cannot store document without _id field.")
-    }
-    const db = await this.checkSetup()
-    if (!document.createdAt) {
-      document.createdAt = new Date().toISOString()
-    }
-    document.updatedAt = new Date().toISOString()
-    if (opts?.force && document._id) {
-      try {
-        const existing = await this.get(document._id)
-        if (existing) {
-          document._rev = existing._rev
-        }
-      } catch (err: any) {
-        if (err.status !== 404) {
-          throw err
-        }
-      }
-    }
-    return this.updateOutput(() => db.insert(document))
-  }
-
-  async bulkDocs(documents: AnyDocument[]) {
-    const db = await this.checkSetup()
-    return this.updateOutput(() => db.bulk({ docs: documents }))
-  }
-
-  async allDocs<T>(params: DatabaseQueryOpts): Promise<AllDocsResponse<T>> {
-    const db = await this.checkSetup()
-    return this.updateOutput(() => db.list(params))
-  }
-
-  async query<T>(
-    viewName: string,
-    params: DatabaseQueryOpts
-  ): Promise<AllDocsResponse<T>> {
-    const db = await this.checkSetup()
-    const [database, view] = viewName.split("/")
-    return this.updateOutput(() => db.view(database, view, params))
-  }
-
-  async destroy() {
-    try {
-      return await this.nano().db.destroy(this.name)
-    } catch (err: any) {
-      // didn't exist, don't worry
-      if (err.statusCode === 404) {
-        return
-      } else {
-        throw { ...err, status: err.statusCode }
-      }
-    }
-  }
-
-  async compact() {
-    const db = await this.checkSetup()
-    return this.updateOutput(() => db.compact())
-  }
-
-  // All below functions are in-frequently called, just utilise PouchDB
-  // for them as it implements them better than we can
-  async dump(stream: WriteStream, opts?: { filter?: any }) {
-    const pouch = getPouchDB(this.name)
-    // @ts-ignore
-    return pouch.dump(stream, opts)
-  }
-
-  async load(stream: ReadStream) {
-    const pouch = getPouchDB(this.name)
-    // @ts-ignore
-    return pouch.load(stream)
-  }
-
-  async createIndex(opts: DatabaseCreateIndexOpts) {
-    const pouch = getPouchDB(this.name)
-    return pouch.createIndex(opts)
-  }
-
-  async deleteIndex(opts: DatabaseDeleteIndexOpts) {
-    const pouch = getPouchDB(this.name)
-    return pouch.deleteIndex(opts)
-  }
-
-  async getIndexes() {
-    const pouch = getPouchDB(this.name)
-    return pouch.getIndexes()
-  }
-}

package/src/db/couch/connections.ts

@@ -1,77 +0,0 @@
-import env from "../../environment"
-
-export const getCouchInfo = (connection?: string) => {
-  const urlInfo = getUrlInfo(connection)
-  let username
-  let password
-  if (urlInfo.auth?.username) {
-    // set from url
-    username = urlInfo.auth.username
-  } else if (env.COUCH_DB_USERNAME) {
-    // set from env
-    username = env.COUCH_DB_USERNAME
-  } else if (!env.isTest()) {
-    throw new Error("CouchDB username not set")
-  }
-  if (urlInfo.auth?.password) {
-    // set from url
-    password = urlInfo.auth.password
-  } else if (env.COUCH_DB_PASSWORD) {
-    // set from env
-    password = env.COUCH_DB_PASSWORD
-  } else if (!env.isTest()) {
-    throw new Error("CouchDB password not set")
-  }
-  const authCookie = Buffer.from(`${username}:${password}`).toString("base64")
-  return {
-    url: urlInfo.url!,
-    auth: {
-      username: username,
-      password: password,
-    },
-    cookie: `Basic ${authCookie}`,
-  }
-}
-
-export const getUrlInfo = (url = env.COUCH_DB_URL) => {
-  let cleanUrl, username, password, host
-  if (url) {
-    // Ensure the URL starts with a protocol
-    const protoRegex = /^https?:\/\//i
-    if (!protoRegex.test(url)) {
-      url = `http://${url}`
-    }
-
-    // Split into protocol and remainder
-    const split = url.split("://")
-    const protocol = split[0]
-    const rest = split.slice(1).join("://")
-
-    // Extract auth if specified
-    if (url.includes("@")) {
-      // Split into host and remainder
-      let parts = rest.split("@")
-      host = parts[parts.length - 1]
-      let auth = parts.slice(0, -1).join("@")
-
-      // Split auth into username and password
-      if (auth.includes(":")) {
-        const authParts = auth.split(":")
-        username = authParts[0]
-        password = authParts.slice(1).join(":")
-      } else {
-        username = auth
-      }
-    } else {
-      host = rest
-    }
-    cleanUrl = `${protocol}://${host}`
-  }
-  return {
-    url: cleanUrl,
-    auth: {
-      username,
-      password,
-    },
-  }
-}

package/src/db/couch/index.ts

@@ -1,5 +0,0 @@
-export * from "./connections"
-export * from "./DatabaseImpl"
-export * from "./utils"
-export { init, getPouch, getPouchDB, closePouchDB } from "./pouchDB"
-export * from "../constants"

package/src/db/couch/pouchDB.ts

@@ -1,97 +0,0 @@
-import PouchDB from "pouchdb"
-import env from "../../environment"
-import { PouchOptions } from "@budibase/types"
-import { getCouchInfo } from "./connections"
-
-let Pouch: any
-let initialised = false
-
-/**
- * Return a constructor for PouchDB.
- * This should be rarely used outside of the main application config.
- * Exposed for exceptional cases such as in-memory views.
- */
-export const getPouch = (opts: PouchOptions = {}) => {
-  let { url, cookie } = getCouchInfo()
-  let POUCH_DB_DEFAULTS = {
-    prefix: url,
-    fetch: (url: string, opts: any) => {
-      // use a specific authorization cookie - be very explicit about how we authenticate
-      opts.headers.set("Authorization", cookie)
-      return PouchDB.fetch(url, opts)
-    },
-  }
-
-  if (opts.inMemory) {
-    const inMemory = require("pouchdb-adapter-memory")
-    PouchDB.plugin(inMemory)
-    POUCH_DB_DEFAULTS = {
-      // @ts-ignore
-      adapter: "memory",
-    }
-  }
-
-  if (opts.onDisk) {
-    POUCH_DB_DEFAULTS = {
-      // @ts-ignore
-      adapter: "leveldb",
-    }
-  }
-
-  if (opts.replication) {
-    const replicationStream = require("@budibase/pouchdb-replication-stream")
-    PouchDB.plugin(replicationStream.plugin)
-    // @ts-ignore
-    PouchDB.adapter("writableStream", replicationStream.adapters.writableStream)
-  }
-
-  if (opts.find) {
-    const find = require("pouchdb-find")
-    PouchDB.plugin(find)
-  }
-
-  return PouchDB.defaults(POUCH_DB_DEFAULTS)
-}
-
-export function init(opts?: PouchOptions) {
-  Pouch = getPouch(opts)
-  initialised = true
-}
-
-const checkInitialised = () => {
-  if (!initialised) {
-    throw new Error("init has not been called")
-  }
-}
-
-export function getPouchDB(dbName: string, opts?: any): PouchDB.Database {
-  checkInitialised()
-  const db = new Pouch(dbName, opts)
-  const dbPut = db.put
-  db.put = async (doc: any, options = {}) => {
-    if (!doc.createdAt) {
-      doc.createdAt = new Date().toISOString()
-    }
-    doc.updatedAt = new Date().toISOString()
-    return dbPut(doc, options)
-  }
-  db.exists = async () => {
-    const info = await db.info()
-    return !info.error
-  }
-  return db
-}
-
-// use this function if you have called getPouchDB - close
-// the databases you've opened once finished
-export async function closePouchDB(db: PouchDB.Database) {
-  if (!db || env.isTest()) {
-    return
-  }
-  try {
-    // specifically await so that if there is an error, it can be ignored
-    return await db.close()
-  } catch (err) {
-    // ignore error, already closed
-  }
-}