@budibase/server 1.3.12-alpha.1 → 1.3.12-alpha.2

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,
 }

package/src/integrations/firebase.ts

@@ -6,184 +6,182 @@ import {
 } from "@budibase/types"
 import { Firestore, WhereFilterOp } from "@google-cloud/firestore"
 
-module Firebase {
-  interface FirebaseConfig {
-    email: string
-    privateKey: string
-    projectId: string
-  }
+interface FirebaseConfig {
+  email: string
+  privateKey: string
+  projectId: string
+}
 
-  const SCHEMA: Integration = {
-    docs: "https://firebase.google.com/docs/firestore/quickstart",
-    friendlyName: "Firestore",
-    type: "Non-relational",
-    description:
-      "Cloud Firestore is a flexible, scalable database for mobile, web, and server development from Firebase and Google Cloud.",
-    datasource: {
-      email: {
-        type: DatasourceFieldType.STRING,
-        required: true,
-      },
-      privateKey: {
-        type: DatasourceFieldType.STRING,
-        required: true,
-      },
-      projectId: {
-        type: DatasourceFieldType.STRING,
-        required: true,
-      },
+const SCHEMA: Integration = {
+  docs: "https://firebase.google.com/docs/firestore/quickstart",
+  friendlyName: "Firestore",
+  type: "Non-relational",
+  description:
+    "Cloud Firestore is a flexible, scalable database for mobile, web, and server development from Firebase and Google Cloud.",
+  datasource: {
+    email: {
+      type: DatasourceFieldType.STRING,
+      required: true,
     },
-    query: {
-      create: {
-        type: QueryType.JSON,
-      },
-      read: {
-        type: QueryType.JSON,
-      },
-      update: {
-        type: QueryType.JSON,
-      },
-      delete: {
-        type: QueryType.JSON,
-      },
+    privateKey: {
+      type: DatasourceFieldType.STRING,
+      required: true,
     },
-    extra: {
-      collection: {
-        displayName: "Collection",
-        type: DatasourceFieldType.STRING,
-        required: true,
-      },
-      filterField: {
-        displayName: "Filter field",
-        type: DatasourceFieldType.STRING,
-        required: false,
-      },
-      filter: {
-        displayName: "Filter comparison",
-        type: DatasourceFieldType.LIST,
-        required: false,
-        data: {
-          read: [
-            "==",
-            "<",
-            "<=",
-            "!=",
-            ">=",
-            ">",
-            "array-contains",
-            "in",
-            "not-in",
-            "array-contains-any",
-          ],
-        },
-      },
-      filterValue: {
-        displayName: "Filter value",
-        type: DatasourceFieldType.STRING,
-        required: false,
+    projectId: {
+      type: DatasourceFieldType.STRING,
+      required: true,
+    },
+  },
+  query: {
+    create: {
+      type: QueryType.JSON,
+    },
+    read: {
+      type: QueryType.JSON,
+    },
+    update: {
+      type: QueryType.JSON,
+    },
+    delete: {
+      type: QueryType.JSON,
+    },
+  },
+  extra: {
+    collection: {
+      displayName: "Collection",
+      type: DatasourceFieldType.STRING,
+      required: true,
+    },
+    filterField: {
+      displayName: "Filter field",
+      type: DatasourceFieldType.STRING,
+      required: false,
+    },
+    filter: {
+      displayName: "Filter comparison",
+      type: DatasourceFieldType.LIST,
+      required: false,
+      data: {
+        read: [
+          "==",
+          "<",
+          "<=",
+          "!=",
+          ">=",
+          ">",
+          "array-contains",
+          "in",
+          "not-in",
+          "array-contains-any",
+        ],
       },
     },
-  }
+    filterValue: {
+      displayName: "Filter value",
+      type: DatasourceFieldType.STRING,
+      required: false,
+    },
+  },
+}
 
-  class FirebaseIntegration implements IntegrationBase {
-    private config: FirebaseConfig
-    private client: Firestore
+class FirebaseIntegration implements IntegrationBase {
+  private config: FirebaseConfig
+  private client: Firestore
 
-    constructor(config: FirebaseConfig) {
-      this.config = config
-      this.client = new Firestore({
-        projectId: config.projectId,
-        credentials: {
-          client_email: config.email,
-          private_key: config.privateKey?.replace(/\\n/g, "\n"),
-        },
-      })
-    }
+  constructor(config: FirebaseConfig) {
+    this.config = config
+    this.client = new Firestore({
+      projectId: config.projectId,
+      credentials: {
+        client_email: config.email,
+        private_key: config.privateKey?.replace(/\\n/g, "\n"),
+      },
+    })
+  }
 
-    async create(query: { json: object; extra: { [key: string]: string } }) {
-      try {
-        const documentReference = this.client
-          .collection(query.extra.collection)
-          .doc()
-        await documentReference.set({ ...query.json, id: documentReference.id })
-        const snapshot = await documentReference.get()
-        return snapshot.data()
-      } catch (err) {
-        console.error("Error writing to Firestore", err)
-        throw err
-      }
+  async create(query: { json: object; extra: { [key: string]: string } }) {
+    try {
+      const documentReference = this.client
+        .collection(query.extra.collection)
+        .doc()
+      await documentReference.set({ ...query.json, id: documentReference.id })
+      const snapshot = await documentReference.get()
+      return snapshot.data()
+    } catch (err) {
+      console.error("Error writing to Firestore", err)
+      throw err
     }
+  }
 
-    async read(query: { json: object; extra: { [key: string]: string } }) {
-      try {
-        let snapshot
-        const collectionRef = this.client.collection(query.extra.collection)
-        if (
-          query.extra.filterField &&
-          query.extra.filter &&
-          query.extra.filterValue
-        ) {
-          snapshot = await collectionRef
-            .where(
-              query.extra.filterField,
-              query.extra.filter as WhereFilterOp,
-              query.extra.filterValue
-            )
-            .get()
-        } else {
-          snapshot = await collectionRef.get()
-        }
-        const result: any[] = []
-        snapshot.forEach(doc => result.push(doc.data()))
-
-        return result
-      } catch (err) {
-        console.error("Error querying Firestore", err)
-        throw err
+  async read(query: { json: object; extra: { [key: string]: string } }) {
+    try {
+      let snapshot
+      const collectionRef = this.client.collection(query.extra.collection)
+      if (
+        query.extra.filterField &&
+        query.extra.filter &&
+        query.extra.filterValue
+      ) {
+        snapshot = await collectionRef
+          .where(
+            query.extra.filterField,
+            query.extra.filter as WhereFilterOp,
+            query.extra.filterValue
+          )
+          .get()
+      } else {
+        snapshot = await collectionRef.get()
       }
-    }
-
-    async update(query: {
-      json: Record<string, any>
-      extra: { [key: string]: string }
-    }) {
-      try {
-        await this.client
-          .collection(query.extra.collection)
-          .doc(query.json.id)
-          .update(query.json)
+      const result: any[] = []
+      snapshot.forEach(doc => result.push(doc.data()))
 
-        return (
-          await this.client
-            .collection(query.extra.collection)
-            .doc(query.json.id)
-            .get()
-        ).data()
-      } catch (err) {
-        console.error("Error writing to Firestore", err)
-        throw err
-      }
+      return result
+    } catch (err) {
+      console.error("Error querying Firestore", err)
+      throw err
     }
+  }
 
-    async delete(query: {
-      json: { id: string }
-      extra: { [key: string]: string }
-    }) {
-      try {
+  async update(query: {
+    json: Record<string, any>
+    extra: { [key: string]: string }
+  }) {
+    try {
+      await this.client
+        .collection(query.extra.collection)
+        .doc(query.json.id)
+        .update(query.json)
+
+      return (
         await this.client
           .collection(query.extra.collection)
           .doc(query.json.id)
-          .delete()
-        return true
-      } catch (err) {
-        console.error("Error deleting from Firestore", err)
-        throw err
-      }
+          .get()
+      ).data()
+    } catch (err) {
+      console.error("Error writing to Firestore", err)
+      throw err
     }
   }
 
-  module.exports = {
-    schema: SCHEMA,
-    integration: FirebaseIntegration,
+  async delete(query: {
+    json: { id: string }
+    extra: { [key: string]: string }
+  }) {
+    try {
+      await this.client
+        .collection(query.extra.collection)
+        .doc(query.json.id)
+        .delete()
+      return true
+    } catch (err) {
+      console.error("Error deleting from Firestore", err)
+      throw err
+    }
   }
 }
+
+export default {
+  schema: SCHEMA,
+  integration: FirebaseIntegration,
+}