@budibase/server 2.1.46-alpha.4 → 2.1.46-alpha.6

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@budibase/server",
   "email": "hi@budibase.com",
-  "version": "2.1.46-alpha.4",
+  "version": "2.1.46-alpha.6",
   "description": "Budibase Web Server",
   "main": "src/index.ts",
   "repository": {
@@ -43,11 +43,11 @@
   "license": "GPL-3.0",
   "dependencies": {
     "@apidevtools/swagger-parser": "10.0.3",
-    "@budibase/backend-core": "2.1.46-alpha.4",
-    "@budibase/client": "2.1.46-alpha.4",
-    "@budibase/pro": "2.1.46-alpha.3",
-    "@budibase/string-templates": "2.1.46-alpha.4",
-    "@budibase/types": "2.1.46-alpha.4",
+    "@budibase/backend-core": "2.1.46-alpha.6",
+    "@budibase/client": "2.1.46-alpha.6",
+    "@budibase/pro": "2.1.46-alpha.5",
+    "@budibase/string-templates": "2.1.46-alpha.6",
+    "@budibase/types": "2.1.46-alpha.6",
     "@bull-board/api": "3.7.0",
     "@bull-board/koa": "3.9.4",
     "@elastic/elasticsearch": "7.10.0",
@@ -165,5 +165,5 @@
   "optionalDependencies": {
     "oracledb": "5.3.0"
   },
-  "gitHead": "eb7eb957aa1915405c330ecb223106913ad52ac5"
+  "gitHead": "694c0013a8e7380f5c8953a2be61a515e5fbf820"
 }

package/src/api/routes/tests/{application.spec.js → application.spec.ts}

@@ -12,13 +12,11 @@ jest.mock("../../../utilities/redis", () => ({
   shutdown: jest.fn(),
 }))
 
-const {
-  clearAllApps,
-  checkBuilderEndpoint,
-} = require("./utilities/TestFunctions")
-const setup = require("./utilities")
-const { AppStatus } = require("../../../db/utils")
-const { events } = require("@budibase/backend-core")
+import { clearAllApps, checkBuilderEndpoint } from "./utilities/TestFunctions"
+import * as setup from "./utilities"
+import { AppStatus } from "../../../db/utils"
+import { events } from "@budibase/backend-core"
+import env from "../../../environment"
 
 describe("/applications", () => {
   let request = setup.getRequest()
@@ -234,4 +232,39 @@ describe("/applications", () => {
       expect(getRes.body.application.updatedAt).toBeDefined()
     })
   })
+
+  describe("sync", () => {
+    it("app should sync correctly", async () => {
+      const res = await request
+        .post(`/api/applications/${config.getAppId()}/sync`)
+        .set(config.defaultHeaders())
+        .expect("Content-Type", /json/)
+        .expect(200)
+      expect(res.body.message).toEqual("App sync completed successfully.")
+    })
+
+    it("app should not sync if production", async () => {
+      const res = await request
+        .post(`/api/applications/app_123456/sync`)
+        .set(config.defaultHeaders())
+        .expect("Content-Type", /json/)
+        .expect(400)
+      expect(res.body.message).toEqual(
+        "This action cannot be performed for production apps"
+      )
+    })
+
+    it("app should not sync if sync is disabled", async () => {
+      env._set("DISABLE_AUTO_PROD_APP_SYNC", true)
+      const res = await request
+        .post(`/api/applications/${config.getAppId()}/sync`)
+        .set(config.defaultHeaders())
+        .expect("Content-Type", /json/)
+        .expect(200)
+      expect(res.body.message).toEqual(
+        "App sync disabled. You can reenable with the DISABLE_AUTO_PROD_APP_SYNC environment variable."
+      )
+      env._set("DISABLE_AUTO_PROD_APP_SYNC", false)
+    })
+  })
 })

package/src/api/routes/tests/{backup.spec.js → backup.spec.ts}

@@ -8,10 +8,10 @@ jest.mock("@budibase/backend-core", () => {
   }
 })
 
-const { checkBuilderEndpoint } = require("./utilities/TestFunctions")
-const setup = require("./utilities")
-const { events } = require("@budibase/backend-core")
-
+import * as setup from "./utilities"
+import { events } from "@budibase/backend-core"
+import sdk from "../../../sdk"
+import { checkBuilderEndpoint } from "./utilities/TestFunctions"
 describe("/backups", () => {
   let request = setup.getRequest()
   let config = setup.getConfig()
@@ -30,7 +30,7 @@ describe("/backups", () => {
         .expect(200)
       expect(res.text).toBeDefined()
       expect(res.headers["content-type"]).toEqual("application/gzip")
-      expect(events.app.exported.mock.calls.length).toBe(1)
+      expect(events.app.exported).toBeCalledTimes(1)
     })
 
     it("should apply authorization to endpoint", async () => {
@@ -41,4 +41,15 @@ describe("/backups", () => {
       })
     })
   })
-})
+
+  describe("calculateBackupStats", () => {
+    it("should be able to calculate the backup statistics", async () => {
+      config.createAutomation()
+      config.createScreen()
+      let res = await sdk.backups.calculateBackupStats(config.getAppId())
+      expect(res.automations).toEqual(1)
+      expect(res.datasources).toEqual(1)
+      expect(res.screens).toEqual(1)
+    })
+  })
+})

package/src/api/routes/tests/cloud.spec.ts

@@ -0,0 +1,66 @@
+import { db as dbCore } from "@budibase/backend-core"
+import { AppStatus } from "../../../db/utils"
+
+import * as setup from "./utilities"
+
+describe("/cloud", () => {
+  let request = setup.getRequest()
+  let config = setup.getConfig()
+
+  afterAll(setup.afterAll)
+
+  beforeEach(async () => {
+    await config.init()
+  })
+
+  afterEach(async () => {
+    // clear all mocks
+    jest.clearAllMocks()
+  })
+
+  describe("import", () => {
+    it("should be able to import apps", async () => {
+      // first we need to delete any existing apps on the system so it looks clean otherwise the
+      // import will not run
+      await request
+        .delete(
+          `/api/applications/${dbCore.getProdAppID(
+            config.getAppId()
+          )}?unpublish=true`
+        )
+        .set(config.defaultHeaders())
+        .expect("Content-Type", /json/)
+        .expect(200)
+      await request
+        .delete(`/api/applications/${config.getAppId()}`)
+        .set(config.defaultHeaders())
+        .expect("Content-Type", /json/)
+        .expect(200)
+
+      // get a count of apps before the import
+      const preImportApps = await request
+        .get(`/api/applications?status=${AppStatus.ALL}`)
+        .set(config.defaultHeaders())
+        .expect("Content-Type", /json/)
+        .expect(200)
+
+      // Perform the import
+      const res = await request
+        .post(`/api/cloud/import`)
+        .attach("importFile", "src/api/routes/tests/data/export-test.tar.gz")
+        .set(config.defaultHeaders())
+        .expect(200)
+      expect(res.body.message).toEqual("Apps successfully imported.")
+
+      // get a count of apps after the import
+      const postImportApps = await request
+        .get(`/api/applications?status=${AppStatus.ALL}`)
+        .set(config.defaultHeaders())
+        .expect("Content-Type", /json/)
+        .expect(200)
+
+      // There are two apps in the file that was imported so check for this
+      expect(postImportApps.body.length).toEqual(2)
+    })
+  })
+})

package/src/api/routes/tests/{datasource.spec.js → datasource.spec.ts}

@@ -1,16 +1,16 @@
 jest.mock("pg")
+import * as setup from "./utilities"
+import { checkBuilderEndpoint } from "./utilities/TestFunctions"
+import { checkCacheForDynamicVariable } from "../../../threads/utils"
+import { events } from "@budibase/backend-core"
 
-let setup = require("./utilities")
 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()
   let config = setup.getConfig()
-  let datasource
+  let datasource: any
 
   afterAll(setup.afterAll)
 
@@ -26,7 +26,7 @@ describe("/datasources", () => {
         .post(`/api/datasources`)
         .send(basicDatasource())
         .set(config.defaultHeaders())
-        .expect('Content-Type', /json/)
+        .expect("Content-Type", /json/)
         .expect(200)
 
       expect(res.body.datasource.name).toEqual("Test")
@@ -42,7 +42,7 @@ describe("/datasources", () => {
         .put(`/api/datasources/${datasource._id}`)
         .send(datasource)
         .set(config.defaultHeaders())
-        .expect('Content-Type', /json/)
+        .expect("Content-Type", /json/)
         .expect(200)
 
       expect(res.body.datasource.name).toEqual("Updated Test")
@@ -51,25 +51,34 @@ describe("/datasources", () => {
     })
 
     describe("dynamic variables", () => {
-      async function preview(datasource, fields) {
+      async function preview(
+        datasource: any,
+        fields: { path: string; queryString: string }
+      ) {
         return config.previewQuery(request, config, datasource, fields)
       }
 
       it("should invalidate changed or removed variables", async () => {
         const { datasource, query } = await config.dynamicVariableDatasource()
         // preview once to cache variables
-        await preview(datasource, { path: "www.test.com", queryString: "test={{ variable3 }}" })
+        await preview(datasource, {
+          path: "www.test.com",
+          queryString: "test={{ variable3 }}",
+        })
         // check variables in cache
-        let contents = await checkCacheForDynamicVariable(query._id, "variable3")
+        let contents = await checkCacheForDynamicVariable(
+          query._id,
+          "variable3"
+        )
         expect(contents.rows.length).toEqual(1)
-        
+
         // update the datasource to remove the variables
         datasource.config.dynamicVariables = []
         const res = await request
           .put(`/api/datasources/${datasource._id}`)
           .send(datasource)
           .set(config.defaultHeaders())
-          .expect('Content-Type', /json/)
+          .expect("Content-Type", /json/)
           .expect(200)
         expect(res.body.errors).toBeUndefined()
 
@@ -85,7 +94,7 @@ describe("/datasources", () => {
       const res = await request
         .get(`/api/datasources`)
         .set(config.defaultHeaders())
-        .expect('Content-Type', /json/)
+        .expect("Content-Type", /json/)
         .expect(200)
 
       const datasources = res.body
@@ -160,7 +169,7 @@ describe("/datasources", () => {
       const res = await request
         .get(`/api/datasources`)
         .set(config.defaultHeaders())
-        .expect('Content-Type', /json/)
+        .expect("Content-Type", /json/)
         .expect(200)
 
       expect(res.body.length).toEqual(1)
@@ -174,6 +183,5 @@ describe("/datasources", () => {
         url: `/api/datasources/${datasource._id}/${datasource._rev}`,
       })
     })
-
   })
 })

package/src/api/routes/tests/plugin.spec.ts

@@ -0,0 +1,179 @@
+let mockObjectStore = jest.fn().mockImplementation(() => {
+  return [{ name: "test.js" }]
+})
+
+let deleteFolder = jest.fn().mockImplementation()
+jest.mock("@budibase/backend-core", () => {
+  const core = jest.requireActual("@budibase/backend-core")
+  return {
+    ...core,
+    objectStore: {
+      ...core.objectStore,
+      upload: jest.fn(),
+      uploadDirectory: mockObjectStore,
+      deleteFolder: deleteFolder,
+    },
+  }
+})
+
+import { events } from "@budibase/backend-core"
+import * as setup from "./utilities"
+
+describe("/plugins", () => {
+  let request = setup.getRequest()
+  let config = setup.getConfig()
+
+  afterAll(setup.afterAll)
+
+  beforeEach(async () => {
+    await config.init()
+    jest.clearAllMocks()
+  })
+
+  const createPlugin = async (status?: number) => {
+    return request
+      .post(`/api/plugin/upload`)
+      .attach("file", "src/api/routes/tests/data/comment-box-1.0.2.tar.gz")
+      .set(config.defaultHeaders())
+      .expect("Content-Type", /json/)
+      .expect(status ? status : 200)
+  }
+
+  const getPlugins = async (status?: number) => {
+    return request
+      .get(`/api/plugin`)
+      .set(config.defaultHeaders())
+      .expect("Content-Type", /json/)
+      .expect(status ? status : 200)
+  }
+
+  describe("upload", () => {
+    it("should be able to upload a plugin", async () => {
+      let res = await createPlugin()
+      expect(res.body).toBeDefined()
+      expect(res.body.plugins).toBeDefined()
+      expect(res.body.plugins[0]._id).toEqual("plg_comment-box")
+      expect(events.plugin.imported).toHaveBeenCalledTimes(1)
+    })
+
+    it("should not be able to create a plugin if there is an error", async () => {
+      mockObjectStore.mockImplementationOnce(() => {
+        throw new Error()
+      })
+      let res = await createPlugin(400)
+      expect(res.body.message).toEqual("Failed to import plugin: Error")
+      expect(events.plugin.imported).toHaveBeenCalledTimes(0)
+    })
+  })
+
+  describe("fetch", () => {
+    it("should be able to fetch plugins", async () => {
+      await createPlugin()
+      const res = await getPlugins()
+      expect(res.body).toBeDefined()
+      expect(res.body[0]._id).toEqual("plg_comment-box")
+    })
+  })
+
+  describe("destroy", () => {
+    it("should be able to delete a plugin", async () => {
+      await createPlugin()
+      const res = await request
+        .delete(`/api/plugin/plg_comment-box`)
+        .set(config.defaultHeaders())
+        .expect("Content-Type", /json/)
+        .expect(200)
+      expect(res.body).toBeDefined()
+      expect(res.body.message).toEqual("Plugin plg_comment-box deleted.")
+
+      const plugins = await getPlugins()
+      expect(plugins.body).toBeDefined()
+      expect(plugins.body.length).toEqual(0)
+      expect(events.plugin.deleted).toHaveBeenCalledTimes(1)
+    })
+    it("should handle an error deleting a plugin", async () => {
+      deleteFolder.mockImplementationOnce(() => {
+        throw new Error()
+      })
+
+      await createPlugin()
+      const res = await request
+        .delete(`/api/plugin/plg_comment-box`)
+        .set(config.defaultHeaders())
+        .expect("Content-Type", /json/)
+        .expect(400)
+
+      expect(res.body.message).toEqual("Failed to delete plugin: Error")
+      expect(events.plugin.deleted).toHaveBeenCalledTimes(0)
+      const plugins = await getPlugins()
+      expect(plugins.body).toBeDefined()
+      expect(plugins.body.length).toEqual(1)
+    })
+  })
+
+  describe("github", () => {
+    const createGithubPlugin = async (status?: number, url?: string) => {
+      return await request
+        .post(`/api/plugin`)
+        .send({
+          source: "Github",
+          url,
+          githubToken: "token",
+        })
+        .set(config.defaultHeaders())
+        .expect("Content-Type", /json/)
+        .expect(status ? status : 200)
+    }
+    it("should be able to create a plugin from github", async () => {
+      const res = await createGithubPlugin(
+        200,
+        "https://github.com/my-repo/budibase-comment-box.git"
+      )
+      expect(res.body).toBeDefined()
+      expect(res.body.plugin).toBeDefined()
+      expect(res.body.plugin._id).toEqual("plg_comment-box")
+    })
+    it("should fail if the url is not from github", async () => {
+      const res = await createGithubPlugin(
+        400,
+        "https://notgithub.com/my-repo/budibase-comment-box"
+      )
+      expect(res.body.message).toEqual(
+        "Failed to import plugin: The plugin origin must be from Github"
+      )
+    })
+  })
+  describe("npm", () => {
+    it("should be able to create a plugin from npm", async () => {
+      const res = await request
+        .post(`/api/plugin`)
+        .send({
+          source: "NPM",
+          url: "https://www.npmjs.com/package/budibase-component",
+        })
+        .set(config.defaultHeaders())
+        .expect("Content-Type", /json/)
+        .expect(200)
+      expect(res.body).toBeDefined()
+      expect(res.body.plugin._id).toEqual("plg_budibase-component")
+      expect(events.plugin.imported).toHaveBeenCalled()
+    })
+  })
+
+  describe("url", () => {
+    it("should be able to create a plugin from a URL", async () => {
+      const res = await request
+        .post(`/api/plugin`)
+        .send({
+          source: "URL",
+          url: "https://www.someurl.com/comment-box/comment-box-1.0.2.tar.gz",
+        })
+        .set(config.defaultHeaders())
+        .expect("Content-Type", /json/)
+        .expect(200)
+      expect(res.body).toBeDefined()
+      expect(res.body.plugin._id).toEqual("plg_comment-box")
+      expect(events.plugin.imported).toHaveBeenCalledTimes(1)
+    })
+  })
+})

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

@@ -9,7 +9,6 @@ const route = "/test"
 // there are checks which are disabled in test env,
 // these checks need to be enabled for this test
 
-
 describe("/routing", () => {
   let request = setup.getRequest()
   let config = setup.getConfig()

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

@@ -51,7 +51,7 @@ describe("/tables", () => {
       table.dataImport.schema = table.schema
 
       const res = await createTable(table)
- 
+
       expect(events.table.created).toBeCalledTimes(1)
       expect(events.table.created).toBeCalledWith(res.body)
       expect(events.table.imported).toBeCalledTimes(1)
@@ -87,6 +87,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 +115,7 @@ describe("/tables", () => {
             updated: "updatedName"
           },
           schema: {
-            updatedName: {type: "string"}
+            updatedName: { type: "string" }
           }
         })
         .set(config.defaultHeaders())

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

@@ -90,4 +90,90 @@ 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.')
+    })
+  })
+
+
+
+
 })

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

@@ -63,14 +63,14 @@ export function afterAll() {
 
 export function getRequest() {
   if (!request) {
-    exports.beforeAll()
+    beforeAll()
   }
   return request
 }
 
 export function getConfig() {
   if (!config) {
-    exports.beforeAll()
+    beforeAll()
   }
   return config
 }

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.
@@ -123,3 +124,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
+}