@budibase/server 2.1.45 → 2.1.46-alpha.0

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()
+export async function updateRelatedFormula(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,17 +112,19 @@ 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), {
+  let enrichedRow = (await outputProcessing(table, cloneDeep(row), {
     squash: false,
-  })
+  })) as Row
   // use enriched row to generate formulas for saving, specifically only use as context
   row = processFormulas(table, row, {
     dynamic: false,
@@ -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,15 +44,26 @@ 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
+}) {
+  let fetchedTable: Table
   if (!table) {
-    const db = getAppDB()
-    table = await db.get(tableId)
+    const db = context.getAppDB()
+    fetchedTable = await db.get(tableId)
+  } else {
+    fetchedTable = table
   }
-  const errors = {}
-  for (let fieldName of Object.keys(table.schema)) {
-    const constraints = cloneDeep(table.schema[fieldName].constraints)
-    const type = table.schema[fieldName].type
+  const errors: any = {}
+  for (let fieldName of Object.keys(fetchedTable.schema)) {
+    const constraints = cloneDeep(fetchedTable.schema[fieldName].constraints)
+    const type = fetchedTable.schema[fieldName].type
     // formulas shouldn't validated, data will be deleted anyway
     if (type === FieldTypes.FORMULA) {
       continue
@@ -70,7 +80,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

package/src/api/controllers/screen.ts

@@ -7,9 +7,9 @@ import {
   roles,
 } from "@budibase/backend-core"
 import { updateAppPackage } from "./application"
-import { Plugin, ScreenProps } from "@budibase/types"
+import { Plugin, ScreenProps, BBContext } from "@budibase/types"
 
-exports.fetch = async (ctx: any) => {
+export async function fetch(ctx: BBContext) {
   const db = context.getAppDB()
 
   const screens = (
@@ -20,13 +20,17 @@ exports.fetch = async (ctx: any) => {
     )
   ).rows.map((el: any) => el.doc)
 
+  const roleId = ctx.user?.role?._id as string
+  if (!roleId) {
+    ctx.throw("Unable to retrieve users role ID.")
+  }
   ctx.body = await new roles.AccessController().checkScreensAccess(
     screens,
-    ctx.user.role._id
+    roleId
   )
 }
 
-exports.save = async (ctx: any) => {
+export async function save(ctx: BBContext) {
   const db = context.getAppDB()
   let screen = ctx.request.body
 
@@ -92,7 +96,7 @@ exports.save = async (ctx: any) => {
   }
 }
 
-exports.destroy = async (ctx: any) => {
+export async function destroy(ctx: BBContext) {
   const db = context.getAppDB()
   const id = ctx.params.screenId
   const screen = await db.get(id)
@@ -106,7 +110,7 @@ exports.destroy = async (ctx: any) => {
   ctx.status = 200
 }
 
-const findPlugins = (component: ScreenProps, foundPlugins: string[]) => {
+function findPlugins(component: ScreenProps, foundPlugins: string[]) {
   if (!component) {
     return
   }

package/src/api/controllers/script.ts

@@ -0,0 +1,12 @@
+import ScriptRunner from "../../utilities/scriptRunner"
+import { BBContext } from "@budibase/types"
+
+export async function execute(ctx: BBContext) {
+  const { script, context } = ctx.request.body
+  const runner = new ScriptRunner(script, context)
+  ctx.body = runner.execute()
+}
+
+export async function save(ctx: BBContext) {
+  ctx.throw(501, "Not currently implemented")
+}