@budibase/server 1.3.20 → 1.3.21-alpha.0

package/src/integrations/dynamodb.ts

@@ -5,218 +5,216 @@ import {
   IntegrationBase,
 } from "@budibase/types"
 
-module DynamoModule {
-  const AWS = require("aws-sdk")
-  const { AWS_REGION } = require("../db/dynamoClient")
+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",
-      },
+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,
     },
-    query: {
-      create: {
-        type: QueryType.FIELDS,
-        customisable: true,
-        fields: {
-          table: {
-            type: DatasourceFieldType.STRING,
-            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,
         },
       },
-      read: {
-        type: QueryType.FIELDS,
-        customisable: true,
-        readable: true,
-        fields: {
-          table: {
-            type: DatasourceFieldType.STRING,
-            required: true,
-          },
-          index: {
-            type: DatasourceFieldType.STRING,
-          },
+    },
+    read: {
+      type: QueryType.FIELDS,
+      customisable: true,
+      readable: true,
+      fields: {
+        table: {
+          type: DatasourceFieldType.STRING,
+          required: true,
+        },
+        index: {
+          type: DatasourceFieldType.STRING,
         },
       },
-      scan: {
-        type: QueryType.FIELDS,
-        customisable: true,
-        readable: true,
-        fields: {
-          table: {
-            type: DatasourceFieldType.STRING,
-            required: true,
-          },
-          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
+  },
+}
 
-    constructor(config: DynamoDBConfig) {
-      this.config = config
+class DynamoDBIntegration implements IntegrationBase {
+  private config: DynamoDBConfig
+  private client: any
 
-      // User is using a local dynamoDB endpoint, don't auth with remote
-      if (this.config?.endpoint?.includes("localhost")) {
-        // @ts-ignore
-        this.config = {}
-      }
+  constructor(config: DynamoDBConfig) {
+    this.config = config
 
-      this.config = {
-        ...this.config,
-        currentClockSkew: true,
-        region: config.region || AWS_REGION,
-        endpoint: config.endpoint || undefined,
-      }
-      this.client = new AWS.DynamoDB.DocumentClient(this.config)
+    // User is using a local dynamoDB endpoint, don't auth with remote
+    if (this.config?.endpoint?.includes("localhost")) {
+      // @ts-ignore
+      this.config = {}
     }
 
-    async create(query: { table: string; json: object }) {
-      const params = {
-        TableName: query.table,
-        ...query.json,
-      }
-      return this.client.put(params).promise()
+    this.config = {
+      ...this.config,
+      currentClockSkew: true,
+      region: config.region || AWS_REGION,
+      endpoint: config.endpoint || undefined,
     }
+    this.client = new AWS.DynamoDB.DocumentClient(this.config)
+  }
 
-    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
+  async create(query: { table: string; json: object }) {
+    const params = {
+      TableName: query.table,
+      ...query.json,
     }
+    return this.client.put(params).promise()
+  }
 
-    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
+  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
+  }
 
-    async describe(query: { table: string }) {
-      const params = {
-        TableName: query.table,
-      }
-      return new AWS.DynamoDB(this.config).describeTable(params).promise()
+  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
+  }
 
-    async get(query: { table: string; json: object }) {
-      const params = {
-        TableName: query.table,
-        ...query.json,
-      }
-      return this.client.get(params).promise()
+  async describe(query: { table: string }) {
+    const params = {
+      TableName: query.table,
     }
+    return new AWS.DynamoDB(this.config).describeTable(params).promise()
+  }
 
-    async update(query: { table: string; json: object }) {
-      const params = {
-        TableName: query.table,
-        ...query.json,
-      }
-      return this.client.update(params).promise()
+  async get(query: { table: string; json: object }) {
+    const params = {
+      TableName: query.table,
+      ...query.json,
     }
+    return this.client.get(params).promise()
+  }
 
-    async delete(query: { table: string; json: object }) {
-      const params = {
-        TableName: query.table,
-        ...query.json,
-      }
-      return this.client.delete(params).promise()
+  async update(query: { table: string; json: object }) {
+    const params = {
+      TableName: query.table,
+      ...query.json,
     }
+    return this.client.update(params).promise()
   }
 
-  module.exports = {
-    schema: SCHEMA,
-    integration: DynamoDBIntegration,
+  async delete(query: { table: string; json: object }) {
+    const params = {
+      TableName: query.table,
+      ...query.json,
+    }
+    return this.client.delete(params).promise()
   }
 }
+
+export default {
+  schema: SCHEMA,
+  integration: DynamoDBIntegration,
+}

package/src/integrations/elasticsearch.ts

@@ -5,151 +5,149 @@ import {
   IntegrationBase,
 } from "@budibase/types"
 
-module ElasticsearchModule {
-  const { Client } = require("@elastic/elasticsearch")
+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",
-      },
+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,
-          },
+  },
+  query: {
+    create: {
+      type: QueryType.FIELDS,
+      customisable: true,
+      fields: {
+        index: {
+          type: DatasourceFieldType.STRING,
+          required: true,
         },
       },
-      read: {
-        type: QueryType.FIELDS,
-        customisable: true,
-        fields: {
-          index: {
-            type: DatasourceFieldType.STRING,
-            required: true,
-          },
+    },
+    read: {
+      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,
-          },
+    },
+    update: {
+      type: QueryType.FIELDS,
+      customisable: true,
+      fields: {
+        id: {
+          type: DatasourceFieldType.STRING,
+          required: true,
+        },
+        index: {
+          type: DatasourceFieldType.STRING,
+          required: true,
         },
       },
-      delete: {
-        type: QueryType.FIELDS,
-        fields: {
-          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()
     }
   }
+}
 
-  module.exports = {
-    schema: SCHEMA,
-    integration: ElasticSearchIntegration,
-  }
+export default {
+  schema: SCHEMA,
+  integration: ElasticSearchIntegration,
 }