@sqlitecloud/drivers 1.0.422 → 1.0.507

package/lib/drivers/connection-tls.js

@@ -156,12 +156,12 @@ class SQLiteCloudTlsConnection extends connection_1.SQLiteCloudConnection {
                 (_a = this.socket) === null || _a === void 0 ? void 0 : _a.destroy();
                 this.socket = undefined;
             }, timeoutMs);
-            (_d = this.socket) === null || _d === void 0 ? void 0 : _d.write(formattedCommands, 'utf-8', () => {
+            (_d = this.socket) === null || _d === void 0 ? void 0 : _d.write(formattedCommands, () => {
                 clearTimeout(timeout); // Clear the timeout on successful write
             });
         }
         else {
-            (_e = this.socket) === null || _e === void 0 ? void 0 : _e.write(formattedCommands, 'utf-8');
+            (_e = this.socket) === null || _e === void 0 ? void 0 : _e.write(formattedCommands);
         }
         return this;
     }

package/lib/drivers/database.js

@@ -114,6 +114,7 @@ class Database extends eventemitter3_1.default {
                 })
                     .catch(error => {
                     this.handleError(error, callback);
+                    this.close();
                     done(error);
                 });
             });
@@ -134,6 +135,7 @@ class Database extends eventemitter3_1.default {
                 })
                     .catch(error => {
                     this.handleError(error, callback);
+                    this.close();
                     done(error);
                 });
             });
@@ -144,20 +146,20 @@ class Database extends eventemitter3_1.default {
             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);
+                this.connection.sendCommands(command, (error, results) => {
+                    callback === null || callback === void 0 ? void 0 : callback.call(this, error, results);
+                    done(error);
+                });
             }
             else {
                 error = new types_1.SQLiteCloudError('Connection unavailable. Maybe it got disconnected?', { errorCode: 'ERR_CONNECTION_NOT_ESTABLISHED' });
-                this.handleError(error, callback);
+                callback === null || callback === void 0 ? void 0 : callback.call(this, error, null);
+                done(error);
             }
-            done(error);
         });
     }
     /** Handles an error by closing the connection, calling the callback and/or emitting an error event */
     handleError(error, callback) {
-        var _a;
-        // an errored connection is thrown out
-        (_a = this.connection) === null || _a === void 0 ? void 0 : _a.close();
         if (callback) {
             callback.call(this, error);
         }
@@ -340,11 +342,14 @@ class Database extends eventemitter3_1.default {
      * parameters is emitted, regardless of whether a callback was provided or not.
      */
     close(callback) {
-        var _a;
-        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');
+        this.operations.enqueue(done => {
+            var _a;
+            (_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');
+            this.operations.clear();
+            done(null);
+        });
     }
     /**
      * Loads a compiled SQLite extension into the database connection object.

package/lib/drivers/protocol.d.ts

@@ -1,5 +1,5 @@
-import { SQLiteCloudCommand, type SQLCloudRowsetMetadata, type SQLiteCloudDataTypes } from './types';
 import { SQLiteCloudRowset } from './rowset';
+import { SQLiteCloudCommand, type SQLCloudRowsetMetadata, type SQLiteCloudDataTypes } from './types';
 import { Buffer } from 'buffer';
 export declare const CMD_STRING = "+";
 export declare const CMD_ZEROSTRING = "!";
@@ -50,4 +50,4 @@ export declare function popData(buffer: Buffer): {
     fwdBuffer: Buffer;
 };
 /** Format a command to be sent via SCSP protocol */
-export declare function formatCommand(command: SQLiteCloudCommand): string;
+export declare function formatCommand(command: SQLiteCloudCommand): Buffer;

package/lib/drivers/protocol.js

@@ -15,8 +15,8 @@ exports.bufferEndsWith = bufferEndsWith;
 exports.parseRowsetChunks = parseRowsetChunks;
 exports.popData = popData;
 exports.formatCommand = formatCommand;
-const types_1 = require("./types");
 const rowset_1 = require("./rowset");
+const types_1 = require("./types");
 // explicitly importing buffer library to allow cross-platform support by replacing it
 const buffer_1 = require("buffer");
 // https://www.npmjs.com/package/lz4js
@@ -272,7 +272,17 @@ function popData(buffer) {
     // console.debug(`popData - dataType: ${dataType}, spaceIndex: ${spaceIndex}, commandLength: ${commandLength}, commandEnd: ${commandEnd}`)
     switch (dataType) {
         case exports.CMD_INT:
-            return popResults(parseInt(buffer.subarray(1, spaceIndex).toString()));
+            // SQLite uses 64-bit INTEGER, but JS uses 53-bit Number
+            const value = BigInt(buffer.subarray(1, spaceIndex).toString());
+            if (types_1.SAFE_INTEGER_MODE === 'bigint') {
+                return popResults(value);
+            }
+            if (types_1.SAFE_INTEGER_MODE === 'mixed') {
+                if (value <= BigInt(Number.MIN_SAFE_INTEGER) || BigInt(Number.MAX_SAFE_INTEGER) <= value) {
+                    return popResults(value);
+                }
+            }
+            return popResults(Number(value));
         case exports.CMD_FLOAT:
             return popResults(parseFloat(buffer.subarray(1, spaceIndex).toString()));
         case exports.CMD_NULL:
@@ -314,15 +324,15 @@ function formatCommand(command) {
 }
 function serializeCommand(data, zeroString = false) {
     const n = data.length;
-    let serializedData = `${n} `;
+    let serializedData = buffer_1.Buffer.from(`${n} `);
     for (let i = 0; i < n; i++) {
         // the first string is the sql and it must be zero-terminated
         const zs = i == 0 || zeroString;
-        serializedData += serializeData(data[i], zs);
+        serializedData = buffer_1.Buffer.concat([serializedData, serializeData(data[i], zs)]);
     }
-    const bytesTotal = buffer_1.Buffer.byteLength(serializedData, 'utf-8');
-    const header = `${exports.CMD_ARRAY}${bytesTotal} `;
-    return header + serializedData;
+    const bytesTotal = serializedData.byteLength;
+    const header = buffer_1.Buffer.from(`${exports.CMD_ARRAY}${bytesTotal} `);
+    return buffer_1.Buffer.concat([header, serializedData]);
 }
 function serializeData(data, zeroString = false) {
     if (typeof data === 'string') {
@@ -332,22 +342,25 @@ function serializeData(data, zeroString = false) {
             data += '\0';
         }
         const header = `${cmd}${buffer_1.Buffer.byteLength(data, 'utf-8')} `;
-        return header + data;
+        return buffer_1.Buffer.from(header + data);
     }
     if (typeof data === 'number') {
         if (Number.isInteger(data)) {
-            return `${exports.CMD_INT}${data} `;
+            return buffer_1.Buffer.from(`${exports.CMD_INT}${data} `);
         }
         else {
-            return `${exports.CMD_FLOAT}${data} `;
+            return buffer_1.Buffer.from(`${exports.CMD_FLOAT}${data} `);
         }
     }
+    if (typeof data === 'bigint') {
+        return buffer_1.Buffer.from(`${exports.CMD_INT}${data} `);
+    }
     if (buffer_1.Buffer.isBuffer(data)) {
-        const header = `${exports.CMD_BLOB}${data.length} `;
-        return header + data.toString('utf-8');
+        const header = `${exports.CMD_BLOB}${data.byteLength} `;
+        return buffer_1.Buffer.concat([buffer_1.Buffer.from(header), data]);
     }
     if (data === null || data === undefined) {
-        return `${exports.CMD_NULL} `;
+        return buffer_1.Buffer.from(`${exports.CMD_NULL} `);
     }
     if (Array.isArray(data)) {
         return serializeCommand(data, zeroString);

package/lib/drivers/types.d.ts

@@ -6,6 +6,16 @@ import tls from 'tls';
 export declare const DEFAULT_TIMEOUT: number;
 /** Default tls connection port */
 export declare const DEFAULT_PORT = 8860;
+/**
+ * Support to SQLite 64bit integer
+ *
+ * number - (default) always return Number type (max: 2^53 - 1)
+ *   Precision is lost when selecting greater numbers from SQLite
+ * bigint - always return BigInt type (max: 2^63 - 1) for all numbers from SQLite
+ *  (inlcuding `lastID` from WRITE statements)
+ * mixed - use BigInt and Number types depending on the value size
+ */
+export declare let SAFE_INTEGER_MODE: string;
 /**
  * Configuration for SQLite cloud connection
  * @note Options are all lowecase so they 1:1 compatible with C SDK
@@ -21,6 +31,8 @@ export interface SQLiteCloudConfig {
     password_hashed?: boolean;
     /** API key can be provided instead of username and password */
     apikey?: string;
+    /** Access Token provided in place of API Key or username/password */
+    token?: string;
     /** Host name is required unless connectionstring is provided, eg: xxx.sqlitecloud.io */
     host?: string;
     /** Port number for tls socket */

package/lib/drivers/types.js

@@ -2,12 +2,32 @@
 /**
  * types.ts - shared types and interfaces
  */
+var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SQLiteCloudArrayType = exports.SQLiteCloudError = exports.DEFAULT_PORT = exports.DEFAULT_TIMEOUT = void 0;
+exports.SQLiteCloudArrayType = exports.SQLiteCloudError = exports.SAFE_INTEGER_MODE = exports.DEFAULT_PORT = exports.DEFAULT_TIMEOUT = void 0;
 /** Default timeout value for queries */
 exports.DEFAULT_TIMEOUT = 300 * 1000;
 /** Default tls connection port */
 exports.DEFAULT_PORT = 8860;
+/**
+ * Support to SQLite 64bit integer
+ *
+ * number - (default) always return Number type (max: 2^53 - 1)
+ *   Precision is lost when selecting greater numbers from SQLite
+ * bigint - always return BigInt type (max: 2^63 - 1) for all numbers from SQLite
+ *  (inlcuding `lastID` from WRITE statements)
+ * mixed - use BigInt and Number types depending on the value size
+ */
+exports.SAFE_INTEGER_MODE = 'number';
+if (typeof process !== 'undefined') {
+    exports.SAFE_INTEGER_MODE = ((_a = process.env['SAFE_INTEGER_MODE']) === null || _a === void 0 ? void 0 : _a.toLowerCase()) || 'number';
+}
+if (exports.SAFE_INTEGER_MODE == 'bigint') {
+    console.debug('BigInt mode: Using Number for all INTEGER values from SQLite, including meta information from WRITE statements.');
+}
+if (exports.SAFE_INTEGER_MODE == 'mixed') {
+    console.debug('Mixed mode: Using BigInt for INTEGER values from SQLite (including meta information from WRITE statements) bigger then 2^53, Number otherwise.');
+}
 /** Custom error reported by SQLiteCloud drivers */
 class SQLiteCloudError extends Error {
     constructor(message, args) {

package/lib/drivers/utilities.js

@@ -15,7 +15,6 @@ exports.parseconnectionstring = parseconnectionstring;
 exports.parseBoolean = parseBoolean;
 exports.parseBooleanToZeroOne = parseBooleanToZeroOne;
 const types_1 = require("./types");
-const types_2 = require("./types");
 // explicitly importing these libraries to allow cross-platform support by replacing them
 const whatwg_url_1 = require("whatwg-url");
 //
@@ -46,42 +45,45 @@ function anonimizeError(error) {
 function getInitializationCommands(config) {
     // we check the credentials using non linearizable so we're quicker
     // then we bring back linearizability unless specified otherwise
-    let commands = 'SET CLIENT KEY NONLINEARIZABLE TO 1; ';
+    let commands = 'SET CLIENT KEY NONLINEARIZABLE TO 1;';
     // first user authentication, then all other commands
     if (config.apikey) {
-        commands += `AUTH APIKEY ${config.apikey}; `;
+        commands += `AUTH APIKEY ${config.apikey};`;
+    }
+    else if (config.token) {
+        commands += `AUTH TOKEN ${config.token};`;
     }
     else {
-        commands += `AUTH USER ${config.username || ''} ${config.password_hashed ? 'HASH' : 'PASSWORD'} ${config.password || ''}; `;
+        commands += `AUTH USER ${config.username || ''} ${config.password_hashed ? 'HASH' : 'PASSWORD'} ${config.password || ''};`;
     }
     if (config.compression) {
-        commands += 'SET CLIENT KEY COMPRESSION TO 1; ';
+        commands += 'SET CLIENT KEY COMPRESSION TO 1;';
     }
     if (config.zerotext) {
-        commands += 'SET CLIENT KEY ZEROTEXT TO 1; ';
+        commands += 'SET CLIENT KEY ZEROTEXT TO 1;';
     }
     if (config.noblob) {
-        commands += 'SET CLIENT KEY NOBLOB TO 1; ';
+        commands += 'SET CLIENT KEY NOBLOB TO 1;';
     }
     if (config.maxdata) {
-        commands += `SET CLIENT KEY MAXDATA TO ${config.maxdata}; `;
+        commands += `SET CLIENT KEY MAXDATA TO ${config.maxdata};`;
     }
     if (config.maxrows) {
-        commands += `SET CLIENT KEY MAXROWS TO ${config.maxrows}; `;
+        commands += `SET CLIENT KEY MAXROWS TO ${config.maxrows};`;
     }
     if (config.maxrowset) {
-        commands += `SET CLIENT KEY MAXROWSET TO ${config.maxrowset}; `;
+        commands += `SET CLIENT KEY MAXROWSET TO ${config.maxrowset};`;
     }
     // we ALWAYS set non linearizable to 1 when we start so we can be quicker on login
     // but then we need to put it back to its default value if "linearizable" unless set
     if (!config.non_linearizable) {
-        commands += 'SET CLIENT KEY NONLINEARIZABLE TO 0; ';
+        commands += 'SET CLIENT KEY NONLINEARIZABLE TO 0;';
     }
     if (config.database) {
         if (config.create && !config.memory) {
-            commands += `CREATE DATABASE ${config.database} IF NOT EXISTS; `;
+            commands += `CREATE DATABASE ${config.database} IF NOT EXISTS;`;
         }
-        commands += `USE DATABASE ${config.database}; `;
+        commands += `USE DATABASE ${config.database};`;
     }
     return commands;
 }
@@ -102,15 +104,14 @@ function getUpdateResults(results) {
     if (results) {
         if (Array.isArray(results) && results.length > 0) {
             switch (results[0]) {
-                case types_2.SQLiteCloudArrayType.ARRAY_TYPE_SQLITE_EXEC:
+                case types_1.SQLiteCloudArrayType.ARRAY_TYPE_SQLITE_EXEC:
                     return {
-                        type: results[0],
-                        index: results[1],
+                        type: Number(results[0]),
+                        index: Number(results[1]),
                         lastID: results[2], // ROWID (sqlite3_last_insert_rowid)
                         changes: results[3], // CHANGES(sqlite3_changes)
                         totalChanges: results[4], // TOTAL_CHANGES (sqlite3_total_changes)
-                        finalized: results[5], // FINALIZED
-                        //
+                        finalized: Number(results[5]), // FINALIZED
                         rowId: results[2] // same as lastId
                     };
             }
@@ -159,15 +160,19 @@ function validateConfiguration(config) {
     config.create = parseBoolean(config.create);
     config.non_linearizable = parseBoolean(config.non_linearizable);
     config.insecure = parseBoolean(config.insecure);
-    const hasCredentials = (config.username && config.password) || config.apikey;
+    const hasCredentials = (config.username && config.password) || config.apikey || config.token;
     if (!config.host || !hasCredentials) {
         console.error('SQLiteCloudConnection.validateConfiguration - missing arguments', config);
-        throw new types_1.SQLiteCloudError('The user, password and host arguments or the ?apikey= must be specified.', { errorCode: 'ERR_MISSING_ARGS' });
+        throw new types_1.SQLiteCloudError('The user, password and host arguments, the ?apikey= or the ?token= must be specified.', { errorCode: 'ERR_MISSING_ARGS' });
     }
     if (!config.connectionstring) {
         // build connection string from configuration, values are already validated
+        config.connectionstring = `sqlitecloud://${config.host}:${config.port}/${config.database || ''}`;
         if (config.apikey) {
-            config.connectionstring = `sqlitecloud://${config.host}:${config.port}/${config.database || ''}?apikey=${config.apikey}`;
+            config.connectionstring += `?apikey=${config.apikey}`;
+        }
+        else if (config.token) {
+            config.connectionstring += `?token=${config.token}`;
         }
         else {
             config.connectionstring = `sqlitecloud://${encodeURIComponent(config.username || '')}:${encodeURIComponent(config.password || '')}@${config.host}:${config.port}/${config.database}`;
@@ -192,16 +197,15 @@ function parseconnectionstring(connectionstring) {
         // all lowecase options
         const options = {};
         url.searchParams.forEach((value, key) => {
-            options[key.toLowerCase().replace(/-/g, '_')] = value;
+            options[key.toLowerCase().replace(/-/g, '_')] = value.trim();
         });
-        const config = Object.assign({ username: decodeURIComponent(url.username), password: decodeURIComponent(url.password), host: url.hostname, port: url.port ? parseInt(url.port) : undefined }, options);
-        // either you use an apikey or username and password
-        if (config.apikey) {
-            if (config.username || config.password) {
-                console.warn('SQLiteCloudConnection.parseconnectionstring - apikey and username/password are both specified, using apikey');
-            }
-            delete config.username;
-            delete config.password;
+        const config = Object.assign(Object.assign({}, options), { username: url.username ? decodeURIComponent(url.username) : undefined, password: url.password ? decodeURIComponent(url.password) : undefined, password_hashed: options.password_hashed ? parseBoolean(options.password_hashed) : undefined, host: url.hostname, 
+            // type cast values
+            port: url.port ? parseInt(url.port) : undefined, insecure: options.insecure ? parseBoolean(options.insecure) : undefined, timeout: options.timeout ? parseInt(options.timeout) : undefined, zerotext: options.zerotext ? parseBoolean(options.zerotext) : undefined, create: options.create ? parseBoolean(options.create) : undefined, memory: options.memory ? parseBoolean(options.memory) : undefined, compression: options.compression ? parseBoolean(options.compression) : undefined, non_linearizable: options.non_linearizable ? parseBoolean(options.non_linearizable) : undefined, noblob: options.noblob ? parseBoolean(options.noblob) : undefined, maxdata: options.maxdata ? parseInt(options.maxdata) : undefined, maxrows: options.maxrows ? parseInt(options.maxrows) : undefined, maxrowset: options.maxrowset ? parseInt(options.maxrowset) : undefined, usewebsocket: options.usewebsocket ? parseBoolean(options.usewebsocket) : undefined, verbose: options.verbose ? parseBoolean(options.verbose) : undefined });
+        // either you use an apikey, token or username and password
+        if (Number(!!config.apikey) + Number(!!config.token) + Number(!!(config.username || config.password)) > 1) {
+            console.error('SQLiteCloudConnection.parseconnectionstring - choose between apikey, token or username/password');
+            throw new types_1.SQLiteCloudError('Choose between apikey, token or username/password');
         }
         const database = url.pathname.replace('/', ''); // pathname is database name, remove the leading slash
         if (database) {
@@ -210,7 +214,7 @@ function parseconnectionstring(connectionstring) {
         return config;
     }
     catch (error) {
-        throw new types_1.SQLiteCloudError(`Invalid connection string: ${connectionstring}`);
+        throw new types_1.SQLiteCloudError(`Invalid connection string: ${connectionstring} - error: ${error}`);
     }
 }
 /** Returns true if value is 1 or true */