@budibase/server 2.1.43-alpha.1 → 2.1.43

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

@@ -1,41 +1,35 @@
-import * as linkRows from "../../../db/linkedRows"
-import {
+const linkRows = require("../../../db/linkedRows")
+const {
   generateRowID,
   getRowParams,
   getTableIDFromRowID,
   DocumentType,
   InternalTables,
-} from "../../../db/utils"
-import * as userController from "../user"
-import {
+} = require("../../../db/utils")
+const { dangerousGetDB } = require("@budibase/backend-core/db")
+const userController = require("../user")
+const {
   inputProcessing,
   outputProcessing,
   cleanupAttachments,
-} from "../../../utilities/rowProcessor"
-import { FieldTypes } from "../../../constants"
-import { validate as rowValidate, findRow } from "./utils"
-import { fullSearch, paginatedSearch } from "./internalSearch"
-import { getGlobalUsersFromMetadata } from "../../../utilities/global"
-import * as inMemoryViews from "../../../db/inMemoryView"
-import env from "../../../environment"
-import {
+} = require("../../../utilities/rowProcessor")
+const { FieldTypes } = require("../../../constants")
+const { validate, findRow } = require("./utils")
+const { fullSearch, paginatedSearch } = require("./internalSearch")
+const { getGlobalUsersFromMetadata } = require("../../../utilities/global")
+const inMemoryViews = require("../../../db/inMemoryView")
+const env = require("../../../environment")
+const {
   migrateToInMemoryView,
   migrateToDesignView,
   getFromDesignDoc,
   getFromMemoryDoc,
-} from "../view/utils"
-import { cloneDeep } from "lodash/fp"
-import { context, db as dbCore } from "@budibase/backend-core"
-import { finaliseRow, updateRelatedFormula } from "./staticFormula"
-import * as exporters from "../view/exporters"
-import { apiFileReturn } from "../../../utilities/fileSystem"
-import {
-  BBContext,
-  Database,
-  LinkDocumentValue,
-  Row,
-  Table,
-} from "@budibase/types"
+} = require("../view/utils")
+const { cloneDeep } = require("lodash/fp")
+const { getAppDB } = require("@budibase/backend-core/context")
+const { finaliseRow, updateRelatedFormula } = require("./staticFormula")
+const exporters = require("../view/exporters")
+const { apiFileReturn } = require("../../../utilities/fileSystem")
 
 const CALCULATION_TYPES = {
   SUM: "sum",
@@ -43,7 +37,7 @@ const CALCULATION_TYPES = {
   STATS: "stats",
 }
 
-async function getView(db: Database, viewName: string) {
+async function getView(db, viewName) {
   let mainGetter = env.SELF_HOSTED ? getFromDesignDoc : getFromMemoryDoc
   let secondaryGetter = env.SELF_HOSTED ? getFromMemoryDoc : getFromDesignDoc
   let migration = env.SELF_HOSTED ? migrateToDesignView : migrateToInMemoryView
@@ -51,7 +45,7 @@ async function getView(db: Database, viewName: string) {
     migrate = false
   try {
     viewInfo = await mainGetter(db, viewName)
-  } catch (err: any) {
+  } catch (err) {
     // check if it can be retrieved from design doc (needs migrated)
     if (err.status !== 404) {
       viewInfo = null
@@ -69,7 +63,7 @@ async function getView(db: Database, viewName: string) {
   return viewInfo
 }
 
-async function getRawTableData(ctx: BBContext, db: Database, tableId: string) {
+async function getRawTableData(ctx, db, tableId) {
   let rows
   if (tableId === InternalTables.USER_METADATA) {
     await userController.fetchMetadata(ctx)
@@ -82,11 +76,11 @@ async function getRawTableData(ctx: BBContext, db: Database, tableId: string) {
     )
     rows = response.rows.map(row => row.doc)
   }
-  return rows as Row[]
+  return rows
 }
 
-export async function patch(ctx: BBContext) {
-  const db = context.getAppDB()
+exports.patch = async ctx => {
+  const db = getAppDB()
   const inputs = ctx.request.body
   const tableId = inputs.tableId
   const isUserTable = tableId === InternalTables.USER_METADATA
@@ -110,15 +104,15 @@ export async function patch(ctx: BBContext) {
   }
   let dbTable = await db.get(tableId)
   // need to build up full patch fields before coerce
-  let combinedRow: any = cloneDeep(oldRow)
+  let combinedRow = cloneDeep(oldRow)
   for (let key of Object.keys(inputs)) {
     if (!dbTable.schema[key]) continue
     combinedRow[key] = inputs[key]
   }
 
   // this returns the table and row incase they have been updated
-  let { table, row } = inputProcessing(ctx.user!, dbTable, combinedRow)
-  const validateResult = await rowValidate({
+  let { table, row } = inputProcessing(ctx.user, dbTable, combinedRow)
+  const validateResult = await validate({
     row,
     table,
   })
@@ -128,12 +122,12 @@ export async function patch(ctx: BBContext) {
   }
 
   // returned row is cleaned and prepared for writing to DB
-  row = (await linkRows.updateLinks({
+  row = await linkRows.updateLinks({
     eventType: linkRows.EventType.ROW_UPDATE,
     row,
     tableId: row.tableId,
     table,
-  })) as Row
+  })
   // check if any attachments removed
   await cleanupAttachments(table, { oldRow, row })
 
@@ -150,8 +144,8 @@ export async function patch(ctx: BBContext) {
   })
 }
 
-export async function save(ctx: BBContext) {
-  const db = context.getAppDB()
+exports.save = async function (ctx) {
+  const db = getAppDB()
   let inputs = ctx.request.body
   inputs.tableId = ctx.params.tableId
 
@@ -161,8 +155,8 @@ export async function save(ctx: BBContext) {
 
   // this returns the table and row incase they have been updated
   const dbTable = await db.get(inputs.tableId)
-  let { table, row } = inputProcessing(ctx.user!, dbTable, inputs)
-  const validateResult = await rowValidate({
+  let { table, row } = inputProcessing(ctx.user, dbTable, inputs)
+  const validateResult = await validate({
     row,
     table,
   })
@@ -172,12 +166,12 @@ export async function save(ctx: BBContext) {
   }
 
   // make sure link rows are up to date
-  row = (await linkRows.updateLinks({
+  row = await linkRows.updateLinks({
     eventType: linkRows.EventType.ROW_SAVE,
     row,
     tableId: row.tableId,
     table,
-  })) as Row
+  })
 
   return finaliseRow(table, row, {
     oldTable: dbTable,
@@ -185,16 +179,16 @@ export async function save(ctx: BBContext) {
   })
 }
 
-export async function fetchView(ctx: BBContext) {
+exports.fetchView = async ctx => {
   const viewName = ctx.params.viewName
 
   // if this is a table view being looked for just transfer to that
   if (viewName.startsWith(DocumentType.TABLE)) {
     ctx.params.tableId = viewName
-    return fetch(ctx)
+    return exports.fetch(ctx)
   }
 
-  const db = context.getAppDB()
+  const db = getAppDB()
   const { calculation, group, field } = ctx.query
   const viewInfo = await getView(db, viewName)
   let response
@@ -206,12 +200,7 @@ export async function fetchView(ctx: BBContext) {
   } else {
     const tableId = viewInfo.meta.tableId
     const data = await getRawTableData(ctx, db, tableId)
-    response = await inMemoryViews.runView(
-      viewInfo,
-      calculation as string,
-      !!group,
-      data
-    )
+    response = await inMemoryViews.runView(viewInfo, calculation, group, data)
   }
 
   let rows
@@ -252,8 +241,8 @@ export async function fetchView(ctx: BBContext) {
   return rows
 }
 
-export async function fetch(ctx: BBContext) {
-  const db = context.getAppDB()
+exports.fetch = async ctx => {
+  const db = getAppDB()
 
   const tableId = ctx.params.tableId
   let table = await db.get(tableId)
@@ -261,16 +250,16 @@ export async function fetch(ctx: BBContext) {
   return outputProcessing(table, rows)
 }
 
-export async function find(ctx: BBContext) {
-  const db = dbCore.getDB(ctx.appId)
+exports.find = async ctx => {
+  const db = dangerousGetDB(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)
   return row
 }
 
-export async function destroy(ctx: BBContext) {
-  const db = context.getAppDB()
+exports.destroy = async function (ctx) {
+  const db = getAppDB()
   const { _id } = ctx.request.body
   let row = await db.get(_id)
   let _rev = ctx.request.body._rev || row._rev
@@ -305,20 +294,18 @@ export async function destroy(ctx: BBContext) {
   return { response, row }
 }
 
-export async function bulkDestroy(ctx: BBContext) {
-  const db = context.getAppDB()
+exports.bulkDestroy = async ctx => {
+  const db = getAppDB()
   const tableId = ctx.params.tableId
   const table = await db.get(tableId)
   let { rows } = ctx.request.body
 
   // before carrying out any updates, make sure the rows are ready to be returned
   // they need to be the full rows (including previous relationships) for automations
-  const processedRows = (await outputProcessing(table, rows, {
-    squash: false,
-  })) as Row[]
+  rows = await outputProcessing(table, rows, { squash: false })
 
   // remove the relationships first
-  let updates: Promise<any>[] = processedRows.map(row =>
+  let updates = rows.map(row =>
     linkRows.updateLinks({
       eventType: linkRows.EventType.ROW_DELETE,
       row,
@@ -327,7 +314,7 @@ export async function bulkDestroy(ctx: BBContext) {
   )
   if (tableId === InternalTables.USER_METADATA) {
     updates = updates.concat(
-      processedRows.map(row => {
+      rows.map(row => {
         ctx.params = {
           id: row._id,
         }
@@ -335,23 +322,23 @@ export async function bulkDestroy(ctx: BBContext) {
       })
     )
   } else {
-    await db.bulkDocs(processedRows.map(row => ({ ...row, _deleted: true })))
+    await db.bulkDocs(rows.map(row => ({ ...row, _deleted: true })))
   }
   // remove any attachments that were on the rows from object storage
-  await cleanupAttachments(table, { rows: processedRows })
-  await updateRelatedFormula(table, processedRows)
+  await cleanupAttachments(table, { rows })
+  await updateRelatedFormula(table, rows)
   await Promise.all(updates)
-  return { response: { ok: true }, rows: processedRows }
+  return { response: { ok: true }, rows }
 }
 
-export async function search(ctx: BBContext) {
+exports.search = async ctx => {
   // Fetch the whole table when running in cypress, as search doesn't work
   if (!env.COUCH_DB_URL && env.isCypress()) {
-    return { rows: await fetch(ctx) }
+    return { rows: await exports.fetch(ctx) }
   }
 
   const { tableId } = ctx.params
-  const db = context.getAppDB()
+  const db = getAppDB()
   const { paginate, query, ...params } = ctx.request.body
   params.version = ctx.version
   params.tableId = tableId
@@ -376,15 +363,15 @@ export async function search(ctx: BBContext) {
   return response
 }
 
-export async function validate(ctx: BBContext) {
-  return rowValidate({
+exports.validate = async ctx => {
+  return validate({
     tableId: ctx.params.tableId,
     row: ctx.request.body,
   })
 }
 
-export async function exportRows(ctx: BBContext) {
-  const db = context.getAppDB()
+exports.exportRows = async ctx => {
+  const db = getAppDB()
   const table = await db.get(ctx.params.tableId)
   const rowIds = ctx.request.body.rows
   let format = ctx.query.format
@@ -396,8 +383,8 @@ export async function exportRows(ctx: BBContext) {
     })
   ).rows.map(row => row.doc)
 
-  let result = (await outputProcessing(table, response)) as Row[]
-  let rows: Row[] = []
+  let result = await outputProcessing(table, response)
+  let rows = []
 
   // Filter data to only specified columns if required
   if (columns && columns.length) {
@@ -412,7 +399,6 @@ export async function exportRows(ctx: BBContext) {
   }
 
   let headers = Object.keys(rows[0])
-  // @ts-ignore
   const exporter = exporters[format]
   const filename = `export.${format}`
 
@@ -421,8 +407,8 @@ export async function exportRows(ctx: BBContext) {
   return apiFileReturn(exporter(headers, rows))
 }
 
-export async function fetchEnrichedRow(ctx: BBContext) {
-  const db = context.getAppDB()
+exports.fetchEnrichedRow = async ctx => {
+  const db = getAppDB()
   const tableId = ctx.params.tableId
   const rowId = ctx.params.rowId
   // need table to work out where links go in row
@@ -431,10 +417,10 @@ export async function fetchEnrichedRow(ctx: BBContext) {
     findRow(ctx, tableId, rowId),
   ])
   // get the link docs
-  const linkVals = (await linkRows.getLinkDocuments({
+  const linkVals = await linkRows.getLinkDocuments({
     tableId,
     rowId,
-  })) as LinkDocumentValue[]
+  })
   // look up the actual rows based on the ids
   let response = (
     await db.allDocs({
@@ -443,8 +429,8 @@ export async function fetchEnrichedRow(ctx: BBContext) {
     })
   ).rows.map(row => row.doc)
   // group responses by table
-  let groups: any = {},
-    tables: Record<string, Table> = {}
+  let groups = {},
+    tables = {}
   for (let row of response) {
     if (!row.tableId) {
       row.tableId = getTableIDFromRowID(row._id)
@@ -457,11 +443,11 @@ export async function fetchEnrichedRow(ctx: BBContext) {
       groups[linkedTableId].push(row)
     }
   }
-  let linkedRows: Row[] = []
+  let linkedRows = []
   for (let [tableId, rows] of Object.entries(groups)) {
     // need to include the IDs in these rows for any links they may have
     linkedRows = linkedRows.concat(
-      await outputProcessing(tables[tableId], rows as Row[])
+      await outputProcessing(tables[tableId], rows)
     )
   }