@sqlitecloud/drivers 1.0.406 → 1.0.422

package/README.md

@@ -54,7 +54,7 @@ let database = new Database('sqlitecloud://user:password@xxx.sqlite.cloud:8860/c
 
 let name = 'Breaking The Rules'
 
-let results = await database.sql`SELECT * FROM tracks WHERE name = ${name}`
+let results = await database.sql('SELECT * FROM tracks WHERE name = ?', name)
 // => returns [{ AlbumId: 1, Name: 'Breaking The Rules', Composer: 'Angus Young... }]
 ```
 
@@ -82,7 +82,7 @@ await pubSub.listen(PUBSUB_ENTITY_TYPE.TABLE, 'albums', (error, results, data) =
   }
 })
 
-await database.sql`INSERT INTO albums (Title, ArtistId) values ('Brand new song', 1)`
+await database.sql("INSERT INTO albums (Title, ArtistId) values ('Brand new song', 1)")
 
 // Stop listening changes on the table
 await pubSub.unlisten(PUBSUB_ENTITY_TYPE.TABLE, 'albums')

package/lib/drivers/connection-tls.d.ts

@@ -1,8 +1,8 @@
 /**
  * connection-tls.ts - connection via tls socket and sqlitecloud protocol
  */
-import { type SQLiteCloudConfig, type ErrorCallback, type ResultsCallback, SQLiteCloudCommand } from './types';
 import { SQLiteCloudConnection } from './connection';
+import { type ErrorCallback, type ResultsCallback, SQLiteCloudCommand, type SQLiteCloudConfig } from './types';
 /**
  * Implementation of SQLiteCloudConnection that connects to the database using specific tls APIs
  * that connect to native sockets or tls sockets and communicates via raw, binary protocol.

package/lib/drivers/connection-tls.js

@@ -37,10 +37,10 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SQLiteCloudTlsConnection = void 0;
-const types_1 = require("./types");
 const connection_1 = require("./connection");
-const utilities_1 = require("./utilities");
 const protocol_1 = require("./protocol");
+const types_1 = require("./types");
+const utilities_1 = require("./utilities");
 // explicitly importing buffer library to allow cross-platform support by replacing it
 const buffer_1 = require("buffer");
 const tls = __importStar(require("tls"));
@@ -101,6 +101,10 @@ class SQLiteCloudTlsConnection extends connection_1.SQLiteCloudConnection {
                 callback === null || callback === void 0 ? void 0 : callback.call(this, error);
             });
         });
+        this.socket.setKeepAlive(true);
+        // disable Nagle algorithm because we want our writes to be sent ASAP
+        // https://brooker.co.za/blog/2024/05/09/nagle.html
+        this.socket.setNoDelay(true);
         this.socket.on('data', data => {
             this.processCommandsData(data);
         });
@@ -117,6 +121,10 @@ class SQLiteCloudTlsConnection extends connection_1.SQLiteCloudConnection {
             this.close();
             this.processCommandsFinish(new types_1.SQLiteCloudError('Connection closed', { errorCode: 'ERR_CONNECTION_CLOSED' }));
         });
+        this.socket.on('timeout', () => {
+            this.close();
+            this.processCommandsFinish(new types_1.SQLiteCloudError('Connection ened due to timeout', { errorCode: 'ERR_CONNECTION_TIMEOUT' }));
+        });
         return this;
     }
     /** Will send a command immediately (no queueing), return the rowset/result or throw an error */

package/lib/drivers/connection-ws.d.ts

@@ -1,8 +1,8 @@
 /**
  * transport-ws.ts - handles low level communication with sqlitecloud server via socket.io websocket
  */
-import { SQLiteCloudConfig, ErrorCallback, ResultsCallback, SQLiteCloudCommand } from './types';
 import { SQLiteCloudConnection } from './connection';
+import { ErrorCallback, ResultsCallback, SQLiteCloudCommand, SQLiteCloudConfig } from './types';
 /**
  * Implementation of TransportConnection that connects to the database indirectly
  * via SQLite Cloud Gateway, a socket.io based deamon that responds to sql query

package/lib/drivers/connection-ws.js

@@ -4,10 +4,10 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SQLiteCloudWebsocketConnection = void 0;
-const types_1 = require("./types");
-const rowset_1 = require("./rowset");
-const connection_1 = require("./connection");
 const socket_io_client_1 = require("socket.io-client");
+const connection_1 = require("./connection");
+const rowset_1 = require("./rowset");
+const types_1 = require("./types");
 /**
  * Implementation of TransportConnection that connects to the database indirectly
  * via SQLite Cloud Gateway, a socket.io based deamon that responds to sql query
@@ -17,7 +17,8 @@ const socket_io_client_1 = require("socket.io-client");
 class SQLiteCloudWebsocketConnection extends connection_1.SQLiteCloudConnection {
     /** True if connection is open */
     get connected() {
-        return !!this.socket;
+        var _a;
+        return !!(this.socket && ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.connected));
     }
     /* Opens a connection with the server and sends the initialization commands. Will throw in case of errors. */
     connectTransport(config, callback) {
@@ -30,8 +31,18 @@ class SQLiteCloudWebsocketConnection extends connection_1.SQLiteCloudConnection
                 const connectionstring = this.config.connectionstring;
                 const gatewayUrl = ((_a = this.config) === null || _a === void 0 ? void 0 : _a.gatewayurl) || `${this.config.host === 'localhost' ? 'ws' : 'wss'}://${this.config.host}:4000`;
                 this.socket = (0, socket_io_client_1.io)(gatewayUrl, { auth: { token: connectionstring } });
+                this.socket.on('connect', () => {
+                    callback === null || callback === void 0 ? void 0 : callback.call(this, null);
+                });
+                this.socket.on('disconnect', (reason) => {
+                    this.close();
+                    callback === null || callback === void 0 ? void 0 : callback.call(this, new types_1.SQLiteCloudError('Disconnected', { errorCode: 'ERR_CONNECTION_ENDED', cause: reason }));
+                });
+                this.socket.on('error', (error) => {
+                    this.close();
+                    callback === null || callback === void 0 ? void 0 : callback.call(this, new types_1.SQLiteCloudError('Connection error', { errorCode: 'ERR_CONNECTION_ERROR', cause: error }));
+                });
             }
-            callback === null || callback === void 0 ? void 0 : callback.call(this, null);
         }
         catch (error) {
             callback === null || callback === void 0 ? void 0 : callback.call(this, error);
@@ -71,14 +82,14 @@ class SQLiteCloudWebsocketConnection extends connection_1.SQLiteCloudConnection
     }
     /** Disconnect socket.io from server */
     close() {
-        var _a;
+        var _a, _b;
         console.assert(this.socket !== null, 'SQLiteCloudWebsocketConnection.close - connection already closed');
         if (this.socket) {
-            (_a = this.socket) === null || _a === void 0 ? void 0 : _a.close();
+            (_a = this.socket) === null || _a === void 0 ? void 0 : _a.removeAllListeners();
+            (_b = this.socket) === null || _b === void 0 ? void 0 : _b.close();
             this.socket = undefined;
         }
         this.operations.clear();
-        this.socket = undefined;
         return this;
     }
 }

package/lib/drivers/database.d.ts

@@ -1,8 +1,7 @@
-import { SQLiteCloudConfig, RowCountCallback, SQLiteCloudCommand } from './types';
-import { ErrorCallback, ResultsCallback, RowCallback, RowsCallback } from './types';
 import EventEmitter from 'eventemitter3';
 import { PubSub } from './pubsub';
 import { Statement } from './statement';
+import { ErrorCallback as ConnectionCallback, ResultsCallback, RowCallback, RowCountCallback, RowsCallback, SQLiteCloudCommand, SQLiteCloudConfig } from './types';
 /**
  * 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
@@ -11,14 +10,17 @@ import { Statement } from './statement';
  */
 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);
+    constructor(config: SQLiteCloudConfig | string, callback?: ConnectionCallback);
+    constructor(config: SQLiteCloudConfig | string, mode?: number, callback?: ConnectionCallback);
     /** Configuration used to open database connections */
     private config;
-    /** Database connections */
-    private connections;
+    /** Database connection */
+    private connection;
+    /** Used to syncronize opening of connection and commands */
+    private operations;
     /** Returns first available connection from connection pool */
-    private getConnection;
+    private createConnection;
+    private enqueueCommand;
     /** Handles an error by closing the connection, calling the callback and/or emitting an error event */
     private handleError;
     /**
@@ -115,7 +117,7 @@ export declare class Database extends EventEmitter {
      * 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;
+    exec(sql: string, callback?: ConnectionCallback): 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
@@ -124,7 +126,7 @@ export declare class Database extends EventEmitter {
      * 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;
+    close(callback?: ConnectionCallback): void;
     /**
      * Loads a compiled SQLite extension into the database connection object.
      * @param path Filename of the extension to load.
@@ -134,7 +136,7 @@ export declare class Database extends EventEmitter {
      * 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;
+    loadExtension(_path: string, callback?: ConnectionCallback): this;
     /**
      * Allows the user to interrupt long-running queries. Wrapper around
      * sqlite3_interrupt and causes other data-fetching functions to be
@@ -152,6 +154,10 @@ export declare class Database extends EventEmitter {
      * metadata in case of insert, update, delete.
      */
     sql(sql: TemplateStringsArray | string | SQLiteCloudCommand, ...values: any[]): Promise<any>;
+    /**
+     * Returns true if the database connection is open.
+     */
+    isConnected(): boolean;
     /**
      * PubSub class provides a Pub/Sub real-time updates and notifications system to
      * allow multiple applications to communicate with each other asynchronously.

package/lib/drivers/database.js

@@ -49,13 +49,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Database = void 0;
-const rowset_1 = require("./rowset");
-const types_1 = require("./types");
-const utilities_1 = require("./utilities");
+// Trying as much as possible to be a drop-in replacement for SQLite3 API
+// https://github.com/TryGhost/node-sqlite3/wiki/API
+// https://github.com/TryGhost/node-sqlite3
+// https://github.com/TryGhost/node-sqlite3/blob/master/lib/sqlite3.d.ts
 const eventemitter3_1 = __importDefault(require("eventemitter3"));
-const utilities_2 = require("./utilities");
 const pubsub_1 = require("./pubsub");
+const queue_1 = require("./queue");
+const rowset_1 = require("./rowset");
 const statement_1 = require("./statement");
+const types_1 = require("./types");
+const utilities_1 = require("./utilities");
 // Uses eventemitter3 instead of node events for browser compatibility
 // https://github.com/primus/eventemitter3
 /**
@@ -67,9 +71,10 @@ const statement_1 = require("./statement");
 class Database extends eventemitter3_1.default {
     constructor(config, mode, callback) {
         super();
-        /** Database connections */
-        this.connections = [];
+        /** Used to syncronize opening of connection and commands */
+        this.operations = new queue_1.OperationsQueue();
         this.config = typeof config === 'string' ? { connectionstring: config } : config;
+        this.connection = null;
         // mode is optional and so is callback
         // https://github.com/TryGhost/node-sqlite3/wiki/API#new-sqlite3databasefilename--mode--callback
         if (typeof mode === 'function') {
@@ -77,8 +82,8 @@ class Database extends eventemitter3_1.default {
             mode = undefined;
         }
         // mode is ignored for now
-        // opens first connection to the database automatically
-        this.getConnection((error, _connection) => {
+        // opens the connection to the database automatically
+        this.createConnection(error => {
             if (callback) {
                 callback.call(this, error);
             }
@@ -88,60 +93,71 @@ class Database extends eventemitter3_1.default {
     // private methods
     //
     /** Returns first available connection from connection pool */
-    getConnection(callback) {
-        var _a, _b, _c;
-        // TODO sqlitecloud-js / implement database connection pool #10
-        if (((_a = this.connections) === null || _a === void 0 ? void 0 : _a.length) > 0) {
-            callback === null || callback === void 0 ? void 0 : callback.call(this, null, this.connections[0]);
-        }
-        else {
-            // connect using websocket if tls is not supported or if explicitly requested
-            const useWebsocket = utilities_2.isBrowser || ((_b = this.config) === null || _b === void 0 ? void 0 : _b.usewebsocket) || ((_c = this.config) === null || _c === void 0 ? void 0 : _c.gatewayurl);
-            if (useWebsocket) {
-                // socket.io transport works in both node.js and browser environments and connects via SQLite Cloud Gateway
+    createConnection(callback) {
+        var _a, _b;
+        // connect using websocket if tls is not supported or if explicitly requested
+        const useWebsocket = 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);
+        if (useWebsocket) {
+            // socket.io transport works in both node.js and browser environments and connects via SQLite Cloud Gateway
+            this.operations.enqueue(done => {
                 Promise.resolve().then(() => __importStar(require('./connection-ws'))).then(module => {
-                    this.connections.push(new module.default(this.config, error => {
+                    this.connection = new module.default(this.config, (error) => {
                         if (error) {
-                            this.handleError(this.connections[0], error, callback);
+                            this.handleError(error, callback);
                         }
                         else {
-                            console.assert;
-                            callback === null || callback === void 0 ? void 0 : callback.call(this, null, this.connections[0]);
+                            callback === null || callback === void 0 ? void 0 : callback.call(this, null);
                             this.emitEvent('open');
                         }
-                    }));
+                        done(error);
+                    });
                 })
                     .catch(error => {
-                    this.handleError(null, error, callback);
+                    this.handleError(error, callback);
+                    done(error);
                 });
-            }
-            else {
-                // tls sockets work only in node.js environments
+            });
+        }
+        else {
+            this.operations.enqueue(done => {
                 Promise.resolve().then(() => __importStar(require('./connection-tls'))).then(module => {
-                    this.connections.push(new module.default(this.config, error => {
+                    this.connection = new module.default(this.config, (error) => {
                         if (error) {
-                            this.handleError(this.connections[0], error, callback);
+                            this.handleError(error, callback);
                         }
                         else {
-                            console.assert;
-                            callback === null || callback === void 0 ? void 0 : callback.call(this, null, this.connections[0]);
+                            callback === null || callback === void 0 ? void 0 : callback.call(this, null);
                             this.emitEvent('open');
                         }
-                    }));
+                        done(error);
+                    });
                 })
                     .catch(error => {
-                    this.handleError(null, error, callback);
+                    this.handleError(error, callback);
+                    done(error);
                 });
-            }
+            });
         }
     }
+    enqueueCommand(command, callback) {
+        this.operations.enqueue(done => {
+            let error = null;
+            // we don't wont to silently open a new connection after a disconnession
+            if (this.connection && this.connection.connected) {
+                this.connection.sendCommands(command, callback);
+            }
+            else {
+                error = new types_1.SQLiteCloudError('Connection unavailable. Maybe it got disconnected?', { errorCode: 'ERR_CONNECTION_NOT_ESTABLISHED' });
+                this.handleError(error, callback);
+            }
+            done(error);
+        });
+    }
     /** Handles an error by closing the connection, calling the callback and/or emitting an error event */
-    handleError(connection, error, callback) {
+    handleError(error, callback) {
+        var _a;
         // an errored connection is thrown out
-        if (connection) {
-            this.connections = this.connections.filter(c => c !== connection);
-            connection.close();
-        }
+        (_a = this.connection) === null || _a === void 0 ? void 0 : _a.close();
         if (callback) {
             callback.call(this, error);
         }
@@ -195,10 +211,9 @@ class Database extends eventemitter3_1.default {
     }
     /** Enable verbose mode */
     verbose() {
+        var _a;
         this.config.verbose = true;
-        for (const connection of this.connections) {
-            connection.verbose();
-        }
+        (_a = this.connection) === null || _a === void 0 ? void 0 : _a.verbose();
         return this;
     }
     /** Set a configuration option for the database */
@@ -209,21 +224,14 @@ class Database extends eventemitter3_1.default {
     run(sql, ...params) {
         const { args, callback } = (0, utilities_1.popCallback)(params);
         const command = { query: sql, parameters: args };
-        this.getConnection((error, connection) => {
-            if (error || !connection) {
-                this.handleError(null, error, callback);
+        this.enqueueCommand(command, (error, results) => {
+            if (error) {
+                this.handleError(error, callback);
             }
             else {
-                connection.sendCommands(command, (error, results) => {
-                    if (error) {
-                        this.handleError(connection, error, callback);
-                    }
-                    else {
-                        // context may include id of last row inserted, total changes, etc...
-                        const context = this.processContext(results);
-                        callback === null || callback === void 0 ? void 0 : callback.call(context || this, null, context ? context : results);
-                    }
-                });
+                // context may include id of last row inserted, total changes, etc...
+                const context = this.processContext(results);
+                callback === null || callback === void 0 ? void 0 : callback.call(context || this, null, context ? context : results);
             }
         });
         return this;
@@ -231,24 +239,17 @@ class Database extends eventemitter3_1.default {
     get(sql, ...params) {
         const { args, callback } = (0, utilities_1.popCallback)(params);
         const command = { query: sql, parameters: args };
-        this.getConnection((error, connection) => {
-            if (error || !connection) {
-                this.handleError(null, error, callback);
+        this.enqueueCommand(command, (error, results) => {
+            if (error) {
+                this.handleError(error, callback);
             }
             else {
-                connection.sendCommands(command, (error, results) => {
-                    if (error) {
-                        this.handleError(connection, error, callback);
-                    }
-                    else {
-                        if (results && results instanceof rowset_1.SQLiteCloudRowset && results.length > 0) {
-                            callback === null || callback === void 0 ? void 0 : callback.call(this, null, results[0]);
-                        }
-                        else {
-                            callback === null || callback === void 0 ? void 0 : callback.call(this, null);
-                        }
-                    }
-                });
+                if (results && results instanceof rowset_1.SQLiteCloudRowset && results.length > 0) {
+                    callback === null || callback === void 0 ? void 0 : callback.call(this, null, results[0]);
+                }
+                else {
+                    callback === null || callback === void 0 ? void 0 : callback.call(this, null);
+                }
             }
         });
         return this;
@@ -256,24 +257,17 @@ class Database extends eventemitter3_1.default {
     all(sql, ...params) {
         const { args, callback } = (0, utilities_1.popCallback)(params);
         const command = { query: sql, parameters: args };
-        this.getConnection((error, connection) => {
-            if (error || !connection) {
-                this.handleError(null, error, callback);
+        this.enqueueCommand(command, (error, results) => {
+            if (error) {
+                this.handleError(error, callback);
             }
             else {
-                connection.sendCommands(command, (error, results) => {
-                    if (error) {
-                        this.handleError(connection, error, callback);
-                    }
-                    else {
-                        if (results && results instanceof rowset_1.SQLiteCloudRowset) {
-                            callback === null || callback === void 0 ? void 0 : callback.call(this, null, results);
-                        }
-                        else {
-                            callback === null || callback === void 0 ? void 0 : callback.call(this, null);
-                        }
-                    }
-                });
+                if (results && results instanceof rowset_1.SQLiteCloudRowset) {
+                    callback === null || callback === void 0 ? void 0 : callback.call(this, null, results);
+                }
+                else {
+                    callback === null || callback === void 0 ? void 0 : callback.call(this, null);
+                }
             }
         });
         return this;
@@ -282,32 +276,25 @@ class Database extends eventemitter3_1.default {
         // extract optional parameters and one or two callbacks
         const { args, callback, complete } = (0, utilities_1.popCallback)(params);
         const command = { query: sql, parameters: args };
-        this.getConnection((error, connection) => {
-            if (error || !connection) {
-                this.handleError(null, error, callback);
+        this.enqueueCommand(command, (error, rowset) => {
+            if (error) {
+                this.handleError(error, callback);
             }
             else {
-                connection.sendCommands(command, (error, rowset) => {
-                    if (error) {
-                        this.handleError(connection, error, callback);
-                    }
-                    else {
-                        if (rowset && rowset instanceof rowset_1.SQLiteCloudRowset) {
-                            if (callback) {
-                                for (const row of rowset) {
-                                    callback.call(this, null, row);
-                                }
-                            }
-                            if (complete) {
-                                ;
-                                complete.call(this, null, rowset.numberOfRows);
-                            }
-                        }
-                        else {
-                            callback === null || callback === void 0 ? void 0 : callback.call(this, new types_1.SQLiteCloudError('Invalid rowset'));
+                if (rowset && rowset instanceof rowset_1.SQLiteCloudRowset) {
+                    if (callback) {
+                        for (const row of rowset) {
+                            callback.call(this, null, row);
                         }
                     }
-                });
+                    if (complete) {
+                        ;
+                        complete.call(this, null, rowset.numberOfRows);
+                    }
+                }
+                else {
+                    callback === null || callback === void 0 ? void 0 : callback.call(this, new types_1.SQLiteCloudError('Invalid rowset'));
+                }
             }
         });
         return this;
@@ -333,20 +320,13 @@ class Database extends eventemitter3_1.default {
      * will be emitted on the database object.
      */
     exec(sql, callback) {
-        this.getConnection((error, connection) => {
-            if (error || !connection) {
-                this.handleError(null, error, callback);
+        this.enqueueCommand(sql, (error, results) => {
+            if (error) {
+                this.handleError(error, callback);
             }
             else {
-                connection.sendCommands(sql, (error, results) => {
-                    if (error) {
-                        this.handleError(connection, error, callback);
-                    }
-                    else {
-                        const context = this.processContext(results);
-                        callback === null || callback === void 0 ? void 0 : callback.call(context ? context : this, null);
-                    }
-                });
+                const context = this.processContext(results);
+                callback === null || callback === void 0 ? void 0 : callback.call(context ? context : this, null);
             }
         });
         return this;
@@ -361,11 +341,8 @@ class Database extends eventemitter3_1.default {
      */
     close(callback) {
         var _a;
-        if (((_a = this.connections) === null || _a === void 0 ? void 0 : _a.length) > 0) {
-            for (const connection of this.connections) {
-                connection.close();
-            }
-        }
+        this.operations.clear();
+        (_a = this.connection) === null || _a === void 0 ? void 0 : _a.close();
         callback === null || callback === void 0 ? void 0 : callback.call(this, null);
         this.emitEvent('close');
     }
@@ -433,26 +410,25 @@ class Database extends eventemitter3_1.default {
                 throw new Error('Invalid sql');
             }
             return new Promise((resolve, reject) => {
-                this.getConnection((error, connection) => {
-                    if (error || !connection) {
+                this.enqueueCommand(commands, (error, results) => {
+                    if (error) {
                         reject(error);
                     }
                     else {
-                        connection.sendCommands(commands, (error, results) => {
-                            if (error) {
-                                reject(error);
-                            }
-                            else {
-                                // metadata for operations like insert, update, delete?
-                                const context = this.processContext(results);
-                                resolve(context ? context : results);
-                            }
-                        });
+                        // metadata for operations like insert, update, delete?
+                        const context = this.processContext(results);
+                        resolve(context ? context : results);
                     }
                 });
             });
         });
     }
+    /**
+     * Returns true if the database connection is open.
+     */
+    isConnected() {
+        return this.connection != null && this.connection.connected;
+    }
     /**
      * PubSub class provides a Pub/Sub real-time updates and notifications system to
      * allow multiple applications to communicate with each other asynchronously.
@@ -464,12 +440,19 @@ class Database extends eventemitter3_1.default {
     getPubSub() {
         return __awaiter(this, void 0, void 0, function* () {
             return new Promise((resolve, reject) => {
-                this.getConnection((error, connection) => {
-                    if (error || !connection) {
-                        reject(error);
+                this.operations.enqueue(done => {
+                    let error = null;
+                    try {
+                        if (!this.connection) {
+                            error = new types_1.SQLiteCloudError('Connection not established', { errorCode: 'ERR_CONNECTION_NOT_ESTABLISHED' });
+                            reject(error);
+                        }
+                        else {
+                            resolve(new pubsub_1.PubSub(this.connection));
+                        }
                     }
-                    else {
-                        resolve(new pubsub_1.PubSub(connection));
+                    finally {
+                        done(error);
                     }
                 });
             });

package/lib/drivers/pubsub.js

@@ -86,14 +86,14 @@ class PubSub {
      */
     removeChannel(name) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.connection.sql(`REMOVE CHANNEL ?;`, name);
+            return this.connection.sql('REMOVE CHANNEL ?;', name);
         });
     }
     /**
      * Send a message to the channel.
      */
     notifyChannel(channelName, message) {
-        return this.connection.sql `NOTIFY ${channelName} ${message};`;
+        return this.connection.sql('NOTIFY ? ?;', channelName, message);
     }
     /**
      * Ask the server to close the connection to the database and

package/lib/drivers/utilities.d.ts

@@ -17,6 +17,8 @@ export declare function getUpdateResults(results?: any): Record<string, any> | u
  * containing the arguments array with the callbacks removed (if any), and the callback itself.
  * If there are multiple callbacks, the first one is returned as 'callback' and the last one
  * as 'completeCallback'.
+ *
+ * @returns args is a simple list of SQLiteCloudDataTypes, we flat them into a single array
  */
 export declare function popCallback<T extends ErrorCallback = ErrorCallback>(args: (SQLiteCloudDataTypes | T | ErrorCallback)[]): {
     args: SQLiteCloudDataTypes[];