@budibase/server 1.3.21-alpha.1 → 1.3.21

package/src/integrations/airtable.ts

@@ -5,144 +5,146 @@ import {
   IntegrationBase,
 } from "@budibase/types"
 
-const Airtable = require("airtable")
+module AirtableModule {
+  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,
-    },
-  },
-  query: {
-    create: {
-      type: QueryType.FIELDS,
-      customisable: true,
-      fields: {
-        table: {
-          type: DatasourceFieldType.STRING,
-          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,
       },
     },
-    read: {
-      type: QueryType.FIELDS,
-      fields: {
-        table: {
-          type: DatasourceFieldType.STRING,
-          required: true,
-        },
-        view: {
-          type: DatasourceFieldType.STRING,
-          required: true,
-        },
-        numRecords: {
-          type: DatasourceFieldType.NUMBER,
-          default: 10,
+    query: {
+      create: {
+        type: QueryType.FIELDS,
+        customisable: true,
+        fields: {
+          table: {
+            type: DatasourceFieldType.STRING,
+            required: true,
+          },
         },
       },
-    },
-    update: {
-      type: QueryType.FIELDS,
-      customisable: true,
-      fields: {
-        id: {
-          display: "Record ID",
-          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,
+          },
         },
-        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,
+          },
         },
       },
+      delete: {
+        type: QueryType.JSON,
+      },
     },
-    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
+      }
     }
   }
-}
 
-export default {
-  schema: SCHEMA,
-  integration: AirtableIntegration,
+  module.exports = {
+    schema: SCHEMA,
+    integration: AirtableIntegration,
+  }
 }

package/src/integrations/arangodb.ts

@@ -5,104 +5,106 @@ import {
   IntegrationBase,
 } from "@budibase/types"
 
-const { Database, aql } = require("arangojs")
+module ArangoModule {
+  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,
-    },
-  },
-  query: {
-    read: {
-      type: QueryType.SQL,
+  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,
+      },
     },
-    create: {
-      type: QueryType.JSON,
+    query: {
+      read: {
+        type: QueryType.SQL,
+      },
+      create: {
+        type: QueryType.JSON,
+      },
     },
-  },
-}
+  }
 
-class ArangoDBIntegration implements IntegrationBase {
-  private config: ArangodbConfig
-  private client: any
+  class ArangoDBIntegration implements IntegrationBase {
+    private config: ArangodbConfig
+    private client: any
 
-  constructor(config: ArangodbConfig) {
-    const newConfig = {
-      auth: {
-        username: config.username,
-        password: config.password,
-      },
-    }
+    constructor(config: ArangodbConfig) {
+      const newConfig = {
+        auth: {
+          username: config.username,
+          password: config.password,
+        },
+      }
 
-    this.config = config
-    this.client = new Database(newConfig)
-  }
+      this.config = config
+      this.client = new Database(newConfig)
+    }
 
-  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()
+    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()
+      }
     }
-  }
 
-  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 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,
+  module.exports = {
+    schema: SCHEMA,
+    integration: ArangoDBIntegration,
+  }
 }

package/src/integrations/base/query.ts

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

package/src/integrations/base/sqlTable.ts

@@ -96,9 +96,7 @@ function generateSchema(
     const deletedColumns = Object.entries(oldTable.schema)
       .filter(
         ([key, schema]) =>
-          schema.type !== FieldTypes.LINK &&
-          schema.type !== FieldTypes.FORMULA &&
-          table.schema[key] == null
+          schema.type !== FieldTypes.LINK && table.schema[key] == null
       )
       .map(([key]) => key)
     deletedColumns.forEach(key => {

package/src/integrations/couchdb.ts

@@ -5,103 +5,109 @@ import {
   IntegrationBase,
 } from "@budibase/types"
 
-const PouchDB = require("pouchdb")
+module CouchDBModule {
+  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,
-    },
-  },
-  query: {
-    create: {
-      type: QueryType.JSON,
-    },
-    read: {
-      type: QueryType.JSON,
-    },
-    update: {
-      type: QueryType.JSON,
+  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,
+      },
     },
-    delete: {
-      type: QueryType.FIELDS,
-      fields: {
-        id: {
-          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}`)
-  }
+    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
+    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 create(query: { json: object }) {
-    return this.query("post", "Error writing to couchDB", query)
-  }
+    async create(query: { json: object }) {
+      return this.query("post", "Error writing to couchDB", 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 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 update(query: { json: object }) {
-    return this.query("put", "Error updating couchDB document", query)
-  }
+    async update(query: { json: object }) {
+      return this.query("put", "Error updating couchDB document", query)
+    }
 
-  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 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,
+  module.exports = {
+    schema: SCHEMA,
+    integration: CouchDBIntegration,
+  }
 }