@budibase/server 1.3.14 → 1.3.15-alpha.2

package/src/integrations/airtable.ts

@@ -5,146 +5,144 @@ import {
   IntegrationBase,
 } from "@budibase/types"
 
-module AirtableModule {
-  const Airtable = require("airtable")
+const Airtable = require("airtable")
 
-  interface AirtableConfig {
-    apiKey: string
-    base: string
-  }
+interface AirtableConfig {
+  apiKey: string
+  base: string
+}
 
-  const SCHEMA: Integration = {
-    docs: "https://airtable.com/api",
-    description:
-      "Airtable is a spreadsheet-database hybrid, with the features of a database but applied to a spreadsheet.",
-    friendlyName: "Airtable",
-    type: "Spreadsheet",
-    datasource: {
-      apiKey: {
-        type: DatasourceFieldType.PASSWORD,
-        default: "enter api key",
-        required: true,
-      },
-      base: {
-        type: DatasourceFieldType.STRING,
-        default: "mybase",
-        required: true,
-      },
+const SCHEMA: Integration = {
+  docs: "https://airtable.com/api",
+  description:
+    "Airtable is a spreadsheet-database hybrid, with the features of a database but applied to a spreadsheet.",
+  friendlyName: "Airtable",
+  type: "Spreadsheet",
+  datasource: {
+    apiKey: {
+      type: DatasourceFieldType.PASSWORD,
+      default: "enter api key",
+      required: true,
+    },
+    base: {
+      type: DatasourceFieldType.STRING,
+      default: "mybase",
+      required: true,
     },
-    query: {
-      create: {
-        type: QueryType.FIELDS,
-        customisable: true,
-        fields: {
-          table: {
-            type: DatasourceFieldType.STRING,
-            required: true,
-          },
+  },
+  query: {
+    create: {
+      type: QueryType.FIELDS,
+      customisable: true,
+      fields: {
+        table: {
+          type: DatasourceFieldType.STRING,
+          required: true,
         },
       },
-      read: {
-        type: QueryType.FIELDS,
-        fields: {
-          table: {
-            type: DatasourceFieldType.STRING,
-            required: true,
-          },
-          view: {
-            type: DatasourceFieldType.STRING,
-            required: true,
-          },
-          numRecords: {
-            type: DatasourceFieldType.NUMBER,
-            default: 10,
-          },
+    },
+    read: {
+      type: QueryType.FIELDS,
+      fields: {
+        table: {
+          type: DatasourceFieldType.STRING,
+          required: true,
         },
-      },
-      update: {
-        type: QueryType.FIELDS,
-        customisable: true,
-        fields: {
-          id: {
-            display: "Record ID",
-            type: DatasourceFieldType.STRING,
-            required: true,
-          },
-          table: {
-            type: DatasourceFieldType.STRING,
-            required: true,
-          },
+        view: {
+          type: DatasourceFieldType.STRING,
+          required: true,
+        },
+        numRecords: {
+          type: DatasourceFieldType.NUMBER,
+          default: 10,
         },
       },
-      delete: {
-        type: QueryType.JSON,
+    },
+    update: {
+      type: QueryType.FIELDS,
+      customisable: true,
+      fields: {
+        id: {
+          display: "Record ID",
+          type: DatasourceFieldType.STRING,
+          required: true,
+        },
+        table: {
+          type: DatasourceFieldType.STRING,
+          required: true,
+        },
       },
     },
-  }
+    delete: {
+      type: QueryType.JSON,
+    },
+  },
+}
 
-  class AirtableIntegration implements IntegrationBase {
-    private config: AirtableConfig
-    private client: any
+class AirtableIntegration implements IntegrationBase {
+  private config: AirtableConfig
+  private client: any
 
-    constructor(config: AirtableConfig) {
-      this.config = config
-      this.client = new Airtable(config).base(config.base)
-    }
+  constructor(config: AirtableConfig) {
+    this.config = config
+    this.client = new Airtable(config).base(config.base)
+  }
 
-    async create(query: { table: any; json: any }) {
-      const { table, json } = query
+  async create(query: { table: any; json: any }) {
+    const { table, json } = query
 
-      try {
-        return await this.client(table).create([
-          {
-            fields: json,
-          },
-        ])
-      } catch (err) {
-        console.error("Error writing to airtable", err)
-        throw err
-      }
+    try {
+      return await this.client(table).create([
+        {
+          fields: json,
+        },
+      ])
+    } catch (err) {
+      console.error("Error writing to airtable", err)
+      throw err
     }
+  }
 
-    async read(query: { table: any; numRecords: any; view: any }) {
-      try {
-        const records = await this.client(query.table)
-          .select({ maxRecords: query.numRecords || 10, view: query.view })
-          .firstPage()
-        // @ts-ignore
-        return records.map(({ fields }) => fields)
-      } catch (err) {
-        console.error("Error writing to airtable", err)
-        return []
-      }
+  async read(query: { table: any; numRecords: any; view: any }) {
+    try {
+      const records = await this.client(query.table)
+        .select({ maxRecords: query.numRecords || 10, view: query.view })
+        .firstPage()
+      // @ts-ignore
+      return records.map(({ fields }) => fields)
+    } catch (err) {
+      console.error("Error writing to airtable", err)
+      return []
     }
+  }
 
-    async update(query: { table: any; id: any; json: any }) {
-      const { table, id, json } = query
+  async update(query: { table: any; id: any; json: any }) {
+    const { table, id, json } = query
 
-      try {
-        return await this.client(table).update([
-          {
-            id,
-            fields: json,
-          },
-        ])
-      } catch (err) {
-        console.error("Error writing to airtable", err)
-        throw err
-      }
+    try {
+      return await this.client(table).update([
+        {
+          id,
+          fields: json,
+        },
+      ])
+    } catch (err) {
+      console.error("Error writing to airtable", err)
+      throw err
     }
+  }
 
-    async delete(query: { table: any; ids: any }) {
-      try {
-        return await this.client(query.table).destroy(query.ids)
-      } catch (err) {
-        console.error("Error writing to airtable", err)
-        throw err
-      }
+  async delete(query: { table: any; ids: any }) {
+    try {
+      return await this.client(query.table).destroy(query.ids)
+    } catch (err) {
+      console.error("Error writing to airtable", err)
+      throw err
     }
   }
+}
 
-  module.exports = {
-    schema: SCHEMA,
-    integration: AirtableIntegration,
-  }
+export default {
+  schema: SCHEMA,
+  integration: AirtableIntegration,
 }

package/src/integrations/arangodb.ts

@@ -5,106 +5,104 @@ import {
   IntegrationBase,
 } from "@budibase/types"
 
-module ArangoModule {
-  const { Database, aql } = require("arangojs")
+const { Database, aql } = require("arangojs")
 
-  interface ArangodbConfig {
-    url: string
-    username: string
-    password: string
-    databaseName: string
-    collection: string
-  }
+interface ArangodbConfig {
+  url: string
+  username: string
+  password: string
+  databaseName: string
+  collection: string
+}
 
-  const SCHEMA: Integration = {
-    docs: "https://github.com/arangodb/arangojs",
-    friendlyName: "ArangoDB",
-    type: "Non-relational",
-    description:
-      "ArangoDB is a scalable open-source multi-model database natively supporting graph, document and search. All supported data models & access patterns can be combined in queries allowing for maximal flexibility. ",
-    datasource: {
-      url: {
-        type: DatasourceFieldType.STRING,
-        default: "http://localhost:8529",
-        required: true,
-      },
-      username: {
-        type: DatasourceFieldType.STRING,
-        default: "root",
-        required: true,
-      },
-      password: {
-        type: DatasourceFieldType.PASSWORD,
-        required: true,
-      },
-      databaseName: {
-        type: DatasourceFieldType.STRING,
-        default: "_system",
-        required: true,
-      },
-      collection: {
-        type: DatasourceFieldType.STRING,
-        required: true,
-      },
+const SCHEMA: Integration = {
+  docs: "https://github.com/arangodb/arangojs",
+  friendlyName: "ArangoDB",
+  type: "Non-relational",
+  description:
+    "ArangoDB is a scalable open-source multi-model database natively supporting graph, document and search. All supported data models & access patterns can be combined in queries allowing for maximal flexibility. ",
+  datasource: {
+    url: {
+      type: DatasourceFieldType.STRING,
+      default: "http://localhost:8529",
+      required: true,
     },
-    query: {
-      read: {
-        type: QueryType.SQL,
-      },
-      create: {
-        type: QueryType.JSON,
-      },
+    username: {
+      type: DatasourceFieldType.STRING,
+      default: "root",
+      required: true,
     },
-  }
-
-  class ArangoDBIntegration implements IntegrationBase {
-    private config: ArangodbConfig
-    private client: any
+    password: {
+      type: DatasourceFieldType.PASSWORD,
+      required: true,
+    },
+    databaseName: {
+      type: DatasourceFieldType.STRING,
+      default: "_system",
+      required: true,
+    },
+    collection: {
+      type: DatasourceFieldType.STRING,
+      required: true,
+    },
+  },
+  query: {
+    read: {
+      type: QueryType.SQL,
+    },
+    create: {
+      type: QueryType.JSON,
+    },
+  },
+}
 
-    constructor(config: ArangodbConfig) {
-      const newConfig = {
-        auth: {
-          username: config.username,
-          password: config.password,
-        },
-      }
+class ArangoDBIntegration implements IntegrationBase {
+  private config: ArangodbConfig
+  private client: any
 
-      this.config = config
-      this.client = new Database(newConfig)
+  constructor(config: ArangodbConfig) {
+    const newConfig = {
+      auth: {
+        username: config.username,
+        password: config.password,
+      },
     }
 
-    async read(query: { sql: any }) {
-      try {
-        const result = await this.client.query(query.sql)
-        return result.all()
-      } catch (err) {
-        // @ts-ignore
-        console.error("Error querying arangodb", err.message)
-        throw err
-      } finally {
-        this.client.close()
-      }
-    }
+    this.config = config
+    this.client = new Database(newConfig)
+  }
 
-    async create(query: { json: any }) {
-      const clc = this.client.collection(this.config.collection)
-      try {
-        const result = await this.client.query(
-          aql`INSERT ${query.json} INTO ${clc} RETURN NEW`
-        )
-        return result.all()
-      } catch (err) {
-        // @ts-ignore
-        console.error("Error querying arangodb", err.message)
-        throw err
-      } finally {
-        this.client.close()
-      }
+  async read(query: { sql: any }) {
+    try {
+      const result = await this.client.query(query.sql)
+      return result.all()
+    } catch (err) {
+      // @ts-ignore
+      console.error("Error querying arangodb", err.message)
+      throw err
+    } finally {
+      this.client.close()
     }
   }
 
-  module.exports = {
-    schema: SCHEMA,
-    integration: ArangoDBIntegration,
+  async create(query: { json: any }) {
+    const clc = this.client.collection(this.config.collection)
+    try {
+      const result = await this.client.query(
+        aql`INSERT ${query.json} INTO ${clc} RETURN NEW`
+      )
+      return result.all()
+    } catch (err) {
+      // @ts-ignore
+      console.error("Error querying arangodb", err.message)
+      throw err
+    } finally {
+      this.client.close()
+    }
   }
 }
+
+export default {
+  schema: SCHEMA,
+  integration: ArangoDBIntegration,
+}

package/src/integrations/base/query.ts

@@ -1,11 +1,11 @@
 import { QueryJson, Datasource } from "@budibase/types"
-const { integrations } = require("../index")
+const { getIntegration } = require("../index")
 
 export async function makeExternalQuery(
   datasource: Datasource,
   json: QueryJson
 ) {
-  const Integration = integrations[datasource.source]
+  const Integration = await getIntegration(datasource.source)
   // query is the opinionated function
   if (Integration.prototype.query) {
     const integration = new Integration(datasource.config)

package/src/integrations/couchdb.ts

@@ -5,109 +5,103 @@ import {
   IntegrationBase,
 } from "@budibase/types"
 
-module CouchDBModule {
-  const PouchDB = require("pouchdb")
+const PouchDB = require("pouchdb")
 
-  interface CouchDBConfig {
-    url: string
-    database: string
-  }
+interface CouchDBConfig {
+  url: string
+  database: string
+}
 
-  const SCHEMA: Integration = {
-    docs: "https://docs.couchdb.org/en/stable/",
-    friendlyName: "CouchDB",
-    type: "Non-relational",
-    description:
-      "Apache CouchDB is an open-source document-oriented NoSQL database, implemented in Erlang.",
-    datasource: {
-      url: {
-        type: DatasourceFieldType.STRING,
-        required: true,
-        default: "http://localhost:5984",
-      },
-      database: {
-        type: DatasourceFieldType.STRING,
-        required: true,
-      },
+const SCHEMA: Integration = {
+  docs: "https://docs.couchdb.org/en/stable/",
+  friendlyName: "CouchDB",
+  type: "Non-relational",
+  description:
+    "Apache CouchDB is an open-source document-oriented NoSQL database, implemented in Erlang.",
+  datasource: {
+    url: {
+      type: DatasourceFieldType.STRING,
+      required: true,
+      default: "http://localhost:5984",
     },
-    query: {
-      create: {
-        type: QueryType.JSON,
-      },
-      read: {
-        type: QueryType.JSON,
-      },
-      update: {
-        type: QueryType.JSON,
-      },
-      delete: {
-        type: QueryType.FIELDS,
-        fields: {
-          id: {
-            type: DatasourceFieldType.STRING,
-            required: true,
-          },
+    database: {
+      type: DatasourceFieldType.STRING,
+      required: true,
+    },
+  },
+  query: {
+    create: {
+      type: QueryType.JSON,
+    },
+    read: {
+      type: QueryType.JSON,
+    },
+    update: {
+      type: QueryType.JSON,
+    },
+    delete: {
+      type: QueryType.FIELDS,
+      fields: {
+        id: {
+          type: DatasourceFieldType.STRING,
+          required: true,
         },
       },
     },
-  }
+  },
+}
 
-  class CouchDBIntegration implements IntegrationBase {
-    private config: CouchDBConfig
-    private readonly client: any
+class CouchDBIntegration implements IntegrationBase {
+  private config: CouchDBConfig
+  private readonly client: any
 
-    constructor(config: CouchDBConfig) {
-      this.config = config
-      this.client = new PouchDB(`${config.url}/${config.database}`)
-    }
-
-    async query(
-      command: string,
-      errorMsg: string,
-      query: { json?: object; id?: string }
-    ) {
-      try {
-        const response = await this.client[command](query.id || query.json)
-        await this.client.close()
-        return response
-      } catch (err) {
-        console.error(errorMsg, err)
-        throw err
-      }
-    }
+  constructor(config: CouchDBConfig) {
+    this.config = config
+    this.client = new PouchDB(`${config.url}/${config.database}`)
+  }
 
-    async create(query: { json: object }) {
-      return this.query("post", "Error writing to couchDB", query)
+  async query(
+    command: string,
+    errorMsg: string,
+    query: { json?: object; id?: string }
+  ) {
+    try {
+      const response = await this.client[command](query.id || query.json)
+      await this.client.close()
+      return response
+    } catch (err) {
+      console.error(errorMsg, err)
+      throw err
     }
+  }
 
-    async read(query: { json: object }) {
-      const result = await this.query("allDocs", "Error querying couchDB", {
-        json: {
-          include_docs: true,
-          ...query.json,
-        },
-      })
-      return result.rows.map((row: { doc: object }) => row.doc)
-    }
+  async create(query: { json: object }) {
+    return this.query("post", "Error writing to couchDB", query)
+  }
 
-    async update(query: { json: object }) {
-      return this.query("put", "Error updating couchDB document", query)
-    }
+  async read(query: { json: object }) {
+    const result = await this.query("allDocs", "Error querying couchDB", {
+      json: {
+        include_docs: true,
+        ...query.json,
+      },
+    })
+    return result.rows.map((row: { doc: object }) => row.doc)
+  }
 
-    async delete(query: { id: string }) {
-      const doc = await this.query(
-        "get",
-        "Cannot find doc to be deleted",
-        query
-      )
-      return this.query("remove", "Error deleting couchDB document", {
-        json: doc,
-      })
-    }
+  async update(query: { json: object }) {
+    return this.query("put", "Error updating couchDB document", query)
   }
 
-  module.exports = {
-    schema: SCHEMA,
-    integration: CouchDBIntegration,
+  async delete(query: { id: string }) {
+    const doc = await this.query("get", "Cannot find doc to be deleted", query)
+    return this.query("remove", "Error deleting couchDB document", {
+      json: doc,
+    })
   }
 }
+
+export default {
+  schema: SCHEMA,
+  integration: CouchDBIntegration,
+}