@budibase/server 1.0.200-alpha.3 → 1.0.200

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

@@ -1,5 +1,4 @@
 const setup = require("./utilities")
-const { events } = require("@budibase/backend-core")
 
 function priceTable() {
   return {
@@ -30,70 +29,27 @@ 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", () => {
-
-    it("returns a success message when the view is successfully created", async () => {
-      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()
+    beforeEach(async () => {
+      table = await config.createTable(priceTable())
     })
 
-    it("creates a view with a filter", async () => {
-      jest.clearAllMocks()
-
-      const res = await saveView({
-        calculation: null,
-        filters: [{
-          value: "1",
-          condition: "EQUALS",
-          key: "price"
-        }],
-      })
+    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)
 
       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 () => {
@@ -145,100 +101,6 @@ 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())
@@ -262,6 +124,10 @@ describe("/views", () => {
   })
 
   describe("query", () => {
+    beforeEach(async () => {
+      table = await config.createTable(priceTable())
+    })
+
     it("returns data for the created view", async () => {
       await config.createView({
         name: "TestView",
@@ -335,82 +201,37 @@ 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", () => {
-
-    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}`)
+    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)
-    }
-
-    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")
+      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`)
+        .set(config.defaultHeaders())
+        .expect(200)
+      // this shouldn't be JSON
+      try {
+        JSON.parse(res.text)
+      } catch (err) {
+        error = err
+      }
+      expect(error).toBeDefined()
     })
   })
 })

package/src/app.ts

@@ -18,7 +18,6 @@ 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()
 
@@ -84,7 +83,6 @@ server.on("close", async () => {
   }
   await automations.shutdown()
   await redis.shutdown()
-  await events.shutdown()
   await Thread.shutdown()
   api.shutdown()
   if (!env.isTest()) {
@@ -98,22 +96,6 @@ 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()
 })
 
@@ -136,3 +118,12 @@ 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,7 +1,5 @@
 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
@@ -22,5 +20,3 @@ exports.shutdown = () => {
 }
 
 exports.queue = queue
-exports.TRIGGER_DEFINITIONS = TRIGGER_DEFINITIONS
-exports.ACTION_DEFINITIONS = ACTION_DEFINITIONS

package/src/automations/steps/executeQuery.js

@@ -72,7 +72,7 @@ exports.run = async function ({ inputs, appId, emitter }) {
   })
 
   try {
-    await queryController.executeV1(ctx)
+    await queryController.executeV2(ctx)
     const { data, ...rest } = ctx.body
     return {
       response: data,

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

@@ -1,9 +1,5 @@
 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,12 +1,9 @@
 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")
   )
@@ -70,6 +67,7 @@ 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
@@ -86,7 +84,6 @@ module.exports = {
     module.exports[key] = value
   },
   isTest,
-  isJest,
   isCypress,
   isDev,
   isProd: () => {

package/src/integrations/firebase.ts

@@ -66,7 +66,6 @@ module Firebase {
             "==",
             "<",
             "<=",
-            "==",
             "!=",
             ">=",
             ">",

package/src/migrations/index.ts

@@ -1,6 +1,7 @@
-import { migrations, redis } from "@budibase/backend-core"
-import { Migration, MigrationOptions, MigrationName } from "@budibase/types"
-import env from "../environment"
+const {
+  MIGRATION_TYPES,
+  runMigrations,
+} = require("@budibase/backend-core/migrations")
 
 // migration functions
 import * as userEmailViewCasing from "./functions/userEmailViewCasing"
@@ -8,129 +9,59 @@ import * as quota1 from "./functions/quotas1"
 import * as appUrls from "./functions/appUrls"
 import * as developerQuota from "./functions/developerQuota"
 import * as publishedAppsQuota from "./functions/publishedAppsQuota"
-import * as backfill from "./functions/backfill"
+
+export interface Migration {
+  type: string
+  name: string
+  opts?: object
+  fn: Function
+}
 
 /**
- * Populate the migration function and additional configuration from
- * the static migration definitions.
+ * e.g.
+ * {
+ *   tenantIds: ['bb'],
+ *   force: {
+ *    global: ['quota_1']
+ *   }
+ * }
  */
-export const buildMigrations = () => {
-  const definitions = migrations.DEFINITIONS
-  const serverMigrations: Migration[] = []
-
-  for (const definition of definitions) {
-    switch (definition.name) {
-      case MigrationName.USER_EMAIL_VIEW_CASING: {
-        serverMigrations.push({
-          ...definition,
-          fn: userEmailViewCasing.run,
-        })
-        break
-      }
-      case MigrationName.QUOTAS_1: {
-        serverMigrations.push({
-          ...definition,
-          fn: quota1.run,
-        })
-        break
-      }
-      case MigrationName.APP_URLS: {
-        serverMigrations.push({
-          ...definition,
-          appOpts: { all: true },
-          fn: appUrls.run,
-        })
-        break
-      }
-      case MigrationName.DEVELOPER_QUOTA: {
-        serverMigrations.push({
-          ...definition,
-          fn: developerQuota.run,
-        })
-        break
-      }
-      case MigrationName.PUBLISHED_APP_QUOTA: {
-        serverMigrations.push({
-          ...definition,
-          fn: publishedAppsQuota.run,
-        })
-        break
-      }
-      case MigrationName.EVENT_APP_BACKFILL: {
-        serverMigrations.push({
-          ...definition,
-          appOpts: { all: true },
-          fn: backfill.app.run,
-          silent: !!env.SELF_HOSTED, // reduce noisy logging
-          preventRetry: !!env.SELF_HOSTED, // only ever run once
-        })
-        break
-      }
-      case MigrationName.EVENT_GLOBAL_BACKFILL: {
-        serverMigrations.push({
-          ...definition,
-          fn: backfill.global.run,
-          silent: !!env.SELF_HOSTED, // reduce noisy logging
-          preventRetry: !!env.SELF_HOSTED, // only ever run once
-        })
-        break
-      }
-      case MigrationName.EVENT_INSTALLATION_BACKFILL: {
-        serverMigrations.push({
-          ...definition,
-          fn: backfill.installation.run,
-          silent: !!env.SELF_HOSTED, // reduce noisy logging
-          preventRetry: !!env.SELF_HOSTED, // only ever run once
-        })
-        break
-      }
-    }
+export interface MigrationOptions {
+  tenantIds?: string[]
+  force?: {
+    [type: string]: string[]
   }
-
-  return serverMigrations
 }
 
-export const MIGRATIONS = buildMigrations()
+export const MIGRATIONS: Migration[] = [
+  {
+    type: MIGRATION_TYPES.GLOBAL,
+    name: "user_email_view_casing",
+    fn: userEmailViewCasing.run,
+  },
+  {
+    type: MIGRATION_TYPES.GLOBAL,
+    name: "quotas_1",
+    fn: quota1.run,
+  },
+  {
+    type: MIGRATION_TYPES.APP,
+    name: "app_urls",
+    opts: { all: true },
+    fn: appUrls.run,
+  },
+  {
+    type: MIGRATION_TYPES.GLOBAL,
+    name: "developer_quota",
+    fn: developerQuota.run,
+  },
+  {
+    type: MIGRATION_TYPES.GLOBAL,
+    name: "published_apps_quota",
+    fn: publishedAppsQuota.run,
+  },
+]
 
 export const migrate = async (options?: MigrationOptions) => {
-  if (env.SELF_HOSTED) {
-    // self host runs migrations on startup
-    // make sure only a single instance runs them
-    await migrateWithLock(options)
-  } else {
-    await migrations.runMigrations(MIGRATIONS, options)
-  }
-}
-
-const migrateWithLock = async (options?: MigrationOptions) => {
-  // get a new lock client
-
-  const redlock = await redis.clients.getMigrationsRedlock()
-  // lock for 15 minutes
-  const ttl = 1000 * 60 * 15
-
-  let migrationLock
-
-  // acquire lock
-  try {
-    migrationLock = await redlock.lock("migrations", ttl)
-  } catch (e: any) {
-    if (e.name === "LockError") {
-      return
-    } else {
-      throw e
-    }
-  }
-
-  // run migrations
-  try {
-    await migrations.runMigrations(MIGRATIONS, options)
-  } finally {
-    // release lock
-    try {
-      await migrationLock.unlock()
-    } catch (e) {
-      console.error("unable to release migration lock")
-    }
-  }
+  await runMigrations(MIGRATIONS, options)
 }

package/src/module.d.ts

@@ -1,3 +1,4 @@
+declare module "@budibase/backend-core"
 declare module "@budibase/backend-core/tenancy"
 declare module "@budibase/backend-core/db"
 declare module "@budibase/backend-core/context"