@budibase/server 0.9.174 → 0.9.176-alpha.2

package/dist/api/controllers/table/internal.js

@@ -0,0 +1,138 @@
+"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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+const CouchDB = require("../../../db");
+const linkRows = require("../../../db/linkedRows");
+const { getRowParams, generateTableID } = require("../../../db/utils");
+const { FieldTypes } = require("../../../constants");
+const { TableSaveFunctions } = require("./utils");
+exports.save = function (ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const appId = ctx.appId;
+        const db = new CouchDB(appId);
+        const _a = ctx.request.body, { dataImport } = _a, rest = __rest(_a, ["dataImport"]);
+        let tableToSave = Object.assign({ type: "table", _id: generateTableID(), views: {} }, rest);
+        // if the table obj had an _id then it will have been retrieved
+        let oldTable;
+        if (ctx.request.body && ctx.request.body._id) {
+            oldTable = yield db.get(ctx.request.body._id);
+        }
+        // saving a table is a complex operation, involving many different steps, this
+        // has been broken out into a utility to make it more obvious/easier to manipulate
+        const tableSaveFunctions = new TableSaveFunctions({
+            db,
+            ctx,
+            oldTable,
+            dataImport,
+        });
+        tableToSave = yield tableSaveFunctions.before(tableToSave);
+        // make sure that types don't change of a column, have to remove
+        // the column if you want to change the type
+        if (oldTable && oldTable.schema) {
+            for (let propKey of Object.keys(tableToSave.schema)) {
+                let column = tableToSave.schema[propKey];
+                let oldColumn = oldTable.schema[propKey];
+                if (oldColumn && oldColumn.type === "internal") {
+                    oldColumn.type = "auto";
+                }
+                if (oldColumn && oldColumn.type !== column.type) {
+                    ctx.throw(400, "Cannot change the type of a column");
+                }
+            }
+        }
+        // Don't rename if the name is the same
+        let { _rename } = tableToSave;
+        /* istanbul ignore next */
+        if (_rename && _rename.old === _rename.updated) {
+            _rename = null;
+            delete tableToSave._rename;
+        }
+        // rename row fields when table column is renamed
+        /* istanbul ignore next */
+        if (_rename && tableToSave.schema[_rename.updated].type === FieldTypes.LINK) {
+            ctx.throw(400, "Cannot rename a linked column.");
+        }
+        tableToSave = yield tableSaveFunctions.mid(tableToSave);
+        // update schema of non-statistics views when new columns are added
+        for (let view in tableToSave.views) {
+            const tableView = tableToSave.views[view];
+            if (!tableView)
+                continue;
+            if (tableView.schema.group || tableView.schema.field)
+                continue;
+            tableView.schema = tableToSave.schema;
+        }
+        // update linked rows
+        try {
+            const linkResp = yield linkRows.updateLinks({
+                appId,
+                eventType: oldTable
+                    ? linkRows.EventType.TABLE_UPDATED
+                    : linkRows.EventType.TABLE_SAVE,
+                table: tableToSave,
+                oldTable: oldTable,
+            });
+            if (linkResp != null && linkResp._rev) {
+                tableToSave._rev = linkResp._rev;
+            }
+        }
+        catch (err) {
+            ctx.throw(400, err);
+        }
+        // don't perform any updates until relationships have been
+        // checked by the updateLinks function
+        const updatedRows = tableSaveFunctions.getUpdatedRows();
+        if (updatedRows && updatedRows.length !== 0) {
+            yield db.bulkDocs(updatedRows);
+        }
+        const result = yield db.put(tableToSave);
+        tableToSave._rev = result.rev;
+        tableToSave = yield tableSaveFunctions.after(tableToSave);
+        return tableToSave;
+    });
+};
+exports.destroy = function (ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const appId = ctx.appId;
+        const db = new CouchDB(appId);
+        const tableToDelete = yield db.get(ctx.params.tableId);
+        // Delete all rows for that table
+        const rows = yield db.allDocs(getRowParams(ctx.params.tableId, null, {
+            include_docs: true,
+        }));
+        yield db.bulkDocs(rows.rows.map(row => (Object.assign(Object.assign({}, row.doc), { _deleted: true }))));
+        // update linked rows
+        yield linkRows.updateLinks({
+            appId,
+            eventType: linkRows.EventType.TABLE_DELETE,
+            table: tableToDelete,
+        });
+        // don't remove the table itself until very end
+        yield db.remove(tableToDelete);
+        // remove table search index
+        const currentIndexes = yield db.getIndexes();
+        const existingIndex = currentIndexes.indexes.find(existing => existing.name === `search:${ctx.params.tableId}`);
+        if (existingIndex) {
+            yield db.deleteIndex(existingIndex);
+        }
+        return tableToDelete;
+    });
+};

package/dist/api/controllers/table/utils.js

@@ -277,4 +277,21 @@ exports.checkForViewUpdates = (db, table, rename, deletedColumns) => __awaiter(v
         }
     }
 });
+exports.generateForeignKey = (column, relatedTable) => {
+    return `fk_${relatedTable.name}_${column.fieldName}`;
+};
+exports.generateJunctionTableName = (column, table, relatedTable) => {
+    return `jt_${table.name}_${relatedTable.name}_${column.name}_${column.fieldName}`;
+};
+exports.foreignKeyStructure = (keyName, meta = null) => {
+    const structure = {
+        type: FieldTypes.NUMBER,
+        constraints: {},
+        name: keyName,
+    };
+    if (meta) {
+        structure.meta = meta;
+    }
+    return structure;
+};
 exports.TableSaveFunctions = TableSaveFunctions;

package/dist/constants/index.js

@@ -56,6 +56,9 @@ exports.DataSourceOperation = {
     READ: "READ",
     UPDATE: "UPDATE",
     DELETE: "DELETE",
+    CREATE_TABLE: "CREATE_TABLE",
+    UPDATE_TABLE: "UPDATE_TABLE",
+    DELETE_TABLE: "DELETE_TABLE",
 };
 exports.SortDirection = {
     ASCENDING: "ASCENDING",
@@ -140,5 +143,8 @@ exports.MetadataTypes = {
     AUTOMATION_TEST_INPUT: "automationTestInput",
     AUTOMATION_TEST_HISTORY: "automationTestHistory",
 };
+exports.BuildSchemaErrors = {
+    NO_KEY: "no_key",
+};
 // pass through the list from the auth/core lib
 exports.ObjectStoreBuckets = ObjectStoreBuckets;

package/dist/definitions/datasource.js

@@ -7,6 +7,9 @@ var Operation;
     Operation["READ"] = "READ";
     Operation["UPDATE"] = "UPDATE";
     Operation["DELETE"] = "DELETE";
+    Operation["CREATE_TABLE"] = "CREATE_TABLE";
+    Operation["UPDATE_TABLE"] = "UPDATE_TABLE";
+    Operation["DELETE_TABLE"] = "DELETE_TABLE";
 })(Operation = exports.Operation || (exports.Operation = {}));
 var SortDirection;
 (function (SortDirection) {

package/dist/integrations/base/datasourcePlus.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/integrations/base/sql.js

@@ -1,11 +1,18 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const knex_1 = require("knex");
-const BASE_LIMIT = 5000;
 const datasource_1 = require("../../definitions/datasource");
 const utils_1 = require("../utils");
+const sqlTable_1 = __importDefault(require("./sqlTable"));
+const BASE_LIMIT = 5000;
 function parseBody(body) {
     for (let [key, value] of Object.entries(body)) {
+        if (Array.isArray(value)) {
+            body[key] = JSON.stringify(value);
+        }
         if (typeof value !== "string") {
             continue;
         }
@@ -192,19 +199,12 @@ function buildDelete(knex, json, opts) {
         return query.delete().returning("*");
     }
 }
-class SqlQueryBuilder {
+class SqlQueryBuilder extends sqlTable_1.default {
     // pass through client to get flavour of SQL
     constructor(client, limit = BASE_LIMIT) {
-        this.sqlClient = client;
+        super(client);
         this.limit = limit;
     }
-    /**
-     * @param json the input JSON structure from which an SQL query will be built.
-     * @return {string} the operation that was found in the JSON.
-     */
-    _operation(json) {
-        return json.endpoint.operation;
-    }
     /**
      * @param json The JSON query DSL which is to be converted to SQL.
      * @param opts extra options which are to be passed into the query builder, e.g. disableReturning
@@ -212,7 +212,8 @@ class SqlQueryBuilder {
      * @return {{ sql: string, bindings: object }} the query ready to be passed to the driver.
      */
     _query(json, opts = {}) {
-        const client = knex_1.knex({ client: this.sqlClient });
+        const sqlClient = this.getSqlClient();
+        const client = knex_1.knex({ client: sqlClient });
         let query;
         switch (this._operation(json)) {
             case datasource_1.Operation.CREATE:
@@ -227,6 +228,10 @@ class SqlQueryBuilder {
             case datasource_1.Operation.DELETE:
                 query = buildDelete(client, json, opts);
                 break;
+            case datasource_1.Operation.CREATE_TABLE:
+            case datasource_1.Operation.UPDATE_TABLE:
+            case datasource_1.Operation.DELETE_TABLE:
+                return this._tableQuery(json);
             default:
                 throw `Operation type is not supported by SQL query builder`;
         }

package/dist/integrations/base/sqlTable.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const knex_1 = require("knex");
+const datasource_1 = require("../../definitions/datasource");
+const utils_1 = require("../utils");
+const { FieldTypes, RelationshipTypes } = require("../../constants");
+function generateSchema(schema, table, tables, oldTable = null) {
+    let primaryKey = table && table.primary ? table.primary[0] : null;
+    const columns = Object.values(table.schema);
+    // all columns in a junction table will be meta
+    let metaCols = columns.filter(col => col.meta);
+    let isJunction = metaCols.length === columns.length;
+    // can't change primary once its set for now
+    if (primaryKey && !oldTable && !isJunction) {
+        schema.increments(primaryKey).primary();
+    }
+    else if (!oldTable && isJunction) {
+        schema.primary(metaCols.map(col => col.name));
+    }
+    // check if any columns need added
+    const foreignKeys = Object.values(table.schema).map(col => col.foreignKey);
+    for (let [key, column] of Object.entries(table.schema)) {
+        // skip things that are already correct
+        const oldColumn = oldTable ? oldTable.schema[key] : null;
+        if ((oldColumn && oldColumn.type === column.type) || (primaryKey === key && !isJunction)) {
+            continue;
+        }
+        switch (column.type) {
+            case FieldTypes.STRING:
+            case FieldTypes.OPTIONS:
+            case FieldTypes.LONGFORM:
+                schema.string(key);
+                break;
+            case FieldTypes.NUMBER:
+                // if meta is specified then this is a junction table entry
+                if (column.meta && column.meta.toKey && column.meta.toTable) {
+                    const { toKey, toTable } = column.meta;
+                    schema.integer(key).unsigned();
+                    schema.foreign(key).references(`${toTable}.${toKey}`);
+                }
+                else if (foreignKeys.indexOf(key) === -1) {
+                    schema.float(key);
+                }
+                break;
+            case FieldTypes.BOOLEAN:
+                schema.boolean(key);
+                break;
+            case FieldTypes.DATETIME:
+                schema.datetime(key);
+                break;
+            case FieldTypes.ARRAY:
+                schema.json(key);
+                break;
+            case FieldTypes.LINK:
+                // this side of the relationship doesn't need any SQL work
+                if (column.relationshipType !== RelationshipTypes.MANY_TO_ONE &&
+                    column.relationshipType !== RelationshipTypes.MANY_TO_MANY) {
+                    if (!column.foreignKey || !column.tableId) {
+                        throw "Invalid relationship schema";
+                    }
+                    const { tableName } = utils_1.breakExternalTableId(column.tableId);
+                    // @ts-ignore
+                    const relatedTable = tables[tableName];
+                    if (!relatedTable) {
+                        throw "Referenced table doesn't exist";
+                    }
+                    schema.integer(column.foreignKey).unsigned();
+                    schema.foreign(column.foreignKey).references(`${tableName}.${relatedTable.primary[0]}`);
+                }
+                break;
+        }
+    }
+    // need to check if any columns have been deleted
+    if (oldTable) {
+        const deletedColumns = Object.entries(oldTable.schema)
+            .filter(([key, schema]) => schema.type !== FieldTypes.LINK && table.schema[key] == null)
+            .map(([key]) => key);
+        deletedColumns.forEach(key => {
+            if (oldTable.constrained && oldTable.constrained.indexOf(key) !== -1) {
+                schema.dropForeign(key);
+            }
+            schema.dropColumn(key);
+        });
+    }
+    return schema;
+}
+function buildCreateTable(knex, table, tables) {
+    return knex.schema.createTable(table.name, schema => {
+        generateSchema(schema, table, tables);
+    });
+}
+function buildUpdateTable(knex, table, tables, oldTable) {
+    return knex.schema.alterTable(table.name, schema => {
+        generateSchema(schema, table, tables, oldTable);
+    });
+}
+function buildDeleteTable(knex, table) {
+    return knex.schema.dropTable(table.name);
+}
+class SqlTableQueryBuilder {
+    // pass through client to get flavour of SQL
+    constructor(client) {
+        this.sqlClient = client;
+    }
+    getSqlClient() {
+        return this.sqlClient;
+    }
+    /**
+     * @param json the input JSON structure from which an SQL query will be built.
+     * @return {string} the operation that was found in the JSON.
+     */
+    _operation(json) {
+        return json.endpoint.operation;
+    }
+    _tableQuery(json) {
+        const client = knex_1.knex({ client: this.sqlClient });
+        let query;
+        if (!json.table || !json.meta || !json.meta.tables) {
+            throw "Cannot execute without table being specified";
+        }
+        switch (this._operation(json)) {
+            case datasource_1.Operation.CREATE_TABLE:
+                query = buildCreateTable(client, json.table, json.meta.tables);
+                break;
+            case datasource_1.Operation.UPDATE_TABLE:
+                if (!json.meta || !json.meta.table) {
+                    throw "Must specify old table for update";
+                }
+                query = buildUpdateTable(client, json.table, json.meta.tables, json.meta.table);
+                break;
+            case datasource_1.Operation.DELETE_TABLE:
+                query = buildDeleteTable(client, json.table);
+                break;
+            default:
+                throw "Table operation is of unknown type";
+        }
+        return query.toSQL();
+    }
+}
+exports.default = SqlTableQueryBuilder;
+module.exports = SqlTableQueryBuilder;

package/dist/integrations/base/utils.js

@@ -0,0 +1,30 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var DatasourceUtils;
+(function (DatasourceUtils) {
+    const { integrations } = require("../index");
+    function makeExternalQuery(datasource, json) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const Integration = integrations[datasource.source];
+            // query is the opinionated function
+            if (Integration.prototype.query) {
+                const integration = new Integration(datasource.config);
+                return integration.query(json);
+            }
+            else {
+                throw "Datasource does not support query.";
+            }
+        });
+    }
+    DatasourceUtils.makeExternalQuery = makeExternalQuery;
+    module.exports.makeExternalQuery = makeExternalQuery;
+})(DatasourceUtils || (DatasourceUtils = {}));

package/dist/integrations/mysql.js

@@ -15,7 +15,7 @@ var MySQLModule;
 (function (MySQLModule) {
     const mysql = require("mysql2");
     const Sql = require("./base/sql");
-    const { buildExternalTableId, convertType, copyExistingPropsOver, } = require("./utils");
+    const { buildExternalTableId, convertType, finaliseExternalTables, } = require("./utils");
     const { FieldTypes } = require("../constants");
     const TYPE_MAP = {
         text: FieldTypes.LONGFORM,
@@ -112,6 +112,8 @@ var MySQLModule;
     class MySQLIntegration extends Sql {
         constructor(config) {
             super("mysql");
+            this.tables = {};
+            this.schemaErrors = {};
             this.config = config;
             if (config.ssl && Object.keys(config.ssl).length === 0) {
                 delete config.ssl;
@@ -148,10 +150,6 @@ var MySQLModule;
                             constraints,
                         };
                     }
-                    // for now just default to first column
-                    if (primaryKeys.length === 0) {
-                        primaryKeys.push(descResp[0].Field);
-                    }
                     if (!tables[tableName]) {
                         tables[tableName] = {
                             _id: buildExternalTableId(datasourceId, tableName),
@@ -160,10 +158,11 @@ var MySQLModule;
                             schema,
                         };
                     }
-                    copyExistingPropsOver(tableName, tables, entities);
                 }
                 this.client.end();
-                this.tables = tables;
+                const final = finaliseExternalTables(tables, entities);
+                this.tables = final.tables;
+                this.schemaErrors = final.errors;
             });
         }
         create(query) {
@@ -225,6 +224,13 @@ var MySQLModule;
                 const operation = this._operation(json);
                 this.client.connect();
                 const input = this._query(json, { disableReturning: true });
+                if (Array.isArray(input)) {
+                    const responses = [];
+                    for (let query of input) {
+                        responses.push(yield internalQuery(this.client, query, false));
+                    }
+                    return responses;
+                }
                 let row;
                 // need to manage returning, a feature mySQL can't do
                 if (operation === operation.DELETE) {

package/dist/integrations/postgres.js

@@ -16,7 +16,7 @@ var PostgresModule;
     const { Pool } = require("pg");
     const Sql = require("./base/sql");
     const { FieldTypes } = require("../constants");
-    const { buildExternalTableId, convertType, copyExistingPropsOver, } = require("./utils");
+    const { buildExternalTableId, convertType, finaliseExternalTables, } = require("./utils");
     const { escapeDangerousCharacters } = require("../utilities");
     const JSON_REGEX = /'{.*}'::json/s;
     const SCHEMA = {
@@ -121,6 +121,8 @@ var PostgresModule;
     class PostgresIntegration extends Sql {
         constructor(config) {
             super("pg");
+            this.tables = {};
+            this.schemaErrors = {};
             this.COLUMNS_SQL = "select * from information_schema.columns where not table_schema = 'information_schema' and not table_schema = 'pg_catalog'";
             this.PRIMARY_KEYS_SQL = `
     select tc.table_schema, tc.table_name, kc.column_name as primary_key 
@@ -177,7 +179,7 @@ var PostgresModule;
                     if (!tables[tableName] || !tables[tableName].schema) {
                         tables[tableName] = {
                             _id: buildExternalTableId(datasourceId, tableName),
-                            primary: tableKeys[tableName] || ["id"],
+                            primary: tableKeys[tableName] || [],
                             name: tableName,
                             schema: {},
                         };
@@ -196,10 +198,9 @@ var PostgresModule;
                         type,
                     };
                 }
-                for (let tableName of Object.keys(tables)) {
-                    copyExistingPropsOver(tableName, tables, entities);
-                }
-                this.tables = tables;
+                const final = finaliseExternalTables(tables, entities);
+                this.tables = final.tables;
+                this.schemaErrors = final.errors;
             });
         }
         create(query) {
@@ -230,8 +231,17 @@ var PostgresModule;
             return __awaiter(this, void 0, void 0, function* () {
                 const operation = this._operation(json).toLowerCase();
                 const input = this._query(json);
-                const response = yield internalQuery(this.client, input);
-                return response.rows.length ? response.rows : [{ [operation]: true }];
+                if (Array.isArray(input)) {
+                    const responses = [];
+                    for (let query of input) {
+                        responses.push(yield internalQuery(this.client, query));
+                    }
+                    return responses;
+                }
+                else {
+                    const response = yield internalQuery(this.client, input);
+                    return response.rows.length ? response.rows : [{ [operation]: true }];
+                }
             });
         }
     }

package/dist/integrations/utils.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.copyExistingPropsOver = exports.isIsoDateString = exports.isSQL = exports.getSqlQuery = exports.convertType = exports.breakRowIdField = exports.convertRowId = exports.isRowId = exports.generateRowIdField = exports.breakExternalTableId = exports.buildExternalTableId = exports.isExternalTable = void 0;
+exports.finaliseExternalTables = exports.isIsoDateString = exports.isSQL = exports.getSqlQuery = exports.convertType = exports.breakRowIdField = exports.convertRowId = exports.isRowId = exports.generateRowIdField = exports.breakExternalTableId = exports.buildExternalTableId = exports.isExternalTable = void 0;
 const datasource_1 = require("../definitions/datasource");
 const { DocumentTypes, SEPARATOR } = require("../db/utils");
-const { FieldTypes } = require("../constants");
+const { FieldTypes, BuildSchemaErrors } = require("../constants");
 const DOUBLE_SEPARATOR = `${SEPARATOR}${SEPARATOR}`;
 const ROW_ID_REGEX = /^\[.*]$/g;
 function isExternalTable(tableId) {
@@ -101,10 +101,10 @@ function isIsoDateString(str) {
 }
 exports.isIsoDateString = isIsoDateString;
 // add the existing relationships from the entities if they exist, to prevent them from being overridden
-function copyExistingPropsOver(tableName, tables, entities) {
+function copyExistingPropsOver(tableName, table, entities) {
     if (entities && entities[tableName]) {
         if (entities[tableName].primaryDisplay) {
-            tables[tableName].primaryDisplay = entities[tableName].primaryDisplay;
+            table.primaryDisplay = entities[tableName].primaryDisplay;
         }
         const existingTableSchema = entities[tableName].schema;
         for (let key in existingTableSchema) {
@@ -112,9 +112,24 @@ function copyExistingPropsOver(tableName, tables, entities) {
                 continue;
             }
             if (existingTableSchema[key].type === "link") {
-                tables[tableName].schema[key] = existingTableSchema[key];
+                table.schema[key] = existingTableSchema[key];
             }
         }
     }
+    return table;
 }
-exports.copyExistingPropsOver = copyExistingPropsOver;
+function finaliseExternalTables(tables, entities) {
+    const finalTables = {};
+    const errors = {};
+    for (let [name, table] of Object.entries(tables)) {
+        // make sure every table has a key
+        if (table.primary == null || table.primary.length === 0) {
+            errors[name] = BuildSchemaErrors.NO_KEY;
+            continue;
+        }
+        // make sure all previous props have been added back
+        finalTables[name] = copyExistingPropsOver(name, table, entities);
+    }
+    return { tables: finalTables, errors };
+}
+exports.finaliseExternalTables = finaliseExternalTables;

package/dist/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@budibase/server",
     "email": "hi@budibase.com",
-    "version": "0.9.173",
+    "version": "0.9.176-alpha.1",
     "description": "Budibase Web Server",
     "main": "src/index.js",
     "repository": {
@@ -68,9 +68,9 @@
     "author": "Budibase",
     "license": "AGPL-3.0-or-later",
     "dependencies": {
-        "@budibase/auth": "^0.9.173",
-        "@budibase/client": "^0.9.173",
-        "@budibase/string-templates": "^0.9.173",
+        "@budibase/auth": "^0.9.176-alpha.1",
+        "@budibase/client": "^0.9.176-alpha.1",
+        "@budibase/string-templates": "^0.9.176-alpha.1",
         "@elastic/elasticsearch": "7.10.0",
         "@koa/router": "8.0.0",
         "@sendgrid/mail": "7.1.1",

package/dist/tests/utilities/TestConfiguration.js

@@ -289,7 +289,8 @@ class TestConfiguration {
     createDatasource(config = null) {
         return __awaiter(this, void 0, void 0, function* () {
             config = config || basicDatasource();
-            this.datasource = yield this._req(config, null, controllers.datasource.save);
+            const response = yield this._req(config, null, controllers.datasource.save);
+            this.datasource = response.datasource;
             return this.datasource;
         });
     }