@budibase/server 1.0.27-alpha.1 → 1.0.27-alpha.13

package/dist/threads/query.js

@@ -8,63 +8,159 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-require("./utils").threadSetup();
+const threadUtils = require("./utils");
+threadUtils.threadSetup();
 const ScriptRunner = require("../utilities/scriptRunner");
 const { integrations } = require("../integrations");
-function formatResponse(resp) {
-    if (typeof resp === "string") {
-        try {
-            resp = JSON.parse(resp);
-        }
-        catch (err) {
-            resp = { response: resp };
-        }
+const { processStringSync } = require("@budibase/string-templates");
+const CouchDB = require("../db");
+class QueryRunner {
+    constructor(input, flags = { noRecursiveQuery: false }) {
+        this.appId = input.appId;
+        this.datasource = input.datasource;
+        this.queryVerb = input.queryVerb;
+        this.fields = input.fields;
+        this.parameters = input.parameters;
+        this.transformer = input.transformer;
+        this.queryId = input.queryId;
+        this.noRecursiveQuery = flags.noRecursiveQuery;
+        this.cachedVariables = [];
+        // allows the response from a query to be stored throughout this
+        // execution so that if it needs to be re-used for another variable
+        // it can be
+        this.queryResponse = {};
+        this.hasRerun = false;
+    }
+    execute() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let { datasource, fields, queryVerb, transformer } = this;
+            // pre-query, make sure datasource variables are added to parameters
+            const parameters = yield this.addDatasourceVariables();
+            const query = threadUtils.enrichQueryFields(fields, parameters);
+            const Integration = integrations[datasource.source];
+            if (!Integration) {
+                throw "Integration type does not exist.";
+            }
+            const integration = new Integration(datasource.config);
+            let output = threadUtils.formatResponse(yield integration[queryVerb](query));
+            let rows = output, info = undefined, extra = undefined;
+            if (threadUtils.hasExtraData(output)) {
+                rows = output.data;
+                info = output.info;
+                extra = output.extra;
+            }
+            // transform as required
+            if (transformer) {
+                const runner = new ScriptRunner(transformer, {
+                    data: rows,
+                    params: parameters,
+                });
+                rows = runner.execute();
+            }
+            // if the request fails we retry once, invalidating the cached value
+            if (info &&
+                info.code >= 400 &&
+                this.cachedVariables.length > 0 &&
+                !this.hasRerun) {
+                this.hasRerun = true;
+                // invalidate the cache value
+                yield threadUtils.invalidateDynamicVariables(this.cachedVariables);
+                return this.execute();
+            }
+            // needs to an array for next step
+            if (!Array.isArray(rows)) {
+                rows = [rows];
+            }
+            // map into JSON if just raw primitive here
+            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);
+            if (integration.end) {
+                integration.end();
+            }
+            return { rows, keys, info, extra };
+        });
+    }
+    runAnotherQuery(queryId, parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const db = new CouchDB(this.appId);
+            const query = yield db.get(queryId);
+            const datasource = yield db.get(query.datasourceId);
+            return new QueryRunner({
+                appId: this.appId,
+                datasource,
+                queryVerb: query.queryVerb,
+                fields: query.fields,
+                parameters,
+                transformer: query.transformer,
+            }, { noRecursiveQuery: true }).execute();
+        });
+    }
+    getDynamicVariable(variable) {
+        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);
+            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);
+            }
+            else {
+                this.cachedVariables.push({ queryId, name });
+            }
+            return value;
+        });
+    }
+    addDatasourceVariables() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let { datasource, parameters, fields } = this;
+            if (!datasource || !datasource.config) {
+                return parameters;
+            }
+            const staticVars = datasource.config.staticVariables || {};
+            const dynamicVars = datasource.config.dynamicVariables || [];
+            for (let [key, value] of Object.entries(staticVars)) {
+                if (!parameters[key]) {
+                    parameters[key] = value;
+                }
+            }
+            if (!this.noRecursiveQuery) {
+                // need to see if this uses any variables
+                const stringFields = JSON.stringify(fields);
+                const foundVars = dynamicVars.filter(variable => {
+                    // don't allow a query to use its own dynamic variable (loop)
+                    if (variable.queryId === this.queryId) {
+                        return false;
+                    }
+                    // look for {{ variable }} but allow spaces between handlebars
+                    const regex = new RegExp(`{{[ ]*${variable.name}[ ]*}}`);
+                    return regex.test(stringFields);
+                });
+                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];
+                    parameters[variable.name] = processStringSync(variable.value, {
+                        data: responses[i].rows,
+                        info: responses[i].extra,
+                    });
+                    // make sure its known that this uses dynamic variables in case it fails
+                    this.hasDynamicVariables = true;
+                }
+            }
+            return parameters;
+        });
     }
-    return resp;
-}
-function hasExtraData(response) {
-    return (typeof response === "object" &&
-        !Array.isArray(response) &&
-        response.data != null &&
-        response.info != null);
-}
-function runAndTransform(datasource, queryVerb, query, transformer) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const Integration = integrations[datasource.source];
-        if (!Integration) {
-            throw "Integration type does not exist.";
-        }
-        const integration = new Integration(datasource.config);
-        let output = formatResponse(yield integration[queryVerb](query));
-        let rows = output, info = undefined, extra = undefined;
-        if (hasExtraData(output)) {
-            rows = output.data;
-            info = output.info;
-            extra = output.extra;
-        }
-        // transform as required
-        if (transformer) {
-            const runner = new ScriptRunner(transformer, { data: rows });
-            rows = runner.execute();
-        }
-        // needs to an array for next step
-        if (!Array.isArray(rows)) {
-            rows = [rows];
-        }
-        // map into JSON if just raw primitive here
-        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);
-        if (integration.end) {
-            integration.end();
-        }
-        return { rows, keys, info, extra };
-    });
 }
 module.exports = (input, callback) => {
-    runAndTransform(input.datasource, input.queryVerb, input.query, input.transformer)
+    const Runner = new QueryRunner(input);
+    Runner.execute()
         .then(response => {
         callback(null, response);
     })

package/dist/threads/utils.js

@@ -1,7 +1,35 @@
 "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());
+    });
+};
 const env = require("../environment");
 const CouchDB = require("../db");
-const { init } = require("@budibase/auth");
+const { init } = require("@budibase/backend-core");
+const redis = require("@budibase/backend-core/redis");
+const { SEPARATOR } = require("@budibase/backend-core/db");
+const { processStringSync } = require("@budibase/string-templates");
+const VARIABLE_TTL_SECONDS = 3600;
+let client;
+const IS_TRIPLE_BRACE = new RegExp(/^{{3}.*}{3}$/);
+const IS_HANDLEBARS = new RegExp(/^{{2}.*}{2}$/);
+function getClient() {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!client) {
+            client = yield new redis.Client(redis.utils.Databases.QUERY_VARS).init();
+        }
+        return client;
+    });
+}
+process.on("exit", () => __awaiter(void 0, void 0, void 0, function* () {
+    if (client)
+        yield client.finish();
+}));
 exports.threadSetup = () => {
     // don't run this if not threading
     if (env.isTest() || env.DISABLE_THREADING) {
@@ -11,3 +39,80 @@ exports.threadSetup = () => {
     env.setInThread();
     init(CouchDB);
 };
+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 => {
+    if (typeof resp === "string") {
+        try {
+            resp = JSON.parse(resp);
+        }
+        catch (err) {
+            resp = { response: resp };
+        }
+    }
+    return resp;
+};
+exports.hasExtraData = response => {
+    return (typeof response === "object" &&
+        !Array.isArray(response) &&
+        response.data != null &&
+        response.info != null);
+};
+exports.enrichQueryFields = (fields, parameters = {}) => {
+    const enrichedQuery = {};
+    // 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] = this.enrichQueryFields(fields[key], parameters);
+        }
+        else if (typeof fields[key] === "string") {
+            // enrich string value as normal
+            let value = fields[key];
+            // add triple brace to avoid escaping e.g. '=' in cookie header
+            if (IS_HANDLEBARS.test(value) && !IS_TRIPLE_BRACE.test(value)) {
+                value = `{${value}}`;
+            }
+            enrichedQuery[key] = processStringSync(value, parameters, {
+                noHelpers: 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;
+};