@budibase/server 2.1.32-alpha.4 → 2.1.32-alpha.6

package/dist/api/controllers/row/staticFormula.js

@@ -8,12 +8,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-const { getRowParams } = require("../../../db/utils");
-const { outputProcessing, processAutoColumn, processFormulas, } = require("../../../utilities/rowProcessor");
-const { FieldTypes, FormulaTypes } = require("../../../constants");
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.finaliseRow = exports.updateAllFormulasInTable = void 0;
+const utils_1 = require("../../../db/utils");
+const rowProcessor_1 = require("../../../utilities/rowProcessor");
+const constants_1 = require("../../../constants");
+const backend_core_1 = require("@budibase/backend-core");
 const { isEqual } = require("lodash");
 const { cloneDeep } = require("lodash/fp");
-const { getAppDB } = require("@budibase/backend-core/context");
 /**
  * This function runs through a list of enriched rows, looks at the rows which
  * are related and then checks if they need the state of their formulas
@@ -21,7 +23,7 @@ const { getAppDB } = require("@budibase/backend-core/context");
  * NOTE: this will only for affect static formulas.
  */
 exports.updateRelatedFormula = (table, enrichedRows) => __awaiter(void 0, void 0, void 0, function* () {
-    const db = getAppDB();
+    const db = backend_core_1.context.getAppDB();
     // no formula to update, we're done
     if (!table.relatedFormula) {
         return;
@@ -34,7 +36,7 @@ exports.updateRelatedFormula = (table, enrichedRows) => __awaiter(void 0, void 0
         let relatedRows = {};
         for (let [key, field] of Object.entries(enrichedRow)) {
             const columnDefinition = table.schema[key];
-            if (columnDefinition && columnDefinition.type === FieldTypes.LINK) {
+            if (columnDefinition && columnDefinition.type === constants_1.FieldTypes.LINK) {
                 const relatedTableId = columnDefinition.tableId;
                 if (!relatedRows[relatedTableId]) {
                     relatedRows[relatedTableId] = [];
@@ -56,10 +58,10 @@ exports.updateRelatedFormula = (table, enrichedRows) => __awaiter(void 0, void 0
             }
             for (let column of Object.values(relatedTable.schema)) {
                 // needs updated in related rows
-                if (column.type === FieldTypes.FORMULA &&
-                    column.formulaType === FormulaTypes.STATIC) {
+                if (column.type === constants_1.FieldTypes.FORMULA &&
+                    column.formulaType === constants_1.FormulaTypes.STATIC) {
                     // re-enrich rows for all the related, don't update the related formula for them
-                    promises = promises.concat(relatedRows[tableId].map(related => exports.finaliseRow(relatedTable, related, {
+                    promises = promises.concat(relatedRows[tableId].map(related => finaliseRow(relatedTable, related, {
                         updateFormula: false,
                     })));
                     break;
@@ -69,80 +71,88 @@ exports.updateRelatedFormula = (table, enrichedRows) => __awaiter(void 0, void 0
     }
     yield Promise.all(promises);
 });
-exports.updateAllFormulasInTable = (table) => __awaiter(void 0, void 0, void 0, function* () {
-    const db = getAppDB();
-    // start by getting the raw rows (which will be written back to DB after update)
-    let rows = (yield db.allDocs(getRowParams(table._id, null, {
-        include_docs: true,
-    }))).rows.map(row => row.doc);
-    // now enrich the rows, note the clone so that we have the base state of the
-    // rows so that we don't write any of the enriched information back
-    let enrichedRows = yield outputProcessing(table, cloneDeep(rows), {
-        squash: false,
-    });
-    const updatedRows = [];
-    for (let row of rows) {
-        // find the enriched row, if found process the formulas
-        const enrichedRow = enrichedRows.find(enriched => enriched._id === row._id);
-        if (enrichedRow) {
-            const processed = processFormulas(table, cloneDeep(row), {
-                dynamic: false,
-                contextRows: enrichedRow,
-            });
-            // values have changed, need to add to bulk docs to update
-            if (!isEqual(processed, row)) {
-                updatedRows.push(processed);
+function updateAllFormulasInTable(table) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const db = backend_core_1.context.getAppDB();
+        // start by getting the raw rows (which will be written back to DB after update)
+        let rows = (yield db.allDocs((0, utils_1.getRowParams)(table._id, null, {
+            include_docs: true,
+        }))).rows.map(row => row.doc);
+        // now enrich the rows, note the clone so that we have the base state of the
+        // rows so that we don't write any of the enriched information back
+        let enrichedRows = yield (0, rowProcessor_1.outputProcessing)(table, cloneDeep(rows), {
+            squash: false,
+        });
+        const updatedRows = [];
+        for (let row of rows) {
+            // find the enriched row, if found process the formulas
+            const enrichedRow = enrichedRows.find((enriched) => enriched._id === row._id);
+            if (enrichedRow) {
+                const processed = (0, rowProcessor_1.processFormulas)(table, cloneDeep(row), {
+                    dynamic: false,
+                    contextRows: enrichedRow,
+                });
+                // values have changed, need to add to bulk docs to update
+                if (!isEqual(processed, row)) {
+                    updatedRows.push(processed);
+                }
             }
         }
-    }
-    yield db.bulkDocs(updatedRows);
-});
+        yield db.bulkDocs(updatedRows);
+    });
+}
+exports.updateAllFormulasInTable = updateAllFormulasInTable;
 /**
  * This function runs at the end of the save/patch functions of the row controller, all this
  * really does is enrich the row, handle any static formula processing, then return the enriched
  * row. The reason we need to return the enriched row is that the automation row created trigger
  * expects the row to be totally enriched/contain all relationships.
  */
-exports.finaliseRow = (table, row, { oldTable, updateFormula } = { updateFormula: true }) => __awaiter(void 0, void 0, void 0, function* () {
-    const db = getAppDB();
-    row.type = "row";
-    // process the row before return, to include relationships
-    let enrichedRow = yield outputProcessing(table, cloneDeep(row), {
-        squash: false,
-    });
-    // use enriched row to generate formulas for saving, specifically only use as context
-    row = processFormulas(table, row, {
-        dynamic: false,
-        contextRows: enrichedRow,
-    });
-    // don't worry about rev, tables handle rev/lastID updates
-    // if another row has been written since processing this will
-    // handle the auto ID clash
-    if (oldTable && !isEqual(oldTable, table)) {
-        try {
-            yield db.put(table);
-        }
-        catch (err) {
-            if (err.status === 409) {
-                const updatedTable = yield db.get(table._id);
-                let response = processAutoColumn(null, updatedTable, row, {
-                    reprocessing: true,
-                });
-                yield db.put(response.table);
-                row = response.row;
+function finaliseRow(table, row, { oldTable, updateFormula } = {
+    updateFormula: true,
+}) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const db = backend_core_1.context.getAppDB();
+        row.type = "row";
+        // process the row before return, to include relationships
+        let enrichedRow = yield (0, rowProcessor_1.outputProcessing)(table, cloneDeep(row), {
+            squash: false,
+        });
+        // use enriched row to generate formulas for saving, specifically only use as context
+        row = (0, rowProcessor_1.processFormulas)(table, row, {
+            dynamic: false,
+            contextRows: enrichedRow,
+        });
+        // don't worry about rev, tables handle rev/lastID updates
+        // if another row has been written since processing this will
+        // handle the auto ID clash
+        if (oldTable && !isEqual(oldTable, table)) {
+            try {
+                yield db.put(table);
             }
-            else {
-                throw err;
+            catch (err) {
+                if (err.status === 409) {
+                    const updatedTable = yield db.get(table._id);
+                    let response = (0, rowProcessor_1.processAutoColumn)(null, updatedTable, row, {
+                        reprocessing: true,
+                    });
+                    yield db.put(response.table);
+                    row = response.row;
+                }
+                else {
+                    throw err;
+                }
             }
         }
-    }
-    const response = yield db.put(row);
-    // for response, calculate the formulas for the enriched row
-    enrichedRow._rev = response.rev;
-    enrichedRow = yield processFormulas(table, enrichedRow, { dynamic: false });
-    // this updates the related formulas in other rows based on the relations to this row
-    if (updateFormula) {
-        yield exports.updateRelatedFormula(table, enrichedRow);
-    }
-    return { row: enrichedRow, table };
-});
+        const response = yield db.put(row);
+        // for response, calculate the formulas for the enriched row
+        enrichedRow._rev = response.rev;
+        enrichedRow = yield (0, rowProcessor_1.processFormulas)(table, enrichedRow, { dynamic: false });
+        // this updates the related formulas in other rows based on the relations to this row
+        if (updateFormula) {
+            yield exports.updateRelatedFormula(table, enrichedRow);
+        }
+        return { row: enrichedRow, table };
+    });
+}
+exports.finaliseRow = finaliseRow;

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

@@ -1,4 +1,27 @@
 "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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 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) {
@@ -8,14 +31,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validate = exports.findRow = exports.getDatasourceAndQuery = exports.removeKeyNumbering = void 0;
+const utils_1 = require("../../../db/utils");
+const userController = __importStar(require("../user"));
+const constants_1 = require("../../../constants");
+const backend_core_1 = require("@budibase/backend-core");
+const query_1 = require("../../../integrations/base/query");
+var utils_2 = require("../../../integrations/base/utils");
+Object.defineProperty(exports, "removeKeyNumbering", { enumerable: true, get: function () { return utils_2.removeKeyNumbering; } });
 const validateJs = require("validate.js");
 const { cloneDeep } = require("lodash/fp");
-const { InternalTables } = require("../../../db/utils");
-const userController = require("../user");
-const { FieldTypes } = require("../../../constants");
-const { getAppDB } = require("@budibase/backend-core/context");
-const { makeExternalQuery } = require("../../../integrations/base/query");
-const { removeKeyNumbering } = require("../../../integrations/base/utils");
 validateJs.extend(validateJs.validators.datetime, {
     parse: function (value) {
         return new Date(value).getTime();
@@ -25,91 +51,99 @@ validateJs.extend(validateJs.validators.datetime, {
         return new Date(value).toISOString();
     },
 });
-exports.removeKeyNumbering = removeKeyNumbering;
-exports.getDatasourceAndQuery = (json) => __awaiter(void 0, void 0, void 0, function* () {
-    const datasourceId = json.endpoint.datasourceId;
-    const db = getAppDB();
-    const datasource = yield db.get(datasourceId);
-    return makeExternalQuery(datasource, json);
-});
-exports.findRow = (ctx, tableId, rowId) => __awaiter(void 0, void 0, void 0, function* () {
-    const db = getAppDB();
-    let row;
-    // TODO remove special user case in future
-    if (tableId === InternalTables.USER_METADATA) {
-        ctx.params = {
-            id: rowId,
-        };
-        yield userController.findMetadata(ctx);
-        row = ctx.body;
-    }
-    else {
-        row = yield db.get(rowId);
-    }
-    if (row.tableId !== tableId) {
-        throw "Supplied tableId does not match the rows tableId";
-    }
-    return row;
-});
-exports.validate = ({ tableId, row, table }) => __awaiter(void 0, void 0, void 0, function* () {
-    if (!table) {
-        const db = getAppDB();
-        table = yield db.get(tableId);
-    }
-    const errors = {};
-    for (let fieldName of Object.keys(table.schema)) {
-        const constraints = cloneDeep(table.schema[fieldName].constraints);
-        const type = table.schema[fieldName].type;
-        // formulas shouldn't validated, data will be deleted anyway
-        if (type === FieldTypes.FORMULA) {
-            continue;
+function getDatasourceAndQuery(json) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const datasourceId = json.endpoint.datasourceId;
+        const db = backend_core_1.context.getAppDB();
+        const datasource = yield db.get(datasourceId);
+        return (0, query_1.makeExternalQuery)(datasource, json);
+    });
+}
+exports.getDatasourceAndQuery = getDatasourceAndQuery;
+function findRow(ctx, tableId, rowId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const db = backend_core_1.context.getAppDB();
+        let row;
+        // TODO remove special user case in future
+        if (tableId === utils_1.InternalTables.USER_METADATA) {
+            ctx.params = {
+                id: rowId,
+            };
+            yield userController.findMetadata(ctx);
+            row = ctx.body;
         }
-        // special case for options, need to always allow unselected (null)
-        if (type === FieldTypes.OPTIONS && constraints.inclusion) {
-            constraints.inclusion.push(null);
+        else {
+            row = yield db.get(rowId);
         }
-        let res;
-        // Validate.js doesn't seem to handle array
-        if (type === FieldTypes.ARRAY && row[fieldName]) {
-            if (row[fieldName].length) {
-                if (!Array.isArray(row[fieldName])) {
-                    row[fieldName] = row[fieldName].split(",");
-                }
-                row[fieldName].map(val => {
-                    if (!constraints.inclusion.includes(val) &&
-                        constraints.inclusion.length !== 0) {
-                        errors[fieldName] = "Field not in list";
-                    }
-                });
+        if (row.tableId !== tableId) {
+            throw "Supplied tableId does not match the rows tableId";
+        }
+        return row;
+    });
+}
+exports.findRow = findRow;
+function validate({ tableId, row, table, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!table) {
+            const db = backend_core_1.context.getAppDB();
+            table = yield db.get(tableId);
+        }
+        const errors = {};
+        for (let fieldName of Object.keys(table.schema)) {
+            const constraints = cloneDeep(table.schema[fieldName].constraints);
+            const type = table.schema[fieldName].type;
+            // formulas shouldn't validated, data will be deleted anyway
+            if (type === constants_1.FieldTypes.FORMULA) {
+                continue;
             }
-            else if (constraints.presence && row[fieldName].length === 0) {
-                // non required MultiSelect creates an empty array, which should not throw errors
-                errors[fieldName] = [`${fieldName} is required`];
+            // special case for options, need to always allow unselected (null)
+            if (type === constants_1.FieldTypes.OPTIONS && constraints.inclusion) {
+                constraints.inclusion.push(null);
             }
-        }
-        else if ((type === FieldTypes.ATTACHMENT || type === FieldTypes.JSON) &&
-            typeof row[fieldName] === "string") {
-            // this should only happen if there is an error
-            try {
-                const json = JSON.parse(row[fieldName]);
-                if (type === FieldTypes.ATTACHMENT) {
-                    if (Array.isArray(json)) {
-                        row[fieldName] = json;
+            let res;
+            // Validate.js doesn't seem to handle array
+            if (type === constants_1.FieldTypes.ARRAY && row[fieldName]) {
+                if (row[fieldName].length) {
+                    if (!Array.isArray(row[fieldName])) {
+                        row[fieldName] = row[fieldName].split(",");
                     }
-                    else {
-                        errors[fieldName] = [`Must be an array`];
+                    row[fieldName].map((val) => {
+                        if (!constraints.inclusion.includes(val) &&
+                            constraints.inclusion.length !== 0) {
+                            errors[fieldName] = "Field not in list";
+                        }
+                    });
+                }
+                else if (constraints.presence && row[fieldName].length === 0) {
+                    // non required MultiSelect creates an empty array, which should not throw errors
+                    errors[fieldName] = [`${fieldName} is required`];
+                }
+            }
+            else if ((type === constants_1.FieldTypes.ATTACHMENT || type === constants_1.FieldTypes.JSON) &&
+                typeof row[fieldName] === "string") {
+                // this should only happen if there is an error
+                try {
+                    const json = JSON.parse(row[fieldName]);
+                    if (type === constants_1.FieldTypes.ATTACHMENT) {
+                        if (Array.isArray(json)) {
+                            row[fieldName] = json;
+                        }
+                        else {
+                            errors[fieldName] = [`Must be an array`];
+                        }
                     }
                 }
+                catch (err) {
+                    errors[fieldName] = [`Contains invalid JSON`];
+                }
             }
-            catch (err) {
-                errors[fieldName] = [`Contains invalid JSON`];
+            else {
+                res = validateJs.single(row[fieldName], constraints);
             }
+            if (res)
+                errors[fieldName] = res;
         }
-        else {
-            res = validateJs.single(row[fieldName], constraints);
-        }
-        if (res)
-            errors[fieldName] = res;
-    }
-    return { valid: Object.keys(errors).length === 0, errors };
-});
+        return { valid: Object.keys(errors).length === 0, errors };
+    });
+}
+exports.validate = validate;

package/dist/api/controllers/screen.js

@@ -9,77 +9,92 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.destroy = exports.save = exports.fetch = void 0;
 const utils_1 = require("../../db/utils");
 const backend_core_1 = require("@budibase/backend-core");
 const application_1 = require("./application");
-exports.fetch = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
-    const db = backend_core_1.context.getAppDB();
-    const screens = (yield db.allDocs((0, utils_1.getScreenParams)(null, {
-        include_docs: true,
-    }))).rows.map((el) => el.doc);
-    ctx.body = yield new backend_core_1.roles.AccessController().checkScreensAccess(screens, ctx.user.role._id);
-});
-exports.save = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
-    const db = backend_core_1.context.getAppDB();
-    let screen = ctx.request.body;
-    let eventFn;
-    if (!screen._id) {
-        screen._id = (0, utils_1.generateScreenID)();
-        eventFn = backend_core_1.events.screen.created;
-    }
-    const response = yield db.put(screen);
-    // Find any custom components being used
-    let pluginNames = [];
-    let pluginAdded = false;
-    findPlugins(screen.props, pluginNames);
-    if (pluginNames.length) {
-        const globalDB = backend_core_1.tenancy.getGlobalDB();
-        const pluginsResponse = yield globalDB.allDocs(backend_core_1.db.getPluginParams(null, {
+function fetch(ctx) {
+    var _a, _b;
+    return __awaiter(this, void 0, void 0, function* () {
+        const db = backend_core_1.context.getAppDB();
+        const screens = (yield db.allDocs((0, utils_1.getScreenParams)(null, {
             include_docs: true,
-        }));
-        const requiredPlugins = pluginsResponse.rows
-            .map((row) => row.doc)
-            .filter((plugin) => {
-            return (plugin.schema.type === "component" &&
-                pluginNames.includes(`plugin/${plugin.name}`));
-        });
-        // Update the app metadata
-        const application = yield db.get(utils_1.DocumentType.APP_METADATA);
-        let usedPlugins = application.usedPlugins || [];
-        requiredPlugins.forEach((plugin) => {
-            if (!usedPlugins.find((x) => x._id === plugin._id)) {
-                pluginAdded = true;
-                usedPlugins.push({
-                    _id: plugin._id,
-                    name: plugin.name,
-                    version: plugin.version,
-                    jsUrl: plugin.jsUrl,
-                    hash: plugin.hash,
-                });
+        }))).rows.map((el) => el.doc);
+        const roleId = (_b = (_a = ctx.user) === null || _a === void 0 ? void 0 : _a.role) === null || _b === void 0 ? void 0 : _b._id;
+        if (!roleId) {
+            ctx.throw("Unable to retrieve users role ID.");
+        }
+        ctx.body = yield new backend_core_1.roles.AccessController().checkScreensAccess(screens, roleId);
+    });
+}
+exports.fetch = fetch;
+function save(ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const db = backend_core_1.context.getAppDB();
+        let screen = ctx.request.body;
+        let eventFn;
+        if (!screen._id) {
+            screen._id = (0, utils_1.generateScreenID)();
+            eventFn = backend_core_1.events.screen.created;
+        }
+        const response = yield db.put(screen);
+        // Find any custom components being used
+        let pluginNames = [];
+        let pluginAdded = false;
+        findPlugins(screen.props, pluginNames);
+        if (pluginNames.length) {
+            const globalDB = backend_core_1.tenancy.getGlobalDB();
+            const pluginsResponse = yield globalDB.allDocs(backend_core_1.db.getPluginParams(null, {
+                include_docs: true,
+            }));
+            const requiredPlugins = pluginsResponse.rows
+                .map((row) => row.doc)
+                .filter((plugin) => {
+                return (plugin.schema.type === "component" &&
+                    pluginNames.includes(`plugin/${plugin.name}`));
+            });
+            // Update the app metadata
+            const application = yield db.get(utils_1.DocumentType.APP_METADATA);
+            let usedPlugins = application.usedPlugins || [];
+            requiredPlugins.forEach((plugin) => {
+                if (!usedPlugins.find((x) => x._id === plugin._id)) {
+                    pluginAdded = true;
+                    usedPlugins.push({
+                        _id: plugin._id,
+                        name: plugin.name,
+                        version: plugin.version,
+                        jsUrl: plugin.jsUrl,
+                        hash: plugin.hash,
+                    });
+                }
+            });
+            if (pluginAdded) {
+                yield (0, application_1.updateAppPackage)({ usedPlugins }, ctx.appId);
             }
-        });
-        if (pluginAdded) {
-            yield (0, application_1.updateAppPackage)({ usedPlugins }, ctx.appId);
         }
-    }
-    if (eventFn) {
-        yield eventFn(screen);
-    }
-    ctx.message = `Screen ${screen.name} saved.`;
-    ctx.body = Object.assign(Object.assign({}, screen), { _id: response.id, _rev: response.rev, pluginAdded });
-});
-exports.destroy = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
-    const db = backend_core_1.context.getAppDB();
-    const id = ctx.params.screenId;
-    const screen = yield db.get(id);
-    yield db.remove(id, ctx.params.screenRev);
-    yield backend_core_1.events.screen.deleted(screen);
-    ctx.body = {
-        message: "Screen deleted successfully",
-    };
-    ctx.status = 200;
-});
-const findPlugins = (component, foundPlugins) => {
+        if (eventFn) {
+            yield eventFn(screen);
+        }
+        ctx.message = `Screen ${screen.name} saved.`;
+        ctx.body = Object.assign(Object.assign({}, screen), { _id: response.id, _rev: response.rev, pluginAdded });
+    });
+}
+exports.save = save;
+function destroy(ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const db = backend_core_1.context.getAppDB();
+        const id = ctx.params.screenId;
+        const screen = yield db.get(id);
+        yield db.remove(id, ctx.params.screenRev);
+        yield backend_core_1.events.screen.deleted(screen);
+        ctx.body = {
+            message: "Screen deleted successfully",
+        };
+        ctx.status = 200;
+    });
+}
+exports.destroy = destroy;
+function findPlugins(component, foundPlugins) {
     if (!component) {
         return;
     }
@@ -92,4 +107,4 @@ const findPlugins = (component, foundPlugins) => {
         return;
     }
     component._children.forEach(child => findPlugins(child, foundPlugins));
-};
+}

package/dist/api/controllers/script.js

@@ -8,16 +8,23 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-const ScriptRunner = require("../../utilities/scriptRunner");
-exports.execute = function (ctx) {
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.save = exports.execute = void 0;
+const scriptRunner_1 = __importDefault(require("../../utilities/scriptRunner"));
+function execute(ctx) {
     return __awaiter(this, void 0, void 0, function* () {
         const { script, context } = ctx.request.body;
-        const runner = new ScriptRunner(script, context);
+        const runner = new scriptRunner_1.default(script, context);
         ctx.body = runner.execute();
     });
-};
-exports.save = function (ctx) {
+}
+exports.execute = execute;
+function save(ctx) {
     return __awaiter(this, void 0, void 0, function* () {
         ctx.throw(501, "Not currently implemented");
     });
-};
+}
+exports.save = save;