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

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()
 }

package/src/automations/triggerInfo/app.js

@@ -0,0 +1,31 @@
+exports.definition = {
+  name: "App Action",
+  event: "app:trigger",
+  icon: "ri-window-fill",
+  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/src/automations/triggerInfo/cron.js

@@ -0,0 +1,31 @@
+exports.definition = {
+  name: "Cron Trigger",
+  event: "cron:trigger",
+  icon: "ri-timer-line",
+  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/src/automations/triggerInfo/index.js

@@ -0,0 +1,15 @@
+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/src/automations/triggerInfo/rowDeleted.js

@@ -0,0 +1,32 @@
+exports.definition = {
+  name: "Row Deleted",
+  event: "row:delete",
+  icon: "ri-delete-bin-line",
+  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/src/automations/triggerInfo/rowSaved.js

@@ -0,0 +1,40 @@
+exports.definition = {
+  name: "Row Created",
+  event: "row:save",
+  icon: "ri-save-line",
+  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",
+}