@budibase/server 2.1.43-alpha.2 → 2.1.43

package/src/tests/utilities/{structures.ts → structures.js}

@@ -1,13 +1,14 @@
-import { roles, permissions } from "@budibase/backend-core"
-import { createHomeScreen } from "../../constants/screens"
-import { EMPTY_LAYOUT } from "../../constants/layouts"
-import { cloneDeep } from "lodash/fp"
-import { TRIGGER_DEFINITIONS, ACTION_DEFINITIONS } from "../../automations"
+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")
 const { v4: uuidv4 } = require("uuid")
+const { TRIGGER_DEFINITIONS, ACTION_DEFINITIONS } = require("../../automations")
 
-export const TENANT_ID = "default"
+exports.TENANT_ID = "default"
 
-export function basicTable() {
+exports.basicTable = () => {
   return {
     name: "TestTable",
     type: "table",
@@ -29,16 +30,16 @@ export function basicTable() {
   }
 }
 
-export function basicView(tableId: string) {
+exports.basicView = tableId => {
   return {
     tableId,
     name: "ViewTest",
   }
 }
 
-export function filterView(tableId: string) {
+exports.filterView = tableId => {
   return {
-    ...basicView(tableId),
+    ...this.basicView(tableId),
     filters: [
       {
         value: 0,
@@ -49,58 +50,56 @@ export function filterView(tableId: string) {
   }
 }
 
-export function calculationView(tableId: string) {
+exports.calculationView = tableId => {
   return {
-    ...basicView(tableId),
+    ...this.basicView(tableId),
     field: "count",
     calculation: "sum",
   }
 }
 
-export function view(tableId: string) {
+exports.view = tableId => {
   return {
-    ...filterView(tableId),
-    ...calculationView(tableId),
+    ...this.filterView(tableId),
+    ...this.calculationView(tableId),
   }
 }
 
-export function automationStep(
-  actionDefinition = ACTION_DEFINITIONS.CREATE_ROW
-) {
+exports.automationStep = (actionDefinition = ACTION_DEFINITIONS.CREATE_ROW) => {
   return {
     id: uuidv4(),
     ...actionDefinition,
   }
 }
 
-export function automationTrigger(
+exports.automationTrigger = (
   triggerDefinition = TRIGGER_DEFINITIONS.ROW_SAVED
-) {
+) => {
   return {
     id: uuidv4(),
     ...triggerDefinition,
   }
 }
 
-export function newAutomation({ steps, trigger }: any = {}) {
-  const automation: any = basicAutomation()
+exports.newAutomation = ({ steps, trigger } = {}) => {
+  const automation = exports.basicAutomation()
 
   if (trigger) {
     automation.definition.trigger = trigger
   } else {
-    automation.definition.trigger = automationTrigger()
+    automation.definition.trigger = exports.automationTrigger()
   }
 
   if (steps) {
     automation.definition.steps = steps
   } else {
-    automation.definition.steps = [automationStep()]
+    automation.definition.steps = [exports.automationStep()]
   }
 
   return automation
 }
 
-export function basicAutomation() {
+exports.basicAutomation = () => {
   return {
     name: "My Automation",
     screenId: "kasdkfldsafkl",
@@ -116,7 +115,7 @@ export function basicAutomation() {
   }
 }
 
-export function basicRow(tableId: string) {
+exports.basicRow = tableId => {
   return {
     name: "Test Contact",
     description: "original description",
@@ -124,27 +123,23 @@ export function basicRow(tableId: string) {
   }
 }
 
-export function basicLinkedRow(
-  tableId: string,
-  linkedRowId: string,
-  linkField: string = "link"
-) {
+exports.basicLinkedRow = (tableId, linkedRowId, linkField = "link") => {
   // this is based on the basic linked tables you get from the test configuration
   return {
-    ...basicRow(tableId),
+    ...exports.basicRow(tableId),
     [linkField]: [linkedRowId],
   }
 }
 
-export function basicRole() {
+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,
   }
 }
 
-export function basicDatasource() {
+exports.basicDatasource = () => {
   return {
     datasource: {
       type: "datasource",
@@ -155,7 +150,7 @@ export function basicDatasource() {
   }
 }
 
-export function basicQuery(datasourceId: string) {
+exports.basicQuery = datasourceId => {
   return {
     datasourceId: datasourceId,
     name: "New Query",
@@ -166,7 +161,7 @@ export function basicQuery(datasourceId: string) {
   }
 }
 
-export function basicUser(role: string) {
+exports.basicUser = role => {
   return {
     email: "bill@bill.com",
     password: "yeeooo",
@@ -174,15 +169,15 @@ export function basicUser(role: string) {
   }
 }
 
-export function basicScreen() {
+exports.basicScreen = () => {
   return createHomeScreen()
 }
 
-export function basicLayout() {
+exports.basicLayout = () => {
   return cloneDeep(EMPTY_LAYOUT)
 }
 
-export function basicWebhook(automationId: string) {
+exports.basicWebhook = automationId => {
   return {
     live: true,
     name: "webhook",

package/src/threads/automation.ts

@@ -6,8 +6,8 @@ import {
   disableCronById,
   isErrorInOutput,
 } from "../automations/utils"
-import * as actions from "../automations/actions"
-import * as automationUtils from "../automations/automationUtils"
+import { default as actions } from "../automations/actions"
+import { default as automationUtils } from "../automations/automationUtils"
 import { default as AutomationEmitter } from "../events/AutomationEmitter"
 import { generateAutomationMetadataID, isProdAppID } from "../db/utils"
 import { definitions as triggerDefs } from "../automations/triggerInfo"
@@ -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)
           )
@@ -335,7 +336,7 @@ class Orchestrator {
                   )) {
                     originalStepInput[key][innerKey][innerObject] =
                       automationUtils.substituteLoopStep(
-                        innerValue as string,
+                        innerValue,
                         `steps.${loopStepNumber}`
                       )
                   }
@@ -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 {
@@ -164,7 +169,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 * as 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

package/src/utilities/{centralPath.ts → centralPath.js}

@@ -1,4 +1,4 @@
-import path from "path"
+const path = require("path")
 
 // this simply runs all of our path join and resolve functions through
 // a central location incase we need to add some protection to file paths
@@ -8,7 +8,7 @@ import path from "path"
  * @param args Any number of string arguments to add to a path
  * @returns {string} The final path ready to use
  */
-export function join(...args: any) {
+exports.join = function (...args) {
   return path.join(...args)
 }
 
@@ -17,6 +17,6 @@ export function join(...args: any) {
  * @param args Any number of string arguments to add to a path
  * @returns {string} The final path ready to use
  */
-export function resolve(...args: any) {
+exports.resolve = function (...args) {
   return path.resolve(...args)
 }

package/src/utilities/{csvParser.ts → csvParser.js}

@@ -1,25 +1,18 @@
-import { FieldSchema, Table } from "@budibase/types"
-import csv from "csvtojson"
-import { FieldTypes } from "../constants"
+const csv = require("csvtojson")
+const { FieldTypes } = require("../constants")
 
-type CsvParseOpts = {
-  schema?: { [key: string]: any }
-  existingTable: Table
-  csvString?: string
-}
-
-const VALIDATORS: any = {
+const VALIDATORS = {
   [FieldTypes.STRING]: () => true,
   [FieldTypes.OPTIONS]: () => true,
   [FieldTypes.BARCODEQR]: () => true,
-  [FieldTypes.NUMBER]: (attribute?: string) => {
+  [FieldTypes.NUMBER]: attribute => {
     // allow not to be present
     if (!attribute) {
       return true
     }
     return !isNaN(Number(attribute))
   },
-  [FieldTypes.DATETIME]: (attribute?: string) => {
+  [FieldTypes.DATETIME]: attribute => {
     // allow not to be present
     if (!attribute) {
       return true
@@ -28,14 +21,14 @@ const VALIDATORS: any = {
   },
 }
 
-const PARSERS: any = {
-  [FieldTypes.NUMBER]: (attribute?: string) => {
+const PARSERS = {
+  [FieldTypes.NUMBER]: attribute => {
     if (!attribute) {
       return attribute
     }
     return Number(attribute)
   },
-  [FieldTypes.DATETIME]: (attribute?: string) => {
+  [FieldTypes.DATETIME]: attribute => {
     if (!attribute) {
       return attribute
     }
@@ -43,10 +36,10 @@ const PARSERS: any = {
   },
 }
 
-export function parse(csvString: string, parsers: any): Record<string, any> {
+function parse(csvString, parsers) {
   const result = csv().fromString(csvString)
 
-  const schema: Record<string, any> = {}
+  const schema = {}
 
   return new Promise((resolve, reject) => {
     result.on("header", headers => {
@@ -84,22 +77,16 @@ export function parse(csvString: string, parsers: any): Record<string, any> {
   })
 }
 
-export function updateSchema({
-  schema,
-  existingTable,
-}: {
-  schema?: Record<string, any>
-  existingTable?: Table
-}) {
+function updateSchema({ schema, existingTable }) {
   if (!schema) {
     return schema
   }
-  const finalSchema: Record<string, FieldSchema> = {}
-  const schemaKeyMap: Record<string, any> = {}
+  const finalSchema = {}
+  const schemaKeyMap = {}
   Object.keys(schema).forEach(key => (schemaKeyMap[key.toLowerCase()] = key))
-  for (let [key, field] of Object.entries(existingTable?.schema || {})) {
+  for (let [key, field] of Object.entries(existingTable.schema)) {
     const lcKey = key.toLowerCase()
-    const foundKey: string = schemaKeyMap[lcKey]
+    const foundKey = schemaKeyMap[lcKey]
     if (foundKey) {
       finalSchema[key] = schema[foundKey]
       finalSchema[key].type = field.type
@@ -108,22 +95,15 @@ export function updateSchema({
   return finalSchema
 }
 
-export async function transform({
-  schema,
-  csvString,
-  existingTable,
-}: CsvParseOpts) {
-  if (!schema || !csvString) {
-    throw new Error("Unable to transform CSV without schema")
-  }
-  const colParser: any = {}
+async function transform({ schema, csvString, existingTable }) {
+  const colParser = {}
 
   // make sure the table has all the columns required for import
   if (existingTable) {
     schema = updateSchema({ schema, existingTable })
   }
 
-  for (let [key, field] of Object.entries(schema || {})) {
+  for (let [key, field] of Object.entries(schema)) {
     // don't import data to auto columns
     if (!field.autocolumn) {
       colParser[key] = PARSERS[field.type] || field.type
@@ -132,10 +112,8 @@ export async function transform({
 
   try {
     const data = await csv({ colParser }).fromString(csvString)
-    const schemaKeyMap: any = {}
-    Object.keys(schema || {}).forEach(
-      key => (schemaKeyMap[key.toLowerCase()] = key)
-    )
+    const schemaKeyMap = {}
+    Object.keys(schema).forEach(key => (schemaKeyMap[key.toLowerCase()] = key))
     for (let element of data) {
       if (!data) {
         continue
@@ -159,3 +137,9 @@ export async function transform({
     throw err
   }
 }
+
+module.exports = {
+  parse,
+  transform,
+  updateSchema,
+}

package/src/utilities/fileSystem/{clientLibrary.ts → clientLibrary.js}

@@ -1,9 +1,9 @@
-import { join } from "path"
-import { ObjectStoreBuckets } from "../../constants"
-import fs from "fs"
-import { objectStore } from "@budibase/backend-core"
-import { resolve } from "../centralPath"
-import env from "../../environment"
+const { join } = require("path")
+const { ObjectStoreBuckets } = require("../../constants")
+const fs = require("fs")
+const { upload, retrieveToTmp, streamUpload } = require("./utilities")
+const { resolve } = require("../centralPath")
+const env = require("../../environment")
 const TOP_LEVEL_PATH = join(__dirname, "..", "..", "..")
 
 /**
@@ -33,18 +33,18 @@ const TOP_LEVEL_PATH = join(__dirname, "..", "..", "..")
  * @param appId The app ID to backup
  * @returns {Promise<void>}
  */
-export async function backupClientLibrary(appId: string) {
+exports.backupClientLibrary = async appId => {
   // Copy existing manifest to tmp
   let tmpManifestPath
   try {
     // Try to load the manifest from the new file location
-    tmpManifestPath = await objectStore.retrieveToTmp(
+    tmpManifestPath = await retrieveToTmp(
       ObjectStoreBuckets.APPS,
       join(appId, "manifest.json")
     )
   } catch (error) {
     // Fallback to loading it from the old location for old apps
-    tmpManifestPath = await objectStore.retrieveToTmp(
+    tmpManifestPath = await retrieveToTmp(
       ObjectStoreBuckets.APPS,
       join(
         appId,
@@ -58,19 +58,19 @@ export async function backupClientLibrary(appId: string) {
   }
 
   // Copy existing client lib to tmp
-  const tmpClientPath = await objectStore.retrieveToTmp(
+  const tmpClientPath = await retrieveToTmp(
     ObjectStoreBuckets.APPS,
     join(appId, "budibase-client.js")
   )
 
   // Upload manifest and client library as backups
-  const manifestUpload = objectStore.upload({
+  const manifestUpload = upload({
     bucket: ObjectStoreBuckets.APPS,
     filename: join(appId, "manifest.json.bak"),
     path: tmpManifestPath,
     type: "application/json",
   })
-  const clientUpload = objectStore.upload({
+  const clientUpload = upload({
     bucket: ObjectStoreBuckets.APPS,
     filename: join(appId, "budibase-client.js.bak"),
     path: tmpClientPath,
@@ -85,7 +85,7 @@ export async function backupClientLibrary(appId: string) {
  * @param appId The app ID to update
  * @returns {Promise<void>}
  */
-export async function updateClientLibrary(appId: string) {
+exports.updateClientLibrary = async appId => {
   let manifest, client
 
   if (env.isDev()) {
@@ -99,7 +99,7 @@ export async function updateClientLibrary(appId: string) {
   }
 
   // Upload latest manifest and client library
-  const manifestUpload = objectStore.streamUpload(
+  const manifestUpload = streamUpload(
     ObjectStoreBuckets.APPS,
     join(appId, "manifest.json"),
     fs.createReadStream(manifest),
@@ -107,7 +107,7 @@ export async function updateClientLibrary(appId: string) {
       ContentType: "application/json",
     }
   )
-  const clientUpload = objectStore.streamUpload(
+  const clientUpload = streamUpload(
     ObjectStoreBuckets.APPS,
     join(appId, "budibase-client.js"),
     fs.createReadStream(client),
@@ -124,27 +124,27 @@ export async function updateClientLibrary(appId: string) {
  * @param appId The app ID to revert
  * @returns {Promise<void>}
  */
-export async function revertClientLibrary(appId: string) {
+exports.revertClientLibrary = async appId => {
   // Copy backups manifest to tmp directory
-  const tmpManifestPath = await objectStore.retrieveToTmp(
+  const tmpManifestPath = await retrieveToTmp(
     ObjectStoreBuckets.APPS,
     join(appId, "manifest.json.bak")
   )
 
   // Copy backup client lib to tmp
-  const tmpClientPath = await objectStore.retrieveToTmp(
+  const tmpClientPath = await retrieveToTmp(
     ObjectStoreBuckets.APPS,
     join(appId, "budibase-client.js.bak")
   )
 
   // Upload backups as new versions
-  const manifestUpload = objectStore.upload({
+  const manifestUpload = upload({
     bucket: ObjectStoreBuckets.APPS,
     filename: join(appId, "manifest.json"),
     path: tmpManifestPath,
     type: "application/json",
   })
-  const clientUpload = objectStore.upload({
+  const clientUpload = upload({
     bucket: ObjectStoreBuckets.APPS,
     filename: join(appId, "budibase-client.js"),
     path: tmpClientPath,