@budibase/server 2.1.45 → 2.1.46-alpha.1

package/dist/db/inMemoryView.js

@@ -8,46 +8,55 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-const newid = require("./newid");
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runView = void 0;
+const newid_1 = __importDefault(require("./newid"));
 // bypass the main application db config
 // use in memory pouchdb directly
-const { getPouch, closeDB } = require("@budibase/backend-core/db");
-const Pouch = getPouch({ inMemory: true });
-exports.runView = (view, calculation, group, data) => __awaiter(void 0, void 0, void 0, function* () {
-    // use a different ID each time for the DB, make sure they
-    // are always unique for each query, don't want overlap
-    // which could cause 409s
-    const db = new Pouch(newid());
-    try {
-        // write all the docs to the in memory Pouch (remove revs)
-        yield db.bulkDocs(data.map(row => (Object.assign(Object.assign({}, row), { _rev: undefined }))));
-        let fn = (doc, emit) => emit(doc._id);
-        eval("fn = " + view.map.replace("function (doc)", "function (doc, emit)"));
-        const queryFns = {
-            meta: view.meta,
-            map: fn,
-        };
-        if (view.reduce) {
-            queryFns.reduce = view.reduce;
-        }
-        const response = yield db.query(queryFns, {
-            include_docs: !calculation,
-            group: !!group,
-        });
-        // need to fix the revs to be totally accurate
-        for (let row of response.rows) {
-            if (!row._rev || !row._id) {
-                continue;
+const backend_core_1 = require("@budibase/backend-core");
+const Pouch = backend_core_1.db.getPouch({ inMemory: true });
+function runView(view, calculation, group, data) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        // use a different ID each time for the DB, make sure they
+        // are always unique for each query, don't want overlap
+        // which could cause 409s
+        const db = new Pouch((0, newid_1.default)());
+        try {
+            // write all the docs to the in memory Pouch (remove revs)
+            yield db.bulkDocs(data.map(row => (Object.assign(Object.assign({}, row), { _rev: undefined }))));
+            let fn = (doc, emit) => emit(doc._id);
+            eval("fn = " + ((_a = view === null || view === void 0 ? void 0 : view.map) === null || _a === void 0 ? void 0 : _a.replace("function (doc)", "function (doc, emit)")));
+            const queryFns = {
+                meta: view.meta,
+                map: fn,
+            };
+            if (view.reduce) {
+                queryFns.reduce = view.reduce;
             }
-            const found = data.find(possible => possible._id === row._id);
-            if (found) {
-                row._rev = found._rev;
+            const response = yield db.query(queryFns, {
+                include_docs: !calculation,
+                group: !!group,
+            });
+            // need to fix the revs to be totally accurate
+            for (let row of response.rows) {
+                if (!row._rev || !row._id) {
+                    continue;
+                }
+                const found = data.find(possible => possible._id === row._id);
+                if (found) {
+                    row._rev = found._rev;
+                }
             }
+            return response;
         }
-        return response;
-    }
-    finally {
-        yield db.destroy();
-        yield closeDB(db);
-    }
-});
+        finally {
+            yield db.destroy();
+            yield backend_core_1.db.closePouchDB(db);
+        }
+    });
+}
+exports.runView = runView;

package/dist/db/index.js

@@ -1,7 +1,9 @@
 "use strict";
-const core = require("@budibase/backend-core");
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = void 0;
+const backend_core_1 = require("@budibase/backend-core");
 const env = require("../environment");
-exports.init = () => {
+function init() {
     const dbConfig = {
         replication: true,
         find: true,
@@ -10,5 +12,6 @@ exports.init = () => {
         dbConfig.inMemory = true;
         dbConfig.allDbs = true;
     }
-    core.init({ db: dbConfig });
-};
+    (0, backend_core_1.init)({ db: dbConfig });
+}
+exports.init = init;

package/dist/db/linkedRows/LinkController.js

@@ -8,42 +8,18 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-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,
-    };
-}
+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"));
 class LinkController {
     constructor({ tableId, row, table, oldTable }) {
-        this._db = getAppDB();
+        this._db = backend_core_1.context.getAppDB();
         this._tableId = tableId;
         this._row = row;
         this._table = table;
@@ -70,14 +46,14 @@ class LinkController {
      * @returns {Promise<boolean>} True if there are any linked fields, otherwise it will return
      * false.
      */
-    doesTableHaveLinkedFields(table = null) {
+    doesTableHaveLinkedFields(table) {
         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 === FieldTypes.LINK) {
+                if (type === constants_1.FieldTypes.LINK) {
                     return true;
                 }
             }
@@ -88,19 +64,21 @@ class LinkController {
      * Utility function for main getLinkDocuments function - refer to it for functionality.
      */
     getRowLinkDocs(rowId) {
-        return getLinkDocuments({
+        return (0, linkUtils_1.getLinkDocuments)({
             tableId: this._tableId,
             rowId,
-            includeDocs: IncludeDocs.INCLUDE,
+            includeDocs: linkUtils_1.IncludeDocs.INCLUDE,
         });
     }
     /**
      * Utility function for main getLinkDocuments function - refer to it for functionality.
      */
     getTableLinkDocs() {
-        return getLinkDocuments({
-            tableId: this._tableId,
-            includeDocs: IncludeDocs.INCLUDE,
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield (0, linkUtils_1.getLinkDocuments)({
+                tableId: this._tableId,
+                includeDocs: linkUtils_1.IncludeDocs.INCLUDE,
+            }));
         });
     }
     /**
@@ -109,10 +87,10 @@ class LinkController {
     validateTable(table) {
         const usedAlready = [];
         for (let schema of Object.values(table.schema)) {
-            if (schema.type !== FieldTypes.LINK) {
+            if (schema.type !== constants_1.FieldTypes.LINK) {
                 continue;
             }
-            const unique = schema.tableId + schema.fieldName;
+            const unique = schema.tableId + (schema === null || schema === void 0 ? void 0 : schema.fieldName);
             if (usedAlready.indexOf(unique) !== -1) {
                 throw new Error("Cannot re-use the linked column name for a linked table.");
             }
@@ -132,6 +110,7 @@ class LinkController {
             "relationshipType",
         ];
         for (let field of compareFields) {
+            // @ts-ignore
             if (linkSchema1[field] !== linkSchema2[field]) {
                 return false;
             }
@@ -144,17 +123,17 @@ class LinkController {
      */
     handleRelationshipType(linkerField, linkedField) {
         if (!linkerField.relationshipType ||
-            linkerField.relationshipType === RelationshipTypes.MANY_TO_MANY) {
-            linkedField.relationshipType = RelationshipTypes.MANY_TO_MANY;
+            linkerField.relationshipType === constants_1.RelationshipTypes.MANY_TO_MANY) {
+            linkedField.relationshipType = constants_1.RelationshipTypes.MANY_TO_MANY;
             // make sure by default all are many to many (if not specified)
-            linkerField.relationshipType = RelationshipTypes.MANY_TO_MANY;
+            linkerField.relationshipType = constants_1.RelationshipTypes.MANY_TO_MANY;
         }
-        else if (linkerField.relationshipType === RelationshipTypes.MANY_TO_ONE) {
+        else if (linkerField.relationshipType === constants_1.RelationshipTypes.MANY_TO_ONE) {
             // Ensure that the other side of the relationship is locked to one record
-            linkedField.relationshipType = RelationshipTypes.ONE_TO_MANY;
+            linkedField.relationshipType = constants_1.RelationshipTypes.ONE_TO_MANY;
         }
-        else if (linkerField.relationshipType === RelationshipTypes.ONE_TO_MANY) {
-            linkedField.relationshipType = RelationshipTypes.MANY_TO_ONE;
+        else if (linkerField.relationshipType === constants_1.RelationshipTypes.ONE_TO_MANY) {
+            linkedField.relationshipType = constants_1.RelationshipTypes.MANY_TO_ONE;
         }
         return { linkerField, linkedField };
     }
@@ -172,12 +151,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 === FieldTypes.LINK && rowField != null) {
+                if (field.type === constants_1.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);
@@ -190,19 +169,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 === InternalTables.USER_METADATA) {
-                        const users = yield this._db.allDocs(getUserMetadataParams(null, {}));
-                        const metadataRequired = rowField.filter(userId => !users.rows.some(user => user.id === userId));
+                    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));
                         // 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.relationshipType === RelationshipTypes.ONE_TO_MANY) {
-                            let links = (yield getLinkDocuments({
+                        if ((linkedSchema === null || linkedSchema === void 0 ? void 0 : linkedSchema.relationshipType) === constants_1.RelationshipTypes.ONE_TO_MANY) {
+                            let links = (yield (0, linkUtils_1.getLinkDocuments)({
                                 tableId: field.tableId,
                                 rowId: linkId,
-                                includeDocs: IncludeDocs.EXCLUDE,
+                                includeDocs: linkUtils_1.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
@@ -219,7 +198,7 @@ class LinkController {
                                 // skip links that don't exist
                                 continue;
                             }
-                            operations.push(new LinkDocument(table._id, fieldName, row._id, field.tableId, field.fieldName, linkId));
+                            operations.push(new LinkDocument_1.default(table._id, fieldName, row._id, field.tableId, field.fieldName, linkId));
                         }
                     }
                     // find the docs that need to be deleted
@@ -270,10 +249,10 @@ class LinkController {
     removeFieldFromTable(fieldName) {
         return __awaiter(this, void 0, void 0, function* () {
             let oldTable = this._oldTable;
-            let field = oldTable.schema[fieldName];
+            let field = oldTable === null || oldTable === void 0 ? void 0 : oldTable.schema[fieldName];
             const linkDocs = yield this.getTableLinkDocs();
             let toDelete = linkDocs.filter(linkDoc => {
-                let correctFieldName = linkDoc.doc1.tableId === oldTable._id
+                let correctFieldName = linkDoc.doc1.tableId === (oldTable === null || oldTable === void 0 ? void 0 : oldTable._id)
                     ? linkDoc.doc1.fieldName
                     : linkDoc.doc2.fieldName;
                 return correctFieldName === fieldName;
@@ -283,7 +262,9 @@ class LinkController {
             }));
             // remove schema from other table
             let linkedTable = yield this._db.get(field.tableId);
-            delete linkedTable.schema[field.fieldName];
+            if (field.fieldName) {
+                delete linkedTable.schema[field.fieldName];
+            }
             yield this._db.put(linkedTable);
         });
     }
@@ -301,7 +282,7 @@ class LinkController {
             const schema = table.schema;
             for (let fieldName of Object.keys(schema)) {
                 const field = schema[fieldName];
-                if (field.type === FieldTypes.LINK) {
+                if (field.type === constants_1.FieldTypes.LINK && field.fieldName) {
                     // handle this in a separate try catch, want
                     // the put to bubble up as an error, if can't update
                     // table for some reason
@@ -315,7 +296,7 @@ class LinkController {
                     }
                     const fields = this.handleRelationshipType(field, {
                         name: field.fieldName,
-                        type: FieldTypes.LINK,
+                        type: constants_1.FieldTypes.LINK,
                         // these are the props of the table that initiated the link
                         tableId: table._id,
                         fieldName: fieldName,
@@ -355,10 +336,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.schema)) {
-                const field = oldTable.schema[fieldName];
+            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];
                 // this field has been removed from the table schema
-                if (field.type === FieldTypes.LINK &&
+                if (field.type === constants_1.FieldTypes.LINK &&
                     newTable.schema[fieldName] == null) {
                     yield this.removeFieldFromTable(fieldName);
                 }
@@ -381,7 +362,7 @@ class LinkController {
             for (let fieldName of Object.keys(schema)) {
                 const field = schema[fieldName];
                 try {
-                    if (field.type === FieldTypes.LINK) {
+                    if (field.type === constants_1.FieldTypes.LINK && field.fieldName) {
                         const linkedTable = yield this._db.get(field.tableId);
                         delete linkedTable.schema[field.fieldName];
                         yield this._db.put(linkedTable);
@@ -389,7 +370,7 @@ class LinkController {
                 }
                 catch (err) {
                     /* istanbul ignore next */
-                    Sentry.captureException(err);
+                    node_1.default.captureException(err);
                 }
             }
             // need to get the full link docs to delete them

package/dist/db/linkedRows/LinkDocument.js

@@ -0,0 +1,32 @@
+"use strict";
+const utils_1 = require("../utils");
+const constants_1 = require("../../constants");
+/**
+ * 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
+ */
+class LinkDocumentImpl {
+    constructor(tableId1, fieldName1, rowId1, tableId2, fieldName2, rowId2) {
+        this._id = (0, utils_1.generateLinkID)(tableId1, tableId2, rowId1, rowId2, fieldName1, fieldName2);
+        this.type = constants_1.FieldTypes.LINK;
+        this.doc1 = {
+            tableId: tableId1,
+            fieldName: fieldName1,
+            rowId: rowId1,
+        };
+        this.doc2 = {
+            tableId: tableId2,
+            fieldName: fieldName2,
+            rowId: rowId2,
+        };
+    }
+}
+module.exports = LinkDocumentImpl;