@budibase/server 1.0.19-alpha.1 → 1.0.22

package/src/integrations/rest.ts

@@ -2,58 +2,29 @@ import {
   Integration,
   DatasourceFieldTypes,
   QueryTypes,
-  RestConfig,
-  RestQueryFields as RestQuery,
 } from "../definitions/datasource"
 import { IntegrationBase } from "./base/IntegrationBase"
 
-const BodyTypes = {
-  NONE: "none",
-  FORM_DATA: "form",
-  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")
+
+  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,
@@ -66,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,
+          },
+        },
       },
     },
   }
@@ -99,106 +137,94 @@ 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")
       if (contentType && contentType.indexOf("application/json") !== -1) {
-        data = await response.json()
-        raw = JSON.stringify(data)
+        return await response.json()
       } else {
-        data = await response.text()
-        raw = data
-      }
-      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,
-        },
+        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}`
     }
 
-    async _req(query: RestQuery) {
-      const { path = "", queryString = "", headers = {}, method = "GET", disabledHeaders, bodyType, requestBody } = query
+    async create({ path = "", queryString = "", headers = {}, json = {} }) {
       this.headers = {
         ...this.config.defaultHeaders,
         ...headers,
       }
 
-      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), {
+        method: "POST",
+        headers: this.headers,
+        body: JSON.stringify(json),
+      })
 
-      let json
-      if (bodyType === BodyTypes.JSON && requestBody) {
-        try {
-          json = JSON.parse(requestBody)
-        } catch (err) {
-          throw "Invalid JSON for request body"
-        }
-      }
+      return await this.parseResponse(response)
+    }
 
-      const input: any = { method, headers: this.headers }
-      if (json && typeof json === "object" && Object.keys(json).length > 0) {
-        input.body = JSON.stringify(json)
+    async read({ path = "", queryString = "", headers = {} }) {
+      this.headers = {
+        ...this.config.defaultHeaders,
+        ...headers,
       }
 
-      this.startTimeMs = performance.now()
-      const response = await fetch(this.getUrl(path, queryString), input)
+      const response = await fetch(this.getUrl(path, queryString), {
+        headers: this.headers,
+      })
+
       return await this.parseResponse(response)
     }
 
-    async create(opts: RestQuery) {
-      return this._req({ ...opts, method: "POST" })
-    }
+    async update({ 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: "PUT",
+        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 patch({ path = "", queryString = "", headers = {}, json = {} }) {
+      this.headers = {
+        ...this.config.defaultHeaders,
+        ...headers,
+      }
+
+      const response = await fetch(this.getUrl(path, queryString), {
+        method: "PATCH",
+        headers: this.headers,
+        body: JSON.stringify(json),
+      })
+
+      return await this.parseResponse(response)
     }
 
-    async delete(opts: RestQuery) {
-      return this._req({ ...opts, method: "DELETE" })
+    async delete({ path = "", queryString = "", headers = {} }) {
+      this.headers = {
+        ...this.config.defaultHeaders,
+        ...headers,
+      }
+
+      const response = await fetch(this.getUrl(path, queryString), {
+        method: "DELETE",
+        headers: this.headers,
+      })
+
+      return await this.parseResponse(response)
     }
   }
 

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(), 
@@ -27,7 +24,6 @@ describe("REST Integration", () => {
     config = new TestConfiguration({
       url: BASE_URL,
     })
-    jest.clearAllMocks()
   })
 
   it("calls the create method with the correct params", async () => {
@@ -37,10 +33,9 @@ describe("REST Integration", () => {
       headers: {
         Accept: "application/json",
       },
-      bodyType: "json",
-      requestBody: JSON.stringify({
+      json: {
         name: "test",
-      }),
+      },
     }
     const response = await config.integration.create(query)
     expect(fetch).toHaveBeenCalledWith(`${BASE_URL}/api?test=1`, {
@@ -65,7 +60,6 @@ describe("REST Integration", () => {
       headers: {
         Accept: "text/html",
       },
-      method: "GET",
     })
   })
 
@@ -76,14 +70,13 @@ 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: {
         Accept: "application/json",
@@ -98,10 +91,9 @@ 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`, {
@@ -109,7 +101,6 @@ describe("REST Integration", () => {
       headers: {
         Accept: "application/json",
       },
-      body: '{"name":"test"}',
     })
   })
 })

package/src/threads/query.js

@@ -15,15 +15,6 @@ 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) {
@@ -31,15 +22,7 @@ async function runAndTransform(datasource, queryVerb, query, transformer) {
   }
   const integration = new Integration(datasource.config)
 
-  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
-  }
+  let rows = formatResponse(await integration[queryVerb](query))
 
   // transform as required
   if (transformer) {
@@ -64,7 +47,7 @@ async function runAndTransform(datasource, queryVerb, query, transformer) {
     integration.end()
   }
 
-  return { rows, keys, info, extra }
+  return { rows, keys }
 }
 
 module.exports = (input, callback) => {

package/src/utilities/index.js

@@ -150,14 +150,3 @@ 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]}`
-}