@budibase/server 1.3.20 → 1.3.21-alpha.1

package/src/integrations/mysql.ts

@@ -19,274 +19,269 @@ import dayjs from "dayjs"
 const { NUMBER_REGEX } = require("../utilities")
 import Sql from "./base/sql"
 
-module MySQLModule {
-  const mysql = require("mysql2/promise")
+const mysql = require("mysql2/promise")
 
-  interface MySQLConfig {
-    host: string
-    port: number
-    user: string
-    password: string
-    database: string
-    ssl?: { [key: string]: any }
-    rejectUnauthorized: boolean
-    typeCast: Function
-  }
+interface MySQLConfig {
+  host: string
+  port: number
+  user: string
+  password: string
+  database: string
+  ssl?: { [key: string]: any }
+  rejectUnauthorized: boolean
+  typeCast: Function
+}
 
-  const SCHEMA: Integration = {
-    docs: "https://github.com/sidorares/node-mysql2",
-    plus: true,
-    friendlyName: "MySQL",
-    type: "Relational",
-    description:
-      "MySQL Database Service is a fully managed database service to deploy cloud-native applications. ",
-    datasource: {
-      host: {
-        type: DatasourceFieldType.STRING,
-        default: "localhost",
-        required: true,
-      },
-      port: {
-        type: DatasourceFieldType.NUMBER,
-        default: 3306,
-        required: false,
-      },
-      user: {
-        type: DatasourceFieldType.STRING,
-        default: "root",
-        required: true,
-      },
-      password: {
-        type: DatasourceFieldType.PASSWORD,
-        default: "root",
-        required: true,
-      },
-      database: {
-        type: DatasourceFieldType.STRING,
-        required: true,
-      },
-      ssl: {
-        type: DatasourceFieldType.OBJECT,
-        required: false,
-      },
-      rejectUnauthorized: {
-        type: DatasourceFieldType.BOOLEAN,
-        default: true,
-        required: false,
-      },
+const SCHEMA: Integration = {
+  docs: "https://github.com/sidorares/node-mysql2",
+  plus: true,
+  friendlyName: "MySQL",
+  type: "Relational",
+  description:
+    "MySQL Database Service is a fully managed database service to deploy cloud-native applications. ",
+  datasource: {
+    host: {
+      type: DatasourceFieldType.STRING,
+      default: "localhost",
+      required: true,
     },
-    query: {
-      create: {
-        type: QueryType.SQL,
-      },
-      read: {
-        type: QueryType.SQL,
-      },
-      update: {
-        type: QueryType.SQL,
-      },
-      delete: {
-        type: QueryType.SQL,
-      },
+    port: {
+      type: DatasourceFieldType.NUMBER,
+      default: 3306,
+      required: false,
     },
-  }
+    user: {
+      type: DatasourceFieldType.STRING,
+      default: "root",
+      required: true,
+    },
+    password: {
+      type: DatasourceFieldType.PASSWORD,
+      default: "root",
+      required: true,
+    },
+    database: {
+      type: DatasourceFieldType.STRING,
+      required: true,
+    },
+    ssl: {
+      type: DatasourceFieldType.OBJECT,
+      required: false,
+    },
+    rejectUnauthorized: {
+      type: DatasourceFieldType.BOOLEAN,
+      default: true,
+      required: false,
+    },
+  },
+  query: {
+    create: {
+      type: QueryType.SQL,
+    },
+    read: {
+      type: QueryType.SQL,
+    },
+    update: {
+      type: QueryType.SQL,
+    },
+    delete: {
+      type: QueryType.SQL,
+    },
+  },
+}
 
-  const TimezoneAwareDateTypes = ["timestamp"]
+const TimezoneAwareDateTypes = ["timestamp"]
 
-  function bindingTypeCoerce(bindings: any[]) {
-    for (let i = 0; i < bindings.length; i++) {
-      const binding = bindings[i]
-      if (typeof binding !== "string") {
-        continue
-      }
-      const matches = binding.match(NUMBER_REGEX)
-      // check if number first
-      if (matches && matches[0] !== "" && !isNaN(Number(matches[0]))) {
-        bindings[i] = parseFloat(binding)
-      }
-      // if not a number, see if it is a date - important to do in this order as any
-      // integer will be considered a valid date
-      else if (/^\d/.test(binding) && dayjs(binding).isValid()) {
-        bindings[i] = dayjs(binding).toDate()
-      }
+function bindingTypeCoerce(bindings: any[]) {
+  for (let i = 0; i < bindings.length; i++) {
+    const binding = bindings[i]
+    if (typeof binding !== "string") {
+      continue
+    }
+    const matches = binding.match(NUMBER_REGEX)
+    // check if number first
+    if (matches && matches[0] !== "" && !isNaN(Number(matches[0]))) {
+      bindings[i] = parseFloat(binding)
+    }
+    // if not a number, see if it is a date - important to do in this order as any
+    // integer will be considered a valid date
+    else if (/^\d/.test(binding) && dayjs(binding).isValid()) {
+      bindings[i] = dayjs(binding).toDate()
     }
-    return bindings
   }
+  return bindings
+}
 
-  class MySQLIntegration extends Sql implements DatasourcePlus {
-    private config: MySQLConfig
-    private client: any
-    public tables: Record<string, Table> = {}
-    public schemaErrors: Record<string, string> = {}
+class MySQLIntegration extends Sql implements DatasourcePlus {
+  private config: MySQLConfig
+  private client: any
+  public tables: Record<string, Table> = {}
+  public schemaErrors: Record<string, string> = {}
 
-    constructor(config: MySQLConfig) {
-      super(SqlClient.MY_SQL)
-      this.config = config
-      if (config.ssl && Object.keys(config.ssl).length === 0) {
-        delete config.ssl
-      }
-      // make sure this defaults to true
-      if (
-        config.rejectUnauthorized != null &&
-        !config.rejectUnauthorized &&
-        config.ssl
-      ) {
-        config.ssl.rejectUnauthorized = config.rejectUnauthorized
-      }
-      // @ts-ignore
-      delete config.rejectUnauthorized
-      this.config = {
-        ...config,
-        typeCast: function (field: any, next: any) {
-          if (
-            field.type == "DATETIME" ||
-            field.type === "DATE" ||
-            field.type === "TIMESTAMP"
-          ) {
-            return field.string()
-          }
-          return next()
-        },
-      }
+  constructor(config: MySQLConfig) {
+    super(SqlClient.MY_SQL)
+    this.config = config
+    if (config.ssl && Object.keys(config.ssl).length === 0) {
+      delete config.ssl
     }
-
-    getBindingIdentifier(): string {
-      return "?"
+    // make sure this defaults to true
+    if (
+      config.rejectUnauthorized != null &&
+      !config.rejectUnauthorized &&
+      config.ssl
+    ) {
+      config.ssl.rejectUnauthorized = config.rejectUnauthorized
     }
-
-    getStringConcat(parts: string[]): string {
-      return `concat(${parts.join(", ")})`
+    // @ts-ignore
+    delete config.rejectUnauthorized
+    this.config = {
+      ...config,
+      typeCast: function (field: any, next: any) {
+        if (
+          field.type == "DATETIME" ||
+          field.type === "DATE" ||
+          field.type === "TIMESTAMP"
+        ) {
+          return field.string()
+        }
+        return next()
+      },
     }
+  }
 
-    async connect() {
-      this.client = await mysql.createConnection(this.config)
-    }
+  getBindingIdentifier(): string {
+    return "?"
+  }
 
-    async disconnect() {
-      await this.client.end()
-    }
+  getStringConcat(parts: string[]): string {
+    return `concat(${parts.join(", ")})`
+  }
+
+  async connect() {
+    this.client = await mysql.createConnection(this.config)
+  }
+
+  async disconnect() {
+    await this.client.end()
+  }
 
-    async internalQuery(
-      query: SqlQuery,
-      opts: { connect?: boolean; disableCoercion?: boolean } = {
-        connect: true,
-        disableCoercion: false,
+  async internalQuery(
+    query: SqlQuery,
+    opts: { connect?: boolean; disableCoercion?: boolean } = {
+      connect: true,
+      disableCoercion: false,
+    }
+  ): Promise<any[] | any> {
+    try {
+      if (opts?.connect) {
+        await this.connect()
       }
-    ): Promise<any[] | any> {
-      try {
-        if (opts?.connect) {
-          await this.connect()
-        }
-        const baseBindings = query.bindings || []
-        const bindings = opts?.disableCoercion
-          ? baseBindings
-          : bindingTypeCoerce(baseBindings)
-        // Node MySQL is callback based, so we must wrap our call in a promise
-        const response = await this.client.query(query.sql, bindings)
-        return response[0]
-      } finally {
-        if (opts?.connect) {
-          await this.disconnect()
-        }
+      const baseBindings = query.bindings || []
+      const bindings = opts?.disableCoercion
+        ? baseBindings
+        : bindingTypeCoerce(baseBindings)
+      // Node MySQL is callback based, so we must wrap our call in a promise
+      const response = await this.client.query(query.sql, bindings)
+      return response[0]
+    } finally {
+      if (opts?.connect) {
+        await this.disconnect()
       }
     }
+  }
 
-    async buildSchema(datasourceId: string, entities: Record<string, Table>) {
-      const tables: { [key: string]: Table } = {}
-      const database = this.config.database
-      await this.connect()
+  async buildSchema(datasourceId: string, entities: Record<string, Table>) {
+    const tables: { [key: string]: Table } = {}
+    const database = this.config.database
+    await this.connect()
 
-      try {
-        // get the tables first
-        const tablesResp = await this.internalQuery(
-          { sql: "SHOW TABLES;" },
+    try {
+      // get the tables first
+      const tablesResp = await this.internalQuery(
+        { sql: "SHOW TABLES;" },
+        { connect: false }
+      )
+      const tableNames = tablesResp.map(
+        (obj: any) =>
+          obj[`Tables_in_${database}`] ||
+          obj[`Tables_in_${database.toLowerCase()}`]
+      )
+      for (let tableName of tableNames) {
+        const primaryKeys = []
+        const schema: TableSchema = {}
+        const descResp = await this.internalQuery(
+          { sql: `DESCRIBE \`${tableName}\`;` },
           { connect: false }
         )
-        const tableNames = tablesResp.map(
-          (obj: any) =>
-            obj[`Tables_in_${database}`] ||
-            obj[`Tables_in_${database.toLowerCase()}`]
-        )
-        for (let tableName of tableNames) {
-          const primaryKeys = []
-          const schema: TableSchema = {}
-          const descResp = await this.internalQuery(
-            { sql: `DESCRIBE \`${tableName}\`;` },
-            { connect: false }
-          )
-          for (let column of descResp) {
-            const columnName = column.Field
-            if (
-              column.Key === "PRI" &&
-              primaryKeys.indexOf(column.Key) === -1
-            ) {
-              primaryKeys.push(columnName)
-            }
-            const constraints = {
-              presence: column.Null !== "YES",
-            }
-            const isAuto: boolean =
-              typeof column.Extra === "string" &&
-              (column.Extra === "auto_increment" ||
-                column.Extra.toLowerCase().includes("generated"))
-            schema[columnName] = {
-              name: columnName,
-              autocolumn: isAuto,
-              constraints,
-              ...convertSqlType(column.Type),
-              externalType: column.Type,
-            }
+        for (let column of descResp) {
+          const columnName = column.Field
+          if (column.Key === "PRI" && primaryKeys.indexOf(column.Key) === -1) {
+            primaryKeys.push(columnName)
           }
-          if (!tables[tableName]) {
-            tables[tableName] = {
-              _id: buildExternalTableId(datasourceId, tableName),
-              primary: primaryKeys,
-              name: tableName,
-              schema,
-            }
+          const constraints = {
+            presence: column.Null !== "YES",
+          }
+          const isAuto: boolean =
+            typeof column.Extra === "string" &&
+            (column.Extra === "auto_increment" ||
+              column.Extra.toLowerCase().includes("generated"))
+          schema[columnName] = {
+            name: columnName,
+            autocolumn: isAuto,
+            constraints,
+            ...convertSqlType(column.Type),
+            externalType: column.Type,
+          }
+        }
+        if (!tables[tableName]) {
+          tables[tableName] = {
+            _id: buildExternalTableId(datasourceId, tableName),
+            primary: primaryKeys,
+            name: tableName,
+            schema,
           }
         }
-      } finally {
-        await this.disconnect()
       }
-      const final = finaliseExternalTables(tables, entities)
-      this.tables = final.tables
-      this.schemaErrors = final.errors
+    } finally {
+      await this.disconnect()
     }
+    const final = finaliseExternalTables(tables, entities)
+    this.tables = final.tables
+    this.schemaErrors = final.errors
+  }
 
-    async create(query: SqlQuery | string) {
-      const results = await this.internalQuery(getSqlQuery(query))
-      return results.length ? results : [{ created: true }]
-    }
+  async create(query: SqlQuery | string) {
+    const results = await this.internalQuery(getSqlQuery(query))
+    return results.length ? results : [{ created: true }]
+  }
 
-    async read(query: SqlQuery | string) {
-      return this.internalQuery(getSqlQuery(query))
-    }
+  async read(query: SqlQuery | string) {
+    return this.internalQuery(getSqlQuery(query))
+  }
 
-    async update(query: SqlQuery | string) {
-      const results = await this.internalQuery(getSqlQuery(query))
-      return results.length ? results : [{ updated: true }]
-    }
+  async update(query: SqlQuery | string) {
+    const results = await this.internalQuery(getSqlQuery(query))
+    return results.length ? results : [{ updated: true }]
+  }
 
-    async delete(query: SqlQuery | string) {
-      const results = await this.internalQuery(getSqlQuery(query))
-      return results.length ? results : [{ deleted: true }]
-    }
+  async delete(query: SqlQuery | string) {
+    const results = await this.internalQuery(getSqlQuery(query))
+    return results.length ? results : [{ deleted: true }]
+  }
 
-    async query(json: QueryJson) {
-      await this.connect()
-      try {
-        const queryFn = (query: any) =>
-          this.internalQuery(query, { connect: false, disableCoercion: true })
-        return await this.queryWithReturning(json, queryFn)
-      } finally {
-        await this.disconnect()
-      }
+  async query(json: QueryJson) {
+    await this.connect()
+    try {
+      const queryFn = (query: any) =>
+        this.internalQuery(query, { connect: false, disableCoercion: true })
+      return await this.queryWithReturning(json, queryFn)
+    } finally {
+      await this.disconnect()
     }
   }
+}
 
-  module.exports = {
-    schema: SCHEMA,
-    integration: MySQLIntegration,
-  }
+export default {
+  schema: SCHEMA,
+  integration: MySQLIntegration,
 }