@budibase/server 0.0.32 → 0.0.999-alpha.30

package/dist/api/controllers/query/index.js

@@ -0,0 +1,299 @@
+"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.destroy = exports.executeV2 = exports.executeV1 = exports.preview = exports.find = exports.save = exports.import = exports.fetch = void 0;
+const utils_1 = require("../../../db/utils");
+const constants_1 = require("../../../constants");
+const threads_1 = require("../../../threads");
+const datasource_1 = require("../datasource");
+const import_1 = require("./import");
+const utils_2 = require("../../../threads/utils");
+const environment_1 = __importDefault(require("../../../environment"));
+const pro_1 = require("@budibase/pro");
+const backend_core_1 = require("@budibase/backend-core");
+const sdk_1 = __importDefault(require("../../../sdk"));
+const Runner = new threads_1.Thread(threads_1.ThreadType.QUERY, {
+    timeoutMs: environment_1.default.QUERY_THREAD_TIMEOUT || 10000,
+});
+// simple function to append "readable" to all read queries
+function enrichQueries(input) {
+    const wasArray = Array.isArray(input);
+    const queries = wasArray ? input : [input];
+    for (let query of queries) {
+        if (query.queryVerb === constants_1.BaseQueryVerbs.READ) {
+            query.readable = true;
+        }
+    }
+    return wasArray ? queries : queries[0];
+}
+function fetch(ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const db = backend_core_1.context.getAppDB();
+        const body = yield db.allDocs((0, utils_1.getQueryParams)(null, {
+            include_docs: true,
+        }));
+        ctx.body = enrichQueries(body.rows.map((row) => row.doc));
+    });
+}
+exports.fetch = fetch;
+const _import = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+    const body = ctx.request.body;
+    const data = body.data;
+    const importer = new import_1.RestImporter(data);
+    yield importer.init();
+    let datasourceId;
+    if (!body.datasourceId) {
+        // construct new datasource
+        const info = yield importer.getInfo();
+        let datasource = {
+            type: "datasource",
+            source: "REST",
+            config: {
+                url: info.url,
+                defaultHeaders: [],
+                rejectUnauthorized: true,
+            },
+            name: info.name,
+        };
+        // save the datasource
+        const datasourceCtx = Object.assign({}, ctx);
+        datasourceCtx.request.body.datasource = datasource;
+        yield (0, datasource_1.save)(datasourceCtx);
+        datasourceId = datasourceCtx.body.datasource._id;
+    }
+    else {
+        // use existing datasource
+        datasourceId = body.datasourceId;
+    }
+    const importResult = yield importer.importQueries(datasourceId);
+    ctx.body = Object.assign(Object.assign({}, importResult), { datasourceId });
+    ctx.status = 200;
+});
+exports.import = _import;
+function save(ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const db = backend_core_1.context.getAppDB();
+        const query = ctx.request.body;
+        const datasource = yield sdk_1.default.datasources.get(query.datasourceId);
+        let eventFn;
+        if (!query._id) {
+            query._id = (0, utils_1.generateQueryID)(query.datasourceId);
+            eventFn = () => backend_core_1.events.query.created(datasource, query);
+        }
+        else {
+            eventFn = () => backend_core_1.events.query.updated(datasource, query);
+        }
+        const response = yield db.put(query);
+        yield eventFn();
+        query._rev = response.rev;
+        ctx.body = query;
+        ctx.message = `Query ${query.name} saved successfully.`;
+    });
+}
+exports.save = save;
+function find(ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const db = backend_core_1.context.getAppDB();
+        const query = enrichQueries(yield db.get(ctx.params.queryId));
+        // remove properties that could be dangerous in real app
+        if ((0, utils_1.isProdAppID)(ctx.appId)) {
+            delete query.fields;
+            delete query.parameters;
+        }
+        ctx.body = query;
+    });
+}
+exports.find = find;
+//Required to discern between OIDC OAuth config entries
+function getOAuthConfigCookieId(ctx) {
+    if (ctx.user.providerType === backend_core_1.constants.Config.OIDC) {
+        return backend_core_1.utils.getCookie(ctx, backend_core_1.constants.Cookie.OIDC_CONFIG);
+    }
+}
+function getAuthConfig(ctx) {
+    const authCookie = backend_core_1.utils.getCookie(ctx, backend_core_1.constants.Cookie.Auth);
+    let authConfigCtx = {};
+    authConfigCtx["configId"] = getOAuthConfigCookieId(ctx);
+    authConfigCtx["sessionId"] = authCookie ? authCookie.sessionId : null;
+    return authConfigCtx;
+}
+function preview(ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { datasource, envVars } = yield sdk_1.default.datasources.getWithEnvVars(ctx.request.body.datasourceId);
+        const query = ctx.request.body;
+        // preview may not have a queryId as it hasn't been saved, but if it does
+        // this stops dynamic variables from calling the same query
+        const { fields, parameters, queryVerb, transformer, queryId } = query;
+        const authConfigCtx = getAuthConfig(ctx);
+        try {
+            const inputs = {
+                appId: ctx.appId,
+                datasource,
+                queryVerb,
+                fields,
+                parameters,
+                transformer,
+                queryId,
+                // have to pass down to the thread runner - can't put into context now
+                environmentVariables: envVars,
+                ctx: {
+                    user: ctx.user,
+                    auth: Object.assign({}, authConfigCtx),
+                },
+            };
+            const runFn = () => Runner.run(inputs);
+            const { rows, keys, info, extra } = yield pro_1.quotas.addQuery(runFn, {
+                datasourceId: datasource._id,
+            });
+            const schemaFields = {};
+            if ((rows === null || rows === void 0 ? void 0 : rows.length) > 0) {
+                for (let key of [...new Set(keys)]) {
+                    const field = rows[0][key];
+                    let type = typeof field, fieldType = constants_1.FieldTypes.STRING;
+                    if (field)
+                        switch (type) {
+                            case "boolean":
+                                schemaFields[key] = constants_1.FieldTypes.BOOLEAN;
+                                break;
+                            case "object":
+                                if (field instanceof Date) {
+                                    fieldType = constants_1.FieldTypes.DATETIME;
+                                }
+                                else if (Array.isArray(field)) {
+                                    fieldType = constants_1.FieldTypes.ARRAY;
+                                }
+                                else {
+                                    fieldType = constants_1.FieldTypes.JSON;
+                                }
+                                break;
+                            case "number":
+                                fieldType = constants_1.FieldTypes.NUMBER;
+                                break;
+                        }
+                    schemaFields[key] = fieldType;
+                }
+            }
+            // remove configuration before sending event
+            delete datasource.config;
+            yield backend_core_1.events.query.previewed(datasource, query);
+            ctx.body = {
+                rows,
+                schemaFields,
+                info,
+                extra,
+            };
+        }
+        catch (err) {
+            ctx.throw(400, err);
+        }
+    });
+}
+exports.preview = preview;
+function execute(ctx, opts = { rowsOnly: false, isAutomation: false }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const db = backend_core_1.context.getAppDB();
+        const query = yield db.get(ctx.params.queryId);
+        const { datasource, envVars } = yield sdk_1.default.datasources.getWithEnvVars(query.datasourceId);
+        let authConfigCtx = {};
+        if (!opts.isAutomation) {
+            authConfigCtx = getAuthConfig(ctx);
+        }
+        const enrichedParameters = ctx.request.body.parameters || {};
+        // make sure parameters are fully enriched with defaults
+        if (query && query.parameters) {
+            for (let parameter of query.parameters) {
+                if (!enrichedParameters[parameter.name]) {
+                    enrichedParameters[parameter.name] = parameter.default;
+                }
+            }
+        }
+        // call the relevant CRUD method on the integration class
+        try {
+            const inputs = {
+                appId: ctx.appId,
+                datasource,
+                queryVerb: query.queryVerb,
+                fields: query.fields,
+                pagination: ctx.request.body.pagination,
+                parameters: enrichedParameters,
+                transformer: query.transformer,
+                queryId: ctx.params.queryId,
+                // have to pass down to the thread runner - can't put into context now
+                environmentVariables: envVars,
+                ctx: {
+                    user: ctx.user,
+                    auth: Object.assign({}, authConfigCtx),
+                },
+            };
+            const runFn = () => Runner.run(inputs);
+            const { rows, pagination, extra } = yield pro_1.quotas.addQuery(runFn, {
+                datasourceId: datasource._id,
+            });
+            // remove the raw from execution incase transformer being used to hide data
+            if (extra === null || extra === void 0 ? void 0 : extra.raw) {
+                delete extra.raw;
+            }
+            if (opts && opts.rowsOnly) {
+                ctx.body = rows;
+            }
+            else {
+                ctx.body = Object.assign({ data: rows, pagination }, extra);
+            }
+        }
+        catch (err) {
+            ctx.throw(400, err);
+        }
+    });
+}
+function executeV1(ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return execute(ctx, { rowsOnly: true, isAutomation: false });
+    });
+}
+exports.executeV1 = executeV1;
+function executeV2(ctx, { isAutomation } = {}) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return execute(ctx, { rowsOnly: false, isAutomation });
+    });
+}
+exports.executeV2 = executeV2;
+const removeDynamicVariables = (queryId) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const db = backend_core_1.context.getAppDB();
+    const query = yield db.get(queryId);
+    const datasource = yield sdk_1.default.datasources.get(query.datasourceId);
+    const dynamicVariables = (_a = datasource.config) === null || _a === void 0 ? void 0 : _a.dynamicVariables;
+    if (dynamicVariables) {
+        // delete dynamic variables from the datasource
+        datasource.config.dynamicVariables = dynamicVariables.filter((dv) => dv.queryId !== queryId);
+        yield db.put(datasource);
+        // invalidate the deleted variables
+        const variablesToDelete = dynamicVariables.filter((dv) => dv.queryId === queryId);
+        yield (0, utils_2.invalidateDynamicVariables)(variablesToDelete);
+    }
+});
+function destroy(ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const db = backend_core_1.context.getAppDB();
+        const queryId = ctx.params.queryId;
+        yield removeDynamicVariables(queryId);
+        const query = yield db.get(queryId);
+        const datasource = yield sdk_1.default.datasources.get(query.datasourceId);
+        yield db.remove(ctx.params.queryId, ctx.params.revId);
+        ctx.message = `Query deleted.`;
+        ctx.status = 200;
+        yield backend_core_1.events.query.deleted(datasource, query);
+    });
+}
+exports.destroy = destroy;

package/dist/api/controllers/query/validation.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateQueryPreviewValidation = exports.generateQueryValidation = exports.queryValidation = void 0;
+const backend_core_1 = require("@budibase/backend-core");
+const joi_1 = __importDefault(require("joi"));
+const OPTIONAL_STRING = joi_1.default.string().optional().allow(null).allow("");
+function queryValidation() {
+    return joi_1.default.object({
+        _id: joi_1.default.string(),
+        _rev: joi_1.default.string(),
+        name: joi_1.default.string().required(),
+        fields: joi_1.default.object().required(),
+        datasourceId: joi_1.default.string().required(),
+        readable: joi_1.default.boolean(),
+        parameters: joi_1.default.array().items(joi_1.default.object({
+            name: joi_1.default.string(),
+            default: joi_1.default.string().allow(""),
+        })),
+        queryVerb: joi_1.default.string().allow().required(),
+        extra: joi_1.default.object().optional(),
+        schema: joi_1.default.object({}).required().unknown(true),
+        transformer: OPTIONAL_STRING,
+        flags: joi_1.default.object().optional(),
+    }).unknown(true);
+}
+exports.queryValidation = queryValidation;
+function generateQueryValidation() {
+    // prettier-ignore
+    return backend_core_1.auth.joiValidator.body(queryValidation());
+}
+exports.generateQueryValidation = generateQueryValidation;
+function generateQueryPreviewValidation() {
+    // prettier-ignore
+    return backend_core_1.auth.joiValidator.body(joi_1.default.object({
+        _id: OPTIONAL_STRING,
+        _rev: OPTIONAL_STRING,
+        readable: joi_1.default.boolean().optional(),
+        fields: joi_1.default.object().required(),
+        queryVerb: joi_1.default.string().required(),
+        name: OPTIONAL_STRING,
+        flags: joi_1.default.object().optional(),
+        schema: joi_1.default.object().optional(),
+        extra: joi_1.default.object().optional(),
+        datasourceId: joi_1.default.string().required(),
+        transformer: OPTIONAL_STRING,
+        parameters: joi_1.default.object({}).required().unknown(true),
+        queryId: OPTIONAL_STRING,
+    }).unknown(true));
+}
+exports.generateQueryPreviewValidation = generateQueryPreviewValidation;

package/dist/api/controllers/role.js

@@ -0,0 +1,109 @@
+"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.destroy = exports.save = exports.find = exports.fetch = void 0;
+const backend_core_1 = require("@budibase/backend-core");
+const utils_1 = require("../../db/utils");
+const UpdateRolesOptions = {
+    CREATED: "created",
+    REMOVED: "removed",
+};
+function updateRolesOnUserTable(db, roleId, updateOption) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const table = yield db.get(utils_1.InternalTables.USER_METADATA);
+        const schema = table.schema;
+        const remove = updateOption === UpdateRolesOptions.REMOVED;
+        let updated = false;
+        for (let prop of Object.keys(schema)) {
+            if (prop === "roleId") {
+                updated = true;
+                const constraints = schema[prop].constraints;
+                const indexOf = constraints.inclusion.indexOf(roleId);
+                if (remove && indexOf !== -1) {
+                    constraints.inclusion.splice(indexOf, 1);
+                }
+                else if (!remove && indexOf === -1) {
+                    constraints.inclusion.push(roleId);
+                }
+                break;
+            }
+        }
+        if (updated) {
+            yield db.put(table);
+        }
+    });
+}
+function fetch(ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        ctx.body = yield backend_core_1.roles.getAllRoles();
+    });
+}
+exports.fetch = fetch;
+function find(ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        ctx.body = yield backend_core_1.roles.getRole(ctx.params.roleId);
+    });
+}
+exports.find = find;
+function save(ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const db = backend_core_1.context.getAppDB();
+        let { _id, name, inherits, permissionId } = ctx.request.body;
+        let isCreate = false;
+        if (!_id) {
+            _id = (0, utils_1.generateRoleID)();
+            isCreate = true;
+        }
+        else if (backend_core_1.roles.isBuiltin(_id)) {
+            ctx.throw(400, "Cannot update builtin roles.");
+        }
+        const role = new backend_core_1.roles.Role(_id, name, permissionId).addInheritance(inherits);
+        if (ctx.request.body._rev) {
+            role._rev = ctx.request.body._rev;
+        }
+        const result = yield db.put(role);
+        if (isCreate) {
+            yield backend_core_1.events.role.created(role);
+        }
+        else {
+            yield backend_core_1.events.role.updated(role);
+        }
+        yield updateRolesOnUserTable(db, _id, UpdateRolesOptions.CREATED);
+        role._rev = result.rev;
+        ctx.body = role;
+        ctx.message = `Role '${role.name}' created successfully.`;
+    });
+}
+exports.save = save;
+function destroy(ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const db = backend_core_1.context.getAppDB();
+        const roleId = ctx.params.roleId;
+        const role = yield db.get(roleId);
+        if (backend_core_1.roles.isBuiltin(roleId)) {
+            ctx.throw(400, "Cannot delete builtin role.");
+        }
+        // first check no users actively attached to role
+        const users = (yield db.allDocs((0, utils_1.getUserMetadataParams)(undefined, {
+            include_docs: true,
+        }))).rows.map(row => row.doc);
+        const usersWithRole = users.filter(user => user.roleId === roleId);
+        if (usersWithRole.length !== 0) {
+            ctx.throw(400, "Cannot delete role when it is in use.");
+        }
+        yield db.remove(roleId, ctx.params.rev);
+        yield backend_core_1.events.role.deleted(role);
+        yield updateRolesOnUserTable(db, ctx.params.roleId, UpdateRolesOptions.REMOVED);
+        ctx.message = `Role ${ctx.params.roleId} deleted successfully`;
+        ctx.status = 200;
+    });
+}
+exports.destroy = destroy;

package/dist/api/controllers/routing.js

@@ -0,0 +1,105 @@
+"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.clientFetch = exports.fetch = void 0;
+const routing_1 = require("../../utilities/routing");
+const backend_core_1 = require("@budibase/backend-core");
+const URL_SEPARATOR = "/";
+class Routing {
+    constructor() {
+        this.json = {};
+    }
+    getTopLevel(fullpath) {
+        if (fullpath.charAt(0) !== URL_SEPARATOR) {
+            fullpath = URL_SEPARATOR + fullpath;
+        }
+        // replace the first value with the home route
+        return URL_SEPARATOR + fullpath.split(URL_SEPARATOR)[1];
+    }
+    getScreensProp(fullpath) {
+        const topLevel = this.getTopLevel(fullpath);
+        if (!this.json[topLevel]) {
+            this.json[topLevel] = {
+                subpaths: {},
+            };
+        }
+        if (!this.json[topLevel].subpaths[fullpath]) {
+            this.json[topLevel].subpaths[fullpath] = {
+                screens: {},
+            };
+        }
+        return this.json[topLevel].subpaths[fullpath].screens;
+    }
+    addScreenId(fullpath, roleId, screenId) {
+        this.getScreensProp(fullpath)[roleId] = screenId;
+    }
+}
+/**
+ * Gets the full routing structure by querying the routing view and processing the result into the tree.
+ * @returns {Promise<object>} The routing structure, this is the full structure designed for use in the builder,
+ * if the client routing is required then the updateRoutingStructureForUserRole should be used.
+ */
+function getRoutingStructure() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const screenRoutes = yield (0, routing_1.getRoutingInfo)();
+        const routing = new Routing();
+        for (let screenRoute of screenRoutes) {
+            let fullpath = screenRoute.routing.route;
+            const roleId = screenRoute.routing.roleId;
+            routing.addScreenId(fullpath, roleId, screenRoute.id);
+        }
+        return { routes: routing.json };
+    });
+}
+function fetch(ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        ctx.body = yield getRoutingStructure();
+    });
+}
+exports.fetch = fetch;
+function clientFetch(ctx) {
+    var _a, _b;
+    return __awaiter(this, void 0, void 0, function* () {
+        const routing = yield getRoutingStructure();
+        let roleId = (_b = (_a = ctx.user) === null || _a === void 0 ? void 0 : _a.role) === null || _b === void 0 ? void 0 : _b._id;
+        const roleIds = (yield backend_core_1.roles.getUserRoleHierarchy(roleId, {
+            idOnly: true,
+        }));
+        for (let topLevel of Object.values(routing.routes)) {
+            for (let subpathKey of Object.keys(topLevel.subpaths)) {
+                let found = false;
+                const subpath = topLevel.subpaths[subpathKey];
+                const roleOptions = Object.keys(subpath.screens);
+                if (roleOptions.length === 1 && !roleOptions[0]) {
+                    subpath.screenId = subpath.screens[roleOptions[0]];
+                    subpath.roleId = backend_core_1.roles.BUILTIN_ROLE_IDS.BASIC;
+                    found = true;
+                }
+                else {
+                    for (let roleId of roleIds) {
+                        if (roleId && roleOptions.indexOf(roleId) !== -1) {
+                            subpath.screenId = subpath.screens[roleId];
+                            subpath.roleId = roleId;
+                            found = true;
+                            break;
+                        }
+                    }
+                }
+                delete subpath.screens;
+                if (!found) {
+                    delete topLevel.subpaths[subpathKey];
+                }
+            }
+        }
+        ctx.body = routing;
+    });
+}
+exports.clientFetch = clientFetch;