@budibase/server 1.0.32 → 1.0.39

package/dist/integrations/rest.js

@@ -10,18 +10,57 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const datasource_1 = require("../definitions/datasource");
+const BodyTypes = {
+    NONE: "none",
+    FORM_DATA: "form",
+    XML: "xml",
+    ENCODED: "encoded",
+    JSON: "json",
+    TEXT: "text",
+};
+const coreFields = {
+    path: {
+        type: datasource_1.DatasourceFieldTypes.STRING,
+        display: "URL",
+    },
+    queryString: {
+        type: datasource_1.DatasourceFieldTypes.STRING,
+    },
+    headers: {
+        type: datasource_1.DatasourceFieldTypes.OBJECT,
+    },
+    enabledHeaders: {
+        type: datasource_1.DatasourceFieldTypes.OBJECT,
+    },
+    requestBody: {
+        type: datasource_1.DatasourceFieldTypes.JSON,
+    },
+    bodyType: {
+        type: datasource_1.DatasourceFieldTypes.STRING,
+        enum: Object.values(BodyTypes),
+    },
+    pagination: {
+        type: datasource_1.DatasourceFieldTypes.OBJECT,
+    },
+};
 var RestModule;
 (function (RestModule) {
     const fetch = require("node-fetch");
+    const { formatBytes } = require("../utilities");
+    const { performance } = require("perf_hooks");
+    const FormData = require("form-data");
+    const { URLSearchParams } = require("url");
+    const { parseStringPromise: xmlParser, Builder: XmlBuilder, } = require("xml2js");
     const SCHEMA = {
         docs: "https://github.com/node-fetch/node-fetch",
-        description: "Representational state transfer (REST) is a de-facto standard for a software architecture for interactive applications that typically use multiple Web services. ",
+        description: "With the REST API datasource, you can connect, query and pull data from multiple REST APIs. You can then use the retrieved data to build apps.",
         friendlyName: "REST API",
         datasource: {
             url: {
                 type: datasource_1.DatasourceFieldTypes.STRING,
-                default: "localhost",
-                required: true,
+                default: "",
+                required: false,
+                deprecated: true,
             },
             defaultHeaders: {
                 type: datasource_1.DatasourceFieldTypes.OBJECT,
@@ -34,174 +73,274 @@ var RestModule;
                 readable: true,
                 displayName: "POST",
                 type: datasource_1.QueryTypes.FIELDS,
-                urlDisplay: true,
-                fields: {
-                    path: {
-                        type: datasource_1.DatasourceFieldTypes.STRING,
-                    },
-                    queryString: {
-                        type: datasource_1.DatasourceFieldTypes.STRING,
-                    },
-                    headers: {
-                        type: datasource_1.DatasourceFieldTypes.OBJECT,
-                    },
-                    requestBody: {
-                        type: datasource_1.DatasourceFieldTypes.JSON,
-                    },
-                },
+                fields: coreFields,
             },
             read: {
                 displayName: "GET",
                 readable: true,
                 type: datasource_1.QueryTypes.FIELDS,
-                urlDisplay: true,
-                fields: {
-                    path: {
-                        type: datasource_1.DatasourceFieldTypes.STRING,
-                    },
-                    queryString: {
-                        type: datasource_1.DatasourceFieldTypes.STRING,
-                    },
-                    headers: {
-                        type: datasource_1.DatasourceFieldTypes.OBJECT,
-                    },
-                },
+                fields: coreFields,
             },
             update: {
                 displayName: "PUT",
                 readable: true,
                 type: datasource_1.QueryTypes.FIELDS,
-                urlDisplay: true,
-                fields: {
-                    path: {
-                        type: datasource_1.DatasourceFieldTypes.STRING,
-                    },
-                    queryString: {
-                        type: datasource_1.DatasourceFieldTypes.STRING,
-                    },
-                    headers: {
-                        type: datasource_1.DatasourceFieldTypes.OBJECT,
-                    },
-                    requestBody: {
-                        type: datasource_1.DatasourceFieldTypes.JSON,
-                    },
-                },
+                fields: coreFields,
             },
             patch: {
                 displayName: "PATCH",
                 readable: true,
                 type: datasource_1.QueryTypes.FIELDS,
-                urlDisplay: true,
-                fields: {
-                    path: {
-                        type: datasource_1.DatasourceFieldTypes.STRING,
-                    },
-                    queryString: {
-                        type: datasource_1.DatasourceFieldTypes.STRING,
-                    },
-                    headers: {
-                        type: datasource_1.DatasourceFieldTypes.OBJECT,
-                    },
-                    requestBody: {
-                        type: datasource_1.DatasourceFieldTypes.JSON,
-                    },
-                },
+                fields: coreFields,
             },
             delete: {
                 displayName: "DELETE",
                 type: datasource_1.QueryTypes.FIELDS,
-                urlDisplay: true,
-                fields: {
-                    path: {
-                        type: datasource_1.DatasourceFieldTypes.STRING,
-                    },
-                    queryString: {
-                        type: datasource_1.DatasourceFieldTypes.STRING,
-                    },
-                    headers: {
-                        type: datasource_1.DatasourceFieldTypes.OBJECT,
-                    },
-                    requestBody: {
-                        type: datasource_1.DatasourceFieldTypes.JSON,
-                    },
-                },
+                fields: coreFields,
             },
         },
     };
     class RestIntegration {
         constructor(config) {
             this.headers = {};
+            this.startTimeMs = performance.now();
             this.config = config;
         }
-        parseResponse(response) {
+        parseResponse(response, pagination) {
             return __awaiter(this, void 0, void 0, function* () {
-                const contentType = response.headers.get("content-type");
-                if (contentType && contentType.indexOf("application/json") !== -1) {
-                    return yield response.json();
+                let data, raw, headers;
+                const contentType = response.headers.get("content-type") || "";
+                try {
+                    if (contentType.includes("application/json")) {
+                        data = yield response.json();
+                        raw = JSON.stringify(data);
+                    }
+                    else if (contentType.includes("text/xml") ||
+                        contentType.includes("application/xml")) {
+                        const rawXml = yield response.text();
+                        data =
+                            (yield xmlParser(rawXml, {
+                                explicitArray: false,
+                                trim: true,
+                                explicitRoot: false,
+                            })) || {};
+                        // there is only one structure, its an array, return the array so it appears as rows
+                        const keys = Object.keys(data);
+                        if (keys.length === 1 && Array.isArray(data[keys[0]])) {
+                            data = data[keys[0]];
+                        }
+                        raw = rawXml;
+                    }
+                    else {
+                        data = yield response.text();
+                        raw = data;
+                    }
+                }
+                catch (err) {
+                    throw "Failed to parse response body.";
                 }
-                else {
-                    return yield response.text();
+                const size = formatBytes(response.headers.get("content-length") || Buffer.byteLength(raw, "utf8"));
+                const time = `${Math.round(performance.now() - this.startTimeMs)}ms`;
+                headers = response.headers.raw();
+                for (let [key, value] of Object.entries(headers)) {
+                    headers[key] = Array.isArray(value) ? value[0] : value;
                 }
+                // Check if a pagination cursor exists in the response
+                let nextCursor = null;
+                if (pagination === null || pagination === void 0 ? void 0 : pagination.responseParam) {
+                    nextCursor = data === null || data === void 0 ? void 0 : data[pagination.responseParam];
+                }
+                return {
+                    data,
+                    info: {
+                        code: response.status,
+                        size,
+                        time,
+                    },
+                    extra: {
+                        raw,
+                        headers,
+                    },
+                    pagination: {
+                        cursor: nextCursor,
+                    },
+                };
             });
         }
-        getUrl(path, queryString) {
-            return `${this.config.url}/${path}?${queryString}`;
+        getUrl(path, queryString, pagination, paginationValues) {
+            // Add pagination params to query string if required
+            if ((pagination === null || pagination === void 0 ? void 0 : pagination.location) === "query" && paginationValues) {
+                const { pageParam, sizeParam } = pagination;
+                const params = new URLSearchParams();
+                // Append page number or cursor param if configured
+                if (pageParam && paginationValues.page != null) {
+                    params.append(pageParam, paginationValues.page);
+                }
+                // Append page size param if configured
+                if (sizeParam && paginationValues.limit != null) {
+                    params.append(sizeParam, paginationValues.limit);
+                }
+                // Prepend query string with pagination params
+                let paginationString = params.toString();
+                if (paginationString) {
+                    queryString = `${paginationString}&${queryString}`;
+                }
+            }
+            const main = `${path}?${queryString}`;
+            let complete = main;
+            if (this.config.url && !main.startsWith("http")) {
+                complete = !this.config.url ? main : `${this.config.url}/${main}`;
+            }
+            if (!complete.startsWith("http")) {
+                complete = `http://${complete}`;
+            }
+            return complete;
+        }
+        addBody(bodyType, body, input, pagination, paginationValues) {
+            if (!input.headers) {
+                input.headers = {};
+            }
+            if (bodyType === BodyTypes.NONE) {
+                return input;
+            }
+            let error, object = {}, string = "";
+            try {
+                if (body) {
+                    string = typeof body !== "string" ? JSON.stringify(body) : body;
+                    object = typeof body === "object" ? body : JSON.parse(body);
+                }
+            }
+            catch (err) {
+                error = err;
+            }
+            // Util to add pagination values to a certain body type
+            const addPaginationToBody = (insertFn) => {
+                if ((pagination === null || pagination === void 0 ? void 0 : pagination.location) === "body") {
+                    if ((pagination === null || pagination === void 0 ? void 0 : pagination.pageParam) && (paginationValues === null || paginationValues === void 0 ? void 0 : paginationValues.page) != null) {
+                        insertFn(pagination.pageParam, paginationValues.page);
+                    }
+                    if ((pagination === null || pagination === void 0 ? void 0 : pagination.sizeParam) && (paginationValues === null || paginationValues === void 0 ? void 0 : paginationValues.limit) != null) {
+                        insertFn(pagination.sizeParam, paginationValues.limit);
+                    }
+                }
+            };
+            switch (bodyType) {
+                case BodyTypes.TEXT:
+                    // content type defaults to plaintext
+                    input.body = string;
+                    break;
+                case BodyTypes.ENCODED:
+                    const params = new URLSearchParams();
+                    for (let [key, value] of Object.entries(object)) {
+                        params.append(key, value);
+                    }
+                    addPaginationToBody((key, value) => {
+                        params.append(key, value);
+                    });
+                    input.body = params;
+                    break;
+                case BodyTypes.FORM_DATA:
+                    const form = new FormData();
+                    for (let [key, value] of Object.entries(object)) {
+                        form.append(key, value);
+                    }
+                    addPaginationToBody((key, value) => {
+                        form.append(key, value);
+                    });
+                    input.body = form;
+                    break;
+                case BodyTypes.XML:
+                    if (object != null) {
+                        string = new XmlBuilder().buildObject(object);
+                    }
+                    input.body = string;
+                    input.headers["Content-Type"] = "application/xml";
+                    break;
+                case BodyTypes.JSON:
+                    // if JSON error, throw it
+                    if (error) {
+                        throw "Invalid JSON for request body";
+                    }
+                    addPaginationToBody((key, value) => {
+                        object[key] = value;
+                    });
+                    input.body = JSON.stringify(object);
+                    input.headers["Content-Type"] = "application/json";
+                    break;
+            }
+            return input;
+        }
+        getAuthHeaders(authConfigId) {
+            let headers = {};
+            if (this.config.authConfigs && authConfigId) {
+                const authConfig = this.config.authConfigs.filter(c => c._id === authConfigId)[0];
+                // check the config still exists before proceeding
+                // if not - do nothing
+                if (authConfig) {
+                    let config;
+                    switch (authConfig.type) {
+                        case datasource_1.AuthType.BASIC:
+                            config = authConfig.config;
+                            headers.Authorization = `Basic ${Buffer.from(`${config.username}:${config.password}`).toString("base64")}`;
+                            break;
+                        case datasource_1.AuthType.BEARER:
+                            config = authConfig.config;
+                            headers.Authorization = `Bearer ${config.token}`;
+                            break;
+                    }
+                }
+            }
+            return headers;
+        }
+        _req(query) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const { path = "", queryString = "", headers = {}, method = "GET", disabledHeaders, bodyType, requestBody, authConfigId, pagination, paginationValues, } = query;
+                const authHeaders = this.getAuthHeaders(authConfigId);
+                this.headers = Object.assign(Object.assign(Object.assign({}, this.config.defaultHeaders), headers), authHeaders);
+                if (disabledHeaders) {
+                    for (let headerKey of Object.keys(this.headers)) {
+                        if (disabledHeaders[headerKey]) {
+                            delete this.headers[headerKey];
+                        }
+                    }
+                }
+                let input = { method, headers: this.headers };
+                input = this.addBody(bodyType, requestBody, input, pagination, paginationValues);
+                this.startTimeMs = performance.now();
+                const url = this.getUrl(path, queryString, pagination, paginationValues);
+                const response = yield fetch(url, input);
+                return yield this.parseResponse(response, pagination);
+            });
         }
-        create({ path = "", queryString = "", headers = {}, json = {} }) {
+        create(opts) {
             return __awaiter(this, void 0, void 0, function* () {
-                this.headers = Object.assign(Object.assign({}, this.config.defaultHeaders), headers);
-                const response = yield fetch(this.getUrl(path, queryString), {
-                    method: "POST",
-                    headers: this.headers,
-                    body: JSON.stringify(json),
-                });
-                return yield this.parseResponse(response);
+                return this._req(Object.assign(Object.assign({}, opts), { method: "POST" }));
             });
         }
-        read({ path = "", queryString = "", headers = {} }) {
+        read(opts) {
             return __awaiter(this, void 0, void 0, function* () {
-                this.headers = Object.assign(Object.assign({}, this.config.defaultHeaders), headers);
-                const response = yield fetch(this.getUrl(path, queryString), {
-                    headers: this.headers,
-                });
-                return yield this.parseResponse(response);
+                return this._req(Object.assign(Object.assign({}, opts), { method: "GET" }));
             });
         }
-        update({ path = "", queryString = "", headers = {}, json = {} }) {
+        update(opts) {
             return __awaiter(this, void 0, void 0, function* () {
-                this.headers = Object.assign(Object.assign({}, this.config.defaultHeaders), headers);
-                const response = yield fetch(this.getUrl(path, queryString), {
-                    method: "PUT",
-                    headers: this.headers,
-                    body: JSON.stringify(json),
-                });
-                return yield this.parseResponse(response);
+                return this._req(Object.assign(Object.assign({}, opts), { method: "PUT" }));
             });
         }
-        patch({ path = "", queryString = "", headers = {}, json = {} }) {
+        patch(opts) {
             return __awaiter(this, void 0, void 0, function* () {
-                this.headers = Object.assign(Object.assign({}, this.config.defaultHeaders), headers);
-                const response = yield fetch(this.getUrl(path, queryString), {
-                    method: "PATCH",
-                    headers: this.headers,
-                    body: JSON.stringify(json),
-                });
-                return yield this.parseResponse(response);
+                return this._req(Object.assign(Object.assign({}, opts), { method: "PATCH" }));
             });
         }
-        delete({ path = "", queryString = "", headers = {} }) {
+        delete(opts) {
             return __awaiter(this, void 0, void 0, function* () {
-                this.headers = Object.assign(Object.assign({}, this.config.defaultHeaders), headers);
-                const response = yield fetch(this.getUrl(path, queryString), {
-                    method: "DELETE",
-                    headers: this.headers,
-                });
-                return yield this.parseResponse(response);
+                return this._req(Object.assign(Object.assign({}, opts), { method: "DELETE" }));
             });
         }
     }
     module.exports = {
         schema: SCHEMA,
         integration: RestIntegration,
+        AuthType: datasource_1.AuthType,
     };
 })(RestModule || (RestModule = {}));

package/dist/integrations/s3.js

@@ -20,7 +20,7 @@ var S3Module;
         datasource: {
             region: {
                 type: "string",
-                required: true,
+                required: false,
                 default: "us-east-1",
             },
             accessKeyId: {
@@ -31,6 +31,15 @@ var S3Module;
                 type: "password",
                 required: true,
             },
+            endpoint: {
+                type: "string",
+                required: false,
+            },
+            signatureVersion: {
+                type: "string",
+                required: false,
+                default: "v4"
+            },
         },
         query: {
             read: {
@@ -47,13 +56,13 @@ var S3Module;
     class S3Integration {
         constructor(config) {
             this.config = config;
-            this.connectionPromise = this.connect();
-            this.client = new AWS.S3();
-        }
-        connect() {
-            return __awaiter(this, void 0, void 0, function* () {
-                AWS.config.update(this.config);
-            });
+            if (this.config.endpoint) {
+                this.config.s3ForcePathStyle = true;
+            }
+            else {
+                delete this.config.endpoint;
+            }
+            this.client = new AWS.S3(this.config);
         }
         read(query) {
             return __awaiter(this, void 0, void 0, function* () {

package/dist/integrations/utils.js

@@ -2,39 +2,39 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.finaliseExternalTables = exports.isIsoDateString = exports.isSQL = exports.getSqlQuery = exports.convertSqlType = exports.breakRowIdField = exports.convertRowId = exports.isRowId = exports.generateRowIdField = exports.breakExternalTableId = exports.buildExternalTableId = exports.isExternalTable = exports.SqlClients = void 0;
 const datasource_1 = require("../definitions/datasource");
-const { DocumentTypes, SEPARATOR } = require("../db/utils");
-const { FieldTypes, BuildSchemaErrors, InvalidColumns, } = require("../constants");
-const DOUBLE_SEPARATOR = `${SEPARATOR}${SEPARATOR}`;
+const utils_1 = require("../db/utils");
+const constants_1 = require("../constants");
+const DOUBLE_SEPARATOR = `${utils_1.SEPARATOR}${utils_1.SEPARATOR}`;
 const ROW_ID_REGEX = /^\[.*]$/g;
 const SQL_TYPE_MAP = {
-    text: FieldTypes.LONGFORM,
-    varchar: FieldTypes.STRING,
-    integer: FieldTypes.NUMBER,
-    bigint: FieldTypes.NUMBER,
-    decimal: FieldTypes.NUMBER,
-    smallint: FieldTypes.NUMBER,
-    real: FieldTypes.NUMBER,
-    "double precision": FieldTypes.NUMBER,
-    timestamp: FieldTypes.DATETIME,
-    time: FieldTypes.DATETIME,
-    boolean: FieldTypes.BOOLEAN,
-    json: FieldTypes.JSON,
-    date: FieldTypes.DATETIME,
-    blob: FieldTypes.LONGFORM,
-    enum: FieldTypes.STRING,
-    float: FieldTypes.NUMBER,
-    int: FieldTypes.NUMBER,
-    numeric: FieldTypes.NUMBER,
-    mediumint: FieldTypes.NUMBER,
-    dec: FieldTypes.NUMBER,
-    double: FieldTypes.NUMBER,
-    fixed: FieldTypes.NUMBER,
-    datetime: FieldTypes.DATETIME,
-    tinyint: FieldTypes.BOOLEAN,
-    long: FieldTypes.LONGFORM,
-    number: FieldTypes.NUMBER,
-    binary_float: FieldTypes.NUMBER,
-    binary_double: FieldTypes.NUMBER,
+    text: constants_1.FieldTypes.LONGFORM,
+    varchar: constants_1.FieldTypes.STRING,
+    integer: constants_1.FieldTypes.NUMBER,
+    bigint: constants_1.FieldTypes.NUMBER,
+    decimal: constants_1.FieldTypes.NUMBER,
+    smallint: constants_1.FieldTypes.NUMBER,
+    real: constants_1.FieldTypes.NUMBER,
+    "double precision": constants_1.FieldTypes.NUMBER,
+    timestamp: constants_1.FieldTypes.DATETIME,
+    time: constants_1.FieldTypes.DATETIME,
+    boolean: constants_1.FieldTypes.BOOLEAN,
+    json: constants_1.FieldTypes.JSON,
+    date: constants_1.FieldTypes.DATETIME,
+    blob: constants_1.FieldTypes.LONGFORM,
+    enum: constants_1.FieldTypes.STRING,
+    float: constants_1.FieldTypes.NUMBER,
+    int: constants_1.FieldTypes.NUMBER,
+    numeric: constants_1.FieldTypes.NUMBER,
+    mediumint: constants_1.FieldTypes.NUMBER,
+    dec: constants_1.FieldTypes.NUMBER,
+    double: constants_1.FieldTypes.NUMBER,
+    fixed: constants_1.FieldTypes.NUMBER,
+    datetime: constants_1.FieldTypes.DATETIME,
+    tinyint: constants_1.FieldTypes.BOOLEAN,
+    long: constants_1.FieldTypes.LONGFORM,
+    number: constants_1.FieldTypes.NUMBER,
+    binary_float: constants_1.FieldTypes.NUMBER,
+    binary_double: constants_1.FieldTypes.NUMBER,
 };
 var SqlClients;
 (function (SqlClients) {
@@ -44,7 +44,7 @@ var SqlClients;
     SqlClients["ORACLE"] = "oracledb";
 })(SqlClients = exports.SqlClients || (exports.SqlClients = {}));
 function isExternalTable(tableId) {
-    return tableId.includes(DocumentTypes.DATASOURCE);
+    return tableId.includes(utils_1.DocumentTypes.DATASOURCE);
 }
 exports.isExternalTable = isExternalTable;
 function buildExternalTableId(datasourceId, tableName) {
@@ -109,7 +109,7 @@ function convertSqlType(type) {
             return internal;
         }
     }
-    return FieldTypes.STRING;
+    return constants_1.FieldTypes.STRING;
 }
 exports.convertSqlType = convertSqlType;
 function getSqlQuery(query) {
@@ -148,7 +148,10 @@ function copyExistingPropsOver(tableName, table, entities) {
             if (!existingTableSchema.hasOwnProperty(key)) {
                 continue;
             }
-            if (existingTableSchema[key].type === "link") {
+            if (existingTableSchema[key].type === constants_1.FieldTypes.LINK ||
+                existingTableSchema[key].type === constants_1.FieldTypes.OPTIONS ||
+                ((!table.schema[key] || table.schema[key].type === constants_1.FieldTypes.NUMBER) &&
+                    existingTableSchema[key].type === constants_1.FieldTypes.BOOLEAN)) {
                 table.schema[key] = existingTableSchema[key];
             }
         }
@@ -156,18 +159,18 @@ function copyExistingPropsOver(tableName, table, entities) {
     return table;
 }
 function finaliseExternalTables(tables, entities) {
-    const invalidColumns = Object.values(InvalidColumns);
+    const invalidColumns = Object.values(constants_1.InvalidColumns);
     let finalTables = {};
     const errors = {};
     for (let [name, table] of Object.entries(tables)) {
         const schemaFields = Object.keys(table.schema);
         // make sure every table has a key
         if (table.primary == null || table.primary.length === 0) {
-            errors[name] = BuildSchemaErrors.NO_KEY;
+            errors[name] = constants_1.BuildSchemaErrors.NO_KEY;
             continue;
         }
         else if (schemaFields.find(field => invalidColumns.includes(field))) {
-            errors[name] = BuildSchemaErrors.INVALID_COLUMN;
+            errors[name] = constants_1.BuildSchemaErrors.INVALID_COLUMN;
             continue;
         }
         // make sure all previous props have been added back

package/dist/middleware/authorized.js

@@ -8,8 +8,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-const { getUserRoleHierarchy, getRequiredResourceRole, BUILTIN_ROLE_IDS, } = require("@budibase/auth/roles");
-const { PermissionTypes, doesHaveBasePermission, } = require("@budibase/auth/permissions");
+const { getUserRoleHierarchy, getRequiredResourceRole, BUILTIN_ROLE_IDS, } = require("@budibase/backend-core/roles");
+const { PermissionTypes, doesHaveBasePermission, } = require("@budibase/backend-core/permissions");
 const builderMiddleware = require("./builder");
 const { isWebhookEndpoint } = require("./utils");
 function hasResource(ctx) {

package/dist/middleware/builder.js

@@ -12,8 +12,8 @@ const { APP_DEV_PREFIX } = require("../db/utils");
 const { doesUserHaveLock, updateLock, checkDebounce, setDebounce, } = require("../utilities/redis");
 const CouchDB = require("../db");
 const { DocumentTypes } = require("../db/utils");
-const { PermissionTypes } = require("@budibase/auth/permissions");
-const { app: appCache } = require("@budibase/auth/cache");
+const { PermissionTypes } = require("@budibase/backend-core/permissions");
+const { app: appCache } = require("@budibase/backend-core/cache");
 const DEBOUNCE_TIME_SEC = 30;
 /************************************************** *
  * This middleware has been broken out of the       *

package/dist/middleware/currentapp.js

@@ -8,13 +8,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-const { getAppId, setCookie, getCookie, clearCookie } = require("@budibase/auth").utils;
-const { Cookies } = require("@budibase/auth").constants;
-const { getRole } = require("@budibase/auth/roles");
-const { BUILTIN_ROLE_IDS } = require("@budibase/auth/roles");
+const { getAppId, setCookie, getCookie, clearCookie, } = require("@budibase/backend-core/utils");
+const { Cookies } = require("@budibase/backend-core/constants");
+const { getRole } = require("@budibase/backend-core/roles");
+const { BUILTIN_ROLE_IDS } = require("@budibase/backend-core/roles");
 const { generateUserMetadataID, isDevAppID } = require("../db/utils");
-const { dbExists } = require("@budibase/auth/db");
-const { isUserInAppTenant } = require("@budibase/auth/tenancy");
+const { dbExists } = require("@budibase/backend-core/db");
+const { isUserInAppTenant } = require("@budibase/backend-core/tenancy");
 const { getCachedSelf } = require("../utilities/global");
 const CouchDB = require("../db");
 const env = require("../environment");