@budibase/server 0.0.32 → 0.0.999-alpha.30

package/src/automations/steps/filter.ts

@@ -0,0 +1,105 @@
+import {
+  AutomationActionStepId,
+  AutomationStepSchema,
+  AutomationStepInput,
+  AutomationStepType,
+  AutomationIOType,
+} from "@budibase/types"
+
+export const FilterConditions = {
+  EQUAL: "EQUAL",
+  NOT_EQUAL: "NOT_EQUAL",
+  GREATER_THAN: "GREATER_THAN",
+  LESS_THAN: "LESS_THAN",
+}
+
+export const PrettyFilterConditions = {
+  [FilterConditions.EQUAL]: "Equals",
+  [FilterConditions.NOT_EQUAL]: "Not equals",
+  [FilterConditions.GREATER_THAN]: "Greater than",
+  [FilterConditions.LESS_THAN]: "Less than",
+}
+
+export const definition: AutomationStepSchema = {
+  name: "Condition",
+  tagline: "{{inputs.field}} {{inputs.condition}} {{inputs.value}}",
+  icon: "Branch2",
+  description:
+    "Conditionally halt automations which do not meet certain conditions",
+  type: AutomationStepType.LOGIC,
+  internal: true,
+  stepId: AutomationActionStepId.FILTER,
+  inputs: {
+    condition: FilterConditions.EQUAL,
+  },
+  schema: {
+    inputs: {
+      properties: {
+        field: {
+          type: AutomationIOType.STRING,
+          title: "Reference Value",
+        },
+        condition: {
+          type: AutomationIOType.STRING,
+          title: "Condition",
+          enum: Object.values(FilterConditions),
+          pretty: Object.values(PrettyFilterConditions),
+        },
+        value: {
+          type: AutomationIOType.STRING,
+          title: "Comparison Value",
+        },
+      },
+      required: ["field", "condition", "value"],
+    },
+    outputs: {
+      properties: {
+        success: {
+          type: AutomationIOType.BOOLEAN,
+          description: "Whether the action was successful",
+        },
+        result: {
+          type: AutomationIOType.BOOLEAN,
+          description: "Whether the logic block passed",
+        },
+      },
+      required: ["success", "result"],
+    },
+  },
+}
+
+export async function run({ inputs }: AutomationStepInput) {
+  try {
+    let { field, condition, value } = inputs
+    // coerce types so that we can use them
+    if (!isNaN(value) && !isNaN(field)) {
+      value = parseFloat(value)
+      field = parseFloat(field)
+    } else if (!isNaN(Date.parse(value)) && !isNaN(Date.parse(field))) {
+      value = Date.parse(value)
+      field = Date.parse(field)
+    }
+    let result = false
+    if (typeof field !== "object" && typeof value !== "object") {
+      switch (condition) {
+        case FilterConditions.EQUAL:
+          result = field === value
+          break
+        case FilterConditions.NOT_EQUAL:
+          result = field !== value
+          break
+        case FilterConditions.GREATER_THAN:
+          result = field > value
+          break
+        case FilterConditions.LESS_THAN:
+          result = field < value
+          break
+      }
+    } else {
+      result = false
+    }
+    return { success: true, result }
+  } catch (err) {
+    return { success: false, result: false }
+  }
+}

package/src/automations/steps/integromat.ts

@@ -0,0 +1,110 @@
+import fetch from "node-fetch"
+import { getFetchResponse } from "./utils"
+import {
+  AutomationActionStepId,
+  AutomationStepSchema,
+  AutomationStepInput,
+  AutomationStepType,
+  AutomationIOType,
+} from "@budibase/types"
+
+export const definition: AutomationStepSchema = {
+  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: AutomationActionStepId.integromat,
+  type: AutomationStepType.ACTION,
+  internal: false,
+  inputs: {},
+  schema: {
+    inputs: {
+      properties: {
+        url: {
+          type: AutomationIOType.STRING,
+          title: "Webhook URL",
+        },
+        value1: {
+          type: AutomationIOType.STRING,
+          title: "Input Value 1",
+        },
+        value2: {
+          type: AutomationIOType.STRING,
+          title: "Input Value 2",
+        },
+        value3: {
+          type: AutomationIOType.STRING,
+          title: "Input Value 3",
+        },
+        value4: {
+          type: AutomationIOType.STRING,
+          title: "Input Value 4",
+        },
+        value5: {
+          type: AutomationIOType.STRING,
+          title: "Input Value 5",
+        },
+      },
+      required: ["url", "value1", "value2", "value3", "value4", "value5"],
+    },
+    outputs: {
+      properties: {
+        success: {
+          type: AutomationIOType.BOOLEAN,
+          description: "Whether call was successful",
+        },
+        httpStatus: {
+          type: AutomationIOType.NUMBER,
+          description: "The HTTP status code returned",
+        },
+        response: {
+          type: AutomationIOType.OBJECT,
+          description: "The webhook response - this can have properties",
+        },
+      },
+      required: ["success", "response"],
+    },
+  },
+}
+
+export async function run({ inputs }: AutomationStepInput) {
+  const { url, value1, value2, value3, value4, value5 } = inputs
+
+  if (!url?.trim()?.length) {
+    return {
+      httpStatus: 400,
+      response: "Missing Webhook URL",
+      success: false,
+    }
+  }
+  let response
+  try {
+    response = await fetch(url, {
+      method: "post",
+      body: JSON.stringify({
+        value1,
+        value2,
+        value3,
+        value4,
+        value5,
+      }),
+      headers: {
+        "Content-Type": "application/json",
+      },
+    })
+  } catch (err: any) {
+    return {
+      httpStatus: 400,
+      response: err.message,
+      success: false,
+    }
+  }
+
+  const { status, message } = await getFetchResponse(response)
+  return {
+    httpStatus: status,
+    success: status === 200,
+    response: message,
+  }
+}

package/src/automations/steps/loop.ts

@@ -0,0 +1,58 @@
+import {
+  AutomationActionStepId,
+  AutomationCustomIOType,
+  AutomationIOType,
+  AutomationStepSchema,
+  AutomationStepType,
+} from "@budibase/types"
+
+export const definition: AutomationStepSchema = {
+  name: "Looping",
+  icon: "Reuse",
+  tagline: "Loop the block",
+  description: "Loop",
+  stepId: AutomationActionStepId.LOOP,
+  internal: true,
+  inputs: {},
+  schema: {
+    inputs: {
+      properties: {
+        option: {
+          customType: AutomationCustomIOType.LOOP_OPTION,
+          title: "Input type",
+        },
+        binding: {
+          type: AutomationIOType.STRING,
+          title: "Binding / Value",
+        },
+        iterations: {
+          type: AutomationIOType.NUMBER,
+          title: "Max loop iterations",
+        },
+        failure: {
+          type: AutomationIOType.STRING,
+          title: "Failure Condition",
+        },
+      },
+      required: ["type", "value", "iterations", "failure"],
+    },
+    outputs: {
+      properties: {
+        items: {
+          customType: AutomationCustomIOType.ITEM,
+          description: "The item currently being executed",
+        },
+        success: {
+          type: AutomationIOType.BOOLEAN,
+          description: "Whether the message loop was successfully",
+        },
+        iterations: {
+          type: AutomationIOType.NUMBER,
+          description: "The amount of times the block ran",
+        },
+      },
+      required: ["success", "items", "iterations"],
+    },
+  },
+  type: AutomationStepType.LOGIC,
+}

package/src/automations/steps/outgoingWebhook.ts

@@ -0,0 +1,141 @@
+import fetch from "node-fetch"
+import { getFetchResponse } from "./utils"
+import * as automationUtils from "../automationUtils"
+import {
+  AutomationActionStepId,
+  AutomationCustomIOType,
+  AutomationIOType,
+  AutomationStepInput,
+  AutomationStepSchema,
+  AutomationStepType,
+} from "@budibase/types"
+
+enum RequestType {
+  POST = "POST",
+  GET = "GET",
+  PUT = "PUT",
+  DELETE = "DELETE",
+  PATCH = "PATCH",
+}
+
+const BODY_REQUESTS = [RequestType.POST, RequestType.PUT, RequestType.PATCH]
+
+/**
+ * NOTE: this functionality is deprecated - it no longer should be used.
+ */
+
+export const definition: AutomationStepSchema = {
+  deprecated: true,
+  name: "Outgoing webhook",
+  tagline: "Send a {{inputs.requestMethod}} request",
+  icon: "Send",
+  description: "Send a request of specified method to a URL",
+  type: AutomationStepType.ACTION,
+  internal: true,
+  stepId: AutomationActionStepId.OUTGOING_WEBHOOK,
+  inputs: {
+    requestMethod: "POST",
+    url: "http://",
+    requestBody: "{}",
+    headers: "{}",
+  },
+  schema: {
+    inputs: {
+      properties: {
+        requestMethod: {
+          type: AutomationIOType.STRING,
+          enum: Object.values(RequestType),
+          title: "Request method",
+        },
+        url: {
+          type: AutomationIOType.STRING,
+          title: "URL",
+        },
+        requestBody: {
+          type: AutomationIOType.STRING,
+          title: "JSON Body",
+          customType: AutomationCustomIOType.WIDE,
+        },
+        headers: {
+          type: AutomationIOType.STRING,
+          title: "Headers",
+          customType: AutomationCustomIOType.WIDE,
+        },
+      },
+      required: ["requestMethod", "url"],
+    },
+    outputs: {
+      properties: {
+        response: {
+          type: AutomationIOType.OBJECT,
+          description: "The response from the webhook",
+        },
+        httpStatus: {
+          type: AutomationIOType.NUMBER,
+          description: "The HTTP status code returned",
+        },
+        success: {
+          type: AutomationIOType.BOOLEAN,
+          description: "Whether the action was successful",
+        },
+      },
+      required: ["response", "success"],
+    },
+  },
+}
+
+export async function run({ inputs }: AutomationStepInput) {
+  let { requestMethod, url, requestBody, headers } = inputs
+  if (!url.startsWith("http")) {
+    url = `http://${url}`
+  }
+  const request: any = {
+    method: requestMethod,
+  }
+  if (headers) {
+    try {
+      const customHeaders =
+        typeof headers === "string" ? JSON.parse(headers) : headers
+      request.headers = { ...request.headers, ...customHeaders }
+    } catch (err) {
+      return {
+        success: false,
+        response: "Unable to process headers, must be a JSON object.",
+      }
+    }
+  }
+  if (
+    requestBody &&
+    requestBody.length !== 0 &&
+    BODY_REQUESTS.indexOf(requestMethod) !== -1
+  ) {
+    request.body =
+      typeof requestBody === "string"
+        ? requestBody
+        : JSON.stringify(requestBody)
+    request.headers = {
+      ...request.headers,
+      "Content-Type": "application/json",
+    }
+  }
+
+  try {
+    // do a quick JSON parse if there is a body, to generate an error if its invalid
+    if (request.body) {
+      JSON.parse(request.body)
+    }
+    const response = await fetch(url, request)
+    const { status, message } = await getFetchResponse(response)
+    return {
+      httpStatus: status,
+      response: message,
+      success: status >= 200 && status <= 206,
+    }
+  } catch (err) {
+    /* istanbul ignore next */
+    return {
+      success: false,
+      response: automationUtils.getError(err),
+    }
+  }
+}

package/src/automations/steps/queryRows.ts

@@ -0,0 +1,196 @@
+import * as rowController from "../../api/controllers/row"
+import * as tableController from "../../api/controllers/table"
+import { FieldTypes } from "../../constants"
+import { buildCtx } from "./utils"
+import * as automationUtils from "../automationUtils"
+import {
+  AutomationActionStepId,
+  AutomationCustomIOType,
+  AutomationIOType,
+  AutomationStepInput,
+  AutomationStepSchema,
+  AutomationStepType,
+  SearchFilters,
+  Table,
+} from "@budibase/types"
+
+enum SortOrder {
+  ASCENDING = "ascending",
+  DESCENDING = "descending",
+}
+
+const SortOrderPretty = {
+  [SortOrder.ASCENDING]: "Ascending",
+  [SortOrder.DESCENDING]: "Descending",
+}
+
+enum EmptyFilterOption {
+  RETURN_ALL = "all",
+  RETURN_NONE = "none",
+}
+
+const EmptyFilterOptionPretty = {
+  [EmptyFilterOption.RETURN_ALL]: "Return all table rows",
+  [EmptyFilterOption.RETURN_NONE]: "Return no rows",
+}
+
+export const definition: AutomationStepSchema = {
+  description: "Query rows from the database",
+  icon: "Search",
+  name: "Query rows",
+  tagline: "Query rows from {{inputs.enriched.table.name}} table",
+  type: AutomationStepType.ACTION,
+  stepId: AutomationActionStepId.QUERY_ROWS,
+  internal: true,
+  inputs: {},
+  schema: {
+    inputs: {
+      properties: {
+        tableId: {
+          type: AutomationIOType.STRING,
+          customType: AutomationCustomIOType.TABLE,
+          title: "Table",
+        },
+        filters: {
+          type: AutomationIOType.OBJECT,
+          customType: AutomationCustomIOType.FILTERS,
+          title: "Filtering",
+        },
+        sortColumn: {
+          type: AutomationIOType.STRING,
+          title: "Sort Column",
+          customType: AutomationCustomIOType.COLUMN,
+        },
+        sortOrder: {
+          type: AutomationIOType.STRING,
+          title: "Sort Order",
+          enum: Object.values(SortOrder),
+          pretty: Object.values(SortOrderPretty),
+        },
+        limit: {
+          type: AutomationIOType.NUMBER,
+          title: "Limit",
+          customType: AutomationCustomIOType.QUERY_LIMIT,
+        },
+        onEmptyFilter: {
+          pretty: Object.values(EmptyFilterOptionPretty),
+          enum: Object.values(EmptyFilterOption),
+          type: AutomationIOType.STRING,
+          title: "When Filter Empty",
+        },
+      },
+      required: ["tableId"],
+    },
+    outputs: {
+      properties: {
+        rows: {
+          type: AutomationIOType.ARRAY,
+          customType: AutomationCustomIOType.ROWS,
+          description: "The rows that were found",
+        },
+        success: {
+          type: AutomationIOType.BOOLEAN,
+          description: "Whether the query was successful",
+        },
+      },
+      required: ["rows", "success"],
+    },
+  },
+}
+
+async function getTable(appId: string, tableId: string) {
+  const ctx: any = buildCtx(appId, null, {
+    params: {
+      tableId,
+    },
+  })
+  await tableController.find(ctx)
+  return ctx.body
+}
+
+function typeCoercion(filters: SearchFilters, table: Table) {
+  if (!filters || !table) {
+    return filters
+  }
+  for (let key of Object.keys(filters)) {
+    // @ts-ignore
+    const searchParam = filters[key]
+    if (typeof searchParam === "object") {
+      for (let [property, value] of Object.entries(searchParam)) {
+        const column = table.schema[property]
+        // convert string inputs
+        if (!column || typeof value !== "string") {
+          continue
+        }
+        if (column.type === FieldTypes.NUMBER) {
+          searchParam[property] = parseFloat(value)
+        }
+      }
+    }
+  }
+  return filters
+}
+
+function hasNullFilters(filters: any[]) {
+  return (
+    filters.length === 0 ||
+    filters.some(filter => filter.value === null || filter.value === "")
+  )
+}
+
+export async function run({ inputs, appId }: AutomationStepInput) {
+  const { tableId, filters, sortColumn, sortOrder, limit } = inputs
+  if (!tableId) {
+    return {
+      success: false,
+      response: {
+        message: "You must select a table to query.",
+      },
+    }
+  }
+  const table = await getTable(appId, tableId)
+  let sortType = FieldTypes.STRING
+  if (table && table.schema && table.schema[sortColumn] && sortColumn) {
+    const fieldType = table.schema[sortColumn].type
+    sortType =
+      fieldType === FieldTypes.NUMBER ? FieldTypes.NUMBER : FieldTypes.STRING
+  }
+  const ctx: any = buildCtx(appId, null, {
+    params: {
+      tableId,
+    },
+    body: {
+      sortType,
+      limit,
+      sort: sortColumn,
+      query: typeCoercion(filters || {}, table),
+      // default to ascending, like data tab
+      sortOrder: sortOrder || SortOrder.ASCENDING,
+    },
+    version: "1",
+  })
+  try {
+    let rows
+
+    if (
+      inputs.onEmptyFilter === EmptyFilterOption.RETURN_NONE &&
+      inputs["filters-def"] &&
+      hasNullFilters(inputs["filters-def"])
+    ) {
+      rows = []
+    } else {
+      await rowController.search(ctx)
+      rows = ctx.body ? ctx.body.rows : []
+    }
+
+    return {
+      rows,
+      success: ctx.status === 200,
+    }
+  } catch (err) {
+    return {
+      success: false,
+      response: automationUtils.getError(err),
+    }
+  }
+}

package/src/automations/steps/sendSmtpEmail.ts

@@ -0,0 +1,92 @@
+import { sendSmtpEmail } from "../../utilities/workerRequests"
+import * as automationUtils from "../automationUtils"
+import {
+  AutomationActionStepId,
+  AutomationStepSchema,
+  AutomationStepInput,
+  AutomationStepType,
+  AutomationIOType,
+} from "@budibase/types"
+
+export const definition: AutomationStepSchema = {
+  description: "Send an email using SMTP",
+  tagline: "Send SMTP email to {{inputs.to}}",
+  icon: "Email",
+  name: "Send Email (SMTP)",
+  type: AutomationStepType.ACTION,
+  internal: true,
+  stepId: AutomationActionStepId.SEND_EMAIL_SMTP,
+  inputs: {},
+  schema: {
+    inputs: {
+      properties: {
+        to: {
+          type: AutomationIOType.STRING,
+          title: "Send To",
+        },
+        from: {
+          type: AutomationIOType.STRING,
+          title: "Send From",
+        },
+        cc: {
+          type: AutomationIOType.STRING,
+          title: "CC",
+        },
+        bcc: {
+          type: AutomationIOType.STRING,
+          title: "BCC",
+        },
+        subject: {
+          type: AutomationIOType.STRING,
+          title: "Email Subject",
+        },
+        contents: {
+          type: AutomationIOType.STRING,
+          title: "HTML Contents",
+        },
+      },
+      required: ["to", "from", "subject", "contents"],
+    },
+    outputs: {
+      properties: {
+        success: {
+          type: AutomationIOType.BOOLEAN,
+          description: "Whether the email was sent",
+        },
+        response: {
+          type: AutomationIOType.OBJECT,
+          description: "A response from the email client, this may be an error",
+        },
+      },
+      required: ["success"],
+    },
+  },
+}
+
+export async function run({ inputs }: AutomationStepInput) {
+  let { to, from, subject, contents, cc, bcc } = inputs
+  if (!contents) {
+    contents = "<h1>No content</h1>"
+  }
+  to = to || undefined
+  try {
+    let response = await sendSmtpEmail(
+      to,
+      from,
+      subject,
+      contents,
+      cc,
+      bcc,
+      true
+    )
+    return {
+      success: true,
+      response,
+    }
+  } catch (err) {
+    return {
+      success: false,
+      response: automationUtils.getError(err),
+    }
+  }
+}