@budibase/server 2.1.32-alpha.8 → 2.1.32

package/dist/utilities/rowProcessor/index.js

@@ -1,18 +1,4 @@
 "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 __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 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) {
@@ -22,22 +8,111 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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.cleanupAttachments = exports.outputProcessing = exports.inputProcessing = exports.coerce = exports.processAutoColumn = void 0;
-const linkedRows_1 = __importDefault(require("../../db/linkedRows"));
-const constants_1 = require("../../constants");
-const index_1 = require("../index");
-const utils_1 = require("./utils");
-const constants_2 = require("../../constants");
-const backend_core_1 = require("@budibase/backend-core");
-const utils_2 = require("../../db/utils");
-const map_1 = require("./map");
+const linkRows = require("../../db/linkedRows");
 const { cloneDeep } = require("lodash/fp");
-__exportStar(require("./utils"), exports);
+const { FieldTypes, AutoFieldSubTypes } = require("../../constants");
+const { attachmentsRelativeURL } = require("../index");
+const { processFormulas, fixAutoColumnSubType } = require("./utils");
+const { deleteFiles } = require("../../utilities/fileSystem/utilities");
+const { ObjectStoreBuckets } = require("../../constants");
+const { isProdAppID, getProdAppID, dbExists, } = require("@budibase/backend-core/db");
+const { getAppId } = require("@budibase/backend-core/context");
+const { InternalTables } = require("../../db/utils");
 const BASE_AUTO_ID = 1;
+/**
+ * A map of how we convert various properties in rows to each other based on the row type.
+ */
+const TYPE_TRANSFORM_MAP = {
+    [FieldTypes.LINK]: {
+        "": [],
+        [null]: [],
+        [undefined]: undefined,
+        parse: link => {
+            if (Array.isArray(link) && typeof link[0] === "object") {
+                return link.map(el => (el && el._id ? el._id : el));
+            }
+            if (typeof link === "string") {
+                return [link];
+            }
+            return link;
+        },
+    },
+    [FieldTypes.OPTIONS]: {
+        "": null,
+        [null]: null,
+        [undefined]: undefined,
+    },
+    [FieldTypes.ARRAY]: {
+        "": [],
+        [null]: [],
+        [undefined]: undefined,
+    },
+    [FieldTypes.STRING]: {
+        "": "",
+        [null]: "",
+        [undefined]: undefined,
+    },
+    [FieldTypes.BARCODEQR]: {
+        "": "",
+        [null]: "",
+        [undefined]: undefined,
+    },
+    [FieldTypes.FORMULA]: {
+        "": "",
+        [null]: "",
+        [undefined]: undefined,
+    },
+    [FieldTypes.LONGFORM]: {
+        "": "",
+        [null]: "",
+        [undefined]: undefined,
+    },
+    [FieldTypes.NUMBER]: {
+        "": null,
+        [null]: null,
+        [undefined]: undefined,
+        parse: n => parseFloat(n),
+    },
+    [FieldTypes.DATETIME]: {
+        "": null,
+        [undefined]: undefined,
+        [null]: null,
+        parse: date => {
+            if (date instanceof Date) {
+                return date.toISOString();
+            }
+            return date;
+        },
+    },
+    [FieldTypes.ATTACHMENT]: {
+        "": [],
+        [null]: [],
+        [undefined]: undefined,
+    },
+    [FieldTypes.BOOLEAN]: {
+        "": null,
+        [null]: null,
+        [undefined]: undefined,
+        true: true,
+        false: false,
+    },
+    [FieldTypes.AUTO]: {
+        parse: () => undefined,
+    },
+    [FieldTypes.JSON]: {
+        parse: input => {
+            try {
+                if (input === "") {
+                    return undefined;
+                }
+                return JSON.parse(input);
+            }
+            catch (err) {
+                return input;
+            }
+        },
+    },
+};
 /**
  * Given the old state of the row and the new one after an update, this will
  * find the keys that have been removed in the updated row.
@@ -46,13 +121,13 @@ function getRemovedAttachmentKeys(oldRow, row, attachmentKey) {
     if (!oldRow[attachmentKey]) {
         return [];
     }
-    const oldKeys = oldRow[attachmentKey].map((attachment) => attachment.key);
+    const oldKeys = oldRow[attachmentKey].map(attachment => attachment.key);
     // no attachments in new row, all removed
     if (!row[attachmentKey]) {
         return oldKeys;
     }
-    const newKeys = row[attachmentKey].map((attachment) => attachment.key);
-    return oldKeys.filter((key) => newKeys.indexOf(key) === -1);
+    const newKeys = row[attachmentKey].map(attachment => attachment.key);
+    return oldKeys.filter(key => newKeys.indexOf(key) === -1);
 }
 /**
  * This will update any auto columns that are found on the row/table with the correct information based on
@@ -64,41 +139,41 @@ function getRemovedAttachmentKeys(oldRow, row, attachmentKey) {
  * @returns {{row: Object, table: Object}} The updated row and table, the table may need to be updated
  * for automatic ID purposes.
  */
-function processAutoColumn(user, table, row, opts) {
+function processAutoColumn(user, table, row, opts = { reprocessing: false, noAutoRelationships: false }) {
     let noUser = !user || !user.userId;
-    let isUserTable = table._id === utils_2.InternalTables.USER_METADATA;
+    let isUserTable = table._id === InternalTables.USER_METADATA;
     let now = new Date().toISOString();
     // if a row doesn't have a revision then it doesn't exist yet
     const creating = !row._rev;
     // check its not user table, or whether any of the processing options have been disabled
-    const shouldUpdateUserFields = !isUserTable && !(opts === null || opts === void 0 ? void 0 : opts.reprocessing) && !(opts === null || opts === void 0 ? void 0 : opts.noAutoRelationships) && !noUser;
+    const shouldUpdateUserFields = !isUserTable && !opts.reprocessing && !opts.noAutoRelationships && !noUser;
     for (let [key, schema] of Object.entries(table.schema)) {
         if (!schema.autocolumn) {
             continue;
         }
         if (!schema.subtype) {
-            schema = (0, utils_1.fixAutoColumnSubType)(schema);
+            schema = fixAutoColumnSubType(schema);
         }
         switch (schema.subtype) {
-            case constants_1.AutoFieldSubTypes.CREATED_BY:
-                if (creating && shouldUpdateUserFields && user) {
+            case AutoFieldSubTypes.CREATED_BY:
+                if (creating && shouldUpdateUserFields) {
                     row[key] = [user.userId];
                 }
                 break;
-            case constants_1.AutoFieldSubTypes.CREATED_AT:
+            case AutoFieldSubTypes.CREATED_AT:
                 if (creating) {
                     row[key] = now;
                 }
                 break;
-            case constants_1.AutoFieldSubTypes.UPDATED_BY:
-                if (shouldUpdateUserFields && user) {
+            case AutoFieldSubTypes.UPDATED_BY:
+                if (shouldUpdateUserFields) {
                     row[key] = [user.userId];
                 }
                 break;
-            case constants_1.AutoFieldSubTypes.UPDATED_AT:
+            case AutoFieldSubTypes.UPDATED_AT:
                 row[key] = now;
                 break;
-            case constants_1.AutoFieldSubTypes.AUTO_ID:
+            case AutoFieldSubTypes.AUTO_ID:
                 if (creating) {
                     schema.lastID = !schema.lastID ? BASE_AUTO_ID : schema.lastID + 1;
                     row[key] = schema.lastID;
@@ -109,29 +184,28 @@ function processAutoColumn(user, table, row, opts) {
     return { table, row };
 }
 exports.processAutoColumn = processAutoColumn;
+exports.fixAutoColumnSubType = fixAutoColumnSubType;
+exports.processFormulas = processFormulas;
 /**
  * This will coerce a value to the correct types based on the type transform map
  * @param {object} row The value to coerce
  * @param {object} type The type fo coerce to
  * @returns {object} The coerced value
  */
-function coerce(row, type) {
+exports.coerce = (row, type) => {
     // no coercion specified for type, skip it
-    if (!map_1.TYPE_TRANSFORM_MAP[type]) {
+    if (!TYPE_TRANSFORM_MAP[type]) {
         return row;
     }
     // eslint-disable-next-line no-prototype-builtins
-    if (map_1.TYPE_TRANSFORM_MAP[type].hasOwnProperty(row)) {
-        // @ts-ignore
-        return map_1.TYPE_TRANSFORM_MAP[type][row];
+    if (TYPE_TRANSFORM_MAP[type].hasOwnProperty(row)) {
+        return TYPE_TRANSFORM_MAP[type][row];
     }
-    else if (map_1.TYPE_TRANSFORM_MAP[type].parse) {
-        // @ts-ignore
-        return map_1.TYPE_TRANSFORM_MAP[type].parse(row);
+    else if (TYPE_TRANSFORM_MAP[type].parse) {
+        return TYPE_TRANSFORM_MAP[type].parse(row);
     }
     return row;
-}
-exports.coerce = coerce;
+};
 /**
  * Given an input route this function will apply all the necessary pre-processing to it, such as coercion
  * of column values or adding auto-column values.
@@ -141,7 +215,7 @@ exports.coerce = coerce;
  * @param {object} opts some input processing options (like disabling auto-column relationships).
  * @returns {object} the row which has been prepared to be written to the DB.
  */
-function inputProcessing(user, table, row, opts) {
+exports.inputProcessing = (user = {}, table, row, opts = { noAutoRelationships: false }) => {
     let clonedRow = cloneDeep(row);
     // need to copy the table so it can be differenced on way out
     const copiedTable = cloneDeep(table);
@@ -156,12 +230,12 @@ function inputProcessing(user, table, row, opts) {
             continue;
         }
         // remove any formula values, they are to be generated
-        if (field.type === constants_1.FieldTypes.FORMULA) {
+        if (field.type === FieldTypes.FORMULA) {
             delete clonedRow[key];
         }
         // otherwise coerce what is there to correct types
         else {
-            clonedRow[key] = coerce(value, field.type);
+            clonedRow[key] = exports.coerce(value, field.type);
         }
     }
     if (!clonedRow._id || !clonedRow._rev) {
@@ -170,8 +244,7 @@ function inputProcessing(user, table, row, opts) {
     }
     // handle auto columns - this returns an object like {table, row}
     return processAutoColumn(user, copiedTable, clonedRow, opts);
-}
-exports.inputProcessing = inputProcessing;
+};
 /**
  * This function enriches the input rows with anything they are supposed to contain, for example
  * link records or attachment links.
@@ -181,37 +254,34 @@ exports.inputProcessing = inputProcessing;
  * @param {object} opts used to set some options for the output, such as disabling relationship squashing.
  * @returns {object[]|object} the enriched rows will be returned.
  */
-function outputProcessing(table, rows, opts = { squash: true }) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let wasArray = true;
-        if (!(rows instanceof Array)) {
-            rows = [rows];
-            wasArray = false;
-        }
-        // attach any linked row information
-        let enriched = yield linkedRows_1.default.attachFullLinkedDocs(table, rows);
-        // process formulas
-        enriched = (0, utils_1.processFormulas)(table, enriched, { dynamic: true });
-        // update the attachments URL depending on hosting
-        for (let [property, column] of Object.entries(table.schema)) {
-            if (column.type === constants_1.FieldTypes.ATTACHMENT) {
-                for (let row of enriched) {
-                    if (row[property] == null || !Array.isArray(row[property])) {
-                        continue;
-                    }
-                    row[property].forEach((attachment) => {
-                        attachment.url = (0, index_1.attachmentsRelativeURL)(attachment.key);
-                    });
+exports.outputProcessing = (table, rows, opts = { squash: true }) => __awaiter(void 0, void 0, void 0, function* () {
+    let wasArray = true;
+    if (!(rows instanceof Array)) {
+        rows = [rows];
+        wasArray = false;
+    }
+    // attach any linked row information
+    let enriched = yield linkRows.attachFullLinkedDocs(table, rows);
+    // process formulas
+    enriched = processFormulas(table, enriched, { dynamic: true });
+    // update the attachments URL depending on hosting
+    for (let [property, column] of Object.entries(table.schema)) {
+        if (column.type === FieldTypes.ATTACHMENT) {
+            for (let row of enriched) {
+                if (row[property] == null || !Array.isArray(row[property])) {
+                    continue;
                 }
+                row[property].forEach(attachment => {
+                    attachment.url = attachmentsRelativeURL(attachment.key);
+                });
             }
         }
-        if (opts.squash) {
-            enriched = yield linkedRows_1.default.squashLinksToPrimaryDisplay(table, enriched);
-        }
-        return wasArray ? enriched : enriched[0];
-    });
-}
-exports.outputProcessing = outputProcessing;
+    }
+    if (opts.squash) {
+        enriched = yield linkRows.squashLinksToPrimaryDisplay(table, enriched);
+    }
+    return wasArray ? enriched : enriched[0];
+});
 /**
  * Clean up any attachments that were attached to a row.
  * @param {object} table The table from which a row is being removed.
@@ -222,46 +292,43 @@ exports.outputProcessing = outputProcessing;
  * deleted attachment columns.
  * @return {Promise<void>} When all attachments have been removed this will return.
  */
-function cleanupAttachments(table, { row, rows, oldRow, oldTable, }) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const appId = backend_core_1.context.getAppId();
-        if (!backend_core_1.db.isProdAppID(appId)) {
-            const prodAppId = backend_core_1.db.getProdAppID(appId);
-            // if prod exists, then don't allow deleting
-            const exists = yield backend_core_1.db.dbExists(prodAppId);
-            if (exists) {
-                return;
-            }
+exports.cleanupAttachments = (table, { row, rows, oldRow, oldTable }) => __awaiter(void 0, void 0, void 0, function* () {
+    const appId = getAppId();
+    if (!isProdAppID(appId)) {
+        const prodAppId = getProdAppID(appId);
+        // if prod exists, then don't allow deleting
+        const exists = yield dbExists(prodAppId);
+        if (exists) {
+            return;
         }
-        let files = [];
-        function addFiles(row, key) {
-            if (row[key]) {
-                files = files.concat(row[key].map((attachment) => attachment.key));
-            }
+    }
+    let files = [];
+    function addFiles(row, key) {
+        if (row[key]) {
+            files = files.concat(row[key].map(attachment => attachment.key));
         }
-        const schemaToUse = oldTable ? oldTable.schema : table.schema;
-        for (let [key, schema] of Object.entries(schemaToUse)) {
-            if (schema.type !== constants_1.FieldTypes.ATTACHMENT) {
-                continue;
-            }
-            // old table had this column, new table doesn't - delete it
-            if (rows && oldTable && !table.schema[key]) {
-                rows.forEach(row => addFiles(row, key));
-            }
-            else if (oldRow && row) {
-                // if updating, need to manage the differences
-                files = files.concat(getRemovedAttachmentKeys(oldRow, row, key));
-            }
-            else if (row) {
-                addFiles(row, key);
-            }
-            else if (rows) {
-                rows.forEach(row => addFiles(row, key));
-            }
+    }
+    const schemaToUse = oldTable ? oldTable.schema : table.schema;
+    for (let [key, schema] of Object.entries(schemaToUse)) {
+        if (schema.type !== FieldTypes.ATTACHMENT) {
+            continue;
         }
-        if (files.length > 0) {
-            return backend_core_1.objectStore.deleteFiles(constants_2.ObjectStoreBuckets.APPS, files);
+        // old table had this column, new table doesn't - delete it
+        if (oldTable && !table.schema[key]) {
+            rows.forEach(row => addFiles(row, key));
         }
-    });
-}
-exports.cleanupAttachments = cleanupAttachments;
+        else if (oldRow && row) {
+            // if updating, need to manage the differences
+            files = files.concat(getRemovedAttachmentKeys(oldRow, row, key));
+        }
+        else if (row) {
+            addFiles(row, key);
+        }
+        else if (rows) {
+            rows.forEach(row => addFiles(row, key));
+        }
+    }
+    if (files.length > 0) {
+        return deleteFiles(ObjectStoreBuckets.APPS, files);
+    }
+});

package/dist/utilities/rowProcessor/utils.js

@@ -1,75 +1,67 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.processDates = exports.processFormulas = exports.fixAutoColumnSubType = void 0;
-const constants_1 = require("../../constants");
-const string_templates_1 = require("@budibase/string-templates");
+const { FieldTypes, FormulaTypes, AutoFieldDefaultNames, AutoFieldSubTypes, } = require("../../constants");
+const { processStringSync } = require("@budibase/string-templates");
 /**
  * If the subtype has been lost for any reason this works out what
  * subtype the auto column should be.
  */
-function fixAutoColumnSubType(column) {
+exports.fixAutoColumnSubType = column => {
     if (!column.autocolumn || !column.name || column.subtype) {
         return column;
     }
     // the columns which get auto generated
-    if (column.name.endsWith(constants_1.AutoFieldDefaultNames.CREATED_BY)) {
-        column.subtype = constants_1.AutoFieldSubTypes.CREATED_BY;
+    if (column.name.endsWith(AutoFieldDefaultNames.CREATED_BY)) {
+        column.subtype = AutoFieldSubTypes.CREATED_BY;
     }
-    else if (column.name.endsWith(constants_1.AutoFieldDefaultNames.UPDATED_BY)) {
-        column.subtype = constants_1.AutoFieldSubTypes.UPDATED_BY;
+    else if (column.name.endsWith(AutoFieldDefaultNames.UPDATED_BY)) {
+        column.subtype = AutoFieldSubTypes.UPDATED_BY;
     }
-    else if (column.name.endsWith(constants_1.AutoFieldDefaultNames.CREATED_AT)) {
-        column.subtype = constants_1.AutoFieldSubTypes.CREATED_AT;
+    else if (column.name.endsWith(AutoFieldDefaultNames.CREATED_AT)) {
+        column.subtype = AutoFieldSubTypes.CREATED_AT;
     }
-    else if (column.name.endsWith(constants_1.AutoFieldDefaultNames.UPDATED_AT)) {
-        column.subtype = constants_1.AutoFieldSubTypes.UPDATED_AT;
+    else if (column.name.endsWith(AutoFieldDefaultNames.UPDATED_AT)) {
+        column.subtype = AutoFieldSubTypes.UPDATED_AT;
     }
-    else if (column.name.endsWith(constants_1.AutoFieldDefaultNames.AUTO_ID)) {
-        column.subtype = constants_1.AutoFieldSubTypes.AUTO_ID;
+    else if (column.name.endsWith(AutoFieldDefaultNames.AUTO_ID)) {
+        column.subtype = AutoFieldSubTypes.AUTO_ID;
     }
     return column;
-}
-exports.fixAutoColumnSubType = fixAutoColumnSubType;
+};
 /**
  * Looks through the rows provided and finds formulas - which it then processes.
  */
-function processFormulas(table, rows, { dynamic, contextRows } = { dynamic: true }) {
+exports.processFormulas = (table, rows, { dynamic, contextRows } = { dynamic: true }) => {
     const single = !Array.isArray(rows);
-    let rowArray;
     if (single) {
-        rowArray = [rows];
+        rows = [rows];
         contextRows = contextRows ? [contextRows] : contextRows;
     }
-    else {
-        rowArray = rows;
-    }
     for (let [column, schema] of Object.entries(table.schema)) {
-        const isStatic = schema.formulaType === constants_1.FormulaTypes.STATIC;
-        if (schema.type !== constants_1.FieldTypes.FORMULA ||
+        const isStatic = schema.formulaType === FormulaTypes.STATIC;
+        if (schema.type !== FieldTypes.FORMULA ||
             (dynamic && isStatic) ||
             (!dynamic && !isStatic)) {
             continue;
         }
         // iterate through rows and process formula
-        for (let i = 0; i < rowArray.length; i++) {
+        for (let i = 0; i < rows.length; i++) {
             if (schema.formula) {
-                let row = rowArray[i];
+                let row = rows[i];
                 let context = contextRows ? contextRows[i] : row;
-                rowArray[i] = Object.assign(Object.assign({}, row), { [column]: (0, string_templates_1.processStringSync)(schema.formula, context) });
+                rows[i] = Object.assign(Object.assign({}, row), { [column]: processStringSync(schema.formula, context) });
             }
         }
     }
-    return single ? rowArray[0] : rowArray;
-}
-exports.processFormulas = processFormulas;
+    return single ? rows[0] : rows;
+};
 /**
  * Processes any date columns and ensures that those without the ignoreTimezones
  * flag set are parsed as UTC rather than local time.
  */
-function processDates(table, rows) {
+exports.processDates = (table, rows) => {
     let datesWithTZ = [];
     for (let [column, schema] of Object.entries(table.schema)) {
-        if (schema.type !== constants_1.FieldTypes.DATETIME) {
+        if (schema.type !== FieldTypes.DATETIME) {
             continue;
         }
         if (!schema.timeOnly && !schema.ignoreTimezones) {
@@ -84,5 +76,4 @@ function processDates(table, rows) {
         }
     }
     return rows;
-}
-exports.processDates = processDates;
+};

package/dist/utilities/security.js

@@ -1,57 +1,53 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getBasePermissions = exports.getPermissionType = exports.CURRENTLY_SUPPORTED_LEVELS = void 0;
-const backend_core_1 = require("@budibase/backend-core");
-const utils_1 = require("../db/utils");
-exports.CURRENTLY_SUPPORTED_LEVELS = [
-    backend_core_1.permissions.PermissionLevel.WRITE,
-    backend_core_1.permissions.PermissionLevel.READ,
-    backend_core_1.permissions.PermissionLevel.EXECUTE,
+const { PermissionLevels, PermissionTypes, getBuiltinPermissionByID, isPermissionLevelHigherThanRead, } = require("@budibase/backend-core/permissions");
+const { lowerBuiltinRoleID, getBuiltinRoles, } = require("@budibase/backend-core/roles");
+const { DocumentType } = require("../db/utils");
+const CURRENTLY_SUPPORTED_LEVELS = [
+    PermissionLevels.WRITE,
+    PermissionLevels.READ,
+    PermissionLevels.EXECUTE,
 ];
-function getPermissionType(resourceId) {
-    const docType = Object.values(utils_1.DocumentType).filter(docType => resourceId.startsWith(docType))[0];
+exports.getPermissionType = resourceId => {
+    const docType = Object.values(DocumentType).filter(docType => resourceId.startsWith(docType))[0];
     switch (docType) {
-        case utils_1.DocumentType.TABLE:
-        case utils_1.DocumentType.ROW:
-            return backend_core_1.permissions.PermissionType.TABLE;
-        case utils_1.DocumentType.AUTOMATION:
-            return backend_core_1.permissions.PermissionType.AUTOMATION;
-        case utils_1.DocumentType.WEBHOOK:
-            return backend_core_1.permissions.PermissionType.WEBHOOK;
-        case utils_1.DocumentType.QUERY:
-        case utils_1.DocumentType.DATASOURCE:
-            return backend_core_1.permissions.PermissionType.QUERY;
+        case DocumentType.TABLE:
+        case DocumentType.ROW:
+            return PermissionTypes.TABLE;
+        case DocumentType.AUTOMATION:
+            return PermissionTypes.AUTOMATION;
+        case DocumentType.WEBHOOK:
+            return PermissionTypes.WEBHOOK;
+        case DocumentType.QUERY:
+        case DocumentType.DATASOURCE:
+            return PermissionTypes.QUERY;
         default:
             // views don't have an ID, will end up here
-            return backend_core_1.permissions.PermissionType.VIEW;
+            return PermissionTypes.VIEW;
     }
-}
-exports.getPermissionType = getPermissionType;
+};
 /**
  *  works out the basic permissions based on builtin roles for a resource, using its ID
+ * @param resourceId
+ * @returns {{}}
  */
-function getBasePermissions(resourceId) {
-    const type = getPermissionType(resourceId);
-    const basePermissions = {};
-    for (let [roleId, role] of Object.entries(backend_core_1.roles.getBuiltinRoles())) {
+exports.getBasePermissions = resourceId => {
+    const type = exports.getPermissionType(resourceId);
+    const permissions = {};
+    for (let [roleId, role] of Object.entries(getBuiltinRoles())) {
         if (!role.permissionId) {
             continue;
         }
-        const perms = backend_core_1.permissions.getBuiltinPermissionByID(role.permissionId);
-        if (!perms) {
-            continue;
-        }
+        const perms = getBuiltinPermissionByID(role.permissionId);
         const typedPermission = perms.permissions.find(perm => perm.type === type);
         if (typedPermission &&
-            exports.CURRENTLY_SUPPORTED_LEVELS.indexOf(typedPermission.level) !== -1) {
+            CURRENTLY_SUPPORTED_LEVELS.indexOf(typedPermission.level) !== -1) {
             const level = typedPermission.level;
-            basePermissions[level] = backend_core_1.roles.lowerBuiltinRoleID(basePermissions[level], roleId);
-            if (backend_core_1.permissions.isPermissionLevelHigherThanRead(level)) {
-                basePermissions[backend_core_1.permissions.PermissionLevel.READ] =
-                    backend_core_1.roles.lowerBuiltinRoleID(basePermissions[backend_core_1.permissions.PermissionLevel.READ], roleId);
+            permissions[level] = lowerBuiltinRoleID(permissions[level], roleId);
+            if (isPermissionLevelHigherThanRead(level)) {
+                permissions[PermissionLevels.READ] = lowerBuiltinRoleID(permissions[PermissionLevels.READ], roleId);
             }
         }
     }
-    return basePermissions;
-}
-exports.getBasePermissions = getBasePermissions;
+    return permissions;
+};
+exports.CURRENTLY_SUPPORTED_LEVELS = CURRENTLY_SUPPORTED_LEVELS;