@budibase/server 1.0.123-alpha.0 → 1.0.123

package/dist/api/controllers/table/utils.js

@@ -8,75 +8,64 @@ 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.TableSaveFunctions = exports.hasTypeChanged = exports.areSwitchableTypes = exports.foreignKeyStructure = exports.generateJunctionTableName = exports.generateForeignKey = exports.checkForViewUpdates = exports.getTable = exports.getExternalTable = exports.getAllExternalTables = exports.getAllInternalTables = exports.checkStaticTables = exports.handleSearchIndexes = exports.handleDataImport = exports.makeSureTableUpToDate = exports.checkForColumnUpdates = exports.clearColumns = void 0;
-const csvParser_1 = require("../../../utilities/csvParser");
-const utils_1 = require("../../../db/utils");
-const lodash_1 = require("lodash");
-const constants_1 = require("../../../constants");
-const rowProcessor_1 = require("../../../utilities/rowProcessor");
-const constants_2 = require("../../../constants");
-const utils_2 = require("../../../integrations/utils");
-const utils_3 = require("../view/utils");
-const viewBuilder_1 = __importDefault(require("../view/viewBuilder"));
+const csvParser = require("../../../utilities/csvParser");
+const { getRowParams, generateRowID, InternalTables, getTableParams, BudibaseInternalDB, } = require("../../../db/utils");
+const { isEqual } = require("lodash");
+const { AutoFieldSubTypes, FieldTypes } = require("../../../constants");
+const { inputProcessing, cleanupAttachments, } = require("../../../utilities/rowProcessor");
+const { USERS_TABLE_SCHEMA, SwitchableTypes, CanSwitchTypes, } = require("../../../constants");
+const { isExternalTable, breakExternalTableId, isSQL, } = require("../../../integrations/utils");
+const { getViews, saveView } = require("../view/utils");
+const viewTemplate = require("../view/viewBuilder");
+const usageQuota = require("../../../utilities/usageQuota");
 const { getAppDB } = require("@budibase/backend-core/context");
-const fp_1 = require("lodash/fp");
-const pro_1 = require("@budibase/pro");
-function clearColumns(table, columnNames) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const db = getAppDB();
-        const rows = yield db.allDocs((0, utils_1.getRowParams)(table._id, null, {
+const { cloneDeep } = require("lodash/fp");
+exports.clearColumns = (table, columnNames) => __awaiter(void 0, void 0, void 0, function* () {
+    const db = getAppDB();
+    const rows = yield db.allDocs(getRowParams(table._id, null, {
+        include_docs: true,
+    }));
+    return db.bulkDocs(rows.rows.map(({ doc }) => {
+        columnNames.forEach(colName => delete doc[colName]);
+        return doc;
+    }));
+});
+exports.checkForColumnUpdates = (oldTable, updatedTable) => __awaiter(void 0, void 0, void 0, function* () {
+    const db = getAppDB();
+    let updatedRows = [];
+    const rename = updatedTable._rename;
+    let deletedColumns = [];
+    if (oldTable && oldTable.schema && updatedTable.schema) {
+        deletedColumns = Object.keys(oldTable.schema).filter(colName => updatedTable.schema[colName] == null);
+    }
+    // check for renaming of columns or deleted columns
+    if (rename || deletedColumns.length !== 0) {
+        // Update all rows
+        const rows = yield db.allDocs(getRowParams(updatedTable._id, null, {
             include_docs: true,
         }));
-        return db.bulkDocs(rows.rows.map(({ doc }) => {
-            columnNames.forEach((colName) => delete doc[colName]);
-            return doc;
-        }));
-    });
-}
-exports.clearColumns = clearColumns;
-function checkForColumnUpdates(oldTable, updatedTable) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const db = getAppDB();
-        let updatedRows = [];
-        const rename = updatedTable._rename;
-        let deletedColumns = [];
-        if (oldTable && oldTable.schema && updatedTable.schema) {
-            deletedColumns = Object.keys(oldTable.schema).filter(colName => updatedTable.schema[colName] == null);
-        }
-        // check for renaming of columns or deleted columns
-        if (rename || deletedColumns.length !== 0) {
-            // Update all rows
-            const rows = yield db.allDocs((0, utils_1.getRowParams)(updatedTable._id, null, {
-                include_docs: true,
-            }));
-            const rawRows = rows.rows.map(({ doc }) => doc);
-            updatedRows = rawRows.map((row) => {
-                row = (0, fp_1.cloneDeep)(row);
-                if (rename) {
-                    row[rename.updated] = row[rename.old];
-                    delete row[rename.old];
-                }
-                else if (deletedColumns.length !== 0) {
-                    deletedColumns.forEach((colName) => delete row[colName]);
-                }
-                return row;
-            });
-            // cleanup any attachments from object storage for deleted attachment columns
-            yield (0, rowProcessor_1.cleanupAttachments)(updatedTable, { oldTable, rows: rawRows });
-            // Update views
-            yield checkForViewUpdates(updatedTable, rename, deletedColumns);
-            delete updatedTable._rename;
-        }
-        return { rows: updatedRows, table: updatedTable };
-    });
-}
-exports.checkForColumnUpdates = checkForColumnUpdates;
+        const rawRows = rows.rows.map(({ doc }) => doc);
+        updatedRows = rawRows.map(row => {
+            row = cloneDeep(row);
+            if (rename) {
+                row[rename.updated] = row[rename.old];
+                delete row[rename.old];
+            }
+            else if (deletedColumns.length !== 0) {
+                deletedColumns.forEach(colName => delete row[colName]);
+            }
+            return row;
+        });
+        // cleanup any attachments from object storage for deleted attachment columns
+        yield cleanupAttachments(updatedTable, { oldTable, rows: rawRows });
+        // Update views
+        yield exports.checkForViewUpdates(updatedTable, rename, deletedColumns);
+        delete updatedTable._rename;
+    }
+    return { rows: updatedRows, table: updatedTable };
+});
 // makes sure the passed in table isn't going to reset the auto ID
-function makeSureTableUpToDate(table, tableToSave) {
+exports.makeSureTableUpToDate = (table, tableToSave) => {
     if (!table) {
         return tableToSave;
     }
@@ -84,83 +73,66 @@ function makeSureTableUpToDate(table, tableToSave) {
     tableToSave._rev = table._rev;
     // make sure auto IDs are always updated - these are internal
     // so the client may not know they have changed
-    let field;
-    let column;
-    for ([field, column] of Object.entries(table.schema)) {
+    for (let [field, column] of Object.entries(table.schema)) {
         if (column.autocolumn &&
-            column.subtype === constants_1.AutoFieldSubTypes.AUTO_ID &&
+            column.subtype === AutoFieldSubTypes.AUTO_ID &&
             tableToSave.schema[field]) {
             tableToSave.schema[field].lastID = column.lastID;
         }
     }
     return tableToSave;
-}
-exports.makeSureTableUpToDate = makeSureTableUpToDate;
-function handleDataImport(user, table, dataImport) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!dataImport || !dataImport.csvString) {
-            return table;
-        }
-        const db = getAppDB();
-        // Populate the table with rows imported from CSV in a bulk update
-        const data = yield (0, csvParser_1.transform)(Object.assign(Object.assign({}, dataImport), { existingTable: table }));
-        let finalData = [];
-        for (let i = 0; i < data.length; i++) {
-            let row = data[i];
-            row._id = (0, utils_1.generateRowID)(table._id);
-            row.tableId = table._id;
-            const processed = (0, rowProcessor_1.inputProcessing)(user, table, row, {
-                noAutoRelationships: true,
-            });
-            table = processed.table;
-            row = processed.row;
-            let fieldName;
-            let schema;
-            for ([fieldName, schema] of Object.entries(table.schema)) {
-                // check whether the options need to be updated for inclusion as part of the data import
-                if (schema.type === constants_1.FieldTypes.OPTIONS &&
-                    (!schema.constraints.inclusion ||
-                        schema.constraints.inclusion.indexOf(row[fieldName]) === -1)) {
-                    schema.constraints.inclusion = [
-                        ...schema.constraints.inclusion,
-                        row[fieldName],
-                    ];
-                }
+};
+exports.handleDataImport = (user, table, dataImport) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!dataImport || !dataImport.csvString) {
+        return table;
+    }
+    const db = getAppDB();
+    // Populate the table with rows imported from CSV in a bulk update
+    const data = yield csvParser.transform(Object.assign(Object.assign({}, dataImport), { existingTable: table }));
+    let finalData = [];
+    for (let i = 0; i < data.length; i++) {
+        let row = data[i];
+        row._id = generateRowID(table._id);
+        row.tableId = table._id;
+        const processed = inputProcessing(user, table, row, {
+            noAutoRelationships: true,
+        });
+        table = processed.table;
+        row = processed.row;
+        for (let [fieldName, schema] of Object.entries(table.schema)) {
+            // check whether the options need to be updated for inclusion as part of the data import
+            if (schema.type === FieldTypes.OPTIONS &&
+                (!schema.constraints.inclusion ||
+                    schema.constraints.inclusion.indexOf(row[fieldName]) === -1)) {
+                schema.constraints.inclusion = [
+                    ...schema.constraints.inclusion,
+                    row[fieldName],
+                ];
             }
-            finalData.push(row);
         }
-        yield pro_1.quotas.addRows(finalData.length, () => db.bulkDocs(finalData));
-        let response = yield db.put(table);
-        table._rev = response._rev;
-        return table;
+        finalData.push(row);
+    }
+    yield usageQuota.update(usageQuota.Properties.ROW, finalData.length, {
+        dryRun: true,
     });
-}
-exports.handleDataImport = handleDataImport;
-function handleSearchIndexes(table) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const db = getAppDB();
-        // create relevant search indexes
-        if (table.indexes && table.indexes.length > 0) {
-            const currentIndexes = yield db.getIndexes();
-            const indexName = `search:${table._id}`;
-            const existingIndex = currentIndexes.indexes.find((existing) => existing.name === indexName);
-            if (existingIndex) {
-                const currentFields = existingIndex.def.fields.map((field) => Object.keys(field)[0]);
-                // if index fields have changed, delete the original index
-                if (!(0, lodash_1.isEqual)(currentFields, table.indexes)) {
-                    yield db.deleteIndex(existingIndex);
-                    // create/recreate the index with fields
-                    yield db.createIndex({
-                        index: {
-                            fields: table.indexes,
-                            name: indexName,
-                            ddoc: "search_ddoc",
-                            type: "json",
-                        },
-                    });
-                }
-            }
-            else {
+    yield db.bulkDocs(finalData);
+    yield usageQuota.update(usageQuota.Properties.ROW, finalData.length);
+    let response = yield db.put(table);
+    table._rev = response._rev;
+    return table;
+});
+exports.handleSearchIndexes = (table) => __awaiter(void 0, void 0, void 0, function* () {
+    const db = getAppDB();
+    // create relevant search indexes
+    if (table.indexes && table.indexes.length > 0) {
+        const currentIndexes = yield db.getIndexes();
+        const indexName = `search:${table._id}`;
+        const existingIndex = currentIndexes.indexes.find(existing => existing.name === indexName);
+        if (existingIndex) {
+            const currentFields = existingIndex.def.fields.map(field => Object.keys(field)[0]);
+            // if index fields have changed, delete the original index
+            if (!isEqual(currentFields, table.indexes)) {
+                yield db.deleteIndex(existingIndex);
                 // create/recreate the index with fields
                 yield db.createIndex({
                     index: {
@@ -172,14 +144,24 @@ function handleSearchIndexes(table) {
                 });
             }
         }
-        return table;
-    });
-}
-exports.handleSearchIndexes = handleSearchIndexes;
-function checkStaticTables(table) {
+        else {
+            // create/recreate the index with fields
+            yield db.createIndex({
+                index: {
+                    fields: table.indexes,
+                    name: indexName,
+                    ddoc: "search_ddoc",
+                    type: "json",
+                },
+            });
+        }
+    }
+    return table;
+});
+exports.checkStaticTables = table => {
     // check user schema has all required elements
-    if (table._id === utils_1.InternalTables.USER_METADATA) {
-        for (let [key, schema] of Object.entries(constants_2.USERS_TABLE_SCHEMA.schema)) {
+    if (table._id === InternalTables.USER_METADATA) {
+        for (let [key, schema] of Object.entries(USERS_TABLE_SCHEMA.schema)) {
             // check if the schema exists on the table to be created/updated
             if (table.schema[key] == null) {
                 table.schema[key] = schema;
@@ -187,8 +169,7 @@ function checkStaticTables(table) {
         }
     }
     return table;
-}
-exports.checkStaticTables = checkStaticTables;
+};
 class TableSaveFunctions {
     constructor({ user, oldTable, dataImport }) {
         this.db = getAppDB();
@@ -202,16 +183,16 @@ class TableSaveFunctions {
     before(table) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.oldTable) {
-                table = makeSureTableUpToDate(this.oldTable, table);
+                table = exports.makeSureTableUpToDate(this.oldTable, table);
             }
-            table = checkStaticTables(table);
+            table = exports.checkStaticTables(table);
             return table;
         });
     }
     // when confirmed valid
     mid(table) {
         return __awaiter(this, void 0, void 0, function* () {
-            let response = yield checkForColumnUpdates(this.oldTable, table);
+            let response = yield exports.checkForColumnUpdates(this.oldTable, table);
             this.rows = this.rows.concat(response.rows);
             return table;
         });
@@ -219,8 +200,8 @@ class TableSaveFunctions {
     // after saving
     after(table) {
         return __awaiter(this, void 0, void 0, function* () {
-            table = yield handleSearchIndexes(table);
-            table = yield handleDataImport(this.user, table, this.dataImport);
+            table = yield exports.handleSearchIndexes(table);
+            table = yield exports.handleDataImport(this.user, table, this.dataImport);
             return table;
         });
     }
@@ -228,128 +209,111 @@ class TableSaveFunctions {
         return this.rows;
     }
 }
-function getAllInternalTables() {
-    return __awaiter(this, void 0, void 0, function* () {
-        const db = getAppDB();
-        const internalTables = yield db.allDocs((0, utils_1.getTableParams)(null, {
-            include_docs: true,
-        }));
-        return internalTables.rows.map((tableDoc) => (Object.assign(Object.assign({}, tableDoc.doc), { type: "internal", sourceId: utils_1.BudibaseInternalDB._id })));
-    });
-}
-exports.getAllInternalTables = getAllInternalTables;
-function getAllExternalTables(datasourceId) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const db = getAppDB();
+exports.getAllInternalTables = () => __awaiter(void 0, void 0, void 0, function* () {
+    const db = getAppDB();
+    const internalTables = yield db.allDocs(getTableParams(null, {
+        include_docs: true,
+    }));
+    return internalTables.rows.map(tableDoc => (Object.assign(Object.assign({}, tableDoc.doc), { type: "internal", sourceId: BudibaseInternalDB._id })));
+});
+exports.getAllExternalTables = (datasourceId) => __awaiter(void 0, void 0, void 0, function* () {
+    const db = getAppDB();
+    const datasource = yield db.get(datasourceId);
+    if (!datasource || !datasource.entities) {
+        throw "Datasource is not configured fully.";
+    }
+    return datasource.entities;
+});
+exports.getExternalTable = (datasourceId, tableName) => __awaiter(void 0, void 0, void 0, function* () {
+    const entities = yield exports.getAllExternalTables(datasourceId);
+    return entities[tableName];
+});
+exports.getTable = (tableId) => __awaiter(void 0, void 0, void 0, function* () {
+    const db = getAppDB();
+    if (isExternalTable(tableId)) {
+        let { datasourceId, tableName } = breakExternalTableId(tableId);
         const datasource = yield db.get(datasourceId);
-        if (!datasource || !datasource.entities) {
-            throw "Datasource is not configured fully.";
-        }
-        return datasource.entities;
-    });
-}
-exports.getAllExternalTables = getAllExternalTables;
-function getExternalTable(datasourceId, tableName) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const entities = yield getAllExternalTables(datasourceId);
-        return entities[tableName];
-    });
-}
-exports.getExternalTable = getExternalTable;
-function getTable(tableId) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const db = getAppDB();
-        if ((0, utils_2.isExternalTable)(tableId)) {
-            let { datasourceId, tableName } = (0, utils_2.breakExternalTableId)(tableId);
-            const datasource = yield db.get(datasourceId);
-            const table = yield getExternalTable(datasourceId, tableName);
-            return Object.assign(Object.assign({}, table), { sql: (0, utils_2.isSQL)(datasource) });
-        }
-        else {
-            return db.get(tableId);
+        const table = yield exports.getExternalTable(datasourceId, tableName);
+        return Object.assign(Object.assign({}, table), { sql: isSQL(datasource) });
+    }
+    else {
+        return db.get(tableId);
+    }
+});
+exports.checkForViewUpdates = (table, rename, deletedColumns) => __awaiter(void 0, void 0, void 0, function* () {
+    const views = yield getViews();
+    const tableViews = views.filter(view => view.meta.tableId === table._id);
+    // Check each table view to see if impacted by this table action
+    for (let view of tableViews) {
+        let needsUpdated = false;
+        // First check for renames, otherwise check for deletions
+        if (rename) {
+            // Update calculation field if required
+            if (view.meta.field === rename.old) {
+                view.meta.field = rename.updated;
+                needsUpdated = true;
+            }
+            // Update group by field if required
+            if (view.meta.groupBy === rename.old) {
+                view.meta.groupBy = rename.updated;
+                needsUpdated = true;
+            }
+            // Update filters if required
+            if (view.meta.filters) {
+                view.meta.filters.forEach(filter => {
+                    if (filter.key === rename.old) {
+                        filter.key = rename.updated;
+                        needsUpdated = true;
+                    }
+                });
+            }
         }
-    });
-}
-exports.getTable = getTable;
-function checkForViewUpdates(table, rename, deletedColumns) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const views = yield (0, utils_3.getViews)();
-        const tableViews = views.filter(view => view.meta.tableId === table._id);
-        // Check each table view to see if impacted by this table action
-        for (let view of tableViews) {
-            let needsUpdated = false;
-            // First check for renames, otherwise check for deletions
-            if (rename) {
-                // Update calculation field if required
-                if (view.meta.field === rename.old) {
-                    view.meta.field = rename.updated;
+        else if (deletedColumns) {
+            deletedColumns.forEach(column => {
+                // Remove calculation statement if required
+                if (view.meta.field === column) {
+                    delete view.meta.field;
+                    delete view.meta.calculation;
+                    delete view.meta.groupBy;
                     needsUpdated = true;
                 }
-                // Update group by field if required
-                if (view.meta.groupBy === rename.old) {
-                    view.meta.groupBy = rename.updated;
+                // Remove group by field if required
+                if (view.meta.groupBy === column) {
+                    delete view.meta.groupBy;
                     needsUpdated = true;
                 }
-                // Update filters if required
-                if (view.meta.filters) {
-                    view.meta.filters.forEach((filter) => {
-                        if (filter.key === rename.old) {
-                            filter.key = rename.updated;
-                            needsUpdated = true;
-                        }
+                // Remove filters referencing deleted field if required
+                if (view.meta.filters && view.meta.filters.length) {
+                    const initialLength = view.meta.filters.length;
+                    view.meta.filters = view.meta.filters.filter(filter => {
+                        return filter.key !== column;
                     });
-                }
-            }
-            else if (deletedColumns) {
-                deletedColumns.forEach((column) => {
-                    // Remove calculation statement if required
-                    if (view.meta.field === column) {
-                        delete view.meta.field;
-                        delete view.meta.calculation;
-                        delete view.meta.groupBy;
-                        needsUpdated = true;
-                    }
-                    // Remove group by field if required
-                    if (view.meta.groupBy === column) {
-                        delete view.meta.groupBy;
+                    if (initialLength !== view.meta.filters.length) {
                         needsUpdated = true;
                     }
-                    // Remove filters referencing deleted field if required
-                    if (view.meta.filters && view.meta.filters.length) {
-                        const initialLength = view.meta.filters.length;
-                        view.meta.filters = view.meta.filters.filter((filter) => {
-                            return filter.key !== column;
-                        });
-                        if (initialLength !== view.meta.filters.length) {
-                            needsUpdated = true;
-                        }
-                    }
-                });
-            }
-            // Update view if required
-            if (needsUpdated) {
-                const newViewTemplate = (0, viewBuilder_1.default)(view.meta);
-                yield (0, utils_3.saveView)(null, view.name, newViewTemplate);
-                if (!newViewTemplate.meta.schema) {
-                    newViewTemplate.meta.schema = table.schema;
                 }
-                table.views[view.name] = newViewTemplate.meta;
+            });
+        }
+        // Update view if required
+        if (needsUpdated) {
+            const newViewTemplate = viewTemplate(view.meta);
+            yield saveView(null, view.name, newViewTemplate);
+            if (!newViewTemplate.meta.schema) {
+                newViewTemplate.meta.schema = table.schema;
             }
+            table.views[view.name] = newViewTemplate.meta;
         }
-    });
-}
-exports.checkForViewUpdates = checkForViewUpdates;
-function generateForeignKey(column, relatedTable) {
+    }
+});
+exports.generateForeignKey = (column, relatedTable) => {
     return `fk_${relatedTable.name}_${column.fieldName}`;
-}
-exports.generateForeignKey = generateForeignKey;
-function generateJunctionTableName(column, table, relatedTable) {
+};
+exports.generateJunctionTableName = (column, table, relatedTable) => {
     return `jt_${table.name}_${relatedTable.name}_${column.name}_${column.fieldName}`;
-}
-exports.generateJunctionTableName = generateJunctionTableName;
-function foreignKeyStructure(keyName, meta = null) {
+};
+exports.foreignKeyStructure = (keyName, meta = null) => {
     const structure = {
-        type: constants_1.FieldTypes.NUMBER,
+        type: FieldTypes.NUMBER,
         constraints: {},
         name: keyName,
     };
@@ -357,40 +321,34 @@ function foreignKeyStructure(keyName, meta = null) {
         structure.meta = meta;
     }
     return structure;
-}
-exports.foreignKeyStructure = foreignKeyStructure;
-function areSwitchableTypes(type1, type2) {
-    if (constants_2.SwitchableTypes.indexOf(type1) === -1 &&
-        constants_2.SwitchableTypes.indexOf(type2) === -1) {
+};
+exports.areSwitchableTypes = (type1, type2) => {
+    if (SwitchableTypes.indexOf(type1) === -1 &&
+        SwitchableTypes.indexOf(type2) === -1) {
         return false;
     }
-    for (let option of constants_2.CanSwitchTypes) {
+    for (let option of CanSwitchTypes) {
         const index1 = option.indexOf(type1), index2 = option.indexOf(type2);
         if (index1 !== -1 && index2 !== -1 && index1 !== index2) {
             return true;
         }
     }
     return false;
-}
-exports.areSwitchableTypes = areSwitchableTypes;
-function hasTypeChanged(table, oldTable) {
+};
+exports.hasTypeChanged = (table, oldTable) => {
     if (!oldTable) {
         return false;
     }
-    let key;
-    let field;
-    for ([key, field] of Object.entries(oldTable.schema)) {
+    for (let [key, field] of Object.entries(oldTable.schema)) {
         const oldType = field.type;
         if (!table.schema[key]) {
             continue;
         }
         const newType = table.schema[key].type;
-        if (oldType !== newType && !areSwitchableTypes(oldType, newType)) {
+        if (oldType !== newType && !exports.areSwitchableTypes(oldType, newType)) {
             return true;
         }
     }
     return false;
-}
-exports.hasTypeChanged = hasTypeChanged;
-const _TableSaveFunctions = TableSaveFunctions;
-exports.TableSaveFunctions = _TableSaveFunctions;
+};
+exports.TableSaveFunctions = TableSaveFunctions;

package/dist/api/index.js

@@ -10,14 +10,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 const Router = require("@koa/router");
 const { buildAuthMiddleware, auditLog, buildTenancyMiddleware, } = require("@budibase/backend-core/auth");
-const { errors } = require("@budibase/backend-core");
 const currentApp = require("../middleware/currentapp");
 const compress = require("koa-compress");
 const zlib = require("zlib");
 const { mainRoutes, staticRoutes, publicRoutes } = require("./routes");
 const pkg = require("../../package.json");
 const env = require("../environment");
-const { middleware: pro } = require("@budibase/pro");
 const router = new Router();
 router.get("/health", ctx => (ctx.status = 200));
 router.get("/version", ctx => (ctx.body = pkg.version));
@@ -51,7 +49,6 @@ router
     noTenancyRequired: true,
 }))
     .use(currentApp)
-    .use(pro.licensing())
     .use(auditLog);
 // error handling middleware
 router.use((ctx, next) => __awaiter(void 0, void 0, void 0, function* () {
@@ -60,12 +57,10 @@ router.use((ctx, next) => __awaiter(void 0, void 0, void 0, function* () {
     }
     catch (err) {
         ctx.status = err.status || err.statusCode || 500;
-        const error = errors.getPublicError(err);
         ctx.body = {
             message: err.message,
             status: ctx.status,
             validationErrors: err.validation,
-            error,
         };
         if (env.NODE_ENV !== "jest") {
             ctx.log.error(err);