@budibase/server 1.0.46 → 1.0.49-alpha.1

package/dist/api/controllers/table/bulkFormula.js

@@ -0,0 +1,160 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+const CouchDB = require("../../../db");
+const { FieldTypes, FormulaTypes } = require("../../../constants");
+const { getAllInternalTables, clearColumns } = require("./utils");
+const { doesContainStrings } = require("@budibase/string-templates");
+const { cloneDeep } = require("lodash/fp");
+const { isEqual, uniq } = require("lodash");
+const { updateAllFormulasInTable } = require("../row/staticFormula");
+function isStaticFormula(column) {
+    return (column.type === FieldTypes.FORMULA &&
+        column.formulaType === FormulaTypes.STATIC);
+}
+/**
+ * This retrieves the formula columns from a table schema that use a specified column name
+ * in the formula.
+ */
+function getFormulaThatUseColumn(table, columnNames) {
+    let formula = [];
+    columnNames = Array.isArray(columnNames) ? columnNames : [columnNames];
+    for (let column of Object.values(table.schema)) {
+        // not a static formula, or doesn't contain a relationship
+        if (!isStaticFormula(column)) {
+            continue;
+        }
+        if (!doesContainStrings(column.formula, columnNames)) {
+            continue;
+        }
+        formula.push(column.name);
+    }
+    return formula;
+}
+/**
+ * This functions checks for when a related table, column or related column is deleted, if any
+ * tables need to have the formula column removed.
+ */
+function checkIfFormulaNeedsCleared(appId, table, { oldTable, deletion }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const db = new CouchDB(appId);
+        // start by retrieving all tables, remove the current table from the list
+        const tables = (yield getAllInternalTables(appId)).filter(tbl => tbl._id !== table._id);
+        const schemaToUse = oldTable ? oldTable.schema : table.schema;
+        let removedColumns = Object.values(schemaToUse).filter(column => deletion || !table.schema[column.name]);
+        // remove any formula columns that used related columns
+        for (let removed of removedColumns) {
+            let tableToUse = table;
+            // if relationship, get the related table
+            if (removed.type === FieldTypes.LINK) {
+                tableToUse = tables.find(table => table._id === removed.tableId);
+            }
+            const columnsToDelete = getFormulaThatUseColumn(tableToUse, removed.name);
+            if (columnsToDelete.length > 0) {
+                yield clearColumns(db, table, columnsToDelete);
+            }
+            // need a special case, where a column has been removed from this table, but was used
+            // in a different, related tables formula
+            if (!table.relatedFormula) {
+                continue;
+            }
+            for (let relatedTableId of table.relatedFormula) {
+                const relatedColumns = Object.values(table.schema).filter(column => column.tableId === relatedTableId);
+                const relatedTable = tables.find(table => table._id === relatedTableId);
+                // look to see if the column was used in a relationship formula,
+                // relationships won't be used for this
+                if (relatedTable && relatedColumns && removed.type !== FieldTypes.LINK) {
+                    let relatedFormulaToRemove = [];
+                    for (let column of relatedColumns) {
+                        relatedFormulaToRemove = relatedFormulaToRemove.concat(getFormulaThatUseColumn(relatedTable, [
+                            column.fieldName,
+                            removed.name,
+                        ]));
+                    }
+                    if (relatedFormulaToRemove.length > 0) {
+                        yield clearColumns(db, relatedTable, uniq(relatedFormulaToRemove));
+                    }
+                }
+            }
+        }
+    });
+}
+/**
+ * This function adds a note to related tables that they are
+ * used in a static formula - so that the link controller
+ * can manage hydrating related rows formula fields. This is
+ * specifically only for static formula.
+ */
+function updateRelatedFormulaLinksOnTables(appId, table, { deletion } = { deletion: false }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const db = new CouchDB(appId);
+        // start by retrieving all tables, remove the current table from the list
+        const tables = (yield getAllInternalTables(appId)).filter(tbl => tbl._id !== table._id);
+        // clone the tables, so we can compare at end
+        const initialTables = cloneDeep(tables);
+        // first find the related column names
+        const relatedColumns = Object.values(table.schema).filter(col => col.type === FieldTypes.LINK);
+        // we start by removing the formula field from all tables
+        for (let otherTable of tables) {
+            if (!otherTable.relatedFormula) {
+                continue;
+            }
+            const index = otherTable.relatedFormula.indexOf(table._id);
+            if (index !== -1) {
+                otherTable.relatedFormula.splice(index, 1);
+            }
+        }
+        // if deleting, just remove the table IDs, don't try add
+        if (!deletion) {
+            for (let relatedCol of relatedColumns) {
+                let columns = getFormulaThatUseColumn(table, relatedCol.name);
+                if (!columns || columns.length === 0) {
+                    continue;
+                }
+                const relatedTable = tables.find(related => related._id === relatedCol.tableId);
+                // check if the table is already in the list of related formula, if it isn't, then add it
+                if (relatedTable &&
+                    (!relatedTable.relatedFormula ||
+                        !relatedTable.relatedFormula.includes(table._id))) {
+                    relatedTable.relatedFormula = relatedTable.relatedFormula
+                        ? [...relatedTable.relatedFormula, table._id]
+                        : [table._id];
+                }
+            }
+        }
+        // now we just need to compare all the tables and see if any need saved
+        for (let initial of initialTables) {
+            const found = tables.find(tbl => initial._id === tbl._id);
+            if (found && !isEqual(initial, found)) {
+                yield db.put(found);
+            }
+        }
+    });
+}
+function checkIfFormulaUpdated(appId, table, { oldTable }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // look to see if any formula values have changed
+        const shouldUpdate = Object.values(table.schema).find(column => isStaticFormula(column) &&
+            (!oldTable ||
+                !oldTable.schema[column.name] ||
+                !isEqual(oldTable.schema[column.name], column)));
+        // if a static formula column has updated, then need to run the update
+        if (shouldUpdate != null) {
+            yield updateAllFormulasInTable(appId, table);
+        }
+    });
+}
+exports.runStaticFormulaChecks = (appId, table, { oldTable, deletion }) => __awaiter(void 0, void 0, void 0, function* () {
+    yield updateRelatedFormulaLinksOnTables(appId, table, { deletion });
+    yield checkIfFormulaNeedsCleared(appId, table, { oldTable, deletion });
+    if (!deletion) {
+        yield checkIfFormulaUpdated(appId, table, { oldTable });
+    }
+});

package/dist/api/controllers/table/index.js

@@ -12,9 +12,9 @@ const CouchDB = require("../../../db");
 const internal = require("./internal");
 const external = require("./external");
 const csvParser = require("../../../utilities/csvParser");
-const { isExternalTable } = require("../../../integrations/utils");
-const { getTableParams, getDatasourceParams, BudibaseInternalDB, } = require("../../../db/utils");
-const { getTable } = require("./utils");
+const { isExternalTable, isSQL } = require("../../../integrations/utils");
+const { getDatasourceParams } = require("../../../db/utils");
+const { getTable, getAllInternalTables } = require("./utils");
 function pickApi({ tableId, table }) {
     if (table && !tableId) {
         tableId = table._id;
@@ -31,15 +31,18 @@ function pickApi({ tableId, table }) {
 exports.fetch = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
         const db = new CouchDB(ctx.appId);
-        const internalTables = yield db.allDocs(getTableParams(null, {
-            include_docs: true,
-        }));
-        const internal = internalTables.rows.map(row => (Object.assign(Object.assign({}, row.doc), { type: "internal", sourceId: BudibaseInternalDB._id })));
+        const internal = yield getAllInternalTables(ctx.appId);
         const externalTables = yield db.allDocs(getDatasourceParams("plus", {
             include_docs: true,
         }));
-        const external = externalTables.rows.flatMap(row => {
-            return Object.values(row.doc.entities || {}).map(entity => (Object.assign(Object.assign({}, entity), { type: "external", sourceId: row.doc._id })));
+        const external = externalTables.rows.flatMap(tableDoc => {
+            let entities = tableDoc.doc.entities;
+            if (entities) {
+                return Object.values(entities).map(entity => (Object.assign(Object.assign({}, entity), { type: "external", sourceId: tableDoc.doc._id, sql: isSQL(tableDoc.doc) })));
+            }
+            else {
+                return [];
+            }
         });
         ctx.body = [...internal, ...external];
     });

package/dist/api/controllers/table/internal.js

@@ -24,6 +24,9 @@ const linkRows = require("../../../db/linkedRows");
 const { getRowParams, generateTableID } = require("../../../db/utils");
 const { FieldTypes } = require("../../../constants");
 const { TableSaveFunctions, hasTypeChanged, getTable, handleDataImport, } = require("./utils");
+const usageQuota = require("../../../utilities/usageQuota");
+const { cleanupAttachments } = require("../../../utilities/rowProcessor");
+const { runStaticFormulaChecks } = require("./bulkFormula");
 exports.save = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
         const appId = ctx.appId;
@@ -105,6 +108,8 @@ exports.save = function (ctx) {
         const result = yield db.put(tableToSave);
         tableToSave._rev = result.rev;
         tableToSave = yield tableSaveFunctions.after(tableToSave);
+        // has to run after, make sure it has _id
+        yield runStaticFormulaChecks(appId, tableToSave, { oldTable });
         return tableToSave;
     });
 };
@@ -118,6 +123,7 @@ exports.destroy = function (ctx) {
             include_docs: true,
         }));
         yield db.bulkDocs(rows.rows.map(row => (Object.assign(Object.assign({}, row.doc), { _deleted: true }))));
+        yield usageQuota.update(usageQuota.Properties.ROW, -rows.rows.length);
         // update linked rows
         yield linkRows.updateLinks({
             appId,
@@ -132,6 +138,9 @@ exports.destroy = function (ctx) {
         if (existingIndex) {
             yield db.deleteIndex(existingIndex);
         }
+        // has to run after, make sure it has _id
+        yield runStaticFormulaChecks(appId, tableToDelete, { deletion: true });
+        yield cleanupAttachments(appId, tableToDelete, { rows });
         return tableToDelete;
     });
 };

package/dist/api/controllers/table/utils.js

@@ -10,15 +10,27 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 const CouchDB = require("../../../db");
 const csvParser = require("../../../utilities/csvParser");
-const { getRowParams, generateRowID, InternalTables, } = require("../../../db/utils");
-const { isEqual } = require("lodash/fp");
+const { getRowParams, generateRowID, InternalTables, getTableParams, BudibaseInternalDB, } = require("../../../db/utils");
+const { isEqual } = require("lodash");
 const { AutoFieldSubTypes, FieldTypes } = require("../../../constants");
-const { inputProcessing } = require("../../../utilities/rowProcessor");
-const { USERS_TABLE_SCHEMA, SwitchableTypes } = require("../../../constants");
-const { isExternalTable, breakExternalTableId, } = require("../../../integrations/utils");
+const { inputProcessing, cleanupAttachments, } = require("../../../utilities/rowProcessor");
+const { USERS_TABLE_SCHEMA, SwitchableTypes, CanSwitchTypes, } = require("../../../constants");
+const { isExternalTable, breakExternalTableId, isSQL, } = require("../../../integrations/utils");
 const { getViews, saveView } = require("../view/utils");
 const viewTemplate = require("../view/viewBuilder");
-exports.checkForColumnUpdates = (db, oldTable, updatedTable) => __awaiter(void 0, void 0, void 0, function* () {
+const usageQuota = require("../../../utilities/usageQuota");
+const { cloneDeep } = require("lodash/fp");
+exports.clearColumns = (appId, table, columnNames) => __awaiter(void 0, void 0, void 0, function* () {
+    const db = new CouchDB(appId);
+    const rows = yield db.allDocs(getRowParams(table._id, null, {
+        include_docs: true,
+    }));
+    return db.bulkDocs(rows.rows.map(({ doc }) => {
+        columnNames.forEach(colName => delete doc[colName]);
+        return doc;
+    }));
+});
+exports.checkForColumnUpdates = (appId, db, oldTable, updatedTable) => __awaiter(void 0, void 0, void 0, function* () {
     let updatedRows = [];
     const rename = updatedTable._rename;
     let deletedColumns = [];
@@ -31,16 +43,20 @@ exports.checkForColumnUpdates = (db, oldTable, updatedTable) => __awaiter(void 0
         const rows = yield db.allDocs(getRowParams(updatedTable._id, null, {
             include_docs: true,
         }));
-        updatedRows = rows.rows.map(({ doc }) => {
+        const rawRows = rows.rows.map(({ doc }) => doc);
+        updatedRows = rawRows.map(row => {
+            row = cloneDeep(row);
             if (rename) {
-                doc[rename.updated] = doc[rename.old];
-                delete doc[rename.old];
+                row[rename.updated] = row[rename.old];
+                delete row[rename.old];
             }
             else if (deletedColumns.length !== 0) {
-                deletedColumns.forEach(colName => delete doc[colName]);
+                deletedColumns.forEach(colName => delete row[colName]);
             }
-            return doc;
+            return row;
         });
+        // cleanup any attachments from object storage for deleted attachment columns
+        yield cleanupAttachments(appId, updatedTable, { oldTable, rows: rawRows });
         // Update views
         yield exports.checkForViewUpdates(db, updatedTable, rename, deletedColumns);
         delete updatedTable._rename;
@@ -95,7 +111,11 @@ exports.handleDataImport = (appId, user, table, dataImport) => __awaiter(void 0,
         }
         finalData.push(row);
     }
+    yield usageQuota.update(usageQuota.Properties.ROW, finalData.length, {
+        dryRun: true,
+    });
     yield db.bulkDocs(finalData);
+    yield usageQuota.update(usageQuota.Properties.ROW, finalData.length);
     let response = yield db.put(table);
     table._rev = response._rev;
     return table;
@@ -174,7 +194,7 @@ class TableSaveFunctions {
     // when confirmed valid
     mid(table) {
         return __awaiter(this, void 0, void 0, function* () {
-            let response = yield exports.checkForColumnUpdates(this.db, this.oldTable, table);
+            let response = yield exports.checkForColumnUpdates(this.appId, this.db, this.oldTable, table);
             this.rows = this.rows.concat(response.rows);
             return table;
         });
@@ -191,6 +211,13 @@ class TableSaveFunctions {
         return this.rows;
     }
 }
+exports.getAllInternalTables = (appId) => __awaiter(void 0, void 0, void 0, function* () {
+    const db = new CouchDB(appId);
+    const internalTables = yield db.allDocs(getTableParams(null, {
+        include_docs: true,
+    }));
+    return internalTables.rows.map(tableDoc => (Object.assign(Object.assign({}, tableDoc.doc), { type: "internal", sourceId: BudibaseInternalDB._id })));
+});
 exports.getAllExternalTables = (appId, datasourceId) => __awaiter(void 0, void 0, void 0, function* () {
     const db = new CouchDB(appId);
     const datasource = yield db.get(datasourceId);
@@ -207,7 +234,9 @@ exports.getTable = (appId, tableId) => __awaiter(void 0, void 0, void 0, functio
     const db = new CouchDB(appId);
     if (isExternalTable(tableId)) {
         let { datasourceId, tableName } = breakExternalTableId(tableId);
-        return exports.getExternalTable(appId, datasourceId, tableName);
+        const datasource = yield db.get(datasourceId);
+        const table = yield exports.getExternalTable(appId, datasourceId, tableName);
+        return Object.assign(Object.assign({}, table), { sql: isSQL(datasource) });
     }
     else {
         return db.get(tableId);
@@ -295,6 +324,19 @@ exports.foreignKeyStructure = (keyName, meta = null) => {
     }
     return structure;
 };
+exports.areSwitchableTypes = (type1, type2) => {
+    if (SwitchableTypes.indexOf(type1) === -1 &&
+        SwitchableTypes.indexOf(type2) === -1) {
+        return false;
+    }
+    for (let option of CanSwitchTypes) {
+        const index1 = option.indexOf(type1), index2 = option.indexOf(type2);
+        if (index1 !== -1 && index2 !== -1 && index1 !== index2) {
+            return true;
+        }
+    }
+    return false;
+};
 exports.hasTypeChanged = (table, oldTable) => {
     if (!oldTable) {
         return false;
@@ -305,7 +347,7 @@ exports.hasTypeChanged = (table, oldTable) => {
             continue;
         }
         const newType = table.schema[key].type;
-        if (oldType !== newType && SwitchableTypes.indexOf(oldType) === -1) {
+        if (oldType !== newType && !exports.areSwitchableTypes(oldType, newType)) {
             return true;
         }
     }

package/dist/api/controllers/user.js

@@ -155,6 +155,8 @@ exports.updateSelfMetadata = function (ctx) {
         ctx.request.body._id = ctx.user._id;
         // make sure no stale rev
         delete ctx.request.body._rev;
+        // make sure no csrf token
+        delete ctx.request.body.csrfToken;
         yield exports.updateMetadata(ctx);
     });
 };

package/dist/api/routes/index.js

@@ -21,7 +21,6 @@ const integrationRoutes = require("./integration");
 const permissionRoutes = require("./permission");
 const datasourceRoutes = require("./datasource");
 const queryRoutes = require("./query");
-const hostingRoutes = require("./hosting");
 const backupRoutes = require("./backup");
 const metadataRoutes = require("./metadata");
 const devRoutes = require("./dev");
@@ -46,7 +45,6 @@ exports.mainRoutes = [
     permissionRoutes,
     datasourceRoutes,
     queryRoutes,
-    hostingRoutes,
     backupRoutes,
     metadataRoutes,
     devRoutes,

package/dist/api/routes/static.js

@@ -43,5 +43,6 @@ router
     .post("/api/attachments/process", authorized(BUILDER), controller.uploadFile)
     .post("/api/attachments/:tableId/upload", paramResource("tableId"), authorized(PermissionTypes.TABLE, PermissionLevels.WRITE), controller.uploadFile)
     // TODO: this likely needs to be secured in some way
-    .get("/:appId/:path*", controller.serveApp);
+    .get("/:appId/:path*", controller.serveApp)
+    .post("/api/attachments/:datasourceId/url", authorized(PermissionTypes.TABLE, PermissionLevels.READ), controller.getSignedUploadURL);
 module.exports = router;

package/dist/automations/steps/createRow.js

@@ -10,7 +10,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 const rowController = require("../../api/controllers/row");
 const automationUtils = require("../automationUtils");
-const env = require("../../environment");
 const usage = require("../../utilities/usageQuota");
 const { buildCtx } = require("./utils");
 exports.definition = {
@@ -87,10 +86,9 @@ exports.run = function ({ inputs, appId, emitter }) {
         });
         try {
             inputs.row = yield automationUtils.cleanUpRow(appId, inputs.row.tableId, inputs.row);
-            if (env.USE_QUOTAS) {
-                yield usage.update(usage.Properties.ROW, 1);
-            }
+            yield usage.update(usage.Properties.ROW, 1, { dryRun: true });
             yield rowController.save(ctx);
+            yield usage.update(usage.Properties.ROW, 1);
             return {
                 row: inputs.row,
                 response: ctx.body,

package/dist/automations/steps/deleteRow.js

@@ -9,7 +9,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 const rowController = require("../../api/controllers/row");
-const env = require("../../environment");
 const usage = require("../../utilities/usageQuota");
 const { buildCtx } = require("./utils");
 const automationUtils = require("../automationUtils");
@@ -81,9 +80,7 @@ exports.run = function ({ inputs, appId, emitter }) {
             },
         });
         try {
-            if (env.isProd()) {
-                yield usage.update(usage.Properties.ROW, -1);
-            }
+            yield usage.update(usage.Properties.ROW, -1);
             yield rowController.destroy(ctx);
             return {
                 response: ctx.body,

package/dist/constants/index.js

@@ -41,17 +41,21 @@ exports.FieldTypes = {
     JSON: "json",
     INTERNAL: "internal",
 };
-exports.SwitchableTypes = [
-    exports.FieldTypes.STRING,
-    exports.FieldTypes.OPTIONS,
-    exports.FieldTypes.NUMBER,
-    exports.FieldTypes.BOOLEAN,
+exports.CanSwitchTypes = [
+    [exports.FieldTypes.JSON, exports.FieldTypes.ARRAY],
+    [exports.FieldTypes.STRING, exports.FieldTypes.OPTIONS],
+    [exports.FieldTypes.BOOLEAN, exports.FieldTypes.NUMBER],
 ];
+exports.SwitchableTypes = exports.CanSwitchTypes.reduce((prev, current) => prev ? prev.concat(current) : current);
 exports.RelationshipTypes = {
     ONE_TO_MANY: "one-to-many",
     MANY_TO_ONE: "many-to-one",
     MANY_TO_MANY: "many-to-many",
 };
+exports.FormulaTypes = {
+    STATIC: "static",
+    DYNAMIC: "dynamic",
+};
 exports.AuthTypes = {
     APP: "app",
     BUILDER: "builder",
@@ -67,6 +71,9 @@ exports.DataSourceOperation = {
     UPDATE_TABLE: "UPDATE_TABLE",
     DELETE_TABLE: "DELETE_TABLE",
 };
+exports.DatasourceAuthTypes = {
+    GOOGLE: "google",
+};
 exports.SortDirection = {
     ASCENDING: "ASCENDING",
     DESCENDING: "DESCENDING",

package/dist/db/linkedRows/index.js

@@ -61,7 +61,7 @@ function getLinksForRows(appId, rows) {
             .map(el => (Object.assign(Object.assign({}, el), { unique: el.id + el.thisId + el.fieldName }))), "unique");
     });
 }
-function getFullLinkedDocs(ctx, appId, links) {
+function getFullLinkedDocs(appId, links) {
     return __awaiter(this, void 0, void 0, function* () {
         // create DBs
         const db = new CouchDB(appId);
@@ -132,13 +132,12 @@ exports.updateLinks = function (args) {
 /**
  * Given a table and a list of rows this will retrieve all of the attached docs and enrich them into the row.
  * This is required for formula fields, this may only be utilised internally (for now).
- * @param {object} ctx The request which is looking for rows.
+ * @param {string} appId The ID of the app which this request is in the context of.
  * @param {object} table The table from which the rows originated.
  * @param {array<object>} rows The rows which are to be enriched.
  * @return {Promise<*>} returns the rows with all of the enriched relationships on it.
  */
-exports.attachFullLinkedDocs = (ctx, table, rows) => __awaiter(void 0, void 0, void 0, function* () {
-    const appId = ctx.appId;
+exports.attachFullLinkedDocs = (appId, table, rows) => __awaiter(void 0, void 0, void 0, function* () {
     const linkedTableIds = getLinkedTableIDs(table);
     if (linkedTableIds.length === 0) {
         return rows;
@@ -150,7 +149,7 @@ exports.attachFullLinkedDocs = (ctx, table, rows) => __awaiter(void 0, void 0, v
     // clear any existing links that could be dupe'd
     rows = clearRelationshipFields(table, rows);
     // now get the docs and combine into the rows
-    let linked = yield getFullLinkedDocs(ctx, appId, links);
+    let linked = yield getFullLinkedDocs(appId, links);
     const linkedTables = [];
     for (let row of rows) {
         for (let link of links.filter(link => link.thisId === row._id)) {

package/dist/definitions/datasource.js

@@ -49,6 +49,7 @@ var SourceNames;
     SourceNames["ARANGODB"] = "ARANGODB";
     SourceNames["REST"] = "REST";
     SourceNames["ORACLE"] = "ORACLE";
+    SourceNames["GOOGLE_SHEETS"] = "GOOGLE_SHEETS";
 })(SourceNames = exports.SourceNames || (exports.SourceNames = {}));
 var IncludeRelationships;
 (function (IncludeRelationships) {

package/dist/environment.js

@@ -30,6 +30,7 @@ module.exports = {
     MINIO_ACCESS_KEY: process.env.MINIO_ACCESS_KEY,
     MINIO_SECRET_KEY: process.env.MINIO_SECRET_KEY,
     USE_QUOTAS: process.env.USE_QUOTAS,
+    EXCLUDE_QUOTAS_TENANTS: process.env.EXCLUDE_QUOTAS_TENANTS,
     REDIS_URL: process.env.REDIS_URL,
     REDIS_PASSWORD: process.env.REDIS_PASSWORD,
     INTERNAL_API_KEY: process.env.INTERNAL_API_KEY,

package/dist/integrations/base/sql.js

@@ -69,10 +69,16 @@ class InternalBuilder {
         this.client = client;
     }
     // right now we only do filters on the specific table being queried
-    addFilters(tableName, query, filters) {
+    addFilters(query, filters, opts) {
         function iterate(structure, fn) {
             for (let [key, value] of Object.entries(structure)) {
-                fn(`${tableName}.${key}`, value);
+                const isRelationshipField = key.includes(".");
+                if (!opts.relationship && !isRelationshipField) {
+                    fn(`${opts.tableName}.${key}`, value);
+                }
+                if (opts.relationship && isRelationshipField) {
+                    fn(key, value);
+                }
             }
         }
         if (!filters) {
@@ -248,7 +254,7 @@ class InternalBuilder {
         if (foundOffset) {
             query = query.offset(foundOffset);
         }
-        query = this.addFilters(tableName, query, filters);
+        query = this.addFilters(query, filters, { tableName });
         // add sorting to pre-query
         query = this.addSorting(query, json);
         // @ts-ignore
@@ -261,13 +267,14 @@ class InternalBuilder {
             preQuery = this.addSorting(preQuery, json);
         }
         // handle joins
-        return this.addRelationships(knex, preQuery, selectStatement, tableName, relationships);
+        query = this.addRelationships(knex, preQuery, selectStatement, tableName, relationships);
+        return this.addFilters(query, filters, { relationship: true });
     }
     update(knex, json, opts) {
         const { endpoint, body, filters } = json;
         let query = knex(endpoint.entityId);
         const parsedBody = parseBody(body);
-        query = this.addFilters(endpoint.entityId, query, filters);
+        query = this.addFilters(query, filters, { tableName: endpoint.entityId });
         // mysql can't use returning
         if (opts.disableReturning) {
             return query.update(parsedBody);
@@ -279,7 +286,7 @@ class InternalBuilder {
     delete(knex, json, opts) {
         const { endpoint, filters } = json;
         let query = knex(endpoint.entityId);
-        query = this.addFilters(endpoint.entityId, query, filters);
+        query = this.addFilters(query, filters, { tableName: endpoint.entityId });
         // mysql can't use returning
         if (opts.disableReturning) {
             return query.delete();