@budibase/server 1.3.19-alpha.2 → 1.3.19

package/src/integrations/s3.ts

@@ -1,83 +1,86 @@
 import { Integration, QueryType, IntegrationBase } from "@budibase/types"
-const AWS = require("aws-sdk")
 
-interface S3Config {
-  region: string
-  accessKeyId: string
-  secretAccessKey: string
-  s3ForcePathStyle: boolean
-  endpoint?: string
-}
+module S3Module {
+  const AWS = require("aws-sdk")
 
-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",
+  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",
+      },
     },
-  },
-  query: {
-    read: {
-      type: QueryType.FIELDS,
-      fields: {
-        bucket: {
-          type: "string",
-          required: true,
+    query: {
+      read: {
+        type: QueryType.FIELDS,
+        fields: {
+          bucket: {
+            type: "string",
+            required: true,
+          },
         },
       },
     },
-  },
-}
+  }
 
-class S3Integration implements IntegrationBase {
-  private readonly config: S3Config
-  private client: any
+  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
+    constructor(config: S3Config) {
+      this.config = config
+      if (this.config.endpoint) {
+        this.config.s3ForcePathStyle = true
+      } else {
+        delete this.config.endpoint
+      }
+
+      this.client = new AWS.S3(this.config)
     }
 
-    this.client = new AWS.S3(this.config)
+    async read(query: { bucket: string }) {
+      const response = await this.client
+        .listObjects({
+          Bucket: query.bucket,
+        })
+        .promise()
+      return response.Contents
+    }
   }
 
-  async read(query: { bucket: string }) {
-    const response = await this.client
-      .listObjects({
-        Bucket: query.bucket,
-      })
-      .promise()
-    return response.Contents
+  module.exports = {
+    schema: SCHEMA,
+    integration: S3Integration,
   }
 }
-
-export default {
-  schema: SCHEMA,
-  integration: S3Integration,
-}

package/src/integrations/snowflake.ts

@@ -1,97 +1,99 @@
 import { Integration, QueryType, SqlQuery } from "@budibase/types"
 import { Snowflake } from "snowflake-promise"
 
-interface SnowflakeConfig {
-  account: string
-  username: string
-  password: string
-  warehouse: string
-  database: string
-  schema: string
-}
+module SnowflakeModule {
+  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,
+  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,
+      },
     },
-    schema: {
-      type: "string",
-      required: true,
+    query: {
+      create: {
+        type: QueryType.SQL,
+      },
+      read: {
+        type: QueryType.SQL,
+      },
+      update: {
+        type: QueryType.SQL,
+      },
+      delete: {
+        type: QueryType.SQL,
+      },
     },
-  },
-  query: {
-    create: {
-      type: QueryType.SQL,
-    },
-    read: {
-      type: QueryType.SQL,
-    },
-    update: {
-      type: QueryType.SQL,
-    },
-    delete: {
-      type: QueryType.SQL,
-    },
-  },
-}
+  }
 
-class SnowflakeIntegration {
-  private client: Snowflake
+  class SnowflakeIntegration {
+    private client: Snowflake
 
-  constructor(config: SnowflakeConfig) {
-    this.client = new Snowflake(config)
-  }
+    constructor(config: SnowflakeConfig) {
+      this.client = new Snowflake(config)
+    }
 
-  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 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 create(query: SqlQuery) {
-    return this.internalQuery(query)
-  }
+    async create(query: SqlQuery) {
+      return this.internalQuery(query)
+    }
 
-  async read(query: SqlQuery) {
-    return this.internalQuery(query)
-  }
+    async read(query: SqlQuery) {
+      return this.internalQuery(query)
+    }
 
-  async update(query: SqlQuery) {
-    return this.internalQuery(query)
-  }
+    async update(query: SqlQuery) {
+      return this.internalQuery(query)
+    }
 
-  async delete(query: SqlQuery) {
-    return this.internalQuery(query)
+    async delete(query: SqlQuery) {
+      return this.internalQuery(query)
+    }
   }
-}
 
-export default {
-  schema: SCHEMA,
-  integration: SnowflakeIntegration,
+  module.exports = {
+    schema: SCHEMA,
+    integration: SnowflakeIntegration,
+  }
 }

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

@@ -1,12 +1,10 @@
-import { default as AirtableIntegration } from "../airtable"
+const Airtable = require("airtable")
+const AirtableIntegration = require("../airtable")
 jest.mock("airtable")
 
 class TestConfiguration {
-  integration: any
-  client: any
-
-  constructor(config: any = {}) {
-    this.integration = new AirtableIntegration.integration(config)
+  constructor(config = {}) {
+    this.integration = new AirtableIntegration.integration(config) 
     this.client = {
       create: jest.fn(),
       select: jest.fn(() => ({
@@ -15,12 +13,12 @@ class TestConfiguration {
       update: jest.fn(),
       destroy: jest.fn(),
     }
-    this.integration.client = () => this.client
+    this.integration.client = () => this.client 
   }
 }
 
 describe("Airtable Integration", () => {
-  let config: any
+  let config 
 
   beforeEach(() => {
     config = new TestConfiguration()
@@ -29,23 +27,22 @@ 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"
     })
   })
 
@@ -54,22 +51,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.ts → arangodb.spec.js}

@@ -1,16 +1,15 @@
-import { default as ArangoDBIntegration } from "../arangodb"
+const arangodb = require("arangojs")
+const ArangoDBIntegration = require("../arangodb")
 jest.mock("arangojs")
 
 class TestConfiguration {
-  integration: any
-
-  constructor(config: any = {}) {
-    this.integration = new ArangoDBIntegration.integration(config)
+  constructor(config = {}) {
+    this.integration = new ArangoDBIntegration.integration(config) 
   }
 }
 
 describe("ArangoDB Integration", () => {
-  let config: any
+  let config 
   let indexName = "Users"
 
   beforeEach(() => {
@@ -19,20 +18,18 @@ 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 = {
-      sql: `test`,
+      json: `test`, 
     }
     const response = await config.integration.read(query)
     expect(config.integration.client.query).toHaveBeenCalledWith(query.sql)
   })
-})
+})

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

@@ -1,29 +1,23 @@
-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()
-    }
-)
+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()
+})
 
-import { default as CouchDBIntegration } from "../couchdb"
+const CouchDBIntegration = require("../couchdb")
 
 class TestConfiguration {
-  integration: any
-
-  constructor(config: any = {}) {
-    this.integration = new CouchDBIntegration.integration(config)
+  constructor(config = {}) {
+    this.integration = new CouchDBIntegration.integration(config) 
   }
 }
 
 describe("CouchDB Integration", () => {
-  let config: any
+  let config 
 
   beforeEach(() => {
     config = new TestConfiguration()
@@ -31,37 +25,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)
@@ -73,4 +67,4 @@ describe("CouchDB Integration", () => {
     expect(config.integration.client.get).toHaveBeenCalledWith(id)
     expect(config.integration.client.remove).toHaveBeenCalled()
   })
-})
+})