@budibase/server 2.1.32-alpha.7 → 2.1.32

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,20 +45,12 @@ 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
-}) {
+exports.validate = async ({ tableId, row, table }) => {
   if (!table) {
-    const db = context.getAppDB()
+    const db = getAppDB()
     table = await db.get(tableId)
   }
-  const errors: any = {}
+  const errors = {}
   for (let fieldName of Object.keys(table.schema)) {
     const constraints = cloneDeep(table.schema[fieldName].constraints)
     const type = table.schema[fieldName].type
@@ -77,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")
+}

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

@@ -17,9 +17,13 @@ const { clientLibraryPath } = require("../../../utilities")
 const { upload, deleteFiles } = require("../../../utilities/fileSystem")
 const { attachmentsRelativeURL } = require("../../../utilities")
 const { DocumentType } = require("../../../db/utils")
-const { context, objectStore, utils } = require("@budibase/backend-core")
+const { getAppDB, getAppId } = require("@budibase/backend-core/context")
+const { setCookie, clearCookie } = require("@budibase/backend-core/utils")
 const AWS = require("aws-sdk")
 const fs = require("fs")
+const {
+  downloadTarballDirect,
+} = require("../../../utilities/fileSystem/utilities")
 
 async function prepareUpload({ s3Key, bucket, metadata, file }: any) {
   const response = await upload({
@@ -44,7 +48,7 @@ export const toggleBetaUiFeature = async function (ctx: any) {
   const cookieName = `beta:${ctx.params.feature}`
 
   if (ctx.cookies.get(cookieName)) {
-    utils.clearCookie(ctx, cookieName)
+    clearCookie(ctx, cookieName)
     ctx.body = {
       message: `${ctx.params.feature} disabled`,
     }
@@ -57,11 +61,11 @@ export const toggleBetaUiFeature = async function (ctx: any) {
   if (!fs.existsSync(builderPath)) {
     fs.mkdirSync(builderPath)
   }
-  await objectStore.downloadTarballDirect(
+  await downloadTarballDirect(
     "https://cdn.budi.live/beta:design_ui/new_ui.tar.gz",
     builderPath
   )
-  utils.setCookie(ctx, {}, cookieName)
+  setCookie(ctx, {}, cookieName)
 
   ctx.body = {
     message: `${ctx.params.feature} enabled`,
@@ -99,9 +103,9 @@ export const deleteObjects = async function (ctx: any) {
 }
 
 export const serveApp = async function (ctx: any) {
-  const db = context.getAppDB({ skip_setup: true })
+  const db = getAppDB({ skip_setup: true })
   const appInfo = await db.get(DocumentType.APP_METADATA)
-  let appId = context.getAppId()
+  let appId = getAppId()
 
   if (!env.isJest()) {
     const App = require("./templates/BudibaseApp.svelte").default
@@ -130,11 +134,11 @@ export const serveApp = async function (ctx: any) {
 }
 
 export const serveBuilderPreview = async function (ctx: any) {
-  const db = context.getAppDB({ skip_setup: true })
+  const db = getAppDB({ skip_setup: true })
   const appInfo = await db.get(DocumentType.APP_METADATA)
 
   if (!env.isJest()) {
-    let appId = context.getAppId()
+    let appId = getAppId()
     const previewHbs = loadHandlebarsFile(`${__dirname}/templates/preview.hbs`)
     ctx.body = await processString(previewHbs, {
       clientLibPath: clientLibraryPath(appId, appInfo.version, ctx),
@@ -152,7 +156,7 @@ export const serveClientLibrary = async function (ctx: any) {
 }
 
 export const getSignedUploadURL = async function (ctx: any) {
-  const database = context.getAppDB()
+  const database = getAppDB()
 
   // Ensure datasource is valid
   let datasource

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

@@ -1,14 +1,13 @@
-import { FieldTypes, FormulaTypes } from "../../../constants"
-import { clearColumns } from "./utils"
-import { doesContainStrings } from "@budibase/string-templates"
-import { cloneDeep } from "lodash/fp"
-import { isEqual, uniq } from "lodash"
-import { updateAllFormulasInTable } from "../row/staticFormula"
-import { context } from "@budibase/backend-core"
-import { FieldSchema, Table } from "@budibase/types"
-import sdk from "../../../sdk"
+const { FieldTypes, FormulaTypes } = require("../../../constants")
+const { clearColumns } = require("./utils")
+const { doesContainStrings } = require("@budibase/string-templates")
+const { cloneDeep } = require("lodash/fp")
+const { isEqual, uniq } = require("lodash")
+const { updateAllFormulasInTable } = require("../row/staticFormula")
+const { getAppDB } = require("@budibase/backend-core/context")
+const sdk = require("../../../sdk")
 
-function isStaticFormula(column: FieldSchema) {
+function isStaticFormula(column) {
   return (
     column.type === FieldTypes.FORMULA &&
     column.formulaType === FormulaTypes.STATIC
@@ -19,8 +18,8 @@ function isStaticFormula(column: FieldSchema) {
  * This retrieves the formula columns from a table schema that use a specified column name
  * in the formula.
  */
-function getFormulaThatUseColumn(table: Table, columnNames: string[] | string) {
-  let formula: string[] = []
+function getFormulaThatUseColumn(table, columnNames) {
+  let formula = []
   columnNames = Array.isArray(columnNames) ? columnNames : [columnNames]
   for (let column of Object.values(table.schema)) {
     // not a static formula, or doesn't contain a relationship
@@ -39,10 +38,7 @@ function getFormulaThatUseColumn(table: Table, columnNames: string[] | string) {
  * This functions checks for when a related table, column or related column is deleted, if any
  * tables need to have the formula column removed.
  */
-async function checkIfFormulaNeedsCleared(
-  table: Table,
-  { oldTable, deletion }: { oldTable?: Table; deletion?: boolean }
-) {
+async function checkIfFormulaNeedsCleared(table, { oldTable, deletion }) {
   // start by retrieving all tables, remove the current table from the list
   const tables = (await sdk.tables.getAllInternalTables()).filter(
     tbl => tbl._id !== table._id
@@ -53,14 +49,11 @@ async function checkIfFormulaNeedsCleared(
   )
   // remove any formula columns that used related columns
   for (let removed of removedColumns) {
-    let tableToUse: Table | undefined = table
+    let tableToUse = table
     // if relationship, get the related table
     if (removed.type === FieldTypes.LINK) {
       tableToUse = tables.find(table => table._id === removed.tableId)
     }
-    if (!tableToUse) {
-      continue
-    }
     const columnsToDelete = getFormulaThatUseColumn(tableToUse, removed.name)
     if (columnsToDelete.length > 0) {
       await clearColumns(table, columnsToDelete)
@@ -78,11 +71,11 @@ async function checkIfFormulaNeedsCleared(
       // look to see if the column was used in a relationship formula,
       // relationships won't be used for this
       if (relatedTable && relatedColumns && removed.type !== FieldTypes.LINK) {
-        let relatedFormulaToRemove: string[] = []
+        let relatedFormulaToRemove = []
         for (let column of relatedColumns) {
           relatedFormulaToRemove = relatedFormulaToRemove.concat(
             getFormulaThatUseColumn(relatedTable, [
-              column.fieldName!,
+              column.fieldName,
               removed.name,
             ])
           )
@@ -102,14 +95,13 @@ async function checkIfFormulaNeedsCleared(
  * specifically only for static formula.
  */
 async function updateRelatedFormulaLinksOnTables(
-  table: Table,
-  { deletion }: { deletion?: boolean } = {}
+  table,
+  { deletion } = { deletion: false }
 ) {
-  const tableId: string = table._id!
-  const db = context.getAppDB()
+  const db = getAppDB()
   // start by retrieving all tables, remove the current table from the list
   const tables = (await sdk.tables.getAllInternalTables()).filter(
-    tbl => tbl._id !== tableId
+    tbl => tbl._id !== table._id
   )
   // clone the tables, so we can compare at end
   const initialTables = cloneDeep(tables)
@@ -122,7 +114,7 @@ async function updateRelatedFormulaLinksOnTables(
     if (!otherTable.relatedFormula) {
       continue
     }
-    const index = otherTable.relatedFormula.indexOf(tableId)
+    const index = otherTable.relatedFormula.indexOf(table._id)
     if (index !== -1) {
       otherTable.relatedFormula.splice(index, 1)
     }
@@ -141,11 +133,11 @@ async function updateRelatedFormulaLinksOnTables(
       if (
         relatedTable &&
         (!relatedTable.relatedFormula ||
-          !relatedTable.relatedFormula.includes(tableId))
+          !relatedTable.relatedFormula.includes(table._id))
       ) {
         relatedTable.relatedFormula = relatedTable.relatedFormula
-          ? [...relatedTable.relatedFormula, tableId]
-          : [tableId]
+          ? [...relatedTable.relatedFormula, table._id]
+          : [table._id]
       }
     }
   }
@@ -158,10 +150,7 @@ async function updateRelatedFormulaLinksOnTables(
   }
 }
 
-async function checkIfFormulaUpdated(
-  table: Table,
-  { oldTable }: { oldTable?: Table }
-) {
+async function checkIfFormulaUpdated(table, { oldTable }) {
   // look to see if any formula values have changed
   const shouldUpdate = Object.values(table.schema).find(
     column =>
@@ -176,10 +165,7 @@ async function checkIfFormulaUpdated(
   }
 }
 
-export async function runStaticFormulaChecks(
-  table: Table,
-  { oldTable, deletion }: { oldTable?: Table; deletion?: boolean }
-) {
+exports.runStaticFormulaChecks = async (table, { oldTable, deletion }) => {
   await updateRelatedFormulaLinksOnTables(table, { deletion })
   await checkIfFormulaNeedsCleared(table, { oldTable, deletion })
   if (!deletion) {

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

@@ -1,47 +1,38 @@
-import {
+const {
   buildExternalTableId,
   breakExternalTableId,
-} from "../../../integrations/utils"
-import {
+} = require("../../../integrations/utils")
+const {
   generateForeignKey,
   generateJunctionTableName,
   foreignKeyStructure,
   hasTypeChanged,
-} from "./utils"
-import {
+} = require("./utils")
+const {
   DataSourceOperation,
   FieldTypes,
   RelationshipTypes,
-} from "../../../constants"
-import { makeExternalQuery } from "../../../integrations/base/query"
-import csvParser from "../../../utilities/csvParser"
-import { handleRequest } from "../row/external"
-import { events, context } from "@budibase/backend-core"
-import {
-  Datasource,
-  Table,
-  QueryJson,
-  Operation,
-  RenameColumn,
-  FieldSchema,
-  BBContext,
-  TableRequest,
-} from "@budibase/types"
-import sdk from "../../../sdk"
+} = require("../../../constants")
+const { makeExternalQuery } = require("../../../integrations/base/query")
 const { cloneDeep } = require("lodash/fp")
+const csvParser = require("../../../utilities/csvParser")
+const { handleRequest } = require("../row/external")
+const { getAppDB } = require("@budibase/backend-core/context")
+const { events } = require("@budibase/backend-core")
+const sdk = require("../../../sdk")
 
 async function makeTableRequest(
-  datasource: Datasource,
-  operation: Operation,
-  table: Table,
-  tables: Record<string, Table>,
-  oldTable?: Table,
-  renamed?: RenameColumn
+  datasource,
+  operation,
+  table,
+  tables,
+  oldTable = null,
+  renamed = null
 ) {
-  const json: QueryJson = {
+  const json = {
     endpoint: {
-      datasourceId: datasource._id!,
-      entityId: table._id!,
+      datasourceId: datasource._id,
+      entityId: table._id,
       operation,
     },
     meta: {
@@ -50,19 +41,15 @@ async function makeTableRequest(
     table,
   }
   if (oldTable) {
-    json.meta!.table = oldTable
+    json.meta.table = oldTable
   }
   if (renamed) {
-    json.meta!.renamed = renamed
+    json.meta.renamed = renamed
   }
   return makeExternalQuery(datasource, json)
 }
 
-function cleanupRelationships(
-  table: Table,
-  tables: Record<string, Table>,
-  oldTable?: Table
-) {
+function cleanupRelationships(table, tables, oldTable = null) {
   const tableToIterate = oldTable ? oldTable : table
   // clean up relationships in couch table schemas
   for (let [key, schema] of Object.entries(tableToIterate.schema)) {
@@ -91,7 +78,7 @@ function cleanupRelationships(
   }
 }
 
-function getDatasourceId(table: Table) {
+function getDatasourceId(table) {
   if (!table) {
     throw "No table supplied"
   }
@@ -101,7 +88,7 @@ function getDatasourceId(table: Table) {
   return breakExternalTableId(table._id).datasourceId
 }
 
-function otherRelationshipType(type?: string) {
+function otherRelationshipType(type) {
   if (type === RelationshipTypes.MANY_TO_MANY) {
     return RelationshipTypes.MANY_TO_MANY
   }
@@ -110,21 +97,13 @@ function otherRelationshipType(type?: string) {
     : RelationshipTypes.ONE_TO_MANY
 }
 
-function generateManyLinkSchema(
-  datasource: Datasource,
-  column: FieldSchema,
-  table: Table,
-  relatedTable: Table
-): Table {
-  if (!table.primary || !relatedTable.primary) {
-    throw new Error("Unable to generate many link schema, no primary keys")
-  }
+function generateManyLinkSchema(datasource, column, table, relatedTable) {
   const primary = table.name + table.primary[0]
   const relatedPrimary = relatedTable.name + relatedTable.primary[0]
   const jcTblName = generateJunctionTableName(column, table, relatedTable)
   // first create the new table
   const junctionTable = {
-    _id: buildExternalTableId(datasource._id!, jcTblName),
+    _id: buildExternalTableId(datasource._id, jcTblName),
     name: jcTblName,
     primary: [primary, relatedPrimary],
     constrained: [primary, relatedPrimary],
@@ -146,15 +125,7 @@ function generateManyLinkSchema(
   return junctionTable
 }
 
-function generateLinkSchema(
-  column: FieldSchema,
-  table: Table,
-  relatedTable: Table,
-  type: string
-) {
-  if (!table.primary || !relatedTable.primary) {
-    throw new Error("Unable to generate link schema, no primary keys")
-  }
+function generateLinkSchema(column, table, relatedTable, type) {
   const isOneSide = type === RelationshipTypes.ONE_TO_MANY
   const primary = isOneSide ? relatedTable.primary[0] : table.primary[0]
   // generate a foreign key
@@ -165,12 +136,7 @@ function generateLinkSchema(
   return foreignKey
 }
 
-function generateRelatedSchema(
-  linkColumn: FieldSchema,
-  table: Table,
-  relatedTable: Table,
-  columnName: string
-) {
+function generateRelatedSchema(linkColumn, table, relatedTable, columnName) {
   // generate column for other table
   const relatedSchema = cloneDeep(linkColumn)
   // swap them from the main link
@@ -193,21 +159,21 @@ function generateRelatedSchema(
   table.schema[columnName] = relatedSchema
 }
 
-function isRelationshipSetup(column: FieldSchema) {
+function isRelationshipSetup(column) {
   return column.foreignKey || column.through
 }
 
-export async function save(ctx: BBContext) {
-  const table: TableRequest = ctx.request.body
-  const renamed = table?._rename
+exports.save = async function (ctx) {
+  const table = ctx.request.body
+  const { _rename: renamed } = table
   // can't do this right now
   delete table.dataImport
-  const datasourceId = getDatasourceId(ctx.request.body)!
+  const datasourceId = getDatasourceId(ctx.request.body)
   // table doesn't exist already, note that it is created
   if (!table._id) {
     table.created = true
   }
-  let tableToSave: TableRequest = {
+  let tableToSave = {
     type: "table",
     _id: buildExternalTableId(datasourceId, table.name),
     ...table,
@@ -222,10 +188,13 @@ export async function save(ctx: BBContext) {
     ctx.throw(400, "A column type has changed.")
   }
 
-  const db = context.getAppDB()
+  const db = getAppDB()
   const datasource = await db.get(datasourceId)
+  if (!datasource.entities) {
+    datasource.entities = {}
+  }
   const oldTables = cloneDeep(datasource.entities)
-  const tables: Record<string, Table> = datasource.entities
+  const tables = datasource.entities
 
   const extraTablesToUpdate = []
 
@@ -237,11 +206,8 @@ export async function save(ctx: BBContext) {
     const relatedTable = Object.values(tables).find(
       table => table._id === schema.tableId
     )
-    if (!relatedTable) {
-      continue
-    }
-    const relatedColumnName = schema.fieldName!
-    const relationType = schema.relationshipType!
+    const relatedColumnName = schema.fieldName
+    const relationType = schema.relationshipType
     if (relationType === RelationshipTypes.MANY_TO_MANY) {
       const junctionTable = generateManyLinkSchema(
         datasource,
@@ -281,7 +247,9 @@ export async function save(ctx: BBContext) {
 
   cleanupRelationships(tableToSave, tables, oldTable)
 
-  const operation = oldTable ? Operation.UPDATE_TABLE : Operation.CREATE_TABLE
+  const operation = oldTable
+    ? DataSourceOperation.UPDATE_TABLE
+    : DataSourceOperation.CREATE_TABLE
   await makeTableRequest(
     datasource,
     operation,
@@ -293,7 +261,9 @@ export async function save(ctx: BBContext) {
   // update any extra tables (like foreign keys in other tables)
   for (let extraTable of extraTablesToUpdate) {
     const oldExtraTable = oldTables[extraTable.name]
-    let op = oldExtraTable ? Operation.UPDATE_TABLE : Operation.CREATE_TABLE
+    let op = oldExtraTable
+      ? DataSourceOperation.UPDATE_TABLE
+      : DataSourceOperation.CREATE_TABLE
     await makeTableRequest(datasource, op, extraTable, tables, oldExtraTable)
   }
 
@@ -313,20 +283,18 @@ export async function save(ctx: BBContext) {
   return tableToSave
 }
 
-export async function destroy(ctx: BBContext) {
-  const tableToDelete: TableRequest = await sdk.tables.getTable(
-    ctx.params.tableId
-  )
+exports.destroy = async function (ctx) {
+  const tableToDelete = await sdk.tables.getTable(ctx.params.tableId)
   if (!tableToDelete || !tableToDelete.created) {
     ctx.throw(400, "Cannot delete tables which weren't created in Budibase.")
   }
   const datasourceId = getDatasourceId(tableToDelete)
 
-  const db = context.getAppDB()
+  const db = getAppDB()
   const datasource = await db.get(datasourceId)
   const tables = datasource.entities
 
-  const operation = Operation.DELETE_TABLE
+  const operation = DataSourceOperation.DELETE_TABLE
   await makeTableRequest(datasource, operation, tableToDelete, tables)
 
   cleanupRelationships(tableToDelete, tables)
@@ -337,7 +305,7 @@ export async function destroy(ctx: BBContext) {
   return tableToDelete
 }
 
-export async function bulkImport(ctx: BBContext) {
+exports.bulkImport = async function (ctx) {
   const table = await sdk.tables.getTable(ctx.params.tableId)
   const { dataImport } = ctx.request.body
   if (!dataImport || !dataImport.schema || !dataImport.csvString) {