@budibase/server 2.6.23 → 2.6.24-alpha.0

package/dist/db/inMemoryView.js

@@ -1,62 +0,0 @@
-"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());
-    });
-};
-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 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 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;
-        }
-        finally {
-            yield db.destroy();
-            yield backend_core_1.db.closePouchDB(db);
-        }
-    });
-}
-exports.runView = runView;

package/dist/db/index.js

@@ -1,43 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.init = void 0;
-const core = __importStar(require("@budibase/backend-core"));
-const environment_1 = __importDefault(require("../environment"));
-function init() {
-    const dbConfig = {
-        replication: true,
-        find: true,
-    };
-    if (environment_1.default.isTest() && !environment_1.default.COUCH_DB_URL) {
-        dbConfig.inMemory = true;
-        dbConfig.allDbs = true;
-    }
-    core.init({ db: dbConfig });
-}
-exports.init = init;

package/dist/db/linkedRows/LinkController.js

@@ -1,392 +0,0 @@
-"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());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-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 types_1 = require("@budibase/types");
-class LinkController {
-    constructor({ tableId, row, table, oldTable }) {
-        this._db = backend_core_1.context.getAppDB();
-        this._tableId = tableId;
-        this._row = row;
-        this._table = table;
-        this._oldTable = oldTable;
-    }
-    /**
-     * Retrieves the table, if it was not already found in the eventData.
-     * @returns {Promise<object>} This will return a table based on the event data, either
-     * if it was in the event already, or it uses the specified tableId to get it.
-     */
-    table() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this._table == null) {
-                this._table =
-                    this._table == null ? yield this._db.get(this._tableId) : this._table;
-            }
-            return this._table;
-        });
-    }
-    /**
-     * Checks if the table this was constructed with has any linking columns currently.
-     * If the table has not been retrieved this will retrieve it based on the eventData.
-     * @params {object|null} table If a table that is not known to the link controller is to be tested.
-     * @returns {Promise<boolean>} True if there are any linked fields, otherwise it will return
-     * false.
-     */
-    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 === constants_1.FieldTypes.LINK) {
-                    return true;
-                }
-            }
-            return false;
-        });
-    }
-    /**
-     * Utility function for main getLinkDocuments function - refer to it for functionality.
-     */
-    getRowLinkDocs(rowId) {
-        return (0, linkUtils_1.getLinkDocuments)({
-            tableId: this._tableId,
-            rowId,
-            includeDocs: linkUtils_1.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,
-            }));
-        });
-    }
-    /**
-     * Makes sure the passed in table schema contains valid relationship structures.
-     */
-    validateTable(table) {
-        const usedAlready = [];
-        for (let schema of Object.values(table.schema)) {
-            if (schema.type !== constants_1.FieldTypes.LINK) {
-                continue;
-            }
-            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.");
-            }
-            usedAlready.push(unique);
-        }
-    }
-    /**
-     * Returns whether the two link schemas are equal (in the important parts, not a pure equality check)
-     */
-    areLinkSchemasEqual(linkSchema1, linkSchema2) {
-        const compareFields = [
-            "name",
-            "type",
-            "tableId",
-            "fieldName",
-            "autocolumn",
-            "relationshipType",
-        ];
-        for (let field of compareFields) {
-            // @ts-ignore
-            if (linkSchema1[field] !== linkSchema2[field]) {
-                return false;
-            }
-        }
-        return true;
-    }
-    /**
-     * Given the link field of this table, and the link field of the linked table, this makes sure
-     * the state of relationship type is accurate on both.
-     */
-    handleRelationshipType(linkerField, linkedField) {
-        if (!linkerField.relationshipType ||
-            linkerField.relationshipType === types_1.RelationshipTypes.MANY_TO_MANY) {
-            linkedField.relationshipType = types_1.RelationshipTypes.MANY_TO_MANY;
-            // make sure by default all are many to many (if not specified)
-            linkerField.relationshipType = types_1.RelationshipTypes.MANY_TO_MANY;
-        }
-        else if (linkerField.relationshipType === types_1.RelationshipTypes.MANY_TO_ONE) {
-            // Ensure that the other side of the relationship is locked to one record
-            linkedField.relationshipType = types_1.RelationshipTypes.ONE_TO_MANY;
-        }
-        else if (linkerField.relationshipType === types_1.RelationshipTypes.ONE_TO_MANY) {
-            linkedField.relationshipType = types_1.RelationshipTypes.MANY_TO_ONE;
-        }
-        return { linkerField, linkedField };
-    }
-    // all operations here will assume that the table
-    // this operation is related to has linked rows
-    /**
-     * When a row is saved this will carry out the necessary operations to make sure
-     * the link has been created/updated.
-     * @returns {Promise<object>} returns the row that has been cleaned and prepared to be written to the DB - links
-     * have also been created.
-     */
-    rowSaved() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const table = yield this.table();
-            const row = this._row;
-            const operations = [];
-            // get link docs to compare against
-            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) {
-                    // check which links actual pertain to the update in this row
-                    const thisFieldLinkDocs = linkDocs.filter(linkDoc => linkDoc.doc1.fieldName === fieldName ||
-                        linkDoc.doc2.fieldName === fieldName);
-                    const linkDocIds = thisFieldLinkDocs.map(linkDoc => {
-                        return linkDoc.doc1.rowId === row._id
-                            ? linkDoc.doc2.rowId
-                            : linkDoc.doc1.rowId;
-                    });
-                    // if 1:N, ensure that this ID is not already attached to another record
-                    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));
-                        // ensure non-existing user metadata is created in the app DB
-                        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) === types_1.RelationshipTypes.ONE_TO_MANY) {
-                            let links = (yield (0, linkUtils_1.getLinkDocuments)({
-                                tableId: field.tableId,
-                                rowId: linkId,
-                                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
-                            if (links.length > 0) {
-                                throw new Error(`1:N Relationship Error: Record already linked to another.`);
-                            }
-                        }
-                        if (linkId && linkId !== "" && linkDocIds.indexOf(linkId) === -1) {
-                            // first check the doc we're linking to exists
-                            try {
-                                yield this._db.get(linkId);
-                            }
-                            catch (err) {
-                                // skip links that don't exist
-                                continue;
-                            }
-                            operations.push(new LinkDocument_1.default(table._id, fieldName, row._id, field.tableId, field.fieldName, linkId));
-                        }
-                    }
-                    // find the docs that need to be deleted
-                    let toDeleteDocs = thisFieldLinkDocs
-                        .filter(doc => {
-                        let correctDoc = doc.doc1.fieldName === fieldName ? doc.doc2 : doc.doc1;
-                        return rowField.indexOf(correctDoc.rowId) === -1;
-                    })
-                        .map(doc => {
-                        return Object.assign(Object.assign({}, doc), { _deleted: true });
-                    });
-                    // now add the docs to be deleted to the bulk operation
-                    operations.push(...toDeleteDocs);
-                    // remove the field from this row, link doc will be added to row on way out
-                    delete row[fieldName];
-                }
-            }
-            yield this._db.bulkDocs(operations);
-            return row;
-        });
-    }
-    /**
-     * When a row is deleted this will carry out the necessary operations to make sure
-     * any links that existed have been removed.
-     * @returns {Promise<object>} The operation has been completed and the link documents should now
-     * be accurate. This also returns the row that was deleted.
-     */
-    rowDeleted() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const row = this._row;
-            // need to get the full link docs to be be able to delete it
-            const linkDocs = yield this.getRowLinkDocs(row._id);
-            if (linkDocs.length === 0) {
-                return null;
-            }
-            const toDelete = linkDocs.map(doc => {
-                return Object.assign(Object.assign({}, doc), { _deleted: true });
-            });
-            yield this._db.bulkDocs(toDelete);
-            return row;
-        });
-    }
-    /**
-     * Remove a field from a table as well as any linked rows that pertained to it.
-     * @param {string} fieldName The field to be removed from the table.
-     * @returns {Promise<void>} The table has now been updated.
-     */
-    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];
-            const linkDocs = yield this.getTableLinkDocs();
-            let toDelete = linkDocs.filter(linkDoc => {
-                let correctFieldName = linkDoc.doc1.tableId === (oldTable === null || oldTable === void 0 ? void 0 : oldTable._id)
-                    ? linkDoc.doc1.fieldName
-                    : linkDoc.doc2.fieldName;
-                return correctFieldName === fieldName;
-            });
-            yield this._db.bulkDocs(toDelete.map(doc => {
-                return Object.assign(Object.assign({}, doc), { _deleted: true });
-            }));
-            // remove schema from other table
-            let linkedTable = yield this._db.get(field.tableId);
-            if (field.fieldName) {
-                delete linkedTable.schema[field.fieldName];
-            }
-            yield this._db.put(linkedTable);
-        });
-    }
-    /**
-     * When a table is saved this will carry out the necessary operations to make sure
-     * any linked tables are notified and updated correctly.
-     * @returns {Promise<object>} The operation has been completed and the link documents should now
-     * be accurate. Also returns the table that was operated on.
-     */
-    tableSaved() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const table = yield this.table();
-            // validate the table first
-            this.validateTable(table);
-            const schema = table.schema;
-            for (let fieldName of Object.keys(schema)) {
-                const field = schema[fieldName];
-                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
-                    let linkedTable;
-                    try {
-                        linkedTable = yield this._db.get(field.tableId);
-                    }
-                    catch (err) {
-                        /* istanbul ignore next */
-                        continue;
-                    }
-                    const fields = this.handleRelationshipType(field, {
-                        name: field.fieldName,
-                        type: constants_1.FieldTypes.LINK,
-                        // these are the props of the table that initiated the link
-                        tableId: table._id,
-                        fieldName: fieldName,
-                    });
-                    // update table schema after checking relationship types
-                    schema[fieldName] = fields.linkerField;
-                    const linkedField = fields.linkedField;
-                    if (field.autocolumn) {
-                        linkedField.autocolumn = field.autocolumn;
-                        linkedField.subtype = field.subtype;
-                    }
-                    // check the linked table to make sure we aren't overwriting an existing column
-                    const existingSchema = linkedTable.schema[field.fieldName];
-                    if (existingSchema != null &&
-                        !this.areLinkSchemasEqual(existingSchema, linkedField)) {
-                        throw new Error("Cannot overwrite existing column.");
-                    }
-                    // create the link field in the other table
-                    linkedTable.schema[field.fieldName] = linkedField;
-                    const response = yield this._db.put(linkedTable);
-                    // special case for when linking back to self, make sure rev updated
-                    if (linkedTable._id === table._id) {
-                        table._rev = response.rev;
-                    }
-                }
-            }
-            return table;
-        });
-    }
-    /**
-     * Update a table, this means if a field is removed need to handle removing from other table and removing
-     * any link docs that pertained to it.
-     * @returns {Promise<Object>} The table which has been saved, same response as with the tableSaved function.
-     */
-    tableUpdated() {
-        return __awaiter(this, void 0, void 0, function* () {
-            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];
-                // this field has been removed from the table schema
-                if (field.type === constants_1.FieldTypes.LINK &&
-                    newTable.schema[fieldName] == null) {
-                    yield this.removeFieldFromTable(fieldName);
-                }
-            }
-            // now handle as if its a new save
-            return this.tableSaved();
-        });
-    }
-    /**
-     * When a table is deleted this will carry out the necessary operations to make sure
-     * any linked tables have the joining column correctly removed as well as removing any
-     * now stale linking documents.
-     * @returns {Promise<object>} The operation has been completed and the link documents should now
-     * be accurate. Also returns the table that was operated on.
-     */
-    tableDeleted() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const table = yield this.table();
-            const schema = table.schema;
-            for (let fieldName of Object.keys(schema)) {
-                const field = schema[fieldName];
-                try {
-                    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);
-                    }
-                }
-                catch (err) {
-                    /* istanbul ignore next */
-                    node_1.default.captureException(err);
-                }
-            }
-            // need to get the full link docs to delete them
-            const linkDocs = yield this.getTableLinkDocs();
-            if (linkDocs.length === 0) {
-                return null;
-            }
-            // get link docs for this table and configure for deletion
-            const toDelete = linkDocs.map(doc => {
-                return Object.assign(Object.assign({}, doc), { _deleted: true });
-            });
-            yield this._db.bulkDocs(toDelete);
-            return table;
-        });
-    }
-}
-exports.default = LinkController;

package/dist/db/linkedRows/LinkDocument.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-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,
-        };
-    }
-}
-exports.default = LinkDocumentImpl;