@budibase/server 0.9.171 → 0.9.173-alpha.2

package/dist/api/controllers/analytics.js

@@ -26,6 +26,10 @@ exports.endUserPing = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
         };
         return;
     }
+    posthogClient.identify({
+        distinctId: ctx.user && ctx.user._id,
+        properties: {},
+    });
     posthogClient.capture({
         event: "budibase:end_user_ping",
         distinctId: ctx.user && ctx.user._id,

package/dist/api/controllers/application.js

@@ -19,7 +19,7 @@ const { BASE_LAYOUTS } = require("../../constants/layouts");
 const { createHomeScreen } = require("../../constants/screens");
 const { cloneDeep } = require("lodash/fp");
 const { processObject } = require("@budibase/string-templates");
-const { getAllApps } = require("@budibase/auth/db");
+const { getAllApps, isDevAppID, getDeployedAppID, Replication, } = require("@budibase/auth/db");
 const { USERS_TABLE_SCHEMA } = require("../../constants");
 const { getDeployedApps, removeAppFromUserRoles, } = require("../../utilities/workerRequests");
 const { clientLibraryPath, stringToReadStream } = require("../../utilities");
@@ -111,183 +111,197 @@ function createInstance(template) {
         return { _id: appId };
     });
 }
-exports.fetch = function (ctx) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const dev = ctx.query && ctx.query.status === AppStatus.DEV;
-        const all = ctx.query && ctx.query.status === AppStatus.ALL;
-        const apps = yield getAllApps(CouchDB, { dev, all });
-        // get the locks for all the dev apps
-        if (dev || all) {
-            const locks = yield getAllLocks();
-            for (let app of apps) {
-                if (app.status !== "development") {
-                    continue;
-                }
-                const lock = locks.find(lock => lock.appId === app.appId);
-                if (lock) {
-                    app.lockedBy = lock.user;
-                }
-                else {
-                    // make sure its definitely not present
-                    delete app.lockedBy;
-                }
+exports.fetch = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+    const dev = ctx.query && ctx.query.status === AppStatus.DEV;
+    const all = ctx.query && ctx.query.status === AppStatus.ALL;
+    const apps = yield getAllApps(CouchDB, { dev, all });
+    // get the locks for all the dev apps
+    if (dev || all) {
+        const locks = yield getAllLocks();
+        for (let app of apps) {
+            if (app.status !== "development") {
+                continue;
+            }
+            const lock = locks.find(lock => lock.appId === app.appId);
+            if (lock) {
+                app.lockedBy = lock.user;
+            }
+            else {
+                // make sure its definitely not present
+                delete app.lockedBy;
             }
         }
-        ctx.body = apps;
-    });
-};
-exports.fetchAppDefinition = function (ctx) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const db = new CouchDB(ctx.params.appId);
-        const layouts = yield getLayouts(db);
+    }
+    ctx.body = apps;
+});
+exports.fetchAppDefinition = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+    const db = new CouchDB(ctx.params.appId);
+    const layouts = yield getLayouts(db);
+    const userRoleId = getUserRoleId(ctx);
+    const accessController = new AccessController(ctx.params.appId);
+    const screens = yield accessController.checkScreensAccess(yield getScreens(db), userRoleId);
+    ctx.body = {
+        layouts,
+        screens,
+        libraries: ["@budibase/standard-components"],
+    };
+});
+exports.fetchAppPackage = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+    const db = new CouchDB(ctx.params.appId);
+    const application = yield db.get(DocumentTypes.APP_METADATA);
+    const layouts = yield getLayouts(db);
+    let screens = yield getScreens(db);
+    // Only filter screens if the user is not a builder
+    if (!(ctx.user.builder && ctx.user.builder.global)) {
         const userRoleId = getUserRoleId(ctx);
         const accessController = new AccessController(ctx.params.appId);
-        const screens = yield accessController.checkScreensAccess(yield getScreens(db), userRoleId);
-        ctx.body = {
-            layouts,
-            screens,
-            libraries: ["@budibase/standard-components"],
-        };
+        screens = yield accessController.checkScreensAccess(screens, userRoleId);
+    }
+    ctx.body = {
+        application,
+        screens,
+        layouts,
+        clientLibPath: clientLibraryPath(ctx.params.appId),
+    };
+});
+exports.create = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+    const { useTemplate, templateKey, templateString } = ctx.request.body;
+    const instanceConfig = {
+        useTemplate,
+        key: templateKey,
+        templateString,
+    };
+    if (ctx.request.files && ctx.request.files.templateFile) {
+        instanceConfig.file = ctx.request.files.templateFile;
+    }
+    const instance = yield createInstance(instanceConfig);
+    const appId = instance._id;
+    const url = yield getAppUrlIfNotInUse(ctx);
+    const db = new CouchDB(appId);
+    let _rev;
+    try {
+        // if template there will be an existing doc
+        const existing = yield db.get(DocumentTypes.APP_METADATA);
+        _rev = existing._rev;
+    }
+    catch (err) {
+        // nothing to do
+    }
+    const newApplication = {
+        _id: DocumentTypes.APP_METADATA,
+        _rev,
+        appId: instance._id,
+        type: "app",
+        version: packageJson.version,
+        componentLibraries: ["@budibase/standard-components"],
+        name: ctx.request.body.name,
+        url: url,
+        template: ctx.request.body.template,
+        instance: instance,
+        tenantId: getTenantId(),
+        updatedAt: new Date().toISOString(),
+        createdAt: new Date().toISOString(),
+    };
+    const response = yield db.put(newApplication, { force: true });
+    newApplication._rev = response.rev;
+    // Only create the default home screens and layout if we aren't importing
+    // an app
+    if (useTemplate !== "true") {
+        yield createEmptyAppPackage(ctx, newApplication);
+    }
+    /* istanbul ignore next */
+    if (!env.isTest()) {
+        yield createApp(appId);
+    }
+    ctx.status = 200;
+    ctx.body = newApplication;
+});
+exports.update = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+    const data = yield updateAppPackage(ctx, ctx.request.body, ctx.params.appId);
+    ctx.status = 200;
+    ctx.body = data;
+});
+exports.updateClient = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+    // Get current app version
+    const db = new CouchDB(ctx.params.appId);
+    const application = yield db.get(DocumentTypes.APP_METADATA);
+    const currentVersion = application.version;
+    // Update client library and manifest
+    if (!env.isTest()) {
+        yield backupClientLibrary(ctx.params.appId);
+        yield updateClientLibrary(ctx.params.appId);
+    }
+    // Update versions in app package
+    const appPackageUpdates = {
+        version: packageJson.version,
+        revertableVersion: currentVersion,
+    };
+    const data = yield updateAppPackage(ctx, appPackageUpdates, ctx.params.appId);
+    ctx.status = 200;
+    ctx.body = data;
+});
+exports.revertClient = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+    // Check app can be reverted
+    const db = new CouchDB(ctx.params.appId);
+    const application = yield db.get(DocumentTypes.APP_METADATA);
+    if (!application.revertableVersion) {
+        ctx.throw(400, "There is no version to revert to");
+    }
+    // Update client library and manifest
+    if (!env.isTest()) {
+        yield revertClientLibrary(ctx.params.appId);
+    }
+    // Update versions in app package
+    const appPackageUpdates = {
+        version: application.revertableVersion,
+        revertableVersion: null,
+    };
+    const data = yield updateAppPackage(ctx, appPackageUpdates, ctx.params.appId);
+    ctx.status = 200;
+    ctx.body = data;
+});
+exports.delete = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+    const db = new CouchDB(ctx.params.appId);
+    const result = yield db.destroy();
+    /* istanbul ignore next */
+    if (!env.isTest() && !ctx.query.unpublish) {
+        yield deleteApp(ctx.params.appId);
+    }
+    // make sure the app/role doesn't stick around after the app has been deleted
+    yield removeAppFromUserRoles(ctx, ctx.params.appId);
+    ctx.status = 200;
+    ctx.body = result;
+});
+exports.sync = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+    const appId = ctx.params.appId;
+    if (!isDevAppID(appId)) {
+        ctx.throw(400, "This action cannot be performed for production apps");
+    }
+    const prodAppId = getDeployedAppID(appId);
+    const replication = new Replication({
+        source: prodAppId,
+        target: appId,
     });
-};
-exports.fetchAppPackage = function (ctx) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const db = new CouchDB(ctx.params.appId);
-        const application = yield db.get(DocumentTypes.APP_METADATA);
-        const layouts = yield getLayouts(db);
-        let screens = yield getScreens(db);
-        // Only filter screens if the user is not a builder
-        if (!(ctx.user.builder && ctx.user.builder.global)) {
-            const userRoleId = getUserRoleId(ctx);
-            const accessController = new AccessController(ctx.params.appId);
-            screens = yield accessController.checkScreensAccess(screens, userRoleId);
-        }
+    let error;
+    try {
+        yield replication.replicate({
+            filter: function (doc) {
+                return doc._id !== DocumentTypes.APP_METADATA;
+            },
+        });
+    }
+    catch (err) {
+        error = err;
+    }
+    if (error) {
+        ctx.throw(400, error);
+    }
+    else {
         ctx.body = {
-            application,
-            screens,
-            layouts,
-            clientLibPath: clientLibraryPath(ctx.params.appId),
-        };
-    });
-};
-exports.create = function (ctx) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const { useTemplate, templateKey, templateString } = ctx.request.body;
-        const instanceConfig = {
-            useTemplate,
-            key: templateKey,
-            templateString,
-        };
-        if (ctx.request.files && ctx.request.files.templateFile) {
-            instanceConfig.file = ctx.request.files.templateFile;
-        }
-        const instance = yield createInstance(instanceConfig);
-        const appId = instance._id;
-        const url = yield getAppUrlIfNotInUse(ctx);
-        const db = new CouchDB(appId);
-        let _rev;
-        try {
-            // if template there will be an existing doc
-            const existing = yield db.get(DocumentTypes.APP_METADATA);
-            _rev = existing._rev;
-        }
-        catch (err) {
-            // nothing to do
-        }
-        const newApplication = {
-            _id: DocumentTypes.APP_METADATA,
-            _rev,
-            appId: instance._id,
-            type: "app",
-            version: packageJson.version,
-            componentLibraries: ["@budibase/standard-components"],
-            name: ctx.request.body.name,
-            url: url,
-            template: ctx.request.body.template,
-            instance: instance,
-            tenantId: getTenantId(),
-            updatedAt: new Date().toISOString(),
-            createdAt: new Date().toISOString(),
-        };
-        const response = yield db.put(newApplication, { force: true });
-        newApplication._rev = response.rev;
-        // Only create the default home screens and layout if we aren't importing
-        // an app
-        if (useTemplate !== "true") {
-            yield createEmptyAppPackage(ctx, newApplication);
-        }
-        /* istanbul ignore next */
-        if (!env.isTest()) {
-            yield createApp(appId);
-        }
-        ctx.status = 200;
-        ctx.body = newApplication;
-    });
-};
-exports.update = function (ctx) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const data = yield updateAppPackage(ctx, ctx.request.body, ctx.params.appId);
-        ctx.status = 200;
-        ctx.body = data;
-    });
-};
-exports.updateClient = function (ctx) {
-    return __awaiter(this, void 0, void 0, function* () {
-        // Get current app version
-        const db = new CouchDB(ctx.params.appId);
-        const application = yield db.get(DocumentTypes.APP_METADATA);
-        const currentVersion = application.version;
-        // Update client library and manifest
-        if (!env.isTest()) {
-            yield backupClientLibrary(ctx.params.appId);
-            yield updateClientLibrary(ctx.params.appId);
-        }
-        // Update versions in app package
-        const appPackageUpdates = {
-            version: packageJson.version,
-            revertableVersion: currentVersion,
-        };
-        const data = yield updateAppPackage(ctx, appPackageUpdates, ctx.params.appId);
-        ctx.status = 200;
-        ctx.body = data;
-    });
-};
-exports.revertClient = function (ctx) {
-    return __awaiter(this, void 0, void 0, function* () {
-        // Check app can be reverted
-        const db = new CouchDB(ctx.params.appId);
-        const application = yield db.get(DocumentTypes.APP_METADATA);
-        if (!application.revertableVersion) {
-            ctx.throw(400, "There is no version to revert to");
-        }
-        // Update client library and manifest
-        if (!env.isTest()) {
-            yield revertClientLibrary(ctx.params.appId);
-        }
-        // Update versions in app package
-        const appPackageUpdates = {
-            version: application.revertableVersion,
-            revertableVersion: null,
+            message: "App sync completed successfully.",
         };
-        const data = yield updateAppPackage(ctx, appPackageUpdates, ctx.params.appId);
-        ctx.status = 200;
-        ctx.body = data;
-    });
-};
-exports.delete = function (ctx) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const db = new CouchDB(ctx.params.appId);
-        const result = yield db.destroy();
-        /* istanbul ignore next */
-        if (!env.isTest() && !ctx.query.unpublish) {
-            yield deleteApp(ctx.params.appId);
-        }
-        // make sure the app/role doesn't stick around after the app has been deleted
-        yield removeAppFromUserRoles(ctx, ctx.params.appId);
-        ctx.status = 200;
-        ctx.body = result;
-    });
-};
+    }
+});
 const updateAppPackage = (ctx, appPackage, appId) => __awaiter(void 0, void 0, void 0, function* () {
     const url = yield getAppUrlIfNotInUse(ctx);
     const db = new CouchDB(appId);

package/dist/api/controllers/auth.js

@@ -33,14 +33,24 @@ exports.fetchSelf = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
             ctx.body = yield outputProcessing(ctx, userTable, Object.assign(Object.assign({}, user), metadata));
         }
         catch (err) {
+            let response;
             // user didn't exist in app, don't pretend they do
             if (user.roleId === BUILTIN_ROLE_IDS.PUBLIC) {
-                ctx.body = {};
+                response = {};
             }
             // user has a role of some sort, return them
+            else if (err.status === 404) {
+                const metadata = {
+                    _id: userId,
+                };
+                const dbResp = yield db.put(metadata);
+                user._rev = dbResp.rev;
+                response = user;
+            }
             else {
-                ctx.body = user;
+                response = user;
             }
+            ctx.body = response;
         }
     }
     else {

package/dist/api/controllers/backup.js

@@ -8,13 +8,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-const { performBackup } = require("../../utilities/fileSystem");
+const { streamBackup } = require("../../utilities/fileSystem");
 exports.exportAppDump = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
         const { appId } = ctx.query;
-        const appname = decodeURI(ctx.query.appname);
-        const backupIdentifier = `${appname}Backup${new Date().getTime()}.txt`;
+        const appName = decodeURI(ctx.query.appname);
+        const backupIdentifier = `${appName}-export-${new Date().getTime()}.txt`;
         ctx.attachment(backupIdentifier);
-        ctx.body = yield performBackup(appId, backupIdentifier);
+        ctx.body = yield streamBackup(appId);
     });
 };

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

@@ -10,7 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 const CouchDB = require("../../../db");
 const Deployment = require("./Deployment");
-const { Replication } = require("@budibase/auth/db");
+const { Replication, getDeployedAppID } = require("@budibase/auth/db");
 const { DocumentTypes, getAutomationParams } = require("../../../db/utils");
 const { disableAllCrons, enableCronTrigger, } = require("../../../automations/utils");
 // the max time we can wait for an invalidation to complete before considering it failed
@@ -82,7 +82,7 @@ function initDeployedApp(prodAppId) {
 function deployApp(deployment) {
     return __awaiter(this, void 0, void 0, function* () {
         try {
-            const productionAppId = deployment.appId.replace("_dev", "");
+            const productionAppId = getDeployedAppID(deployment.appId);
             const replication = new Replication({
                 source: deployment.appId,
                 target: productionAppId,
@@ -96,21 +96,8 @@ function deployApp(deployment) {
             appDoc.instance._id = productionAppId;
             yield db.put(appDoc);
             console.log("New app doc written successfully.");
-            console.log("Setting up live repl between dev and prod");
-            // Set up live sync between the live and dev instances
-            const liveReplication = new Replication({
-                source: productionAppId,
-                target: deployment.appId,
-            });
-            liveReplication.subscribe({
-                filter: function (doc) {
-                    return doc._id !== DocumentTypes.APP_METADATA;
-                },
-            });
-            console.log("Set up live repl between dev and prod");
-            console.log("Initialising deployed app");
             yield initDeployedApp(productionAppId);
-            console.log("Init complete, setting deployment to successful");
+            console.log("Deployed app initialised, setting deployment to successful");
             deployment.setStatus(DeploymentStatus.SUCCESS);
             yield storeDeploymentHistory(deployment);
         }

package/dist/api/controllers/dev.js

@@ -16,11 +16,11 @@ const { request } = require("../../utilities/workerRequests");
 const { clearLock } = require("../../utilities/redis");
 const { Replication } = require("@budibase/auth").db;
 const { DocumentTypes } = require("../../db/utils");
-function redirect(ctx, method) {
+function redirect(ctx, method, path = "global") {
     return __awaiter(this, void 0, void 0, function* () {
         const { devPath } = ctx.params;
         const queryString = ctx.originalUrl.split("?")[1] || "";
-        const response = yield fetch(checkSlashesInUrl(`${env.WORKER_URL}/api/global/${devPath}?${queryString}`), request(ctx, {
+        const response = yield fetch(checkSlashesInUrl(`${env.WORKER_URL}/api/${path}/${devPath}?${queryString}`), request(ctx, {
             method,
             body: ctx.request.body,
         }, true));
@@ -45,15 +45,21 @@ function redirect(ctx, method) {
         ctx.cookies;
     });
 }
-exports.redirectGet = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
-    yield redirect(ctx, "GET");
-});
-exports.redirectPost = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
-    yield redirect(ctx, "POST");
-});
-exports.redirectDelete = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
-    yield redirect(ctx, "DELETE");
-});
+exports.buildRedirectGet = path => {
+    return (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        yield redirect(ctx, "GET", path);
+    });
+};
+exports.buildRedirectPost = path => {
+    return (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        yield redirect(ctx, "POST", path);
+    });
+};
+exports.buildRedirectDelete = path => {
+    return (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        yield redirect(ctx, "DELETE", path);
+    });
+};
 exports.clearLock = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
     const { appId } = ctx.params;
     try {

package/dist/api/controllers/permission.js

@@ -132,6 +132,7 @@ exports.getResourcePerms = function (ctx) {
             for (let role of roles) {
                 const rolePerms = role.permissions;
                 if (rolePerms &&
+                    rolePerms[resourceId] &&
                     (rolePerms[resourceId] === level ||
                         rolePerms[resourceId].indexOf(level) !== -1)) {
                     permissions[level] = getExternalRoleID(role._id);

package/dist/api/controllers/query.js

@@ -14,6 +14,7 @@ const { generateQueryID, getQueryParams } = require("../../db/utils");
 const { integrations } = require("../../integrations");
 const { BaseQueryVerbs } = require("../../constants");
 const env = require("../../environment");
+const ScriptRunner = require("../../utilities/scriptRunner");
 // simple function to append "readable" to all read queries
 function enrichQueries(input) {
     const wasArray = Array.isArray(input);
@@ -35,11 +36,29 @@ function formatResponse(resp) {
             resp = { response: resp };
         }
     }
-    if (!Array.isArray(resp)) {
-        resp = [resp];
-    }
     return resp;
 }
+function runAndTransform(integration, queryVerb, enrichedQuery, transformer) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let rows = formatResponse(yield integration[queryVerb](enrichedQuery));
+        // transform as required
+        if (transformer) {
+            const runner = new ScriptRunner(transformer, { data: rows });
+            rows = runner.execute();
+        }
+        // needs to an array for next step
+        if (!Array.isArray(rows)) {
+            rows = [rows];
+        }
+        // map into JSON if just raw primitive here
+        if (rows.find(row => typeof row !== "object")) {
+            rows = rows.map(value => ({ value }));
+        }
+        // get all the potential fields in the schema
+        let keys = rows.flatMap(Object.keys);
+        return { rows, keys };
+    });
+}
 exports.fetch = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
         const db = new CouchDB(ctx.appId);
@@ -119,12 +138,10 @@ exports.preview = function (ctx) {
         if (!Integration) {
             ctx.throw(400, "Integration type does not exist.");
         }
-        const { fields, parameters, queryVerb } = ctx.request.body;
+        const { fields, parameters, queryVerb, transformer } = ctx.request.body;
         const enrichedQuery = yield enrichQueryFields(fields, parameters);
         const integration = new Integration(datasource.config);
-        const rows = formatResponse(yield integration[queryVerb](enrichedQuery));
-        // get all the potential fields in the schema
-        const keys = rows.flatMap(Object.keys);
+        const { rows, keys } = yield runAndTransform(integration, queryVerb, enrichedQuery, transformer);
         ctx.body = {
             rows,
             schemaFields: [...new Set(keys)],
@@ -147,7 +164,8 @@ exports.execute = function (ctx) {
         const enrichedQuery = yield enrichQueryFields(query.fields, ctx.request.body.parameters);
         const integration = new Integration(datasource.config);
         // call the relevant CRUD method on the integration class
-        ctx.body = formatResponse(yield integration[query.queryVerb](enrichedQuery));
+        const { rows } = yield runAndTransform(integration, query.queryVerb, enrichedQuery, query.transformer);
+        ctx.body = rows;
         // cleanup
         if (integration.end) {
             integration.end();