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

package/dist/automations/triggerInfo/cron.js

@@ -0,0 +1,32 @@
+"use strict";
+exports.definition = {
+    name: "Cron Trigger",
+    event: "cron:trigger",
+    icon: "ri-timer-line",
+    tagline: "Cron Trigger (<b>{{inputs.cron}}</b>)",
+    description: "Triggers automation on a cron schedule.",
+    stepId: "CRON",
+    inputs: {},
+    schema: {
+        inputs: {
+            properties: {
+                cron: {
+                    type: "string",
+                    customType: "cron",
+                    title: "Expression",
+                },
+            },
+            required: ["cron"],
+        },
+        outputs: {
+            properties: {
+                timestamp: {
+                    type: "number",
+                    description: "Timestamp the cron was executed",
+                },
+            },
+            required: ["timestamp"],
+        },
+    },
+    type: "TRIGGER",
+};

package/dist/automations/triggerInfo/index.js

@@ -0,0 +1,15 @@
+"use strict";
+const app = require("./app");
+const cron = require("./cron");
+const rowDeleted = require("./rowDeleted");
+const rowSaved = require("./rowSaved");
+const rowUpdated = require("./rowUpdated");
+const webhook = require("./webhook");
+exports.definitions = {
+    ROW_SAVED: rowSaved.definition,
+    ROW_UPDATED: rowUpdated.definition,
+    ROW_DELETED: rowDeleted.definition,
+    WEBHOOK: webhook.definition,
+    APP: app.definition,
+    CRON: cron.definition,
+};

package/dist/automations/triggerInfo/rowDeleted.js

@@ -0,0 +1,33 @@
+"use strict";
+exports.definition = {
+    name: "Row Deleted",
+    event: "row:delete",
+    icon: "ri-delete-bin-line",
+    tagline: "Row is deleted from {{inputs.enriched.table.name}}",
+    description: "Fired when a row is deleted from your database",
+    stepId: "ROW_DELETED",
+    inputs: {},
+    schema: {
+        inputs: {
+            properties: {
+                tableId: {
+                    type: "string",
+                    customType: "table",
+                    title: "Table",
+                },
+            },
+            required: ["tableId"],
+        },
+        outputs: {
+            properties: {
+                row: {
+                    type: "object",
+                    customType: "row",
+                    description: "The row that was deleted",
+                },
+            },
+            required: ["row"],
+        },
+    },
+    type: "TRIGGER",
+};

package/dist/automations/triggerInfo/rowSaved.js

@@ -0,0 +1,41 @@
+"use strict";
+exports.definition = {
+    name: "Row Created",
+    event: "row:save",
+    icon: "ri-save-line",
+    tagline: "Row is added to {{inputs.enriched.table.name}}",
+    description: "Fired when a row is added to your database",
+    stepId: "ROW_SAVED",
+    inputs: {},
+    schema: {
+        inputs: {
+            properties: {
+                tableId: {
+                    type: "string",
+                    customType: "table",
+                    title: "Table",
+                },
+            },
+            required: ["tableId"],
+        },
+        outputs: {
+            properties: {
+                row: {
+                    type: "object",
+                    customType: "row",
+                    description: "The new row that was created",
+                },
+                id: {
+                    type: "string",
+                    description: "Row ID - can be used for updating",
+                },
+                revision: {
+                    type: "string",
+                    description: "Revision of row",
+                },
+            },
+            required: ["row", "id"],
+        },
+    },
+    type: "TRIGGER",
+};

package/dist/automations/triggerInfo/rowUpdated.js

@@ -0,0 +1,41 @@
+"use strict";
+exports.definition = {
+    name: "Row Updated",
+    event: "row:update",
+    icon: "ri-refresh-line",
+    tagline: "Row is updated in {{inputs.enriched.table.name}}",
+    description: "Fired when a row is updated in your database",
+    stepId: "ROW_UPDATED",
+    inputs: {},
+    schema: {
+        inputs: {
+            properties: {
+                tableId: {
+                    type: "string",
+                    customType: "table",
+                    title: "Table",
+                },
+            },
+            required: ["tableId"],
+        },
+        outputs: {
+            properties: {
+                row: {
+                    type: "object",
+                    customType: "row",
+                    description: "The row that was updated",
+                },
+                id: {
+                    type: "string",
+                    description: "Row ID - can be used for updating",
+                },
+                revision: {
+                    type: "string",
+                    description: "Revision of row",
+                },
+            },
+            required: ["row", "id"],
+        },
+    },
+    type: "TRIGGER",
+};

package/dist/automations/triggerInfo/webhook.js

@@ -0,0 +1,37 @@
+"use strict";
+exports.definition = {
+    name: "Webhook",
+    event: "web:trigger",
+    icon: "ri-global-line",
+    tagline: "Webhook endpoint is hit",
+    description: "Trigger an automation when a HTTP POST webhook is hit",
+    stepId: "WEBHOOK",
+    inputs: {},
+    schema: {
+        inputs: {
+            properties: {
+                schemaUrl: {
+                    type: "string",
+                    customType: "webhookUrl",
+                    title: "Schema URL",
+                },
+                triggerUrl: {
+                    type: "string",
+                    customType: "webhookUrl",
+                    title: "Trigger URL",
+                },
+            },
+            required: ["schemaUrl", "triggerUrl"],
+        },
+        outputs: {
+            properties: {
+                body: {
+                    type: "object",
+                    description: "Body of the request which hit the webhook",
+                },
+            },
+            required: ["body"],
+        },
+    },
+    type: "TRIGGER",
+};

package/dist/automations/triggers.js

@@ -10,234 +10,16 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 const CouchDB = require("../db");
 const emitter = require("../events/index");
-const env = require("../environment");
-const Queue = env.isTest()
-    ? require("../utilities/queue/inMemoryQueue")
-    : require("bull");
 const { getAutomationParams } = require("../db/utils");
 const { coerce } = require("../utilities/rowProcessor");
-const { utils } = require("@budibase/auth/redis");
-const { JobQueues } = require("../constants");
-const { isExternalTable, breakExternalTableId, } = require("../integrations/utils");
-const { getExternalTable } = require("../api/controllers/table/utils");
-const { opts } = utils.getRedisOptions();
-let automationQueue = new Queue(JobQueues.AUTOMATIONS, { redis: opts });
-const FAKE_STRING = "TEST";
-const FAKE_BOOL = false;
-const FAKE_NUMBER = 1;
-const FAKE_DATETIME = "1970-01-01T00:00:00.000Z";
-const BUILTIN_DEFINITIONS = {
-    ROW_SAVED: {
-        name: "Row Created",
-        event: "row:save",
-        icon: "ri-save-line",
-        tagline: "Row is added to {{inputs.enriched.table.name}}",
-        description: "Fired when a row is added to your database",
-        stepId: "ROW_SAVED",
-        inputs: {},
-        schema: {
-            inputs: {
-                properties: {
-                    tableId: {
-                        type: "string",
-                        customType: "table",
-                        title: "Table",
-                    },
-                },
-                required: ["tableId"],
-            },
-            outputs: {
-                properties: {
-                    row: {
-                        type: "object",
-                        customType: "row",
-                        description: "The new row that was created",
-                    },
-                    id: {
-                        type: "string",
-                        description: "Row ID - can be used for updating",
-                    },
-                    revision: {
-                        type: "string",
-                        description: "Revision of row",
-                    },
-                },
-                required: ["row", "id"],
-            },
-        },
-        type: "TRIGGER",
-    },
-    ROW_UPDATED: {
-        name: "Row Updated",
-        event: "row:update",
-        icon: "ri-refresh-line",
-        tagline: "Row is updated in {{inputs.enriched.table.name}}",
-        description: "Fired when a row is updated in your database",
-        stepId: "ROW_UPDATED",
-        inputs: {},
-        schema: {
-            inputs: {
-                properties: {
-                    tableId: {
-                        type: "string",
-                        customType: "table",
-                        title: "Table",
-                    },
-                },
-                required: ["tableId"],
-            },
-            outputs: {
-                properties: {
-                    row: {
-                        type: "object",
-                        customType: "row",
-                        description: "The row that was updated",
-                    },
-                    id: {
-                        type: "string",
-                        description: "Row ID - can be used for updating",
-                    },
-                    revision: {
-                        type: "string",
-                        description: "Revision of row",
-                    },
-                },
-                required: ["row", "id"],
-            },
-        },
-        type: "TRIGGER",
-    },
-    ROW_DELETED: {
-        name: "Row Deleted",
-        event: "row:delete",
-        icon: "ri-delete-bin-line",
-        tagline: "Row is deleted from {{inputs.enriched.table.name}}",
-        description: "Fired when a row is deleted from your database",
-        stepId: "ROW_DELETED",
-        inputs: {},
-        schema: {
-            inputs: {
-                properties: {
-                    tableId: {
-                        type: "string",
-                        customType: "table",
-                        title: "Table",
-                    },
-                },
-                required: ["tableId"],
-            },
-            outputs: {
-                properties: {
-                    row: {
-                        type: "object",
-                        customType: "row",
-                        description: "The row that was deleted",
-                    },
-                },
-                required: ["row"],
-            },
-        },
-        type: "TRIGGER",
-    },
-    WEBHOOK: {
-        name: "Webhook",
-        event: "web:trigger",
-        icon: "ri-global-line",
-        tagline: "Webhook endpoint is hit",
-        description: "Trigger an automation when a HTTP POST webhook is hit",
-        stepId: "WEBHOOK",
-        inputs: {},
-        schema: {
-            inputs: {
-                properties: {
-                    schemaUrl: {
-                        type: "string",
-                        customType: "webhookUrl",
-                        title: "Schema URL",
-                    },
-                    triggerUrl: {
-                        type: "string",
-                        customType: "webhookUrl",
-                        title: "Trigger URL",
-                    },
-                },
-                required: ["schemaUrl", "triggerUrl"],
-            },
-            outputs: {
-                properties: {
-                    body: {
-                        type: "object",
-                        description: "Body of the request which hit the webhook",
-                    },
-                },
-                required: ["body"],
-            },
-        },
-        type: "TRIGGER",
-    },
-    APP: {
-        name: "App Action",
-        event: "app:trigger",
-        icon: "ri-window-fill",
-        tagline: "Automation fired from the frontend",
-        description: "Trigger an automation from an action inside your app",
-        stepId: "APP",
-        inputs: {},
-        schema: {
-            inputs: {
-                properties: {
-                    fields: {
-                        type: "object",
-                        customType: "triggerSchema",
-                        title: "Fields",
-                    },
-                },
-                required: [],
-            },
-            outputs: {
-                properties: {
-                    fields: {
-                        type: "object",
-                        description: "Fields submitted from the app frontend",
-                    },
-                },
-                required: ["fields"],
-            },
-        },
-        type: "TRIGGER",
-    },
-    CRON: {
-        name: "Cron Trigger",
-        event: "cron:trigger",
-        icon: "ri-timer-line",
-        tagline: "Cron Trigger (<b>{{inputs.cron}}</b>)",
-        description: "Triggers automation on a cron schedule.",
-        stepId: "CRON",
-        inputs: {},
-        schema: {
-            inputs: {
-                properties: {
-                    cron: {
-                        type: "string",
-                        customType: "cron",
-                        title: "Expression",
-                    },
-                },
-                required: ["cron"],
-            },
-            outputs: {
-                properties: {
-                    timestamp: {
-                        type: "number",
-                        description: "Timestamp the cron was executed",
-                    },
-                },
-                required: ["timestamp"],
-            },
-        },
-        type: "TRIGGER",
-    },
-};
+const { definitions } = require("./triggerInfo");
+const { isDevAppID } = require("../db/utils");
+// need this to call directly, so we can get a response
+const { queue } = require("./bullboard");
+const { checkTestFlag } = require("../utilities/redis");
+const utils = require("./utils");
+const env = require("../environment");
+const TRIGGER_DEFINITIONS = definitions;
 function queueRelevantRowAutomations(event, eventType) {
     return __awaiter(this, void 0, void 0, function* () {
         if (event.appId == null) {
@@ -255,12 +37,18 @@ function queueRelevantRowAutomations(event, eventType) {
         for (let automation of automations) {
             let automationDef = automation.definition;
             let automationTrigger = automationDef ? automationDef.trigger : {};
-            if (!automation.live ||
-                !automationTrigger.inputs ||
-                automationTrigger.inputs.tableId !== event.row.tableId) {
+            // 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 (!env.ALLOW_DEV_AUTOMATIONS &&
+                isDevAppID(event.appId) &&
+                !(yield checkTestFlag(automation._id))) {
                 continue;
             }
-            automationQueue.add({ automation, event });
+            if (automationTrigger.inputs &&
+                automationTrigger.inputs.tableId === event.row.tableId) {
+                yield queue.add({ automation, event });
+            }
         }
     });
 }
@@ -291,55 +79,9 @@ emitter.on("row:delete", function (event) {
         yield queueRelevantRowAutomations(event, "row:delete");
     });
 });
-function fillRowOutput(automation, params) {
+exports.externalTrigger = function (automation, params, { getResponses } = {}) {
     return __awaiter(this, void 0, void 0, function* () {
-        let triggerSchema = automation.definition.trigger;
-        let tableId = triggerSchema.inputs.tableId;
-        try {
-            let table;
-            if (!isExternalTable(tableId)) {
-                const db = new CouchDB(params.appId);
-                table = yield db.get(tableId);
-            }
-            else {
-                const { datasourceId, tableName } = breakExternalTableId(tableId);
-                table = yield getExternalTable(params.appId, datasourceId, tableName);
-            }
-            let row = {};
-            for (let schemaKey of Object.keys(table.schema)) {
-                const paramValue = params[schemaKey];
-                let propSchema = table.schema[schemaKey];
-                switch (propSchema.constraints.type) {
-                    case "string":
-                        row[schemaKey] = paramValue || FAKE_STRING;
-                        break;
-                    case "boolean":
-                        row[schemaKey] = paramValue || FAKE_BOOL;
-                        break;
-                    case "number":
-                        row[schemaKey] = paramValue || FAKE_NUMBER;
-                        break;
-                    case "datetime":
-                        row[schemaKey] = paramValue || FAKE_DATETIME;
-                        break;
-                }
-            }
-            params.row = row;
-        }
-        catch (err) {
-            /* istanbul ignore next */
-            throw "Failed to find table for trigger";
-        }
-        return params;
-    });
-}
-module.exports.externalTrigger = function (automation, params) {
-    return __awaiter(this, void 0, void 0, function* () {
-        // TODO: replace this with allowing user in builder to input values in future
         if (automation.definition != null && automation.definition.trigger != null) {
-            if (automation.definition.trigger.inputs.tableId != null) {
-                params = yield fillRowOutput(automation, params);
-            }
             if (automation.definition.trigger.stepId === "APP") {
                 // values are likely to be submitted as strings, so we shall convert to correct type
                 const coercedFields = {};
@@ -350,12 +92,13 @@ module.exports.externalTrigger = function (automation, params) {
                 params.fields = coercedFields;
             }
         }
-        automationQueue.add({ automation, event: params });
+        const data = { automation, event: params };
+        if (getResponses) {
+            return utils.processEvent({ data });
+        }
+        else {
+            return queue.add(data);
+        }
     });
 };
-module.exports.getQueues = () => {
-    return [automationQueue];
-};
-module.exports.fillRowOutput = fillRowOutput;
-module.exports.automationQueue = automationQueue;
-module.exports.BUILTIN_DEFINITIONS = BUILTIN_DEFINITIONS;
+exports.TRIGGER_DEFINITIONS = TRIGGER_DEFINITIONS;