@budibase/server 2.1.43-alpha.1 → 2.1.43

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

@@ -8,15 +8,11 @@ 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.fullSearch = exports.paginatedSearch = exports.QueryBuilder = void 0;
-const utils_1 = require("../../../db/utils");
-const utils_2 = require("./utils");
-const node_fetch_1 = __importDefault(require("node-fetch"));
-const backend_core_1 = require("@budibase/backend-core");
+const { SearchIndexes } = require("../../../db/utils");
+const { removeKeyNumbering } = require("./utils");
+const fetch = require("node-fetch");
+const { getCouchInfo } = require("@budibase/backend-core/db");
+const { getAppId } = require("@budibase/backend-core/context");
 /**
  * Class to build lucene query URLs.
  * Optionally takes a base lucene query object.
@@ -28,11 +24,10 @@ class QueryBuilder {
         this.sortOrder = "ascending";
         this.sortType = "string";
         this.includeDocs = true;
+        this.version = null;
     }
     setVersion(version) {
-        if (version != null) {
-            this.version = version;
-        }
+        this.version = version;
         return this;
     }
     setTable(tableId) {
@@ -64,9 +59,7 @@ class QueryBuilder {
         return this;
     }
     setBookmark(bookmark) {
-        if (bookmark != null) {
-            this.bookmark = bookmark;
-        }
+        this.bookmark = bookmark;
         return this;
     }
     excludeDocs() {
@@ -82,7 +75,7 @@ class QueryBuilder {
         return this;
     }
     addRange(key, low, high) {
-        this.query.range[key] = {
+        this.query.range = {
             low,
             high,
         };
@@ -181,7 +174,6 @@ class QueryBuilder {
             return `${key}:(${statement})`;
         };
         const notContains = (key, value) => {
-            // @ts-ignore
             const allPrefix = allOr === "" ? "*:* AND" : "";
             return allPrefix + "NOT " + contains(key, value);
         };
@@ -206,7 +198,7 @@ class QueryBuilder {
         function build(structure, queryFn) {
             for (let [key, value] of Object.entries(structure)) {
                 // check for new format - remove numbering if needed
-                key = (0, utils_2.removeKeyNumbering)(key);
+                key = removeKeyNumbering(key);
                 key = builder.preprocess(key.replace(/ /g, "_"), {
                     escape: true,
                 });
@@ -275,10 +267,10 @@ class QueryBuilder {
             });
         }
         if (this.query.empty) {
-            build(this.query.empty, (key) => `!${key}:["" TO *]`);
+            build(this.query.empty, key => `!${key}:["" TO *]`);
         }
         if (this.query.notEmpty) {
-            build(this.query.notEmpty, (key) => `${key}:["" TO *]`);
+            build(this.query.notEmpty, key => `${key}:["" TO *]`);
         }
         if (this.query.oneOf) {
             build(this.query.oneOf, oneOf);
@@ -318,14 +310,15 @@ class QueryBuilder {
     }
     run() {
         return __awaiter(this, void 0, void 0, function* () {
-            const appId = backend_core_1.context.getAppId();
-            const { url, cookie } = backend_core_1.db.getCouchInfo();
-            const fullPath = `${url}/${appId}/_design/database/_search/${utils_1.SearchIndexes.ROWS}`;
+            const appId = getAppId();
+            const { url, cookie } = getCouchInfo();
+            const fullPath = `${url}/${appId}/_design/database/_search/${SearchIndexes.ROWS}`;
             const body = this.buildSearchBody();
             return yield runQuery(fullPath, body, cookie);
         });
     }
 }
+// exported for unit testing
 exports.QueryBuilder = QueryBuilder;
 /**
  * Executes a lucene search query.
@@ -335,7 +328,7 @@ exports.QueryBuilder = QueryBuilder;
  * @returns {Promise<{rows: []}>}
  */
 const runQuery = (url, body, cookie) => __awaiter(void 0, void 0, void 0, function* () {
-    const response = yield (0, node_fetch_1.default)(url, {
+    const response = yield fetch(url, {
         body: JSON.stringify(body),
         method: "POST",
         headers: {
@@ -347,7 +340,7 @@ const runQuery = (url, body, cookie) => __awaiter(void 0, void 0, void 0, functi
         rows: [],
     };
     if (json.rows != null && json.rows.length > 0) {
-        output.rows = json.rows.map((row) => row.doc);
+        output.rows = json.rows.map(row => row.doc);
     }
     if (json.bookmark) {
         output.bookmark = json.bookmark;
@@ -370,36 +363,34 @@ const runQuery = (url, body, cookie) => __awaiter(void 0, void 0, void 0, functi
  *   rows {array|null} Current results in the recursive search
  * @returns {Promise<*[]|*>}
  */
-function recursiveSearch(query, params) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const bookmark = params.bookmark;
-        const rows = params.rows || [];
-        if (rows.length >= params.limit) {
-            return rows;
-        }
-        let pageSize = 200;
-        if (rows.length > params.limit - 200) {
-            pageSize = params.limit - rows.length;
-        }
-        const page = yield new QueryBuilder(query)
-            .setVersion(params.version)
-            .setTable(params.tableId)
-            .setBookmark(bookmark)
-            .setLimit(pageSize)
-            .setSort(params.sort)
-            .setSortOrder(params.sortOrder)
-            .setSortType(params.sortType)
-            .run();
-        if (!page.rows.length) {
-            return rows;
-        }
-        if (page.rows.length < 200) {
-            return [...rows, ...page.rows];
-        }
-        const newParams = Object.assign(Object.assign({}, params), { bookmark: page.bookmark, rows: [...rows, ...page.rows] });
-        return yield recursiveSearch(query, newParams);
-    });
-}
+const recursiveSearch = (query, params) => __awaiter(void 0, void 0, void 0, function* () {
+    const bookmark = params.bookmark;
+    const rows = params.rows || [];
+    if (rows.length >= params.limit) {
+        return rows;
+    }
+    let pageSize = 200;
+    if (rows.length > params.limit - 200) {
+        pageSize = params.limit - rows.length;
+    }
+    const page = yield new QueryBuilder(query)
+        .setVersion(params.version)
+        .setTable(params.tableId)
+        .setBookmark(bookmark)
+        .setLimit(pageSize)
+        .setSort(params.sort)
+        .setSortOrder(params.sortOrder)
+        .setSortType(params.sortType)
+        .run();
+    if (!page.rows.length) {
+        return rows;
+    }
+    if (page.rows.length < 200) {
+        return [...rows, ...page.rows];
+    }
+    const newParams = Object.assign(Object.assign({}, params), { bookmark: page.bookmark, rows: [...rows, ...page.rows] });
+    return yield recursiveSearch(query, newParams);
+});
 /**
  * Performs a paginated search. A bookmark will be returned to allow the next
  * page to be fetched. There is a max limit off 200 results per page in a
@@ -415,34 +406,31 @@ function recursiveSearch(query, params) {
  *   bookmark {string} The bookmark to resume from
  * @returns {Promise<{hasNextPage: boolean, rows: *[]}>}
  */
-function paginatedSearch(query, params) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let limit = params.limit;
-        if (limit == null || isNaN(limit) || limit < 0) {
-            limit = 50;
-        }
-        limit = Math.min(limit, 200);
-        const search = new QueryBuilder(query)
-            .setVersion(params.version)
-            .setTable(params.tableId)
-            .setSort(params.sort)
-            .setSortOrder(params.sortOrder)
-            .setSortType(params.sortType);
-        const searchResults = yield search
-            .setBookmark(params.bookmark)
-            .setLimit(limit)
-            .run();
-        // Try fetching 1 row in the next page to see if another page of results
-        // exists or not
-        const nextResults = yield search
-            .setTable(params.tableId)
-            .setBookmark(searchResults.bookmark)
-            .setLimit(1)
-            .run();
-        return Object.assign(Object.assign({}, searchResults), { hasNextPage: nextResults.rows && nextResults.rows.length > 0 });
-    });
-}
-exports.paginatedSearch = paginatedSearch;
+exports.paginatedSearch = (query, params) => __awaiter(void 0, void 0, void 0, function* () {
+    let limit = params.limit;
+    if (limit == null || isNaN(limit) || limit < 0) {
+        limit = 50;
+    }
+    limit = Math.min(limit, 200);
+    const search = new QueryBuilder(query)
+        .setVersion(params.version)
+        .setTable(params.tableId)
+        .setSort(params.sort)
+        .setSortOrder(params.sortOrder)
+        .setSortType(params.sortType);
+    const searchResults = yield search
+        .setBookmark(params.bookmark)
+        .setLimit(limit)
+        .run();
+    // Try fetching 1 row in the next page to see if another page of results
+    // exists or not
+    const nextResults = yield search
+        .setTable(params.tableId)
+        .setBookmark(searchResults.bookmark)
+        .setLimit(1)
+        .run();
+    return Object.assign(Object.assign({}, searchResults), { hasNextPage: nextResults.rows && nextResults.rows.length > 0 });
+});
 /**
  * Performs a full search, fetching multiple pages if required to return the
  * desired amount of results. There is a limit of 1000 results to avoid
@@ -458,15 +446,12 @@ exports.paginatedSearch = paginatedSearch;
  *   limit {number} The desired number of results
  * @returns {Promise<{rows: *}>}
  */
-function fullSearch(query, params) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let limit = params.limit;
-        if (limit == null || isNaN(limit) || limit < 0) {
-            limit = 1000;
-        }
-        params.limit = Math.min(limit, 1000);
-        const rows = yield recursiveSearch(query, params);
-        return { rows };
-    });
-}
-exports.fullSearch = fullSearch;
+exports.fullSearch = (query, params) => __awaiter(void 0, void 0, void 0, function* () {
+    let limit = params.limit;
+    if (limit == null || isNaN(limit) || limit < 0) {
+        limit = 1000;
+    }
+    params.limit = Math.min(limit, 1000);
+    const rows = yield recursiveSearch(query, params);
+    return { rows };
+});

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

@@ -8,154 +8,141 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.finaliseRow = exports.updateAllFormulasInTable = exports.updateRelatedFormula = void 0;
-const utils_1 = require("../../../db/utils");
-const rowProcessor_1 = require("../../../utilities/rowProcessor");
-const constants_1 = require("../../../constants");
-const backend_core_1 = require("@budibase/backend-core");
+const { getRowParams } = require("../../../db/utils");
+const { outputProcessing, processAutoColumn, processFormulas, } = require("../../../utilities/rowProcessor");
+const { FieldTypes, FormulaTypes } = require("../../../constants");
 const { isEqual } = require("lodash");
 const { cloneDeep } = require("lodash/fp");
+const { getAppDB } = require("@budibase/backend-core/context");
 /**
  * This function runs through a list of enriched rows, looks at the rows which
  * are related and then checks if they need the state of their formulas
  * updated.
  * NOTE: this will only for affect static formulas.
  */
-function updateRelatedFormula(table, enrichedRows) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const db = backend_core_1.context.getAppDB();
-        // no formula to update, we're done
-        if (!table.relatedFormula) {
-            return;
-        }
-        let promises = [];
-        for (let enrichedRow of Array.isArray(enrichedRows)
-            ? enrichedRows
-            : [enrichedRows]) {
-            // the related rows by tableId
-            let relatedRows = {};
-            for (let [key, field] of Object.entries(enrichedRow)) {
-                const columnDefinition = table.schema[key];
-                if (columnDefinition && columnDefinition.type === constants_1.FieldTypes.LINK) {
-                    const relatedTableId = columnDefinition.tableId;
-                    if (!relatedRows[relatedTableId]) {
-                        relatedRows[relatedTableId] = [];
-                    }
-                    relatedRows[relatedTableId] = relatedRows[relatedTableId].concat(field);
+exports.updateRelatedFormula = (table, enrichedRows) => __awaiter(void 0, void 0, void 0, function* () {
+    const db = getAppDB();
+    // no formula to update, we're done
+    if (!table.relatedFormula) {
+        return;
+    }
+    let promises = [];
+    for (let enrichedRow of Array.isArray(enrichedRows)
+        ? enrichedRows
+        : [enrichedRows]) {
+        // the related rows by tableId
+        let relatedRows = {};
+        for (let [key, field] of Object.entries(enrichedRow)) {
+            const columnDefinition = table.schema[key];
+            if (columnDefinition && columnDefinition.type === FieldTypes.LINK) {
+                const relatedTableId = columnDefinition.tableId;
+                if (!relatedRows[relatedTableId]) {
+                    relatedRows[relatedTableId] = [];
                 }
+                relatedRows[relatedTableId] = relatedRows[relatedTableId].concat(field);
             }
-            for (let tableId of table.relatedFormula) {
-                let relatedTable;
-                try {
-                    // no rows to update, skip
-                    if (!relatedRows[tableId] || relatedRows[tableId].length === 0) {
-                        continue;
-                    }
-                    relatedTable = yield db.get(tableId);
-                }
-                catch (err) {
-                    // no error scenario, table doesn't seem to exist anymore, ignore
+        }
+        for (let tableId of table.relatedFormula) {
+            let relatedTable;
+            try {
+                // no rows to update, skip
+                if (!relatedRows[tableId] || relatedRows[tableId].length === 0) {
+                    continue;
                 }
-                for (let column of Object.values(relatedTable.schema)) {
-                    // needs updated in related rows
-                    if (column.type === constants_1.FieldTypes.FORMULA &&
-                        column.formulaType === constants_1.FormulaTypes.STATIC) {
-                        // re-enrich rows for all the related, don't update the related formula for them
-                        promises = promises.concat(relatedRows[tableId].map(related => finaliseRow(relatedTable, related, {
-                            updateFormula: false,
-                        })));
-                        break;
-                    }
+                relatedTable = yield db.get(tableId);
+            }
+            catch (err) {
+                // no error scenario, table doesn't seem to exist anymore, ignore
+            }
+            for (let column of Object.values(relatedTable.schema)) {
+                // needs updated in related rows
+                if (column.type === FieldTypes.FORMULA &&
+                    column.formulaType === FormulaTypes.STATIC) {
+                    // re-enrich rows for all the related, don't update the related formula for them
+                    promises = promises.concat(relatedRows[tableId].map(related => exports.finaliseRow(relatedTable, related, {
+                        updateFormula: false,
+                    })));
+                    break;
                 }
             }
         }
-        yield Promise.all(promises);
+    }
+    yield Promise.all(promises);
+});
+exports.updateAllFormulasInTable = (table) => __awaiter(void 0, void 0, void 0, function* () {
+    const db = getAppDB();
+    // start by getting the raw rows (which will be written back to DB after update)
+    let rows = (yield db.allDocs(getRowParams(table._id, null, {
+        include_docs: true,
+    }))).rows.map(row => row.doc);
+    // now enrich the rows, note the clone so that we have the base state of the
+    // rows so that we don't write any of the enriched information back
+    let enrichedRows = yield outputProcessing(table, cloneDeep(rows), {
+        squash: false,
     });
-}
-exports.updateRelatedFormula = updateRelatedFormula;
-function updateAllFormulasInTable(table) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const db = backend_core_1.context.getAppDB();
-        // start by getting the raw rows (which will be written back to DB after update)
-        let rows = (yield db.allDocs((0, utils_1.getRowParams)(table._id, null, {
-            include_docs: true,
-        }))).rows.map(row => row.doc);
-        // now enrich the rows, note the clone so that we have the base state of the
-        // rows so that we don't write any of the enriched information back
-        let enrichedRows = yield (0, rowProcessor_1.outputProcessing)(table, cloneDeep(rows), {
-            squash: false,
-        });
-        const updatedRows = [];
-        for (let row of rows) {
-            // find the enriched row, if found process the formulas
-            const enrichedRow = enrichedRows.find((enriched) => enriched._id === row._id);
-            if (enrichedRow) {
-                const processed = (0, rowProcessor_1.processFormulas)(table, cloneDeep(row), {
-                    dynamic: false,
-                    contextRows: enrichedRow,
-                });
-                // values have changed, need to add to bulk docs to update
-                if (!isEqual(processed, row)) {
-                    updatedRows.push(processed);
-                }
+    const updatedRows = [];
+    for (let row of rows) {
+        // find the enriched row, if found process the formulas
+        const enrichedRow = enrichedRows.find(enriched => enriched._id === row._id);
+        if (enrichedRow) {
+            const processed = processFormulas(table, cloneDeep(row), {
+                dynamic: false,
+                contextRows: enrichedRow,
+            });
+            // values have changed, need to add to bulk docs to update
+            if (!isEqual(processed, row)) {
+                updatedRows.push(processed);
             }
         }
-        yield db.bulkDocs(updatedRows);
-    });
-}
-exports.updateAllFormulasInTable = updateAllFormulasInTable;
+    }
+    yield db.bulkDocs(updatedRows);
+});
 /**
  * This function runs at the end of the save/patch functions of the row controller, all this
  * really does is enrich the row, handle any static formula processing, then return the enriched
  * row. The reason we need to return the enriched row is that the automation row created trigger
  * expects the row to be totally enriched/contain all relationships.
  */
-function finaliseRow(table, row, { oldTable, updateFormula } = {
-    updateFormula: true,
-}) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const db = backend_core_1.context.getAppDB();
-        row.type = "row";
-        // process the row before return, to include relationships
-        let enrichedRow = (yield (0, rowProcessor_1.outputProcessing)(table, cloneDeep(row), {
-            squash: false,
-        }));
-        // use enriched row to generate formulas for saving, specifically only use as context
-        row = (0, rowProcessor_1.processFormulas)(table, row, {
-            dynamic: false,
-            contextRows: enrichedRow,
-        });
-        // don't worry about rev, tables handle rev/lastID updates
-        // if another row has been written since processing this will
-        // handle the auto ID clash
-        if (oldTable && !isEqual(oldTable, table)) {
-            try {
-                yield db.put(table);
+exports.finaliseRow = (table, row, { oldTable, updateFormula } = { updateFormula: true }) => __awaiter(void 0, void 0, void 0, function* () {
+    const db = getAppDB();
+    row.type = "row";
+    // process the row before return, to include relationships
+    let enrichedRow = yield outputProcessing(table, cloneDeep(row), {
+        squash: false,
+    });
+    // use enriched row to generate formulas for saving, specifically only use as context
+    row = processFormulas(table, row, {
+        dynamic: false,
+        contextRows: enrichedRow,
+    });
+    // don't worry about rev, tables handle rev/lastID updates
+    // if another row has been written since processing this will
+    // handle the auto ID clash
+    if (oldTable && !isEqual(oldTable, table)) {
+        try {
+            yield db.put(table);
+        }
+        catch (err) {
+            if (err.status === 409) {
+                const updatedTable = yield db.get(table._id);
+                let response = processAutoColumn(null, updatedTable, row, {
+                    reprocessing: true,
+                });
+                yield db.put(response.table);
+                row = response.row;
             }
-            catch (err) {
-                if (err.status === 409) {
-                    const updatedTable = yield db.get(table._id);
-                    let response = (0, rowProcessor_1.processAutoColumn)(null, updatedTable, row, {
-                        reprocessing: true,
-                    });
-                    yield db.put(response.table);
-                    row = response.row;
-                }
-                else {
-                    throw err;
-                }
+            else {
+                throw err;
             }
         }
-        const response = yield db.put(row);
-        // for response, calculate the formulas for the enriched row
-        enrichedRow._rev = response.rev;
-        enrichedRow = yield (0, rowProcessor_1.processFormulas)(table, enrichedRow, { dynamic: false });
-        // this updates the related formulas in other rows based on the relations to this row
-        if (updateFormula) {
-            yield exports.updateRelatedFormula(table, enrichedRow);
-        }
-        return { row: enrichedRow, table };
-    });
-}
-exports.finaliseRow = finaliseRow;
+    }
+    const response = yield db.put(row);
+    // for response, calculate the formulas for the enriched row
+    enrichedRow._rev = response.rev;
+    enrichedRow = yield processFormulas(table, enrichedRow, { dynamic: false });
+    // this updates the related formulas in other rows based on the relations to this row
+    if (updateFormula) {
+        yield exports.updateRelatedFormula(table, enrichedRow);
+    }
+    return { row: enrichedRow, table };
+});