@budibase/server 2.3.13 → 2.3.14-alpha.0

package/dist/tests/utilities/TestConfiguration.js

@@ -0,0 +1,626 @@
+"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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _TestConfiguration_setMultiTenancy, _TestConfiguration_setSelfHosted;
+const tests_1 = require("@budibase/backend-core/tests");
+// init the licensing mock
+const pro = __importStar(require("@budibase/pro"));
+tests_1.mocks.licenses.init(pro);
+// use unlimited license by default
+tests_1.mocks.licenses.useUnlimited();
+const db_1 = require("../../db");
+(0, db_1.init)();
+const environment_1 = __importDefault(require("../../environment"));
+const backend_core_1 = require("@budibase/backend-core");
+const structures_1 = require("./structures");
+const backend_core_2 = require("@budibase/backend-core");
+const controllers = __importStar(require("./controllers"));
+const fileSystem_1 = require("../../utilities/fileSystem");
+const newid_1 = __importDefault(require("../../db/newid"));
+const utils_1 = require("../../db/utils");
+const startup_1 = require("../../startup");
+const supertest_1 = __importDefault(require("supertest"));
+const types_1 = require("@budibase/types");
+class TestConfiguration {
+    constructor(openServer = true) {
+        // MODES
+        _TestConfiguration_setMultiTenancy.set(this, (value) => {
+            environment_1.default._set("MULTI_TENANCY", value);
+            backend_core_1.env._set("MULTI_TENANCY", value);
+        });
+        _TestConfiguration_setSelfHosted.set(this, (value) => {
+            environment_1.default._set("SELF_HOSTED", value);
+            backend_core_1.env._set("SELF_HOSTED", value);
+        });
+        this.modeCloud = () => {
+            __classPrivateFieldGet(this, _TestConfiguration_setSelfHosted, "f").call(this, false);
+            __classPrivateFieldGet(this, _TestConfiguration_setMultiTenancy, "f").call(this, true);
+        };
+        this.modeSelf = () => {
+            __classPrivateFieldGet(this, _TestConfiguration_setSelfHosted, "f").call(this, true);
+            __classPrivateFieldGet(this, _TestConfiguration_setMultiTenancy, "f").call(this, false);
+        };
+        if (openServer) {
+            // use a random port because it doesn't matter
+            environment_1.default.PORT = "0";
+            this.server = require("../../app").default;
+            // we need the request for logging in, involves cookies, hard to fake
+            this.request = (0, supertest_1.default)(this.server);
+            this.started = true;
+        }
+        else {
+            this.started = false;
+        }
+        this.appId = null;
+        this.allApps = [];
+        this.tenantId = null;
+        this.defaultUserValues = this.populateDefaultUserValues();
+    }
+    populateDefaultUserValues() {
+        return {
+            globalUserId: `us_${(0, newid_1.default)()}`,
+            email: tests_1.generator.email(),
+            firstName: tests_1.generator.first(),
+            lastName: tests_1.generator.last(),
+            csrfToken: tests_1.generator.hash(),
+        };
+    }
+    getRequest() {
+        return this.request;
+    }
+    getApp() {
+        return this.app;
+    }
+    getProdApp() {
+        return this.prodApp;
+    }
+    getAppId() {
+        return this.appId;
+    }
+    getProdAppId() {
+        return this.prodAppId;
+    }
+    getUserDetails() {
+        return {
+            globalId: this.defaultUserValues.globalUserId,
+            email: this.defaultUserValues.email,
+            firstName: this.defaultUserValues.firstName,
+            lastName: this.defaultUserValues.lastName,
+        };
+    }
+    doInContext(appId, task) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!appId) {
+                appId = this.appId;
+            }
+            const tenant = this.getTenantId();
+            return backend_core_2.tenancy.doInTenant(tenant, () => {
+                // check if already in a context
+                if (backend_core_2.context.getAppId() == null && appId !== null) {
+                    return backend_core_2.context.doInAppContext(appId, () => __awaiter(this, void 0, void 0, function* () {
+                        return task();
+                    }));
+                }
+                else {
+                    return task();
+                }
+            });
+        });
+    }
+    // SETUP /  TEARDOWN
+    // use a new id as the name to avoid name collisions
+    init(appName = (0, newid_1.default)()) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.defaultUserValues = this.populateDefaultUserValues();
+            if (backend_core_2.context.isMultiTenant()) {
+                this.tenantId = tests_1.structures.tenant.id();
+            }
+            if (!this.started) {
+                yield (0, startup_1.startup)();
+            }
+            this.user = yield this.globalUser();
+            this.globalUserId = this.user._id;
+            this.userMetadataId = (0, utils_1.generateUserMetadataID)(this.globalUserId);
+            return this.createApp(appName);
+        });
+    }
+    end() {
+        if (!this) {
+            return;
+        }
+        if (this.server) {
+            this.server.close();
+        }
+        if (this.allApps) {
+            (0, fileSystem_1.cleanup)(this.allApps.map(app => app.appId));
+        }
+    }
+    // UTILS
+    _req(body, params, controlFunc) {
+        // create a fake request ctx
+        const request = {};
+        const appId = this.appId;
+        request.appId = appId;
+        // fake cookies, we don't need them
+        request.cookies = { set: () => { }, get: () => { } };
+        request.config = { jwtSecret: environment_1.default.JWT_SECRET };
+        request.user = { appId, tenantId: this.getTenantId() };
+        request.query = {};
+        request.request = {
+            body,
+        };
+        if (params) {
+            request.params = params;
+        }
+        return this.doInContext(appId, () => __awaiter(this, void 0, void 0, function* () {
+            yield controlFunc(request);
+            return request.body;
+        }));
+    }
+    // USER / AUTH
+    globalUser({ id = this.defaultUserValues.globalUserId, firstName = this.defaultUserValues.firstName, lastName = this.defaultUserValues.lastName, builder = true, admin = false, email = this.defaultUserValues.email, roles, } = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return backend_core_2.tenancy.doWithGlobalDB(this.getTenantId(), (db) => __awaiter(this, void 0, void 0, function* () {
+                let existing;
+                try {
+                    existing = yield db.get(id);
+                }
+                catch (err) {
+                    existing = { email };
+                }
+                const user = Object.assign(Object.assign({ _id: id }, existing), { roles: roles || {}, tenantId: this.getTenantId(), firstName,
+                    lastName });
+                yield backend_core_2.sessions.createASession(id, {
+                    sessionId: "sessionid",
+                    tenantId: this.getTenantId(),
+                    csrfToken: this.defaultUserValues.csrfToken,
+                });
+                if (builder) {
+                    user.builder = { global: true };
+                }
+                else {
+                    user.builder = { global: false };
+                }
+                if (admin) {
+                    user.admin = { global: true };
+                }
+                else {
+                    user.admin = { global: false };
+                }
+                const resp = yield db.put(user);
+                return Object.assign({ _rev: resp.rev }, user);
+            }));
+        });
+    }
+    createUser(user = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let { id, firstName, lastName, email, builder, admin, roles } = user;
+            firstName = firstName || this.defaultUserValues.firstName;
+            lastName = lastName || this.defaultUserValues.lastName;
+            email = email || this.defaultUserValues.email;
+            roles = roles || {};
+            if (builder == null) {
+                builder = true;
+            }
+            const globalId = !id ? `us_${Math.random()}` : `us_${id}`;
+            const resp = yield this.globalUser({
+                id: globalId,
+                firstName,
+                lastName,
+                email,
+                builder,
+                admin,
+                roles,
+            });
+            yield backend_core_2.cache.user.invalidateUser(globalId);
+            return Object.assign(Object.assign({}, resp), { globalId });
+        });
+    }
+    login({ roleId, userId, builder, prodApp = false } = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const appId = prodApp ? this.prodAppId : this.appId;
+            return backend_core_2.context.doInAppContext(appId, () => __awaiter(this, void 0, void 0, function* () {
+                userId = !userId ? `us_uuid1` : userId;
+                if (!this.request) {
+                    throw "Server has not been opened, cannot login.";
+                }
+                // make sure the user exists in the global DB
+                if (roleId !== backend_core_2.roles.BUILTIN_ROLE_IDS.PUBLIC) {
+                    yield this.globalUser({
+                        id: userId,
+                        builder,
+                        roles: { [this.prodAppId]: roleId },
+                    });
+                }
+                yield backend_core_2.sessions.createASession(userId, {
+                    sessionId: "sessionid",
+                    tenantId: this.getTenantId(),
+                });
+                // have to fake this
+                const authObj = {
+                    userId,
+                    sessionId: "sessionid",
+                    tenantId: this.getTenantId(),
+                };
+                const app = {
+                    roleId: roleId,
+                    appId,
+                };
+                const authToken = backend_core_2.auth.jwt.sign(authObj, environment_1.default.JWT_SECRET);
+                const appToken = backend_core_2.auth.jwt.sign(app, environment_1.default.JWT_SECRET);
+                // returning necessary request headers
+                yield backend_core_2.cache.user.invalidateUser(userId);
+                return {
+                    Accept: "application/json",
+                    Cookie: [
+                        `${backend_core_2.constants.Cookie.Auth}=${authToken}`,
+                        `${backend_core_2.constants.Cookie.CurrentApp}=${appToken}`,
+                    ],
+                    [backend_core_2.constants.Header.APP_ID]: appId,
+                };
+            }));
+        });
+    }
+    defaultHeaders(extras = {}) {
+        const tenantId = this.getTenantId();
+        const authObj = {
+            userId: this.defaultUserValues.globalUserId,
+            sessionId: "sessionid",
+            tenantId,
+        };
+        const app = {
+            roleId: backend_core_2.roles.BUILTIN_ROLE_IDS.ADMIN,
+            appId: this.appId,
+        };
+        const authToken = backend_core_2.auth.jwt.sign(authObj, environment_1.default.JWT_SECRET);
+        const appToken = backend_core_2.auth.jwt.sign(app, environment_1.default.JWT_SECRET);
+        const headers = Object.assign({ Accept: "application/json", Cookie: [
+                `${backend_core_2.constants.Cookie.Auth}=${authToken}`,
+                `${backend_core_2.constants.Cookie.CurrentApp}=${appToken}`,
+            ], [backend_core_2.constants.Header.CSRF_TOKEN]: this.defaultUserValues.csrfToken }, extras);
+        if (this.appId) {
+            headers[backend_core_2.constants.Header.APP_ID] = this.appId;
+        }
+        return headers;
+    }
+    getTenantId() {
+        return this.tenantId || structures_1.TENANT_ID;
+    }
+    publicHeaders({ prodApp = true } = {}) {
+        const appId = prodApp ? this.prodAppId : this.appId;
+        const headers = {
+            Accept: "application/json",
+        };
+        if (appId) {
+            headers[backend_core_2.constants.Header.APP_ID] = appId;
+        }
+        if (this.tenantId) {
+            headers[backend_core_2.constants.Header.TENANT_ID] = this.tenantId;
+        }
+        return headers;
+    }
+    roleHeaders({ email = this.defaultUserValues.email, roleId = backend_core_2.roles.BUILTIN_ROLE_IDS.ADMIN, builder = false, prodApp = true, } = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.login({ email, roleId, builder, prodApp });
+        });
+    }
+    // API
+    generateApiKey(userId = this.defaultUserValues.globalUserId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return backend_core_2.tenancy.doWithGlobalDB(this.getTenantId(), (db) => __awaiter(this, void 0, void 0, function* () {
+                const id = backend_core_2.db.generateDevInfoID(userId);
+                let devInfo;
+                try {
+                    devInfo = yield db.get(id);
+                }
+                catch (err) {
+                    devInfo = { _id: id, userId };
+                }
+                devInfo.apiKey = backend_core_2.encryption.encrypt(`${this.getTenantId()}${backend_core_2.db.SEPARATOR}${(0, newid_1.default)()}`);
+                yield db.put(devInfo);
+                return devInfo.apiKey;
+            }));
+        });
+    }
+    // APP
+    createApp(appName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // create dev app
+            // clear any old app
+            this.appId = null;
+            yield backend_core_2.context.doInAppContext(null, () => __awaiter(this, void 0, void 0, function* () {
+                this.app = yield this._req({ name: appName }, null, controllers.app.create);
+                this.appId = this.app.appId;
+            }));
+            return yield backend_core_2.context.doInAppContext(this.appId, () => __awaiter(this, void 0, void 0, function* () {
+                // create production app
+                this.prodApp = yield this.publish();
+                this.allApps.push(this.prodApp);
+                this.allApps.push(this.app);
+                return this.app;
+            }));
+        });
+    }
+    publish() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._req(null, null, controllers.deploy.publishApp);
+            // @ts-ignore
+            const prodAppId = this.getAppId().replace("_dev", "");
+            this.prodAppId = prodAppId;
+            return backend_core_2.context.doInAppContext(prodAppId, () => __awaiter(this, void 0, void 0, function* () {
+                const db = backend_core_2.context.getProdAppDB();
+                return yield db.get(backend_core_2.db.DocumentType.APP_METADATA);
+            }));
+        });
+    }
+    unpublish() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this._req(null, { appId: this.appId }, controllers.app.unpublish);
+            this.prodAppId = null;
+            this.prodApp = null;
+            return response;
+        });
+    }
+    // TABLE
+    updateTable(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            config = config || (0, structures_1.basicTable)();
+            this.table = yield this._req(config, null, controllers.table.save);
+            return this.table;
+        });
+    }
+    createTable(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (config != null && config._id) {
+                delete config._id;
+            }
+            return this.updateTable(config);
+        });
+    }
+    getTable(tableId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            tableId = tableId || this.table._id;
+            return this._req(null, { tableId }, controllers.table.find);
+        });
+    }
+    createLinkedTable(relationshipType, links = ["link"]) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.table) {
+                throw "Must have created a table first.";
+            }
+            const tableConfig = (0, structures_1.basicTable)();
+            tableConfig.primaryDisplay = "name";
+            for (let link of links) {
+                tableConfig.schema[link] = {
+                    type: "link",
+                    fieldName: link,
+                    tableId: this.table._id,
+                    name: link,
+                };
+                if (relationshipType) {
+                    tableConfig.schema[link].relationshipType = relationshipType;
+                }
+            }
+            const linkedTable = yield this.createTable(tableConfig);
+            this.linkedTable = linkedTable;
+            return linkedTable;
+        });
+    }
+    createAttachmentTable() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const table = (0, structures_1.basicTable)();
+            table.schema.attachment = {
+                type: "attachment",
+            };
+            return this.createTable(table);
+        });
+    }
+    // ROW
+    createRow(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.table) {
+                throw "Test requires table to be configured.";
+            }
+            const tableId = (config && config.tableId) || this.table._id;
+            config = config || (0, structures_1.basicRow)(tableId);
+            return this._req(config, { tableId }, controllers.row.save);
+        });
+    }
+    getRow(tableId, rowId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._req(null, { tableId, rowId }, controllers.row.find);
+        });
+    }
+    getRows(tableId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!tableId && this.table) {
+                tableId = this.table._id;
+            }
+            return this._req(null, { tableId }, controllers.row.fetch);
+        });
+    }
+    // ROLE
+    createRole(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            config = config || (0, structures_1.basicRole)();
+            return this._req(config, null, controllers.role.save);
+        });
+    }
+    addPermission(roleId, resourceId, level = "read") {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._req(null, {
+                roleId,
+                resourceId,
+                level,
+            }, controllers.perms.addPermission);
+        });
+    }
+    // VIEW
+    createView(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.table) {
+                throw "Test requires table to be configured.";
+            }
+            const view = config || {
+                tableId: this.table._id,
+                name: "ViewTest",
+            };
+            return this._req(view, null, controllers.view.save);
+        });
+    }
+    // AUTOMATION
+    createAutomation(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            config = config || (0, structures_1.basicAutomation)();
+            if (config._rev) {
+                delete config._rev;
+            }
+            this.automation = (yield this._req(config, null, controllers.automation.create)).automation;
+            return this.automation;
+        });
+    }
+    getAllAutomations() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._req(null, null, controllers.automation.fetch);
+        });
+    }
+    deleteAutomation(automation) {
+        return __awaiter(this, void 0, void 0, function* () {
+            automation = automation || this.automation;
+            if (!automation) {
+                return;
+            }
+            return this._req(null, { id: automation._id, rev: automation._rev }, controllers.automation.destroy);
+        });
+    }
+    createWebhook(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.automation) {
+                throw "Must create an automation before creating webhook.";
+            }
+            config = config || (0, structures_1.basicWebhook)(this.automation._id);
+            return (yield this._req(config, null, controllers.webhook.save)).webhook;
+        });
+    }
+    // DATASOURCE
+    createDatasource(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            config = config || (0, structures_1.basicDatasource)();
+            const response = yield this._req(config, null, controllers.datasource.save);
+            this.datasource = response.datasource;
+            return this.datasource;
+        });
+    }
+    updateDatasource(datasource) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this._req(datasource, { datasourceId: datasource._id }, controllers.datasource.update);
+            this.datasource = response.datasource;
+            return this.datasource;
+        });
+    }
+    restDatasource(cfg) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.createDatasource({
+                datasource: Object.assign(Object.assign({}, (0, structures_1.basicDatasource)().datasource), { source: types_1.SourceName.REST, config: cfg || {} }),
+            });
+        });
+    }
+    dynamicVariableDatasource() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let datasource = yield this.restDatasource();
+            const basedOnQuery = yield this.createQuery(Object.assign(Object.assign({}, (0, structures_1.basicQuery)(datasource._id)), { fields: {
+                    path: "www.google.com",
+                } }));
+            datasource = yield this.updateDatasource(Object.assign(Object.assign({}, datasource), { config: {
+                    dynamicVariables: [
+                        {
+                            queryId: basedOnQuery._id,
+                            name: "variable3",
+                            value: "{{ data.0.[value] }}",
+                        },
+                    ],
+                } }));
+            return { datasource, query: basedOnQuery };
+        });
+    }
+    // QUERY
+    previewQuery(request, config, datasource, fields, params, verb) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return request
+                .post(`/api/queries/preview`)
+                .send({
+                datasourceId: datasource._id,
+                parameters: params || {},
+                fields,
+                queryVerb: verb || "read",
+                name: datasource.name,
+            })
+                .set(config.defaultHeaders())
+                .expect("Content-Type", /json/)
+                .expect(200);
+        });
+    }
+    createQuery(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.datasource && !config) {
+                throw "No datasource created for query.";
+            }
+            config = config || (0, structures_1.basicQuery)(this.datasource._id);
+            return this._req(config, null, controllers.query.save);
+        });
+    }
+    // SCREEN
+    createScreen(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            config = config || (0, structures_1.basicScreen)();
+            return this._req(config, null, controllers.screen.save);
+        });
+    }
+    // LAYOUT
+    createLayout(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            config = config || (0, structures_1.basicLayout)();
+            return yield this._req(config, null, controllers.layout.save);
+        });
+    }
+}
+_TestConfiguration_setMultiTenancy = new WeakMap(), _TestConfiguration_setSelfHosted = new WeakMap();
+module.exports = TestConfiguration;

package/dist/tests/utilities/controllers.js

@@ -0,0 +1,40 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deploy = exports.layout = exports.webhook = exports.screen = exports.query = exports.datasource = exports.automation = exports.user = exports.app = exports.view = exports.perms = exports.role = exports.row = exports.table = void 0;
+exports.table = __importStar(require("../../api/controllers/table"));
+exports.row = __importStar(require("../../api/controllers/row"));
+exports.role = __importStar(require("../../api/controllers/role"));
+exports.perms = __importStar(require("../../api/controllers/permission"));
+exports.view = __importStar(require("../../api/controllers/view"));
+exports.app = __importStar(require("../../api/controllers/application"));
+exports.user = __importStar(require("../../api/controllers/user"));
+exports.automation = __importStar(require("../../api/controllers/automation"));
+exports.datasource = __importStar(require("../../api/controllers/datasource"));
+exports.query = __importStar(require("../../api/controllers/query"));
+exports.screen = __importStar(require("../../api/controllers/screen"));
+exports.webhook = __importStar(require("../../api/controllers/webhook"));
+exports.layout = __importStar(require("../../api/controllers/layout"));
+exports.deploy = __importStar(require("../../api/controllers/deploy"));