@budibase/server 2.0.30-alpha.14 → 2.0.30-alpha.16

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

package/dist/threads/automation.js

@@ -72,16 +72,12 @@ function getLoopIterations(loopStep, input) {
  * inputs and handles any outputs.
  */
 class Orchestrator {
-    constructor(automation, triggerOutput, opts) {
+    constructor(job) {
+        let automation = job.data.automation, triggerOutput = job.data.event;
         const metadata = triggerOutput.metadata;
         this._chainCount = metadata ? metadata.automationChainCount : 0;
         this._appId = triggerOutput.appId;
-        if (opts === null || opts === void 0 ? void 0 : opts.repeat) {
-            this._repeat = {
-                jobId: opts.repeat.jobId,
-                jobKey: opts.repeat.key,
-            };
-        }
+        this._job = job;
         const triggerStepId = automation.definition.trigger.stepId;
         triggerOutput = this.cleanupTriggerOutputs(triggerStepId, triggerOutput);
         // remove from context
@@ -131,15 +127,14 @@ class Orchestrator {
         });
     }
     stopCron(reason) {
-        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this._repeat) {
+            if (!this._job.opts.repeat) {
                 return;
             }
             logWarn(`CRON disabled reason=${reason} - ${this._appId}/${this._automation._id}`);
             const automation = this._automation;
             const trigger = automation.definition.trigger;
-            yield (0, utils_2.disableCron)((_a = this._repeat) === null || _a === void 0 ? void 0 : _a.jobId, (_b = this._repeat) === null || _b === void 0 ? void 0 : _b.jobKey);
+            yield (0, utils_2.disableCronById)(this._job.id);
             this.updateExecutionOutput(trigger.id, trigger.stepId, {}, {
                 status: types_1.AutomationStatus.STOPPED_ERROR,
                 success: false,
@@ -149,7 +144,7 @@ class Orchestrator {
     }
     checkIfShouldStop(metadata) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!metadata.errorCount || !this._repeat) {
+            if (!metadata.errorCount || !this._job.opts.repeat) {
                 return false;
             }
             if (metadata.errorCount >= constants_1.MAX_AUTOMATION_RECURRING_ERRORS) {
@@ -404,13 +399,13 @@ class Orchestrator {
         });
     }
 }
-function execute(input, callback) {
-    const appId = input.data.event.appId;
+function execute(job, callback) {
+    const appId = job.data.event.appId;
     if (!appId) {
         throw new Error("Unable to execute, event doesn't contain app ID.");
     }
     doInAppContext(appId, () => __awaiter(this, void 0, void 0, function* () {
-        const automationOrchestrator = new Orchestrator(input.data.automation, input.data.event, input.opts);
+        const automationOrchestrator = new Orchestrator(job);
         try {
             const response = yield automationOrchestrator.execute();
             callback(null, response);
@@ -421,13 +416,13 @@ function execute(input, callback) {
     }));
 }
 exports.execute = execute;
-const removeStalled = (input) => __awaiter(void 0, void 0, void 0, function* () {
-    const appId = input.data.event.appId;
+const removeStalled = (job) => __awaiter(void 0, void 0, void 0, function* () {
+    const appId = job.data.event.appId;
     if (!appId) {
         throw new Error("Unable to execute, event doesn't contain app ID.");
     }
     yield doInAppContext(appId, () => __awaiter(void 0, void 0, void 0, function* () {
-        const automationOrchestrator = new Orchestrator(input.data.automation, input.data.event, input.opts);
+        const automationOrchestrator = new Orchestrator(job);
         yield automationOrchestrator.stopCron("stalled");
     }));
 });