@budibase/server 2.0.33 → 2.0.34-alpha.0

package/dist/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@budibase/server",
     "email": "hi@budibase.com",
-    "version": "2.0.32",
+    "version": "2.0.33",
     "description": "Budibase Web Server",
     "main": "src/index.ts",
     "repository": {
@@ -77,23 +77,23 @@
     "license": "GPL-3.0",
     "dependencies": {
         "@apidevtools/swagger-parser": "10.0.3",
-        "@budibase/backend-core": "^2.0.32",
-        "@budibase/client": "^2.0.32",
-        "@budibase/pro": "2.0.32",
-        "@budibase/string-templates": "^2.0.32",
-        "@budibase/types": "^2.0.32",
+        "@budibase/backend-core": "^2.0.33",
+        "@budibase/client": "^2.0.33",
+        "@budibase/pro": "2.0.33",
+        "@budibase/string-templates": "^2.0.33",
+        "@budibase/types": "^2.0.33",
         "@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.0",
+        "@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.8.5",
+        "bull": "4.10.1",
         "chmodr": "1.2.0",
         "chokidar": "3.5.3",
         "csvtojson": "2.0.10",
@@ -112,7 +112,7 @@
         "js-yaml": "4.1.0",
         "jsonschema": "1.4.0",
         "knex": "0.95.15",
-        "koa": "2.7.0",
+        "koa": "2.13.4",
         "koa-body": "4.2.0",
         "koa-compress": "4.0.1",
         "koa-connect": "2.1.0",
@@ -123,7 +123,7 @@
         "koa2-ratelimit": "1.1.1",
         "lodash": "4.17.21",
         "memorystream": "0.3.1",
-        "mongodb": "3.6.3",
+        "mongodb": "4.9",
         "mssql": "6.2.3",
         "mysql2": "2.3.3",
         "node-fetch": "2.6.7",
@@ -146,7 +146,7 @@
         "to-json-schema": "0.2.5",
         "uuid": "3.3.2",
         "validate.js": "0.13.1",
-        "vm2": "3.9.6",
+        "vm2": "3.9.11",
         "worker-farm": "1.7.0",
         "xml2js": "0.4.23",
         "yargs": "13.2.4",
@@ -159,17 +159,17 @@
         "@jest/test-sequencer": "24.9.0",
         "@types/apidoc": "0.50.0",
         "@types/bson": "4.2.0",
-        "@types/bull": "3.15.8",
         "@types/global-agent": "2.1.1",
         "@types/google-spreadsheet": "3.1.5",
+        "@types/ioredis": "4.28.10",
         "@types/jest": "27.5.1",
         "@types/koa": "2.13.4",
-        "@types/koa__router": "8.0.0",
+        "@types/koa__router": "8.0.11",
         "@types/lodash": "4.14.180",
-        "@types/mongodb": "3.6.3",
         "@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",
         "@typescript-eslint/parser": "5.12.0",
         "apidoc": "0.50.4",

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

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GLOBAL_DB_EXPORT_FILE = exports.DB_EXPORT_FILE = void 0;
+exports.DB_EXPORT_FILE = "db.txt";
+exports.GLOBAL_DB_EXPORT_FILE = "global.txt";

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

@@ -0,0 +1,172 @@
+"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 utilities_1 = require("../../../utilities/fileSystem/utilities");
+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* () {
+        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, { filter: opts === null || opts === void 0 ? void 0 : opts.filter });
+                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, { filter: opts === null || opts === void 0 ? void 0 : opts.filter });
+                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;
+        if (!environment_1.default.isTest()) {
+            tmpPath = yield (0, utilities_1.retrieveDirectory)(constants_1.ObjectStoreBuckets.APPS, appPath);
+        }
+        else {
+            tmpPath = (0, fileSystem_1.createTempFolder)(uuid());
+        }
+        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;

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

@@ -0,0 +1,162 @@
+"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.importApp = exports.getListOfAppsInMulti = exports.getGlobalDBFile = exports.untarFile = void 0;
+const backend_core_1 = require("@budibase/backend-core");
+const utils_1 = require("../../../db/utils");
+const budibaseDir_1 = require("../../../utilities/budibaseDir");
+const constants_1 = require("./constants");
+const utilities_1 = require("../../../utilities/fileSystem/utilities");
+const fileSystem_1 = require("../../../utilities/fileSystem");
+const constants_2 = require("../../../constants");
+const path_1 = require("path");
+const fs_1 = __importDefault(require("fs"));
+const __1 = __importDefault(require("../../"));
+const uuid = require("uuid/v4");
+const tar = require("tar");
+function updateAttachmentColumns(prodAppId, db) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // iterate through attachment documents and update them
+        const tables = yield __1.default.tables.getAllInternalTables(db);
+        for (let table of tables) {
+            const attachmentCols = [];
+            for (let [key, column] of Object.entries(table.schema)) {
+                if (column.type === constants_2.FieldTypes.ATTACHMENT) {
+                    attachmentCols.push(key);
+                }
+            }
+            // no attachment columns, nothing to do
+            if (attachmentCols.length === 0) {
+                continue;
+            }
+            // use the CouchDB Mango query API to lookup rows that have attachments
+            const params = {
+                selector: {
+                    _id: {
+                        $regex: `^${utils_1.TABLE_ROW_PREFIX}`,
+                    },
+                },
+            };
+            attachmentCols.forEach(col => (params.selector[col] = { $exists: true }));
+            const { rows } = yield backend_core_1.db.directCouchFind(db.name, params);
+            for (let row of rows) {
+                for (let column of attachmentCols) {
+                    if (!Array.isArray(row[column])) {
+                        continue;
+                    }
+                    row[column] = row[column].map((attachment) => {
+                        // URL looks like: /prod-budi-app-assets/appId/attachments/file.csv
+                        const urlParts = attachment.url.split("/");
+                        // drop the first empty element
+                        urlParts.shift();
+                        // get the prefix
+                        const prefix = urlParts.shift();
+                        // remove the app ID
+                        urlParts.shift();
+                        // add new app ID
+                        urlParts.unshift(prodAppId);
+                        const key = urlParts.join("/");
+                        return Object.assign(Object.assign({}, attachment), { key, url: `/${prefix}/${key}` });
+                    });
+                }
+            }
+            // write back the updated attachments
+            yield db.bulkDocs(rows);
+        }
+    });
+}
+/**
+ * This function manages temporary template files which are stored by Koa.
+ * @param {Object} template The template object retrieved from the Koa context object.
+ * @returns {Object} Returns a fs read stream which can be loaded into the database.
+ */
+function getTemplateStream(template) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (template.file) {
+            return fs_1.default.createReadStream(template.file.path);
+        }
+        else if (template.key) {
+            const [type, name] = template.key.split("/");
+            const tmpPath = yield (0, fileSystem_1.downloadTemplate)(type, name);
+            return fs_1.default.createReadStream((0, path_1.join)(tmpPath, name, "db", "dump.txt"));
+        }
+    });
+}
+function untarFile(file) {
+    const tmpPath = (0, path_1.join)((0, budibaseDir_1.budibaseTempDir)(), uuid());
+    fs_1.default.mkdirSync(tmpPath);
+    // extract the tarball
+    tar.extract({
+        sync: true,
+        cwd: tmpPath,
+        file: file.path,
+    });
+    return tmpPath;
+}
+exports.untarFile = untarFile;
+function getGlobalDBFile(tmpPath) {
+    return fs_1.default.readFileSync((0, path_1.join)(tmpPath, constants_1.GLOBAL_DB_EXPORT_FILE), "utf8");
+}
+exports.getGlobalDBFile = getGlobalDBFile;
+function getListOfAppsInMulti(tmpPath) {
+    return fs_1.default.readdirSync(tmpPath).filter(dir => dir !== constants_1.GLOBAL_DB_EXPORT_FILE);
+}
+exports.getListOfAppsInMulti = getListOfAppsInMulti;
+function importApp(appId, db, template) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let prodAppId = backend_core_1.db.getProdAppID(appId);
+        let dbStream;
+        const isTar = template.file && template.file.type === "application/gzip";
+        const isDirectory = template.file && fs_1.default.lstatSync(template.file.path).isDirectory();
+        if (template.file && (isTar || isDirectory)) {
+            const tmpPath = isTar ? untarFile(template.file) : template.file.path;
+            const contents = fs_1.default.readdirSync(tmpPath);
+            // have to handle object import
+            if (contents.length) {
+                let promises = [];
+                let excludedFiles = [constants_1.GLOBAL_DB_EXPORT_FILE, constants_1.DB_EXPORT_FILE];
+                for (let filename of contents) {
+                    const path = (0, path_1.join)(tmpPath, filename);
+                    if (excludedFiles.includes(filename)) {
+                        continue;
+                    }
+                    filename = (0, path_1.join)(prodAppId, filename);
+                    if (fs_1.default.lstatSync(path).isDirectory()) {
+                        promises.push((0, utilities_1.uploadDirectory)(constants_2.ObjectStoreBuckets.APPS, path, filename));
+                    }
+                    else {
+                        promises.push((0, utilities_1.upload)({
+                            bucket: constants_2.ObjectStoreBuckets.APPS,
+                            path,
+                            filename,
+                        }));
+                    }
+                }
+                yield Promise.all(promises);
+            }
+            dbStream = fs_1.default.createReadStream((0, path_1.join)(tmpPath, constants_1.DB_EXPORT_FILE));
+        }
+        else {
+            dbStream = yield getTemplateStream(template);
+        }
+        // @ts-ignore
+        const { ok } = yield db.load(dbStream);
+        if (!ok) {
+            throw "Error loading database dump from template.";
+        }
+        yield updateAttachmentColumns(prodAppId, db);
+        return ok;
+    });
+}
+exports.importApp = importApp;

package/dist/sdk/app/backups/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 exportApps = __importStar(require("./exports"));
+const importApps = __importStar(require("./imports"));
+const statistics = __importStar(require("./statistics"));
+exports.default = Object.assign(Object.assign(Object.assign({}, exportApps), importApps), statistics);

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

@@ -0,0 +1,73 @@
+"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.calculateBackupStats = exports.calculateScreenCount = exports.calculateAutomationCount = exports.calculateDatasourceCount = void 0;
+const backend_core_1 = require("@budibase/backend-core");
+const utils_1 = require("../../../db/utils");
+function runInContext(appId, cb, db) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (db) {
+            return cb(db);
+        }
+        else {
+            const devAppId = backend_core_1.db.getDevAppID(appId);
+            return backend_core_1.context.doInAppContext(devAppId, () => {
+                const db = backend_core_1.context.getAppDB();
+                return cb(db);
+            });
+        }
+    });
+}
+function calculateDatasourceCount(appId, db) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return runInContext(appId, (db) => __awaiter(this, void 0, void 0, function* () {
+            const datasourceList = yield db.allDocs((0, utils_1.getDatasourceParams)());
+            const tableList = yield db.allDocs((0, utils_1.getTableParams)());
+            return datasourceList.rows.length + tableList.rows.length;
+        }), db);
+    });
+}
+exports.calculateDatasourceCount = calculateDatasourceCount;
+function calculateAutomationCount(appId, db) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return runInContext(appId, (db) => __awaiter(this, void 0, void 0, function* () {
+            const automationList = yield db.allDocs((0, utils_1.getAutomationParams)());
+            return automationList.rows.length;
+        }), db);
+    });
+}
+exports.calculateAutomationCount = calculateAutomationCount;
+function calculateScreenCount(appId, db) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return runInContext(appId, (db) => __awaiter(this, void 0, void 0, function* () {
+            const screenList = yield db.allDocs((0, utils_1.getScreenParams)());
+            return screenList.rows.length;
+        }), db);
+    });
+}
+exports.calculateScreenCount = calculateScreenCount;
+function calculateBackupStats(appId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return runInContext(appId, (db) => __awaiter(this, void 0, void 0, function* () {
+            const promises = [];
+            promises.push(calculateDatasourceCount(appId, db));
+            promises.push(calculateAutomationCount(appId, db));
+            promises.push(calculateScreenCount(appId, db));
+            const responses = yield Promise.all(promises);
+            return {
+                datasources: responses[0],
+                automations: responses[1],
+                screens: responses[2],
+            };
+        }));
+    });
+}
+exports.calculateBackupStats = calculateBackupStats;

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

@@ -0,0 +1,61 @@
+"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 });
+const context_1 = require("@budibase/backend-core/context");
+const utils_1 = require("../../../db/utils");
+const utils_2 = require("../../../integrations/utils");
+function getAllInternalTables(db) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!db) {
+            db = (0, context_1.getAppDB)();
+        }
+        const internalTables = yield db.allDocs((0, utils_1.getTableParams)(null, {
+            include_docs: true,
+        }));
+        return internalTables.rows.map((tableDoc) => (Object.assign(Object.assign({}, tableDoc.doc), { type: "internal", sourceId: utils_1.BudibaseInternalDB._id })));
+    });
+}
+function getAllExternalTables(datasourceId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const db = (0, context_1.getAppDB)();
+        const datasource = yield db.get(datasourceId);
+        if (!datasource || !datasource.entities) {
+            throw "Datasource is not configured fully.";
+        }
+        return datasource.entities;
+    });
+}
+function getExternalTable(datasourceId, tableName) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const entities = yield getAllExternalTables(datasourceId);
+        return entities[tableName];
+    });
+}
+function getTable(tableId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const db = (0, context_1.getAppDB)();
+        if ((0, utils_2.isExternalTable)(tableId)) {
+            let { datasourceId, tableName } = (0, utils_2.breakExternalTableId)(tableId);
+            const datasource = yield db.get(datasourceId);
+            const table = yield getExternalTable(datasourceId, tableName);
+            return Object.assign(Object.assign({}, table), { sql: (0, utils_2.isSQL)(datasource) });
+        }
+        else {
+            return db.get(tableId);
+        }
+    });
+}
+exports.default = {
+    getAllInternalTables,
+    getAllExternalTables,
+    getExternalTable,
+    getTable,
+};

package/dist/sdk/index.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const backups_1 = __importDefault(require("./app/backups"));
+const tables_1 = __importDefault(require("./app/tables"));
+const sdk = {
+    backups: backups_1.default,
+    tables: tables_1.default,
+};
+// default export for TS
+exports.default = sdk;
+// default export for JS
+module.exports = sdk;

package/dist/tests/utilities/TestConfiguration.js

@@ -24,7 +24,7 @@ const newid = require("../../db/newid");
 const context = require("@budibase/backend-core/context");
 const { generateDevInfoID, SEPARATOR } = require("@budibase/backend-core/db");
 const { encrypt } = require("@budibase/backend-core/encryption");
-const { DocumentType } = require("../../db/utils");
+const { DocumentType, generateUserMetadataID } = require("../../db/utils");
 const GLOBAL_USER_ID = "us_uuid1";
 const EMAIL = "babs@babs.com";
 const FIRSTNAME = "Barbara";
@@ -87,7 +87,9 @@ class TestConfiguration {
     // use a new id as the name to avoid name collisions
     init(appName = newid()) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.globalUser();
+            this.user = yield this.globalUser();
+            this.globalUserId = this.user._id;
+            this.userMetadataId = generateUserMetadataID(this.globalUserId);
             return this.createApp(appName);
         });
     }