@budibase/server 0.0.32 → 0.0.999-alpha.30

package/dist/automations/triggerInfo/webhook.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.definition = void 0;
+const types_1 = require("@budibase/types");
+exports.definition = {
+    name: "Webhook",
+    event: "web:trigger",
+    icon: "Send",
+    tagline: "Webhook endpoint is hit",
+    description: "Trigger an automation when a HTTP POST webhook is hit",
+    stepId: types_1.AutomationTriggerStepId.WEBHOOK,
+    inputs: {},
+    schema: {
+        inputs: {
+            properties: {
+                schemaUrl: {
+                    type: types_1.AutomationIOType.STRING,
+                    customType: types_1.AutomationCustomIOType.WEBHOOK_URL,
+                    title: "Schema URL",
+                },
+                triggerUrl: {
+                    type: types_1.AutomationIOType.STRING,
+                    customType: types_1.AutomationCustomIOType.WEBHOOK_URL,
+                    title: "Trigger URL",
+                },
+            },
+            required: ["schemaUrl", "triggerUrl"],
+        },
+        outputs: {
+            properties: {
+                body: {
+                    type: types_1.AutomationIOType.OBJECT,
+                    description: "Body of the request which hit the webhook",
+                },
+            },
+            required: ["body"],
+        },
+    },
+    type: types_1.AutomationStepType.TRIGGER,
+};

package/dist/automations/triggers.js

@@ -0,0 +1,180 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rebootTrigger = exports.externalTrigger = exports.TRIGGER_DEFINITIONS = void 0;
+const index_1 = __importDefault(require("../events/index"));
+const utils_1 = require("../db/utils");
+const rowProcessor_1 = require("../utilities/rowProcessor");
+const triggerInfo_1 = require("./triggerInfo");
+const utils_2 = require("../db/utils");
+// need this to call directly, so we can get a response
+const bullboard_1 = require("./bullboard");
+const redis_1 = require("../utilities/redis");
+const utils = __importStar(require("./utils"));
+const environment_1 = __importDefault(require("../environment"));
+const backend_core_1 = require("@budibase/backend-core");
+exports.TRIGGER_DEFINITIONS = triggerInfo_1.definitions;
+const JOB_OPTS = {
+    removeOnComplete: true,
+    removeOnFail: true,
+};
+function getAllAutomations() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const db = backend_core_1.context.getAppDB();
+        let automations = yield db.allDocs((0, utils_1.getAutomationParams)(null, { include_docs: true }));
+        return automations.rows.map(row => row.doc);
+    });
+}
+function queueRelevantRowAutomations(event, eventType) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (event.appId == null) {
+            throw `No appId specified for ${eventType} - check event emitters.`;
+        }
+        yield backend_core_1.context.doInAppContext(event.appId, () => __awaiter(this, void 0, void 0, function* () {
+            let automations = yield getAllAutomations();
+            // filter down to the correct event type
+            automations = automations.filter(automation => {
+                const trigger = automation.definition.trigger;
+                return trigger && trigger.event === eventType;
+            });
+            for (let automation of automations) {
+                let automationDef = automation.definition;
+                let automationTrigger = automationDef ? automationDef.trigger : {};
+                // don't queue events which are for dev apps, only way to test automations is
+                // running tests on them, in production the test flag will never
+                // be checked due to lazy evaluation (first always false)
+                if (!environment_1.default.ALLOW_DEV_AUTOMATIONS &&
+                    (0, utils_2.isDevAppID)(event.appId) &&
+                    !(yield (0, redis_1.checkTestFlag)(automation._id))) {
+                    continue;
+                }
+                if (automationTrigger.inputs &&
+                    automationTrigger.inputs.tableId === event.row.tableId) {
+                    yield bullboard_1.automationQueue.add({ automation, event }, JOB_OPTS);
+                }
+            }
+        }));
+    });
+}
+index_1.default.on("row:save", function (event) {
+    return __awaiter(this, void 0, void 0, function* () {
+        /* istanbul ignore next */
+        if (!event || !event.row || !event.row.tableId) {
+            return;
+        }
+        yield queueRelevantRowAutomations(event, "row:save");
+    });
+});
+index_1.default.on("row:update", function (event) {
+    return __awaiter(this, void 0, void 0, function* () {
+        /* istanbul ignore next */
+        if (!event || !event.row || !event.row.tableId) {
+            return;
+        }
+        yield queueRelevantRowAutomations(event, "row:update");
+    });
+});
+index_1.default.on("row:delete", function (event) {
+    return __awaiter(this, void 0, void 0, function* () {
+        /* istanbul ignore next */
+        if (!event || !event.row || !event.row.tableId) {
+            return;
+        }
+        yield queueRelevantRowAutomations(event, "row:delete");
+    });
+});
+function externalTrigger(automation, params, { getResponses } = {}) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (automation.definition != null &&
+            automation.definition.trigger != null &&
+            automation.definition.trigger.stepId === triggerInfo_1.definitions.APP.stepId &&
+            automation.definition.trigger.stepId === "APP" &&
+            !(yield (0, redis_1.checkTestFlag)(automation._id))) {
+            // values are likely to be submitted as strings, so we shall convert to correct type
+            const coercedFields = {};
+            const fields = automation.definition.trigger.inputs.fields;
+            for (let key of Object.keys(fields || {})) {
+                coercedFields[key] = (0, rowProcessor_1.coerce)(params.fields[key], fields[key]);
+            }
+            params.fields = coercedFields;
+        }
+        const data = { automation, event: params };
+        if (getResponses) {
+            data.event = Object.assign(Object.assign({}, data.event), { appId: backend_core_1.context.getAppId(), automation });
+            return utils.processEvent({ data });
+        }
+        else {
+            return bullboard_1.automationQueue.add(data, JOB_OPTS);
+        }
+    });
+}
+exports.externalTrigger = externalTrigger;
+function rebootTrigger() {
+    return __awaiter(this, void 0, void 0, function* () {
+        // reboot cron option is only available on the main thread at
+        // startup and only usable in self host and single tenant environments
+        if (environment_1.default.isInThread() || !environment_1.default.SELF_HOSTED || environment_1.default.MULTI_TENANCY) {
+            return;
+        }
+        // iterate through all production apps, find the reboot crons
+        // and trigger events for them
+        const appIds = (yield backend_core_1.db.getAllApps({
+            dev: false,
+            idsOnly: true,
+        }));
+        for (let prodAppId of appIds) {
+            yield backend_core_1.context.doInAppContext(prodAppId, () => __awaiter(this, void 0, void 0, function* () {
+                let automations = yield getAllAutomations();
+                let rebootEvents = [];
+                for (let automation of automations) {
+                    if (utils.isRebootTrigger(automation)) {
+                        const job = {
+                            automation,
+                            event: {
+                                appId: prodAppId,
+                                timestamp: Date.now(),
+                            },
+                        };
+                        rebootEvents.push(bullboard_1.automationQueue.add(job, JOB_OPTS));
+                    }
+                }
+                yield Promise.all(rebootEvents);
+            }));
+        }
+    });
+}
+exports.rebootTrigger = rebootTrigger;

package/dist/automations/utils.js

@@ -0,0 +1,264 @@
+"use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isErrorInOutput = exports.isRecurring = exports.cleanupAutomations = exports.checkForWebhooks = exports.enableCronTrigger = exports.isRebootTrigger = exports.isCronTrigger = exports.clearMetadata = exports.disableCronById = exports.disableAllCrons = exports.removeDeprecated = exports.updateTestHistory = exports.processEvent = void 0;
+const threads_1 = require("../threads");
+const triggerInfo_1 = require("./triggerInfo");
+const bullboard_1 = require("./bullboard");
+const newid_1 = __importDefault(require("../db/newid"));
+const utilities_1 = require("../utilities");
+const constants_1 = require("../constants");
+const backend_core_1 = require("@budibase/backend-core");
+const utils_1 = require("../db/utils");
+const fp_1 = require("lodash/fp");
+const pro_1 = require("@budibase/pro");
+const types_1 = require("@budibase/types");
+const sdk_1 = __importDefault(require("../sdk"));
+const REBOOT_CRON = "@reboot";
+const WH_STEP_ID = triggerInfo_1.definitions.WEBHOOK.stepId;
+const CRON_STEP_ID = triggerInfo_1.definitions.CRON.stepId;
+const Runner = new threads_1.Thread(threads_1.ThreadType.AUTOMATION);
+const jobMessage = (job, message) => {
+    return `app=${job.data.event.appId} automation=${job.data.automation._id} jobId=${job.id} trigger=${job.data.automation.definition.trigger.event} : ${message}`;
+};
+function processEvent(job) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const automationId = job.data.automation._id;
+            console.log(jobMessage(job, "running"));
+            // need to actually await these so that an error can be captured properly
+            return yield backend_core_1.context.doInContext(job.data.event.appId, () => __awaiter(this, void 0, void 0, function* () {
+                const runFn = () => Runner.run(job);
+                return pro_1.quotas.addAutomation(runFn, {
+                    automationId,
+                });
+            }));
+        }
+        catch (err) {
+            const errJson = JSON.stringify(err);
+            console.error(jobMessage(job, `was unable to run - ${errJson}`));
+            console.trace(err);
+            return { err };
+        }
+    });
+}
+exports.processEvent = processEvent;
+function updateTestHistory(appId, automation, history) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return (0, utilities_1.updateEntityMetadata)(constants_1.MetadataTypes.AUTOMATION_TEST_HISTORY, automation._id, (metadata) => {
+            if (metadata && Array.isArray(metadata.history)) {
+                metadata.history.push(history);
+            }
+            else {
+                metadata = {
+                    history: [history],
+                };
+            }
+            return metadata;
+        });
+    });
+}
+exports.updateTestHistory = updateTestHistory;
+function removeDeprecated(definitions) {
+    const base = (0, fp_1.cloneDeep)(definitions);
+    for (let key of Object.keys(base)) {
+        if (base[key].deprecated) {
+            delete base[key];
+        }
+    }
+    return base;
+}
+exports.removeDeprecated = removeDeprecated;
+// end the repetition and the job itself
+function disableAllCrons(appId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const promises = [];
+        const jobs = yield bullboard_1.automationQueue.getRepeatableJobs();
+        for (let job of jobs) {
+            if (job.key.includes(`${appId}_cron`)) {
+                promises.push(bullboard_1.automationQueue.removeRepeatableByKey(job.key));
+                if (job.id) {
+                    promises.push(bullboard_1.automationQueue.removeJobs(job.id));
+                }
+            }
+        }
+        return Promise.all(promises);
+    });
+}
+exports.disableAllCrons = disableAllCrons;
+function disableCronById(jobId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const repeatJobs = yield bullboard_1.automationQueue.getRepeatableJobs();
+        for (let repeatJob of repeatJobs) {
+            if (repeatJob.id === jobId) {
+                yield bullboard_1.automationQueue.removeRepeatableByKey(repeatJob.key);
+            }
+        }
+        console.log(`jobId=${jobId} disabled`);
+    });
+}
+exports.disableCronById = disableCronById;
+function clearMetadata() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const db = backend_core_1.context.getProdAppDB();
+        const automationMetadata = (yield db.allDocs((0, utils_1.getAutomationMetadataParams)({
+            include_docs: true,
+        }))).rows.map((row) => row.doc);
+        for (let metadata of automationMetadata) {
+            metadata._deleted = true;
+        }
+        yield db.bulkDocs(automationMetadata);
+    });
+}
+exports.clearMetadata = clearMetadata;
+function isCronTrigger(auto) {
+    return (auto &&
+        auto.definition.trigger &&
+        auto.definition.trigger.stepId === CRON_STEP_ID);
+}
+exports.isCronTrigger = isCronTrigger;
+function isRebootTrigger(auto) {
+    const trigger = auto ? auto.definition.trigger : null;
+    return isCronTrigger(auto) && (trigger === null || trigger === void 0 ? void 0 : trigger.inputs.cron) === REBOOT_CRON;
+}
+exports.isRebootTrigger = isRebootTrigger;
+/**
+ * This function handles checking of any cron jobs that need to be enabled/updated.
+ * @param {string} appId The ID of the app in which we are checking for webhooks
+ * @param {object|undefined} automation The automation object to be updated.
+ */
+function enableCronTrigger(appId, automation) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const trigger = automation ? automation.definition.trigger : null;
+        // need to create cron job
+        if (isCronTrigger(automation) &&
+            !isRebootTrigger(automation) &&
+            (trigger === null || trigger === void 0 ? void 0 : trigger.inputs.cron)) {
+            // make a job id rather than letting Bull decide, makes it easier to handle on way out
+            const jobId = `${appId}_cron_${(0, newid_1.default)()}`;
+            const job = yield bullboard_1.automationQueue.add({
+                automation,
+                event: { appId, timestamp: Date.now() },
+            }, { repeat: { cron: trigger.inputs.cron }, jobId });
+            // Assign cron job ID from bull so we can remove it later if the cron trigger is removed
+            trigger.cronJobId = job.id;
+            // can't use getAppDB here as this is likely to be called from dev app,
+            // but this call could be for dev app or prod app, need to just use what
+            // was passed in
+            yield backend_core_1.db.doWithDB(appId, (db) => __awaiter(this, void 0, void 0, function* () {
+                const response = yield db.put(automation);
+                automation._id = response.id;
+                automation._rev = response.rev;
+            }));
+        }
+        return automation;
+    });
+}
+exports.enableCronTrigger = enableCronTrigger;
+/**
+ * This function handles checking if any webhooks need to be created or deleted for automations.
+ * @param {string} appId The ID of the app in which we are checking for webhooks
+ * @param {object|undefined} oldAuto The old automation object if updating/deleting
+ * @param {object|undefined} newAuto The new automation object if creating/updating
+ * @returns {Promise<object|undefined>} After this is complete the new automation object may have been updated and should be
+ * written to DB (this does not write to DB as it would be wasteful to repeat).
+ */
+function checkForWebhooks({ oldAuto, newAuto }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const appId = backend_core_1.context.getAppId();
+        if (!appId) {
+            throw new Error("Unable to check webhooks - no app ID in context.");
+        }
+        const oldTrigger = oldAuto ? oldAuto.definition.trigger : null;
+        const newTrigger = newAuto ? newAuto.definition.trigger : null;
+        const triggerChanged = oldTrigger && newTrigger && oldTrigger.id !== newTrigger.id;
+        function isWebhookTrigger(auto) {
+            return (auto &&
+                auto.definition.trigger &&
+                auto.definition.trigger.stepId === WH_STEP_ID);
+        }
+        // need to delete webhook
+        if (isWebhookTrigger(oldAuto) &&
+            (!isWebhookTrigger(newAuto) || triggerChanged) &&
+            oldTrigger.webhookId) {
+            try {
+                let db = backend_core_1.context.getAppDB();
+                // need to get the webhook to get the rev
+                const webhook = yield db.get(oldTrigger.webhookId);
+                // might be updating - reset the inputs to remove the URLs
+                if (newTrigger) {
+                    delete newTrigger.webhookId;
+                    newTrigger.inputs = {};
+                }
+                yield sdk_1.default.automations.webhook.destroy(webhook._id, webhook._rev);
+            }
+            catch (err) {
+                // don't worry about not being able to delete, if it doesn't exist all good
+            }
+        }
+        // need to create webhook
+        if ((!isWebhookTrigger(oldAuto) || triggerChanged) &&
+            isWebhookTrigger(newAuto)) {
+            const webhook = yield sdk_1.default.automations.webhook.save(sdk_1.default.automations.webhook.newDoc("Automation webhook", types_1.WebhookActionType.AUTOMATION, newAuto._id));
+            const id = webhook._id;
+            newTrigger.webhookId = id;
+            // the app ID has to be development for this endpoint
+            // it can only be used when building the app
+            // but the trigger endpoint will always be used in production
+            const prodAppId = backend_core_1.db.getProdAppID(appId);
+            newTrigger.inputs = {
+                schemaUrl: `api/webhooks/schema/${appId}/${id}`,
+                triggerUrl: `api/webhooks/trigger/${prodAppId}/${id}`,
+            };
+        }
+        return newAuto;
+    });
+}
+exports.checkForWebhooks = checkForWebhooks;
+/**
+ * When removing an app/unpublishing it need to make sure automations are cleaned up (cron).
+ * @param appId {string} the app that is being removed.
+ * @return {Promise<void>} clean is complete if this succeeds.
+ */
+function cleanupAutomations(appId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield disableAllCrons(appId);
+    });
+}
+exports.cleanupAutomations = cleanupAutomations;
+/**
+ * Checks if the supplied automation is of a recurring type.
+ * @param automation The automation to check.
+ * @return {boolean} if it is recurring (cron).
+ */
+function isRecurring(automation) {
+    return automation.definition.trigger.stepId === triggerInfo_1.definitions.CRON.stepId;
+}
+exports.isRecurring = isRecurring;
+function isErrorInOutput(output) {
+    var _a;
+    let first = true, error = false;
+    for (let step of output.steps) {
+        // skip the trigger, its always successful if automation ran
+        if (first) {
+            first = false;
+            continue;
+        }
+        if (!((_a = step.outputs) === null || _a === void 0 ? void 0 : _a.success)) {
+            error = true;
+        }
+    }
+    return error;
+}
+exports.isErrorInOutput = isErrorInOutput;

package/dist/constants/definitions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/constants/index.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GOOGLE_SHEETS_PRIMARY_KEY = exports.MAX_AUTOMATION_RECURRING_ERRORS = exports.ObjectStoreBuckets = exports.AutomationErrors = exports.BuildSchemaErrors = exports.InvalidColumns = exports.MetadataTypes = exports.BaseQueryVerbs = exports.OBJ_STORE_DIRECTORY = exports.AutoFieldDefaultNames = exports.AutoFieldSubTypes = exports.USERS_TABLE_SCHEMA = exports.SortDirection = exports.DatasourceAuthTypes = exports.DataSourceOperation = exports.AuthTypes = exports.FormulaTypes = exports.SwitchableTypes = exports.CanSwitchTypes = exports.NoEmptyFilterStrings = exports.FilterTypes = exports.RelationshipTypes = exports.FieldTypes = void 0;
+const backend_core_1 = require("@budibase/backend-core");
+var types_1 = require("@budibase/types");
+Object.defineProperty(exports, "FieldTypes", { enumerable: true, get: function () { return types_1.FieldType; } });
+Object.defineProperty(exports, "RelationshipTypes", { enumerable: true, get: function () { return types_1.RelationshipTypes; } });
+var FilterTypes;
+(function (FilterTypes) {
+    FilterTypes["STRING"] = "string";
+    FilterTypes["FUZZY"] = "fuzzy";
+    FilterTypes["RANGE"] = "range";
+    FilterTypes["EQUAL"] = "equal";
+    FilterTypes["NOT_EQUAL"] = "notEqual";
+    FilterTypes["EMPTY"] = "empty";
+    FilterTypes["NOT_EMPTY"] = "notEmpty";
+    FilterTypes["CONTAINS"] = "contains";
+    FilterTypes["NOT_CONTAINS"] = "notContains";
+    FilterTypes["ONE_OF"] = "oneOf";
+})(FilterTypes = exports.FilterTypes || (exports.FilterTypes = {}));
+exports.NoEmptyFilterStrings = [
+    FilterTypes.STRING,
+    FilterTypes.FUZZY,
+    FilterTypes.EQUAL,
+    FilterTypes.NOT_EQUAL,
+    FilterTypes.CONTAINS,
+    FilterTypes.NOT_CONTAINS,
+];
+exports.CanSwitchTypes = [
+    [exports.FieldTypes.JSON, exports.FieldTypes.ARRAY],
+    [
+        exports.FieldTypes.STRING,
+        exports.FieldTypes.OPTIONS,
+        exports.FieldTypes.LONGFORM,
+        exports.FieldTypes.BARCODEQR,
+    ],
+    [exports.FieldTypes.BOOLEAN, exports.FieldTypes.NUMBER],
+];
+exports.SwitchableTypes = exports.CanSwitchTypes.reduce((prev, current) => prev ? prev.concat(current) : current);
+var FormulaTypes;
+(function (FormulaTypes) {
+    FormulaTypes["STATIC"] = "static";
+    FormulaTypes["DYNAMIC"] = "dynamic";
+})(FormulaTypes = exports.FormulaTypes || (exports.FormulaTypes = {}));
+var AuthTypes;
+(function (AuthTypes) {
+    AuthTypes["APP"] = "app";
+    AuthTypes["BUILDER"] = "builder";
+    AuthTypes["EXTERNAL"] = "external";
+})(AuthTypes = exports.AuthTypes || (exports.AuthTypes = {}));
+var DataSourceOperation;
+(function (DataSourceOperation) {
+    DataSourceOperation["CREATE"] = "CREATE";
+    DataSourceOperation["READ"] = "READ";
+    DataSourceOperation["UPDATE"] = "UPDATE";
+    DataSourceOperation["DELETE"] = "DELETE";
+    DataSourceOperation["BULK_CREATE"] = "BULK_CREATE";
+    DataSourceOperation["CREATE_TABLE"] = "CREATE_TABLE";
+    DataSourceOperation["UPDATE_TABLE"] = "UPDATE_TABLE";
+    DataSourceOperation["DELETE_TABLE"] = "DELETE_TABLE";
+})(DataSourceOperation = exports.DataSourceOperation || (exports.DataSourceOperation = {}));
+var DatasourceAuthTypes;
+(function (DatasourceAuthTypes) {
+    DatasourceAuthTypes["GOOGLE"] = "google";
+})(DatasourceAuthTypes = exports.DatasourceAuthTypes || (exports.DatasourceAuthTypes = {}));
+var SortDirection;
+(function (SortDirection) {
+    SortDirection["ASCENDING"] = "ASCENDING";
+    SortDirection["DESCENDING"] = "DESCENDING";
+})(SortDirection = exports.SortDirection || (exports.SortDirection = {}));
+exports.USERS_TABLE_SCHEMA = {
+    _id: "ta_users",
+    type: "table",
+    views: {},
+    name: "Users",
+    // TODO: ADMIN PANEL - when implemented this doesn't need to be carried out
+    schema: {
+        email: {
+            type: exports.FieldTypes.STRING,
+            constraints: {
+                type: exports.FieldTypes.STRING,
+                email: true,
+                length: {
+                    maximum: "",
+                },
+                presence: true,
+            },
+            fieldName: "email",
+            name: "email",
+        },
+        firstName: {
+            name: "firstName",
+            fieldName: "firstName",
+            type: exports.FieldTypes.STRING,
+            constraints: {
+                type: exports.FieldTypes.STRING,
+                presence: false,
+            },
+        },
+        lastName: {
+            name: "lastName",
+            fieldName: "lastName",
+            type: exports.FieldTypes.STRING,
+            constraints: {
+                type: exports.FieldTypes.STRING,
+                presence: false,
+            },
+        },
+        roleId: {
+            fieldName: "roleId",
+            name: "roleId",
+            type: exports.FieldTypes.OPTIONS,
+            constraints: {
+                type: exports.FieldTypes.STRING,
+                presence: false,
+                inclusion: Object.values(backend_core_1.roles.BUILTIN_ROLE_IDS),
+            },
+        },
+        status: {
+            fieldName: "status",
+            name: "status",
+            type: exports.FieldTypes.OPTIONS,
+            constraints: {
+                type: exports.FieldTypes.STRING,
+                presence: false,
+                inclusion: Object.values(backend_core_1.constants.UserStatus),
+            },
+        },
+    },
+    primaryDisplay: "email",
+};
+var AutoFieldSubTypes;
+(function (AutoFieldSubTypes) {
+    AutoFieldSubTypes["CREATED_BY"] = "createdBy";
+    AutoFieldSubTypes["CREATED_AT"] = "createdAt";
+    AutoFieldSubTypes["UPDATED_BY"] = "updatedBy";
+    AutoFieldSubTypes["UPDATED_AT"] = "updatedAt";
+    AutoFieldSubTypes["AUTO_ID"] = "autoID";
+})(AutoFieldSubTypes = exports.AutoFieldSubTypes || (exports.AutoFieldSubTypes = {}));
+var AutoFieldDefaultNames;
+(function (AutoFieldDefaultNames) {
+    AutoFieldDefaultNames["CREATED_BY"] = "Created By";
+    AutoFieldDefaultNames["CREATED_AT"] = "Created At";
+    AutoFieldDefaultNames["UPDATED_BY"] = "Updated By";
+    AutoFieldDefaultNames["UPDATED_AT"] = "Updated At";
+    AutoFieldDefaultNames["AUTO_ID"] = "Auto ID";
+})(AutoFieldDefaultNames = exports.AutoFieldDefaultNames || (exports.AutoFieldDefaultNames = {}));
+exports.OBJ_STORE_DIRECTORY = "/prod-budi-app-assets";
+var BaseQueryVerbs;
+(function (BaseQueryVerbs) {
+    BaseQueryVerbs["CREATE"] = "create";
+    BaseQueryVerbs["READ"] = "read";
+    BaseQueryVerbs["UPDATE"] = "update";
+    BaseQueryVerbs["DELETE"] = "delete";
+})(BaseQueryVerbs = exports.BaseQueryVerbs || (exports.BaseQueryVerbs = {}));
+var MetadataTypes;
+(function (MetadataTypes) {
+    MetadataTypes["AUTOMATION_TEST_INPUT"] = "automationTestInput";
+    MetadataTypes["AUTOMATION_TEST_HISTORY"] = "automationTestHistory";
+})(MetadataTypes = exports.MetadataTypes || (exports.MetadataTypes = {}));
+var InvalidColumns;
+(function (InvalidColumns) {
+    InvalidColumns["ID"] = "_id";
+    InvalidColumns["REV"] = "_rev";
+    InvalidColumns["TABLE_ID"] = "tableId";
+})(InvalidColumns = exports.InvalidColumns || (exports.InvalidColumns = {}));
+var BuildSchemaErrors;
+(function (BuildSchemaErrors) {
+    BuildSchemaErrors["NO_KEY"] = "no_key";
+    BuildSchemaErrors["INVALID_COLUMN"] = "invalid_column";
+})(BuildSchemaErrors = exports.BuildSchemaErrors || (exports.BuildSchemaErrors = {}));
+var AutomationErrors;
+(function (AutomationErrors) {
+    AutomationErrors["INCORRECT_TYPE"] = "INCORRECT_TYPE";
+    AutomationErrors["MAX_ITERATIONS"] = "MAX_ITERATIONS_REACHED";
+    AutomationErrors["FAILURE_CONDITION"] = "FAILURE_CONDITION_MET";
+})(AutomationErrors = exports.AutomationErrors || (exports.AutomationErrors = {}));
+// pass through the list from the auth/core lib
+exports.ObjectStoreBuckets = backend_core_1.objectStore.ObjectStoreBuckets;
+exports.MAX_AUTOMATION_RECURRING_ERRORS = 5;
+exports.GOOGLE_SHEETS_PRIMARY_KEY = "rowNumber";