rqlite-js 2.6.0 → 3.0.0

package/dist/index.d.ts

@@ -0,0 +1,329 @@
+import { Readable } from "node:stream";
+import { Agent } from "node:http";
+import { Agent as Agent$1 } from "node:https";
+
+//#region src/http-request/index.d.ts
+
+type HttpAuthentication = {
+  username?: string;
+  password?: string;
+};
+type HttpRequestOptions = {
+  auth?: HttpAuthentication;
+  body?: unknown;
+  headers?: Record<string, string>;
+  httpMethod?: string;
+  query?: Record<string, unknown>;
+  stream?: boolean;
+  timeout?: number;
+  uri?: string;
+  useLeader?: boolean;
+  retries?: number;
+  maxRedirects?: number;
+  attempt?: number;
+  retryAttempt?: number;
+  redirectAttempt?: number;
+  attemptHostIndex?: number;
+  exponentailBackoffBase?: number;
+  exponentailBackoffExponent?: number;
+  json?: boolean;
+  httpAgent?: Agent | DispatcherLike;
+  httpsAgent?: Agent$1 | DispatcherLike;
+};
+/** Minimal undici/Node fetch dispatcher shape */
+type DispatcherLike = {
+  dispatch?: (...args: unknown[]) => unknown;
+  close?: () => Promise<void>;
+  destroy?: () => Promise<void>;
+};
+type HttpResponse = {
+  status: number;
+  body: unknown;
+};
+type HttpRequestConstructorOptions = {
+  authentication?: HttpAuthentication;
+  activeHostRoundRobin?: boolean;
+  httpAgent?: Agent | DispatcherLike;
+  httpsAgent?: Agent$1 | DispatcherLike;
+  retryableErrorCodes?: Set<string> | string[];
+  retryableStatusCodes?: Set<number> | number[];
+  retryableHttpMethods?: Set<string> | string[];
+  exponentailBackoffBase?: number;
+  exponentailBackoffExponent?: number;
+};
+/**
+ * Generic HTTP Request class which all RQLiteJS clients should extend
+ */
+declare class HttpRequest {
+  activeHostIndex: number;
+  activeHostRoundRobin: boolean;
+  absoluteUriPattern: RegExp;
+  hosts: string[];
+  httpAgent?: Agent | DispatcherLike;
+  httpsAgent?: Agent$1 | DispatcherLike;
+  leaderHostIndex: number;
+  retryableErrorCodes: Set<string>;
+  retryableStatusCodes: Set<number>;
+  retryableHttpMethods: Set<string>;
+  exponentailBackoffBase: number;
+  exponentailBackoffExponent: number;
+  authentication: Map<string, string>;
+  constructor(hosts: string[] | string, options?: HttpRequestConstructorOptions);
+  setAuthentication(authentication?: HttpAuthentication): void;
+  setExponentailBackoffBase(exponentailBackoffBase: number): void;
+  getExponentailBackoffBase(): number;
+  setExponentailBackoffExponent(exponentailBackoffExponent: number): void;
+  getExponentailBackoffExponent(): number;
+  setRetryableErrorCodes(retryableErrorCodes: Set<string>): void;
+  getRetryableErrorCodes(): Set<string>;
+  setRetryableStatusCodes(retryableStatusCodes: Set<number>): void;
+  getRetryableStatusCodes(): Set<number>;
+  setRetryableHttpMethods(retryableHttpMethods: Set<string>): void;
+  getRetryableHttpMethods(): Set<string>;
+  setHttpAgent(httpAgent: Agent | DispatcherLike): void;
+  getHttpAgent(): Agent | DispatcherLike | undefined;
+  setHttpsAgent(httpsAgent: Agent$1 | DispatcherLike): void;
+  getHttpsAgent(): Agent$1 | DispatcherLike | undefined;
+  setHosts(hosts: string[] | string): void;
+  getHosts(): string[];
+  findHostIndex(host: string): number;
+  getActiveHost(useLeader?: boolean): string;
+  setActiveHostIndex(activeHostIndex: number): number;
+  getLeaderHostIndex(): number;
+  setLeaderHostIndex(leaderHostIndex: number): number;
+  getActiveHostIndex(): number;
+  setActiveHostRoundRobin(activeHostRoundRobin: boolean): void;
+  getActiveHostRoundRobin(): boolean;
+  getNextActiveHostIndex(activeHostIndex?: number): number;
+  setNextActiveHostIndex(): void;
+  getTotalHosts(): number;
+  uriIsAbsolute(uri: string): boolean;
+  requestIsRetryable(options?: {
+    statusCode?: number;
+    errorCode?: string;
+    httpMethod?: string;
+  }): boolean;
+  /**
+   * Perform an HTTP request using the provided options
+   */
+  fetch(options?: HttpRequestOptions): Promise<HttpResponse | Readable>;
+  get(...args: any[]): Promise<HttpResponse | Readable>;
+  post(...args: any[]): Promise<HttpResponse | Readable>;
+}
+//#endregion
+//#region src/api/client/index.d.ts
+type ApiClientRequestOptions = {
+  useLeader?: boolean;
+  level?: string;
+  pretty?: boolean;
+  timings?: boolean;
+  atomic?: boolean;
+  transaction?: boolean;
+  raw?: boolean;
+};
+/**
+ * Base API client for RQLite which abstracts the HTTP calls from the user
+ */
+declare class ApiClient extends HttpRequest {
+  /**
+   * Perform a RQLite data API get request
+   * @see https://rqlite.io/docs/api/api/
+   */
+  get(...args: any[]): Promise<HttpResponse>;
+  /**
+   * Perform a RQLite data API post request
+   * @see https://rqlite.io/docs/api/api/
+   */
+  post(...args: any[]): Promise<HttpResponse>;
+}
+//#endregion
+//#region src/api/results/result-fields.d.ts
+/**
+ * RQLite JSON response field name constants
+ * @module api/results/result-fields
+ * @see https://rqlite.io/docs/api/api/
+ */
+declare const RESULT_FIELD_TIME = "time";
+declare const RESULT_FIELD_ROWS_AFFECTED = "rows_affected";
+declare const RESULT_FIELD_LAST_INSERT_ID = "last_insert_id";
+declare const RESULT_FIELD_COLUMNS = "columns";
+declare const RESULT_FIELD_VALUES = "values";
+declare const RESULT_FIELD_RESULTS = "results";
+//#endregion
+//#region src/api/results/data-result.d.ts
+type RqliteSingleResult = {
+  [RESULT_FIELD_TIME]?: number | string;
+  [RESULT_FIELD_ROWS_AFFECTED]?: number | string;
+  [RESULT_FIELD_LAST_INSERT_ID]?: number;
+  [RESULT_FIELD_COLUMNS]?: string[];
+  [RESULT_FIELD_VALUES]?: unknown[][];
+  [key: string]: unknown;
+};
+/**
+ * A class that represents one data result from an RQLite query or execute API call
+ * @see https://rqlite.io/docs/api/api/
+ */
+declare class DataResult {
+  time: number;
+  lastInsertId?: number;
+  rowsAffected: number;
+  data: Record<string, unknown>;
+  constructor(result: RqliteSingleResult, valuesIndex?: number);
+  get(property: string): unknown;
+  getTime(): number;
+  getLastInsertId(): number | undefined;
+  getRowsAffected(): number;
+  toObject(): Record<string, unknown>;
+  toArray(): unknown[];
+  toColumnsArray(): string[];
+  toString(): string;
+}
+//#endregion
+//#region src/api/results/data-result-error.d.ts
+/**
+ * A class that represents one data error result from an RQLite query or execute API call
+ * @see https://rqlite.io/docs/api/api/
+ */
+declare class DataResultError extends Error {
+  code: string;
+  errorV2?: Record<string, unknown>;
+  constructor(message: string, errorV2?: Record<string, unknown>);
+  getErrorV2(): Record<string, unknown> | undefined;
+  toObject(): Record<string, unknown>;
+  toString(): string;
+}
+//#endregion
+//#region src/api/results/data-results.d.ts
+type RqliteApiData = {
+  [RESULT_FIELD_TIME]?: number | string;
+  [RESULT_FIELD_RESULTS]: RqliteSingleResult[];
+};
+/**
+ * A class to manage a list of results from an RQLite query or execute API response
+ * @see https://rqlite.io/docs/api/api/
+ */
+declare class DataResults {
+  time: number;
+  results: Array<DataResult | DataResultError>;
+  constructor(data: RqliteApiData);
+  setApiData(data: RqliteApiData): void;
+  hasError(): boolean;
+  getFirstError(): DataResultError | undefined;
+  getTime(): number;
+  get(index: number): DataResult | DataResultError | undefined;
+  getResults(): Array<DataResult | DataResultError>;
+  toArray(): Record<string, unknown>[];
+  toString(): string;
+}
+//#endregion
+//#region src/api/paths.d.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/
+ */
+declare const PATH_QUERY = "/db/query";
+declare const PATH_EXECUTE = "/db/execute";
+declare const PATH_LOAD = "/db/load";
+declare const PATH_BACKUP = "/db/backup";
+declare const PATH_STATUS = "/status";
+//#endregion
+//#region src/api/consistency-levels.d.ts
+/**
+ * RQLite read consistency level constants
+ * @module api/consistency-levels
+ * @see https://rqlite.io/docs/api/read-consistency/
+ */
+declare const CONSISTENCY_LEVEL_NONE = "none";
+declare const CONSISTENCY_LEVEL_STRONG = "strong";
+declare const CONSISTENCY_LEVEL_LINEARIZABLE = "linearizable";
+declare const CONSISTENCY_LEVEL_WEAK = "weak";
+//#endregion
+//#region src/api/data/index.d.ts
+type DataRequestBaseOptions = {
+  raw?: boolean;
+};
+type QueryRequestOptions = ApiClientRequestOptions & DataRequestBaseOptions;
+type ExecuteRequestOptions = ApiClientRequestOptions & DataRequestBaseOptions;
+/**
+ * Data api client to perform RQLite queries
+ */
+declare class DataApiClient 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/
+   */
+  query(sql: string | string[], options?: QueryRequestOptions): Promise<DataResults | HttpResponse>;
+  /**
+   * Send an RQLite execute API request to the RQLite server
+   * @see https://rqlite.io/docs/api/api/
+   */
+  execute(sql: string | string[], options?: ExecuteRequestOptions): Promise<DataResults | HttpResponse>;
+}
+//#endregion
+//#region src/api/backup-formats.d.ts
+/**
+ * RQLite backup data format constants
+ * @module api/backup-formats
+ * @see https://rqlite.io/docs/guides/backup/
+ */
+declare const BACKUP_DATA_FORMAT_SQL = "sql";
+declare const BACKUP_DATA_FORMAT_DUMP = "dump";
+//#endregion
+//#region src/api/backup/index.d.ts
+/**
+ * Backup api client to perform RQLite back up and load operations
+ */
+declare class BackupApiClient extends HttpRequest {
+  /**
+   * Perform a SQL dump backup from the RQLite server
+   * @see https://rqlite.io/docs/guides/backup/
+   * @see module:api/backup-formats
+   */
+  backup(format?: string): Promise<Readable>;
+  /**
+   * Perform a SQL restore by sending data the RQLite server
+   * @see https://rqlite.io/docs/guides/backup/
+   * @see module:api/backup-formats
+   */
+  load(data: Buffer | string, format?: string): Promise<Readable>;
+}
+//#endregion
+//#region src/api/status/index.d.ts
+type StatusRequestOptions = {
+  raw?: boolean;
+  attemptHostIndex?: number;
+  useLeader?: boolean;
+};
+type StatusAllHostsResponse = {
+  response: HttpResponse;
+  host: string;
+};
+/**
+ * Data api client to perform RQLite status queries
+ */
+declare class StatusApiClient extends ApiClient {
+  /**
+   * Get the RQLite server status which defaults to the leader host
+   * @see https://rqlite.io/docs/guides/monitoring-rqlite/
+   */
+  status(options?: StatusRequestOptions): Promise<HttpResponse>;
+  /**
+   * Get the RQLite server status for all hosts
+   * @see https://rqlite.io/docs/guides/monitoring-rqlite/
+   */
+  statusAllHosts(options?: StatusRequestOptions): Promise<StatusAllHostsResponse[]>;
+}
+//#endregion
+//#region src/index.d.ts
+declare const _default: {
+  DataApiClient: typeof DataApiClient;
+  BackupApiClient: typeof BackupApiClient;
+  StatusApiClient: typeof 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, _default as default };
+//# sourceMappingURL=index.d.ts.map