@budibase/server 2.1.32-alpha.4 → 2.1.32-alpha.6

package/src/api/controllers/row/internal.js

@@ -6,7 +6,6 @@ const {
   DocumentType,
   InternalTables,
 } = require("../../../db/utils")
-const { getDB } = require("@budibase/backend-core/db")
 const userController = require("../user")
 const {
   inputProcessing,
@@ -26,7 +25,7 @@ const {
   getFromMemoryDoc,
 } = require("../view/utils")
 const { cloneDeep } = require("lodash/fp")
-const { getAppDB } = require("@budibase/backend-core/context")
+const { context, db: dbCore } = require("@budibase/backend-core")
 const { finaliseRow, updateRelatedFormula } = require("./staticFormula")
 const exporters = require("../view/exporters")
 const { apiFileReturn } = require("../../../utilities/fileSystem")
@@ -80,7 +79,7 @@ async function getRawTableData(ctx, db, tableId) {
 }
 
 exports.patch = async ctx => {
-  const db = getAppDB()
+  const db = context.getAppDB()
   const inputs = ctx.request.body
   const tableId = inputs.tableId
   const isUserTable = tableId === InternalTables.USER_METADATA
@@ -145,7 +144,7 @@ exports.patch = async ctx => {
 }
 
 exports.save = async function (ctx) {
-  const db = getAppDB()
+  const db = context.getAppDB()
   let inputs = ctx.request.body
   inputs.tableId = ctx.params.tableId
 
@@ -188,7 +187,7 @@ exports.fetchView = async ctx => {
     return exports.fetch(ctx)
   }
 
-  const db = getAppDB()
+  const db = context.getAppDB()
   const { calculation, group, field } = ctx.query
   const viewInfo = await getView(db, viewName)
   let response
@@ -242,7 +241,7 @@ exports.fetchView = async ctx => {
 }
 
 exports.fetch = async ctx => {
-  const db = getAppDB()
+  const db = context.getAppDB()
 
   const tableId = ctx.params.tableId
   let table = await db.get(tableId)
@@ -251,7 +250,7 @@ exports.fetch = async ctx => {
 }
 
 exports.find = async ctx => {
-  const db = getDB(ctx.appId)
+  const db = dbCore.getDB(ctx.appId)
   const table = await db.get(ctx.params.tableId)
   let row = await findRow(ctx, ctx.params.tableId, ctx.params.rowId)
   row = await outputProcessing(table, row)
@@ -259,7 +258,7 @@ exports.find = async ctx => {
 }
 
 exports.destroy = async function (ctx) {
-  const db = getAppDB()
+  const db = context.getAppDB()
   const { _id } = ctx.request.body
   let row = await db.get(_id)
   let _rev = ctx.request.body._rev || row._rev
@@ -295,7 +294,7 @@ exports.destroy = async function (ctx) {
 }
 
 exports.bulkDestroy = async ctx => {
-  const db = getAppDB()
+  const db = context.getAppDB()
   const tableId = ctx.params.tableId
   const table = await db.get(tableId)
   let { rows } = ctx.request.body
@@ -338,7 +337,7 @@ exports.search = async ctx => {
   }
 
   const { tableId } = ctx.params
-  const db = getAppDB()
+  const db = context.getAppDB()
   const { paginate, query, ...params } = ctx.request.body
   params.version = ctx.version
   params.tableId = tableId
@@ -371,7 +370,7 @@ exports.validate = async ctx => {
 }
 
 exports.exportRows = async ctx => {
-  const db = getAppDB()
+  const db = context.getAppDB()
   const table = await db.get(ctx.params.tableId)
   const rowIds = ctx.request.body.rows
   let format = ctx.query.format
@@ -408,7 +407,7 @@ exports.exportRows = async ctx => {
 }
 
 exports.fetchEnrichedRow = async ctx => {
-  const db = getAppDB()
+  const db = context.getAppDB()
   const tableId = ctx.params.tableId
   const rowId = ctx.params.rowId
   // need table to work out where links go in row

package/src/api/controllers/row/{internalSearch.js → internalSearch.ts}

@@ -1,15 +1,35 @@
-const { SearchIndexes } = require("../../../db/utils")
-const { removeKeyNumbering } = require("./utils")
-const fetch = require("node-fetch")
-const { getCouchInfo } = require("@budibase/backend-core/db")
-const { getAppId } = require("@budibase/backend-core/context")
+import { SearchIndexes } from "../../../db/utils"
+import { removeKeyNumbering } from "./utils"
+import fetch from "node-fetch"
+import { db as dbCore, context } from "@budibase/backend-core"
+import { SearchFilters, Row } from "@budibase/types"
+
+type SearchParams = {
+  tableId: string
+  sort?: string
+  sortOrder?: string
+  sortType?: string
+  limit?: number
+  bookmark?: string
+  version?: string
+  rows?: Row[]
+}
 
 /**
  * Class to build lucene query URLs.
  * Optionally takes a base lucene query object.
  */
-class QueryBuilder {
-  constructor(base) {
+export class QueryBuilder {
+  query: SearchFilters
+  limit: number
+  sort?: string
+  bookmark?: string
+  sortOrder: string
+  sortType: string
+  includeDocs: boolean
+  version?: string
+
+  constructor(base?: SearchFilters) {
     this.query = {
       allOr: false,
       string: {},
@@ -29,49 +49,52 @@ class QueryBuilder {
     this.sortOrder = "ascending"
     this.sortType = "string"
     this.includeDocs = true
-    this.version = null
   }
 
-  setVersion(version) {
-    this.version = version
+  setVersion(version?: string) {
+    if (version != null) {
+      this.version = version
+    }
     return this
   }
 
-  setTable(tableId) {
-    this.query.equal.tableId = tableId
+  setTable(tableId: string) {
+    this.query.equal!.tableId = tableId
     return this
   }
 
-  setLimit(limit) {
+  setLimit(limit?: number) {
     if (limit != null) {
       this.limit = limit
     }
     return this
   }
 
-  setSort(sort) {
+  setSort(sort?: string) {
     if (sort != null) {
       this.sort = sort
     }
     return this
   }
 
-  setSortOrder(sortOrder) {
+  setSortOrder(sortOrder?: string) {
     if (sortOrder != null) {
       this.sortOrder = sortOrder
     }
     return this
   }
 
-  setSortType(sortType) {
+  setSortType(sortType?: string) {
     if (sortType != null) {
       this.sortType = sortType
     }
     return this
   }
 
-  setBookmark(bookmark) {
-    this.bookmark = bookmark
+  setBookmark(bookmark?: string) {
+    if (bookmark != null) {
+      this.bookmark = bookmark
+    }
     return this
   }
 
@@ -80,61 +103,61 @@ class QueryBuilder {
     return this
   }
 
-  addString(key, partial) {
-    this.query.string[key] = partial
+  addString(key: string, partial: string) {
+    this.query.string![key] = partial
     return this
   }
 
-  addFuzzy(key, fuzzy) {
-    this.query.fuzzy[key] = fuzzy
+  addFuzzy(key: string, fuzzy: string) {
+    this.query.fuzzy![key] = fuzzy
     return this
   }
 
-  addRange(key, low, high) {
-    this.query.range = {
+  addRange(key: string, low: string | number, high: string | number) {
+    this.query.range![key] = {
       low,
       high,
     }
     return this
   }
 
-  addEqual(key, value) {
-    this.query.equal[key] = value
+  addEqual(key: string, value: any) {
+    this.query.equal![key] = value
     return this
   }
 
-  addNotEqual(key, value) {
-    this.query.notEqual[key] = value
+  addNotEqual(key: string, value: any) {
+    this.query.notEqual![key] = value
     return this
   }
 
-  addEmpty(key, value) {
-    this.query.empty[key] = value
+  addEmpty(key: string, value: any) {
+    this.query.empty![key] = value
     return this
   }
 
-  addNotEmpty(key, value) {
-    this.query.notEmpty[key] = value
+  addNotEmpty(key: string, value: any) {
+    this.query.notEmpty![key] = value
     return this
   }
 
-  addOneOf(key, value) {
-    this.query.oneOf[key] = value
+  addOneOf(key: string, value: any) {
+    this.query.oneOf![key] = value
     return this
   }
 
-  addContains(key, value) {
-    this.query.contains[key] = value
+  addContains(key: string, value: any) {
+    this.query.contains![key] = value
     return this
   }
 
-  addNotContains(key, value) {
-    this.query.notContains[key] = value
+  addNotContains(key: string, value: any) {
+    this.query.notContains![key] = value
     return this
   }
 
-  addContainsAny(key, value) {
-    this.query.containsAny[key] = value
+  addContainsAny(key: string, value: any) {
+    this.query.containsAny![key] = value
     return this
   }
 
@@ -145,7 +168,7 @@ class QueryBuilder {
    * @param options The preprocess options
    * @returns {string|*}
    */
-  preprocess(value, { escape, lowercase, wrap, type } = {}) {
+  preprocess(value: any, { escape, lowercase, wrap, type }: any = {}) {
     const hasVersion = !!this.version
     // Determine if type needs wrapped
     const originalType = typeof value
@@ -173,12 +196,12 @@ class QueryBuilder {
     let query = allOr ? "" : "*:*"
     const allPreProcessingOpts = { escape: true, lowercase: true, wrap: true }
     let tableId
-    if (this.query.equal.tableId) {
-      tableId = this.query.equal.tableId
-      delete this.query.equal.tableId
+    if (this.query.equal!.tableId) {
+      tableId = this.query.equal!.tableId
+      delete this.query.equal!.tableId
     }
 
-    const equal = (key, value) => {
+    const equal = (key: string, value: any) => {
       // 0 evaluates to false, which means we would return all rows if we don't check it
       if (!value && value !== 0) {
         return null
@@ -186,7 +209,7 @@ class QueryBuilder {
       return `${key}:${builder.preprocess(value, allPreProcessingOpts)}`
     }
 
-    const contains = (key, value, mode = "AND") => {
+    const contains = (key: string, value: any, mode = "AND") => {
       if (Array.isArray(value) && value.length === 0) {
         return null
       }
@@ -202,16 +225,17 @@ class QueryBuilder {
       return `${key}:(${statement})`
     }
 
-    const notContains = (key, value) => {
+    const notContains = (key: string, value: any) => {
+      // @ts-ignore
       const allPrefix = allOr === "" ? "*:* AND" : ""
       return allPrefix + "NOT " + contains(key, value)
     }
 
-    const containsAny = (key, value) => {
+    const containsAny = (key: string, value: any) => {
       return contains(key, value, "OR")
     }
 
-    const oneOf = (key, value) => {
+    const oneOf = (key: string, value: any) => {
       if (!Array.isArray(value)) {
         if (typeof value === "string") {
           value = value.split(",")
@@ -229,7 +253,7 @@ class QueryBuilder {
       return `${key}:(${orStatement})`
     }
 
-    function build(structure, queryFn) {
+    function build(structure: any, queryFn: any) {
       for (let [key, value] of Object.entries(structure)) {
         // check for new format - remove numbering if needed
         key = removeKeyNumbering(key)
@@ -249,7 +273,7 @@ class QueryBuilder {
 
     // Construct the actual lucene search query string from JSON structure
     if (this.query.string) {
-      build(this.query.string, (key, value) => {
+      build(this.query.string, (key: string, value: any) => {
         if (!value) {
           return null
         }
@@ -262,7 +286,7 @@ class QueryBuilder {
       })
     }
     if (this.query.range) {
-      build(this.query.range, (key, value) => {
+      build(this.query.range, (key: string, value: any) => {
         if (!value) {
           return null
         }
@@ -278,7 +302,7 @@ class QueryBuilder {
       })
     }
     if (this.query.fuzzy) {
-      build(this.query.fuzzy, (key, value) => {
+      build(this.query.fuzzy, (key: string, value: any) => {
         if (!value) {
           return null
         }
@@ -294,7 +318,7 @@ class QueryBuilder {
       build(this.query.equal, equal)
     }
     if (this.query.notEqual) {
-      build(this.query.notEqual, (key, value) => {
+      build(this.query.notEqual, (key: string, value: any) => {
         if (!value) {
           return null
         }
@@ -302,10 +326,10 @@ class QueryBuilder {
       })
     }
     if (this.query.empty) {
-      build(this.query.empty, key => `!${key}:["" TO *]`)
+      build(this.query.empty, (key: string) => `!${key}:["" TO *]`)
     }
     if (this.query.notEmpty) {
-      build(this.query.notEmpty, key => `${key}:["" TO *]`)
+      build(this.query.notEmpty, (key: string) => `${key}:["" TO *]`)
     }
     if (this.query.oneOf) {
       build(this.query.oneOf, oneOf)
@@ -329,7 +353,7 @@ class QueryBuilder {
   }
 
   buildSearchBody() {
-    let body = {
+    let body: any = {
       q: this.buildSearchQuery(),
       limit: Math.min(this.limit, 200),
       include_docs: this.includeDocs,
@@ -346,17 +370,14 @@ class QueryBuilder {
   }
 
   async run() {
-    const appId = getAppId()
-    const { url, cookie } = getCouchInfo()
+    const appId = context.getAppId()
+    const { url, cookie } = dbCore.getCouchInfo()
     const fullPath = `${url}/${appId}/_design/database/_search/${SearchIndexes.ROWS}`
     const body = this.buildSearchBody()
     return await runQuery(fullPath, body, cookie)
   }
 }
 
-// exported for unit testing
-exports.QueryBuilder = QueryBuilder
-
 /**
  * Executes a lucene search query.
  * @param url The query URL
@@ -364,7 +385,7 @@ exports.QueryBuilder = QueryBuilder
  * @param cookie The auth cookie for CouchDB
  * @returns {Promise<{rows: []}>}
  */
-const runQuery = async (url, body, cookie) => {
+const runQuery = async (url: string, body: any, cookie: string) => {
   const response = await fetch(url, {
     body: JSON.stringify(body),
     method: "POST",
@@ -374,11 +395,11 @@ const runQuery = async (url, body, cookie) => {
   })
   const json = await response.json()
 
-  let output = {
+  let output: any = {
     rows: [],
   }
   if (json.rows != null && json.rows.length > 0) {
-    output.rows = json.rows.map(row => row.doc)
+    output.rows = json.rows.map((row: any) => row.doc)
   }
   if (json.bookmark) {
     output.bookmark = json.bookmark
@@ -402,7 +423,7 @@ const runQuery = async (url, body, cookie) => {
  *   rows {array|null} Current results in the recursive search
  * @returns {Promise<*[]|*>}
  */
-const recursiveSearch = async (query, params) => {
+async function recursiveSearch(query: any, params: any): Promise<any> {
   const bookmark = params.bookmark
   const rows = params.rows || []
   if (rows.length >= params.limit) {
@@ -450,7 +471,10 @@ const recursiveSearch = async (query, params) => {
  *   bookmark {string} The bookmark to resume from
  * @returns {Promise<{hasNextPage: boolean, rows: *[]}>}
  */
-exports.paginatedSearch = async (query, params) => {
+export async function paginatedSearch(
+  query: SearchFilters,
+  params: SearchParams
+) {
   let limit = params.limit
   if (limit == null || isNaN(limit) || limit < 0) {
     limit = 50
@@ -496,7 +520,7 @@ exports.paginatedSearch = async (query, params) => {
  *   limit {number} The desired number of results
  * @returns {Promise<{rows: *}>}
  */
-exports.fullSearch = async (query, params) => {
+export async function fullSearch(query: SearchFilters, params: SearchParams) {
   let limit = params.limit
   if (limit == null || isNaN(limit) || limit < 0) {
     limit = 1000

package/src/api/controllers/row/{staticFormula.js → staticFormula.ts}

@@ -1,13 +1,14 @@
-const { getRowParams } = require("../../../db/utils")
-const {
+import { getRowParams } from "../../../db/utils"
+import {
   outputProcessing,
   processAutoColumn,
   processFormulas,
-} = require("../../../utilities/rowProcessor")
-const { FieldTypes, FormulaTypes } = require("../../../constants")
+} from "../../../utilities/rowProcessor"
+import { FieldTypes, FormulaTypes } from "../../../constants"
+import { context } from "@budibase/backend-core"
+import { Table, Row } from "@budibase/types"
 const { isEqual } = require("lodash")
 const { cloneDeep } = require("lodash/fp")
-const { getAppDB } = require("@budibase/backend-core/context")
 
 /**
  * This function runs through a list of enriched rows, looks at the rows which
@@ -15,22 +16,22 @@ const { getAppDB } = require("@budibase/backend-core/context")
  * updated.
  * NOTE: this will only for affect static formulas.
  */
-exports.updateRelatedFormula = async (table, enrichedRows) => {
-  const db = getAppDB()
+exports.updateRelatedFormula = async (table: Table, enrichedRows: Row[]) => {
+  const db = context.getAppDB()
   // no formula to update, we're done
   if (!table.relatedFormula) {
     return
   }
-  let promises = []
+  let promises: Promise<any>[] = []
   for (let enrichedRow of Array.isArray(enrichedRows)
     ? enrichedRows
     : [enrichedRows]) {
     // the related rows by tableId
-    let relatedRows = {}
+    let relatedRows: Record<string, Row[]> = {}
     for (let [key, field] of Object.entries(enrichedRow)) {
       const columnDefinition = table.schema[key]
       if (columnDefinition && columnDefinition.type === FieldTypes.LINK) {
-        const relatedTableId = columnDefinition.tableId
+        const relatedTableId = columnDefinition.tableId!
         if (!relatedRows[relatedTableId]) {
           relatedRows[relatedTableId] = []
         }
@@ -38,7 +39,7 @@ exports.updateRelatedFormula = async (table, enrichedRows) => {
       }
     }
     for (let tableId of table.relatedFormula) {
-      let relatedTable
+      let relatedTable: Table
       try {
         // no rows to update, skip
         if (!relatedRows[tableId] || relatedRows[tableId].length === 0) {
@@ -48,7 +49,7 @@ exports.updateRelatedFormula = async (table, enrichedRows) => {
       } catch (err) {
         // no error scenario, table doesn't seem to exist anymore, ignore
       }
-      for (let column of Object.values(relatedTable.schema)) {
+      for (let column of Object.values(relatedTable!.schema)) {
         // needs updated in related rows
         if (
           column.type === FieldTypes.FORMULA &&
@@ -57,7 +58,7 @@ exports.updateRelatedFormula = async (table, enrichedRows) => {
           // re-enrich rows for all the related, don't update the related formula for them
           promises = promises.concat(
             relatedRows[tableId].map(related =>
-              exports.finaliseRow(relatedTable, related, {
+              finaliseRow(relatedTable, related, {
                 updateFormula: false,
               })
             )
@@ -70,8 +71,8 @@ exports.updateRelatedFormula = async (table, enrichedRows) => {
   await Promise.all(promises)
 }
 
-exports.updateAllFormulasInTable = async table => {
-  const db = getAppDB()
+export async function updateAllFormulasInTable(table: Table) {
+  const db = context.getAppDB()
   // start by getting the raw rows (which will be written back to DB after update)
   let rows = (
     await db.allDocs(
@@ -88,7 +89,9 @@ exports.updateAllFormulasInTable = async table => {
   const updatedRows = []
   for (let row of rows) {
     // find the enriched row, if found process the formulas
-    const enrichedRow = enrichedRows.find(enriched => enriched._id === row._id)
+    const enrichedRow = enrichedRows.find(
+      (enriched: any) => enriched._id === row._id
+    )
     if (enrichedRow) {
       const processed = processFormulas(table, cloneDeep(row), {
         dynamic: false,
@@ -109,12 +112,14 @@ exports.updateAllFormulasInTable = async table => {
  * row. The reason we need to return the enriched row is that the automation row created trigger
  * expects the row to be totally enriched/contain all relationships.
  */
-exports.finaliseRow = async (
-  table,
-  row,
-  { oldTable, updateFormula } = { updateFormula: true }
-) => {
-  const db = getAppDB()
+export async function finaliseRow(
+  table: Table,
+  row: Row,
+  { oldTable, updateFormula }: { oldTable?: Table; updateFormula: boolean } = {
+    updateFormula: true,
+  }
+) {
+  const db = context.getAppDB()
   row.type = "row"
   // process the row before return, to include relationships
   let enrichedRow = await outputProcessing(table, cloneDeep(row), {
@@ -131,7 +136,7 @@ exports.finaliseRow = async (
   if (oldTable && !isEqual(oldTable, table)) {
     try {
       await db.put(table)
-    } catch (err) {
+    } catch (err: any) {
       if (err.status === 409) {
         const updatedTable = await db.get(table._id)
         let response = processAutoColumn(null, updatedTable, row, {

package/src/api/controllers/row/{utils.js → utils.ts}

@@ -1,33 +1,32 @@
+import { InternalTables } from "../../../db/utils"
+import * as userController from "../user"
+import { FieldTypes } from "../../../constants"
+import { context } from "@budibase/backend-core"
+import { makeExternalQuery } from "../../../integrations/base/query"
+import { BBContext, Row, Table } from "@budibase/types"
+export { removeKeyNumbering } from "../../../integrations/base/utils"
 const validateJs = require("validate.js")
 const { cloneDeep } = require("lodash/fp")
-const { InternalTables } = require("../../../db/utils")
-const userController = require("../user")
-const { FieldTypes } = require("../../../constants")
-const { getAppDB } = require("@budibase/backend-core/context")
-const { makeExternalQuery } = require("../../../integrations/base/query")
-const { removeKeyNumbering } = require("../../../integrations/base/utils")
 
 validateJs.extend(validateJs.validators.datetime, {
-  parse: function (value) {
+  parse: function (value: string) {
     return new Date(value).getTime()
   },
   // Input is a unix timestamp
-  format: function (value) {
+  format: function (value: string) {
     return new Date(value).toISOString()
   },
 })
 
-exports.removeKeyNumbering = removeKeyNumbering
-
-exports.getDatasourceAndQuery = async json => {
+export async function getDatasourceAndQuery(json: any) {
   const datasourceId = json.endpoint.datasourceId
-  const db = getAppDB()
+  const db = context.getAppDB()
   const datasource = await db.get(datasourceId)
   return makeExternalQuery(datasource, json)
 }
 
-exports.findRow = async (ctx, tableId, rowId) => {
-  const db = getAppDB()
+export async function findRow(ctx: BBContext, tableId: string, rowId: string) {
+  const db = context.getAppDB()
   let row
   // TODO remove special user case in future
   if (tableId === InternalTables.USER_METADATA) {
@@ -45,12 +44,20 @@ exports.findRow = async (ctx, tableId, rowId) => {
   return row
 }
 
-exports.validate = async ({ tableId, row, table }) => {
+export async function validate({
+  tableId,
+  row,
+  table,
+}: {
+  tableId?: string
+  row: Row
+  table: Table
+}) {
   if (!table) {
-    const db = getAppDB()
+    const db = context.getAppDB()
     table = await db.get(tableId)
   }
-  const errors = {}
+  const errors: any = {}
   for (let fieldName of Object.keys(table.schema)) {
     const constraints = cloneDeep(table.schema[fieldName].constraints)
     const type = table.schema[fieldName].type
@@ -70,7 +77,7 @@ exports.validate = async ({ tableId, row, table }) => {
         if (!Array.isArray(row[fieldName])) {
           row[fieldName] = row[fieldName].split(",")
         }
-        row[fieldName].map(val => {
+        row[fieldName].map((val: any) => {
           if (
             !constraints.inclusion.includes(val) &&
             constraints.inclusion.length !== 0