@budibase/server 1.0.27-alpha.2 → 1.0.27-alpha.23

package/dist/integrations/utils.js

@@ -2,39 +2,39 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.finaliseExternalTables = exports.isIsoDateString = exports.isSQL = exports.getSqlQuery = exports.convertSqlType = exports.breakRowIdField = exports.convertRowId = exports.isRowId = exports.generateRowIdField = exports.breakExternalTableId = exports.buildExternalTableId = exports.isExternalTable = exports.SqlClients = void 0;
 const datasource_1 = require("../definitions/datasource");
-const { DocumentTypes, SEPARATOR } = require("../db/utils");
-const { FieldTypes, BuildSchemaErrors, InvalidColumns, } = require("../constants");
-const DOUBLE_SEPARATOR = `${SEPARATOR}${SEPARATOR}`;
+const utils_1 = require("../db/utils");
+const constants_1 = require("../constants");
+const DOUBLE_SEPARATOR = `${utils_1.SEPARATOR}${utils_1.SEPARATOR}`;
 const ROW_ID_REGEX = /^\[.*]$/g;
 const SQL_TYPE_MAP = {
-    text: FieldTypes.LONGFORM,
-    varchar: FieldTypes.STRING,
-    integer: FieldTypes.NUMBER,
-    bigint: FieldTypes.NUMBER,
-    decimal: FieldTypes.NUMBER,
-    smallint: FieldTypes.NUMBER,
-    real: FieldTypes.NUMBER,
-    "double precision": FieldTypes.NUMBER,
-    timestamp: FieldTypes.DATETIME,
-    time: FieldTypes.DATETIME,
-    boolean: FieldTypes.BOOLEAN,
-    json: FieldTypes.JSON,
-    date: FieldTypes.DATETIME,
-    blob: FieldTypes.LONGFORM,
-    enum: FieldTypes.STRING,
-    float: FieldTypes.NUMBER,
-    int: FieldTypes.NUMBER,
-    numeric: FieldTypes.NUMBER,
-    mediumint: FieldTypes.NUMBER,
-    dec: FieldTypes.NUMBER,
-    double: FieldTypes.NUMBER,
-    fixed: FieldTypes.NUMBER,
-    datetime: FieldTypes.DATETIME,
-    tinyint: FieldTypes.BOOLEAN,
-    long: FieldTypes.LONGFORM,
-    number: FieldTypes.NUMBER,
-    binary_float: FieldTypes.NUMBER,
-    binary_double: FieldTypes.NUMBER,
+    text: constants_1.FieldTypes.LONGFORM,
+    varchar: constants_1.FieldTypes.STRING,
+    integer: constants_1.FieldTypes.NUMBER,
+    bigint: constants_1.FieldTypes.NUMBER,
+    decimal: constants_1.FieldTypes.NUMBER,
+    smallint: constants_1.FieldTypes.NUMBER,
+    real: constants_1.FieldTypes.NUMBER,
+    "double precision": constants_1.FieldTypes.NUMBER,
+    timestamp: constants_1.FieldTypes.DATETIME,
+    time: constants_1.FieldTypes.DATETIME,
+    boolean: constants_1.FieldTypes.BOOLEAN,
+    json: constants_1.FieldTypes.JSON,
+    date: constants_1.FieldTypes.DATETIME,
+    blob: constants_1.FieldTypes.LONGFORM,
+    enum: constants_1.FieldTypes.STRING,
+    float: constants_1.FieldTypes.NUMBER,
+    int: constants_1.FieldTypes.NUMBER,
+    numeric: constants_1.FieldTypes.NUMBER,
+    mediumint: constants_1.FieldTypes.NUMBER,
+    dec: constants_1.FieldTypes.NUMBER,
+    double: constants_1.FieldTypes.NUMBER,
+    fixed: constants_1.FieldTypes.NUMBER,
+    datetime: constants_1.FieldTypes.DATETIME,
+    tinyint: constants_1.FieldTypes.BOOLEAN,
+    long: constants_1.FieldTypes.LONGFORM,
+    number: constants_1.FieldTypes.NUMBER,
+    binary_float: constants_1.FieldTypes.NUMBER,
+    binary_double: constants_1.FieldTypes.NUMBER,
 };
 var SqlClients;
 (function (SqlClients) {
@@ -44,7 +44,7 @@ var SqlClients;
     SqlClients["ORACLE"] = "oracledb";
 })(SqlClients = exports.SqlClients || (exports.SqlClients = {}));
 function isExternalTable(tableId) {
-    return tableId.includes(DocumentTypes.DATASOURCE);
+    return tableId.includes(utils_1.DocumentTypes.DATASOURCE);
 }
 exports.isExternalTable = isExternalTable;
 function buildExternalTableId(datasourceId, tableName) {
@@ -109,7 +109,7 @@ function convertSqlType(type) {
             return internal;
         }
     }
-    return FieldTypes.STRING;
+    return constants_1.FieldTypes.STRING;
 }
 exports.convertSqlType = convertSqlType;
 function getSqlQuery(query) {
@@ -148,7 +148,10 @@ function copyExistingPropsOver(tableName, table, entities) {
             if (!existingTableSchema.hasOwnProperty(key)) {
                 continue;
             }
-            if (existingTableSchema[key].type === "link") {
+            if (existingTableSchema[key].type === constants_1.FieldTypes.LINK ||
+                existingTableSchema[key].type === constants_1.FieldTypes.OPTIONS ||
+                ((!table.schema[key] || table.schema[key].type === constants_1.FieldTypes.NUMBER) &&
+                    existingTableSchema[key].type === constants_1.FieldTypes.BOOLEAN)) {
                 table.schema[key] = existingTableSchema[key];
             }
         }
@@ -156,18 +159,18 @@ function copyExistingPropsOver(tableName, table, entities) {
     return table;
 }
 function finaliseExternalTables(tables, entities) {
-    const invalidColumns = Object.values(InvalidColumns);
+    const invalidColumns = Object.values(constants_1.InvalidColumns);
     let finalTables = {};
     const errors = {};
     for (let [name, table] of Object.entries(tables)) {
         const schemaFields = Object.keys(table.schema);
         // make sure every table has a key
         if (table.primary == null || table.primary.length === 0) {
-            errors[name] = BuildSchemaErrors.NO_KEY;
+            errors[name] = constants_1.BuildSchemaErrors.NO_KEY;
             continue;
         }
         else if (schemaFields.find(field => invalidColumns.includes(field))) {
-            errors[name] = BuildSchemaErrors.INVALID_COLUMN;
+            errors[name] = constants_1.BuildSchemaErrors.INVALID_COLUMN;
             continue;
         }
         // make sure all previous props have been added back

package/dist/middleware/authorized.js

@@ -8,8 +8,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-const { getUserRoleHierarchy, getRequiredResourceRole, BUILTIN_ROLE_IDS, } = require("@budibase/auth/roles");
-const { PermissionTypes, doesHaveBasePermission, } = require("@budibase/auth/permissions");
+const { getUserRoleHierarchy, getRequiredResourceRole, BUILTIN_ROLE_IDS, } = require("@budibase/backend-core/roles");
+const { PermissionTypes, doesHaveBasePermission, } = require("@budibase/backend-core/permissions");
 const builderMiddleware = require("./builder");
 const { isWebhookEndpoint } = require("./utils");
 function hasResource(ctx) {

package/dist/middleware/builder.js

@@ -12,8 +12,8 @@ const { APP_DEV_PREFIX } = require("../db/utils");
 const { doesUserHaveLock, updateLock, checkDebounce, setDebounce, } = require("../utilities/redis");
 const CouchDB = require("../db");
 const { DocumentTypes } = require("../db/utils");
-const { PermissionTypes } = require("@budibase/auth/permissions");
-const { app: appCache } = require("@budibase/auth/cache");
+const { PermissionTypes } = require("@budibase/backend-core/permissions");
+const { app: appCache } = require("@budibase/backend-core/cache");
 const DEBOUNCE_TIME_SEC = 30;
 /************************************************** *
  * This middleware has been broken out of the       *

package/dist/middleware/currentapp.js

@@ -8,13 +8,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-const { getAppId, setCookie, getCookie, clearCookie } = require("@budibase/auth").utils;
-const { Cookies } = require("@budibase/auth").constants;
-const { getRole } = require("@budibase/auth/roles");
-const { BUILTIN_ROLE_IDS } = require("@budibase/auth/roles");
+const { getAppId, setCookie, getCookie, clearCookie, } = require("@budibase/backend-core/utils");
+const { Cookies } = require("@budibase/backend-core/constants");
+const { getRole } = require("@budibase/backend-core/roles");
+const { BUILTIN_ROLE_IDS } = require("@budibase/backend-core/roles");
 const { generateUserMetadataID, isDevAppID } = require("../db/utils");
-const { dbExists } = require("@budibase/auth/db");
-const { isUserInAppTenant } = require("@budibase/auth/tenancy");
+const { dbExists } = require("@budibase/backend-core/db");
+const { isUserInAppTenant } = require("@budibase/backend-core/tenancy");
 const { getCachedSelf } = require("../utilities/global");
 const CouchDB = require("../db");
 const env = require("../environment");
@@ -49,6 +49,15 @@ module.exports = (ctx, next) => __awaiter(void 0, void 0, void 0, function* () {
         !isWebhookEndpoint(ctx) &&
         (!ctx.user || !ctx.user.builder || !ctx.user.builder.global)) {
         clearCookie(ctx, Cookies.CurrentApp);
+        // have to set the return url on the server side as client side is not available
+        setCookie(ctx, ctx.url, Cookies.RETURN_URL, {
+            // don't sign so the browser can easily read
+            sign: false,
+            // use the request domain to match how ui handles the return url cookie.
+            // it's important we don't use the shared domain here as the builder
+            // can't delete from it without awareness of the domain.
+            requestDomain: true,
+        });
         return ctx.redirect("/");
     }
     let appId, roleId = BUILTIN_ROLE_IDS.PUBLIC;

package/dist/middleware/usageQuota.js

@@ -11,7 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 const CouchDB = require("../db");
 const usageQuota = require("../utilities/usageQuota");
 const env = require("../environment");
-const { getTenantId } = require("@budibase/auth/tenancy");
+const { getTenantId } = require("@budibase/backend-core/tenancy");
 const { isExternalTable, isRowId: isExternalRowId, } = require("../integrations/utils");
 // tenants without limits
 const EXCLUDED_TENANTS = ["bb", "default", "bbtest", "bbstaging"];

package/dist/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@budibase/server",
     "email": "hi@budibase.com",
-    "version": "1.0.27-alpha.1",
+    "version": "1.0.27-alpha.22",
     "description": "Budibase Web Server",
     "main": "src/index.ts",
     "repository": {
@@ -70,9 +70,9 @@
     "license": "GPL-3.0",
     "dependencies": {
         "@apidevtools/swagger-parser": "^10.0.3",
-        "@budibase/auth": "^1.0.27-alpha.1",
-        "@budibase/client": "^1.0.27-alpha.1",
-        "@budibase/string-templates": "^1.0.27-alpha.1",
+        "@budibase/backend-core": "^1.0.27-alpha.22",
+        "@budibase/client": "^1.0.27-alpha.22",
+        "@budibase/string-templates": "^1.0.27-alpha.22",
         "@bull-board/api": "^3.7.0",
         "@bull-board/koa": "^3.7.0",
         "@elastic/elasticsearch": "7.10.0",
@@ -122,6 +122,7 @@
         "pouchdb-replication-stream": "1.2.9",
         "server-destroy": "1.0.1",
         "svelte": "^3.38.2",
+        "swagger-parser": "^10.0.3",
         "to-json-schema": "0.2.5",
         "uuid": "3.3.2",
         "validate.js": "0.13.1",

package/dist/tests/utilities/TestConfiguration.js

@@ -8,20 +8,20 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-const { BUILTIN_ROLE_IDS } = require("@budibase/auth/roles");
+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");
 const controllers = require("./controllers");
 const supertest = require("supertest");
 const { cleanup } = require("../../utilities/fileSystem");
-const { Cookies, Headers } = require("@budibase/auth").constants;
-const { jwt } = require("@budibase/auth").auth;
-const auth = require("@budibase/auth");
-const { getGlobalDB } = require("@budibase/auth/tenancy");
-const { createASession } = require("@budibase/auth/sessions");
-const { user: userCache } = require("@budibase/auth/cache");
+const { Cookies, Headers } = require("@budibase/backend-core/constants");
+const { jwt } = require("@budibase/backend-core/auth");
+const core = require("@budibase/backend-core");
+const { getGlobalDB } = require("@budibase/backend-core/tenancy");
+const { createASession } = require("@budibase/backend-core/sessions");
+const { user: userCache } = require("@budibase/backend-core/cache");
 const CouchDB = require("../../db");
-auth.init(CouchDB);
+core.init(CouchDB);
 const GLOBAL_USER_ID = "us_uuid1";
 const EMAIL = "babs@babs.com";
 class TestConfiguration {
@@ -294,6 +294,53 @@ class TestConfiguration {
             return this.datasource;
         });
     }
+    updateDatasource(datasource) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this._req(datasource, { datasourceId: datasource._id }, controllers.datasource.update);
+            this.datasource = response.datasource;
+            return this.datasource;
+        });
+    }
+    restDatasource(cfg) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.createDatasource({
+                datasource: Object.assign(Object.assign({}, basicDatasource().datasource), { source: "REST", config: cfg || {} }),
+            });
+        });
+    }
+    dynamicVariableDatasource() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let datasource = yield this.restDatasource();
+            const basedOnQuery = yield this.createQuery(Object.assign(Object.assign({}, basicQuery(datasource._id)), { fields: {
+                    path: "www.google.com",
+                } }));
+            datasource = yield this.updateDatasource(Object.assign(Object.assign({}, datasource), { config: {
+                    dynamicVariables: [
+                        {
+                            queryId: basedOnQuery._id,
+                            name: "variable3",
+                            value: "{{ data.0.[value] }}",
+                        },
+                    ],
+                } }));
+            return { datasource, query: basedOnQuery };
+        });
+    }
+    previewQuery(request, config, datasource, fields) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return request
+                .post(`/api/queries/preview`)
+                .send({
+                datasourceId: datasource._id,
+                parameters: {},
+                fields,
+                queryVerb: "read",
+            })
+                .set(config.defaultHeaders())
+                .expect("Content-Type", /json/)
+                .expect(200);
+        });
+    }
     createQuery(config = null) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.datasource && !config) {

package/dist/tests/utilities/structures.js

@@ -1,6 +1,6 @@
 "use strict";
-const { BUILTIN_ROLE_IDS } = require("@budibase/auth/roles");
-const { BUILTIN_PERMISSION_IDS } = require("@budibase/auth/permissions");
+const { BUILTIN_ROLE_IDS } = require("@budibase/backend-core/roles");
+const { BUILTIN_PERMISSION_IDS } = require("@budibase/backend-core/permissions");
 const { createHomeScreen } = require("../../constants/screens");
 const { EMPTY_LAYOUT } = require("../../constants/layouts");
 const { cloneDeep } = require("lodash/fp");

package/dist/threads/automation.js

@@ -14,10 +14,10 @@ const actions = require("../automations/actions");
 const automationUtils = require("../automations/automationUtils");
 const AutomationEmitter = require("../events/AutomationEmitter");
 const { processObject } = require("@budibase/string-templates");
-const { DEFAULT_TENANT_ID } = require("@budibase/auth").constants;
+const { DEFAULT_TENANT_ID } = require("@budibase/backend-core/constants");
 const CouchDB = require("../db");
 const { DocumentTypes, isDevAppID } = require("../db/utils");
-const { doInTenant } = require("@budibase/auth/tenancy");
+const { doInTenant } = require("@budibase/backend-core/tenancy");
 const usage = require("../utilities/usageQuota");
 const { definitions: triggerDefs } = require("../automations/triggerInfo");
 const FILTER_STEP_ID = actions.ACTION_DEFINITIONS.FILTER.stepId;

package/dist/threads/query.js

@@ -8,63 +8,208 @@ 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");
+const IS_TRIPLE_BRACE = new RegExp(/^{{3}.*}{3}$/);
+const IS_HANDLEBARS = new RegExp(/^{{2}.*}{2}$/);
+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.pagination = input.pagination;
+        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;
     }
-    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 }));
+    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();
+            let query = this.enrichQueryFields(fields, parameters);
+            // Add pagination values for REST queries
+            if (this.pagination) {
+                query.paginationValues = this.pagination;
+            }
+            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, pagination = undefined;
+            if (threadUtils.hasExtraData(output)) {
+                rows = output.data;
+                info = output.info;
+                extra = output.extra;
+                pagination = output.pagination;
+            }
+            // 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, pagination };
+        });
+    }
+    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;
+        });
+    }
+    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];
+            }
         }
-        // get all the potential fields in the schema
-        let keys = rows.flatMap(Object.keys);
-        if (integration.end) {
-            integration.end();
+        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 { rows, keys, info, extra };
-    });
+        return enrichedQuery;
+    }
 }
 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);
     })