@budibase/server 0.0.32 → 0.0.999-alpha.30

package/dist/package.json

@@ -0,0 +1,180 @@
+{
+    "name": "@budibase/server",
+    "email": "hi@budibase.com",
+    "version": "0.0.999-alpha.30",
+    "description": "Budibase Web Server",
+    "main": "src/index.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/Budibase/budibase.git"
+    },
+    "scripts": {
+        "prebuild": "rimraf dist/",
+        "build": "tsc -p tsconfig.build.json && mv dist/src/* dist/ && rimraf dist/src/",
+        "build:dev": "yarn prebuild && tsc --build --watch --preserveWatchOutput",
+        "debug": "yarn build && node --expose-gc --inspect=9222 dist/index.js",
+        "postbuild": "copyfiles -u 1 src/**/*.svelte dist/ && copyfiles -u 1 src/**/*.hbs dist/ && copyfiles -u 1 src/**/*.json dist/",
+        "test": "bash scripts/test.sh",
+        "test:memory": "jest --maxWorkers=2 --logHeapUsage --forceExit",
+        "test:watch": "jest --watch",
+        "predocker": "copyfiles -f ../client/dist/budibase-client.js ../client/manifest.json client",
+        "build:docker": "yarn run predocker && docker build . -t app-service --label version=$BUDIBASE_RELEASE_VERSION",
+        "build:docs": "node ./scripts/docs/generate.js open",
+        "run:docker": "node dist/index.js",
+        "run:docker:cluster": "pm2-runtime start pm2.config.js",
+        "dev:stack:up": "node scripts/dev/manage.js up",
+        "dev:stack:down": "node scripts/dev/manage.js down",
+        "dev:stack:nuke": "node scripts/dev/manage.js nuke",
+        "dev:builder": "yarn run dev:stack:up && nodemon",
+        "dev:built": "yarn run dev:stack:up && yarn run run:docker",
+        "specs": "ts-node specs/generate.ts && openapi-typescript specs/openapi.yaml --output src/definitions/openapi.ts",
+        "initialise": "node scripts/initialise.js",
+        "env:multi:enable": "node scripts/multiTenancy.js enable",
+        "env:multi:disable": "node scripts/multiTenancy.js disable",
+        "env:selfhost:enable": "node scripts/selfhost.js enable",
+        "env:selfhost:disable": "node scripts/selfhost.js disable",
+        "env:localdomain:enable": "node scripts/localdomain.js enable",
+        "env:localdomain:disable": "node scripts/localdomain.js disable",
+        "env:account:enable": "node scripts/account.js enable",
+        "env:account:disable": "node scripts/account.js disable"
+    },
+    "keywords": [
+        "budibase"
+    ],
+    "author": "Budibase",
+    "license": "GPL-3.0",
+    "dependencies": {
+        "@apidevtools/swagger-parser": "10.0.3",
+        "@budibase/backend-core": "0.0.999-alpha.30",
+        "@budibase/client": "0.0.999-alpha.30",
+        "@budibase/pro": "0.0.999-alpha.30",
+        "@budibase/shared-core": "0.0.999-alpha.30",
+        "@budibase/string-templates": "0.0.999-alpha.30",
+        "@budibase/types": "0.0.999-alpha.30",
+        "@bull-board/api": "3.7.0",
+        "@bull-board/koa": "3.9.4",
+        "@elastic/elasticsearch": "7.10.0",
+        "@google-cloud/firestore": "5.0.2",
+        "@koa/router": "8.0.8",
+        "@sendgrid/mail": "7.1.1",
+        "@sentry/node": "6.17.7",
+        "airtable": "0.10.1",
+        "arangojs": "7.2.0",
+        "aws-sdk": "2.1030.0",
+        "bcryptjs": "2.4.3",
+        "bull": "4.10.1",
+        "chmodr": "1.2.0",
+        "chokidar": "3.5.3",
+        "cookies": "0.8.0",
+        "csvtojson": "2.0.10",
+        "curlconverter": "3.21.0",
+        "dd-trace": "3.13.2",
+        "dotenv": "8.2.0",
+        "download": "8.0.0",
+        "elastic-apm-node": "3.38.0",
+        "fix-path": "3.0.0",
+        "form-data": "4.0.0",
+        "fs-extra": "8.1.0",
+        "global-agent": "3.0.0",
+        "google-auth-library": "7.12.0",
+        "google-spreadsheet": "3.2.0",
+        "jimp": "0.16.1",
+        "joi": "17.6.0",
+        "js-yaml": "4.1.0",
+        "jsonschema": "1.4.0",
+        "knex": "2.4.0",
+        "koa": "2.13.4",
+        "koa-body": "4.2.0",
+        "koa-compress": "4.0.1",
+        "koa-connect": "2.1.0",
+        "koa-send": "5.0.0",
+        "koa-session": "5.12.0",
+        "koa-static": "5.0.0",
+        "koa-useragent": "^4.1.0",
+        "koa2-ratelimit": "1.1.1",
+        "lodash": "4.17.21",
+        "memorystream": "0.3.1",
+        "mongodb": "4.9",
+        "mssql": "6.2.3",
+        "mysql2": "2.3.3",
+        "node-fetch": "2.6.7",
+        "open": "8.4.0",
+        "pg": "8.5.1",
+        "posthog-node": "1.3.0",
+        "pouchdb": "7.3.0",
+        "pouchdb-adapter-memory": "7.2.2",
+        "pouchdb-all-dbs": "1.0.2",
+        "pouchdb-find": "7.2.2",
+        "pouchdb-replication-stream": "1.2.9",
+        "redis": "4",
+        "server-destroy": "1.0.1",
+        "snowflake-promise": "^4.5.0",
+        "socket.io": "4.6.1",
+        "svelte": "3.49.0",
+        "swagger-parser": "10.0.3",
+        "tar": "6.1.11",
+        "to-json-schema": "0.2.5",
+        "uuid": "3.3.2",
+        "validate.js": "0.13.1",
+        "vm2": "3.9.16",
+        "worker-farm": "1.7.0",
+        "xml2js": "0.5.0",
+        "yargs": "13.2.4"
+    },
+    "devDependencies": {
+        "@babel/core": "7.17.4",
+        "@babel/preset-env": "7.16.11",
+        "@budibase/standard-components": "^0.9.139",
+        "@jest/test-sequencer": "29.5.0",
+        "@swc/core": "^1.3.25",
+        "@swc/jest": "^0.2.24",
+        "@trendyol/jest-testcontainers": "^2.1.1",
+        "@types/apidoc": "0.50.0",
+        "@types/bson": "4.2.0",
+        "@types/global-agent": "2.1.1",
+        "@types/google-spreadsheet": "3.1.5",
+        "@types/ioredis": "4.28.10",
+        "@types/jest": "29.5.0",
+        "@types/koa": "2.13.4",
+        "@types/koa__router": "8.0.8",
+        "@types/lodash": "4.14.180",
+        "@types/node": "14.18.20",
+        "@types/node-fetch": "2.6.1",
+        "@types/oracledb": "5.2.2",
+        "@types/pouchdb": "6.4.0",
+        "@types/redis": "4.0.11",
+        "@types/server-destroy": "1.0.1",
+        "@types/supertest": "2.0.12",
+        "@types/tar": "6.1.3",
+        "@typescript-eslint/parser": "5.45.0",
+        "apidoc": "0.50.4",
+        "babel-jest": "29.5.0",
+        "copyfiles": "2.4.1",
+        "docker-compose": "0.23.17",
+        "eslint": "6.8.0",
+        "ioredis-mock": "7.2.0",
+        "is-wsl": "2.2.0",
+        "jest": "29.5.0",
+        "jest-openapi": "0.14.2",
+        "jest-runner": "29.5.0",
+        "jest-serial-runner": "^1.2.1",
+        "nodemon": "2.0.15",
+        "openapi-types": "9.3.1",
+        "openapi-typescript": "5.2.0",
+        "path-to-regexp": "6.2.0",
+        "prettier": "2.5.1",
+        "rimraf": "3.0.2",
+        "supertest": "6.2.2",
+        "swagger-jsdoc": "6.1.0",
+        "timekeeper": "2.2.0",
+        "ts-jest": "29.0.5",
+        "ts-node": "10.8.1",
+        "tsconfig-paths": "4.0.0",
+        "typescript": "4.7.3",
+        "update-dotenv": "1.1.1"
+    },
+    "optionalDependencies": {
+        "oracledb": "5.3.0"
+    },
+    "gitHead": "d1836a898cab3f8ab80ee6d8f42be1a9eed7dcdc"
+}

package/dist/sdk/app/applications/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const sync = __importStar(require("./sync"));
+const utils = __importStar(require("./utils"));
+exports.default = Object.assign(Object.assign({}, sync), utils);

package/dist/sdk/app/applications/sync.js

@@ -0,0 +1,164 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncApp = exports.syncUsersToAllApps = void 0;
+const environment_1 = __importDefault(require("../../../environment"));
+const backend_core_1 = require("@budibase/backend-core");
+const pro_1 = require("@budibase/pro");
+const __1 = __importDefault(require("../../"));
+const global_1 = require("../../../utilities/global");
+const utils_1 = require("../../../db/utils");
+function syncUsersToApp(appId, users, groups) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!(yield backend_core_1.db.dbExists(appId))) {
+            return;
+        }
+        yield backend_core_1.context.doInAppContext(appId, () => __awaiter(this, void 0, void 0, function* () {
+            const db = backend_core_1.context.getAppDB();
+            for (let user of users) {
+                let ctxUser = user;
+                let deletedUser = false;
+                const metadataId = (0, utils_1.generateUserMetadataID)(user._id);
+                if (user.deleted) {
+                    deletedUser = true;
+                }
+                // make sure role is correct
+                if (!deletedUser) {
+                    ctxUser = yield (0, global_1.processUser)(ctxUser, { appId, groups });
+                }
+                let roleId = ctxUser.roleId;
+                if (roleId === backend_core_1.roles.BUILTIN_ROLE_IDS.PUBLIC) {
+                    roleId = undefined;
+                }
+                let metadata;
+                try {
+                    metadata = yield db.get(metadataId);
+                }
+                catch (err) {
+                    if (err.status !== 404) {
+                        throw err;
+                    }
+                    // no metadata and user is to be deleted, can skip
+                    // no role - user isn't in app anyway
+                    if (!roleId) {
+                        continue;
+                    }
+                    else if (!deletedUser) {
+                        // doesn't exist yet, creating it
+                        metadata = {
+                            tableId: utils_1.InternalTables.USER_METADATA,
+                        };
+                    }
+                }
+                // the user doesn't exist, or doesn't have a role anymore
+                // get rid of their metadata
+                if (deletedUser || !roleId) {
+                    yield db.remove(metadata);
+                    continue;
+                }
+                // assign the roleId for the metadata doc
+                if (roleId) {
+                    metadata.roleId = roleId;
+                }
+                let combined = __1.default.users.combineMetadataAndUser(ctxUser, metadata);
+                // if no combined returned, there are no updates to make
+                if (combined) {
+                    yield db.put(combined);
+                }
+            }
+        }));
+    });
+}
+function syncUsersToAllApps(userIds) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // list of users, if one has been deleted it will be undefined in array
+        const users = (yield (0, global_1.getGlobalUsers)(userIds, {
+            noProcessing: true,
+        }));
+        const groups = yield pro_1.sdk.groups.fetch();
+        const finalUsers = [];
+        for (let userId of userIds) {
+            const user = users.find(user => user._id === userId);
+            if (!user) {
+                finalUsers.push({ _id: userId, deleted: true });
+            }
+            else {
+                finalUsers.push(user);
+            }
+        }
+        const devAppIds = yield backend_core_1.db.getDevAppIDs();
+        let promises = [];
+        for (let devAppId of devAppIds) {
+            const prodAppId = backend_core_1.db.getProdAppID(devAppId);
+            for (let appId of [prodAppId, devAppId]) {
+                promises.push(syncUsersToApp(appId, finalUsers, groups));
+            }
+        }
+        const resp = yield Promise.allSettled(promises);
+        const failed = resp.filter(promise => promise.status === "rejected");
+        if (failed.length > 0) {
+            const reasons = failed.map(fail => fail.reason);
+            backend_core_1.logging.logAlert("Failed to sync users to apps", reasons);
+        }
+    });
+}
+exports.syncUsersToAllApps = syncUsersToAllApps;
+function syncApp(appId, opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (environment_1.default.DISABLE_AUTO_PROD_APP_SYNC) {
+            return {
+                message: "App sync disabled. You can reenable with the DISABLE_AUTO_PROD_APP_SYNC environment variable.",
+            };
+        }
+        if (backend_core_1.db.isProdAppID(appId)) {
+            throw new Error("This action cannot be performed for production apps");
+        }
+        // replicate prod to dev
+        const prodAppId = backend_core_1.db.getProdAppID(appId);
+        // specific case, want to make sure setup is skipped
+        const prodDb = backend_core_1.context.getProdAppDB({ skip_setup: true });
+        const exists = yield prodDb.exists();
+        let error;
+        if (exists) {
+            const replication = new backend_core_1.db.Replication({
+                source: prodAppId,
+                target: appId,
+            });
+            try {
+                const replOpts = replication.appReplicateOpts();
+                if (opts === null || opts === void 0 ? void 0 : opts.automationOnly) {
+                    replOpts.filter = (doc) => doc._id.startsWith(backend_core_1.db.DocumentType.AUTOMATION);
+                }
+                yield replication.replicate(replOpts);
+            }
+            catch (err) {
+                error = err;
+            }
+            finally {
+                yield replication.close();
+            }
+        }
+        // sync the users - kept for safe keeping
+        yield __1.default.users.syncGlobalUsers();
+        if (error) {
+            throw error;
+        }
+        else {
+            return {
+                message: "App sync completed successfully.",
+            };
+        }
+    });
+}
+exports.syncApp = syncApp;

package/dist/sdk/app/applications/utils.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAppUrl = void 0;
+const URL_REGEX_SLASH = /\/|\\/g;
+function getAppUrl(opts) {
+    // construct the url
+    let url;
+    if (opts === null || opts === void 0 ? void 0 : opts.url) {
+        // if the url is provided, use that
+        url = encodeURI(opts === null || opts === void 0 ? void 0 : opts.url);
+    }
+    else if (opts === null || opts === void 0 ? void 0 : opts.name) {
+        // otherwise use the name
+        url = encodeURI(`${opts === null || opts === void 0 ? void 0 : opts.name}`);
+    }
+    if (url) {
+        url = `/${url.replace(URL_REGEX_SLASH, "")}`.toLowerCase();
+    }
+    return url;
+}
+exports.getAppUrl = getAppUrl;

package/dist/sdk/app/automations/index.js

@@ -0,0 +1,29 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const webhook = __importStar(require("./webhook"));
+exports.default = {
+    webhook,
+};

package/dist/sdk/app/automations/webhook.js

@@ -0,0 +1,54 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.destroy = exports.save = exports.newDoc = void 0;
+const backend_core_1 = require("@budibase/backend-core");
+const utils_1 = require("../../../db/utils");
+function isWebhookID(id) {
+    return id.startsWith(backend_core_1.db.DocumentType.WEBHOOK);
+}
+function newDoc(name, type, target) {
+    return {
+        live: true,
+        name,
+        action: {
+            type,
+            target,
+        },
+    };
+}
+exports.newDoc = newDoc;
+function save(webhook) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const db = backend_core_1.context.getAppDB();
+        // check that the webhook exists
+        if (webhook._id && isWebhookID(webhook._id)) {
+            yield db.get(webhook._id);
+        }
+        else {
+            webhook._id = (0, utils_1.generateWebhookID)();
+        }
+        const response = yield db.put(webhook);
+        webhook._rev = response.rev;
+        return webhook;
+    });
+}
+exports.save = save;
+function destroy(id, rev) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const db = backend_core_1.context.getAppDB();
+        if (!id || !isWebhookID(id)) {
+            throw new Error("Provided webhook ID is not valid.");
+        }
+        return yield db.remove(id, rev);
+    });
+}
+exports.destroy = destroy;

package/dist/sdk/app/backups/constants.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STATIC_APP_FILES = exports.GLOBAL_DB_EXPORT_FILE = exports.DB_EXPORT_FILE = void 0;
+exports.DB_EXPORT_FILE = "db.txt";
+exports.GLOBAL_DB_EXPORT_FILE = "global.txt";
+exports.STATIC_APP_FILES = ["manifest.json", "budibase-client.js"];

package/dist/sdk/app/backups/exports.js

@@ -0,0 +1,184 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.streamExportApp = exports.exportMultipleApps = exports.exportApp = exports.exportDB = void 0;
+const backend_core_1 = require("@budibase/backend-core");
+const budibaseDir_1 = require("../../../utilities/budibaseDir");
+const fileSystem_1 = require("../../../utilities/fileSystem");
+const constants_1 = require("../../../constants");
+const utils_1 = require("../../../db/utils");
+const constants_2 = require("./constants");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = require("path");
+const environment_1 = __importDefault(require("../../../environment"));
+const uuid = require("uuid/v4");
+const tar = require("tar");
+const MemoryStream = require("memorystream");
+function tarFilesToTmp(tmpDir, files) {
+    const exportFile = (0, path_1.join)((0, budibaseDir_1.budibaseTempDir)(), `${uuid()}.tar.gz`);
+    tar.create({
+        sync: true,
+        gzip: true,
+        file: exportFile,
+        recursive: true,
+        cwd: tmpDir,
+    }, files);
+    return exportFile;
+}
+/**
+ * Exports a DB to either file or a variable (memory).
+ * @param {string} dbName the DB which is to be exported.
+ * @param {object} opts various options for the export, e.g. whether to stream,
+ * a filter function or the name of the export.
+ * @return {*} either a readable stream or a string
+ */
+function exportDB(dbName, opts = {}) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const exportOpts = {
+            filter: opts === null || opts === void 0 ? void 0 : opts.filter,
+            batch_size: 1000,
+            batch_limit: 5,
+            style: "main_only",
+        };
+        return backend_core_1.db.doWithDB(dbName, (db) => __awaiter(this, void 0, void 0, function* () {
+            // Write the dump to file if required
+            if (opts === null || opts === void 0 ? void 0 : opts.exportPath) {
+                const path = opts === null || opts === void 0 ? void 0 : opts.exportPath;
+                const writeStream = fs_1.default.createWriteStream(path);
+                yield db.dump(writeStream, exportOpts);
+                return path;
+            }
+            else {
+                // Stringify the dump in memory if required
+                const memStream = new MemoryStream();
+                let appString = "";
+                memStream.on("data", (chunk) => {
+                    appString += chunk.toString();
+                });
+                yield db.dump(memStream, exportOpts);
+                return appString;
+            }
+        }));
+    });
+}
+exports.exportDB = exportDB;
+function defineFilter(excludeRows) {
+    const ids = [utils_1.USER_METDATA_PREFIX, utils_1.LINK_USER_METADATA_PREFIX];
+    if (excludeRows) {
+        ids.push(utils_1.TABLE_ROW_PREFIX);
+    }
+    return (doc) => !ids.map(key => doc._id.includes(key)).reduce((prev, curr) => prev || curr);
+}
+/**
+ * Local utility to back up the database state for an app, excluding global user
+ * data or user relationships.
+ * @param {string} appId The app to back up
+ * @param {object} config Config to send to export DB/attachment export
+ * @returns {*} either a string or a stream of the backup
+ */
+function exportApp(appId, config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const prodAppId = backend_core_1.db.getProdAppID(appId);
+        const appPath = `${prodAppId}/`;
+        // export bucket contents
+        let tmpPath = (0, fileSystem_1.createTempFolder)(uuid());
+        if (!environment_1.default.isTest()) {
+            // write just the static files
+            if (config === null || config === void 0 ? void 0 : config.excludeRows) {
+                for (let path of constants_2.STATIC_APP_FILES) {
+                    const contents = yield backend_core_1.objectStore.retrieve(constants_1.ObjectStoreBuckets.APPS, (0, path_1.join)(appPath, path));
+                    fs_1.default.writeFileSync((0, path_1.join)(tmpPath, path), contents);
+                }
+            }
+            // get all of the files
+            else {
+                tmpPath = yield backend_core_1.objectStore.retrieveDirectory(constants_1.ObjectStoreBuckets.APPS, appPath);
+            }
+        }
+        const downloadedPath = (0, path_1.join)(tmpPath, appPath);
+        if (fs_1.default.existsSync(downloadedPath)) {
+            const allFiles = fs_1.default.readdirSync(downloadedPath);
+            for (let file of allFiles) {
+                const path = (0, path_1.join)(downloadedPath, file);
+                // move out of app directory, simplify structure
+                fs_1.default.renameSync(path, (0, path_1.join)(downloadedPath, "..", file));
+            }
+            // remove the old app directory created by object export
+            fs_1.default.rmdirSync(downloadedPath);
+        }
+        // enforce an export of app DB to the tmp path
+        const dbPath = (0, path_1.join)(tmpPath, constants_2.DB_EXPORT_FILE);
+        yield exportDB(appId, Object.assign(Object.assign({}, config), { filter: defineFilter(config === null || config === void 0 ? void 0 : config.excludeRows), exportPath: dbPath }));
+        // if tar requested, return where the tarball is
+        if (config === null || config === void 0 ? void 0 : config.tar) {
+            // now the tmpPath contains both the DB export and attachments, tar this
+            const tarPath = tarFilesToTmp(tmpPath, fs_1.default.readdirSync(tmpPath));
+            // cleanup the tmp export files as tarball returned
+            fs_1.default.rmSync(tmpPath, { recursive: true, force: true });
+            return tarPath;
+        }
+        // tar not requested, turn the directory where export is
+        else {
+            return tmpPath;
+        }
+    });
+}
+exports.exportApp = exportApp;
+/**
+ * Export all apps + global DB (if supplied) to a single tarball, this includes
+ * the attachments for each app as well.
+ * @param {object[]} appMetadata The IDs and names of apps to export.
+ * @param {string} globalDbContents The contents of the global DB to export as well.
+ * @return {string} The path to the tarball.
+ */
+function exportMultipleApps(appMetadata, globalDbContents) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const tmpPath = (0, path_1.join)((0, budibaseDir_1.budibaseTempDir)(), uuid());
+        fs_1.default.mkdirSync(tmpPath);
+        let exportPromises = [];
+        // export each app to a directory, then move it into the complete export
+        const exportAndMove = (appId, appName) => __awaiter(this, void 0, void 0, function* () {
+            const path = yield exportApp(appId);
+            yield fs_1.default.promises.rename(path, (0, path_1.join)(tmpPath, appName));
+        });
+        for (let metadata of appMetadata) {
+            exportPromises.push(exportAndMove(metadata.appId, metadata.name));
+        }
+        // wait for all exports to finish
+        yield Promise.all(exportPromises);
+        // add the global DB contents
+        if (globalDbContents) {
+            fs_1.default.writeFileSync((0, path_1.join)(tmpPath, constants_2.GLOBAL_DB_EXPORT_FILE), globalDbContents);
+        }
+        const appNames = appMetadata.map(metadata => metadata.name);
+        const tarPath = tarFilesToTmp(tmpPath, [...appNames, constants_2.GLOBAL_DB_EXPORT_FILE]);
+        // clear up the tmp path now tarball generated
+        fs_1.default.rmSync(tmpPath, { recursive: true, force: true });
+        return tarPath;
+    });
+}
+exports.exportMultipleApps = exportMultipleApps;
+/**
+ * Streams a backup of the database state for an app
+ * @param {string} appId The ID of the app which is to be backed up.
+ * @param {boolean} excludeRows Flag to state whether the export should include data.
+ * @returns {*} a readable stream of the backup which is written in real time
+ */
+function streamExportApp(appId, excludeRows) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const tmpPath = yield exportApp(appId, { excludeRows, tar: true });
+        return (0, fileSystem_1.streamFile)(tmpPath);
+    });
+}
+exports.streamExportApp = streamExportApp;