@budibase/server 0.9.140-alpha.1 → 0.9.140-alpha.5

package/dist/api/controllers/analytics.js

@@ -12,7 +12,7 @@ const env = require("../../environment");
 exports.isEnabled = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
         ctx.body = {
-            enabled: env.ENABLE_ANALYTICS === "true",
+            enabled: !env.SELF_HOSTED && env.ENABLE_ANALYTICS === "true",
         };
     });
 };

package/dist/api/controllers/datasource.js

@@ -39,7 +39,7 @@ exports.buildSchemaFromDb = function (ctx) {
         const connector = new Connector(datasource.config);
         yield connector.buildSchema(datasource._id, datasource.entities);
         datasource.entities = connector.tables;
-        const response = yield db.post(datasource);
+        const response = yield db.put(datasource);
         datasource._rev = response.rev;
         ctx.body = datasource;
     });
@@ -69,7 +69,7 @@ exports.save = function (ctx) {
         const db = new CouchDB(ctx.appId);
         const plus = ctx.request.body.plus;
         const datasource = Object.assign({ _id: generateDatasourceID({ plus }), type: plus ? DocumentTypes.DATASOURCE_PLUS : DocumentTypes.DATASOURCE }, ctx.request.body);
-        const response = yield db.post(datasource);
+        const response = yield db.put(datasource);
         datasource._rev = response.rev;
         // Drain connection pools when configuration is changed
         if (datasource.source) {

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

@@ -368,6 +368,10 @@ var External;
                 // finally cleanup anything that needs to be removed
                 for (let [colName, { isMany, rows, tableId }] of Object.entries(related)) {
                     const table = this.getTable(tableId);
+                    // if its not the foreign key skip it, nothing to do
+                    if (table.primary && table.primary.indexOf(colName) !== -1) {
+                        continue;
+                    }
                     for (let row of rows) {
                         const filters = buildFilters(generateIdForRow(row, table), {}, table);
                         // safety check, if there are no filters on deletion bad things happen

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

@@ -21,14 +21,17 @@ var __rest = (this && this.__rest) || function (s, e) {
 };
 const CouchDB = require("../../../db");
 const linkRows = require("../../../db/linkedRows");
-const { getRowParams, generateRowID, DocumentTypes, InternalTables, } = require("../../../db/utils");
+const { getRowParams, generateRowID, DocumentTypes, InternalTables, generateMemoryViewID, } = require("../../../db/utils");
 const userController = require("../user");
-const { inputProcessing, outputProcessing, } = require("../../../utilities/rowProcessor");
+const { inputProcessing, outputProcessing, processAutoColumn, } = require("../../../utilities/rowProcessor");
 const { FieldTypes } = require("../../../constants");
 const { isEqual } = require("lodash");
 const { validate, findRow } = require("./utils");
 const { fullSearch, paginatedSearch } = require("./internalSearch");
 const { getGlobalUsersFromMetadata } = require("../../../utilities/global");
+const inMemoryViews = require("../../../db/inMemoryView");
+const env = require("../../../environment");
+const { migrateToInMemoryView } = require("../view/utils");
 const CALCULATION_TYPES = {
     SUM: "sum",
     COUNT: "count",
@@ -37,17 +40,92 @@ const CALCULATION_TYPES = {
 function storeResponse(ctx, db, row, oldTable, table) {
     return __awaiter(this, void 0, void 0, function* () {
         row.type = "row";
-        const response = yield db.put(row);
         // don't worry about rev, tables handle rev/lastID updates
+        // if another row has been written since processing this will
+        // handle the auto ID clash
         if (!isEqual(oldTable, table)) {
-            yield db.put(table);
+            try {
+                yield db.put(table);
+            }
+            catch (err) {
+                if (err.status === 409) {
+                    const updatedTable = yield db.get(table._id);
+                    let response = processAutoColumn(null, updatedTable, row, {
+                        reprocessing: true,
+                    });
+                    yield db.put(response.table);
+                    row = response.row;
+                }
+                else {
+                    throw err;
+                }
+            }
         }
+        const response = yield db.put(row);
         row._rev = response.rev;
         // process the row before return, to include relationships
         row = yield outputProcessing(ctx, table, row, { squash: false });
         return { row, table };
     });
 }
+// doesn't do the outputProcessing
+function getRawTableData(ctx, db, tableId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let rows;
+        if (tableId === InternalTables.USER_METADATA) {
+            yield userController.fetchMetadata(ctx);
+            rows = ctx.body;
+        }
+        else {
+            const response = yield db.allDocs(getRowParams(tableId, null, {
+                include_docs: true,
+            }));
+            rows = response.rows.map(row => row.doc);
+        }
+        return rows;
+    });
+}
+function getView(db, viewName) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let viewInfo;
+        function getFromDesignDoc() {
+            return __awaiter(this, void 0, void 0, function* () {
+                const designDoc = yield db.get("_design/database");
+                viewInfo = designDoc.views[viewName];
+                return viewInfo;
+            });
+        }
+        let migrate = false;
+        if (env.SELF_HOSTED) {
+            viewInfo = yield getFromDesignDoc();
+        }
+        else {
+            try {
+                viewInfo = yield db.get(generateMemoryViewID(viewName));
+                if (viewInfo) {
+                    viewInfo = viewInfo.view;
+                }
+            }
+            catch (err) {
+                // check if it can be retrieved from design doc (needs migrated)
+                if (err.status !== 404) {
+                    viewInfo = null;
+                }
+                else {
+                    viewInfo = yield getFromDesignDoc();
+                    migrate = !!viewInfo;
+                }
+            }
+        }
+        if (migrate) {
+            yield migrateToInMemoryView(db, viewName);
+        }
+        if (!viewInfo) {
+            throw "View does not exist.";
+        }
+        return viewInfo;
+    });
+}
 exports.patch = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
     const appId = ctx.appId;
     const db = new CouchDB(appId);
@@ -142,15 +220,19 @@ exports.fetchView = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
     }
     const db = new CouchDB(appId);
     const { calculation, group, field } = ctx.query;
-    const designDoc = yield db.get("_design/database");
-    const viewInfo = designDoc.views[viewName];
-    if (!viewInfo) {
-        throw "View does not exist.";
+    const viewInfo = yield getView(db, viewName);
+    let response;
+    if (env.SELF_HOSTED) {
+        response = yield db.query(`database/${viewName}`, {
+            include_docs: !calculation,
+            group: !!group,
+        });
+    }
+    else {
+        const tableId = viewInfo.meta.tableId;
+        const data = yield getRawTableData(ctx, db, tableId);
+        response = yield inMemoryViews.runView(viewInfo, calculation, group, data);
     }
-    const response = yield db.query(`database/${viewName}`, {
-        include_docs: !calculation,
-        group: !!group,
-    });
     let rows;
     if (!calculation) {
         response.rows = response.rows.map(row => row.doc);
@@ -183,17 +265,9 @@ exports.fetchView = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
 exports.fetch = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
     const appId = ctx.appId;
     const db = new CouchDB(appId);
-    let rows, table = yield db.get(ctx.params.tableId);
-    if (ctx.params.tableId === InternalTables.USER_METADATA) {
-        yield userController.fetchMetadata(ctx);
-        rows = ctx.body;
-    }
-    else {
-        const response = yield db.allDocs(getRowParams(ctx.params.tableId, null, {
-            include_docs: true,
-        }));
-        rows = response.rows.map(row => row.doc);
-    }
+    const tableId = ctx.params.tableId;
+    let table = yield db.get(tableId);
+    let rows = yield getRawTableData(ctx, db, tableId);
     return outputProcessing(ctx, table, rows);
 });
 exports.find = (ctx) => __awaiter(void 0, void 0, void 0, function* () {

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

@@ -131,7 +131,7 @@ exports.save = function (ctx) {
         if (updatedRows && updatedRows.length !== 0) {
             yield db.bulkDocs(updatedRows);
         }
-        const result = yield db.post(tableToSave);
+        const result = yield db.put(tableToSave);
         tableToSave._rev = result.rev;
         tableToSave = yield tableSaveFunctions.after(tableToSave);
         ctx.eventEmitter &&

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

@@ -65,21 +65,16 @@ exports.handleDataImport = (appId, user, table, dataImport) => __awaiter(void 0,
     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);
+            const processed = inputProcessing(user, table, row, {
+                noAutoRelationships: true,
+            });
             table = processed.table;
             row = processed.row;
-            // make sure link rows are up to date
-            row = yield linkRows.updateLinks({
-                appId,
-                eventType: linkRows.EventType.ROW_SAVE,
-                row,
-                tableId: row.tableId,
-                table,
-            });
             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 &&
@@ -91,9 +86,16 @@ exports.handleDataImport = (appId, user, table, dataImport) => __awaiter(void 0,
                     ];
                 }
             }
-            data[i] = row;
+            // make sure link rows are up to date
+            finalData.push(linkRows.updateLinks({
+                appId,
+                eventType: linkRows.EventType.ROW_SAVE,
+                row,
+                tableId: row.tableId,
+                table,
+            }));
         }
-        yield db.bulkDocs(data);
+        yield db.bulkDocs(yield Promise.all(finalData));
         let response = yield db.put(table);
         table._rev = response._rev;
     }

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

@@ -23,100 +23,78 @@ const CouchDB = require("../../../db");
 const viewTemplate = require("./viewBuilder");
 const { apiFileReturn } = require("../../../utilities/fileSystem");
 const exporters = require("./exporters");
+const { saveView, getView, getViews, deleteView } = require("./utils");
 const { fetchView } = require("../row");
-const { ViewNames } = require("../../../db/utils");
-const controller = {
-    fetch: (ctx) => __awaiter(void 0, void 0, void 0, function* () {
-        const db = new CouchDB(ctx.appId);
-        const designDoc = yield db.get("_design/database");
-        const response = [];
-        for (let name of Object.keys(designDoc.views)) {
-            // Only return custom views, not built ins
-            if (Object.values(ViewNames).indexOf(name) !== -1) {
-                continue;
-            }
-            response.push(Object.assign({ name }, designDoc.views[name]));
-        }
-        ctx.body = response;
-    }),
-    save: (ctx) => __awaiter(void 0, void 0, void 0, function* () {
-        const db = new CouchDB(ctx.appId);
-        const _a = ctx.request.body, { originalName } = _a, viewToSave = __rest(_a, ["originalName"]);
-        const designDoc = yield db.get("_design/database");
-        const view = viewTemplate(viewToSave);
-        if (!viewToSave.name) {
-            ctx.throw(400, "Cannot create view without a name");
-        }
-        designDoc.views = Object.assign(Object.assign({}, designDoc.views), { [viewToSave.name]: view });
-        // view has been renamed
-        if (originalName) {
-            delete designDoc.views[originalName];
-        }
-        yield db.put(designDoc);
-        // add views to table document
-        const table = yield db.get(ctx.request.body.tableId);
-        if (!table.views)
-            table.views = {};
-        if (!view.meta.schema) {
-            view.meta.schema = table.schema;
-        }
-        table.views[viewToSave.name] = view.meta;
-        if (originalName) {
-            delete table.views[originalName];
-        }
-        yield db.put(table);
-        ctx.body = Object.assign(Object.assign({}, table.views[viewToSave.name]), { name: viewToSave.name });
-    }),
-    destroy: (ctx) => __awaiter(void 0, void 0, void 0, function* () {
-        const db = new CouchDB(ctx.appId);
-        const designDoc = yield db.get("_design/database");
-        const viewName = decodeURI(ctx.params.viewName);
-        const view = designDoc.views[viewName];
-        delete designDoc.views[viewName];
-        yield db.put(designDoc);
-        const table = yield db.get(view.meta.tableId);
-        delete table.views[viewName];
-        yield db.put(table);
-        ctx.body = view;
-    }),
-    exportView: (ctx) => __awaiter(void 0, void 0, void 0, function* () {
-        const db = new CouchDB(ctx.appId);
-        const designDoc = yield db.get("_design/database");
-        const viewName = decodeURI(ctx.query.view);
-        const view = designDoc.views[viewName];
-        const format = ctx.query.format;
-        if (!format) {
-            ctx.throw(400, "Format must be specified, either csv or json");
-        }
-        if (view) {
-            ctx.params.viewName = viewName;
-            // Fetch view rows
-            ctx.query = {
-                group: view.meta.groupBy,
-                calculation: view.meta.calculation,
-                stats: !!view.meta.field,
-                field: view.meta.field,
-            };
-        }
-        else {
-            // table all_ view
-            /* istanbul ignore next */
-            ctx.params.viewName = viewName;
-        }
-        yield fetchView(ctx);
-        let schema = view && view.meta && view.meta.schema;
-        if (!schema) {
-            const tableId = ctx.params.tableId || view.meta.tableId;
-            const table = yield db.get(tableId);
-            schema = table.schema;
-        }
-        // Export part
-        let headers = Object.keys(schema);
-        const exporter = exporters[format];
-        const filename = `${viewName}.${format}`;
-        // send down the file
-        ctx.attachment(filename);
-        ctx.body = apiFileReturn(exporter(headers, ctx.body));
-    }),
-};
-module.exports = controller;
+exports.fetch = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+    const db = new CouchDB(ctx.appId);
+    ctx.body = yield getViews(db);
+});
+exports.save = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+    const db = new CouchDB(ctx.appId);
+    const _a = ctx.request.body, { originalName } = _a, viewToSave = __rest(_a, ["originalName"]);
+    const view = viewTemplate(viewToSave);
+    if (!viewToSave.name) {
+        ctx.throw(400, "Cannot create view without a name");
+    }
+    yield saveView(db, originalName, viewToSave.name, view);
+    // add views to table document
+    const table = yield db.get(ctx.request.body.tableId);
+    if (!table.views)
+        table.views = {};
+    if (!view.meta.schema) {
+        view.meta.schema = table.schema;
+    }
+    table.views[viewToSave.name] = view.meta;
+    if (originalName) {
+        delete table.views[originalName];
+    }
+    yield db.put(table);
+    ctx.body = Object.assign(Object.assign({}, table.views[viewToSave.name]), { name: viewToSave.name });
+});
+exports.destroy = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+    const db = new CouchDB(ctx.appId);
+    const viewName = decodeURI(ctx.params.viewName);
+    const view = yield deleteView(db, viewName);
+    const table = yield db.get(view.meta.tableId);
+    delete table.views[viewName];
+    yield db.put(table);
+    ctx.body = view;
+});
+exports.exportView = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+    const db = new CouchDB(ctx.appId);
+    const viewName = decodeURI(ctx.query.view);
+    const view = yield getView(db, viewName);
+    const format = ctx.query.format;
+    if (!format) {
+        ctx.throw(400, "Format must be specified, either csv or json");
+    }
+    if (view) {
+        ctx.params.viewName = viewName;
+        // Fetch view rows
+        ctx.query = {
+            group: view.meta.groupBy,
+            calculation: view.meta.calculation,
+            stats: !!view.meta.field,
+            field: view.meta.field,
+        };
+    }
+    else {
+        // table all_ view
+        /* istanbul ignore next */
+        ctx.params.viewName = viewName;
+    }
+    yield fetchView(ctx);
+    let schema = view && view.meta && view.meta.schema;
+    if (!schema) {
+        const tableId = ctx.params.tableId || view.meta.tableId;
+        const table = yield db.get(tableId);
+        schema = table.schema;
+    }
+    // Export part
+    let headers = Object.keys(schema);
+    const exporter = exporters[format];
+    const filename = `${viewName}.${format}`;
+    // send down the file
+    ctx.attachment(filename);
+    ctx.body = apiFileReturn(exporter(headers, ctx.body));
+});

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

@@ -0,0 +1,102 @@
+"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 { ViewNames, generateMemoryViewID, getMemoryViewParams, } = require("../../../db/utils");
+const env = require("../../../environment");
+exports.getView = (db, viewName) => __awaiter(void 0, void 0, void 0, function* () {
+    if (env.SELF_HOSTED) {
+        const designDoc = yield db.get("_design/database");
+        return designDoc.views[viewName];
+    }
+    else {
+        const viewDoc = yield db.get(generateMemoryViewID(viewName));
+        return viewDoc.view;
+    }
+});
+exports.getViews = (db) => __awaiter(void 0, void 0, void 0, function* () {
+    const response = [];
+    if (env.SELF_HOSTED) {
+        const designDoc = yield db.get("_design/database");
+        for (let name of Object.keys(designDoc.views)) {
+            // Only return custom views, not built ins
+            if (Object.values(ViewNames).indexOf(name) !== -1) {
+                continue;
+            }
+            response.push(Object.assign({ name }, designDoc.views[name]));
+        }
+    }
+    else {
+        const views = (yield db.allDocs(getMemoryViewParams({
+            include_docs: true,
+        }))).rows.map(row => row.doc);
+        for (let viewDoc of views) {
+            response.push(Object.assign({ name: viewDoc.name }, viewDoc.view));
+        }
+    }
+    return response;
+});
+exports.saveView = (db, originalName, viewName, viewTemplate) => __awaiter(void 0, void 0, void 0, function* () {
+    if (env.SELF_HOSTED) {
+        const designDoc = yield db.get("_design/database");
+        designDoc.views = Object.assign(Object.assign({}, designDoc.views), { [viewName]: viewTemplate });
+        // view has been renamed
+        if (originalName) {
+            delete designDoc.views[originalName];
+        }
+        yield db.put(designDoc);
+    }
+    else {
+        const id = generateMemoryViewID(viewName);
+        const originalId = originalName ? generateMemoryViewID(originalName) : null;
+        const viewDoc = {
+            _id: id,
+            view: viewTemplate,
+            name: viewName,
+            tableId: viewTemplate.meta.tableId,
+        };
+        try {
+            const old = yield db.get(id);
+            if (originalId) {
+                const originalDoc = yield db.get(originalId);
+                yield db.remove(originalDoc._id, originalDoc._rev);
+            }
+            if (old && old._rev) {
+                viewDoc._rev = old._rev;
+            }
+        }
+        catch (err) {
+            // didn't exist, just skip
+        }
+        yield db.put(viewDoc);
+    }
+});
+exports.deleteView = (db, viewName) => __awaiter(void 0, void 0, void 0, function* () {
+    if (env.SELF_HOSTED) {
+        const designDoc = yield db.get("_design/database");
+        const view = designDoc.views[viewName];
+        delete designDoc.views[viewName];
+        yield db.put(designDoc);
+        return view;
+    }
+    else {
+        const id = generateMemoryViewID(viewName);
+        const viewDoc = yield db.get(id);
+        yield db.remove(viewDoc._id, viewDoc._rev);
+        return viewDoc.view;
+    }
+});
+exports.migrateToInMemoryView = (db, viewName) => __awaiter(void 0, void 0, void 0, function* () {
+    // delete the view initially
+    const designDoc = yield db.get("_design/database");
+    const view = designDoc.views[viewName];
+    delete designDoc.views[viewName];
+    yield db.put(designDoc);
+    yield exports.saveView(db, null, viewName, view);
+});

package/dist/automations/steps/createRow.js

@@ -12,6 +12,7 @@ const rowController = require("../../api/controllers/row");
 const automationUtils = require("../automationUtils");
 const env = require("../../environment");
 const usage = require("../../utilities/usageQuota");
+const { buildCtx } = require("./utils");
 exports.definition = {
     name: "Create Row",
     tagline: "Create a {{inputs.enriched.table.name}} row",
@@ -78,19 +79,15 @@ exports.run = function ({ inputs, appId, apiKey, emitter }) {
             };
         }
         // have to clean up the row, remove the table from it
-        const ctx = {
+        const ctx = buildCtx(appId, emitter, {
+            body: inputs.row,
             params: {
                 tableId: inputs.row.tableId,
             },
-            request: {
-                body: inputs.row,
-            },
-            appId,
-            eventEmitter: emitter,
-        };
+        });
         try {
             inputs.row = yield automationUtils.cleanUpRow(appId, inputs.row.tableId, inputs.row);
-            if (env.isProd()) {
+            if (env.USE_QUOTAS) {
                 yield usage.update(apiKey, usage.Properties.ROW, 1);
             }
             yield rowController.save(ctx);

package/dist/automations/steps/deleteRow.js

@@ -11,6 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 const rowController = require("../../api/controllers/row");
 const env = require("../../environment");
 const usage = require("../../utilities/usageQuota");
+const { buildCtx } = require("./utils");
 exports.definition = {
     description: "Delete a row from your database",
     icon: "TableRowRemoveCenter",
@@ -69,19 +70,15 @@ exports.run = function ({ inputs, appId, apiKey, emitter }) {
                 },
             };
         }
-        let ctx = {
+        let ctx = buildCtx(appId, emitter, {
+            body: {
+                _id: inputs.id,
+                _rev: inputs.revision,
+            },
             params: {
                 tableId: inputs.tableId,
             },
-            request: {
-                body: {
-                    _id: inputs.id,
-                    _rev: inputs.revision,
-                },
-            },
-            appId,
-            eventEmitter: emitter,
-        };
+        });
         try {
             if (env.isProd()) {
                 yield usage.update(apiKey, usage.Properties.ROW, -1);

package/dist/automations/steps/queryRows.js

@@ -11,6 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 const rowController = require("../../api/controllers/row");
 const tableController = require("../../api/controllers/table");
 const { FieldTypes } = require("../../constants");
+const { buildCtx } = require("./utils");
 const SortOrders = {
     ASCENDING: "ascending",
     DESCENDING: "descending",
@@ -77,12 +78,11 @@ exports.definition = {
 };
 function getTable(appId, tableId) {
     return __awaiter(this, void 0, void 0, function* () {
-        const ctx = {
+        const ctx = buildCtx(appId, null, {
             params: {
                 id: tableId,
             },
-            appId,
-        };
+        });
         yield tableController.find(ctx);
         return ctx.body;
     });
@@ -97,21 +97,18 @@ exports.run = function ({ inputs, appId }) {
             sortType =
                 fieldType === FieldTypes.NUMBER ? FieldTypes.NUMBER : FieldTypes.STRING;
         }
-        const ctx = {
+        const ctx = buildCtx(appId, null, {
             params: {
                 tableId,
             },
-            request: {
-                body: {
-                    sortOrder,
-                    sortType,
-                    sort: sortColumn,
-                    query: filters || {},
-                    limit,
-                },
+            body: {
+                sortOrder,
+                sortType,
+                sort: sortColumn,
+                query: filters || {},
+                limit,
             },
-            appId,
-        };
+        });
         try {
             yield rowController.search(ctx);
             return {