@budibase/server 1.1.32-alpha.4 → 1.1.32

package/dist/threads/automation.js

@@ -8,45 +8,36 @@ 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 });
-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 { logAlertWithInfo, logWarn } = require("@budibase/backend-core/logging");
+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 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 { DocumentTypes } = require("../db/utils");
+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: true, status: "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 automations_1.LoopStepTypes.ARRAY:
-                if (typeof input.binding === "string") {
+            case LoopStepTypes.ARRAY:
+                if (isString) {
                     return JSON.parse(input.binding);
                 }
                 break;
-            case automations_1.LoopStepTypes.STRING:
-                if (Array.isArray(input.binding)) {
+            case LoopStepTypes.STRING:
+                if (isArray) {
                     return input.binding.join(",");
                 }
                 break;
@@ -64,7 +55,7 @@ function getLoopIterations(loopStep, input) {
     }
     return Array.isArray(binding)
         ? binding.length
-        : automationUtils_1.default.stringSplit(binding).length;
+        : automationUtils.stringSplit(binding).length;
 }
 /**
  * The automation orchestrator is a class responsible for executing automations.
@@ -72,16 +63,11 @@ function getLoopIterations(loopStep, input) {
  * inputs and handles any outputs.
  */
 class Orchestrator {
-    constructor(automation, triggerOutput, opts) {
-        const metadata = triggerOutput.metadata;
-        this._chainCount = metadata ? metadata.automationChainCount : 0;
+    constructor(automation, triggerOutput = {}) {
+        this._metadata = triggerOutput.metadata;
+        this._chainCount = this._metadata ? this._metadata.automationChainCount : 0;
         this._appId = triggerOutput.appId;
-        if (opts === null || opts === void 0 ? void 0 : opts.repeat) {
-            this._repeat = {
-                jobId: opts.repeat.jobId,
-                jobKey: opts.repeat.key,
-            };
-        }
+        this._app = null;
         const triggerStepId = automation.definition.trigger.stepId;
         triggerOutput = this.cleanupTriggerOutputs(triggerStepId, triggerOutput);
         // remove from context
@@ -92,7 +78,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_1.default(this._chainCount + 1);
+        this._emitter = new AutomationEmitter(this._chainCount + 1);
         this.executionOutput = { trigger: {}, steps: [] };
         // setup the execution output
         const triggerId = automation.definition.trigger.id;
@@ -106,98 +92,32 @@ class Orchestrator {
     }
     getStepFunctionality(stepId) {
         return __awaiter(this, void 0, void 0, function* () {
-            let step = yield actions_1.default.getAction(stepId);
+            let step = yield actions.getAction(stepId);
             if (step == null) {
                 throw `Cannot find automation step by name ${stepId}`;
             }
             return step;
         });
     }
-    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) {
+    getApp() {
         return __awaiter(this, void 0, void 0, function* () {
-            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;
+            if (this._app) {
+                return this._app;
             }
             const db = getAppDB();
-            try {
-                yield db.put(metadata);
-            }
-            catch (err) {
-                logAlertWithInfo("Failed to write automation metadata", db.name, automation._id, err);
-            }
+            this._app = yield db.get(DocumentTypes.APP_METADATA);
+            return this._app;
         });
     }
     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 ||
-            this.executionOutput.trigger.id === id) {
+        if (this.executionOutput.steps.length === 0) {
             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,
@@ -211,19 +131,10 @@ class Orchestrator {
         return __awaiter(this, void 0, void 0, function* () {
             let automation = this._automation;
             let stopped = false;
-            let loopStep = undefined;
+            let loopStep = null;
             let stepCount = 0;
-            let loopStepNumber = undefined;
+            let loopStepNumber = null;
             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;
@@ -247,17 +158,17 @@ class Orchestrator {
                         }
                         catch (err) {
                             this.updateContextAndOutput(loopStepNumber, step, tempOutput, {
-                                status: constants_1.AutomationErrors.INCORRECT_TYPE,
+                                status: AutomationErrors.INCORRECT_TYPE,
                                 success: false,
                             });
-                            loopSteps = undefined;
-                            loopStep = undefined;
+                            loopSteps = null;
+                            loopStep = null;
                             break;
                         }
                         let item;
                         if (typeof loopStep.inputs.binding === "string" &&
                             loopStep.inputs.option === "String") {
-                            item = automationUtils_1.default.stringSplit(newInput.binding);
+                            item = automationUtils.stringSplit(newInput.binding);
                         }
                         else {
                             item = loopStep.inputs.binding;
@@ -272,31 +183,31 @@ class Orchestrator {
                                 for (let [innerKey, innerValue] of Object.entries(originalStepInput[key])) {
                                     if (typeof innerValue === "string") {
                                         originalStepInput[key][innerKey] =
-                                            automationUtils_1.default.substituteLoopStep(innerValue, `steps.${loopStepNumber}`);
+                                            automationUtils.substituteLoopStep(innerValue, `steps.${loopStepNumber}`);
                                     }
                                 }
                             }
                             else {
                                 if (typeof value === "string") {
-                                    originalStepInput[key] = automationUtils_1.default.substituteLoopStep(value, `steps.${loopStepNumber}`);
+                                    originalStepInput[key] = automationUtils.substituteLoopStep(value, `steps.${loopStepNumber}`);
                                 }
                             }
                         }
                         if (index === env.AUTOMATION_MAX_ITERATION ||
                             index === parseInt(loopStep.inputs.iterations)) {
                             this.updateContextAndOutput(loopStepNumber, step, tempOutput, {
-                                status: constants_1.AutomationErrors.MAX_ITERATIONS,
+                                status: AutomationErrors.MAX_ITERATIONS,
                                 success: true,
                             });
-                            loopSteps = undefined;
-                            loopStep = undefined;
+                            loopSteps = null;
+                            loopStep = null;
                             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 === null || loopStep === void 0 ? void 0 : loopStep.inputs.failure);
+                                return currentItem[value] === loopStep.inputs.failure;
                             });
                         }
                         else {
@@ -304,11 +215,11 @@ class Orchestrator {
                         }
                         if (isFailure) {
                             this.updateContextAndOutput(loopStepNumber, step, tempOutput, {
-                                status: constants_1.AutomationErrors.FAILURE_CONDITION,
+                                status: AutomationErrors.FAILURE_CONDITION,
                                 success: false,
                             });
-                            loopSteps = undefined;
-                            loopStep = undefined;
+                            loopSteps = null;
+                            loopStep = null;
                             break;
                         }
                     }
@@ -320,7 +231,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_1.default.cleanInputValues(inputs, step.schema.inputs);
+                    inputs = automationUtils.cleanInputValues(inputs, step.schema.inputs);
                     try {
                         // appId is always passed
                         const outputs = yield stepFn({
@@ -351,7 +262,7 @@ class Orchestrator {
                     if (loopStep) {
                         iterationCount++;
                         if (index === iterations - 1) {
-                            loopStep = undefined;
+                            loopStep = null;
                             this._context.steps.splice(loopStepNumber, 1);
                             break;
                         }
@@ -370,22 +281,19 @@ class Orchestrator {
                         inputs: step.inputs,
                     });
                     this._context.steps.splice(loopStepNumber, 0, tempOutput);
-                    loopSteps = undefined;
+                    loopSteps = null;
                 }
             }
             // store the logs for the automation run
-            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);
-            }
+            yield storeLog(this._automation, this.executionOutput);
             return this.executionOutput;
         });
     }
 }
-function execute(input, callback) {
+module.exports = (input, callback) => {
     const appId = input.data.event.appId;
-    doInAppContext(appId, () => __awaiter(this, void 0, void 0, function* () {
-        const automationOrchestrator = new Orchestrator(input.data.automation, input.data.event, input.opts);
+    doInAppContext(appId, () => __awaiter(void 0, void 0, void 0, function* () {
+        const automationOrchestrator = new Orchestrator(input.data.automation, input.data.event);
         try {
             const response = yield automationOrchestrator.execute();
             callback(null, response);
@@ -394,5 +302,4 @@ function execute(input, callback) {
             callback(err);
         }
     }));
-}
-exports.execute = execute;
+};

package/dist/threads/index.js

@@ -54,14 +54,17 @@ 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 = this.shouldDisableThreading();
+        this.disableThreading =
+            env.isTest() ||
+                env.DISABLE_THREADING ||
+                this.count === 0 ||
+                env.isInThread();
         if (!this.disableThreading) {
             const workerOpts = {
                 autoStart: true,
@@ -71,41 +74,31 @@ class Thread {
                 this.timeoutMs = opts.timeoutMs;
                 workerOpts.maxCallTime = opts.timeoutMs;
             }
-            this.workers = (0, worker_farm_1.default)(workerOpts, typeToFile(type), ["execute"]);
+            this.workers = (0, worker_farm_1.default)(workerOpts, typeToFile(type));
             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) => {
-            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);
-                    }
-                });
-            }
+            let fncToCall;
             // if in test then don't use threading
             if (this.disableThreading) {
-                Promise.resolve().then(() => __importStar(require(typeToFile(this.type)))).then((thread) => {
-                    fire(thread);
-                });
+                fncToCall = require(typeToFile(this.type));
             }
             else {
-                fire(this.workers);
+                fncToCall = 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,13 +8,8 @@ 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 });
-exports.execute = void 0;
-const utils_1 = __importDefault(require("./utils"));
-utils_1.default.threadSetup();
+const threadUtils = require("./utils");
+threadUtils.threadSetup();
 const ScriptRunner = require("../utilities/scriptRunner");
 const { integrations } = require("../integrations");
 const { processStringSync } = require("@budibase/string-templates");
@@ -44,7 +39,6 @@ class QueryRunner {
         this.queryResponse = {};
         this.hasRerun = false;
         this.hasRefreshedOAuth = false;
-        this.hasDynamicVariables = false;
     }
     execute() {
         var _a;
@@ -58,7 +52,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);
                     });
             }
@@ -85,9 +79,9 @@ class QueryRunner {
             if (this.pagination) {
                 query.paginationValues = this.pagination;
             }
-            let output = utils_1.default.formatResponse(yield integration[queryVerb](query));
+            let output = threadUtils.formatResponse(yield integration[queryVerb](query));
             let rows = output, info = undefined, extra = undefined, pagination = undefined;
-            if (utils_1.default.hasExtraData(output)) {
+            if (threadUtils.hasExtraData(output)) {
                 rows = output.data;
                 info = output.info;
                 extra = output.extra;
@@ -113,7 +107,7 @@ class QueryRunner {
                 else {
                     this.hasRerun = true;
                 }
-                yield utils_1.default.invalidateDynamicVariables(this.cachedVariables);
+                yield threadUtils.invalidateDynamicVariables(this.cachedVariables);
                 return this.execute();
             }
             // check for undefined response
@@ -125,8 +119,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);
@@ -147,7 +141,6 @@ class QueryRunner {
                 fields: query.fields,
                 parameters,
                 transformer: query.transformer,
-                queryId,
             }, { noRecursiveQuery: true }).execute();
         });
     }
@@ -179,14 +172,14 @@ class QueryRunner {
         return __awaiter(this, void 0, void 0, function* () {
             let { parameters } = this;
             const queryId = variable.queryId, name = variable.name;
-            let value = yield utils_1.default.checkCacheForDynamicVariable(queryId, name);
+            let value = yield threadUtils.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 utils_1.default.storeDynamicVariable(queryId, name, value);
+                yield threadUtils.storeDynamicVariable(queryId, name, value);
             }
             else {
                 this.cachedVariables.push({ queryId, name });
@@ -210,7 +203,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;
@@ -219,7 +212,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];
@@ -237,8 +230,8 @@ class QueryRunner {
         });
     }
 }
-function execute(input, callback) {
-    doInAppContext(input.appId, () => __awaiter(this, void 0, void 0, function* () {
+module.exports = (input, callback) => {
+    doInAppContext(input.appId, () => __awaiter(void 0, void 0, void 0, function* () {
         const Runner = new QueryRunner(input);
         try {
             const response = yield Runner.execute();
@@ -248,5 +241,4 @@ function execute(input, callback) {
             callback(err);
         }
     }));
-}
-exports.execute = execute;
+};

package/dist/threads/utils.js

@@ -8,8 +8,6 @@ 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");
@@ -25,14 +23,10 @@ function getClient() {
     });
 }
 process.on("exit", () => __awaiter(void 0, void 0, void 0, function* () {
-    if (client) {
+    if (client)
         yield client.finish();
-    }
 }));
-function makeVariableKey(queryId, variable) {
-    return `${queryId}${SEPARATOR}${variable}`;
-}
-function threadSetup() {
+exports.threadSetup = () => {
     // don't run this if not threading
     if (env.isTest() || env.DISABLE_THREADING) {
         return;
@@ -40,34 +34,27 @@ function threadSetup() {
     // when thread starts, make sure it is recorded
     env.setInThread();
     db.init();
+};
+function makeVariableKey(queryId, variable) {
+    return `${queryId}${SEPARATOR}${variable}`;
 }
-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) {
+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 => {
     if (typeof resp === "string") {
         try {
             resp = JSON.parse(resp);
@@ -77,21 +64,11 @@ function formatResponse(resp) {
         }
     }
     return resp;
-}
-exports.formatResponse = formatResponse;
-function hasExtraData(response) {
+};
+exports.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,
 };