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

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,
+  }
+}

package/src/automations/tests/automation.spec.js

@@ -1,34 +1,18 @@
 jest.mock("../../utilities/usageQuota")
 jest.mock("../thread")
 jest.spyOn(global.console, "error")
-jest.mock("worker-farm", () => {
-  return () => {
-    const value = jest
-      .fn()
-      .mockReturnValueOnce(undefined)
-      .mockReturnValueOnce("Error")
-    return (input, callback) => {
-      workerJob = input
-      if (callback) {
-        callback(value())
-      }
-    }
-  }
-})
 
 require("../../environment")
 const automation = require("../index")
 const usageQuota = require("../../utilities/usageQuota")
 const thread = require("../thread")
 const triggers = require("../triggers")
-const { basicAutomation, basicTable } = require("../../tests/utilities/structures")
+const { basicAutomation } = require("../../tests/utilities/structures")
 const { wait } = require("../../utilities")
 const { makePartial } = require("../../tests/utilities")
 const { cleanInputValues } = require("../automationUtils")
 const setup = require("./utilities")
 
-let workerJob
-
 usageQuota.getAPIKey.mockReturnValue({ apiKey: "test" })
 
 describe("Run through some parts of the automations system", () => {
@@ -44,59 +28,12 @@ describe("Run through some parts of the automations system", () => {
   it("should be able to init in builder", async () => {
     await triggers.externalTrigger(basicAutomation(), { a: 1 })
     await wait(100)
-    expect(workerJob).toBeUndefined()
     expect(thread).toHaveBeenCalled()
   })
 
   it("should be able to init in prod", async () => {
-    await setup.runInProd(async () => {
-      await triggers.externalTrigger(basicAutomation(), { a: 1 })
-      await wait(100)
-      // haven't added a mock implementation so getAPIKey of usageQuota just returns undefined
-      expect(usageQuota.update).toHaveBeenCalledWith("test", "automationRuns", 1)
-      expect(workerJob).toBeDefined()
-    })
-  })
-
-  it("try error scenario", async () => {
-    await setup.runInProd(async () => {
-      // the second call will throw an error
-      await triggers.externalTrigger(basicAutomation(), { a: 1 })
-      await wait(100)
-      expect(console.error).toHaveBeenCalled()
-    })
-  })
-
-  it("should be able to check triggering row filling", async () => {
-    const automation = basicAutomation()
-    let table = basicTable()
-    table.schema.boolean = {
-      type: "boolean",
-      constraints: {
-        type: "boolean",
-      },
-    }
-    table.schema.number = {
-      type: "number",
-      constraints: {
-        type: "number",
-      },
-    }
-    table.schema.datetime = {
-      type: "datetime",
-      constraints: {
-        type: "datetime",
-      },
-    }
-    table = await config.createTable(table)
-    automation.definition.trigger.inputs.tableId = table._id
-    const params = await triggers.fillRowOutput(automation, { appId: config.getAppId() })
-    expect(params.row).toBeDefined()
-    const date = new Date(params.row.datetime)
-    expect(typeof params.row.name).toBe("string")
-    expect(typeof params.row.boolean).toBe("boolean")
-    expect(typeof params.row.number).toBe("number")
-    expect(date.getFullYear()).toBe(1970)
+    await triggers.externalTrigger(basicAutomation(), { a: 1 })
+    await wait(100)
   })
 
   it("should check coercion", async () => {

package/src/automations/tests/delay.spec.js

@@ -4,7 +4,7 @@ describe("test the delay logic", () => {
   it("should be able to run the delay", async () => {
     const time = 100
     const before = Date.now()
-    await setup.runStep(setup.logic.DELAY.stepId, { time: time })
+    await setup.runStep(setup.actions.DELAY.stepId, { time: time })
     const now = Date.now()
     // divide by two just so that test will always pass as long as there was some sort of delay
     expect(now - before).toBeGreaterThanOrEqual(time / 2)

package/src/automations/tests/filter.spec.js

@@ -1,48 +1,48 @@
 const setup = require("./utilities")
-const { LogicConditions } = require("../steps/filter")
+const { FilterConditions } = require("../steps/filter")
 
 describe("test the filter logic", () => {
   async function checkFilter(field, condition, value, pass = true) {
-    let res = await setup.runStep(setup.logic.FILTER.stepId,
+    let res = await setup.runStep(setup.actions.FILTER.stepId,
       { field, condition, value }
     )
     expect(res.success).toEqual(pass)
   }
 
   it("should be able test equality", async () => {
-    await checkFilter("hello", LogicConditions.EQUAL, "hello", true)
-    await checkFilter("hello", LogicConditions.EQUAL, "no", false)
+    await checkFilter("hello", FilterConditions.EQUAL, "hello", true)
+    await checkFilter("hello", FilterConditions.EQUAL, "no", false)
   })
 
   it("should be able to test greater than", async () => {
-    await checkFilter(10, LogicConditions.GREATER_THAN, 5, true)
-    await checkFilter(10, LogicConditions.GREATER_THAN, 15, false)
+    await checkFilter(10, FilterConditions.GREATER_THAN, 5, true)
+    await checkFilter(10, FilterConditions.GREATER_THAN, 15, false)
   })
 
   it("should be able to test less than", async () => {
-    await checkFilter(5, LogicConditions.LESS_THAN, 10, true)
-    await checkFilter(15, LogicConditions.LESS_THAN, 10, false)
+    await checkFilter(5, FilterConditions.LESS_THAN, 10, true)
+    await checkFilter(15, FilterConditions.LESS_THAN, 10, false)
   })
 
   it("should be able to in-equality", async () => {
-    await checkFilter("hello", LogicConditions.NOT_EQUAL, "no", true)
-    await checkFilter(10, LogicConditions.NOT_EQUAL, 10, false)
+    await checkFilter("hello", FilterConditions.NOT_EQUAL, "no", true)
+    await checkFilter(10, FilterConditions.NOT_EQUAL, 10, false)
   })
 
   it("check number coercion", async () => {
-    await checkFilter("10", LogicConditions.GREATER_THAN, "5", true)
+    await checkFilter("10", FilterConditions.GREATER_THAN, "5", true)
   })
 
   it("check date coercion", async () => {
     await checkFilter(
       (new Date()).toISOString(),
-      LogicConditions.GREATER_THAN,
+      FilterConditions.GREATER_THAN,
       (new Date(-10000)).toISOString(),
       true
     )
   })
 
   it("check objects always false", async () => {
-    await checkFilter({}, LogicConditions.EQUAL, {}, false)
+    await checkFilter({}, FilterConditions.EQUAL, {}, false)
   })
 })

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

@@ -1,6 +1,5 @@
 const TestConfig = require("../../../tests/utilities/TestConfiguration")
 const actions = require("../../actions")
-const logic = require("../../logic")
 const emitter = require("../../../events/index")
 const env = require("../../../environment")
 
@@ -34,16 +33,7 @@ exports.runInProd = async fn => {
 }
 
 exports.runStep = async function runStep(stepId, inputs) {
-  let step
-  if (
-    Object.values(exports.actions)
-      .map(action => action.stepId)
-      .includes(stepId)
-  ) {
-    step = await actions.getAction(stepId)
-  } else {
-    step = logic.getLogic(stepId)
-  }
+  let step = await actions.getAction(stepId)
   expect(step).toBeDefined()
   return step({
     inputs,
@@ -56,5 +46,4 @@ exports.runStep = async function runStep(stepId, inputs) {
 
 exports.apiKey = "test"
 
-exports.actions = actions.BUILTIN_DEFINITIONS
-exports.logic = logic.BUILTIN_DEFINITIONS
+exports.actions = actions.ACTION_DEFINITIONS

package/src/automations/thread.js

@@ -1,5 +1,4 @@
 const actions = require("./actions")
-const logic = require("./logic")
 const automationUtils = require("./automationUtils")
 const AutomationEmitter = require("../events/AutomationEmitter")
 const { processObject } = require("@budibase/string-templates")
@@ -8,7 +7,7 @@ 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.
@@ -30,15 +29,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)
   }
 
-  async getStepFunctionality(type, stepId) {
-    let step = null
-    if (type === "ACTION") {
-      step = await actions.getAction(stepId)
-    } else if (type === "LOGIC") {
-      step = logic.getLogic(stepId)
-    }
+  async getStepFunctionality(stepId) {
+    let step = await actions.getAction(stepId)
     if (step == null) {
       throw `Cannot find automation step by name ${stepId}`
     }
@@ -55,11 +54,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)
+  }
+
   async execute() {
     let automation = this._automation
     const app = await this.getApp()
     for (let step of automation.definition.steps) {
-      let stepFn = await this.getStepFunctionality(step.type, step.stepId)
+      let stepFn = await this.getStepFunctionality(step.stepId)
       step.inputs = await processObject(step.inputs, this._context)
       step.inputs = automationUtils.cleanInputValues(
         step.inputs,
@@ -81,27 +89,20 @@ 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 = async (job, cb = null) => {
-  try {
-    const automationOrchestrator = new Orchestrator(
-      job.data.automation,
-      job.data.event
-    )
-    await automationOrchestrator.execute()
-    if (cb) {
-      cb()
-    }
-  } catch (err) {
-    if (cb) {
-      cb(err)
-    }
-  }
+module.exports = async job => {
+  const automationOrchestrator = new Orchestrator(
+    job.data.automation,
+    job.data.event
+  )
+  return automationOrchestrator.execute()
 }