@budibase/server 1.0.199 → 1.0.200-alpha.2

package/src/api/index.js

@@ -71,10 +71,8 @@ router.use(async (ctx, next) => {
       validationErrors: err.validation,
       error,
     }
-    if (env.NODE_ENV !== "jest") {
-      ctx.log.error(err)
-      console.trace(err)
-    }
+    ctx.log.error(err)
+    console.trace(err)
   }
 })
 

package/src/api/routes/analytics.js

@@ -3,8 +3,6 @@ const controller = require("../controllers/analytics")
 
 const router = Router()
 
-router
-  .get("/api/bbtel", controller.isEnabled)
-  .post("/api/bbtel/ping", controller.endUserPing)
+router.get("/api/bbtel", controller.isEnabled)
 
 module.exports = router

package/src/api/routes/public/utils/Endpoint.ts

@@ -1,4 +1,4 @@
-import Router from "koa-router"
+import Router from "@koa/router"
 
 export type CtxFn = (ctx: any, next?: any) => void | Promise<any>
 

package/src/api/routes/tests/__snapshots__/datasource.spec.js.snap

@@ -7,7 +7,8 @@ Array [
     "entities": Array [
       Object {
         "_id": "ta_users",
-        "_rev": "1-039883a06c1f9cb3945731d79838181e",
+        "_rev": "1-6f4013e796887f1771bf7837598d87e7",
+        "createdAt": "2020-01-01T00:00:00.000Z",
         "name": "Users",
         "primaryDisplay": "email",
         "schema": Object {
@@ -72,6 +73,7 @@ Array [
           },
         },
         "type": "table",
+        "updatedAt": "2020-01-01T00:00:00.000Z",
         "views": Object {},
       },
     ],
@@ -81,9 +83,11 @@ Array [
   },
   Object {
     "config": Object {},
+    "createdAt": "2020-01-01T00:00:00.000Z",
     "name": "Test",
     "source": "POSTGRES",
     "type": "datasource",
+    "updatedAt": "2020-01-01T00:00:00.000Z",
   },
 ]
 `;

package/src/api/routes/tests/application.spec.js

@@ -18,6 +18,7 @@ const {
 } = require("./utilities/TestFunctions")
 const setup = require("./utilities")
 const { AppStatus } = require("../../../db/utils")
+const { events } = require("@budibase/backend-core")
 
 describe("/applications", () => {
   let request = setup.getRequest()
@@ -28,17 +29,49 @@ describe("/applications", () => {
   beforeEach(async () => {
     await clearAllApps()
     await config.init()
+    jest.clearAllMocks()
   })
 
   describe("create", () => {
-    it("returns a success message when the application is successfully created", async () => {
+    it("creates empty app", async () => {
       const res = await request
         .post("/api/applications")
-        .send({ name: "My App" })
+        .field("name", "My App")
         .set(config.defaultHeaders())
         .expect("Content-Type", /json/)
         .expect(200)
       expect(res.body._id).toBeDefined()
+      expect(events.app.created).toBeCalledTimes(1)
+    })
+
+    it("creates app from template", async () => {
+      const res = await request
+        .post("/api/applications")
+        .field("name", "My App")
+        .field("useTemplate", "true")
+        .field("templateKey", "test")
+        .field("templateString", "{}") // override the file download
+        .set(config.defaultHeaders())
+        .expect("Content-Type", /json/)
+        .expect(200)
+      expect(res.body._id).toBeDefined()
+      expect(events.app.created).toBeCalledTimes(1)
+      expect(events.app.templateImported).toBeCalledTimes(1)
+    })
+
+
+    it("creates app from file", async () => {
+      const res = await request
+        .post("/api/applications")
+        .field("name", "My App")
+        .field("useTemplate", "true")
+        .set(config.defaultHeaders())
+        .attach('templateFile', 'src/api/routes/tests/data/export.txt')
+        .expect("Content-Type", /json/)
+        .expect(200)
+      expect(res.body._id).toBeDefined()
+      expect(events.app.created).toBeCalledTimes(1)
+      expect(events.app.fileImported).toBeCalledTimes(1)
     })
 
     it("should apply authorization to endpoint", async () => {
@@ -101,7 +134,32 @@ describe("/applications", () => {
         .set(config.defaultHeaders())
         .expect("Content-Type", /json/)
         .expect(200)
-      expect(res.body.rev).toBeDefined()
+      expect(res.body._rev).toBeDefined()
+      expect(events.app.updated).toBeCalledTimes(1)
+    })
+  })
+
+  describe("delete", () => {
+    it("should delete app", async () => {
+      await config.createApp("to-delete")
+      const appId = config.getAppId()
+      await request
+        .delete(`/api/applications/${appId}`)
+        .set(config.defaultHeaders())
+        .expect("Content-Type", /json/)
+        .expect(200)
+      expect(events.app.deleted).toBeCalledTimes(1)
+    })
+
+    it("should unpublish app", async () => {
+      await config.createApp("to-unpublish")
+      const appId = config.getProdAppId()
+      await request
+        .delete(`/api/applications/${appId}?unpublish=true`)
+        .set(config.defaultHeaders())
+        .expect("Content-Type", /json/)
+        .expect(200)
+      expect(events.app.unpublished).toBeCalledTimes(1)
     })
   })
 
@@ -113,6 +171,7 @@ describe("/applications", () => {
         .set(config.defaultHeaders())
         .expect("Content-Type", /json/)
         .expect(200)
+        expect(events.app.versionUpdated).toBeCalledTimes(1)
     })
     it("should be able to revert the app client library version", async () => {
       // We need to first update the version so that we can then revert
@@ -126,6 +185,7 @@ describe("/applications", () => {
         .set(config.defaultHeaders())
         .expect("Content-Type", /json/)
         .expect(200)
+        expect(events.app.versionReverted).toBeCalledTimes(1)
     })
   })
 
@@ -141,7 +201,7 @@ describe("/applications", () => {
         .set(headers)
         .expect("Content-Type", /json/)
         .expect(200)
-      expect(res.body.rev).toBeDefined()
+      expect(res.body._rev).toBeDefined()
       // retrieve the app to check it
       const getRes = await request
         .get(`/api/applications/${config.getAppId()}/appPackage`)

package/src/api/routes/tests/automation.spec.js

@@ -5,17 +5,14 @@ const {
   testAutomation,
 } = require("./utilities/TestFunctions")
 const setup = require("./utilities")
-const { basicAutomation } = setup.structures
-
+const { basicAutomation, newAutomation, automationTrigger, automationStep } = setup.structures
 const MAX_RETRIES = 4
-
-let ACTION_DEFINITIONS = {}
-let TRIGGER_DEFINITIONS = {}
+const { TRIGGER_DEFINITIONS, ACTION_DEFINITIONS } = require("../../../automations")
+const { events } = require("@budibase/backend-core")
 
 describe("/automations", () => {
   let request = setup.getRequest()
   let config = setup.getConfig()
-  let automation
 
   afterAll(setup.afterAll)
 
@@ -32,7 +29,6 @@ describe("/automations", () => {
         .expect(200)
 
       expect(Object.keys(res.body).length).not.toEqual(0)
-      ACTION_DEFINITIONS = res.body
     })
 
     it("returns a list of definitions for triggerInfo", async () => {
@@ -43,7 +39,6 @@ describe("/automations", () => {
         .expect(200)
 
       expect(Object.keys(res.body).length).not.toEqual(0)
-      TRIGGER_DEFINITIONS = res.body
     })
 
     it("returns all of the definitions in one", async () => {
@@ -53,76 +48,59 @@ describe("/automations", () => {
         .expect('Content-Type', /json/)
         .expect(200)
 
-      expect(Object.keys(res.body.action).length).toBeGreaterThanOrEqual(Object.keys(ACTION_DEFINITIONS).length)
+      let definitionsLength = Object.keys(ACTION_DEFINITIONS).length
+      definitionsLength-- // OUTGOING_WEBHOOK is deprecated
+
+      expect(Object.keys(res.body.action).length).toBeGreaterThanOrEqual(definitionsLength)
       expect(Object.keys(res.body.trigger).length).toEqual(Object.keys(TRIGGER_DEFINITIONS).length)
     })
   })
 
   describe("create", () => {
-    const autoConfig = basicAutomation()
-    it("should setup the automation fully", () => {
-      let trigger = TRIGGER_DEFINITIONS["ROW_SAVED"]
-      trigger.id = "wadiawdo34"
-      let createAction = ACTION_DEFINITIONS["CREATE_ROW"]
-      createAction.inputs.row = {
-        name: "{{trigger.row.name}}",
-        description: "{{trigger.row.description}}"
-      }
-      createAction.id = "awde444wk"
+    it("creates an automation with no steps", async () => {
+      const automation = newAutomation()
+      automation.definition.steps = []
 
-      autoConfig.definition.steps.push(createAction)
-      autoConfig.definition.trigger = trigger
-    })
-
-    it("returns a success message when the automation is successfully created", async () => {
       const res = await request
         .post(`/api/automations`)
         .set(config.defaultHeaders())
-        .send(autoConfig)
+        .send(automation)
         .expect('Content-Type', /json/)
         .expect(200)
 
       expect(res.body.message).toEqual("Automation created successfully")
       expect(res.body.automation.name).toEqual("My Automation")
       expect(res.body.automation._id).not.toEqual(null)
-      automation = res.body.automation
+      expect(events.automation.created).toBeCalledTimes(1)
+      expect(events.automation.stepCreated).not.toBeCalled()
     })
 
-    it("should be able to create an automation with a webhook trigger", async () => {
-      const autoConfig = basicAutomation()
-      autoConfig.definition.trigger = TRIGGER_DEFINITIONS["WEBHOOK"]
-      autoConfig.definition.trigger.id = "webhook_trigger_id"
+    it("creates an automation with steps", async () => {
+      const automation = newAutomation()
+      automation.definition.steps.push(automationStep())
+      jest.clearAllMocks()
+
       const res = await request
         .post(`/api/automations`)
         .set(config.defaultHeaders())
-        .send(autoConfig)
-        .expect('Content-Type', /json/)
-        .expect(200)
-      const originalAuto = res.body.automation
-      expect(originalAuto._id).toBeDefined()
-      expect(originalAuto._rev).toBeDefined()
-      // try removing the webhook trigger
-      const newConfig = originalAuto
-      newConfig.definition.trigger = TRIGGER_DEFINITIONS["ROW_SAVED"]
-      newConfig.definition.trigger.id = "row_saved_id"
-      const newRes = await request
-        .post(`/api/automations`)
-        .set(config.defaultHeaders())
-        .send(newConfig)
+        .send(automation)
         .expect('Content-Type', /json/)
         .expect(200)
-      const newAuto = newRes.body.automation
-      expect(newAuto._id).toEqual(originalAuto._id)
-      expect(newAuto._rev).toBeDefined()
-      expect(newAuto._rev).not.toEqual(originalAuto._rev)
+
+      expect(res.body.message).toEqual("Automation created successfully")
+      expect(res.body.automation.name).toEqual("My Automation")
+      expect(res.body.automation._id).not.toEqual(null)
+      expect(events.automation.created).toBeCalledTimes(1)
+      expect(events.automation.stepCreated).toBeCalledTimes(2)
     })
 
     it("should apply authorization to endpoint", async () => {
+      const automation = newAutomation()
       await checkBuilderEndpoint({
         config,
         method: "POST",
         url: `/api/automations`,
-        body: autoConfig
+        body: automation
       })
     })
   })
@@ -140,15 +118,23 @@ describe("/automations", () => {
     })
   })
 
-  describe("trigger", () => {
-    it("trigger the automation successfully", async () => {
+  describe("test", () => {
+    it("tests the automation successfully", async () => {
       let table = await config.createTable()
+      let automation = newAutomation()
       automation.definition.trigger.inputs.tableId = table._id
-      automation.definition.steps[0].inputs.row.tableId = table._id
+      automation.definition.steps[0].inputs = {
+        row: {
+          name: "{{trigger.row.name}}",
+          description: "{{trigger.row.description}}",
+          tableId: table._id
+        }
+      }
       automation.appId = config.appId
       automation = await config.createAutomation(automation)
       await setup.delay(500)
       const res = await testAutomation(config, automation)
+      expect(events.automation.tested).toBeCalledTimes(1)
       // this looks a bit mad but we don't actually have a way to wait for a response from the automation to
       // know that it has finished all of its actions - this is currently the best way
       // also when this runs in CI it is very temper-mental so for now trying to make run stable by repeating until it works
@@ -170,20 +156,141 @@ describe("/automations", () => {
   })
 
   describe("update", () => {
-    it("updates a automations data", async () => {
-      automation = await config.createAutomation(automation)
-      automation.name = "Updated Name"
-      automation.type = "automation"
 
-      const res = await request
+    const update = async (automation) => {
+      return request
         .put(`/api/automations`)
         .set(config.defaultHeaders())
         .send(automation)
         .expect('Content-Type', /json/)
         .expect(200)
+    }
+
+    const updateWithPost = async (automation) => {
+      return request
+        .post(`/api/automations`)
+        .set(config.defaultHeaders())
+        .send(automation)
+        .expect('Content-Type', /json/)
+        .expect(200)
+    }
+
+    it("updates a automations name", async () => {
+      let automation = newAutomation()
+      await config.createAutomation(automation)
+      automation.name = "Updated Name"
+      jest.clearAllMocks()
+
+      const res = await update(automation)
+
+      const automationRes = res.body.automation
+      const message = res.body.message
+
+      // doc attributes
+      expect(automationRes._id).toEqual(automation._id)
+      expect(automationRes._rev).toBeDefined()
+      expect(automationRes._rev).not.toEqual(automation._rev)
+      // content updates
+      expect(automationRes.name).toEqual("Updated Name")
+      expect(message).toEqual(`Automation ${automation._id} updated successfully.`)
+      // events
+      expect(events.automation.created).not.toBeCalled()
+      expect(events.automation.stepCreated).not.toBeCalled()
+      expect(events.automation.stepDeleted).not.toBeCalled()
+      expect(events.automation.triggerUpdated).not.toBeCalled()
+    })
+
+
+    it("updates a automations name using POST request", async () => {
+      let automation = newAutomation()
+      await config.createAutomation(automation)
+      automation.name = "Updated Name"
+      jest.clearAllMocks()
+
+      // the POST request will defer to the update
+      // when an id has been supplied.
+      const res = await updateWithPost(automation)
+
+      const automationRes = res.body.automation
+      const message = res.body.message
+      // doc attributes
+      expect(automationRes._id).toEqual(automation._id)
+      expect(automationRes._rev).toBeDefined()
+      expect(automationRes._rev).not.toEqual(automation._rev)
+      // content updates
+      expect(automationRes.name).toEqual("Updated Name")
+      expect(message).toEqual(`Automation ${automation._id} updated successfully.`)
+      // events
+      expect(events.automation.created).not.toBeCalled()
+      expect(events.automation.stepCreated).not.toBeCalled()
+      expect(events.automation.stepDeleted).not.toBeCalled()
+      expect(events.automation.triggerUpdated).not.toBeCalled()
+    })
+
+    it("updates an automation trigger", async () => {
+      let automation = newAutomation()
+      automation = await config.createAutomation(automation)
+      automation.definition.trigger = automationTrigger(TRIGGER_DEFINITIONS.WEBHOOK)
+      jest.clearAllMocks()
+
+      await update(automation)
+
+      // events
+      expect(events.automation.created).not.toBeCalled()
+      expect(events.automation.stepCreated).not.toBeCalled()
+      expect(events.automation.stepDeleted).not.toBeCalled()
+      expect(events.automation.triggerUpdated).toBeCalledTimes(1)
+    })
+
+    it("adds automation steps", async () => {
+      let automation = newAutomation()
+      automation = await config.createAutomation(automation)
+      automation.definition.steps.push(automationStep())
+      automation.definition.steps.push(automationStep())
+      jest.clearAllMocks()
+
+      // check the post request honours updates with same id
+      await update(automation)
+
+      // events
+      expect(events.automation.stepCreated).toBeCalledTimes(2)
+      expect(events.automation.created).not.toBeCalled()
+      expect(events.automation.stepDeleted).not.toBeCalled()
+      expect(events.automation.triggerUpdated).not.toBeCalled()
+    })
+
+
+    it("removes automation steps", async () => {
+      let automation = newAutomation()
+      automation.definition.steps.push(automationStep())
+      automation = await config.createAutomation(automation)
+      automation.definition.steps = []
+      jest.clearAllMocks()
+
+      // check the post request honours updates with same id
+      await update(automation)
+
+      // events
+      expect(events.automation.stepDeleted).toBeCalledTimes(2)
+      expect(events.automation.stepCreated).not.toBeCalled()
+      expect(events.automation.created).not.toBeCalled()
+      expect(events.automation.triggerUpdated).not.toBeCalled()
+    })
+
+    it("adds and removes automation steps", async () => {
+      let automation = newAutomation()
+      automation = await config.createAutomation(automation)
+      automation.definition.steps = [automationStep(), automationStep()]
+      jest.clearAllMocks()
+
+      // check the post request honours updates with same id
+      await update(automation)
 
-        expect(res.body.message).toEqual(`Automation ${automation._id} updated successfully.`)
-        expect(res.body.automation.name).toEqual("Updated Name")
+      // events
+      expect(events.automation.stepCreated).toBeCalledTimes(2)
+      expect(events.automation.stepDeleted).toBeCalledTimes(1)
+      expect(events.automation.created).not.toBeCalled()
+      expect(events.automation.triggerUpdated).not.toBeCalled()
     })
   })
 
@@ -219,7 +326,8 @@ describe("/automations", () => {
         .expect('Content-Type', /json/)
         .expect(200)
 
-        expect(res.body.id).toEqual(automation._id)
+      expect(res.body.id).toEqual(automation._id)
+      expect(events.automation.deleted).toBeCalledTimes(1)
     })
 
     it("should apply authorization to endpoint", async () => {

package/src/api/routes/tests/backup.spec.js

@@ -2,6 +2,7 @@ jest.mock("../../../utilities/fileSystem/utilities")
 
 const { checkBuilderEndpoint } = require("./utilities/TestFunctions")
 const setup = require("./utilities")
+const { events } = require("@budibase/backend-core")
 
 describe("/backups", () => {
   let request = setup.getRequest()
@@ -21,6 +22,7 @@ describe("/backups", () => {
         .expect(200)
       expect(res.text).toBeDefined()
       expect(res.text.includes(`"db_name":"${config.getAppId()}"`)).toEqual(true)
+      expect(events.app.exported.mock.calls.length).toBe(1)
     })
 
     it("should apply authorization to endpoint", async () => {

package/src/api/routes/tests/data/export.txt

@@ -0,0 +1 @@
+{}

package/src/api/routes/tests/datasource.spec.js

@@ -5,6 +5,7 @@ let { basicDatasource } = setup.structures
 let { checkBuilderEndpoint } = require("./utilities/TestFunctions")
 const pg = require("pg")
 const { checkCacheForDynamicVariable } = require("../../../threads/utils")
+const { events } = require("@budibase/backend-core") 
 
 describe("/datasources", () => {
   let request = setup.getRequest()
@@ -16,6 +17,7 @@ describe("/datasources", () => {
   beforeEach(async () => {
     await config.init()
     datasource = await config.createDatasource()
+    jest.clearAllMocks()
   })
 
   describe("create", () => {
@@ -29,6 +31,7 @@ describe("/datasources", () => {
 
       expect(res.body.datasource.name).toEqual("Test")
       expect(res.body.errors).toBeUndefined()
+      expect(events.datasource.created).toBeCalledTimes(1)
     })
   })
 
@@ -44,6 +47,7 @@ describe("/datasources", () => {
 
       expect(res.body.datasource.name).toEqual("Updated Test")
       expect(res.body.errors).toBeUndefined()
+      expect(events.datasource.updated).toBeCalledTimes(1)
     })
 
     describe("dynamic variables", () => {
@@ -160,6 +164,7 @@ describe("/datasources", () => {
         .expect(200)
 
       expect(res.body.length).toEqual(1)
+      expect(events.datasource.deleted).toBeCalledTimes(1)
     })
 
     it("should apply authorization to endpoint", async () => {

package/src/api/routes/tests/deployment.spec.js

@@ -0,0 +1,25 @@
+const setup = require("./utilities")
+const { events } = require("@budibase/backend-core")
+
+describe("/deployments", () => {
+  let request = setup.getRequest()
+  let config = setup.getConfig()
+
+  afterAll(setup.afterAll)
+
+  beforeEach(async () => {
+    await config.init()
+    jest.clearAllMocks()
+  })
+
+  describe("deploy", () => {
+    it("should deploy the application", async () => {
+      await request
+        .post(`/api/deploy`)
+        .set(config.defaultHeaders())
+        .expect("Content-Type", /json/)
+        .expect(200)
+      expect(events.app.published.mock.calls.length).toBe(1)
+    })
+  })
+})

package/src/api/routes/tests/dev.spec.js

@@ -0,0 +1,40 @@
+const setup = require("./utilities")
+const { events } = require("@budibase/backend-core")
+const version = require("../../../../package.json").version
+
+describe("/dev", () => {
+  let request = setup.getRequest()
+  let config = setup.getConfig()
+
+  afterAll(setup.afterAll)
+
+  beforeEach(async () => {
+    await config.init()
+    jest.clearAllMocks()
+  })
+
+  describe("revert", () => {
+    it("should revert the application", async () => {
+      await request
+        .post(`/api/dev/${config.getAppId()}/revert`)
+        .set(config.defaultHeaders())
+        .expect("Content-Type", /json/)
+        .expect(200)
+      expect(events.app.reverted).toBeCalledTimes(1)
+    })
+  })
+
+  describe("version", () => {
+    it("should get the installation version", async () => {
+      const res = await request
+        .get(`/api/dev/version`)
+        .set(config.defaultHeaders())
+        .expect("Content-Type", /json/)
+        .expect(200)
+
+      expect(res.body.version).toBe(version)
+      expect(events.version.checked).toBeCalledTimes(1)
+      expect(events.version.checked).toBeCalledWith(version)
+    })
+  })
+})

package/src/api/routes/tests/layout.spec.js

@@ -1,6 +1,7 @@
 const { checkBuilderEndpoint } = require("./utilities/TestFunctions")
 const setup = require("./utilities")
 const { basicLayout } = setup.structures
+const { events } = require("@budibase/backend-core")
 
 describe("/layouts", () => {
   let request = setup.getRequest()
@@ -12,6 +13,7 @@ describe("/layouts", () => {
   beforeEach(async () => {
     await config.init()
     layout = await config.createLayout()
+    jest.clearAllMocks()
   })
 
   describe("save", () => {
@@ -23,6 +25,7 @@ describe("/layouts", () => {
         .expect("Content-Type", /json/)
         .expect(200)
       expect(res.body._rev).toBeDefined()
+      expect(events.layout.created).toBeCalledTimes(1)
     })
 
     it("should apply authorization to endpoint", async () => {
@@ -42,6 +45,7 @@ describe("/layouts", () => {
         .expect("Content-Type", /json/)
         .expect(200)
       expect(res.body.message).toBeDefined()
+      expect(events.layout.deleted).toBeCalledTimes(1)
     })
 
     it("should apply authorization to endpoint", async () => {