hedera-web-mindshore/src/js/db/connection.js

import { JsonConnection } from '../vn/json-connection'
import { ResultSet } from './result-set'

/**
 * Simulates a connection to a database by making asynchronous requests to a
 * remote REST service that returns the results in JSON format.
 * Using this class can perform any operation that can be done with a database,
 * like open/close a connection or selecion/updating queries.
 *
 * Warning! You should set a well defined dababase level privileges to use this
 * class or you could have a serious security hole in you application becasuse
 * the user can send any statement to the server. For example: DROP DATABASE
 */
const Flag = {
  NOT_NULL: 1,
  PRI_KEY: 2,
  AI: 512 | 2 | 1
}

const Type = {
  BOOLEAN: 1,
  INTEGER: 3,
  DOUBLE: 4,
  STRING: 5,
  DATE: 8,
  DATE_TIME: 9
}

export class Connection extends JsonConnection {
  static Flag = Flag
  static Type = Type

  /**
   * Runs a SQL query on the database.
   *
   * @param {String} sql The SQL statement
   * @return {ResultSet} The result
   */
  async execSql (sql) {
    const json = await this.send('core/query', { sql })
    const results = []
    let err

    if (json) {
      try {
        if (json && json instanceof Array) {
          for (let i = 0; i < json.length; i++) {
            if (json[i] !== true) {
              const rows = json[i].data
              const columns = json[i].columns

              const data = new Array(rows.length)
              results.push({
                data,
                columns,
                tables: json[i].tables
              })

              for (let j = 0; j < rows.length; j++) {
                const row = data[j] = {}
                for (let k = 0; k < columns.length; k++) { row[columns[k].name] = rows[j][k] }
              }

              for (let j = 0; j < columns.length; j++) {
                let castFunc = null
                const col = columns[j]

                switch (col.type) {
                  case Type.DATE:
                  case Type.DATE_TIME:
                  case Type.TIMESTAMP:
                    castFunc = this.valueToDate
                    break
                }

                if (castFunc !== null) {
                  if (col.def != null) { col.def = castFunc(col.def) }

                  for (let k = 0; k < data.length; k++) {
                    if (data[k][col.name] != null) { data[k][col.name] = castFunc(data[k][col.name]) }
                  }
                }
              }
            } else { results.push(json[i]) }
          }
        }
      } catch (e) {
        err = e
      }
    }

    return new ResultSet(results, err)
  }

  /**
   * Runs a query on the database.
   *
   * @param {String} query The SQL statement
   * @param {Object} params The query params
   * @return {ResultSet} The result
   */
  async execQuery (query, params) {
    const sql = query.replace(/#\w+/g, key => {
      const value = params[key.substring(1)]
      return value ? this.renderValue(value) : key
    })

    return await this.execSql(sql)
  }

  async query (query, params) {
    const res = await this.execQuery(query, params)
    return res.fetchData()
  }

  async getObject (query, params) {
    const res = await this.execQuery(query, params)
    return res.fetchObject()
  }

  async getValue (query, params) {
    const res = await this.execQuery(query, params)
    return res.fetchValue()
  }

  renderValue (v) {
    switch (typeof v) {
      case 'number':
        return v
      case 'boolean':
        return (v) ? 'TRUE' : 'FALSE'
      case 'string':
        return "'" + v.replace(this.regexp, this.replaceFunc) + "'"
      default:
        if (v instanceof Date) {
          if (!isNaN(v.getTime())) {
            const unixTime = parseInt(fixTz(v).getTime() / 1000)
            return 'DATE(FROM_UNIXTIME(' + unixTime + '))'
          } else { return '0000-00-00' }
        } else { return 'NULL' }
    }
  }

  /*
   * Parses a value to date.
   */
  valueToDate (value) {
    return fixTz(new Date(value))
  }
}

// TODO: Read time zone from db configuration
const tz = { timeZone: 'Europe/Madrid' }
const isLocal = Intl
  .DateTimeFormat()
  .resolvedOptions()
  .timeZone === tz.timeZone

function fixTz (date) {
  if (isLocal) return date

  const localDate = new Date(date.toLocaleString('en-US', tz))
  const hasTime = localDate.getHours() ||
    localDate.getMinutes() ||
    localDate.getSeconds() ||
    localDate.getMilliseconds()

  if (!hasTime) {
    date.setHours(date.getHours() + 12)
    date.setHours(0, 0, 0, 0)
  }

  return date
}