@budibase/server 2.0.34-alpha.5 → 2.0.34-alpha.7

package/dist/sdk/index.js

@@ -5,9 +5,11 @@ var __importDefault = (this && this.__importDefault) || function (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;

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/packages/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

@@ -25,6 +25,7 @@ const context = require("@budibase/backend-core/context");
 const { generateDevInfoID, SEPARATOR } = require("@budibase/backend-core/db");
 const { encrypt } = require("@budibase/backend-core/encryption");
 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,6 +92,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* () {
+            if (!this.started) {
+                yield startup();
+            }
             this.user = yield this.globalUser();
             this.globalUserId = this.user._id;
             this.userMetadataId = generateUserMetadataID(this.globalUserId);