@budibase/server 1.3.19-alpha.1 → 1.3.19

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

@@ -1,26 +1,22 @@
 const mongo = require("mongodb")
-import { default as MongoDBIntegration } from "../mongodb"
+const MongoDBIntegration = require("../mongodb")
 jest.mock("mongodb")
 
 class TestConfiguration {
-  integration: any
-
-  constructor(config: any = {}) {
+  constructor(config = {}) {
     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: any
+  let config
   let indexName = "Users"
 
   beforeEach(() => {
@@ -58,16 +54,13 @@ 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 () => {
@@ -115,7 +108,7 @@ describe("MongoDB Integration", () => {
       json: {
         filter: {
           _id: "ObjectId('ACBD12345678ABCD12345678')",
-          name: "ObjectId('BBBB12345678ABCD12345678')",
+          name: "ObjectId('BBBB12345678ABCD12345678')"
         },
         update: {
           _id: "ObjectId('FFFF12345678ABCD12345678')",
@@ -129,7 +122,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"),
@@ -140,7 +133,7 @@ describe("MongoDB Integration", () => {
       name: mongo.ObjectID.createFromHexString("CCCC12345678ABCD12345678"),
     })
     expect(args[2]).toEqual({
-      upsert: false,
+      upsert: false
     })
   })
 
@@ -150,7 +143,7 @@ describe("MongoDB Integration", () => {
         filter: {
           _id: {
             $eq: "ObjectId('ACBD12345678ABCD12345678')",
-          },
+          }
         },
         update: {
           $set: {
@@ -165,20 +158,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
     })
   })
 
@@ -188,12 +181,12 @@ describe("MongoDB Integration", () => {
         filter: {
           _id: {
             $eq: "ObjectId('ACBD12345678ABCD12345678')",
-          },
+          }
         },
         update: {
           $set: {
             name: "UPDATED",
-            age: 99,
+            age: 99
           },
         },
         options: {
@@ -204,21 +197,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
     })
   })
 
@@ -249,12 +242,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: {
@@ -262,17 +255,15 @@ describe("MongoDB Integration", () => {
           data: [
             { cid: 1 },
             { cid: 2 },
-            {
-              nested: {
-                name: "test",
-              },
-            },
-          ],
+            { nested: {
+              name: "test"
+            }}
+          ]
         },
       },
     })
     expect(args[2]).toEqual({
-      upsert: true,
+      upsert: true
     })
   })
 
@@ -304,12 +295,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: {
@@ -317,18 +308,16 @@ 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.ts → mysql.spec.js}

@@ -1,16 +1,14 @@
-import { default as MySQLIntegration } from "../mysql"
+const MySQLIntegration = require("../mysql")
 jest.mock("mysql2")
 
 class TestConfiguration {
-  integration: any
-
-  constructor(config: any = { ssl: {} }) {
+  constructor(config = { ssl: {} }) {
     this.integration = new MySQLIntegration.integration(config)
   }
 }
 
 describe("MySQL Integration", () => {
-  let config: any
+  let config 
 
   beforeEach(() => {
     config = new TestConfiguration()
@@ -19,7 +17,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, [])
   })
@@ -27,7 +25,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, [])
   })
@@ -35,7 +33,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, [])
   })
@@ -43,34 +41,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.ts → oracle.spec.js}

@@ -1,19 +1,17 @@
 const oracledb = require("oracledb")
-import { default as OracleIntegration } from "../oracle"
+const OracleIntegration = require("../oracle")
 jest.mock("oracledb")
 
 class TestConfiguration {
-  integration: any
-
-  constructor(config: any = {}) {
-    this.integration = new OracleIntegration.integration(config)
+  constructor(config = {}) {
+    this.integration = new OracleIntegration.integration(config) 
   }
 }
 
 const options = { autoCommit: true }
 
 describe("Oracle Integration", () => {
-  let config: any
+  let config 
 
   beforeEach(() => {
     jest.clearAllMocks()
@@ -28,7 +26,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)
@@ -37,7 +35,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)
@@ -45,8 +43,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)
@@ -55,7 +53,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)
@@ -67,9 +65,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)
@@ -77,8 +75,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)
@@ -86,11 +84,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.ts → postgres.spec.js}

@@ -1,17 +1,15 @@
 const pg = require("pg")
-import { default as PostgresIntegration } from "../postgres"
+const PostgresIntegration = require("../postgres")
 jest.mock("pg")
 
 class TestConfiguration {
-  integration: any
-
-  constructor(config: any = {}) {
-    this.integration = new PostgresIntegration.integration(config)
+  constructor(config = {}) {
+    this.integration = new PostgresIntegration.integration(config) 
   }
 }
 
 describe("Postgres Integration", () => {
-  let config: any
+  let config 
 
   beforeEach(() => {
     config = new TestConfiguration()
@@ -20,7 +18,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, [])
   })
@@ -28,15 +26,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, [])
   })
@@ -44,7 +42,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, [])
   })
@@ -55,27 +53,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.ts → redis.spec.js}

@@ -1,16 +1,13 @@
 const Redis = require("ioredis-mock")
-import { default as RedisIntegration } from "../redis"
+const RedisIntegration = require("../redis")
 
 class TestConfiguration {
-  integration: any
-  redis: any
-
-  constructor(config: any = {}) {
-    this.integration = new RedisIntegration.integration(config)
+  constructor(config = {}) {
+    this.integration = new RedisIntegration.integration(config) 
     this.redis = new Redis({
       data: {
-        test: "test",
-        result: "1",
+        test: 'test',
+        result: "1"
       },
     })
     this.integration.client = this.redis
@@ -18,7 +15,7 @@ class TestConfiguration {
 }
 
 describe("Redis Integration", () => {
-  let config: any
+  let config 
 
   beforeEach(() => {
     config = new TestConfiguration()
@@ -27,15 +24,15 @@ describe("Redis Integration", () => {
   it("calls the create method with the correct params", async () => {
     const body = {
       key: "key",
-      value: "value",
+      value: "value"
     }
-    await config.integration.create(body)
+    const response = 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")
@@ -43,7 +40,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)
@@ -51,34 +48,28 @@ 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']
     ])
   })
-})
+})