@budibase/server 1.0.200-alpha.3 → 1.0.200

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

@@ -13,7 +13,6 @@ const setup = require("./utilities")
 const { checkBuilderEndpoint } = require("./utilities/TestFunctions")
 const { checkCacheForDynamicVariable } = require("../../../threads/utils")
 const { basicQuery, basicDatasource } = setup.structures
-const { events } = require("@budibase/backend-core")
 
 describe("/queries", () => {
   let request = setup.getRequest()
@@ -39,46 +38,16 @@ describe("/queries", () => {
     return { datasource, query }
   }
 
-  const createQuery = async (query) => {
-    return request
-      .post(`/api/queries`)
-      .send(query)
-      .set(config.defaultHeaders())
-      .expect("Content-Type", /json/)
-      .expect(200)
-  }
-
   describe("create", () => {
     it("should create a new query", async () => {
       const { _id } = await config.createDatasource()
       const query = basicQuery(_id)
-      jest.clearAllMocks()
-      const res = await createQuery(query)
-
-      expect(res.res.statusMessage).toEqual(
-        `Query ${query.name} saved successfully.`
-      )
-      expect(res.body).toEqual({
-        _rev: res.body._rev,
-        _id: res.body._id,
-        ...query,
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString()
-      })
-      expect(events.query.created).toBeCalledTimes(1)
-      expect(events.query.updated).not.toBeCalled()
-    })
-  })
-
-  describe("update", () => {
-    it("should update query", async () => {
-      const { _id } = await config.createDatasource()
-      const query = basicQuery(_id)
-      const res = await createQuery(query)
-      jest.clearAllMocks()
-      query._id = res.body._id
-      query._rev = res.body._rev
-      await createQuery(query)
+      const res = await request
+        .post(`/api/queries`)
+        .send(query)
+        .set(config.defaultHeaders())
+        .expect("Content-Type", /json/)
+        .expect(200)
 
       expect(res.res.statusMessage).toEqual(
         `Query ${query.name} saved successfully.`
@@ -87,11 +56,7 @@ describe("/queries", () => {
         _rev: res.body._rev,
         _id: res.body._id,
         ...query,
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString()
       })
-      expect(events.query.created).not.toBeCalled()
-      expect(events.query.updated).toBeCalledTimes(1)
     })
   })
 
@@ -108,9 +73,7 @@ describe("/queries", () => {
         {
           _rev: query._rev,
           _id: query._id,
-          createdAt: new Date().toISOString(),
           ...basicQuery(datasource._id),
-          updatedAt: new Date().toISOString(),
           readable: true,
         },
       ])
@@ -186,8 +149,6 @@ describe("/queries", () => {
         .expect(200)
 
       expect(res.body).toEqual([])
-      expect(events.query.deleted).toBeCalledTimes(1)
-      expect(events.query.deleted).toBeCalledWith(datasource, query)
     })
 
     it("should apply authorization to endpoint", async () => {
@@ -201,25 +162,21 @@ describe("/queries", () => {
 
   describe("preview", () => {
     it("should be able to preview the query", async () => {
-      const query = {
-        datasourceId: datasource._id,
-        parameters: {},
-        fields: {},
-        queryVerb: "read",
-        name: datasource.name,
-      }
       const res = await request
         .post(`/api/queries/preview`)
-        .send(query)
+        .send({
+          datasourceId: datasource._id,
+          parameters: {},
+          fields: {},
+          queryVerb: "read",
+          name: datasource.name,
+        })
         .set(config.defaultHeaders())
         .expect("Content-Type", /json/)
         .expect(200)
       // these responses come from the mock
       expect(res.body.schemaFields).toEqual(["a", "b"])
       expect(res.body.rows.length).toEqual(1)
-      expect(events.query.previewed).toBeCalledTimes(1)
-      datasource.config = { schema: "public" }
-      expect(events.query.previewed).toBeCalledWith(datasource, query)
     })
 
     it("should apply authorization to endpoint", async () => {

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

@@ -4,7 +4,6 @@ const {
 } = require("@budibase/backend-core/permissions")
 const setup = require("./utilities")
 const { basicRole } = setup.structures
-const { events } = require("@budibase/backend-core")
 
 describe("/roles", () => {
   let request = setup.getRequest()
@@ -16,48 +15,20 @@ describe("/roles", () => {
     await config.init()
   })
 
-  const createRole = async (role) => {
-    if (!role) {
-      role =  basicRole()
-    }
-
-    return request
-      .post(`/api/roles`)
-      .send(role)
-      .set(config.defaultHeaders())
-      .expect("Content-Type", /json/)
-      .expect(200)
-  }
-
   describe("create", () => {
     it("returns a success message when role is successfully created", async () => {
-      const res = await createRole()
-
-      expect(res.res.statusMessage).toEqual(
-        "Role 'NewRole' created successfully."
-      )
-      expect(res.body._id).toBeDefined()
-      expect(res.body._rev).toBeDefined()
-      expect(events.role.updated).not.toBeCalled()
-      expect(events.role.created).toBeCalledTimes(1)
-      expect(events.role.created).toBeCalledWith(res.body)
-    })
-  })
-
-  describe("update", () => {
-    it("updates a role", async () => {
-      let res = await createRole()
-      jest.clearAllMocks()
-      res = await createRole(res.body)
+      const res = await request
+        .post(`/api/roles`)
+        .send(basicRole())
+        .set(config.defaultHeaders())
+        .expect("Content-Type", /json/)
+        .expect(200)
 
       expect(res.res.statusMessage).toEqual(
         "Role 'NewRole' created successfully."
       )
       expect(res.body._id).toBeDefined()
       expect(res.body._rev).toBeDefined()
-      expect(events.role.created).not.toBeCalled()
-      expect(events.role.updated).toBeCalledTimes(1)
-      expect(events.role.updated).toBeCalledWith(res.body)
     })
   })
 
@@ -109,10 +80,8 @@ describe("/roles", () => {
     it("should delete custom roles", async () => {
       const customRole = await config.createRole({
         name: "user",
-        permissionId: BUILTIN_PERMISSION_IDS.READ_ONLY,
-        inherits: BUILTIN_ROLE_IDS.BASIC,
+        permissionId: BUILTIN_PERMISSION_IDS.READ_ONLY
       })
-      delete customRole._rev_tree
       await request
         .delete(`/api/roles/${customRole._id}/${customRole._rev}`)
         .set(config.defaultHeaders())
@@ -121,8 +90,6 @@ describe("/roles", () => {
         .get(`/api/roles/${customRole._id}`)
         .set(config.defaultHeaders())
         .expect(404)
-      expect(events.role.deleted).toBeCalledTimes(1)
-      expect(events.role.deleted).toBeCalledWith(customRole)
     })
   })
 })

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

@@ -5,6 +5,9 @@ const { doInAppContext } = require("@budibase/backend-core/context")
 const { doInTenant } = require("@budibase/backend-core/tenancy")
 const { quotas, QuotaUsageType, StaticQuotaName, MonthlyQuotaName } = require("@budibase/pro")
 
+// mock the fetch for the search system
+jest.mock("node-fetch")
+
 describe("/rows", () => {
   let request = setup.getRequest()
   let config = setup.getConfig()
@@ -100,8 +103,6 @@ describe("/rows", () => {
         _id: existing._id,
         _rev: existing._rev,
         type: "row",
-        createdAt: "2020-01-01T00:00:00.000Z",
-        updatedAt: "2020-01-01T00:00:00.000Z",
       })
       await assertQueryUsage(queryUsage + 1)
     })

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

@@ -1,7 +1,6 @@
 const { checkBuilderEndpoint } = require("./utilities/TestFunctions")
 const setup = require("./utilities")
 const { basicScreen } = setup.structures
-const { events } = require("@budibase/backend-core")
 
 describe("/screens", () => {
   let request = setup.getRequest()
@@ -36,40 +35,16 @@ describe("/screens", () => {
   })
 
   describe("save", () => {
-    const saveScreen = async (screen) => {
+    it("should be able to save a screen", async () => {
+      const screenCfg = basicScreen()
       const res = await request
         .post(`/api/screens`)
-        .send(screen)
+        .send(screenCfg)
         .set(config.defaultHeaders())
         .expect("Content-Type", /json/)
         .expect(200)
-      return res
-    }
-
-    it("should be able to create a screen", async () => {
-      jest.clearAllMocks()
-
-      const screen = basicScreen()
-      const res = await saveScreen(screen)
-
-      expect(res.body._rev).toBeDefined()
-      expect(res.body.name).toEqual(screen.name)
-      expect(events.screen.created).toBeCalledTimes(1)
-    })
-
-    it("should be able to update a screen", async () => {
-      const screen = basicScreen()
-      let res = await saveScreen(screen)
-      screen._id = res.body._id
-      screen._rev = res.body._rev
-      screen.name = "edit"
-      jest.clearAllMocks()
-
-      res = await saveScreen(screen)
-
       expect(res.body._rev).toBeDefined()
-      expect(res.body.name).toEqual(screen.name)
-      expect(events.screen.created).not.toBeCalled()
+      expect(res.body.name).toEqual(screenCfg.name)
     })
 
     it("should apply authorization to endpoint", async () => {
@@ -89,7 +64,6 @@ describe("/screens", () => {
         .expect("Content-Type", /json/)
         .expect(200)
       expect(res.body.message).toBeDefined()
-      expect(events.screen.deleted).toBeCalledTimes(1)
     })
 
     it("should apply authorization to endpoint", async () => {

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

@@ -14,9 +14,8 @@ jest.mock("aws-sdk", () => ({
 }))
 
 const setup = require("./utilities")
-const { events, constants } = require("@budibase/backend-core")
 
-describe("/static", () => {
+describe("/attachments", () => {
   let request = setup.getRequest()
   let config = setup.getConfig()
   let app
@@ -27,138 +26,73 @@ describe("/static", () => {
     app = await config.init()
   })
 
-  describe("/builder", () => {
-    it("should serve the builder", async () => {
-      const res = await request
-        .get("/builder/portal")
-        .set(config.defaultHeaders())
-        .expect("Content-Type", /text\/html/)
-        .expect(200)
-
-      expect(res.text).toContain("<title>Budibase</title>")
-      expect(events.serve.servedBuilder).toBeCalledTimes(1)
-    })
-  })
-
-  describe("/app", () => {
-
-    beforeEach(() => {
-      jest.clearAllMocks()
+  describe("generateSignedUrls", () => {
+    let datasource
+
+    beforeEach(async () => {
+      datasource = await config.createDatasource({
+        datasource: {
+          type: "datasource",
+          name: "Test",
+          source: "S3",
+          config: {},
+        },
+      })
     })
 
-    it("should serve the app by id", async () => {
-      const headers = config.defaultHeaders()
-      delete headers[constants.Headers.APP_ID]
-
+    it("should be able to generate a signed upload URL", async () => {
+      const bucket = "foo"
+      const key = "bar"
       const res = await request
-        .get(`/${config.prodAppId}`)
-        .set(headers)
+        .post(`/api/attachments/${datasource._id}/url`)
+        .send({ bucket, key })
+        .set(config.defaultHeaders())
+        .expect("Content-Type", /json/)
         .expect(200)
-
-      expect(res.body.appId).toBe(config.prodAppId)
-      expect(events.serve.servedApp).toBeCalledTimes(1)
-      expect(events.serve.servedApp).toBeCalledWith(res.body)
-      expect(events.serve.servedAppPreview).not.toBeCalled()
+      expect(res.body.signedUrl).toEqual("my-url")
+      expect(res.body.publicUrl).toEqual(
+        `https://${bucket}.s3.eu-west-1.amazonaws.com/${key}`
+      )
     })
 
-    it("should serve the app by url", async () => {
-      const headers = config.defaultHeaders()
-      delete headers[constants.Headers.APP_ID]
-      
+    it("should handle an invalid datasource ID", async () => {
       const res = await request
-        .get(`/app${config.prodApp.url}`)
-        .set(headers)
-        .expect(200)
-
-      expect(res.body.appId).toBe(config.prodAppId)
-      expect(events.serve.servedApp).toBeCalledTimes(1)
-      expect(events.serve.servedApp).toBeCalledWith(res.body)
-      expect(events.serve.servedAppPreview).not.toBeCalled()
+        .post(`/api/attachments/foo/url`)
+        .send({
+          bucket: "foo",
+          key: "bar",
+        })
+        .set(config.defaultHeaders())
+        .expect("Content-Type", /json/)
+        .expect(400)
+      expect(res.body.message).toEqual(
+        "The specified datasource could not be found"
+      )
     })
 
-    it("should serve the app preview by id", async () => {
+    it("should require a bucket parameter", async () => {
       const res = await request
-        .get(`/${config.appId}`)
+        .post(`/api/attachments/${datasource._id}/url`)
+        .send({
+          bucket: undefined,
+          key: "bar",
+        })
         .set(config.defaultHeaders())
-        .expect(200)
-
-      expect(res.body.appId).toBe(config.appId)
-      expect(events.serve.servedAppPreview).toBeCalledTimes(1)
-      expect(events.serve.servedAppPreview).toBeCalledWith(res.body)
-      expect(events.serve.servedApp).not.toBeCalled()
+        .expect("Content-Type", /json/)
+        .expect(400)
+      expect(res.body.message).toEqual("bucket and key values are required")
     })
-  })
 
-  describe("/attachments", () => {
-    describe("generateSignedUrls", () => {
-      let datasource
-  
-      beforeEach(async () => {
-        datasource = await config.createDatasource({
-          datasource: {
-            type: "datasource",
-            name: "Test",
-            source: "S3",
-            config: {},
-          },
+    it("should require a key parameter", async () => {
+      const res = await request
+        .post(`/api/attachments/${datasource._id}/url`)
+        .send({
+          bucket: "foo",
         })
-      })
-  
-      it("should be able to generate a signed upload URL", async () => {
-        const bucket = "foo"
-        const key = "bar"
-        const res = await request
-          .post(`/api/attachments/${datasource._id}/url`)
-          .send({ bucket, key })
-          .set(config.defaultHeaders())
-          .expect("Content-Type", /json/)
-          .expect(200)
-        expect(res.body.signedUrl).toEqual("my-url")
-        expect(res.body.publicUrl).toEqual(
-          `https://${bucket}.s3.eu-west-1.amazonaws.com/${key}`
-        )
-      })
-  
-      it("should handle an invalid datasource ID", async () => {
-        const res = await request
-          .post(`/api/attachments/foo/url`)
-          .send({
-            bucket: "foo",
-            key: "bar",
-          })
-          .set(config.defaultHeaders())
-          .expect("Content-Type", /json/)
-          .expect(400)
-        expect(res.body.message).toEqual(
-          "The specified datasource could not be found"
-        )
-      })
-  
-      it("should require a bucket parameter", async () => {
-        const res = await request
-          .post(`/api/attachments/${datasource._id}/url`)
-          .send({
-            bucket: undefined,
-            key: "bar",
-          })
-          .set(config.defaultHeaders())
-          .expect("Content-Type", /json/)
-          .expect(400)
-        expect(res.body.message).toEqual("bucket and key values are required")
-      })
-  
-      it("should require a key parameter", async () => {
-        const res = await request
-          .post(`/api/attachments/${datasource._id}/url`)
-          .send({
-            bucket: "foo",
-          })
-          .set(config.defaultHeaders())
-          .expect("Content-Type", /json/)
-          .expect(400)
-        expect(res.body.message).toEqual("bucket and key values are required")
-      })
+        .set(config.defaultHeaders())
+        .expect("Content-Type", /json/)
+        .expect(400)
+      expect(res.body.message).toEqual("bucket and key values are required")
     })
   })
-
 })

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

@@ -2,7 +2,6 @@ const { checkBuilderEndpoint } = require("./utilities/TestFunctions")
 const { getAppDB } = require("@budibase/backend-core/context")
 const setup = require("./utilities")
 const { basicTable } = setup.structures
-const { events } = require("@budibase/backend-core")
 
 describe("/tables", () => {
   let request = setup.getRequest()
@@ -15,76 +14,24 @@ describe("/tables", () => {
   })
 
   describe("create", () => {
-
-    beforeEach(() => {
-      jest.clearAllMocks()
-    })
-
-    const createTable = (table) => {
-      if (!table) {
-        table = basicTable()
-      }
-      return request
-        .post(`/api/tables`)
-        .send(table)
-        .set(config.defaultHeaders())
-        .expect('Content-Type', /json/)
-        .expect(200)
-
-    }
-
     it("returns a success message when the table is successfully created", async () => {
-      const res = await createTable()
-
-      expect(res.res.statusMessage).toEqual("Table TestTable saved successfully.")
-      expect(res.body.name).toEqual("TestTable")
-      expect(events.table.created).toBeCalledTimes(1)
-      expect(events.table.created).toBeCalledWith(res.body)
-    })
-
-    it("creates a table via data import CSV", async () => {
-      const table = basicTable()
-      table.dataImport = {
-        csvString: "\"name\",\"description\"\n\"test-name\",\"test-desc\"",
-      }
-      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)
-      expect(events.table.imported).toBeCalledWith(res.body, "csv")
-      expect(events.rows.imported).toBeCalledTimes(1)
-      expect(events.rows.imported).toBeCalledWith(res.body, "csv", 1)
-    })
-
-    it("should apply authorization to endpoint", async () => {
-      await checkBuilderEndpoint({
-        config,
-        method: "POST",
-        url: `/api/tables`,
-        body: basicTable()
-      })
-    })
-  })
-
-  describe("update", () => {
-    it("updates a table", async () => {
-      const testTable = await config.createTable()
-
       const res = await request
         .post(`/api/tables`)
-        .send(testTable)
+        .send({
+          name: "TestTable",
+          key: "name",
+          schema: {
+            name: {type: "string"}
+          }
+        })
         .set(config.defaultHeaders())
         .expect('Content-Type', /json/)
         .expect(200)
-
-      expect(events.table.updated).toBeCalledTimes(1)
-      expect(events.table.updated).toBeCalledWith(res.body)
+      expect(res.res.statusMessage).toEqual("Table TestTable saved successfully.")
+      expect(res.body.name).toEqual("TestTable")
     })
 
-    it("updates all the row fields for a table when a schema key is renamed", async () => {
+    it("renames all the row fields for a table when a schema key is renamed", async () => {
       const testTable = await config.createTable()
 
       const testRow = await request
@@ -127,44 +74,19 @@ describe("/tables", () => {
       expect(res.body.name).toBeUndefined()
     })
 
-    describe("user table", () => {
-      it("should add roleId and email field when adjusting user table schema", async () => {
-        const res = await request
-          .post(`/api/tables`)
-          .send({
-            ...basicTable(),
-            _id: "ta_users",
-          })
-          .set(config.defaultHeaders())
-          .expect('Content-Type', /json/)
-          .expect(200)
-        expect(res.body.schema.email).toBeDefined()
-        expect(res.body.schema.roleId).toBeDefined()
-      })
-    })
-  })
-
-  describe("import", () => {
-    it("imports rows successfully", async () => {
-      const table = await config.createTable()
-      const importRequest = {
-        dataImport: {
-          csvString: "\"name\",\"description\"\n\"test-name\",\"test-desc\"",
-          schema: table.schema
+    it("should apply authorization to endpoint", async () => {
+      await checkBuilderEndpoint({
+        config,
+        method: "POST",
+        url: `/api/tables`,
+        body: {
+          name: "TestTable",
+          key: "name",
+          schema: {
+            name: {type: "string"}
+          }
         }
-      }
-      jest.clearAllMocks()
-
-      await request
-        .post(`/api/tables/${table._id}/import`)
-        .send(importRequest)
-        .set(config.defaultHeaders())
-        .expect('Content-Type', /json/)
-        .expect(200)
-
-      expect(events.table.created).not.toHaveBeenCalled()
-      expect(events.rows.imported).toBeCalledTimes(1)
-      expect(events.rows.imported).toBeCalledWith(table, "csv", 1)
+      })
     })
   })
 
@@ -231,6 +153,22 @@ describe("/tables", () => {
     })
   })
 
+  describe("updating user table", () => {
+    it("should add roleId and email field when adjusting user table schema", async () => {
+      const res = await request
+        .post(`/api/tables`)
+        .send({
+          ...basicTable(),
+          _id: "ta_users",
+        })
+        .set(config.defaultHeaders())
+        .expect('Content-Type', /json/)
+        .expect(200)
+      expect(res.body.schema.email).toBeDefined()
+      expect(res.body.schema.roleId).toBeDefined()
+    })
+  })
+
   describe("validate csv", () => {
     it("should be able to validate a CSV layout", async () => {
       const res = await request
@@ -267,8 +205,6 @@ describe("/tables", () => {
         .expect('Content-Type', /json/)
         .expect(200)
       expect(res.body.message).toEqual(`Table ${testTable._id} deleted.`)
-      expect(events.table.deleted).toBeCalledTimes(1)
-      expect(events.table.deleted).toBeCalledWith(testTable)
     })
 
     it("deletes linked references to the table after deletion", async () => {