@budibase/server 1.3.21 → 1.3.22-alpha.1

package/src/integrations/tests/{mongo.spec.js → mongo.spec.ts}

@@ -1,22 +1,26 @@
 const mongo = require("mongodb")
-const MongoDBIntegration = require("../mongodb")
+import { default as MongoDBIntegration } from "../mongodb"
 jest.mock("mongodb")
 
 class TestConfiguration {
-  constructor(config = {}) {
+  integration: any
+
+  constructor(config: any = {}) {
     this.integration = new MongoDBIntegration.integration(config)
   }
 }
 
 function disableConsole() {
   jest.spyOn(console, "error")
+  // @ts-ignore
   console.error.mockImplementation(() => {})
 
+  // @ts-ignore
   return console.error.mockRestore
 }
 
 describe("MongoDB Integration", () => {
-  let config
+  let config: any
   let indexName = "Users"
 
   beforeEach(() => {
@@ -54,13 +58,16 @@ describe("MongoDB Integration", () => {
           id: "test",
         },
         options: {
-          opt: "option"
-        }
+          opt: "option",
+        },
       },
       extra: { collection: "testCollection", actionTypes: "deleteOne" },
     }
     await config.integration.delete(query)
-    expect(config.integration.client.deleteOne).toHaveBeenCalledWith(query.json.filter, query.json.options)
+    expect(config.integration.client.deleteOne).toHaveBeenCalledWith(
+      query.json.filter,
+      query.json.options
+    )
   })
 
   it("calls the update method with the correct params", async () => {
@@ -108,7 +115,7 @@ describe("MongoDB Integration", () => {
       json: {
         filter: {
           _id: "ObjectId('ACBD12345678ABCD12345678')",
-          name: "ObjectId('BBBB12345678ABCD12345678')"
+          name: "ObjectId('BBBB12345678ABCD12345678')",
         },
         update: {
           _id: "ObjectId('FFFF12345678ABCD12345678')",
@@ -122,7 +129,7 @@ describe("MongoDB Integration", () => {
     }
     await config.integration.update(query)
     expect(config.integration.client.updateOne).toHaveBeenCalled()
-    
+
     const args = config.integration.client.updateOne.mock.calls[0]
     expect(args[0]).toEqual({
       _id: mongo.ObjectID.createFromHexString("ACBD12345678ABCD12345678"),
@@ -133,7 +140,7 @@ describe("MongoDB Integration", () => {
       name: mongo.ObjectID.createFromHexString("CCCC12345678ABCD12345678"),
     })
     expect(args[2]).toEqual({
-      upsert: false
+      upsert: false,
     })
   })
 
@@ -143,7 +150,7 @@ describe("MongoDB Integration", () => {
         filter: {
           _id: {
             $eq: "ObjectId('ACBD12345678ABCD12345678')",
-          }
+          },
         },
         update: {
           $set: {
@@ -158,20 +165,20 @@ describe("MongoDB Integration", () => {
     }
     await config.integration.update(query)
     expect(config.integration.client.updateOne).toHaveBeenCalled()
-    
+
     const args = config.integration.client.updateOne.mock.calls[0]
     expect(args[0]).toEqual({
       _id: {
         $eq: mongo.ObjectID.createFromHexString("ACBD12345678ABCD12345678"),
-      }
+      },
     })
     expect(args[1]).toEqual({
       $set: {
         _id: mongo.ObjectID.createFromHexString("FFFF12345678ABCD12345678"),
-      }
+      },
     })
     expect(args[2]).toEqual({
-      upsert: true
+      upsert: true,
     })
   })
 
@@ -181,12 +188,12 @@ describe("MongoDB Integration", () => {
         filter: {
           _id: {
             $eq: "ObjectId('ACBD12345678ABCD12345678')",
-          }
+          },
         },
         update: {
           $set: {
             name: "UPDATED",
-            age: 99
+            age: 99,
           },
         },
         options: {
@@ -197,21 +204,21 @@ describe("MongoDB Integration", () => {
     }
     await config.integration.read(query)
     expect(config.integration.client.findOneAndUpdate).toHaveBeenCalled()
-    
+
     const args = config.integration.client.findOneAndUpdate.mock.calls[0]
     expect(args[0]).toEqual({
       _id: {
         $eq: mongo.ObjectID.createFromHexString("ACBD12345678ABCD12345678"),
-      }
+      },
     })
     expect(args[1]).toEqual({
       $set: {
         name: "UPDATED",
-        age: 99
-      }
+        age: 99,
+      },
     })
     expect(args[2]).toEqual({
-      upsert: false
+      upsert: false,
     })
   })
 
@@ -242,12 +249,12 @@ describe("MongoDB Integration", () => {
     }
     await config.integration.update(query)
     expect(config.integration.client.updateOne).toHaveBeenCalled()
-    
+
     const args = config.integration.client.updateOne.mock.calls[0]
     expect(args[0]).toEqual({
       _id: {
         $eq: mongo.ObjectID.createFromHexString("ACBD12345678ABCD12345678"),
-      }
+      },
     })
     expect(args[1]).toEqual({
       $set: {
@@ -255,15 +262,17 @@ describe("MongoDB Integration", () => {
           data: [
             { cid: 1 },
             { cid: 2 },
-            { nested: {
-              name: "test"
-            }}
-          ]
+            {
+              nested: {
+                name: "test",
+              },
+            },
+          ],
         },
       },
     })
     expect(args[2]).toEqual({
-      upsert: true
+      upsert: true,
     })
   })
 
@@ -295,12 +304,12 @@ describe("MongoDB Integration", () => {
     }
     await config.integration.update(query)
     expect(config.integration.client.updateOne).toHaveBeenCalled()
-    
+
     const args = config.integration.client.updateOne.mock.calls[0]
     expect(args[0]).toEqual({
       _id: {
         $eq: mongo.ObjectID.createFromHexString("ACBD12345678ABCD12345678"),
-      }
+      },
     })
     expect(args[1]).toEqual({
       $set: {
@@ -308,16 +317,18 @@ describe("MongoDB Integration", () => {
           data: [
             { cid: 1 },
             { cid: 2 },
-            { nested: {
-              name: "te}st"
-            }}
-          ]
+            {
+              nested: {
+                name: "te}st",
+              },
+            },
+          ],
         },
       },
     })
     expect(args[2]).toEqual({
       upsert: true,
-      extra: "ad\"{\"d"
+      extra: 'ad"{"d',
     })
   })
 })

package/src/integrations/tests/{mysql.spec.js → mysql.spec.ts}

@@ -1,14 +1,16 @@
-const MySQLIntegration = require("../mysql")
+import { default as MySQLIntegration } from "../mysql"
 jest.mock("mysql2")
 
 class TestConfiguration {
-  constructor(config = { ssl: {} }) {
+  integration: any
+
+  constructor(config: any = { ssl: {} }) {
     this.integration = new MySQLIntegration.integration(config)
   }
 }
 
 describe("MySQL Integration", () => {
-  let config 
+  let config: any
 
   beforeEach(() => {
     config = new TestConfiguration()
@@ -17,7 +19,7 @@ describe("MySQL Integration", () => {
   it("calls the create method with the correct params", async () => {
     const sql = "insert into users (name, age) values ('Joe', 123);"
     await config.integration.create({
-      sql
+      sql,
     })
     expect(config.integration.client.query).toHaveBeenCalledWith(sql, [])
   })
@@ -25,7 +27,7 @@ describe("MySQL Integration", () => {
   it("calls the read method with the correct params", async () => {
     const sql = "select * from users;"
     await config.integration.read({
-      sql
+      sql,
     })
     expect(config.integration.client.query).toHaveBeenCalledWith(sql, [])
   })
@@ -33,7 +35,7 @@ describe("MySQL Integration", () => {
   it("calls the update method with the correct params", async () => {
     const sql = "update table users set name = 'test';"
     await config.integration.update({
-      sql
+      sql,
     })
     expect(config.integration.client.query).toHaveBeenCalledWith(sql, [])
   })
@@ -41,34 +43,34 @@ describe("MySQL Integration", () => {
   it("calls the delete method with the correct params", async () => {
     const sql = "delete from users where name = 'todelete';"
     await config.integration.delete({
-      sql
+      sql,
     })
     expect(config.integration.client.query).toHaveBeenCalledWith(sql, [])
   })
 
   describe("no rows returned", () => {
     it("returns the correct response when the create response has no rows", async () => {
-    const sql = "insert into users (name, age) values ('Joe', 123);"
-      const response = await config.integration.create({ 
-        sql
+      const sql = "insert into users (name, age) values ('Joe', 123);"
+      const response = await config.integration.create({
+        sql,
       })
       expect(response).toEqual([{ created: true }])
     })
 
     it("returns the correct response when the update response has no rows", async () => {
       const sql = "update table users set name = 'test';"
-      const response = await config.integration.update({ 
-        sql
+      const response = await config.integration.update({
+        sql,
       })
       expect(response).toEqual([{ updated: true }])
     })
 
     it("returns the correct response when the delete response has no rows", async () => {
       const sql = "delete from users where name = 'todelete';"
-      const response = await config.integration.delete({ 
-        sql
+      const response = await config.integration.delete({
+        sql,
       })
       expect(response).toEqual([{ deleted: true }])
     })
   })
-})
+})

package/src/integrations/tests/{oracle.spec.js → oracle.spec.ts}

@@ -1,17 +1,19 @@
 const oracledb = require("oracledb")
-const OracleIntegration = require("../oracle")
+import { default as OracleIntegration } from "../oracle"
 jest.mock("oracledb")
 
 class TestConfiguration {
-  constructor(config = {}) {
-    this.integration = new OracleIntegration.integration(config) 
+  integration: any
+
+  constructor(config: any = {}) {
+    this.integration = new OracleIntegration.integration(config)
   }
 }
 
 const options = { autoCommit: true }
 
 describe("Oracle Integration", () => {
-  let config 
+  let config: any
 
   beforeEach(() => {
     jest.clearAllMocks()
@@ -26,7 +28,7 @@ describe("Oracle Integration", () => {
   it("calls the create method with the correct params", async () => {
     const sql = "insert into users (name, age) values ('Joe', 123);"
     await config.integration.create({
-      sql
+      sql,
     })
     expect(oracledb.executeMock).toHaveBeenCalledWith(sql, [], options)
     expect(oracledb.executeMock).toHaveBeenCalledTimes(1)
@@ -35,7 +37,7 @@ describe("Oracle Integration", () => {
   it("calls the read method with the correct params", async () => {
     const sql = "select * from users;"
     await config.integration.read({
-      sql
+      sql,
     })
     expect(oracledb.executeMock).toHaveBeenCalledWith(sql, [], options)
     expect(oracledb.executeMock).toHaveBeenCalledTimes(1)
@@ -43,8 +45,8 @@ describe("Oracle Integration", () => {
 
   it("calls the update method with the correct params", async () => {
     const sql = "update table users set name = 'test';"
-    const response = await config.integration.update({ 
-      sql
+    const response = await config.integration.update({
+      sql,
     })
     expect(oracledb.executeMock).toHaveBeenCalledWith(sql, [], options)
     expect(oracledb.executeMock).toHaveBeenCalledTimes(1)
@@ -53,7 +55,7 @@ describe("Oracle Integration", () => {
   it("calls the delete method with the correct params", async () => {
     const sql = "delete from users where name = 'todelete';"
     await config.integration.delete({
-      sql
+      sql,
     })
     expect(oracledb.executeMock).toHaveBeenCalledWith(sql, [], options)
     expect(oracledb.executeMock).toHaveBeenCalledTimes(1)
@@ -65,9 +67,9 @@ describe("Oracle Integration", () => {
     })
 
     it("returns the correct response when the create response has no rows", async () => {
-    const sql = "insert into users (name, age) values ('Joe', 123);"
-      const response = await config.integration.create({ 
-        sql
+      const sql = "insert into users (name, age) values ('Joe', 123);"
+      const response = await config.integration.create({
+        sql,
       })
       expect(response).toEqual([{ created: true }])
       expect(oracledb.executeMock).toHaveBeenCalledTimes(1)
@@ -75,8 +77,8 @@ describe("Oracle Integration", () => {
 
     it("returns the correct response when the update response has no rows", async () => {
       const sql = "update table users set name = 'test';"
-      const response = await config.integration.update({ 
-        sql
+      const response = await config.integration.update({
+        sql,
       })
       expect(response).toEqual([{ updated: true }])
       expect(oracledb.executeMock).toHaveBeenCalledTimes(1)
@@ -84,11 +86,11 @@ describe("Oracle Integration", () => {
 
     it("returns the correct response when the delete response has no rows", async () => {
       const sql = "delete from users where name = 'todelete';"
-      const response = await config.integration.delete({ 
-        sql
+      const response = await config.integration.delete({
+        sql,
       })
       expect(response).toEqual([{ deleted: true }])
       expect(oracledb.executeMock).toHaveBeenCalledTimes(1)
     })
   })
-})
+})

package/src/integrations/tests/{postgres.spec.js → postgres.spec.ts}

@@ -1,15 +1,17 @@
 const pg = require("pg")
-const PostgresIntegration = require("../postgres")
+import { default as PostgresIntegration } from "../postgres"
 jest.mock("pg")
 
 class TestConfiguration {
-  constructor(config = {}) {
-    this.integration = new PostgresIntegration.integration(config) 
+  integration: any
+
+  constructor(config: any = {}) {
+    this.integration = new PostgresIntegration.integration(config)
   }
 }
 
 describe("Postgres Integration", () => {
-  let config 
+  let config: any
 
   beforeEach(() => {
     config = new TestConfiguration()
@@ -18,7 +20,7 @@ describe("Postgres Integration", () => {
   it("calls the create method with the correct params", async () => {
     const sql = "insert into users (name, age) values ('Joe', 123);"
     await config.integration.create({
-      sql
+      sql,
     })
     expect(pg.queryMock).toHaveBeenCalledWith(sql, [])
   })
@@ -26,15 +28,15 @@ describe("Postgres Integration", () => {
   it("calls the read method with the correct params", async () => {
     const sql = "select * from users;"
     await config.integration.read({
-      sql
+      sql,
     })
     expect(pg.queryMock).toHaveBeenCalledWith(sql, [])
   })
 
   it("calls the update method with the correct params", async () => {
     const sql = "update table users set name = 'test';"
-    const response = await config.integration.update({ 
-      sql
+    const response = await config.integration.update({
+      sql,
     })
     expect(pg.queryMock).toHaveBeenCalledWith(sql, [])
   })
@@ -42,7 +44,7 @@ describe("Postgres Integration", () => {
   it("calls the delete method with the correct params", async () => {
     const sql = "delete from users where name = 'todelete';"
     await config.integration.delete({
-      sql
+      sql,
     })
     expect(pg.queryMock).toHaveBeenCalledWith(sql, [])
   })
@@ -53,27 +55,27 @@ describe("Postgres Integration", () => {
     })
 
     it("returns the correct response when the create response has no rows", async () => {
-    const sql = "insert into users (name, age) values ('Joe', 123);"
-      const response = await config.integration.create({ 
-        sql
+      const sql = "insert into users (name, age) values ('Joe', 123);"
+      const response = await config.integration.create({
+        sql,
       })
       expect(response).toEqual([{ created: true }])
     })
 
     it("returns the correct response when the update response has no rows", async () => {
       const sql = "update table users set name = 'test';"
-      const response = await config.integration.update({ 
-        sql
+      const response = await config.integration.update({
+        sql,
       })
       expect(response).toEqual([{ updated: true }])
     })
 
     it("returns the correct response when the delete response has no rows", async () => {
       const sql = "delete from users where name = 'todelete';"
-      const response = await config.integration.delete({ 
-        sql
+      const response = await config.integration.delete({
+        sql,
       })
       expect(response).toEqual([{ deleted: true }])
     })
   })
-})
+})

package/src/integrations/tests/{redis.spec.js → redis.spec.ts}

@@ -1,13 +1,16 @@
 const Redis = require("ioredis-mock")
-const RedisIntegration = require("../redis")
+import { default as RedisIntegration } from "../redis"
 
 class TestConfiguration {
-  constructor(config = {}) {
-    this.integration = new RedisIntegration.integration(config) 
+  integration: any
+  redis: any
+
+  constructor(config: any = {}) {
+    this.integration = new RedisIntegration.integration(config)
     this.redis = new Redis({
       data: {
-        test: 'test',
-        result: "1"
+        test: "test",
+        result: "1",
       },
     })
     this.integration.client = this.redis
@@ -15,7 +18,7 @@ class TestConfiguration {
 }
 
 describe("Redis Integration", () => {
-  let config 
+  let config: any
 
   beforeEach(() => {
     config = new TestConfiguration()
@@ -24,15 +27,15 @@ describe("Redis Integration", () => {
   it("calls the create method with the correct params", async () => {
     const body = {
       key: "key",
-      value: "value"
+      value: "value",
     }
-    const response = await config.integration.create(body)
+    await config.integration.create(body)
     expect(await config.redis.get("key")).toEqual("value")
   })
 
   it("calls the read method with the correct params", async () => {
     const body = {
-      key: "test"
+      key: "test",
     }
     const response = await config.integration.read(body)
     expect(response).toEqual("test")
@@ -40,7 +43,7 @@ describe("Redis Integration", () => {
 
   it("calls the delete method with the correct params", async () => {
     const body = {
-      key: "test"
+      key: "test",
     }
     await config.integration.delete(body)
     expect(await config.redis.get(body.key)).toEqual(null)
@@ -48,28 +51,34 @@ describe("Redis Integration", () => {
 
   it("calls the pipeline method with the correct params", async () => {
     const body = {
-      json: "KEYS *"
+      json: "KEYS *",
     }
 
     // ioredis-mock doesn't support pipelines
-    config.integration.client.pipeline = jest.fn(() => ({ exec: jest.fn(() => [[]]) }))
+    config.integration.client.pipeline = jest.fn(() => ({
+      exec: jest.fn(() => [[]]),
+    }))
 
     await config.integration.command(body)
-    expect(config.integration.client.pipeline).toHaveBeenCalledWith([["keys", "*"]])
+    expect(config.integration.client.pipeline).toHaveBeenCalledWith([
+      ["keys", "*"],
+    ])
   })
 
   it("calls the pipeline method with several separated commands when there are newlines", async () => {
     const body = {
-      json: 'SET foo "bar"\nGET foo'
+      json: 'SET foo "bar"\nGET foo',
     }
 
     // ioredis-mock doesn't support pipelines
-    config.integration.client.pipeline = jest.fn(() => ({ exec: jest.fn(() => [[]]) }))
+    config.integration.client.pipeline = jest.fn(() => ({
+      exec: jest.fn(() => [[]]),
+    }))
 
     await config.integration.command(body)
     expect(config.integration.client.pipeline).toHaveBeenCalledWith([
-      ["set", 'foo', '"bar"'],
-      ["get", 'foo']
+      ["set", "foo", '"bar"'],
+      ["get", "foo"],
     ])
   })
-})
+})