@budibase/server 1.0.21 → 1.0.23-alpha.2

package/src/integrations/tests/rest.spec.js

@@ -1,6 +1,9 @@
 jest.mock("node-fetch", () =>
   jest.fn(() => ({
     headers: {
+      raw: () => {
+        return { "content-type": ["application/json"] }
+      },
       get: () => ["application/json"]
     },
     json: jest.fn(), 
@@ -9,6 +12,12 @@ jest.mock("node-fetch", () =>
 )
 const fetch = require("node-fetch")
 const RestIntegration = require("../rest")
+const { AuthType } = require("../rest")
+
+const HEADERS = {
+  "Accept": "application/json",
+  "Content-Type": "application/json"
+}
 
 class TestConfiguration {
   constructor(config = {}) {
@@ -24,26 +33,24 @@ describe("REST Integration", () => {
     config = new TestConfiguration({
       url: BASE_URL,
     })
+    jest.clearAllMocks()
   })
 
   it("calls the create method with the correct params", async () => {
     const query = {
       path: "api",
       queryString: "test=1",
-      headers: {
-        Accept: "application/json",
-      },
-      json: {
+      headers: HEADERS,
+      bodyType: "json",
+      requestBody: JSON.stringify({
         name: "test",
-      },
+      }),
     }
     const response = await config.integration.create(query)
     expect(fetch).toHaveBeenCalledWith(`${BASE_URL}/api?test=1`, {
       method: "POST",
       body: '{"name":"test"}',
-      headers: {
-        Accept: "application/json",
-      },
+      headers: HEADERS,
     })
   })
 
@@ -60,6 +67,7 @@ describe("REST Integration", () => {
       headers: {
         Accept: "text/html",
       },
+      method: "GET",
     })
   })
 
@@ -70,17 +78,16 @@ describe("REST Integration", () => {
       headers: {
         Accept: "application/json",
       },
-      json: {
+      bodyType: "json",
+      requestBody: JSON.stringify({
         name: "test",
-      },
+      }),
     }
     const response = await config.integration.update(query)
     expect(fetch).toHaveBeenCalledWith(`${BASE_URL}/api?test=1`, {
-      method: "POST",
+      method: "PUT",
       body: '{"name":"test"}',
-      headers: {
-        Accept: "application/json",
-      },
+      headers: HEADERS,
     })
   })
 
@@ -91,16 +98,157 @@ describe("REST Integration", () => {
       headers: {
         Accept: "application/json",
       },
-      json: {
+      bodyType: "json",
+      requestBody: JSON.stringify({
         name: "test",
-      },
+      }),
     }
     const response = await config.integration.delete(query)
     expect(fetch).toHaveBeenCalledWith(`${BASE_URL}/api?test=1`, {
       method: "DELETE",
-      headers: {
-        Accept: "application/json",
-      },
+      headers: HEADERS,
+      body: '{"name":"test"}',
+    })
+  })
+
+  describe("request body", () => {
+    const input = { a: 1, b: 2 }
+
+    it("should allow no body", () => {
+      const output = config.integration.addBody("none", null, {})
+      expect(output.body).toBeUndefined()
+      expect(Object.keys(output.headers).length).toEqual(0)
+    })
+
+    it("should allow text body", () => {
+      const output = config.integration.addBody("text", "hello world", {})
+      expect(output.body).toEqual("hello world")
+      // gets added by fetch
+      expect(Object.keys(output.headers).length).toEqual(0)
+    })
+
+    it("should allow form data", () => {
+      const FormData = require("form-data")
+      const output = config.integration.addBody("form", input, {})
+      expect(output.body instanceof FormData).toEqual(true)
+      expect(output.body._valueLength).toEqual(2)
+      // gets added by fetch
+      expect(Object.keys(output.headers).length).toEqual(0)
+    })
+
+    it("should allow encoded form data", () => {
+      const { URLSearchParams } = require("url")
+      const output = config.integration.addBody("encoded", input, {})
+      expect(output.body instanceof URLSearchParams).toEqual(true)
+      expect(output.body.toString()).toEqual("a=1&b=2")
+      // gets added by fetch
+      expect(Object.keys(output.headers).length).toEqual(0)
+    })
+
+    it("should allow JSON", () => {
+      const output = config.integration.addBody("json", input, {})
+      expect(output.body).toEqual(JSON.stringify(input))
+      expect(output.headers["Content-Type"]).toEqual("application/json")
+    })
+
+    it("should allow XML", () => {
+      const output = config.integration.addBody("xml", input, {})
+      expect(output.body.includes("<a>1</a>")).toEqual(true)
+      expect(output.body.includes("<b>2</b>")).toEqual(true)
+      expect(output.headers["Content-Type"]).toEqual("application/xml")
+    })
+  })
+
+  describe("response", () => {
+    function buildInput(json, text, header) {
+      return {
+        status: 200,
+        json: json ? async () => json : undefined,
+        text: text ? async () => text : undefined,
+        headers: { get: key => key === "content-length" ? 100 : header, raw: () => ({ "content-type": header }) }
+      }
+    }
+
+    it("should be able to parse JSON response", async () => {
+      const input = buildInput({a: 1}, null, "application/json")
+      const output = await config.integration.parseResponse(input)
+      expect(output.data).toEqual({a: 1})
+      expect(output.info.code).toEqual(200)
+      expect(output.info.size).toEqual("100B")
+      expect(output.extra.raw).toEqual(JSON.stringify({a: 1}))
+      expect(output.extra.headers["content-type"]).toEqual("application/json")
+    })
+
+    it("should be able to parse text response", async () => {
+      const text = "hello world"
+      const input = buildInput(null, text, "text/plain")
+      const output = await config.integration.parseResponse(input)
+      expect(output.data).toEqual(text)
+      expect(output.extra.raw).toEqual(text)
+      expect(output.extra.headers["content-type"]).toEqual("text/plain")
+    })
+
+    it("should be able to parse XML response", async () => {
+      const text = "<root><a>1</a><b>2</b></root>"
+      const input = buildInput(null, text, "application/xml")
+      const output = await config.integration.parseResponse(input)
+      expect(output.data).toEqual({a: "1", b: "2"})
+      expect(output.extra.raw).toEqual(text)
+      expect(output.extra.headers["content-type"]).toEqual("application/xml")
+    })
+  })
+
+  describe("authentication", () => {
+    const basicAuth = {
+      _id: "c59c14bd1898a43baa08da68959b24686",
+      name: "basic-1",
+      type : AuthType.BASIC,
+      config : {
+        username: "user",
+        password: "password"
+      }
+    }
+    
+    const bearerAuth = {
+      _id: "0d91d732f34e4befabeff50b392a8ff3",
+      name: "bearer-1",
+      type : AuthType.BEARER,
+      config : {
+        "token": "mytoken"
+      }
+    }
+
+    beforeEach(() => {
+      config = new TestConfiguration({
+        url: BASE_URL,
+        authConfigs : [basicAuth, bearerAuth]
+      })
+    })
+
+    it("adds basic auth", async () => {
+      const query = {
+        authConfigId: "c59c14bd1898a43baa08da68959b24686"
+      }
+      await config.integration.read(query)
+      expect(fetch).toHaveBeenCalledWith(`${BASE_URL}/?`, {
+        method: "GET",
+        headers: {
+          Authorization: "Basic dXNlcjpwYXNzd29yZA=="
+        },
+      })
+    })
+
+    it("adds bearer auth", async () => {
+      const query = {
+        authConfigId: "0d91d732f34e4befabeff50b392a8ff3"
+      }
+      await config.integration.read(query)
+      expect(fetch).toHaveBeenCalledWith(`${BASE_URL}/?`, {
+        method: "GET",
+        headers: {
+          Authorization: "Bearer mytoken"
+        },
+      })
     })
   })
 })

package/src/threads/automation.js

@@ -1,6 +1,5 @@
-// when thread starts, make sure it is recorded
+require("./utils").threadSetup()
 const env = require("../environment")
-env.setInThread()
 const actions = require("../automations/actions")
 const automationUtils = require("../automations/automationUtils")
 const AutomationEmitter = require("../events/AutomationEmitter")

package/src/threads/query.js

@@ -1,6 +1,4 @@
-// when thread starts, make sure it is recorded
-const env = require("../environment")
-env.setInThread()
+require("./utils").threadSetup()
 const ScriptRunner = require("../utilities/scriptRunner")
 const { integrations } = require("../integrations")
 
@@ -15,6 +13,15 @@ function formatResponse(resp) {
   return resp
 }
 
+function hasExtraData(response) {
+  return (
+    typeof response === "object" &&
+    !Array.isArray(response) &&
+    response.data != null &&
+    response.info != null
+  )
+}
+
 async function runAndTransform(datasource, queryVerb, query, transformer) {
   const Integration = integrations[datasource.source]
   if (!Integration) {
@@ -22,7 +29,15 @@ async function runAndTransform(datasource, queryVerb, query, transformer) {
   }
   const integration = new Integration(datasource.config)
 
-  let rows = formatResponse(await integration[queryVerb](query))
+  let output = formatResponse(await integration[queryVerb](query))
+  let rows = output,
+    info = undefined,
+    extra = undefined
+  if (hasExtraData(output)) {
+    rows = output.data
+    info = output.info
+    extra = output.extra
+  }
 
   // transform as required
   if (transformer) {
@@ -47,7 +62,7 @@ async function runAndTransform(datasource, queryVerb, query, transformer) {
     integration.end()
   }
 
-  return { rows, keys }
+  return { rows, keys, info, extra }
 }
 
 module.exports = (input, callback) => {

package/src/threads/utils.js

@@ -0,0 +1,13 @@
+const env = require("../environment")
+const CouchDB = require("../db")
+const { init } = require("@budibase/auth")
+
+exports.threadSetup = () => {
+  // don't run this if not threading
+  if (env.isTest() || env.DISABLE_THREADING) {
+    return
+  }
+  // when thread starts, make sure it is recorded
+  env.setInThread()
+  init(CouchDB)
+}

package/src/utilities/index.js

@@ -150,3 +150,14 @@ exports.doesDatabaseExist = async dbName => {
     return false
   }
 }
+
+exports.formatBytes = bytes => {
+  const units = ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"]
+  const byteIncrements = 1024
+  let unit = 0
+  let size = parseInt(bytes, 10) || 0
+  while (size >= byteIncrements && ++unit) {
+    size /= byteIncrements
+  }
+  return `${size.toFixed(size < 10 && unit > 0 ? 1 : 0)}${units[unit]}`
+}