rqlite-js 2.5.7 → 2.6.0

package/README.md

@@ -1,215 +1,234 @@
-# rqlite-js · [![npm version](https://img.shields.io/npm/v/rqlite-js.svg?style=flat)](https://www.npmjs.com/package/rqlite-js) · [![Build Status](https://travis-ci.org/rqlite/rqlite-js.svg?branch=master)](https://travis-ci.org/rqlite/rqlite-js) · [![Google Group](https://img.shields.io/badge/Google%20Group--blue.svg)](https://groups.google.com/group/rqlite)
-A promise based client library for [rqlite](https://github.com/rqlite/rqlite), the lightweight, distributed database built on SQLite.  This package is designed to provide javascript classes with interfaces that line up with RQLite API endpoints.  Please note that there is no code in this package for writing SQL queries.  There are other Javascript SQL generator libraries such as [sequel](https://www.npmjs.com/package/sequel) which can be used to create the SQLite query strings.  You are welcome to use one of those libraries or write your own SQL queries directly in your code.
+# rqlite-js · [![npm version](https://img.shields.io/npm/v/rqlite-js.svg?style=flat)](https://www.npmjs.com/package/rqlite-js) · [![CI](https://github.com/rqlite/rqlite-js/actions/workflows/ci.yml/badge.svg)](https://github.com/rqlite/rqlite-js/actions/workflows/ci.yml)
+
+A promise-based client library for [rqlite](https://rqlite.io), the lightweight, distributed database built on SQLite. Clients mirror the HTTP API endpoints (`/db/query`, `/db/execute`, `/db/backup`, `/status`). This package does not generate SQL—use your own SQL strings or another SQL builder.
+
+**Requirements:** Node.js `>= 18`. CI tests Node 18–24 on `ubuntu-latest`; Docker integrations use Node 24. Tested against **rqlite 10.x** (Docker image `rqlite/rqlite:10.6.6`).
+
+See the official docs:
+
+- [Accessing rqlite (HTTP API)](https://rqlite.io/docs/api/api/)
+- [Read consistency](https://rqlite.io/docs/api/read-consistency/)
+- [Backup and restore](https://rqlite.io/docs/guides/backup/)
+- [Monitoring / status](https://rqlite.io/docs/guides/monitoring-rqlite/)
 
 ## Features
-* Automatically follow 301 redirects from replicates to leader node
-* Round robin load balancing of leader node and all replicate nodes for query api requests
-* HTTP Keepalive support through http and https agents when initializing clients or on individual requests see [Client options](#client-options)
-* Unit and integration tests for contributors
+
+- Follow 301/302 redirects from followers to the leader
+- Round-robin host balancing for non-leader reads
+- HTTP keepalive via `http` / `https` agents
+- Unit and Docker integration tests
+
+## Install
+
+```bash
+npm install rqlite-js
+```
+
+## Quick start
+
+```javascript
+import { DataApiClient } from 'rqlite-js'
+
+const dataApiClient = new DataApiClient('http://localhost:4001')
+
+await dataApiClient.execute('CREATE TABLE IF NOT EXISTS foo (id INTEGER NOT NULL PRIMARY KEY, name TEXT)')
+const insert = await dataApiClient.execute('INSERT INTO foo(name) VALUES("fiona")')
+if (insert.hasError()) {
+  throw insert.getFirstError()
+}
+const id = insert.get(0).getLastInsertId()
+const select = await dataApiClient.query(`SELECT id, name FROM foo WHERE id=${id}`)
+console.log(select.get(0).toObject()) // { id: 1, name: 'fiona' }
+```
 
 ## DataApiClient
-The data API client will allow you to access the [data API endpoints](https://github.com/rqlite/rqlite/blob/master/DOC/DATA_API.md) of RQLite such as `query` and `execute`.  All data methods will return a DataResults instance which is an array of DataResult instances.  The DataResult instances are designed to abstract working with the response body from RQLite data endpoints.  If you want to work with the raw HTTP response instead of using the DataResults the options accept a raw options which can be set to true.  This is covered in the examples below.
 
-### DataApiClient Methods
-The follow methods are available on the DataApiClient including their method signatures.  Both the query and execute methods return a DataResults instance which provides methods for handling the RQLite response body states. In the case of a query there will only ever be one result in the DataResults.
+Access the [data API](https://rqlite.io/docs/api/api/) (`query` / `execute`). By default methods return a `DataResults` instance. Pass `{ raw: true }` to get `{ status, body }` instead.
 
-* DataApiClient.query(sql, options) - Single query SQL statments sent via HTTP get (Note, if you pass an array it will call execute internally)
-* DataApiClient.execute(sql, options) - Multiple SQL statments
+### Methods
 
-## DATA API Usage
+- `query(sql, options)` — read via HTTP GET (or POST when `sql` is an array)
+- `execute(sql, options)` — write via HTTP POST (`sql` may be a string or string array)
 
-### CREATE TABLE Example
-The code sample shows how you would connect to a rqlite server and create a table.
+### Create table
 
 ```javascript
 import { DataApiClient } from 'rqlite-js'
 
 const dataApiClient = new DataApiClient('http://localhost:4001')
-try {
-  // You can create your own raw SQL query or use another SQL generator library of your liking.
-  const sql = 'CREATE TABLE foo (id integer not null primary key, name text)'
-  const dataResults = await dataApiClient.execute(sql)
-  // Check the results for an error to make sure we the SQL query did
-  // not generate an error while executing.
-  if (dataResults.hasError()) {
-    const error = dataResults.getFirstError()
-    console.error(error, 'rqlite create tables results contained an error.')
-    return
-  }
-  // We are successful and have results to use from our SQL query.
-  console.log(dataResults.toString(), 'Checkout the rqlite results as a JSON string.')
-  console.log(dataResults.toArray(), 'Checkout the rqlite results as plain javascript array for app use.')
-  console.log(dataResults.get(0).toString(), 'Checkout just the first rqlite result as a JSON string.')
-
-  // Lets get the same query as a raw HTTP response
-  const { statusCode, body } = await dataApiClient.execute(sql, { raw: true })
-  console.log(body, 'HTTP reponse body.')
-  console.log(statusCode, 'HTTP response code.')
-} catch (e) {
-  console.error(e, 'The HTTP client got an HTTP error, there must be something else going on.')
+const dataResults = await dataApiClient.execute(
+  'CREATE TABLE foo (id INTEGER NOT NULL PRIMARY KEY, name TEXT)',
+)
+if (dataResults.hasError()) {
+  console.error(dataResults.getFirstError())
+} else {
+  console.log(dataResults.toArray())
 }
+
+// Raw HTTP response shape from this client:
+const { status, body } = await dataApiClient.execute(
+  'CREATE TABLE IF NOT EXISTS bar (id INTEGER NOT NULL PRIMARY KEY)',
+  { raw: true },
+)
+console.log(status, body)
 ```
 
-### Multiple QUERY Example
-The code sample shows how would connect to a rqlite server insert a row then select the row.
+### Insert, select, update
 
 ```javascript
 import { DataApiClient } from 'rqlite-js'
 
 const dataApiClient = new DataApiClient('http://localhost:4001')
-try {
-  // Insert a row into the table foo we create above in the CREATE TABLE example.
-  // The values for sql can be a string or an array if you want to execute multiple
-  // SQL queries on the server.
-  let dataResults = await dataApiClient.execute('INSERT INTO foo(name) VALUES(\"fiona\")')
-  if (dataResults.hasError()) {
-    const error = dataResults.getFirstError()
-    console.error(error, 'rqlite insert results contained an error.')
-    return
-  }
-  const id = dataResults.get(0).getLastInsertId()
-  console.log(id, 'The id of the inserted row')
-  dataResults = await dataApiClient.query(`SELECT name FROM foo WHERE id="${id}"`)
-  if (dataResults.hasError()) {
-    const error = dataResults.getFirstError()
-    console.error(error, 'rqlite select results contained an error.')
-    return
-  }
-  console.log(dataResults.get(0).get('name'), 'The value for the name field which should equal fiona')
-  console.log(dataResults.get(0).toObject(), 'rqlitejs results are great, but I just want to work with a plain js object maybe to send back in my api')
-  console.log(dataResults.get(0).get('id'), 'This is just the id of the first result.')
-  dataResults = await dataApiClient.execute(`UPDATE foo SET name="justin" WHERE name="fiona"`)
-  if (dataResults.hasError()) {
-    const error = dataResults.getFirstError()
-    console.error(error, 'rqlite select results contained an error.')
-    return
-  }
-  const rowsAffected = dataResults.get(0).getRowsAffected()
-  console.log(rowsAffected, 'The number of rows updated for each update query which should be 1 for the first row')
-  dataResults = await dataApiClient.query(`SELECT name FROM foo WHERE id="${id}"`)
-  if (dataResults.hasError()) {
-    const error = dataResults.getFirstError()
-    console.error(error, 'rqlite select results contained an error.')
-    return
-  }
-  console.log(dataResults.get(0).get('name'), 'The value for the name field which should now equal justin')
-} catch (e) {
-  console.error(e, 'The HTTP client got an HTTP error, there must be something else going on.')
+
+let dataResults = await dataApiClient.execute('INSERT INTO foo(name) VALUES("fiona")')
+if (dataResults.hasError()) {
+  throw dataResults.getFirstError()
 }
+const id = dataResults.get(0).getLastInsertId()
+
+dataResults = await dataApiClient.query(`SELECT id, name FROM foo WHERE id=${id}`)
+console.log(dataResults.get(0).get('name')) // fiona
+console.log(dataResults.get(0).toObject()) // { id: 1, name: 'fiona' }
+
+dataResults = await dataApiClient.execute('UPDATE foo SET name="justin" WHERE name="fiona"')
+console.log(dataResults.get(0).getRowsAffected()) // 1
 ```
 
-### Using transactions Example
-The code sample shows how would connect to a rqlite and run multiple insert queries within a transaction [transactions](https://github.com/rqlite/rqlite/blob/master/DOC/DATA_API.md#transactions).
+### Transactions (rqlite v5+)
+
+Use `{ atomic: true }` for a single transaction ([API docs](https://rqlite.io/docs/api/api/)). Legacy `{ transaction: true }` remains for older rqlite v4 servers.
 
 ```javascript
 import { DataApiClient } from 'rqlite-js'
 
 const dataApiClient = new DataApiClient('http://localhost:4001')
-try {
-  // Insert a row into the table foo we create above in the CREATE TABLE example.
-  // The values for sql can be a string or an array if you want to execute multiple
-  // SQL queries on the server.
-  const sql = [
-    'INSERT INTO foo(name) VALUES(\"fiona\")',
-    'INSERT INTO bar(name) VALUES(\"test\")',
-  ]
-  const dataResults = await dataApiClient.execute(sql, { transaction: true })
-  if (dataResults.hasError()) {
-    const error = dataResults.getFirstError()
-    console.error(error, 'rqlite insert results contained an error.')
-    return
-  }
-  console.log(dataResults.get(0).getLastInsertId(), 'The id for the first insert is in index 0 last_insert_id')
-  console.log(dataResults.get(1).getLastInsertId(), 'The id for the second insert is in index 1 last_insert_id')
-} catch (e) {
-  console.error(e, 'The HTTP client got an HTTP error, there must be something else going on.')
+const sql = [
+  'INSERT INTO foo(name) VALUES("fiona")',
+  'INSERT INTO foo(name) VALUES("justin")',
+]
+const dataResults = await dataApiClient.execute(sql, { atomic: true })
+if (dataResults.hasError()) {
+  throw dataResults.getFirstError()
 }
+console.log(dataResults.get(0).getLastInsertId())
+console.log(dataResults.get(1).getLastInsertId())
 ```
 
-### Multiple QUERY Example With Consistency
-The code sample shows how would connect to a rqlite and run multiple select queries with [strong consistency](https://github.com/rqlite/rqlite/blob/master/DOC/CONSISTENCY.md).
+### Consistency
 
 ```javascript
-import { DataApiClient } from 'rqlite-js'
+import { DataApiClient, CONSISTENCY_LEVEL_STRONG } from 'rqlite-js'
 
 const dataApiClient = new DataApiClient('http://localhost:4001')
-try {
-  const sql = [
-    'SELECT name FROM foo WHERE id="1"',
-    'SELECT id FROM bar WHERE name="test"',
-  ]
-  const dataResults = await dataApiClient.query(sql, { level: 'strong' })
-  if (dataResults.hasError()) {
-    const error = dataResults.getFirstError()
-    console.error(error, 'rqlite insert results contained an error.')
-    return
-  }
-  console.log(dataResults.get(0).toString(), 'The results for the first select are in index 0')
-  console.log(dataResults.get(1).toString(), 'The results for the second select are in index 1')
-} catch (e) {
-  console.error(e, 'The HTTP client got an HTTP error, there must be something else going on.')
+const dataResults = await dataApiClient.query(
+  'SELECT name FROM foo WHERE id=1',
+  { level: CONSISTENCY_LEVEL_STRONG },
+)
+```
+
+See [read consistency](https://rqlite.io/docs/api/read-consistency/) for `none`, `weak`, `strong`, and `linearizable`.
+
+### Errors (`error` and `error_v2`)
+
+Failed statements still use the legacy `error` string. On rqlite v10+, structured `error_v2` is also exposed:
+
+```javascript
+const dataResults = await dataApiClient.execute('INSERT INTO nonsense')
+if (dataResults.hasError()) {
+  const err = dataResults.getFirstError()
+  console.error(err.message)
+  console.error(err.getErrorV2()) // { message, sqlite: { code, extended_code } } when present
+  console.error(err.toObject())
 }
 ```
+
 ### Authentication
-Authentication can be set using the authentication property on the DataApiClient options.
 
 ```javascript
 import { DataApiClient } from 'rqlite-js'
 
-const username = 'rqliteUsername'
-const password = 'rqlitePassword'
 const dataApiClient = new DataApiClient('http://localhost:4001', {
-  authentication: { username, password },
+  authentication: {
+    username: 'rqliteUsername',
+    password: 'rqlitePassword',
+  },
 })
-try {
-  const sql = [
-    'SELECT name FROM foo WHERE id="1"',
-    'SELECT id FROM bar WHERE name="test"',
-  ]
-  const dataResults = await dataApiClient.query(sql, { level: 'strong' })
-  if (dataResults.hasError()) {
-    const error = dataResults.getFirstError()
-    console.error(error, 'rqlite insert results contained an error.')
-    return
-  }
-  console.log(dataResults.get(0).toString(), 'The results for the first select are in index 0')
-  console.log(dataResults.get(1).toString(), 'The results for the second select are in index 1')
-} catch (e) {
-  console.error(e, 'The HTTP client got an HTTP error, there must be something else going on.')
-}
 ```
 
-### Client options
-Multiple hosts can be provided using the construtor for the data api client. For greater performance when making http requests it is often useful to provide an http and https agent to the client through options.
+### Client options (hosts, agents, retries)
 
 ```javascript
-import { DataApiClient } from 'rqlite-js'
 import http from 'http'
 import https from 'https'
+import { DataApiClient } from 'rqlite-js'
 
-// Hosts can be an array or a string that is comma seperated e.g. 'http://localhost:4001,http://localhost:4002,http://localhost:4003'
-const dataApiClient = new DataApiClient(['http://localhost:4001', 'http://localhost:4002', 'http://localhost:4003'], {
-  httpAgent: new http.Agent({ keepAlive: true }),
-  httpsAgent: new https.Agent({ keepAlive: true }),
-})
+const dataApiClient = new DataApiClient(
+  ['http://localhost:4001', 'http://localhost:4002', 'http://localhost:4003'],
+  {
+    httpAgent: new http.Agent({ keepAlive: true }),
+    httpsAgent: new https.Agent({ keepAlive: true }),
+    // Optional retry customization:
+    retryableStatusCodes: new Set([408, 429, 500, 502, 503, 504]),
+    retryableErrorCodes: new Set(['ECONNRESET', 'ETIMEDOUT']),
+    retryableHttpMethods: new Set(['GET', 'POST']),
+    retries: 0, // disable retries
+  },
+)
 ```
 
-### Retrys
-All http requests are retried with exponential backoff up to the number of hosts times 3. Each retry tries the next host in the rotation. To see the http status codes, error codes and http methods which cause a retry have a look at [es6/http-request/retryable.js](es6/http-request/retryable.js). When creating an instance you can supply your own Set or Array of replacement values. To manually disable all retry logic provide the contructor an entries properties with the value 0.
+Hosts may also be a comma-separated string: `'http://localhost:4001,http://localhost:4002'`.
+
+## StatusApiClient
 
 ```javascript
-import { DataApiClient } from 'rqlite-js'
-import http from 'http'
-import https from 'https'
+import { StatusApiClient } from 'rqlite-js'
+
+const statusApiClient = new StatusApiClient('http://localhost:4001')
+const { status, body } = await statusApiClient.status()
+console.log(status, body.store?.ready)
 
-// Hosts can be an array or a string that is comma seperated e.g. 'http://localhost:4001,http://localhost:4002,http://localhost:4003'
-const dataApiClient = new DataApiClient(['http://localhost:4001', 'http://localhost:4002', 'http://localhost:4003'], {
-  retryableErrorCodes: Set([600]), // Retry HTTP response status code 600
-  retryableStatusCodes: Set(['SPECIAL_ERROR_CODE']), // Retry error.code === SPECIAL_ERROR_CODE
-  retryableHttpMethods: Set(['GET']), // Only retry GET requests
-  retries: 0, // Manually disable all retry logic
+// One status call per configured host:
+const all = await statusApiClient.statusAllHosts()
+all.forEach(({ host, response }) => {
+  console.log(host, response.body?.store?.ready)
 })
 ```
 
-## Testing
-Please see the [docs/test/README.md](docs/test/README.md) for more information on testing for use by contributors.
+See [Monitoring rqlite](https://rqlite.io/docs/guides/monitoring-rqlite/).
+
+## BackupApiClient
+
+```javascript
+import { BackupApiClient, BACKUP_DATA_FORMAT_SQL } from 'rqlite-js'
+
+const backupApiClient = new BackupApiClient('http://localhost:4001')
+
+// Binary SQLite backup stream (default):
+const backupStream = await backupApiClient.backup()
+
+// SQL text backup:
+const sqlStream = await backupApiClient.backup(BACKUP_DATA_FORMAT_SQL)
+
+// Restore from SQL buffer/string:
+await backupApiClient.load(
+  Buffer.from('CREATE TABLE foo (id INTEGER PRIMARY KEY);'),
+  BACKUP_DATA_FORMAT_SQL,
+)
+```
+
+See [Backup and restore](https://rqlite.io/docs/guides/backup/).
+
+## Releases
+
+Versions and `CHANGELOG.md` are managed with [release-please](https://github.com/googleapis/release-please). Merging the release PR creates a GitHub Release; the publish workflow re-runs the full test suite (including Docker integrations) then runs [`npm stage publish`](https://docs.npmjs.com/staged-publishing/) via [trusted publishing](https://docs.npmjs.com/trusted-publishers/) (OIDC). A maintainer must then approve the staged version with 2FA on npmjs.com (or `npm stage approve <id>`) before it goes live.
+
+**Local quality gate (required before commit/push/publish):**
+
+```bash
+npm run verify                 # lint, type-check, unit, build, compiled unit
+npm run verify:integrations    # Docker + rqlite 10.6.6 integrations
+```
+
+## Contributing / testing
+
+See [docs/test/README.md](docs/test/README.md).

package/lib/api/backup/index.js

@@ -1,30 +1,24 @@
-"use strict";var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");Object.defineProperty(exports, "__esModule", { value: true });exports.default = exports.PATH_LOAD = exports.PATH_BACKUP = exports.BACKUP_DATA_FORMAT_SQL = exports.BACKUP_DATA_FORMAT_DUMP = void 0;var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+"use strict";var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");Object.defineProperty(exports, "__esModule", { value: true });Object.defineProperty(exports, "BACKUP_DATA_FORMAT_DUMP", { enumerable: true, get: function () {return _backupFormats.BACKUP_DATA_FORMAT_DUMP;} });Object.defineProperty(exports, "BACKUP_DATA_FORMAT_SQL", { enumerable: true, get: function () {return _backupFormats.BACKUP_DATA_FORMAT_SQL;} });Object.defineProperty(exports, "PATH_BACKUP", { enumerable: true, get: function () {return _paths.PATH_BACKUP;} });Object.defineProperty(exports, "PATH_LOAD", { enumerable: true, get: function () {return _paths.PATH_LOAD;} });exports.default = void 0;
+
 
 
 
 var _httpRequest = _interopRequireDefault(require("../../http-request"));
-var _contentTypes = require("../../http-request/content-types"); /**
- * Backup api client to perform RQLite back and load operations
- * @module api/backup
- */ /**
- * The RQLite load api path
- */const PATH_LOAD = exports.PATH_LOAD = '/db/load';
+var _contentTypes = require("../../http-request/content-types");
 
-/**
- * The RQLite backup api path
- */
-const PATH_BACKUP = exports.PATH_BACKUP = '/db/backup';
 
-/**
- * Use plain SQL dump as the back up format
- */
-const BACKUP_DATA_FORMAT_SQL = exports.BACKUP_DATA_FORMAT_SQL = 'sql';
 
-/**
- * Use sqlite3 dump as the back up format
- */
-const BACKUP_DATA_FORMAT_DUMP = exports.BACKUP_DATA_FORMAT_DUMP = 'dump';
+var _httpHeaders = require("../../http-request/http-headers");
+
+
 
+var _paths = require("../paths");
+var _backupFormats = require("../backup-formats");
+var _queryParams = require("../query-params"); /**
+ * Backup api client to perform RQLite back and load operations
+ * @module api/backup
+ * @see https://rqlite.io/docs/guides/backup/
+ */
 /**
  * Backup api client to perform RQLite back up and load operations
  */
@@ -32,41 +26,47 @@ class BackupApiClient extends _httpRequest.default {
   /**
    * 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
+   * @returns {Promise<*>} The response stream
+   * @see https://rqlite.io/docs/guides/backup/
+   * @see module:api/backup-formats
    */
-  backup(format = BACKUP_DATA_FORMAT_DUMP) {var _superprop_getGet = () => super.get,_this = this;return (0, _asyncToGenerator2.default)(function* () {
-      const stream = _superprop_getGet().call(_this, {
-        headers: {
-          // Always sends application/octet-stream from the server in RQLite v4.x
-          Accept: _contentTypes.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;})();
+  async backup(format = _backupFormats.BACKUP_DATA_FORMAT_DUMP) {
+    return super.get({
+      headers: {
+        // Always sends application/octet-stream from the server in RQLite v4.x
+        [_httpHeaders.HTTP_HEADER_ACCEPT]: _contentTypes.CONTENT_TYPE_APPLICATION_OCTET_STREAM
+      },
+      query: {
+        [_queryParams.QUERY_PARAM_FMT]: format === _backupFormats.BACKUP_DATA_FORMAT_SQL ? format : undefined
+      },
+      json: false,
+      stream: true,
+      uri: _paths.PATH_BACKUP,
+      useLeader: true
+    });
   }
 
   /**
    * 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
+   * @returns {Promise<*>} The response stream
+   * @see https://rqlite.io/docs/guides/backup/
+   * @see module:api/backup-formats
    */
-  load(data, format = BACKUP_DATA_FORMAT_SQL) {var _superprop_getPost = () => super.post,_this2 = this;return (0, _asyncToGenerator2.default)(function* () {
-      return _superprop_getPost().call(_this2, {
-        body: data,
-        headers: {
-          // eslint-disable-next-line max-len
-          'Content-Type': format === BACKUP_DATA_FORMAT_SQL ? _contentTypes.CONTENT_TYPE_TEXT_PLAIN : _contentTypes.CONTENT_TYPE_APPLICATION_OCTET_STREAM
-        },
-        json: false,
-        stream: true,
-        uri: PATH_LOAD,
-        useLeader: true
-      });})();
+  async load(data, format = _backupFormats.BACKUP_DATA_FORMAT_SQL) {
+    return super.post({
+      body: data,
+      headers: {
+        [_httpHeaders.HTTP_HEADER_CONTENT_TYPE]: format === _backupFormats.BACKUP_DATA_FORMAT_SQL ?
+        _contentTypes.CONTENT_TYPE_TEXT_PLAIN :
+        _contentTypes.CONTENT_TYPE_APPLICATION_OCTET_STREAM
+      },
+      json: false,
+      stream: true,
+      uri: _paths.PATH_LOAD,
+      useLeader: true
+    });
   }
 }exports.default = BackupApiClient;
 //# sourceMappingURL=index.js.map

package/lib/api/backup/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["_httpRequest","_interopRequireDefault","require","_contentTypes","PATH_LOAD","exports","PATH_BACKUP","BACKUP_DATA_FORMAT_SQL","BACKUP_DATA_FORMAT_DUMP","BackupApiClient","HttpRequest","backup","format","_superprop_getGet","get","_this","_asyncToGenerator2","default","stream","call","headers","Accept","CONTENT_TYPE_APPLICATION_OCTET_STREAM","query","fmt","undefined","json","uri","useLeader","load","data","_superprop_getPost","post","_this2","body","CONTENT_TYPE_TEXT_PLAIN"],"sources":["../../../es6/api/backup/index.js"],"sourcesContent":["/**\n * Backup api client to perform RQLite back and load operations\n * @module api/backup\n */\nimport HttpRequest from '../../http-request'\nimport { CONTENT_TYPE_APPLICATION_OCTET_STREAM, CONTENT_TYPE_TEXT_PLAIN } from '../../http-request/content-types'\n\n/**\n * The RQLite load api path\n */\nexport const PATH_LOAD = '/db/load'\n\n/**\n * The RQLite backup api path\n */\nexport const PATH_BACKUP = '/db/backup'\n\n/**\n * Use plain SQL dump as the back up format\n */\nexport const BACKUP_DATA_FORMAT_SQL = 'sql'\n\n/**\n * Use sqlite3 dump as the back up format\n */\nexport const BACKUP_DATA_FORMAT_DUMP = 'dump'\n\n/**\n * Backup api client to perform RQLite back up and load operations\n */\nexport default class BackupApiClient extends HttpRequest {\n  /**\n   * Perform a SQL dump backup from the RQLite server\n   * @param {String} [format=BACKUP_DATA_FORMAT_DUMP] The backup data format\n   * @returns {Stream} The response stream\n   */\n  async backup (format = BACKUP_DATA_FORMAT_DUMP) {\n    const stream = super.get({\n      headers: {\n        // Always sends application/octet-stream from the server in RQLite v4.x\n        Accept: CONTENT_TYPE_APPLICATION_OCTET_STREAM,\n      },\n      query: { fmt: format === BACKUP_DATA_FORMAT_SQL ? format : undefined },\n      json: false,\n      stream: true,\n      uri: PATH_BACKUP,\n      useLeader: true,\n    })\n    return stream\n  }\n\n  /**\n   * Perform a SQL restore by sending data the RQLite server\n   * @param {Buffer|String} data The data to be loaded\n   * @param {String} [format=BACKUP_DATA_FORMAT_SQL] The backup data format\n   * @returns {Stream} The response stream\n   */\n  async load (data, format = BACKUP_DATA_FORMAT_SQL) {\n    return super.post({\n      body: data,\n      headers: {\n        // eslint-disable-next-line max-len\n        'Content-Type': format === BACKUP_DATA_FORMAT_SQL ? CONTENT_TYPE_TEXT_PLAIN : CONTENT_TYPE_APPLICATION_OCTET_STREAM,\n      },\n      json: false,\n      stream: true,\n      uri: PATH_LOAD,\n      useLeader: true,\n    })\n  }\n}\n"],"mappings":";;;;AAIA,IAAAA,YAAA,GAAAC,sBAAA,CAAAC,OAAA;AACA,IAAAC,aAAA,GAAAD,OAAA,qCAAiH,CALjH;AACA;AACA;AACA,GAHA,CAOA;AACA;AACA,GACO,MAAME,SAAS,GAAAC,OAAA,CAAAD,SAAA,GAAG,UAAU;;AAEnC;AACA;AACA;AACO,MAAME,WAAW,GAAAD,OAAA,CAAAC,WAAA,GAAG,YAAY;;AAEvC;AACA;AACA;AACO,MAAMC,sBAAsB,GAAAF,OAAA,CAAAE,sBAAA,GAAG,KAAK;;AAE3C;AACA;AACA;AACO,MAAMC,uBAAuB,GAAAH,OAAA,CAAAG,uBAAA,GAAG,MAAM;;AAE7C;AACA;AACA;AACe,MAAMC,eAAe,SAASC,oBAAW,CAAC;EACvD;AACF;AACA;AACA;AACA;EACQC,MAAMA,CAAEC,MAAM,GAAGJ,uBAAuB,EAAE,KAAAK,iBAAA,GAAAA,CAAA,WAAAC,GAAA,CAAAC,KAAA,mBAAAC,kBAAA,CAAAC,OAAA;MAC9C,MAAMC,MAAM,GAAGL,iBAAA,GAAAM,IAAA,CAAAJ,KAAA,EAAU;QACvBK,OAAO,EAAE;UACP;UACAC,MAAM,EAAEC;QACV,CAAC;QACDC,KAAK,EAAE,EAAEC,GAAG,EAAEZ,MAAM,KAAKL,sBAAsB,GAAGK,MAAM,GAAGa,SAAS,CAAC,CAAC;QACtEC,IAAI,EAAE,KAAK;QACXR,MAAM,EAAE,IAAI;QACZS,GAAG,EAAErB,WAAW;QAChBsB,SAAS,EAAE;MACb,CAAC,CAAC;MACF,OAAOV,MAAM;EACf;;EAEA;AACF;AACA;AACA;AACA;AACA;EACQW,IAAIA,CAAEC,IAAI,EAAElB,MAAM,GAAGL,sBAAsB,EAAE,KAAAwB,kBAAA,GAAAA,CAAA,WAAAC,IAAA,CAAAC,MAAA,mBAAAjB,kBAAA,CAAAC,OAAA;MACjD,OAAOc,kBAAA,GAAAZ,IAAA,CAAAc,MAAA,EAAW;QAChBC,IAAI,EAAEJ,IAAI;QACVV,OAAO,EAAE;UACP;UACA,cAAc,EAAER,MAAM,KAAKL,sBAAsB,GAAG4B,qCAAuB,GAAGb;QAChF,CAAC;QACDI,IAAI,EAAE,KAAK;QACXR,MAAM,EAAE,IAAI;QACZS,GAAG,EAAEvB,SAAS;QACdwB,SAAS,EAAE;MACb,CAAC,CAAC;EACJ;AACF,CAACvB,OAAA,CAAAY,OAAA,GAAAR,eAAA","ignoreList":[]}
+{"version":3,"file":"index.js","names":["_httpRequest","_interopRequireDefault","require","_contentTypes","_httpHeaders","_paths","_backupFormats","_queryParams","BackupApiClient","HttpRequest","backup","format","BACKUP_DATA_FORMAT_DUMP","get","headers","HTTP_HEADER_ACCEPT","CONTENT_TYPE_APPLICATION_OCTET_STREAM","query","QUERY_PARAM_FMT","BACKUP_DATA_FORMAT_SQL","undefined","json","stream","uri","PATH_BACKUP","useLeader","load","data","post","body","HTTP_HEADER_CONTENT_TYPE","CONTENT_TYPE_TEXT_PLAIN","PATH_LOAD","exports","default"],"sources":["../../../es6/api/backup/index.js"],"sourcesContent":["/**\n * Backup api client to perform RQLite back and load operations\n * @module api/backup\n * @see https://rqlite.io/docs/guides/backup/\n */\nimport HttpRequest from '../../http-request'\nimport {\n  CONTENT_TYPE_APPLICATION_OCTET_STREAM,\n  CONTENT_TYPE_TEXT_PLAIN,\n} from '../../http-request/content-types'\nimport {\n  HTTP_HEADER_ACCEPT,\n  HTTP_HEADER_CONTENT_TYPE,\n} from '../../http-request/http-headers'\nimport { PATH_BACKUP, PATH_LOAD } from '../paths'\nimport { BACKUP_DATA_FORMAT_DUMP, BACKUP_DATA_FORMAT_SQL } from '../backup-formats'\nimport { QUERY_PARAM_FMT } from '../query-params'\n\nexport { PATH_LOAD, PATH_BACKUP } from '../paths'\nexport { BACKUP_DATA_FORMAT_SQL, BACKUP_DATA_FORMAT_DUMP } from '../backup-formats'\n\n/**\n * Backup api client to perform RQLite back up and load operations\n */\nexport default class BackupApiClient extends HttpRequest {\n  /**\n   * Perform a SQL dump backup from the RQLite server\n   * @param {String} [format=BACKUP_DATA_FORMAT_DUMP] The backup data format\n   * @returns {Promise<*>} The response stream\n   * @see https://rqlite.io/docs/guides/backup/\n   * @see module:api/backup-formats\n   */\n  async backup (format = BACKUP_DATA_FORMAT_DUMP) {\n    return super.get({\n      headers: {\n        // Always sends application/octet-stream from the server in RQLite v4.x\n        [HTTP_HEADER_ACCEPT]: CONTENT_TYPE_APPLICATION_OCTET_STREAM,\n      },\n      query: {\n        [QUERY_PARAM_FMT]: format === BACKUP_DATA_FORMAT_SQL ? format : undefined,\n      },\n      json: false,\n      stream: true,\n      uri: PATH_BACKUP,\n      useLeader: true,\n    })\n  }\n\n  /**\n   * Perform a SQL restore by sending data the RQLite server\n   * @param {Buffer|String} data The data to be loaded\n   * @param {String} [format=BACKUP_DATA_FORMAT_SQL] The backup data format\n   * @returns {Promise<*>} The response stream\n   * @see https://rqlite.io/docs/guides/backup/\n   * @see module:api/backup-formats\n   */\n  async load (data, format = BACKUP_DATA_FORMAT_SQL) {\n    return super.post({\n      body: data,\n      headers: {\n        [HTTP_HEADER_CONTENT_TYPE]: format === BACKUP_DATA_FORMAT_SQL\n          ? CONTENT_TYPE_TEXT_PLAIN\n          : CONTENT_TYPE_APPLICATION_OCTET_STREAM,\n      },\n      json: false,\n      stream: true,\n      uri: PATH_LOAD,\n      useLeader: true,\n    })\n  }\n}\n"],"mappings":";;;;;AAKA,IAAAA,YAAA,GAAAC,sBAAA,CAAAC,OAAA;AACA,IAAAC,aAAA,GAAAD,OAAA;;;;AAIA,IAAAE,YAAA,GAAAF,OAAA;;;;AAIA,IAAAG,MAAA,GAAAH,OAAA;AACA,IAAAI,cAAA,GAAAJ,OAAA;AACA,IAAAK,YAAA,GAAAL,OAAA,oBAAiD,CAhBjD;AACA;AACA;AACA;AACA;AAiBA;AACA;AACA;AACe,MAAMM,eAAe,SAASC,oBAAW,CAAC;EACvD;AACF;AACA;AACA;AACA;AACA;AACA;EACE,MAAMC,MAAMA,CAAEC,MAAM,GAAGC,sCAAuB,EAAE;IAC9C,OAAO,KAAK,CAACC,GAAG,CAAC;MACfC,OAAO,EAAE;QACP;QACA,CAACC,+BAAkB,GAAGC;MACxB,CAAC;MACDC,KAAK,EAAE;QACL,CAACC,4BAAe,GAAGP,MAAM,KAAKQ,qCAAsB,GAAGR,MAAM,GAAGS;MAClE,CAAC;MACDC,IAAI,EAAE,KAAK;MACXC,MAAM,EAAE,IAAI;MACZC,GAAG,EAAEC,kBAAW;MAChBC,SAAS,EAAE;IACb,CAAC,CAAC;EACJ;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;EACE,MAAMC,IAAIA,CAAEC,IAAI,EAAEhB,MAAM,GAAGQ,qCAAsB,EAAE;IACjD,OAAO,KAAK,CAACS,IAAI,CAAC;MAChBC,IAAI,EAAEF,IAAI;MACVb,OAAO,EAAE;QACP,CAACgB,qCAAwB,GAAGnB,MAAM,KAAKQ,qCAAsB;QACzDY,qCAAuB;QACvBf;MACN,CAAC;MACDK,IAAI,EAAE,KAAK;MACXC,MAAM,EAAE,IAAI;MACZC,GAAG,EAAES,gBAAS;MACdP,SAAS,EAAE;IACb,CAAC,CAAC;EACJ;AACF,CAACQ,OAAA,CAAAC,OAAA,GAAA1B,eAAA","ignoreList":[]}

package/lib/api/backup/test.unit.js

@@ -0,0 +1,45 @@
+"use strict";var _chai = require("chai");
+var _backupNock = require("../../test/backups/backup-nock");
+var _restoreNock = require("../../test/backups/restore-nock");
+var _ = _interopRequireWildcard(require("."));var cache;function _interopRequireWildcard(e, t) {if (!t && e && e.__esModule) return e;var r,c,a = Object.defineProperty,n = { __proto__: null, default: e };if (Object(e) !== e) return n;if (cache || "function" != typeof WeakMap || (cache = new WeakMap()), cache) {if (cache.has(e)) return cache.get(e);cache.set(e, n);}for (c in e) "default" !== c && {}.hasOwnProperty.call(e, c) && ((r = a && Object.getOwnPropertyDescriptor(e, c)) && (r.get || r.set) ? a(n, c, r) : n[c] = e[c]);return n;}
+
+const HOST = 'http://www.rqlite.com:4001';
+
+/**
+ * Capture the stream data and resolve a promise with the parsed JSON
+ */
+function handleRequestStreamAsPromise(request) {
+  return new Promise((resolve, reject) => {
+    let result = Buffer.from('');
+    request.
+    on('data', (data) => {
+      result = Buffer.concat([result, data]);
+    }).
+    on('end', () => resolve(result)).
+    on('error', reject);
+  });
+}
+
+describe('api backup', () => {
+  describe('backupApiClient.backup()', () => {
+    it(`should call ${HOST}${_.PATH_BACKUP} endpoint using HTTP GET`, async () => {
+      const backupApiClient = new _.default(HOST);
+      const scope = (0, _backupNock.backupSuccess)({ url: HOST, path: _.PATH_BACKUP });
+      const request = await backupApiClient.backup();
+      const result = await handleRequestStreamAsPromise(request);
+      _chai.assert.isTrue(scope.isDone(), 'http request captured by nock');
+      _chai.assert.equal(result, _backupNock.BACKUP_SUCCESS_RESPONSE);
+    });
+  });
+  describe('backupApiClient.load()', () => {
+    it(`should call ${HOST}${_.PATH_LOAD} endpoint using HTTP POST`, async () => {
+      const backupApiClient = new _.default(HOST);
+      const scope = (0, _restoreNock.restoreSuccess)({ url: HOST, path: _.PATH_LOAD, body: _backupNock.BACKUP_SUCCESS_RESPONSE });
+      const request = await backupApiClient.load(_backupNock.BACKUP_SUCCESS_RESPONSE);
+      const result = await handleRequestStreamAsPromise(request);
+      _chai.assert.isTrue(scope.isDone(), 'http request captured by nock');
+      _chai.assert.deepEqual(JSON.parse(result.toString()), _restoreNock.RESTORE_SUCCESS_RESPONSE);
+    });
+  });
+});
+//# sourceMappingURL=test.unit.js.map

package/lib/api/backup/test.unit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"test.unit.js","names":["_chai","require","_backupNock","_restoreNock","_","_interopRequireWildcard","cache","e","t","__esModule","r","c","a","Object","defineProperty","n","__proto__","default","WeakMap","has","get","set","hasOwnProperty","call","getOwnPropertyDescriptor","HOST","handleRequestStreamAsPromise","request","Promise","resolve","reject","result","Buffer","from","on","data","concat","describe","it","PATH_BACKUP","backupApiClient","BackupApiClient","scope","backupSuccess","url","path","backup","assert","isTrue","isDone","equal","BACKUP_SUCCESS_RESPONSE","PATH_LOAD","restoreSuccess","body","load","deepEqual","JSON","parse","toString","RESTORE_SUCCESS_RESPONSE"],"sources":["../../../es6/api/backup/test.unit.js"],"sourcesContent":["import { assert } from 'chai'\nimport { backupSuccess, BACKUP_SUCCESS_RESPONSE } from '../../test/backups/backup-nock'\nimport { restoreSuccess, RESTORE_SUCCESS_RESPONSE } from '../../test/backups/restore-nock'\nimport BackupApiClient, { PATH_BACKUP, PATH_LOAD } from '.'\n\nconst HOST = 'http://www.rqlite.com:4001'\n\n/**\n * Capture the stream data and resolve a promise with the parsed JSON\n */\nfunction handleRequestStreamAsPromise (request) {\n  return new Promise((resolve, reject) => {\n    let result = Buffer.from('')\n    request\n      .on('data', (data) => {\n        result = Buffer.concat([result, data])\n      })\n      .on('end', () => resolve(result))\n      .on('error', reject)\n  })\n}\n\ndescribe('api backup', () => {\n  describe('backupApiClient.backup()', () => {\n    it(`should call ${HOST}${PATH_BACKUP} endpoint using HTTP GET`, async () => {\n      const backupApiClient = new BackupApiClient(HOST)\n      const scope = backupSuccess({ url: HOST, path: PATH_BACKUP })\n      const request = await backupApiClient.backup()\n      const result = await handleRequestStreamAsPromise(request)\n      assert.isTrue(scope.isDone(), 'http request captured by nock')\n      assert.equal(result, BACKUP_SUCCESS_RESPONSE)\n    })\n  })\n  describe('backupApiClient.load()', () => {\n    it(`should call ${HOST}${PATH_LOAD} endpoint using HTTP POST`, async () => {\n      const backupApiClient = new BackupApiClient(HOST)\n      const scope = restoreSuccess({ url: HOST, path: PATH_LOAD, body: BACKUP_SUCCESS_RESPONSE })\n      const request = await backupApiClient.load(BACKUP_SUCCESS_RESPONSE)\n      const result = await handleRequestStreamAsPromise(request)\n      assert.isTrue(scope.isDone(), 'http request captured by nock')\n      assert.deepEqual(JSON.parse(result.toString()), RESTORE_SUCCESS_RESPONSE)\n    })\n  })\n})\n"],"mappings":"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","ignoreList":[]}

package/lib/api/backup-formats.js

@@ -0,0 +1,16 @@
+"use strict";Object.defineProperty(exports, "__esModule", { value: true });exports.BACKUP_DATA_FORMAT_SQL = exports.BACKUP_DATA_FORMAT_DUMP = void 0; /**
+ * RQLite backup data format constants
+ * @module api/backup-formats
+ * @see https://rqlite.io/docs/guides/backup/
+ */
+
+/**
+ * Use plain SQL dump as the back up format
+ */
+const BACKUP_DATA_FORMAT_SQL = exports.BACKUP_DATA_FORMAT_SQL = 'sql';
+
+/**
+ * Use sqlite3 dump as the back up format (default binary backup)
+ */
+const BACKUP_DATA_FORMAT_DUMP = exports.BACKUP_DATA_FORMAT_DUMP = 'dump';
+//# sourceMappingURL=backup-formats.js.map

package/lib/api/backup-formats.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"backup-formats.js","names":["BACKUP_DATA_FORMAT_SQL","exports","BACKUP_DATA_FORMAT_DUMP"],"sources":["../../es6/api/backup-formats.js"],"sourcesContent":["/**\n * RQLite backup data format constants\n * @module api/backup-formats\n * @see https://rqlite.io/docs/guides/backup/\n */\n\n/**\n * Use plain SQL dump as the back up format\n */\nexport const BACKUP_DATA_FORMAT_SQL = 'sql'\n\n/**\n * Use sqlite3 dump as the back up format (default binary backup)\n */\nexport const BACKUP_DATA_FORMAT_DUMP = 'dump'\n"],"mappings":"sJAAA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACO,MAAMA,sBAAsB,GAAAC,OAAA,CAAAD,sBAAA,GAAG,KAAK;;AAE3C;AACA;AACA;AACO,MAAME,uBAAuB,GAAAD,OAAA,CAAAC,uBAAA,GAAG,MAAM","ignoreList":[]}