@budibase/server 0.9.174 → 0.9.176-alpha.2

package/dist/api/controllers/datasource.js

@@ -10,8 +10,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 const CouchDB = require("../../db");
 const { generateDatasourceID, getDatasourceParams, getQueryParams, DocumentTypes, BudibaseInternalDB, getTableParams, } = require("../../db/utils");
+const { BuildSchemaErrors } = require("../../constants");
 const { integrations } = require("../../integrations");
-const { makeExternalQuery } = require("./row/utils");
+const { getDatasourceAndQuery } = require("./row/utils");
 exports.fetch = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
         const database = new CouchDB(ctx.appId);
@@ -33,11 +34,15 @@ exports.buildSchemaFromDb = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
         const db = new CouchDB(ctx.appId);
         const datasource = yield db.get(ctx.params.datasourceId);
-        const tables = yield buildSchemaHelper(datasource);
+        const { tables, error } = yield buildSchemaHelper(datasource);
         datasource.entities = tables;
-        const response = yield db.put(datasource);
-        datasource._rev = response.rev;
-        ctx.body = datasource;
+        const dbResp = yield db.put(datasource);
+        datasource._rev = dbResp.rev;
+        const response = { datasource };
+        if (error) {
+            response.error = error;
+        }
+        ctx.body = response;
     });
 };
 exports.update = function (ctx) {
@@ -57,7 +62,7 @@ exports.update = function (ctx) {
         }
         ctx.status = 200;
         ctx.message = "Datasource saved successfully.";
-        ctx.body = datasource;
+        ctx.body = { datasource };
     });
 };
 exports.save = function (ctx) {
@@ -66,12 +71,14 @@ exports.save = function (ctx) {
         const plus = ctx.request.body.datasource.plus;
         const fetchSchema = ctx.request.body.fetchSchema;
         const datasource = Object.assign({ _id: generateDatasourceID({ plus }), type: plus ? DocumentTypes.DATASOURCE_PLUS : DocumentTypes.DATASOURCE }, ctx.request.body.datasource);
+        let schemaError = null;
         if (fetchSchema) {
-            let tables = yield buildSchemaHelper(datasource);
+            const { tables, error } = yield buildSchemaHelper(datasource);
+            schemaError = error;
             datasource.entities = tables;
         }
-        const response = yield db.put(datasource);
-        datasource._rev = response.rev;
+        const dbResp = yield db.put(datasource);
+        datasource._rev = dbResp.rev;
         // Drain connection pools when configuration is changed
         if (datasource.source) {
             const source = integrations[datasource.source];
@@ -79,9 +86,11 @@ exports.save = function (ctx) {
                 yield source.pool.end();
             }
         }
-        ctx.status = 200;
-        ctx.message = "Datasource saved successfully.";
-        ctx.body = datasource;
+        const response = { datasource };
+        if (schemaError) {
+            response.error = schemaError;
+        }
+        ctx.body = response;
     });
 };
 exports.destroy = function (ctx) {
@@ -107,7 +116,7 @@ exports.query = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
         const queryJson = ctx.request.body;
         try {
-            ctx.body = yield makeExternalQuery(ctx.appId, queryJson);
+            ctx.body = yield getDatasourceAndQuery(ctx.appId, queryJson);
         }
         catch (err) {
             ctx.throw(400, err);
@@ -120,5 +129,23 @@ const buildSchemaHelper = (datasource) => __awaiter(void 0, void 0, void 0, func
     const connector = new Connector(datasource.config);
     yield connector.buildSchema(datasource._id, datasource.entities);
     datasource.entities = connector.tables;
-    return connector.tables;
+    // make sure they all have a display name selected
+    for (let entity of Object.values(datasource.entities)) {
+        if (entity.primaryDisplay) {
+            continue;
+        }
+        const notAutoColumn = Object.values(entity.schema).find(schema => !schema.autocolumn);
+        if (notAutoColumn) {
+            entity.primaryDisplay = notAutoColumn.name;
+        }
+    }
+    const errors = connector.schemaErrors;
+    let error = null;
+    if (errors && Object.keys(errors).length > 0) {
+        const noKeyTables = Object.entries(errors)
+            .filter(entry => entry[1] === BuildSchemaErrors.NO_KEY)
+            .map(([name]) => name);
+        error = `No primary key constraint found for the following: ${noKeyTables.join(", ")}`;
+    }
+    return { tables: connector.tables, error };
 });

package/dist/api/controllers/query.js

@@ -95,7 +95,9 @@ function enrichQueryFields(fields, parameters = {}) {
             }
             else if (typeof fields[key] === "string") {
                 // enrich string value as normal
-                enrichedQuery[key] = yield processString(fields[key], parameters);
+                enrichedQuery[key] = yield processString(fields[key], parameters, {
+                    noHelpers: true,
+                });
             }
             else {
                 enrichedQuery[key] = fields[key];

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

@@ -24,12 +24,13 @@ const datasource_1 = require("../../../definitions/datasource");
 const utils_1 = require("../../../integrations/utils");
 var External;
 (function (External) {
-    const { makeExternalQuery } = require("./utils");
+    const { getDatasourceAndQuery } = require("./utils");
     const { DataSourceOperation, FieldTypes, RelationshipTypes, } = require("../../../constants");
     const { breakExternalTableId, isSQL } = require("../../../integrations/utils");
     const { processObjectSync } = require("@budibase/string-templates");
     const { cloneDeep } = require("lodash/fp");
     const CouchDB = require("../../../db");
+    const { processFormulas } = require("../../../utilities/rowProcessor/utils");
     function buildFilters(id, filters, table) {
         const primary = table.primary;
         // if passed in array need to copy for shifting etc
@@ -182,7 +183,7 @@ var External;
             let newRow = {}, manyRelationships = [];
             for (let [key, field] of Object.entries(table.schema)) {
                 // if set already, or not set just skip it
-                if ((!row[key] && row[key] !== "") || newRow[key] || field.autocolumn) {
+                if (row[key] == null || newRow[key] || field.autocolumn || field.type === FieldTypes.FORMULA) {
                     continue;
                 }
                 // if its an empty string then it means return the column to null (if possible)
@@ -295,7 +296,7 @@ var External;
                 // do this at end once its been added to the final rows
                 finalRows = this.updateRelationshipColumns(row, finalRows, relationships);
             }
-            return Object.values(finalRows);
+            return processFormulas(table, Object.values(finalRows));
         }
         /**
          * Gets the list of relationship JSON structures based on the columns in the table,
@@ -359,7 +360,7 @@ var External;
                     const tableId = isMany ? field.through : field.tableId;
                     const manyKey = field.throughFrom || primaryKey;
                     const fieldName = isMany ? manyKey : field.fieldName;
-                    const response = yield makeExternalQuery(this.appId, {
+                    const response = yield getDatasourceAndQuery(this.appId, {
                         endpoint: getEndpoint(tableId, DataSourceOperation.READ),
                         filters: {
                             equal: {
@@ -403,7 +404,7 @@ var External;
                         ? DataSourceOperation.UPDATE
                         : DataSourceOperation.CREATE;
                     if (!found) {
-                        promises.push(makeExternalQuery(appId, {
+                        promises.push(getDatasourceAndQuery(appId, {
                             endpoint: getEndpoint(tableId, operation),
                             // if we're doing many relationships then we're writing, only one response
                             body,
@@ -430,7 +431,7 @@ var External;
                                 ? DataSourceOperation.DELETE
                                 : DataSourceOperation.UPDATE;
                             const body = isMany ? null : { [colName]: null };
-                            promises.push(makeExternalQuery(this.appId, {
+                            promises.push(getDatasourceAndQuery(this.appId, {
                                 endpoint: getEndpoint(tableId, op),
                                 body,
                                 filters,
@@ -449,13 +450,14 @@ var External;
          * is more performant and has the added benefit of protecting against this scenario.
          */
         buildFields(table, includeRelations = datasource_1.IncludeRelationships.INCLUDE) {
-            function extractNonLinkFieldNames(table, existing = []) {
+            function extractRealFields(table, existing = []) {
                 return Object.entries(table.schema)
                     .filter(column => column[1].type !== FieldTypes.LINK &&
+                    column[1].type !== FieldTypes.FORMULA &&
                     !existing.find((field) => field === column[0]))
                     .map(column => `${table.name}.${column[0]}`);
             }
-            let fields = extractNonLinkFieldNames(table);
+            let fields = extractRealFields(table);
             for (let field of Object.values(table.schema)) {
                 if (field.type !== FieldTypes.LINK || !includeRelations) {
                     continue;
@@ -463,7 +465,7 @@ var External;
                 const { tableName: linkTableName } = breakExternalTableId(field.tableId);
                 const linkTable = this.tables[linkTableName];
                 if (linkTable) {
-                    const linkedFields = extractNonLinkFieldNames(linkTable, fields);
+                    const linkedFields = extractRealFields(linkTable, fields);
                     fields = fields.concat(linkedFields);
                 }
             }
@@ -521,7 +523,7 @@ var External;
                     },
                 };
                 // can't really use response right now
-                const response = yield makeExternalQuery(appId, json);
+                const response = yield getDatasourceAndQuery(appId, json);
                 // handle many to many relationships now if we know the ID (could be auto increment)
                 if (operation !== DataSourceOperation.READ &&
                     processed.manyRelationships) {

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;

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

@@ -0,0 +1,222 @@
+"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, } = require("./utils");
+const { DataSourceOperation, FieldTypes, RelationshipTypes, } = require("../../../constants");
+const { makeExternalQuery } = require("../../../integrations/base/utils");
+const { cloneDeep } = require("lodash/fp");
+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
+        delete table.dataImport;
+        const datasourceId = getDatasourceId(ctx.request.body);
+        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);
+        }
+        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);
+        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;
+    });
+};

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,120 +53,24 @@ 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.validateCSVSchema = function (ctx) {