rqlite-js 2.5.7 → 3.0.0

package/src/index.ts

@@ -0,0 +1,38 @@
+/**
+ * RQLite JS client which export all of the api clients
+ * @module rqlite-js
+ * @see https://rqlite.io/docs/api/api/
+ */
+import DataApiClient from './api/data/index.js'
+import BackupApiClient from './api/backup/index.js'
+import StatusApiClient from './api/status/index.js'
+
+export {
+  DataApiClient,
+  BackupApiClient,
+  StatusApiClient,
+}
+
+export {
+  PATH_QUERY,
+  PATH_EXECUTE,
+  CONSISTENCY_LEVEL_NONE,
+  CONSISTENCY_LEVEL_STRONG,
+  CONSISTENCY_LEVEL_LINEARIZABLE,
+  CONSISTENCY_LEVEL_WEAK,
+} from './api/data/index.js'
+
+export {
+  PATH_BACKUP,
+  PATH_LOAD,
+  BACKUP_DATA_FORMAT_SQL,
+  BACKUP_DATA_FORMAT_DUMP,
+} from './api/backup/index.js'
+
+export { PATH_STATUS } from './api/status/index.js'
+
+export default {
+  DataApiClient,
+  BackupApiClient,
+  StatusApiClient,
+}

package/.eslintrc

@@ -1,20 +0,0 @@
-{
-  "env": {
-    "node": true,
-    "mocha": true
-  },
-  "extends": "airbnb-base",
-  "plugins": [
-    "mocha",
-    "babel"
-  ],
-  "rules": {
-    "import/no-extraneous-dependencies": ["error", { "devDependencies": true }],
-    "mocha/no-exclusive-tests": "error",
-    "object-curly-newline": 0,
-    "object-curly-spacing": [2, "always"],
-    "semi": [2, "never"],
-    "space-before-function-paren": [2, "always"]
-  },
-  "parser": "@babel/eslint-parser"
-}

package/.travis.yml

@@ -1,24 +0,0 @@
-sudo: required
-
-services:
-  - docker
-  
-language: node_js
-
-node_js:
-  - "14"
-
-cache:
-  directories:
-    - "node_modules"
-
-before_install:
-  - docker pull rqlite/rqlite:5.12.1
-  - docker run -d -p 4001:4001 -p 4002:4002 --name=rqlite-js rqlite/rqlite:5.12.1
-
-script:
-  - npm run build-all
-  - npm run test-build -- --reporter tap
-  - npm run test-build-integrations -- --reporter tap
-  - docker stop rqlite-js
-  - docker rm rqlite-js

package/es6/api/backup/index.js

@@ -1,71 +0,0 @@
-/**
- * Backup api client to perform RQLite back and load operations
- * @module api/backup
- */
-import HttpRequest from '../../http-request'
-import { CONTENT_TYPE_APPLICATION_OCTET_STREAM, CONTENT_TYPE_TEXT_PLAIN } from '../../http-request/content-types'
-
-/**
- * The RQLite load api path
- */
-export const PATH_LOAD = '/db/load'
-
-/**
- * The RQLite backup api path
- */
-export const PATH_BACKUP = '/db/backup'
-
-/**
- * Use plain SQL dump as the back up format
- */
-export const BACKUP_DATA_FORMAT_SQL = 'sql'
-
-/**
- * Use sqlite3 dump as the back up format
- */
-export const BACKUP_DATA_FORMAT_DUMP = 'dump'
-
-/**
- * Backup api client to perform RQLite back up and load operations
- */
-export default class BackupApiClient extends HttpRequest {
-  /**
-   * Perform a SQL dump backup from the RQLite server
-   * @param {String} [format=BACKUP_DATA_FORMAT_DUMP] The backup data format
-   * @returns {Stream} The response stream
-   */
-  async backup (format = BACKUP_DATA_FORMAT_DUMP) {
-    const stream = super.get({
-      headers: {
-        // Always sends application/octet-stream from the server in RQLite v4.x
-        Accept: CONTENT_TYPE_APPLICATION_OCTET_STREAM,
-      },
-      query: { fmt: format === BACKUP_DATA_FORMAT_SQL ? format : undefined },
-      json: false,
-      stream: true,
-      uri: PATH_BACKUP,
-      useLeader: true,
-    })
-    return stream
-  }
-
-  /**
-   * Perform a SQL restore by sending data the RQLite server
-   * @param {Buffer|String} data The data to be loaded
-   * @param {String} [format=BACKUP_DATA_FORMAT_SQL] The backup data format
-   * @returns {Stream} The response stream
-   */
-  async load (data, format = BACKUP_DATA_FORMAT_SQL) {
-    return super.post({
-      body: data,
-      headers: {
-        // eslint-disable-next-line max-len
-        'Content-Type': format === BACKUP_DATA_FORMAT_SQL ? CONTENT_TYPE_TEXT_PLAIN : CONTENT_TYPE_APPLICATION_OCTET_STREAM,
-      },
-      json: false,
-      stream: true,
-      uri: PATH_LOAD,
-      useLeader: true,
-    })
-  }
-}

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,129 +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 linearizable which must come from
- * the master node
- */
-export const CONSISTENCY_LEVEL_LINEARIZABLE = 'linearizable'
-
-/**
- * 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'