@budibase/server 2.2.26 → 2.2.27-alpha.1

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

@@ -10,7 +10,7 @@ describe("/tables", () => {
 
   afterAll(setup.afterAll)
 
-  beforeEach(async () => {
+  beforeAll(async () => {
     const app = await config.init()
     appId = app.appId
   })
@@ -43,21 +43,18 @@ describe("/tables", () => {
       expect(events.table.created).toBeCalledWith(res.body)
     })
 
-    it("creates a table via data import CSV", async () => {
+    it("creates a table via data import", async () => {
       const table = basicTable()
-      table.dataImport = {
-        csvString: "\"name\",\"description\"\n\"test-name\",\"test-desc\"",
-      }
-      table.dataImport.schema = table.schema
+      table.rows = [{ name: 'test-name', description: 'test-desc' }]
 
       const res = await createTable(table)
- 
+
       expect(events.table.created).toBeCalledTimes(1)
       expect(events.table.created).toBeCalledWith(res.body)
       expect(events.table.imported).toBeCalledTimes(1)
-      expect(events.table.imported).toBeCalledWith(res.body, "csv")
+      expect(events.table.imported).toBeCalledWith(res.body)
       expect(events.rows.imported).toBeCalledTimes(1)
-      expect(events.rows.imported).toBeCalledWith(res.body, "csv", 1)
+      expect(events.rows.imported).toBeCalledWith(res.body, 1)
     })
 
     it("should apply authorization to endpoint", async () => {
@@ -87,6 +84,12 @@ describe("/tables", () => {
 
     it("updates all the row fields for a table when a schema key is renamed", async () => {
       const testTable = await config.createTable()
+      await config.createView({
+        name: "TestView",
+        field: "Price",
+        calculation: "stats",
+        tableId: testTable._id,
+      })
 
       const testRow = await request
         .post(`/api/${testTable._id}/rows`)
@@ -109,7 +112,7 @@ describe("/tables", () => {
             updated: "updatedName"
           },
           schema: {
-            updatedName: {type: "string"}
+            updatedName: { type: "string" }
           }
         })
         .set(config.defaultHeaders())
@@ -149,11 +152,10 @@ describe("/tables", () => {
     it("imports rows successfully", async () => {
       const table = await config.createTable()
       const importRequest = {
-        dataImport: {
-          csvString: "\"name\",\"description\"\n\"test-name\",\"test-desc\"",
-          schema: table.schema
-        }
+        schema: table.schema,
+        rows: [{ name: 'test-name', description: 'test-desc' }]
       }
+
       jest.clearAllMocks()
 
       await request
@@ -165,7 +167,7 @@ describe("/tables", () => {
 
       expect(events.table.created).not.toHaveBeenCalled()
       expect(events.rows.imported).toBeCalledTimes(1)
-      expect(events.rows.imported).toBeCalledWith(table, "csv", 1)
+      expect(events.rows.imported).toBeCalledWith(table, 1)
     })
   })
 
@@ -200,24 +202,6 @@ describe("/tables", () => {
     })
   })
 
-  describe("validate csv", () => {
-    it("should be able to validate a CSV layout", async () => {
-      const res = await request
-        .post(`/api/tables/csv/validate`)
-        .send({
-          csvString: "a,b,c,d\n1,2,3,4"
-        })
-        .set(config.defaultHeaders())
-        .expect('Content-Type', /json/)
-        .expect(200)
-      expect(res.body.schema).toBeDefined()
-      expect(res.body.schema.a).toEqual({
-        type: "string",
-        success: true,
-      })
-    })
-  })
-
   describe("indexing", () => {
     it("should be able to create a table with indexes", async () => {
       await context.doInAppContext(appId, async () => {

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

@@ -6,7 +6,7 @@ describe("/templates", () => {
 
   afterAll(setup.afterAll)
 
-  beforeEach(async () => {
+  beforeAll(async () => {
     await config.init()
   })
 

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

@@ -3,6 +3,8 @@ const { checkPermissionsEndpoint } = require("./utilities/TestFunctions")
 const setup = require("./utilities")
 const { BUILTIN_ROLE_IDS } = roles
 
+jest.setTimeout(30000)
+
 jest.mock("../../../utilities/workerRequests", () => ({
   getGlobalUsers: jest.fn(() => {
     return {}
@@ -19,6 +21,7 @@ describe("/users", () => {
 
   afterAll(setup.afterAll)
 
+  // For some reason this cannot be a beforeAll or the test "should be able to update the user" fail
   beforeEach(async () => {
     await config.init()
   })
@@ -90,4 +93,109 @@ describe("/users", () => {
       expect(res.body.tableId).toBeDefined()
     })
   })
+  describe("setFlag", () => {
+    it("should throw an error if a flag is not provided", async () => {
+      await config.createUser()
+      const res = await request
+        .post(`/api/users/flags`)
+        .set(config.defaultHeaders())
+        .send({ value: "test" })
+        .expect(400)
+        .expect("Content-Type", /json/)
+      expect(res.body.message).toEqual("Must supply a 'flag' field in request body.")
+
+    })
+
+    it("should be able to set a flag on the user", async () => {
+      await config.createUser()
+      const res = await request
+        .post(`/api/users/flags`)
+        .set(config.defaultHeaders())
+        .send({ value: "test", flag: "test" })
+        .expect(200)
+        .expect("Content-Type", /json/)
+      expect(res.body.message).toEqual("Flag set successfully")
+    })
+  })
+
+  describe("getFlags", () => {
+    it("should get flags for a specific user", async () => {
+      let flagData = { value: "test", flag: "test" }
+      await config.createUser()
+      await request
+        .post(`/api/users/flags`)
+        .set(config.defaultHeaders())
+        .send(flagData)
+        .expect(200)
+        .expect("Content-Type", /json/)
+
+      const res = await request
+        .get(`/api/users/flags`)
+        .set(config.defaultHeaders())
+        .expect(200)
+        .expect("Content-Type", /json/)
+      expect(res.body[flagData.value]).toEqual(flagData.flag)
+    })
+  })
+
+  describe("setFlag", () => {
+    it("should throw an error if a flag is not provided", async () => {
+      await config.createUser()
+      const res = await request
+        .post(`/api/users/flags`)
+        .set(config.defaultHeaders())
+        .send({ value: "test" })
+        .expect(400)
+        .expect("Content-Type", /json/)
+      expect(res.body.message).toEqual("Must supply a 'flag' field in request body.")
+
+    })
+
+    it("should be able to set a flag on the user", async () => {
+      await config.createUser()
+      const res = await request
+        .post(`/api/users/flags`)
+        .set(config.defaultHeaders())
+        .send({ value: "test", flag: "test" })
+        .expect(200)
+        .expect("Content-Type", /json/)
+      expect(res.body.message).toEqual("Flag set successfully")
+    })
+  })
+
+  describe("syncUser", () => {
+    it("should sync the user", async () => {
+      let user = await config.createUser()
+      await config.createApp('New App')
+      let res = await request
+        .post(`/api/users/metadata/sync/${user._id}`)
+        .set(config.defaultHeaders())
+        .expect(200)
+        .expect("Content-Type", /json/)
+      expect(res.body.message).toEqual('User synced.')
+    })
+
+
+    it("should sync the user when a previous user is specified", async () => {
+      const app1 = await config.createApp('App 1')
+      const app2 = await config.createApp('App 2')
+
+      let user = await config.createUser(
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        false,
+        true,
+        { [app1.appId]: 'ADMIN' })
+      let res = await request
+        .post(`/api/users/metadata/sync/${user._id}`)
+        .set(config.defaultHeaders())
+        .send({ previousUser: { ...user, roles: { ...user.roles, [app2.appId]: 'BASIC' } } })
+        .expect(200)
+        .expect("Content-Type", /json/)
+
+      expect(res.body.message).toEqual('User synced.')
+    })
+  })
 })

package/src/api/routes/tests/utilities/TestFunctions.ts

@@ -3,7 +3,9 @@ import * as appController from "../../../controllers/application"
 import { AppStatus } from "../../../../db/utils"
 import { roles, tenancy, context } from "@budibase/backend-core"
 import { TENANT_ID } from "../../../../tests/utilities/structures"
-import * as env from "../../../../environment"
+import env from "../../../../environment"
+import { db } from "@budibase/backend-core"
+import Nano from "@budibase/nano"
 
 class Request {
   appId: any
@@ -30,7 +32,10 @@ export const getAllTableRows = async (config: any) => {
   return req.body
 }
 
-export const clearAllApps = async (tenantId = TENANT_ID) => {
+export const clearAllApps = async (
+  tenantId = TENANT_ID,
+  exceptions: Array<string> = []
+) => {
   await tenancy.doInTenant(tenantId, async () => {
     const req: any = { query: { status: AppStatus.DEV }, user: { tenantId } }
     await appController.fetch(req)
@@ -38,7 +43,7 @@ export const clearAllApps = async (tenantId = TENANT_ID) => {
     if (!apps || apps.length <= 0) {
       return
     }
-    for (let app of apps) {
+    for (let app of apps.filter((x: any) => !exceptions.includes(x.appId))) {
       const { appId } = app
       const req = new Request(null, { appId })
       await runRequest(appId, appController.destroy, req)
@@ -55,6 +60,24 @@ export const clearAllAutomations = async (config: any) => {
   }
 }
 
+export const wipeDb = async () => {
+  const couchInfo = db.getCouchInfo()
+  const nano = Nano({
+    url: couchInfo.url,
+    requestDefaults: {
+      headers: {
+        Authorization: couchInfo.cookie,
+      },
+    },
+    parseUrl: false,
+  })
+  let dbs
+  do {
+    dbs = await nano.db.list()
+    await Promise.all(dbs.map(x => nano.db.destroy(x)))
+  } while (dbs.length)
+}
+
 export const createRequest = (
   request: any,
   method: any,

package/src/api/routes/tests/utilities/index.ts

@@ -1,5 +1,6 @@
 import TestConfig from "../../../../tests/utilities/TestConfiguration"
 import env from "../../../../environment"
+import supertest from "supertest"
 export * as structures from "../../../../tests/utilities/structures"
 
 function user() {
@@ -44,7 +45,8 @@ export function delay(ms: number) {
   return new Promise(resolve => setTimeout(resolve, ms))
 }
 
-let request: any, config: any
+let request: supertest.SuperTest<supertest.Test> | undefined | null,
+  config: TestConfig | null
 
 export function beforeAll() {
   config = new TestConfig()
@@ -63,16 +65,16 @@ export function afterAll() {
 
 export function getRequest() {
   if (!request) {
-    exports.beforeAll()
+    beforeAll()
   }
-  return request
+  return request!
 }
 
 export function getConfig() {
   if (!config) {
-    exports.beforeAll()
+    beforeAll()
   }
-  return config
+  return config!
 }
 
 export async function switchToSelfHosted(func: any) {

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

@@ -28,8 +28,11 @@ describe("/views", () => {
 
   afterAll(setup.afterAll)
 
-  beforeEach(async () => {
+  beforeAll(async () => {
     await config.init()
+  })
+  
+  beforeEach(async() => {
     table = await config.createTable(priceTable())
   })
 

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

@@ -9,7 +9,8 @@ describe("/webhooks", () => {
 
   afterAll(setup.afterAll)
 
-  beforeEach(async () => {
+  const setupTest = async () => {
+    config.modeSelf()
     await config.init()
     const autoConfig = basicAutomation()
     autoConfig.definition.trigger = {
@@ -18,7 +19,9 @@ describe("/webhooks", () => {
     }
     await config.createAutomation(autoConfig)
     webhook = await config.createWebhook()
-  })
+  }
+
+  beforeAll(setupTest)
 
   describe("create", () => {
     it("should create a webhook successfully", async () => {
@@ -44,6 +47,8 @@ describe("/webhooks", () => {
   })
 
   describe("fetch", () => {
+    beforeAll(setupTest)
+
     it("returns the correct routing for basic user", async () => {
       const res = await request
         .get(`/api/webhooks`)
@@ -64,6 +69,8 @@ describe("/webhooks", () => {
   })
 
   describe("delete", () => {
+    beforeAll(setupTest)
+    
     it("should successfully delete", async () => {
       const res = await request
         .delete(`/api/webhooks/${webhook._id}/${webhook._rev}`)
@@ -84,6 +91,8 @@ describe("/webhooks", () => {
   })
 
   describe("build schema", () => {
+    beforeAll(setupTest)
+
     it("should allow building a schema", async () => {
       const res = await request
         .post(`/api/webhooks/schema/${config.getAppId()}/${webhook._id}`)
@@ -113,7 +122,7 @@ describe("/webhooks", () => {
   describe("trigger", () => {
     it("should allow triggering from public", async () => {
       // replicate changes before checking webhook
-      await config.deploy()
+      await config.publish()
 
       const res = await request
         .post(`/api/webhooks/trigger/${config.prodAppId}/${webhook._id}`)

package/src/api/routes/user.ts

@@ -48,4 +48,4 @@ router
     controller.getFlags
   )
 
-export = router
+export default router

package/src/api/routes/utils/validators.ts

@@ -18,7 +18,7 @@ export function tableValidator() {
     schema: Joi.object().required(),
     name: Joi.string().required(),
     views: Joi.object(),
-    dataImport: Joi.object(),
+    rows: Joi.array(),
   }).unknown(true))
 }
 

package/src/api/routes/view.ts

@@ -31,4 +31,4 @@ router
   )
   .post("/api/views", authorized(permissions.BUILDER), viewController.save)
 
-export = router
+export default router

package/src/api/routes/webhook.ts

@@ -24,4 +24,4 @@ router
   // this shouldn't have authorisation, right now its always public
   .post("/api/webhooks/trigger/:instance/:id", controller.trigger)
 
-export = router
+export default router

package/src/app.ts

@@ -1,5 +1,5 @@
 // need to load environment first
-import * as env from "./environment"
+import env from "./environment"
 
 // enable APM if configured
 if (process.env.ELASTIC_APM_ENABLED) {
@@ -19,7 +19,7 @@ import * as api from "./api"
 import * as automations from "./automations"
 import { Thread } from "./threads"
 import * as redis from "./utilities/redis"
-import { events, logging } from "@budibase/backend-core"
+import { events, logging, middleware } from "@budibase/backend-core"
 import { initialise as initialiseWebsockets } from "./websocket"
 import { startup } from "./startup"
 const Sentry = require("@sentry/node")
@@ -40,6 +40,8 @@ app.use(
   })
 )
 
+app.use(middleware.logging)
+
 if (env.isProd()) {
   env._set("NODE_ENV", "production")
   Sentry.init()
@@ -60,6 +62,7 @@ initialiseWebsockets(server)
 
 let shuttingDown = false,
   errCode = 0
+
 server.on("close", async () => {
   // already in process
   if (shuttingDown) {
@@ -69,7 +72,7 @@ server.on("close", async () => {
   console.log("Server Closed")
   await automations.shutdown()
   await redis.shutdown()
-  await events.shutdown()
+  events.shutdown()
   await Thread.shutdown()
   api.shutdown()
   if (!env.isTest()) {
@@ -77,7 +80,7 @@ server.on("close", async () => {
   }
 })
 
-export = server.listen(env.PORT || 0, async () => {
+export default server.listen(env.PORT || 0, async () => {
   await startup(app, server)
 })
 

package/src/automations/automationUtils.ts

@@ -5,6 +5,7 @@ import {
 } from "@budibase/string-templates"
 import sdk from "../sdk"
 import { Row } from "@budibase/types"
+import { LoopStep, LoopStepType, LoopInput } from "../definitions/automations"
 
 /**
  * When values are input to the system generally they will be of type string as this is required for template strings.
@@ -133,3 +134,26 @@ export function stringSplit(value: string | string[]) {
   }
   return value
 }
+
+export function typecastForLooping(loopStep: LoopStep, input: LoopInput) {
+  if (!input || !input.binding) {
+    return null
+  }
+  try {
+    switch (loopStep.inputs.option) {
+      case LoopStepType.ARRAY:
+        if (typeof input.binding === "string") {
+          return JSON.parse(input.binding)
+        }
+        break
+      case LoopStepType.STRING:
+        if (Array.isArray(input.binding)) {
+          return input.binding.join(",")
+        }
+        break
+    }
+  } catch (err) {
+    throw new Error("Unable to cast to correct type")
+  }
+  return input.binding
+}

package/src/automations/logging/index.ts

@@ -1,4 +1,4 @@
-import * as env from "../../environment"
+import env from "../../environment"
 import { AutomationResults, Automation, App } from "@budibase/types"
 import { automations } from "@budibase/pro"
 import { db as dbUtils } from "@budibase/backend-core"

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

@@ -21,7 +21,7 @@ const setup = require("./utilities")
 describe("Run through some parts of the automations system", () => {
   let config = setup.getConfig()
 
-  beforeEach(async () => {
+  beforeAll(async () => {
     await automation.init()
     await config.init()
   })
@@ -29,9 +29,9 @@ describe("Run through some parts of the automations system", () => {
   afterAll(setup.afterAll)
 
   it("should be able to init in builder", async () => {
-    await triggers.externalTrigger(basicAutomation(), { a: 1, appId: "app_123" })
-    await wait(100)
-    expect(thread.execute).toHaveBeenCalled()
+      await triggers.externalTrigger(basicAutomation(), { a: 1, appId: config.appId })
+      await wait(100)
+      expect(thread.execute).toHaveBeenCalled()
   })
 
   it("should check coercion", async () => {

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

@@ -0,0 +1,34 @@
+const setup = require("./utilities")
+
+describe("test the bash action", () => {
+    let config = setup.getConfig()
+
+    beforeAll(async () => {
+        await config.init()
+    })
+    afterAll(setup.afterAll)
+
+    it("should be able to execute a script", async () => {
+
+        let res = await setup.runStep("EXECUTE_BASH",
+            inputs = {
+                code: "echo 'test'"
+            }
+
+        )
+        expect(res.stdout).toEqual("test\n")
+        expect(res.success).toEqual(true)
+    })
+
+    it("should handle a null value", async () => {
+
+        let res = await setup.runStep("EXECUTE_BASH",
+            inputs = {
+                code: null
+            }
+
+
+        )
+        expect(res.stdout).toEqual("Budibase bash automation failed: Invalid inputs")
+    })
+})

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

@@ -0,0 +1,27 @@
+const setup = require("./utilities")
+const fetch = require("node-fetch")
+
+jest.mock("node-fetch")
+
+describe("test the outgoing webhook action", () => {
+    let inputs
+    let config = setup.getConfig()
+
+    beforeAll(async () => {
+        await config.init()
+        inputs = {
+            username: "joe_bloggs",
+            url: "http://www.test.com",
+        }
+    })
+
+    afterAll(setup.afterAll)
+
+    it("should be able to run the action", async () => {
+        const res = await setup.runStep(setup.actions.discord.stepId, inputs)
+        expect(res.response.url).toEqual("http://www.test.com")
+        expect(res.response.method).toEqual("post")
+        expect(res.success).toEqual(true)
+    })
+
+})

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

@@ -0,0 +1,48 @@
+const setup = require("./utilities")
+
+describe("test the execute query action", () => {
+    let config = setup.getConfig()
+
+    beforeAll(async () => {
+        await config.init()
+
+        await config.createDatasource()
+        query = await config.createQuery()
+
+    })
+
+    afterAll(setup.afterAll)
+
+    it("should be able to execute a query", async () => {
+        let res = await setup.runStep(setup.actions.EXECUTE_QUERY.stepId,
+            inputs = {
+                query: { queryId: query._id }
+            }
+        )
+        expect(res.response).toEqual([{ a: 'string', b: 1 }])
+        expect(res.success).toEqual(true)
+    })
+
+    it("should handle a null query value", async () => {
+        let res = await setup.runStep(setup.actions.EXECUTE_QUERY.stepId,
+            inputs = {
+                query: null
+            }
+        )
+        expect(res.response.message).toEqual("Invalid inputs")
+        expect(res.success).toEqual(false)
+    })
+
+
+    it("should handle an error executing a query", async () => {
+        let res = await setup.runStep(setup.actions.EXECUTE_QUERY.stepId,
+            inputs = {
+                query: { queryId: "wrong_id" }
+            }
+        )
+        expect(res.response).toEqual('Error: missing')
+        expect(res.success).toEqual(false)
+    })
+
+
+})