@budibase/server 1.3.20 → 1.3.21-alpha.1

package/src/integrations/s3.ts

@@ -1,86 +1,83 @@
 import { Integration, QueryType, IntegrationBase } from "@budibase/types"
+const AWS = require("aws-sdk")
 
-module S3Module {
-  const AWS = require("aws-sdk")
-
-  interface S3Config {
-    region: string
-    accessKeyId: string
-    secretAccessKey: string
-    s3ForcePathStyle: boolean
-    endpoint?: string
-  }
+interface S3Config {
+  region: string
+  accessKeyId: string
+  secretAccessKey: string
+  s3ForcePathStyle: boolean
+  endpoint?: string
+}
 
-  const SCHEMA: Integration = {
-    docs: "https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/S3.html",
-    description:
-      "Amazon Simple Storage Service (Amazon S3) is an object storage service that offers industry-leading scalability, data availability, security, and performance.",
-    friendlyName: "Amazon S3",
-    type: "Object store",
-    datasource: {
-      region: {
-        type: "string",
-        required: false,
-        default: "us-east-1",
-      },
-      accessKeyId: {
-        type: "password",
-        required: true,
-      },
-      secretAccessKey: {
-        type: "password",
-        required: true,
-      },
-      endpoint: {
-        type: "string",
-        required: false,
-      },
-      signatureVersion: {
-        type: "string",
-        required: false,
-        default: "v4",
-      },
+const SCHEMA: Integration = {
+  docs: "https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/S3.html",
+  description:
+    "Amazon Simple Storage Service (Amazon S3) is an object storage service that offers industry-leading scalability, data availability, security, and performance.",
+  friendlyName: "Amazon S3",
+  type: "Object store",
+  datasource: {
+    region: {
+      type: "string",
+      required: false,
+      default: "us-east-1",
+    },
+    accessKeyId: {
+      type: "password",
+      required: true,
     },
-    query: {
-      read: {
-        type: QueryType.FIELDS,
-        fields: {
-          bucket: {
-            type: "string",
-            required: true,
-          },
+    secretAccessKey: {
+      type: "password",
+      required: true,
+    },
+    endpoint: {
+      type: "string",
+      required: false,
+    },
+    signatureVersion: {
+      type: "string",
+      required: false,
+      default: "v4",
+    },
+  },
+  query: {
+    read: {
+      type: QueryType.FIELDS,
+      fields: {
+        bucket: {
+          type: "string",
+          required: true,
         },
       },
     },
-  }
-
-  class S3Integration implements IntegrationBase {
-    private readonly config: S3Config
-    private client: any
+  },
+}
 
-    constructor(config: S3Config) {
-      this.config = config
-      if (this.config.endpoint) {
-        this.config.s3ForcePathStyle = true
-      } else {
-        delete this.config.endpoint
-      }
+class S3Integration implements IntegrationBase {
+  private readonly config: S3Config
+  private client: any
 
-      this.client = new AWS.S3(this.config)
+  constructor(config: S3Config) {
+    this.config = config
+    if (this.config.endpoint) {
+      this.config.s3ForcePathStyle = true
+    } else {
+      delete this.config.endpoint
     }
 
-    async read(query: { bucket: string }) {
-      const response = await this.client
-        .listObjects({
-          Bucket: query.bucket,
-        })
-        .promise()
-      return response.Contents
-    }
+    this.client = new AWS.S3(this.config)
   }
 
-  module.exports = {
-    schema: SCHEMA,
-    integration: S3Integration,
+  async read(query: { bucket: string }) {
+    const response = await this.client
+      .listObjects({
+        Bucket: query.bucket,
+      })
+      .promise()
+    return response.Contents
   }
 }
+
+export default {
+  schema: SCHEMA,
+  integration: S3Integration,
+}

package/src/integrations/snowflake.ts

@@ -1,99 +1,97 @@
 import { Integration, QueryType, SqlQuery } from "@budibase/types"
 import { Snowflake } from "snowflake-promise"
 
-module SnowflakeModule {
-  interface SnowflakeConfig {
-    account: string
-    username: string
-    password: string
-    warehouse: string
-    database: string
-    schema: string
-  }
+interface SnowflakeConfig {
+  account: string
+  username: string
+  password: string
+  warehouse: string
+  database: string
+  schema: string
+}
 
-  const SCHEMA: Integration = {
-    docs: "https://developers.snowflake.com/",
-    description:
-      "Snowflake is a solution for data warehousing, data lakes, data engineering, data science, data application development, and securely sharing and consuming shared data.",
-    friendlyName: "Snowflake",
-    type: "Relational",
-    datasource: {
-      account: {
-        type: "string",
-        required: true,
-      },
-      username: {
-        type: "string",
-        required: true,
-      },
-      password: {
-        type: "password",
-        required: true,
-      },
-      warehouse: {
-        type: "string",
-        required: true,
-      },
-      database: {
-        type: "string",
-        required: true,
-      },
-      schema: {
-        type: "string",
-        required: true,
-      },
+const SCHEMA: Integration = {
+  docs: "https://developers.snowflake.com/",
+  description:
+    "Snowflake is a solution for data warehousing, data lakes, data engineering, data science, data application development, and securely sharing and consuming shared data.",
+  friendlyName: "Snowflake",
+  type: "Relational",
+  datasource: {
+    account: {
+      type: "string",
+      required: true,
     },
-    query: {
-      create: {
-        type: QueryType.SQL,
-      },
-      read: {
-        type: QueryType.SQL,
-      },
-      update: {
-        type: QueryType.SQL,
-      },
-      delete: {
-        type: QueryType.SQL,
-      },
+    username: {
+      type: "string",
+      required: true,
     },
-  }
-
-  class SnowflakeIntegration {
-    private client: Snowflake
+    password: {
+      type: "password",
+      required: true,
+    },
+    warehouse: {
+      type: "string",
+      required: true,
+    },
+    database: {
+      type: "string",
+      required: true,
+    },
+    schema: {
+      type: "string",
+      required: true,
+    },
+  },
+  query: {
+    create: {
+      type: QueryType.SQL,
+    },
+    read: {
+      type: QueryType.SQL,
+    },
+    update: {
+      type: QueryType.SQL,
+    },
+    delete: {
+      type: QueryType.SQL,
+    },
+  },
+}
 
-    constructor(config: SnowflakeConfig) {
-      this.client = new Snowflake(config)
-    }
+class SnowflakeIntegration {
+  private client: Snowflake
 
-    async internalQuery(query: SqlQuery) {
-      await this.client.connect()
-      try {
-        return await this.client.execute(query.sql)
-      } catch (err: any) {
-        throw err?.message.split(":")[1] || err?.message
-      }
-    }
+  constructor(config: SnowflakeConfig) {
+    this.client = new Snowflake(config)
+  }
 
-    async create(query: SqlQuery) {
-      return this.internalQuery(query)
+  async internalQuery(query: SqlQuery) {
+    await this.client.connect()
+    try {
+      return await this.client.execute(query.sql)
+    } catch (err: any) {
+      throw err?.message.split(":")[1] || err?.message
     }
+  }
 
-    async read(query: SqlQuery) {
-      return this.internalQuery(query)
-    }
+  async create(query: SqlQuery) {
+    return this.internalQuery(query)
+  }
 
-    async update(query: SqlQuery) {
-      return this.internalQuery(query)
-    }
+  async read(query: SqlQuery) {
+    return this.internalQuery(query)
+  }
 
-    async delete(query: SqlQuery) {
-      return this.internalQuery(query)
-    }
+  async update(query: SqlQuery) {
+    return this.internalQuery(query)
   }
 
-  module.exports = {
-    schema: SCHEMA,
-    integration: SnowflakeIntegration,
+  async delete(query: SqlQuery) {
+    return this.internalQuery(query)
   }
 }
+
+export default {
+  schema: SCHEMA,
+  integration: SnowflakeIntegration,
+}

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

@@ -1,10 +1,12 @@
-const Airtable = require("airtable")
-const AirtableIntegration = require("../airtable")
+import { default as AirtableIntegration } from "../airtable"
 jest.mock("airtable")
 
 class TestConfiguration {
-  constructor(config = {}) {
-    this.integration = new AirtableIntegration.integration(config) 
+  integration: any
+  client: any
+
+  constructor(config: any = {}) {
+    this.integration = new AirtableIntegration.integration(config)
     this.client = {
       create: jest.fn(),
       select: jest.fn(() => ({
@@ -13,12 +15,12 @@ class TestConfiguration {
       update: jest.fn(),
       destroy: jest.fn(),
     }
-    this.integration.client = () => this.client 
+    this.integration.client = () => this.client
   }
 }
 
 describe("Airtable Integration", () => {
-  let config 
+  let config: any
 
   beforeEach(() => {
     config = new TestConfiguration()
@@ -27,22 +29,23 @@ describe("Airtable Integration", () => {
   it("calls the create method with the correct params", async () => {
     const response = await config.integration.create({
       table: "test",
-      json: {}
+      json: {},
     })
     expect(config.client.create).toHaveBeenCalledWith([
       {
-        fields: {}
-      }
+        fields: {},
+      },
     ])
   })
 
   it("calls the read method with the correct params", async () => {
     const response = await config.integration.read({
       table: "test",
-      view: "Grid view"
+      view: "Grid view",
     })
     expect(config.client.select).toHaveBeenCalledWith({
-      maxRecords: 10, view: "Grid view"
+      maxRecords: 10,
+      view: "Grid view",
     })
   })
 
@@ -51,22 +54,22 @@ describe("Airtable Integration", () => {
       table: "table",
       id: "123",
       json: {
-        name: "test"
-      }
+        name: "test",
+      },
     })
     expect(config.client.update).toHaveBeenCalledWith([
       {
         id: "123",
-        fields: { name: "test" }
-      }
+        fields: { name: "test" },
+      },
     ])
   })
 
   it("calls the delete method with the correct params", async () => {
-    const ids = [1,2,3,4]
+    const ids = [1, 2, 3, 4]
     const response = await config.integration.delete({
-      ids
+      ids,
     })
     expect(config.client.destroy).toHaveBeenCalledWith(ids)
   })
-})
+})

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

@@ -1,15 +1,16 @@
-const arangodb = require("arangojs")
-const ArangoDBIntegration = require("../arangodb")
+import { default as ArangoDBIntegration } from "../arangodb"
 jest.mock("arangojs")
 
 class TestConfiguration {
-  constructor(config = {}) {
-    this.integration = new ArangoDBIntegration.integration(config) 
+  integration: any
+
+  constructor(config: any = {}) {
+    this.integration = new ArangoDBIntegration.integration(config)
   }
 }
 
 describe("ArangoDB Integration", () => {
-  let config 
+  let config: any
   let indexName = "Users"
 
   beforeEach(() => {
@@ -18,18 +19,20 @@ describe("ArangoDB Integration", () => {
 
   it("calls the create method with the correct params", async () => {
     const body = {
-      json: "Hello"
+      json: "Hello",
     }
 
     const response = await config.integration.create(body)
-    expect(config.integration.client.query).toHaveBeenCalledWith(`INSERT Hello INTO collection RETURN NEW`)
+    expect(config.integration.client.query).toHaveBeenCalledWith(
+      `INSERT Hello INTO collection RETURN NEW`
+    )
   })
 
   it("calls the read method with the correct params", async () => {
     const query = {
-      json: `test`, 
+      sql: `test`,
     }
     const response = await config.integration.read(query)
     expect(config.integration.client.query).toHaveBeenCalledWith(query.sql)
   })
-})
+})

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

@@ -1,23 +1,29 @@
-jest.mock("pouchdb", () => function CouchDBMock() {
-  this.post = jest.fn()
-  this.allDocs = jest.fn(() => ({ rows: [] }))
-  this.put = jest.fn()
-  this.get = jest.fn()
-  this.remove = jest.fn()
-  this.plugin = jest.fn()
-  this.close = jest.fn()
-})
+jest.mock(
+  "pouchdb",
+  () =>
+    function CouchDBMock(this: any) {
+      this.post = jest.fn()
+      this.allDocs = jest.fn(() => ({ rows: [] }))
+      this.put = jest.fn()
+      this.get = jest.fn()
+      this.remove = jest.fn()
+      this.plugin = jest.fn()
+      this.close = jest.fn()
+    }
+)
 
-const CouchDBIntegration = require("../couchdb")
+import { default as CouchDBIntegration } from "../couchdb"
 
 class TestConfiguration {
-  constructor(config = {}) {
-    this.integration = new CouchDBIntegration.integration(config) 
+  integration: any
+
+  constructor(config: any = {}) {
+    this.integration = new CouchDBIntegration.integration(config)
   }
 }
 
 describe("CouchDB Integration", () => {
-  let config 
+  let config: any
 
   beforeEach(() => {
     config = new TestConfiguration()
@@ -25,37 +31,37 @@ describe("CouchDB Integration", () => {
 
   it("calls the create method with the correct params", async () => {
     const doc = {
-      test: 1
-    } 
-    const response = await config.integration.create({ 
-      json: doc
+      test: 1,
+    }
+    const response = await config.integration.create({
+      json: doc,
     })
     expect(config.integration.client.post).toHaveBeenCalledWith(doc)
   })
 
   it("calls the read method with the correct params", async () => {
     const doc = {
-      name: "search" 
-    } 
+      name: "search",
+    }
 
-    const response = await config.integration.read({ 
-      json: doc
+    const response = await config.integration.read({
+      json: doc,
     })
 
     expect(config.integration.client.allDocs).toHaveBeenCalledWith({
       include_docs: true,
-      name: "search"
+      name: "search",
     })
   })
 
   it("calls the update method with the correct params", async () => {
     const doc = {
       _id: "1234",
-      name: "search" 
-    } 
+      name: "search",
+    }
 
-    const response = await config.integration.update({ 
-      json: doc
+    const response = await config.integration.update({
+      json: doc,
     })
 
     expect(config.integration.client.put).toHaveBeenCalledWith(doc)
@@ -67,4 +73,4 @@ describe("CouchDB Integration", () => {
     expect(config.integration.client.get).toHaveBeenCalledWith(id)
     expect(config.integration.client.remove).toHaveBeenCalled()
   })
-})
+})