@budibase/server 1.3.21-alpha.1 → 1.3.21

package/src/integrations/dynamodb.ts

@@ -5,216 +5,218 @@ import {
   IntegrationBase,
 } from "@budibase/types"
 
-const AWS = require("aws-sdk")
-const { AWS_REGION } = require("../db/dynamoClient")
+module DynamoModule {
+  const AWS = require("aws-sdk")
+  const { AWS_REGION } = require("../db/dynamoClient")
 
-interface DynamoDBConfig {
-  region: string
-  accessKeyId: string
-  secretAccessKey: string
-  endpoint?: string
-  currentClockSkew?: boolean
-}
+  interface DynamoDBConfig {
+    region: string
+    accessKeyId: string
+    secretAccessKey: string
+    endpoint?: string
+    currentClockSkew?: boolean
+  }
 
-const SCHEMA: Integration = {
-  docs: "https://github.com/dabit3/dynamodb-documentclient-cheat-sheet",
-  description:
-    "Amazon DynamoDB is a key-value and document database that delivers single-digit millisecond performance at any scale.",
-  friendlyName: "DynamoDB",
-  type: "Non-relational",
-  datasource: {
-    region: {
-      type: DatasourceFieldType.STRING,
-      required: true,
-      default: "us-east-1",
-    },
-    accessKeyId: {
-      type: DatasourceFieldType.PASSWORD,
-      required: true,
-    },
-    secretAccessKey: {
-      type: DatasourceFieldType.PASSWORD,
-      required: true,
-    },
-    endpoint: {
-      type: DatasourceFieldType.STRING,
-      required: false,
-      default: "https://dynamodb.us-east-1.amazonaws.com",
-    },
-  },
-  query: {
-    create: {
-      type: QueryType.FIELDS,
-      customisable: true,
-      fields: {
-        table: {
-          type: DatasourceFieldType.STRING,
-          required: true,
-        },
+  const SCHEMA: Integration = {
+    docs: "https://github.com/dabit3/dynamodb-documentclient-cheat-sheet",
+    description:
+      "Amazon DynamoDB is a key-value and document database that delivers single-digit millisecond performance at any scale.",
+    friendlyName: "DynamoDB",
+    type: "Non-relational",
+    datasource: {
+      region: {
+        type: DatasourceFieldType.STRING,
+        required: true,
+        default: "us-east-1",
+      },
+      accessKeyId: {
+        type: DatasourceFieldType.PASSWORD,
+        required: true,
+      },
+      secretAccessKey: {
+        type: DatasourceFieldType.PASSWORD,
+        required: true,
+      },
+      endpoint: {
+        type: DatasourceFieldType.STRING,
+        required: false,
+        default: "https://dynamodb.us-east-1.amazonaws.com",
       },
     },
-    read: {
-      type: QueryType.FIELDS,
-      customisable: true,
-      readable: true,
-      fields: {
-        table: {
-          type: DatasourceFieldType.STRING,
-          required: true,
-        },
-        index: {
-          type: DatasourceFieldType.STRING,
+    query: {
+      create: {
+        type: QueryType.FIELDS,
+        customisable: true,
+        fields: {
+          table: {
+            type: DatasourceFieldType.STRING,
+            required: true,
+          },
         },
       },
-    },
-    scan: {
-      type: QueryType.FIELDS,
-      customisable: true,
-      readable: true,
-      fields: {
-        table: {
-          type: DatasourceFieldType.STRING,
-          required: true,
+      read: {
+        type: QueryType.FIELDS,
+        customisable: true,
+        readable: true,
+        fields: {
+          table: {
+            type: DatasourceFieldType.STRING,
+            required: true,
+          },
+          index: {
+            type: DatasourceFieldType.STRING,
+          },
         },
-        index: {
-          type: DatasourceFieldType.STRING,
+      },
+      scan: {
+        type: QueryType.FIELDS,
+        customisable: true,
+        readable: true,
+        fields: {
+          table: {
+            type: DatasourceFieldType.STRING,
+            required: true,
+          },
+          index: {
+            type: DatasourceFieldType.STRING,
+          },
         },
       },
-    },
-    describe: {
-      type: QueryType.FIELDS,
-      customisable: true,
-      readable: true,
-      fields: {
-        table: {
-          type: DatasourceFieldType.STRING,
-          required: true,
+      describe: {
+        type: QueryType.FIELDS,
+        customisable: true,
+        readable: true,
+        fields: {
+          table: {
+            type: DatasourceFieldType.STRING,
+            required: true,
+          },
         },
       },
-    },
-    get: {
-      type: QueryType.FIELDS,
-      customisable: true,
-      readable: true,
-      fields: {
-        table: {
-          type: DatasourceFieldType.STRING,
-          required: true,
+      get: {
+        type: QueryType.FIELDS,
+        customisable: true,
+        readable: true,
+        fields: {
+          table: {
+            type: DatasourceFieldType.STRING,
+            required: true,
+          },
         },
       },
-    },
-    update: {
-      type: QueryType.FIELDS,
-      customisable: true,
-      fields: {
-        table: {
-          type: DatasourceFieldType.STRING,
-          required: true,
+      update: {
+        type: QueryType.FIELDS,
+        customisable: true,
+        fields: {
+          table: {
+            type: DatasourceFieldType.STRING,
+            required: true,
+          },
         },
       },
-    },
-    delete: {
-      type: QueryType.FIELDS,
-      customisable: true,
-      fields: {
-        table: {
-          type: DatasourceFieldType.STRING,
-          required: true,
+      delete: {
+        type: QueryType.FIELDS,
+        customisable: true,
+        fields: {
+          table: {
+            type: DatasourceFieldType.STRING,
+            required: true,
+          },
         },
       },
     },
-  },
-}
+  }
 
-class DynamoDBIntegration implements IntegrationBase {
-  private config: DynamoDBConfig
-  private client: any
+  class DynamoDBIntegration implements IntegrationBase {
+    private config: DynamoDBConfig
+    private client: any
 
-  constructor(config: DynamoDBConfig) {
-    this.config = config
+    constructor(config: DynamoDBConfig) {
+      this.config = config
 
-    // User is using a local dynamoDB endpoint, don't auth with remote
-    if (this.config?.endpoint?.includes("localhost")) {
-      // @ts-ignore
-      this.config = {}
-    }
+      // User is using a local dynamoDB endpoint, don't auth with remote
+      if (this.config?.endpoint?.includes("localhost")) {
+        // @ts-ignore
+        this.config = {}
+      }
 
-    this.config = {
-      ...this.config,
-      currentClockSkew: true,
-      region: config.region || AWS_REGION,
-      endpoint: config.endpoint || undefined,
+      this.config = {
+        ...this.config,
+        currentClockSkew: true,
+        region: config.region || AWS_REGION,
+        endpoint: config.endpoint || undefined,
+      }
+      this.client = new AWS.DynamoDB.DocumentClient(this.config)
     }
-    this.client = new AWS.DynamoDB.DocumentClient(this.config)
-  }
 
-  async create(query: { table: string; json: object }) {
-    const params = {
-      TableName: query.table,
-      ...query.json,
+    async create(query: { table: string; json: object }) {
+      const params = {
+        TableName: query.table,
+        ...query.json,
+      }
+      return this.client.put(params).promise()
     }
-    return this.client.put(params).promise()
-  }
 
-  async read(query: { table: string; json: object; index: null | string }) {
-    const params = {
-      TableName: query.table,
-      IndexName: query.index ? query.index : undefined,
-      ...query.json,
+    async read(query: { table: string; json: object; index: null | string }) {
+      const params = {
+        TableName: query.table,
+        IndexName: query.index ? query.index : undefined,
+        ...query.json,
+      }
+      const response = await this.client.query(params).promise()
+      if (response.Items) {
+        return response.Items
+      }
+      return response
     }
-    const response = await this.client.query(params).promise()
-    if (response.Items) {
-      return response.Items
-    }
-    return response
-  }
 
-  async scan(query: { table: string; json: object; index: null | string }) {
-    const params = {
-      TableName: query.table,
-      IndexName: query.index ? query.index : undefined,
-      ...query.json,
+    async scan(query: { table: string; json: object; index: null | string }) {
+      const params = {
+        TableName: query.table,
+        IndexName: query.index ? query.index : undefined,
+        ...query.json,
+      }
+      const response = await this.client.scan(params).promise()
+      if (response.Items) {
+        return response.Items
+      }
+      return response
     }
-    const response = await this.client.scan(params).promise()
-    if (response.Items) {
-      return response.Items
-    }
-    return response
-  }
 
-  async describe(query: { table: string }) {
-    const params = {
-      TableName: query.table,
+    async describe(query: { table: string }) {
+      const params = {
+        TableName: query.table,
+      }
+      return new AWS.DynamoDB(this.config).describeTable(params).promise()
     }
-    return new AWS.DynamoDB(this.config).describeTable(params).promise()
-  }
 
-  async get(query: { table: string; json: object }) {
-    const params = {
-      TableName: query.table,
-      ...query.json,
+    async get(query: { table: string; json: object }) {
+      const params = {
+        TableName: query.table,
+        ...query.json,
+      }
+      return this.client.get(params).promise()
     }
-    return this.client.get(params).promise()
-  }
 
-  async update(query: { table: string; json: object }) {
-    const params = {
-      TableName: query.table,
-      ...query.json,
+    async update(query: { table: string; json: object }) {
+      const params = {
+        TableName: query.table,
+        ...query.json,
+      }
+      return this.client.update(params).promise()
     }
-    return this.client.update(params).promise()
-  }
 
-  async delete(query: { table: string; json: object }) {
-    const params = {
-      TableName: query.table,
-      ...query.json,
+    async delete(query: { table: string; json: object }) {
+      const params = {
+        TableName: query.table,
+        ...query.json,
+      }
+      return this.client.delete(params).promise()
     }
-    return this.client.delete(params).promise()
   }
-}
 
-export default {
-  schema: SCHEMA,
-  integration: DynamoDBIntegration,
+  module.exports = {
+    schema: SCHEMA,
+    integration: DynamoDBIntegration,
+  }
 }

package/src/integrations/elasticsearch.ts

@@ -5,149 +5,151 @@ import {
   IntegrationBase,
 } from "@budibase/types"
 
-const { Client } = require("@elastic/elasticsearch")
+module ElasticsearchModule {
+  const { Client } = require("@elastic/elasticsearch")
 
-interface ElasticsearchConfig {
-  url: string
-}
+  interface ElasticsearchConfig {
+    url: string
+  }
 
-const SCHEMA: Integration = {
-  docs: "https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/index.html",
-  description:
-    "Elasticsearch is a search engine based on the Lucene library. It provides a distributed, multitenant-capable full-text search engine with an HTTP web interface and schema-free JSON documents.",
-  friendlyName: "ElasticSearch",
-  type: "Non-relational",
-  datasource: {
-    url: {
-      type: DatasourceFieldType.STRING,
-      required: true,
-      default: "http://localhost:9200",
-    },
-  },
-  query: {
-    create: {
-      type: QueryType.FIELDS,
-      customisable: true,
-      fields: {
-        index: {
-          type: DatasourceFieldType.STRING,
-          required: true,
-        },
+  const SCHEMA: Integration = {
+    docs: "https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/index.html",
+    description:
+      "Elasticsearch is a search engine based on the Lucene library. It provides a distributed, multitenant-capable full-text search engine with an HTTP web interface and schema-free JSON documents.",
+    friendlyName: "ElasticSearch",
+    type: "Non-relational",
+    datasource: {
+      url: {
+        type: DatasourceFieldType.STRING,
+        required: true,
+        default: "http://localhost:9200",
       },
     },
-    read: {
-      type: QueryType.FIELDS,
-      customisable: true,
-      fields: {
-        index: {
-          type: DatasourceFieldType.STRING,
-          required: true,
+    query: {
+      create: {
+        type: QueryType.FIELDS,
+        customisable: true,
+        fields: {
+          index: {
+            type: DatasourceFieldType.STRING,
+            required: true,
+          },
         },
       },
-    },
-    update: {
-      type: QueryType.FIELDS,
-      customisable: true,
-      fields: {
-        id: {
-          type: DatasourceFieldType.STRING,
-          required: true,
-        },
-        index: {
-          type: DatasourceFieldType.STRING,
-          required: true,
+      read: {
+        type: QueryType.FIELDS,
+        customisable: true,
+        fields: {
+          index: {
+            type: DatasourceFieldType.STRING,
+            required: true,
+          },
         },
       },
-    },
-    delete: {
-      type: QueryType.FIELDS,
-      fields: {
-        index: {
-          type: DatasourceFieldType.STRING,
-          required: true,
+      update: {
+        type: QueryType.FIELDS,
+        customisable: true,
+        fields: {
+          id: {
+            type: DatasourceFieldType.STRING,
+            required: true,
+          },
+          index: {
+            type: DatasourceFieldType.STRING,
+            required: true,
+          },
         },
-        id: {
-          type: DatasourceFieldType.STRING,
-          required: true,
+      },
+      delete: {
+        type: QueryType.FIELDS,
+        fields: {
+          index: {
+            type: DatasourceFieldType.STRING,
+            required: true,
+          },
+          id: {
+            type: DatasourceFieldType.STRING,
+            required: true,
+          },
         },
       },
     },
-  },
-}
+  }
 
-class ElasticSearchIntegration implements IntegrationBase {
-  private config: ElasticsearchConfig
-  private client: any
+  class ElasticSearchIntegration implements IntegrationBase {
+    private config: ElasticsearchConfig
+    private client: any
 
-  constructor(config: ElasticsearchConfig) {
-    this.config = config
-    this.client = new Client({ node: config.url })
-  }
+    constructor(config: ElasticsearchConfig) {
+      this.config = config
+      this.client = new Client({ node: config.url })
+    }
 
-  async create(query: { index: string; json: object }) {
-    const { index, json } = query
+    async create(query: { index: string; json: object }) {
+      const { index, json } = query
 
-    try {
-      const result = await this.client.index({
-        index,
-        body: json,
-      })
-      return result.body
-    } catch (err) {
-      console.error("Error writing to elasticsearch", err)
-      throw err
-    } finally {
-      await this.client.close()
+      try {
+        const result = await this.client.index({
+          index,
+          body: json,
+        })
+        return result.body
+      } catch (err) {
+        console.error("Error writing to elasticsearch", err)
+        throw err
+      } finally {
+        await this.client.close()
+      }
     }
-  }
 
-  async read(query: { index: string; json: object }) {
-    const { index, json } = query
-    try {
-      const result = await this.client.search({
-        index: index,
-        body: json,
-      })
-      return result.body.hits.hits.map(({ _source }: any) => _source)
-    } catch (err) {
-      console.error("Error querying elasticsearch", err)
-      throw err
-    } finally {
-      await this.client.close()
+    async read(query: { index: string; json: object }) {
+      const { index, json } = query
+      try {
+        const result = await this.client.search({
+          index: index,
+          body: json,
+        })
+        return result.body.hits.hits.map(({ _source }: any) => _source)
+      } catch (err) {
+        console.error("Error querying elasticsearch", err)
+        throw err
+      } finally {
+        await this.client.close()
+      }
     }
-  }
 
-  async update(query: { id: string; index: string; json: object }) {
-    const { id, index, json } = query
-    try {
-      const result = await this.client.update({
-        id,
-        index,
-        body: json,
-      })
-      return result.body
-    } catch (err) {
-      console.error("Error querying elasticsearch", err)
-      throw err
-    } finally {
-      await this.client.close()
+    async update(query: { id: string; index: string; json: object }) {
+      const { id, index, json } = query
+      try {
+        const result = await this.client.update({
+          id,
+          index,
+          body: json,
+        })
+        return result.body
+      } catch (err) {
+        console.error("Error querying elasticsearch", err)
+        throw err
+      } finally {
+        await this.client.close()
+      }
     }
-  }
 
-  async delete(query: object) {
-    try {
-      const result = await this.client.delete(query)
-      return result.body
-    } catch (err) {
-      console.error("Error deleting from elasticsearch", err)
-      throw err
-    } finally {
-      await this.client.close()
+    async delete(query: object) {
+      try {
+        const result = await this.client.delete(query)
+        return result.body
+      } catch (err) {
+        console.error("Error deleting from elasticsearch", err)
+        throw err
+      } finally {
+        await this.client.close()
+      }
     }
   }
-}
 
-export default {
-  schema: SCHEMA,
-  integration: ElasticSearchIntegration,
+  module.exports = {
+    schema: SCHEMA,
+    integration: ElasticSearchIntegration,
+  }
 }