@budibase/server 1.0.113 → 1.0.116

package/dist/tests/utilities/TestConfiguration.js

@@ -8,9 +8,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-const core = require("@budibase/backend-core");
-const CouchDB = require("../../db");
-core.init(CouchDB);
+require("../../db").init();
 const { BUILTIN_ROLE_IDS } = require("@budibase/backend-core/roles");
 const env = require("../../environment");
 const { basicTable, basicRow, basicRole, basicAutomation, basicDatasource, basicQuery, basicScreen, basicLayout, basicWebhook, TENANT_ID, } = require("./structures");
@@ -19,7 +17,7 @@ const supertest = require("supertest");
 const { cleanup } = require("../../utilities/fileSystem");
 const { Cookies, Headers } = require("@budibase/backend-core/constants");
 const { jwt } = require("@budibase/backend-core/auth");
-const { getGlobalDB } = require("@budibase/backend-core/tenancy");
+const { doInTenant, doWithGlobalDB } = require("@budibase/backend-core/tenancy");
 const { createASession } = require("@budibase/backend-core/sessions");
 const { user: userCache } = require("@budibase/backend-core/cache");
 const newid = require("../../db/newid");
@@ -50,8 +48,23 @@ class TestConfiguration {
     getAppId() {
         return this.appId;
     }
-    getCouch() {
-        return CouchDB;
+    doInContext(appId, task) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!appId) {
+                appId = this.appId;
+            }
+            return doInTenant(TENANT_ID, () => {
+                // check if already in a context
+                if (context.getAppId() == null && appId !== null) {
+                    return context.doInAppContext(appId, () => __awaiter(this, void 0, void 0, function* () {
+                        return task();
+                    }));
+                }
+                else {
+                    return task();
+                }
+            });
+        });
     }
     _req(config, params, controlFunc) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -65,66 +78,57 @@ class TestConfiguration {
             request.request = {
                 body: config,
             };
-            function run() {
-                return __awaiter(this, void 0, void 0, function* () {
-                    if (params) {
-                        request.params = params;
-                    }
-                    yield controlFunc(request);
-                    return request.body;
-                });
-            }
-            // check if already in a context
-            if (context.getAppId() == null && this.appId !== null) {
-                return context.doInAppContext(this.appId, () => __awaiter(this, void 0, void 0, function* () {
-                    return run();
-                }));
-            }
-            else {
-                return run();
-            }
+            return this.doInContext(this.appId, () => __awaiter(this, void 0, void 0, function* () {
+                if (params) {
+                    request.params = params;
+                }
+                yield controlFunc(request);
+                return request.body;
+            }));
         });
     }
     generateApiKey(userId = GLOBAL_USER_ID) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = getGlobalDB(TENANT_ID);
-            const id = generateDevInfoID(userId);
-            let devInfo;
-            try {
-                devInfo = yield db.get(id);
-            }
-            catch (err) {
-                devInfo = { _id: id, userId };
-            }
-            devInfo.apiKey = encrypt(`${TENANT_ID}${SEPARATOR}${newid()}`);
-            yield db.put(devInfo);
-            return devInfo.apiKey;
+            return doWithGlobalDB(TENANT_ID, (db) => __awaiter(this, void 0, void 0, function* () {
+                const id = generateDevInfoID(userId);
+                let devInfo;
+                try {
+                    devInfo = yield db.get(id);
+                }
+                catch (err) {
+                    devInfo = { _id: id, userId };
+                }
+                devInfo.apiKey = encrypt(`${TENANT_ID}${SEPARATOR}${newid()}`);
+                yield db.put(devInfo);
+                return devInfo.apiKey;
+            }));
         });
     }
     globalUser({ id = GLOBAL_USER_ID, builder = true, email = EMAIL, roles, } = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = getGlobalDB(TENANT_ID);
-            let existing;
-            try {
-                existing = yield db.get(id);
-            }
-            catch (err) {
-                existing = { email };
-            }
-            const user = Object.assign(Object.assign({ _id: id }, existing), { roles: roles || {}, tenantId: TENANT_ID });
-            yield createASession(id, {
-                sessionId: "sessionid",
-                tenantId: TENANT_ID,
-                csrfToken: CSRF_TOKEN,
-            });
-            if (builder) {
-                user.builder = { global: true };
-            }
-            else {
-                user.builder = { global: false };
-            }
-            const resp = yield db.put(user);
-            return Object.assign({ _rev: resp._rev }, user);
+            return doWithGlobalDB(TENANT_ID, (db) => __awaiter(this, void 0, void 0, function* () {
+                let existing;
+                try {
+                    existing = yield db.get(id);
+                }
+                catch (err) {
+                    existing = { email };
+                }
+                const user = Object.assign(Object.assign({ _id: id }, existing), { roles: roles || {}, tenantId: TENANT_ID });
+                yield createASession(id, {
+                    sessionId: "sessionid",
+                    tenantId: TENANT_ID,
+                    csrfToken: CSRF_TOKEN,
+                });
+                if (builder) {
+                    user.builder = { global: true };
+                }
+                else {
+                    user.builder = { global: false };
+                }
+                const resp = yield db.put(user);
+                return Object.assign({ _rev: resp._rev }, user);
+            }));
         });
     }
     // use a new id as the name to avoid name collisions
@@ -182,9 +186,12 @@ class TestConfiguration {
     createApp(appName) {
         return __awaiter(this, void 0, void 0, function* () {
             // create dev app
+            // clear any old app
+            this.appId = null;
+            yield context.updateAppId(null);
             this.app = yield this._req({ name: appName }, null, controllers.app.create);
             this.appId = this.app.appId;
-            context.updateAppId(this.appId);
+            yield context.updateAppId(this.appId);
             // create production app
             this.prodApp = yield this.deploy();
             this.prodAppId = this.prodApp.appId;

package/dist/threads/index.js

@@ -34,12 +34,14 @@ class Thread {
                 maxConcurrentWorkers: this.count,
             };
             if (opts.timeoutMs) {
+                this.timeoutMs = opts.timeoutMs;
                 workerOpts.maxCallTime = opts.timeoutMs;
             }
             this.workers = workerFarm(workerOpts, typeToFile(type));
         }
     }
     run(data) {
+        const timeoutMs = this.timeoutMs;
         return new Promise((resolve, reject) => {
             let fncToCall;
             // if in test then don't use threading
@@ -50,7 +52,10 @@ class Thread {
                 fncToCall = this.workers;
             }
             fncToCall(data, (err, response) => {
-                if (err) {
+                if (err && err.type === "TimeoutError") {
+                    reject(new Error(`Query response time exceeded ${timeoutMs}ms timeout.`));
+                }
+                else if (err) {
                     reject(err);
                 }
                 else {

package/dist/threads/query.js

@@ -12,10 +12,10 @@ const threadUtils = require("./utils");
 threadUtils.threadSetup();
 const ScriptRunner = require("../utilities/scriptRunner");
 const { integrations } = require("../integrations");
-const { processStringSync, findHBSBlocks, } = require("@budibase/string-templates");
+const { processStringSync } = require("@budibase/string-templates");
 const { doInAppContext, getAppDB } = require("@budibase/backend-core/context");
 const { isSQL } = require("../integrations/utils");
-const CONST_CHAR_REGEX = new RegExp("'[^']*'", "g");
+const { enrichQueryFields, interpolateSQL, } = require("../integrations/queries/sql");
 class QueryRunner {
     constructor(input, flags = { noRecursiveQuery: false }) {
         this.datasource = input.datasource;
@@ -33,67 +33,6 @@ class QueryRunner {
         this.queryResponse = {};
         this.hasRerun = false;
     }
-    interpolateSQL(fields, parameters, integration) {
-        let sql = fields.sql;
-        if (!sql) {
-            return fields;
-        }
-        const bindings = findHBSBlocks(sql);
-        let variables = [], arrays = [];
-        for (let binding of bindings) {
-            // look for array/list operations in the SQL statement, which will need handled later
-            const listRegexMatch = sql.match(new RegExp(`(in|IN|In|iN)( )+[(]?${binding}[)]?`));
-            // check if the variable was used as part of a string concat e.g. 'Hello {{binding}}'
-            // start by finding all the instances of const character strings
-            const charConstMatch = sql.match(CONST_CHAR_REGEX) || [];
-            // now look within them to see if a binding is used
-            const charConstBindingMatch = charConstMatch.find(string => string.match(new RegExp(`'[^']*${binding}[^']*'`)));
-            if (charConstBindingMatch) {
-                let [part1, part2] = charConstBindingMatch.split(binding);
-                part1 = `'${part1.substring(1)}'`;
-                part2 = `'${part2.substring(0, part2.length - 1)}'`;
-                sql = sql.replace(charConstBindingMatch, integration.getStringConcat([
-                    part1,
-                    integration.getBindingIdentifier(),
-                    part2,
-                ]));
-            }
-            // generate SQL parameterised array
-            else if (listRegexMatch) {
-                arrays.push(binding);
-                // determine the length of the array
-                const value = this.enrichQueryFields([binding], parameters)[0].split(",");
-                // build a string like ($1, $2, $3)
-                let replacement = `${Array.apply(null, Array(value.length))
-                    .map(() => integration.getBindingIdentifier())
-                    .join(",")}`;
-                // check if parentheses are needed
-                if (!listRegexMatch[0].includes(`(${binding})`)) {
-                    replacement = `(${replacement})`;
-                }
-                sql = sql.replace(binding, replacement);
-            }
-            else {
-                sql = sql.replace(binding, integration.getBindingIdentifier());
-            }
-            variables.push(binding);
-        }
-        // replicate the knex structure
-        fields.sql = sql;
-        fields.bindings = this.enrichQueryFields(variables, parameters);
-        // check for arrays in the data
-        let updated = [];
-        for (let i = 0; i < variables.length; i++) {
-            if (arrays.includes(variables[i])) {
-                updated = updated.concat(fields.bindings[i].split(","));
-            }
-            else {
-                updated.push(fields.bindings[i]);
-            }
-        }
-        fields.bindings = updated;
-        return fields;
-    }
     execute() {
         return __awaiter(this, void 0, void 0, function* () {
             let { datasource, fields, queryVerb, transformer } = this;
@@ -107,10 +46,10 @@ class QueryRunner {
             let query;
             // handle SQL injections by interpolating the variables
             if (isSQL(datasource)) {
-                query = this.interpolateSQL(fields, parameters, integration);
+                query = interpolateSQL(fields, parameters, integration);
             }
             else {
-                query = this.enrichQueryFields(fields, parameters);
+                query = enrichQueryFields(fields, parameters);
             }
             // Add pagination values for REST queries
             if (this.pagination) {
@@ -237,44 +176,6 @@ class QueryRunner {
             return parameters;
         });
     }
-    enrichQueryFields(fields, parameters = {}) {
-        const enrichedQuery = Array.isArray(fields) ? [] : {};
-        // 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
-                enrichedQuery[key] = 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;
-    }
 }
 module.exports = (input, callback) => {
     doInAppContext(input.appId, () => {

package/dist/threads/utils.js

@@ -9,8 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 const env = require("../environment");
-const CouchDB = require("../db");
-const { init } = require("@budibase/backend-core");
+const db = require("../db");
 const redis = require("@budibase/backend-core/redis");
 const { SEPARATOR } = require("@budibase/backend-core/db");
 const VARIABLE_TTL_SECONDS = 3600;
@@ -34,7 +33,7 @@ exports.threadSetup = () => {
     }
     // when thread starts, make sure it is recorded
     env.setInThread();
-    init(CouchDB);
+    db.init();
 };
 function makeVariableKey(queryId, variable) {
     return `${queryId}${SEPARATOR}${variable}`;