@budibase/server 2.1.45 → 2.1.46-alpha.0

package/dist/db/linkedRows/index.js

@@ -8,20 +8,29 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-const LinkController = require("./LinkController");
-const { IncludeDocs, getLinkDocuments, createLinkView, getUniqueByProp, getRelatedTableForField, getLinkedTableIDs, getLinkedTable, } = require("./linkUtils");
-const { flatten } = require("lodash");
-const { FieldTypes } = require("../../constants");
-const { getMultiIDParams, USER_METDATA_PREFIX } = require("../../db/utils");
-const { partition } = require("lodash");
-const { getGlobalUsersFromMetadata } = require("../../utilities/global");
-const { processFormulas } = require("../../utilities/rowProcessor/utils");
-const { getAppDB } = require("@budibase/backend-core/context");
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.squashLinksToPrimaryDisplay = exports.attachFullLinkedDocs = exports.updateLinks = exports.EventType = exports.createLinkView = exports.getLinkDocuments = exports.IncludeDocs = void 0;
+const LinkController_1 = __importDefault(require("./LinkController"));
+const linkUtils_1 = require("./linkUtils");
+const lodash_1 = require("lodash");
+const constants_1 = require("../../constants");
+const utils_1 = require("../utils");
+const lodash_2 = require("lodash");
+const global_1 = require("../../utilities/global");
+const rowProcessor_1 = require("../../utilities/rowProcessor");
+const backend_core_1 = require("@budibase/backend-core");
+var linkUtils_2 = require("./linkUtils");
+Object.defineProperty(exports, "IncludeDocs", { enumerable: true, get: function () { return linkUtils_2.IncludeDocs; } });
+Object.defineProperty(exports, "getLinkDocuments", { enumerable: true, get: function () { return linkUtils_2.getLinkDocuments; } });
+Object.defineProperty(exports, "createLinkView", { enumerable: true, get: function () { return linkUtils_2.createLinkView; } });
 /**
  * This functionality makes sure that when rows with links are created, updated or deleted they are processed
  * correctly - making sure that no stale links are left around and that all links have been made successfully.
  */
-const EventType = {
+exports.EventType = {
     ROW_SAVE: "row:save",
     ROW_UPDATE: "row:update",
     ROW_DELETE: "row:delete",
@@ -29,14 +38,9 @@ const EventType = {
     TABLE_UPDATED: "table:updated",
     TABLE_DELETE: "table:delete",
 };
-exports.EventType = EventType;
-// re-export search here for ease of use
-exports.IncludeDocs = IncludeDocs;
-exports.getLinkDocuments = getLinkDocuments;
-exports.createLinkView = createLinkView;
 function clearRelationshipFields(table, rows) {
     for (let [key, field] of Object.entries(table.schema)) {
-        if (field.type === FieldTypes.LINK) {
+        if (field.type === constants_1.FieldTypes.LINK) {
             rows = rows.map(row => {
                 delete row[key];
                 return row;
@@ -49,13 +53,14 @@ function getLinksForRows(rows) {
     return __awaiter(this, void 0, void 0, function* () {
         const tableIds = [...new Set(rows.map(el => el.tableId))];
         // start by getting all the link values for performance reasons
-        const responses = flatten(yield Promise.all(tableIds.map(tableId => getLinkDocuments({
+        const promises = tableIds.map(tableId => (0, linkUtils_1.getLinkDocuments)({
             tableId: tableId,
-            includeDocs: IncludeDocs.EXCLUDE,
-        }))));
+            includeDocs: linkUtils_1.IncludeDocs.EXCLUDE,
+        }));
+        const responses = (0, lodash_1.flatten)((yield Promise.all(promises)));
         // have to get unique as the previous table query can
         // return duplicates, could be querying for both tables in a relation
-        return getUniqueByProp(responses
+        return (0, linkUtils_1.getUniqueByProp)(responses
             .filter(el => el != null)
             // create a unique ID which we can use for getting only unique ones
             .map(el => (Object.assign(Object.assign({}, el), { unique: el.id + el.thisId + el.fieldName }))), "unique");
@@ -64,17 +69,17 @@ function getLinksForRows(rows) {
 function getFullLinkedDocs(links) {
     return __awaiter(this, void 0, void 0, function* () {
         // create DBs
-        const db = getAppDB();
+        const db = backend_core_1.context.getAppDB();
         const linkedRowIds = links.map(link => link.id);
         const uniqueRowIds = [...new Set(linkedRowIds)];
-        let dbRows = (yield db.allDocs(getMultiIDParams(uniqueRowIds))).rows.map(row => row.doc);
+        let dbRows = (yield db.allDocs((0, utils_1.getMultiIDParams)(uniqueRowIds))).rows.map(row => row.doc);
         // convert the unique db rows back to a full list of linked rows
         const linked = linkedRowIds
             .map(id => dbRows.find(row => row && row._id === id))
             .filter(row => row != null);
         // need to handle users as specific cases
-        let [users, other] = partition(linked, linkRow => linkRow._id.startsWith(USER_METDATA_PREFIX));
-        users = yield getGlobalUsersFromMetadata(users);
+        let [users, other] = (0, lodash_2.partition)(linked, linkRow => linkRow._id.startsWith(utils_1.USER_METDATA_PREFIX));
+        users = yield (0, global_1.getGlobalUsersFromMetadata)(users);
         return [...other, ...users];
     });
 }
@@ -89,7 +94,7 @@ function getFullLinkedDocs(links) {
  * @returns {Promise<object>} When the update is complete this will respond successfully. Returns the row for
  * row operations and the table for table operations.
  */
-exports.updateLinks = function (args) {
+function updateLinks(args) {
     return __awaiter(this, void 0, void 0, function* () {
         const { eventType, row, tableId, table, oldTable } = args;
         const baseReturnObj = row == null ? table : row;
@@ -97,7 +102,7 @@ exports.updateLinks = function (args) {
         if (tableId == null && table != null) {
             args.tableId = table._id;
         }
-        let linkController = new LinkController(args);
+        let linkController = new LinkController_1.default(args);
         try {
             if (!(yield linkController.doesTableHaveLinkedFields(table)) &&
                 (oldTable == null ||
@@ -109,22 +114,23 @@ exports.updateLinks = function (args) {
             return baseReturnObj;
         }
         switch (eventType) {
-            case EventType.ROW_SAVE:
-            case EventType.ROW_UPDATE:
+            case exports.EventType.ROW_SAVE:
+            case exports.EventType.ROW_UPDATE:
                 return yield linkController.rowSaved();
-            case EventType.ROW_DELETE:
+            case exports.EventType.ROW_DELETE:
                 return yield linkController.rowDeleted();
-            case EventType.TABLE_SAVE:
+            case exports.EventType.TABLE_SAVE:
                 return yield linkController.tableSaved();
-            case EventType.TABLE_UPDATED:
+            case exports.EventType.TABLE_UPDATED:
                 return yield linkController.tableUpdated();
-            case EventType.TABLE_DELETE:
+            case exports.EventType.TABLE_DELETE:
                 return yield linkController.tableDeleted();
             default:
                 throw "Type of event is not known, linked row handler requires update.";
         }
     });
-};
+}
+exports.updateLinks = updateLinks;
 /**
  * Given a table and a list of rows this will retrieve all of the attached docs and enrich them into the row.
  * This is required for formula fields, this may only be utilised internally (for now).
@@ -132,63 +138,69 @@ exports.updateLinks = function (args) {
  * @param {array<object>} rows The rows which are to be enriched.
  * @return {Promise<*>} returns the rows with all of the enriched relationships on it.
  */
-exports.attachFullLinkedDocs = (table, rows) => __awaiter(void 0, void 0, void 0, function* () {
-    const linkedTableIds = getLinkedTableIDs(table);
-    if (linkedTableIds.length === 0) {
-        return rows;
-    }
-    // get all the links
-    const links = (yield getLinksForRows(rows)).filter(link => rows.some(row => row._id === link.thisId));
-    // clear any existing links that could be dupe'd
-    rows = clearRelationshipFields(table, rows);
-    // now get the docs and combine into the rows
-    let linked = yield getFullLinkedDocs(links);
-    const linkedTables = [];
-    for (let row of rows) {
-        for (let link of links.filter(link => link.thisId === row._id)) {
-            if (row[link.fieldName] == null) {
-                row[link.fieldName] = [];
-            }
-            const linkedRow = linked.find(row => row._id === link.id);
-            if (linkedRow) {
-                const linkedTableId = linkedRow.tableId || getRelatedTableForField(table, link.fieldName);
-                const linkedTable = yield getLinkedTable(linkedTableId, linkedTables);
-                if (linkedTable) {
-                    row[link.fieldName].push(processFormulas(linkedTable, linkedRow));
+function attachFullLinkedDocs(table, rows) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const linkedTableIds = (0, linkUtils_1.getLinkedTableIDs)(table);
+        if (linkedTableIds.length === 0) {
+            return rows;
+        }
+        // get all the links
+        const links = (yield getLinksForRows(rows)).filter(link => rows.some(row => row._id === link.thisId));
+        // clear any existing links that could be dupe'd
+        rows = clearRelationshipFields(table, rows);
+        // now get the docs and combine into the rows
+        let linked = yield getFullLinkedDocs(links);
+        const linkedTables = [];
+        for (let row of rows) {
+            for (let link of links.filter(link => link.thisId === row._id)) {
+                if (row[link.fieldName] == null) {
+                    row[link.fieldName] = [];
+                }
+                const linkedRow = linked.find(row => row._id === link.id);
+                if (linkedRow) {
+                    const linkedTableId = linkedRow.tableId || (0, linkUtils_1.getRelatedTableForField)(table, link.fieldName);
+                    const linkedTable = yield (0, linkUtils_1.getLinkedTable)(linkedTableId, linkedTables);
+                    if (linkedTable) {
+                        row[link.fieldName].push((0, rowProcessor_1.processFormulas)(linkedTable, linkedRow));
+                    }
                 }
             }
         }
-    }
-    return rows;
-});
+        return rows;
+    });
+}
+exports.attachFullLinkedDocs = attachFullLinkedDocs;
 /**
  * This function will take the given enriched rows and squash the links to only contain the primary display field.
  * @param {object} table The table from which the rows originated.
  * @param {array<object>} enriched The pre-enriched rows (full docs) which are to be squashed.
  * @returns {Promise<Array>} The rows after having their links squashed to only contain the ID and primary display.
  */
-exports.squashLinksToPrimaryDisplay = (table, enriched) => __awaiter(void 0, void 0, void 0, function* () {
-    // will populate this as we find them
-    const linkedTables = [table];
-    for (let row of enriched) {
-        // this only fetches the table if its not already in array
-        const rowTable = yield getLinkedTable(row.tableId, linkedTables);
-        for (let [column, schema] of Object.entries(rowTable.schema)) {
-            if (schema.type !== FieldTypes.LINK || !Array.isArray(row[column])) {
-                continue;
-            }
-            const newLinks = [];
-            for (let link of row[column]) {
-                const linkTblId = link.tableId || getRelatedTableForField(table, column);
-                const linkedTable = yield getLinkedTable(linkTblId, linkedTables);
-                const obj = { _id: link._id };
-                if (link[linkedTable.primaryDisplay]) {
-                    obj.primaryDisplay = link[linkedTable.primaryDisplay];
+function squashLinksToPrimaryDisplay(table, enriched) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // will populate this as we find them
+        const linkedTables = [table];
+        for (let row of enriched) {
+            // this only fetches the table if its not already in array
+            const rowTable = yield (0, linkUtils_1.getLinkedTable)(row.tableId, linkedTables);
+            for (let [column, schema] of Object.entries((rowTable === null || rowTable === void 0 ? void 0 : rowTable.schema) || {})) {
+                if (schema.type !== constants_1.FieldTypes.LINK || !Array.isArray(row[column])) {
+                    continue;
+                }
+                const newLinks = [];
+                for (let link of row[column]) {
+                    const linkTblId = link.tableId || (0, linkUtils_1.getRelatedTableForField)(table, column);
+                    const linkedTable = yield (0, linkUtils_1.getLinkedTable)(linkTblId, linkedTables);
+                    const obj = { _id: link._id };
+                    if ((linkedTable === null || linkedTable === void 0 ? void 0 : linkedTable.primaryDisplay) && link[linkedTable.primaryDisplay]) {
+                        obj.primaryDisplay = link[linkedTable.primaryDisplay];
+                    }
+                    newLinks.push(obj);
                 }
-                newLinks.push(obj);
+                row[column] = newLinks;
             }
-            row[column] = newLinks;
         }
-    }
-    return enriched;
-});
+        return enriched;
+    });
+}
+exports.squashLinksToPrimaryDisplay = squashLinksToPrimaryDisplay;

package/dist/db/linkedRows/linkUtils.js

@@ -8,11 +8,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-const Sentry = require("@sentry/node");
-const { ViewName, getQueryIndex } = require("../utils");
-const { FieldTypes } = require("../../constants");
-const { createLinkView } = require("../views/staticViews");
-const { getAppDB } = require("@budibase/backend-core/context");
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRelatedTableForField = exports.getLinkedTable = exports.getLinkedTableIDs = exports.getUniqueByProp = exports.getLinkDocuments = exports.IncludeDocs = exports.createLinkView = void 0;
+const utils_1 = require("../utils");
+const constants_1 = require("../../constants");
+const staticViews_1 = require("../views/staticViews");
+const backend_core_1 = require("@budibase/backend-core");
+var staticViews_2 = require("../views/staticViews");
+Object.defineProperty(exports, "createLinkView", { enumerable: true, get: function () { return staticViews_2.createLinkView; } });
 /**
  * Only needed so that boolean parameters are being used for includeDocs
  * @type {{EXCLUDE: boolean, INCLUDE: boolean}}
@@ -21,7 +24,6 @@ exports.IncludeDocs = {
     INCLUDE: true,
     EXCLUDE: false,
 };
-exports.createLinkView = createLinkView;
 /**
  * Gets the linking documents, not the linked documents themselves.
  * @param {string} args.tableId The table which we are searching for linked rows against.
@@ -35,10 +37,10 @@ exports.createLinkView = createLinkView;
  * @returns {Promise<object[]>} This will return an array of the linking documents that were found
  * (if any).
  */
-exports.getLinkDocuments = function (args) {
+function getLinkDocuments(args) {
     return __awaiter(this, arguments, void 0, function* () {
         const { tableId, rowId, includeDocs } = args;
-        const db = getAppDB();
+        const db = backend_core_1.context.getAppDB();
         let params;
         if (rowId != null) {
             params = { key: [tableId, rowId] };
@@ -49,7 +51,7 @@ exports.getLinkDocuments = function (args) {
         }
         params.include_docs = !!includeDocs;
         try {
-            let linkRows = (yield db.query(getQueryIndex(ViewName.LINK), params)).rows;
+            let linkRows = (yield db.query((0, utils_1.getQueryIndex)(utils_1.ViewName.LINK), params)).rows;
             // filter to get unique entries
             const foundIds = [];
             linkRows = linkRows.filter(link => {
@@ -74,48 +76,56 @@ exports.getLinkDocuments = function (args) {
         catch (err) {
             // check if the view doesn't exist, it should for all new instances
             if (err != null && err.name === "not_found") {
-                yield exports.createLinkView();
-                return exports.getLinkDocuments(arguments[0]);
+                yield (0, staticViews_1.createLinkView)();
+                return getLinkDocuments(arguments[0]);
             }
             else {
                 /* istanbul ignore next */
-                Sentry.captureException(err);
+                backend_core_1.logging.logAlert("Failed to get link documents", err);
+                throw err;
             }
         }
     });
-};
-exports.getUniqueByProp = (array, prop) => {
+}
+exports.getLinkDocuments = getLinkDocuments;
+function getUniqueByProp(array, prop) {
     return array.filter((obj, pos, arr) => {
         return arr.map(mapObj => mapObj[prop]).indexOf(obj[prop]) === pos;
     });
-};
-exports.getLinkedTableIDs = table => {
+}
+exports.getUniqueByProp = getUniqueByProp;
+function getLinkedTableIDs(table) {
     return Object.values(table.schema)
-        .filter(column => column.type === FieldTypes.LINK)
+        .filter((column) => column.type === constants_1.FieldTypes.LINK)
         .map(column => column.tableId);
-};
-exports.getLinkedTable = (id, tables) => __awaiter(void 0, void 0, void 0, function* () {
-    const db = getAppDB();
-    let linkedTable = tables.find(table => table._id === id);
-    if (linkedTable) {
+}
+exports.getLinkedTableIDs = getLinkedTableIDs;
+function getLinkedTable(id, tables) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const db = backend_core_1.context.getAppDB();
+        let linkedTable = tables.find(table => table._id === id);
+        if (linkedTable) {
+            return linkedTable;
+        }
+        linkedTable = yield db.get(id);
+        if (linkedTable) {
+            tables.push(linkedTable);
+        }
         return linkedTable;
-    }
-    linkedTable = yield db.get(id);
-    if (linkedTable) {
-        tables.push(linkedTable);
-    }
-    return linkedTable;
-});
-exports.getRelatedTableForField = (table, fieldName) => {
+    });
+}
+exports.getLinkedTable = getLinkedTable;
+function getRelatedTableForField(table, fieldName) {
     // look to see if its on the table, straight in the schema
     const field = table.schema[fieldName];
     if (field != null) {
         return field.tableId;
     }
     for (let column of Object.values(table.schema)) {
-        if (column.type === FieldTypes.LINK && column.fieldName === fieldName) {
+        if (column.type === constants_1.FieldTypes.LINK && column.fieldName === fieldName) {
             return column.tableId;
         }
     }
     return null;
-};
+}
+exports.getRelatedTableForField = getRelatedTableForField;