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

package/src/automations/steps/filter.js

@@ -1,29 +1,30 @@
-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
+exports.FilterConditions = FilterConditions
+exports.PrettyFilterConditions = PrettyFilterConditions
 
-module.exports.definition = {
+exports.definition = {
   name: "Filter",
   tagline: "{{inputs.field}} {{inputs.condition}} {{inputs.value}}",
   icon: "ri-git-branch-line",
   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: {
@@ -35,8 +36,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",
@@ -57,7 +58,7 @@ module.exports.definition = {
   },
 }
 
-module.exports.run = async function filter({ inputs }) {
+exports.run = async function filter({ inputs }) {
   let { field, condition, value } = inputs
   // coerce types so that we can use them
   if (!isNaN(value) && !isNaN(field)) {
@@ -70,16 +71,16 @@ module.exports.run = async 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/src/automations/steps/integromat.js

@@ -0,0 +1,87 @@
+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 = async function ({ inputs }) {
+  const { url, value1, value2, value3, value4, value5 } = inputs
+
+  const response = await fetch(url, {
+    method: "post",
+    body: JSON.stringify({
+      value1,
+      value2,
+      value3,
+      value4,
+      value5,
+    }),
+    headers: {
+      "Content-Type": "application/json",
+    },
+  })
+
+  const { status, message } = await getFetchResponse(response)
+  return {
+    httpStatus: status,
+    success: status === 200,
+    response: message,
+  }
+}

package/src/automations/steps/outgoingWebhook.js

@@ -1,4 +1,5 @@
 const fetch = require("node-fetch")
+const { getFetchResponse } = require("./utils")
 
 const RequestType = {
   POST: "POST",
@@ -16,12 +17,13 @@ const BODY_REQUESTS = [RequestType.POST, RequestType.PUT, RequestType.PATCH]
  * 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",
   description: "Send a request of specified method to a URL",
   type: "ACTION",
+  internal: true,
   stepId: "OUTGOING_WEBHOOK",
   inputs: {
     requestMethod: "POST",
@@ -60,6 +62,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",
@@ -70,7 +76,7 @@ module.exports.definition = {
   },
 }
 
-module.exports.run = async function ({ inputs }) {
+exports.run = async function ({ inputs }) {
   let { requestMethod, url, requestBody, headers } = inputs
   if (!url.startsWith("http")) {
     url = `http://${url}`
@@ -107,19 +113,11 @@ module.exports.run = async function ({ inputs }) {
       JSON.parse(request.body)
     }
     const response = await 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 = await response.json()
-    } else {
-      resp = await response.text()
-    }
+    const { status, message } = await getFetchResponse(response)
     return {
-      response: resp,
-      success: success,
+      httpStatus: status,
+      response: message,
+      success: status === 200,
     }
   } catch (err) {
     /* istanbul ignore next */

package/src/automations/steps/sendSmtpEmail.js

@@ -1,11 +1,12 @@
 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: {
@@ -46,7 +47,7 @@ module.exports.definition = {
   },
 }
 
-module.exports.run = async function ({ inputs }) {
+exports.run = async function ({ inputs }) {
   let { to, from, subject, contents } = inputs
   if (!contents) {
     contents = "<h1>No content</h1>"
@@ -58,7 +59,6 @@ module.exports.run = async function ({ inputs }) {
       response,
     }
   } catch (err) {
-    console.error(err)
     return {
       success: false,
       response: err,

package/src/automations/steps/serverLog.js

@@ -4,12 +4,13 @@
  * GET/DELETE requests cannot handle body elements so they will not be sent if configured.
  */
 
-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: "",
@@ -36,6 +37,9 @@ module.exports.definition = {
   },
 }
 
-module.exports.run = async function ({ inputs, appId }) {
+exports.run = async function ({ inputs, appId }) {
   console.log(`App ${appId} - ${inputs.text}`)
+  return {
+    success: true,
+  }
 }

package/src/automations/steps/slack.js

@@ -0,0 +1,64 @@
+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 = async function ({ inputs }) {
+  let { url, text } = inputs
+  const response = await fetch(url, {
+    method: "post",
+    body: JSON.stringify({
+      text,
+    }),
+    headers: {
+      "Content-Type": "application/json",
+    },
+  })
+
+  const { status, message } = await getFetchResponse(response)
+  return {
+    httpStatus: status,
+    response: message,
+    success: status === 200,
+  }
+}

package/src/automations/steps/updateRow.js

@@ -1,12 +1,13 @@
 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: {
@@ -53,7 +54,7 @@ module.exports.definition = {
   },
 }
 
-module.exports.run = async function ({ inputs, appId, emitter }) {
+exports.run = async function ({ inputs, appId, emitter }) {
   if (inputs.rowId == null || inputs.row == null) {
     return {
       success: false,
@@ -100,7 +101,6 @@ module.exports.run = async function ({ inputs, appId, emitter }) {
       success: ctx.status === 200,
     }
   } catch (err) {
-    console.error(err)
     return {
       success: false,
       response: err,

package/src/automations/steps/utils.js

@@ -0,0 +1,36 @@
+exports.getFetchResponse = async fetched => {
+  let status = fetched.status,
+    message
+  const contentType = fetched.headers.get("content-type")
+  try {
+    if (contentType && contentType.indexOf("application/json") !== -1) {
+      message = await fetched.json()
+    } else {
+      message = await 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/src/automations/steps/zapier.js

@@ -0,0 +1,84 @@
+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 = async function ({ inputs }) {
+  const { url, value1, value2, value3, value4, value5 } = inputs
+
+  // send the platform to make sure zaps always work, even
+  // if no values supplied
+  const response = await fetch(url, {
+    method: "post",
+    body: JSON.stringify({
+      platform: "budibase",
+      value1,
+      value2,
+      value3,
+      value4,
+      value5,
+    }),
+    headers: {
+      "Content-Type": "application/json",
+    },
+  })
+
+  const { status, message } = await getFetchResponse(response)
+
+  return {
+    success: status === 200,
+    httpStatus: status,
+    response: message,
+  }
+}