@sqlitecloud/drivers 0.0.34

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 SQLiteCloud, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,52 @@
+# sqlitecloud-js
+
+[![npm package][npm-img]][npm-url]
+[![Build Status][build-img]][build-url]
+[![Downloads][downloads-img]][downloads-url]
+[![Issues][issues-img]][issues-url]
+[![codecov](https://codecov.io/gh/sqlitecloud/sqlitecloud-js/graph/badge.svg?token=ZOKE9WFH62)](https://codecov.io/gh/sqlitecloud/sqlitecloud-js)
+
+## Install
+
+```bash
+npm install sqlitecloud-js
+```
+
+## Usage
+
+```ts
+import { Database } from 'sqlitecloud-js'
+
+let database = new Database('sqlitecloud://user:password@xxx.sqlite.cloud:8860/chinook.db')
+
+let name = 'Breaking The Rules'
+
+let results = await database.sql`SELECT * FROM tracks WHERE name = ${name}`
+// => returns [{ AlbumId: 1, Name: 'Breaking The Rules', Composer: 'Angus Young... }]
+```
+
+Use [Database.sql](https://sqlitecloud.github.io/sqlitecloud-js/classes/Database.html#sql) to execute prepared statements or plain SQL queries asynchronously. This method returns an array of rows for SELECT queries and supports the standard syntax for UPDATE, INSERT, and DELETE.
+
+We aim for full compatibility with the established [sqlite3 API](https://www.npmjs.com/package/sqlite3), with the primary distinction being that our driver connects to SQLiteCloud databases. This allows you to migrate your [SQLite to the cloud](https://sqlitecloud.io) while continuing to use your existing codebase.
+
+The package is developed entirely in TypeScript and is fully compatible with JavaScript. It doesn't require any native libraries. This makes it a straightforward and effective tool for managing cloud-based databases in a familiar SQLite environment.
+
+## More
+
+How do I deploy SQLite in the cloud?  
+[https://sqlitecloud.io](https://sqlitecloud.io)
+
+How do I connect SQLite cloud with Javascript?  
+[https://sqlitecloud.github.io/sqlitecloud-js/](https://sqlitecloud.github.io/sqlitecloud-js/)
+
+How can I contribute or suggest features?  
+[https://github.com/sqlitecloud/sqlitecloud-js/issues](https://github.com/sqlitecloud/sqlitecloud-js/issues)
+
+[build-img]: https://github.com/sqlitecloud/sqlitecloud-js/actions/workflows/build-test-deploy.yml/badge.svg
+[build-url]: https://github.com/sqlitecloud/sqlitecloud-js/actions/workflows/build-test-deploy.yml
+[downloads-img]: https://img.shields.io/npm/dt/sqlitecloud-js
+[downloads-url]: https://www.npmtrends.com/sqlitecloud-js
+[npm-img]: https://img.shields.io/npm/v/sqlitecloud-js
+[npm-url]: https://www.npmjs.com/package/sqlitecloud-js
+[issues-img]: https://img.shields.io/github/issues/sqlitecloud/sqlitecloud-js
+[issues-url]: https://github.com/sqlitecloud/sqlitecloud-js/issues

package/lib/connection.d.ts

@@ -0,0 +1,65 @@
+/**
+ * connection.ts - handles low level communication with sqlitecloud server
+ */
+import { SQLiteCloudConfig, ErrorCallback, ResultsCallback } from './types';
+/** Default timeout value for queries */
+export declare const DEFAULT_TIMEOUT: number;
+/** Default tls connection port */
+export declare const DEFAULT_PORT = 9960;
+/**
+ * Base class for SQLiteCloudConnection handles basics and defines methods.
+ * Actual connection management and communication with the server in concrete classes.
+ */
+export declare class SQLiteCloudConnection {
+    /** Parse and validate provided connectionString or configuration */
+    constructor(config: SQLiteCloudConfig | string, callback?: ErrorCallback);
+    /** Configuration passed by client or extracted from connection string */
+    protected config: SQLiteCloudConfig;
+    /** Transport used to communicate with server */
+    protected transport?: ConnectionTransport;
+    /** Operations are serialized by waiting an any pending promises */
+    protected operations: OperationsQueue;
+    /** True if connection is open */
+    get connected(): boolean;
+    /** Connect will establish a tls or websocket transport to the server based on configuration and environment */
+    protected connect(callback?: ErrorCallback): this;
+    /** Validate configuration, apply defaults, throw if something is missing or misconfigured */
+    protected validateConfiguration(config: SQLiteCloudConfig): SQLiteCloudConfig;
+    /** Will log to console if verbose mode is enabled */
+    protected log(message: string, ...optionalParams: any[]): void;
+    /** Enable verbose logging for debug purposes */
+    verbose(): void;
+    /** Will enquee a command to be executed and callback with the resulting rowset/result/error */
+    sendCommands(commands: string, callback?: ResultsCallback): this;
+    /** Disconnect from server, release connection. */
+    close(): this;
+}
+type OperationCallback = (error: Error | null) => void;
+type Operation = (done: OperationCallback) => void;
+export declare class OperationsQueue {
+    private queue;
+    private isProcessing;
+    /** Add operations to the queue, process immediately if possible, else wait for previous operations to complete */
+    enqueue(operation: Operation): void;
+    /** Clear the queue */
+    clear(): void;
+    /** Process the next operation in the queue */
+    private processNext;
+}
+/** Messages going to the server are sometimes logged when error conditions occour and need to be stripped of user credentials  */
+export declare function anonimizeCommand(message: string): string;
+/** Strip message code in error of user credentials */
+export declare function anonimizeError(error: Error): Error;
+/** Initialization commands sent to database when connection is established */
+export declare function getInitializationCommands(config: SQLiteCloudConfig): string;
+/** ConnectionTransport implements the underlying transport layer for the connection */
+export interface ConnectionTransport {
+    /** True if connection is currently open */
+    get connected(): boolean;
+    connect(config: SQLiteCloudConfig, callback?: ErrorCallback): this;
+    /** Send a command, return the rowset/result or throw an error */
+    processCommands(commands: string, callback?: ResultsCallback): this;
+    /** Disconnect from server, release transport. */
+    close(): this;
+}
+export {};

package/lib/connection.js

@@ -0,0 +1,264 @@
+"use strict";
+/**
+ * connection.ts - handles low level communication with sqlitecloud server
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInitializationCommands = exports.anonimizeError = exports.anonimizeCommand = exports.OperationsQueue = exports.SQLiteCloudConnection = exports.DEFAULT_PORT = exports.DEFAULT_TIMEOUT = void 0;
+const types_1 = require("./types");
+const utilities_1 = require("./utilities");
+/** Default timeout value for queries */
+exports.DEFAULT_TIMEOUT = 300 * 1000;
+/** Default tls connection port */
+exports.DEFAULT_PORT = 9960;
+/**
+ * Base class for SQLiteCloudConnection handles basics and defines methods.
+ * Actual connection management and communication with the server in concrete classes.
+ */
+class SQLiteCloudConnection {
+    /** Parse and validate provided connectionString or configuration */
+    constructor(config, callback) {
+        /** Operations are serialized by waiting an any pending promises */
+        this.operations = new OperationsQueue();
+        if (typeof config === 'string') {
+            this.config = this.validateConfiguration({ connectionString: config });
+        }
+        else {
+            this.config = this.validateConfiguration(config);
+        }
+        // connect transport layer to server
+        this.connect(callback);
+    }
+    //
+    // public properties
+    //
+    /** True if connection is open */
+    get connected() {
+        var _a;
+        return ((_a = this.transport) === null || _a === void 0 ? void 0 : _a.connected) || false;
+    }
+    /** Connect will establish a tls or websocket transport to the server based on configuration and environment */
+    connect(callback) {
+        this.operations.enqueue(done => {
+            var _a, _b;
+            // connect using websocket if tls is not supported or if explicitly requested
+            if (utilities_1.isBrowser || ((_a = this.config) === null || _a === void 0 ? void 0 : _a.useWebsocket) || ((_b = this.config) === null || _b === void 0 ? void 0 : _b.gatewayUrl)) {
+                // socket.io transport works in both node.js and browser environments and connects via SQLite Cloud Gateway
+                Promise.resolve().then(() => __importStar(require('./transport-ws'))).then(transport => {
+                    this.transport = new transport.WebSocketTransport();
+                    this.transport.connect(this.config, error => {
+                        if (error) {
+                            console.error(`SQLiteCloudConnection.connect - error while connecting WebSocketTransport: ${error.toString()}`, this.config, error);
+                            this.close();
+                        }
+                        callback === null || callback === void 0 ? void 0 : callback.call(this, error || null);
+                        done(error);
+                    });
+                })
+                    .catch(error => {
+                    done(error);
+                });
+            }
+            else {
+                // tls sockets work only in node.js environments
+                Promise.resolve().then(() => __importStar(require('./transport-tls'))).then(transport => {
+                    this.transport = new transport.TlsSocketTransport();
+                    this.transport.connect(this.config, error => {
+                        if (error) {
+                            console.error(`SQLiteCloudConnection.connect - error while connecting TlsSocketTransport: ${error.toString()}`, this.config, error);
+                            this.close();
+                        }
+                        callback === null || callback === void 0 ? void 0 : callback.call(this, error || null);
+                        done(error);
+                    });
+                })
+                    .catch(error => {
+                    done(error);
+                });
+            }
+        });
+        return this;
+    }
+    //
+    // private methods
+    //
+    /** Validate configuration, apply defaults, throw if something is missing or misconfigured */
+    validateConfiguration(config) {
+        if (config.connectionString) {
+            config = Object.assign(Object.assign(Object.assign({}, config), (0, utilities_1.parseConnectionString)(config.connectionString)), { connectionString: config.connectionString // keep original connection string
+             });
+        }
+        // apply defaults where needed
+        config.port || (config.port = exports.DEFAULT_PORT);
+        config.timeout = config.timeout && config.timeout > 0 ? config.timeout : exports.DEFAULT_TIMEOUT;
+        config.clientId || (config.clientId = 'SQLiteCloud');
+        config.verbose = (0, utilities_1.parseBoolean)(config.verbose);
+        config.noBlob = (0, utilities_1.parseBoolean)(config.noBlob);
+        config.compression = (0, utilities_1.parseBoolean)(config.compression);
+        config.createDatabase = (0, utilities_1.parseBoolean)(config.createDatabase);
+        config.nonlinearizable = (0, utilities_1.parseBoolean)(config.nonlinearizable);
+        config.sqliteMode = (0, utilities_1.parseBoolean)(config.sqliteMode);
+        if (!config.username || !config.password || !config.host) {
+            console.error('SQLiteCloudConnection.validateConfiguration - missing arguments', config);
+            throw new types_1.SQLiteCloudError('The user, password and host arguments must be specified.', { errorCode: 'ERR_MISSING_ARGS' });
+        }
+        if (!config.connectionString) {
+            // build connection string from configuration, values are already validated
+            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+            config.connectionString = `sqlitecloud://${config.username}:${config.password}@${config.host}:${config.port}/${config.database}`;
+        }
+        return config;
+    }
+    /** Will log to console if verbose mode is enabled */
+    log(message, ...optionalParams) {
+        if (this.config.verbose) {
+            message = anonimizeCommand(message);
+            console.log(`${new Date().toISOString()} ${this.config.clientId}: ${message}`, ...optionalParams);
+        }
+    }
+    //
+    // public methods
+    //
+    /** Enable verbose logging for debug purposes */
+    verbose() {
+        this.config.verbose = true;
+    }
+    /** Will enquee a command to be executed and callback with the resulting rowset/result/error */
+    sendCommands(commands, callback) {
+        this.operations.enqueue(done => {
+            if (this.transport) {
+                this.transport.processCommands(commands, (error, result) => {
+                    callback === null || callback === void 0 ? void 0 : callback.call(this, error, result);
+                    done(error);
+                });
+            }
+            else {
+                const error = new types_1.SQLiteCloudError('Connection not established', { errorCode: 'ERR_CONNECTION_NOT_ESTABLISHED' });
+                callback === null || callback === void 0 ? void 0 : callback.call(this, error);
+                done(error);
+            }
+        });
+        return this;
+    }
+    /** Disconnect from server, release connection. */
+    close() {
+        var _a;
+        this.operations.clear();
+        (_a = this.transport) === null || _a === void 0 ? void 0 : _a.close();
+        this.transport = undefined;
+        return this;
+    }
+}
+exports.SQLiteCloudConnection = SQLiteCloudConnection;
+class OperationsQueue {
+    constructor() {
+        this.queue = [];
+        this.isProcessing = false;
+    }
+    /** Add operations to the queue, process immediately if possible, else wait for previous operations to complete */
+    enqueue(operation) {
+        this.queue.push(operation);
+        if (!this.isProcessing) {
+            this.processNext();
+        }
+    }
+    /** Clear the queue */
+    clear() {
+        this.queue = [];
+        this.isProcessing = false;
+    }
+    /** Process the next operation in the queue */
+    processNext() {
+        if (this.queue.length === 0) {
+            this.isProcessing = false;
+            return;
+        }
+        this.isProcessing = true;
+        const operation = this.queue.shift();
+        operation === null || operation === void 0 ? void 0 : operation(() => {
+            // could receive (error) => { ...
+            // if (error) {
+            //   console.warn('OperationQueue.processNext - error in operation', error)
+            // }
+            // process the next operation in the queue
+            this.processNext();
+        });
+    }
+}
+exports.OperationsQueue = OperationsQueue;
+//
+// utility functions
+//
+/** Messages going to the server are sometimes logged when error conditions occour and need to be stripped of user credentials  */
+function anonimizeCommand(message) {
+    // hide password in AUTH command if needed
+    message = message.replace(/USER \S+/, 'USER ******');
+    message = message.replace(/PASSWORD \S+?(?=;)/, 'PASSWORD ******');
+    message = message.replace(/HASH \S+?(?=;)/, 'HASH ******');
+    return message;
+}
+exports.anonimizeCommand = anonimizeCommand;
+/** Strip message code in error of user credentials */
+function anonimizeError(error) {
+    if (error === null || error === void 0 ? void 0 : error.message) {
+        error.message = anonimizeCommand(error.message);
+    }
+    return error;
+}
+exports.anonimizeError = anonimizeError;
+/** Initialization commands sent to database when connection is established */
+function getInitializationCommands(config) {
+    // first user authentication, then all other commands
+    let commands = `AUTH USER ${config.username || ''} ${config.passwordHashed ? 'HASH' : 'PASSWORD'} ${config.password || ''}; `;
+    if (config.database) {
+        if (config.createDatabase && !config.dbMemory) {
+            commands += `CREATE DATABASE ${config.database} IF NOT EXISTS; `;
+        }
+        commands += `USE DATABASE ${config.database}; `;
+    }
+    if (config.sqliteMode) {
+        commands += 'SET CLIENT KEY SQLITE TO 1; ';
+    }
+    if (config.compression) {
+        commands += 'SET CLIENT KEY COMPRESSION TO 1; ';
+    }
+    if (config.nonlinearizable) {
+        commands += 'SET CLIENT KEY NONLINEARIZABLE TO 1; ';
+    }
+    if (config.noBlob) {
+        commands += 'SET CLIENT KEY NOBLOB TO 1; ';
+    }
+    if (config.maxData) {
+        commands += `SET CLIENT KEY MAXDATA TO ${config.maxData}; `;
+    }
+    if (config.maxRows) {
+        commands += `SET CLIENT KEY MAXROWS TO ${config.maxRows}; `;
+    }
+    if (config.maxRowset) {
+        commands += `SET CLIENT KEY MAXROWSET TO ${config.maxRowset}; `;
+    }
+    return commands;
+}
+exports.getInitializationCommands = getInitializationCommands;

package/lib/database.d.ts

@@ -0,0 +1,154 @@
+import { SQLiteCloudConfig, RowCountCallback } from './types';
+import { Statement } from './statement';
+import { ErrorCallback, ResultsCallback, RowCallback, RowsCallback } from './types';
+import EventEmitter from 'eventemitter3';
+/**
+ * Creating a Database object automatically opens a connection to the SQLite database.
+ * When the connection is established the Database object emits an open event and calls
+ * the optional provided callback. If the connection cannot be established an error event
+ * will be emitted and the optional callback is called with the error information.
+ */
+export declare class Database extends EventEmitter {
+    /** Create and initialize a database from a full configuration object, or connection string */
+    constructor(config: SQLiteCloudConfig | string, callback?: ErrorCallback);
+    constructor(config: SQLiteCloudConfig | string, mode?: number, callback?: ErrorCallback);
+    /** Configuration used to open database connections */
+    private config;
+    /** Database connections */
+    private connections;
+    /** Returns first available connection from connection pool */
+    private getConnection;
+    /** Handles an error by closing the connection, calling the callback and/or emitting an error event */
+    private handleError;
+    /**
+     * Some queries like inserts or updates processed via run or exec may generate
+     * an empty result (eg. no data was selected), but still have some metadata.
+     * For example the server may pass the id of the last row that was modified.
+     * In this case the callback results should be empty but the context may contain
+     * additional information like lastID, etc.
+     * @see https://github.com/TryGhost/node-sqlite3/wiki/API#runsql--param---callback
+     * @param results Results received from the server
+     * @returns A context object if one makes sense, otherwise undefined
+     */
+    private processContext;
+    /** Emits given event with optional arguments on the next tick so callbacks can complete first */
+    private emitEvent;
+    /**
+     * Returns the configuration with which this database was opened.
+     * The configuration is readonly and cannot be changed as there may
+     * be multiple connections using the same configuration.
+     * @returns {SQLiteCloudConfig} A configuration object
+     */
+    getConfiguration(): SQLiteCloudConfig;
+    /** Enable verbose mode */
+    verbose(): this;
+    /** Set a configuration option for the database */
+    configure(_option: string, _value: any): this;
+    /**
+     * Runs the SQL query with the specified parameters and calls the callback afterwards.
+     * The callback will contain the results passed back from the server, for example in the
+     * case of an update or insert, these would contain the number of rows modified, etc.
+     * It does not retrieve any result data. The function returns the Database object for
+     * which it was called to allow for function chaining.
+     */
+    run<T>(sql: string, callback?: ResultsCallback<T>): this;
+    run<T>(sql: string, params: any, callback?: ResultsCallback<T>): this;
+    /**
+     * Runs the SQL query with the specified parameters and calls the callback with
+     * a subsequent result row. The function returns the Database object to allow for
+     * function chaining. The parameters are the same as the Database#run function,
+     * with the following differences: The signature of the callback is `function(err, row) {}`.
+     * If the result set is empty, the second parameter is undefined, otherwise it is an
+     * object containing the values for the first row. The property names correspond to
+     * the column names of the result set. It is impossible to access them by column index;
+     * the only supported way is by column name.
+     */
+    get<T>(sql: string, callback?: RowCallback<T>): this;
+    get<T>(sql: string, params: any, callback?: RowCallback<T>): this;
+    /**
+     * Runs the SQL query with the specified parameters and calls the callback
+     * with all result rows afterwards. The function returns the Database object to
+     * allow for function chaining. The parameters are the same as the Database#run
+     * function, with the following differences: The signature of the callback is
+     * function(err, rows) {}. rows is an array. If the result set is empty, it will
+     * be an empty array, otherwise it will have an object for each result row which
+     * in turn contains the values of that row, like the Database#get function.
+     * Note that it first retrieves all result rows and stores them in memory.
+     * For queries that have potentially large result sets, use the Database#each
+     * function to retrieve all rows or Database#prepare followed by multiple Statement#get
+     * calls to retrieve a previously unknown amount of rows.
+     */
+    all<T>(sql: string, callback?: RowsCallback<T>): this;
+    all<T>(sql: string, params: any, callback?: RowsCallback<T>): this;
+    /**
+     * Runs the SQL query with the specified parameters and calls the callback once for each result row.
+     * The function returns the Database object to allow for function chaining. The parameters are the
+     * same as the Database#run function, with the following differences: The signature of the callback
+     * is function(err, row) {}. If the result set succeeds but is empty, the callback is never called.
+     * In all other cases, the callback is called once for every retrieved row. The order of calls correspond
+     * exactly to the order of rows in the result set. After all row callbacks were called, the completion
+     * callback will be called if present. The first argument is an error object, and the second argument
+     * is the number of retrieved rows. If you specify only one function, it will be treated as row callback,
+     * if you specify two, the first (== second to last) function will be the row callback, the last function
+     * will be the completion callback. If you know that a query only returns a very limited number of rows,
+     * it might be more convenient to use Database#all to retrieve all rows at once. There is currently no
+     * way to abort execution.
+     */
+    each<T>(sql: string, callback?: RowCallback<T>, complete?: RowCountCallback): this;
+    each<T>(sql: string, params: any, callback?: RowCallback<T>, complete?: RowCountCallback): this;
+    /**
+     * Prepares the SQL statement and optionally binds the specified parameters and
+     * calls the callback when done. The function returns a Statement object.
+     * When preparing was successful, the first and only argument to the callback
+     * is null, otherwise it is the error object. When bind parameters are supplied,
+     * they are bound to the prepared statement before calling the callback.
+     */
+    prepare<T = any>(sql: string, ...params: any[]): Statement<T>;
+    /**
+     * Runs all SQL queries in the supplied string. No result rows are retrieved.
+     * The function returns the Database object to allow for function chaining.
+     * If a query fails, no subsequent statements will be executed (wrap it in a
+     * transaction if you want all or none to be executed). When all statements
+     * have been executed successfully, or when an error occurs, the callback
+     * function is called, with the first parameter being either null or an error
+     * object. When no callback is provided and an error occurs, an error event
+     * will be emitted on the database object.
+     */
+    exec(sql: string, callback?: ErrorCallback): this;
+    /**
+     * If the optional callback is provided, this function will be called when the
+     * database was closed successfully or when an error occurred. The first argument
+     * is an error object. When it is null, closing succeeded. If no callback is provided
+     * and an error occurred, an error event with the error object as the only parameter
+     * will be emitted on the database object. If closing succeeded, a close event with no
+     * parameters is emitted, regardless of whether a callback was provided or not.
+     */
+    close(callback?: ErrorCallback): void;
+    /**
+     * Loads a compiled SQLite extension into the database connection object.
+     * @param path Filename of the extension to load.
+     * @param callback  If provided, this function will be called when the extension
+     * was loaded successfully or when an error occurred. The first argument is an
+     * error object. When it is null, loading succeeded. If no callback is provided
+     * and an error occurred, an error event with the error object as the only parameter
+     * will be emitted on the database object.
+     */
+    loadExtension(_path: string, callback?: ErrorCallback): this;
+    /**
+     * Allows the user to interrupt long-running queries. Wrapper around
+     * sqlite3_interrupt and causes other data-fetching functions to be
+     * passed an err with code = sqlite3.INTERRUPT. The database must be
+     * open to use this function.
+     */
+    interrupt(): void;
+    /**
+     * Sql is a promise based API for executing SQL statements. You can
+     * pass a simple string with a SQL statement or a template string
+     * using backticks and parameters in ${parameter} format. These parameters
+     * will be properly escaped and quoted like when using a prepared statement.
+     * @param sql A sql string or a template string in `backticks` format
+     * @returns An array of rows in case of selections or an object with
+     * metadata in case of insert, update, delete.
+     */
+    sql(sql: TemplateStringsArray | string, ...values: any[]): Promise<any>;
+}