@budibase/backend-core 3.2.5 → 3.2.7

package/src/db/searchIndexes/searchIndexes.ts

@@ -1,62 +0,0 @@
-import { User, SearchIndex } from "@budibase/types"
-import { getGlobalDB } from "../../context"
-
-export async function createUserIndex() {
-  const db = getGlobalDB()
-  let designDoc
-  try {
-    designDoc = await db.get<any>("_design/database")
-  } catch (err: any) {
-    if (err.status === 404) {
-      designDoc = { _id: "_design/database" }
-    }
-  }
-
-  const fn = function (user: User) {
-    if (user._id && !user._id.startsWith("us_")) {
-      return
-    }
-    const ignoredFields = [
-      "_id",
-      "_rev",
-      "password",
-      "account",
-      "license",
-      "budibaseAccess",
-      "accountPortalAccess",
-      "csrfToken",
-    ]
-
-    function idx(input: Record<string, any>, prev?: string) {
-      for (let key of Object.keys(input)) {
-        if (ignoredFields.includes(key)) {
-          continue
-        }
-        let idxKey = prev != null ? `${prev}.${key}` : key
-        if (typeof input[key] === "string") {
-          // @ts-expect-error index is available in a CouchDB map function
-          // eslint-disable-next-line no-undef
-          index(idxKey, input[key].toLowerCase(), { facet: true })
-        } else if (typeof input[key] !== "object") {
-          // @ts-expect-error index is available in a CouchDB map function
-          // eslint-disable-next-line no-undef
-          index(idxKey, input[key], { facet: true })
-        } else {
-          idx(input[key], idxKey)
-        }
-      }
-    }
-    idx(user)
-  }
-
-  designDoc.indexes = {
-    [SearchIndex.USER]: {
-      index: fn.toString(),
-      analyzer: {
-        default: "keyword",
-        name: "perfield",
-      },
-    },
-  }
-  await db.put(designDoc)
-}

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

@@ -1,55 +0,0 @@
-import _ from "lodash"
-import { AnyDocument } from "@budibase/types"
-import { generator } from "../../../tests"
-import { DatabaseImpl } from "../couch"
-import { newid } from "../../utils"
-
-describe("DatabaseImpl", () => {
-  const database = new DatabaseImpl(generator.word())
-  const documents: AnyDocument[] = []
-
-  beforeAll(async () => {
-    const docsToCreate = Array.from({ length: 10 }).map(() => ({
-      _id: newid(),
-    }))
-    const createdDocs = await database.bulkDocs(docsToCreate)
-
-    documents.push(...createdDocs.map((x: any) => ({ _id: x.id, _rev: x.rev })))
-  })
-
-  describe("document exists", () => {
-    it("can check existing docs by id", async () => {
-      const existingDoc = _.sample(documents)
-      const result = await database.exists(existingDoc!._id!)
-
-      expect(result).toBe(true)
-    })
-
-    it("can check non existing docs by id", async () => {
-      const result = await database.exists(newid())
-
-      expect(result).toBe(false)
-    })
-
-    it("can check an existing doc by id multiple times", async () => {
-      const existingDoc = _.sample(documents)
-      const id = existingDoc!._id!
-
-      const results = []
-      results.push(await database.exists(id))
-      results.push(await database.exists(id))
-      results.push(await database.exists(id))
-
-      expect(results).toEqual([true, true, true])
-    })
-
-    it("returns false after the doc is deleted", async () => {
-      const existingDoc = _.sample(documents)
-      const id = existingDoc!._id!
-      expect(await database.exists(id)).toBe(true)
-
-      await database.remove(existingDoc!)
-      expect(await database.exists(id)).toBe(false)
-    })
-  })
-})

package/src/db/tests/connections.spec.ts

@@ -1,22 +0,0 @@
-import env from "../../environment"
-import { getCouchInfo } from "../couch"
-
-const MAIN_COUCH_URL = "http://user:test@localhost:5984"
-
-describe("connections", () => {
-  beforeAll(() => {
-    env._set("COUCH_DB_SQL_URL", "https://user:test@localhost:4984")
-  })
-
-  it("should strip URL credentials", () => {
-    const response = getCouchInfo(MAIN_COUCH_URL)
-    expect(response.url).toBe("http://localhost:5984")
-    expect(response.sqlUrl).toBe("https://localhost:4984")
-  })
-
-  it("should return separate auth credentials", () => {
-    const response = getCouchInfo(MAIN_COUCH_URL)
-    expect(response.auth.username).toBe("user")
-    expect(response.auth.password).toBe("test")
-  })
-})

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

@@ -1,32 +0,0 @@
-import { doInTenant } from "../../context"
-import { structures } from "../../../tests"
-import { getDB } from "../db"
-
-interface Doc {
-  _id: string
-  createdAt?: string
-  updatedAt?: string
-}
-
-describe("db", () => {
-  describe("getDB", () => {
-    it("returns a db", async () => {
-      const dbName = structures.db.id()
-      const db = getDB(dbName)
-      expect(db).toBeDefined()
-      expect(db.name).toBe(dbName)
-    })
-
-    it("uses the custom put function", async () => {
-      await doInTenant("foo", async () => {
-        const db = getDB(structures.db.id())
-        let doc: Doc = { _id: "test" }
-        await db.put(doc)
-        doc = await db.get(doc._id)
-        expect(doc.createdAt).toBe(new Date().toISOString())
-        expect(doc.updatedAt).toBe(new Date().toISOString())
-        await db.destroy()
-      })
-    })
-  })
-})

package/src/db/tests/lucene.spec.ts

@@ -1,400 +0,0 @@
-import { newid } from "../../docIds/newid"
-import { getDB } from "../db"
-import {
-  Database,
-  EmptyFilterOption,
-  SortOrder,
-  SortType,
-  DocumentType,
-  SEPARATOR,
-} from "@budibase/types"
-import { fullSearch, paginatedSearch, QueryBuilder } from "../lucene"
-
-const INDEX_NAME = "main"
-const TABLE_ID = DocumentType.TABLE + SEPARATOR + newid()
-
-const index = `function(doc) {
-  if (!doc._id.startsWith("ro_")) {
-    return
-  }
-  let keys = Object.keys(doc).filter(key => !key.startsWith("_"))
-  for (let key of keys) {
-    const value = doc[key]
-    if (Array.isArray(value)) {
-      for (let val of value) {
-        index(key, val)
-      }
-    } else if (value) {
-      index(key, value)
-    }
-  }
-}`
-
-function rowId(id?: string) {
-  return DocumentType.ROW + SEPARATOR + (id || newid())
-}
-
-describe("lucene", () => {
-  let db: Database, dbName: string
-
-  beforeAll(async () => {
-    dbName = `db-${newid()}`
-    // create the DB for testing
-    db = getDB(dbName)
-    await db.put({
-      _id: rowId(),
-      tableId: TABLE_ID,
-      property: "word",
-      array: ["1", "4"],
-    })
-    await db.put({
-      _id: rowId(),
-      tableId: TABLE_ID,
-      property: "word2",
-      array: ["3", "1"],
-    })
-    await db.put({
-      _id: rowId(),
-      tableId: TABLE_ID,
-      property: "word3",
-      number: 1,
-      array: ["1", "2"],
-    })
-  })
-
-  it("should be able to create a lucene index", async () => {
-    const response = await db.put({
-      _id: "_design/database",
-      indexes: {
-        [INDEX_NAME]: {
-          index: index,
-          analyzer: "standard",
-        },
-      },
-    })
-    expect(response.ok).toBe(true)
-  })
-
-  describe("query builder", () => {
-    it("should be able to perform a basic query", async () => {
-      const builder = new QueryBuilder(dbName, INDEX_NAME)
-      builder.setSort("property")
-      builder.setSortOrder("desc")
-      builder.setSortType("string")
-      const resp = await builder.run()
-      expect(resp.rows.length).toBe(3)
-    })
-
-    it("should handle limits", async () => {
-      const builder = new QueryBuilder(dbName, INDEX_NAME)
-      builder.setLimit(1)
-      const resp = await builder.run()
-      expect(resp.rows.length).toBe(1)
-    })
-
-    it("should be able to perform a string search", async () => {
-      const builder = new QueryBuilder(dbName, INDEX_NAME)
-      builder.addString("property", "wo")
-      const resp = await builder.run()
-      expect(resp.rows.length).toBe(3)
-    })
-
-    it("should be able to perform a range search", async () => {
-      const builder = new QueryBuilder(dbName, INDEX_NAME)
-      builder.addRange("number", 0, 1)
-      const resp = await builder.run()
-      expect(resp.rows.length).toBe(1)
-    })
-
-    it("should be able to perform an equal search", async () => {
-      const builder = new QueryBuilder(dbName, INDEX_NAME)
-      builder.addEqual("property", "word2")
-      const resp = await builder.run()
-      expect(resp.rows.length).toBe(1)
-    })
-
-    it("should be able to perform a not equal search", async () => {
-      const builder = new QueryBuilder(dbName, INDEX_NAME)
-      builder.addNotEqual("property", "word2")
-      const resp = await builder.run()
-      expect(resp.rows.length).toBe(2)
-    })
-
-    it("should be able to perform an empty search", async () => {
-      const builder = new QueryBuilder(dbName, INDEX_NAME)
-      builder.addEmpty("number", true)
-      const resp = await builder.run()
-      expect(resp.rows.length).toBe(2)
-    })
-
-    it("should be able to perform a not empty search", async () => {
-      const builder = new QueryBuilder(dbName, INDEX_NAME)
-      builder.addNotEmpty("number", true)
-      const resp = await builder.run()
-      expect(resp.rows.length).toBe(1)
-    })
-
-    it("should be able to perform a one of search", async () => {
-      const builder = new QueryBuilder(dbName, INDEX_NAME)
-      builder.addOneOf("property", ["word", "word2"])
-      const resp = await builder.run()
-      expect(resp.rows.length).toBe(2)
-    })
-
-    it("should return all rows when doing a one of search against falsey value", async () => {
-      const builder = new QueryBuilder(dbName, INDEX_NAME)
-      builder.addOneOf("property", null)
-      let resp = await builder.run()
-      expect(resp.rows.length).toBe(3)
-
-      builder.addOneOf("property", undefined)
-      resp = await builder.run()
-      expect(resp.rows.length).toBe(3)
-
-      builder.addOneOf("property", "")
-      resp = await builder.run()
-      expect(resp.rows.length).toBe(3)
-
-      builder.addOneOf("property", [])
-      resp = await builder.run()
-      expect(resp.rows.length).toBe(0)
-    })
-
-    it("should be able to perform a contains search", async () => {
-      const builder = new QueryBuilder(dbName, INDEX_NAME)
-      builder.addContains("property", ["word"])
-      const resp = await builder.run()
-      expect(resp.rows.length).toBe(1)
-    })
-
-    it("should be able to perform a not contains search", async () => {
-      const builder = new QueryBuilder(dbName, INDEX_NAME)
-      builder.addNotContains("property", ["word2"])
-      const resp = await builder.run()
-      expect(resp.rows.length).toBe(2)
-    })
-
-    it("should be able to perform an or not contains search", async () => {
-      const builder = new QueryBuilder(dbName, INDEX_NAME)
-      builder.addNotContains("array", ["1"])
-      builder.addNotContains("array", ["2"])
-      builder.setAllOr()
-      const resp = await builder.run()
-      expect(resp.rows.length).toBe(2)
-    })
-
-    describe("empty filters behaviour", () => {
-      it("should return all rows by default", async () => {
-        const builder = new QueryBuilder(dbName, INDEX_NAME)
-        builder.addEqual("property", "")
-        builder.addEqual("number", null)
-        builder.addString("property", "")
-        builder.addFuzzy("property", "")
-        builder.addNotEqual("number", undefined)
-        builder.addOneOf("number", null)
-        builder.addContains("array", undefined)
-        builder.addNotContains("array", null)
-        builder.addContainsAny("array", null)
-
-        const resp = await builder.run()
-        expect(resp.rows.length).toBe(3)
-      })
-
-      it("should return all rows when onEmptyFilter is ALL", async () => {
-        const builder = new QueryBuilder(dbName, INDEX_NAME)
-        builder.setOnEmptyFilter(EmptyFilterOption.RETURN_ALL)
-        builder.setAllOr()
-        builder.addEqual("property", "")
-        builder.addEqual("number", null)
-        builder.addString("property", "")
-        builder.addFuzzy("property", "")
-        builder.addNotEqual("number", undefined)
-        builder.addOneOf("number", null)
-        builder.addContains("array", undefined)
-        builder.addNotContains("array", null)
-        builder.addContainsAny("array", null)
-
-        const resp = await builder.run()
-        expect(resp.rows.length).toBe(3)
-      })
-
-      it("should return no rows when onEmptyFilter is NONE", async () => {
-        const builder = new QueryBuilder(dbName, INDEX_NAME)
-        builder.setOnEmptyFilter(EmptyFilterOption.RETURN_NONE)
-        builder.addEqual("property", "")
-        builder.addEqual("number", null)
-        builder.addString("property", "")
-        builder.addFuzzy("property", "")
-        builder.addNotEqual("number", undefined)
-        builder.addOneOf("number", null)
-        builder.addContains("array", undefined)
-        builder.addNotContains("array", null)
-        builder.addContainsAny("array", null)
-
-        const resp = await builder.run()
-        expect(resp.rows.length).toBe(0)
-      })
-
-      it("should return all matching rows when onEmptyFilter is NONE, but a filter value is provided", async () => {
-        const builder = new QueryBuilder(dbName, INDEX_NAME)
-        builder.setOnEmptyFilter(EmptyFilterOption.RETURN_NONE)
-        builder.addEqual("property", "")
-        builder.addEqual("number", 1)
-        builder.addString("property", "")
-        builder.addFuzzy("property", "")
-        builder.addNotEqual("number", undefined)
-        builder.addOneOf("number", null)
-        builder.addContains("array", undefined)
-        builder.addNotContains("array", null)
-        builder.addContainsAny("array", null)
-
-        const resp = await builder.run()
-        expect(resp.rows.length).toBe(1)
-      })
-    })
-
-    describe("skip", () => {
-      const skipDbName = `db-${newid()}`
-      let docs: {
-        _id: string
-        property: string
-        array: string[]
-      }[]
-
-      beforeAll(async () => {
-        const db = getDB(skipDbName)
-
-        docs = Array(QueryBuilder.maxLimit * 2.5)
-          .fill(0)
-          .map((_, i) => ({
-            _id: rowId(i.toString().padStart(3, "0")),
-            tableId: TABLE_ID,
-            property: `value_${i.toString().padStart(3, "0")}`,
-            array: [],
-          }))
-        await db.bulkDocs(docs)
-
-        await db.put({
-          _id: "_design/database",
-          indexes: {
-            [INDEX_NAME]: {
-              index: index,
-              analyzer: "standard",
-            },
-          },
-        })
-      })
-
-      it("should be able to apply skip", async () => {
-        const builder = new QueryBuilder(skipDbName, INDEX_NAME)
-        const firstResponse = await builder.run()
-        builder.setSkip(40)
-        const secondResponse = await builder.run()
-
-        // Return the default limit
-        expect(firstResponse.rows.length).toBe(50)
-        expect(secondResponse.rows.length).toBe(50)
-
-        // Should have the expected overlap
-        expect(firstResponse.rows.slice(40)).toEqual(
-          secondResponse.rows.slice(0, 10)
-        )
-      })
-
-      it("should handle limits", async () => {
-        const builder = new QueryBuilder(skipDbName, INDEX_NAME)
-        builder.setLimit(10)
-        builder.setSkip(50)
-        builder.setSort("_id")
-
-        const resp = await builder.run()
-        expect(resp.rows.length).toBe(10)
-        expect(resp.rows).toEqual(
-          docs.slice(50, 60).map(expect.objectContaining)
-        )
-      })
-
-      it("should be able to skip searching through multiple responses", async () => {
-        const builder = new QueryBuilder(skipDbName, INDEX_NAME)
-        // Skipping 2 max limits plus a little bit more
-        const skip = QueryBuilder.maxLimit * 2 + 37
-        builder.setSkip(skip)
-        builder.setSort("_id")
-        const resp = await builder.run()
-
-        expect(resp.rows.length).toBe(50)
-        expect(resp.rows).toEqual(
-          docs.slice(skip, skip + resp.rows.length).map(expect.objectContaining)
-        )
-      })
-
-      it("should not return results if skipping all docs", async () => {
-        const builder = new QueryBuilder(skipDbName, INDEX_NAME)
-        // Skipping 2 max limits plus a little bit more
-        const skip = docs.length + 1
-        builder.setSkip(skip)
-
-        const resp = await builder.run()
-
-        expect(resp.rows.length).toBe(0)
-      })
-
-      it("skip should respect with filters", async () => {
-        const builder = new QueryBuilder(skipDbName, INDEX_NAME)
-        builder.setLimit(10)
-        builder.setSkip(50)
-        builder.addString("property", "value_1")
-        builder.setSort("property")
-
-        const resp = await builder.run()
-        expect(resp.rows.length).toBe(10)
-        expect(resp.rows).toEqual(
-          docs.slice(150, 160).map(expect.objectContaining)
-        )
-      })
-    })
-  })
-
-  describe("paginated search", () => {
-    it("should be able to perform a paginated search", async () => {
-      const page = await paginatedSearch(
-        dbName,
-        INDEX_NAME,
-        {
-          string: {
-            property: "wo",
-          },
-        },
-        {
-          tableId: TABLE_ID,
-          limit: 1,
-          sort: "property",
-          sortType: SortType.STRING,
-          sortOrder: SortOrder.DESCENDING,
-        }
-      )
-      expect(page.rows.length).toBe(1)
-      expect(page.hasNextPage).toBe(true)
-      expect(page.bookmark).toBeDefined()
-    })
-  })
-
-  describe("full search", () => {
-    it("should be able to perform a full search", async () => {
-      const page = await fullSearch(
-        dbName,
-        INDEX_NAME,
-        {
-          string: {
-            property: "wo",
-          },
-        },
-        {
-          tableId: TABLE_ID,
-          query: {},
-        }
-      )
-      expect(page.rows.length).toBe(3)
-    })
-  })
-})

package/src/db/tests/pouch.spec.js

@@ -1,62 +0,0 @@
-require("../../../tests")
-const getUrlInfo = require("../couch").getUrlInfo
-
-describe("pouch", () => {
-  describe("Couch DB URL parsing", () => {
-    it("should handle a null Couch DB URL", () => {
-      const info = getUrlInfo(null)
-      expect(info.url).toBeUndefined()
-      expect(info.auth.username).toBeUndefined()
-    })
-    it("should be able to parse a basic Couch DB URL", () => {
-      const info = getUrlInfo("http://host.com")
-      expect(info.url).toBe("http://host.com")
-      expect(info.auth.username).toBeUndefined()
-    })
-    it("should be able to parse a Couch DB basic URL with HTTPS", () => {
-      const info = getUrlInfo("https://host.com")
-      expect(info.url).toBe("https://host.com")
-      expect(info.auth.username).toBeUndefined()
-    })
-    it("should be able to parse a basic Couch DB URL with a custom port", () => {
-      const info = getUrlInfo("https://host.com:1234")
-      expect(info.url).toBe("https://host.com:1234")
-      expect(info.auth.username).toBeUndefined()
-    })
-    it("should be able to parse a Couch DB URL with auth", () => {
-      const info = getUrlInfo("https://user:pass@host.com:1234")
-      expect(info.url).toBe("https://host.com:1234")
-      expect(info.auth.username).toBe("user")
-      expect(info.auth.password).toBe("pass")
-    })
-    it("should be able to parse a Couch DB URL with auth and special chars", () => {
-      const info = getUrlInfo("https://user:s:p@s://@://:d@;][~s@host.com:1234")
-      expect(info.url).toBe("https://host.com:1234")
-      expect(info.auth.username).toBe("user")
-      expect(info.auth.password).toBe("s:p@s://@://:d@;][~s")
-    })
-    it("should be able to parse a Couch DB URL without a protocol", () => {
-      const info = getUrlInfo("host.com:1234")
-      expect(info.url).toBe("http://host.com:1234")
-      expect(info.auth.username).toBeUndefined()
-    })
-    it("should be able to parse a Couch DB URL with auth and without a protocol", () => {
-      const info = getUrlInfo("user:s:p@s://@://:d@;][~s@host.com:1234")
-      expect(info.url).toBe("http://host.com:1234")
-      expect(info.auth.username).toBe("user")
-      expect(info.auth.password).toBe("s:p@s://@://:d@;][~s")
-    })
-    it("should be able to parse a Couch DB URL with only username auth", () => {
-      const info = getUrlInfo("https://user@host.com:1234")
-      expect(info.url).toBe("https://host.com:1234")
-      expect(info.auth.username).toBe("user")
-      expect(info.auth.password).toBeUndefined()
-    })
-    it("should be able to parse a Couch DB URL with only username auth and without a protocol", () => {
-      const info = getUrlInfo("user@host.com:1234")
-      expect(info.url).toBe("http://host.com:1234")
-      expect(info.auth.username).toBe("user")
-      expect(info.auth.password).toBeUndefined()
-    })
-  })
-})

package/src/db/tests/utils.spec.ts

@@ -1,63 +0,0 @@
-import {
-  getDevelopmentAppID,
-  getProdAppID,
-  isDevAppID,
-  isProdAppID,
-} from "../../docIds/conversions"
-import { generateAppID } from "../utils"
-
-describe("utils", () => {
-  describe("generateAppID", () => {
-    function getID() {
-      const appId = generateAppID()
-      const split = appId.split("_")
-      const uuid = split[split.length - 1]
-      const devAppId = `app_dev_${uuid}`
-      return { appId, devAppId, split, uuid }
-    }
-
-    it("should be able to generate a new app ID", () => {
-      expect(generateAppID().startsWith("app_")).toEqual(true)
-    })
-
-    it("should be able to convert a production app ID to development", () => {
-      const { appId, uuid } = getID()
-      expect(getDevelopmentAppID(appId)).toEqual(`app_dev_${uuid}`)
-    })
-
-    it("should be able to convert a development app ID to development", () => {
-      const { devAppId, uuid } = getID()
-      expect(getDevelopmentAppID(devAppId)).toEqual(`app_dev_${uuid}`)
-    })
-
-    it("should be able to convert a development ID to a production", () => {
-      const { devAppId, uuid } = getID()
-      expect(getProdAppID(devAppId)).toEqual(`app_${uuid}`)
-    })
-
-    it("should be able to convert a production ID to production", () => {
-      const { appId, uuid } = getID()
-      expect(getProdAppID(appId)).toEqual(`app_${uuid}`)
-    })
-
-    it("should be able to confirm dev app ID is development", () => {
-      const { devAppId } = getID()
-      expect(isDevAppID(devAppId)).toEqual(true)
-    })
-
-    it("should be able to confirm prod app ID is not development", () => {
-      const { appId } = getID()
-      expect(isDevAppID(appId)).toEqual(false)
-    })
-
-    it("should be able to confirm prod app ID is prod", () => {
-      const { appId } = getID()
-      expect(isProdAppID(appId)).toEqual(true)
-    })
-
-    it("should be able to confirm dev app ID is not prod", () => {
-      const { devAppId } = getID()
-      expect(isProdAppID(devAppId)).toEqual(false)
-    })
-  })
-})