@budibase/server 1.1.32 → 1.1.33-alpha.2

package/dist/threads/automation.js

@@ -8,36 +8,45 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-require("./utils").threadSetup();
-const actions = require("../automations/actions");
-const automationUtils = require("../automations/automationUtils");
-const AutomationEmitter = require("../events/AutomationEmitter");
-const { processObject } = require("@budibase/string-templates");
-const { DocumentTypes } = require("../db/utils");
-const { definitions: triggerDefs } = require("../automations/triggerInfo");
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execute = void 0;
+const utils_1 = __importDefault(require("./utils"));
+utils_1.default.threadSetup();
+const utils_2 = require("../automations/utils");
+const actions_1 = __importDefault(require("../automations/actions"));
+const automationUtils_1 = __importDefault(require("../automations/automationUtils"));
+const AutomationEmitter_1 = __importDefault(require("../events/AutomationEmitter"));
+const utils_3 = require("../db/utils");
+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 { 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: true, status: "STOPPED" };
+const { logAlertWithInfo, logWarn } = require("@budibase/backend-core/logging");
+const { processObject } = require("@budibase/string-templates");
+const FILTER_STEP_ID = actions_1.default.ACTION_DEFINITIONS.FILTER.stepId;
+const LOOP_STEP_ID = actions_1.default.ACTION_DEFINITIONS.LOOP.stepId;
+const CRON_STEP_ID = triggerInfo_1.definitions.CRON.stepId;
+const STOPPED_STATUS = { success: true, status: types_1.AutomationStatus.STOPPED };
 const { cloneDeep } = require("lodash/fp");
 const env = require("../environment");
 function typecastForLooping(loopStep, input) {
     if (!input || !input.binding) {
         return null;
     }
-    const isArray = Array.isArray(input.binding), isString = typeof input.binding === "string";
     try {
         switch (loopStep.inputs.option) {
-            case LoopStepTypes.ARRAY:
-                if (isString) {
+            case automations_1.LoopStepTypes.ARRAY:
+                if (typeof input.binding === "string") {
                     return JSON.parse(input.binding);
                 }
                 break;
-            case LoopStepTypes.STRING:
-                if (isArray) {
+            case automations_1.LoopStepTypes.STRING:
+                if (Array.isArray(input.binding)) {
                     return input.binding.join(",");
                 }
                 break;
@@ -55,7 +64,7 @@ function getLoopIterations(loopStep, input) {
     }
     return Array.isArray(binding)
         ? binding.length
-        : automationUtils.stringSplit(binding).length;
+        : automationUtils_1.default.stringSplit(binding).length;
 }
 /**
  * The automation orchestrator is a class responsible for executing automations.
@@ -63,11 +72,16 @@ function getLoopIterations(loopStep, input) {
  * inputs and handles any outputs.
  */
 class Orchestrator {
-    constructor(automation, triggerOutput = {}) {
-        this._metadata = triggerOutput.metadata;
-        this._chainCount = this._metadata ? this._metadata.automationChainCount : 0;
+    constructor(automation, triggerOutput, opts) {
+        const metadata = triggerOutput.metadata;
+        this._chainCount = metadata ? metadata.automationChainCount : 0;
         this._appId = triggerOutput.appId;
-        this._app = null;
+        if (opts === null || opts === void 0 ? void 0 : opts.repeat) {
+            this._repeat = {
+                jobId: opts.repeat.jobId,
+                jobKey: opts.repeat.key,
+            };
+        }
         const triggerStepId = automation.definition.trigger.stepId;
         triggerOutput = this.cleanupTriggerOutputs(triggerStepId, triggerOutput);
         // remove from context
@@ -78,7 +92,7 @@ class Orchestrator {
         this._automation = automation;
         // create an emitter which has the chain count for this automation run in it, so it can block
         // excessive chaining if required
-        this._emitter = new AutomationEmitter(this._chainCount + 1);
+        this._emitter = new AutomationEmitter_1.default(this._chainCount + 1);
         this.executionOutput = { trigger: {}, steps: [] };
         // setup the execution output
         const triggerId = automation.definition.trigger.id;
@@ -92,32 +106,98 @@ class Orchestrator {
     }
     getStepFunctionality(stepId) {
         return __awaiter(this, void 0, void 0, function* () {
-            let step = yield actions.getAction(stepId);
+            let step = yield actions_1.default.getAction(stepId);
             if (step == null) {
                 throw `Cannot find automation step by name ${stepId}`;
             }
             return step;
         });
     }
-    getApp() {
+    getMetadata() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const metadataId = (0, utils_3.generateAutomationMetadataID)(this._automation._id);
+            const db = getAppDB();
+            let metadata;
+            try {
+                metadata = yield db.get(metadataId);
+            }
+            catch (err) {
+                metadata = {
+                    _id: metadataId,
+                    errorCount: 0,
+                };
+            }
+            return metadata;
+        });
+    }
+    checkIfShouldStop(metadata) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!metadata.errorCount || !this._repeat) {
+                return false;
+            }
+            const automation = this._automation;
+            const trigger = automation.definition.trigger;
+            if (metadata.errorCount >= constants_1.MAX_AUTOMATION_RECURRING_ERRORS) {
+                logWarn(`CRON disabled due to errors - ${this._appId}/${this._automation._id}`);
+                yield (0, utils_2.disableCron)((_a = this._repeat) === null || _a === void 0 ? void 0 : _a.jobId, (_b = this._repeat) === null || _b === void 0 ? void 0 : _b.jobKey);
+                this.updateExecutionOutput(trigger.id, trigger.stepId, {}, {
+                    status: types_1.AutomationStatus.STOPPED_ERROR,
+                    success: false,
+                });
+                yield (0, logging_1.storeLog)(automation, this.executionOutput);
+                return true;
+            }
+            return false;
+        });
+    }
+    updateMetadata(metadata) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this._app) {
-                return this._app;
+            const output = this.executionOutput, automation = this._automation;
+            if (!output || !(0, utils_2.isRecurring)(automation)) {
+                return;
+            }
+            const count = metadata.errorCount;
+            const isError = (0, utils_2.isErrorInOutput)(output);
+            // nothing to do in this scenario, escape
+            if (!count && !isError) {
+                return;
+            }
+            if (isError) {
+                metadata.errorCount = count ? count + 1 : 1;
+            }
+            else {
+                metadata.errorCount = 0;
             }
             const db = getAppDB();
-            this._app = yield db.get(DocumentTypes.APP_METADATA);
-            return this._app;
+            try {
+                yield db.put(metadata);
+            }
+            catch (err) {
+                logAlertWithInfo("Failed to write automation metadata", db.name, automation._id, err);
+            }
         });
     }
     updateExecutionOutput(id, stepId, inputs, outputs) {
         const stepObj = { id, stepId, inputs, outputs };
+        // replacing trigger when disabling CRON
+        if (stepId === CRON_STEP_ID &&
+            outputs.status === types_1.AutomationStatus.STOPPED_ERROR) {
+            this.executionOutput.trigger = stepObj;
+            this.executionOutput.steps = [stepObj];
+            return;
+        }
         // first entry is always the trigger (constructor)
-        if (this.executionOutput.steps.length === 0) {
+        if (this.executionOutput.steps.length === 0 ||
+            this.executionOutput.trigger.id === id) {
             this.executionOutput.trigger = stepObj;
         }
         this.executionOutput.steps.push(stepObj);
     }
     updateContextAndOutput(loopStepNumber, step, output, result) {
+        if (!loopStepNumber) {
+            throw new Error("No loop step number provided.");
+        }
         this.executionOutput.steps.splice(loopStepNumber, 0, {
             id: step.id,
             stepId: step.stepId,
@@ -131,10 +211,19 @@ class Orchestrator {
         return __awaiter(this, void 0, void 0, function* () {
             let automation = this._automation;
             let stopped = false;
-            let loopStep = null;
+            let loopStep = undefined;
             let stepCount = 0;
-            let loopStepNumber = null;
+            let loopStepNumber = undefined;
             let loopSteps = [];
+            let metadata;
+            // check if this is a recurring automation,
+            if ((0, utils_3.isProdAppID)(this._appId) && (0, utils_2.isRecurring)(automation)) {
+                metadata = yield this.getMetadata();
+                const shouldStop = yield this.checkIfShouldStop(metadata);
+                if (shouldStop) {
+                    return;
+                }
+            }
             for (let step of automation.definition.steps) {
                 stepCount++;
                 let input, iterations = 1, iterationCount = 0;
@@ -158,17 +247,17 @@ class Orchestrator {
                         }
                         catch (err) {
                             this.updateContextAndOutput(loopStepNumber, step, tempOutput, {
-                                status: AutomationErrors.INCORRECT_TYPE,
+                                status: constants_1.AutomationErrors.INCORRECT_TYPE,
                                 success: false,
                             });
-                            loopSteps = null;
-                            loopStep = null;
+                            loopSteps = undefined;
+                            loopStep = undefined;
                             break;
                         }
                         let item;
                         if (typeof loopStep.inputs.binding === "string" &&
                             loopStep.inputs.option === "String") {
-                            item = automationUtils.stringSplit(newInput.binding);
+                            item = automationUtils_1.default.stringSplit(newInput.binding);
                         }
                         else {
                             item = loopStep.inputs.binding;
@@ -183,31 +272,31 @@ class Orchestrator {
                                 for (let [innerKey, innerValue] of Object.entries(originalStepInput[key])) {
                                     if (typeof innerValue === "string") {
                                         originalStepInput[key][innerKey] =
-                                            automationUtils.substituteLoopStep(innerValue, `steps.${loopStepNumber}`);
+                                            automationUtils_1.default.substituteLoopStep(innerValue, `steps.${loopStepNumber}`);
                                     }
                                 }
                             }
                             else {
                                 if (typeof value === "string") {
-                                    originalStepInput[key] = automationUtils.substituteLoopStep(value, `steps.${loopStepNumber}`);
+                                    originalStepInput[key] = automationUtils_1.default.substituteLoopStep(value, `steps.${loopStepNumber}`);
                                 }
                             }
                         }
                         if (index === env.AUTOMATION_MAX_ITERATION ||
                             index === parseInt(loopStep.inputs.iterations)) {
                             this.updateContextAndOutput(loopStepNumber, step, tempOutput, {
-                                status: AutomationErrors.MAX_ITERATIONS,
+                                status: constants_1.AutomationErrors.MAX_ITERATIONS,
                                 success: true,
                             });
-                            loopSteps = null;
-                            loopStep = null;
+                            loopSteps = undefined;
+                            loopStep = undefined;
                             break;
                         }
                         let isFailure = false;
                         const currentItem = (_a = this._context.steps[loopStepNumber]) === null || _a === void 0 ? void 0 : _a.currentItem;
                         if (currentItem && typeof currentItem === "object") {
                             isFailure = Object.keys(currentItem).some(value => {
-                                return currentItem[value] === loopStep.inputs.failure;
+                                return currentItem[value] === (loopStep === null || loopStep === void 0 ? void 0 : loopStep.inputs.failure);
                             });
                         }
                         else {
@@ -215,11 +304,11 @@ class Orchestrator {
                         }
                         if (isFailure) {
                             this.updateContextAndOutput(loopStepNumber, step, tempOutput, {
-                                status: AutomationErrors.FAILURE_CONDITION,
+                                status: constants_1.AutomationErrors.FAILURE_CONDITION,
                                 success: false,
                             });
-                            loopSteps = null;
-                            loopStep = null;
+                            loopSteps = undefined;
+                            loopStep = undefined;
                             break;
                         }
                     }
@@ -231,7 +320,7 @@ class Orchestrator {
                     // If it's a loop step, we need to manually add the bindings to the context
                     let stepFn = yield this.getStepFunctionality(step.stepId);
                     let inputs = yield processObject(originalStepInput, this._context);
-                    inputs = automationUtils.cleanInputValues(inputs, step.schema.inputs);
+                    inputs = automationUtils_1.default.cleanInputValues(inputs, step.schema.inputs);
                     try {
                         // appId is always passed
                         const outputs = yield stepFn({
@@ -262,7 +351,7 @@ class Orchestrator {
                     if (loopStep) {
                         iterationCount++;
                         if (index === iterations - 1) {
-                            loopStep = null;
+                            loopStep = undefined;
                             this._context.steps.splice(loopStepNumber, 1);
                             break;
                         }
@@ -281,19 +370,22 @@ class Orchestrator {
                         inputs: step.inputs,
                     });
                     this._context.steps.splice(loopStepNumber, 0, tempOutput);
-                    loopSteps = null;
+                    loopSteps = undefined;
                 }
             }
             // store the logs for the automation run
-            yield storeLog(this._automation, this.executionOutput);
+            yield (0, logging_1.storeLog)(this._automation, this.executionOutput);
+            if ((0, utils_3.isProdAppID)(this._appId) && (0, utils_2.isRecurring)(automation) && metadata) {
+                yield this.updateMetadata(metadata);
+            }
             return this.executionOutput;
         });
     }
 }
-module.exports = (input, callback) => {
+function execute(input, callback) {
     const appId = input.data.event.appId;
-    doInAppContext(appId, () => __awaiter(void 0, void 0, void 0, function* () {
-        const automationOrchestrator = new Orchestrator(input.data.automation, input.data.event);
+    doInAppContext(appId, () => __awaiter(this, void 0, void 0, function* () {
+        const automationOrchestrator = new Orchestrator(input.data.automation, input.data.event, input.opts);
         try {
             const response = yield automationOrchestrator.execute();
             callback(null, response);
@@ -302,4 +394,5 @@ module.exports = (input, callback) => {
             callback(err);
         }
     }));
-};
+}
+exports.execute = execute;

package/dist/threads/definitions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/threads/index.js

@@ -54,17 +54,14 @@ function typeToFile(type) {
         default:
             throw "Unknown thread type";
     }
+    // have to use require here, to make it work with worker-farm
     return require.resolve(filename);
 }
 class Thread {
     constructor(type, opts = { timeoutMs: null, count: 1 }) {
         this.type = type;
         this.count = opts.count ? opts.count : 1;
-        this.disableThreading =
-            env.isTest() ||
-                env.DISABLE_THREADING ||
-                this.count === 0 ||
-                env.isInThread();
+        this.disableThreading = this.shouldDisableThreading();
         if (!this.disableThreading) {
             const workerOpts = {
                 autoStart: true,
@@ -74,31 +71,41 @@ class Thread {
                 this.timeoutMs = opts.timeoutMs;
                 workerOpts.maxCallTime = opts.timeoutMs;
             }
-            this.workers = (0, worker_farm_1.default)(workerOpts, typeToFile(type));
+            this.workers = (0, worker_farm_1.default)(workerOpts, typeToFile(type), ["execute"]);
             Thread.workerRefs.push(this.workers);
         }
     }
+    shouldDisableThreading() {
+        return !!(env.isTest() ||
+            env.DISABLE_THREADING ||
+            this.count === 0 ||
+            env.isInThread());
+    }
     run(data) {
+        const timeout = this.timeoutMs;
         return new Promise((resolve, reject) => {
-            let fncToCall;
+            function fire(worker) {
+                worker.execute(data, (err, response) => {
+                    if (err && err.type === "TimeoutError") {
+                        reject(new Error(`Query response time exceeded ${timeout}ms timeout.`));
+                    }
+                    else if (err) {
+                        reject(err);
+                    }
+                    else {
+                        resolve(response);
+                    }
+                });
+            }
             // if in test then don't use threading
             if (this.disableThreading) {
-                fncToCall = require(typeToFile(this.type));
+                Promise.resolve().then(() => __importStar(require(typeToFile(this.type)))).then((thread) => {
+                    fire(thread);
+                });
             }
             else {
-                fncToCall = this.workers;
+                fire(this.workers);
             }
-            fncToCall(data, (err, response) => {
-                if (err && err.type === "TimeoutError") {
-                    reject(new Error(`Query response time exceeded ${this.timeoutMs}ms timeout.`));
-                }
-                else if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve(response);
-                }
-            });
         });
     }
     static stopThreads() {

package/dist/threads/query.js

@@ -8,8 +8,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-const threadUtils = require("./utils");
-threadUtils.threadSetup();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execute = void 0;
+const utils_1 = __importDefault(require("./utils"));
+utils_1.default.threadSetup();
 const ScriptRunner = require("../utilities/scriptRunner");
 const { integrations } = require("../integrations");
 const { processStringSync } = require("@budibase/string-templates");
@@ -39,6 +44,7 @@ class QueryRunner {
         this.queryResponse = {};
         this.hasRerun = false;
         this.hasRefreshedOAuth = false;
+        this.hasDynamicVariables = false;
     }
     execute() {
         var _a;
@@ -52,7 +58,7 @@ class QueryRunner {
             }
             if (datasourceClone.config.authConfigs) {
                 datasourceClone.config.authConfigs =
-                    datasourceClone.config.authConfigs.map(config => {
+                    datasourceClone.config.authConfigs.map((config) => {
                         return enrichQueryFields(config, this.ctx);
                     });
             }
@@ -79,9 +85,9 @@ class QueryRunner {
             if (this.pagination) {
                 query.paginationValues = this.pagination;
             }
-            let output = threadUtils.formatResponse(yield integration[queryVerb](query));
+            let output = utils_1.default.formatResponse(yield integration[queryVerb](query));
             let rows = output, info = undefined, extra = undefined, pagination = undefined;
-            if (threadUtils.hasExtraData(output)) {
+            if (utils_1.default.hasExtraData(output)) {
                 rows = output.data;
                 info = output.info;
                 extra = output.extra;
@@ -107,7 +113,7 @@ class QueryRunner {
                 else {
                     this.hasRerun = true;
                 }
-                yield threadUtils.invalidateDynamicVariables(this.cachedVariables);
+                yield utils_1.default.invalidateDynamicVariables(this.cachedVariables);
                 return this.execute();
             }
             // check for undefined response
@@ -119,8 +125,8 @@ class QueryRunner {
                 rows = [rows];
             }
             // map into JSON if just raw primitive here
-            if (rows.find(row => typeof row !== "object")) {
-                rows = rows.map(value => ({ value }));
+            if (rows.find((row) => typeof row !== "object")) {
+                rows = rows.map((value) => ({ value }));
             }
             // get all the potential fields in the schema
             let keys = rows.flatMap(Object.keys);
@@ -141,6 +147,7 @@ class QueryRunner {
                 fields: query.fields,
                 parameters,
                 transformer: query.transformer,
+                queryId,
             }, { noRecursiveQuery: true }).execute();
         });
     }
@@ -172,14 +179,14 @@ class QueryRunner {
         return __awaiter(this, void 0, void 0, function* () {
             let { parameters } = this;
             const queryId = variable.queryId, name = variable.name;
-            let value = yield threadUtils.checkCacheForDynamicVariable(queryId, name);
+            let value = yield utils_1.default.checkCacheForDynamicVariable(queryId, name);
             if (!value) {
                 value = this.queryResponse[queryId]
                     ? this.queryResponse[queryId]
                     : yield this.runAnotherQuery(queryId, parameters);
                 // store incase this query is to be called again
                 this.queryResponse[queryId] = value;
-                yield threadUtils.storeDynamicVariable(queryId, name, value);
+                yield utils_1.default.storeDynamicVariable(queryId, name, value);
             }
             else {
                 this.cachedVariables.push({ queryId, name });
@@ -203,7 +210,7 @@ class QueryRunner {
             if (!this.noRecursiveQuery) {
                 // need to see if this uses any variables
                 const stringFields = JSON.stringify(fields);
-                const foundVars = dynamicVars.filter(variable => {
+                const foundVars = dynamicVars.filter((variable) => {
                     // don't allow a query to use its own dynamic variable (loop)
                     if (variable.queryId === this.queryId) {
                         return false;
@@ -212,7 +219,7 @@ class QueryRunner {
                     const regex = new RegExp(`{{[ ]*${variable.name}[ ]*}}`);
                     return regex.test(stringFields);
                 });
-                const dynamics = foundVars.map(dynVar => this.getDynamicVariable(dynVar));
+                const dynamics = foundVars.map((dynVar) => this.getDynamicVariable(dynVar));
                 const responses = yield Promise.all(dynamics);
                 for (let i = 0; i < foundVars.length; i++) {
                     const variable = foundVars[i];
@@ -230,8 +237,8 @@ class QueryRunner {
         });
     }
 }
-module.exports = (input, callback) => {
-    doInAppContext(input.appId, () => __awaiter(void 0, void 0, void 0, function* () {
+function execute(input, callback) {
+    doInAppContext(input.appId, () => __awaiter(this, void 0, void 0, function* () {
         const Runner = new QueryRunner(input);
         try {
             const response = yield Runner.execute();
@@ -241,4 +248,5 @@ module.exports = (input, callback) => {
             callback(err);
         }
     }));
-};
+}
+exports.execute = execute;

package/dist/threads/utils.js

@@ -8,6 +8,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasExtraData = exports.formatResponse = exports.storeDynamicVariable = exports.invalidateDynamicVariables = exports.checkCacheForDynamicVariable = exports.threadSetup = void 0;
 const env = require("../environment");
 const db = require("../db");
 const redis = require("@budibase/backend-core/redis");
@@ -23,10 +25,14 @@ function getClient() {
     });
 }
 process.on("exit", () => __awaiter(void 0, void 0, void 0, function* () {
-    if (client)
+    if (client) {
         yield client.finish();
+    }
 }));
-exports.threadSetup = () => {
+function makeVariableKey(queryId, variable) {
+    return `${queryId}${SEPARATOR}${variable}`;
+}
+function threadSetup() {
     // don't run this if not threading
     if (env.isTest() || env.DISABLE_THREADING) {
         return;
@@ -34,27 +40,34 @@ exports.threadSetup = () => {
     // when thread starts, make sure it is recorded
     env.setInThread();
     db.init();
-};
-function makeVariableKey(queryId, variable) {
-    return `${queryId}${SEPARATOR}${variable}`;
 }
-exports.checkCacheForDynamicVariable = (queryId, variable) => __awaiter(void 0, void 0, void 0, function* () {
-    const cache = yield getClient();
-    return cache.get(makeVariableKey(queryId, variable));
-});
-exports.invalidateDynamicVariables = (cachedVars) => __awaiter(void 0, void 0, void 0, function* () {
-    const cache = yield getClient();
-    let promises = [];
-    for (let variable of cachedVars) {
-        promises.push(cache.delete(makeVariableKey(variable.queryId, variable.name)));
-    }
-    yield Promise.all(promises);
-});
-exports.storeDynamicVariable = (queryId, variable, value) => __awaiter(void 0, void 0, void 0, function* () {
-    const cache = yield getClient();
-    yield cache.store(makeVariableKey(queryId, variable), value, VARIABLE_TTL_SECONDS);
-});
-exports.formatResponse = resp => {
+exports.threadSetup = threadSetup;
+function checkCacheForDynamicVariable(queryId, variable) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const cache = yield getClient();
+        return cache.get(makeVariableKey(queryId, variable));
+    });
+}
+exports.checkCacheForDynamicVariable = checkCacheForDynamicVariable;
+function invalidateDynamicVariables(cachedVars) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const cache = yield getClient();
+        let promises = [];
+        for (let variable of cachedVars) {
+            promises.push(cache.delete(makeVariableKey(variable.queryId, variable.name)));
+        }
+        yield Promise.all(promises);
+    });
+}
+exports.invalidateDynamicVariables = invalidateDynamicVariables;
+function storeDynamicVariable(queryId, variable, value) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const cache = yield getClient();
+        yield cache.store(makeVariableKey(queryId, variable), value, VARIABLE_TTL_SECONDS);
+    });
+}
+exports.storeDynamicVariable = storeDynamicVariable;
+function formatResponse(resp) {
     if (typeof resp === "string") {
         try {
             resp = JSON.parse(resp);
@@ -64,11 +77,21 @@ exports.formatResponse = resp => {
         }
     }
     return resp;
-};
-exports.hasExtraData = response => {
+}
+exports.formatResponse = formatResponse;
+function hasExtraData(response) {
     return (typeof response === "object" &&
         !Array.isArray(response) &&
         response &&
         response.data != null &&
         response.info != null);
+}
+exports.hasExtraData = hasExtraData;
+exports.default = {
+    hasExtraData,
+    formatResponse,
+    storeDynamicVariable,
+    invalidateDynamicVariables,
+    checkCacheForDynamicVariable,
+    threadSetup,
 };