@sqlitecloud/drivers 0.0.56 → 1.0.178

package/README.md

@@ -18,6 +18,7 @@ npm install @sqlitecloud/drivers
 import { Database } from '@sqlitecloud/drivers'
 
 let database = new Database('sqlitecloud://user:password@xxx.sqlite.cloud:8860/chinook.sqlite')
+// or use sqlitecloud://xxx.sqlite.cloud:8860?apikey=xxxxxxx
 
 let name = 'Breaking The Rules'
 

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

@@ -4,7 +4,7 @@
 import { type SQLiteCloudConfig, type ErrorCallback, type ResultsCallback } from './types';
 import { SQLiteCloudConnection } from './connection';
 /**
- * Implementation of SQLiteCloudConnection that connects to the database using specific Bun APIs
+ * 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.
  */
 export declare class SQLiteCloudTlsConnection extends SQLiteCloudConnection {

package/lib/drivers/connection-tls.js

@@ -33,7 +33,7 @@ const utilities_1 = require("./utilities");
 const protocol_1 = require("./protocol");
 const tls = __importStar(require("tls"));
 /**
- * Implementation of SQLiteCloudConnection that connects to the database using specific Bun APIs
+ * 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.
  */
 class SQLiteCloudTlsConnection extends connection_1.SQLiteCloudConnection {
@@ -65,7 +65,7 @@ class SQLiteCloudTlsConnection extends connection_1.SQLiteCloudConnection {
         const connectionOptions = {
             host: config.host,
             port: config.port,
-            rejectUnauthorized: false,
+            rejectUnauthorized: config.host != 'localhost',
             // Server name for the SNI (Server Name Indication) TLS extension.
             // https://r2.nodejs.org/docs/v6.11.4/api/tls.html#tls_class_tls_tlssocket
             servername: config.host

package/lib/drivers/connection-ws.js

@@ -27,9 +27,9 @@ class SQLiteCloudWebsocketConnection extends connection_1.SQLiteCloudConnection
             console.assert(!this.connected, 'Connection already established');
             if (!this.socket) {
                 this.config = config;
-                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 } });
+                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 } });
             }
             callback === null || callback === void 0 ? void 0 : callback.call(this, null);
         }

package/lib/drivers/connection.d.ts

@@ -8,7 +8,7 @@ import { OperationsQueue } from './queue';
  * Actual connection management and communication with the server in concrete classes.
  */
 export declare abstract class SQLiteCloudConnection {
-    /** Parse and validate provided connectionString or configuration */
+    /** 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;
@@ -29,6 +29,16 @@ export declare abstract class SQLiteCloudConnection {
     verbose(): void;
     /** Will enquee a command to be executed and callback with the resulting rowset/result/error */
     sendCommands(commands: string, callback?: ResultsCallback): this;
+    /**
+     * 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>;
     /** Disconnect from server, release transport. */
     abstract close(): this;
 }

package/lib/drivers/connection.js

@@ -2,6 +2,15 @@
 /**
  * connection.ts - base abstract class for sqlitecloud server connections
  */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SQLiteCloudConnection = void 0;
 const types_1 = require("./types");
@@ -13,12 +22,12 @@ const utilities_2 = require("./utilities");
  * Actual connection management and communication with the server in concrete classes.
  */
 class SQLiteCloudConnection {
-    /** Parse and validate provided connectionString or configuration */
+    /** Parse and validate provided connectionstring or configuration */
     constructor(config, callback) {
         /** Operations are serialized by waiting an any pending promises */
         this.operations = new queue_1.OperationsQueue();
         if (typeof config === 'string') {
-            this.config = (0, utilities_1.validateConfiguration)({ connectionString: config });
+            this.config = (0, utilities_1.validateConfiguration)({ connectionstring: config });
         }
         else {
             this.config = (0, utilities_1.validateConfiguration)(config);
@@ -53,7 +62,7 @@ class SQLiteCloudConnection {
     log(message, ...optionalParams) {
         if (this.config.verbose) {
             message = (0, utilities_2.anonimizeCommand)(message);
-            console.log(`${new Date().toISOString()} ${this.config.clientId}: ${message}`, ...optionalParams);
+            console.log(`${new Date().toISOString()} ${this.config.clientid}: ${message}`, ...optionalParams);
         }
     }
     /** Enable verbose logging for debug purposes */
@@ -77,5 +86,51 @@ class SQLiteCloudConnection {
         });
         return this;
     }
+    /**
+     * 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, ...values) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let preparedSql = '';
+            // sql is a TemplateStringsArray, the 'raw' property is specific to TemplateStringsArray
+            if (Array.isArray(sql) && 'raw' in sql) {
+                sql.forEach((string, i) => {
+                    preparedSql += string + (i < values.length ? '?' : '');
+                });
+                preparedSql = (0, utilities_1.prepareSql)(preparedSql, ...values);
+            }
+            else {
+                if (typeof sql === 'string') {
+                    if ((values === null || values === void 0 ? void 0 : values.length) > 0) {
+                        preparedSql = (0, utilities_1.prepareSql)(sql, ...values);
+                    }
+                    else {
+                        preparedSql = sql;
+                    }
+                }
+                else {
+                    throw new Error('Invalid sql');
+                }
+            }
+            return new Promise((resolve, reject) => {
+                this.sendCommands(preparedSql, (error, results) => {
+                    if (error) {
+                        reject(error);
+                    }
+                    else {
+                        // metadata for operations like insert, update, delete?
+                        const context = (0, utilities_2.getUpdateResults)(results);
+                        resolve(context ? context : results);
+                    }
+                });
+            });
+        });
+    }
 }
 exports.SQLiteCloudConnection = SQLiteCloudConnection;

package/lib/drivers/database.js

@@ -58,7 +58,7 @@ class Database extends eventemitter3_1.default {
         super();
         /** Database connections */
         this.connections = [];
-        this.config = typeof config === 'string' ? { connectionString: config } : config;
+        this.config = typeof config === 'string' ? { connectionstring: config } : config;
         // mode is optional and so is callback
         // https://github.com/TryGhost/node-sqlite3/wiki/API#new-sqlite3databasefilename--mode--callback
         if (typeof mode === 'function') {
@@ -85,7 +85,7 @@ class Database extends eventemitter3_1.default {
         }
         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);
+            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
                 Promise.resolve().then(() => __importStar(require('./connection-ws'))).then(module => {
@@ -210,7 +210,7 @@ class Database extends eventemitter3_1.default {
                     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 ? undefined : results);
+                        callback === null || callback === void 0 ? void 0 : callback.call(context || this, null, context ? context : results);
                     }
                 });
             }

package/lib/drivers/types.d.ts

@@ -8,17 +8,22 @@ import tls from 'tls';
 export declare const DEFAULT_TIMEOUT: number;
 /** Default tls connection port */
 export declare const DEFAULT_PORT = 9960;
-/** Configuration for SQLite cloud connection */
+/**
+ * Configuration for SQLite cloud connection
+ * @note Options are all lowecase so they 1:1 compatible with C SDK
+ */
 export interface SQLiteCloudConfig {
     /** Connection string in the form of sqlitecloud://user:password@host:port/database?options */
-    connectionString?: string;
-    /** User name is required unless connectionString is provided */
+    connectionstring?: string;
+    /** User name is required unless connectionstring is provided */
     username?: string;
     /** Password is required unless connection string is provided */
     password?: string;
     /** True if password is hashed, default is false */
-    passwordHashed?: boolean;
-    /** Host name is required unless connectionString is provided, eg: xxx.sqlitecloud.io */
+    password_hashed?: boolean;
+    /** API key can be provided instead of username and password */
+    apikey?: string;
+    /** Host name is required unless connectionstring is provided, eg: xxx.sqlitecloud.io */
     host?: string;
     /** Port number for tls socket */
     port?: number;
@@ -28,29 +33,31 @@ export interface SQLiteCloudConfig {
     timeout?: number;
     /** Name of database to open */
     database?: string;
+    /** Flag to tell the server to zero-terminate strings */
+    zerotext?: boolean;
     /** Create the database if it doesn't exist? */
-    createDatabase?: boolean;
+    create?: boolean;
     /** Database will be created in memory */
-    dbMemory?: boolean;
+    memory?: boolean;
     compression?: boolean;
     /** Request for immediate responses from the server node without waiting for linerizability guarantees */
-    nonlinearizable?: boolean;
+    non_linearizable?: boolean;
     /** Server should send BLOB columns */
-    noBlob?: boolean;
+    noblob?: boolean;
     /** Do not send columns with more than max_data bytes */
-    maxData?: number;
+    maxdata?: number;
     /** Server should chunk responses with more than maxRows */
-    maxRows?: number;
+    maxrows?: number;
     /** Server should limit total number of rows in a set to maxRowset */
-    maxRowset?: number;
+    maxrowset?: number;
     /** Custom options and configurations for tls socket, eg: additional certificates */
-    tlsOptions?: tls.ConnectionOptions;
+    tlsoptions?: tls.ConnectionOptions;
     /** True if we should force use of SQLite Cloud Gateway and websocket connections, default: true in browsers, false in node.js */
-    useWebsocket?: boolean;
+    usewebsocket?: boolean;
     /** Url where we can connect to a SQLite Cloud Gateway that has a socket.io deamon waiting to connect, eg. wss://host:4000 */
-    gatewayUrl?: string;
+    gatewayurl?: string;
     /** Optional identifier used for verbose logging */
-    clientId?: string;
+    clientid?: string;
     /** True if connection should enable debug logs */
     verbose?: boolean;
 }
@@ -83,7 +90,7 @@ export interface SQLCloudRowsetMetadata {
     }[];
 }
 /** Basic types that can be returned by SQLiteCloud APIs */
-export type SQLiteCloudDataTypes = string | number | boolean | Record<string | number, unknown> | Buffer | null | undefined;
+export type SQLiteCloudDataTypes = string | number | bigint | boolean | Record<string | number, unknown> | Buffer | null | undefined;
 /** Custom error reported by SQLiteCloud drivers */
 export declare class SQLiteCloudError extends Error {
     constructor(message: string, args?: Partial<SQLiteCloudError>);

package/lib/drivers/utilities.d.ts

@@ -11,6 +11,8 @@ export declare function getInitializationCommands(config: SQLiteCloudConfig): st
 export declare function escapeSqlParameter(param: SQLiteCloudDataTypes): string;
 /** Take a sql statement and replaces ? or $named parameters that are properly serialized and escaped. */
 export declare function prepareSql(sql: string, ...params: (SQLiteCloudDataTypes | SQLiteCloudDataTypes[])[]): string;
+/** Converts results of an update or insert call into a more meaning full result set */
+export declare function getUpdateResults(results?: any): Record<string, any> | undefined;
 /**
  * Many of the methods in our API may contain a callback as their last argument.
  * This method will take the arguments array passed to the method and return an object
@@ -25,7 +27,13 @@ export declare function popCallback<T extends ErrorCallback = ErrorCallback>(arg
 };
 /** Validate configuration, apply defaults, throw if something is missing or misconfigured */
 export declare function validateConfiguration(config: SQLiteCloudConfig): SQLiteCloudConfig;
-/** Parse connectionString like sqlitecloud://username:password@host:port/database?option1=xxx&option2=xxx into its components */
-export declare function parseConnectionString(connectionString: string): SQLiteCloudConfig;
+/**
+ * Parse connectionstring like sqlitecloud://username:password@host:port/database?option1=xxx&option2=xxx
+ * or sqlitecloud://host.sqlite.cloud:8860/chinook.sqlite?apikey=mIiLARzKm9XBVllbAzkB1wqrgijJ3Gx0X5z1Agm3xBo
+ * into its basic components.
+ */
+export declare function parseconnectionstring(connectionstring: string): SQLiteCloudConfig;
 /** Returns true if value is 1 or true */
 export declare function parseBoolean(value: string | boolean | null | undefined): boolean;
+/** Returns true if value is 1 or true */
+export declare function parseBooleanToZeroOne(value: string | boolean | null | undefined): 0 | 1;

package/lib/drivers/utilities.js

@@ -3,8 +3,9 @@
 // utilities.ts - utility methods to manipulate SQL statements
 //
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseBoolean = exports.parseConnectionString = exports.validateConfiguration = exports.popCallback = exports.prepareSql = exports.escapeSqlParameter = exports.getInitializationCommands = exports.anonimizeError = exports.anonimizeCommand = exports.isNode = exports.isBrowser = void 0;
+exports.parseBooleanToZeroOne = exports.parseBoolean = exports.parseconnectionstring = exports.validateConfiguration = exports.popCallback = exports.getUpdateResults = exports.prepareSql = exports.escapeSqlParameter = exports.getInitializationCommands = exports.anonimizeError = exports.anonimizeCommand = exports.isNode = exports.isBrowser = void 0;
 const types_1 = require("./types");
+const types_2 = require("./types");
 //
 // determining running environment, thanks to browser-or-node
 // https://www.npmjs.com/package/browser-or-node
@@ -33,31 +34,44 @@ function anonimizeError(error) {
 exports.anonimizeError = anonimizeError;
 /** Initialization commands sent to database when connection is established */
 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; ';
     // 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.apikey) {
+        commands += `AUTH APIKEY ${config.apikey}; `;
+    }
+    else {
+        commands += `AUTH USER ${config.username || ''} ${config.password_hashed ? 'HASH' : 'PASSWORD'} ${config.password || ''}; `;
     }
     if (config.compression) {
         commands += 'SET CLIENT KEY COMPRESSION TO 1; ';
     }
-    if (config.nonlinearizable) {
-        commands += 'SET CLIENT KEY NONLINEARIZABLE TO 1; ';
+    if (config.zerotext) {
+        commands += 'SET CLIENT KEY ZEROTEXT TO 1; ';
     }
-    if (config.noBlob) {
+    if (config.noblob) {
         commands += 'SET CLIENT KEY NOBLOB TO 1; ';
     }
-    if (config.maxData) {
-        commands += `SET CLIENT KEY MAXDATA TO ${config.maxData}; `;
+    if (config.maxdata) {
+        commands += `SET CLIENT KEY MAXDATA TO ${config.maxdata}; `;
+    }
+    if (config.maxrows) {
+        commands += `SET CLIENT KEY MAXROWS TO ${config.maxrows}; `;
     }
-    if (config.maxRows) {
-        commands += `SET CLIENT KEY MAXROWS TO ${config.maxRows}; `;
+    if (config.maxrowset) {
+        commands += `SET CLIENT KEY MAXROWSET TO ${config.maxrowset}; `;
     }
-    if (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; ';
+    }
+    if (config.database) {
+        if (config.create && !config.memory) {
+            commands += `CREATE DATABASE ${config.database} IF NOT EXISTS; `;
+        }
+        commands += `USE DATABASE ${config.database}; `;
     }
     return commands;
 }
@@ -72,7 +86,7 @@ function escapeSqlParameter(param) {
         param = param.replace(/'/g, "''");
         return `'${param}'`;
     }
-    if (typeof param === 'number') {
+    if (typeof param === 'number' || typeof param === 'bigint') {
         return param.toString();
     }
     if (typeof param === 'boolean') {
@@ -128,6 +142,28 @@ function prepareSql(sql, ...params) {
     return preparedSql;
 }
 exports.prepareSql = prepareSql;
+/** Converts results of an update or insert call into a more meaning full result set */
+function getUpdateResults(results) {
+    if (results) {
+        if (Array.isArray(results) && results.length > 0) {
+            switch (results[0]) {
+                case types_2.SQLiteCloudArrayType.ARRAY_TYPE_SQLITE_EXEC:
+                    return {
+                        type: results[0],
+                        index: results[1],
+                        lastID: results[2],
+                        changes: results[3],
+                        totalChanges: results[4],
+                        finalized: results[5],
+                        //
+                        rowId: results[2] // same as lastId
+                    };
+            }
+        }
+    }
+    return undefined;
+}
+exports.getUpdateResults = getUpdateResults;
 /**
  * Many of the methods in our API may contain a callback as their last argument.
  * This method will take the arguments array passed to the method and return an object
@@ -154,47 +190,66 @@ exports.popCallback = popCallback;
 /** Validate configuration, apply defaults, throw if something is missing or misconfigured */
 function validateConfiguration(config) {
     console.assert(config, 'SQLiteCloudConnection.validateConfiguration - missing config');
-    if (config.connectionString) {
-        config = Object.assign(Object.assign(Object.assign({}, config), parseConnectionString(config.connectionString)), { connectionString: config.connectionString // keep original connection string
+    if (config.connectionstring) {
+        config = Object.assign(Object.assign(Object.assign({}, config), parseconnectionstring(config.connectionstring)), { connectionstring: config.connectionstring // keep original connection string
          });
     }
     // apply defaults where needed
     config.port || (config.port = types_1.DEFAULT_PORT);
     config.timeout = config.timeout && config.timeout > 0 ? config.timeout : types_1.DEFAULT_TIMEOUT;
-    config.clientId || (config.clientId = 'SQLiteCloud');
+    config.clientid || (config.clientid = 'SQLiteCloud');
     config.verbose = parseBoolean(config.verbose);
-    config.noBlob = parseBoolean(config.noBlob);
+    config.noblob = parseBoolean(config.noblob);
     config.compression = parseBoolean(config.compression);
-    config.createDatabase = parseBoolean(config.createDatabase);
-    config.nonlinearizable = parseBoolean(config.nonlinearizable);
+    config.create = parseBoolean(config.create);
+    config.non_linearizable = parseBoolean(config.non_linearizable);
     config.insecure = parseBoolean(config.insecure);
-    if (!config.username || !config.password || !config.host) {
+    const hasCredentials = (config.username && config.password) || config.apikey;
+    if (!config.host || !hasCredentials) {
         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' });
+        throw new types_1.SQLiteCloudError('The user, password and host arguments or the ?apikey= must be specified.', { errorCode: 'ERR_MISSING_ARGS' });
     }
-    if (!config.connectionString) {
+    if (!config.connectionstring) {
         // build connection string from configuration, values are already validated
         // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-        config.connectionString = `sqlitecloud://${encodeURIComponent(config.username)}:${encodeURIComponent(config.password)}@${config.host}:${config.port}/${config.database}`;
+        if (config.apikey) {
+            config.connectionstring = `sqlitecloud://${config.host}:${config.port}/${config.database || ''}?apikey=${config.apikey}`;
+        }
+        else {
+            config.connectionstring = `sqlitecloud://${encodeURIComponent(config.username || '')}:${encodeURIComponent(config.password || '')}@${config.host}:${config.port}/${config.database}`;
+        }
     }
     return config;
 }
 exports.validateConfiguration = validateConfiguration;
-/** Parse connectionString like sqlitecloud://username:password@host:port/database?option1=xxx&option2=xxx into its components */
-function parseConnectionString(connectionString) {
+/**
+ * Parse connectionstring like sqlitecloud://username:password@host:port/database?option1=xxx&option2=xxx
+ * or sqlitecloud://host.sqlite.cloud:8860/chinook.sqlite?apikey=mIiLARzKm9XBVllbAzkB1wqrgijJ3Gx0X5z1Agm3xBo
+ * into its basic components.
+ */
+function parseconnectionstring(connectionstring) {
     try {
         // The URL constructor throws a TypeError if the URL is not valid.
         // in spite of having the same structure as a regular url
         // protocol://username:password@host:port/database?option1=xxx&option2=xxx)
         // the sqlitecloud: protocol is not recognized by the URL constructor in browsers
         // so we need to replace it with https: to make it work
-        const knownProtocolUrl = connectionString.replace('sqlitecloud:', 'https:');
+        const knownProtocolUrl = connectionstring.replace('sqlitecloud:', 'https:');
         const url = new URL(knownProtocolUrl);
+        // all lowecase options
         const options = {};
         url.searchParams.forEach((value, key) => {
-            options[key] = value;
+            options[key.toLowerCase().replaceAll('-', '_')] = value;
         });
         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 database = url.pathname.replace('/', ''); // pathname is database name, remove the leading slash
         if (database) {
             config.database = database;
@@ -202,10 +257,10 @@ 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}`);
     }
 }
-exports.parseConnectionString = parseConnectionString;
+exports.parseconnectionstring = parseconnectionstring;
 /** Returns true if value is 1 or true */
 function parseBoolean(value) {
     if (typeof value === 'string') {
@@ -214,3 +269,11 @@ function parseBoolean(value) {
     return value ? true : false;
 }
 exports.parseBoolean = parseBoolean;
+/** Returns true if value is 1 or true */
+function parseBooleanToZeroOne(value) {
+    if (typeof value === 'string') {
+        return value.toLowerCase() === 'true' || value === '1' ? 1 : 0;
+    }
+    return value ? 1 : 0;
+}
+exports.parseBooleanToZeroOne = parseBooleanToZeroOne;

package/lib/index.d.ts

@@ -3,4 +3,4 @@ export { Statement } from './drivers/statement';
 export { SQLiteCloudConnection } from './drivers/connection';
 export { type SQLiteCloudConfig, type SQLCloudRowsetMetadata, SQLiteCloudError, type ResultsCallback, type ErrorCallback } from './drivers/types';
 export { SQLiteCloudRowset, SQLiteCloudRow } from './drivers/rowset';
-export { escapeSqlParameter, prepareSql, parseConnectionString, validateConfiguration } from './drivers/utilities';
+export { escapeSqlParameter, prepareSql, parseconnectionstring, validateConfiguration } from './drivers/utilities';

package/lib/index.js

@@ -3,7 +3,7 @@
 // index.ts - export drivers classes, utilities, types
 //
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateConfiguration = exports.parseConnectionString = exports.prepareSql = exports.escapeSqlParameter = exports.SQLiteCloudRow = exports.SQLiteCloudRowset = exports.SQLiteCloudError = exports.SQLiteCloudConnection = exports.Statement = exports.Database = void 0;
+exports.validateConfiguration = exports.parseconnectionstring = exports.prepareSql = exports.escapeSqlParameter = exports.SQLiteCloudRow = exports.SQLiteCloudRowset = exports.SQLiteCloudError = exports.SQLiteCloudConnection = exports.Statement = exports.Database = void 0;
 // include ONLY packages used by drivers
 // do NOT include anything related to gateway or bun or express
 // connection-tls does not want/need to load on browser and is loaded dynamically by Database
@@ -22,5 +22,5 @@ Object.defineProperty(exports, "SQLiteCloudRow", { enumerable: true, get: functi
 var utilities_1 = require("./drivers/utilities");
 Object.defineProperty(exports, "escapeSqlParameter", { enumerable: true, get: function () { return utilities_1.escapeSqlParameter; } });
 Object.defineProperty(exports, "prepareSql", { enumerable: true, get: function () { return utilities_1.prepareSql; } });
-Object.defineProperty(exports, "parseConnectionString", { enumerable: true, get: function () { return utilities_1.parseConnectionString; } });
+Object.defineProperty(exports, "parseconnectionstring", { enumerable: true, get: function () { return utilities_1.parseconnectionstring; } });
 Object.defineProperty(exports, "validateConfiguration", { enumerable: true, get: function () { return utilities_1.validateConfiguration; } });