@budibase/server 1.0.49 → 1.0.50-alpha.0

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

@@ -19,13 +19,11 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-const CouchDB = require("../../../db");
 const linkRows = require("../../../db/linkedRows");
-const { getRowParams, generateRowID, DocumentTypes, InternalTables, } = require("../../../db/utils");
+const { generateRowID, getRowParams, DocumentTypes, InternalTables, } = require("../../../db/utils");
 const userController = require("../user");
-const { inputProcessing, outputProcessing, processAutoColumn, cleanupAttachments, } = require("../../../utilities/rowProcessor");
+const { inputProcessing, outputProcessing, cleanupAttachments, } = 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");
@@ -33,59 +31,13 @@ const inMemoryViews = require("../../../db/inMemoryView");
 const env = require("../../../environment");
 const { migrateToInMemoryView, migrateToDesignView, getFromDesignDoc, getFromMemoryDoc, } = require("../view/utils");
 const { cloneDeep } = require("lodash/fp");
+const { getAppDB } = require("@budibase/backend-core/context");
+const { finaliseRow, updateRelatedFormula } = require("./staticFormula");
 const CALCULATION_TYPES = {
     SUM: "sum",
     COUNT: "count",
     STATS: "stats",
 };
-function storeResponse(ctx, db, row, oldTable, table) {
-    return __awaiter(this, void 0, void 0, function* () {
-        row.type = "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)) {
-            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 mainGetter = env.SELF_HOSTED ? getFromDesignDoc : getFromMemoryDoc;
@@ -114,9 +66,24 @@ function getView(db, viewName) {
         return viewInfo;
     });
 }
+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;
+    });
+}
 exports.patch = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
-    const appId = ctx.appId;
-    const db = new CouchDB(appId);
+    const db = getAppDB();
     const inputs = ctx.request.body;
     const tableId = inputs.tableId;
     const isUserTable = tableId === InternalTables.USER_METADATA;
@@ -155,26 +122,27 @@ exports.patch = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
     }
     // returned row is cleaned and prepared for writing to DB
     row = yield linkRows.updateLinks({
-        appId,
         eventType: linkRows.EventType.ROW_UPDATE,
         row,
         tableId: row.tableId,
         table,
     });
     // check if any attachments removed
-    yield cleanupAttachments(appId, table, { oldRow, row });
+    yield cleanupAttachments(table, { oldRow, row });
     if (isUserTable) {
         // the row has been updated, need to put it into the ctx
         ctx.request.body = row;
         yield userController.updateMetadata(ctx);
         return { row: ctx.body, table };
     }
-    return storeResponse(ctx, db, row, dbTable, table);
+    return finaliseRow(table, row, {
+        oldTable: dbTable,
+        updateFormula: true,
+    });
 });
 exports.save = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
-        const appId = ctx.appId;
-        const db = new CouchDB(appId);
+        const db = getAppDB();
         let inputs = ctx.request.body;
         inputs.tableId = ctx.params.tableId;
         if (!inputs._rev && !inputs._id) {
@@ -192,24 +160,25 @@ exports.save = function (ctx) {
         }
         // make sure link rows are up to date
         row = yield linkRows.updateLinks({
-            appId,
             eventType: linkRows.EventType.ROW_SAVE,
             row,
             tableId: row.tableId,
             table,
         });
-        return storeResponse(ctx, db, row, dbTable, table);
+        return finaliseRow(table, row, {
+            oldTable: dbTable,
+            updateFormula: true,
+        });
     });
 };
 exports.fetchView = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
-    const appId = ctx.appId;
     const viewName = ctx.params.viewName;
     // if this is a table view being looked for just transfer to that
     if (viewName.startsWith(DocumentTypes.TABLE)) {
         ctx.params.tableId = viewName;
         return exports.fetch(ctx);
     }
-    const db = new CouchDB(appId);
+    const db = getAppDB();
     const { calculation, group, field } = ctx.query;
     const viewInfo = yield getView(db, viewName);
     let response;
@@ -237,7 +206,7 @@ exports.fetchView = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
                 schema: {},
             };
         }
-        rows = yield outputProcessing(ctx, table, response.rows);
+        rows = yield outputProcessing(table, response.rows);
     }
     if (calculation === CALCULATION_TYPES.STATS) {
         response.rows = response.rows.map(row => (Object.assign(Object.assign({ group: row.key, field }, row.value), { avg: row.value.sum / row.value.count })));
@@ -254,25 +223,22 @@ exports.fetchView = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
     return rows;
 });
 exports.fetch = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
-    const appId = ctx.appId;
-    const db = new CouchDB(appId);
+    const db = getAppDB();
     const tableId = ctx.params.tableId;
     let table = yield db.get(tableId);
     let rows = yield getRawTableData(ctx, db, tableId);
-    return outputProcessing(ctx, table, rows);
+    return outputProcessing(table, rows);
 });
 exports.find = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
-    const appId = ctx.appId;
-    const db = new CouchDB(appId);
+    const db = getAppDB();
     const table = yield db.get(ctx.params.tableId);
-    let row = yield findRow(ctx, db, ctx.params.tableId, ctx.params.rowId);
-    row = yield outputProcessing(ctx, table, row);
+    let row = yield findRow(ctx, ctx.params.tableId, ctx.params.rowId);
+    row = yield outputProcessing(table, row);
     return row;
 });
 exports.destroy = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
-        const appId = ctx.appId;
-        const db = new CouchDB(appId);
+        const db = getAppDB();
         const { _id, _rev } = ctx.request.body;
         let row = yield db.get(_id);
         if (row.tableId !== ctx.params.tableId) {
@@ -280,16 +246,17 @@ exports.destroy = function (ctx) {
         }
         const table = yield db.get(row.tableId);
         // update the row to include full relationships before deleting them
-        row = yield outputProcessing(ctx, table, row, { squash: false });
+        row = yield outputProcessing(table, row, { squash: false });
         // now remove the relationships
         yield linkRows.updateLinks({
-            appId,
             eventType: linkRows.EventType.ROW_DELETE,
             row,
             tableId: row.tableId,
         });
         // remove any attachments that were on the row from object storage
-        yield cleanupAttachments(appId, table, { row });
+        yield cleanupAttachments(table, { row });
+        // remove any static formula
+        yield updateRelatedFormula(table, row);
         let response;
         if (ctx.params.tableId === InternalTables.USER_METADATA) {
             ctx.params = {
@@ -305,17 +272,15 @@ exports.destroy = function (ctx) {
     });
 };
 exports.bulkDestroy = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
-    const appId = ctx.appId;
-    const db = new CouchDB(appId);
+    const db = getAppDB();
     const tableId = ctx.params.tableId;
     const table = yield db.get(tableId);
     let { rows } = ctx.request.body;
     // before carrying out any updates, make sure the rows are ready to be returned
     // they need to be the full rows (including previous relationships) for automations
-    rows = yield outputProcessing(ctx, table, rows, { squash: false });
+    rows = yield outputProcessing(table, rows, { squash: false });
     // remove the relationships first
     let updates = rows.map(row => linkRows.updateLinks({
-        appId,
         eventType: linkRows.EventType.ROW_DELETE,
         row,
         tableId: row.tableId,
@@ -332,7 +297,8 @@ exports.bulkDestroy = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
         yield db.bulkDocs(rows.map(row => (Object.assign(Object.assign({}, row), { _deleted: true }))));
     }
     // remove any attachments that were on the rows from object storage
-    yield cleanupAttachments(appId, table, { rows });
+    yield cleanupAttachments(table, { rows });
+    yield updateRelatedFormula(table, rows);
     yield Promise.all(updates);
     return { response: { ok: true }, rows };
 });
@@ -341,50 +307,46 @@ exports.search = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
     if (env.isCypress()) {
         return { rows: yield exports.fetch(ctx) };
     }
-    const appId = ctx.appId;
     const { tableId } = ctx.params;
-    const db = new CouchDB(appId);
+    const db = getAppDB();
     const _a = ctx.request.body, { paginate, query } = _a, params = __rest(_a, ["paginate", "query"]);
     params.version = ctx.version;
     params.tableId = tableId;
     let response;
     if (paginate) {
-        response = yield paginatedSearch(appId, query, params);
+        response = yield paginatedSearch(query, params);
     }
     else {
-        response = yield fullSearch(appId, query, params);
+        response = yield fullSearch(query, params);
     }
     // Enrich search results with relationships
     if (response.rows && response.rows.length) {
         // enrich with global users if from users table
         if (tableId === InternalTables.USER_METADATA) {
-            response.rows = yield getGlobalUsersFromMetadata(appId, response.rows);
+            response.rows = yield getGlobalUsersFromMetadata(response.rows);
         }
         const table = yield db.get(tableId);
-        response.rows = yield outputProcessing(ctx, table, response.rows);
+        response.rows = yield outputProcessing(table, response.rows);
     }
     return response;
 });
 exports.validate = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
     return validate({
-        appId: ctx.appId,
         tableId: ctx.params.tableId,
         row: ctx.request.body,
     });
 });
 exports.fetchEnrichedRow = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
-    const appId = ctx.appId;
-    const db = new CouchDB(appId);
+    const db = getAppDB();
     const tableId = ctx.params.tableId;
     const rowId = ctx.params.rowId;
     // need table to work out where links go in row
     let [table, row] = yield Promise.all([
         db.get(tableId),
-        findRow(ctx, db, tableId, rowId),
+        findRow(ctx, tableId, rowId),
     ]);
     // get the link docs
     const linkVals = yield linkRows.getLinkDocuments({
-        appId,
         tableId,
         rowId,
     });
@@ -408,7 +370,7 @@ exports.fetchEnrichedRow = (ctx) => __awaiter(void 0, void 0, void 0, function*
     let linkedRows = [];
     for (let [tableId, rows] of Object.entries(groups)) {
         // need to include the IDs in these rows for any links they may have
-        linkedRows = linkedRows.concat(yield outputProcessing(ctx, tables[tableId], rows));
+        linkedRows = linkedRows.concat(yield outputProcessing(tables[tableId], rows));
     }
     // insert the link rows in the correct place throughout the main row
     for (let fieldName of Object.keys(table.schema)) {

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

@@ -11,13 +11,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 const { SearchIndexes } = require("../../../db/utils");
 const fetch = require("node-fetch");
 const { getCouchUrl } = require("@budibase/backend-core/db");
+const { getAppId } = require("@budibase/backend-core/context");
 /**
  * Class to build lucene query URLs.
  * Optionally takes a base lucene query object.
  */
 class QueryBuilder {
-    constructor(appId, base) {
-        this.appId = appId;
+    constructor(base) {
         this.query = Object.assign({ string: {}, fuzzy: {}, range: {}, equal: {}, notEqual: {}, empty: {}, notEmpty: {} }, base);
         this.limit = 50;
         this.sortOrder = "ascending";
@@ -34,19 +34,27 @@ class QueryBuilder {
         return this;
     }
     setLimit(limit) {
-        this.limit = limit;
+        if (limit != null) {
+            this.limit = limit;
+        }
         return this;
     }
     setSort(sort) {
-        this.sort = sort;
+        if (sort != null) {
+            this.sort = sort;
+        }
         return this;
     }
     setSortOrder(sortOrder) {
-        this.sortOrder = sortOrder;
+        if (sortOrder != null) {
+            this.sortOrder = sortOrder;
+        }
         return this;
     }
     setSortType(sortType) {
-        this.sortType = sortType;
+        if (sortType != null) {
+            this.sortType = sortType;
+        }
         return this;
     }
     setBookmark(bookmark) {
@@ -213,7 +221,8 @@ class QueryBuilder {
     }
     run() {
         return __awaiter(this, void 0, void 0, function* () {
-            const url = `${getCouchUrl()}/${this.appId}/_design/database/_search/${SearchIndexes.ROWS}`;
+            const appId = getAppId();
+            const url = `${getCouchUrl()}/${appId}/_design/database/_search/${SearchIndexes.ROWS}`;
             const body = this.buildSearchBody();
             return yield runQuery(url, body);
         });
@@ -246,7 +255,6 @@ const runQuery = (url, body) => __awaiter(void 0, void 0, void 0, function* () {
  * Gets round the fixed limit of 200 results from a query by fetching as many
  * pages as required and concatenating the results. This recursively operates
  * until enough results have been found.
- * @param appId {string} The app ID to search
  * @param query {object} The JSON query structure
  * @param params {object} The search params including:
  *   tableId {string} The table ID to search
@@ -259,7 +267,7 @@ const runQuery = (url, body) => __awaiter(void 0, void 0, void 0, function* () {
  *   rows {array|null} Current results in the recursive search
  * @returns {Promise<*[]|*>}
  */
-const recursiveSearch = (appId, query, params) => __awaiter(void 0, void 0, void 0, function* () {
+const recursiveSearch = (query, params) => __awaiter(void 0, void 0, void 0, function* () {
     const bookmark = params.bookmark;
     const rows = params.rows || [];
     if (rows.length >= params.limit) {
@@ -269,7 +277,7 @@ const recursiveSearch = (appId, query, params) => __awaiter(void 0, void 0, void
     if (rows.length > params.limit - 200) {
         pageSize = params.limit - rows.length;
     }
-    const page = yield new QueryBuilder(appId, query)
+    const page = yield new QueryBuilder(query)
         .setVersion(params.version)
         .setTable(params.tableId)
         .setBookmark(bookmark)
@@ -285,13 +293,12 @@ const recursiveSearch = (appId, query, params) => __awaiter(void 0, void 0, void
         return [...rows, ...page.rows];
     }
     const newParams = Object.assign(Object.assign({}, params), { bookmark: page.bookmark, rows: [...rows, ...page.rows] });
-    return yield recursiveSearch(appId, query, newParams);
+    return yield recursiveSearch(query, newParams);
 });
 /**
  * Performs a paginated search. A bookmark will be returned to allow the next
  * page to be fetched. There is a max limit off 200 results per page in a
  * paginated search.
- * @param appId {string} The app ID to search
  * @param query {object} The JSON query structure
  * @param params {object} The search params including:
  *   tableId {string} The table ID to search
@@ -303,13 +310,13 @@ const recursiveSearch = (appId, query, params) => __awaiter(void 0, void 0, void
  *   bookmark {string} The bookmark to resume from
  * @returns {Promise<{hasNextPage: boolean, rows: *[]}>}
  */
-exports.paginatedSearch = (appId, query, params) => __awaiter(void 0, void 0, void 0, function* () {
+exports.paginatedSearch = (query, params) => __awaiter(void 0, void 0, void 0, function* () {
     let limit = params.limit;
     if (limit == null || isNaN(limit) || limit < 0) {
         limit = 50;
     }
     limit = Math.min(limit, 200);
-    const search = new QueryBuilder(appId, query)
+    const search = new QueryBuilder(query)
         .setVersion(params.version)
         .setTable(params.tableId)
         .setSort(params.sort)
@@ -332,7 +339,6 @@ exports.paginatedSearch = (appId, query, params) => __awaiter(void 0, void 0, vo
  * desired amount of results. There is a limit of 1000 results to avoid
  * heavy performance hits, and to avoid client components breaking from
  * handling too much data.
- * @param appId {string} The app ID to search
  * @param query {object} The JSON query structure
  * @param params {object} The search params including:
  *   tableId {string} The table ID to search
@@ -343,12 +349,12 @@ exports.paginatedSearch = (appId, query, params) => __awaiter(void 0, void 0, vo
  *   limit {number} The desired number of results
  * @returns {Promise<{rows: *}>}
  */
-exports.fullSearch = (appId, query, params) => __awaiter(void 0, void 0, void 0, function* () {
+exports.fullSearch = (query, params) => __awaiter(void 0, void 0, void 0, function* () {
     let limit = params.limit;
     if (limit == null || isNaN(limit) || limit < 0) {
         limit = 1000;
     }
     params.limit = Math.min(limit, 1000);
-    const rows = yield recursiveSearch(appId, query, params);
+    const rows = yield recursiveSearch(query, params);
     return { rows };
 });

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

@@ -0,0 +1,147 @@
+"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 { getRowParams } = require("../../../db/utils");
+const { outputProcessing, processAutoColumn, processFormulas, } = require("../../../utilities/rowProcessor");
+const { FieldTypes, FormulaTypes } = require("../../../constants");
+const { isEqual } = require("lodash");
+const { cloneDeep } = require("lodash/fp");
+const { getAppDB } = require("@budibase/backend-core/context");
+/**
+ * This function runs through a list of enriched rows, looks at the rows which
+ * are related and then checks if they need the state of their formulas
+ * updated.
+ * NOTE: this will only for affect static formulas.
+ */
+exports.updateRelatedFormula = (table, enrichedRows) => __awaiter(void 0, void 0, void 0, function* () {
+    const db = getAppDB();
+    // no formula to update, we're done
+    if (!table.relatedFormula) {
+        return;
+    }
+    let promises = [];
+    for (let enrichedRow of Array.isArray(enrichedRows)
+        ? enrichedRows
+        : [enrichedRows]) {
+        // the related rows by tableId
+        let relatedRows = {};
+        for (let [key, field] of Object.entries(enrichedRow)) {
+            const columnDefinition = table.schema[key];
+            if (columnDefinition && columnDefinition.type === FieldTypes.LINK) {
+                const relatedTableId = columnDefinition.tableId;
+                if (!relatedRows[relatedTableId]) {
+                    relatedRows[relatedTableId] = [];
+                }
+                relatedRows[relatedTableId] = relatedRows[relatedTableId].concat(field);
+            }
+        }
+        for (let tableId of table.relatedFormula) {
+            let relatedTable;
+            try {
+                // no rows to update, skip
+                if (!relatedRows[tableId] || relatedRows[tableId].length === 0) {
+                    continue;
+                }
+                relatedTable = yield db.get(tableId);
+            }
+            catch (err) {
+                // no error scenario, table doesn't seem to exist anymore, ignore
+            }
+            for (let column of Object.values(relatedTable.schema)) {
+                // needs updated in related rows
+                if (column.type === FieldTypes.FORMULA &&
+                    column.formulaType === FormulaTypes.STATIC) {
+                    // re-enrich rows for all the related, don't update the related formula for them
+                    promises = promises.concat(relatedRows[tableId].map(related => exports.finaliseRow(relatedTable, related, {
+                        updateFormula: false,
+                    })));
+                }
+            }
+        }
+    }
+    yield Promise.all(promises);
+});
+exports.updateAllFormulasInTable = (table) => __awaiter(void 0, void 0, void 0, function* () {
+    const db = getAppDB();
+    // start by getting the raw rows (which will be written back to DB after update)
+    let rows = (yield db.allDocs(getRowParams(table._id, null, {
+        include_docs: true,
+    }))).rows.map(row => row.doc);
+    // now enrich the rows, note the clone so that we have the base state of the
+    // rows so that we don't write any of the enriched information back
+    let enrichedRows = yield outputProcessing(table, cloneDeep(rows), {
+        squash: false,
+    });
+    const updatedRows = [];
+    for (let row of rows) {
+        // find the enriched row, if found process the formulas
+        const enrichedRow = enrichedRows.find(enriched => enriched._id === row._id);
+        if (enrichedRow) {
+            const processed = processFormulas(table, cloneDeep(row), {
+                dynamic: false,
+                contextRows: enrichedRow,
+            });
+            // values have changed, need to add to bulk docs to update
+            if (!isEqual(processed, row)) {
+                updatedRows.push(processed);
+            }
+        }
+    }
+    yield db.bulkDocs(updatedRows);
+});
+/**
+ * This function runs at the end of the save/patch functions of the row controller, all this
+ * really does is enrich the row, handle any static formula processing, then return the enriched
+ * row. The reason we need to return the enriched row is that the automation row created trigger
+ * expects the row to be totally enriched/contain all relationships.
+ */
+exports.finaliseRow = (table, row, { oldTable, updateFormula } = { updateFormula: true }) => __awaiter(void 0, void 0, void 0, function* () {
+    const db = getAppDB();
+    row.type = "row";
+    // process the row before return, to include relationships
+    let enrichedRow = yield outputProcessing(table, cloneDeep(row), {
+        squash: false,
+    });
+    // use enriched row to generate formulas for saving, specifically only use as context
+    row = processFormulas(table, row, {
+        dynamic: false,
+        contextRows: enrichedRow,
+    });
+    // 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 (oldTable && !isEqual(oldTable, 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);
+    // for response, calculate the formulas for the enriched row
+    enrichedRow._rev = response.rev;
+    enrichedRow = yield processFormulas(table, enrichedRow, { dynamic: false });
+    // this updates the related formulas in other rows based on the relations to this row
+    if (updateFormula) {
+        yield exports.updateRelatedFormula(table, enrichedRow);
+    }
+    return { row: enrichedRow, table };
+});

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

@@ -10,12 +10,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 const validateJs = require("validate.js");
 const { cloneDeep } = require("lodash/fp");
-const CouchDB = require("../../../db");
 const { InternalTables } = require("../../../db/utils");
 const userController = require("../user");
 const { FieldTypes } = require("../../../constants");
 const { processStringSync } = require("@budibase/string-templates");
 const { makeExternalQuery } = require("../../../integrations/base/utils");
+const { getAppDB } = require("@budibase/backend-core/context");
 validateJs.extend(validateJs.validators.datetime, {
     parse: function (value) {
         return new Date(value).getTime();
@@ -25,13 +25,14 @@ validateJs.extend(validateJs.validators.datetime, {
         return new Date(value).toISOString();
     },
 });
-exports.getDatasourceAndQuery = (appId, json) => __awaiter(void 0, void 0, void 0, function* () {
+exports.getDatasourceAndQuery = (json) => __awaiter(void 0, void 0, void 0, function* () {
     const datasourceId = json.endpoint.datasourceId;
-    const db = new CouchDB(appId);
+    const db = getAppDB();
     const datasource = yield db.get(datasourceId);
     return makeExternalQuery(datasource, json);
 });
-exports.findRow = (ctx, db, tableId, rowId) => __awaiter(void 0, void 0, void 0, function* () {
+exports.findRow = (ctx, tableId, rowId) => __awaiter(void 0, void 0, void 0, function* () {
+    const db = getAppDB();
     let row;
     // TODO remove special user case in future
     if (tableId === InternalTables.USER_METADATA) {
@@ -49,9 +50,9 @@ exports.findRow = (ctx, db, tableId, rowId) => __awaiter(void 0, void 0, void 0,
     }
     return row;
 });
-exports.validate = ({ appId, tableId, row, table }) => __awaiter(void 0, void 0, void 0, function* () {
+exports.validate = ({ tableId, row, table }) => __awaiter(void 0, void 0, void 0, function* () {
     if (!table) {
-        const db = new CouchDB(appId);
+        const db = getAppDB();
         table = yield db.get(tableId);
     }
     const errors = {};
@@ -64,19 +65,17 @@ exports.validate = ({ appId, tableId, row, table }) => __awaiter(void 0, void 0,
         }
         let res;
         // Validate.js doesn't seem to handle array
-        if (type === FieldTypes.ARRAY) {
-            const hasValues = Array.isArray(row[fieldName]) && row[fieldName].length > 0;
-            // Check values are valid if values are specified
-            if (hasValues) {
+        if (type === FieldTypes.ARRAY && row[fieldName]) {
+            if (row[fieldName].length) {
                 row[fieldName].map(val => {
                     if (!constraints.inclusion.includes(val)) {
-                        errors[fieldName] = "Value not in list";
+                        errors[fieldName] = "Field not in list";
                     }
                 });
             }
-            // Check for required constraint
-            if (constraints.presence === true && !hasValues) {
-                errors[fieldName] = "Required field";
+            else if (constraints.presence && row[fieldName].length === 0) {
+                // non required MultiSelect creates an empty array, which should not throw errors
+                errors[fieldName] = [`${fieldName} is required`];
             }
         }
         else if (type === FieldTypes.JSON && typeof row[fieldName] === "string") {