@budibase/server 1.0.47 → 1.0.49-alpha.2

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

@@ -14,7 +14,7 @@ const { resolve, join } = require("../../../utilities/centralPath");
 const uuid = require("uuid");
 const { ObjectStoreBuckets } = require("../../../constants");
 const { processString } = require("@budibase/string-templates");
-const { getDeployedApps } = require("../../../utilities/workerRequests");
+const { getAllApps } = require("@budibase/backend-core/db");
 const CouchDB = require("../../../db");
 const { loadHandlebarsFile, NODE_MODULES_PATH, TOP_LEVEL_PATH, } = require("../../../utilities/fileSystem");
 const env = require("../../../environment");
@@ -22,6 +22,8 @@ const { clientLibraryPath } = require("../../../utilities");
 const { upload } = require("../../../utilities/fileSystem");
 const { attachmentsRelativeURL } = require("../../../utilities");
 const { DocumentTypes } = require("../../../db/utils");
+const AWS = require("aws-sdk");
+const AWS_REGION = env.AWS_REGION ? env.AWS_REGION : "eu-west-1";
 function prepareUpload({ s3Key, bucket, metadata, file }) {
     return __awaiter(this, void 0, void 0, function* () {
         const response = yield upload({
@@ -41,13 +43,15 @@ function prepareUpload({ s3Key, bucket, metadata, file }) {
         };
     });
 }
-function checkForSelfHostedURL(ctx) {
+function getAppIdFromUrl(ctx) {
     return __awaiter(this, void 0, void 0, function* () {
-        // the "appId" component of the URL may actually be a specific self hosted URL
+        // the "appId" component of the URL can be the id or the custom url
         let possibleAppUrl = `/${encodeURI(ctx.params.appId).toLowerCase()}`;
-        const apps = yield getDeployedApps();
-        if (apps[possibleAppUrl] && apps[possibleAppUrl].appId) {
-            return apps[possibleAppUrl].appId;
+        // search prod apps for a url that matches, exclude dev where id is always used
+        const apps = yield getAllApps(CouchDB, { dev: false });
+        const app = apps.filter(a => a.url && a.url.toLowerCase() === possibleAppUrl)[0];
+        if (app && app.appId) {
+            return app.appId;
         }
         else {
             return ctx.params.appId;
@@ -80,10 +84,7 @@ exports.uploadFile = function (ctx) {
 };
 exports.serveApp = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
-        let appId = ctx.params.appId;
-        if (env.SELF_HOSTED) {
-            appId = yield checkForSelfHostedURL(ctx);
-        }
+        let appId = yield getAppIdFromUrl(ctx);
         const App = require("./templates/BudibaseApp.svelte").default;
         const db = new CouchDB(appId, { skip_setup: true });
         const appInfo = yield db.get(DocumentTypes.APP_METADATA);
@@ -109,3 +110,51 @@ exports.serveClientLibrary = function (ctx) {
         });
     });
 };
+exports.getSignedUploadURL = function (ctx) {
+    var _a, _b, _c;
+    return __awaiter(this, void 0, void 0, function* () {
+        const database = new CouchDB(ctx.appId);
+        // Ensure datasource is valid
+        let datasource;
+        try {
+            const { datasourceId } = ctx.params;
+            datasource = yield database.get(datasourceId);
+            if (!datasource) {
+                ctx.throw(400, "The specified datasource could not be found");
+            }
+        }
+        catch (error) {
+            ctx.throw(400, "The specified datasource could not be found");
+        }
+        // Ensure we aren't using a custom endpoint
+        if ((_a = datasource === null || datasource === void 0 ? void 0 : datasource.config) === null || _a === void 0 ? void 0 : _a.endpoint) {
+            ctx.throw(400, "S3 datasources with custom endpoints are not supported");
+        }
+        // Determine type of datasource and generate signed URL
+        let signedUrl;
+        let publicUrl;
+        if (datasource.source === "S3") {
+            const { bucket, key } = ctx.request.body || {};
+            if (!bucket || !key) {
+                ctx.throw(400, "bucket and key values are required");
+                return;
+            }
+            try {
+                const s3 = new AWS.S3({
+                    region: AWS_REGION,
+                    accessKeyId: (_b = datasource === null || datasource === void 0 ? void 0 : datasource.config) === null || _b === void 0 ? void 0 : _b.accessKeyId,
+                    secretAccessKey: (_c = datasource === null || datasource === void 0 ? void 0 : datasource.config) === null || _c === void 0 ? void 0 : _c.secretAccessKey,
+                    apiVersion: "2006-03-01",
+                    signatureVersion: "v4",
+                });
+                const params = { Bucket: bucket, Key: key };
+                signedUrl = s3.getSignedUrl("putObject", params);
+                publicUrl = `https://${bucket}.s3.${AWS_REGION}.amazonaws.com/${key}`;
+            }
+            catch (error) {
+                ctx.throw(400, error);
+            }
+        }
+        ctx.body = { signedUrl, publicUrl };
+    });
+};

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,11 +21,11 @@ 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");
 const cloudRoutes = require("./cloud");
+const migrationRoutes = require("./migrations");
 exports.mainRoutes = [
     authRoutes,
     deployRoutes,
@@ -46,7 +46,6 @@ exports.mainRoutes = [
     permissionRoutes,
     datasourceRoutes,
     queryRoutes,
-    hostingRoutes,
     backupRoutes,
     metadataRoutes,
     devRoutes,
@@ -55,5 +54,6 @@ exports.mainRoutes = [
     // this could be breaking as koa may recognise other routes as this
     tableRoutes,
     rowRoutes,
+    migrationRoutes,
 ];
 exports.staticRoutes = staticRoutes;

package/dist/api/routes/migrations.js

@@ -0,0 +1,9 @@
+"use strict";
+const Router = require("@koa/router");
+const migrationsController = require("../controllers/migrations");
+const router = Router();
+const { internalApi } = require("@budibase/backend-core/auth");
+router
+    .post("/api/migrations/run", internalApi, migrationsController.migrate)
+    .get("/api/migrations/definitions", internalApi, migrationsController.fetchDefinitions);
+module.exports = router;

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/app.js

@@ -1,4 +1,23 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 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) {
@@ -9,7 +28,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const env = require("./environment");
+const env = __importStar(require("./environment"));
 const CouchDB = require("./db");
 require("@budibase/backend-core").init(CouchDB);
 const Koa = require("koa");
@@ -24,6 +43,7 @@ const Sentry = require("@sentry/node");
 const fileSystem = require("./utilities/fileSystem");
 const bullboard = require("./automations/bullboard");
 const redis = require("./utilities/redis");
+const migrations = __importStar(require("./migrations"));
 const app = new Koa();
 // set up top level koa middleware
 app.use(koaBody({
@@ -76,12 +96,22 @@ module.exports = server.listen(env.PORT || 0, () => __awaiter(void 0, void 0, vo
     yield redis.init();
     yield automations.init();
 }));
-process.on("uncaughtException", err => {
-    console.error(err);
+const shutdown = () => {
     server.close();
     server.destroy();
+};
+process.on("uncaughtException", err => {
+    console.error(err);
+    shutdown();
 });
 process.on("SIGTERM", () => {
-    server.close();
-    server.destroy();
+    shutdown();
 });
+// run migrations on startup if not done via http
+// not recommended in a clustered environment
+if (!env.HTTP_MIGRATIONS) {
+    migrations.migrate().catch(err => {
+        console.error("Error performing migrations. Exiting.\n", err);
+        shutdown();
+    });
+}

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,