@budibase/server 0.9.138 → 0.9.140-alpha.2

package/dist/automations/steps/filter.js

@@ -8,29 +8,30 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-const LogicConditions = {
+const FilterConditions = {
     EQUAL: "EQUAL",
     NOT_EQUAL: "NOT_EQUAL",
     GREATER_THAN: "GREATER_THAN",
     LESS_THAN: "LESS_THAN",
 };
-const PrettyLogicConditions = {
-    [LogicConditions.EQUAL]: "Equals",
-    [LogicConditions.NOT_EQUAL]: "Not equals",
-    [LogicConditions.GREATER_THAN]: "Greater than",
-    [LogicConditions.LESS_THAN]: "Less than",
+const PrettyFilterConditions = {
+    [FilterConditions.EQUAL]: "Equals",
+    [FilterConditions.NOT_EQUAL]: "Not equals",
+    [FilterConditions.GREATER_THAN]: "Greater than",
+    [FilterConditions.LESS_THAN]: "Less than",
 };
-module.exports.LogicConditions = LogicConditions;
-module.exports.PrettyLogicConditions = PrettyLogicConditions;
-module.exports.definition = {
+exports.FilterConditions = FilterConditions;
+exports.PrettyFilterConditions = PrettyFilterConditions;
+exports.definition = {
     name: "Filter",
     tagline: "{{inputs.field}} {{inputs.condition}} {{inputs.value}}",
-    icon: "ri-git-branch-line",
+    icon: "Branch2",
     description: "Filter any automations which do not meet certain conditions",
     type: "LOGIC",
+    internal: true,
     stepId: "FILTER",
     inputs: {
-        condition: LogicConditions.EQUALS,
+        condition: FilterConditions.EQUALS,
     },
     schema: {
         inputs: {
@@ -42,8 +43,8 @@ module.exports.definition = {
                 condition: {
                     type: "string",
                     title: "Condition",
-                    enum: Object.values(LogicConditions),
-                    pretty: Object.values(PrettyLogicConditions),
+                    enum: Object.values(FilterConditions),
+                    pretty: Object.values(PrettyFilterConditions),
                 },
                 value: {
                     type: "string",
@@ -63,7 +64,7 @@ module.exports.definition = {
         },
     },
 };
-module.exports.run = function filter({ inputs }) {
+exports.run = function filter({ inputs }) {
     return __awaiter(this, void 0, void 0, function* () {
         let { field, condition, value } = inputs;
         // coerce types so that we can use them
@@ -78,16 +79,16 @@ module.exports.run = function filter({ inputs }) {
         let success = false;
         if (typeof field !== "object" && typeof value !== "object") {
             switch (condition) {
-                case LogicConditions.EQUAL:
+                case FilterConditions.EQUAL:
                     success = field === value;
                     break;
-                case LogicConditions.NOT_EQUAL:
+                case FilterConditions.NOT_EQUAL:
                     success = field !== value;
                     break;
-                case LogicConditions.GREATER_THAN:
+                case FilterConditions.GREATER_THAN:
                     success = field > value;
                     break;
-                case LogicConditions.LESS_THAN:
+                case FilterConditions.LESS_THAN:
                     success = field < value;
                     break;
             }

package/dist/automations/steps/integromat.js

@@ -0,0 +1,94 @@
+"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: "Integromat Integration",
+    tagline: "Trigger an Integromat scenario",
+    description: "Performs a webhook call to Integromat and gets the response (if configured)",
+    icon: "ri-shut-down-line",
+    stepId: "integromat",
+    type: "ACTION",
+    internal: false,
+    inputs: {},
+    schema: {
+        inputs: {
+            properties: {
+                url: {
+                    type: "string",
+                    title: "Webhook URL",
+                },
+                value1: {
+                    type: "string",
+                    title: "Input Value 1",
+                },
+                value2: {
+                    type: "string",
+                    title: "Input Value 2",
+                },
+                value3: {
+                    type: "string",
+                    title: "Input Value 3",
+                },
+                value4: {
+                    type: "string",
+                    title: "Input Value 4",
+                },
+                value5: {
+                    type: "string",
+                    title: "Input Value 5",
+                },
+            },
+            required: ["url", "value1", "value2", "value3", "value4", "value5"],
+        },
+        outputs: {
+            properties: {
+                success: {
+                    type: "boolean",
+                    description: "Whether call was successful",
+                },
+                httpStatus: {
+                    type: "number",
+                    description: "The HTTP status code returned",
+                },
+                response: {
+                    type: "object",
+                    description: "The webhook response - this can have properties",
+                },
+            },
+            required: ["success", "response"],
+        },
+    },
+};
+exports.run = function ({ inputs }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { url, value1, value2, value3, value4, value5 } = inputs;
+        const response = yield fetch(url, {
+            method: "post",
+            body: JSON.stringify({
+                value1,
+                value2,
+                value3,
+                value4,
+                value5,
+            }),
+            headers: {
+                "Content-Type": "application/json",
+            },
+        });
+        const { status, message } = yield getFetchResponse(response);
+        return {
+            httpStatus: status,
+            success: status === 200,
+            response: message,
+        };
+    });
+};

package/dist/automations/steps/outgoingWebhook.js

@@ -9,6 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 const fetch = require("node-fetch");
+const { getFetchResponse } = require("./utils");
 const RequestType = {
     POST: "POST",
     GET: "GET",
@@ -22,12 +23,13 @@ const BODY_REQUESTS = [RequestType.POST, RequestType.PUT, RequestType.PATCH];
  * is complex and maybe better to be opinionated here.
  * GET/DELETE requests cannot handle body elements so they will not be sent if configured.
  */
-module.exports.definition = {
+exports.definition = {
     name: "Outgoing webhook",
     tagline: "Send a {{inputs.requestMethod}} request",
-    icon: "ri-send-plane-line",
+    icon: "Send",
     description: "Send a request of specified method to a URL",
     type: "ACTION",
+    internal: true,
     stepId: "OUTGOING_WEBHOOK",
     inputs: {
         requestMethod: "POST",
@@ -66,6 +68,10 @@ module.exports.definition = {
                     type: "object",
                     description: "The response from the webhook",
                 },
+                httpStatus: {
+                    type: "number",
+                    description: "The HTTP status code returned",
+                },
                 success: {
                     type: "boolean",
                     description: "Whether the action was successful",
@@ -75,7 +81,7 @@ module.exports.definition = {
         },
     },
 };
-module.exports.run = function ({ inputs }) {
+exports.run = function ({ inputs }) {
     return __awaiter(this, void 0, void 0, function* () {
         let { requestMethod, url, requestBody, headers } = inputs;
         if (!url.startsWith("http")) {
@@ -94,13 +100,16 @@ module.exports.run = function ({ inputs }) {
             request.headers = {
                 "Content-Type": "application/json",
             };
-            if (headers && headers.length !== 0) {
+            if (headers) {
                 try {
-                    const customHeaders = JSON.parse(headers);
+                    const customHeaders = typeof headers === "string" ? JSON.parse(headers) : headers;
                     request.headers = Object.assign(Object.assign({}, request.headers), customHeaders);
                 }
                 catch (err) {
-                    console.error(err);
+                    return {
+                        success: false,
+                        response: "Unable to process headers, must be a JSON object.",
+                    };
                 }
             }
         }
@@ -110,21 +119,11 @@ module.exports.run = function ({ inputs }) {
                 JSON.parse(request.body);
             }
             const response = yield fetch(url, request);
-            const contentType = response.headers.get("content-type");
-            const success = response.status === 200;
-            let resp;
-            if (!success) {
-                resp = response.statusText;
-            }
-            else if (contentType && contentType.indexOf("application/json") !== -1) {
-                resp = yield response.json();
-            }
-            else {
-                resp = yield response.text();
-            }
+            const { status, message } = yield getFetchResponse(response);
             return {
-                response: resp,
-                success: success,
+                httpStatus: status,
+                response: message,
+                success: status === 200,
             };
         }
         catch (err) {

package/dist/automations/steps/queryRows.js

@@ -0,0 +1,129 @@
+"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 rowController = require("../../api/controllers/row");
+const tableController = require("../../api/controllers/table");
+const { FieldTypes } = require("../../constants");
+const SortOrders = {
+    ASCENDING: "ascending",
+    DESCENDING: "descending",
+};
+const SortOrdersPretty = {
+    [SortOrders.ASCENDING]: "Ascending",
+    [SortOrders.DESCENDING]: "Descending",
+};
+exports.definition = {
+    description: "Query rows from the database",
+    icon: "Search",
+    name: "Query rows",
+    tagline: "Query rows from {{inputs.enriched.table.name}} table",
+    type: "ACTION",
+    stepId: "QUERY_ROWS",
+    internal: true,
+    inputs: {},
+    schema: {
+        inputs: {
+            properties: {
+                tableId: {
+                    type: "string",
+                    customType: "table",
+                    title: "Table",
+                },
+                filters: {
+                    type: "object",
+                    customType: "filters",
+                    title: "Filtering",
+                },
+                sortColumn: {
+                    type: "string",
+                    title: "Sort Column",
+                    customType: "column",
+                },
+                sortOrder: {
+                    type: "string",
+                    title: "Sort Order",
+                    enum: Object.values(SortOrders),
+                    pretty: Object.values(SortOrdersPretty),
+                },
+                limit: {
+                    type: "number",
+                    title: "Limit",
+                },
+            },
+            required: ["tableId"],
+        },
+        outputs: {
+            properties: {
+                rows: {
+                    type: "array",
+                    customType: "rows",
+                    description: "The rows that were found",
+                },
+                success: {
+                    type: "boolean",
+                    description: "Whether the deletion was successful",
+                },
+            },
+            required: ["rows", "success"],
+        },
+    },
+};
+function getTable(appId, tableId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const ctx = {
+            params: {
+                id: tableId,
+            },
+            appId,
+        };
+        yield tableController.find(ctx);
+        return ctx.body;
+    });
+}
+exports.run = function ({ inputs, appId }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { tableId, filters, sortColumn, sortOrder, limit } = inputs;
+        const table = yield getTable(appId, tableId);
+        let sortType = FieldTypes.STRING;
+        if (table && table.schema && sortColumn) {
+            const fieldType = table.schema[sortColumn].type;
+            sortType =
+                fieldType === FieldTypes.NUMBER ? FieldTypes.NUMBER : FieldTypes.STRING;
+        }
+        const ctx = {
+            params: {
+                tableId,
+            },
+            request: {
+                body: {
+                    sortOrder,
+                    sortType,
+                    sort: sortColumn,
+                    query: filters || {},
+                    limit,
+                },
+            },
+            appId,
+        };
+        try {
+            yield rowController.search(ctx);
+            return {
+                rows: ctx.body ? ctx.body.rows : [],
+                success: ctx.status === 200,
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                response: err,
+            };
+        }
+    });
+};

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",
+    icon: "Email",
     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",
+    icon: "Monitoring",
     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",
+    icon: "Refresh",
     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;
+};