@budibase/server 1.0.199 → 1.0.200-alpha.2

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

@@ -13,6 +13,7 @@ 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()
@@ -38,16 +39,46 @@ 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)
-      const res = await request
-        .post(`/api/queries`)
-        .send(query)
-        .set(config.defaultHeaders())
-        .expect("Content-Type", /json/)
-        .expect(200)
+      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)
 
       expect(res.res.statusMessage).toEqual(
         `Query ${query.name} saved successfully.`
@@ -56,7 +87,11 @@ 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)
     })
   })
 
@@ -73,7 +108,9 @@ describe("/queries", () => {
         {
           _rev: query._rev,
           _id: query._id,
+          createdAt: new Date().toISOString(),
           ...basicQuery(datasource._id),
+          updatedAt: new Date().toISOString(),
           readable: true,
         },
       ])
@@ -149,6 +186,8 @@ 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 () => {
@@ -162,21 +201,25 @@ 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({
-          datasourceId: datasource._id,
-          parameters: {},
-          fields: {},
-          queryVerb: "read",
-          name: datasource.name,
-        })
+        .send(query)
         .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,6 +4,7 @@ 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()
@@ -15,20 +16,48 @@ 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 request
-        .post(`/api/roles`)
-        .send(basicRole())
-        .set(config.defaultHeaders())
-        .expect("Content-Type", /json/)
-        .expect(200)
+      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)
 
       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)
     })
   })
 
@@ -80,8 +109,10 @@ describe("/roles", () => {
     it("should delete custom roles", async () => {
       const customRole = await config.createRole({
         name: "user",
-        permissionId: BUILTIN_PERMISSION_IDS.READ_ONLY
+        permissionId: BUILTIN_PERMISSION_IDS.READ_ONLY,
+        inherits: BUILTIN_ROLE_IDS.BASIC,
       })
+      delete customRole._rev_tree
       await request
         .delete(`/api/roles/${customRole._id}/${customRole._rev}`)
         .set(config.defaultHeaders())
@@ -90,6 +121,8 @@ 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,9 +5,6 @@ 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()
@@ -103,6 +100,8 @@ 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,6 +1,7 @@
 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()
@@ -35,16 +36,40 @@ describe("/screens", () => {
   })
 
   describe("save", () => {
-    it("should be able to save a screen", async () => {
-      const screenCfg = basicScreen()
+    const saveScreen = async (screen) => {
       const res = await request
         .post(`/api/screens`)
-        .send(screenCfg)
+        .send(screen)
         .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(screenCfg.name)
+      expect(res.body.name).toEqual(screen.name)
+      expect(events.screen.created).not.toBeCalled()
     })
 
     it("should apply authorization to endpoint", async () => {
@@ -64,6 +89,7 @@ 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,8 +14,9 @@ jest.mock("aws-sdk", () => ({
 }))
 
 const setup = require("./utilities")
+const { events, constants } = require("@budibase/backend-core")
 
-describe("/attachments", () => {
+describe("/static", () => {
   let request = setup.getRequest()
   let config = setup.getConfig()
   let app
@@ -26,73 +27,138 @@ describe("/attachments", () => {
     app = await config.init()
   })
 
-  describe("generateSignedUrls", () => {
-    let datasource
-
-    beforeEach(async () => {
-      datasource = await config.createDatasource({
-        datasource: {
-          type: "datasource",
-          name: "Test",
-          source: "S3",
-          config: {},
-        },
-      })
+  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()
     })
 
-    it("should be able to generate a signed upload URL", async () => {
-      const bucket = "foo"
-      const key = "bar"
+    it("should serve the app by id", async () => {
+      const headers = config.defaultHeaders()
+      delete headers[constants.Headers.APP_ID]
+
       const res = await request
-        .post(`/api/attachments/${datasource._id}/url`)
-        .send({ bucket, key })
-        .set(config.defaultHeaders())
-        .expect("Content-Type", /json/)
+        .get(`/${config.prodAppId}`)
+        .set(headers)
         .expect(200)
-      expect(res.body.signedUrl).toEqual("my-url")
-      expect(res.body.publicUrl).toEqual(
-        `https://${bucket}.s3.eu-west-1.amazonaws.com/${key}`
-      )
+
+      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()
     })
 
-    it("should handle an invalid datasource ID", async () => {
+    it("should serve the app by url", async () => {
+      const headers = config.defaultHeaders()
+      delete headers[constants.Headers.APP_ID]
+      
       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"
-      )
+        .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()
     })
 
-    it("should require a bucket parameter", async () => {
+    it("should serve the app preview by id", async () => {
       const res = await request
-        .post(`/api/attachments/${datasource._id}/url`)
-        .send({
-          bucket: undefined,
-          key: "bar",
-        })
+        .get(`/${config.appId}`)
         .set(config.defaultHeaders())
-        .expect("Content-Type", /json/)
-        .expect(400)
-      expect(res.body.message).toEqual("bucket and key values are required")
+        .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()
     })
+  })
 
-    it("should require a key parameter", async () => {
-      const res = await request
-        .post(`/api/attachments/${datasource._id}/url`)
-        .send({
-          bucket: "foo",
+  describe("/attachments", () => {
+    describe("generateSignedUrls", () => {
+      let datasource
+  
+      beforeEach(async () => {
+        datasource = await config.createDatasource({
+          datasource: {
+            type: "datasource",
+            name: "Test",
+            source: "S3",
+            config: {},
+          },
         })
-        .set(config.defaultHeaders())
-        .expect("Content-Type", /json/)
-        .expect(400)
-      expect(res.body.message).toEqual("bucket and key values are required")
+      })
+  
+      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")
+      })
     })
   })
+
 })

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

@@ -2,6 +2,7 @@ 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()
@@ -14,24 +15,76 @@ describe("/tables", () => {
   })
 
   describe("create", () => {
-    it("returns a success message when the table is successfully created", async () => {
-      const res = await request
+
+    beforeEach(() => {
+      jest.clearAllMocks()
+    })
+
+    const createTable = (table) => {
+      if (!table) {
+        table = basicTable()
+      }
+      return request
         .post(`/api/tables`)
-        .send({
-          name: "TestTable",
-          key: "name",
-          schema: {
-            name: {type: "string"}
-          }
-        })
+        .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("renames all the row fields for a table when a schema key is renamed", async () => {
+    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)
+        .set(config.defaultHeaders())
+        .expect('Content-Type', /json/)
+        .expect(200)
+
+      expect(events.table.updated).toBeCalledTimes(1)
+      expect(events.table.updated).toBeCalledWith(res.body)
+    })
+
+    it("updates all the row fields for a table when a schema key is renamed", async () => {
       const testTable = await config.createTable()
 
       const testRow = await request
@@ -74,22 +127,47 @@ describe("/tables", () => {
       expect(res.body.name).toBeUndefined()
     })
 
-    it("should apply authorization to endpoint", async () => {
-      await checkBuilderEndpoint({
-        config,
-        method: "POST",
-        url: `/api/tables`,
-        body: {
-          name: "TestTable",
-          key: "name",
-          schema: {
-            name: {type: "string"}
-          }
-        }
+    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
+        }
+      }
+      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)
+    })
+  })
+
   describe("fetch", () => {
     let testTable
 
@@ -153,22 +231,6 @@ 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
@@ -205,6 +267,8 @@ 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 () => {