@budibase/server 1.0.219 → 1.0.220-alpha.0

package/dist/tests/utilities/TestConfiguration.js

@@ -26,6 +26,8 @@ const { generateDevInfoID, SEPARATOR } = require("@budibase/backend-core/db");
 const { encrypt } = require("@budibase/backend-core/encryption");
 const GLOBAL_USER_ID = "us_uuid1";
 const EMAIL = "babs@babs.com";
+const FIRSTNAME = "Barbara";
+const LASTNAME = "Barbington";
 const CSRF_TOKEN = "e3727778-7af0-4226-b5eb-f43cbe60a306";
 class TestConfiguration {
     constructor(openServer = true) {
@@ -51,6 +53,14 @@ class TestConfiguration {
     getProdAppId() {
         return this.prodAppId;
     }
+    getUserDetails() {
+        return {
+            globalId: GLOBAL_USER_ID,
+            email: EMAIL,
+            firstName: FIRSTNAME,
+            lastName: LASTNAME,
+        };
+    }
     doInContext(appId, task) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!appId) {
@@ -109,7 +119,7 @@ class TestConfiguration {
         });
     }
     // USER / AUTH
-    globalUser({ id = GLOBAL_USER_ID, builder = true, admin = false, email = EMAIL, roles, } = {}) {
+    globalUser({ id = GLOBAL_USER_ID, firstName = FIRSTNAME, lastName = LASTNAME, builder = true, admin = false, email = EMAIL, roles, } = {}) {
         return __awaiter(this, void 0, void 0, function* () {
             return doWithGlobalDB(TENANT_ID, (db) => __awaiter(this, void 0, void 0, function* () {
                 let existing;
@@ -119,7 +129,8 @@ class TestConfiguration {
                 catch (err) {
                     existing = { email };
                 }
-                const user = Object.assign(Object.assign({ _id: id }, existing), { roles: roles || {}, tenantId: TENANT_ID });
+                const user = Object.assign(Object.assign({ _id: id }, existing), { roles: roles || {}, tenantId: TENANT_ID, firstName,
+                    lastName });
                 yield createASession(id, {
                     sessionId: "sessionid",
                     tenantId: TENANT_ID,
@@ -142,11 +153,13 @@ class TestConfiguration {
             }));
         });
     }
-    createUser(id = null, email = EMAIL, builder = true, admin = false, roles = {}) {
+    createUser(id = null, firstName = FIRSTNAME, lastName = LASTNAME, email = EMAIL, builder = true, admin = false, roles = {}) {
         return __awaiter(this, void 0, void 0, function* () {
             const globalId = !id ? `us_${Math.random()}` : `us_${id}`;
             const resp = yield this.globalUser({
                 id: globalId,
+                firstName,
+                lastName,
                 email,
                 builder,
                 admin,
@@ -466,15 +479,15 @@ class TestConfiguration {
         });
     }
     // QUERY
-    previewQuery(request, config, datasource, fields) {
+    previewQuery(request, config, datasource, fields, params, verb) {
         return __awaiter(this, void 0, void 0, function* () {
             return request
                 .post(`/api/queries/preview`)
                 .send({
                 datasourceId: datasource._id,
-                parameters: {},
+                parameters: params || {},
                 fields,
-                queryVerb: "read",
+                queryVerb: verb || "read",
                 name: datasource.name,
             })
                 .set(config.defaultHeaders())

package/dist/threads/automation.js

@@ -19,10 +19,11 @@ const { doInTenant } = require("@budibase/backend-core/tenancy");
 const { definitions: triggerDefs } = require("../automations/triggerInfo");
 const { doInAppContext, getAppDB } = require("@budibase/backend-core/context");
 const { AutomationErrors, LoopStepTypes } = require("../constants");
+const { storeLog } = require("../automations/logging");
 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: false, status: "STOPPED" };
+const STOPPED_STATUS = { success: true, status: "STOPPED" };
 const { cloneDeep } = require("lodash/fp");
 const env = require("../environment");
 function typecastForLooping(loopStep, input) {
@@ -195,7 +196,7 @@ class Orchestrator {
                                 }
                             }
                         }
-                        if (index === parseInt(env.AUTOMATION_MAX_ITERATIONS) ||
+                        if (index === env.AUTOMATION_MAX_ITERATION ||
                             index === parseInt(loopStep.inputs.iterations)) {
                             this.updateContextAndOutput(loopStepNumber, step, tempOutput, {
                                 status: AutomationErrors.MAX_ITERATIONS,
@@ -248,7 +249,7 @@ class Orchestrator {
                         this._context.steps[stepCount] = outputs;
                         // if filter causes us to stop execution don't break the loop, set a var
                         // so that we can finish iterating through the steps and record that it stopped
-                        if (step.stepId === FILTER_STEP_ID && !outputs.success) {
+                        if (step.stepId === FILTER_STEP_ID && !outputs.result) {
                             stopped = true;
                             this.updateExecutionOutput(step.id, step.stepId, step.inputs, Object.assign(Object.assign({}, outputs), STOPPED_STATUS));
                             continue;
@@ -289,6 +290,8 @@ class Orchestrator {
                     loopSteps = null;
                 }
             }
+            // store the logs for the automation run
+            yield storeLog(this._automation, this.executionOutput);
             return this.executionOutput;
         });
     }

package/dist/threads/index.js

@@ -22,6 +22,15 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -92,7 +101,7 @@ class Thread {
             });
         });
     }
-    static shutdown() {
+    static stopThreads() {
         return new Promise(resolve => {
             if (Thread.workerRefs.length === 0) {
                 resolve();
@@ -110,6 +119,11 @@ class Thread {
             Thread.workerRefs = [];
         });
     }
+    static shutdown() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield Thread.stopThreads();
+        });
+    }
 }
 exports.Thread = Thread;
 Thread.workerRefs = [];

package/dist/threads/query.js

@@ -14,6 +14,10 @@ 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, interpolateSQL, } = require("../integrations/queries/sql");
 class QueryRunner {
@@ -27,29 +31,49 @@ 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;
     }
     execute() {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             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 = yield 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 = Object.assign(Object.assign({}, 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
             if (this.pagination) {
@@ -67,17 +91,22 @@ 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 (((_a = this.ctx.user) === null || _a === void 0 ? void 0 : _a.provider) &&
+                    info.code === 401 &&
+                    !this.hasRefreshedOAuth) {
+                    yield this.refreshOAuth2(this.ctx);
+                    // Attempt to refresh the access token from the provider
+                    this.hasRefreshedOAuth = true;
+                }
+                else {
+                    this.hasRerun = true;
+                }
                 yield threadUtils.invalidateDynamicVariables(this.cachedVariables);
                 return this.execute();
             }
@@ -115,6 +144,30 @@ class QueryRunner {
             }, { noRecursiveQuery: true }).execute();
         });
     }
+    refreshOAuth2(ctx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { oauth2, providerType, _id } = ctx.user;
+            const { configId } = ctx.auth;
+            if (!providerType || !(oauth2 === null || oauth2 === void 0 ? void 0 : oauth2.refreshToken)) {
+                throw new Error("No refresh token found for authenticated user");
+            }
+            const resp = yield 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);
+                yield updateUserOAuth(globalUserId, resp);
+                this.ctx.user = yield 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;
+        });
+    }
     getDynamicVariable(variable) {
         return __awaiter(this, void 0, void 0, function* () {
             let { parameters } = this;