@budibase/server 1.3.19 → 1.3.21-alpha.0

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

@@ -1,15 +1,16 @@
-const AWS = require("aws-sdk")
-const DynamoDBIntegration = require("../dynamodb")
+import { default as DynamoDBIntegration } from "../dynamodb"
 jest.mock("aws-sdk")
 
 class TestConfiguration {
-  constructor(config = {}) {
-    this.integration = new DynamoDBIntegration.integration(config) 
+  integration: any
+
+  constructor(config: any = {}) {
+    this.integration = new DynamoDBIntegration.integration(config)
   }
 }
 
 describe("DynamoDB Integration", () => {
-  let config 
+  let config: any
   let tableName = "Users"
 
   beforeEach(() => {
@@ -17,25 +18,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,
@@ -47,57 +48,59 @@ 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",
     })
   })
 
@@ -105,14 +108,14 @@ describe("DynamoDB Integration", () => {
     const config = {
       region: "us-east-1",
       accessKeyId: "test",
-      secretAccessKeyId: "test"
+      secretAccessKey: "test",
     }
 
-    const integration = new DynamoDBIntegration.integration(config)
+    const integration: any = new DynamoDBIntegration.integration(config)
 
     expect(integration.config).toEqual({
       currentClockSkew: true,
-      ...config
+      ...config,
     })
   })
 
@@ -120,16 +123,16 @@ describe("DynamoDB Integration", () => {
     const config = {
       region: "us-east-1",
       accessKeyId: "test",
-      secretAccessKeyId: "test",
-      endpoint: "localhost:8080"
+      secretAccessKey: "test",
+      endpoint: "localhost:8080",
     }
 
-    const integration = new DynamoDBIntegration.integration(config)
+    const integration: any = new DynamoDBIntegration.integration(config)
 
     expect(integration.config).toEqual({
       region: "us-east-1",
       currentClockSkew: true,
-      endpoint: "localhost:8080"
+      endpoint: "localhost:8080",
     })
   })
 
@@ -137,15 +140,16 @@ describe("DynamoDB Integration", () => {
     const config = {
       region: "us-east-1",
       accessKeyId: "test",
-      secretAccessKeyId: "test",
-      endpoint: "dynamodb.aws.foo.net"
+      secretAccessKey: "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.js → elasticsearch.spec.ts}

@@ -1,15 +1,16 @@
-const elasticsearch = require("@elastic/elasticsearch")
-const ElasticSearchIntegration = require("../elasticsearch")
+import { default as ElasticSearchIntegration } from "../elasticsearch"
 jest.mock("@elastic/elasticsearch")
 
 class TestConfiguration {
-  constructor(config = {}) {
-    this.integration = new ElasticSearchIntegration.integration(config) 
+  integration: any
+
+  constructor(config: any = {}) {
+    this.integration = new ElasticSearchIntegration.integration(config)
   }
 }
 
 describe("Elasticsearch Integration", () => {
-  let config 
+  let config: any
   let indexName = "Users"
 
   beforeEach(() => {
@@ -18,15 +19,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,
     })
   })
 
@@ -34,43 +35,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)
@@ -78,4 +79,4 @@ describe("Elasticsearch Integration", () => {
     expect(config.integration.client.delete).toHaveBeenCalledWith(body)
     expect(response).toEqual(expect.any(Array))
   })
-})
+})

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

@@ -1,92 +1,97 @@
-const firebase = require("@google-cloud/firestore")
-const FirebaseIntegration = require("../firebase")
+import { default as FirebaseIntegration } from "../firebase"
 jest.mock("@google-cloud/firestore")
 
 class TestConfiguration {
-  constructor(config = {}) {
-    this.integration = new FirebaseIntegration.integration(config) 
+  integration: any
+
+  constructor(config: any = {}) {
+    this.integration = new FirebaseIntegration.integration(config)
   }
 }
 
 describe("Firebase Integration", () => {
-  let config 
+  let config: any
   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.js → microsoftSqlServer.spec.ts}

@@ -1,15 +1,16 @@
-const sqlServer = require("mssql")
-const MSSQLIntegration = require("../microsoftSqlServer")
+import { default as MSSQLIntegration } from "../microsoftSqlServer"
 jest.mock("mssql")
 
 class TestConfiguration {
-  constructor(config = {}) {
-    this.integration = new MSSQLIntegration.integration(config) 
+  integration: any
+
+  constructor(config: any = {}) {
+    this.integration = new MSSQLIntegration.integration(config)
   }
 }
 
 describe("MS SQL Server Integration", () => {
-  let config
+  let config: any
 
   beforeEach(async () => {
     config = new TestConfiguration()
@@ -23,7 +24,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)
@@ -32,7 +33,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)
@@ -45,11 +46,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)
     })
   })
-})
+})