@budibase/server 2.1.43-alpha.2 → 2.1.43

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

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

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

@@ -1,14 +1,13 @@
-import { getRowParams } from "../../../db/utils"
-import {
+const { getRowParams } = require("../../../db/utils")
+const {
   outputProcessing,
   processAutoColumn,
   processFormulas,
-} from "../../../utilities/rowProcessor"
-import { FieldTypes, FormulaTypes } from "../../../constants"
-import { context } from "@budibase/backend-core"
-import { Table, Row } from "@budibase/types"
+} = require("../../../utilities/rowProcessor")
+const { FieldTypes, FormulaTypes } = require("../../../constants")
 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
@@ -16,22 +15,22 @@ const { cloneDeep } = require("lodash/fp")
  * updated.
  * NOTE: this will only for affect static formulas.
  */
-export async function updateRelatedFormula(table: Table, enrichedRows: Row[]) {
-  const db = context.getAppDB()
+exports.updateRelatedFormula = async (table, enrichedRows) => {
+  const db = getAppDB()
   // no formula to update, we're done
   if (!table.relatedFormula) {
     return
   }
-  let promises: Promise<any>[] = []
+  let promises = []
   for (let enrichedRow of Array.isArray(enrichedRows)
     ? enrichedRows
     : [enrichedRows]) {
     // the related rows by tableId
-    let relatedRows: Record<string, Row[]> = {}
+    let relatedRows = {}
     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] = []
         }
@@ -39,7 +38,7 @@ export async function updateRelatedFormula(table: Table, enrichedRows: Row[]) {
       }
     }
     for (let tableId of table.relatedFormula) {
-      let relatedTable: Table
+      let relatedTable
       try {
         // no rows to update, skip
         if (!relatedRows[tableId] || relatedRows[tableId].length === 0) {
@@ -49,7 +48,7 @@ export async function updateRelatedFormula(table: Table, enrichedRows: Row[]) {
       } 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 &&
@@ -58,7 +57,7 @@ export async function updateRelatedFormula(table: Table, enrichedRows: Row[]) {
           // re-enrich rows for all the related, don't update the related formula for them
           promises = promises.concat(
             relatedRows[tableId].map(related =>
-              finaliseRow(relatedTable, related, {
+              exports.finaliseRow(relatedTable, related, {
                 updateFormula: false,
               })
             )
@@ -71,8 +70,8 @@ export async function updateRelatedFormula(table: Table, enrichedRows: Row[]) {
   await Promise.all(promises)
 }
 
-export async function updateAllFormulasInTable(table: Table) {
-  const db = context.getAppDB()
+exports.updateAllFormulasInTable = async table => {
+  const db = getAppDB()
   // start by getting the raw rows (which will be written back to DB after update)
   let rows = (
     await db.allDocs(
@@ -89,9 +88,7 @@ export async function updateAllFormulasInTable(table: Table) {
   const updatedRows = []
   for (let row of rows) {
     // find the enriched row, if found process the formulas
-    const enrichedRow = enrichedRows.find(
-      (enriched: any) => enriched._id === row._id
-    )
+    const enrichedRow = enrichedRows.find(enriched => enriched._id === row._id)
     if (enrichedRow) {
       const processed = processFormulas(table, cloneDeep(row), {
         dynamic: false,
@@ -112,19 +109,17 @@ export async function updateAllFormulasInTable(table: 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.
  */
-export async function finaliseRow(
-  table: Table,
-  row: Row,
-  { oldTable, updateFormula }: { oldTable?: Table; updateFormula: boolean } = {
-    updateFormula: true,
-  }
-) {
-  const db = context.getAppDB()
+exports.finaliseRow = async (
+  table,
+  row,
+  { oldTable, updateFormula } = { updateFormula: true }
+) => {
+  const db = 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,
@@ -136,7 +131,7 @@ export async function finaliseRow(
   if (oldTable && !isEqual(oldTable, table)) {
     try {
       await db.put(table)
-    } catch (err: any) {
+    } catch (err) {
       if (err.status === 409) {
         const updatedTable = await db.get(table._id)
         let response = processAutoColumn(null, updatedTable, row, {

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

@@ -1,32 +1,33 @@
-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: string) {
+  parse: function (value) {
     return new Date(value).getTime()
   },
   // Input is a unix timestamp
-  format: function (value: string) {
+  format: function (value) {
     return new Date(value).toISOString()
   },
 })
 
-export async function getDatasourceAndQuery(json: any) {
+exports.removeKeyNumbering = removeKeyNumbering
+
+exports.getDatasourceAndQuery = async json => {
   const datasourceId = json.endpoint.datasourceId
-  const db = context.getAppDB()
+  const db = getAppDB()
   const datasource = await db.get(datasourceId)
   return makeExternalQuery(datasource, json)
 }
 
-export async function findRow(ctx: BBContext, tableId: string, rowId: string) {
-  const db = context.getAppDB()
+exports.findRow = async (ctx, tableId, rowId) => {
+  const db = getAppDB()
   let row
   // TODO remove special user case in future
   if (tableId === InternalTables.USER_METADATA) {
@@ -44,26 +45,15 @@ export async function findRow(ctx: BBContext, tableId: string, rowId: string) {
   return row
 }
 
-export async function validate({
-  tableId,
-  row,
-  table,
-}: {
-  tableId?: string
-  row: Row
-  table?: Table
-}) {
-  let fetchedTable: Table
+exports.validate = async ({ tableId, row, table }) => {
   if (!table) {
-    const db = context.getAppDB()
-    fetchedTable = await db.get(tableId)
-  } else {
-    fetchedTable = table
+    const db = getAppDB()
+    table = await db.get(tableId)
   }
-  const errors: any = {}
-  for (let fieldName of Object.keys(fetchedTable.schema)) {
-    const constraints = cloneDeep(fetchedTable.schema[fieldName].constraints)
-    const type = fetchedTable.schema[fieldName].type
+  const errors = {}
+  for (let fieldName of Object.keys(table.schema)) {
+    const constraints = cloneDeep(table.schema[fieldName].constraints)
+    const type = table.schema[fieldName].type
     // formulas shouldn't validated, data will be deleted anyway
     if (type === FieldTypes.FORMULA) {
       continue
@@ -80,7 +70,7 @@ export async function validate({
         if (!Array.isArray(row[fieldName])) {
           row[fieldName] = row[fieldName].split(",")
         }
-        row[fieldName].map((val: any) => {
+        row[fieldName].map(val => {
           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, BBContext } from "@budibase/types"
+import { Plugin, ScreenProps } from "@budibase/types"
 
-export async function fetch(ctx: BBContext) {
+exports.fetch = async (ctx: any) => {
   const db = context.getAppDB()
 
   const screens = (
@@ -20,17 +20,13 @@ export async function fetch(ctx: BBContext) {
     )
   ).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,
-    roleId
+    ctx.user.role._id
   )
 }
 
-export async function save(ctx: BBContext) {
+exports.save = async (ctx: any) => {
   const db = context.getAppDB()
   let screen = ctx.request.body
 
@@ -96,7 +92,7 @@ export async function save(ctx: BBContext) {
   }
 }
 
-export async function destroy(ctx: BBContext) {
+exports.destroy = async (ctx: any) => {
   const db = context.getAppDB()
   const id = ctx.params.screenId
   const screen = await db.get(id)
@@ -110,7 +106,7 @@ export async function destroy(ctx: BBContext) {
   ctx.status = 200
 }
 
-function findPlugins(component: ScreenProps, foundPlugins: string[]) {
+const findPlugins = (component: ScreenProps, foundPlugins: string[]) => {
   if (!component) {
     return
   }

package/src/api/controllers/script.js

@@ -0,0 +1,11 @@
+const ScriptRunner = require("../../utilities/scriptRunner")
+
+exports.execute = async function (ctx) {
+  const { script, context } = ctx.request.body
+  const runner = new ScriptRunner(script, context)
+  ctx.body = runner.execute()
+}
+
+exports.save = async function (ctx) {
+  ctx.throw(501, "Not currently implemented")
+}