@budibase/server 1.0.49-alpha.0 → 1.0.49-alpha.4

package/dist/api/controllers/application.js

@@ -49,24 +49,22 @@ function getUserRoleId(ctx) {
         ? BUILTIN_ROLE_IDS.PUBLIC
         : ctx.user.role._id;
 }
-function getAppUrl(ctx) {
-    return __awaiter(this, void 0, void 0, function* () {
-        // construct the url
-        let url;
-        if (ctx.request.body.url) {
-            // if the url is provided, use that
-            url = encodeURI(ctx.request.body.url);
-        }
-        else if (ctx.request.body.name) {
-            // otherwise use the name
-            url = encodeURI(`${ctx.request.body.name}`);
-        }
-        if (url) {
-            url = `/${url.replace(URL_REGEX_SLASH, "")}`.toLowerCase();
-        }
-        return url;
-    });
-}
+exports.getAppUrl = ctx => {
+    // construct the url
+    let url;
+    if (ctx.request.body.url) {
+        // if the url is provided, use that
+        url = encodeURI(ctx.request.body.url);
+    }
+    else if (ctx.request.body.name) {
+        // otherwise use the name
+        url = encodeURI(`${ctx.request.body.name}`);
+    }
+    if (url) {
+        url = `/${url.replace(URL_REGEX_SLASH, "")}`.toLowerCase();
+    }
+    return url;
+};
 const checkAppUrl = (ctx, apps, url, currentAppId) => {
     if (currentAppId) {
         apps = apps.filter(app => app.appId !== currentAppId);
@@ -183,7 +181,7 @@ exports.create = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
     const apps = yield getAllApps(CouchDB, { dev: true });
     const name = ctx.request.body.name;
     checkAppName(ctx, apps, name);
-    const url = yield getAppUrl(ctx);
+    const url = exports.getAppUrl(ctx);
     checkAppUrl(ctx, apps, url);
     const { useTemplate, templateKey, templateString } = ctx.request.body;
     const instanceConfig = {
@@ -245,7 +243,7 @@ exports.update = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
     if (name) {
         checkAppName(ctx, apps, name, ctx.params.appId);
     }
-    const url = yield getAppUrl(ctx);
+    const url = yield exports.getAppUrl(ctx);
     if (url) {
         checkAppUrl(ctx, apps, url, ctx.params.appId);
         ctx.request.body.url = url;

package/dist/api/controllers/migrations.js

@@ -0,0 +1,21 @@
+"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 { migrate, MIGRATIONS } = require("../../migrations");
+exports.migrate = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+    const options = ctx.request.body;
+    // don't await as can take a while, just return
+    migrate(options);
+    ctx.status = 200;
+});
+exports.fetchDefinitions = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+    ctx.body = MIGRATIONS;
+    ctx.status = 200;
+});

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

@@ -21,11 +21,10 @@ 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 { 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 +32,12 @@ const inMemoryViews = require("../../../db/inMemoryView");
 const env = require("../../../environment");
 const { migrateToInMemoryView, migrateToDesignView, getFromDesignDoc, getFromMemoryDoc, } = require("../view/utils");
 const { cloneDeep } = require("lodash/fp");
+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,6 +66,22 @@ 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);
@@ -169,7 +137,10 @@ exports.patch = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
         yield userController.updateMetadata(ctx);
         return { row: ctx.body, table };
     }
-    return storeResponse(ctx, db, row, dbTable, table);
+    return finaliseRow(ctx.appId, table, row, {
+        oldTable: dbTable,
+        updateFormula: true,
+    });
 });
 exports.save = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -198,7 +169,10 @@ exports.save = function (ctx) {
             tableId: row.tableId,
             table,
         });
-        return storeResponse(ctx, db, row, dbTable, table);
+        return finaliseRow(ctx.appId, table, row, {
+            oldTable: dbTable,
+            updateFormula: true,
+        });
     });
 };
 exports.fetchView = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
@@ -290,6 +264,8 @@ exports.destroy = function (ctx) {
         });
         // remove any attachments that were on the row from object storage
         yield cleanupAttachments(appId, table, { row });
+        // remove any static formula
+        yield updateRelatedFormula(appId, table, row);
         let response;
         if (ctx.params.tableId === InternalTables.USER_METADATA) {
             ctx.params = {
@@ -333,6 +309,7 @@ exports.bulkDestroy = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
     }
     // remove any attachments that were on the rows from object storage
     yield cleanupAttachments(appId, table, { rows });
+    yield updateRelatedFormula(appId, table, rows);
     yield Promise.all(updates);
     return { response: { ok: true }, rows };
 });

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

@@ -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) {

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 CouchDB = require("../../../db");
+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");
+/**
+ * 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 = (appId, table, enrichedRows) => __awaiter(void 0, void 0, void 0, function* () {
+    const db = new CouchDB(appId);
+    // 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(appId, relatedTable, related, {
+                        updateFormula: false,
+                    })));
+                }
+            }
+        }
+    }
+    yield Promise.all(promises);
+});
+exports.updateAllFormulasInTable = (appId, table) => __awaiter(void 0, void 0, void 0, function* () {
+    const db = new CouchDB(appId);
+    // 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({ appId }, 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 = (appId, table, row, { oldTable, updateFormula } = { updateFormula: true }) => __awaiter(void 0, void 0, void 0, function* () {
+    const db = new CouchDB(appId);
+    row.type = "row";
+    // process the row before return, to include relationships
+    let enrichedRow = yield outputProcessing({ appId }, 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(appId, table, enrichedRow);
+    }
+    return { row: enrichedRow, table };
+});

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

@@ -0,0 +1,160 @@
+"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 { FieldTypes, FormulaTypes } = require("../../../constants");
+const { getAllInternalTables, clearColumns } = require("./utils");
+const { doesContainStrings } = require("@budibase/string-templates");
+const { cloneDeep } = require("lodash/fp");
+const { isEqual, uniq } = require("lodash");
+const { updateAllFormulasInTable } = require("../row/staticFormula");
+function isStaticFormula(column) {
+    return (column.type === FieldTypes.FORMULA &&
+        column.formulaType === FormulaTypes.STATIC);
+}
+/**
+ * This retrieves the formula columns from a table schema that use a specified column name
+ * in the formula.
+ */
+function getFormulaThatUseColumn(table, columnNames) {
+    let formula = [];
+    columnNames = Array.isArray(columnNames) ? columnNames : [columnNames];
+    for (let column of Object.values(table.schema)) {
+        // not a static formula, or doesn't contain a relationship
+        if (!isStaticFormula(column)) {
+            continue;
+        }
+        if (!doesContainStrings(column.formula, columnNames)) {
+            continue;
+        }
+        formula.push(column.name);
+    }
+    return formula;
+}
+/**
+ * This functions checks for when a related table, column or related column is deleted, if any
+ * tables need to have the formula column removed.
+ */
+function checkIfFormulaNeedsCleared(appId, table, { oldTable, deletion }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const db = new CouchDB(appId);
+        // start by retrieving all tables, remove the current table from the list
+        const tables = (yield getAllInternalTables(appId)).filter(tbl => tbl._id !== table._id);
+        const schemaToUse = oldTable ? oldTable.schema : table.schema;
+        let removedColumns = Object.values(schemaToUse).filter(column => deletion || !table.schema[column.name]);
+        // remove any formula columns that used related columns
+        for (let removed of removedColumns) {
+            let tableToUse = table;
+            // if relationship, get the related table
+            if (removed.type === FieldTypes.LINK) {
+                tableToUse = tables.find(table => table._id === removed.tableId);
+            }
+            const columnsToDelete = getFormulaThatUseColumn(tableToUse, removed.name);
+            if (columnsToDelete.length > 0) {
+                yield clearColumns(db, table, columnsToDelete);
+            }
+            // need a special case, where a column has been removed from this table, but was used
+            // in a different, related tables formula
+            if (!table.relatedFormula) {
+                continue;
+            }
+            for (let relatedTableId of table.relatedFormula) {
+                const relatedColumns = Object.values(table.schema).filter(column => column.tableId === relatedTableId);
+                const relatedTable = tables.find(table => table._id === relatedTableId);
+                // look to see if the column was used in a relationship formula,
+                // relationships won't be used for this
+                if (relatedTable && relatedColumns && removed.type !== FieldTypes.LINK) {
+                    let relatedFormulaToRemove = [];
+                    for (let column of relatedColumns) {
+                        relatedFormulaToRemove = relatedFormulaToRemove.concat(getFormulaThatUseColumn(relatedTable, [
+                            column.fieldName,
+                            removed.name,
+                        ]));
+                    }
+                    if (relatedFormulaToRemove.length > 0) {
+                        yield clearColumns(db, relatedTable, uniq(relatedFormulaToRemove));
+                    }
+                }
+            }
+        }
+    });
+}
+/**
+ * This function adds a note to related tables that they are
+ * used in a static formula - so that the link controller
+ * can manage hydrating related rows formula fields. This is
+ * specifically only for static formula.
+ */
+function updateRelatedFormulaLinksOnTables(appId, table, { deletion } = { deletion: false }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const db = new CouchDB(appId);
+        // start by retrieving all tables, remove the current table from the list
+        const tables = (yield getAllInternalTables(appId)).filter(tbl => tbl._id !== table._id);
+        // clone the tables, so we can compare at end
+        const initialTables = cloneDeep(tables);
+        // first find the related column names
+        const relatedColumns = Object.values(table.schema).filter(col => col.type === FieldTypes.LINK);
+        // we start by removing the formula field from all tables
+        for (let otherTable of tables) {
+            if (!otherTable.relatedFormula) {
+                continue;
+            }
+            const index = otherTable.relatedFormula.indexOf(table._id);
+            if (index !== -1) {
+                otherTable.relatedFormula.splice(index, 1);
+            }
+        }
+        // if deleting, just remove the table IDs, don't try add
+        if (!deletion) {
+            for (let relatedCol of relatedColumns) {
+                let columns = getFormulaThatUseColumn(table, relatedCol.name);
+                if (!columns || columns.length === 0) {
+                    continue;
+                }
+                const relatedTable = tables.find(related => related._id === relatedCol.tableId);
+                // check if the table is already in the list of related formula, if it isn't, then add it
+                if (relatedTable &&
+                    (!relatedTable.relatedFormula ||
+                        !relatedTable.relatedFormula.includes(table._id))) {
+                    relatedTable.relatedFormula = relatedTable.relatedFormula
+                        ? [...relatedTable.relatedFormula, table._id]
+                        : [table._id];
+                }
+            }
+        }
+        // now we just need to compare all the tables and see if any need saved
+        for (let initial of initialTables) {
+            const found = tables.find(tbl => initial._id === tbl._id);
+            if (found && !isEqual(initial, found)) {
+                yield db.put(found);
+            }
+        }
+    });
+}
+function checkIfFormulaUpdated(appId, table, { oldTable }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // look to see if any formula values have changed
+        const shouldUpdate = Object.values(table.schema).find(column => isStaticFormula(column) &&
+            (!oldTable ||
+                !oldTable.schema[column.name] ||
+                !isEqual(oldTable.schema[column.name], column)));
+        // if a static formula column has updated, then need to run the update
+        if (shouldUpdate != null) {
+            yield updateAllFormulasInTable(appId, table);
+        }
+    });
+}
+exports.runStaticFormulaChecks = (appId, table, { oldTable, deletion }) => __awaiter(void 0, void 0, void 0, function* () {
+    yield updateRelatedFormulaLinksOnTables(appId, table, { deletion });
+    yield checkIfFormulaNeedsCleared(appId, table, { oldTable, deletion });
+    if (!deletion) {
+        yield checkIfFormulaUpdated(appId, table, { oldTable });
+    }
+});

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

@@ -13,8 +13,8 @@ const internal = require("./internal");
 const external = require("./external");
 const csvParser = require("../../../utilities/csvParser");
 const { isExternalTable, isSQL } = require("../../../integrations/utils");
-const { getTableParams, getDatasourceParams, BudibaseInternalDB, } = require("../../../db/utils");
-const { getTable } = require("./utils");
+const { getDatasourceParams } = require("../../../db/utils");
+const { getTable, getAllInternalTables } = require("./utils");
 function pickApi({ tableId, table }) {
     if (table && !tableId) {
         tableId = table._id;
@@ -31,10 +31,7 @@ function pickApi({ tableId, table }) {
 exports.fetch = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
         const db = new CouchDB(ctx.appId);
-        const internalTables = yield db.allDocs(getTableParams(null, {
-            include_docs: true,
-        }));
-        const internal = internalTables.rows.map(tableDoc => (Object.assign(Object.assign({}, tableDoc.doc), { type: "internal", sourceId: BudibaseInternalDB._id })));
+        const internal = yield getAllInternalTables(ctx.appId);
         const externalTables = yield db.allDocs(getDatasourceParams("plus", {
             include_docs: true,
         }));

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

@@ -25,6 +25,8 @@ const { getRowParams, generateTableID } = require("../../../db/utils");
 const { FieldTypes } = require("../../../constants");
 const { TableSaveFunctions, hasTypeChanged, getTable, handleDataImport, } = require("./utils");
 const usageQuota = require("../../../utilities/usageQuota");
+const { cleanupAttachments } = require("../../../utilities/rowProcessor");
+const { runStaticFormulaChecks } = require("./bulkFormula");
 exports.save = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
         const appId = ctx.appId;
@@ -106,6 +108,8 @@ exports.save = function (ctx) {
         const result = yield db.put(tableToSave);
         tableToSave._rev = result.rev;
         tableToSave = yield tableSaveFunctions.after(tableToSave);
+        // has to run after, make sure it has _id
+        yield runStaticFormulaChecks(appId, tableToSave, { oldTable });
         return tableToSave;
     });
 };
@@ -134,6 +138,9 @@ exports.destroy = function (ctx) {
         if (existingIndex) {
             yield db.deleteIndex(existingIndex);
         }
+        // has to run after, make sure it has _id
+        yield runStaticFormulaChecks(appId, tableToDelete, { deletion: true });
+        yield cleanupAttachments(appId, tableToDelete, { rows });
         return tableToDelete;
     });
 };