@budibase/server 2.1.43-alpha.1 → 2.1.43

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

@@ -1,21 +1,26 @@
-import * as actions from "../../automations/actions"
-import * as triggers from "../../automations/triggers"
-import {
+const actions = require("../../automations/actions")
+const triggers = require("../../automations/triggers")
+const {
   getAutomationParams,
   generateAutomationID,
   DocumentType,
-} from "../../db/utils"
-import {
+} = require("../../db/utils")
+const {
   checkForWebhooks,
   updateTestHistory,
   removeDeprecated,
-} from "../../automations/utils"
-import { deleteEntityMetadata } from "../../utilities"
-import { MetadataTypes } from "../../constants"
-import { setTestFlag, clearTestFlag } from "../../utilities/redis"
-import { context, cache, events } from "@budibase/backend-core"
-import { automations } from "@budibase/pro"
-import { Automation, BBContext } from "@budibase/types"
+} = require("../../automations/utils")
+const { deleteEntityMetadata } = require("../../utilities")
+const { MetadataTypes } = require("../../constants")
+const { setTestFlag, clearTestFlag } = require("../../utilities/redis")
+const {
+  getAppDB,
+  getProdAppDB,
+  doInAppContext,
+} = require("@budibase/backend-core/context")
+const { events } = require("@budibase/backend-core")
+const { app } = require("@budibase/backend-core/cache")
+const { automations } = require("@budibase/pro")
 
 const ACTION_DEFS = removeDeprecated(actions.ACTION_DEFINITIONS)
 const TRIGGER_DEFS = removeDeprecated(triggers.TRIGGER_DEFINITIONS)
@@ -26,7 +31,7 @@ const TRIGGER_DEFS = removeDeprecated(triggers.TRIGGER_DEFINITIONS)
  *                       *
  *************************/
 
-async function cleanupAutomationMetadata(automationId: string) {
+async function cleanupAutomationMetadata(automationId) {
   await deleteEntityMetadata(MetadataTypes.AUTOMATION_TEST_INPUT, automationId)
   await deleteEntityMetadata(
     MetadataTypes.AUTOMATION_TEST_HISTORY,
@@ -34,7 +39,7 @@ async function cleanupAutomationMetadata(automationId: string) {
   )
 }
 
-function cleanAutomationInputs(automation: Automation) {
+function cleanAutomationInputs(automation) {
   if (automation == null) {
     return automation
   }
@@ -58,14 +63,14 @@ function cleanAutomationInputs(automation: Automation) {
   return automation
 }
 
-export async function create(ctx: BBContext) {
-  const db = context.getAppDB()
+exports.create = async function (ctx) {
+  const db = getAppDB()
   let automation = ctx.request.body
   automation.appId = ctx.appId
 
   // call through to update if already exists
   if (automation._id && automation._rev) {
-    return update(ctx)
+    return exports.update(ctx)
   }
 
   automation._id = generateAutomationID()
@@ -92,23 +97,17 @@ export async function create(ctx: BBContext) {
   }
 }
 
-export function getNewSteps(oldAutomation: Automation, automation: Automation) {
+const getNewSteps = (oldAutomation, automation) => {
   const oldStepIds = oldAutomation.definition.steps.map(s => s.id)
   return automation.definition.steps.filter(s => !oldStepIds.includes(s.id))
 }
 
-export function getDeletedSteps(
-  oldAutomation: Automation,
-  automation: Automation
-) {
+const getDeletedSteps = (oldAutomation, automation) => {
   const stepIds = automation.definition.steps.map(s => s.id)
   return oldAutomation.definition.steps.filter(s => !stepIds.includes(s.id))
 }
 
-export async function handleStepEvents(
-  oldAutomation: Automation,
-  automation: Automation
-) {
+const handleStepEvents = async (oldAutomation, automation) => {
   // new steps
   const newSteps = getNewSteps(oldAutomation, automation)
   for (let step of newSteps) {
@@ -122,8 +121,8 @@ export async function handleStepEvents(
   }
 }
 
-export async function update(ctx: BBContext) {
-  const db = context.getAppDB()
+exports.update = async function (ctx) {
+  const db = getAppDB()
   let automation = ctx.request.body
   automation.appId = ctx.appId
   const oldAutomation = await db.get(automation._id)
@@ -147,8 +146,9 @@ export async function update(ctx: BBContext) {
   if (oldAutoTrigger && oldAutoTrigger.id !== newAutoTrigger.id) {
     await events.automation.triggerUpdated(automation)
     await deleteEntityMetadata(
+      ctx.appId,
       MetadataTypes.AUTOMATION_TEST_INPUT,
-      automation._id!
+      automation._id
     )
   }
 
@@ -165,8 +165,8 @@ export async function update(ctx: BBContext) {
   }
 }
 
-export async function fetch(ctx: BBContext) {
-  const db = context.getAppDB()
+exports.fetch = async function (ctx) {
+  const db = getAppDB()
   const response = await db.allDocs(
     getAutomationParams(null, {
       include_docs: true,
@@ -175,13 +175,13 @@ export async function fetch(ctx: BBContext) {
   ctx.body = response.rows.map(row => row.doc)
 }
 
-export async function find(ctx: BBContext) {
-  const db = context.getAppDB()
+exports.find = async function (ctx) {
+  const db = getAppDB()
   ctx.body = await db.get(ctx.params.id)
 }
 
-export async function destroy(ctx: BBContext) {
-  const db = context.getAppDB()
+exports.destroy = async function (ctx) {
+  const db = getAppDB()
   const automationId = ctx.params.id
   const oldAutomation = await db.get(automationId)
   await checkForWebhooks({
@@ -193,14 +193,14 @@ export async function destroy(ctx: BBContext) {
   await events.automation.deleted(oldAutomation)
 }
 
-export async function logSearch(ctx: BBContext) {
+exports.logSearch = async function (ctx) {
   ctx.body = await automations.logs.logSearch(ctx.request.body)
 }
 
-export async function clearLogError(ctx: BBContext) {
+exports.clearLogError = async function (ctx) {
   const { automationId, appId } = ctx.request.body
-  await context.doInAppContext(appId, async () => {
-    const db = context.getProdAppDB()
+  await doInAppContext(appId, async () => {
+    const db = getProdAppDB()
     const metadata = await db.get(DocumentType.APP_METADATA)
     if (!automationId) {
       delete metadata.automationErrors
@@ -211,20 +211,20 @@ export async function clearLogError(ctx: BBContext) {
       delete metadata.automationErrors[automationId]
     }
     await db.put(metadata)
-    await cache.app.invalidateAppMetadata(metadata.appId, metadata)
+    await app.invalidateAppMetadata(metadata.appId, metadata)
     ctx.body = { message: `Error logs cleared.` }
   })
 }
 
-export async function getActionList(ctx: BBContext) {
+exports.getActionList = async function (ctx) {
   ctx.body = ACTION_DEFS
 }
 
-export async function getTriggerList(ctx: BBContext) {
+exports.getTriggerList = async function (ctx) {
   ctx.body = TRIGGER_DEFS
 }
 
-export async function getDefinitionList(ctx: BBContext) {
+module.exports.getDefinitionList = async function (ctx) {
   ctx.body = {
     trigger: TRIGGER_DEFS,
     action: ACTION_DEFS,
@@ -237,8 +237,8 @@ export async function getDefinitionList(ctx: BBContext) {
  *                   *
  *********************/
 
-export async function trigger(ctx: BBContext) {
-  const db = context.getAppDB()
+exports.trigger = async function (ctx) {
+  const db = getAppDB()
   let automation = await db.get(ctx.params.id)
   await triggers.externalTrigger(automation, {
     ...ctx.request.body,
@@ -250,7 +250,7 @@ export async function trigger(ctx: BBContext) {
   }
 }
 
-function prepareTestInput(input: any) {
+function prepareTestInput(input) {
   // prepare the test parameters
   if (input.id && input.row) {
     input.row._id = input.id
@@ -261,8 +261,8 @@ function prepareTestInput(input: any) {
   return input
 }
 
-export async function test(ctx: BBContext) {
-  const db = context.getAppDB()
+exports.test = async function (ctx) {
+  const db = getAppDB()
   let automation = await db.get(ctx.params.id)
   await setTestFlag(automation._id)
   const testInput = prepareTestInput(ctx.request.body)

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

@@ -1,14 +1,14 @@
-import env from "../../environment"
-import { db as dbCore, tenancy } from "@budibase/backend-core"
-import { streamFile } from "../../utilities/fileSystem"
-import { stringToReadStream } from "../../utilities"
-import { getDocParams, DocumentType, isDevAppID } from "../../db/utils"
-import { create } from "./application"
-import { join } from "path"
-import { App, BBContext, Database } from "@budibase/types"
-import sdk from "../../sdk"
+const env = require("../../environment")
+const { getAllApps, getGlobalDBName } = require("@budibase/backend-core/db")
+const { getGlobalDB } = require("@budibase/backend-core/tenancy")
+const { streamFile } = require("../../utilities/fileSystem")
+const { stringToReadStream } = require("../../utilities")
+const { getDocParams, DocumentType, isDevAppID } = require("../../db/utils")
+const { create } = require("./application")
+const { join } = require("path")
+const sdk = require("../../sdk")
 
-async function createApp(appName: string, appDirectory: string) {
+async function createApp(appName, appDirectory) {
   const ctx = {
     request: {
       body: {
@@ -25,7 +25,7 @@ async function createApp(appName: string, appDirectory: string) {
   return create(ctx)
 }
 
-async function getAllDocType(db: Database, docType: string) {
+async function getAllDocType(db, docType) {
   const response = await db.allDocs(
     getDocParams(docType, null, {
       include_docs: true,
@@ -34,19 +34,19 @@ async function getAllDocType(db: Database, docType: string) {
   return response.rows.map(row => row.doc)
 }
 
-export async function exportApps(ctx: BBContext) {
+exports.exportApps = async ctx => {
   if (env.SELF_HOSTED || !env.MULTI_TENANCY) {
     ctx.throw(400, "Exporting only allowed in multi-tenant cloud environments.")
   }
-  const apps = (await dbCore.getAllApps({ all: true })) as App[]
-  const globalDBString = await sdk.backups.exportDB(dbCore.getGlobalDBName(), {
-    filter: (doc: any) => !doc._id.startsWith(DocumentType.USER),
+  const apps = await getAllApps({ all: true })
+  const globalDBString = await sdk.backups.exportDB(getGlobalDBName(), {
+    filter: doc => !doc._id.startsWith(DocumentType.USER),
   })
   // only export the dev apps as they will be the latest, the user can republish the apps
   // in their self-hosted environment
   let appMetadata = apps
-    .filter((app: App) => isDevAppID(app.appId || app._id))
-    .map((app: App) => ({ appId: (app.appId || app._id)!, name: app.name }))
+    .filter(app => isDevAppID(app.appId || app._id))
+    .map(app => ({ appId: app.appId || app._id, name: app.name }))
   const tmpPath = await sdk.backups.exportMultipleApps(
     appMetadata,
     globalDBString
@@ -56,25 +56,25 @@ export async function exportApps(ctx: BBContext) {
   ctx.body = streamFile(tmpPath)
 }
 
-async function checkHasBeenImported() {
+async function hasBeenImported() {
   if (!env.SELF_HOSTED || env.MULTI_TENANCY) {
     return true
   }
-  const apps = await dbCore.getAllApps({ all: true })
+  const apps = await getAllApps({ all: true })
   return apps.length !== 0
 }
 
-export async function hasBeenImported(ctx: BBContext) {
+exports.hasBeenImported = async ctx => {
   ctx.body = {
-    imported: await checkHasBeenImported(),
+    imported: await hasBeenImported(),
   }
 }
 
-export async function importApps(ctx: BBContext) {
+exports.importApps = async ctx => {
   if (!env.SELF_HOSTED || env.MULTI_TENANCY) {
     ctx.throw(400, "Importing only allowed in self hosted environments.")
   }
-  const beenImported = await checkHasBeenImported()
+  const beenImported = await hasBeenImported()
   if (beenImported || !ctx.request.files || !ctx.request.files.importFile) {
     ctx.throw(
       400,
@@ -90,7 +90,7 @@ export async function importApps(ctx: BBContext) {
   const globalDbImport = sdk.backups.getGlobalDBFile(tmpPath)
   const appNames = sdk.backups.getListOfAppsInMulti(tmpPath)
 
-  const globalDb = tenancy.getGlobalDB()
+  const globalDb = getGlobalDB()
   // load the global db first
   await globalDb.load(stringToReadStream(globalDbImport))
   for (let appName of appNames) {

package/src/api/controllers/component.ts

@@ -2,9 +2,8 @@ import { DocumentType } from "../../db/utils"
 import { Plugin } from "@budibase/types"
 import { db as dbCore, context, tenancy } from "@budibase/backend-core"
 import { getComponentLibraryManifest } from "../../utilities/fileSystem"
-import { BBContext } from "@budibase/types"
 
-export async function fetchAppComponentDefinitions(ctx: BBContext) {
+exports.fetchAppComponentDefinitions = async function (ctx: any) {
   try {
     const db = context.getAppDB()
     const app = await db.get(DocumentType.APP_METADATA)

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

@@ -1,37 +1,31 @@
-import {
+const {
   generateDatasourceID,
   getDatasourceParams,
   getQueryParams,
   DocumentType,
   BudibaseInternalDB,
   getTableParams,
-} from "../../db/utils"
-import { destroy as tableDestroy } from "./table/internal"
-import { BuildSchemaErrors, InvalidColumns } from "../../constants"
-import { getIntegration } from "../../integrations"
-import { getDatasourceAndQuery } from "./row/utils"
-import { invalidateDynamicVariables } from "../../threads/utils"
-import { db as dbCore, context, events } from "@budibase/backend-core"
-import { BBContext, Datasource, Row } from "@budibase/types"
-
-export async function fetch(ctx: BBContext) {
+} = require("../../db/utils")
+const { BuildSchemaErrors, InvalidColumns } = require("../../constants")
+const { getIntegration } = require("../../integrations")
+const { getDatasourceAndQuery } = require("./row/utils")
+const { invalidateDynamicVariables } = require("../../threads/utils")
+const { getAppDB } = require("@budibase/backend-core/context")
+const { events } = require("@budibase/backend-core")
+
+exports.fetch = async function (ctx) {
   // Get internal tables
-  const db = context.getAppDB()
+  const db = getAppDB()
   const internalTables = await db.allDocs(
     getTableParams(null, {
       include_docs: true,
     })
   )
-
-  const internal = internalTables.rows.reduce((acc: any, row: Row) => {
-    const sourceId = row.doc.sourceId || "bb_internal"
-    acc[sourceId] = acc[sourceId] || []
-    acc[sourceId].push(row.doc)
-    return acc
-  }, {})
+  const internal = internalTables.rows.map(row => row.doc)
 
   const bbInternalDb = {
     ...BudibaseInternalDB,
+    entities: internal,
   }
 
   // Get external datasources
@@ -43,24 +37,18 @@ export async function fetch(ctx: BBContext) {
     )
   ).rows.map(row => row.doc)
 
-  const allDatasources = [bbInternalDb, ...datasources]
-
-  for (let datasource of allDatasources) {
+  for (let datasource of datasources) {
     if (datasource.config && datasource.config.auth) {
       // strip secrets from response so they don't show in the network request
       delete datasource.config.auth
     }
-
-    if (datasource.type === dbCore.BUDIBASE_DATASOURCE_TYPE) {
-      datasource.entities = internal[datasource._id]
-    }
   }
 
   ctx.body = [bbInternalDb, ...datasources]
 }
 
-export async function buildSchemaFromDb(ctx: BBContext) {
-  const db = context.getAppDB()
+exports.buildSchemaFromDb = async function (ctx) {
+  const db = getAppDB()
   const datasource = await db.get(ctx.params.datasourceId)
   const tablesFilter = ctx.request.body.tablesFilter
 
@@ -71,9 +59,7 @@ export async function buildSchemaFromDb(ctx: BBContext) {
     }
     for (let key in tables) {
       if (
-        tablesFilter.some(
-          (filter: any) => filter.toLowerCase() === key.toLowerCase()
-        )
+        tablesFilter.some(filter => filter.toLowerCase() === key.toLowerCase())
       ) {
         datasource.entities[key] = tables[key]
       }
@@ -86,7 +72,7 @@ export async function buildSchemaFromDb(ctx: BBContext) {
   const dbResp = await db.put(datasource)
   datasource._rev = dbResp.rev
 
-  const response: any = { datasource }
+  const response = { datasource }
   if (error) {
     response.error = error
   }
@@ -96,9 +82,9 @@ export async function buildSchemaFromDb(ctx: BBContext) {
 /**
  * Make sure all datasource entities have a display name selected
  */
-function setDefaultDisplayColumns(datasource: Datasource) {
+const setDefaultDisplayColumns = datasource => {
   //
-  for (let entity of Object.values(datasource.entities || {})) {
+  for (let entity of Object.values(datasource.entities)) {
     if (entity.primaryDisplay) {
       continue
     }
@@ -114,12 +100,9 @@ function setDefaultDisplayColumns(datasource: Datasource) {
 /**
  * Check for variables that have been updated or removed and invalidate them.
  */
-async function invalidateVariables(
-  existingDatasource: Datasource,
-  updatedDatasource: Datasource
-) {
-  const existingVariables: any = existingDatasource.config?.dynamicVariables
-  const updatedVariables: any = updatedDatasource.config?.dynamicVariables
+const invalidateVariables = async (existingDatasource, updatedDatasource) => {
+  const existingVariables = existingDatasource.config.dynamicVariables
+  const updatedVariables = updatedDatasource.config.dynamicVariables
   const toInvalidate = []
 
   if (!existingVariables) {
@@ -131,9 +114,9 @@ async function invalidateVariables(
     toInvalidate.push(...existingVariables)
   } else {
     // invaldate changed / removed
-    existingVariables.forEach((existing: any) => {
+    existingVariables.forEach(existing => {
       const unchanged = updatedVariables.find(
-        (updated: any) =>
+        updated =>
           existing.name === updated.name &&
           existing.queryId === updated.queryId &&
           existing.value === updated.value
@@ -146,20 +129,13 @@ async function invalidateVariables(
   await invalidateDynamicVariables(toInvalidate)
 }
 
-export async function update(ctx: BBContext) {
-  const db = context.getAppDB()
+exports.update = async function (ctx) {
+  const db = getAppDB()
   const datasourceId = ctx.params.datasourceId
   let datasource = await db.get(datasourceId)
   const auth = datasource.config.auth
   await invalidateVariables(datasource, ctx.request.body)
-
-  const isBudibaseSource = datasource.type === dbCore.BUDIBASE_DATASOURCE_TYPE
-
-  const dataSourceBody = isBudibaseSource
-    ? { name: ctx.request.body?.name }
-    : ctx.request.body
-
-  datasource = { ...datasource, ...dataSourceBody }
+  datasource = { ...datasource, ...ctx.request.body }
   if (auth && !ctx.request.body.auth) {
     // don't strip auth config from DB
     datasource.config.auth = auth
@@ -170,7 +146,7 @@ export async function update(ctx: BBContext) {
   datasource._rev = response.rev
 
   // Drain connection pools when configuration is changed
-  if (datasource.source && !isBudibaseSource) {
+  if (datasource.source) {
     const source = await getIntegration(datasource.source)
     if (source && source.pool) {
       await source.pool.end()
@@ -182,8 +158,8 @@ export async function update(ctx: BBContext) {
   ctx.body = { datasource }
 }
 
-export async function save(ctx: BBContext) {
-  const db = context.getAppDB()
+exports.save = async function (ctx) {
+  const db = getAppDB()
   const plus = ctx.request.body.datasource.plus
   const fetchSchema = ctx.request.body.fetchSchema
 
@@ -213,63 +189,27 @@ export async function save(ctx: BBContext) {
     }
   }
 
-  const response: any = { datasource }
+  const response = { datasource }
   if (schemaError) {
     response.error = schemaError
   }
   ctx.body = response
 }
 
-async function destroyInternalTablesBySourceId(datasourceId: string) {
-  const db = context.getAppDB()
-
-  // Get all internal tables
-  const internalTables = await db.allDocs(
-    getTableParams(null, {
-      include_docs: true,
-    })
-  )
-
-  // Filter by datasource and return the docs.
-  const datasourceTableDocs = internalTables.rows.reduce(
-    (acc: any, table: any) => {
-      if (table.doc.sourceId == datasourceId) {
-        acc.push(table.doc)
-      }
-      return acc
-    },
-    []
-  )
-
-  // Destroy the tables.
-  for (const table of datasourceTableDocs) {
-    await tableDestroy({
-      params: {
-        tableId: table._id,
-      },
-    })
-  }
-}
-
-export async function destroy(ctx: BBContext) {
-  const db = context.getAppDB()
+exports.destroy = async function (ctx) {
+  const db = getAppDB()
   const datasourceId = ctx.params.datasourceId
 
   const datasource = await db.get(datasourceId)
   // Delete all queries for the datasource
-
-  if (datasource.type === dbCore.BUDIBASE_DATASOURCE_TYPE) {
-    await destroyInternalTablesBySourceId(datasourceId)
-  } else {
-    const queries = await db.allDocs(getQueryParams(datasourceId, null))
-    await db.bulkDocs(
-      queries.rows.map((row: any) => ({
-        _id: row.id,
-        _rev: row.value.rev,
-        _deleted: true,
-      }))
-    )
-  }
+  const queries = await db.allDocs(getQueryParams(datasourceId, null))
+  await db.bulkDocs(
+    queries.rows.map(row => ({
+      _id: row.id,
+      _rev: row.value.rev,
+      _deleted: true,
+    }))
+  )
 
   // delete the datasource
   await db.remove(datasourceId, ctx.params.revId)
@@ -279,28 +219,28 @@ export async function destroy(ctx: BBContext) {
   ctx.status = 200
 }
 
-export async function find(ctx: BBContext) {
-  const database = context.getAppDB()
+exports.find = async function (ctx) {
+  const database = getAppDB()
   ctx.body = await database.get(ctx.params.datasourceId)
 }
 
 // dynamic query functionality
-export async function query(ctx: BBContext) {
+exports.query = async function (ctx) {
   const queryJson = ctx.request.body
   try {
     ctx.body = await getDatasourceAndQuery(queryJson)
-  } catch (err: any) {
+  } catch (err) {
     ctx.throw(400, err)
   }
 }
 
-function getErrorTables(errors: any, errorType: string) {
+function getErrorTables(errors, errorType) {
   return Object.entries(errors)
     .filter(entry => entry[1] === errorType)
     .map(([name]) => name)
 }
 
-function updateError(error: any, newError: any, tables: string[]) {
+function updateError(error, newError, tables) {
   if (!error) {
     error = ""
   }
@@ -311,7 +251,7 @@ function updateError(error: any, newError: any, tables: string[]) {
   return error
 }
 
-async function buildSchemaHelper(datasource: Datasource) {
+const buildSchemaHelper = async datasource => {
   const Connector = await getIntegration(datasource.source)
 
   // Connect to the DB and build the schema