rqlite-js 2.5.6 → 2.6.0

package/es6/api/client/index.js

@@ -1,83 +0,0 @@
-/**
- * Base API client for RQLite which abstracts the HTTP calls
- * @module api/client
- */
-import HttpRequest from '../../http-request'
-import { HTTP_METHOD_GET, HTTP_METHOD_POST } from '../../http-request/http-methods'
-
-/**
- * @typedef HttpRequestOptions
- * @type {import('../../http-request').HttpRequestOptions}
- */
-
-/**
- * Create the base HTTP query options from RQLite API options
- * @param {Object} [options={}] The RQLite API options
- * @param {String} [options.level] The consistency level
- * @param {String} [options.pretty] Pretty print the response body
- * @param {String} [options.timings] Provide query timings
- * @param {String} [options.atomic] Treat all commands in the request as a single transaction
- * for RQLite v5 and higher
- * @param {String} [options.transaction] Treat all commands in the request as a single transaction
- * for RQLite v4 and lower
- * @returns {Object} The HTTP query
- */
-export function createQuery (options = {}) {
-  const { level, pretty, timings, atomic, transaction } = options
-
-  // Remove all undefined values
-  const query = { level, pretty, timings, atomic, transaction }
-  return Object.entries(query).reduce((acc, entry) => {
-    const [key, val] = entry
-    // Only take defined values
-    if (typeof val !== 'undefined') {
-      acc[key] = val
-    }
-    return acc
-  }, {})
-}
-
-/**
- * Base API client for RQLite which abstracts the HTTP calls
- * from the user
- */
-export default class ApiClient extends HttpRequest {
-  /**
-   * Perform a RQLite data API get request
-   * @param {String} path The path for the request i.e. /db/query
-   * @param {String} sql The SQL query
-   * @param {HttpRequestOptions} [options={}] RQLite API options
-   */
-  async get (path, sql, options = {}) {
-    const { useLeader } = options
-    if (!path) {
-      throw new Error('The path argument is required')
-    }
-    return super.get({
-      useLeader,
-      uri: path,
-      httpMethod: HTTP_METHOD_GET,
-      query: { ...createQuery(options), q: sql },
-    })
-  }
-
-  /**
-   * Perform a RQLite data API post request
-   * @param {String} path The path for the request i.e. /db/query
-   * @param {String} sql The SQL query
-   * @param {HttpRequestOptions} [options={}] RQLite API options
-   */
-  async post (path, sql, options = {}) {
-    const { useLeader } = options
-    if (!path) {
-      throw new Error('The path argument is required')
-    }
-    return super.post({
-      useLeader,
-      uri: path,
-      httpMethod: HTTP_METHOD_POST,
-      query: createQuery(options),
-      body: Array.isArray(sql) ? sql : [sql],
-    })
-  }
-}

package/es6/api/data/index.js

@@ -1,123 +0,0 @@
-/**
- * Data api client to perform RQLite data operations such
- * as query and execute
- * @module api/data
- */
-import ApiClient from '../client'
-import { DataResults } from '../results'
-
-/**
- * The RQLite query api path
- */
-export const PATH_QUERY = '/db/query'
-
-/**
- * The RQLite execute api path
- */
-export const PATH_EXECUTE = '/db/execute'
-
-/**
- * Read query consistency level none which means
- * any node can respond
- */
-export const CONSISTENCY_LEVEL_NONE = 'none'
-
-/**
- * Read query consistency strong which must come from
- * the master node
- */
-export const CONSISTENCY_LEVEL_STRONG = 'strong'
-
-/**
- * Read query consistency weak which must come from
- * the master node
- */
-export const CONSISTENCY_LEVEL_WEAK = 'weak'
-
-/**
- * @typedef HttpRequestOptions
- * @type {import('../../http-request').HttpRequestOptions}
- */
-
-/**
- * Data request base options
- * @typedef DataRequestBaseOptions
- * @type {Object}
- * @property {Boolean} [raw] If true return the raw http response from
- * RQLite response
- */
-
-/**
- * Data query request base options
- * @typedef QueryRequestBaseOptions
- * @type {Object}
- * @property {String} level The api consistency level
- */
-
-/**
- * Data query request options
- * @typedef QueryRequestOptions
- * @type {HttpRequestOptions & DataRequestBaseOptions & QueryRequestBaseOptions}
- */
-
-/**
- * Data execute request options
- * @typedef ExecuteRequestOptions
- * @type {HttpRequestOptions & DataRequestBaseOptions}
- */
-
-/**
- * Send an RQLite query API request to the RQLite server
- * @param {String} sql The SQL string to excute on the server
- * @param {DataRequestBaseOptions} [options={}] RQLite api options
- */
-function handleResponse (response, options = {}) {
-  const { raw } = options
-  const { body } = response
-  if (raw) {
-    return response
-  }
-  return new DataResults(body)
-}
-
-/**
- * Data api client to perform RQLite queries
- */
-export default class DataApiClient extends ApiClient {
-  /**
-   * Send an RQLite query API request to the RQLite server
-   * @param {String} sql The SQL string to excute on the server
-   * @param {QueryRequestOptions} [options={}] RQLite api options
-   */
-  async query (sql, options = {}) {
-    const { level } = options
-    let { useLeader } = options
-    // Weak and strong consistency will be redirect to the master anyway
-    // so skip the redirect HTTP response and got right to the master
-    if (level !== CONSISTENCY_LEVEL_NONE) {
-      useLeader = true
-    }
-    let response
-    if (Array.isArray(sql)) {
-      response = await super.post(PATH_QUERY, sql, { ...options, useLeader })
-    } else {
-      response = await super.get(PATH_QUERY, sql, { ...options, useLeader })
-    }
-    // If round robin is true try and balance selects across hosts when
-    // the master node is not queried directly
-    if (!useLeader) {
-      this.setNextActiveHostIndex()
-    }
-    return handleResponse(response, options)
-  }
-
-  /**
-   * Send an RQLite execute API request to the RQLite server
-   * @param {String} sql The SQL string to excute on the server
-   * @param {ExecuteRequestOptions} [options={}] RQLite execute api options
-   */
-  async execute (sql, options = {}) {
-    const response = await super.post(PATH_EXECUTE, sql, options)
-    return handleResponse(response, options)
-  }
-}

package/es6/api/results/data-result-error.js

@@ -1,32 +0,0 @@
-/**
- * Class for handling RQLite data api result error
- * @module api/results/data-results
- */
-
-/**
- * A class that represents one data error result from an RQLite query or execute
- * API call
- */
-export default class DataResultError extends Error {
-  constructor (...args) {
-    super(...args)
-    this.name = this.constructor.name
-    this.code = this.constructor.name
-  }
-
-  /**
-   * Get the result data error as plain object
-   * @returns {Object} The data as an object
-   */
-  toObject () {
-    return { error: this.message }
-  }
-
-  /**
-   * Convert the result data error to a JSON string
-   * @returns {String} The JSON string for the data object
-   */
-  toString () {
-    return JSON.stringify(this.toObject())
-  }
-}

package/es6/api/results/data-result.js

@@ -1,134 +0,0 @@
-/**
- * Class for handling single RQLite data api result
- * @module api/results/data-result
- */
-
-/**
- * A class that represents one data result from an RQLite query or execute
- * API call
- */
-export default class DataResult {
-  /**
-   * The time the results query took to complete
-   * @type {Number}
-   */
-  time = 0.0
-
-  /**
-   * The last insert id
-   * @type {Number}
-   */
-  lastInsertId
-
-  /**
-   * The rows affected
-   * @type {Number}
-   */
-  rowsAffected = 0
-
-  /**
-   * An array of DataResult and/or DataResultError instances
-   * @type {Array<DataResult|DataResultError>}
-   */
-  results = []
-
-  /**
-   * An object after the columns and values are mapped from
-   * an RQLite response
-   */
-  data = {}
-
-  /**
-   * The data result constructor
-   * @param {Array} result An API response individual result
-   * @param {Array} [valuesIndex] The index to get the values from the result
-   */
-  constructor (result, valuesIndex) {
-    if (typeof result !== 'object') {
-      throw new Error('The result argument is required to be an object')
-    }
-    if (typeof valuesIndex !== 'undefined' && !Number.isFinite(valuesIndex)) {
-      throw new Error('The valuesIndex argument is required to be a finite number when provided')
-    }
-    this.time = parseFloat(result.time || 0.0)
-    this.rowsAffected = parseInt(result.rows_affected || 0, 10)
-    this.lastInsertId = result.last_insert_id
-    // Map the values array to an object where columns are the properties
-    if (Number.isFinite(valuesIndex)) {
-      const { columns } = result
-      const resultValues = result.values[valuesIndex]
-      if (resultValues) {
-        this.data = resultValues.reduce((acc, val, i) => {
-          const col = columns[i]
-          acc[col] = val
-          return acc
-        }, {})
-      }
-    }
-  }
-
-  /**
-   * Return the value a property or undefined if it does not exist
-   * @returns {*} The value of the property or undefined
-   */
-  get (property) {
-    return this.data[property]
-  }
-
-  /**
-   * Get the time the result took
-   * @returns {Number} The time the query took
-   */
-  getTime () {
-    return this.time
-  }
-
-  /**
-   * Get the last insert id
-   * @returns {Number|undefined}
-   */
-  getLastInsertId () {
-    return this.lastInsertId
-  }
-
-  /**
-   * Get the row affected
-   * @returns {Number|undefined}
-   */
-  getRowsAffected () {
-    return this.rowsAffected
-  }
-
-  /**
-   * Get the result data as plain object
-   * @returns {Object} The data as an object
-   */
-  toObject () {
-    // Clone deep
-    return JSON.parse(JSON.stringify(this.data))
-  }
-
-  /**
-   * Map the data values to an array
-   * @returns {Array}
-   */
-  toArray () {
-    return Object.values(this.data)
-  }
-
-  /**
-   * Map the data properites to an array
-   * @returns {String[]}
-   */
-  toColumnsArray () {
-    return Object.keys(this.data)
-  }
-
-  /**
-   * Convert the result data to a JSON string
-   * @returns {String} The JSON string for the data object
-   */
-  toString () {
-    return JSON.stringify(this.data)
-  }
-}

package/es6/api/results/data-results.js

@@ -1,121 +0,0 @@
-/**
- * Class for handling many RQLite data api results
- * @module api/results/data-results
- */
-import DataResult from './data-result'
-import DataResultError from './data-result-error'
-
-/**
- * A class to manage a list of results from an RQLite query or execute API response
- */
-export default class DataResults {
-  /**
-   * The time the results took to return from the
-   * RQLite api
-   * @type {Number}
-   */
-  time = 0.0
-
-  /**
-   * The results which is an empty arry to start
-   * @type {DataResult[]}
-   */
-  results = []
-
-  /**
-   * The data result list constructor
-   * @param {Object} data The data object sent from a RQLite API response
-   * @param {Number} data.time The time the API response took to complete
-   * @param {Object[{error:String,values:Object}]} data.results The results array
-   */
-  constructor (data) {
-    this.setApiData(data)
-  }
-
-  /**
-   * Set the api as results
-   * @param {Object} data Api data
-   */
-  setApiData (data) {
-    if (typeof data !== 'object') {
-      throw new Error('The data argument is required to be an object')
-    }
-    if (!data.results) {
-      throw new Error('The data object is required to have a results property')
-    }
-    this.time = parseFloat(data.time || 0.0)
-    const { results = [] } = data
-    this.results = results.reduce((acc, result) => {
-      // If there is an error property this is an error
-      if (typeof result === 'object' && result.error) {
-        return acc.concat(new DataResultError(result.error))
-      }
-      const { values: vals } = result
-      // We don't have values so this is a single result row
-      if (!vals) {
-        return acc.concat(new DataResult(result))
-      }
-      // Map the values to DataResult instances
-      const dataResults = vals.map((_v, valuesIndex) => new DataResult(result, valuesIndex))
-      return acc.concat(dataResults)
-    }, [])
-  }
-
-  /**
-   * Returns true if an instance of DataResultError exists in the results
-   * @returns {Boolean} True if a DataResultError instance exists
-   */
-  hasError () {
-    return !!this.getFirstError()
-  }
-
-  /**
-   * Get the first error that occured
-   * @returns {DataResultError|undefined}
-   */
-  getFirstError () {
-    return this.results.find((v) => v instanceof DataResultError)
-  }
-
-  /**
-   * Get the time the results took
-   * @returns {Number} The time the query took
-   */
-  getTime () {
-    return this.time
-  }
-
-  /**
-   * Return one result at a specific index or undefined it it does not exist
-   * @returns {DataResult|DataResultError|undefined}
-   */
-  get (index) {
-    return this.results[index]
-  }
-
-  /**
-   * Return the results array
-   * @returns {Array<DataResult|DataResultError>}
-   */
-  getResults () {
-    return this.results
-  }
-
-  /**
-   * Get the result data list as array of plain objects
-   * @returns {Object[]} The data as an array or objects
-   */
-  toArray () {
-    return this.results.map((result) => result.toObject())
-  }
-
-  /**
-   * Convert the result data list to a JSON string that is an
-   * array of objects
-   * @returns {String} A JSON string
-   */
-  toString () {
-    const list = this.results.map((result) => result.toObject())
-    return JSON.stringify(list)
-  }
-}

package/es6/api/results/index.js

@@ -1,7 +0,0 @@
-/**
- * Features for handle RQLite data api responses for success and errors
- * @module api/results
- */
-export { default as DataResult } from './data-result'
-export { default as DataResultError } from './data-result-error'
-export { default as DataResults } from './data-results'

package/es6/api/status/index.js

@@ -1,54 +0,0 @@
-/**
- * Status api client to perform RQLite status and diagnostics operations
- * @module api/status
- */
-import ApiClient from '../client'
-
-/**
- * @typedef {Object} HttpResponse
- * @property {Object} Body The HTTP response body parsed by JSON.parse()
- * @property {Number} statusCode The HTTP response code
- */
-
-/**
- * @typedef {Object} StatusAllHostsResponse
- * @property {HttpResponse} response An HTTP response
- * @property {String} host The host name
- */
-
-/**
- * The RQLite status api path
- */
-export const PATH_STATUS = '/status'
-
-/**
- * Data api client to perform RQLite queries
- */
-export default class StatusApiClient extends ApiClient {
-  /**
-   * Get the RQLite server status which defaults to the master host
-   * @param {Object} [options={}] RQLite api options
-   * @returns {HttpResponse} An HTTP response object
-   */
-  async status (options = {}) {
-    return super.get(PATH_STATUS, { useLeader: true, ...options })
-  }
-
-  /**
-   * Get the RQLite server status for all hosts as an array of object with
-   * the host and their status
-   * @param {Object} [options={}] RQLite api options
-   * @param {Object} [options.raw] If true return the raw http response from
-   * RQLite response
-   * @returns {StatusAllHostsResponse[]} An array of http response for the provide hosts
-   */
-  async statusAllHosts (options = {}) {
-    const hosts = this.getHosts()
-    // Get the status for all of the hosts
-    const promises = hosts.map(async (_host, activeHostIndex) => {
-      const response = await this.status({ ...options, activeHostIndex })
-      return { response, host: hosts[activeHostIndex] }
-    })
-    return Promise.all(promises)
-  }
-}

package/es6/http-request/content-types.js

@@ -1,4 +0,0 @@
-export const CONTENT_TYPE_TEXT_PLAIN = 'text/plain'
-export const CONTENT_TYPE_APPLICATION_JSON = 'application/json'
-export const CONTENT_TYPE_APPLICATION_X_WWW_FORM_URLENCODED = 'application/x-www-form-urlencoded'
-export const CONTENT_TYPE_APPLICATION_OCTET_STREAM = 'application/octet-stream'

package/es6/http-request/errors.js

@@ -1,16 +0,0 @@
-/* eslint-disable import/prefer-default-export */
-/**
- * Http request errors
- * @module http-request/errors
- */
-
-/**
- * Error when max rediret attempts have been reached
- */
-export class ERROR_HTTP_REQUEST_MAX_REDIRECTS extends Error {
-  constructor (...args) {
-    super(...args)
-    this.name = this.constructor.name
-    this.code = this.constructor.name
-  }
-}

package/es6/http-request/http-methods.js

@@ -1,39 +0,0 @@
-/**
- * Http methods
- * @module http-request/http-methods
- */
-
-/**
- * Http DELETE method
- */
-export const HTTP_METHOD_DELETE = 'DELETE'
-
-/**
- * Http GET method
- */
-export const HTTP_METHOD_GET = 'GET'
-
-/**
- * Http HEAD method
- */
-export const HTTP_METHOD_HEAD = 'HEAD'
-
-/**
- * Http OPTIONS method
- */
-export const HTTP_METHOD_OPTIONS = 'OPTIONS'
-
-/**
- * Http PATCH method
- */
-export const HTTP_METHOD_PATCH = 'PATCH'
-
-/**
- * Http POST method
- */
-export const HTTP_METHOD_POST = 'POST'
-
-/**
- * Http PUT method
- */
-export const HTTP_METHOD_PUT = 'PUT'