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

package/dist/automations/steps/sendSmtpEmail.js

@@ -9,12 +9,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 const { sendSmtpEmail } = require("../../utilities/workerRequests");
-module.exports.definition = {
+exports.definition = {
     description: "Send an email using SMTP",
     tagline: "Send SMTP email to {{inputs.to}}",
     icon: "ri-mail-open-line",
     name: "Send Email (SMTP)",
     type: "ACTION",
+    internal: true,
     stepId: "SEND_EMAIL_SMTP",
     inputs: {},
     schema: {
@@ -54,7 +55,7 @@ module.exports.definition = {
         },
     },
 };
-module.exports.run = function ({ inputs }) {
+exports.run = function ({ inputs }) {
     return __awaiter(this, void 0, void 0, function* () {
         let { to, from, subject, contents } = inputs;
         if (!contents) {
@@ -68,7 +69,6 @@ module.exports.run = function ({ inputs }) {
             };
         }
         catch (err) {
-            console.error(err);
             return {
                 success: false,
                 response: err,

package/dist/automations/steps/serverLog.js

@@ -13,12 +13,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-module.exports.definition = {
+exports.definition = {
     name: "Backend log",
     tagline: "Console log a value in the backend",
     icon: "ri-server-line",
     description: "Logs the given text to the server (using console.log)",
     type: "ACTION",
+    internal: true,
     stepId: "SERVER_LOG",
     inputs: {
         text: "",
@@ -44,8 +45,11 @@ module.exports.definition = {
         },
     },
 };
-module.exports.run = function ({ inputs, appId }) {
+exports.run = function ({ inputs, appId }) {
     return __awaiter(this, void 0, void 0, function* () {
         console.log(`App ${appId} - ${inputs.text}`);
+        return {
+            success: true,
+        };
     });
 };

package/dist/automations/steps/slack.js

@@ -0,0 +1,73 @@
+"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 fetch = require("node-fetch");
+const { getFetchResponse } = require("./utils");
+exports.definition = {
+    name: "Slack Message",
+    tagline: "Send a message to Slack",
+    description: "Send a message to Slack",
+    icon: "ri-slack-line",
+    stepId: "slack",
+    type: "ACTION",
+    internal: false,
+    inputs: {},
+    schema: {
+        inputs: {
+            properties: {
+                url: {
+                    type: "string",
+                    title: "Incoming Webhook URL",
+                },
+                text: {
+                    type: "string",
+                    title: "Message",
+                },
+            },
+            required: ["url", "text"],
+        },
+        outputs: {
+            properties: {
+                httpStatus: {
+                    type: "number",
+                    description: "The HTTP status code of the request",
+                },
+                success: {
+                    type: "boolean",
+                    description: "Whether the message sent successfully",
+                },
+                response: {
+                    type: "string",
+                    description: "The response from the Slack Webhook",
+                },
+            },
+        },
+    },
+};
+exports.run = function ({ inputs }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let { url, text } = inputs;
+        const response = yield fetch(url, {
+            method: "post",
+            body: JSON.stringify({
+                text,
+            }),
+            headers: {
+                "Content-Type": "application/json",
+            },
+        });
+        const { status, message } = yield getFetchResponse(response);
+        return {
+            httpStatus: status,
+            response: message,
+            success: status === 200,
+        };
+    });
+};

package/dist/automations/steps/updateRow.js

@@ -10,12 +10,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 const rowController = require("../../api/controllers/row");
 const automationUtils = require("../automationUtils");
-module.exports.definition = {
+exports.definition = {
     name: "Update Row",
     tagline: "Update a {{inputs.enriched.table.name}} row",
     icon: "ri-refresh-line",
     description: "Update a row in your database",
     type: "ACTION",
+    internal: true,
     stepId: "UPDATE_ROW",
     inputs: {},
     schema: {
@@ -61,7 +62,7 @@ module.exports.definition = {
         },
     },
 };
-module.exports.run = function ({ inputs, appId, emitter }) {
+exports.run = function ({ inputs, appId, emitter }) {
     return __awaiter(this, void 0, void 0, function* () {
         if (inputs.rowId == null || inputs.row == null) {
             return {
@@ -100,7 +101,6 @@ module.exports.run = function ({ inputs, appId, emitter }) {
             };
         }
         catch (err) {
-            console.error(err);
             return {
                 success: false,
                 response: err,

package/dist/automations/steps/utils.js

@@ -0,0 +1,46 @@
+"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());
+    });
+};
+exports.getFetchResponse = (fetched) => __awaiter(void 0, void 0, void 0, function* () {
+    let status = fetched.status, message;
+    const contentType = fetched.headers.get("content-type");
+    try {
+        if (contentType && contentType.indexOf("application/json") !== -1) {
+            message = yield fetched.json();
+        }
+        else {
+            message = yield fetched.text();
+        }
+    }
+    catch (err) {
+        message = "Failed to retrieve response";
+    }
+    return { status, message };
+});
+// need to make sure all ctx structures have the
+// throw added to them, so that controllers don't
+// throw a ctx.throw undefined when error occurs
+exports.buildCtx = (appId, emitter, { body, params } = {}) => {
+    const ctx = {
+        appId,
+        user: { appId },
+        eventEmitter: emitter,
+        throw: (code, error) => {
+            throw error;
+        },
+    };
+    if (body) {
+        ctx.request = { body };
+    }
+    if (params) {
+        ctx.params = params;
+    }
+    return ctx;
+};

package/dist/automations/steps/zapier.js

@@ -0,0 +1,91 @@
+"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 fetch = require("node-fetch");
+const { getFetchResponse } = require("./utils");
+exports.definition = {
+    name: "Zapier Webhook",
+    stepId: "zapier",
+    type: "ACTION",
+    internal: false,
+    description: "Trigger a Zapier Zap via webhooks",
+    tagline: "Trigger a Zapier Zap",
+    icon: "ri-flashlight-line",
+    schema: {
+        inputs: {
+            properties: {
+                url: {
+                    type: "string",
+                    title: "Webhook URL",
+                },
+                value1: {
+                    type: "string",
+                    title: "Payload Value 1",
+                },
+                value2: {
+                    type: "string",
+                    title: "Payload Value 2",
+                },
+                value3: {
+                    type: "string",
+                    title: "Payload Value 3",
+                },
+                value4: {
+                    type: "string",
+                    title: "Payload Value 4",
+                },
+                value5: {
+                    type: "string",
+                    title: "Payload Value 5",
+                },
+            },
+            required: ["url"],
+        },
+        outputs: {
+            properties: {
+                httpStatus: {
+                    type: "number",
+                    description: "The HTTP status code of the request",
+                },
+                response: {
+                    type: "string",
+                    description: "The response from Zapier",
+                },
+            },
+        },
+    },
+};
+exports.run = function ({ inputs }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { url, value1, value2, value3, value4, value5 } = inputs;
+        // send the platform to make sure zaps always work, even
+        // if no values supplied
+        const response = yield fetch(url, {
+            method: "post",
+            body: JSON.stringify({
+                platform: "budibase",
+                value1,
+                value2,
+                value3,
+                value4,
+                value5,
+            }),
+            headers: {
+                "Content-Type": "application/json",
+            },
+        });
+        const { status, message } = yield getFetchResponse(response);
+        return {
+            success: status === 200,
+            httpStatus: status,
+            response: message,
+        };
+    });
+};

package/dist/automations/tests/utilities/index.js

@@ -10,7 +10,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 const TestConfig = require("../../../tests/utilities/TestConfiguration");
 const actions = require("../../actions");
-const logic = require("../../logic");
 const emitter = require("../../../events/index");
 const env = require("../../../environment");
 let config;
@@ -41,15 +40,7 @@ exports.runInProd = (fn) => __awaiter(void 0, void 0, void 0, function* () {
 });
 exports.runStep = function runStep(stepId, inputs) {
     return __awaiter(this, void 0, void 0, function* () {
-        let step;
-        if (Object.values(exports.actions)
-            .map(action => action.stepId)
-            .includes(stepId)) {
-            step = yield actions.getAction(stepId);
-        }
-        else {
-            step = logic.getLogic(stepId);
-        }
+        let step = yield actions.getAction(stepId);
         expect(step).toBeDefined();
         return step({
             inputs,
@@ -61,5 +52,4 @@ exports.runStep = function runStep(stepId, inputs) {
     });
 };
 exports.apiKey = "test";
-exports.actions = actions.BUILTIN_DEFINITIONS;
-exports.logic = logic.BUILTIN_DEFINITIONS;
+exports.actions = actions.ACTION_DEFINITIONS;

package/dist/automations/thread.js

@@ -9,7 +9,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 const actions = require("./actions");
-const logic = require("./logic");
 const automationUtils = require("./automationUtils");
 const AutomationEmitter = require("../events/AutomationEmitter");
 const { processObject } = require("@budibase/string-templates");
@@ -17,7 +16,7 @@ const { DEFAULT_TENANT_ID } = require("@budibase/auth").constants;
 const CouchDB = require("../db");
 const { DocumentTypes } = require("../db/utils");
 const { doInTenant } = require("@budibase/auth/tenancy");
-const FILTER_STEP_ID = logic.BUILTIN_DEFINITIONS.FILTER.stepId;
+const FILTER_STEP_ID = actions.ACTION_DEFINITIONS.FILTER.stepId;
 /**
  * The automation orchestrator is a class responsible for executing automations.
  * It handles the context of the automation and makes sure each step gets the correct
@@ -38,16 +37,15 @@ class Orchestrator {
         // create an emitter which has the chain count for this automation run in it, so it can block
         // excessive chaining if required
         this._emitter = new AutomationEmitter(this._chainCount + 1);
+        this.executionOutput = { trigger: {}, steps: [] };
+        // setup the execution output
+        const triggerStepId = automation.definition.trigger.stepId;
+        const triggerId = automation.definition.trigger.id;
+        this.updateExecutionOutput(triggerId, triggerStepId, null, triggerOutput);
     }
-    getStepFunctionality(type, stepId) {
+    getStepFunctionality(stepId) {
         return __awaiter(this, void 0, void 0, function* () {
-            let step = null;
-            if (type === "ACTION") {
-                step = yield actions.getAction(stepId);
-            }
-            else if (type === "LOGIC") {
-                step = logic.getLogic(stepId);
-            }
+            let step = yield actions.getAction(stepId);
             if (step == null) {
                 throw `Cannot find automation step by name ${stepId}`;
             }
@@ -65,12 +63,20 @@ class Orchestrator {
             return this._app;
         });
     }
+    updateExecutionOutput(id, stepId, inputs, outputs) {
+        const stepObj = { id, stepId, inputs, outputs };
+        // first entry is always the trigger (constructor)
+        if (this.executionOutput.steps.length === 0) {
+            this.executionOutput.trigger = stepObj;
+        }
+        this.executionOutput.steps.push(stepObj);
+    }
     execute() {
         return __awaiter(this, void 0, void 0, function* () {
             let automation = this._automation;
             const app = yield this.getApp();
             for (let step of automation.definition.steps) {
-                let stepFn = yield this.getStepFunctionality(step.type, step.stepId);
+                let stepFn = yield this.getStepFunctionality(step.stepId);
                 step.inputs = yield processObject(step.inputs, this._context);
                 step.inputs = automationUtils.cleanInputValues(step.inputs, step.schema.inputs);
                 // appId is always passed
@@ -89,26 +95,18 @@ class Orchestrator {
                         break;
                     }
                     this._context.steps.push(outputs);
+                    this.updateExecutionOutput(step.id, step.stepId, step.inputs, outputs);
                 }
                 catch (err) {
                     console.error(`Automation error - ${step.stepId} - ${err}`);
+                    return err;
                 }
             }
+            return this.executionOutput;
         });
     }
 }
-// callback is required for worker-farm to state that the worker thread has completed
-module.exports = (job, cb = null) => __awaiter(void 0, void 0, void 0, function* () {
-    try {
-        const automationOrchestrator = new Orchestrator(job.data.automation, job.data.event);
-        yield automationOrchestrator.execute();
-        if (cb) {
-            cb();
-        }
-    }
-    catch (err) {
-        if (cb) {
-            cb(err);
-        }
-    }
+module.exports = (job) => __awaiter(void 0, void 0, void 0, function* () {
+    const automationOrchestrator = new Orchestrator(job.data.automation, job.data.event);
+    return automationOrchestrator.execute();
 });

package/dist/automations/triggerInfo/app.js

@@ -0,0 +1,32 @@
+"use strict";
+exports.definition = {
+    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",
+};