@budibase/server 1.0.46 → 1.0.49-alpha.1

package/dist/api/controllers/application.js

@@ -20,7 +20,7 @@ const { cloneDeep } = require("lodash/fp");
 const { processObject } = require("@budibase/string-templates");
 const { getAllApps, isDevAppID, getDeployedAppID, Replication, } = require("@budibase/backend-core/db");
 const { USERS_TABLE_SCHEMA } = require("../../constants");
-const { getDeployedApps, removeAppFromUserRoles, } = require("../../utilities/workerRequests");
+const { removeAppFromUserRoles } = require("../../utilities/workerRequests");
 const { clientLibraryPath, stringToReadStream } = require("../../utilities");
 const { getAllLocks } = require("../../utilities/redis");
 const { updateClientLibrary, backupClientLibrary, revertClientLibrary, } = require("../../utilities/fileSystem/clientLibrary");
@@ -49,31 +49,44 @@ function getUserRoleId(ctx) {
         ? BUILTIN_ROLE_IDS.PUBLIC
         : ctx.user.role._id;
 }
-function getAppUrlIfNotInUse(ctx) {
+function getAppUrl(ctx) {
     return __awaiter(this, void 0, void 0, function* () {
+        // construct the url
         let url;
         if (ctx.request.body.url) {
+            // if the url is provided, use that
             url = encodeURI(ctx.request.body.url);
         }
         else if (ctx.request.body.name) {
+            // otherwise use the name
             url = encodeURI(`${ctx.request.body.name}`);
         }
         if (url) {
             url = `/${url.replace(URL_REGEX_SLASH, "")}`.toLowerCase();
         }
-        if (!env.SELF_HOSTED) {
-            return url;
-        }
-        const deployedApps = yield getDeployedApps();
-        if (url &&
-            deployedApps[url] != null &&
-            ctx.params != null &&
-            deployedApps[url].appId !== ctx.params.appId) {
-            ctx.throw(400, "App name/URL is already in use.");
-        }
         return url;
     });
 }
+const checkAppUrl = (ctx, apps, url, currentAppId) => {
+    if (currentAppId) {
+        apps = apps.filter(app => app.appId !== currentAppId);
+    }
+    if (apps.some(app => app.url === url)) {
+        ctx.throw(400, "App URL is already in use.");
+    }
+};
+const checkAppName = (ctx, apps, name, currentAppId) => {
+    // TODO: Replace with Joi
+    if (!name) {
+        ctx.throw(400, "Name is required");
+    }
+    if (currentAppId) {
+        apps = apps.filter(app => app.appId !== currentAppId);
+    }
+    if (apps.some(app => app.name === name)) {
+        ctx.throw(400, "App name is already in use.");
+    }
+};
 function createInstance(template) {
     return __awaiter(this, void 0, void 0, function* () {
         const tenantId = isMultiTenant() ? getTenantId() : null;
@@ -167,6 +180,11 @@ exports.fetchAppPackage = (ctx) => __awaiter(void 0, void 0, void 0, function* (
     };
 });
 exports.create = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+    const apps = yield getAllApps(CouchDB, { dev: true });
+    const name = ctx.request.body.name;
+    checkAppName(ctx, apps, name);
+    const url = yield getAppUrl(ctx);
+    checkAppUrl(ctx, apps, url);
     const { useTemplate, templateKey, templateString } = ctx.request.body;
     const instanceConfig = {
         useTemplate,
@@ -178,7 +196,6 @@ exports.create = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
     }
     const instance = yield createInstance(instanceConfig);
     const appId = instance._id;
-    const url = yield getAppUrlIfNotInUse(ctx);
     const db = new CouchDB(appId);
     let _rev;
     try {
@@ -196,7 +213,7 @@ exports.create = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
         type: "app",
         version: packageJson.version,
         componentLibraries: ["@budibase/standard-components"],
-        name: ctx.request.body.name,
+        name: name,
         url: url,
         template: ctx.request.body.template,
         instance: instance,
@@ -219,8 +236,21 @@ exports.create = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
     ctx.status = 200;
     ctx.body = newApplication;
 });
+// This endpoint currently operates as a PATCH rather than a PUT
+// Thus name and url fields are handled only if present
 exports.update = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
-    const data = yield updateAppPackage(ctx, ctx.request.body, ctx.params.appId);
+    const apps = yield getAllApps(CouchDB, { dev: true });
+    // validation
+    const name = ctx.request.body.name;
+    if (name) {
+        checkAppName(ctx, apps, name, ctx.params.appId);
+    }
+    const url = yield getAppUrl(ctx);
+    if (url) {
+        checkAppUrl(ctx, apps, url, ctx.params.appId);
+        ctx.request.body.url = url;
+    }
+    const data = yield updateAppPackage(ctx.request.body, ctx.params.appId);
     ctx.status = 200;
     ctx.body = data;
 });
@@ -239,7 +269,7 @@ exports.updateClient = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
         version: packageJson.version,
         revertableVersion: currentVersion,
     };
-    const data = yield updateAppPackage(ctx, appPackageUpdates, ctx.params.appId);
+    const data = yield updateAppPackage(appPackageUpdates, ctx.params.appId);
     ctx.status = 200;
     ctx.body = data;
 });
@@ -259,7 +289,7 @@ exports.revertClient = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
         version: application.revertableVersion,
         revertableVersion: null,
     };
-    const data = yield updateAppPackage(ctx, appPackageUpdates, ctx.params.appId);
+    const data = yield updateAppPackage(appPackageUpdates, ctx.params.appId);
     ctx.status = 200;
     ctx.body = data;
 });
@@ -326,11 +356,10 @@ exports.sync = (ctx, next) => __awaiter(void 0, void 0, void 0, function* () {
         };
     }
 });
-const updateAppPackage = (ctx, appPackage, appId) => __awaiter(void 0, void 0, void 0, function* () {
-    const url = yield getAppUrlIfNotInUse(ctx);
+const updateAppPackage = (appPackage, appId) => __awaiter(void 0, void 0, void 0, function* () {
     const db = new CouchDB(appId);
     const application = yield db.get(DocumentTypes.APP_METADATA);
-    const newAppPackage = Object.assign(Object.assign(Object.assign({}, application), appPackage), { url });
+    const newAppPackage = Object.assign(Object.assign({}, application), appPackage);
     if (appPackage._rev !== application._rev) {
         newAppPackage._rev = application._rev;
     }

package/dist/api/controllers/auth.js

@@ -24,6 +24,8 @@ exports.fetchSelf = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
     const user = yield getFullUser(ctx, userId);
     // this shouldn't be returned by the app self
     delete user.roles;
+    // forward the csrf token from the session
+    user.csrfToken = ctx.user.csrfToken;
     if (appId) {
         const db = new CouchDB(appId);
         // remove the full roles structure
@@ -31,6 +33,8 @@ exports.fetchSelf = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
         try {
             const userTable = yield db.get(InternalTables.USER_METADATA);
             const metadata = yield db.get(userId);
+            // make sure there is never a stale csrf token
+            delete metadata.csrfToken;
             // specifically needs to make sure is enriched
             ctx.body = yield outputProcessing(ctx, userTable, Object.assign(Object.assign({}, user), metadata));
         }

package/dist/api/controllers/datasource.js

@@ -28,6 +28,12 @@ exports.fetch = function (ctx) {
         const datasources = (yield database.allDocs(getDatasourceParams(null, {
             include_docs: true,
         }))).rows.map(row => row.doc);
+        for (let datasource of datasources) {
+            if (datasource.config && datasource.config.auth) {
+                // strip secrets from response so they don't show in the network request
+                delete datasource.config.auth;
+            }
+        }
         ctx.body = [bbInternalDb, ...datasources];
     });
 };
@@ -78,8 +84,13 @@ exports.update = function (ctx) {
         const db = new CouchDB(ctx.appId);
         const datasourceId = ctx.params.datasourceId;
         let datasource = yield db.get(datasourceId);
+        const auth = datasource.config.auth;
         yield invalidateVariables(datasource, ctx.request.body);
         datasource = Object.assign(Object.assign({}, datasource), ctx.request.body);
+        if (auth && !ctx.request.body.auth) {
+            // don't strip auth config from DB
+            datasource.config.auth = auth;
+        }
         const response = yield db.put(datasource);
         datasource._rev = response.rev;
         // Drain connection pools when configuration is changed

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

@@ -431,6 +431,7 @@ 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
@@ -442,7 +443,7 @@ var External;
                     const linkTable = this.getTable(tableId);
                     // @ts-ignore
                     const linkPrimary = linkTable.primary[0];
-                    const rows = related[key].rows || [];
+                    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[linkPrimary]);
                     const operation = isUpdate

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

@@ -21,11 +21,10 @@ var __rest = (this && this.__rest) || function (s, e) {
 };
 const CouchDB = require("../../../db");
 const linkRows = require("../../../db/linkedRows");
-const { getRowParams, generateRowID, DocumentTypes, InternalTables, } = require("../../../db/utils");
+const { generateRowID, getRowParams, DocumentTypes, InternalTables, } = require("../../../db/utils");
 const userController = require("../user");
-const { inputProcessing, outputProcessing, processAutoColumn, cleanupAttachments, } = require("../../../utilities/rowProcessor");
+const { inputProcessing, outputProcessing, cleanupAttachments, } = require("../../../utilities/rowProcessor");
 const { FieldTypes } = require("../../../constants");
-const { isEqual } = require("lodash");
 const { validate, findRow } = require("./utils");
 const { fullSearch, paginatedSearch } = require("./internalSearch");
 const { getGlobalUsersFromMetadata } = require("../../../utilities/global");
@@ -33,59 +32,12 @@ const inMemoryViews = require("../../../db/inMemoryView");
 const env = require("../../../environment");
 const { migrateToInMemoryView, migrateToDesignView, getFromDesignDoc, getFromMemoryDoc, } = require("../view/utils");
 const { cloneDeep } = require("lodash/fp");
+const { finaliseRow, updateRelatedFormula } = require("./staticFormula");
 const CALCULATION_TYPES = {
     SUM: "sum",
     COUNT: "count",
     STATS: "stats",
 };
-function storeResponse(ctx, db, row, oldTable, table) {
-    return __awaiter(this, void 0, void 0, function* () {
-        row.type = "row";
-        // don't worry about rev, tables handle rev/lastID updates
-        // if another row has been written since processing this will
-        // handle the auto ID clash
-        if (!isEqual(oldTable, table)) {
-            try {
-                yield db.put(table);
-            }
-            catch (err) {
-                if (err.status === 409) {
-                    const updatedTable = yield db.get(table._id);
-                    let response = processAutoColumn(null, updatedTable, row, {
-                        reprocessing: true,
-                    });
-                    yield db.put(response.table);
-                    row = response.row;
-                }
-                else {
-                    throw err;
-                }
-            }
-        }
-        const response = yield db.put(row);
-        row._rev = response.rev;
-        // process the row before return, to include relationships
-        row = yield outputProcessing(ctx, table, row, { squash: false });
-        return { row, table };
-    });
-}
-// doesn't do the outputProcessing
-function getRawTableData(ctx, db, tableId) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let rows;
-        if (tableId === InternalTables.USER_METADATA) {
-            yield userController.fetchMetadata(ctx);
-            rows = ctx.body;
-        }
-        else {
-            const response = yield db.allDocs(getRowParams(tableId, null, {
-                include_docs: true,
-            }));
-            rows = response.rows.map(row => row.doc);
-        }
-        return rows;
-    });
-}
 function getView(db, viewName) {
     return __awaiter(this, void 0, void 0, function* () {
         let mainGetter = env.SELF_HOSTED ? getFromDesignDoc : getFromMemoryDoc;
@@ -114,6 +66,22 @@ function getView(db, viewName) {
         return viewInfo;
     });
 }
+function getRawTableData(ctx, db, tableId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let rows;
+        if (tableId === InternalTables.USER_METADATA) {
+            yield userController.fetchMetadata(ctx);
+            rows = ctx.body;
+        }
+        else {
+            const response = yield db.allDocs(getRowParams(tableId, null, {
+                include_docs: true,
+            }));
+            rows = response.rows.map(row => row.doc);
+        }
+        return rows;
+    });
+}
 exports.patch = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
     const appId = ctx.appId;
     const db = new CouchDB(appId);
@@ -169,7 +137,10 @@ exports.patch = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
         yield userController.updateMetadata(ctx);
         return { row: ctx.body, table };
     }
-    return storeResponse(ctx, db, row, dbTable, table);
+    return finaliseRow(ctx.appId, table, row, {
+        oldTable: dbTable,
+        updateFormula: true,
+    });
 });
 exports.save = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -198,7 +169,10 @@ exports.save = function (ctx) {
             tableId: row.tableId,
             table,
         });
-        return storeResponse(ctx, db, row, dbTable, table);
+        return finaliseRow(ctx.appId, table, row, {
+            oldTable: dbTable,
+            updateFormula: true,
+        });
     });
 };
 exports.fetchView = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
@@ -290,6 +264,8 @@ exports.destroy = function (ctx) {
         });
         // remove any attachments that were on the row from object storage
         yield cleanupAttachments(appId, table, { row });
+        // remove any static formula
+        yield updateRelatedFormula(appId, table, row);
         let response;
         if (ctx.params.tableId === InternalTables.USER_METADATA) {
             ctx.params = {
@@ -333,6 +309,7 @@ exports.bulkDestroy = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
     }
     // remove any attachments that were on the rows from object storage
     yield cleanupAttachments(appId, table, { rows });
+    yield updateRelatedFormula(appId, table, rows);
     yield Promise.all(updates);
     return { response: { ok: true }, rows };
 });

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

@@ -34,19 +34,27 @@ class QueryBuilder {
         return this;
     }
     setLimit(limit) {
-        this.limit = limit;
+        if (limit != null) {
+            this.limit = limit;
+        }
         return this;
     }
     setSort(sort) {
-        this.sort = sort;
+        if (sort != null) {
+            this.sort = sort;
+        }
         return this;
     }
     setSortOrder(sortOrder) {
-        this.sortOrder = sortOrder;
+        if (sortOrder != null) {
+            this.sortOrder = sortOrder;
+        }
         return this;
     }
     setSortType(sortType) {
-        this.sortType = sortType;
+        if (sortType != null) {
+            this.sortType = sortType;
+        }
         return this;
     }
     setBookmark(bookmark) {

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

@@ -0,0 +1,147 @@
+"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 { getRowParams } = require("../../../db/utils");
+const { outputProcessing, processAutoColumn, processFormulas, } = require("../../../utilities/rowProcessor");
+const { FieldTypes, FormulaTypes } = require("../../../constants");
+const { isEqual } = require("lodash");
+const { cloneDeep } = require("lodash/fp");
+/**
+ * This function runs through a list of enriched rows, looks at the rows which
+ * are related and then checks if they need the state of their formulas
+ * updated.
+ * NOTE: this will only for affect static formulas.
+ */
+exports.updateRelatedFormula = (appId, table, enrichedRows) => __awaiter(void 0, void 0, void 0, function* () {
+    const db = new CouchDB(appId);
+    // no formula to update, we're done
+    if (!table.relatedFormula) {
+        return;
+    }
+    let promises = [];
+    for (let enrichedRow of Array.isArray(enrichedRows)
+        ? enrichedRows
+        : [enrichedRows]) {
+        // the related rows by tableId
+        let relatedRows = {};
+        for (let [key, field] of Object.entries(enrichedRow)) {
+            const columnDefinition = table.schema[key];
+            if (columnDefinition && columnDefinition.type === FieldTypes.LINK) {
+                const relatedTableId = columnDefinition.tableId;
+                if (!relatedRows[relatedTableId]) {
+                    relatedRows[relatedTableId] = [];
+                }
+                relatedRows[relatedTableId] = relatedRows[relatedTableId].concat(field);
+            }
+        }
+        for (let tableId of table.relatedFormula) {
+            let relatedTable;
+            try {
+                // no rows to update, skip
+                if (!relatedRows[tableId] || relatedRows[tableId].length === 0) {
+                    continue;
+                }
+                relatedTable = yield db.get(tableId);
+            }
+            catch (err) {
+                // no error scenario, table doesn't seem to exist anymore, ignore
+            }
+            for (let column of Object.values(relatedTable.schema)) {
+                // needs updated in related rows
+                if (column.type === FieldTypes.FORMULA &&
+                    column.formulaType === FormulaTypes.STATIC) {
+                    // re-enrich rows for all the related, don't update the related formula for them
+                    promises = promises.concat(relatedRows[tableId].map(related => exports.finaliseRow(appId, relatedTable, related, {
+                        updateFormula: false,
+                    })));
+                }
+            }
+        }
+    }
+    yield Promise.all(promises);
+});
+exports.updateAllFormulasInTable = (appId, table) => __awaiter(void 0, void 0, void 0, function* () {
+    const db = new CouchDB(appId);
+    // start by getting the raw rows (which will be written back to DB after update)
+    let rows = (yield db.allDocs(getRowParams(table._id, null, {
+        include_docs: true,
+    }))).rows.map(row => row.doc);
+    // now enrich the rows, note the clone so that we have the base state of the
+    // rows so that we don't write any of the enriched information back
+    let enrichedRows = yield outputProcessing({ appId }, table, cloneDeep(rows), {
+        squash: false,
+    });
+    const updatedRows = [];
+    for (let row of rows) {
+        // find the enriched row, if found process the formulas
+        const enrichedRow = enrichedRows.find(enriched => enriched._id === row._id);
+        if (enrichedRow) {
+            const processed = processFormulas(table, cloneDeep(row), {
+                dynamic: false,
+                contextRows: enrichedRow,
+            });
+            // values have changed, need to add to bulk docs to update
+            if (!isEqual(processed, row)) {
+                updatedRows.push(processed);
+            }
+        }
+    }
+    yield db.bulkDocs(updatedRows);
+});
+/**
+ * This function runs at the end of the save/patch functions of the row controller, all this
+ * really does is enrich the row, handle any static formula processing, then return the enriched
+ * row. The reason we need to return the enriched row is that the automation row created trigger
+ * expects the row to be totally enriched/contain all relationships.
+ */
+exports.finaliseRow = (appId, table, row, { oldTable, updateFormula } = { updateFormula: true }) => __awaiter(void 0, void 0, void 0, function* () {
+    const db = new CouchDB(appId);
+    row.type = "row";
+    // process the row before return, to include relationships
+    let enrichedRow = yield outputProcessing({ appId }, table, cloneDeep(row), {
+        squash: false,
+    });
+    // use enriched row to generate formulas for saving, specifically only use as context
+    row = processFormulas(table, row, {
+        dynamic: false,
+        contextRows: enrichedRow,
+    });
+    // don't worry about rev, tables handle rev/lastID updates
+    // if another row has been written since processing this will
+    // handle the auto ID clash
+    if (oldTable && !isEqual(oldTable, table)) {
+        try {
+            yield db.put(table);
+        }
+        catch (err) {
+            if (err.status === 409) {
+                const updatedTable = yield db.get(table._id);
+                let response = processAutoColumn(null, updatedTable, row, {
+                    reprocessing: true,
+                });
+                yield db.put(response.table);
+                row = response.row;
+            }
+            else {
+                throw err;
+            }
+        }
+    }
+    const response = yield db.put(row);
+    // for response, calculate the formulas for the enriched row
+    enrichedRow._rev = response.rev;
+    enrichedRow = yield processFormulas(table, enrichedRow, { dynamic: false });
+    // this updates the related formulas in other rows based on the relations to this row
+    if (updateFormula) {
+        yield exports.updateRelatedFormula(appId, table, enrichedRow);
+    }
+    return { row: enrichedRow, table };
+});

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

@@ -64,19 +64,17 @@ exports.validate = ({ appId, tableId, row, table }) => __awaiter(void 0, void 0,
         }
         let res;
         // Validate.js doesn't seem to handle array
-        if (type === FieldTypes.ARRAY) {
-            const hasValues = Array.isArray(row[fieldName]) && row[fieldName].length > 0;
-            // Check values are valid if values are specified
-            if (hasValues) {
+        if (type === FieldTypes.ARRAY && row[fieldName]) {
+            if (row[fieldName].length) {
                 row[fieldName].map(val => {
                     if (!constraints.inclusion.includes(val)) {
-                        errors[fieldName] = "Value not in list";
+                        errors[fieldName] = "Field not in list";
                     }
                 });
             }
-            // Check for required constraint
-            if (constraints.presence === true && !hasValues) {
-                errors[fieldName] = "Required field";
+            else if (constraints.presence && row[fieldName].length === 0) {
+                // non required MultiSelect creates an empty array, which should not throw errors
+                errors[fieldName] = [`${fieldName} is required`];
             }
         }
         else if (type === FieldTypes.JSON && typeof row[fieldName] === "string") {

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 };
+    });
+};