@budibase/server 1.0.219 → 1.0.220-alpha.2

package/src/threads/query.js

@@ -4,6 +4,14 @@ const ScriptRunner = require("../utilities/scriptRunner")
 const { integrations } = 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 {
   enrichQueryFields,
@@ -21,29 +29,58 @@ class QueryRunner {
     this.queryId = input.queryId
     this.noRecursiveQuery = flags.noRecursiveQuery
     this.cachedVariables = []
+    // Additional context items for enrichment
+    this.ctx = input.ctx
     // allows the response from a query to be stored throughout this
     // execution so that if it needs to be re-used for another variable
     // it can be
     this.queryResponse = {}
     this.hasRerun = false
+    this.hasRefreshedOAuth = false
   }
 
   async execute() {
     let { datasource, fields, queryVerb, transformer } = this
-    const Integration = integrations[datasource.source]
+
+    let datasourceClone = cloneDeep(datasource)
+    let fieldsClone = cloneDeep(fields)
+
+    const Integration = integrations[datasourceClone.source]
     if (!Integration) {
       throw "Integration type does not exist."
     }
-    const integration = new Integration(datasource.config)
+
+    if (datasourceClone.config.authConfigs) {
+      datasourceClone.config.authConfigs =
+        datasourceClone.config.authConfigs.map(config => {
+          return enrichQueryFields(config, this.ctx)
+        })
+    }
+
+    const integration = new Integration(datasourceClone.config)
 
     // pre-query, make sure datasource variables are added to parameters
     const parameters = await this.addDatasourceVariables()
+
+    // Enrich the parameters with the addition context items.
+    // 'user' is now a reserved variable key in mapping parameters
+    const enrichedParameters = enrichQueryFields(parameters, this.ctx)
+    const enrichedContext = { ...enrichedParameters, ...this.ctx }
+
+    // Parse global headers
+    if (datasourceClone.config.defaultHeaders) {
+      datasourceClone.config.defaultHeaders = enrichQueryFields(
+        datasourceClone.config.defaultHeaders,
+        enrichedContext
+      )
+    }
+
     let query
     // handle SQL injections by interpolating the variables
-    if (isSQL(datasource)) {
-      query = interpolateSQL(fields, parameters, integration)
+    if (isSQL(datasourceClone)) {
+      query = interpolateSQL(fieldsClone, enrichedParameters, integration)
     } else {
-      query = enrichQueryFields(fields, parameters)
+      query = enrichQueryFields(fieldsClone, enrichedContext)
     }
 
     // Add pagination values for REST queries
@@ -67,20 +104,25 @@ class QueryRunner {
     if (transformer) {
       const runner = new ScriptRunner(transformer, {
         data: rows,
-        params: parameters,
+        params: enrichedParameters,
       })
       rows = runner.execute()
     }
 
     // if the request fails we retry once, invalidating the cached value
-    if (
-      info &&
-      info.code >= 400 &&
-      this.cachedVariables.length > 0 &&
-      !this.hasRerun
-    ) {
-      this.hasRerun = true
-      // invalidate the cache value
+    if (info && info.code >= 400 && !this.hasRerun) {
+      if (
+        this.ctx.user?.provider &&
+        info.code === 401 &&
+        !this.hasRefreshedOAuth
+      ) {
+        await this.refreshOAuth2(this.ctx)
+        // Attempt to refresh the access token from the provider
+        this.hasRefreshedOAuth = true
+      } else {
+        this.hasRerun = true
+      }
+
       await threadUtils.invalidateDynamicVariables(this.cachedVariables)
       return this.execute()
     }
@@ -126,6 +168,38 @@ class QueryRunner {
     ).execute()
   }
 
+  async refreshOAuth2(ctx) {
+    const { oauth2, providerType, _id } = ctx.user
+    const { configId } = ctx.auth
+
+    if (!providerType || !oauth2?.refreshToken) {
+      throw new Error("No refresh token found for authenticated user")
+    }
+
+    const resp = await refreshOAuthToken(
+      oauth2.refreshToken,
+      providerType,
+      configId
+    )
+
+    // Refresh session flow. Should be in same location as refreshOAuthToken
+    // There are several other properties available in 'resp'
+    if (!resp.err) {
+      const globalUserId = getGlobalIDFromUserMetadataID(_id)
+      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.
+      let errorMessage = resp.err.data ? resp.err.data : resp.err.toString()
+      throw new Error(
+        "OAuth2 access token could not be refreshed: " + errorMessage
+      )
+    }
+
+    return resp
+  }
+
   async getDynamicVariable(variable) {
     let { parameters } = this
     const queryId = variable.queryId,

package/src/utilities/fileSystem/index.js

@@ -21,6 +21,7 @@ const env = require("../../environment")
 const {
   USER_METDATA_PREFIX,
   LINK_USER_METADATA_PREFIX,
+  TABLE_ROW_PREFIX,
 } = require("../../db/utils")
 const MemoryStream = require("memorystream")
 const { getAppId } = require("@budibase/backend-core/context")
@@ -109,6 +110,23 @@ exports.apiFileReturn = contents => {
   return fs.createReadStream(path)
 }
 
+exports.defineFilter = excludeRows => {
+  if (excludeRows) {
+    return doc =>
+      !(
+        doc._id.includes(USER_METDATA_PREFIX) ||
+        doc._id.includes(LINK_USER_METADATA_PREFIX) ||
+        doc._id.includes(TABLE_ROW_PREFIX)
+      )
+  } else if (!excludeRows) {
+    return doc =>
+      !(
+        doc._id.includes(USER_METDATA_PREFIX) ||
+        doc._id.includes(LINK_USER_METADATA_PREFIX)
+      )
+  }
+}
+
 /**
  * Local utility to back up the database state for an app, excluding global user
  * data or user relationships.
@@ -116,14 +134,10 @@ exports.apiFileReturn = contents => {
  * @param {object} config Config to send to export DB
  * @returns {*} either a string or a stream of the backup
  */
-const backupAppData = async (appId, config) => {
+const backupAppData = async (appId, config, includeRows) => {
   return await exports.exportDB(appId, {
     ...config,
-    filter: doc =>
-      !(
-        doc._id.includes(USER_METDATA_PREFIX) ||
-        doc._id.includes(LINK_USER_METADATA_PREFIX)
-      ),
+    filter: exports.defineFilter(includeRows),
   })
 }
 
@@ -142,8 +156,8 @@ exports.performBackup = async (appId, backupName) => {
  * @param {string} appId The ID of the app which is to be backed up.
  * @returns {*} a readable stream of the backup which is written in real time
  */
-exports.streamBackup = async appId => {
-  return await backupAppData(appId, { stream: true })
+exports.streamBackup = async (appId, includeRows) => {
+  return await backupAppData(appId, { stream: true }, includeRows)
 }
 
 /**

package/src/utilities/index.js

@@ -54,13 +54,8 @@ exports.objectStoreUrl = () => {
  * @return {string} The URL to be inserted into appPackage response or server rendered
  * app index file.
  */
-exports.clientLibraryPath = (appId, version, ctx) => {
+exports.clientLibraryPath = (appId, version) => {
   if (env.isProd()) {
-    // TODO: remove - for beta testing UI
-    if (ctx && ctx.cookies.get("beta:design_ui")) {
-      return "https://cdn.budi.live/beta:design_ui/budibase-client.js"
-    }
-
     let url = `${exports.objectStoreUrl()}/${sanitizeKey(
       appId
     )}/budibase-client.js`

package/src/utilities/workerRequests.js

@@ -137,3 +137,19 @@ exports.readGlobalUser = async ctx => {
   )
   return checkResponse(response, "get user", { ctx })
 }
+
+exports.createAdminUser = async (email, password, tenantId) => {
+  const response = await fetch(
+    checkSlashesInUrl(env.WORKER_URL + "/api/global/users/init"),
+    request(null, { method: "POST", body: { email, password, tenantId } })
+  )
+  return checkResponse(response, "create admin user")
+}
+
+exports.getChecklist = async () => {
+  const response = await fetch(
+    checkSlashesInUrl(env.WORKER_URL + "/api/global/configs/checklist"),
+    request(null, { method: "GET" })
+  )
+  return checkResponse(response, "get checklist")
+}