@budibase/server 2.1.44 → 2.1.46-alpha.0

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

@@ -8,11 +8,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-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");
+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");
 /**
  * Class to build lucene query URLs.
  * Optionally takes a base lucene query object.
@@ -24,10 +28,11 @@ class QueryBuilder {
         this.sortOrder = "ascending";
         this.sortType = "string";
         this.includeDocs = true;
-        this.version = null;
     }
     setVersion(version) {
-        this.version = version;
+        if (version != null) {
+            this.version = version;
+        }
         return this;
     }
     setTable(tableId) {
@@ -59,7 +64,9 @@ class QueryBuilder {
         return this;
     }
     setBookmark(bookmark) {
-        this.bookmark = bookmark;
+        if (bookmark != null) {
+            this.bookmark = bookmark;
+        }
         return this;
     }
     excludeDocs() {
@@ -75,7 +82,7 @@ class QueryBuilder {
         return this;
     }
     addRange(key, low, high) {
-        this.query.range = {
+        this.query.range[key] = {
             low,
             high,
         };
@@ -174,6 +181,7 @@ class QueryBuilder {
             return `${key}:(${statement})`;
         };
         const notContains = (key, value) => {
+            // @ts-ignore
             const allPrefix = allOr === "" ? "*:* AND" : "";
             return allPrefix + "NOT " + contains(key, value);
         };
@@ -198,7 +206,7 @@ class QueryBuilder {
         function build(structure, queryFn) {
             for (let [key, value] of Object.entries(structure)) {
                 // check for new format - remove numbering if needed
-                key = removeKeyNumbering(key);
+                key = (0, utils_2.removeKeyNumbering)(key);
                 key = builder.preprocess(key.replace(/ /g, "_"), {
                     escape: true,
                 });
@@ -267,10 +275,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);
@@ -310,15 +318,14 @@ class QueryBuilder {
     }
     run() {
         return __awaiter(this, void 0, void 0, function* () {
-            const appId = getAppId();
-            const { url, cookie } = getCouchInfo();
-            const fullPath = `${url}/${appId}/_design/database/_search/${SearchIndexes.ROWS}`;
+            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 body = this.buildSearchBody();
             return yield runQuery(fullPath, body, cookie);
         });
     }
 }
-// exported for unit testing
 exports.QueryBuilder = QueryBuilder;
 /**
  * Executes a lucene search query.
@@ -328,7 +335,7 @@ exports.QueryBuilder = QueryBuilder;
  * @returns {Promise<{rows: []}>}
  */
 const runQuery = (url, body, cookie) => __awaiter(void 0, void 0, void 0, function* () {
-    const response = yield fetch(url, {
+    const response = yield (0, node_fetch_1.default)(url, {
         body: JSON.stringify(body),
         method: "POST",
         headers: {
@@ -340,7 +347,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;
@@ -363,34 +370,36 @@ const runQuery = (url, body, cookie) => __awaiter(void 0, void 0, void 0, functi
  *   rows {array|null} Current results in the recursive search
  * @returns {Promise<*[]|*>}
  */
-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);
-});
+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);
+    });
+}
 /**
  * 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
@@ -406,31 +415,34 @@ const recursiveSearch = (query, params) => __awaiter(void 0, void 0, void 0, fun
  *   bookmark {string} The bookmark to resume from
  * @returns {Promise<{hasNextPage: boolean, rows: *[]}>}
  */
-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 });
-});
+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;
 /**
  * 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
@@ -446,12 +458,15 @@ exports.paginatedSearch = (query, params) => __awaiter(void 0, void 0, void 0, f
  *   limit {number} The desired number of results
  * @returns {Promise<{rows: *}>}
  */
-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 };
-});
+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;

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

@@ -8,141 +8,154 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-const { getRowParams } = require("../../../db/utils");
-const { outputProcessing, processAutoColumn, processFormulas, } = require("../../../utilities/rowProcessor");
-const { FieldTypes, FormulaTypes } = require("../../../constants");
+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 { 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.
  */
-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);
-            }
+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;
         }
-        for (let tableId of table.relatedFormula) {
-            let relatedTable;
-            try {
-                // no rows to update, skip
-                if (!relatedRows[tableId] || relatedRows[tableId].length === 0) {
-                    continue;
+        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);
                 }
-                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;
+            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 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;
+                    }
                 }
             }
         }
-    }
-    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,
+        yield Promise.all(promises);
     });
-    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);
+}
+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);
+                }
             }
         }
-    }
-    yield db.bulkDocs(updatedRows);
-});
+        yield db.bulkDocs(updatedRows);
+    });
+}
+exports.updateAllFormulasInTable = updateAllFormulasInTable;
 /**
  * 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.
  */
-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;
+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);
             }
-            else {
-                throw err;
+            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;
+                }
             }
         }
-    }
-    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 };
-});
+        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;