connection-parameters.js

'use strict'
/**
 * Copyright (c) 2010-2017 Brian Carlson (brian.m.carlson@gmail.com)
 * All rights reserved.
 *
 * This source code is licensed under the MIT license found in the
 * README.md file in the root directory of this source tree.
 */

var dns = require('dns')
var async = require('async')

var defaults = require('./defaults')

var parse = require('connection-string') // parses a connection string
var pgparse = require('pg-connection-string').parse // parses unix domain a connection string

var val = function (key, config, envVar) {
  if (envVar === undefined) {
    envVar = process.env['PG' + key.toUpperCase()]
  } else if (envVar === false) {
    // do nothing ... use false
  } else {
    envVar = process.env[envVar]
  }

  return config[key] ||
    envVar ||
    defaults[key]
}

var useSsl = function () {
  switch (process.env.PGSSLMODE) {
    case 'disable':
      return false
    case 'prefer':
    case 'require':
    case 'verify-ca':
    case 'verify-full':
      return true
  }
  return defaults.ssl
}

var ConnectionParameters = function (config) {
  config = config || {}

  // if a string is passed, it is a raw connection string so we define it as
  // connectionString option and convert config to object
  if (typeof config === 'string') {
    config = { connectionString: config }
  }

  // if the config has a connectionString defined, parse IT into the config we use
  // this will override other default values with what is stored in connectionString
  if (config.connectionString) {
    config = Object.assign({}, config, parse(config.connectionString))

    // mimicrate connection-string object to postgrsql compatible
    // convert path to database name
    if (Array.isArray(config.path)) {
      config.database = config.path[0]
    }

    // convert hosts list to host and port
    if (Array.isArray(config.hosts)) {
      config.host = config.hosts.map(function (host) {
        return host.name
      })
      // take first port in hosts list
      config.port = config.hosts[0].port
    }

    // convert params to separeted options
    if (config.params && typeof config.params === 'object') {
      Object.keys(config.params).forEach(function (key) {
        var val = config.params[key]

        switch (val) {
          case 'true':
            val = true
            break
          case 'false':
            val = false
            break
          default:
            var intVal = parseInt(val)
            if (!isNaN(intVal)) {
              val = intVal
            }
        }
        config[key] = val
      })
    }
  }

  this.user = val('user', config)
  this.database = val('database', config)
  this.port = parseInt(val('port', config), 10)
  this.host = Array.isArray(config.host) ? config.host : val('host', config)
  this.password = val('password', config)
  this.binary = val('binary', config)
  this.ssl = typeof config.ssl === 'undefined' ? useSsl() : config.ssl
  this.client_encoding = val('client_encoding', config)
  this.replication = val('replication', config)

  this.isDomainSocket = false
  if (config.isDomainSocket) {
    this.isDomainSocket = config.isDomainSocket
  }

  // if host is string and its start from / use it as unix socket
  if (typeof this.host === 'string' && this.host.indexOf('/') === 0) {
    this.isDomainSocket = true
  }

  this.application_name = val('application_name', config, 'PGAPPNAME')
  this.fallback_application_name = val('fallback_application_name', config, false)
  this.statement_timeout = val('statement_timeout', config, false)
  this.query_timeout = val('query_timeout', config, false)

  if (config.connectionTimeoutMillis === undefined) {
    this.connect_timeout = process.env.PGCONNECT_TIMEOUT || 0
  } else {
    this.connect_timeout = Math.floor(config.connectionTimeoutMillis / 1000)
  }

  if (config.keepAlive === false) {
    this.keepalives = 0
  } else if (config.keepAlive === true) {
    this.keepalives = 1
  }

  if (typeof config.keepAliveInitialDelayMillis === 'number') {
    this.keepalives_idle = Math.floor(config.keepAliveInitialDelayMillis / 1000)
  }

  this.target_session_attrs = val('target_session_attrs', config)
}

// Convert arg to a string, surround in single quotes, and escape single quotes and backslashes
var quoteParamValue = function (value) {
  return "'" + ('' + value).replace(/\\/g, '\\\\').replace(/'/g, "\\'") + "'"
}

var add = function (params, config, paramName) {
  var value = config[paramName]
  if (value !== undefined && value !== null) {
    params.push(paramName + '=' + quoteParamValue(value))
  }
}

ConnectionParameters.prototype.getLibpqConnectionString = function (cb) {
  var params = []
  add(params, this, 'user')
  add(params, this, 'password')
  add(params, this, 'port')
  add(params, this, 'application_name')
  add(params, this, 'fallback_application_name')
  add(params, this, 'connect_timeout')
  add(params, this, 'target_session_attrs')

  var ssl = typeof this.ssl === 'object' ? this.ssl : this.ssl ? { sslmode: this.ssl } : {}
  add(params, ssl, 'sslmode')
  add(params, ssl, 'sslca')
  add(params, ssl, 'sslkey')
  add(params, ssl, 'sslcert')
  add(params, ssl, 'sslrootcert')

  if (this.database) {
    params.push('dbname=' + quoteParamValue(this.database))
  }
  if (this.replication) {
    params.push('replication=' + quoteParamValue(this.replication))
  }
  if (this.host) {
    params.push('host=' + quoteParamValue(Array.isArray(this.host) ? this.host.join(',') : this.host))
  }
  if (this.isDomainSocket) {
    return cb(null, params.join(' '))
  }
  if (this.client_encoding) {
    params.push('client_encoding=' + quoteParamValue(this.client_encoding))
  }
  async.map((Array.isArray(this.host) ? this.host : [this.host]), dns.lookup, function (err, addresses) {
    if (err) return cb(err, null)
    params.push('hostaddr=' + quoteParamValue(addresses.join(',')))
    return cb(null, params.join(' '))
  })
}

module.exports = ConnectionParameters