@budibase/server 1.3.19-alpha.2 → 1.3.19

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

@@ -1,16 +1,15 @@
-import { default as DynamoDBIntegration } from "../dynamodb"
+const AWS = require("aws-sdk")
+const DynamoDBIntegration = require("../dynamodb")
 jest.mock("aws-sdk")
 
 class TestConfiguration {
-  integration: any
-
-  constructor(config: any = {}) {
-    this.integration = new DynamoDBIntegration.integration(config)
+  constructor(config = {}) {
+    this.integration = new DynamoDBIntegration.integration(config) 
   }
 }
 
 describe("DynamoDB Integration", () => {
-  let config: any
+  let config 
   let tableName = "Users"
 
   beforeEach(() => {
@@ -18,25 +17,25 @@ describe("DynamoDB Integration", () => {
   })
 
   it("calls the create method with the correct params", async () => {
-    const response = await config.integration.create({
+    const response = await config.integration.create({ 
       table: tableName,
       json: {
-        Name: "John",
-      },
+        Name: "John"
+      }
     })
     expect(config.integration.client.put).toHaveBeenCalledWith({
       TableName: tableName,
-      Name: "John",
+      Name: "John"
     })
   })
 
   it("calls the read method with the correct params", async () => {
     const indexName = "Test"
 
-    const response = await config.integration.read({
+    const response = await config.integration.read({ 
       table: tableName,
-      index: indexName,
-      json: {},
+      index: indexName, 
+      json: {}
     })
     expect(config.integration.client.query).toHaveBeenCalledWith({
       TableName: tableName,
@@ -48,59 +47,57 @@ describe("DynamoDB Integration", () => {
   it("calls the scan method with the correct params", async () => {
     const indexName = "Test"
 
-    const response = await config.integration.scan({
+    const response = await config.integration.scan({ 
       table: tableName,
-      index: indexName,
-      json: {},
+      index: indexName, 
+      json: {}
     })
     expect(config.integration.client.scan).toHaveBeenCalledWith({
       TableName: tableName,
       IndexName: indexName,
     })
-    expect(response).toEqual([
-      {
-        Name: "test",
-      },
-    ])
+    expect(response).toEqual([{
+      Name: "test"
+    }])
   })
 
   it("calls the get method with the correct params", async () => {
-    const response = await config.integration.get({
+    const response = await config.integration.get({ 
       table: tableName,
       json: {
-        Id: 123,
-      },
+        Id: 123
+      }
     })
 
     expect(config.integration.client.get).toHaveBeenCalledWith({
       TableName: tableName,
-      Id: 123,
+      Id: 123
     })
   })
 
   it("calls the update method with the correct params", async () => {
-    const response = await config.integration.update({
+    const response = await config.integration.update({ 
       table: tableName,
       json: {
-        Name: "John",
-      },
+        Name: "John"
+      }
     })
     expect(config.integration.client.update).toHaveBeenCalledWith({
       TableName: tableName,
-      Name: "John",
+      Name: "John"
     })
   })
 
   it("calls the delete method with the correct params", async () => {
-    const response = await config.integration.delete({
+    const response = await config.integration.delete({ 
       table: tableName,
       json: {
-        Name: "John",
-      },
+        Name: "John"
+      }
     })
     expect(config.integration.client.delete).toHaveBeenCalledWith({
       TableName: tableName,
-      Name: "John",
+      Name: "John"
     })
   })
 
@@ -108,14 +105,14 @@ describe("DynamoDB Integration", () => {
     const config = {
       region: "us-east-1",
       accessKeyId: "test",
-      secretAccessKey: "test",
+      secretAccessKeyId: "test"
     }
 
-    const integration: any = new DynamoDBIntegration.integration(config)
+    const integration = new DynamoDBIntegration.integration(config)
 
     expect(integration.config).toEqual({
       currentClockSkew: true,
-      ...config,
+      ...config
     })
   })
 
@@ -123,16 +120,16 @@ describe("DynamoDB Integration", () => {
     const config = {
       region: "us-east-1",
       accessKeyId: "test",
-      secretAccessKey: "test",
-      endpoint: "localhost:8080",
+      secretAccessKeyId: "test",
+      endpoint: "localhost:8080"
     }
 
-    const integration: any = new DynamoDBIntegration.integration(config)
+    const integration = new DynamoDBIntegration.integration(config)
 
     expect(integration.config).toEqual({
       region: "us-east-1",
       currentClockSkew: true,
-      endpoint: "localhost:8080",
+      endpoint: "localhost:8080"
     })
   })
 
@@ -140,16 +137,15 @@ describe("DynamoDB Integration", () => {
     const config = {
       region: "us-east-1",
       accessKeyId: "test",
-      secretAccessKey: "test",
-      endpoint: "dynamodb.aws.foo.net",
+      secretAccessKeyId: "test",
+      endpoint: "dynamodb.aws.foo.net"
     }
 
     const integration = new DynamoDBIntegration.integration(config)
 
-    // @ts-ignore
     expect(integration.config).toEqual({
       currentClockSkew: true,
-      ...config,
+      ...config
     })
   })
-})
+})

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

@@ -1,16 +1,15 @@
-import { default as ElasticSearchIntegration } from "../elasticsearch"
+const elasticsearch = require("@elastic/elasticsearch")
+const ElasticSearchIntegration = require("../elasticsearch")
 jest.mock("@elastic/elasticsearch")
 
 class TestConfiguration {
-  integration: any
-
-  constructor(config: any = {}) {
-    this.integration = new ElasticSearchIntegration.integration(config)
+  constructor(config = {}) {
+    this.integration = new ElasticSearchIntegration.integration(config) 
   }
 }
 
 describe("Elasticsearch Integration", () => {
-  let config: any
+  let config 
   let indexName = "Users"
 
   beforeEach(() => {
@@ -19,15 +18,15 @@ describe("Elasticsearch Integration", () => {
 
   it("calls the create method with the correct params", async () => {
     const body = {
-      name: "Hello",
+      name: "Hello"
     }
-    const response = await config.integration.create({
+    const response = await config.integration.create({ 
       index: indexName,
-      json: body,
+      json: body
     })
     expect(config.integration.client.index).toHaveBeenCalledWith({
       index: indexName,
-      body,
+      body 
     })
   })
 
@@ -35,43 +34,43 @@ describe("Elasticsearch Integration", () => {
     const body = {
       query: {
         term: {
-          name: "kimchy",
-        },
-      },
+          name: "kimchy"
+        }
+      }
     }
-    const response = await config.integration.read({
+    const response = await config.integration.read({ 
       index: indexName,
-      json: body,
+      json: body
     })
     expect(config.integration.client.search).toHaveBeenCalledWith({
       index: indexName,
-      body,
+      body 
     })
     expect(response).toEqual(expect.any(Array))
   })
 
   it("calls the update method with the correct params", async () => {
     const body = {
-      name: "updated",
+      name: "updated"
     }
 
-    const response = await config.integration.update({
+    const response = await config.integration.update({ 
       id: "1234",
       index: indexName,
-      json: body,
+      json: body
     })
 
     expect(config.integration.client.update).toHaveBeenCalledWith({
       id: "1234",
       index: indexName,
-      body,
+      body 
     })
     expect(response).toEqual(expect.any(Array))
   })
 
   it("calls the delete method with the correct params", async () => {
     const body = {
-      id: "1234",
+      id: "1234"
     }
 
     const response = await config.integration.delete(body)
@@ -79,4 +78,4 @@ describe("Elasticsearch Integration", () => {
     expect(config.integration.client.delete).toHaveBeenCalledWith(body)
     expect(response).toEqual(expect.any(Array))
   })
-})
+})

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

@@ -1,97 +1,92 @@
-import { default as FirebaseIntegration } from "../firebase"
+const firebase = require("@google-cloud/firestore")
+const FirebaseIntegration = require("../firebase")
 jest.mock("@google-cloud/firestore")
 
 class TestConfiguration {
-  integration: any
-
-  constructor(config: any = {}) {
-    this.integration = new FirebaseIntegration.integration(config)
+  constructor(config = {}) {
+    this.integration = new FirebaseIntegration.integration(config) 
   }
 }
 
 describe("Firebase Integration", () => {
-  let config: any
+  let config 
   let tableName = "Users"
 
   beforeEach(() => {
     config = new TestConfiguration({
-      serviceAccount: "{}",
+      serviceAccount: "{}"
     })
   })
 
   it("calls the create method with the correct params", async () => {
-    await config.integration.create({
+    await config.integration.create({ 
       table: tableName,
       json: {
-        Name: "Test Name",
+        Name: "Test Name"
       },
       extra: {
-        collection: "test",
-      },
+        collection: "test"
+      }
     })
     expect(config.integration.client.collection).toHaveBeenCalledWith("test")
-    expect(config.integration.client.set).toHaveBeenCalledWith({
+    expect(config.integration.client.set).toHaveBeenCalledWith({ 
       Name: "Test Name",
-      id: "test_id",
+      id: "test_id"
     })
   })
 
   it("calls the read method with the correct params", async () => {
-    const response = await config.integration.read({
+    const response = await config.integration.read({ 
       table: tableName,
       json: {
-        Name: "Test",
+        Name: "Test"
       },
       extra: {
         collection: "test",
         filterField: "field",
         filter: "==",
         filterValue: "value",
-      },
+      }
     })
     expect(config.integration.client.collection).toHaveBeenCalledWith("test")
-    expect(config.integration.client.where).toHaveBeenCalledWith(
-      "field",
-      "==",
-      "value"
-    )
-    expect(response).toEqual([{ result: "test" }])
+    expect(config.integration.client.where).toHaveBeenCalledWith("field", "==", "value")
+    expect(response).toEqual([{ result: "test"}])
   })
 
   it("calls the update method with the correct params", async () => {
-    const response = await config.integration.update({
+    const response = await config.integration.update({ 
       table: tableName,
       json: {
         id: "test",
-        Name: "Test",
+        Name: "Test"
       },
       extra: {
-        collection: "test",
-      },
+        collection: "test"
+      }
     })
     expect(config.integration.client.collection).toHaveBeenCalledWith("test")
     expect(config.integration.client.update).toHaveBeenCalledWith({
       Name: "Test",
-      id: "test",
+      id: "test"
     })
     expect(response).toEqual({
-      result: "test",
+      result: "test"
     })
   })
 
   it("calls the delete method with the correct params", async () => {
-    const response = await config.integration.delete({
+    const response = await config.integration.delete({ 
       table: tableName,
       json: {
         id: "test",
-        Name: "Test",
+        Name: "Test"
       },
       extra: {
-        collection: "test",
-      },
+        collection: "test"
+      }
     })
     expect(config.integration.client.collection).toHaveBeenCalledWith("test")
     expect(config.integration.client.doc).toHaveBeenCalledWith("test")
     expect(config.integration.client.delete).toHaveBeenCalled()
   })
-})
+})

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

@@ -1,16 +1,15 @@
-import { default as MSSQLIntegration } from "../microsoftSqlServer"
+const sqlServer = require("mssql")
+const MSSQLIntegration = require("../microsoftSqlServer")
 jest.mock("mssql")
 
 class TestConfiguration {
-  integration: any
-
-  constructor(config: any = {}) {
-    this.integration = new MSSQLIntegration.integration(config)
+  constructor(config = {}) {
+    this.integration = new MSSQLIntegration.integration(config) 
   }
 }
 
 describe("MS SQL Server Integration", () => {
-  let config: any
+  let config
 
   beforeEach(async () => {
     config = new TestConfiguration()
@@ -24,7 +23,7 @@ describe("MS SQL Server Integration", () => {
     it("calls the create method with the correct params", async () => {
       const sql = "insert into users (name, age) values ('Joe', 123);"
       const response = await config.integration.create({
-        sql,
+        sql
       })
       expect(config.integration.client.request).toHaveBeenCalledWith()
       expect(response[0]).toEqual(sql)
@@ -33,7 +32,7 @@ describe("MS SQL Server Integration", () => {
     it("calls the read method with the correct params", async () => {
       const sql = "select * from users;"
       const response = await config.integration.read({
-        sql,
+        sql
       })
       expect(config.integration.client.request).toHaveBeenCalledWith()
       expect(response[0]).toEqual(sql)
@@ -46,11 +45,11 @@ describe("MS SQL Server 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[0]).toEqual(sql)
     })
   })
-})
+})