@budibase/server 2.2.26 → 2.2.27-alpha.1

package/dist/sdk/app/datasources/datasources.js

@@ -0,0 +1,147 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeConfigs = exports.removeSecretSingle = exports.removeSecrets = exports.getWithEnvVars = exports.get = exports.enrich = void 0;
+const backend_core_1 = require("@budibase/backend-core");
+const string_templates_1 = require("@budibase/string-templates");
+const types_1 = require("@budibase/types");
+const fp_1 = require("lodash/fp");
+const utils_1 = require("../../utils");
+const integrations_1 = require("../../../integrations");
+const ENV_VAR_PREFIX = "env.";
+function enrichDatasourceWithValues(datasource) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const cloned = (0, fp_1.cloneDeep)(datasource);
+        const env = yield (0, utils_1.getEnvironmentVariables)();
+        const processed = (0, string_templates_1.processObjectSync)(cloned, { env }, { onlyFound: true });
+        return {
+            datasource: processed,
+            envVars: env,
+        };
+    });
+}
+function enrich(datasource) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { datasource: response } = yield enrichDatasourceWithValues(datasource);
+        return response;
+    });
+}
+exports.enrich = enrich;
+function get(datasourceId, opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const appDb = backend_core_1.context.getAppDB();
+        const datasource = yield appDb.get(datasourceId);
+        if (opts === null || opts === void 0 ? void 0 : opts.enriched) {
+            return (yield enrichDatasourceWithValues(datasource)).datasource;
+        }
+        else {
+            return datasource;
+        }
+    });
+}
+exports.get = get;
+function getWithEnvVars(datasourceId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const appDb = backend_core_1.context.getAppDB();
+        const datasource = yield appDb.get(datasourceId);
+        return enrichDatasourceWithValues(datasource);
+    });
+}
+exports.getWithEnvVars = getWithEnvVars;
+function hasAuthConfigs(datasource) {
+    var _a;
+    return datasource.source === types_1.SourceName.REST && ((_a = datasource.config) === null || _a === void 0 ? void 0 : _a.authConfigs);
+}
+function useEnvVars(str) {
+    if (typeof str !== "string") {
+        return false;
+    }
+    const blocks = (0, string_templates_1.findHBSBlocks)(str);
+    return blocks.find(block => block.includes(ENV_VAR_PREFIX)) != null;
+}
+function removeSecrets(datasources) {
+    var _a, _b;
+    return __awaiter(this, void 0, void 0, function* () {
+        const definitions = yield (0, integrations_1.getDefinitions)();
+        for (let datasource of datasources) {
+            const schema = definitions[datasource.source];
+            if (datasource.config) {
+                // strip secrets from response, so they don't show in the network request
+                if (datasource.config.auth) {
+                    delete datasource.config.auth;
+                }
+                // specific to REST datasources, contains passwords
+                if (hasAuthConfigs(datasource)) {
+                    const configs = datasource.config.authConfigs;
+                    for (let config of configs) {
+                        if (config.type !== types_1.RestAuthType.BASIC) {
+                            continue;
+                        }
+                        const basic = config.config;
+                        if (!useEnvVars(basic.password)) {
+                            basic.password = types_1.PASSWORD_REPLACEMENT;
+                        }
+                    }
+                }
+                // remove general passwords
+                for (let key of Object.keys(datasource.config)) {
+                    if (((_b = (_a = schema.datasource) === null || _a === void 0 ? void 0 : _a[key]) === null || _b === void 0 ? void 0 : _b.type) === types_1.DatasourceFieldType.PASSWORD &&
+                        !useEnvVars(datasource.config[key])) {
+                        datasource.config[key] = types_1.PASSWORD_REPLACEMENT;
+                    }
+                }
+            }
+        }
+        return datasources;
+    });
+}
+exports.removeSecrets = removeSecrets;
+function removeSecretSingle(datasource) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return (yield removeSecrets([datasource]))[0];
+    });
+}
+exports.removeSecretSingle = removeSecretSingle;
+function mergeConfigs(update, old) {
+    var _a, _b, _c, _d;
+    if (!update.config) {
+        return update;
+    }
+    // specific to REST datasources, fix the auth configs again if required
+    if (hasAuthConfigs(update)) {
+        const configs = update.config.authConfigs;
+        const oldConfigs = (_a = old.config) === null || _a === void 0 ? void 0 : _a.authConfigs;
+        for (let config of configs) {
+            if (config.type !== types_1.RestAuthType.BASIC) {
+                continue;
+            }
+            const basic = config.config;
+            const oldBasic = (_b = oldConfigs.find(old => old.name === config.name)) === null || _b === void 0 ? void 0 : _b.config;
+            if (basic.password === types_1.PASSWORD_REPLACEMENT) {
+                basic.password = oldBasic.password;
+            }
+        }
+    }
+    // update back to actual passwords for everything else
+    for (let [key, value] of Object.entries(update.config)) {
+        if (value !== types_1.PASSWORD_REPLACEMENT) {
+            continue;
+        }
+        if ((_c = old.config) === null || _c === void 0 ? void 0 : _c[key]) {
+            update.config[key] = (_d = old.config) === null || _d === void 0 ? void 0 : _d[key];
+        }
+        else {
+            delete update.config[key];
+        }
+    }
+    return update;
+}
+exports.mergeConfigs = mergeConfigs;

package/dist/sdk/app/datasources/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const datasources = __importStar(require("./datasources"));
+exports.default = Object.assign({}, datasources);

package/dist/sdk/app/queries/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const queries = __importStar(require("./queries"));
+exports.default = Object.assign({}, queries);

package/dist/sdk/app/queries/queries.js

@@ -0,0 +1,60 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enrichContext = void 0;
+const utils_1 = require("../../utils");
+const string_templates_1 = require("@budibase/string-templates");
+function enrichContext(fields, inputs = {}) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const enrichedQuery = Array.isArray(fields) ? [] : {};
+        if (!fields || !inputs) {
+            return enrichedQuery;
+        }
+        const env = yield (0, utils_1.getEnvironmentVariables)();
+        const parameters = Object.assign(Object.assign({}, inputs), { env });
+        // enrich the fields with dynamic parameters
+        for (let key of Object.keys(fields)) {
+            if (fields[key] == null) {
+                continue;
+            }
+            if (typeof fields[key] === "object") {
+                // enrich nested fields object
+                enrichedQuery[key] = yield enrichContext(fields[key], parameters);
+            }
+            else if (typeof fields[key] === "string") {
+                // enrich string value as normal
+                enrichedQuery[key] = (0, string_templates_1.processStringSync)(fields[key], parameters, {
+                    noEscaping: true,
+                    noHelpers: true,
+                    escapeNewlines: true,
+                });
+            }
+            else {
+                enrichedQuery[key] = fields[key];
+            }
+        }
+        if (enrichedQuery.json ||
+            enrichedQuery.customData ||
+            enrichedQuery.requestBody) {
+            try {
+                enrichedQuery.json = JSON.parse(enrichedQuery.json ||
+                    enrichedQuery.customData ||
+                    enrichedQuery.requestBody);
+            }
+            catch (err) {
+                // no json found, ignore
+            }
+            delete enrichedQuery.customData;
+        }
+        return enrichedQuery;
+    });
+}
+exports.enrichContext = enrichContext;

package/dist/sdk/app/tables/index.js

@@ -8,10 +8,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const backend_core_1 = require("@budibase/backend-core");
 const utils_1 = require("../../../db/utils");
 const utils_2 = require("../../../integrations/utils");
+const datasources_1 = __importDefault(require("../datasources"));
 function getAllInternalTables(db) {
     return __awaiter(this, void 0, void 0, function* () {
         if (!db) {
@@ -26,7 +30,7 @@ function getAllInternalTables(db) {
 function getAllExternalTables(datasourceId) {
     return __awaiter(this, void 0, void 0, function* () {
         const db = backend_core_1.context.getAppDB();
-        const datasource = yield db.get(datasourceId);
+        const datasource = yield datasources_1.default.get(datasourceId, { enriched: true });
         if (!datasource || !datasource.entities) {
             throw "Datasource is not configured fully.";
         }
@@ -44,7 +48,7 @@ function getTable(tableId) {
         const db = backend_core_1.context.getAppDB();
         if ((0, utils_2.isExternalTable)(tableId)) {
             let { datasourceId, tableName } = (0, utils_2.breakExternalTableId)(tableId);
-            const datasource = yield db.get(datasourceId);
+            const datasource = yield datasources_1.default.get(datasourceId);
             const table = yield getExternalTable(datasourceId, tableName);
             return Object.assign(Object.assign({}, table), { sql: (0, utils_2.isSQL)(datasource) });
         }

package/dist/sdk/index.js

@@ -7,6 +7,8 @@ const backups_1 = __importDefault(require("./app/backups"));
 const tables_1 = __importDefault(require("./app/tables"));
 const automations_1 = __importDefault(require("./app/automations"));
 const applications_1 = __importDefault(require("./app/applications"));
+const datasources_1 = __importDefault(require("./app/datasources"));
+const queries_1 = __importDefault(require("./app/queries"));
 const rows_1 = __importDefault(require("./app/rows"));
 const users_1 = __importDefault(require("./users"));
 const sdk = {
@@ -16,6 +18,8 @@ const sdk = {
     applications: applications_1.default,
     rows: rows_1.default,
     users: users_1.default,
+    datasources: datasources_1.default,
+    queries: queries_1.default,
 };
 // default export for TS
 exports.default = sdk;

package/dist/sdk/utils/index.js

@@ -0,0 +1,29 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEnvironmentVariables = void 0;
+const pro_1 = require("@budibase/pro");
+const backend_core_1 = require("@budibase/backend-core");
+const types_1 = require("@budibase/types");
+function getEnvironmentVariables() {
+    return __awaiter(this, void 0, void 0, function* () {
+        let envVars = backend_core_1.context.getEnvironmentVariables();
+        if (!envVars) {
+            const appId = backend_core_1.context.getAppId();
+            const appEnv = backend_core_1.db.isDevAppID(appId)
+                ? types_1.AppEnvironment.DEVELOPMENT
+                : types_1.AppEnvironment.PRODUCTION;
+            envVars = yield pro_1.environmentVariables.fetchValues(appEnv);
+        }
+        return envVars;
+    });
+}
+exports.getEnvironmentVariables = getEnvironmentVariables;

package/dist/startup.js

@@ -36,7 +36,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.startup = void 0;
-const env = __importStar(require("./environment"));
+const environment_1 = __importDefault(require("./environment"));
 const redis = __importStar(require("./utilities/redis"));
 const workerRequests_1 = require("./utilities/workerRequests");
 const backend_core_1 = require("@budibase/backend-core");
@@ -54,8 +54,8 @@ const pino = require("koa-pino-logger");
 let STARTUP_RAN = false;
 function initRoutes(app) {
     return __awaiter(this, void 0, void 0, function* () {
-        app.use(pino((0, backend_core_1.pinoSettings)()));
-        if (!env.isTest()) {
+        app.use(pino(backend_core_1.logging.pinoSettings()));
+        if (!environment_1.default.isTest()) {
             const plugin = yield bullboard.init();
             app.use(plugin);
         }
@@ -91,14 +91,14 @@ function startup(app, server) {
         STARTUP_RAN = true;
         if (server) {
             console.log(`Budibase running on ${JSON.stringify(server.address())}`);
-            env._set("PORT", server.address().port);
+            environment_1.default._set("PORT", server.address().port);
         }
-        events_1.default.emitPort(env.PORT);
+        events_1.default.emitPort(environment_1.default.PORT);
         fileSystem.init();
         yield redis.init();
         // run migrations on startup if not done via http
         // not recommended in a clustered environment
-        if (!env.HTTP_MIGRATIONS && !env.isTest()) {
+        if (!environment_1.default.HTTP_MIGRATIONS && !environment_1.default.isTest()) {
             try {
                 yield migrations.migrate();
             }
@@ -108,20 +108,20 @@ function startup(app, server) {
             }
         }
         // check and create admin user if required
-        if (env.SELF_HOSTED &&
-            !env.MULTI_TENANCY &&
-            env.BB_ADMIN_USER_EMAIL &&
-            env.BB_ADMIN_USER_PASSWORD) {
+        if (environment_1.default.SELF_HOSTED &&
+            !environment_1.default.MULTI_TENANCY &&
+            environment_1.default.BB_ADMIN_USER_EMAIL &&
+            environment_1.default.BB_ADMIN_USER_PASSWORD) {
             const checklist = yield (0, workerRequests_1.getChecklist)();
             if (!((_a = checklist === null || checklist === void 0 ? void 0 : checklist.adminUser) === null || _a === void 0 ? void 0 : _a.checked)) {
                 try {
                     const tenantId = backend_core_1.tenancy.getTenantId();
-                    const user = yield (0, workerRequests_1.createAdminUser)(env.BB_ADMIN_USER_EMAIL, env.BB_ADMIN_USER_PASSWORD, tenantId);
+                    const user = yield (0, workerRequests_1.createAdminUser)(environment_1.default.BB_ADMIN_USER_EMAIL, environment_1.default.BB_ADMIN_USER_PASSWORD, tenantId);
                     // Need to set up an API key for automated integration tests
-                    if (env.isTest()) {
+                    if (environment_1.default.isTest()) {
                         yield (0, workerRequests_1.generateApiKey)(user._id);
                     }
-                    console.log("Admin account automatically created for", env.BB_ADMIN_USER_EMAIL);
+                    console.log("Admin account automatically created for", environment_1.default.BB_ADMIN_USER_EMAIL);
                 }
                 catch (e) {
                     backend_core_1.logging.logAlert("Error creating initial admin user. Exiting.", e);
@@ -130,10 +130,10 @@ function startup(app, server) {
             }
         }
         // monitor plugin directory if required
-        if (env.SELF_HOSTED &&
-            !env.MULTI_TENANCY &&
-            env.PLUGINS_DIR &&
-            fs_1.default.existsSync(env.PLUGINS_DIR)) {
+        if (environment_1.default.SELF_HOSTED &&
+            !environment_1.default.MULTI_TENANCY &&
+            environment_1.default.PLUGINS_DIR &&
+            fs_1.default.existsSync(environment_1.default.PLUGINS_DIR)) {
             (0, watch_1.watch)();
         }
         // check for version updates

package/dist/threads/automation.js

@@ -47,46 +47,27 @@ const triggerInfo_1 = require("../automations/triggerInfo");
 const constants_1 = require("../constants");
 const logging_1 = require("../automations/logging");
 const types_1 = require("@budibase/types");
-const automations_1 = require("../definitions/automations");
 const backend_core_1 = require("@budibase/backend-core");
 const string_templates_1 = require("@budibase/string-templates");
 const fp_1 = require("lodash/fp");
+const sdkUtils = __importStar(require("../sdk/utils"));
 const environment_1 = __importDefault(require("../environment"));
 const FILTER_STEP_ID = actions.ACTION_DEFINITIONS.FILTER.stepId;
 const LOOP_STEP_ID = actions.ACTION_DEFINITIONS.LOOP.stepId;
 const CRON_STEP_ID = triggerInfo_1.definitions.CRON.stepId;
 const STOPPED_STATUS = { success: true, status: types_1.AutomationStatus.STOPPED };
-function typecastForLooping(loopStep, input) {
-    if (!input || !input.binding) {
-        return null;
-    }
-    try {
-        switch (loopStep.inputs.option) {
-            case automations_1.LoopStepType.ARRAY:
-                if (typeof input.binding === "string") {
-                    return JSON.parse(input.binding);
-                }
-                break;
-            case automations_1.LoopStepType.STRING:
-                if (Array.isArray(input.binding)) {
-                    return input.binding.join(",");
-                }
-                break;
-        }
-    }
-    catch (err) {
-        throw new Error("Unable to cast to correct type");
-    }
-    return input.binding;
-}
 function getLoopIterations(loopStep, input) {
-    const binding = typecastForLooping(loopStep, input);
+    const binding = automationUtils.typecastForLooping(loopStep, input);
     if (!loopStep || !binding) {
         return 1;
     }
-    return Array.isArray(binding)
-        ? binding.length
-        : automationUtils.stringSplit(binding).length;
+    if (Array.isArray(binding)) {
+        return binding.length;
+    }
+    if (typeof binding === "string") {
+        return automationUtils.stringSplit(binding).length;
+    }
+    return 1;
 }
 /**
  * The automation orchestrator is a class responsible for executing automations.
@@ -234,6 +215,8 @@ class Orchestrator {
     execute() {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            // this will retrieve from context created at start of thread
+            this._context.env = yield sdkUtils.getEnvironmentVariables();
             let automation = this._automation;
             let stopped = false;
             let loopStep = undefined;
@@ -269,7 +252,7 @@ class Orchestrator {
                         let newInput = yield (0, string_templates_1.processObject)(loopStep.inputs, (0, fp_1.cloneDeep)(this._context));
                         let tempOutput = { items: loopSteps, iterations: iterationCount };
                         try {
-                            newInput.binding = typecastForLooping(loopStep, newInput);
+                            newInput.binding = automationUtils.typecastForLooping(loopStep, newInput);
                         }
                         catch (err) {
                             this.updateContextAndOutput(loopStepNumber, step, tempOutput, {
@@ -280,12 +263,12 @@ class Orchestrator {
                             loopStep = undefined;
                             break;
                         }
-                        let item;
+                        let item = [];
                         if (typeof loopStep.inputs.binding === "string" &&
                             loopStep.inputs.option === "String") {
                             item = automationUtils.stringSplit(newInput.binding);
                         }
-                        else {
+                        else if (Array.isArray(loopStep.inputs.binding)) {
                             item = loopStep.inputs.binding;
                         }
                         this._context.steps[loopStepNumber] = {
@@ -391,7 +374,7 @@ class Orchestrator {
                 }
                 // Delete the step after the loop step as it's irrelevant, since information is included
                 // in the loop step
-                if (wasLoopStep) {
+                if (wasLoopStep && !loopStep) {
                     this._context.steps.splice(loopStepNumber + 1, 1);
                     wasLoopStep = false;
                 }
@@ -408,8 +391,8 @@ class Orchestrator {
                         inputs: step.inputs,
                     });
                     this._context.steps[loopStepNumber] = tempOutput;
-                    loopSteps = undefined;
                     wasLoopStep = true;
+                    loopSteps = [];
                 }
             }
             // store the logs for the automation run
@@ -444,8 +427,12 @@ const removeStalled = (job) => __awaiter(void 0, void 0, void 0, function* () {
         throw new Error("Unable to execute, event doesn't contain app ID.");
     }
     yield backend_core_1.context.doInAppContext(appId, () => __awaiter(void 0, void 0, void 0, function* () {
-        const automationOrchestrator = new Orchestrator(job);
-        yield automationOrchestrator.stopCron("stalled");
+        const envVars = yield sdkUtils.getEnvironmentVariables();
+        // put into automation thread for whole context
+        yield backend_core_1.context.doInEnvironmentContext(envVars, () => __awaiter(void 0, void 0, void 0, function* () {
+            const automationOrchestrator = new Orchestrator(job);
+            yield automationOrchestrator.stopCron("stalled");
+        }));
     }));
 });
 exports.removeStalled = removeStalled;

package/dist/threads/index.js

@@ -37,7 +37,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Thread = exports.ThreadType = void 0;
 const worker_farm_1 = __importDefault(require("worker-farm"));
-const env = __importStar(require("../environment"));
+const environment_1 = __importDefault(require("../environment"));
 exports.ThreadType = {
     QUERY: "query",
     AUTOMATION: "automation",
@@ -76,10 +76,10 @@ class Thread {
         }
     }
     shouldDisableThreading() {
-        return !!(env.isTest() ||
-            env.DISABLE_THREADING ||
+        return !!(environment_1.default.isTest() ||
+            environment_1.default.DISABLE_THREADING ||
             this.count === 0 ||
-            env.isInThread());
+            environment_1.default.isInThread());
     }
     run(data) {
         const timeout = this.timeoutMs;

package/dist/threads/query.js

@@ -20,9 +20,10 @@ const integrations_1 = require("../integrations");
 const string_templates_1 = require("@budibase/string-templates");
 const backend_core_1 = require("@budibase/backend-core");
 const utils_2 = require("../db/utils");
+const sdk_1 = __importDefault(require("../sdk"));
 const fp_1 = require("lodash/fp");
-const { isSQL } = require("../integrations/utils");
-const { enrichQueryFields, interpolateSQL, } = require("../integrations/queries/sql");
+const utils_3 = require("../integrations/utils");
+const sql_1 = require("../integrations/queries/sql");
 class QueryRunner {
     constructor(input, flags = { noRecursiveQuery: false }) {
         this.datasource = input.datasource;
@@ -55,29 +56,30 @@ class QueryRunner {
                 throw "Integration type does not exist.";
             }
             if (datasourceClone.config.authConfigs) {
-                datasourceClone.config.authConfigs =
-                    datasourceClone.config.authConfigs.map((config) => {
-                        return enrichQueryFields(config, this.ctx);
-                    });
+                const updatedConfigs = [];
+                for (let config of datasourceClone.config.authConfigs) {
+                    updatedConfigs.push(yield sdk_1.default.queries.enrichContext(config, this.ctx));
+                }
+                datasourceClone.config.authConfigs = updatedConfigs;
             }
             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 enrichedParameters = yield sdk_1.default.queries.enrichContext(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);
+                datasourceClone.config.defaultHeaders = yield sdk_1.default.queries.enrichContext(datasourceClone.config.defaultHeaders, enrichedContext);
             }
             let query;
             // handle SQL injections by interpolating the variables
-            if (isSQL(datasourceClone)) {
-                query = interpolateSQL(fieldsClone, enrichedContext, integration);
+            if ((0, utils_3.isSQL)(datasourceClone)) {
+                query = yield (0, sql_1.interpolateSQL)(fieldsClone, enrichedContext, integration);
             }
             else {
-                query = enrichQueryFields(fieldsClone, enrichedContext);
+                query = yield sdk_1.default.queries.enrichContext(fieldsClone, enrichedContext);
             }
             // Add pagination values for REST queries
             if (this.pagination) {
@@ -138,7 +140,9 @@ class QueryRunner {
         return __awaiter(this, void 0, void 0, function* () {
             const db = backend_core_1.context.getAppDB();
             const query = yield db.get(queryId);
-            const datasource = yield db.get(query.datasourceId);
+            const datasource = yield sdk_1.default.datasources.get(query.datasourceId, {
+                enriched: true,
+            });
             return new QueryRunner({
                 datasource,
                 queryVerb: query.queryVerb,
@@ -237,7 +241,7 @@ class QueryRunner {
     }
 }
 function execute(input, callback) {
-    backend_core_1.context.doInAppContext(input.appId, () => __awaiter(this, void 0, void 0, function* () {
+    const run = () => __awaiter(this, void 0, void 0, function* () {
         const Runner = new QueryRunner(input);
         try {
             const response = yield Runner.execute();
@@ -246,6 +250,16 @@ function execute(input, callback) {
         catch (err) {
             callback(err);
         }
+    });
+    backend_core_1.context.doInAppContext(input.appId, () => __awaiter(this, void 0, void 0, function* () {
+        if (input.environmentVariables) {
+            return backend_core_1.context.doInEnvironmentContext(input.environmentVariables, () => {
+                return run();
+            });
+        }
+        else {
+            return run();
+        }
     }));
 }
 exports.execute = execute;