@budibase/server 0.9.188 → 0.9.190-alpha.10

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,146 @@
+"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 oldColumn = oldTable.schema[propKey];
+                if (oldColumn && oldColumn.type === "internal") {
+                    oldColumn.type = "auto";
+                }
+            }
+        }
+        // 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;
+    });
+};

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

@@ -14,7 +14,7 @@ const { getRowParams, generateRowID, InternalTables, } = require("../../../db/ut
 const { isEqual } = require("lodash/fp");
 const { AutoFieldSubTypes, FieldTypes } = require("../../../constants");
 const { inputProcessing } = require("../../../utilities/rowProcessor");
-const { USERS_TABLE_SCHEMA } = require("../../../constants");
+const { USERS_TABLE_SCHEMA, SwitchableTypes } = require("../../../constants");
 const { isExternalTable, breakExternalTableId, } = require("../../../integrations/utils");
 const { getViews, saveView } = require("../view/utils");
 const viewTemplate = require("../view/viewBuilder");
@@ -66,37 +66,38 @@ exports.makeSureTableUpToDate = (table, tableToSave) => {
     return tableToSave;
 };
 exports.handleDataImport = (appId, user, table, dataImport) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!dataImport || !dataImport.csvString) {
+        return table;
+    }
     const db = new CouchDB(appId);
-    if (dataImport && dataImport.csvString) {
-        // Populate the table with rows imported from CSV in a bulk update
-        const data = yield csvParser.transform(dataImport);
-        let finalData = [];
-        for (let i = 0; i < data.length; i++) {
-            let row = data[i];
-            row._id = generateRowID(table._id);
-            row.tableId = table._id;
-            const processed = inputProcessing(user, table, row, {
-                noAutoRelationships: true,
-            });
-            table = processed.table;
-            row = processed.row;
-            for (let [fieldName, schema] of Object.entries(table.schema)) {
-                // check whether the options need to be updated for inclusion as part of the data import
-                if (schema.type === FieldTypes.OPTIONS &&
-                    (!schema.constraints.inclusion ||
-                        schema.constraints.inclusion.indexOf(row[fieldName]) === -1)) {
-                    schema.constraints.inclusion = [
-                        ...schema.constraints.inclusion,
-                        row[fieldName],
-                    ];
-                }
+    // Populate the table with rows imported from CSV in a bulk update
+    const data = yield csvParser.transform(Object.assign(Object.assign({}, dataImport), { existingTable: table }));
+    let finalData = [];
+    for (let i = 0; i < data.length; i++) {
+        let row = data[i];
+        row._id = generateRowID(table._id);
+        row.tableId = table._id;
+        const processed = inputProcessing(user, table, row, {
+            noAutoRelationships: true,
+        });
+        table = processed.table;
+        row = processed.row;
+        for (let [fieldName, schema] of Object.entries(table.schema)) {
+            // check whether the options need to be updated for inclusion as part of the data import
+            if (schema.type === FieldTypes.OPTIONS &&
+                (!schema.constraints.inclusion ||
+                    schema.constraints.inclusion.indexOf(row[fieldName]) === -1)) {
+                schema.constraints.inclusion = [
+                    ...schema.constraints.inclusion,
+                    row[fieldName],
+                ];
             }
-            finalData.push(row);
         }
-        yield db.bulkDocs(finalData);
-        let response = yield db.put(table);
-        table._rev = response._rev;
+        finalData.push(row);
     }
+    yield db.bulkDocs(finalData);
+    let response = yield db.put(table);
+    table._rev = response._rev;
     return table;
 });
 exports.handleSearchIndexes = (appId, table) => __awaiter(void 0, void 0, void 0, function* () {
@@ -277,4 +278,37 @@ 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.hasTypeChanged = (table, oldTable) => {
+    if (!oldTable) {
+        return false;
+    }
+    for (let [key, field] of Object.entries(oldTable.schema)) {
+        const oldType = field.type;
+        if (!table.schema[key]) {
+            continue;
+        }
+        const newType = table.schema[key].type;
+        if (oldType !== newType && SwitchableTypes.indexOf(oldType) === -1) {
+            return true;
+        }
+    }
+    return false;
+};
 exports.TableSaveFunctions = TableSaveFunctions;

package/dist/api/controllers/user.js

@@ -11,22 +11,132 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 const CouchDB = require("../../db");
 const { generateUserMetadataID, getUserMetadataParams, } = require("../../db/utils");
 const { InternalTables } = require("../../db/utils");
-const { getGlobalUsers } = require("../../utilities/global");
+const { getGlobalUsers, getRawGlobalUser } = require("../../utilities/global");
 const { getFullUser } = require("../../utilities/users");
-function removeGlobalProps(user) {
-    // make sure to always remove some of the global user props
-    delete user.password;
-    delete user.roles;
-    delete user.builder;
-    return user;
+const { isEqual } = require("lodash");
+const { BUILTIN_ROLE_IDS } = require("@budibase/auth/roles");
+const { getDevelopmentAppID, getDeployedAppIDs } = require("@budibase/auth/db");
+const { doesDatabaseExist } = require("../../utilities");
+const { UserStatus } = require("@budibase/auth/constants");
+function rawMetadata(db) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return (yield db.allDocs(getUserMetadataParams(null, {
+            include_docs: true,
+        }))).rows.map(row => row.doc);
+    });
+}
+function combineMetadataAndUser(user, metadata) {
+    // skip users with no access
+    if (user.roleId === BUILTIN_ROLE_IDS.PUBLIC) {
+        return null;
+    }
+    delete user._rev;
+    const metadataId = generateUserMetadataID(user._id);
+    const newDoc = Object.assign(Object.assign({}, user), { _id: metadataId, tableId: InternalTables.USER_METADATA });
+    const found = Array.isArray(metadata)
+        ? metadata.find(doc => doc._id === metadataId)
+        : metadata;
+    // copy rev over for the purposes of equality check
+    if (found) {
+        newDoc._rev = found._rev;
+    }
+    if (found == null || !isEqual(newDoc, found)) {
+        return Object.assign(Object.assign({}, found), newDoc);
+    }
+    return null;
 }
+exports.syncGlobalUsers = (appId) => __awaiter(void 0, void 0, void 0, function* () {
+    // sync user metadata
+    const db = new CouchDB(appId);
+    const [users, metadata] = yield Promise.all([
+        getGlobalUsers(appId),
+        rawMetadata(db),
+    ]);
+    const toWrite = [];
+    for (let user of users) {
+        const combined = yield combineMetadataAndUser(user, metadata);
+        if (combined) {
+            toWrite.push(combined);
+        }
+    }
+    yield db.bulkDocs(toWrite);
+});
+exports.syncUser = function (ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let deleting = false, user;
+        const userId = ctx.params.id;
+        try {
+            user = yield getRawGlobalUser(userId);
+        }
+        catch (err) {
+            if (err && err.status === 404) {
+                user = {};
+                deleting = true;
+            }
+            else {
+                throw err;
+            }
+        }
+        const roles = user.roles;
+        // remove props which aren't useful to metadata
+        delete user.password;
+        delete user.forceResetPassword;
+        delete user.roles;
+        // run through all production appIDs in the users roles
+        let prodAppIds;
+        // if they are a builder then get all production app IDs
+        if ((user.builder && user.builder.global) || deleting) {
+            prodAppIds = yield getDeployedAppIDs(CouchDB);
+        }
+        else {
+            prodAppIds = Object.entries(roles)
+                .filter(entry => entry[1] !== BUILTIN_ROLE_IDS.PUBLIC)
+                .map(([appId]) => appId);
+        }
+        for (let prodAppId of prodAppIds) {
+            const roleId = roles[prodAppId];
+            const devAppId = getDevelopmentAppID(prodAppId);
+            for (let appId of [prodAppId, devAppId]) {
+                if (!(yield doesDatabaseExist(appId))) {
+                    continue;
+                }
+                const db = new CouchDB(appId);
+                const metadataId = generateUserMetadataID(userId);
+                let metadata;
+                try {
+                    metadata = yield db.get(metadataId);
+                }
+                catch (err) {
+                    if (deleting) {
+                        continue;
+                    }
+                    metadata = {
+                        tableId: InternalTables.USER_METADATA,
+                    };
+                }
+                // assign the roleId for the metadata doc
+                if (roleId) {
+                    metadata.roleId = roleId;
+                }
+                let combined = !deleting
+                    ? combineMetadataAndUser(user, metadata)
+                    : Object.assign(Object.assign({}, metadata), { status: UserStatus.INACTIVE, metadata: BUILTIN_ROLE_IDS.PUBLIC });
+                // if its null then there was no updates required
+                if (combined) {
+                    yield db.put(combined);
+                }
+            }
+        }
+        ctx.body = {
+            message: "User synced.",
+        };
+    });
+};
 exports.fetchMetadata = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
         const database = new CouchDB(ctx.appId);
         const global = yield getGlobalUsers(ctx.appId);
-        const metadata = (yield database.allDocs(getUserMetadataParams(null, {
-            include_docs: true,
-        }))).rows.map(row => row.doc);
+        const metadata = yield rawMetadata(database);
         const users = [];
         for (let user of global) {
             // find the metadata that matches up to the global ID
@@ -52,7 +162,9 @@ exports.updateMetadata = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
         const appId = ctx.appId;
         const db = new CouchDB(appId);
-        const user = removeGlobalProps(ctx.request.body);
+        const user = ctx.request.body;
+        // this isn't applicable to the user
+        delete user.roles;
         const metadata = Object.assign({ tableId: InternalTables.USER_METADATA }, user);
         ctx.body = yield db.put(metadata);
     });

package/dist/api/controllers/view/exporters.js

@@ -15,3 +15,7 @@ exports.csv = function (headers, rows) {
 exports.json = function (headers, rows) {
     return JSON.stringify(rows, undefined, 2);
 };
+exports.ExportFormats = {
+    CSV: "csv",
+    JSON: "json",
+};

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

@@ -25,6 +25,7 @@ const { apiFileReturn } = require("../../../utilities/fileSystem");
 const exporters = require("./exporters");
 const { saveView, getView, getViews, deleteView } = require("./utils");
 const { fetchView } = require("../row");
+const { getTable } = require("../table/utils");
 exports.fetch = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
     const db = new CouchDB(ctx.appId);
     ctx.body = yield getViews(db);
@@ -65,7 +66,7 @@ exports.exportView = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
     const viewName = decodeURI(ctx.query.view);
     const view = yield getView(db, viewName);
     const format = ctx.query.format;
-    if (!format) {
+    if (!format || !Object.values(exporters.ExportFormats).includes(format)) {
         ctx.throw(400, "Format must be specified, either csv or json");
     }
     if (view) {
@@ -87,9 +88,20 @@ exports.exportView = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
     let schema = view && view.meta && view.meta.schema;
     if (!schema) {
         const tableId = ctx.params.tableId || view.meta.tableId;
-        const table = yield db.get(tableId);
+        const table = yield getTable(ctx.appId, tableId);
         schema = table.schema;
     }
+    // make sure no "undefined" entries appear in the CSV
+    if (format === exporters.ExportFormats.CSV) {
+        const schemaKeys = Object.keys(schema);
+        for (let key of schemaKeys) {
+            for (let row of ctx.body) {
+                if (row[key] == null) {
+                    row[key] = "";
+                }
+            }
+        }
+    }
     // Export part
     let headers = Object.keys(schema);
     const exporter = exporters[format];

package/dist/api/routes/query.js

@@ -41,7 +41,7 @@ router
     .get("/api/queries", authorized(BUILDER), queryController.fetch)
     .post("/api/queries", bodySubResource("datasourceId", "_id"), authorized(BUILDER), generateQueryValidation(), queryController.save)
     .post("/api/queries/preview", bodyResource("datasourceId"), authorized(BUILDER), generateQueryPreviewValidation(), queryController.preview)
-    .get("/api/queries/:queryId", authorized(PermissionTypes.QUERY, PermissionLevels.READ), queryController.find)
+    .get("/api/queries/:queryId", paramResource("queryId"), authorized(PermissionTypes.QUERY, PermissionLevels.READ), queryController.find)
     .post("/api/queries/:queryId", paramResource("queryId"), authorized(PermissionTypes.QUERY, PermissionLevels.WRITE), queryController.execute)
     .delete("/api/queries/:queryId/:revId", paramResource("queryId"), authorized(BUILDER), queryController.destroy);
 module.exports = router;