@budibase/server 1.0.49-alpha.6 → 1.0.49

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

@@ -22,21 +22,19 @@ 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 = fp_1.cloneDeep(id);
+        let idCopy = 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)) {
@@ -79,10 +77,10 @@ var External;
      */
     function cleanupConfig(config, table) {
         const primaryOptions = [
-            constants_1.FieldTypes.STRING,
-            constants_1.FieldTypes.LONGFORM,
-            constants_1.FieldTypes.OPTIONS,
-            constants_1.FieldTypes.NUMBER,
+            FieldTypes.STRING,
+            FieldTypes.LONGFORM,
+            FieldTypes.OPTIONS,
+            FieldTypes.NUMBER,
         ];
         // filter out fields which cannot be keys
         const fieldNames = Object.entries(table.schema)
@@ -135,7 +133,7 @@ var External;
         if (!tableId) {
             return {};
         }
-        const { datasourceId, tableName } = utils_3.breakExternalTableId(tableId);
+        const { datasourceId, tableName } = breakExternalTableId(tableId);
         return {
             datasourceId,
             entityId: tableName,
@@ -159,7 +157,7 @@ var External;
     }
     function fixArrayTypes(row, table) {
         for (let [fieldName, schema] of Object.entries(table.schema)) {
-            if (schema.type === constants_1.FieldTypes.ARRAY &&
+            if (schema.type === FieldTypes.ARRAY &&
                 typeof row[fieldName] === "string") {
                 try {
                     row[fieldName] = JSON.parse(row[fieldName]);
@@ -176,8 +174,9 @@ var External;
         return (field.relationshipType && field.relationshipType.split("-")[0] === "one");
     }
     class ExternalRequest {
-        constructor(operation, tableId, datasource) {
+        constructor(appId, operation, tableId, datasource) {
             this.tables = {};
+            this.appId = appId;
             this.operation = operation;
             this.tableId = tableId;
             this.datasource = datasource;
@@ -189,10 +188,8 @@ var External;
             if (!tableId) {
                 throw "Table ID is unknown, cannot find table";
             }
-            const { tableName } = utils_3.breakExternalTableId(tableId);
-            if (tableName) {
-                return this.tables[tableName];
-            }
+            const { tableName } = breakExternalTableId(tableId);
+            return this.tables[tableName];
         }
         inputProcessing(row, table) {
             if (!row) {
@@ -207,7 +204,7 @@ var External;
                 if (row[key] == null ||
                     newRow[key] ||
                     field.autocolumn ||
-                    field.type === constants_1.FieldTypes.FORMULA) {
+                    field.type === FieldTypes.FORMULA) {
                     continue;
                 }
                 // if its an empty string then it means return the column to null (if possible)
@@ -216,17 +213,17 @@ var External;
                     continue;
                 }
                 // parse floats/numbers
-                if (field.type === constants_1.FieldTypes.NUMBER && !isNaN(parseFloat(row[key]))) {
+                if (field.type === FieldTypes.NUMBER && !isNaN(parseFloat(row[key]))) {
                     newRow[key] = parseFloat(row[key]);
                 }
                 // if its not a link then just copy it over
-                if (field.type !== constants_1.FieldTypes.LINK) {
+                if (field.type !== FieldTypes.LINK) {
                     newRow[key] = row[key];
                     continue;
                 }
-                const { tableName: linkTableName } = utils_3.breakExternalTableId(field === null || field === void 0 ? void 0 : field.tableId);
+                const { tableName: linkTableName } = breakExternalTableId(field.tableId);
                 // table has to exist for many to many
-                if (!linkTableName || !this.tables[linkTableName]) {
+                if (!this.tables[linkTableName]) {
                     continue;
                 }
                 const linkTable = this.tables[linkTableName];
@@ -334,7 +331,7 @@ var External;
                 // do this at end once its been added to the final rows
                 finalRows = this.updateRelationshipColumns(row, finalRows, relationships);
             }
-            return utils_4.processFormulas(table, Object.values(finalRows));
+            return processFormulas(table, Object.values(finalRows));
         }
         /**
          * Gets the list of relationship JSON structures based on the columns in the table,
@@ -344,12 +341,12 @@ var External;
         buildRelationships(table) {
             const relationships = [];
             for (let [fieldName, field] of Object.entries(table.schema)) {
-                if (field.type !== constants_1.FieldTypes.LINK) {
+                if (field.type !== FieldTypes.LINK) {
                     continue;
                 }
-                const { tableName: linkTableName } = utils_3.breakExternalTableId(field.tableId);
+                const { tableName: linkTableName } = breakExternalTableId(field.tableId);
                 // no table to link to, this is not a valid relationships
-                if (!linkTableName || !this.tables[linkTableName]) {
+                if (!this.tables[linkTableName]) {
                     continue;
                 }
                 const linkTable = this.tables[linkTableName];
@@ -365,7 +362,7 @@ var External;
                     column: fieldName,
                 };
                 if (field.through) {
-                    const { tableName: throughTableName } = utils_3.breakExternalTableId(field.through);
+                    const { tableName: throughTableName } = breakExternalTableId(field.through);
                     definition.through = throughTableName;
                     // don't support composite keys for relationships
                     definition.from = field.throughTo || table.primary[0];
@@ -384,24 +381,21 @@ var External;
         lookupRelations(tableId, row) {
             return __awaiter(this, void 0, void 0, function* () {
                 const related = {};
-                const { tableName } = utils_3.breakExternalTableId(tableId);
-                if (!tableName) {
-                    return related;
-                }
+                const { tableName } = breakExternalTableId(tableId);
                 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 !== constants_1.FieldTypes.LINK ||
+                    if (field.type !== FieldTypes.LINK ||
                         !field.fieldName ||
                         isOneSide(field)) {
                         continue;
                     }
-                    const isMany = field.relationshipType === constants_1.RelationshipTypes.MANY_TO_MANY;
+                    const isMany = field.relationshipType === RelationshipTypes.MANY_TO_MANY;
                     const tableId = isMany ? field.through : field.tableId;
-                    const { tableName: relatedTableName } = utils_3.breakExternalTableId(tableId);
+                    const { tableName: relatedTableName } = breakExternalTableId(tableId);
                     // @ts-ignore
                     const linkPrimaryKey = this.tables[relatedTableName].primary[0];
                     const manyKey = field.throughTo || primaryKey;
@@ -410,8 +404,8 @@ var External;
                     if (!lookupField || !row[lookupField]) {
                         continue;
                     }
-                    const response = yield utils_2.getDatasourceAndQuery({
-                        endpoint: getEndpoint(tableId, constants_1.DataSourceOperation.READ),
+                    const response = yield getDatasourceAndQuery(this.appId, {
+                        endpoint: getEndpoint(tableId, DataSourceOperation.READ),
                         filters: {
                             equal: {
                                 [fieldName]: row[lookupField],
@@ -437,27 +431,26 @@ var External;
          * all and then re-create, as theres no chance of losing data (e.g. delete succeed, but write fail).
          */
         handleManyRelationships(mainTableId, row, relationships) {
+            var _a;
             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 = string_templates_1.processObjectSync(rest, row, {});
+                    const body = processObjectSync(rest, row);
                     const linkTable = this.getTable(tableId);
                     // @ts-ignore
-                    const linkPrimary = linkTable === null || linkTable === void 0 ? void 0 : linkTable.primary[0];
-                    if (!linkTable || !linkPrimary) {
-                        return;
-                    }
-                    const rows = related[key].rows || [];
+                    const linkPrimary = linkTable.primary[0];
+                    const rows = ((_a = related[key]) === null || _a === void 0 ? void 0 : _a.rows) || [];
                     const found = rows.find((row) => row[linkPrimary] === relationship.id ||
-                        row[linkPrimary] === (body === null || body === void 0 ? void 0 : body[linkPrimary]));
+                        row[linkPrimary] === body[linkPrimary]);
                     const operation = isUpdate
-                        ? constants_1.DataSourceOperation.UPDATE
-                        : constants_1.DataSourceOperation.CREATE;
+                        ? DataSourceOperation.UPDATE
+                        : DataSourceOperation.CREATE;
                     if (!found) {
-                        promises.push(utils_2.getDatasourceAndQuery({
+                        promises.push(getDatasourceAndQuery(appId, {
                             endpoint: getEndpoint(tableId, operation),
                             // if we're doing many relationships then we're writing, only one response
                             body,
@@ -473,8 +466,7 @@ 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 ||
-                        (table.primary && table.primary.indexOf(colName) !== -1)) {
+                    if (table.primary && table.primary.indexOf(colName) !== -1) {
                         continue;
                     }
                     for (let row of rows) {
@@ -482,10 +474,10 @@ var External;
                         // safety check, if there are no filters on deletion bad things happen
                         if (Object.keys(filters).length !== 0) {
                             const op = isMany
-                                ? constants_1.DataSourceOperation.DELETE
-                                : constants_1.DataSourceOperation.UPDATE;
+                                ? DataSourceOperation.DELETE
+                                : DataSourceOperation.UPDATE;
                             const body = isMany ? null : { [colName]: null };
-                            promises.push(utils_2.getDatasourceAndQuery({
+                            promises.push(getDatasourceAndQuery(this.appId, {
                                 endpoint: getEndpoint(tableId, op),
                                 body,
                                 filters,
@@ -506,36 +498,31 @@ var External;
         buildFields(table, includeRelations = datasource_1.IncludeRelationships.INCLUDE) {
             function extractRealFields(table, existing = []) {
                 return Object.entries(table.schema)
-                    .filter(column => column[1].type !== constants_1.FieldTypes.LINK &&
-                    column[1].type !== constants_1.FieldTypes.FORMULA &&
+                    .filter(column => column[1].type !== FieldTypes.LINK &&
+                    column[1].type !== 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 !== constants_1.FieldTypes.LINK || !includeRelations) {
+                if (field.type !== FieldTypes.LINK || !includeRelations) {
                     continue;
                 }
-                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);
-                    }
+                const { tableName: linkTableName } = breakExternalTableId(field.tableId);
+                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 { operation, tableId } = this;
-                let { datasourceId, tableName } = utils_3.breakExternalTableId(tableId);
-                if (!tableName) {
-                    throw "Unable to run without a table name";
-                }
+                const { appId, operation, tableId } = this;
+                let { datasourceId, tableName } = breakExternalTableId(tableId);
                 if (!this.datasource) {
-                    const db = context_1.getAppDB();
+                    const db = new CouchDB(appId);
                     this.datasource = yield db.get(datasourceId);
                     if (!this.datasource || !this.datasource.entities) {
                         throw "No tables found, fetch tables before query.";
@@ -543,7 +530,7 @@ var External;
                     this.tables = this.datasource.entities;
                 }
                 const table = this.tables[tableName];
-                let isSql = utils_3.isSQL(this.datasource);
+                let isSql = isSQL(this.datasource);
                 if (!table) {
                     throw `Unable to process query, table "${tableName}" not defined.`;
                 }
@@ -554,7 +541,7 @@ var External;
                 // clean up row on ingress using schema
                 const processed = this.inputProcessing(row, table);
                 row = processed.row;
-                if (operation === constants_1.DataSourceOperation.DELETE &&
+                if (operation === DataSourceOperation.DELETE &&
                     (filters == null || Object.keys(filters).length === 0)) {
                     throw "Deletion must be filtered";
                 }
@@ -582,15 +569,15 @@ var External;
                     },
                 };
                 // can't really use response right now
-                const response = yield utils_2.getDatasourceAndQuery(json);
+                const response = yield getDatasourceAndQuery(appId, json);
                 // handle many to many relationships now if we know the ID (could be auto increment)
-                if (operation !== constants_1.DataSourceOperation.READ &&
+                if (operation !== 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 === constants_1.DataSourceOperation.READ && Array.isArray(response)
+                return operation === 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 { getAppDB } = require("@budibase/backend-core/context");
-function handleRequest(operation, tableId, opts = {}) {
+const CouchDB = require("../../../db");
+function handleRequest(appId, 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,7 +38,7 @@ function handleRequest(operation, tableId, opts = {}) {
                 }
             }
         }
-        return new ExternalRequest(operation, tableId, opts.datasource).run(opts);
+        return new ExternalRequest(appId, operation, tableId, opts.datasource).run(opts);
     });
 }
 exports.handleRequest = handleRequest;
@@ -164,7 +164,7 @@ exports.fetchEnrichedRow = (ctx) => __awaiter(void 0, void 0, void 0, function*
     const id = ctx.params.rowId;
     const tableId = ctx.params.tableId;
     const { datasourceId, tableName } = breakExternalTableId(tableId);
-    const db = getAppDB();
+    const db = new CouchDB(appId);
     const datasource = yield db.get(datasourceId);
     if (!datasource || !datasource.entities) {
         ctx.throw(400, "Datasource has not been configured for plus API.");