@budibase/server 0.9.125-alpha.4 → 0.9.125-alpha.8

package/dist/api/controllers/automation.js

@@ -10,17 +10,23 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 const CouchDB = require("../../db");
 const actions = require("../../automations/actions");
-const logic = require("../../automations/logic");
 const triggers = require("../../automations/triggers");
-const webhooks = require("./webhook");
 const { getAutomationParams, generateAutomationID } = require("../../db/utils");
-const WH_STEP_ID = triggers.BUILTIN_DEFINITIONS.WEBHOOK.stepId;
-const CRON_STEP_ID = triggers.BUILTIN_DEFINITIONS.CRON.stepId;
+const { checkForWebhooks, updateTestHistory, } = require("../../automations/utils");
+const { deleteEntityMetadata } = require("../../utilities");
+const { MetadataTypes } = require("../../constants");
+const { setTestFlag, clearTestFlag } = require("../../utilities/redis");
 /*************************
  *                       *
  *   BUILDER FUNCTIONS   *
  *                       *
  *************************/
+function cleanupAutomationMetadata(appId, automationId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield deleteEntityMetadata(appId, MetadataTypes.AUTOMATION_TEST_INPUT, automationId);
+        yield deleteEntityMetadata(appId, MetadataTypes.AUTOMATION_TEST_HISTORY, automationId);
+    });
+}
 function cleanAutomationInputs(automation) {
     if (automation == null) {
         return automation;
@@ -28,6 +34,10 @@ function cleanAutomationInputs(automation) {
     let steps = automation.definition.steps;
     let trigger = automation.definition.trigger;
     let allSteps = [...steps, trigger];
+    // live is not a property used anymore
+    if (automation.live != null) {
+        delete automation.live;
+    }
     for (let step of allSteps) {
         if (step == null) {
             continue;
@@ -40,101 +50,6 @@ function cleanAutomationInputs(automation) {
     }
     return automation;
 }
-/**
- * This function handles checking of any cron jobs 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
- */
-function checkForCronTriggers({ appId, oldAuto, newAuto }) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const oldTrigger = oldAuto ? oldAuto.definition.trigger : null;
-        const newTrigger = newAuto ? newAuto.definition.trigger : null;
-        function isCronTrigger(auto) {
-            return (auto &&
-                auto.definition.trigger &&
-                auto.definition.trigger.stepId === CRON_STEP_ID);
-        }
-        const isLive = auto => auto && auto.live;
-        const cronTriggerRemoved = isCronTrigger(oldAuto) && !isCronTrigger(newAuto) && oldTrigger.cronJobId;
-        const cronTriggerDeactivated = !isLive(newAuto) && isLive(oldAuto);
-        const cronTriggerActivated = isLive(newAuto) && !isLive(oldAuto);
-        if (cronTriggerRemoved || (cronTriggerDeactivated && oldTrigger.cronJobId)) {
-            yield triggers.automationQueue.removeRepeatableByKey(oldTrigger.cronJobId);
-        }
-        // need to create cron job
-        else if (isCronTrigger(newAuto) && cronTriggerActivated) {
-            const job = yield triggers.automationQueue.add({
-                automation: newAuto,
-                event: { appId, timestamp: Date.now() },
-            }, { repeat: { cron: newTrigger.inputs.cron } });
-            // Assign cron job ID from bull so we can remove it later if the cron trigger is removed
-            newTrigger.cronJobId = job.id;
-        }
-        return newAuto;
-    });
-}
-/**
- * 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({ appId, oldAuto, newAuto }) {
-    return __awaiter(this, void 0, void 0, function* () {
-        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 = new CouchDB(appId);
-                // need to get the webhook to get the rev
-                const webhook = yield db.get(oldTrigger.webhookId);
-                const ctx = {
-                    appId,
-                    params: { id: webhook._id, rev: webhook._rev },
-                };
-                // might be updating - reset the inputs to remove the URLs
-                if (newTrigger) {
-                    delete newTrigger.webhookId;
-                    newTrigger.inputs = {};
-                }
-                yield webhooks.destroy(ctx);
-            }
-            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 ctx = {
-                appId,
-                request: {
-                    body: new webhooks.Webhook("Automation webhook", webhooks.WebhookType.AUTOMATION, newAuto._id),
-                },
-            };
-            yield webhooks.save(ctx);
-            const id = ctx.body.webhook._id;
-            newTrigger.webhookId = id;
-            newTrigger.inputs = {
-                schemaUrl: `api/webhooks/schema/${appId}/${id}`,
-                triggerUrl: `api/webhooks/trigger/${appId}/${id}`,
-            };
-        }
-        return newAuto;
-    });
-}
 exports.create = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
         const db = new CouchDB(ctx.appId);
@@ -151,10 +66,6 @@ exports.create = function (ctx) {
             appId: ctx.appId,
             newAuto: automation,
         });
-        automation = yield checkForCronTriggers({
-            appId: ctx.appId,
-            newAuto: automation,
-        });
         const response = yield db.put(automation);
         automation._rev = response.rev;
         ctx.status = 200;
@@ -176,13 +87,18 @@ exports.update = function (ctx) {
             oldAuto: oldAutomation,
             newAuto: automation,
         });
-        automation = yield checkForCronTriggers({
-            appId: ctx.appId,
-            oldAuto: oldAutomation,
-            newAuto: automation,
-        });
         const response = yield db.put(automation);
         automation._rev = response.rev;
+        const oldAutoTrigger = oldAutomation && oldAutomation.definition.trigger
+            ? oldAutomation.definition.trigger
+            : {};
+        const newAutoTrigger = automation && automation.definition.trigger
+            ? automation.definition.trigger
+            : {};
+        // trigger has been updated, remove the test inputs
+        if (oldAutoTrigger.id !== newAutoTrigger.id) {
+            yield deleteEntityMetadata(ctx.appId, MetadataTypes.AUTOMATION_TEST_INPUT, automation._id);
+        }
         ctx.status = 200;
         ctx.body = {
             message: `Automation ${automation._id} updated successfully.`,
@@ -208,39 +124,32 @@ exports.find = function (ctx) {
 exports.destroy = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
         const db = new CouchDB(ctx.appId);
-        const oldAutomation = yield db.get(ctx.params.id);
+        const automationId = ctx.params.id;
+        const oldAutomation = yield db.get(automationId);
         yield checkForWebhooks({
             appId: ctx.appId,
             oldAuto: oldAutomation,
         });
-        yield checkForCronTriggers({
-            appId: ctx.appId,
-            oldAuto: oldAutomation,
-        });
-        ctx.body = yield db.remove(ctx.params.id, ctx.params.rev);
+        // delete metadata first
+        yield cleanupAutomationMetadata(ctx.appId, automationId);
+        ctx.body = yield db.remove(automationId, ctx.params.rev);
     });
 };
 exports.getActionList = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
-        ctx.body = actions.DEFINITIONS;
+        ctx.body = actions.ACTION_DEFINITIONS;
     });
 };
 exports.getTriggerList = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
-        ctx.body = triggers.BUILTIN_DEFINITIONS;
-    });
-};
-exports.getLogicList = function (ctx) {
-    return __awaiter(this, void 0, void 0, function* () {
-        ctx.body = logic.BUILTIN_DEFINITIONS;
+        ctx.body = triggers.TRIGGER_DEFINITIONS;
     });
 };
 module.exports.getDefinitionList = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
         ctx.body = {
-            logic: logic.BUILTIN_DEFINITIONS,
-            trigger: triggers.BUILTIN_DEFINITIONS,
-            action: actions.DEFINITIONS,
+            trigger: triggers.TRIGGER_DEFINITIONS,
+            action: actions.ACTION_DEFINITIONS,
         };
     });
 };
@@ -251,13 +160,26 @@ module.exports.getDefinitionList = function (ctx) {
  *********************/
 exports.trigger = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
-        const db = new CouchDB(ctx.appId);
+        const appId = ctx.appId;
+        const db = new CouchDB(appId);
         let automation = yield db.get(ctx.params.id);
-        yield triggers.externalTrigger(automation, Object.assign(Object.assign({}, ctx.request.body), { appId: ctx.appId }));
-        ctx.status = 200;
+        yield triggers.externalTrigger(automation, Object.assign(Object.assign({}, ctx.request.body), { appId }));
         ctx.body = {
             message: `Automation ${automation._id} has been triggered.`,
             automation,
         };
     });
 };
+exports.test = function (ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const appId = ctx.appId;
+        const db = new CouchDB(appId);
+        let automation = yield db.get(ctx.params.id);
+        yield setTestFlag(automation._id);
+        const response = yield triggers.externalTrigger(automation, Object.assign(Object.assign({}, ctx.request.body), { appId }), { getResponses: true });
+        // save a test history run
+        yield updateTestHistory(ctx.appId, automation, Object.assign(Object.assign({}, ctx.request.body), { occurredAt: new Date().getTime() }));
+        yield clearTestFlag(automation._id);
+        ctx.body = response;
+    });
+};

package/dist/api/controllers/deploy/index.js

@@ -11,7 +11,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 const CouchDB = require("../../../db");
 const Deployment = require("./Deployment");
 const { Replication } = require("@budibase/auth/db");
-const { DocumentTypes } = require("../../../db/utils");
+const { DocumentTypes, getAutomationParams } = require("../../../db/utils");
+const { disableAllCrons, enableCronTrigger, } = require("../../../automations/utils");
 // the max time we can wait for an invalidation to complete before considering it failed
 const MAX_PENDING_TIME_MS = 30 * 60000;
 const DeploymentStatus = {
@@ -58,6 +59,20 @@ function storeDeploymentHistory(deployment) {
         return deployment;
     });
 }
+function initDeployedApp(prodAppId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const db = new CouchDB(prodAppId);
+        const automations = (yield db.allDocs(getAutomationParams(null, {
+            include_docs: true,
+        }))).rows.map(row => row.doc);
+        const promises = [];
+        yield disableAllCrons(prodAppId);
+        for (let automation of automations) {
+            promises.push(enableCronTrigger(prodAppId, automation));
+        }
+        yield Promise.all(promises);
+    });
+}
 function deployApp(deployment) {
     return __awaiter(this, void 0, void 0, function* () {
         try {
@@ -82,6 +97,7 @@ function deployApp(deployment) {
                     return doc._id !== DocumentTypes.APP_METADATA;
                 },
             });
+            yield initDeployedApp(productionAppId);
             deployment.setStatus(DeploymentStatus.SUCCESS);
             yield storeDeploymentHistory(deployment);
         }

package/dist/api/controllers/metadata.js

@@ -0,0 +1,49 @@
+"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());
+    });
+};
+const { MetadataTypes } = require("../../constants");
+const CouchDB = require("../../db");
+const { generateMetadataID } = require("../../db/utils");
+const { saveEntityMetadata, deleteEntityMetadata } = require("../../utilities");
+exports.getTypes = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+    ctx.body = {
+        types: MetadataTypes,
+    };
+});
+exports.saveMetadata = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+    const { type, entityId } = ctx.params;
+    if (type === MetadataTypes.AUTOMATION_TEST_HISTORY) {
+        ctx.throw(400, "Cannot save automation history type");
+    }
+    ctx.body = yield saveEntityMetadata(ctx.appId, type, entityId, ctx.request.body);
+});
+exports.deleteMetadata = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+    const { type, entityId } = ctx.params;
+    yield deleteEntityMetadata(ctx.appId, type, entityId);
+    ctx.body = {
+        message: "Metadata deleted successfully",
+    };
+});
+exports.getMetadata = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+    const { type, entityId } = ctx.params;
+    const db = new CouchDB(ctx.appId);
+    const id = generateMetadataID(type, entityId);
+    try {
+        ctx.body = yield db.get(id);
+    }
+    catch (err) {
+        if (err.status === 404) {
+            ctx.body = {};
+        }
+        else {
+            ctx.throw(err.status, err);
+        }
+    }
+});

package/dist/api/controllers/query.js

@@ -146,8 +146,6 @@ exports.execute = function (ctx) {
         }
         const enrichedQuery = yield enrichQueryFields(query.fields, ctx.request.body.parameters);
         const integration = new Integration(datasource.config);
-        console.log(query);
-        // ctx.body = {}
         // call the relevant CRUD method on the integration class
         ctx.body = formatResponse(yield integration[query.queryVerb](enrichedQuery));
         // cleanup

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

@@ -34,6 +34,20 @@ const CALCULATION_TYPES = {
     COUNT: "count",
     STATS: "stats",
 };
+function storeResponse(ctx, db, row, oldTable, table) {
+    return __awaiter(this, void 0, void 0, function* () {
+        row.type = "row";
+        const response = yield db.put(row);
+        // don't worry about rev, tables handle rev/lastID updates
+        if (!isEqual(oldTable, table)) {
+            yield db.put(table);
+        }
+        row._rev = response.rev;
+        // process the row before return, to include relationships
+        row = yield outputProcessing(ctx, table, row, { squash: false });
+        return { row, table };
+    });
+}
 exports.patch = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
     const appId = ctx.appId;
     const db = new CouchDB(appId);
@@ -86,14 +100,7 @@ exports.patch = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
         yield userController.updateMetadata(ctx);
         return { row: ctx.body, table };
     }
-    const response = yield db.put(row);
-    // don't worry about rev, tables handle rev/lastID updates
-    if (!isEqual(dbTable, table)) {
-        yield db.put(table);
-    }
-    row._rev = response.rev;
-    row.type = "row";
-    return { row, table };
+    return storeResponse(ctx, db, row, dbTable, table);
 });
 exports.save = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -122,14 +129,7 @@ exports.save = function (ctx) {
             tableId: row.tableId,
             table,
         });
-        row.type = "row";
-        const response = yield db.put(row);
-        // don't worry about rev, tables handle rev/lastID updates
-        if (!isEqual(dbTable, table)) {
-            yield db.put(table);
-        }
-        row._rev = response.rev;
-        return { row, table };
+        return storeResponse(ctx, db, row, dbTable, table);
     });
 };
 exports.fetchView = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
@@ -209,41 +209,51 @@ exports.destroy = function (ctx) {
         const appId = ctx.appId;
         const db = new CouchDB(appId);
         const { _id, _rev } = ctx.request.body;
-        const row = yield db.get(_id);
+        let row = yield db.get(_id);
         if (row.tableId !== ctx.params.tableId) {
             throw "Supplied tableId doesn't match the row's tableId";
         }
+        const table = yield db.get(row.tableId);
+        // update the row to include full relationships before deleting them
+        row = yield outputProcessing(ctx, table, row, { squash: false });
+        // now remove the relationships
         yield linkRows.updateLinks({
             appId,
             eventType: linkRows.EventType.ROW_DELETE,
             row,
             tableId: row.tableId,
         });
+        let response;
         if (ctx.params.tableId === InternalTables.USER_METADATA) {
             ctx.params = {
                 id: _id,
             };
             yield userController.destroyMetadata(ctx);
-            return { response: ctx.body, row };
+            response = ctx.body;
         }
         else {
-            const response = yield db.remove(_id, _rev);
-            return { response, row };
+            response = yield db.remove(_id, _rev);
         }
+        return { response, row };
     });
 };
 exports.bulkDestroy = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
     const appId = ctx.appId;
-    const { rows } = ctx.request.body;
     const db = new CouchDB(appId);
+    const tableId = ctx.params.tableId;
+    const table = yield db.get(tableId);
+    let { rows } = ctx.request.body;
+    // before carrying out any updates, make sure the rows are ready to be returned
+    // they need to be the full rows (including previous relationships) for automations
+    rows = yield outputProcessing(ctx, table, rows, { squash: false });
+    // remove the relationships first
     let updates = rows.map(row => linkRows.updateLinks({
         appId,
         eventType: linkRows.EventType.ROW_DELETE,
         row,
         tableId: row.tableId,
     }));
-    // TODO remove special user case in future
-    if (ctx.params.tableId === InternalTables.USER_METADATA) {
+    if (tableId === InternalTables.USER_METADATA) {
         updates = updates.concat(rows.map(row => {
             ctx.params = {
                 id: row._id,