@budibase/server 2.1.43-alpha.1 → 2.1.43

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

@@ -1,117 +1,104 @@
-import {
+const {
+  DataSourceOperation,
   SortDirection,
   FieldTypes,
   NoEmptyFilterStrings,
-} from "../../../constants"
-import {
+} = require("../../../constants")
+const {
   breakExternalTableId,
   breakRowIdField,
-} from "../../../integrations/utils"
-import { ExternalRequest, RunConfig } from "./ExternalRequest"
-import { context } from "@budibase/backend-core"
-import * as exporters from "../view/exporters"
-import { apiFileReturn } from "../../../utilities/fileSystem"
-import {
-  Operation,
-  BBContext,
-  Row,
-  PaginationJson,
-  Table,
-  Datasource,
-} from "@budibase/types"
+} = require("../../../integrations/utils")
+const ExternalRequest = require("./ExternalRequest")
+const { getAppDB } = require("@budibase/backend-core/context")
+const exporters = require("../view/exporters")
+const { apiFileReturn } = require("../../../utilities/fileSystem")
 
-export async function handleRequest(
-  operation: Operation,
-  tableId: string,
-  opts?: RunConfig
-) {
+async function handleRequest(operation, tableId, opts = {}) {
   // make sure the filters are cleaned up, no empty strings for equals, fuzzy or string
   if (opts && opts.filters) {
     for (let filterField of NoEmptyFilterStrings) {
       if (!opts.filters[filterField]) {
         continue
       }
-      // @ts-ignore
       for (let [key, value] of Object.entries(opts.filters[filterField])) {
         if (!value || value === "") {
-          // @ts-ignore
           delete opts.filters[filterField][key]
         }
       }
     }
   }
-  return new ExternalRequest(operation, tableId, opts?.datasource).run(
-    opts || {}
-  )
+  return new ExternalRequest(operation, tableId, opts.datasource).run(opts)
 }
 
-export async function patch(ctx: BBContext) {
+exports.handleRequest = handleRequest
+
+exports.patch = async ctx => {
   const inputs = ctx.request.body
   const tableId = ctx.params.tableId
   const id = inputs._id
   // don't save the ID to db
   delete inputs._id
-  return handleRequest(Operation.UPDATE, tableId, {
+  return handleRequest(DataSourceOperation.UPDATE, tableId, {
     id: breakRowIdField(id),
     row: inputs,
   })
 }
 
-export async function save(ctx: BBContext) {
+exports.save = async ctx => {
   const inputs = ctx.request.body
   const tableId = ctx.params.tableId
-  return handleRequest(Operation.CREATE, tableId, {
+  return handleRequest(DataSourceOperation.CREATE, tableId, {
     row: inputs,
   })
 }
 
-export async function fetchView(ctx: BBContext) {
+exports.fetchView = async ctx => {
   // there are no views in external datasources, shouldn't ever be called
   // for now just fetch
   const split = ctx.params.viewName.split("all_")
   ctx.params.tableId = split[1] ? split[1] : split[0]
-  return fetch(ctx)
+  return exports.fetch(ctx)
 }
 
-export async function fetch(ctx: BBContext) {
+exports.fetch = async ctx => {
   const tableId = ctx.params.tableId
-  return handleRequest(Operation.READ, tableId)
+  return handleRequest(DataSourceOperation.READ, tableId)
 }
 
-export async function find(ctx: BBContext) {
+exports.find = async ctx => {
   const id = ctx.params.rowId
   const tableId = ctx.params.tableId
-  const response = (await handleRequest(Operation.READ, tableId, {
+  const response = await handleRequest(DataSourceOperation.READ, tableId, {
     id: breakRowIdField(id),
-  })) as Row[]
+  })
   return response ? response[0] : response
 }
 
-export async function destroy(ctx: BBContext) {
+exports.destroy = async ctx => {
   const tableId = ctx.params.tableId
   const id = ctx.request.body._id
-  const { row } = (await handleRequest(Operation.DELETE, tableId, {
+  const { row } = await handleRequest(DataSourceOperation.DELETE, tableId, {
     id: breakRowIdField(id),
-  })) as { row: Row }
+  })
   return { response: { ok: true }, row }
 }
 
-export async function bulkDestroy(ctx: BBContext) {
+exports.bulkDestroy = async ctx => {
   const { rows } = ctx.request.body
   const tableId = ctx.params.tableId
   let promises = []
   for (let row of rows) {
     promises.push(
-      handleRequest(Operation.DELETE, tableId, {
+      handleRequest(DataSourceOperation.DELETE, tableId, {
         id: breakRowIdField(row._id),
       })
     )
   }
-  const responses = (await Promise.all(promises)) as { row: Row }[]
+  const responses = await Promise.all(promises)
   return { response: { ok: true }, rows: responses.map(resp => resp.row) }
 }
 
-export async function search(ctx: BBContext) {
+exports.search = async ctx => {
   const tableId = ctx.params.tableId
   const { paginate, query, ...params } = ctx.request.body
   let { bookmark, limit } = params
@@ -142,26 +129,26 @@ export async function search(ctx: BBContext) {
     }
   }
   try {
-    const rows = (await handleRequest(Operation.READ, tableId, {
+    const rows = await handleRequest(DataSourceOperation.READ, tableId, {
       filters: query,
       sort,
-      paginate: paginateObj as PaginationJson,
-    })) as Row[]
+      paginate: paginateObj,
+    })
     let hasNextPage = false
     if (paginate && rows.length === limit) {
-      const nextRows = (await handleRequest(Operation.READ, tableId, {
+      const nextRows = await handleRequest(DataSourceOperation.READ, tableId, {
         filters: query,
         sort,
         paginate: {
           limit: 1,
           page: bookmark * limit + 1,
         },
-      })) as Row[]
+      })
       hasNextPage = nextRows.length > 0
     }
     // need wrapper object for bookmarks etc when paginating
     return { rows, hasNextPage, bookmark: bookmark + 1 }
-  } catch (err: any) {
+  } catch (err) {
     if (err.message && err.message.includes("does not exist")) {
       throw new Error(
         `Table updated externally, please re-fetch - ${err.message}`
@@ -172,14 +159,14 @@ export async function search(ctx: BBContext) {
   }
 }
 
-export async function validate(ctx: BBContext) {
+exports.validate = async () => {
   // can't validate external right now - maybe in future
   return { valid: true }
 }
 
-export async function exportRows(ctx: BBContext) {
+exports.exportRows = async ctx => {
   const { datasourceId } = breakExternalTableId(ctx.params.tableId)
-  const db = context.getAppDB()
+  const db = getAppDB()
   const format = ctx.query.format
   const { columns } = ctx.request.body
   const datasource = await db.get(datasourceId)
@@ -189,15 +176,13 @@ export async function exportRows(ctx: BBContext) {
   ctx.request.body = {
     query: {
       oneOf: {
-        _id: ctx.request.body.rows.map(
-          (row: string) => JSON.parse(decodeURI(row))[0]
-        ),
+        _id: ctx.request.body.rows.map(row => JSON.parse(decodeURI(row))[0]),
       },
     },
   }
 
-  let result = await search(ctx)
-  let rows: Row[] = []
+  let result = await exports.search(ctx)
+  let rows = []
 
   // Filter data to only specified columns if required
   if (columns && columns.length) {
@@ -212,7 +197,6 @@ export async function exportRows(ctx: BBContext) {
   }
 
   let headers = Object.keys(rows[0])
-  // @ts-ignore
   const exporter = exporters[format]
   const filename = `export.${format}`
 
@@ -221,24 +205,21 @@ export async function exportRows(ctx: BBContext) {
   return apiFileReturn(exporter(headers, rows))
 }
 
-export async function fetchEnrichedRow(ctx: BBContext) {
+exports.fetchEnrichedRow = async ctx => {
   const id = ctx.params.rowId
   const tableId = ctx.params.tableId
   const { datasourceId, tableName } = breakExternalTableId(tableId)
-  const db = context.getAppDB()
-  const datasource: Datasource = await db.get(datasourceId)
-  if (!tableName) {
-    ctx.throw(400, "Unable to find table.")
-  }
+  const db = getAppDB()
+  const datasource = await db.get(datasourceId)
   if (!datasource || !datasource.entities) {
     ctx.throw(400, "Datasource has not been configured for plus API.")
   }
   const tables = datasource.entities
-  const response = (await handleRequest(Operation.READ, tableId, {
+  const response = await handleRequest(DataSourceOperation.READ, tableId, {
     id,
     datasource,
-  })) as Row[]
-  const table: Table = tables[tableName]
+  })
+  const table = tables[tableName]
   const row = response[0]
   // this seems like a lot of work, but basically we need to dig deeper for the enrich
   // for a single row, there is probably a better way to do this with some smart multi-layer joins
@@ -252,19 +233,21 @@ export async function fetchEnrichedRow(ctx: BBContext) {
     }
     const links = row[fieldName]
     const linkedTableId = field.tableId
-    const linkedTableName = breakExternalTableId(linkedTableId).tableName!
-    const linkedTable = tables[linkedTableName]
+    const linkedTable = tables[breakExternalTableId(linkedTableId).tableName]
     // don't support composite keys right now
-    const linkedIds = links.map((link: Row) => breakRowIdField(link._id!)[0])
-    const primaryLink = linkedTable.primary?.[0] as string
-    row[fieldName] = await handleRequest(Operation.READ, linkedTableId!, {
-      tables,
-      filters: {
-        oneOf: {
-          [primaryLink]: linkedIds,
+    const linkedIds = links.map(link => breakRowIdField(link._id)[0])
+    row[fieldName] = await handleRequest(
+      DataSourceOperation.READ,
+      linkedTableId,
+      {
+        tables,
+        filters: {
+          oneOf: {
+            [linkedTable.primary]: linkedIds,
+          },
         },
-      },
-    })
+      }
+    )
   }
   return row
 }

package/src/api/controllers/row/index.ts

@@ -1,6 +1,6 @@
 import { quotas } from "@budibase/pro"
-import * as internal from "./internal"
-import * as external from "./external"
+import internal from "./internal"
+import external from "./external"
 import { isExternalTable } from "../../../integrations/utils"
 
 function pickApi(tableId: any) {
@@ -30,24 +30,16 @@ export async function patch(ctx: any): Promise<any> {
   if (body && !body._id) {
     return save(ctx)
   }
-  try {
-    const { row, table } = await quotas.addQuery(
-      () => pickApi(tableId).patch(ctx),
-      {
-        datasourceId: tableId,
-      }
-    )
-    if (!row) {
-      ctx.throw(404, "Row not found")
+  const { row, table } = await quotas.addQuery(
+    () => pickApi(tableId).patch(ctx),
+    {
+      datasourceId: tableId,
     }
-    ctx.status = 200
-    ctx.eventEmitter &&
-      ctx.eventEmitter.emitRow(`row:update`, appId, row, table)
-    ctx.message = `${table.name} updated successfully.`
-    ctx.body = row
-  } catch (err) {
-    ctx.throw(400, err)
-  }
+  )
+  ctx.status = 200
+  ctx.eventEmitter && ctx.eventEmitter.emitRow(`row:update`, appId, row, table)
+  ctx.message = `${table.name} updated successfully.`
+  ctx.body = row
 }
 
 export const save = async (ctx: any) => {