@budibase/server 2.1.32-alpha.8 → 2.1.32

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,8 +129,8 @@ 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
@@ -175,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
 
@@ -206,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)
@@ -272,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 = ""
   }
@@ -304,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

package/src/api/controllers/deploy/{Deployment.ts → Deployment.js}

@@ -1,20 +1,15 @@
-import newid from "../../../db/newid"
-import { context } from "@budibase/backend-core"
+const newid = require("../../../db/newid")
+const { getAppId } = require("@budibase/backend-core/context")
 
 /**
  * This is used to pass around information about the deployment that is occurring
  */
-export default class Deployment {
-  _id: string
-  verification: any
-  status?: string
-  err?: any
-
+class Deployment {
   constructor(id = null) {
     this._id = id || newid()
   }
 
-  setVerification(verification: any) {
+  setVerification(verification) {
     if (!verification) {
       return
     }
@@ -25,14 +20,14 @@ export default class Deployment {
     return this.verification
   }
 
-  setStatus(status: string, err?: any) {
+  setStatus(status, err = null) {
     this.status = status
     if (err) {
       this.err = err
     }
   }
 
-  fromJSON(json: any) {
+  fromJSON(json) {
     if (json.verification) {
       this.setVerification(json.verification)
     }
@@ -42,9 +37,9 @@ export default class Deployment {
   }
 
   getJSON() {
-    const obj: any = {
+    const obj = {
       _id: this._id,
-      appId: context.getAppId(),
+      appId: getAppId(),
       status: this.status,
     }
     if (this.err) {
@@ -56,3 +51,5 @@ export default class Deployment {
     return obj
   }
 }
+
+module.exports = Deployment

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

@@ -1,11 +1,23 @@
 import Deployment from "./Deployment"
-import { context, db as dbCore, events, cache } from "@budibase/backend-core"
+import {
+  getDevelopmentAppID,
+  getProdAppID,
+  Replication,
+} from "@budibase/backend-core/db"
 import { DocumentType, getAutomationParams } from "../../../db/utils"
 import {
   clearMetadata,
   disableAllCrons,
   enableCronTrigger,
 } from "../../../automations/utils"
+import { app as appCache } from "@budibase/backend-core/cache"
+import {
+  getAppDB,
+  getAppId,
+  getDevAppDB,
+  getProdAppDB,
+} from "@budibase/backend-core/context"
+import { events } from "@budibase/backend-core"
 import { backups } from "@budibase/pro"
 import { AppBackupTrigger } from "@budibase/types"
 
@@ -37,7 +49,7 @@ async function checkAllDeployments(deployments: any) {
 
 async function storeDeploymentHistory(deployment: any) {
   const deploymentJSON = deployment.getJSON()
-  const db = context.getAppDB()
+  const db = getAppDB()
 
   let deploymentDoc
   try {
@@ -65,7 +77,7 @@ async function storeDeploymentHistory(deployment: any) {
 }
 
 async function initDeployedApp(prodAppId: any) {
-  const db = context.getProdAppDB()
+  const db = getProdAppDB()
   console.log("Reading automation docs")
   const automations = (
     await db.allDocs(
@@ -91,9 +103,9 @@ async function initDeployedApp(prodAppId: any) {
 async function deployApp(deployment: any, userId: string) {
   let replication
   try {
-    const appId = context.getAppId()!
-    const devAppId = dbCore.getDevelopmentAppID(appId)
-    const productionAppId = dbCore.getProdAppID(appId)
+    const appId = getAppId()
+    const devAppId = getDevelopmentAppID(appId)
+    const productionAppId = getProdAppID(appId)
 
     // don't try this if feature isn't allowed, will error
     if (await backups.isEnabled()) {
@@ -110,8 +122,8 @@ async function deployApp(deployment: any, userId: string) {
       source: devAppId,
       target: productionAppId,
     }
-    replication = new dbCore.Replication(config)
-    const devDb = context.getDevAppDB()
+    replication = new Replication(config)
+    const devDb = getDevAppDB()
     console.log("Compacting development DB")
     await devDb.compact()
     console.log("Replication object created")
@@ -119,7 +131,7 @@ async function deployApp(deployment: any, userId: string) {
     console.log("replication complete.. replacing app meta doc")
     // app metadata is excluded as it is likely to be in conflict
     // replicate the app metadata document manually
-    const db = context.getProdAppDB()
+    const db = getProdAppDB()
     const appDoc = await devDb.get(DocumentType.APP_METADATA)
     try {
       const prodAppDoc = await db.get(DocumentType.APP_METADATA)
@@ -135,7 +147,7 @@ async function deployApp(deployment: any, userId: string) {
     // remove automation errors if they exist
     delete appDoc.automationErrors
     await db.put(appDoc)
-    await cache.app.invalidateAppMetadata(productionAppId)
+    await appCache.invalidateAppMetadata(productionAppId)
     console.log("New app doc written successfully.")
     await initDeployedApp(productionAppId)
     console.log("Deployed app initialised, setting deployment to successful")
@@ -158,7 +170,7 @@ async function deployApp(deployment: any, userId: string) {
 
 export async function fetchDeployments(ctx: any) {
   try {
-    const db = context.getAppDB()
+    const db = getAppDB()
     const deploymentDoc = await db.get(DocumentType.DEPLOYMENTS)
     const { updated, deployments } = await checkAllDeployments(deploymentDoc)
     if (updated) {
@@ -172,7 +184,7 @@ export async function fetchDeployments(ctx: any) {
 
 export async function deploymentProgress(ctx: any) {
   try {
-    const db = context.getAppDB()
+    const db = getAppDB()
     const deploymentDoc = await db.get(DocumentType.DEPLOYMENTS)
     ctx.body = deploymentDoc[ctx.params.deploymentId]
   } catch (err) {
@@ -185,7 +197,7 @@ export async function deploymentProgress(ctx: any) {
 
 const isFirstDeploy = async () => {
   try {
-    const db = context.getProdAppDB()
+    const db = getProdAppDB()
     await db.get(DocumentType.APP_METADATA)
   } catch (e: any) {
     if (e.status === 404) {

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

@@ -1,23 +1,29 @@
-import fetch from "node-fetch"
-import env from "../../environment"
-import { checkSlashesInUrl } from "../../utilities"
-import { request } from "../../utilities/workerRequests"
-import { clearLock as redisClearLock } from "../../utilities/redis"
-import { DocumentType } from "../../db/utils"
-import { context } from "@budibase/backend-core"
-import { events, db as dbCore, cache } from "@budibase/backend-core"
+const fetch = require("node-fetch")
+const env = require("../../environment")
+const { checkSlashesInUrl } = require("../../utilities")
+const { request } = require("../../utilities/workerRequests")
+const { clearLock } = require("../../utilities/redis")
+const { Replication, getProdAppID } = require("@budibase/backend-core/db")
+const { DocumentType } = require("../../db/utils")
+const { app: appCache } = require("@budibase/backend-core/cache")
+const { getProdAppDB, getAppDB } = require("@budibase/backend-core/context")
+const { events } = require("@budibase/backend-core")
 
-async function redirect(ctx: any, method: string, path: string = "global") {
+async function redirect(ctx, method, path = "global") {
   const { devPath } = ctx.params
   const queryString = ctx.originalUrl.split("?")[1] || ""
   const response = await fetch(
     checkSlashesInUrl(
       `${env.WORKER_URL}/api/${path}/${devPath}?${queryString}`
     ),
-    request(ctx, {
-      method,
-      body: ctx.request.body,
-    })
+    request(
+      ctx,
+      {
+        method,
+        body: ctx.request.body,
+      },
+      true
+    )
   )
   if (response.status !== 200) {
     const err = await response.text()
@@ -40,28 +46,28 @@ async function redirect(ctx: any, method: string, path: string = "global") {
   ctx.cookies
 }
 
-export function buildRedirectGet(path: string) {
-  return async (ctx: any) => {
+exports.buildRedirectGet = path => {
+  return async ctx => {
     await redirect(ctx, "GET", path)
   }
 }
 
-export function buildRedirectPost(path: string) {
-  return async (ctx: any) => {
+exports.buildRedirectPost = path => {
+  return async ctx => {
     await redirect(ctx, "POST", path)
   }
 }
 
-export function buildRedirectDelete(path: string) {
-  return async (ctx: any) => {
+exports.buildRedirectDelete = path => {
+  return async ctx => {
     await redirect(ctx, "DELETE", path)
   }
 }
 
-export async function clearLock(ctx: any) {
+exports.clearLock = async ctx => {
   const { appId } = ctx.params
   try {
-    await redisClearLock(appId, ctx.user)
+    await clearLock(appId, ctx.user)
   } catch (err) {
     ctx.throw(400, `Unable to remove lock. ${err}`)
   }
@@ -70,16 +76,16 @@ export async function clearLock(ctx: any) {
   }
 }
 
-export async function revert(ctx: any) {
+exports.revert = async ctx => {
   const { appId } = ctx.params
-  const productionAppId = dbCore.getProdAppID(appId)
+  const productionAppId = getProdAppID(appId)
 
   // App must have been deployed first
   try {
-    const db = context.getProdAppDB({ skip_setup: true })
-    const exists = await db.exists()
-    if (!exists) {
-      throw new Error("App must be deployed to be reverted.")
+    const db = getProdAppDB({ skip_setup: true })
+    const info = await db.info()
+    if (info.error) {
+      throw info.error
     }
     const deploymentDoc = await db.get(DocumentType.DEPLOYMENTS)
     if (
@@ -92,7 +98,7 @@ export async function revert(ctx: any) {
     return ctx.throw(400, "App has not yet been deployed")
   }
 
-  const replication = new dbCore.Replication({
+  const replication = new Replication({
     source: productionAppId,
     target: appId,
   })
@@ -103,12 +109,12 @@ export async function revert(ctx: any) {
     }
 
     // update appID in reverted app to be dev version again
-    const db = context.getAppDB()
+    const db = getAppDB()
     const appDoc = await db.get(DocumentType.APP_METADATA)
     appDoc.appId = appId
     appDoc.instance._id = appId
     await db.put(appDoc)
-    await cache.app.invalidateAppMetadata(appId)
+    await appCache.invalidateAppMetadata(appId)
     ctx.body = {
       message: "Reverted changes successfully.",
     }
@@ -120,7 +126,7 @@ export async function revert(ctx: any) {
   }
 }
 
-export async function getBudibaseVersion(ctx: any) {
+exports.getBudibaseVersion = async ctx => {
   const version = require("../../../package.json").version
   ctx.body = {
     version,

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

@@ -1,10 +1,10 @@
-import { EMPTY_LAYOUT } from "../../constants/layouts"
-import { generateLayoutID, getScreenParams } from "../../db/utils"
-import { events, context } from "@budibase/backend-core"
-import { BBContext } from "@budibase/types"
+const { EMPTY_LAYOUT } = require("../../constants/layouts")
+const { generateLayoutID, getScreenParams } = require("../../db/utils")
+const { getAppDB } = require("@budibase/backend-core/context")
+const { events } = require("@budibase/backend-core")
 
-export async function save(ctx: BBContext) {
-  const db = context.getAppDB()
+exports.save = async function (ctx) {
+  const db = getAppDB()
   let layout = ctx.request.body
 
   if (!layout.props) {
@@ -24,8 +24,8 @@ export async function save(ctx: BBContext) {
   ctx.status = 200
 }
 
-export async function destroy(ctx: BBContext) {
-  const db = context.getAppDB()
+exports.destroy = async function (ctx) {
+  const db = getAppDB()
   const layoutId = ctx.params.layoutId,
     layoutRev = ctx.params.layoutRev
 

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

@@ -1,16 +1,15 @@
-import { MetadataTypes } from "../../constants"
-import { generateMetadataID } from "../../db/utils"
-import { saveEntityMetadata, deleteEntityMetadata } from "../../utilities"
-import { context } from "@budibase/backend-core"
-import { BBContext } from "@budibase/types"
+const { MetadataTypes } = require("../../constants")
+const { generateMetadataID } = require("../../db/utils")
+const { saveEntityMetadata, deleteEntityMetadata } = require("../../utilities")
+const { getAppDB } = require("@budibase/backend-core/context")
 
-export async function getTypes(ctx: BBContext) {
+exports.getTypes = async ctx => {
   ctx.body = {
     types: MetadataTypes,
   }
 }
 
-export async function saveMetadata(ctx: BBContext) {
+exports.saveMetadata = async ctx => {
   const { type, entityId } = ctx.params
   if (type === MetadataTypes.AUTOMATION_TEST_HISTORY) {
     ctx.throw(400, "Cannot save automation history type")
@@ -18,7 +17,7 @@ export async function saveMetadata(ctx: BBContext) {
   ctx.body = await saveEntityMetadata(type, entityId, ctx.request.body)
 }
 
-export async function deleteMetadata(ctx: BBContext) {
+exports.deleteMetadata = async ctx => {
   const { type, entityId } = ctx.params
   await deleteEntityMetadata(type, entityId)
   ctx.body = {
@@ -26,13 +25,13 @@ export async function deleteMetadata(ctx: BBContext) {
   }
 }
 
-export async function getMetadata(ctx: BBContext) {
+exports.getMetadata = async ctx => {
   const { type, entityId } = ctx.params
-  const db = context.getAppDB()
+  const db = getAppDB()
   const id = generateMetadataID(type, entityId)
   try {
     ctx.body = await db.get(id)
-  } catch (err: any) {
+  } catch (err) {
     if (err.status === 404) {
       ctx.body = {}
     } else {