@budibase/server 2.0.39 → 2.0.40-alpha.1

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,17 @@
+"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 automations_1 = __importDefault(require("./app/automations"));
+const sdk = {
+    backups: backups_1.default,
+    tables: tables_1.default,
+    automations: automations_1.default,
+};
+// default export for TS
+exports.default = sdk;
+// default export for JS
+module.exports = sdk;

package/dist/startup.js

@@ -0,0 +1,152 @@
+"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;
+};
+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.startup = void 0;
+const env = __importStar(require("./environment"));
+const redis_1 = __importDefault(require("./utilities/redis"));
+const workerRequests_1 = require("./utilities/workerRequests");
+const backend_core_1 = require("@budibase/backend-core");
+const fs_1 = __importDefault(require("fs"));
+const watch_1 = require("./watch");
+const automations_1 = __importDefault(require("./automations"));
+const fileSystem_1 = __importDefault(require("./utilities/fileSystem"));
+const events_1 = __importDefault(require("./events"));
+const migrations = __importStar(require("./migrations"));
+const bullboard_1 = __importDefault(require("./automations/bullboard"));
+const pro = __importStar(require("@budibase/pro"));
+const api_1 = __importDefault(require("./api"));
+const sdk_1 = __importDefault(require("./sdk"));
+const pino = require("koa-pino-logger");
+let STARTUP_RAN = false;
+function initRoutes(app) {
+    return __awaiter(this, void 0, void 0, function* () {
+        app.use(pino((0, backend_core_1.pinoSettings)()));
+        if (!env.isTest()) {
+            const plugin = yield bullboard_1.default.init();
+            app.use(plugin);
+        }
+        app.context.eventEmitter = events_1.default;
+        app.context.auth = {};
+        // api routes
+        app.use(api_1.default.router.routes());
+    });
+}
+function initPro() {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield pro.init({
+            backups: {
+                processing: {
+                    exportAppFn: sdk_1.default.backups.exportApp,
+                    importAppFn: sdk_1.default.backups.importApp,
+                    statsFn: sdk_1.default.backups.calculateBackupStats,
+                },
+            },
+        });
+    });
+}
+function shutdown(server) {
+    server.close();
+    server.destroy();
+}
+function startup(app, server) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        if (STARTUP_RAN) {
+            return;
+        }
+        STARTUP_RAN = true;
+        if (server) {
+            console.log(`Budibase running on ${JSON.stringify(server.address())}`);
+            env._set("PORT", server.address().port);
+        }
+        events_1.default.emitPort(env.PORT);
+        fileSystem_1.default.init();
+        yield redis_1.default.init();
+        // run migrations on startup if not done via http
+        // not recommended in a clustered environment
+        if (!env.HTTP_MIGRATIONS && !env.isTest()) {
+            try {
+                yield migrations.migrate();
+            }
+            catch (e) {
+                backend_core_1.logging.logAlert("Error performing migrations. Exiting.", e);
+                shutdown();
+            }
+        }
+        // check and create admin user if required
+        if (env.SELF_HOSTED &&
+            !env.MULTI_TENANCY &&
+            env.BB_ADMIN_USER_EMAIL &&
+            env.BB_ADMIN_USER_PASSWORD) {
+            const checklist = yield (0, workerRequests_1.getChecklist)();
+            if (!((_a = checklist === null || checklist === void 0 ? void 0 : checklist.adminUser) === null || _a === void 0 ? void 0 : _a.checked)) {
+                try {
+                    const tenantId = backend_core_1.tenancy.getTenantId();
+                    const user = yield (0, workerRequests_1.createAdminUser)(env.BB_ADMIN_USER_EMAIL, env.BB_ADMIN_USER_PASSWORD, tenantId);
+                    // Need to set up an API key for automated integration tests
+                    if (env.isTest()) {
+                        yield (0, workerRequests_1.generateApiKey)(user._id);
+                    }
+                    console.log("Admin account automatically created for", env.BB_ADMIN_USER_EMAIL);
+                }
+                catch (e) {
+                    backend_core_1.logging.logAlert("Error creating initial admin user. Exiting.", e);
+                    shutdown();
+                }
+            }
+        }
+        // monitor plugin directory if required
+        if (env.SELF_HOSTED &&
+            !env.MULTI_TENANCY &&
+            env.PLUGINS_DIR &&
+            fs_1.default.existsSync(env.PLUGINS_DIR)) {
+            (0, watch_1.watch)();
+        }
+        // check for version updates
+        yield backend_core_1.installation.checkInstallVersion();
+        // get the references to the queue promises, don't await as
+        // they will never end, unless the processing stops
+        let queuePromises = [];
+        queuePromises.push(automations_1.default.init());
+        queuePromises.push(initPro());
+        if (app) {
+            // bring routes online as final step once everything ready
+            yield initRoutes(app);
+        }
+    });
+}
+exports.startup = startup;

package/dist/tests/utilities/TestConfiguration.js

@@ -24,7 +24,8 @@ 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 { startup } = require("../../startup");
 const GLOBAL_USER_ID = "us_uuid1";
 const EMAIL = "babs@babs.com";
 const FIRSTNAME = "Barbara";
@@ -38,6 +39,10 @@ class TestConfiguration {
             this.server = require("../../app");
             // we need the request for logging in, involves cookies, hard to fake
             this.request = supertest(this.server);
+            this.started = true;
+        }
+        else {
+            this.started = false;
         }
         this.appId = null;
         this.allApps = [];
@@ -87,7 +92,12 @@ 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();
+            if (!this.started) {
+                yield startup();
+            }
+            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");
     }));
 });