@budibase/server 0.0.32 → 0.0.999-alpha.31

package/dist/utilities/usageQuota/rows.js

@@ -0,0 +1,88 @@
+"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.getUniqueRows = void 0;
+const utils_1 = require("../../db/utils");
+const backend_core_1 = require("@budibase/backend-core");
+const ROW_EXCLUSIONS = [utils_1.USER_METDATA_PREFIX];
+function getAppPairs(appIds) {
+    // collect the app ids into dev / prod pairs
+    // keyed by the dev app id
+    const pairs = {};
+    for (let appId of appIds) {
+        const devId = backend_core_1.db.getDevelopmentAppID(appId);
+        if (!pairs[devId]) {
+            pairs[devId] = {};
+        }
+        if (backend_core_1.db.isDevAppID(appId)) {
+            pairs[devId].devId = appId;
+        }
+        else {
+            pairs[devId].prodId = appId;
+        }
+    }
+    return pairs;
+}
+function getAppRows(appId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // need to specify the app ID, as this is used for different apps in one call
+        return backend_core_1.db.doWithDB(appId, (db) => __awaiter(this, void 0, void 0, function* () {
+            const response = yield db.allDocs((0, utils_1.getRowParams)(null, null, {
+                include_docs: false,
+            }));
+            return response.rows
+                .map(r => r.id)
+                .filter(id => {
+                for (let exclusion of ROW_EXCLUSIONS) {
+                    if (id.startsWith(exclusion)) {
+                        return false;
+                    }
+                }
+                return true;
+            });
+        }));
+    });
+}
+/**
+ * Return a set of all rows in the given app ids.
+ * The returned rows will be unique on a per dev/prod app basis.
+ * Rows duplicates may exist across apps due to data import so they are not filtered out.
+ */
+function getUniqueRows(appIds) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let uniqueRows = [], rowsByApp = {};
+        const pairs = getAppPairs(appIds);
+        for (let pair of Object.values(pairs)) {
+            let appRows = [];
+            for (let appId of [pair.devId, pair.prodId]) {
+                if (!appId) {
+                    continue;
+                }
+                try {
+                    appRows = appRows.concat(yield getAppRows(appId));
+                }
+                catch (e) {
+                    console.error(e);
+                    // don't error out if we can't count the app rows, just continue
+                }
+            }
+            // ensure uniqueness on a per app pair basis
+            // this can't be done on all rows because app import results in
+            // duplicate row ids across apps
+            // the array pre-concat is important to avoid stack overflow
+            const prodId = backend_core_1.db.getProdAppID((pair.devId || pair.prodId));
+            rowsByApp[prodId] = [...new Set(appRows)];
+            uniqueRows = uniqueRows.concat(rowsByApp[prodId]);
+        }
+        return { rows: uniqueRows, appRows: rowsByApp };
+    });
+}
+exports.getUniqueRows = getUniqueRows;

package/dist/utilities/usageQuota/usageQuoteReset.js

@@ -0,0 +1,16 @@
+"use strict";
+// UNUSED CODE
+// Preserved for future use
+/* eslint-disable no-unused-vars */
+function getNewQuotaReset() {
+    return Date.now() + 2592000000;
+}
+function resetQuotasIfRequired(quota) {
+    // Check if the quota needs reset
+    if (Date.now() >= quota.quotaReset) {
+        quota.quotaReset = getNewQuotaReset();
+        for (let prop of Object.keys(quota.usageQuota)) {
+            quota.usageQuota[prop] = 0;
+        }
+    }
+}

package/dist/utilities/users.js

@@ -0,0 +1,57 @@
+"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.publicApiUserFix = exports.getFullUser = void 0;
+const utils_1 = require("../db/utils");
+const global_1 = require("./global");
+const backend_core_1 = require("@budibase/backend-core");
+function getFullUser(ctx, userId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const global = yield (0, global_1.getGlobalUser)(userId);
+        let metadata = {};
+        // always prefer the user metadata _id and _rev
+        delete global._id;
+        delete global._rev;
+        try {
+            // this will throw an error if the db doesn't exist, or there is no appId
+            const db = backend_core_1.context.getAppDB();
+            metadata = yield db.get(userId);
+        }
+        catch (err) {
+            // it is fine if there is no user metadata yet
+        }
+        delete metadata.csrfToken;
+        return Object.assign(Object.assign(Object.assign({}, metadata), global), { roleId: global.roleId || backend_core_1.roles.BUILTIN_ROLE_IDS.PUBLIC, tableId: utils_1.InternalTables.USER_METADATA, 
+            // make sure the ID is always a local ID, not a global one
+            _id: userId });
+    });
+}
+exports.getFullUser = getFullUser;
+function publicApiUserFix(ctx) {
+    if (!ctx.request.body) {
+        return ctx;
+    }
+    if (!ctx.request.body._id && ctx.params.userId) {
+        ctx.request.body._id = ctx.params.userId;
+    }
+    if (!ctx.request.body.roles) {
+        ctx.request.body.roles = {};
+    }
+    else {
+        const newRoles = {};
+        for (let [appId, role] of Object.entries(ctx.request.body.roles)) {
+            newRoles[backend_core_1.db.getProdAppID(appId)] = role;
+        }
+        ctx.request.body.roles = newRoles;
+    }
+    return ctx;
+}
+exports.publicApiUserFix = publicApiUserFix;

package/dist/utilities/workerRequests.js

@@ -0,0 +1,171 @@
+"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.generateApiKey = exports.getChecklist = exports.createAdminUser = exports.readGlobalUser = exports.deleteGlobalUser = exports.saveGlobalUser = exports.allGlobalUsers = exports.removeAppFromUserRoles = exports.getGlobalSelf = exports.sendSmtpEmail = exports.request = void 0;
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const environment_1 = __importDefault(require("../environment"));
+const index_1 = require("./index");
+const backend_core_1 = require("@budibase/backend-core");
+const global_1 = require("./global");
+function request(ctx, request) {
+    if (!request.headers) {
+        request.headers = {};
+    }
+    if (!ctx) {
+        request.headers[backend_core_1.constants.Header.API_KEY] = backend_core_1.env.INTERNAL_API_KEY;
+        if (backend_core_1.tenancy.isTenantIdSet()) {
+            request.headers[backend_core_1.constants.Header.TENANT_ID] = backend_core_1.tenancy.getTenantId();
+        }
+    }
+    if (request.body && Object.keys(request.body).length > 0) {
+        request.headers["Content-Type"] = "application/json";
+        request.body =
+            typeof request.body === "object"
+                ? JSON.stringify(request.body)
+                : request.body;
+    }
+    else {
+        delete request.body;
+    }
+    if (ctx && ctx.headers) {
+        request.headers = ctx.headers;
+    }
+    // add x-budibase-correlation-id header
+    backend_core_1.logging.correlation.setHeader(request.headers);
+    return request;
+}
+exports.request = request;
+function checkResponse(response, errorMsg, { ctx } = {}) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (response.status !== 200) {
+            let error;
+            try {
+                error = yield response.json();
+            }
+            catch (err) {
+                error = yield response.text();
+            }
+            const msg = `Unable to ${errorMsg} - ${error.message ? error.message : error}`;
+            if (ctx) {
+                ctx.throw(400, msg);
+            }
+            else {
+                throw msg;
+            }
+        }
+        return response.json();
+    });
+}
+// have to pass in the tenant ID as this could be coming from an automation
+function sendSmtpEmail(to, from, subject, contents, cc, bcc, automation) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // tenant ID will be set in header
+        const response = yield (0, node_fetch_1.default)((0, index_1.checkSlashesInUrl)(environment_1.default.WORKER_URL + `/api/global/email/send`), request(undefined, {
+            method: "POST",
+            body: {
+                email: to,
+                from,
+                contents,
+                subject,
+                cc,
+                bcc,
+                purpose: "custom",
+                automation,
+            },
+        }));
+        return checkResponse(response, "send email");
+    });
+}
+exports.sendSmtpEmail = sendSmtpEmail;
+function getGlobalSelf(ctx, appId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const endpoint = `/api/global/self`;
+        const response = yield (0, node_fetch_1.default)((0, index_1.checkSlashesInUrl)(environment_1.default.WORKER_URL + endpoint), 
+        // we don't want to use API key when getting self
+        request(ctx, { method: "GET" }));
+        let json = yield checkResponse(response, "get self globally", { ctx });
+        if (appId) {
+            json = (0, global_1.updateAppRole)(json);
+        }
+        return json;
+    });
+}
+exports.getGlobalSelf = getGlobalSelf;
+function removeAppFromUserRoles(ctx, appId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const prodAppId = backend_core_1.db.getProdAppID(appId);
+        const response = yield (0, node_fetch_1.default)((0, index_1.checkSlashesInUrl)(environment_1.default.WORKER_URL + `/api/global/roles/${prodAppId}`), request(ctx, {
+            method: "DELETE",
+        }));
+        return checkResponse(response, "remove app role");
+    });
+}
+exports.removeAppFromUserRoles = removeAppFromUserRoles;
+function allGlobalUsers(ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield (0, node_fetch_1.default)((0, index_1.checkSlashesInUrl)(environment_1.default.WORKER_URL + "/api/global/users"), 
+        // we don't want to use API key when getting self
+        request(ctx, { method: "GET" }));
+        return checkResponse(response, "get users", { ctx });
+    });
+}
+exports.allGlobalUsers = allGlobalUsers;
+function saveGlobalUser(ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield (0, node_fetch_1.default)((0, index_1.checkSlashesInUrl)(environment_1.default.WORKER_URL + "/api/global/users"), 
+        // we don't want to use API key when getting self
+        request(ctx, { method: "POST", body: ctx.request.body }));
+        return checkResponse(response, "save user", { ctx });
+    });
+}
+exports.saveGlobalUser = saveGlobalUser;
+function deleteGlobalUser(ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield (0, node_fetch_1.default)((0, index_1.checkSlashesInUrl)(environment_1.default.WORKER_URL + `/api/global/users/${ctx.params.userId}`), 
+        // we don't want to use API key when getting self
+        request(ctx, { method: "DELETE" }));
+        return checkResponse(response, "delete user", { ctx });
+    });
+}
+exports.deleteGlobalUser = deleteGlobalUser;
+function readGlobalUser(ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield (0, node_fetch_1.default)((0, index_1.checkSlashesInUrl)(environment_1.default.WORKER_URL + `/api/global/users/${ctx.params.userId}`), 
+        // we don't want to use API key when getting self
+        request(ctx, { method: "GET" }));
+        return checkResponse(response, "get user", { ctx });
+    });
+}
+exports.readGlobalUser = readGlobalUser;
+function createAdminUser(email, password, tenantId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield (0, node_fetch_1.default)((0, index_1.checkSlashesInUrl)(environment_1.default.WORKER_URL + "/api/global/users/init"), request(undefined, { method: "POST", body: { email, password, tenantId } }));
+        return checkResponse(response, "create admin user");
+    });
+}
+exports.createAdminUser = createAdminUser;
+function getChecklist() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield (0, node_fetch_1.default)((0, index_1.checkSlashesInUrl)(environment_1.default.WORKER_URL + "/api/global/configs/checklist"), request(undefined, { method: "GET" }));
+        return checkResponse(response, "get checklist");
+    });
+}
+exports.getChecklist = getChecklist;
+function generateApiKey(userId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield (0, node_fetch_1.default)((0, index_1.checkSlashesInUrl)(environment_1.default.WORKER_URL + "/api/global/self/api_key"), request(undefined, { method: "POST", body: { userId } }));
+        return checkResponse(response, "generate API key");
+    });
+}
+exports.generateApiKey = generateApiKey;

package/dist/watch.js

@@ -0,0 +1,53 @@
+"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.watch = void 0;
+const path_1 = __importDefault(require("path"));
+const environment_1 = __importDefault(require("./environment"));
+const chokidar_1 = __importDefault(require("chokidar"));
+const fs_1 = __importDefault(require("fs"));
+const backend_core_1 = require("@budibase/backend-core");
+const plugins_1 = __importDefault(require("./sdk/plugins"));
+function watch() {
+    const watchPath = path_1.default.join(environment_1.default.PLUGINS_DIR, "./**/*.tar.gz");
+    chokidar_1.default
+        .watch(watchPath, {
+        ignored: "**/node_modules",
+        awaitWriteFinish: {
+            pollInterval: 100,
+            stabilityThreshold: 250,
+        },
+        usePolling: true,
+        interval: 250,
+    })
+        .on("all", (event, path) => __awaiter(this, void 0, void 0, function* () {
+        // Sanity checks
+        if (!(path === null || path === void 0 ? void 0 : path.endsWith(".tar.gz")) || !fs_1.default.existsSync(path)) {
+            return;
+        }
+        yield backend_core_1.tenancy.doInTenant(backend_core_1.constants.DEFAULT_TENANT_ID, () => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const split = path.split("/");
+                const name = split[split.length - 1];
+                console.log("Importing plugin:", path);
+                yield plugins_1.default.processUploaded({ name, path });
+            }
+            catch (err) {
+                const message = (err === null || err === void 0 ? void 0 : err.message) ? err === null || err === void 0 ? void 0 : err.message : err;
+                console.error("Failed to import plugin:", message);
+            }
+        }));
+    }));
+}
+exports.watch = watch;

package/dist/websockets/client.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const websocket_1 = __importDefault(require("./websocket"));
+const authorized_1 = __importDefault(require("../middleware/authorized"));
+const backend_core_1 = require("@budibase/backend-core");
+class ClientAppWebsocket extends websocket_1.default {
+    constructor(app, server) {
+        super(app, server, "/socket/client", [(0, authorized_1.default)(backend_core_1.permissions.BUILDER)]);
+    }
+}
+exports.default = ClientAppWebsocket;

package/dist/websockets/grid.js

@@ -0,0 +1,60 @@
+"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 });
+const authorized_1 = __importDefault(require("../middleware/authorized"));
+const websocket_1 = __importDefault(require("./websocket"));
+const backend_core_1 = require("@budibase/backend-core");
+class GridSocket extends websocket_1.default {
+    constructor(app, server) {
+        super(app, server, "/socket/grid", [(0, authorized_1.default)(backend_core_1.permissions.BUILDER)]);
+        this.io.on("connection", socket => {
+            const user = socket.data.user;
+            console.log(`Spreadsheet user connected: ${user === null || user === void 0 ? void 0 : user.id}`);
+            // Socket state
+            let currentRoom;
+            // Initial identification of connected spreadsheet
+            socket.on("select-table", (tableId, callback) => __awaiter(this, void 0, void 0, function* () {
+                // Leave current room
+                if (currentRoom) {
+                    socket.to(currentRoom).emit("user-disconnect", socket.data.user);
+                    socket.leave(currentRoom);
+                }
+                // Join new room
+                currentRoom = tableId;
+                socket.join(currentRoom);
+                socket.to(currentRoom).emit("user-update", socket.data.user);
+                // Reply with all users in current room
+                const sockets = yield this.io.in(currentRoom).fetchSockets();
+                callback({
+                    users: sockets.map(socket => socket.data.user),
+                    id: user.id,
+                });
+            }));
+            // Handle users selecting a new cell
+            socket.on("select-cell", cellId => {
+                socket.data.user.selectedCellId = cellId;
+                if (currentRoom) {
+                    socket.to(currentRoom).emit("user-update", socket.data.user);
+                }
+            });
+            // Disconnection cleanup
+            socket.on("disconnect", () => {
+                if (currentRoom) {
+                    socket.to(currentRoom).emit("user-disconnect", socket.data.user);
+                }
+            });
+        });
+    }
+}
+exports.default = GridSocket;

package/dist/websockets/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 });
+exports.gridSocket = exports.clientAppSocket = exports.initialise = void 0;
+const grid_1 = __importDefault(require("./grid"));
+const client_1 = __importDefault(require("./client"));
+let clientAppSocket;
+exports.clientAppSocket = clientAppSocket;
+let gridSocket;
+exports.gridSocket = gridSocket;
+const initialise = (app, server) => {
+    exports.clientAppSocket = clientAppSocket = new client_1.default(app, server);
+    exports.gridSocket = gridSocket = new grid_1.default(app, server);
+};
+exports.initialise = initialise;

package/dist/websockets/websocket.js

@@ -0,0 +1,78 @@
+"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 });
+const socket_io_1 = require("socket.io");
+const http_1 = __importDefault(require("http"));
+const cookies_1 = __importDefault(require("cookies"));
+const koa_useragent_1 = require("koa-useragent");
+const backend_core_1 = require("@budibase/backend-core");
+const currentapp_1 = __importDefault(require("../middleware/currentapp"));
+class Socket {
+    constructor(app, server, path, additionalMiddlewares) {
+        this.io = new socket_io_1.Server(server, {
+            path,
+        });
+        // Attach default middlewares
+        const authenticate = backend_core_1.auth.buildAuthMiddleware([], {
+            publicAllowed: true,
+        });
+        const middlewares = [
+            koa_useragent_1.userAgent,
+            authenticate,
+            currentapp_1.default,
+            ...(additionalMiddlewares || []),
+        ];
+        // Apply middlewares
+        this.io.use((socket, next) => __awaiter(this, void 0, void 0, function* () {
+            // Build fake koa context
+            const res = new http_1.default.ServerResponse(socket.request);
+            const ctx = Object.assign(Object.assign({}, app.createContext(socket.request, res)), { 
+                // Additional overrides needed to make our middlewares work with this
+                // fake koa context
+                cookies: new cookies_1.default(socket.request, res), get: (field) => socket.request.headers[field], throw: (code, message) => {
+                    throw new Error(message);
+                }, 
+                // Needed for koa-useragent middleware
+                headers: socket.request.headers, header: socket.request.headers, 
+                // We don't really care about the path since it will never contain
+                // an app ID
+                path: "/socket" });
+            // Run all koa middlewares
+            try {
+                for (let [idx, middleware] of middlewares.entries()) {
+                    yield middleware(ctx, () => {
+                        if (idx === middlewares.length - 1) {
+                            // Middlewares are finished.
+                            // Extract some data from our enriched koa context to persist
+                            // as metadata for the socket
+                            socket.data.user = {
+                                id: ctx.user._id,
+                                email: ctx.user.email,
+                            };
+                            next();
+                        }
+                    });
+                }
+            }
+            catch (error) {
+                next(error);
+            }
+        }));
+    }
+    // Emit an event to all sockets
+    emit(event, payload) {
+        this.io.sockets.emit(event, payload);
+    }
+}
+exports.default = Socket;

package/docker_run.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+
+if [ -z $CLUSTER_MODE ]; then
+  yarn run:docker
+else
+  yarn run:docker:cluster
+fi

package/jest-testcontainers-config.js

@@ -0,0 +1,8 @@
+const { join } = require("path")
+require("dotenv").config({
+  path: join(__dirname, "..", "..", "hosting", ".env"),
+})
+
+const jestTestcontainersConfigGenerator = require("../../jestTestcontainersConfigGenerator")
+
+module.exports = jestTestcontainersConfigGenerator()

package/jest.config.ts

@@ -0,0 +1,52 @@
+import { Config } from "@jest/types"
+
+import * as fs from "fs"
+const preset = require("ts-jest/jest-preset")
+
+const baseConfig: Config.InitialProjectOptions = {
+  ...preset,
+  preset: "@trendyol/jest-testcontainers",
+  setupFiles: ["./src/tests/jestEnv.ts"],
+  setupFilesAfterEnv: ["./src/tests/jestSetup.ts"],
+  transform: {
+    "^.+\\.ts?$": "@swc/jest",
+  },
+  moduleNameMapper: {
+    "@budibase/backend-core/(.*)": "<rootDir>/../backend-core/$1",
+    "@budibase/backend-core": "<rootDir>/../backend-core/src",
+    "@budibase/shared-core": "<rootDir>/../shared-core/src",
+    "@budibase/types": "<rootDir>/../types/src",
+  },
+}
+
+// add pro sources if they exist
+if (fs.existsSync("../pro/packages")) {
+  baseConfig.moduleNameMapper!["@budibase/pro"] =
+    "<rootDir>/../pro/packages/pro/src"
+}
+
+const config: Config.InitialOptions = {
+  projects: [
+    {
+      ...baseConfig,
+      displayName: "sequential test",
+      testMatch: ["<rootDir>/**/*.seq.spec.[jt]s"],
+      runner: "jest-serial-runner",
+    },
+    {
+      ...baseConfig,
+      testMatch: ["<rootDir>/**/!(*.seq).spec.[jt]s"],
+    },
+  ],
+  collectCoverageFrom: [
+    "src/**/*.{js,ts}",
+    "../backend-core/src/**/*.{js,ts}",
+    // The use of coverage with couchdb view functions breaks tests
+    "!src/db/views/staticViews.*",
+    "!src/**/*.spec.{js,ts}",
+    "!src/tests/**/*.{js,ts}",
+  ],
+  coverageReporters: ["lcov", "json", "clover"],
+}
+
+export default config

package/nodemon.json

@@ -0,0 +1,10 @@
+{
+  "watch": ["src", "../backend-core", "../pro/packages/pro"],
+  "ext": "js,ts,json",
+  "ignore": [
+    "src/**/*.spec.ts",
+    "src/**/*.spec.js",
+    "../backend-core/dist/**/*"
+  ],
+  "exec": "ts-node src/index.ts"
+}