@budibase/server 2.1.43-alpha.2 → 2.1.43

package/dist/db/linkedRows/LinkController.js

@@ -8,18 +8,42 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-const linkUtils_1 = require("./linkUtils");
-const utils_1 = require("../utils");
-const node_1 = __importDefault(require("@sentry/node"));
-const constants_1 = require("../../constants");
-const backend_core_1 = require("@budibase/backend-core");
-const LinkDocument_1 = __importDefault(require("./LinkDocument"));
+const { IncludeDocs, getLinkDocuments } = require("./linkUtils");
+const { generateLinkID, InternalTables, getUserMetadataParams, } = require("../utils");
+const Sentry = require("@sentry/node");
+const { FieldTypes, RelationshipTypes } = require("../../constants");
+const { getAppDB } = require("@budibase/backend-core/context");
+/**
+ * Creates a new link document structure which can be put to the database. It is important to
+ * note that while this talks about linker/linked the link is bi-directional and for all intent
+ * and purposes it does not matter from which direction the link was initiated.
+ * @param {string} tableId1 The ID of the first table (the linker).
+ * @param {string} tableId2 The ID of the second table (the linked).
+ * @param {string} fieldName1 The name of the field in the linker table.
+ * @param {string} fieldName2 The name of the field in the linked table.
+ * @param {string} rowId1 The ID of the row which is acting as the linker.
+ * @param {string} rowId2 The ID of the row which is acting as the linked.
+ * @constructor
+ */
+function LinkDocument(tableId1, fieldName1, rowId1, tableId2, fieldName2, rowId2) {
+    // build the ID out of unique references to this link document
+    this._id = generateLinkID(tableId1, tableId2, rowId1, rowId2, fieldName1, fieldName2);
+    // required for referencing in view
+    this.type = FieldTypes.LINK;
+    this.doc1 = {
+        tableId: tableId1,
+        fieldName: fieldName1,
+        rowId: rowId1,
+    };
+    this.doc2 = {
+        tableId: tableId2,
+        fieldName: fieldName2,
+        rowId: rowId2,
+    };
+}
 class LinkController {
     constructor({ tableId, row, table, oldTable }) {
-        this._db = backend_core_1.context.getAppDB();
+        this._db = getAppDB();
         this._tableId = tableId;
         this._row = row;
         this._table = table;
@@ -46,14 +70,14 @@ class LinkController {
      * @returns {Promise<boolean>} True if there are any linked fields, otherwise it will return
      * false.
      */
-    doesTableHaveLinkedFields(table) {
+    doesTableHaveLinkedFields(table = null) {
         return __awaiter(this, void 0, void 0, function* () {
             if (table == null) {
                 table = yield this.table();
             }
             for (let fieldName of Object.keys(table.schema)) {
                 const { type } = table.schema[fieldName];
-                if (type === constants_1.FieldTypes.LINK) {
+                if (type === FieldTypes.LINK) {
                     return true;
                 }
             }
@@ -64,21 +88,19 @@ class LinkController {
      * Utility function for main getLinkDocuments function - refer to it for functionality.
      */
     getRowLinkDocs(rowId) {
-        return (0, linkUtils_1.getLinkDocuments)({
+        return getLinkDocuments({
             tableId: this._tableId,
             rowId,
-            includeDocs: linkUtils_1.IncludeDocs.INCLUDE,
+            includeDocs: IncludeDocs.INCLUDE,
         });
     }
     /**
      * Utility function for main getLinkDocuments function - refer to it for functionality.
      */
     getTableLinkDocs() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return (yield (0, linkUtils_1.getLinkDocuments)({
-                tableId: this._tableId,
-                includeDocs: linkUtils_1.IncludeDocs.INCLUDE,
-            }));
+        return getLinkDocuments({
+            tableId: this._tableId,
+            includeDocs: IncludeDocs.INCLUDE,
         });
     }
     /**
@@ -87,10 +109,10 @@ class LinkController {
     validateTable(table) {
         const usedAlready = [];
         for (let schema of Object.values(table.schema)) {
-            if (schema.type !== constants_1.FieldTypes.LINK) {
+            if (schema.type !== FieldTypes.LINK) {
                 continue;
             }
-            const unique = schema.tableId + (schema === null || schema === void 0 ? void 0 : schema.fieldName);
+            const unique = schema.tableId + schema.fieldName;
             if (usedAlready.indexOf(unique) !== -1) {
                 throw new Error("Cannot re-use the linked column name for a linked table.");
             }
@@ -110,7 +132,6 @@ class LinkController {
             "relationshipType",
         ];
         for (let field of compareFields) {
-            // @ts-ignore
             if (linkSchema1[field] !== linkSchema2[field]) {
                 return false;
             }
@@ -123,17 +144,17 @@ class LinkController {
      */
     handleRelationshipType(linkerField, linkedField) {
         if (!linkerField.relationshipType ||
-            linkerField.relationshipType === constants_1.RelationshipTypes.MANY_TO_MANY) {
-            linkedField.relationshipType = constants_1.RelationshipTypes.MANY_TO_MANY;
+            linkerField.relationshipType === RelationshipTypes.MANY_TO_MANY) {
+            linkedField.relationshipType = RelationshipTypes.MANY_TO_MANY;
             // make sure by default all are many to many (if not specified)
-            linkerField.relationshipType = constants_1.RelationshipTypes.MANY_TO_MANY;
+            linkerField.relationshipType = RelationshipTypes.MANY_TO_MANY;
         }
-        else if (linkerField.relationshipType === constants_1.RelationshipTypes.MANY_TO_ONE) {
+        else if (linkerField.relationshipType === RelationshipTypes.MANY_TO_ONE) {
             // Ensure that the other side of the relationship is locked to one record
-            linkedField.relationshipType = constants_1.RelationshipTypes.ONE_TO_MANY;
+            linkedField.relationshipType = RelationshipTypes.ONE_TO_MANY;
         }
-        else if (linkerField.relationshipType === constants_1.RelationshipTypes.ONE_TO_MANY) {
-            linkedField.relationshipType = constants_1.RelationshipTypes.MANY_TO_ONE;
+        else if (linkerField.relationshipType === RelationshipTypes.ONE_TO_MANY) {
+            linkedField.relationshipType = RelationshipTypes.MANY_TO_ONE;
         }
         return { linkerField, linkedField };
     }
@@ -151,12 +172,12 @@ class LinkController {
             const row = this._row;
             const operations = [];
             // get link docs to compare against
-            const linkDocs = (yield this.getRowLinkDocs(row._id));
+            const linkDocs = yield this.getRowLinkDocs(row._id);
             for (let fieldName of Object.keys(table.schema)) {
                 // get the links this row wants to make
                 const rowField = row[fieldName];
                 const field = table.schema[fieldName];
-                if (field.type === constants_1.FieldTypes.LINK && rowField != null) {
+                if (field.type === FieldTypes.LINK && rowField != null) {
                     // check which links actual pertain to the update in this row
                     const thisFieldLinkDocs = linkDocs.filter(linkDoc => linkDoc.doc1.fieldName === fieldName ||
                         linkDoc.doc2.fieldName === fieldName);
@@ -169,19 +190,19 @@ class LinkController {
                     const linkedTable = yield this._db.get(field.tableId);
                     const linkedSchema = linkedTable.schema[field.fieldName];
                     // We need to map the global users to metadata in each app for relationships
-                    if (field.tableId === utils_1.InternalTables.USER_METADATA) {
-                        const users = yield this._db.allDocs((0, utils_1.getUserMetadataParams)(null, {}));
-                        const metadataRequired = rowField.filter((userId) => !users.rows.some(user => user.id === userId));
+                    if (field.tableId === InternalTables.USER_METADATA) {
+                        const users = yield this._db.allDocs(getUserMetadataParams(null, {}));
+                        const metadataRequired = rowField.filter(userId => !users.rows.some(user => user.id === userId));
                         // ensure non-existing user metadata is created in the app DB
-                        yield this._db.bulkDocs(metadataRequired.map((userId) => ({ _id: userId })));
+                        yield this._db.bulkDocs(metadataRequired.map(userId => ({ _id: userId })));
                     }
                     // iterate through the link IDs in the row field, see if any don't exist already
                     for (let linkId of rowField) {
-                        if ((linkedSchema === null || linkedSchema === void 0 ? void 0 : linkedSchema.relationshipType) === constants_1.RelationshipTypes.ONE_TO_MANY) {
-                            let links = (yield (0, linkUtils_1.getLinkDocuments)({
+                        if (linkedSchema.relationshipType === RelationshipTypes.ONE_TO_MANY) {
+                            let links = (yield getLinkDocuments({
                                 tableId: field.tableId,
                                 rowId: linkId,
-                                includeDocs: linkUtils_1.IncludeDocs.EXCLUDE,
+                                includeDocs: IncludeDocs.EXCLUDE,
                             })).filter(link => link.id !== row._id && link.fieldName === linkedSchema.name);
                             // The 1 side of 1:N is already related to something else
                             // You must remove the existing relationship
@@ -198,7 +219,7 @@ class LinkController {
                                 // skip links that don't exist
                                 continue;
                             }
-                            operations.push(new LinkDocument_1.default(table._id, fieldName, row._id, field.tableId, field.fieldName, linkId));
+                            operations.push(new LinkDocument(table._id, fieldName, row._id, field.tableId, field.fieldName, linkId));
                         }
                     }
                     // find the docs that need to be deleted
@@ -249,10 +270,10 @@ class LinkController {
     removeFieldFromTable(fieldName) {
         return __awaiter(this, void 0, void 0, function* () {
             let oldTable = this._oldTable;
-            let field = oldTable === null || oldTable === void 0 ? void 0 : oldTable.schema[fieldName];
+            let field = oldTable.schema[fieldName];
             const linkDocs = yield this.getTableLinkDocs();
             let toDelete = linkDocs.filter(linkDoc => {
-                let correctFieldName = linkDoc.doc1.tableId === (oldTable === null || oldTable === void 0 ? void 0 : oldTable._id)
+                let correctFieldName = linkDoc.doc1.tableId === oldTable._id
                     ? linkDoc.doc1.fieldName
                     : linkDoc.doc2.fieldName;
                 return correctFieldName === fieldName;
@@ -262,9 +283,7 @@ class LinkController {
             }));
             // remove schema from other table
             let linkedTable = yield this._db.get(field.tableId);
-            if (field.fieldName) {
-                delete linkedTable.schema[field.fieldName];
-            }
+            delete linkedTable.schema[field.fieldName];
             yield this._db.put(linkedTable);
         });
     }
@@ -282,7 +301,7 @@ class LinkController {
             const schema = table.schema;
             for (let fieldName of Object.keys(schema)) {
                 const field = schema[fieldName];
-                if (field.type === constants_1.FieldTypes.LINK && field.fieldName) {
+                if (field.type === FieldTypes.LINK) {
                     // handle this in a separate try catch, want
                     // the put to bubble up as an error, if can't update
                     // table for some reason
@@ -296,7 +315,7 @@ class LinkController {
                     }
                     const fields = this.handleRelationshipType(field, {
                         name: field.fieldName,
-                        type: constants_1.FieldTypes.LINK,
+                        type: FieldTypes.LINK,
                         // these are the props of the table that initiated the link
                         tableId: table._id,
                         fieldName: fieldName,
@@ -336,10 +355,10 @@ class LinkController {
             const oldTable = this._oldTable;
             // first start by checking if any link columns have been deleted
             const newTable = yield this.table();
-            for (let fieldName of Object.keys((oldTable === null || oldTable === void 0 ? void 0 : oldTable.schema) || {})) {
-                const field = oldTable === null || oldTable === void 0 ? void 0 : oldTable.schema[fieldName];
+            for (let fieldName of Object.keys(oldTable.schema)) {
+                const field = oldTable.schema[fieldName];
                 // this field has been removed from the table schema
-                if (field.type === constants_1.FieldTypes.LINK &&
+                if (field.type === FieldTypes.LINK &&
                     newTable.schema[fieldName] == null) {
                     yield this.removeFieldFromTable(fieldName);
                 }
@@ -362,7 +381,7 @@ class LinkController {
             for (let fieldName of Object.keys(schema)) {
                 const field = schema[fieldName];
                 try {
-                    if (field.type === constants_1.FieldTypes.LINK && field.fieldName) {
+                    if (field.type === FieldTypes.LINK) {
                         const linkedTable = yield this._db.get(field.tableId);
                         delete linkedTable.schema[field.fieldName];
                         yield this._db.put(linkedTable);
@@ -370,7 +389,7 @@ class LinkController {
                 }
                 catch (err) {
                     /* istanbul ignore next */
-                    node_1.default.captureException(err);
+                    Sentry.captureException(err);
                 }
             }
             // need to get the full link docs to delete them

package/dist/db/linkedRows/index.js

@@ -8,29 +8,20 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-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; } });
+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");
 /**
  * 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.
  */
-exports.EventType = {
+const EventType = {
     ROW_SAVE: "row:save",
     ROW_UPDATE: "row:update",
     ROW_DELETE: "row:delete",
@@ -38,9 +29,14 @@ exports.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 === constants_1.FieldTypes.LINK) {
+        if (field.type === FieldTypes.LINK) {
             rows = rows.map(row => {
                 delete row[key];
                 return row;
@@ -53,14 +49,13 @@ 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 promises = tableIds.map(tableId => (0, linkUtils_1.getLinkDocuments)({
+        const responses = flatten(yield Promise.all(tableIds.map(tableId => getLinkDocuments({
             tableId: tableId,
-            includeDocs: linkUtils_1.IncludeDocs.EXCLUDE,
-        }));
-        const responses = (0, lodash_1.flatten)((yield Promise.all(promises)));
+            includeDocs: IncludeDocs.EXCLUDE,
+        }))));
         // have to get unique as the previous table query can
         // return duplicates, could be querying for both tables in a relation
-        return (0, linkUtils_1.getUniqueByProp)(responses
+        return 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");
@@ -69,17 +64,17 @@ function getLinksForRows(rows) {
 function getFullLinkedDocs(links) {
     return __awaiter(this, void 0, void 0, function* () {
         // create DBs
-        const db = backend_core_1.context.getAppDB();
+        const db = getAppDB();
         const linkedRowIds = links.map(link => link.id);
         const uniqueRowIds = [...new Set(linkedRowIds)];
-        let dbRows = (yield db.allDocs((0, utils_1.getMultiIDParams)(uniqueRowIds))).rows.map(row => row.doc);
+        let dbRows = (yield db.allDocs(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] = (0, lodash_2.partition)(linked, linkRow => linkRow._id.startsWith(utils_1.USER_METDATA_PREFIX));
-        users = yield (0, global_1.getGlobalUsersFromMetadata)(users);
+        let [users, other] = partition(linked, linkRow => linkRow._id.startsWith(USER_METDATA_PREFIX));
+        users = yield getGlobalUsersFromMetadata(users);
         return [...other, ...users];
     });
 }
@@ -94,7 +89,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.
  */
-function updateLinks(args) {
+exports.updateLinks = function (args) {
     return __awaiter(this, void 0, void 0, function* () {
         const { eventType, row, tableId, table, oldTable } = args;
         const baseReturnObj = row == null ? table : row;
@@ -102,7 +97,7 @@ function updateLinks(args) {
         if (tableId == null && table != null) {
             args.tableId = table._id;
         }
-        let linkController = new LinkController_1.default(args);
+        let linkController = new LinkController(args);
         try {
             if (!(yield linkController.doesTableHaveLinkedFields(table)) &&
                 (oldTable == null ||
@@ -114,23 +109,22 @@ function updateLinks(args) {
             return baseReturnObj;
         }
         switch (eventType) {
-            case exports.EventType.ROW_SAVE:
-            case exports.EventType.ROW_UPDATE:
+            case EventType.ROW_SAVE:
+            case EventType.ROW_UPDATE:
                 return yield linkController.rowSaved();
-            case exports.EventType.ROW_DELETE:
+            case EventType.ROW_DELETE:
                 return yield linkController.rowDeleted();
-            case exports.EventType.TABLE_SAVE:
+            case EventType.TABLE_SAVE:
                 return yield linkController.tableSaved();
-            case exports.EventType.TABLE_UPDATED:
+            case EventType.TABLE_UPDATED:
                 return yield linkController.tableUpdated();
-            case exports.EventType.TABLE_DELETE:
+            case 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).
@@ -138,69 +132,63 @@ exports.updateLinks = updateLinks;
  * @param {array<object>} rows The rows which are to be enriched.
  * @return {Promise<*>} returns the rows with all of the enriched relationships on it.
  */
-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));
-                    }
+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));
                 }
             }
         }
-        return rows;
-    });
-}
-exports.attachFullLinkedDocs = attachFullLinkedDocs;
+    }
+    return rows;
+});
 /**
  * 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.
  */
-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);
+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];
                 }
-                row[column] = newLinks;
+                newLinks.push(obj);
             }
+            row[column] = newLinks;
         }
-        return enriched;
-    });
-}
-exports.squashLinksToPrimaryDisplay = squashLinksToPrimaryDisplay;
+    }
+    return enriched;
+});