@budibase/backend-core 3.2.4 → 3.2.6

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

package/src/db/couch/tests/DatabaseImpl.spec.ts

@@ -1,118 +0,0 @@
-import tk from "timekeeper"
-
-import { DatabaseImpl } from ".."
-
-import { generator, structures } from "../../../../tests"
-
-const initialTime = new Date()
-tk.freeze(initialTime)
-
-describe("DatabaseImpl", () => {
-  const db = new DatabaseImpl(structures.db.id())
-
-  beforeEach(() => {
-    tk.freeze(initialTime)
-  })
-
-  describe("put", () => {
-    it("persists createdAt and updatedAt fields", async () => {
-      const id = generator.guid()
-      await db.put({ _id: id })
-
-      expect(await db.get(id)).toEqual({
-        _id: id,
-        _rev: expect.any(String),
-        createdAt: initialTime.toISOString(),
-        updatedAt: initialTime.toISOString(),
-      })
-    })
-
-    it("updates updated at fields", async () => {
-      const id = generator.guid()
-
-      await db.put({ _id: id })
-      tk.travel(100)
-
-      await db.put({ ...(await db.get(id)), newValue: 123 })
-
-      expect(await db.get(id)).toEqual({
-        _id: id,
-        _rev: expect.any(String),
-        newValue: 123,
-        createdAt: initialTime.toISOString(),
-        updatedAt: new Date().toISOString(),
-      })
-    })
-  })
-
-  describe("bulkDocs", () => {
-    it("persists createdAt and updatedAt fields", async () => {
-      const ids = generator.unique(() => generator.guid(), 5)
-      await db.bulkDocs(ids.map(id => ({ _id: id })))
-
-      for (const id of ids) {
-        expect(await db.get(id)).toEqual({
-          _id: id,
-          _rev: expect.any(String),
-          createdAt: initialTime.toISOString(),
-          updatedAt: initialTime.toISOString(),
-        })
-      }
-    })
-
-    it("updates updated at fields", async () => {
-      const ids = generator.unique(() => generator.guid(), 5)
-
-      await db.bulkDocs(ids.map(id => ({ _id: id })))
-      tk.travel(100)
-
-      const docsToUpdate = await Promise.all(
-        ids.map(async id => ({ ...(await db.get(id)), newValue: 123 }))
-      )
-      await db.bulkDocs(docsToUpdate)
-
-      for (const id of ids) {
-        expect(await db.get(id)).toEqual({
-          _id: id,
-          _rev: expect.any(String),
-          newValue: 123,
-          createdAt: initialTime.toISOString(),
-          updatedAt: new Date().toISOString(),
-        })
-      }
-    })
-
-    it("keeps existing createdAt", async () => {
-      const ids = generator.unique(() => generator.guid(), 2)
-
-      await db.bulkDocs(ids.map(id => ({ _id: id })))
-      tk.travel(100)
-
-      const newDocs = generator
-        .unique(() => generator.guid(), 3)
-        .map(id => ({ _id: id }))
-      const docsToUpdate = await Promise.all(
-        ids.map(async id => ({ ...(await db.get(id)), newValue: 123 }))
-      )
-      await db.bulkDocs([...newDocs, ...docsToUpdate])
-
-      for (const { _id } of docsToUpdate) {
-        expect(await db.get(_id)).toEqual({
-          _id,
-          _rev: expect.any(String),
-          newValue: 123,
-          createdAt: initialTime.toISOString(),
-          updatedAt: new Date().toISOString(),
-        })
-      }
-      for (const { _id } of newDocs) {
-        expect(await db.get(_id)).toEqual({
-          _id,
-          _rev: expect.any(String),
-          createdAt: new Date().toISOString(),
-          updatedAt: new Date().toISOString(),
-        })
-      }
-    })
-  })
-})

package/src/db/couch/utils.ts

@@ -1,55 +0,0 @@
-import { getCouchInfo } from "./connections"
-import fetch from "node-fetch"
-import { checkSlashesInUrl } from "../../helpers"
-
-export async function directCouchCall(
-  path: string,
-  method: string = "GET",
-  body?: any
-) {
-  let { url, cookie } = getCouchInfo()
-  const couchUrl = `${url}/${path}`
-  return await directCouchUrlCall({ url: couchUrl, cookie, method, body })
-}
-
-export async function directCouchUrlCall({
-  url,
-  cookie,
-  method,
-  body,
-}: {
-  url: string
-  cookie: string
-  method: string
-  body?: Record<string, any>
-}) {
-  const params: any = {
-    method: method,
-    headers: {
-      Authorization: cookie,
-    },
-  }
-  if (body && method !== "GET") {
-    if (typeof body === "string") {
-      params.body = body
-      params.headers["Content-Type"] = "text/plain"
-    } else {
-      params.body = JSON.stringify(body)
-      params.headers["Content-Type"] = "application/json"
-    }
-  }
-  return await fetch(checkSlashesInUrl(encodeURI(url)), params)
-}
-
-export async function directCouchQuery(
-  path: string,
-  method: string = "GET",
-  body?: any
-) {
-  const response = await directCouchCall(path, method, body)
-  if (response.status < 300) {
-    return await response.json()
-  } else {
-    throw "Cannot connect to CouchDB instance"
-  }
-}

package/src/db/db.ts

@@ -1,34 +0,0 @@
-import { directCouchQuery, DatabaseImpl } from "./couch"
-import { CouchFindOptions, Database, DatabaseOpts } from "@budibase/types"
-import { DDInstrumentedDatabase } from "./instrumentation"
-
-export function getDB(dbName: string, opts?: DatabaseOpts): Database {
-  return new DDInstrumentedDatabase(new DatabaseImpl(dbName, opts))
-}
-
-// we have to use a callback for this so that we can close
-// the DB when we're done, without this manual requests would
-// need to close the database when done with it to avoid memory leaks
-export async function doWithDB<T>(
-  dbName: string,
-  cb: (db: Database) => Promise<T>,
-  opts?: DatabaseOpts
-) {
-  const db = getDB(dbName, opts)
-  // need this to be async so that we can correctly close DB after all
-  // async operations have been completed
-  return await cb(db)
-}
-
-export async function directCouchAllDbs(queryString?: string) {
-  let couchPath = "/_all_dbs"
-  if (queryString) {
-    couchPath += `?${queryString}`
-  }
-  return await directCouchQuery(couchPath)
-}
-
-export async function directCouchFind(dbName: string, opts: CouchFindOptions) {
-  const json = await directCouchQuery(`${dbName}/_find`, "POST", opts)
-  return { rows: json.docs, bookmark: json.bookmark }
-}

package/src/db/errors.ts

@@ -1,14 +0,0 @@
-export function checkErrorCode(error: any, code: number) {
-  const stringCode = code.toString()
-  if (typeof error === "object") {
-    return error.status === code || error.message?.includes(stringCode)
-  } else if (typeof error === "number") {
-    return error === code
-  } else if (typeof error === "string") {
-    return error.includes(stringCode)
-  }
-}
-
-export function isDocumentConflictError(error: any) {
-  return checkErrorCode(error, 409)
-}

package/src/db/index.ts

@@ -1,12 +0,0 @@
-export * from "./couch"
-export * from "./db"
-export * from "./utils"
-export * from "./views"
-export * from "../docIds/conversions"
-export { default as Replication } from "./Replication"
-// exports to support old export structure
-export * from "../constants/db"
-export { getGlobalDBName, baseGlobalDBName } from "../context"
-export * from "./lucene"
-export * as searchIndexes from "./searchIndexes"
-export * from "./errors"

package/src/db/instrumentation.ts

@@ -1,199 +0,0 @@
-import {
-  DocumentDestroyResponse,
-  DocumentInsertResponse,
-  DocumentBulkResponse,
-  OkResponse,
-} from "@budibase/nano"
-import {
-  AllDocsResponse,
-  AnyDocument,
-  Database,
-  DatabaseDumpOpts,
-  DatabasePutOpts,
-  DatabaseQueryOpts,
-  Document,
-  RowValue,
-  SqlQueryBinding,
-} from "@budibase/types"
-import tracer from "dd-trace"
-import { Writable } from "stream"
-
-export class DDInstrumentedDatabase implements Database {
-  constructor(private readonly db: Database) {}
-
-  get name(): string {
-    return this.db.name
-  }
-
-  exists(docId?: string): Promise<boolean> {
-    return tracer.trace("db.exists", span => {
-      span?.addTags({ db_name: this.name, doc_id: docId })
-      if (docId) {
-        return this.db.exists(docId)
-      }
-      return this.db.exists()
-    })
-  }
-
-  get<T extends Document>(id?: string | undefined): Promise<T> {
-    return tracer.trace("db.get", span => {
-      span?.addTags({ db_name: this.name, doc_id: id })
-      return this.db.get(id)
-    })
-  }
-
-  tryGet<T extends Document>(id?: string | undefined): Promise<T | undefined> {
-    return tracer.trace("db.tryGet", span => {
-      span?.addTags({ db_name: this.name, doc_id: id })
-      return this.db.tryGet(id)
-    })
-  }
-
-  getMultiple<T extends Document>(
-    ids: string[],
-    opts?: { allowMissing?: boolean | undefined } | undefined
-  ): Promise<T[]> {
-    return tracer.trace("db.getMultiple", span => {
-      span?.addTags({
-        db_name: this.name,
-        num_docs: ids.length,
-        allow_missing: opts?.allowMissing,
-      })
-      return this.db.getMultiple(ids, opts)
-    })
-  }
-
-  remove(idOrDoc: Document): Promise<DocumentDestroyResponse>
-  remove(idOrDoc: string, rev?: string): Promise<DocumentDestroyResponse>
-  remove(
-    idOrDoc: string | Document,
-    rev?: string
-  ): Promise<DocumentDestroyResponse> {
-    return tracer.trace("db.remove", span => {
-      span?.addTags({ db_name: this.name, doc_id: idOrDoc })
-      const isDocument = typeof idOrDoc === "object"
-      const id = isDocument ? idOrDoc._id! : idOrDoc
-      rev = isDocument ? idOrDoc._rev : rev
-      return this.db.remove(id, rev)
-    })
-  }
-
-  bulkRemove(
-    documents: Document[],
-    opts?: { silenceErrors?: boolean }
-  ): Promise<void> {
-    return tracer.trace("db.bulkRemove", span => {
-      span?.addTags({ db_name: this.name, num_docs: documents.length })
-      return this.db.bulkRemove(documents, opts)
-    })
-  }
-
-  put(
-    document: AnyDocument,
-    opts?: DatabasePutOpts | undefined
-  ): Promise<DocumentInsertResponse> {
-    return tracer.trace("db.put", span => {
-      span?.addTags({ db_name: this.name, doc_id: document._id })
-      return this.db.put(document, opts)
-    })
-  }
-
-  bulkDocs(documents: AnyDocument[]): Promise<DocumentBulkResponse[]> {
-    return tracer.trace("db.bulkDocs", span => {
-      span?.addTags({ db_name: this.name, num_docs: documents.length })
-      return this.db.bulkDocs(documents)
-    })
-  }
-
-  allDocs<T extends Document | RowValue>(
-    params: DatabaseQueryOpts
-  ): Promise<AllDocsResponse<T>> {
-    return tracer.trace("db.allDocs", span => {
-      span?.addTags({ db_name: this.name })
-      return this.db.allDocs(params)
-    })
-  }
-
-  query<T extends Document>(
-    viewName: string,
-    params: DatabaseQueryOpts
-  ): Promise<AllDocsResponse<T>> {
-    return tracer.trace("db.query", span => {
-      span?.addTags({ db_name: this.name, view_name: viewName })
-      return this.db.query(viewName, params)
-    })
-  }
-
-  destroy(): Promise<void | OkResponse> {
-    return tracer.trace("db.destroy", span => {
-      span?.addTags({ db_name: this.name })
-      return this.db.destroy()
-    })
-  }
-
-  compact(): Promise<void | OkResponse> {
-    return tracer.trace("db.compact", span => {
-      span?.addTags({ db_name: this.name })
-      return this.db.compact()
-    })
-  }
-
-  dump(stream: Writable, opts?: DatabaseDumpOpts | undefined): Promise<any> {
-    return tracer.trace("db.dump", span => {
-      span?.addTags({ db_name: this.name })
-      return this.db.dump(stream, opts)
-    })
-  }
-
-  load(...args: any[]): Promise<any> {
-    return tracer.trace("db.load", span => {
-      span?.addTags({ db_name: this.name })
-      return this.db.load(...args)
-    })
-  }
-
-  createIndex(...args: any[]): Promise<any> {
-    return tracer.trace("db.createIndex", span => {
-      span?.addTags({ db_name: this.name })
-      return this.db.createIndex(...args)
-    })
-  }
-
-  deleteIndex(...args: any[]): Promise<any> {
-    return tracer.trace("db.deleteIndex", span => {
-      span?.addTags({ db_name: this.name })
-      return this.db.deleteIndex(...args)
-    })
-  }
-
-  getIndexes(...args: any[]): Promise<any> {
-    return tracer.trace("db.getIndexes", span => {
-      span?.addTags({ db_name: this.name })
-      return this.db.getIndexes(...args)
-    })
-  }
-
-  sql<T extends Document>(
-    sql: string,
-    parameters?: SqlQueryBinding
-  ): Promise<T[]> {
-    return tracer.trace("db.sql", span => {
-      span?.addTags({ db_name: this.name })
-      return this.db.sql(sql, parameters)
-    })
-  }
-
-  sqlPurgeDocument(docIds: string[] | string): Promise<void> {
-    return tracer.trace("db.sqlPurgeDocument", span => {
-      span?.addTags({ db_name: this.name })
-      return this.db.sqlPurgeDocument(docIds)
-    })
-  }
-
-  sqlDiskCleanup(): Promise<void> {
-    return tracer.trace("db.sqlDiskCleanup", span => {
-      span?.addTags({ db_name: this.name })
-      return this.db.sqlDiskCleanup()
-    })
-  }
-}