@budibase/server 1.0.23-alpha.1 → 1.0.25

package/src/integrations/rest.ts

@@ -2,65 +2,29 @@ import {
   Integration,
   DatasourceFieldTypes,
   QueryTypes,
-  RestConfig,
-  RestQueryFields as RestQuery,
-  AuthType,
-  BasicAuthConfig,
-  BearerAuthConfig,
 } from "../definitions/datasource"
 import { IntegrationBase } from "./base/IntegrationBase"
 
-const BodyTypes = {
-  NONE: "none",
-  FORM_DATA: "form",
-  XML: "xml",
-  ENCODED: "encoded",
-  JSON: "json",
-  TEXT: "text",
-}
-
-const coreFields = {
-  path: {
-    type: DatasourceFieldTypes.STRING,
-    display: "URL",
-  },
-  queryString: {
-    type: DatasourceFieldTypes.STRING,
-  },
-  headers: {
-    type: DatasourceFieldTypes.OBJECT,
-  },
-  enabledHeaders: {
-    type: DatasourceFieldTypes.OBJECT,
-  },
-  requestBody: {
-    type: DatasourceFieldTypes.JSON,
-  },
-  bodyType: {
-    type: DatasourceFieldTypes.STRING,
-    enum: Object.values(BodyTypes),
-  },
-}
-
 module RestModule {
   const fetch = require("node-fetch")
-  const { formatBytes } = require("../utilities")
-  const { performance } = require("perf_hooks")
-  const FormData = require("form-data")
-  const { URLSearchParams } = require("url")
-  const { parseStringPromise: xmlParser, Builder: XmlBuilder } = require("xml2js")
+
+  interface RestConfig {
+    url: string
+    defaultHeaders: {
+      [key: string]: any
+    }
+  }
 
   const SCHEMA: Integration = {
     docs: "https://github.com/node-fetch/node-fetch",
     description:
-      "With the REST API datasource, you can connect, query and pull data from multiple REST APIs. You can then use the retrieved data to build apps.",
+      "Representational state transfer (REST) is a de-facto standard for a software architecture for interactive applications that typically use multiple Web services. ",
     friendlyName: "REST API",
     datasource: {
       url: {
         type: DatasourceFieldTypes.STRING,
-        default: "",
-        required: false,
-        deprecated: true,
+        default: "localhost",
+        required: true,
       },
       defaultHeaders: {
         type: DatasourceFieldTypes.OBJECT,
@@ -73,30 +37,97 @@ module RestModule {
         readable: true,
         displayName: "POST",
         type: QueryTypes.FIELDS,
-        fields: coreFields,
+        urlDisplay: true,
+        fields: {
+          path: {
+            type: DatasourceFieldTypes.STRING,
+          },
+          queryString: {
+            type: DatasourceFieldTypes.STRING,
+          },
+          headers: {
+            type: DatasourceFieldTypes.OBJECT,
+          },
+          requestBody: {
+            type: DatasourceFieldTypes.JSON,
+          },
+        },
       },
       read: {
         displayName: "GET",
         readable: true,
         type: QueryTypes.FIELDS,
-        fields: coreFields,
+        urlDisplay: true,
+        fields: {
+          path: {
+            type: DatasourceFieldTypes.STRING,
+          },
+          queryString: {
+            type: DatasourceFieldTypes.STRING,
+          },
+          headers: {
+            type: DatasourceFieldTypes.OBJECT,
+          },
+        },
       },
       update: {
         displayName: "PUT",
         readable: true,
         type: QueryTypes.FIELDS,
-        fields: coreFields,
+        urlDisplay: true,
+        fields: {
+          path: {
+            type: DatasourceFieldTypes.STRING,
+          },
+          queryString: {
+            type: DatasourceFieldTypes.STRING,
+          },
+          headers: {
+            type: DatasourceFieldTypes.OBJECT,
+          },
+          requestBody: {
+            type: DatasourceFieldTypes.JSON,
+          },
+        },
       },
       patch: {
         displayName: "PATCH",
         readable: true,
         type: QueryTypes.FIELDS,
-        fields: coreFields,
+        urlDisplay: true,
+        fields: {
+          path: {
+            type: DatasourceFieldTypes.STRING,
+          },
+          queryString: {
+            type: DatasourceFieldTypes.STRING,
+          },
+          headers: {
+            type: DatasourceFieldTypes.OBJECT,
+          },
+          requestBody: {
+            type: DatasourceFieldTypes.JSON,
+          },
+        },
       },
       delete: {
         displayName: "DELETE",
         type: QueryTypes.FIELDS,
-        fields: coreFields,
+        urlDisplay: true,
+        fields: {
+          path: {
+            type: DatasourceFieldTypes.STRING,
+          },
+          queryString: {
+            type: DatasourceFieldTypes.STRING,
+          },
+          headers: {
+            type: DatasourceFieldTypes.OBJECT,
+          },
+          requestBody: {
+            type: DatasourceFieldTypes.JSON,
+          },
+        },
       },
     },
   }
@@ -106,220 +137,99 @@ module RestModule {
     private headers: {
       [key: string]: string
     } = {}
-    private startTimeMs: number = performance.now()
 
     constructor(config: RestConfig) {
       this.config = config
     }
 
     async parseResponse(response: any) {
-      let data, raw, headers
-      const contentType = response.headers.get("content-type") || ""
-      try {
-        if (contentType.includes("application/json")) {
-          data = await response.json()
-          raw = JSON.stringify(data)
-        } else if (
-          contentType.includes("text/xml") ||
-          contentType.includes("application/xml")
-        ) {
-          const rawXml = await response.text()
-          data =
-            (await xmlParser(rawXml, {
-              explicitArray: false,
-              trim: true,
-              explicitRoot: false,
-            })) || {}
-          // there is only one structure, its an array, return the array so it appears as rows
-          const keys = Object.keys(data)
-          if (keys.length === 1 && Array.isArray(data[keys[0]])) {
-            data = data[keys[0]]
-          }
-          raw = rawXml
-        } else {
-          data = await response.text()
-          raw = data
-        }
-      } catch (err) {
-        throw "Failed to parse response body."
-      }
-      const size = formatBytes(
-        response.headers.get("content-length") || Buffer.byteLength(raw, "utf8")
-      )
-      const time = `${Math.round(performance.now() - this.startTimeMs)}ms`
-      headers = response.headers.raw()
-      for (let [key, value] of Object.entries(headers)) {
-        headers[key] = Array.isArray(value) ? value[0] : value
-      }
-      return {
-        data,
-        info: {
-          code: response.status,
-          size,
-          time,
-        },
-        extra: {
-          raw,
-          headers,
-        },
+      const contentType = response.headers.get("content-type")
+      if (contentType && contentType.indexOf("application/json") !== -1) {
+        return await response.json()
+      } else {
+        return await response.text()
       }
     }
 
     getUrl(path: string, queryString: string): string {
-      const main = `${path}?${queryString}`
-      let complete = main
-      if (this.config.url && !main.startsWith(this.config.url)) {
-        complete = !this.config.url ? main : `${this.config.url}/${main}`
-      }
-      if (!complete.startsWith("http")) {
-        complete = `http://${complete}`
-      }
-      return complete
+      return `${this.config.url}/${path}?${queryString}`
     }
 
-    addBody(bodyType: string, body: string | any, input: any) {
-      let error, object, string
-      try {
-        string = typeof body !== "string" ? JSON.stringify(body) : body
-        object = typeof body === "object" ? body : JSON.parse(body)
-      } catch (err) {
-        error = err
-      }
-      if (!input.headers) {
-        input.headers = {}
-      }
-      switch (bodyType) {
-        case BodyTypes.NONE:
-          break
-        case BodyTypes.TEXT:
-          // content type defaults to plaintext
-          input.body = string
-          break
-        case BodyTypes.ENCODED:
-          const params = new URLSearchParams()
-          for (let [key, value] of Object.entries(object)) {
-            params.append(key, value)
-          }
-          input.body = params
-          break
-        case BodyTypes.FORM_DATA:
-          const form = new FormData()
-          for (let [key, value] of Object.entries(object)) {
-            form.append(key, value)
-          }
-          input.body = form
-          break
-        case BodyTypes.XML:
-          if (object != null) {
-            string = (new XmlBuilder()).buildObject(object)
-          }
-          input.body = string
-          input.headers["Content-Type"] = "application/xml"
-          break
-        default:
-        case BodyTypes.JSON:
-          // if JSON error, throw it
-          if (error) {
-            throw "Invalid JSON for request body"
-          }
-          input.body = string
-          input.headers["Content-Type"] = "application/json"
-          break
+    async create({ path = "", queryString = "", headers = {}, json = {} }) {
+      this.headers = {
+        ...this.config.defaultHeaders,
+        ...headers,
       }
-      return input
-    }
 
-    getAuthHeaders(authConfigId: string): { [key: string]: any } {
-      let headers: any = {}
+      const response = await fetch(this.getUrl(path, queryString), {
+        method: "POST",
+        headers: this.headers,
+        body: JSON.stringify(json),
+      })
 
-      if (this.config.authConfigs && authConfigId) {
-        const authConfig = this.config.authConfigs.filter(
-          c => c._id === authConfigId
-        )[0]
-        // check the config still exists before proceeding
-        // if not - do nothing
-        if (authConfig) {
-          let config
-          switch (authConfig.type) {
-            case AuthType.BASIC:
-              config = authConfig.config as BasicAuthConfig
-              headers.Authorization = `Basic ${Buffer.from(
-                `${config.username}:${config.password}`
-              ).toString("base64")}`
-              break
-            case AuthType.BEARER:
-              config = authConfig.config as BearerAuthConfig
-              headers.Authorization = `Bearer ${config.token}`
-              break
-          }
-        }
-      }
-
-      return headers
+      return await this.parseResponse(response)
     }
 
-    async _req(query: RestQuery) {
-      const {
-        path = "",
-        queryString = "",
-        headers = {},
-        method = "GET",
-        disabledHeaders,
-        bodyType,
-        requestBody,
-        authConfigId,
-      } = query
-      const authHeaders = this.getAuthHeaders(authConfigId)
-
+    async read({ path = "", queryString = "", headers = {} }) {
       this.headers = {
         ...this.config.defaultHeaders,
         ...headers,
-        ...authHeaders,
       }
 
-      if (disabledHeaders) {
-        for (let headerKey of Object.keys(this.headers)) {
-          if (disabledHeaders[headerKey]) {
-            delete this.headers[headerKey]
-          }
-        }
-      }
+      const response = await fetch(this.getUrl(path, queryString), {
+        headers: this.headers,
+      })
+
+      return await this.parseResponse(response)
+    }
 
-      let input: any = { method, headers: this.headers }
-      if (requestBody) {
-        input = this.addBody(bodyType, requestBody, input)
+    async update({ path = "", queryString = "", headers = {}, json = {} }) {
+      this.headers = {
+        ...this.config.defaultHeaders,
+        ...headers,
       }
 
-      this.startTimeMs = performance.now()
-      const url = this.getUrl(path, queryString)
-      const response = await fetch(url, input)
+      const response = await fetch(this.getUrl(path, queryString), {
+        method: "PUT",
+        headers: this.headers,
+        body: JSON.stringify(json),
+      })
+
       return await this.parseResponse(response)
     }
 
-    async create(opts: RestQuery) {
-      return this._req({ ...opts, method: "POST" })
-    }
+    async patch({ path = "", queryString = "", headers = {}, json = {} }) {
+      this.headers = {
+        ...this.config.defaultHeaders,
+        ...headers,
+      }
 
-    async read(opts: RestQuery) {
-      return this._req({ ...opts, method: "GET" })
-    }
+      const response = await fetch(this.getUrl(path, queryString), {
+        method: "PATCH",
+        headers: this.headers,
+        body: JSON.stringify(json),
+      })
 
-    async update(opts: RestQuery) {
-      return this._req({ ...opts, method: "PUT" })
+      return await this.parseResponse(response)
     }
 
-    async patch(opts: RestQuery) {
-      return this._req({ ...opts, method: "PATCH" })
-    }
+    async delete({ path = "", queryString = "", headers = {} }) {
+      this.headers = {
+        ...this.config.defaultHeaders,
+        ...headers,
+      }
+
+      const response = await fetch(this.getUrl(path, queryString), {
+        method: "DELETE",
+        headers: this.headers,
+      })
 
-    async delete(opts: RestQuery) {
-      return this._req({ ...opts, method: "DELETE" })
+      return await this.parseResponse(response)
     }
   }
 
   module.exports = {
     schema: SCHEMA,
     integration: RestIntegration,
-    AuthType,
   }
 }

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

@@ -1,9 +1,6 @@
 jest.mock("node-fetch", () =>
   jest.fn(() => ({
     headers: {
-      raw: () => {
-        return { "content-type": ["application/json"] }
-      },
       get: () => ["application/json"]
     },
     json: jest.fn(), 
@@ -12,12 +9,6 @@ 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 = {}) {
@@ -33,24 +24,26 @@ 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: HEADERS,
-      bodyType: "json",
-      requestBody: JSON.stringify({
+      headers: {
+        Accept: "application/json",
+      },
+      json: {
         name: "test",
-      }),
+      },
     }
     const response = await config.integration.create(query)
     expect(fetch).toHaveBeenCalledWith(`${BASE_URL}/api?test=1`, {
       method: "POST",
       body: '{"name":"test"}',
-      headers: HEADERS,
+      headers: {
+        Accept: "application/json",
+      },
     })
   })
 
@@ -67,7 +60,6 @@ describe("REST Integration", () => {
       headers: {
         Accept: "text/html",
       },
-      method: "GET",
     })
   })
 
@@ -78,16 +70,17 @@ describe("REST Integration", () => {
       headers: {
         Accept: "application/json",
       },
-      bodyType: "json",
-      requestBody: JSON.stringify({
+      json: {
         name: "test",
-      }),
+      },
     }
     const response = await config.integration.update(query)
     expect(fetch).toHaveBeenCalledWith(`${BASE_URL}/api?test=1`, {
-      method: "PUT",
+      method: "POST",
       body: '{"name":"test"}',
-      headers: HEADERS,
+      headers: {
+        Accept: "application/json",
+      },
     })
   })
 
@@ -98,157 +91,16 @@ describe("REST Integration", () => {
       headers: {
         Accept: "application/json",
       },
-      bodyType: "json",
-      requestBody: JSON.stringify({
+      json: {
         name: "test",
-      }),
+      },
     }
     const response = await config.integration.delete(query)
     expect(fetch).toHaveBeenCalledWith(`${BASE_URL}/api?test=1`, {
       method: "DELETE",
-      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"
-        },
-      })
+      headers: {
+        Accept: "application/json",
+      },
     })
   })
 })