@budibase/server 0.9.188 → 0.9.190-alpha.2

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

@@ -14,8 +14,8 @@ const CouchDB = require("../../../db");
 const { InternalTables } = require("../../../db/utils");
 const userController = require("../user");
 const { FieldTypes } = require("../../../constants");
-const { integrations } = require("../../../integrations");
 const { processStringSync } = require("@budibase/string-templates");
+const { makeExternalQuery } = require("../../../integrations/base/utils");
 validateJs.extend(validateJs.validators.datetime, {
     parse: function (value) {
         return new Date(value).getTime();
@@ -25,19 +25,11 @@ validateJs.extend(validateJs.validators.datetime, {
         return new Date(value).toISOString();
     },
 });
-exports.makeExternalQuery = (appId, json) => __awaiter(void 0, void 0, void 0, function* () {
+exports.getDatasourceAndQuery = (appId, json) => __awaiter(void 0, void 0, void 0, function* () {
     const datasourceId = json.endpoint.datasourceId;
     const db = new CouchDB(appId);
     const datasource = yield db.get(datasourceId);
-    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.";
-    }
+    return makeExternalQuery(datasource, json);
 });
 exports.findRow = (ctx, db, tableId, rowId) => __awaiter(void 0, void 0, void 0, function* () {
     let row;
@@ -73,7 +65,9 @@ exports.validate = ({ appId, tableId, row, table }) => __awaiter(void 0, void 0,
         }
         let res;
         // Validate.js doesn't seem to handle array
-        if (table.schema[fieldName].type === FieldTypes.ARRAY) {
+        if (table.schema[fieldName].type === FieldTypes.ARRAY &&
+            row[fieldName] &&
+            row[fieldName].length) {
             row[fieldName].map(val => {
                 if (!constraints.inclusion.includes(val)) {
                     errors[fieldName] = "Field not in list";

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

@@ -0,0 +1,249 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+const CouchDB = require("../../../db");
+const { buildExternalTableId, breakExternalTableId, } = require("../../../integrations/utils");
+const { getTable, generateForeignKey, generateJunctionTableName, foreignKeyStructure, hasTypeChanged, } = require("./utils");
+const { DataSourceOperation, FieldTypes, RelationshipTypes, } = require("../../../constants");
+const { makeExternalQuery } = require("../../../integrations/base/utils");
+const { cloneDeep } = require("lodash/fp");
+const csvParser = require("../../../utilities/csvParser");
+const { handleRequest } = require("../row/external");
+function makeTableRequest(datasource, operation, table, tables, oldTable = null) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const json = {
+            endpoint: {
+                datasourceId: datasource._id,
+                entityId: table._id,
+                operation,
+            },
+            meta: {
+                tables,
+            },
+            table,
+        };
+        if (oldTable) {
+            json.meta.table = oldTable;
+        }
+        return makeExternalQuery(datasource, json);
+    });
+}
+function cleanupRelationships(table, tables, oldTable = null) {
+    const tableToIterate = oldTable ? oldTable : table;
+    // clean up relationships in couch table schemas
+    for (let [key, schema] of Object.entries(tableToIterate.schema)) {
+        if (schema.type === FieldTypes.LINK &&
+            (!oldTable || table.schema[key] == null)) {
+            const relatedTable = Object.values(tables).find(table => table._id === schema.tableId);
+            const foreignKey = schema.foreignKey;
+            if (!relatedTable || !foreignKey) {
+                continue;
+            }
+            for (let [relatedKey, relatedSchema] of Object.entries(relatedTable.schema)) {
+                if (relatedSchema.type === FieldTypes.LINK &&
+                    relatedSchema.fieldName === foreignKey) {
+                    delete relatedTable.schema[relatedKey];
+                }
+            }
+        }
+    }
+}
+function getDatasourceId(table) {
+    if (!table) {
+        throw "No table supplied";
+    }
+    if (table.sourceId) {
+        return table.sourceId;
+    }
+    return breakExternalTableId(table._id).datasourceId;
+}
+function otherRelationshipType(type) {
+    if (type === RelationshipTypes.MANY_TO_MANY) {
+        return RelationshipTypes.MANY_TO_MANY;
+    }
+    return type === RelationshipTypes.ONE_TO_MANY
+        ? RelationshipTypes.MANY_TO_ONE
+        : RelationshipTypes.ONE_TO_MANY;
+}
+function generateManyLinkSchema(datasource, column, table, relatedTable) {
+    const primary = table.name + table.primary[0];
+    const relatedPrimary = relatedTable.name + relatedTable.primary[0];
+    const jcTblName = generateJunctionTableName(column, table, relatedTable);
+    // first create the new table
+    const junctionTable = {
+        _id: buildExternalTableId(datasource._id, jcTblName),
+        name: jcTblName,
+        primary: [primary, relatedPrimary],
+        constrained: [primary, relatedPrimary],
+        schema: {
+            [primary]: foreignKeyStructure(primary, {
+                toTable: table.name,
+                toKey: table.primary[0],
+            }),
+            [relatedPrimary]: foreignKeyStructure(relatedPrimary, {
+                toTable: relatedTable.name,
+                toKey: relatedTable.primary[0],
+            }),
+        },
+    };
+    column.through = junctionTable._id;
+    column.throughFrom = primary;
+    column.throughTo = relatedPrimary;
+    column.fieldName = relatedPrimary;
+    return junctionTable;
+}
+function generateLinkSchema(column, table, relatedTable, type) {
+    const isOneSide = type === RelationshipTypes.ONE_TO_MANY;
+    const primary = isOneSide ? relatedTable.primary[0] : table.primary[0];
+    // generate a foreign key
+    const foreignKey = generateForeignKey(column, relatedTable);
+    column.relationshipType = type;
+    column.foreignKey = isOneSide ? foreignKey : primary;
+    column.fieldName = isOneSide ? primary : foreignKey;
+    return foreignKey;
+}
+function generateRelatedSchema(linkColumn, table, relatedTable, columnName) {
+    // generate column for other table
+    const relatedSchema = cloneDeep(linkColumn);
+    // swap them from the main link
+    if (linkColumn.foreignKey) {
+        relatedSchema.fieldName = linkColumn.foreignKey;
+        relatedSchema.foreignKey = linkColumn.fieldName;
+    }
+    // is many to many
+    else {
+        // don't need to copy through, already got it
+        relatedSchema.fieldName = linkColumn.throughFrom;
+        relatedSchema.throughTo = linkColumn.throughFrom;
+        relatedSchema.throughFrom = linkColumn.throughTo;
+    }
+    relatedSchema.relationshipType = otherRelationshipType(linkColumn.relationshipType);
+    relatedSchema.tableId = relatedTable._id;
+    relatedSchema.name = columnName;
+    table.schema[columnName] = relatedSchema;
+}
+function isRelationshipSetup(column) {
+    return column.foreignKey || column.through;
+}
+exports.save = function (ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const appId = ctx.appId;
+        const table = ctx.request.body;
+        // can't do this right now
+        delete table.dataImport;
+        const datasourceId = getDatasourceId(ctx.request.body);
+        // table doesn't exist already, note that it is created
+        if (!table._id) {
+            table.created = true;
+        }
+        let tableToSave = Object.assign({ type: "table", _id: buildExternalTableId(datasourceId, table.name) }, table);
+        let oldTable;
+        if (ctx.request.body && ctx.request.body._id) {
+            oldTable = yield getTable(appId, ctx.request.body._id);
+        }
+        if (hasTypeChanged(tableToSave, oldTable)) {
+            ctx.throw(400, "A column type has changed.");
+        }
+        const db = new CouchDB(appId);
+        const datasource = yield db.get(datasourceId);
+        const oldTables = cloneDeep(datasource.entities);
+        const tables = datasource.entities;
+        const extraTablesToUpdate = [];
+        // check if relations need setup
+        for (let schema of Object.values(tableToSave.schema)) {
+            if (schema.type !== FieldTypes.LINK || isRelationshipSetup(schema)) {
+                continue;
+            }
+            const relatedTable = Object.values(tables).find(table => table._id === schema.tableId);
+            const relatedColumnName = schema.fieldName;
+            const relationType = schema.relationshipType;
+            if (relationType === RelationshipTypes.MANY_TO_MANY) {
+                const junctionTable = generateManyLinkSchema(datasource, schema, table, relatedTable);
+                if (tables[junctionTable.name]) {
+                    throw "Junction table already exists, cannot create another relationship.";
+                }
+                tables[junctionTable.name] = junctionTable;
+                extraTablesToUpdate.push(junctionTable);
+            }
+            else {
+                const fkTable = relationType === RelationshipTypes.ONE_TO_MANY ? table : relatedTable;
+                const foreignKey = generateLinkSchema(schema, table, relatedTable, relationType);
+                fkTable.schema[foreignKey] = foreignKeyStructure(foreignKey);
+                if (fkTable.constrained == null) {
+                    fkTable.constrained = [];
+                }
+                if (fkTable.constrained.indexOf(foreignKey) === -1) {
+                    fkTable.constrained.push(foreignKey);
+                }
+                // foreign key is in other table, need to save it to external
+                if (fkTable._id !== table._id) {
+                    extraTablesToUpdate.push(fkTable);
+                }
+            }
+            generateRelatedSchema(schema, relatedTable, table, relatedColumnName);
+            schema.main = true;
+        }
+        cleanupRelationships(tableToSave, tables, oldTable);
+        const operation = oldTable
+            ? DataSourceOperation.UPDATE_TABLE
+            : DataSourceOperation.CREATE_TABLE;
+        yield makeTableRequest(datasource, operation, tableToSave, tables, oldTable);
+        // update any extra tables (like foreign keys in other tables)
+        for (let extraTable of extraTablesToUpdate) {
+            const oldExtraTable = oldTables[extraTable.name];
+            let op = oldExtraTable
+                ? DataSourceOperation.UPDATE_TABLE
+                : DataSourceOperation.CREATE_TABLE;
+            yield makeTableRequest(datasource, op, extraTable, tables, oldExtraTable);
+        }
+        // make sure the constrained list, all still exist
+        if (Array.isArray(tableToSave.constrained)) {
+            tableToSave.constrained = tableToSave.constrained.filter(constraint => Object.keys(tableToSave.schema).includes(constraint));
+        }
+        // store it into couch now for budibase reference
+        datasource.entities[tableToSave.name] = tableToSave;
+        yield db.put(datasource);
+        return tableToSave;
+    });
+};
+exports.destroy = function (ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const appId = ctx.appId;
+        const tableToDelete = yield getTable(appId, ctx.params.tableId);
+        if (!tableToDelete || !tableToDelete.created) {
+            ctx.throw(400, "Cannot delete tables which weren't created in Budibase.");
+        }
+        const datasourceId = getDatasourceId(tableToDelete);
+        const db = new CouchDB(appId);
+        const datasource = yield db.get(datasourceId);
+        const tables = datasource.entities;
+        const operation = DataSourceOperation.DELETE_TABLE;
+        yield makeTableRequest(datasource, operation, tableToDelete, tables);
+        cleanupRelationships(tableToDelete, tables);
+        delete datasource.entities[tableToDelete.name];
+        yield db.put(datasource);
+        return tableToDelete;
+    });
+};
+exports.bulkImport = function (ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const appId = ctx.appId;
+        const table = yield getTable(appId, ctx.params.tableId);
+        const { dataImport } = ctx.request.body;
+        if (!dataImport || !dataImport.schema || !dataImport.csvString) {
+            ctx.throw(400, "Provided data import information is invalid.");
+        }
+        const rows = yield csvParser.transform(Object.assign(Object.assign({}, dataImport), { existingTable: table }));
+        yield handleRequest(appId, DataSourceOperation.BULK_CREATE, table._id, {
+            rows,
+        });
+        return table;
+    });
+};

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

@@ -8,23 +8,26 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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 internal = require("./internal");
+const external = require("./external");
 const csvParser = require("../../../utilities/csvParser");
-const { getRowParams, getTableParams, generateTableID, getDatasourceParams, BudibaseInternalDB, } = require("../../../db/utils");
-const { FieldTypes } = require("../../../constants");
-const { TableSaveFunctions, getTable } = require("./utils");
+const { isExternalTable } = require("../../../integrations/utils");
+const { getTableParams, getDatasourceParams, BudibaseInternalDB, } = require("../../../db/utils");
+const { getTable } = require("./utils");
+function pickApi({ tableId, table }) {
+    if (table && !tableId) {
+        tableId = table._id;
+    }
+    if (table && table.type === "external") {
+        return external;
+    }
+    else if (tableId && isExternalTable(tableId)) {
+        return external;
+    }
+    return internal;
+}
+// covers both internal and external
 exports.fetch = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
         const db = new CouchDB(ctx.appId);
@@ -50,126 +53,49 @@ exports.find = function (ctx) {
 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);
-        ctx.eventEmitter &&
-            ctx.eventEmitter.emitTable(`table:save`, appId, tableToSave);
+        const table = ctx.request.body;
+        const savedTable = yield pickApi({ table }).save(ctx);
         ctx.status = 200;
-        ctx.message = `Table ${ctx.request.body.name} saved successfully.`;
-        ctx.body = tableToSave;
+        ctx.message = `Table ${table.name} saved successfully.`;
+        ctx.eventEmitter &&
+            ctx.eventEmitter.emitTable(`table:save`, appId, savedTable);
+        ctx.body = savedTable;
     });
 };
 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);
-        }
+        const tableId = ctx.params.tableId;
+        const deletedTable = yield pickApi({ tableId }).destroy(ctx);
         ctx.eventEmitter &&
-            ctx.eventEmitter.emitTable(`table:delete`, appId, tableToDelete);
+            ctx.eventEmitter.emitTable(`table:delete`, appId, deletedTable);
         ctx.status = 200;
-        ctx.body = { message: `Table ${ctx.params.tableId} deleted.` };
+        ctx.body = { message: `Table ${tableId} deleted.` };
+    });
+};
+exports.bulkImport = function (ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const tableId = ctx.params.tableId;
+        yield pickApi({ tableId }).bulkImport(ctx);
+        // right now we don't trigger anything for bulk import because it
+        // can only be done in the builder, but in the future we may need to
+        // think about events for bulk items
+        ctx.status = 200;
+        ctx.body = { message: `Bulk rows created.` };
     });
 };
 exports.validateCSVSchema = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
-        const { csvString, schema = {} } = ctx.request.body;
-        const result = yield csvParser.parse(csvString, schema);
+        // tableId being specified means its an import to an existing table
+        const { csvString, schema = {}, tableId } = ctx.request.body;
+        let existingTable;
+        if (tableId) {
+            existingTable = yield getTable(ctx.appId, tableId);
+        }
+        let result = yield csvParser.parse(csvString, schema);
+        if (existingTable) {
+            result = csvParser.updateSchema({ schema: result, existingTable });
+        }
         ctx.body = { schema: result };
     });
 };

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

@@ -0,0 +1,150 @@
+"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, hasTypeChanged, getTable, handleDataImport, } = 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);
+        }
+        if (hasTypeChanged(tableToSave, oldTable)) {
+            ctx.throw(400, "A column type has changed.");
+        }
+        // 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;
+    });
+};
+exports.bulkImport = function (ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const appId = ctx.appId;
+        const table = yield getTable(appId, ctx.params.tableId);
+        const { dataImport } = ctx.request.body;
+        yield handleDataImport(appId, ctx.user, table, dataImport);
+        return table;
+    });
+};