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

package/src/db/searchIndexes/index.ts

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

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") {
-          // eslint-disable-next-line no-undef
-          // @ts-ignore
-          index(idxKey, input[key].toLowerCase(), { facet: true })
-        } else if (typeof input[key] !== "object") {
-          // eslint-disable-next-line no-undef
-          // @ts-ignore
-          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/index.spec.js

@@ -1,25 +0,0 @@
-require("../../../tests")
-const { structures } = require("../../../tests")
-const { getDB } = require("../db")
-
-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 () => {
-      const db = getDB(structures.db.id())
-      let 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,298 +0,0 @@
-import { newid } from "../../docIds/newid"
-import { getDB } from "../db"
-import { Database } from "@budibase/types"
-import { QueryBuilder, paginatedSearch, fullSearch } from "../lucene"
-
-const INDEX_NAME = "main"
-
-const index = `function(doc) {
-  let props = ["property", "number", "array"]
-  for (let key of props) {
-    if (Array.isArray(doc[key])) {
-      for (let val of doc[key]) {
-        index(key, val)
-      }
-    } else if (doc[key]) {
-      index(key, doc[key])
-    }
-  }
-}`
-
-describe("lucene", () => {
-  let db: Database, dbName: string
-
-  beforeAll(async () => {
-    dbName = `db-${newid()}`
-    // create the DB for testing
-    db = getDB(dbName)
-    await db.put({ _id: newid(), property: "word", array: ["1", "4"] })
-    await db.put({ _id: newid(), property: "word2", array: ["3", "1"] })
-    await db.put({
-      _id: newid(),
-      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("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: i.toString().padStart(3, "0"),
-            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",
-          },
-        },
-        {
-          limit: 1,
-          sort: "property",
-          sortType: "string",
-          sortOrder: "desc",
-        }
-      )
-      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",
-          },
-        },
-        {}
-      )
-      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)
-    })
-  })
-})