@budibase/server 2.1.32-alpha.8 → 2.1.32

package/src/api/controllers/table/{index.ts → index.js}

@@ -1,13 +1,13 @@
-import * as internal from "./internal"
-import * as external from "./external"
-import csvParser from "../../../utilities/csvParser"
-import { isExternalTable, isSQL } from "../../../integrations/utils"
-import { getDatasourceParams } from "../../../db/utils"
-import { context, events } from "@budibase/backend-core"
-import { Table, BBContext } from "@budibase/types"
-import sdk from "../../../sdk"
+const internal = require("./internal")
+const external = require("./external")
+const csvParser = require("../../../utilities/csvParser")
+const { isExternalTable, isSQL } = require("../../../integrations/utils")
+const { getDatasourceParams } = require("../../../db/utils")
+const { getAppDB } = require("@budibase/backend-core/context")
+const { events } = require("@budibase/backend-core")
+const sdk = require("../../../sdk")
 
-function pickApi({ tableId, table }: { tableId?: string; table?: Table }) {
+function pickApi({ tableId, table }) {
   if (table && !tableId) {
     tableId = table._id
   }
@@ -20,8 +20,8 @@ function pickApi({ tableId, table }: { tableId?: string; table?: Table }) {
 }
 
 // covers both internal and external
-export async function fetch(ctx: BBContext) {
-  const db = context.getAppDB()
+exports.fetch = async function (ctx) {
+  const db = getAppDB()
 
   const internal = await sdk.tables.getAllInternalTables()
 
@@ -34,7 +34,7 @@ export async function fetch(ctx: BBContext) {
   const external = externalTables.rows.flatMap(tableDoc => {
     let entities = tableDoc.doc.entities
     if (entities) {
-      return Object.values(entities).map((entity: any) => ({
+      return Object.values(entities).map(entity => ({
         ...entity,
         type: "external",
         sourceId: tableDoc.doc._id,
@@ -48,12 +48,12 @@ export async function fetch(ctx: BBContext) {
   ctx.body = [...internal, ...external]
 }
 
-export async function find(ctx: BBContext) {
+exports.find = async function (ctx) {
   const tableId = ctx.params.tableId
   ctx.body = await sdk.tables.getTable(tableId)
 }
 
-export async function save(ctx: BBContext) {
+exports.save = async function (ctx) {
   const appId = ctx.appId
   const table = ctx.request.body
   const importFormat =
@@ -74,7 +74,7 @@ export async function save(ctx: BBContext) {
   ctx.body = savedTable
 }
 
-export async function destroy(ctx: BBContext) {
+exports.destroy = async function (ctx) {
   const appId = ctx.appId
   const tableId = ctx.params.tableId
   const deletedTable = await pickApi({ tableId }).destroy(ctx)
@@ -86,7 +86,7 @@ export async function destroy(ctx: BBContext) {
   ctx.body = { message: `Table ${tableId} deleted.` }
 }
 
-export async function bulkImport(ctx: BBContext) {
+exports.bulkImport = async function (ctx) {
   const tableId = ctx.params.tableId
   await pickApi({ tableId }).bulkImport(ctx)
   // right now we don't trigger anything for bulk import because it
@@ -96,7 +96,7 @@ export async function bulkImport(ctx: BBContext) {
   ctx.body = { message: `Bulk rows created.` }
 }
 
-export async function validateCSVSchema(ctx: BBContext) {
+exports.validateCSVSchema = async function (ctx) {
   // tableId being specified means its an import to an existing table
   const { csvString, schema = {}, tableId } = ctx.request.body
   let existingTable

package/src/api/controllers/table/internal.ts

@@ -2,7 +2,7 @@ import { updateLinks, EventType } from "../../../db/linkedRows"
 import { getRowParams, generateTableID } from "../../../db/utils"
 import { FieldTypes } from "../../../constants"
 import { TableSaveFunctions, hasTypeChanged, handleDataImport } from "./utils"
-import { context } from "@budibase/backend-core"
+const { getAppDB } = require("@budibase/backend-core/context")
 import { isTest } from "../../../environment"
 import {
   cleanupAttachments,
@@ -35,7 +35,7 @@ function checkAutoColumns(table: Table, oldTable: Table) {
 }
 
 export async function save(ctx: any) {
-  const db = context.getAppDB()
+  const db = getAppDB()
   const { dataImport, ...rest } = ctx.request.body
   let tableToSave = {
     type: "table",
@@ -133,12 +133,12 @@ export async function save(ctx: any) {
     tableToSave._rev = result.rev
   }
   // has to run after, make sure it has _id
-  await runStaticFormulaChecks(tableToSave, { oldTable, deletion: false })
+  await runStaticFormulaChecks(tableToSave, { oldTable, deletion: null })
   return tableToSave
 }
 
 export async function destroy(ctx: any) {
-  const db = context.getAppDB()
+  const db = getAppDB()
   const tableToDelete = await db.get(ctx.params.tableId)
 
   // Delete all rows for that table
@@ -161,7 +161,7 @@ export async function destroy(ctx: any) {
   })
 
   // don't remove the table itself until very end
-  await db.remove(tableToDelete._id, tableToDelete._rev)
+  await db.remove(tableToDelete)
 
   // remove table search index
   if (!isTest() || env.COUCH_DB_URL) {
@@ -176,6 +176,7 @@ export async function destroy(ctx: any) {
 
   // has to run after, make sure it has _id
   await runStaticFormulaChecks(tableToDelete, {
+    oldTable: null,
     deletion: true,
   })
   await cleanupAttachments(tableToDelete, {

package/src/api/controllers/table/utils.ts

@@ -13,28 +13,28 @@ import {
 } from "../../../constants"
 import { getViews, saveView } from "../view/utils"
 import viewTemplate from "../view/viewBuilder"
+const { getAppDB } = require("@budibase/backend-core/context")
 import { cloneDeep } from "lodash/fp"
 import { quotas } from "@budibase/pro"
-import { events, context } from "@budibase/backend-core"
-import { Database } from "@budibase/types"
+import { events } from "@budibase/backend-core"
 
 export async function clearColumns(table: any, columnNames: any) {
-  const db: Database = context.getAppDB()
+  const db = getAppDB()
   const rows = await db.allDocs(
     getRowParams(table._id, null, {
       include_docs: true,
     })
   )
-  return (await db.bulkDocs(
+  return db.bulkDocs(
     rows.rows.map(({ doc }: any) => {
       columnNames.forEach((colName: any) => delete doc[colName])
       return doc
     })
-  )) as { id: string; _rev?: string }[]
+  )
 }
 
 export async function checkForColumnUpdates(oldTable: any, updatedTable: any) {
-  const db = context.getAppDB()
+  const db = getAppDB()
   let updatedRows = []
   const rename = updatedTable._rename
   let deletedColumns: any = []
@@ -95,7 +95,18 @@ export function makeSureTableUpToDate(table: any, tableToSave: any) {
   return tableToSave
 }
 
-export function importToRows(data: any, table: any, user: any = {}) {
+export async function handleDataImport(user: any, table: any, dataImport: any) {
+  if (!dataImport || !dataImport.csvString) {
+    return table
+  }
+
+  const db = getAppDB()
+  // Populate the table with rows imported from CSV in a bulk update
+  const data = await transform({
+    ...dataImport,
+    existingTable: table,
+  })
+
   let finalData: any = []
   for (let i = 0; i < data.length; i++) {
     let row = data[i]
@@ -125,22 +136,6 @@ export function importToRows(data: any, table: any, user: any = {}) {
 
     finalData.push(row)
   }
-  return finalData
-}
-
-export async function handleDataImport(user: any, table: any, dataImport: any) {
-  if (!dataImport || !dataImport.csvString) {
-    return table
-  }
-
-  const db = context.getAppDB()
-  // Populate the table with rows imported from CSV in a bulk update
-  const data = await transform({
-    ...dataImport,
-    existingTable: table,
-  })
-
-  let finalData: any = importToRows(data, table, user)
 
   await quotas.addRows(finalData.length, () => db.bulkDocs(finalData), {
     tableId: table._id,
@@ -150,7 +145,7 @@ export async function handleDataImport(user: any, table: any, dataImport: any) {
 }
 
 export async function handleSearchIndexes(table: any) {
-  const db = context.getAppDB()
+  const db = getAppDB()
   // create relevant search indexes
   if (table.indexes && table.indexes.length > 0) {
     const currentIndexes = await db.getIndexes()
@@ -214,7 +209,7 @@ class TableSaveFunctions {
   rows: any
 
   constructor({ user, oldTable, dataImport }: any) {
-    this.db = context.getAppDB()
+    this.db = getAppDB()
     this.user = user
     this.oldTable = oldTable
     this.dataImport = dataImport
@@ -338,7 +333,7 @@ export function generateJunctionTableName(
   return `jt_${table.name}_${relatedTable.name}_${column.name}_${column.fieldName}`
 }
 
-export function foreignKeyStructure(keyName: any, meta?: any) {
+export function foreignKeyStructure(keyName: any, meta = null) {
   const structure: any = {
     type: FieldTypes.NUMBER,
     constraints: {},

package/src/api/controllers/{templates.ts → templates.js}

@@ -1,20 +1,17 @@
-import nodeFetch from "node-fetch"
-import { downloadTemplate as dlTemplate } from "../../utilities/fileSystem"
-import env from "../../environment"
-import { BBContext } from "@budibase/types"
+const fetch = require("node-fetch")
+const { downloadTemplate } = require("../../utilities/fileSystem")
+const env = require("../../environment")
 
 // development flag, can be used to test against templates exported locally
 const DEFAULT_TEMPLATES_BUCKET =
   "prod-budi-templates.s3-eu-west-1.amazonaws.com"
 
-export async function fetch(ctx: BBContext) {
+exports.fetch = async function (ctx) {
   let type = env.TEMPLATE_REPOSITORY
   let response,
     error = false
   try {
-    response = await nodeFetch(
-      `https://${DEFAULT_TEMPLATES_BUCKET}/manifest.json`
-    )
+    response = await fetch(`https://${DEFAULT_TEMPLATES_BUCKET}/manifest.json`)
     if (response.status !== 200) {
       error = true
     }
@@ -32,10 +29,10 @@ export async function fetch(ctx: BBContext) {
 
 // can't currently test this, have to ignore from coverage
 /* istanbul ignore next */
-export async function downloadTemplate(ctx: BBContext) {
+exports.downloadTemplate = async function (ctx) {
   const { type, name } = ctx.params
 
-  await dlTemplate(type, name)
+  await downloadTemplate(type, name)
 
   ctx.body = {
     message: `template ${type}:${name} downloaded successfully.`,

package/src/api/controllers/{user.ts → user.js}

@@ -1,22 +1,23 @@
-import {
+const {
   generateUserMetadataID,
   getUserMetadataParams,
   generateUserFlagID,
-} from "../../db/utils"
-import { InternalTables } from "../../db/utils"
-import { getGlobalUsers, getRawGlobalUser } from "../../utilities/global"
-import { getFullUser } from "../../utilities/users"
-import { isEqual } from "lodash"
-import {
-  context,
-  constants,
-  roles as rolesCore,
-  db as dbCore,
-} from "@budibase/backend-core"
-import { BBContext, User } from "@budibase/types"
+} = require("../../db/utils")
+const { InternalTables } = require("../../db/utils")
+const { getGlobalUsers, getRawGlobalUser } = require("../../utilities/global")
+const { getFullUser } = require("../../utilities/users")
+const { isEqual } = require("lodash")
+const { BUILTIN_ROLE_IDS } = require("@budibase/backend-core/roles")
+const {
+  getDevelopmentAppID,
+  getProdAppIDs,
+  dbExists,
+} = require("@budibase/backend-core/db")
+const { UserStatus } = require("@budibase/backend-core/constants")
+const { getAppDB, doInAppContext } = require("@budibase/backend-core/context")
 
 async function rawMetadata() {
-  const db = context.getAppDB()
+  const db = getAppDB()
   return (
     await db.allDocs(
       getUserMetadataParams(null, {
@@ -26,9 +27,9 @@ async function rawMetadata() {
   ).rows.map(row => row.doc)
 }
 
-function combineMetadataAndUser(user: any, metadata: any) {
+function combineMetadataAndUser(user, metadata) {
   // skip users with no access
-  if (user.roleId === rolesCore.BUILTIN_ROLE_IDS.PUBLIC) {
+  if (user.roleId === BUILTIN_ROLE_IDS.PUBLIC) {
     return null
   }
   delete user._rev
@@ -54,9 +55,9 @@ function combineMetadataAndUser(user: any, metadata: any) {
   return null
 }
 
-export async function syncGlobalUsers() {
+exports.syncGlobalUsers = async () => {
   // sync user metadata
-  const db = context.getAppDB()
+  const db = getAppDB()
   const [users, metadata] = await Promise.all([getGlobalUsers(), rawMetadata()])
   const toWrite = []
   for (let user of users) {
@@ -68,13 +69,13 @@ export async function syncGlobalUsers() {
   await db.bulkDocs(toWrite)
 }
 
-export async function syncUser(ctx: BBContext) {
+exports.syncUser = async function (ctx) {
   let deleting = false,
-    user: User | any
+    user
   const userId = ctx.params.id
   try {
     user = await getRawGlobalUser(userId)
-  } catch (err: any) {
+  } catch (err) {
     if (err && err.status === 404) {
       user = {}
       deleting = true
@@ -91,21 +92,21 @@ export async function syncUser(ctx: BBContext) {
   let prodAppIds
   // if they are a builder then get all production app IDs
   if ((user.builder && user.builder.global) || deleting) {
-    prodAppIds = await dbCore.getProdAppIDs()
+    prodAppIds = await getProdAppIDs()
   } else {
     prodAppIds = Object.entries(roles)
-      .filter(entry => entry[1] !== rolesCore.BUILTIN_ROLE_IDS.PUBLIC)
+      .filter(entry => entry[1] !== BUILTIN_ROLE_IDS.PUBLIC)
       .map(([appId]) => appId)
   }
   for (let prodAppId of prodAppIds) {
     const roleId = roles[prodAppId]
-    const devAppId = dbCore.getDevelopmentAppID(prodAppId)
+    const devAppId = getDevelopmentAppID(prodAppId)
     for (let appId of [prodAppId, devAppId]) {
-      if (!(await dbCore.dbExists(appId))) {
+      if (!(await dbExists(appId))) {
         continue
       }
-      await context.doInAppContext(appId, async () => {
-        const db = context.getAppDB()
+      await doInAppContext(appId, async () => {
+        const db = getAppDB()
         const metadataId = generateUserMetadataID(userId)
         let metadata
         try {
@@ -126,8 +127,8 @@ export async function syncUser(ctx: BBContext) {
           ? combineMetadataAndUser(user, metadata)
           : {
               ...metadata,
-              status: constants.UserStatus.INACTIVE,
-              metadata: rolesCore.BUILTIN_ROLE_IDS.PUBLIC,
+              status: UserStatus.INACTIVE,
+              metadata: BUILTIN_ROLE_IDS.PUBLIC,
             }
         // if its null then there was no updates required
         if (combined) {
@@ -141,9 +142,10 @@ export async function syncUser(ctx: BBContext) {
   }
 }
 
-export async function fetchMetadata(ctx: BBContext) {
+exports.fetchMetadata = async function (ctx) {
+  const database = getAppDB()
   const global = await getGlobalUsers()
-  const metadata = await rawMetadata()
+  const metadata = await rawMetadata(database)
   const users = []
   for (let user of global) {
     // find the metadata that matches up to the global ID
@@ -160,18 +162,18 @@ export async function fetchMetadata(ctx: BBContext) {
   ctx.body = users
 }
 
-export async function updateSelfMetadata(ctx: BBContext) {
+exports.updateSelfMetadata = async function (ctx) {
   // overwrite the ID with current users
-  ctx.request.body._id = ctx.user?._id
+  ctx.request.body._id = ctx.user._id
   // make sure no stale rev
   delete ctx.request.body._rev
   // make sure no csrf token
   delete ctx.request.body.csrfToken
-  await updateMetadata(ctx)
+  await exports.updateMetadata(ctx)
 }
 
-export async function updateMetadata(ctx: BBContext) {
-  const db = context.getAppDB()
+exports.updateMetadata = async function (ctx) {
+  const db = getAppDB()
   const user = ctx.request.body
   // this isn't applicable to the user
   delete user.roles
@@ -182,8 +184,8 @@ export async function updateMetadata(ctx: BBContext) {
   ctx.body = await db.put(metadata)
 }
 
-export async function destroyMetadata(ctx: BBContext) {
-  const db = context.getAppDB()
+exports.destroyMetadata = async function (ctx) {
+  const db = getAppDB()
   try {
     const dbUser = await db.get(ctx.params.id)
     await db.remove(dbUser._id, dbUser._rev)
@@ -195,18 +197,18 @@ export async function destroyMetadata(ctx: BBContext) {
   }
 }
 
-export async function findMetadata(ctx: BBContext) {
+exports.findMetadata = async function (ctx) {
   ctx.body = await getFullUser(ctx, ctx.params.id)
 }
 
-export async function setFlag(ctx: BBContext) {
-  const userId = ctx.user?._id
+exports.setFlag = async function (ctx) {
+  const userId = ctx.user._id
   const { flag, value } = ctx.request.body
   if (!flag) {
     ctx.throw(400, "Must supply a 'flag' field in request body.")
   }
-  const flagDocId = generateUserFlagID(userId!)
-  const db = context.getAppDB()
+  const flagDocId = generateUserFlagID(userId)
+  const db = getAppDB()
   let doc
   try {
     doc = await db.get(flagDocId)
@@ -218,10 +220,10 @@ export async function setFlag(ctx: BBContext) {
   ctx.body = { message: "Flag set successfully" }
 }
 
-export async function getFlags(ctx: BBContext) {
-  const userId = ctx.user?._id
-  const docId = generateUserFlagID(userId!)
-  const db = context.getAppDB()
+exports.getFlags = async function (ctx) {
+  const userId = ctx.user._id
+  const docId = generateUserFlagID(userId)
+  const db = getAppDB()
   let doc
   try {
     doc = await db.get(docId)

package/src/api/controllers/view/{exporters.ts → exporters.js}

@@ -1,6 +1,4 @@
-import { Row } from "@budibase/types"
-
-export function csv(headers: string[], rows: Row[]) {
+exports.csv = function (headers, rows) {
   let csv = headers.map(key => `"${key}"`).join(",")
 
   for (let row of rows) {
@@ -18,11 +16,11 @@ export function csv(headers: string[], rows: Row[]) {
   return csv
 }
 
-export function json(headers: string[], rows: Row[]) {
+exports.json = function (headers, rows) {
   return JSON.stringify(rows, undefined, 2)
 }
 
-export const ExportFormats = {
+exports.ExportFormats = {
   CSV: "csv",
   JSON: "json",
 }

package/src/api/controllers/view/{index.ts → index.js}

@@ -1,29 +1,21 @@
-import viewTemplate from "./viewBuilder"
-import { apiFileReturn } from "../../../utilities/fileSystem"
-import * as exporters from "./exporters"
-import { deleteView, getView, getViews, saveView } from "./utils"
-import { fetchView } from "../row"
-import { FieldTypes } from "../../../constants"
-import { context, events } from "@budibase/backend-core"
-import { DocumentType } from "../../../db/utils"
-import sdk from "../../../sdk"
-import {
-  BBContext,
-  Row,
-  Table,
-  TableExportFormat,
-  TableSchema,
-  View,
-} from "@budibase/types"
-
+const viewTemplate = require("./viewBuilder")
+const { apiFileReturn } = require("../../../utilities/fileSystem")
+const exporters = require("./exporters")
+const { saveView, getView, getViews, deleteView } = require("./utils")
+const { fetchView } = require("../row")
+const { FieldTypes } = require("../../../constants")
+const { getAppDB } = require("@budibase/backend-core/context")
+const { events } = require("@budibase/backend-core")
+const { DocumentType } = require("../../../db/utils")
 const { cloneDeep, isEqual } = require("lodash")
+const sdk = require("../../../sdk")
 
-export async function fetch(ctx: BBContext) {
+exports.fetch = async ctx => {
   ctx.body = await getViews()
 }
 
-export async function save(ctx: BBContext) {
-  const db = context.getAppDB()
+exports.save = async ctx => {
+  const db = getAppDB()
   const { originalName, ...viewToSave } = ctx.request.body
   const view = viewTemplate(viewToSave)
   const viewName = viewToSave.name
@@ -55,7 +47,7 @@ export async function save(ctx: BBContext) {
   }
 }
 
-export async function calculationEvents(existingView: View, newView: View) {
+const calculationEvents = async (existingView, newView) => {
   const existingCalculation = existingView && existingView.calculation
   const newCalculation = newView && newView.calculation
 
@@ -76,7 +68,7 @@ export async function calculationEvents(existingView: View, newView: View) {
   }
 }
 
-export async function filterEvents(existingView: View, newView: View) {
+const filterEvents = async (existingView, newView) => {
   const hasExistingFilters = !!(
     existingView &&
     existingView.filters &&
@@ -101,7 +93,7 @@ export async function filterEvents(existingView: View, newView: View) {
   }
 }
 
-async function handleViewEvents(existingView: View, newView: View) {
+const handleViewEvents = async (existingView, newView) => {
   if (!existingView) {
     await events.view.created(newView)
   } else {
@@ -111,8 +103,8 @@ async function handleViewEvents(existingView: View, newView: View) {
   await filterEvents(existingView, newView)
 }
 
-export async function destroy(ctx: BBContext) {
-  const db = context.getAppDB()
+exports.destroy = async ctx => {
+  const db = getAppDB()
   const viewName = decodeURI(ctx.params.viewName)
   const view = await deleteView(viewName)
   const table = await db.get(view.meta.tableId)
@@ -123,11 +115,11 @@ export async function destroy(ctx: BBContext) {
   ctx.body = view
 }
 
-export async function exportView(ctx: BBContext) {
-  const viewName = decodeURI(ctx.query.view as string)
+exports.exportView = async ctx => {
+  const viewName = decodeURI(ctx.query.view)
   const view = await getView(viewName)
 
-  const format = ctx.query.format as string
+  const format = ctx.query.format
   if (!format || !Object.values(exporters.ExportFormats).includes(format)) {
     ctx.throw(400, "Format must be specified, either csv or json")
   }
@@ -138,7 +130,6 @@ export async function exportView(ctx: BBContext) {
     ctx.query = {
       group: view.meta.groupBy,
       calculation: view.meta.calculation,
-      // @ts-ignore
       stats: !!view.meta.field,
       field: view.meta.field,
     }
@@ -149,11 +140,11 @@ export async function exportView(ctx: BBContext) {
   }
 
   await fetchView(ctx)
-  let rows = ctx.body as Row[]
+  let rows = ctx.body
 
-  let schema: TableSchema = view && view.meta && view.meta.schema
+  let schema = view && view.meta && view.meta.schema
   const tableId = ctx.params.tableId || view.meta.tableId
-  const table: Table = await sdk.tables.getTable(tableId)
+  const table = await sdk.tables.getTable(tableId)
   if (!schema) {
     schema = table.schema
   }
@@ -184,15 +175,15 @@ export async function exportView(ctx: BBContext) {
 
   // Export part
   let headers = Object.keys(schema)
-  const exporter = format === "csv" ? exporters.csv : exporters.json
+  const exporter = exporters[format]
   const filename = `${viewName}.${format}`
   // send down the file
   ctx.attachment(filename)
   ctx.body = apiFileReturn(exporter(headers, rows))
 
   if (viewName.startsWith(DocumentType.TABLE)) {
-    await events.table.exported(table, format as TableExportFormat)
+    await events.table.exported(table, format)
   } else {
-    await events.view.exported(table, format as TableExportFormat)
+    await events.view.exported(table, format)
   }
 }