@budibase/server 2.1.32-alpha.8 → 2.1.32

package/src/sdk/app/backups/imports.ts

@@ -1,8 +1,11 @@
-import { db as dbCore, objectStore } from "@budibase/backend-core"
-import { Database } from "@budibase/types"
+import { db as dbCore } from "@budibase/backend-core"
 import { getAutomationParams, TABLE_ROW_PREFIX } from "../../../db/utils"
 import { budibaseTempDir } from "../../../utilities/budibaseDir"
 import { DB_EXPORT_FILE, GLOBAL_DB_EXPORT_FILE } from "./constants"
+import {
+  upload,
+  uploadDirectory,
+} from "../../../utilities/fileSystem/utilities"
 import { downloadTemplate } from "../../../utilities/fileSystem"
 import { FieldTypes, ObjectStoreBuckets } from "../../../constants"
 import { join } from "path"
@@ -14,6 +17,7 @@ import {
   CouchFindOptions,
   RowAttachment,
 } from "@budibase/types"
+import PouchDB from "pouchdb"
 const uuid = require("uuid/v4")
 const tar = require("tar")
 
@@ -25,7 +29,10 @@ type TemplateType = {
   key?: string
 }
 
-async function updateAttachmentColumns(prodAppId: string, db: Database) {
+async function updateAttachmentColumns(
+  prodAppId: string,
+  db: PouchDB.Database
+) {
   // iterate through attachment documents and update them
   const tables = await sdk.tables.getAllInternalTables(db)
   for (let table of tables) {
@@ -79,7 +86,7 @@ async function updateAttachmentColumns(prodAppId: string, db: Database) {
   }
 }
 
-async function updateAutomations(prodAppId: string, db: Database) {
+async function updateAutomations(prodAppId: string, db: PouchDB.Database) {
   const automations = (
     await db.allDocs(
       getAutomationParams(null, {
@@ -147,7 +154,7 @@ export function getListOfAppsInMulti(tmpPath: string) {
 
 export async function importApp(
   appId: string,
-  db: Database,
+  db: PouchDB.Database,
   template: TemplateType
 ) {
   let prodAppId = dbCore.getProdAppID(appId)
@@ -170,11 +177,11 @@ export async function importApp(
         filename = join(prodAppId, filename)
         if (fs.lstatSync(path).isDirectory()) {
           promises.push(
-            objectStore.uploadDirectory(ObjectStoreBuckets.APPS, path, filename)
+            uploadDirectory(ObjectStoreBuckets.APPS, path, filename)
           )
         } else {
           promises.push(
-            objectStore.upload({
+            upload({
               bucket: ObjectStoreBuckets.APPS,
               path,
               filename,

package/src/sdk/app/backups/statistics.ts

@@ -1,13 +1,13 @@
 import { context, db as dbCore } from "@budibase/backend-core"
-import { Database } from "@budibase/types"
 import {
   getDatasourceParams,
   getTableParams,
   getAutomationParams,
   getScreenParams,
 } from "../../../db/utils"
+import PouchDB from "pouchdb"
 
-async function runInContext(appId: string, cb: any, db?: Database) {
+async function runInContext(appId: string, cb: any, db?: PouchDB.Database) {
   if (db) {
     return cb(db)
   } else {
@@ -19,10 +19,13 @@ async function runInContext(appId: string, cb: any, db?: Database) {
   }
 }
 
-export async function calculateDatasourceCount(appId: string, db?: Database) {
+export async function calculateDatasourceCount(
+  appId: string,
+  db?: PouchDB.Database
+) {
   return runInContext(
     appId,
-    async (db: Database) => {
+    async (db: PouchDB.Database) => {
       const datasourceList = await db.allDocs(getDatasourceParams())
       const tableList = await db.allDocs(getTableParams())
       return datasourceList.rows.length + tableList.rows.length
@@ -31,10 +34,13 @@ export async function calculateDatasourceCount(appId: string, db?: Database) {
   )
 }
 
-export async function calculateAutomationCount(appId: string, db?: Database) {
+export async function calculateAutomationCount(
+  appId: string,
+  db?: PouchDB.Database
+) {
   return runInContext(
     appId,
-    async (db: Database) => {
+    async (db: PouchDB.Database) => {
       const automationList = await db.allDocs(getAutomationParams())
       return automationList.rows.length
     },
@@ -42,10 +48,13 @@ export async function calculateAutomationCount(appId: string, db?: Database) {
   )
 }
 
-export async function calculateScreenCount(appId: string, db?: Database) {
+export async function calculateScreenCount(
+  appId: string,
+  db?: PouchDB.Database
+) {
   return runInContext(
     appId,
-    async (db: Database) => {
+    async (db: PouchDB.Database) => {
       const screenList = await db.allDocs(getScreenParams())
       return screenList.rows.length
     },
@@ -54,7 +63,7 @@ export async function calculateScreenCount(appId: string, db?: Database) {
 }
 
 export async function calculateBackupStats(appId: string) {
-  return runInContext(appId, async (db: Database) => {
+  return runInContext(appId, async (db: PouchDB.Database) => {
     const promises = []
     promises.push(calculateDatasourceCount(appId, db))
     promises.push(calculateAutomationCount(appId, db))

package/src/sdk/app/tables/index.ts

@@ -1,15 +1,16 @@
-import { context } from "@budibase/backend-core"
+import { getAppDB } from "@budibase/backend-core/context"
 import { BudibaseInternalDB, getTableParams } from "../../../db/utils"
 import {
   breakExternalTableId,
   isExternalTable,
   isSQL,
 } from "../../../integrations/utils"
-import { Table, Database } from "@budibase/types"
+import { Table } from "@budibase/types"
+import PouchDB from "pouchdb"
 
-async function getAllInternalTables(db?: Database): Promise<Table[]> {
+async function getAllInternalTables(db?: PouchDB.Database): Promise<Table[]> {
   if (!db) {
-    db = context.getAppDB()
+    db = getAppDB() as PouchDB.Database
   }
   const internalTables = await db.allDocs(
     getTableParams(null, {
@@ -19,12 +20,12 @@ async function getAllInternalTables(db?: Database): Promise<Table[]> {
   return internalTables.rows.map((tableDoc: any) => ({
     ...tableDoc.doc,
     type: "internal",
-    sourceId: tableDoc.doc.sourceId || BudibaseInternalDB._id,
+    sourceId: BudibaseInternalDB._id,
   }))
 }
 
 async function getAllExternalTables(datasourceId: any): Promise<Table[]> {
-  const db = context.getAppDB()
+  const db = getAppDB()
   const datasource = await db.get(datasourceId)
   if (!datasource || !datasource.entities) {
     throw "Datasource is not configured fully."
@@ -41,7 +42,7 @@ async function getExternalTable(
 }
 
 async function getTable(tableId: any): Promise<Table> {
-  const db = context.getAppDB()
+  const db = getAppDB()
   if (isExternalTable(tableId)) {
     let { datasourceId, tableName } = breakExternalTableId(tableId)
     const datasource = await db.get(datasourceId)

package/src/startup.ts

@@ -1,5 +1,5 @@
 import * as env from "./environment"
-import * as redis from "./utilities/redis"
+import redis from "./utilities/redis"
 import {
   createAdminUser,
   generateApiKey,
@@ -19,7 +19,7 @@ import eventEmitter from "./events"
 import * as migrations from "./migrations"
 import bullboard from "./automations/bullboard"
 import * as pro from "@budibase/pro"
-import * as api from "./api"
+import api from "./api"
 import sdk from "./sdk"
 const pino = require("koa-pino-logger")
 

package/src/tests/utilities/TestConfiguration.js

@@ -1,4 +1,5 @@
 require("../../db").init()
+const { BUILTIN_ROLE_IDS } = require("@budibase/backend-core/roles")
 const env = require("../../environment")
 const {
   basicTable,
@@ -12,21 +13,18 @@ const {
   basicWebhook,
   TENANT_ID,
 } = require("./structures")
-const {
-  constants,
-  tenancy,
-  sessions,
-  cache,
-  context,
-  db: dbCore,
-  encryption,
-  auth,
-  roles,
-} = require("@budibase/backend-core")
 const controllers = require("./controllers")
 const supertest = require("supertest")
 const { cleanup } = require("../../utilities/fileSystem")
+const { Cookies, Headers } = require("@budibase/backend-core/constants")
+const { jwt } = require("@budibase/backend-core/auth")
+const { doInTenant, doWithGlobalDB } = require("@budibase/backend-core/tenancy")
+const { createASession } = require("@budibase/backend-core/sessions")
+const { user: userCache } = require("@budibase/backend-core/cache")
 const newid = require("../../db/newid")
+const context = require("@budibase/backend-core/context")
+const { generateDevInfoID, SEPARATOR } = require("@budibase/backend-core/db")
+const { encrypt } = require("@budibase/backend-core/encryption")
 const { DocumentType, generateUserMetadataID } = require("../../db/utils")
 const { startup } = require("../../startup")
 
@@ -85,7 +83,7 @@ class TestConfiguration {
     if (!appId) {
       appId = this.appId
     }
-    return tenancy.doInTenant(TENANT_ID, () => {
+    return doInTenant(TENANT_ID, () => {
       // check if already in a context
       if (context.getAppId() == null && appId !== null) {
         return context.doInAppContext(appId, async () => {
@@ -118,9 +116,7 @@ class TestConfiguration {
     if (this.server) {
       this.server.close()
     }
-    if (this.allApps) {
-      cleanup(this.allApps.map(app => app.appId))
-    }
+    cleanup(this.allApps.map(app => app.appId))
   }
 
   // UTILS
@@ -157,7 +153,7 @@ class TestConfiguration {
     email = EMAIL,
     roles,
   } = {}) {
-    return tenancy.doWithGlobalDB(TENANT_ID, async db => {
+    return doWithGlobalDB(TENANT_ID, async db => {
       let existing
       try {
         existing = await db.get(id)
@@ -172,7 +168,7 @@ class TestConfiguration {
         firstName,
         lastName,
       }
-      await sessions.createASession(id, {
+      await createASession(id, {
         sessionId: "sessionid",
         tenantId: TENANT_ID,
         csrfToken: CSRF_TOKEN,
@@ -214,7 +210,7 @@ class TestConfiguration {
       admin,
       roles,
     })
-    await cache.user.invalidateUser(globalId)
+    await userCache.invalidateUser(globalId)
     return {
       ...resp,
       globalId,
@@ -229,19 +225,19 @@ class TestConfiguration {
         throw "Server has not been opened, cannot login."
       }
       // make sure the user exists in the global DB
-      if (roleId !== roles.BUILTIN_ROLE_IDS.PUBLIC) {
+      if (roleId !== BUILTIN_ROLE_IDS.PUBLIC) {
         await this.globalUser({
           id: userId,
           builder,
           roles: { [this.prodAppId]: roleId },
         })
       }
-      await sessions.createASession(userId, {
+      await createASession(userId, {
         sessionId: "sessionid",
         tenantId: TENANT_ID,
       })
       // have to fake this
-      const authObj = {
+      const auth = {
         userId,
         sessionId: "sessionid",
         tenantId: TENANT_ID,
@@ -250,45 +246,45 @@ class TestConfiguration {
         roleId: roleId,
         appId,
       }
-      const authToken = auth.jwt.sign(authObj, env.JWT_SECRET)
-      const appToken = auth.jwt.sign(app, env.JWT_SECRET)
+      const authToken = jwt.sign(auth, env.JWT_SECRET)
+      const appToken = jwt.sign(app, env.JWT_SECRET)
 
       // returning necessary request headers
-      await cache.user.invalidateUser(userId)
+      await userCache.invalidateUser(userId)
       return {
         Accept: "application/json",
         Cookie: [
-          `${constants.Cookie.Auth}=${authToken}`,
-          `${constants.Cookie.CurrentApp}=${appToken}`,
+          `${Cookies.Auth}=${authToken}`,
+          `${Cookies.CurrentApp}=${appToken}`,
         ],
-        [constants.Header.APP_ID]: appId,
+        [Headers.APP_ID]: appId,
       }
     })
   }
 
   defaultHeaders(extras = {}) {
-    const authObj = {
+    const auth = {
       userId: GLOBAL_USER_ID,
       sessionId: "sessionid",
       tenantId: TENANT_ID,
     }
     const app = {
-      roleId: roles.BUILTIN_ROLE_IDS.ADMIN,
+      roleId: BUILTIN_ROLE_IDS.ADMIN,
       appId: this.appId,
     }
-    const authToken = auth.jwt.sign(authObj, env.JWT_SECRET)
-    const appToken = auth.jwt.sign(app, env.JWT_SECRET)
+    const authToken = jwt.sign(auth, env.JWT_SECRET)
+    const appToken = jwt.sign(app, env.JWT_SECRET)
     const headers = {
       Accept: "application/json",
       Cookie: [
-        `${constants.Cookie.Auth}=${authToken}`,
-        `${constants.Cookie.CurrentApp}=${appToken}`,
+        `${Cookies.Auth}=${authToken}`,
+        `${Cookies.CurrentApp}=${appToken}`,
       ],
-      [constants.Header.CSRF_TOKEN]: CSRF_TOKEN,
+      [Headers.CSRF_TOKEN]: CSRF_TOKEN,
       ...extras,
     }
     if (this.appId) {
-      headers[constants.Header.APP_ID] = this.appId
+      headers[Headers.APP_ID] = this.appId
     }
     return headers
   }
@@ -300,14 +296,14 @@ class TestConfiguration {
       Accept: "application/json",
     }
     if (appId) {
-      headers[constants.Header.APP_ID] = appId
+      headers[Headers.APP_ID] = appId
     }
     return headers
   }
 
   async roleHeaders({
     email = EMAIL,
-    roleId = roles.BUILTIN_ROLE_IDS.ADMIN,
+    roleId = BUILTIN_ROLE_IDS.ADMIN,
     builder = false,
     prodApp = true,
   } = {}) {
@@ -317,17 +313,15 @@ class TestConfiguration {
   // API
 
   async generateApiKey(userId = GLOBAL_USER_ID) {
-    return tenancy.doWithGlobalDB(TENANT_ID, async db => {
-      const id = dbCore.generateDevInfoID(userId)
+    return doWithGlobalDB(TENANT_ID, async db => {
+      const id = generateDevInfoID(userId)
       let devInfo
       try {
         devInfo = await db.get(id)
       } catch (err) {
         devInfo = { _id: id, userId }
       }
-      devInfo.apiKey = encryption.encrypt(
-        `${TENANT_ID}${dbCore.SEPARATOR}${newid()}`
-      )
+      devInfo.apiKey = encrypt(`${TENANT_ID}${SEPARATOR}${newid()}`)
       await db.put(devInfo)
       return devInfo.apiKey
     })

package/src/tests/utilities/structures.js

@@ -1,4 +1,5 @@
-const { roles, permissions } = require("@budibase/backend-core")
+const { BUILTIN_ROLE_IDS } = require("@budibase/backend-core/roles")
+const { BUILTIN_PERMISSION_IDS } = require("@budibase/backend-core/permissions")
 const { createHomeScreen } = require("../../constants/screens")
 const { EMPTY_LAYOUT } = require("../../constants/layouts")
 const { cloneDeep } = require("lodash/fp")
@@ -133,8 +134,8 @@ exports.basicLinkedRow = (tableId, linkedRowId, linkField = "link") => {
 exports.basicRole = () => {
   return {
     name: "NewRole",
-    inherits: roles.BUILTIN_ROLE_IDS.BASIC,
-    permissionId: permissions.BuiltinPermissionID.READ_ONLY,
+    inherits: BUILTIN_ROLE_IDS.BASIC,
+    permissionId: BUILTIN_PERMISSION_IDS.READ_ONLY,
   }
 }
 

package/src/threads/automation.ts

@@ -23,14 +23,15 @@ import {
   AutomationMetadata,
 } from "../definitions/automations"
 import { WorkerCallback } from "./definitions"
-import { context, logging } from "@budibase/backend-core"
-import { processObject } from "@budibase/string-templates"
-import { cloneDeep } from "lodash/fp"
-import env from "../environment"
+const { doInAppContext, getAppDB } = require("@budibase/backend-core/context")
+const { logAlertWithInfo, logWarn } = require("@budibase/backend-core/logging")
+const { processObject } = require("@budibase/string-templates")
 const FILTER_STEP_ID = actions.ACTION_DEFINITIONS.FILTER.stepId
 const LOOP_STEP_ID = actions.ACTION_DEFINITIONS.LOOP.stepId
 const CRON_STEP_ID = triggerDefs.CRON.stepId
 const STOPPED_STATUS = { success: true, status: AutomationStatus.STOPPED }
+const { cloneDeep } = require("lodash/fp")
+const env = require("../environment")
 
 function typecastForLooping(loopStep: LoopStep, input: LoopInput) {
   if (!input || !input.binding) {
@@ -119,8 +120,8 @@ class Orchestrator {
   }
 
   async getMetadata(): Promise<AutomationMetadata> {
-    const metadataId = generateAutomationMetadataID(this._automation._id!)
-    const db = context.getAppDB()
+    const metadataId = generateAutomationMetadataID(this._automation._id)
+    const db = getAppDB()
     let metadata: AutomationMetadata
     try {
       metadata = await db.get(metadataId)
@@ -137,7 +138,7 @@ class Orchestrator {
     if (!this._job.opts.repeat) {
       return
     }
-    logging.logWarn(
+    logWarn(
       `CRON disabled reason=${reason} - ${this._appId}/${this._automation._id}`
     )
     const automation = this._automation
@@ -183,14 +184,14 @@ class Orchestrator {
     } else {
       metadata.errorCount = 0
     }
-    const db = context.getAppDB()
+    const db = getAppDB()
     try {
       await db.put(metadata)
     } catch (err) {
-      logging.logAlertWithInfo(
+      logAlertWithInfo(
         "Failed to write automation metadata",
         db.name,
-        automation._id!,
+        automation._id,
         err
       )
     }
@@ -264,7 +265,7 @@ class Orchestrator {
 
     for (let step of automation.definition.steps) {
       stepCount++
-      let input: any,
+      let input,
         iterations = 1,
         iterationCount = 0
 
@@ -282,7 +283,7 @@ class Orchestrator {
         let originalStepInput = cloneDeep(step.inputs)
         // Handle if the user has set a max iteration count or if it reaches the max limit set by us
         if (loopStep && input.binding) {
-          let newInput: any = await processObject(
+          let newInput = await processObject(
             loopStep.inputs,
             cloneDeep(this._context)
           )
@@ -351,7 +352,7 @@ class Orchestrator {
             }
           }
           if (
-            index === env.AUTOMATION_MAX_ITERATIONS ||
+            index === env.AUTOMATION_MAX_ITERATION ||
             index === parseInt(loopStep.inputs.iterations)
           ) {
             this.updateContextAndOutput(loopStepNumber, step, tempOutput, {
@@ -480,7 +481,7 @@ export function execute(job: Job, callback: WorkerCallback) {
   if (!appId) {
     throw new Error("Unable to execute, event doesn't contain app ID.")
   }
-  return context.doInAppContext(appId, async () => {
+  doInAppContext(appId, async () => {
     const automationOrchestrator = new Orchestrator(job)
     try {
       const response = await automationOrchestrator.execute()
@@ -496,7 +497,7 @@ export const removeStalled = async (job: Job) => {
   if (!appId) {
     throw new Error("Unable to execute, event doesn't contain app ID.")
   }
-  await context.doInAppContext(appId, async () => {
+  await doInAppContext(appId, async () => {
     const automationOrchestrator = new Orchestrator(job)
     await automationOrchestrator.stopCron("stalled")
   })

package/src/threads/query.ts

@@ -1,12 +1,17 @@
 import { default as threadUtils } from "./utils"
 threadUtils.threadSetup()
 import { WorkerCallback, QueryEvent, QueryVariable } from "./definitions"
-import ScriptRunner from "../utilities/scriptRunner"
-import { getIntegration } from "../integrations"
-import { processStringSync } from "@budibase/string-templates"
-import { context, cache, auth } from "@budibase/backend-core"
-import { getGlobalIDFromUserMetadataID } from "../db/utils"
-import { cloneDeep } from "lodash/fp"
+const ScriptRunner = require("../utilities/scriptRunner")
+const { getIntegration } = require("../integrations")
+const { processStringSync } = require("@budibase/string-templates")
+const { doInAppContext, getAppDB } = require("@budibase/backend-core/context")
+const {
+  refreshOAuthToken,
+  updateUserOAuth,
+} = require("@budibase/backend-core/auth")
+const { user: userCache } = require("@budibase/backend-core/cache")
+const { getGlobalIDFromUserMetadataID } = require("../db/utils")
+const { cloneDeep } = require("lodash/fp")
 
 const { isSQL } = require("../integrations/utils")
 const {
@@ -165,7 +170,7 @@ class QueryRunner {
   }
 
   async runAnotherQuery(queryId: string, parameters: any) {
-    const db = context.getAppDB()
+    const db = getAppDB()
     const query = await db.get(queryId)
     const datasource = await db.get(query.datasourceId)
     return new QueryRunner(
@@ -189,7 +194,7 @@ class QueryRunner {
       throw new Error("No refresh token found for authenticated user")
     }
 
-    const resp: any = await auth.refreshOAuthToken(
+    const resp = await refreshOAuthToken(
       oauth2.refreshToken,
       providerType,
       configId
@@ -199,8 +204,8 @@ class QueryRunner {
     // There are several other properties available in 'resp'
     if (!resp.err) {
       const globalUserId = getGlobalIDFromUserMetadataID(_id)
-      await auth.updateUserOAuth(globalUserId, resp)
-      this.ctx.user = await cache.user.getUser(globalUserId)
+      await updateUserOAuth(globalUserId, resp)
+      this.ctx.user = await userCache.getUser(globalUserId)
     } else {
       // In this event the user may have oAuth issues that
       // could require re-authenticating with their provider.
@@ -280,7 +285,7 @@ class QueryRunner {
 }
 
 export function execute(input: QueryEvent, callback: WorkerCallback) {
-  context.doInAppContext(input.appId!, async () => {
+  doInAppContext(input.appId, async () => {
     const Runner = new QueryRunner(input)
     try {
       const response = await Runner.execute()

package/src/threads/utils.ts

@@ -1,7 +1,8 @@
 import { QueryVariable } from "./definitions"
-import env from "../environment"
-import db from "../db"
-import { redis, db as dbCore } from "@budibase/backend-core"
+const env = require("../environment")
+const db = require("../db")
+const redis = require("@budibase/backend-core/redis")
+const { SEPARATOR } = require("@budibase/backend-core/db")
 
 const VARIABLE_TTL_SECONDS = 3600
 let client: any
@@ -20,7 +21,7 @@ process.on("exit", async () => {
 })
 
 function makeVariableKey(queryId: string, variable: string) {
-  return `${queryId}${dbCore.SEPARATOR}${variable}`
+  return `${queryId}${SEPARATOR}${variable}`
 }
 
 export function threadSetup() {

package/src/utilities/budibaseDir.js

@@ -0,0 +1,3 @@
+const { budibaseTempDir } = require("@budibase/backend-core/objectStore")
+
+module.exports.budibaseTempDir = budibaseTempDir