rqlite-js 2.6.0 → 3.0.0

package/dist/index.js

@@ -0,0 +1,865 @@
+import { Readable } from "node:stream";
+
+//#region src/http-request/http-methods.ts
+/**
+* Http methods
+* @module http-request/http-methods
+*/
+const HTTP_METHOD_DELETE = "DELETE";
+const HTTP_METHOD_GET = "GET";
+const HTTP_METHOD_HEAD = "HEAD";
+const HTTP_METHOD_OPTIONS = "OPTIONS";
+const HTTP_METHOD_PATCH = "PATCH";
+const HTTP_METHOD_POST = "POST";
+const HTTP_METHOD_PUT = "PUT";
+
+//#endregion
+//#region src/http-request/content-types.ts
+const CONTENT_TYPE_TEXT_PLAIN = "text/plain";
+const CONTENT_TYPE_APPLICATION_JSON = "application/json";
+const CONTENT_TYPE_APPLICATION_OCTET_STREAM = "application/octet-stream";
+
+//#endregion
+//#region src/http-request/errors.ts
+/**
+* Http request errors
+* @module http-request/errors
+*/
+/**
+* Error when max redirect attempts have been reached
+*/
+var ERROR_HTTP_REQUEST_MAX_REDIRECTS = class extends Error {
+	code;
+	constructor(...args) {
+		super(...args);
+		this.name = this.constructor.name;
+		this.code = this.constructor.name;
+	}
+};
+
+//#endregion
+//#region src/http-request/retryable.ts
+/**
+* Error codes which can be retried
+*/
+const RETRYABLE_ERROR_CODES = new Set([
+	"EADDRINUSE",
+	"EAI_AGAIN",
+	"ECONNREFUSED",
+	"ECONNRESET",
+	"ENETUNREACH",
+	"ENOTFOUND",
+	"EPIPE",
+	"ETIMEDOUT"
+]);
+/**
+* HTTP status codes which can be retried
+*/
+const RETRYABLE_STATUS_CODES = new Set([
+	408,
+	413,
+	429,
+	500,
+	502,
+	503,
+	504,
+	521,
+	522,
+	524
+]);
+/**
+* HTTP methods which can be retried
+*/
+const RETRYABLE_HTTP_METHODS = new Set([
+	HTTP_METHOD_DELETE,
+	HTTP_METHOD_GET,
+	HTTP_METHOD_HEAD,
+	HTTP_METHOD_OPTIONS,
+	HTTP_METHOD_PATCH,
+	HTTP_METHOD_POST,
+	HTTP_METHOD_PUT
+]);
+
+//#endregion
+//#region src/http-request/auth-keys.ts
+/**
+* Authentication Map key constants
+* @module http-request/auth-keys
+*/
+/**
+* Username key for authentication
+*/
+const AUTH_USERNAME = "username";
+/**
+* Password key for authentication
+*/
+const AUTH_PASSWORD = "password";
+
+//#endregion
+//#region src/http-request/http-headers.ts
+/**
+* HTTP header name constants used by RQLite clients
+* @module http-request/http-headers
+*/
+/**
+* Accept request header
+*/
+const HTTP_HEADER_ACCEPT = "Accept";
+/**
+* Content-Type request header
+*/
+const HTTP_HEADER_CONTENT_TYPE = "Content-Type";
+/**
+* Location response header (redirects)
+*/
+const HTTP_HEADER_LOCATION = "Location";
+
+//#endregion
+//#region src/http-request/index.ts
+/**
+* The default timeout value
+*/
+const DEAULT_TIMEOUT = 3e4;
+/**
+* Create default header for all HTTP requests
+*/
+function createDefaultHeaders(headers = {}) {
+	const accept = headers[HTTP_HEADER_ACCEPT] || CONTENT_TYPE_APPLICATION_JSON;
+	return {
+		...headers,
+		[HTTP_HEADER_ACCEPT]: accept
+	};
+}
+/**
+* Clean the request path remove / from the beginning
+*/
+function cleanPath(path) {
+	return String(path).replace(/^\//, "");
+}
+/**
+* Serialize query params similar to qs arrayFormat: 'brackets'
+*/
+function stringifyQuery(params = {}) {
+	const search = new URLSearchParams();
+	Object.entries(params).forEach(([key, value]) => {
+		if (typeof value === "undefined") return;
+		if (Array.isArray(value)) {
+			value.forEach((entry) => {
+				search.append(`${key}[]`, String(entry));
+			});
+			return;
+		}
+		search.append(key, String(value));
+	});
+	return search.toString();
+}
+function basicAuthHeader(username, password) {
+	return `Basic ${Buffer.from(`${username}:${password}`).toString("base64")}`;
+}
+function getErrorCode(error) {
+	if (!error || typeof error !== "object") return;
+	const err = error;
+	if (typeof err.code === "string") return err.code;
+	if (err.cause && typeof err.cause.code === "string") return err.cause.code;
+	if (err.name === "AbortError" || err.name === "TimeoutError") return "ETIMEDOUT";
+}
+/**
+* Returns the next wait interval, in milliseconds, using an exponential
+* backoff algorithm.
+*/
+function getWaitTimeExponential(attempt = 0, base = 100, exponent = 2) {
+	if (attempt === 0) return 0;
+	return exponent ** attempt * base;
+}
+/**
+* Generic HTTP Request class which all RQLiteJS clients should extend
+*/
+var HttpRequest = class {
+	activeHostIndex = 0;
+	activeHostRoundRobin = true;
+	absoluteUriPattern = /^https?:\/\//;
+	hosts = [];
+	httpAgent;
+	httpsAgent;
+	leaderHostIndex = 0;
+	retryableErrorCodes = RETRYABLE_ERROR_CODES;
+	retryableStatusCodes = RETRYABLE_STATUS_CODES;
+	retryableHttpMethods = RETRYABLE_HTTP_METHODS;
+	exponentailBackoffBase = 100;
+	exponentailBackoffExponent = 1.1;
+	authentication = /* @__PURE__ */ new Map();
+	constructor(hosts, options = {}) {
+		this.setHosts(hosts);
+		if (this.getTotalHosts() === 0) throw new Error("At least one host must be provided");
+		const { activeHostRoundRobin = true, httpAgent, httpsAgent, retryableErrorCodes, retryableStatusCodes, retryableHttpMethods, exponentailBackoffExponent, exponentailBackoffBase, authentication } = options;
+		if (typeof authentication === "object") {
+			const { username, password } = authentication;
+			if (username) this.authentication.set(AUTH_USERNAME, username);
+			if (password) this.authentication.set(AUTH_PASSWORD, password);
+		}
+		if (typeof activeHostRoundRobin !== "undefined") this.setActiveHostRoundRobin(activeHostRoundRobin);
+		if (typeof httpAgent !== "undefined") this.setHttpAgent(httpAgent);
+		if (typeof httpsAgent !== "undefined") this.setHttpsAgent(httpsAgent);
+		if (retryableErrorCodes instanceof Set || Array.isArray(retryableErrorCodes)) this.setRetryableErrorCodes(Array.isArray(retryableErrorCodes) ? new Set(retryableErrorCodes) : retryableErrorCodes);
+		if (retryableStatusCodes instanceof Set || Array.isArray(retryableStatusCodes)) this.setRetryableStatusCodes(Array.isArray(retryableStatusCodes) ? new Set(retryableStatusCodes) : retryableStatusCodes);
+		if (retryableHttpMethods instanceof Set || Array.isArray(retryableHttpMethods)) this.setRetryableHttpMethods(Array.isArray(retryableHttpMethods) ? new Set(retryableHttpMethods) : retryableHttpMethods);
+		if (Number.isFinite(exponentailBackoffBase)) this.setExponentailBackoffBase(exponentailBackoffBase);
+		if (Number.isFinite(exponentailBackoffExponent)) this.setExponentailBackoffExponent(exponentailBackoffExponent);
+	}
+	setAuthentication(authentication = {}) {
+		const { username, password } = authentication;
+		if (username) this.authentication.set(AUTH_USERNAME, username);
+		if (password) this.authentication.set(AUTH_PASSWORD, password);
+	}
+	setExponentailBackoffBase(exponentailBackoffBase) {
+		this.exponentailBackoffBase = exponentailBackoffBase;
+	}
+	getExponentailBackoffBase() {
+		return this.exponentailBackoffBase;
+	}
+	setExponentailBackoffExponent(exponentailBackoffExponent) {
+		this.exponentailBackoffExponent = exponentailBackoffExponent;
+	}
+	getExponentailBackoffExponent() {
+		return this.exponentailBackoffExponent;
+	}
+	setRetryableErrorCodes(retryableErrorCodes) {
+		this.retryableErrorCodes = retryableErrorCodes;
+	}
+	getRetryableErrorCodes() {
+		return this.retryableErrorCodes;
+	}
+	setRetryableStatusCodes(retryableStatusCodes) {
+		this.retryableStatusCodes = retryableStatusCodes;
+	}
+	getRetryableStatusCodes() {
+		return this.retryableStatusCodes;
+	}
+	setRetryableHttpMethods(retryableHttpMethods) {
+		this.retryableHttpMethods = retryableHttpMethods;
+	}
+	getRetryableHttpMethods() {
+		return this.retryableHttpMethods;
+	}
+	setHttpAgent(httpAgent) {
+		this.httpAgent = httpAgent;
+	}
+	getHttpAgent() {
+		return this.httpAgent;
+	}
+	setHttpsAgent(httpsAgent) {
+		this.httpsAgent = httpsAgent;
+	}
+	getHttpsAgent() {
+		return this.httpsAgent;
+	}
+	setHosts(hosts) {
+		this.hosts = (!Array.isArray(hosts) ? String(hosts).split(",") : hosts).reduce((acc, v) => {
+			const host = String(v).trim().replace(/\/$/, "");
+			if (!host) return acc;
+			return acc.concat(host);
+		}, []);
+	}
+	getHosts() {
+		return this.hosts;
+	}
+	findHostIndex(host) {
+		let parsedHostToFind;
+		try {
+			parsedHostToFind = new URL(host);
+		} catch {
+			return -1;
+		}
+		return this.getHosts().findIndex((v) => {
+			try {
+				const parsedHost = new URL(v);
+				return [
+					"hostname",
+					"protocol",
+					"port",
+					"pathname"
+				].every((field) => parsedHostToFind[field] === parsedHost[field]);
+			} catch {
+				return false;
+			}
+		});
+	}
+	getActiveHost(useLeader) {
+		const activeHostIndex = useLeader ? this.getLeaderHostIndex() : this.getActiveHostIndex();
+		return this.getHosts()[activeHostIndex];
+	}
+	setActiveHostIndex(activeHostIndex) {
+		if (!Number.isFinite(activeHostIndex)) throw new Error("The activeHostIndex should be a finite number");
+		const totalHosts = this.getTotalHosts();
+		if (activeHostIndex < 0) this.activeHostIndex = 0;
+		else if (activeHostIndex >= totalHosts) this.activeHostIndex = totalHosts - 1;
+		else this.activeHostIndex = activeHostIndex;
+		return this.activeHostIndex;
+	}
+	getLeaderHostIndex() {
+		return this.leaderHostIndex;
+	}
+	setLeaderHostIndex(leaderHostIndex) {
+		if (!Number.isFinite(leaderHostIndex)) throw new Error("The leaderHostIndex should be a finite number");
+		const totalHosts = this.getTotalHosts();
+		if (leaderHostIndex < 0) this.leaderHostIndex = 0;
+		else if (leaderHostIndex > totalHosts) this.leaderHostIndex = totalHosts - 1;
+		else this.leaderHostIndex = leaderHostIndex;
+		return this.leaderHostIndex;
+	}
+	getActiveHostIndex() {
+		return this.activeHostIndex;
+	}
+	setActiveHostRoundRobin(activeHostRoundRobin) {
+		if (typeof activeHostRoundRobin !== "boolean") throw new Error("The activeHostRoundRobin argument must be boolean");
+		this.activeHostRoundRobin = activeHostRoundRobin;
+	}
+	getActiveHostRoundRobin() {
+		return this.activeHostRoundRobin;
+	}
+	getNextActiveHostIndex(activeHostIndex = this.getActiveHostIndex()) {
+		const totalHosts = this.getTotalHosts();
+		const nextIndex = activeHostIndex + 1;
+		if (totalHosts === nextIndex) return 0;
+		return nextIndex;
+	}
+	setNextActiveHostIndex() {
+		if (!this.getActiveHostRoundRobin()) return;
+		const totalHosts = this.getTotalHosts();
+		if (this.getActiveHostRoundRobin() && totalHosts <= 1) return;
+		this.setActiveHostIndex(this.getNextActiveHostIndex());
+	}
+	getTotalHosts() {
+		return this.getHosts().length;
+	}
+	uriIsAbsolute(uri) {
+		return this.absoluteUriPattern.test(uri);
+	}
+	requestIsRetryable(options = {}) {
+		const { statusCode, errorCode, httpMethod } = options;
+		if (!httpMethod || !this.getRetryableHttpMethods().has(httpMethod)) return false;
+		if (statusCode && this.getRetryableStatusCodes().has(statusCode)) return true;
+		if (errorCode && this.getRetryableErrorCodes().has(errorCode)) return true;
+		return false;
+	}
+	/**
+	* Perform an HTTP request using the provided options
+	*/
+	async fetch(options = {}) {
+		const { body, headers = {}, httpMethod = HTTP_METHOD_GET, query, stream = false, timeout = DEAULT_TIMEOUT, useLeader = false, retries = this.getTotalHosts() * 3, maxRedirects = 10, attempt = 0, retryAttempt = 0, redirectAttempt = 0, attemptHostIndex, exponentailBackoffExponent = this.getExponentailBackoffExponent(), exponentailBackoffBase = this.getExponentailBackoffBase(), httpAgent = this.getHttpAgent(), httpsAgent = this.getHttpsAgent() } = options;
+		const activeHost = Number.isFinite(attemptHostIndex) ? this.getHosts()[attemptHostIndex] : this.getActiveHost(useLeader);
+		let { uri } = options;
+		if (!uri) throw new Error("The uri option is required");
+		uri = this.uriIsAbsolute(uri) ? uri : `${activeHost}/${cleanPath(uri)}`;
+		const requestHeaders = createDefaultHeaders(headers);
+		if (this.authentication.size) requestHeaders.Authorization = basicAuthHeader(this.authentication.get(AUTH_USERNAME) || "", this.authentication.get(AUTH_PASSWORD) || "");
+		const url = new URL(uri);
+		if (query && typeof query === "object") {
+			const serialized = stringifyQuery(query);
+			if (serialized) url.search = serialized;
+		}
+		const controller = new AbortController();
+		const timeoutId = setTimeout(() => controller.abort(), timeout);
+		const fetchInit = {
+			method: httpMethod,
+			headers: requestHeaders,
+			redirect: "manual",
+			signal: controller.signal
+		};
+		const agent = url.protocol === "https:" ? httpsAgent : httpAgent;
+		if (agent && typeof agent.dispatch === "function") {
+			const init = fetchInit;
+			init.dispatcher = agent;
+		}
+		if (typeof body !== "undefined" && body !== null) if (Buffer.isBuffer(body) || typeof body === "string") fetchInit.body = body;
+		else {
+			fetchInit.body = JSON.stringify(body);
+			if (!requestHeaders[HTTP_HEADER_ACCEPT]) requestHeaders[HTTP_HEADER_ACCEPT] = CONTENT_TYPE_APPLICATION_JSON;
+			if (!(HTTP_HEADER_CONTENT_TYPE in requestHeaders) && !Object.keys(requestHeaders).some((k) => k.toLowerCase() === "content-type")) requestHeaders[HTTP_HEADER_CONTENT_TYPE] = CONTENT_TYPE_APPLICATION_JSON;
+			fetchInit.headers = requestHeaders;
+		}
+		const retryOrRedirect = async (responseStatus, responseHeaders, errorCode, error) => {
+			const retryable = this.requestIsRetryable({
+				statusCode: responseStatus,
+				errorCode,
+				httpMethod
+			});
+			let nextAttemptHostIndex = Number.isFinite(attemptHostIndex) ? attemptHostIndex : this.getActiveHostIndex();
+			nextAttemptHostIndex += 1;
+			if (nextAttemptHostIndex === this.getTotalHosts()) nextAttemptHostIndex = 0;
+			if (responseStatus === 301 || responseStatus === 302) {
+				if (redirectAttempt >= maxRedirects) throw new ERROR_HTTP_REQUEST_MAX_REDIRECTS(`The maximum number of redirects ${maxRedirects} has been reached`);
+				let location;
+				if (responseHeaders && typeof responseHeaders.get === "function") location = responseHeaders.get(HTTP_HEADER_LOCATION) || responseHeaders.get(HTTP_HEADER_LOCATION.toLowerCase()) || void 0;
+				else if (responseHeaders && typeof responseHeaders === "object") {
+					const headerMap = responseHeaders;
+					location = headerMap[HTTP_HEADER_LOCATION.toLowerCase()] || headerMap[HTTP_HEADER_LOCATION];
+				}
+				if (useLeader && location) {
+					const newLeaderHostIndex = this.findHostIndex(location);
+					if (newLeaderHostIndex > -1) this.setLeaderHostIndex(newLeaderHostIndex);
+				}
+				return this.fetch({
+					...options,
+					uri: location,
+					attempt: attempt + 1,
+					redirectAttempt: redirectAttempt + 1,
+					attemptHostIndex: nextAttemptHostIndex
+				});
+			}
+			if (retryable && retryAttempt < retries) {
+				const waitTime = getWaitTimeExponential(retryAttempt, exponentailBackoffBase, exponentailBackoffExponent);
+				await new Promise((resolve) => {
+					setTimeout(() => resolve(), waitTime);
+				});
+				return this.fetch({
+					...options,
+					attempt: attempt + 1,
+					retryAttempt: retryAttempt + 1,
+					attemptHostIndex: nextAttemptHostIndex
+				});
+			}
+			if (error instanceof Error) throw error;
+			const wrapped = new Error(error?.message || String(error));
+			Object.assign(wrapped, error);
+			throw wrapped;
+		};
+		try {
+			const response = await fetch(url, fetchInit);
+			clearTimeout(timeoutId);
+			if (response.status === 301 || response.status === 302) return retryOrRedirect(response.status, response.headers, void 0, /* @__PURE__ */ new Error(`Redirect ${response.status}`));
+			if (response.status >= 400) return retryOrRedirect(response.status, response.headers, void 0, Object.assign(/* @__PURE__ */ new Error(`HTTP ${response.status}`), { response: {
+				status: response.status,
+				headers: Object.fromEntries(response.headers.entries())
+			} }));
+			if (stream) {
+				if (!response.body) return Readable.from([]);
+				return Readable.fromWeb(response.body);
+			}
+			const contentType = response.headers.get("content-type") || "";
+			let responseBody;
+			if (contentType.includes("application/json")) responseBody = await response.json();
+			else responseBody = await response.text();
+			return {
+				body: responseBody,
+				status: response.status
+			};
+		} catch (e) {
+			clearTimeout(timeoutId);
+			const errorCode = getErrorCode(e);
+			const err = e;
+			const responseStatus = err.response?.status;
+			const responseHeaders = err.response?.headers;
+			return retryOrRedirect(responseStatus, responseHeaders, errorCode, e);
+		}
+	}
+	async get(...args) {
+		const options = args[0] || {};
+		return this.fetch({
+			...options,
+			httpMethod: HTTP_METHOD_GET
+		});
+	}
+	async post(...args) {
+		const options = args[0] || {};
+		return this.fetch({
+			...options,
+			httpMethod: HTTP_METHOD_POST
+		});
+	}
+};
+
+//#endregion
+//#region src/api/query-params.ts
+/**
+* RQLite HTTP query parameter name constants
+* @module api/query-params
+* @see https://rqlite.io/docs/api/api/
+* @see https://rqlite.io/docs/api/read-consistency/
+* @see https://rqlite.io/docs/guides/backup/
+*/
+const QUERY_PARAM_LEVEL = "level";
+const QUERY_PARAM_PRETTY = "pretty";
+const QUERY_PARAM_TIMINGS = "timings";
+const QUERY_PARAM_ATOMIC = "atomic";
+const QUERY_PARAM_TRANSACTION = "transaction";
+const QUERY_PARAM_Q = "q";
+const QUERY_PARAM_FMT = "fmt";
+
+//#endregion
+//#region src/api/client/index.ts
+/**
+* Create the base HTTP query options from RQLite API options
+* @see https://rqlite.io/docs/api/api/
+* @see module:api/query-params
+*/
+function createQuery(options = {}) {
+	const { level, pretty, timings, atomic, transaction } = options;
+	const query = {
+		[QUERY_PARAM_LEVEL]: level,
+		[QUERY_PARAM_PRETTY]: pretty,
+		[QUERY_PARAM_TIMINGS]: timings,
+		[QUERY_PARAM_ATOMIC]: atomic,
+		[QUERY_PARAM_TRANSACTION]: transaction
+	};
+	return Object.entries(query).reduce((acc, entry) => {
+		const [key, val] = entry;
+		if (typeof val !== "undefined") acc[key] = val;
+		return acc;
+	}, {});
+}
+/**
+* Base API client for RQLite which abstracts the HTTP calls from the user
+*/
+var ApiClient = class extends HttpRequest {
+	/**
+	* Perform a RQLite data API get request
+	* @see https://rqlite.io/docs/api/api/
+	*/
+	async get(...args) {
+		const path = args[0];
+		const sql = args[1];
+		const options = args[2] || {};
+		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),
+				[QUERY_PARAM_Q]: sql
+			}
+		});
+	}
+	/**
+	* Perform a RQLite data API post request
+	* @see https://rqlite.io/docs/api/api/
+	*/
+	async post(...args) {
+		const path = args[0];
+		const sql = args[1];
+		const options = args[2] || {};
+		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]
+		});
+	}
+};
+
+//#endregion
+//#region src/api/results/result-fields.ts
+/**
+* RQLite JSON response field name constants
+* @module api/results/result-fields
+* @see https://rqlite.io/docs/api/api/
+*/
+const RESULT_FIELD_TIME = "time";
+const RESULT_FIELD_ROWS_AFFECTED = "rows_affected";
+const RESULT_FIELD_LAST_INSERT_ID = "last_insert_id";
+const RESULT_FIELD_COLUMNS = "columns";
+const RESULT_FIELD_VALUES = "values";
+const RESULT_FIELD_ERROR = "error";
+const RESULT_FIELD_ERROR_V2 = "error_v2";
+const RESULT_FIELD_RESULTS = "results";
+
+//#endregion
+//#region src/api/results/data-result.ts
+/**
+* A class that represents one data result from an RQLite query or execute API call
+* @see https://rqlite.io/docs/api/api/
+*/
+var DataResult = class {
+	time = 0;
+	lastInsertId;
+	rowsAffected = 0;
+	data = {};
+	constructor(result, valuesIndex) {
+		if (typeof result !== "object" || result === null) 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(String(result[RESULT_FIELD_TIME] || 0));
+		this.rowsAffected = parseInt(String(result[RESULT_FIELD_ROWS_AFFECTED] || 0), 10);
+		this.lastInsertId = result[RESULT_FIELD_LAST_INSERT_ID];
+		if (Number.isFinite(valuesIndex)) {
+			const columns = result[RESULT_FIELD_COLUMNS];
+			const resultValues = result[RESULT_FIELD_VALUES][valuesIndex];
+			if (resultValues) this.data = resultValues.reduce((acc, val, i) => {
+				const col = columns[i];
+				acc[col] = val;
+				return acc;
+			}, {});
+		}
+	}
+	get(property) {
+		return this.data[property];
+	}
+	getTime() {
+		return this.time;
+	}
+	getLastInsertId() {
+		return this.lastInsertId;
+	}
+	getRowsAffected() {
+		return this.rowsAffected;
+	}
+	toObject() {
+		return JSON.parse(JSON.stringify(this.data));
+	}
+	toArray() {
+		return Object.values(this.data);
+	}
+	toColumnsArray() {
+		return Object.keys(this.data);
+	}
+	toString() {
+		return JSON.stringify(this.data);
+	}
+};
+
+//#endregion
+//#region src/api/results/data-result-error.ts
+/**
+* A class that represents one data error result from an RQLite query or execute API call
+* @see https://rqlite.io/docs/api/api/
+*/
+var DataResultError = class extends Error {
+	code;
+	errorV2;
+	constructor(message, errorV2) {
+		super(message);
+		this.name = this.constructor.name;
+		this.code = this.constructor.name;
+		if (errorV2) this.errorV2 = errorV2;
+	}
+	getErrorV2() {
+		return this.errorV2;
+	}
+	toObject() {
+		const obj = { [RESULT_FIELD_ERROR]: this.message };
+		if (this.errorV2) obj[RESULT_FIELD_ERROR_V2] = this.errorV2;
+		return obj;
+	}
+	toString() {
+		return JSON.stringify(this.toObject());
+	}
+};
+
+//#endregion
+//#region src/api/results/data-results.ts
+/**
+* A class to manage a list of results from an RQLite query or execute API response
+* @see https://rqlite.io/docs/api/api/
+*/
+var DataResults = class {
+	time = 0;
+	results = [];
+	constructor(data) {
+		this.setApiData(data);
+	}
+	setApiData(data) {
+		if (typeof data !== "object" || data === null) throw new Error("The data argument is required to be an object");
+		if (!data[RESULT_FIELD_RESULTS]) throw new Error("The data object is required to have a results property");
+		this.time = parseFloat(String(data[RESULT_FIELD_TIME] || 0));
+		this.results = (data[RESULT_FIELD_RESULTS] || []).reduce((acc, result) => {
+			if (typeof result === "object" && result !== null && result[RESULT_FIELD_ERROR]) return acc.concat(new DataResultError(String(result[RESULT_FIELD_ERROR]), result[RESULT_FIELD_ERROR_V2]));
+			const vals = result[RESULT_FIELD_VALUES];
+			if (!vals) return acc.concat(new DataResult(result));
+			const dataResults = vals.map((_v, valuesIndex) => new DataResult(result, valuesIndex));
+			return acc.concat(dataResults);
+		}, []);
+	}
+	hasError() {
+		return !!this.getFirstError();
+	}
+	getFirstError() {
+		return this.results.find((v) => v instanceof DataResultError);
+	}
+	getTime() {
+		return this.time;
+	}
+	get(index) {
+		return this.results[index];
+	}
+	getResults() {
+		return this.results;
+	}
+	toArray() {
+		return this.results.map((result) => result.toObject());
+	}
+	toString() {
+		const list = this.results.map((result) => result.toObject());
+		return JSON.stringify(list);
+	}
+};
+
+//#endregion
+//#region src/api/paths.ts
+/**
+* RQLite HTTP API path constants
+* @module api/paths
+* @see https://rqlite.io/docs/api/api/
+* @see https://rqlite.io/docs/guides/backup/
+* @see https://rqlite.io/docs/guides/monitoring-rqlite/
+*/
+const PATH_QUERY = "/db/query";
+const PATH_EXECUTE = "/db/execute";
+const PATH_LOAD = "/db/load";
+const PATH_BACKUP = "/db/backup";
+const PATH_STATUS = "/status";
+
+//#endregion
+//#region src/api/consistency-levels.ts
+/**
+* RQLite read consistency level constants
+* @module api/consistency-levels
+* @see https://rqlite.io/docs/api/read-consistency/
+*/
+const CONSISTENCY_LEVEL_NONE = "none";
+const CONSISTENCY_LEVEL_STRONG = "strong";
+const CONSISTENCY_LEVEL_LINEARIZABLE = "linearizable";
+const CONSISTENCY_LEVEL_WEAK = "weak";
+
+//#endregion
+//#region src/api/data/index.ts
+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
+*/
+var DataApiClient = class extends ApiClient {
+	/**
+	* Send an RQLite query API request to the RQLite server
+	* @see https://rqlite.io/docs/api/api/
+	* @see https://rqlite.io/docs/api/read-consistency/
+	*/
+	async query(sql, options = {}) {
+		const { level } = options;
+		let { useLeader } = options;
+		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 (!useLeader) this.setNextActiveHostIndex();
+		return handleResponse(response, options);
+	}
+	/**
+	* Send an RQLite execute API request to the RQLite server
+	* @see https://rqlite.io/docs/api/api/
+	*/
+	async execute(sql, options = {}) {
+		return handleResponse(await super.post(PATH_EXECUTE, sql, options), options);
+	}
+};
+
+//#endregion
+//#region src/api/backup-formats.ts
+/**
+* RQLite backup data format constants
+* @module api/backup-formats
+* @see https://rqlite.io/docs/guides/backup/
+*/
+const BACKUP_DATA_FORMAT_SQL = "sql";
+const BACKUP_DATA_FORMAT_DUMP = "dump";
+
+//#endregion
+//#region src/api/backup/index.ts
+/**
+* Backup api client to perform RQLite back up and load operations
+*/
+var BackupApiClient = class extends HttpRequest {
+	/**
+	* Perform a SQL dump backup from the RQLite server
+	* @see https://rqlite.io/docs/guides/backup/
+	* @see module:api/backup-formats
+	*/
+	async backup(format = BACKUP_DATA_FORMAT_DUMP) {
+		return super.get({
+			headers: { [HTTP_HEADER_ACCEPT]: CONTENT_TYPE_APPLICATION_OCTET_STREAM },
+			query: { [QUERY_PARAM_FMT]: format === BACKUP_DATA_FORMAT_SQL ? format : void 0 },
+			json: false,
+			stream: true,
+			uri: PATH_BACKUP,
+			useLeader: true
+		});
+	}
+	/**
+	* Perform a SQL restore by sending data the RQLite server
+	* @see https://rqlite.io/docs/guides/backup/
+	* @see module:api/backup-formats
+	*/
+	async load(data, format = BACKUP_DATA_FORMAT_SQL) {
+		return super.post({
+			body: data,
+			headers: { [HTTP_HEADER_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
+		});
+	}
+};
+
+//#endregion
+//#region src/api/status/index.ts
+/**
+* Data api client to perform RQLite status queries
+*/
+var StatusApiClient = class extends ApiClient {
+	/**
+	* Get the RQLite server status which defaults to the leader host
+	* @see https://rqlite.io/docs/guides/monitoring-rqlite/
+	*/
+	async status(options = {}) {
+		return this.fetch({
+			...options,
+			uri: PATH_STATUS,
+			httpMethod: HTTP_METHOD_GET,
+			useLeader: typeof options.useLeader === "boolean" ? options.useLeader : true
+		});
+	}
+	/**
+	* Get the RQLite server status for all hosts
+	* @see https://rqlite.io/docs/guides/monitoring-rqlite/
+	*/
+	async statusAllHosts(options = {}) {
+		const hosts = this.getHosts();
+		const promises = hosts.map(async (_host, attemptHostIndex) => {
+			return {
+				response: await this.status({
+					...options,
+					useLeader: false,
+					attemptHostIndex
+				}),
+				host: hosts[attemptHostIndex]
+			};
+		});
+		return Promise.all(promises);
+	}
+};
+
+//#endregion
+//#region src/index.ts
+var src_default = {
+	DataApiClient,
+	BackupApiClient,
+	StatusApiClient
+};
+
+//#endregion
+export { BACKUP_DATA_FORMAT_DUMP, BACKUP_DATA_FORMAT_SQL, BackupApiClient, CONSISTENCY_LEVEL_LINEARIZABLE, CONSISTENCY_LEVEL_NONE, CONSISTENCY_LEVEL_STRONG, CONSISTENCY_LEVEL_WEAK, DataApiClient, PATH_BACKUP, PATH_EXECUTE, PATH_LOAD, PATH_QUERY, PATH_STATUS, StatusApiClient, src_default as default };
+//# sourceMappingURL=index.js.map