@budibase/server 0.9.138 → 0.9.140-alpha.2

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: "Apps",
+    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",
+};

package/dist/automations/triggerInfo/cron.js

@@ -0,0 +1,32 @@
+"use strict";
+exports.definition = {
+    name: "Cron Trigger",
+    event: "cron:trigger",
+    icon: "Clock",
+    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: "TableRowRemoveCenter",
+    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: "TableRowAddBottom",
+    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: "Refresh",
+    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: "Send",
+    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",
+};