@budibase/server 1.0.47 → 1.0.49-alpha.10

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

@@ -22,19 +22,21 @@ var __rest = (this && this.__rest) || function (s, e) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const datasource_1 = require("../../../definitions/datasource");
 const utils_1 = require("../../../integrations/utils");
+const utils_2 = require("./utils");
+const constants_1 = require("../../../constants");
+const utils_3 = require("../../../integrations/utils");
+const string_templates_1 = require("@budibase/string-templates");
+// @ts-ignore
+const fp_1 = require("lodash/fp");
+const utils_4 = require("../../../utilities/rowProcessor/utils");
+// @ts-ignore
+const context_1 = require("@budibase/backend-core/context");
 var External;
 (function (External) {
-    const { getDatasourceAndQuery } = require("./utils");
-    const { DataSourceOperation, FieldTypes, RelationshipTypes, } = require("../../../constants");
-    const { breakExternalTableId, isSQL } = require("../../../integrations/utils");
-    const { processObjectSync } = require("@budibase/string-templates");
-    const { cloneDeep } = require("lodash/fp");
-    const CouchDB = require("../../../db");
-    const { processFormulas } = require("../../../utilities/rowProcessor/utils");
     function buildFilters(id, filters, table) {
         const primary = table.primary;
         // if passed in array need to copy for shifting etc
-        let idCopy = cloneDeep(id);
+        let idCopy = fp_1.cloneDeep(id);
         if (filters) {
             // need to map over the filters and make sure the _id field isn't present
             for (let filter of Object.values(filters)) {
@@ -77,10 +79,10 @@ var External;
      */
     function cleanupConfig(config, table) {
         const primaryOptions = [
-            FieldTypes.STRING,
-            FieldTypes.LONGFORM,
-            FieldTypes.OPTIONS,
-            FieldTypes.NUMBER,
+            constants_1.FieldTypes.STRING,
+            constants_1.FieldTypes.LONGFORM,
+            constants_1.FieldTypes.OPTIONS,
+            constants_1.FieldTypes.NUMBER,
         ];
         // filter out fields which cannot be keys
         const fieldNames = Object.entries(table.schema)
@@ -133,7 +135,7 @@ var External;
         if (!tableId) {
             return {};
         }
-        const { datasourceId, tableName } = breakExternalTableId(tableId);
+        const { datasourceId, tableName } = utils_3.breakExternalTableId(tableId);
         return {
             datasourceId,
             entityId: tableName,
@@ -153,11 +155,11 @@ var External;
         thisRow._id = generateIdForRow(row, table);
         thisRow.tableId = table._id;
         thisRow._rev = "rev";
-        return thisRow;
+        return utils_4.processFormulas(table, thisRow);
     }
     function fixArrayTypes(row, table) {
         for (let [fieldName, schema] of Object.entries(table.schema)) {
-            if (schema.type === FieldTypes.ARRAY &&
+            if (schema.type === constants_1.FieldTypes.ARRAY &&
                 typeof row[fieldName] === "string") {
                 try {
                     row[fieldName] = JSON.parse(row[fieldName]);
@@ -174,9 +176,8 @@ var External;
         return (field.relationshipType && field.relationshipType.split("-")[0] === "one");
     }
     class ExternalRequest {
-        constructor(appId, operation, tableId, datasource) {
+        constructor(operation, tableId, datasource) {
             this.tables = {};
-            this.appId = appId;
             this.operation = operation;
             this.tableId = tableId;
             this.datasource = datasource;
@@ -188,8 +189,10 @@ var External;
             if (!tableId) {
                 throw "Table ID is unknown, cannot find table";
             }
-            const { tableName } = breakExternalTableId(tableId);
-            return this.tables[tableName];
+            const { tableName } = utils_3.breakExternalTableId(tableId);
+            if (tableName) {
+                return this.tables[tableName];
+            }
         }
         inputProcessing(row, table) {
             if (!row) {
@@ -204,7 +207,7 @@ var External;
                 if (row[key] == null ||
                     newRow[key] ||
                     field.autocolumn ||
-                    field.type === FieldTypes.FORMULA) {
+                    field.type === constants_1.FieldTypes.FORMULA) {
                     continue;
                 }
                 // if its an empty string then it means return the column to null (if possible)
@@ -213,17 +216,17 @@ var External;
                     continue;
                 }
                 // parse floats/numbers
-                if (field.type === FieldTypes.NUMBER && !isNaN(parseFloat(row[key]))) {
+                if (field.type === constants_1.FieldTypes.NUMBER && !isNaN(parseFloat(row[key]))) {
                     newRow[key] = parseFloat(row[key]);
                 }
                 // if its not a link then just copy it over
-                if (field.type !== FieldTypes.LINK) {
+                if (field.type !== constants_1.FieldTypes.LINK) {
                     newRow[key] = row[key];
                     continue;
                 }
-                const { tableName: linkTableName } = breakExternalTableId(field.tableId);
+                const { tableName: linkTableName } = utils_3.breakExternalTableId(field === null || field === void 0 ? void 0 : field.tableId);
                 // table has to exist for many to many
-                if (!this.tables[linkTableName]) {
+                if (!linkTableName || !this.tables[linkTableName]) {
                     continue;
                 }
                 const linkTable = this.tables[linkTableName];
@@ -275,14 +278,24 @@ var External;
          * This iterates through the returned rows and works out what elements of the rows
          * actually match up to another row (based on primary keys) - this is pretty specific
          * to SQL and the way that SQL relationships are returned based on joins.
+         * This is complicated, but the idea is that when a SQL query returns all the relations
+         * will be separate rows, with all of the data in each row. We have to decipher what comes
+         * from where (which tables) and how to convert that into budibase columns.
          */
-        updateRelationshipColumns(row, rows, relationships) {
+        updateRelationshipColumns(table, row, rows, relationships) {
             const columns = {};
             for (let relationship of relationships) {
                 const linkedTable = this.tables[relationship.tableName];
                 if (!linkedTable) {
                     continue;
                 }
+                const fromColumn = `${table.name}.${relationship.from}`;
+                const toColumn = `${linkedTable.name}.${relationship.to}`;
+                // this is important when working with multiple relationships
+                // between the same tables, don't want to overlap/multiply the relations
+                if (!relationship.through && row[fromColumn] !== row[toColumn]) {
+                    continue;
+                }
                 let linked = basicProcessing(row, linkedTable);
                 if (!linked._id) {
                     continue;
@@ -320,7 +333,7 @@ var External;
                 row._id = rowId;
                 // this is a relationship of some sort
                 if (finalRows[rowId]) {
-                    finalRows = this.updateRelationshipColumns(row, finalRows, relationships);
+                    finalRows = this.updateRelationshipColumns(table, row, finalRows, relationships);
                     continue;
                 }
                 const thisRow = fixArrayTypes(basicProcessing(row, table), table);
@@ -329,9 +342,9 @@ var External;
                 }
                 finalRows[thisRow._id] = thisRow;
                 // do this at end once its been added to the final rows
-                finalRows = this.updateRelationshipColumns(row, finalRows, relationships);
+                finalRows = this.updateRelationshipColumns(table, row, finalRows, relationships);
             }
-            return processFormulas(table, Object.values(finalRows));
+            return utils_4.processFormulas(table, Object.values(finalRows));
         }
         /**
          * Gets the list of relationship JSON structures based on the columns in the table,
@@ -341,12 +354,12 @@ var External;
         buildRelationships(table) {
             const relationships = [];
             for (let [fieldName, field] of Object.entries(table.schema)) {
-                if (field.type !== FieldTypes.LINK) {
+                if (field.type !== constants_1.FieldTypes.LINK) {
                     continue;
                 }
-                const { tableName: linkTableName } = breakExternalTableId(field.tableId);
+                const { tableName: linkTableName } = utils_3.breakExternalTableId(field.tableId);
                 // no table to link to, this is not a valid relationships
-                if (!this.tables[linkTableName]) {
+                if (!linkTableName || !this.tables[linkTableName]) {
                     continue;
                 }
                 const linkTable = this.tables[linkTableName];
@@ -362,7 +375,7 @@ var External;
                     column: fieldName,
                 };
                 if (field.through) {
-                    const { tableName: throughTableName } = breakExternalTableId(field.through);
+                    const { tableName: throughTableName } = utils_3.breakExternalTableId(field.through);
                     definition.through = throughTableName;
                     // don't support composite keys for relationships
                     definition.from = field.throughTo || table.primary[0];
@@ -381,21 +394,24 @@ var External;
         lookupRelations(tableId, row) {
             return __awaiter(this, void 0, void 0, function* () {
                 const related = {};
-                const { tableName } = breakExternalTableId(tableId);
+                const { tableName } = utils_3.breakExternalTableId(tableId);
+                if (!tableName) {
+                    return related;
+                }
                 const table = this.tables[tableName];
                 // @ts-ignore
                 const primaryKey = table.primary[0];
                 // make a new request to get the row with all its relationships
                 // we need this to work out if any relationships need removed
                 for (let field of Object.values(table.schema)) {
-                    if (field.type !== FieldTypes.LINK ||
+                    if (field.type !== constants_1.FieldTypes.LINK ||
                         !field.fieldName ||
                         isOneSide(field)) {
                         continue;
                     }
-                    const isMany = field.relationshipType === RelationshipTypes.MANY_TO_MANY;
+                    const isMany = field.relationshipType === constants_1.RelationshipTypes.MANY_TO_MANY;
                     const tableId = isMany ? field.through : field.tableId;
-                    const { tableName: relatedTableName } = breakExternalTableId(tableId);
+                    const { tableName: relatedTableName } = utils_3.breakExternalTableId(tableId);
                     // @ts-ignore
                     const linkPrimaryKey = this.tables[relatedTableName].primary[0];
                     const manyKey = field.throughTo || primaryKey;
@@ -404,8 +420,8 @@ var External;
                     if (!lookupField || !row[lookupField]) {
                         continue;
                     }
-                    const response = yield getDatasourceAndQuery(this.appId, {
-                        endpoint: getEndpoint(tableId, DataSourceOperation.READ),
+                    const response = yield utils_2.getDatasourceAndQuery({
+                        endpoint: getEndpoint(tableId, constants_1.DataSourceOperation.READ),
                         filters: {
                             equal: {
                                 [fieldName]: row[lookupField],
@@ -432,24 +448,26 @@ var External;
          */
         handleManyRelationships(mainTableId, row, relationships) {
             return __awaiter(this, void 0, void 0, function* () {
-                const { appId } = this;
                 // if we're creating (in a through table) need to wipe the existing ones first
                 const promises = [];
                 const related = yield this.lookupRelations(mainTableId, row);
                 for (let relationship of relationships) {
                     const { key, tableId, isUpdate, id } = relationship, rest = __rest(relationship, ["key", "tableId", "isUpdate", "id"]);
-                    const body = processObjectSync(rest, row);
+                    const body = string_templates_1.processObjectSync(rest, row, {});
                     const linkTable = this.getTable(tableId);
                     // @ts-ignore
-                    const linkPrimary = linkTable.primary[0];
+                    const linkPrimary = linkTable === null || linkTable === void 0 ? void 0 : linkTable.primary[0];
+                    if (!linkTable || !linkPrimary) {
+                        return;
+                    }
                     const rows = related[key].rows || [];
                     const found = rows.find((row) => row[linkPrimary] === relationship.id ||
-                        row[linkPrimary] === body[linkPrimary]);
+                        row[linkPrimary] === (body === null || body === void 0 ? void 0 : body[linkPrimary]));
                     const operation = isUpdate
-                        ? DataSourceOperation.UPDATE
-                        : DataSourceOperation.CREATE;
+                        ? constants_1.DataSourceOperation.UPDATE
+                        : constants_1.DataSourceOperation.CREATE;
                     if (!found) {
-                        promises.push(getDatasourceAndQuery(appId, {
+                        promises.push(utils_2.getDatasourceAndQuery({
                             endpoint: getEndpoint(tableId, operation),
                             // if we're doing many relationships then we're writing, only one response
                             body,
@@ -465,7 +483,8 @@ var External;
                 for (let [colName, { isMany, rows, tableId }] of Object.entries(related)) {
                     const table = this.getTable(tableId);
                     // if its not the foreign key skip it, nothing to do
-                    if (table.primary && table.primary.indexOf(colName) !== -1) {
+                    if (!table ||
+                        (table.primary && table.primary.indexOf(colName) !== -1)) {
                         continue;
                     }
                     for (let row of rows) {
@@ -473,10 +492,10 @@ var External;
                         // safety check, if there are no filters on deletion bad things happen
                         if (Object.keys(filters).length !== 0) {
                             const op = isMany
-                                ? DataSourceOperation.DELETE
-                                : DataSourceOperation.UPDATE;
+                                ? constants_1.DataSourceOperation.DELETE
+                                : constants_1.DataSourceOperation.UPDATE;
                             const body = isMany ? null : { [colName]: null };
-                            promises.push(getDatasourceAndQuery(this.appId, {
+                            promises.push(utils_2.getDatasourceAndQuery({
                                 endpoint: getEndpoint(tableId, op),
                                 body,
                                 filters,
@@ -497,31 +516,36 @@ var External;
         buildFields(table, includeRelations = datasource_1.IncludeRelationships.INCLUDE) {
             function extractRealFields(table, existing = []) {
                 return Object.entries(table.schema)
-                    .filter(column => column[1].type !== FieldTypes.LINK &&
-                    column[1].type !== FieldTypes.FORMULA &&
+                    .filter(column => column[1].type !== constants_1.FieldTypes.LINK &&
+                    column[1].type !== constants_1.FieldTypes.FORMULA &&
                     !existing.find((field) => field === column[0]))
                     .map(column => `${table.name}.${column[0]}`);
             }
             let fields = extractRealFields(table);
             for (let field of Object.values(table.schema)) {
-                if (field.type !== FieldTypes.LINK || !includeRelations) {
+                if (field.type !== constants_1.FieldTypes.LINK || !includeRelations) {
                     continue;
                 }
-                const { tableName: linkTableName } = breakExternalTableId(field.tableId);
-                const linkTable = this.tables[linkTableName];
-                if (linkTable) {
-                    const linkedFields = extractRealFields(linkTable, fields);
-                    fields = fields.concat(linkedFields);
+                const { tableName: linkTableName } = utils_3.breakExternalTableId(field.tableId);
+                if (linkTableName) {
+                    const linkTable = this.tables[linkTableName];
+                    if (linkTable) {
+                        const linkedFields = extractRealFields(linkTable, fields);
+                        fields = fields.concat(linkedFields);
+                    }
                 }
             }
             return fields;
         }
         run(config) {
             return __awaiter(this, void 0, void 0, function* () {
-                const { appId, operation, tableId } = this;
-                let { datasourceId, tableName } = breakExternalTableId(tableId);
+                const { operation, tableId } = this;
+                let { datasourceId, tableName } = utils_3.breakExternalTableId(tableId);
+                if (!tableName) {
+                    throw "Unable to run without a table name";
+                }
                 if (!this.datasource) {
-                    const db = new CouchDB(appId);
+                    const db = context_1.getAppDB();
                     this.datasource = yield db.get(datasourceId);
                     if (!this.datasource || !this.datasource.entities) {
                         throw "No tables found, fetch tables before query.";
@@ -529,7 +553,7 @@ var External;
                     this.tables = this.datasource.entities;
                 }
                 const table = this.tables[tableName];
-                let isSql = isSQL(this.datasource);
+                let isSql = utils_3.isSQL(this.datasource);
                 if (!table) {
                     throw `Unable to process query, table "${tableName}" not defined.`;
                 }
@@ -540,7 +564,7 @@ var External;
                 // clean up row on ingress using schema
                 const processed = this.inputProcessing(row, table);
                 row = processed.row;
-                if (operation === DataSourceOperation.DELETE &&
+                if (operation === constants_1.DataSourceOperation.DELETE &&
                     (filters == null || Object.keys(filters).length === 0)) {
                     throw "Deletion must be filtered";
                 }
@@ -568,15 +592,15 @@ var External;
                     },
                 };
                 // can't really use response right now
-                const response = yield getDatasourceAndQuery(appId, json);
+                const response = yield utils_2.getDatasourceAndQuery(json);
                 // handle many to many relationships now if we know the ID (could be auto increment)
-                if (operation !== DataSourceOperation.READ &&
+                if (operation !== constants_1.DataSourceOperation.READ &&
                     processed.manyRelationships) {
                     yield this.handleManyRelationships(table._id || "", response[0], processed.manyRelationships);
                 }
                 const output = this.outputProcessing(response, table, relationships);
                 // if reading it'll just be an array of rows, return whole thing
-                return operation === DataSourceOperation.READ && Array.isArray(response)
+                return operation === constants_1.DataSourceOperation.READ && Array.isArray(response)
                     ? output
                     : { row: output[0], table };
             });

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

@@ -22,8 +22,8 @@ var __rest = (this && this.__rest) || function (s, e) {
 const { DataSourceOperation, SortDirection, FieldTypes, NoEmptyFilterStrings, } = require("../../../constants");
 const { breakExternalTableId, breakRowIdField, } = require("../../../integrations/utils");
 const ExternalRequest = require("./ExternalRequest");
-const CouchDB = require("../../../db");
-function handleRequest(appId, operation, tableId, opts = {}) {
+const { getAppDB } = require("@budibase/backend-core/context");
+function handleRequest(operation, tableId, opts = {}) {
     return __awaiter(this, void 0, void 0, function* () {
         // make sure the filters are cleaned up, no empty strings for equals, fuzzy or string
         if (opts && opts.filters) {
@@ -38,27 +38,25 @@ function handleRequest(appId, operation, tableId, opts = {}) {
                 }
             }
         }
-        return new ExternalRequest(appId, operation, tableId, opts.datasource).run(opts);
+        return new ExternalRequest(operation, tableId, opts.datasource).run(opts);
     });
 }
 exports.handleRequest = handleRequest;
 exports.patch = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
-    const appId = ctx.appId;
     const inputs = ctx.request.body;
     const tableId = ctx.params.tableId;
     const id = breakRowIdField(inputs._id);
     // don't save the ID to db
     delete inputs._id;
-    return handleRequest(appId, DataSourceOperation.UPDATE, tableId, {
+    return handleRequest(DataSourceOperation.UPDATE, tableId, {
         id,
         row: inputs,
     });
 });
 exports.save = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
-    const appId = ctx.appId;
     const inputs = ctx.request.body;
     const tableId = ctx.params.tableId;
-    return handleRequest(appId, DataSourceOperation.CREATE, tableId, {
+    return handleRequest(DataSourceOperation.CREATE, tableId, {
         row: inputs,
     });
 });
@@ -70,35 +68,31 @@ exports.fetchView = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
     return exports.fetch(ctx);
 });
 exports.fetch = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
-    const appId = ctx.appId;
     const tableId = ctx.params.tableId;
-    return handleRequest(appId, DataSourceOperation.READ, tableId);
+    return handleRequest(DataSourceOperation.READ, tableId);
 });
 exports.find = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
-    const appId = ctx.appId;
     const id = ctx.params.rowId;
     const tableId = ctx.params.tableId;
-    const response = yield handleRequest(appId, DataSourceOperation.READ, tableId, {
+    const response = yield handleRequest(DataSourceOperation.READ, tableId, {
         id,
     });
     return response ? response[0] : response;
 });
 exports.destroy = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
-    const appId = ctx.appId;
     const tableId = ctx.params.tableId;
     const id = ctx.request.body._id;
-    const { row } = yield handleRequest(appId, DataSourceOperation.DELETE, tableId, {
+    const { row } = yield handleRequest(DataSourceOperation.DELETE, tableId, {
         id,
     });
     return { response: { ok: true }, row };
 });
 exports.bulkDestroy = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
-    const appId = ctx.appId;
     const { rows } = ctx.request.body;
     const tableId = ctx.params.tableId;
     let promises = [];
     for (let row of rows) {
-        promises.push(handleRequest(appId, DataSourceOperation.DELETE, tableId, {
+        promises.push(handleRequest(DataSourceOperation.DELETE, tableId, {
             id: breakRowIdField(row._id),
         }));
     }
@@ -106,7 +100,6 @@ exports.bulkDestroy = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
     return { response: { ok: true }, rows: responses.map(resp => resp.row) };
 });
 exports.search = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
-    const appId = ctx.appId;
     const tableId = ctx.params.tableId;
     const _a = ctx.request.body, { paginate, query } = _a, params = __rest(_a, ["paginate", "query"]);
     let { bookmark, limit } = params;
@@ -135,14 +128,14 @@ exports.search = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
             [params.sort]: direction,
         };
     }
-    const rows = yield handleRequest(appId, DataSourceOperation.READ, tableId, {
+    const rows = yield handleRequest(DataSourceOperation.READ, tableId, {
         filters: query,
         sort,
         paginate: paginateObj,
     });
     let hasNextPage = false;
     if (paginate && rows.length === limit) {
-        const nextRows = yield handleRequest(appId, DataSourceOperation.READ, tableId, {
+        const nextRows = yield handleRequest(DataSourceOperation.READ, tableId, {
             filters: query,
             sort,
             paginate: {
@@ -160,17 +153,16 @@ exports.validate = () => __awaiter(void 0, void 0, void 0, function* () {
     return { valid: true };
 });
 exports.fetchEnrichedRow = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
-    const appId = ctx.appId;
     const id = ctx.params.rowId;
     const tableId = ctx.params.tableId;
     const { datasourceId, tableName } = breakExternalTableId(tableId);
-    const db = new CouchDB(appId);
+    const db = getAppDB();
     const datasource = yield db.get(datasourceId);
     if (!datasource || !datasource.entities) {
         ctx.throw(400, "Datasource has not been configured for plus API.");
     }
     const tables = datasource.entities;
-    const response = yield handleRequest(appId, DataSourceOperation.READ, tableId, {
+    const response = yield handleRequest(DataSourceOperation.READ, tableId, {
         id,
         datasource,
     });
@@ -189,7 +181,7 @@ exports.fetchEnrichedRow = (ctx) => __awaiter(void 0, void 0, void 0, function*
         const linkedTable = tables[breakExternalTableId(linkedTableId).tableName];
         // don't support composite keys right now
         const linkedIds = links.map(link => breakRowIdField(link._id)[0]);
-        row[fieldName] = yield handleRequest(appId, DataSourceOperation.READ, linkedTableId, {
+        row[fieldName] = yield handleRequest(DataSourceOperation.READ, linkedTableId, {
             tables,
             filters: {
                 oneOf: {