@budibase/server 1.0.27-alpha.12 → 1.0.27-alpha.16

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

@@ -4,19 +4,23 @@ jest.mock("node-fetch", () =>
       raw: () => {
         return { "content-type": ["application/json"] }
       },
-      get: () => ["application/json"]
+      get: () => ["application/json"],
     },
-    json: jest.fn(), 
-    text: jest.fn()
+    json: jest.fn(() => ({
+      my_next_cursor: 123,
+    })),
+    text: jest.fn(),
   }))
 )
 const fetch = require("node-fetch")
 const RestIntegration = require("../rest")
 const { AuthType } = require("../rest")
+const FormData = require("form-data")
+const { URLSearchParams } = require("url")
 
 const HEADERS = {
-  "Accept": "application/json",
-  "Content-Type": "application/json"
+  Accept: "application/json",
+  "Content-Type": "application/json",
 }
 
 class TestConfiguration {
@@ -165,17 +169,20 @@ describe("REST Integration", () => {
         status: 200,
         json: json ? async () => json : undefined,
         text: text ? async () => text : undefined,
-        headers: { get: key => key === "content-length" ? 100 : header, raw: () => ({ "content-type": header }) }
+        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 input = buildInput({ a: 1 }, null, "application/json")
       const output = await config.integration.parseResponse(input)
-      expect(output.data).toEqual({a: 1})
+      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.raw).toEqual(JSON.stringify({ a: 1 }))
       expect(output.extra.headers["content-type"]).toEqual("application/json")
     })
 
@@ -192,7 +199,7 @@ describe("REST Integration", () => {
       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.data).toEqual({ a: "1", b: "2" })
       expect(output.extra.raw).toEqual(text)
       expect(output.extra.headers["content-type"]).toEqual("application/xml")
     })
@@ -202,53 +209,309 @@ describe("REST Integration", () => {
     const basicAuth = {
       _id: "c59c14bd1898a43baa08da68959b24686",
       name: "basic-1",
-      type : AuthType.BASIC,
-      config : {
+      type: AuthType.BASIC,
+      config: {
         username: "user",
-        password: "password"
-      }
+        password: "password",
+      },
     }
-    
+
     const bearerAuth = {
       _id: "0d91d732f34e4befabeff50b392a8ff3",
       name: "bearer-1",
-      type : AuthType.BEARER,
-      config : {
-        "token": "mytoken"
-      }
+      type: AuthType.BEARER,
+      config: {
+        token: "mytoken",
+      },
     }
 
     beforeEach(() => {
       config = new TestConfiguration({
         url: BASE_URL,
-        authConfigs : [basicAuth, bearerAuth]
+        authConfigs: [basicAuth, bearerAuth],
       })
     })
 
     it("adds basic auth", async () => {
       const query = {
-        authConfigId: "c59c14bd1898a43baa08da68959b24686"
+        authConfigId: "c59c14bd1898a43baa08da68959b24686",
       }
       await config.integration.read(query)
       expect(fetch).toHaveBeenCalledWith(`${BASE_URL}/?`, {
         method: "GET",
         headers: {
-          Authorization: "Basic dXNlcjpwYXNzd29yZA=="
+          Authorization: "Basic dXNlcjpwYXNzd29yZA==",
         },
       })
     })
 
     it("adds bearer auth", async () => {
       const query = {
-        authConfigId: "0d91d732f34e4befabeff50b392a8ff3"
+        authConfigId: "0d91d732f34e4befabeff50b392a8ff3",
       }
       await config.integration.read(query)
       expect(fetch).toHaveBeenCalledWith(`${BASE_URL}/?`, {
         method: "GET",
         headers: {
-          Authorization: "Bearer mytoken"
+          Authorization: "Bearer mytoken",
+        },
+      })
+    })
+  })
+
+  describe("page based pagination", () => {
+    it("can paginate using query params", async () => {
+      const pageParam = "my_page_param"
+      const sizeParam = "my_size_param"
+      const pageValue = 3
+      const sizeValue = 10
+      const query = {
+        path: "api",
+        pagination: {
+          type: "page",
+          location: "query",
+          pageParam,
+          sizeParam,
+        },
+        paginationValues: {
+          page: pageValue,
+          limit: sizeValue,
+        },
+      }
+      await config.integration.read(query)
+      expect(fetch).toHaveBeenCalledWith(
+        `${BASE_URL}/api?${pageParam}=${pageValue}&${sizeParam}=${sizeValue}&`,
+        {
+          headers: {},
+          method: "GET",
+        }
+      )
+    })
+
+    it("can paginate using JSON request body", async () => {
+      const pageParam = "my_page_param"
+      const sizeParam = "my_size_param"
+      const pageValue = 3
+      const sizeValue = 10
+      const query = {
+        bodyType: "json",
+        path: "api",
+        pagination: {
+          type: "page",
+          location: "body",
+          pageParam,
+          sizeParam,
+        },
+        paginationValues: {
+          page: pageValue,
+          limit: sizeValue,
+        },
+      }
+      await config.integration.create(query)
+      expect(fetch).toHaveBeenCalledWith(`${BASE_URL}/api?`, {
+        body: JSON.stringify({
+          [pageParam]: pageValue,
+          [sizeParam]: sizeValue,
+        }),
+        headers: {
+          "Content-Type": "application/json",
+        },
+        method: "POST",
+      })
+    })
+
+    it("can paginate using form-data request body", async () => {
+      const pageParam = "my_page_param"
+      const sizeParam = "my_size_param"
+      const pageValue = 3
+      const sizeValue = 10
+      const query = {
+        bodyType: "form",
+        path: "api",
+        pagination: {
+          type: "page",
+          location: "body",
+          pageParam,
+          sizeParam,
+        },
+        paginationValues: {
+          page: pageValue,
+          limit: sizeValue,
+        },
+      }
+      await config.integration.create(query)
+      expect(fetch).toHaveBeenCalledWith(`${BASE_URL}/api?`, {
+        body: expect.any(FormData),
+        headers: {},
+        method: "POST",
+      })
+      const sentData = JSON.stringify(fetch.mock.calls[0][1].body)
+      expect(sentData).toContain(pageParam)
+      expect(sentData).toContain(sizeParam)
+    })
+
+    it("can paginate using form-encoded request body", async () => {
+      const pageParam = "my_page_param"
+      const sizeParam = "my_size_param"
+      const pageValue = 3
+      const sizeValue = 10
+      const query = {
+        bodyType: "encoded",
+        path: "api",
+        pagination: {
+          type: "page",
+          location: "body",
+          pageParam,
+          sizeParam,
+        },
+        paginationValues: {
+          page: pageValue,
+          limit: sizeValue,
+        },
+      }
+      await config.integration.create(query)
+      expect(fetch).toHaveBeenCalledWith(`${BASE_URL}/api?`, {
+        body: expect.any(URLSearchParams),
+        headers: {},
+        method: "POST",
+      })
+      const sentData = fetch.mock.calls[0][1].body
+      expect(sentData.has(pageParam))
+      expect(sentData.get(pageParam)).toEqual(pageValue.toString())
+      expect(sentData.has(sizeParam))
+      expect(sentData.get(sizeParam)).toEqual(sizeValue.toString())
+    })
+  })
+
+  describe("cursor based pagination", () => {
+    it("can paginate using query params", async () => {
+      const pageParam = "my_page_param"
+      const sizeParam = "my_size_param"
+      const pageValue = 3
+      const sizeValue = 10
+      const query = {
+        path: "api",
+        pagination: {
+          type: "cursor",
+          location: "query",
+          pageParam,
+          sizeParam,
+          responseParam: "my_next_cursor",
+        },
+        paginationValues: {
+          page: pageValue,
+          limit: sizeValue,
+        },
+      }
+      const res = await config.integration.read(query)
+      expect(fetch).toHaveBeenCalledWith(
+        `${BASE_URL}/api?${pageParam}=${pageValue}&${sizeParam}=${sizeValue}&`,
+        {
+          headers: {},
+          method: "GET",
+        }
+      )
+      expect(res.pagination.cursor).toEqual(123)
+    })
+
+    it("can paginate using JSON request body", async () => {
+      const pageParam = "my_page_param"
+      const sizeParam = "my_size_param"
+      const pageValue = 3
+      const sizeValue = 10
+      const query = {
+        bodyType: "json",
+        path: "api",
+        pagination: {
+          type: "page",
+          location: "body",
+          pageParam,
+          sizeParam,
+          responseParam: "my_next_cursor",
+        },
+        paginationValues: {
+          page: pageValue,
+          limit: sizeValue,
+        },
+      }
+      const res = await config.integration.create(query)
+      expect(fetch).toHaveBeenCalledWith(`${BASE_URL}/api?`, {
+        body: JSON.stringify({
+          [pageParam]: pageValue,
+          [sizeParam]: sizeValue,
+        }),
+        headers: {
+          "Content-Type": "application/json",
+        },
+        method: "POST",
+      })
+      expect(res.pagination.cursor).toEqual(123)
+    })
+
+    it("can paginate using form-data request body", async () => {
+      const pageParam = "my_page_param"
+      const sizeParam = "my_size_param"
+      const pageValue = 3
+      const sizeValue = 10
+      const query = {
+        bodyType: "form",
+        path: "api",
+        pagination: {
+          type: "page",
+          location: "body",
+          pageParam,
+          sizeParam,
+          responseParam: "my_next_cursor",
+        },
+        paginationValues: {
+          page: pageValue,
+          limit: sizeValue,
         },
+      }
+      const res = await config.integration.create(query)
+      expect(fetch).toHaveBeenCalledWith(`${BASE_URL}/api?`, {
+        body: expect.any(FormData),
+        headers: {},
+        method: "POST",
+      })
+      const sentData = JSON.stringify(fetch.mock.calls[0][1].body)
+      expect(sentData).toContain(pageParam)
+      expect(sentData).toContain(sizeParam)
+      expect(res.pagination.cursor).toEqual(123)
+    })
+
+    it("can paginate using form-encoded request body", async () => {
+      const pageParam = "my_page_param"
+      const sizeParam = "my_size_param"
+      const pageValue = 3
+      const sizeValue = 10
+      const query = {
+        bodyType: "encoded",
+        path: "api",
+        pagination: {
+          type: "page",
+          location: "body",
+          pageParam,
+          sizeParam,
+          responseParam: "my_next_cursor",
+        },
+        paginationValues: {
+          page: pageValue,
+          limit: sizeValue,
+        },
+      }
+      const res = await config.integration.create(query)
+      expect(fetch).toHaveBeenCalledWith(`${BASE_URL}/api?`, {
+        body: expect.any(URLSearchParams),
+        headers: {},
+        method: "POST",
       })
+      const sentData = fetch.mock.calls[0][1].body
+      expect(sentData.has(pageParam))
+      expect(sentData.get(pageParam)).toEqual(pageValue.toString())
+      expect(sentData.has(sizeParam))
+      expect(sentData.get(sizeParam)).toEqual(sizeValue.toString())
+      expect(res.pagination.cursor).toEqual(123)
     })
   })
 })

package/src/middleware/currentapp.js

@@ -1,6 +1,10 @@
-const { getAppId, setCookie, getCookie, clearCookie } =
-  require("@budibase/backend-core").utils
-const { Cookies } = require("@budibase/backend-core").constants
+const {
+  getAppId,
+  setCookie,
+  getCookie,
+  clearCookie,
+} = require("@budibase/backend-core/utils")
+const { Cookies } = require("@budibase/backend-core/constants")
 const { getRole } = require("@budibase/backend-core/roles")
 const { BUILTIN_ROLE_IDS } = require("@budibase/backend-core/roles")
 const { generateUserMetadataID, isDevAppID } = require("../db/utils")

package/src/middleware/tests/currentapp.spec.js

@@ -32,34 +32,30 @@ function mockAuthWithNoCookie() {
       },
     },
   }))
-  jest.mock("@budibase/backend-core", () => ({
-    utils: {
-      getAppId: jest.fn(),
-      setCookie: jest.fn(),
-      getCookie: jest.fn(),
-    },
-    constants: {
-      Cookies: {},
-    },
+  jest.mock("@budibase/backend-core/utils", () => ({
+    getAppId: jest.fn(),
+    setCookie: jest.fn(),
+    getCookie: jest.fn(),
+  }))
+  jest.mock("@budibase/backend-core/constants", () => ({
+    Cookies: {},
   }))
 }
 
 function mockAuthWithCookie() {
   jest.resetModules()
   mockWorker()
-  jest.mock("@budibase/backend-core", () => ({
-    utils: {
-      getAppId: () => {
-        return "app_test"
-      },
-      setCookie: jest.fn(),
-      getCookie: () => ({appId: "app_different", roleId: "PUBLIC"}),
+  jest.mock("@budibase/backend-core/utils", () => ({
+    getAppId: () => {
+      return "app_test"
     },
-    constants: {
-      Cookies: {
-        Auth: "auth",
-        CurrentApp: "currentapp",
-      },
+    setCookie: jest.fn(),
+    getCookie: () => ({appId: "app_different", roleId: "PUBLIC"}),
+  }))
+  jest.mock("@budibase/backend-core/constants", () => ({
+    Cookies: {
+      Auth: "auth",
+      CurrentApp: "currentapp",
     },
   }))
 }
@@ -121,7 +117,7 @@ describe("Current app middleware", () => {
     async function checkExpected(setCookie) {
       config.setUser()
       await config.executeMiddleware()
-      const cookieFn = require("@budibase/backend-core").utils.setCookie
+      let { setCookie: cookieFn } = require("@budibase/backend-core/utils")
       if (setCookie) {
         expect(cookieFn).toHaveBeenCalled()
       } else {
@@ -140,32 +136,30 @@ describe("Current app middleware", () => {
 
     it("should perform correct when no cookie exists", async () => {
       mockReset()
-      jest.mock("@budibase/backend-core", () => ({
-        utils: {
-          getAppId: () => {
-            return "app_test"
-          },
-          setCookie: jest.fn(),
-          getCookie: jest.fn(),
-        },
-        constants: {
-          Cookies: {},
+      jest.mock("@budibase/backend-core/utils", () => ({
+        getAppId: () => {
+          return "app_test"
         },
+        setCookie: jest.fn(),
+        getCookie: jest.fn(),
+      }))
+      jest.mock("@budibase/backend-core/constants", () => ({
+        Cookies: {},
       }))
       await checkExpected(true)
     })
 
     it("lastly check what occurs when cookie doesn't need updated", async () => {
       mockReset()
-      jest.mock("@budibase/backend-core", () => ({
-        utils: {
-          getAppId: () => {
-            return "app_test"
-          },
-          setCookie: jest.fn(),
-          getCookie: () => ({appId: "app_test", roleId: "PUBLIC"}),
+      jest.mock("@budibase/backend-core/utils", () => ({
+        getAppId: () => {
+          return "app_test"
         },
-        constants: { Cookies: {} },
+        setCookie: jest.fn(),
+        getCookie: () => ({appId: "app_test", roleId: "PUBLIC"}),
+      }))
+      jest.mock("@budibase/backend-core/constants", () => ({
+        Cookies: {},
       }))
       await checkExpected(false)
     })

package/src/tests/utilities/TestConfiguration.js

@@ -15,8 +15,8 @@ const {
 const controllers = require("./controllers")
 const supertest = require("supertest")
 const { cleanup } = require("../../utilities/fileSystem")
-const { Cookies, Headers } = require("@budibase/backend-core").constants
-const { jwt } = require("@budibase/backend-core").auth
+const { Cookies, Headers } = require("@budibase/backend-core/constants")
+const { jwt } = require("@budibase/backend-core/auth")
 const core = require("@budibase/backend-core")
 const { getGlobalDB } = require("@budibase/backend-core/tenancy")
 const { createASession } = require("@budibase/backend-core/sessions")

package/src/threads/automation.js

@@ -4,7 +4,7 @@ const actions = require("../automations/actions")
 const automationUtils = require("../automations/automationUtils")
 const AutomationEmitter = require("../events/AutomationEmitter")
 const { processObject } = require("@budibase/string-templates")
-const { DEFAULT_TENANT_ID } = require("@budibase/backend-core").constants
+const { DEFAULT_TENANT_ID } = require("@budibase/backend-core/constants")
 const CouchDB = require("../db")
 const { DocumentTypes, isDevAppID } = require("../db/utils")
 const { doInTenant } = require("@budibase/backend-core/tenancy")

package/src/threads/query.js

@@ -5,6 +5,9 @@ const { integrations } = require("../integrations")
 const { processStringSync } = require("@budibase/string-templates")
 const CouchDB = require("../db")
 
+const IS_TRIPLE_BRACE = new RegExp(/^{{3}.*}{3}$/)
+const IS_HANDLEBARS = new RegExp(/^{{2}.*}{2}$/)
+
 class QueryRunner {
   constructor(input, flags = { noRecursiveQuery: false }) {
     this.appId = input.appId
@@ -12,6 +15,7 @@ class QueryRunner {
     this.queryVerb = input.queryVerb
     this.fields = input.fields
     this.parameters = input.parameters
+    this.pagination = input.pagination
     this.transformer = input.transformer
     this.queryId = input.queryId
     this.noRecursiveQuery = flags.noRecursiveQuery
@@ -27,7 +31,13 @@ class QueryRunner {
     let { datasource, fields, queryVerb, transformer } = this
     // pre-query, make sure datasource variables are added to parameters
     const parameters = await this.addDatasourceVariables()
-    const query = threadUtils.enrichQueryFields(fields, parameters)
+    let query = this.enrichQueryFields(fields, parameters)
+
+    // Add pagination values for REST queries
+    if (this.pagination) {
+      query.paginationValues = this.pagination
+    }
+
     const Integration = integrations[datasource.source]
     if (!Integration) {
       throw "Integration type does not exist."
@@ -37,11 +47,13 @@ class QueryRunner {
     let output = threadUtils.formatResponse(await integration[queryVerb](query))
     let rows = output,
       info = undefined,
-      extra = undefined
+      extra = undefined,
+      pagination = undefined
     if (threadUtils.hasExtraData(output)) {
       rows = output.data
       info = output.info
       extra = output.extra
+      pagination = output.pagination
     }
 
     // transform as required
@@ -83,7 +95,7 @@ class QueryRunner {
       integration.end()
     }
 
-    return { rows, keys, info, extra }
+    return { rows, keys, info, extra, pagination }
   }
 
   async runAnotherQuery(queryId, parameters) {
@@ -159,6 +171,50 @@ class QueryRunner {
     }
     return parameters
   }
+
+  enrichQueryFields(fields, parameters = {}) {
+    const enrichedQuery = {}
+
+    // enrich the fields with dynamic parameters
+    for (let key of Object.keys(fields)) {
+      if (fields[key] == null) {
+        continue
+      }
+      if (typeof fields[key] === "object") {
+        // enrich nested fields object
+        enrichedQuery[key] = this.enrichQueryFields(fields[key], parameters)
+      } else if (typeof fields[key] === "string") {
+        // enrich string value as normal
+        let value = fields[key]
+        // add triple brace to avoid escaping e.g. '=' in cookie header
+        if (IS_HANDLEBARS.test(value) && !IS_TRIPLE_BRACE.test(value)) {
+          value = `{${value}}`
+        }
+        enrichedQuery[key] = processStringSync(value, parameters, {
+          noHelpers: true,
+        })
+      } else {
+        enrichedQuery[key] = fields[key]
+      }
+    }
+    if (
+      enrichedQuery.json ||
+      enrichedQuery.customData ||
+      enrichedQuery.requestBody
+    ) {
+      try {
+        enrichedQuery.json = JSON.parse(
+          enrichedQuery.json ||
+            enrichedQuery.customData ||
+            enrichedQuery.requestBody
+        )
+      } catch (err) {
+        // no json found, ignore
+      }
+      delete enrichedQuery.customData
+    }
+    return enrichedQuery
+  }
 }
 
 module.exports = (input, callback) => {