@budibase/server 1.0.199 → 1.0.200-alpha.2

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

@@ -1,4 +1,5 @@
 const setup = require("./utilities")
+const { events } = require("@budibase/backend-core")
 
 function priceTable() {
   return {
@@ -29,27 +30,70 @@ describe("/views", () => {
 
   beforeEach(async () => {
     await config.init()
+    table = await config.createTable(priceTable())
   })
 
+  const saveView = async (view) => {
+    const viewToSave = {
+      name: "TestView",
+      field: "Price",
+      calculation: "stats",
+      tableId: table._id,
+      ...view
+    }
+    return request
+      .post(`/api/views`)
+      .send(viewToSave)
+      .set(config.defaultHeaders())
+      .expect("Content-Type", /json/)
+      .expect(200)
+  }
+
   describe("create", () => {
-    beforeEach(async () => {
-      table = await config.createTable(priceTable())
-    })
 
     it("returns a success message when the view is successfully created", async () => {
-      const res = await request
-        .post(`/api/views`)
-        .send({
-          name: "TestView",
-          field: "Price",
-          calculation: "stats",
-          tableId: table._id,
-        })
-        .set(config.defaultHeaders())
-        .expect("Content-Type", /json/)
-        .expect(200)
+      const res = await saveView()
+      expect(res.body.tableId).toBe(table._id)
+      expect(events.view.created).toBeCalledTimes(1)
+    })
+
+    it("creates a view with a calculation", async () => {
+      jest.clearAllMocks()
+
+      const res = await saveView({ calculation: "count" })
 
       expect(res.body.tableId).toBe(table._id)
+      expect(events.view.created).toBeCalledTimes(1)
+      expect(events.view.updated).not.toBeCalled()
+      expect(events.view.calculationCreated).toBeCalledTimes(1)
+      expect(events.view.calculationUpdated).not.toBeCalled()
+      expect(events.view.calculationDeleted).not.toBeCalled()
+      expect(events.view.filterCreated).not.toBeCalled()
+      expect(events.view.filterUpdated).not.toBeCalled()
+      expect(events.view.filterDeleted).not.toBeCalled()
+    })
+
+    it("creates a view with a filter", async () => {
+      jest.clearAllMocks()
+
+      const res = await saveView({
+        calculation: null,
+        filters: [{
+          value: "1",
+          condition: "EQUALS",
+          key: "price"
+        }],
+      })
+
+      expect(res.body.tableId).toBe(table._id)
+      expect(events.view.created).toBeCalledTimes(1)
+      expect(events.view.updated).not.toBeCalled()
+      expect(events.view.calculationCreated).not.toBeCalled()
+      expect(events.view.calculationUpdated).not.toBeCalled()
+      expect(events.view.calculationDeleted).not.toBeCalled()
+      expect(events.view.filterCreated).toBeCalledTimes(1)
+      expect(events.view.filterUpdated).not.toBeCalled()
+      expect(events.view.filterDeleted).not.toBeCalled()
     })
 
     it("updates the table row with the new view metadata", async () => {
@@ -101,6 +145,100 @@ describe("/views", () => {
     })
   })
 
+  describe("update", () => {
+    it("updates a view with no calculation or filter changed", async () => {
+      await saveView()
+      jest.clearAllMocks()
+
+      await saveView()
+
+      expect(events.view.created).not.toBeCalled()
+      expect(events.view.updated).toBeCalledTimes(1)
+      expect(events.view.calculationCreated).not.toBeCalled()
+      expect(events.view.calculationUpdated).not.toBeCalled()
+      expect(events.view.calculationDeleted).not.toBeCalled()
+      expect(events.view.filterCreated).not.toBeCalled()
+      expect(events.view.filterUpdated).not.toBeCalled()
+      expect(events.view.filterDeleted).not.toBeCalled()
+    })
+
+    it("updates a view calculation", async () => {
+      await saveView({ calculation: "sum" })
+      jest.clearAllMocks()
+
+      await saveView({ calculation: "count" })
+
+      expect(events.view.created).not.toBeCalled()
+      expect(events.view.updated).toBeCalledTimes(1)
+      expect(events.view.calculationCreated).not.toBeCalled()
+      expect(events.view.calculationUpdated).toBeCalledTimes(1)
+      expect(events.view.calculationDeleted).not.toBeCalled()
+      expect(events.view.filterCreated).not.toBeCalled()
+      expect(events.view.filterUpdated).not.toBeCalled()
+      expect(events.view.filterDeleted).not.toBeCalled()
+    })
+
+    it("deletes a view calculation", async () => {
+      await saveView({ calculation: "sum" })
+      jest.clearAllMocks()
+
+      await saveView({ calculation: null })
+
+      expect(events.view.created).not.toBeCalled()
+      expect(events.view.updated).toBeCalledTimes(1)
+      expect(events.view.calculationCreated).not.toBeCalled()
+      expect(events.view.calculationUpdated).not.toBeCalled()
+      expect(events.view.calculationDeleted).toBeCalledTimes(1)
+      expect(events.view.filterCreated).not.toBeCalled()
+      expect(events.view.filterUpdated).not.toBeCalled()
+      expect(events.view.filterDeleted).not.toBeCalled()
+    })
+
+    it("updates a view filter", async () => {
+      await saveView({ filters: [{
+        value: "1",
+        condition: "EQUALS",
+        key: "price"
+      }] })
+      jest.clearAllMocks()
+
+      await saveView({ filters: [{
+        value: "2",
+        condition: "EQUALS",
+        key: "price"
+      }] })
+
+      expect(events.view.created).not.toBeCalled()
+      expect(events.view.updated).toBeCalledTimes(1)
+      expect(events.view.calculationCreated).not.toBeCalled()
+      expect(events.view.calculationUpdated).not.toBeCalled()
+      expect(events.view.calculationDeleted).not.toBeCalled()
+      expect(events.view.filterCreated).not.toBeCalled()
+      expect(events.view.filterUpdated).toBeCalledTimes(1)
+      expect(events.view.filterDeleted).not.toBeCalled()
+    })
+
+    it("deletes a view filter", async () => {
+      await saveView({ filters: [{
+        value: "1",
+        condition: "EQUALS",
+        key: "price"
+      }] })
+      jest.clearAllMocks()
+
+      await saveView({ filters: [] })
+
+      expect(events.view.created).not.toBeCalled()
+      expect(events.view.updated).toBeCalledTimes(1)
+      expect(events.view.calculationCreated).not.toBeCalled()
+      expect(events.view.calculationUpdated).not.toBeCalled()
+      expect(events.view.calculationDeleted).not.toBeCalled()
+      expect(events.view.filterCreated).not.toBeCalled()
+      expect(events.view.filterUpdated).not.toBeCalled()
+      expect(events.view.filterDeleted).toBeCalledTimes(1)
+    })
+  })
+
   describe("fetch", () => {
     beforeEach(async () => {
       table = await config.createTable(priceTable())
@@ -124,10 +262,6 @@ describe("/views", () => {
   })
 
   describe("query", () => {
-    beforeEach(async () => {
-      table = await config.createTable(priceTable())
-    })
-
     it("returns data for the created view", async () => {
       await config.createView({
         name: "TestView",
@@ -201,37 +335,82 @@ describe("/views", () => {
         .expect(200)
       expect(res.body.map).toBeDefined()
       expect(res.body.meta.tableId).toEqual(table._id)
+      expect(events.view.deleted).toBeCalledTimes(1)
     })
   })
 
   describe("exportView", () => {
-    it("should be able to export a view", async () => {
-      await config.createTable(priceTable())
-      await config.createRow()
-      const view = await config.createView()
-      let res = await request
-        .get(`/api/views/export?view=${view.name}&format=json`)
-        .set(config.defaultHeaders())
-        .expect(200)
-      let error
-      try {
-        const obj = JSON.parse(res.text)
-        expect(obj.length).toBe(1)
-      } catch (err) {
-        error = err
-      }
-      expect(error).toBeUndefined()
-      res = await request
-        .get(`/api/views/export?view=${view.name}&format=csv`)
+
+    beforeEach(() => {
+      jest.clearAllMocks()
+    })
+
+    const setupExport = async () => {
+      const table = await config.createTable()
+      await config.createRow({ name: "test-name", description: "test-desc" })
+      return table
+    }
+
+    const exportView = async (viewName, format) => {
+      return request
+        .get(`/api/views/export?view=${viewName}&format=${format}`)
         .set(config.defaultHeaders())
         .expect(200)
-      // this shouldn't be JSON
-      try {
-        JSON.parse(res.text)
-      } catch (err) {
-        error = err
-      }
-      expect(error).toBeDefined()
+    }
+
+    const assertJsonExport = (res) => {
+      const rows = JSON.parse(res.text)
+      expect(rows.length).toBe(1)
+      expect(rows[0].name).toBe("test-name")
+      expect(rows[0].description).toBe("test-desc")
+    }
+
+    const assertCSVExport = (res) => {
+      expect(res.text).toBe("\"name\",\"description\"\n\"test-name\",\"test-desc\"")
+    }
+
+    it("should be able to export a table as JSON", async () => {
+      const table = await setupExport()
+
+      const res = await exportView(table._id, "json")
+
+      assertJsonExport(res)
+      expect(events.table.exported).toBeCalledTimes(1)
+      expect(events.table.exported).toBeCalledWith(table, "json")
+    })
+
+    it("should be able to export a table as CSV", async () => {
+      const table = await setupExport()
+
+      const res = await exportView(table._id, "csv")
+
+      assertCSVExport(res)
+      expect(events.table.exported).toBeCalledTimes(1)
+      expect(events.table.exported).toBeCalledWith(table, "csv")
+    })
+
+    it("should be able to export a view as JSON", async () => {
+      let table = await setupExport()
+      const view = await config.createView()
+      table = await config.getTable(table._id)
+
+      let res = await exportView(view.name, "json")
+
+      assertJsonExport(res)
+      expect(events.view.exported).toBeCalledTimes(1)
+      expect(events.view.exported).toBeCalledWith(table, "json")
+    })
+
+    it("should be able to export a view as CSV", async () => {
+      let table = await setupExport()
+      const view = await config.createView()
+      table = await config.getTable(table._id)
+
+      let res = await exportView(view.name, "csv")
+
+      assertCSVExport(res)
+      expect(events.view.exported).toBeCalledTimes(1)
+      expect(events.view.exported).toBeCalledWith(table, "csv")
     })
   })
 })

package/src/app.ts

@@ -18,6 +18,7 @@ const { logAlert } = require("@budibase/backend-core/logging")
 const { Thread } = require("./threads")
 import redis from "./utilities/redis"
 import * as migrations from "./migrations"
+import { events, installation } from "@budibase/backend-core"
 
 const app = new Koa()
 
@@ -83,6 +84,7 @@ server.on("close", async () => {
   }
   await automations.shutdown()
   await redis.shutdown()
+  await events.shutdown()
   await Thread.shutdown()
   api.shutdown()
   if (!env.isTest()) {
@@ -96,6 +98,22 @@ module.exports = server.listen(env.PORT || 0, async () => {
   eventEmitter.emitPort(env.PORT)
   fileSystem.init()
   await redis.init()
+
+  // run migrations on startup if not done via http
+  // not recommended in a clustered environment
+  if (!env.HTTP_MIGRATIONS && !env.isTest()) {
+    try {
+      await migrations.migrate()
+    } catch (e) {
+      logAlert("Error performing migrations. Exiting.", e)
+      shutdown()
+    }
+  }
+
+  // check for version updates
+  await installation.checkInstallVersion()
+
+  // done last - this will never complete
   await automations.init()
 })
 
@@ -118,12 +136,3 @@ process.on("uncaughtException", err => {
 process.on("SIGTERM", () => {
   shutdown()
 })
-
-// run migrations on startup if not done via http
-// not recommended in a clustered environment
-if (!env.HTTP_MIGRATIONS) {
-  migrations.migrate().catch(err => {
-    logAlert("Error performing migrations. Exiting.", err)
-    shutdown()
-  })
-}

package/src/automations/index.js

@@ -1,5 +1,7 @@
 const { processEvent } = require("./utils")
 const { queue, shutdown } = require("./bullboard")
+const { TRIGGER_DEFINITIONS } = require("./triggers")
+const { ACTION_DEFINITIONS } = require("./actions")
 
 /**
  * This module is built purely to kick off the worker farm and manage the inputs/outputs
@@ -20,3 +22,5 @@ exports.shutdown = () => {
 }
 
 exports.queue = queue
+exports.TRIGGER_DEFINITIONS = TRIGGER_DEFINITIONS
+exports.ACTION_DEFINITIONS = ACTION_DEFINITIONS

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

@@ -1,5 +1,9 @@
 const setup = require("./utilities")
 
+// need real Date for this test
+const tk = require('timekeeper');
+tk.reset()
+
 describe("test the delay logic", () => {
   it("should be able to run the delay", async () => {
     const time = 100

package/src/environment.js

@@ -1,9 +1,12 @@
 const { join } = require("path")
 
 function isTest() {
+  return isCypress() || isJest()
+}
+
+function isJest() {
   return (
     process.env.NODE_ENV === "jest" ||
-    process.env.NODE_ENV === "cypress" ||
     (process.env.JEST_WORKER_ID != null &&
       process.env.JEST_WORKER_ID !== "null")
   )
@@ -67,7 +70,6 @@ module.exports = {
   AUTOMATION_MAX_ITERATIONS: process.env.AUTOMATION_MAX_ITERATIONS,
   SENDGRID_API_KEY: process.env.SENDGRID_API_KEY,
   DYNAMO_ENDPOINT: process.env.DYNAMO_ENDPOINT,
-  POSTHOG_TOKEN: process.env.POSTHOG_TOKEN,
   QUERY_THREAD_TIMEOUT: parseIntSafe(process.env.QUERY_THREAD_TIMEOUT),
   SQL_MAX_ROWS: process.env.SQL_MAX_ROWS,
   // flags
@@ -84,6 +86,7 @@ module.exports = {
     module.exports[key] = value
   },
   isTest,
+  isJest,
   isCypress,
   isDev,
   isProd: () => {

package/src/migrations/functions/backfill/app/automations.ts

@@ -0,0 +1,26 @@
+import { events } from "@budibase/backend-core"
+import { getAutomationParams } from "../../../../db/utils"
+import { Automation } from "@budibase/types"
+
+const getAutomations = async (appDb: any): Promise<Automation[]> => {
+  const response = await appDb.allDocs(
+    getAutomationParams(null, {
+      include_docs: true,
+    })
+  )
+  return response.rows.map((row: any) => row.doc)
+}
+
+export const backfill = async (appDb: any, timestamp: string | number) => {
+  const automations = await getAutomations(appDb)
+
+  for (const automation of automations) {
+    await events.automation.created(automation, timestamp)
+
+    for (const step of automation.definition.steps) {
+      await events.automation.stepCreated(automation, step, timestamp)
+    }
+  }
+
+  return automations.length
+}

package/src/migrations/functions/backfill/app/datasources.ts

@@ -0,0 +1,22 @@
+import { events } from "@budibase/backend-core"
+import { getDatasourceParams } from "../../../../db/utils"
+import { Datasource } from "@budibase/types"
+
+const getDatasources = async (appDb: any): Promise<Datasource[]> => {
+  const response = await appDb.allDocs(
+    getDatasourceParams(null, {
+      include_docs: true,
+    })
+  )
+  return response.rows.map((row: any) => row.doc)
+}
+
+export const backfill = async (appDb: any, timestamp: string | number) => {
+  const datasources: Datasource[] = await getDatasources(appDb)
+
+  for (const datasource of datasources) {
+    await events.datasource.created(datasource, timestamp)
+  }
+
+  return datasources.length
+}

package/src/migrations/functions/backfill/app/layouts.ts

@@ -0,0 +1,29 @@
+import { events } from "@budibase/backend-core"
+import { getLayoutParams } from "../../../../db/utils"
+import { Layout } from "@budibase/types"
+
+const getLayouts = async (appDb: any): Promise<Layout[]> => {
+  const response = await appDb.allDocs(
+    getLayoutParams(null, {
+      include_docs: true,
+    })
+  )
+  return response.rows.map((row: any) => row.doc)
+}
+
+export const backfill = async (appDb: any, timestamp: string | number) => {
+  const layouts: Layout[] = await getLayouts(appDb)
+
+  for (const layout of layouts) {
+    // exclude default layouts
+    if (
+      layout._id === "layout_private_master" ||
+      layout._id === "layout_public_master"
+    ) {
+      continue
+    }
+    await events.layout.created(layout, timestamp)
+  }
+
+  return layouts.length
+}

package/src/migrations/functions/backfill/app/queries.ts

@@ -0,0 +1,33 @@
+import { events } from "@budibase/backend-core"
+import { getQueryParams } from "../../../../db/utils"
+import { Query, Datasource } from "@budibase/types"
+
+const getQueries = async (appDb: any): Promise<Query[]> => {
+  const response = await appDb.allDocs(
+    getQueryParams(null, {
+      include_docs: true,
+    })
+  )
+  return response.rows.map((row: any) => row.doc)
+}
+
+const getDatasource = async (
+  appDb: any,
+  datasourceId: string
+): Promise<Datasource> => {
+  return appDb.get(datasourceId)
+}
+
+export const backfill = async (appDb: any, timestamp: string | number) => {
+  const queries: Query[] = await getQueries(appDb)
+
+  for (const query of queries) {
+    const datasource: Datasource = await getDatasource(
+      appDb,
+      query.datasourceId
+    )
+    await events.query.created(datasource, query, timestamp)
+  }
+
+  return queries.length
+}

package/src/migrations/functions/backfill/app/roles.ts

@@ -0,0 +1,22 @@
+import { events } from "@budibase/backend-core"
+import { getRoleParams } from "../../../../db/utils"
+import { Role } from "@budibase/types"
+
+const getRoles = async (appDb: any): Promise<Role[]> => {
+  const response = await appDb.allDocs(
+    getRoleParams(null, {
+      include_docs: true,
+    })
+  )
+  return response.rows.map((row: any) => row.doc)
+}
+
+export const backfill = async (appDb: any, timestamp: string | number) => {
+  const roles = await getRoles(appDb)
+
+  for (const role of roles) {
+    await events.role.created(role, timestamp)
+  }
+
+  return roles.length
+}

package/src/migrations/functions/backfill/app/screens.ts

@@ -0,0 +1,22 @@
+import { events } from "@budibase/backend-core"
+import { getScreenParams } from "../../../../db/utils"
+import { Screen } from "@budibase/types"
+
+const getScreens = async (appDb: any): Promise<Screen[]> => {
+  const response = await appDb.allDocs(
+    getScreenParams(null, {
+      include_docs: true,
+    })
+  )
+  return response.rows.map((row: any) => row.doc)
+}
+
+export const backfill = async (appDb: any, timestamp: string | number) => {
+  const screens = await getScreens(appDb)
+
+  for (const screen of screens) {
+    await events.screen.created(screen, timestamp)
+  }
+
+  return screens.length
+}

package/src/migrations/functions/backfill/app/tables.ts

@@ -0,0 +1,36 @@
+import { events } from "@budibase/backend-core"
+import { getTableParams } from "../../../../db/utils"
+import { Table } from "@budibase/types"
+
+const getTables = async (appDb: any): Promise<Table[]> => {
+  const response = await appDb.allDocs(
+    getTableParams(null, {
+      include_docs: true,
+    })
+  )
+  return response.rows.map((row: any) => row.doc)
+}
+
+export const backfill = async (appDb: any, timestamp: string | number) => {
+  const tables = await getTables(appDb)
+
+  for (const table of tables) {
+    await events.table.created(table, timestamp)
+
+    if (table.views) {
+      for (const view of Object.values(table.views)) {
+        await events.view.created(view, timestamp)
+
+        if (view.calculation) {
+          await events.view.calculationCreated(view, timestamp)
+        }
+
+        if (view.filters?.length) {
+          await events.view.filterCreated(view, timestamp)
+        }
+      }
+    }
+  }
+
+  return tables.length
+}