@budibase/server 0.9.185-alpha.2 → 0.9.185-alpha.20

package/dist/integrations/oracle.js

@@ -0,0 +1,345 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const datasource_1 = require("../definitions/datasource");
+const utils_1 = require("./utils");
+const oracledb_1 = __importDefault(require("oracledb"));
+const sql_1 = __importDefault(require("./base/sql"));
+const constants_1 = require("../constants");
+var OracleModule;
+(function (OracleModule) {
+    oracledb_1.default.outFormat = oracledb_1.default.OUT_FORMAT_OBJECT;
+    const SCHEMA = {
+        docs: "https://github.com/oracle/node-oracledb",
+        plus: true,
+        friendlyName: "Oracle",
+        description: "Oracle Database is an object-relational database management system developed by Oracle Corporation",
+        datasource: {
+            host: {
+                type: datasource_1.DatasourceFieldTypes.STRING,
+                default: "localhost",
+                required: true,
+            },
+            port: {
+                type: datasource_1.DatasourceFieldTypes.NUMBER,
+                required: true,
+                default: 1521,
+            },
+            database: {
+                type: datasource_1.DatasourceFieldTypes.STRING,
+                required: true,
+            },
+            user: {
+                type: datasource_1.DatasourceFieldTypes.STRING,
+                required: true,
+            },
+            password: {
+                type: datasource_1.DatasourceFieldTypes.PASSWORD,
+                required: true,
+            },
+        },
+        query: {
+            create: {
+                type: datasource_1.QueryTypes.SQL,
+            },
+            read: {
+                type: datasource_1.QueryTypes.SQL,
+            },
+            update: {
+                type: datasource_1.QueryTypes.SQL,
+            },
+            delete: {
+                type: datasource_1.QueryTypes.SQL,
+            },
+        },
+    };
+    const UNSUPPORTED_TYPES = ["BLOB", "CLOB", "NCLOB"];
+    const OracleContraintTypes = {
+        PRIMARY: "P",
+        NOT_NULL_OR_CHECK: "C",
+        FOREIGN_KEY: "R",
+        UNIQUE: "U",
+    };
+    class OracleIntegration extends sql_1.default {
+        constructor(config) {
+            super(utils_1.SqlClients.ORACLE);
+            this.tables = {};
+            this.schemaErrors = {};
+            this.COLUMNS_SQL = `
+      SELECT
+        tabs.table_name,
+        cols.column_name,
+        cols.data_type,
+        cols.data_default,
+        cols.column_id,
+        cons.constraint_name,
+        cons.constraint_type,
+        cons.r_constraint_name,
+        cons.search_condition
+      FROM
+        user_tables tabs
+      JOIN 
+        user_tab_columns cols
+        ON tabs.table_name = cols.table_name 
+      LEFT JOIN 
+        user_cons_columns col_cons
+        ON cols.column_name = col_cons.column_name
+        AND cols.table_name = col_cons.table_name
+      LEFT JOIN 
+        user_constraints cons
+        ON col_cons.constraint_name = cons.constraint_name
+        AND cons.table_name = cols.table_name
+      WHERE
+        (cons.status = 'ENABLED'
+          OR cons.status IS NULL)
+    `;
+            this.getConnection = () => __awaiter(this, void 0, void 0, function* () {
+                //connectString : "(DESCRIPTION =(ADDRESS = (PROTOCOL = TCP)(HOST = localhost)(PORT = 1521))(CONNECT_DATA =(SID= ORCL)))"
+                const connectString = `${this.config.host}:${this.config.port || 1521}/${this.config.database}`;
+                const attributes = {
+                    user: this.config.user,
+                    password: this.config.user,
+                    connectString,
+                };
+                return oracledb_1.default.getConnection(attributes);
+            });
+            this.config = config;
+        }
+        /**
+         * Map the flat tabular columns and constraints data into a nested object
+         */
+        mapColumns(result) {
+            const oracleTables = {};
+            if (result.rows) {
+                result.rows.forEach(row => {
+                    const tableName = row.TABLE_NAME;
+                    const columnName = row.COLUMN_NAME;
+                    const dataType = row.DATA_TYPE;
+                    const dataDefault = row.DATA_DEFAULT;
+                    const columnId = row.COLUMN_ID;
+                    const constraintName = row.CONSTRAINT_NAME;
+                    const constraintType = row.CONSTRAINT_TYPE;
+                    const relatedConstraintName = row.R_CONSTRAINT_NAME;
+                    const searchCondition = row.SEARCH_CONDITION;
+                    let table = oracleTables[tableName];
+                    if (!table) {
+                        table = {
+                            name: tableName,
+                            columns: {},
+                        };
+                        oracleTables[tableName] = table;
+                    }
+                    let column = table.columns[columnName];
+                    if (!column) {
+                        column = {
+                            name: columnName,
+                            type: dataType,
+                            default: dataDefault,
+                            id: columnId,
+                            constraints: {},
+                        };
+                        table.columns[columnName] = column;
+                    }
+                    if (constraintName && constraintType) {
+                        let constraint = column.constraints[constraintName];
+                        if (!constraint) {
+                            constraint = {
+                                name: constraintName,
+                                type: constraintType,
+                                relatedConstraintName: relatedConstraintName,
+                                searchCondition: searchCondition,
+                            };
+                        }
+                        column.constraints[constraintName] = constraint;
+                    }
+                });
+            }
+            return oracleTables;
+        }
+        isSupportedColumn(column) {
+            if (UNSUPPORTED_TYPES.includes(column.type)) {
+                return false;
+            }
+            return true;
+        }
+        isAutoColumn(column) {
+            if (column.default && column.default.toLowerCase().includes("nextval")) {
+                return true;
+            }
+            return false;
+        }
+        /**
+         * No native boolean in oracle. Best we can do is to check if a manual 1 or 0 number constraint has been set up
+         * This matches the default behaviour for generating DDL used in knex.
+         */
+        isBooleanType(column) {
+            if (column.type.toLowerCase() === "number" &&
+                Object.values(column.constraints).filter(c => {
+                    if (c.type === OracleContraintTypes.NOT_NULL_OR_CHECK &&
+                        c.searchCondition) {
+                        const condition = c.searchCondition
+                            .replace(/\s/g, "") // remove spaces
+                            .replace(/[']+/g, ""); // remove quotes
+                        if (condition.includes("in(0,1)") ||
+                            condition.includes("in(1,0)")) {
+                            return true;
+                        }
+                    }
+                    return false;
+                }).length > 0) {
+                return true;
+            }
+            return false;
+        }
+        internalConvertType(column) {
+            if (this.isBooleanType(column)) {
+                return constants_1.FieldTypes.BOOLEAN;
+            }
+            return utils_1.convertSqlType(column.type);
+        }
+        /**
+         * Fetches the tables from the oracle table and assigns them to the datasource.
+         * @param {*} datasourceId - datasourceId to fetch
+         * @param entities - the tables that are to be built
+         */
+        buildSchema(datasourceId, entities) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const columnsResponse = yield this.internalQuery({
+                    sql: this.COLUMNS_SQL,
+                });
+                const oracleTables = this.mapColumns(columnsResponse);
+                const tables = {};
+                // iterate each table
+                Object.values(oracleTables).forEach(oracleTable => {
+                    let table = tables[oracleTable.name];
+                    if (!table) {
+                        table = {
+                            _id: utils_1.buildExternalTableId(datasourceId, oracleTable.name),
+                            primary: [],
+                            name: oracleTable.name,
+                            schema: {},
+                        };
+                        tables[oracleTable.name] = table;
+                    }
+                    // iterate each column on the table
+                    Object.values(oracleTable.columns)
+                        // remove columns that we can't read / save
+                        .filter(oracleColumn => this.isSupportedColumn(oracleColumn))
+                        // match the order of the columns in the db
+                        .sort((c1, c2) => c1.id - c2.id)
+                        .forEach(oracleColumn => {
+                        const columnName = oracleColumn.name;
+                        let fieldSchema = table.schema[columnName];
+                        if (!fieldSchema) {
+                            fieldSchema = {
+                                autocolumn: this.isAutoColumn(oracleColumn),
+                                name: columnName,
+                                type: this.internalConvertType(oracleColumn),
+                            };
+                            table.schema[columnName] = fieldSchema;
+                        }
+                        // iterate each constraint on the column
+                        Object.values(oracleColumn.constraints).forEach(oracleConstraint => {
+                            if (oracleConstraint.type === OracleContraintTypes.PRIMARY) {
+                                table.primary.push(columnName);
+                            }
+                        });
+                    });
+                });
+                const final = utils_1.finaliseExternalTables(tables, entities);
+                this.tables = final.tables;
+                this.schemaErrors = final.errors;
+            });
+        }
+        /**
+         * Knex default returning behaviour does not work with oracle
+         * Manually add the behaviour for the return column
+         */
+        addReturning(query, bindings, returnColumn) {
+            if (bindings instanceof Array) {
+                bindings.push({ dir: oracledb_1.default.BIND_OUT });
+                query.sql = query.sql + ` returning \"${returnColumn}\" into :${bindings.length}`;
+            }
+        }
+        internalQuery(query, returnColum, operation) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let connection;
+                try {
+                    connection = yield this.getConnection();
+                    const options = { autoCommit: true };
+                    const bindings = query.bindings || [];
+                    if (returnColum && (operation === datasource_1.Operation.CREATE || operation === datasource_1.Operation.UPDATE)) {
+                        this.addReturning(query, bindings, returnColum);
+                    }
+                    const result = yield connection.execute(query.sql, bindings, options);
+                    return result;
+                }
+                finally {
+                    if (connection) {
+                        try {
+                            yield connection.close();
+                        }
+                        catch (err) {
+                            console.error(err);
+                        }
+                    }
+                }
+            });
+        }
+        create(query) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const response = yield this.internalQuery(utils_1.getSqlQuery(query));
+                return response.rows && response.rows.length
+                    ? response.rows
+                    : [{ created: true }];
+            });
+        }
+        read(query) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const response = yield this.internalQuery(utils_1.getSqlQuery(query));
+                return response.rows ? response.rows : [];
+            });
+        }
+        update(query) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const response = yield this.internalQuery(utils_1.getSqlQuery(query));
+                return response.rows && response.rows.length
+                    ? response.rows
+                    : [{ updated: true }];
+            });
+        }
+        delete(query) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const response = yield this.internalQuery(utils_1.getSqlQuery(query));
+                return response.rows && response.rows.length
+                    ? response.rows
+                    : [{ deleted: true }];
+            });
+        }
+        query(json) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const primaryKeys = json.meta.table.primary;
+                const primaryKey = primaryKeys ? primaryKeys[0] : undefined;
+                const queryFn = (query, operation) => this.internalQuery(query, primaryKey, operation);
+                const processFn = (response) => response.rows ? response.rows : [];
+                const output = yield this.queryWithReturning(json, queryFn, processFn);
+                return output;
+            });
+        }
+    }
+    module.exports = {
+        schema: SCHEMA,
+        integration: OracleIntegration,
+    };
+})(OracleModule || (OracleModule = {}));

package/dist/integrations/utils.js

@@ -3,7 +3,7 @@ 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 } = require("../constants");
+const { FieldTypes, BuildSchemaErrors, InvalidColumns } = require("../constants");
 const DOUBLE_SEPARATOR = `${SEPARATOR}${SEPARATOR}`;
 const ROW_ID_REGEX = /^\[.*]$/g;
 const SQL_TYPE_MAP = {
@@ -31,12 +31,17 @@ const SQL_TYPE_MAP = {
     fixed: FieldTypes.NUMBER,
     datetime: FieldTypes.DATETIME,
     tinyint: FieldTypes.BOOLEAN,
+    long: FieldTypes.LONGFORM,
+    number: FieldTypes.NUMBER,
+    binary_float: FieldTypes.NUMBER,
+    binary_double: FieldTypes.NUMBER,
 };
 var SqlClients;
 (function (SqlClients) {
     SqlClients["MS_SQL"] = "mssql";
     SqlClients["POSTGRES"] = "pg";
     SqlClients["MY_SQL"] = "mysql";
+    SqlClients["ORACLE"] = "oracledb";
 })(SqlClients = exports.SqlClients || (exports.SqlClients = {}));
 function isExternalTable(tableId) {
     return tableId.includes(DocumentTypes.DATASOURCE);
@@ -151,17 +156,27 @@ function copyExistingPropsOver(tableName, table, entities) {
     return table;
 }
 function finaliseExternalTables(tables, entities) {
-    const finalTables = {};
+    const invalidColumns = Object.values(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;
             continue;
         }
+        else if (schemaFields.find(field => invalidColumns.includes(field))) {
+            errors[name] = BuildSchemaErrors.INVALID_COLUMN;
+            continue;
+        }
         // make sure all previous props have been added back
         finalTables[name] = copyExistingPropsOver(name, table, entities);
     }
+    // sort the tables by name
+    finalTables = Object.entries(finalTables)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .reduce((r, [k, v]) => (Object.assign(Object.assign({}, r), { [k]: v })), {});
     return { tables: finalTables, errors };
 }
 exports.finaliseExternalTables = finaliseExternalTables;

package/dist/middleware/builder.js

@@ -13,6 +13,7 @@ const { doesUserHaveLock, updateLock, checkDebounce, setDebounce, } = require(".
 const CouchDB = require("../db");
 const { DocumentTypes } = require("../db/utils");
 const { PermissionTypes } = require("@budibase/auth/permissions");
+const { app: appCache } = require("@budibase/auth/cache");
 const DEBOUNCE_TIME_SEC = 30;
 /************************************************** *
  * This middleware has been broken out of the       *
@@ -51,7 +52,9 @@ function updateAppUpdatedAt(ctx) {
         const db = new CouchDB(appId);
         const metadata = yield db.get(DocumentTypes.APP_METADATA);
         metadata.updatedAt = new Date().toISOString();
-        yield db.put(metadata);
+        const response = yield db.put(metadata);
+        metadata._rev = response.rev;
+        yield appCache.invalidateAppMetadata(appId, metadata);
         // set a new debounce record with a short TTL
         yield setDebounce(appId, DEBOUNCE_TIME_SEC);
     });

package/dist/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@budibase/server",
     "email": "hi@budibase.com",
-    "version": "0.9.185-alpha.1",
+    "version": "0.9.185-alpha.19",
     "description": "Budibase Web Server",
     "main": "src/index.js",
     "repository": {
@@ -68,9 +68,11 @@
     "author": "Budibase",
     "license": "AGPL-3.0-or-later",
     "dependencies": {
-        "@budibase/auth": "^0.9.185-alpha.1",
-        "@budibase/client": "^0.9.185-alpha.1",
-        "@budibase/string-templates": "^0.9.185-alpha.1",
+        "@budibase/auth": "^0.9.185-alpha.19",
+        "@budibase/client": "^0.9.185-alpha.19",
+        "@budibase/string-templates": "^0.9.185-alpha.19",
+        "@bull-board/api": "^3.7.0",
+        "@bull-board/koa": "^3.7.0",
         "@elastic/elasticsearch": "7.10.0",
         "@koa/router": "8.0.0",
         "@sendgrid/mail": "7.1.1",
@@ -80,7 +82,6 @@
         "aws-sdk": "^2.767.0",
         "bcryptjs": "2.4.3",
         "bull": "^3.22.4",
-        "bull-board": "^2.0.1",
         "chmodr": "1.2.0",
         "csvtojson": "2.0.10",
         "dotenv": "8.2.0",
@@ -120,6 +121,7 @@
         "uuid": "3.3.2",
         "validate.js": "0.13.1",
         "vm2": "^3.9.3",
+        "worker-farm": "^1.7.0",
         "yargs": "13.2.4",
         "zlib": "1.0.5"
     },
@@ -133,12 +135,12 @@
         "@types/koa": "^2.13.3",
         "@types/koa-router": "^7.4.2",
         "@types/node": "^15.12.4",
+        "@types/oracledb": "^5.2.1",
         "@typescript-eslint/parser": "4.28.0",
         "babel-jest": "^27.0.2",
         "copyfiles": "^2.4.1",
         "docker-compose": "^0.23.6",
         "eslint": "^6.8.0",
-        "express": "^4.17.1",
         "jest": "^27.0.5",
         "nodemon": "^2.0.4",
         "prettier": "^2.3.1",
@@ -149,5 +151,8 @@
         "typescript": "^4.3.5",
         "update-dotenv": "^1.1.1"
     },
+    "optionalDependencies": {
+        "oracledb": "^5.3.0"
+    },
     "gitHead": "d1836a898cab3f8ab80ee6d8f42be1a9eed7dcdc"
 }

package/dist/{automations/thread.js → threads/automation.js}

@@ -8,17 +8,21 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-const actions = require("./actions");
-const automationUtils = require("./automationUtils");
+// when thread starts, make sure it is recorded
+const env = require("../environment");
+env.setInThread();
+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 CouchDB = require("../db");
 const { DocumentTypes, isDevAppID } = require("../db/utils");
 const { doInTenant } = require("@budibase/auth/tenancy");
-const env = require("../environment");
 const usage = require("../utilities/usageQuota");
+const { definitions: triggerDefs } = require("../automations/triggerInfo");
 const FILTER_STEP_ID = actions.ACTION_DEFINITIONS.FILTER.stepId;
+const CRON_STEP_ID = triggerDefs.CRON.stepId;
 const STOPPED_STATUS = { success: false, status: "STOPPED" };
 /**
  * The automation orchestrator is a class responsible for executing automations.
@@ -31,6 +35,8 @@ class Orchestrator {
         this._chainCount = this._metadata ? this._metadata.automationChainCount : 0;
         this._appId = triggerOutput.appId;
         this._app = null;
+        const triggerStepId = automation.definition.trigger.stepId;
+        triggerOutput = this.cleanupTriggerOutputs(triggerStepId, triggerOutput);
         // remove from context
         delete triggerOutput.appId;
         delete triggerOutput.metadata;
@@ -42,10 +48,15 @@ class Orchestrator {
         this._emitter = new AutomationEmitter(this._chainCount + 1);
         this.executionOutput = { trigger: {}, steps: [] };
         // setup the execution output
-        const triggerStepId = automation.definition.trigger.stepId;
         const triggerId = automation.definition.trigger.id;
         this.updateExecutionOutput(triggerId, triggerStepId, null, triggerOutput);
     }
+    cleanupTriggerOutputs(stepId, triggerOutput) {
+        if (stepId === CRON_STEP_ID) {
+            triggerOutput.timestamp = Date.now();
+        }
+        return triggerOutput;
+    }
     getStepFunctionality(stepId) {
         return __awaiter(this, void 0, void 0, function* () {
             let step = yield actions.getAction(stepId);
@@ -122,7 +133,14 @@ class Orchestrator {
         });
     }
 }
-module.exports = (job) => __awaiter(void 0, void 0, void 0, function* () {
-    const automationOrchestrator = new Orchestrator(job.data.automation, job.data.event);
-    return automationOrchestrator.execute();
-});
+module.exports = (input, callback) => {
+    const automationOrchestrator = new Orchestrator(input.data.automation, input.data.event);
+    automationOrchestrator
+        .execute()
+        .then(response => {
+        callback(null, response);
+    })
+        .catch(err => {
+        callback(err);
+    });
+};

package/dist/threads/index.js

@@ -0,0 +1,64 @@
+"use strict";
+const workerFarm = require("worker-farm");
+const env = require("../environment");
+const ThreadType = {
+    QUERY: "query",
+    AUTOMATION: "automation",
+};
+function typeToFile(type) {
+    let filename = null;
+    switch (type) {
+        case ThreadType.QUERY:
+            filename = "./query";
+            break;
+        case ThreadType.AUTOMATION:
+            filename = "./automation";
+            break;
+        default:
+            throw "Unknown thread type";
+    }
+    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();
+        if (!this.disableThreading) {
+            const workerOpts = {
+                autoStart: true,
+                maxConcurrentWorkers: this.count,
+            };
+            if (opts.timeoutMs) {
+                workerOpts.maxCallTime = opts.timeoutMs;
+            }
+            this.workers = workerFarm(workerOpts, typeToFile(type));
+        }
+    }
+    run(data) {
+        return new Promise((resolve, reject) => {
+            let fncToCall;
+            // if in test then don't use threading
+            if (this.disableThreading) {
+                fncToCall = require(typeToFile(this.type));
+            }
+            else {
+                fncToCall = this.workers;
+            }
+            fncToCall(data, (err, response) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(response);
+                }
+            });
+        });
+    }
+}
+module.exports.Thread = Thread;
+module.exports.ThreadType = ThreadType;

package/dist/threads/query.js

@@ -0,0 +1,64 @@
+"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());
+    });
+};
+// when thread starts, make sure it is recorded
+const env = require("../environment");
+env.setInThread();
+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 };
+        }
+    }
+    return resp;
+}
+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 rows = formatResponse(yield integration[queryVerb](query));
+        // 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 };
+    });
+}
+module.exports = (input, callback) => {
+    runAndTransform(input.datasource, input.queryVerb, input.query, input.transformer)
+        .then(response => {
+        callback(null, response);
+    })
+        .catch(err => {
+        callback(err);
+    });
+};