@sqlitecloud/drivers 0.0.34

package/lib/database.js

@@ -0,0 +1,398 @@
+"use strict";
+//
+// database.ts - database driver api, implements and extends sqlite3
+//
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Database = void 0;
+// 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
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+const connection_1 = require("./connection");
+const rowset_1 = require("./rowset");
+const types_1 = require("./types");
+const utilities_1 = require("./utilities");
+const statement_1 = require("./statement");
+const eventemitter3_1 = __importDefault(require("eventemitter3"));
+// Uses eventemitter3 instead of node events for browser compatibility
+// https://github.com/primus/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.
+ */
+class Database extends eventemitter3_1.default {
+    constructor(config, mode, callback) {
+        super();
+        /** Database connections */
+        this.connections = [];
+        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') {
+            callback = mode;
+            mode = undefined;
+        }
+        // mode is ignored for now
+        // opens first connection to the database automatically
+        this.getConnection(callback);
+    }
+    //
+    // private methods
+    //
+    /** Returns first available connection from connection pool */
+    getConnection(callback) {
+        var _a;
+        // 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 {
+            this.connections.push(new connection_1.SQLiteCloudConnection(this.config, error => {
+                if (error) {
+                    this.handleError(this.connections[0], error, callback);
+                }
+                else {
+                    console.assert;
+                    callback === null || callback === void 0 ? void 0 : callback.call(this, null, this.connections[0]);
+                    this.emitEvent('open');
+                }
+            }));
+        }
+    }
+    /** Handles an error by closing the connection, calling the callback and/or emitting an error event */
+    handleError(connection, error, callback) {
+        // an errored connection is thrown out
+        if (connection) {
+            this.connections = this.connections.filter(c => c !== connection);
+            connection.close();
+        }
+        if (callback) {
+            callback.call(this, error);
+        }
+        else {
+            this.emitEvent('error', error);
+        }
+    }
+    /**
+     * 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
+     */
+    processContext(results) {
+        if (results) {
+            if (Array.isArray(results) && results.length > 0) {
+                switch (results[0]) {
+                    case types_1.SQLiteCloudArrayType.ARRAY_TYPE_SQLITE_EXEC:
+                        return {
+                            lastID: results[2],
+                            changes: results[3],
+                            totalChanges: results[4],
+                            finalized: results[5] // FINALIZED
+                        };
+                }
+            }
+        }
+        return undefined;
+    }
+    /** Emits given event with optional arguments on the next tick so callbacks can complete first */
+    emitEvent(event, ...args) {
+        setTimeout(() => {
+            this.emit(event, ...args);
+        }, 0);
+    }
+    //
+    // public methods
+    //
+    /**
+     * 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() {
+        return JSON.parse(JSON.stringify(this.config));
+    }
+    /** Enable verbose mode */
+    verbose() {
+        this.config.verbose = true;
+        for (const connection of this.connections) {
+            connection.verbose();
+        }
+        return this;
+    }
+    /** Set a configuration option for the database */
+    configure(_option, _value) {
+        // https://github.com/TryGhost/node-sqlite3/wiki/API#configureoption-value
+        return this;
+    }
+    run(sql, ...params) {
+        const { args, callback } = (0, utilities_1.popCallback)(params);
+        const preparedSql = (args === null || args === void 0 ? void 0 : args.length) > 0 ? (0, utilities_1.prepareSql)(sql, ...args) : sql;
+        this.getConnection((error, connection) => {
+            if (error || !connection) {
+                this.handleError(null, error, callback);
+            }
+            else {
+                connection.sendCommands(preparedSql, (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 ? undefined : results);
+                    }
+                });
+            }
+        });
+        return this;
+    }
+    get(sql, ...params) {
+        const { args, callback } = (0, utilities_1.popCallback)(params);
+        const preparedSql = (args === null || args === void 0 ? void 0 : args.length) > 0 ? (0, utilities_1.prepareSql)(sql, ...args) : sql;
+        this.getConnection((error, connection) => {
+            if (error || !connection) {
+                this.handleError(null, error, callback);
+            }
+            else {
+                connection.sendCommands(preparedSql, (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);
+                        }
+                    }
+                });
+            }
+        });
+        return this;
+    }
+    all(sql, ...params) {
+        const { args, callback } = (0, utilities_1.popCallback)(params);
+        const preparedSql = (args === null || args === void 0 ? void 0 : args.length) > 0 ? (0, utilities_1.prepareSql)(sql, ...args) : sql;
+        this.getConnection((error, connection) => {
+            if (error || !connection) {
+                this.handleError(null, error, callback);
+            }
+            else {
+                connection.sendCommands(preparedSql, (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);
+                        }
+                    }
+                });
+            }
+        });
+        return this;
+    }
+    each(sql, ...params) {
+        // extract optional parameters and one or two callbacks
+        const { args, callback, complete } = (0, utilities_1.popCallback)(params);
+        const preparedSql = (args === null || args === void 0 ? void 0 : args.length) > 0 ? (0, utilities_1.prepareSql)(sql, ...args) : sql;
+        this.getConnection((error, connection) => {
+            if (error || !connection) {
+                this.handleError(null, error, callback);
+            }
+            else {
+                connection.sendCommands(preparedSql, (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'));
+                        }
+                    }
+                });
+            }
+        });
+        return 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(sql, ...params) {
+        const { args, callback } = (0, utilities_1.popCallback)(params);
+        return new statement_1.Statement(this, sql, ...args, callback);
+    }
+    /**
+     * 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, callback) {
+        this.getConnection((error, connection) => {
+            if (error || !connection) {
+                this.handleError(null, 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);
+                    }
+                });
+            }
+        });
+        return 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) {
+        var _a;
+        if (((_a = this.connections) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+            for (const connection of this.connections) {
+                connection.close();
+            }
+        }
+        callback === null || callback === void 0 ? void 0 : callback.call(this, null);
+        this.emitEvent('close');
+    }
+    /**
+     * 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, callback) {
+        // TODO sqlitecloud-js / implement database loadExtension #17
+        if (callback) {
+            callback.call(this, new Error('Database.loadExtension - Not implemented'));
+        }
+        else {
+            this.emitEvent('error', new Error('Database.loadExtension - Not implemented'));
+        }
+        return 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() {
+        // TODO sqlitecloud-js / implement database interrupt #13
+    }
+    //
+    // extended APIs
+    //
+    /**
+     * 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.getConnection((error, connection) => {
+                    if (error || !connection) {
+                        reject(error);
+                    }
+                    else {
+                        connection.sendCommands(preparedSql, (error, results) => {
+                            if (error) {
+                                reject(error);
+                            }
+                            else {
+                                // metadata for operations like insert, update, delete?
+                                const context = this.processContext(results);
+                                resolve(context ? context : results);
+                            }
+                        });
+                    }
+                });
+            });
+        });
+    }
+}
+exports.Database = Database;

package/lib/index.d.ts

@@ -0,0 +1,7 @@
+export { Database } from './database';
+export { Statement } from './statement';
+export { SQLiteCloudConfig, SQLCloudRowsetMetadata, SQLiteCloudError, ErrorCallback } from './types';
+export { SQLiteCloudRowset, SQLiteCloudRow } from './rowset';
+export { SQLiteCloudConnection } from './connection';
+export { escapeSqlParameter, prepareSql } from './utilities';
+export { WebSocketTransport } from './transport-ws';

package/lib/index.js

@@ -0,0 +1,22 @@
+"use strict";
+//
+// index.ts - re-export public APIs
+//
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketTransport = exports.prepareSql = exports.escapeSqlParameter = exports.SQLiteCloudConnection = exports.SQLiteCloudRow = exports.SQLiteCloudRowset = exports.SQLiteCloudError = exports.Statement = exports.Database = void 0;
+var database_1 = require("./database");
+Object.defineProperty(exports, "Database", { enumerable: true, get: function () { return database_1.Database; } });
+var statement_1 = require("./statement");
+Object.defineProperty(exports, "Statement", { enumerable: true, get: function () { return statement_1.Statement; } });
+var types_1 = require("./types");
+Object.defineProperty(exports, "SQLiteCloudError", { enumerable: true, get: function () { return types_1.SQLiteCloudError; } });
+var rowset_1 = require("./rowset");
+Object.defineProperty(exports, "SQLiteCloudRowset", { enumerable: true, get: function () { return rowset_1.SQLiteCloudRowset; } });
+Object.defineProperty(exports, "SQLiteCloudRow", { enumerable: true, get: function () { return rowset_1.SQLiteCloudRow; } });
+var connection_1 = require("./connection");
+Object.defineProperty(exports, "SQLiteCloudConnection", { enumerable: true, get: function () { return connection_1.SQLiteCloudConnection; } });
+var utilities_1 = require("./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; } });
+var transport_ws_1 = require("./transport-ws");
+Object.defineProperty(exports, "WebSocketTransport", { enumerable: true, get: function () { return transport_ws_1.WebSocketTransport; } });

package/lib/rowset.d.ts

@@ -0,0 +1,36 @@
+import { SQLCloudRowsetMetadata, SQLiteCloudDataTypes } from './types';
+/** A single row in a dataset with values accessible by column name */
+export declare class SQLiteCloudRow {
+    #private;
+    constructor(rowset: SQLiteCloudRowset, columnsNames: string[], data: SQLiteCloudDataTypes[]);
+    /** Returns the rowset that this row belongs to */
+    getRowset(): SQLiteCloudRowset;
+    /** Returns rowset data as a plain array of values */
+    getData(): SQLiteCloudDataTypes[];
+    /** Column values are accessed by column name */
+    [columnName: string]: SQLiteCloudDataTypes;
+}
+export declare class SQLiteCloudRowset extends Array<SQLiteCloudRow> {
+    #private;
+    constructor(metadata: SQLCloudRowsetMetadata, data: any[]);
+    /**
+     * Rowset version is 1 for a rowset with simple column names, 2 for extended metadata
+     * @see https://github.com/sqlitecloud/sdk/blob/master/PROTOCOL.md
+     */
+    get version(): number;
+    /** Number of rows in row set */
+    get numberOfRows(): number;
+    /** Number of columns in row set */
+    get numberOfColumns(): number;
+    /** Array of columns names */
+    get columnsNames(): string[];
+    /** Get rowset metadata */
+    get metadata(): SQLCloudRowsetMetadata;
+    /** Return value of item at given row and column */
+    getItem(row: number, column: number): any;
+    /** Returns a subset of rows from this rowset */
+    slice(start?: number, end?: number): SQLiteCloudRow[];
+    map(fn: (row: SQLiteCloudRow, index: number, rowset: SQLiteCloudRow[]) => any): any[];
+    /** Returns an instance of SQLiteCloudRowset where rows have been filtered via given callback */
+    filter(fn: (row: SQLiteCloudRow, index: number, rowset: SQLiteCloudRow[]) => boolean): SQLiteCloudRow[];
+}

package/lib/rowset.js

@@ -0,0 +1,138 @@
+"use strict";
+//
+// rowset.ts
+//
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _SQLiteCloudRow_rowset, _SQLiteCloudRow_data, _SQLiteCloudRowset_metadata, _SQLiteCloudRowset_data;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQLiteCloudRowset = exports.SQLiteCloudRow = void 0;
+const types_1 = require("./types");
+/** A single row in a dataset with values accessible by column name */
+class SQLiteCloudRow {
+    constructor(rowset, columnsNames, data) {
+        // rowset is private
+        _SQLiteCloudRow_rowset.set(this, void 0);
+        // data is private
+        _SQLiteCloudRow_data.set(this, void 0);
+        __classPrivateFieldSet(this, _SQLiteCloudRow_rowset, rowset, "f");
+        __classPrivateFieldSet(this, _SQLiteCloudRow_data, data, "f");
+        for (let i = 0; i < columnsNames.length; i++) {
+            this[columnsNames[i]] = data[i];
+        }
+    }
+    /** Returns the rowset that this row belongs to */
+    // @ts-expect-error
+    getRowset() {
+        return __classPrivateFieldGet(this, _SQLiteCloudRow_rowset, "f");
+    }
+    /** Returns rowset data as a plain array of values */
+    // @ts-expect-error
+    getData() {
+        return __classPrivateFieldGet(this, _SQLiteCloudRow_data, "f");
+    }
+}
+exports.SQLiteCloudRow = SQLiteCloudRow;
+_SQLiteCloudRow_rowset = new WeakMap(), _SQLiteCloudRow_data = new WeakMap();
+/* A set of rows returned by a query */
+class SQLiteCloudRowset extends Array {
+    constructor(metadata, data) {
+        super(metadata.numberOfRows);
+        /** Metadata contains number of rows and columns, column names, types, etc.  */
+        _SQLiteCloudRowset_metadata.set(this, void 0);
+        /** Actual data organized in rows */
+        _SQLiteCloudRowset_data.set(this, void 0);
+        // console.assert(data !== undefined && data.length === metadata.numberOfRows * metadata.numberOfColumns, 'Invalid rowset data')
+        // console.assert(metadata !== undefined && metadata.columns.length === metadata.numberOfColumns, 'Invalid columns metadata')
+        __classPrivateFieldSet(this, _SQLiteCloudRowset_metadata, metadata, "f");
+        __classPrivateFieldSet(this, _SQLiteCloudRowset_data, data, "f");
+        // adjust missing column names, duplicate column names, etc.
+        const columnNames = this.columnsNames;
+        for (let i = 0; i < metadata.numberOfColumns; i++) {
+            if (!columnNames[i]) {
+                columnNames[i] = `column_${i}`;
+            }
+            let j = 0;
+            while (columnNames.findIndex((name, index) => index !== i && name === columnNames[i]) >= 0) {
+                columnNames[i] = `${columnNames[i]}_${j}`;
+                j++;
+            }
+        }
+        for (let i = 0, start = 0; i < metadata.numberOfRows; i++, start += metadata.numberOfColumns) {
+            this[i] = new SQLiteCloudRow(this, columnNames, data.slice(start, start + metadata.numberOfColumns));
+        }
+    }
+    /**
+     * Rowset version is 1 for a rowset with simple column names, 2 for extended metadata
+     * @see https://github.com/sqlitecloud/sdk/blob/master/PROTOCOL.md
+     */
+    get version() {
+        return __classPrivateFieldGet(this, _SQLiteCloudRowset_metadata, "f").version;
+    }
+    /** Number of rows in row set */
+    get numberOfRows() {
+        return __classPrivateFieldGet(this, _SQLiteCloudRowset_metadata, "f").numberOfRows;
+    }
+    /** Number of columns in row set */
+    get numberOfColumns() {
+        return __classPrivateFieldGet(this, _SQLiteCloudRowset_metadata, "f").numberOfColumns;
+    }
+    /** Array of columns names */
+    get columnsNames() {
+        return __classPrivateFieldGet(this, _SQLiteCloudRowset_metadata, "f").columns.map(column => column.name);
+    }
+    /** Get rowset metadata */
+    get metadata() {
+        return __classPrivateFieldGet(this, _SQLiteCloudRowset_metadata, "f");
+    }
+    /** Return value of item at given row and column */
+    getItem(row, column) {
+        if (row < 0 || row >= this.numberOfRows || column < 0 || column >= this.numberOfColumns) {
+            throw new types_1.SQLiteCloudError(`This rowset has ${this.numberOfColumns} columns by ${this.numberOfRows} rows, requested column ${column} and row ${row} is invalid.`);
+        }
+        return __classPrivateFieldGet(this, _SQLiteCloudRowset_data, "f")[row * this.numberOfColumns + column];
+    }
+    /** Returns a subset of rows from this rowset */
+    slice(start, end) {
+        // validate and apply boundaries
+        // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice
+        start = start === undefined ? 0 : start < 0 ? this.numberOfRows + start : start;
+        start = Math.min(Math.max(start, 0), this.numberOfRows);
+        end = end === undefined ? this.numberOfRows : end < 0 ? this.numberOfRows + end : end;
+        end = Math.min(Math.max(start, end), this.numberOfRows);
+        const slicedMetadata = Object.assign(Object.assign({}, __classPrivateFieldGet(this, _SQLiteCloudRowset_metadata, "f")), { numberOfRows: end - start });
+        const slicedData = __classPrivateFieldGet(this, _SQLiteCloudRowset_data, "f").slice(start * this.numberOfColumns, end * this.numberOfColumns);
+        console.assert(slicedData && slicedData.length === slicedMetadata.numberOfRows * slicedMetadata.numberOfColumns, 'SQLiteCloudRowset.slice - invalid rowset data');
+        return new SQLiteCloudRowset(slicedMetadata, slicedData);
+    }
+    map(fn) {
+        const results = [];
+        for (let i = 0; i < this.numberOfRows; i++) {
+            const row = this[i];
+            results.push(fn(row, i, this));
+        }
+        return results;
+    }
+    /** Returns an instance of SQLiteCloudRowset where rows have been filtered via given callback */
+    filter(fn) {
+        const filteredData = [];
+        for (let i = 0; i < this.numberOfRows; i++) {
+            const row = this[i];
+            if (fn(row, i, this)) {
+                filteredData.push(...__classPrivateFieldGet(this, _SQLiteCloudRowset_data, "f").slice(i * this.numberOfColumns, (i + 1) * this.numberOfColumns));
+            }
+        }
+        return new SQLiteCloudRowset(Object.assign(Object.assign({}, __classPrivateFieldGet(this, _SQLiteCloudRowset_metadata, "f")), { numberOfRows: filteredData.length / this.numberOfColumns }), filteredData);
+    }
+}
+exports.SQLiteCloudRowset = SQLiteCloudRowset;
+_SQLiteCloudRowset_metadata = new WeakMap(), _SQLiteCloudRowset_data = new WeakMap();