@connecttomahdi/rxdb 17.0.0-beta.17

package/dist/esm/plugins/storage-sqlite/sqlite-helpers.js

@@ -0,0 +1,187 @@
+import { PROMISE_RESOLVE_VOID, promiseWait, errorToPlainJson } from "../../index.js";
+export var NON_IMPLEMENTED_OPERATOR_QUERY_BATCH_SIZE = 50;
+export var DATABASE_STATE_BY_NAME = new Map();
+export var RX_STORAGE_NAME_SQLITE = 'sqlite';
+
+/**
+ * @link https://www.sqlite.org/inmemorydb.html
+ */
+export var SQLITE_IN_MEMORY_DB_NAME = ':memory:';
+export function getDatabaseConnection(sqliteBasics, databaseName) {
+  var state = DATABASE_STATE_BY_NAME.get(databaseName);
+  if (!state) {
+    state = {
+      database: sqliteBasics.open(databaseName),
+      sqliteBasics,
+      openConnections: 1
+    };
+    DATABASE_STATE_BY_NAME.set(databaseName, state);
+  } else {
+    if (state.sqliteBasics !== sqliteBasics && databaseName !== SQLITE_IN_MEMORY_DB_NAME) {
+      throw new Error('opened db with different creator method ' + databaseName + ' ' + state.sqliteBasics.debugId + ' ' + sqliteBasics.debugId);
+    }
+    state.openConnections = state.openConnections + 1;
+  }
+  return state.database;
+}
+export function closeDatabaseConnection(databaseName, sqliteBasics) {
+  var state = DATABASE_STATE_BY_NAME.get(databaseName);
+  if (state) {
+    state.openConnections = state.openConnections - 1;
+    if (state.openConnections === 0) {
+      DATABASE_STATE_BY_NAME.delete(databaseName);
+      return state.database.then(db => sqliteBasics.close(db));
+    }
+  }
+}
+export function getDataFromResultRow(row) {
+  if (!row) {
+    return row;
+  }
+  if (Array.isArray(row)) {
+    if (row[4]) {
+      return row[4];
+    } else {
+      return row[0];
+    }
+  } else {
+    return row.data;
+  }
+}
+export function getSQLiteInsertSQL(collectionName, primaryPath, docData) {
+  // language=SQL
+  var query = "\n        INSERT INTO \"" + collectionName + "\" (\n            id,\n            revision,\n            deleted,\n            lastWriteTime,\n            data\n        ) VALUES (\n            ?,\n            ?,\n            ?,\n            ?,\n            ?\n        );\n    ";
+  var params = [docData[primaryPath], docData._rev, docData._deleted ? 1 : 0, docData._meta.lwt, JSON.stringify(docData)];
+  return {
+    query,
+    params,
+    context: {
+      method: 'getSQLiteInsertSQL',
+      data: {
+        collectionName,
+        primaryPath
+      }
+    }
+  };
+}
+export function getSQLiteUpdateSQL(tableName, primaryPath, writeRow) {
+  var docData = writeRow.document;
+  // language=SQL
+  var query = "\n    UPDATE \"" + tableName + "\"\n    SET \n        revision = ?,\n        deleted = ?,\n        lastWriteTime = ?,\n        data = json(?)\n    WHERE\n        id = ?\n    ";
+  var params = [docData._rev, docData._deleted ? 1 : 0, docData._meta.lwt, JSON.stringify(docData), docData[primaryPath]];
+  return {
+    query,
+    params,
+    context: {
+      method: 'getSQLiteUpdateSQL',
+      data: {
+        tableName,
+        primaryPath
+      }
+    }
+  };
+}
+;
+export var TX_QUEUE_BY_DATABASE = new WeakMap();
+export function sqliteTransaction(database, sqliteBasics, handler,
+/**
+ * Context will be logged
+ * if the commit does error.
+ */
+context) {
+  var queue = TX_QUEUE_BY_DATABASE.get(database);
+  if (!queue) {
+    queue = PROMISE_RESOLVE_VOID;
+  }
+  queue = queue.then(async () => {
+    await openSqliteTransaction(database, sqliteBasics);
+    var handlerResult = await handler();
+    await finishSqliteTransaction(database, sqliteBasics, handlerResult, context);
+  });
+  TX_QUEUE_BY_DATABASE.set(database, queue);
+  return queue;
+}
+
+/**
+ * TODO instead of doing a while loop, we should find a way to listen when the
+ * other transaction is committed.
+ */
+export async function openSqliteTransaction(database, sqliteBasics) {
+  var openedTransaction = false;
+  while (!openedTransaction) {
+    try {
+      await sqliteBasics.run(database, {
+        query: 'BEGIN;',
+        params: [],
+        context: {
+          method: 'openSqliteTransaction',
+          data: ''
+        }
+      });
+      openedTransaction = true;
+    } catch (err) {
+      console.log('open transaction error (will retry):');
+      var errorAsJson = errorToPlainJson(err);
+      console.log(errorAsJson);
+      console.dir(err);
+      if (err.message && (err.message.includes('Database is closed') || err.message.includes('API misuse'))) {
+        throw err;
+      }
+      // wait one tick to not fully block the cpu on errors.
+      await promiseWait(0);
+    }
+  }
+  return;
+}
+export function finishSqliteTransaction(database, sqliteBasics, mode,
+/**
+ * Context will be logged
+ * if the commit does error.
+ */
+context) {
+  return sqliteBasics.run(database, {
+    query: mode + ';',
+    params: [],
+    context: {
+      method: 'finishSqliteTransaction',
+      data: mode
+    }
+  }).catch(err => {
+    if (context) {
+      console.error('cannot close transaction (mode: ' + mode + ')');
+      console.log(JSON.stringify(context, null, 4));
+    }
+    throw err;
+  });
+}
+export var PARAM_KEY = '?';
+export function ensureParamsCountIsCorrect(queryWithParams) {
+  var paramsCount = queryWithParams.params.length;
+  var paramKeyCount = queryWithParams.query.split(PARAM_KEY).length - 1;
+  if (paramsCount !== paramKeyCount) {
+    throw new Error('ensureParamsCountIsCorrect() wrong param count: ' + JSON.stringify(queryWithParams));
+  }
+}
+
+/**
+ * SQLite itself does not know about boolean types
+ * and uses integers instead.
+ * So some libraries need to bind integers and fail on booleans.
+ * @link https://stackoverflow.com/a/2452569/3443137
+ * This method transforms all boolean params to the
+ * correct int representation.
+ */
+export function boolParamsToInt(params) {
+  return params.map(p => {
+    if (typeof p === 'boolean') {
+      if (p) {
+        return 1;
+      } else {
+        return 0;
+      }
+    } else {
+      return p;
+    }
+  });
+}
+//# sourceMappingURL=sqlite-helpers.js.map

package/dist/esm/plugins/storage-sqlite/sqlite-helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-helpers.js","names":["PROMISE_RESOLVE_VOID","promiseWait","errorToPlainJson","NON_IMPLEMENTED_OPERATOR_QUERY_BATCH_SIZE","DATABASE_STATE_BY_NAME","Map","RX_STORAGE_NAME_SQLITE","SQLITE_IN_MEMORY_DB_NAME","getDatabaseConnection","sqliteBasics","databaseName","state","get","database","open","openConnections","set","Error","debugId","closeDatabaseConnection","delete","then","db","close","getDataFromResultRow","row","Array","isArray","data","getSQLiteInsertSQL","collectionName","primaryPath","docData","query","params","_rev","_deleted","_meta","lwt","JSON","stringify","context","method","getSQLiteUpdateSQL","tableName","writeRow","document","TX_QUEUE_BY_DATABASE","WeakMap","sqliteTransaction","handler","queue","openSqliteTransaction","handlerResult","finishSqliteTransaction","openedTransaction","run","err","console","log","errorAsJson","dir","message","includes","mode","catch","error","PARAM_KEY","ensureParamsCountIsCorrect","queryWithParams","paramsCount","length","paramKeyCount","split","boolParamsToInt","map","p"],"sources":["../../../../src/plugins/storage-sqlite/sqlite-helpers.ts"],"sourcesContent":["import {\r\n    BulkWriteRow,\r\n    RxDocumentData,\r\n    PROMISE_RESOLVE_VOID,\r\n    promiseWait,\r\n    errorToPlainJson,\r\n    MaybePromise\r\n} from '../../index.ts';\r\nimport type {\r\n    SQLResultRow,\r\n    SQLiteBasics,\r\n    SQLiteDatabaseClass,\r\n    SQLiteQueryWithParams\r\n} from './sqlite-types.ts';\r\n\r\nexport const NON_IMPLEMENTED_OPERATOR_QUERY_BATCH_SIZE = 50;\r\nexport type DatabaseState = {\r\n    database: Promise<SQLiteDatabaseClass>;\r\n    openConnections: number;\r\n    sqliteBasics: SQLiteBasics<SQLiteDatabaseClass>;\r\n}\r\nexport const DATABASE_STATE_BY_NAME: Map<string, DatabaseState> = new Map();\r\nexport const RX_STORAGE_NAME_SQLITE = 'sqlite';\r\n\r\n\r\n/**\r\n * @link https://www.sqlite.org/inmemorydb.html\r\n */\r\nexport const SQLITE_IN_MEMORY_DB_NAME = ':memory:';\r\n\r\nexport function getDatabaseConnection(\r\n    sqliteBasics: SQLiteBasics<any>,\r\n    databaseName: string\r\n): Promise<SQLiteDatabaseClass> {\r\n    let state = DATABASE_STATE_BY_NAME.get(databaseName);\r\n    if (!state) {\r\n        state = {\r\n            database: sqliteBasics.open(databaseName),\r\n            sqliteBasics,\r\n            openConnections: 1\r\n        };\r\n        DATABASE_STATE_BY_NAME.set(databaseName, state);\r\n    } else {\r\n        if (state.sqliteBasics !== sqliteBasics && databaseName !== SQLITE_IN_MEMORY_DB_NAME) {\r\n            throw new Error('opened db with different creator method ' + databaseName + ' ' + state.sqliteBasics.debugId + ' ' + sqliteBasics.debugId);\r\n        }\r\n        state.openConnections = state.openConnections + 1;\r\n    }\r\n    return state.database;\r\n}\r\n\r\nexport function closeDatabaseConnection(\r\n    databaseName: string,\r\n    sqliteBasics: SQLiteBasics<any>\r\n): MaybePromise<void> {\r\n    const state = DATABASE_STATE_BY_NAME.get(databaseName);\r\n    if (state) {\r\n        state.openConnections = state.openConnections - 1;\r\n        if (state.openConnections === 0) {\r\n            DATABASE_STATE_BY_NAME.delete(databaseName);\r\n            return state.database.then(db => sqliteBasics.close(db));\r\n        }\r\n    }\r\n}\r\n\r\nexport function getDataFromResultRow(row: SQLResultRow): string {\r\n    if (!row) {\r\n        return row;\r\n    }\r\n    if (Array.isArray(row)) {\r\n        if (row[4]) {\r\n            return row[4];\r\n        } else {\r\n            return row[0];\r\n        }\r\n    } else {\r\n        return row.data;\r\n    }\r\n}\r\n\r\nexport function getSQLiteInsertSQL<RxDocType>(\r\n    collectionName: string,\r\n    primaryPath: keyof RxDocType,\r\n    docData: RxDocumentData<RxDocType>\r\n): SQLiteQueryWithParams {\r\n    // language=SQL\r\n    const query = `\r\n        INSERT INTO \"${collectionName}\" (\r\n            id,\r\n            revision,\r\n            deleted,\r\n            lastWriteTime,\r\n            data\r\n        ) VALUES (\r\n            ?,\r\n            ?,\r\n            ?,\r\n            ?,\r\n            ?\r\n        );\r\n    `;\r\n    const params = [\r\n        docData[primaryPath] as string,\r\n        docData._rev,\r\n        docData._deleted ? 1 : 0,\r\n        docData._meta.lwt,\r\n        JSON.stringify(docData)\r\n    ];\r\n    return {\r\n        query,\r\n        params,\r\n        context: {\r\n            method: 'getSQLiteInsertSQL',\r\n            data: {\r\n                collectionName,\r\n                primaryPath\r\n            }\r\n        }\r\n    };\r\n}\r\n\r\nexport function getSQLiteUpdateSQL<RxDocType>(\r\n    tableName: string,\r\n    primaryPath: keyof RxDocType,\r\n    writeRow: BulkWriteRow<RxDocType>\r\n): SQLiteQueryWithParams {\r\n    const docData = writeRow.document;\r\n    // language=SQL\r\n    const query = `\r\n    UPDATE \"${tableName}\"\r\n    SET \r\n        revision = ?,\r\n        deleted = ?,\r\n        lastWriteTime = ?,\r\n        data = json(?)\r\n    WHERE\r\n        id = ?\r\n    `;\r\n    const params = [\r\n        docData._rev,\r\n        docData._deleted ? 1 : 0,\r\n        docData._meta.lwt,\r\n        JSON.stringify(docData),\r\n        docData[primaryPath] as string,\r\n    ];\r\n    return {\r\n        query,\r\n        params,\r\n        context: {\r\n            method: 'getSQLiteUpdateSQL',\r\n            data: {\r\n                tableName,\r\n                primaryPath\r\n            }\r\n        }\r\n    };\r\n};\r\n\r\n\r\nexport const TX_QUEUE_BY_DATABASE: WeakMap<SQLiteDatabaseClass, Promise<void>> = new WeakMap();\r\nexport function sqliteTransaction(\r\n    database: SQLiteDatabaseClass,\r\n    sqliteBasics: SQLiteBasics<any>,\r\n    handler: () => Promise<'COMMIT' | 'ROLLBACK'>,\r\n    /**\r\n     * Context will be logged\r\n     * if the commit does error.\r\n     */\r\n    context?: any\r\n) {\r\n    let queue = TX_QUEUE_BY_DATABASE.get(database);\r\n    if (!queue) {\r\n        queue = PROMISE_RESOLVE_VOID;\r\n    }\r\n    queue = queue.then(async () => {\r\n        await openSqliteTransaction(database, sqliteBasics);\r\n        const handlerResult = await handler();\r\n        await finishSqliteTransaction(database, sqliteBasics, handlerResult, context);\r\n    });\r\n    TX_QUEUE_BY_DATABASE.set(database, queue);\r\n    return queue;\r\n}\r\n\r\n/**\r\n * TODO instead of doing a while loop, we should find a way to listen when the\r\n * other transaction is committed.\r\n */\r\nexport async function openSqliteTransaction(\r\n    database: SQLiteDatabaseClass,\r\n    sqliteBasics: SQLiteBasics<any>\r\n) {\r\n    let openedTransaction = false;\r\n    while (!openedTransaction) {\r\n        try {\r\n            await sqliteBasics.run(\r\n                database,\r\n                {\r\n                    query: 'BEGIN;',\r\n                    params: [],\r\n                    context: {\r\n                        method: 'openSqliteTransaction',\r\n                        data: ''\r\n                    }\r\n                }\r\n            );\r\n            openedTransaction = true;\r\n        } catch (err: any) {\r\n            console.log('open transaction error (will retry):');\r\n            const errorAsJson = errorToPlainJson(err);\r\n            console.log(errorAsJson);\r\n            console.dir(err);\r\n            if (\r\n                err.message && (\r\n                    err.message.includes('Database is closed') ||\r\n                    err.message.includes('API misuse')\r\n                )\r\n            ) {\r\n                throw err;\r\n            }\r\n            // wait one tick to not fully block the cpu on errors.\r\n            await promiseWait(0);\r\n        }\r\n    }\r\n    return;\r\n}\r\nexport function finishSqliteTransaction(\r\n    database: SQLiteDatabaseClass,\r\n    sqliteBasics: SQLiteBasics<any>,\r\n    mode: 'COMMIT' | 'ROLLBACK',\r\n    /**\r\n     * Context will be logged\r\n     * if the commit does error.\r\n     */\r\n    context?: any\r\n) {\r\n    return sqliteBasics.run(\r\n        database,\r\n        {\r\n            query: mode + ';',\r\n            params: [],\r\n            context: {\r\n                method: 'finishSqliteTransaction',\r\n                data: mode\r\n            }\r\n        }\r\n    ).catch(err => {\r\n        if (context) {\r\n            console.error('cannot close transaction (mode: ' + mode + ')');\r\n            console.log(JSON.stringify(context, null, 4));\r\n        }\r\n        throw err;\r\n    });\r\n}\r\n\r\n\r\nexport const PARAM_KEY = '?';\r\n\r\n\r\nexport function ensureParamsCountIsCorrect(queryWithParams: SQLiteQueryWithParams) {\r\n    const paramsCount = queryWithParams.params.length;\r\n    const paramKeyCount = queryWithParams.query.split(PARAM_KEY).length - 1;\r\n    if (paramsCount !== paramKeyCount) {\r\n        throw new Error('ensureParamsCountIsCorrect() wrong param count: ' + JSON.stringify(queryWithParams));\r\n    }\r\n}\r\n\r\n/**\r\n * SQLite itself does not know about boolean types\r\n * and uses integers instead.\r\n * So some libraries need to bind integers and fail on booleans.\r\n * @link https://stackoverflow.com/a/2452569/3443137\r\n * This method transforms all boolean params to the\r\n * correct int representation.\r\n */\r\nexport function boolParamsToInt(params: any[]): any[] {\r\n    return params.map(p => {\r\n        if (typeof p === 'boolean') {\r\n            if (p) {\r\n                return 1;\r\n            } else {\r\n                return 0;\r\n            }\r\n        } else {\r\n            return p;\r\n        }\r\n    });\r\n}\r\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/plugins/storage-sqlite/sqlite-storage-instance.js

@@ -0,0 +1,283 @@
+import _readOnlyError from "@babel/runtime/helpers/readOnlyError";
+import { getPrimaryFieldOfPrimaryKey, categorizeBulkWriteRows, ensureNotFalsy, addRxStorageMultiInstanceSupport, promiseWait, getQueryMatcher, hasPremiumFlag } from "../../index.js";
+import { BehaviorSubject, Subject, filter, firstValueFrom } from 'rxjs';
+import { closeDatabaseConnection, ensureParamsCountIsCorrect, getDatabaseConnection, getSQLiteUpdateSQL, RX_STORAGE_NAME_SQLITE, sqliteTransaction, getDataFromResultRow, getSQLiteInsertSQL, TX_QUEUE_BY_DATABASE } from "./sqlite-helpers.js";
+import { getSortComparator } from "../../rx-query-helper.js";
+import { newRxError } from "../../rx-error.js";
+var shownNonPremiumLog = false;
+var instanceId = 0;
+export var RxStorageInstanceSQLite = /*#__PURE__*/function () {
+  function RxStorageInstanceSQLite(storage, databaseName, collectionName, schema, internals, options, settings, tableName, devMode) {
+    this.changes$ = new Subject();
+    this.instanceId = instanceId++;
+    this.openWriteCount$ = new BehaviorSubject(0);
+    this.opCount = 0;
+    this.storage = storage;
+    this.databaseName = databaseName;
+    this.collectionName = collectionName;
+    this.schema = schema;
+    this.internals = internals;
+    this.options = options;
+    this.settings = settings;
+    this.tableName = tableName;
+    this.devMode = devMode;
+    this.sqliteBasics = storage.settings.sqliteBasics;
+    this.primaryPath = getPrimaryFieldOfPrimaryKey(this.schema.primaryKey);
+  }
+  var _proto = RxStorageInstanceSQLite.prototype;
+  _proto.run = function run(db, queryWithParams) {
+    if (this.devMode) {
+      ensureParamsCountIsCorrect(queryWithParams);
+    }
+    return this.sqliteBasics.run(db, queryWithParams);
+  };
+  _proto.all = function all(db, queryWithParams) {
+    if (this.devMode) {
+      ensureParamsCountIsCorrect(queryWithParams);
+    }
+    this.opCount = this.opCount + 1;
+    if (this.opCount > 500) {
+      throw newRxError('SQL3');
+    }
+    return this.sqliteBasics.all(db, queryWithParams);
+  }
+
+  /**
+   * @link https://medium.com/@JasonWyatt/squeezing-performance-from-sqlite-insertions-971aff98eef2
+   */;
+  _proto.bulkWrite = async function bulkWrite(documentWrites, context) {
+    this.openWriteCount$.next(this.openWriteCount$.getValue() + 1);
+    var database = await this.internals.databasePromise;
+    var ret = {
+      error: []
+    };
+    var writePromises = [];
+    var categorized = {};
+    if (!shownNonPremiumLog && !(await hasPremiumFlag())) {
+      console.warn(['-------------- RxDB SQLite Trial Storage ---------------------------------', 'You are using the free *trial* SQLite-based RxStorage implementation: https://rxdb.info/rx-storage-sqlite.html?console=sqlite-trial', 'This storage is intended only for evaluation purposes and comes with strict limitations (no indexes, no attachments, and a ~300-document cap).', 'For production use and optimal performance, we strongly recommend upgrading to the premium SQLite storage.', 'Premium version: https://rxdb.info/premium/?console=sqlite', 'If you already have premium access, you can disable this message by calling setPremiumFlag() from rxdb-premium/plugins/shared.', '----------------------------------------------------------------------------'].join('\n'));
+      shownNonPremiumLog = true;
+    } else {
+      shownNonPremiumLog = true;
+    }
+    await sqliteTransaction(database, this.sqliteBasics, async () => {
+      if (this.closed) {
+        this.openWriteCount$.next(this.openWriteCount$.getValue() - 1);
+        throw new Error('SQLite.bulkWrite(' + context + ') already closed ' + this.tableName + ' context: ' + context);
+      }
+      var result = await this.all(database, {
+        query: "SELECT data FROM \"" + this.tableName + "\"",
+        params: [],
+        context: {
+          method: 'bulkWrite',
+          data: documentWrites
+        }
+      });
+      var docsInDb = new Map();
+      result.forEach(docSQLResult => {
+        var doc = JSON.parse(getDataFromResultRow(docSQLResult));
+        var id = doc[this.primaryPath];
+        docsInDb.set(id, doc);
+      });
+      categorized = categorizeBulkWriteRows(this, this.primaryPath, docsInDb, documentWrites, context);
+      ret.error = categorized.errors;
+      if (result.length + categorized.bulkInsertDocs.length > 300) {
+        throw newRxError('SQL2');
+      }
+      categorized.bulkInsertDocs.forEach(row => {
+        var insertQuery = getSQLiteInsertSQL(this.tableName, this.primaryPath, row.document);
+        writePromises.push(this.all(database, {
+          query: insertQuery.query,
+          params: insertQuery.params,
+          context: {
+            method: 'bulkWrite',
+            data: categorized
+          }
+        }));
+      });
+      categorized.bulkUpdateDocs.forEach(row => {
+        var updateQuery = getSQLiteUpdateSQL(this.tableName, this.primaryPath, row);
+        writePromises.push(this.run(database, updateQuery));
+      });
+      await Promise.all(writePromises);
+
+      // close transaction
+      if (this.closed) {
+        this.openWriteCount$.next(this.openWriteCount$.getValue() - 1);
+        return 'ROLLBACK';
+      } else {
+        this.openWriteCount$.next(this.openWriteCount$.getValue() - 1);
+        return 'COMMIT';
+      }
+    }, {
+      databaseName: this.databaseName,
+      collectionName: this.collectionName
+    });
+    if (categorized && categorized.eventBulk.events.length > 0) {
+      var lastState = ensureNotFalsy(categorized.newestRow).document;
+      categorized.eventBulk.checkpoint = {
+        id: lastState[this.primaryPath],
+        lwt: lastState._meta.lwt
+      };
+      this.changes$.next(categorized.eventBulk);
+    }
+    return ret;
+  };
+  _proto.query = async function query(originalPreparedQuery) {
+    var database = await this.internals.databasePromise;
+    var result = [];
+    var query = originalPreparedQuery.query;
+    var skip = query.skip ? query.skip : 0;
+    var limit = query.limit ? query.limit : Infinity;
+    var skipPlusLimit = skip + limit;
+    var queryMatcher = getQueryMatcher(this.schema, query);
+    var subResult = await this.all(database, {
+      query: 'SELECT data FROM "' + this.tableName + '"',
+      params: [],
+      context: {
+        method: 'query',
+        data: originalPreparedQuery
+      }
+    });
+    subResult.forEach(row => {
+      var docData = JSON.parse(getDataFromResultRow(row));
+      if (queryMatcher(docData)) {
+        result.push(docData);
+      }
+    });
+    var sortComparator = getSortComparator(this.schema, query);
+    result = result.sort(sortComparator);
+    result = result.slice(skip, skipPlusLimit);
+    return {
+      documents: result
+    };
+  };
+  _proto.count = async function count(originalPreparedQuery) {
+    var results = await this.query(originalPreparedQuery);
+    return {
+      count: results.documents.length,
+      mode: 'fast'
+    };
+  };
+  _proto.findDocumentsById = async function findDocumentsById(ids, withDeleted) {
+    var database = await this.internals.databasePromise;
+    if (this.closed) {
+      throw new Error('SQLite.findDocumentsById() already closed ' + this.tableName);
+    }
+    var result = await this.all(database, {
+      query: "SELECT data FROM \"" + this.tableName + "\"",
+      params: [],
+      context: {
+        method: 'findDocumentsById',
+        data: ids
+      }
+    });
+    var ret = [];
+    for (var i = 0; i < result.length; ++i) {
+      var resultRow = result[i];
+      var doc = JSON.parse(getDataFromResultRow(resultRow));
+      if (ids.includes(doc[this.primaryPath]) && (withDeleted || !doc._deleted)) {
+        ret.push(doc);
+      }
+    }
+    return ret;
+  };
+  _proto.changeStream = function changeStream() {
+    return this.changes$.asObservable();
+  };
+  _proto.cleanup = async function cleanup(minimumDeletedTime) {
+    await promiseWait(0);
+    await promiseWait(0);
+    var database = await this.internals.databasePromise;
+
+    /**
+     * Purge deleted documents
+     */
+    var minTimestamp = new Date().getTime() - minimumDeletedTime;
+    await this.all(database, {
+      query: "\n                    DELETE FROM\n                        \"" + this.tableName + "\"\n                    WHERE\n                        deleted = 1\n                        AND\n                        lastWriteTime < ?\n                ",
+      params: [minTimestamp],
+      context: {
+        method: 'cleanup',
+        data: minimumDeletedTime
+      }
+    });
+    return true;
+  };
+  _proto.getAttachmentData = async function getAttachmentData(_documentId, _attachmentId) {
+    throw newRxError('SQL1');
+  };
+  _proto.remove = async function remove() {
+    if (this.closed) {
+      throw new Error('closed already');
+    }
+    var database = await this.internals.databasePromise;
+    var promises = [this.run(database, {
+      query: "DROP TABLE IF EXISTS \"" + this.tableName + "\"",
+      params: [],
+      context: {
+        method: 'remove',
+        data: this.tableName
+      }
+    })];
+    await Promise.all(promises);
+    return this.close();
+  };
+  _proto.close = async function close() {
+    var queue = TX_QUEUE_BY_DATABASE.get(await this.internals.databasePromise);
+    if (queue) {
+      await queue;
+    }
+    if (this.closed) {
+      return this.closed;
+    }
+    this.closed = (async () => {
+      await firstValueFrom(this.openWriteCount$.pipe(filter(v => v === 0)));
+      var database = await this.internals.databasePromise;
+
+      /**
+       * First get a transaction
+       * to ensure currently running operations
+       * are finished
+       */
+      await sqliteTransaction(database, this.sqliteBasics, () => {
+        return Promise.resolve('COMMIT');
+      }).catch(() => {});
+      this.changes$.complete();
+      await closeDatabaseConnection(this.databaseName, this.storage.settings.sqliteBasics);
+    })();
+    return this.closed;
+  };
+  return RxStorageInstanceSQLite;
+}();
+export async function createSQLiteTrialStorageInstance(storage, params, settings) {
+  var sqliteBasics = settings.sqliteBasics;
+  var tableName = params.collectionName + '-' + params.schema.version;
+  if (params.schema.attachments) {
+    throw newRxError('SQL1');
+  }
+  var internals = {};
+  var useDatabaseName = (settings.databaseNamePrefix ? settings.databaseNamePrefix : '') + '_trial_' + params.databaseName;
+  internals.databasePromise = getDatabaseConnection(storage.settings.sqliteBasics, useDatabaseName).then(async database => {
+    await sqliteTransaction(database, sqliteBasics, async () => {
+      var tableQuery = "\n                CREATE TABLE IF NOT EXISTS \"" + tableName + "\"(\n                    id TEXT NOT NULL PRIMARY KEY UNIQUE,\n                    revision TEXT,\n                    deleted BOOLEAN NOT NULL CHECK (deleted IN (0, 1)),\n                    lastWriteTime INTEGER NOT NULL,\n                    data json\n                );\n                ";
+      await sqliteBasics.run(database, {
+        query: tableQuery,
+        params: [],
+        context: {
+          method: 'createSQLiteStorageInstance create tables',
+          data: params.databaseName
+        }
+      });
+      return 'COMMIT';
+    }, {
+      indexCreation: false,
+      databaseName: params.databaseName,
+      collectionName: params.collectionName
+    });
+    return database;
+  });
+  var instance = new RxStorageInstanceSQLite(storage, params.databaseName, params.collectionName, params.schema, internals, params.options, settings, tableName, params.devMode);
+  await addRxStorageMultiInstanceSupport(RX_STORAGE_NAME_SQLITE, params, instance);
+  return instance;
+}
+//# sourceMappingURL=sqlite-storage-instance.js.map

package/dist/esm/plugins/storage-sqlite/sqlite-storage-instance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-storage-instance.js","names":["getPrimaryFieldOfPrimaryKey","categorizeBulkWriteRows","ensureNotFalsy","addRxStorageMultiInstanceSupport","promiseWait","getQueryMatcher","hasPremiumFlag","BehaviorSubject","Subject","filter","firstValueFrom","closeDatabaseConnection","ensureParamsCountIsCorrect","getDatabaseConnection","getSQLiteUpdateSQL","RX_STORAGE_NAME_SQLITE","sqliteTransaction","getDataFromResultRow","getSQLiteInsertSQL","TX_QUEUE_BY_DATABASE","getSortComparator","newRxError","shownNonPremiumLog","instanceId","RxStorageInstanceSQLite","storage","databaseName","collectionName","schema","internals","options","settings","tableName","devMode","changes$","openWriteCount$","opCount","sqliteBasics","primaryPath","primaryKey","_proto","prototype","run","db","queryWithParams","all","bulkWrite","documentWrites","context","next","getValue","database","databasePromise","ret","error","writePromises","categorized","console","warn","join","closed","Error","result","query","params","method","data","docsInDb","Map","forEach","docSQLResult","doc","JSON","parse","id","set","errors","length","bulkInsertDocs","row","insertQuery","document","push","bulkUpdateDocs","updateQuery","Promise","eventBulk","events","lastState","newestRow","checkpoint","lwt","_meta","originalPreparedQuery","skip","limit","Infinity","skipPlusLimit","queryMatcher","subResult","docData","sortComparator","sort","slice","documents","count","results","mode","findDocumentsById","ids","withDeleted","i","resultRow","includes","_deleted","changeStream","asObservable","cleanup","minimumDeletedTime","minTimestamp","Date","getTime","getAttachmentData","_documentId","_attachmentId","remove","promises","close","queue","get","pipe","v","resolve","catch","complete","createSQLiteTrialStorageInstance","version","attachments","useDatabaseName","databaseNamePrefix","then","tableQuery","indexCreation","instance"],"sources":["../../../../src/plugins/storage-sqlite/sqlite-storage-instance.ts"],"sourcesContent":["import {\r\n    RxJsonSchema,\r\n    RxStorageInstanceCreationParams,\r\n    RxStorageInstance,\r\n    getPrimaryFieldOfPrimaryKey,\r\n    EventBulk,\r\n    RxStorageChangeEvent,\r\n    RxDocumentData,\r\n    BulkWriteRow,\r\n    RxStorageBulkWriteResponse,\r\n    RxStorageQueryResult,\r\n    categorizeBulkWriteRows,\r\n    ensureNotFalsy,\r\n    StringKeys,\r\n    addRxStorageMultiInstanceSupport,\r\n    RxStorageDefaultCheckpoint,\r\n    CategorizeBulkWriteRowsOutput,\r\n    RxStorageCountResult,\r\n    promiseWait,\r\n    getQueryMatcher,\r\n    PreparedQuery,\r\n    hasPremiumFlag\r\n} from '../../index.ts';\r\nimport { BehaviorSubject, Observable, Subject, filter, firstValueFrom } from 'rxjs';\r\nimport type { RxStorageSQLiteTrial } from './index.ts';\r\nimport {\r\n    closeDatabaseConnection,\r\n    ensureParamsCountIsCorrect,\r\n    getDatabaseConnection,\r\n    getSQLiteUpdateSQL,\r\n    RX_STORAGE_NAME_SQLITE,\r\n    sqliteTransaction,\r\n    getDataFromResultRow,\r\n    getSQLiteInsertSQL,\r\n    TX_QUEUE_BY_DATABASE\r\n} from './sqlite-helpers.ts';\r\nimport type {\r\n    SQLiteBasics,\r\n    SQLiteInstanceCreationOptions,\r\n    SQLiteInternals,\r\n    SQLiteQueryWithParams,\r\n    SQLiteStorageSettings\r\n} from './sqlite-types.ts';\r\nimport { getSortComparator } from '../../rx-query-helper.ts';\r\nimport { newRxError } from '../../rx-error.ts';\r\nlet shownNonPremiumLog = false;\r\nlet instanceId = 0;\r\n\r\nexport class RxStorageInstanceSQLite<RxDocType> implements RxStorageInstance<\r\n    RxDocType,\r\n    SQLiteInternals,\r\n    SQLiteInstanceCreationOptions,\r\n    RxStorageDefaultCheckpoint\r\n> {\r\n    public readonly primaryPath: StringKeys<RxDocType>;\r\n    private changes$: Subject<EventBulk<RxStorageChangeEvent<RxDocumentData<RxDocType>>, RxStorageDefaultCheckpoint>> = new Subject();\r\n    public readonly instanceId = instanceId++;\r\n    public closed?: Promise<void>;\r\n\r\n    public sqliteBasics: SQLiteBasics<any>;\r\n\r\n    public readonly openWriteCount$ = new BehaviorSubject(0);\r\n\r\n\r\n    private opCount = 0;\r\n\r\n    constructor(\r\n        public readonly storage: RxStorageSQLiteTrial,\r\n        public readonly databaseName: string,\r\n        public readonly collectionName: string,\r\n        public readonly schema: Readonly<RxJsonSchema<RxDocumentData<RxDocType>>>,\r\n        public readonly internals: SQLiteInternals,\r\n        public readonly options: Readonly<SQLiteInstanceCreationOptions>,\r\n        public readonly settings: SQLiteStorageSettings,\r\n        public readonly tableName: string,\r\n        public readonly devMode: boolean\r\n    ) {\r\n        this.sqliteBasics = storage.settings.sqliteBasics;\r\n        this.primaryPath = getPrimaryFieldOfPrimaryKey(this.schema.primaryKey) as any;\r\n    }\r\n\r\n\r\n    run(\r\n        db: any,\r\n        queryWithParams: SQLiteQueryWithParams\r\n    ) {\r\n        if (this.devMode) {\r\n            ensureParamsCountIsCorrect(queryWithParams);\r\n        }\r\n        return this.sqliteBasics.run(db, queryWithParams);\r\n    }\r\n    all(\r\n        db: any,\r\n        queryWithParams: SQLiteQueryWithParams\r\n    ) {\r\n        if (this.devMode) {\r\n            ensureParamsCountIsCorrect(queryWithParams);\r\n        }\r\n\r\n        this.opCount = this.opCount + 1;\r\n        if (this.opCount > 500) {\r\n            throw newRxError('SQL3');\r\n        }\r\n\r\n        return this.sqliteBasics.all(db, queryWithParams);\r\n    }\r\n\r\n    /**\r\n     * @link https://medium.com/@JasonWyatt/squeezing-performance-from-sqlite-insertions-971aff98eef2\r\n     */\r\n    async bulkWrite(\r\n        documentWrites: BulkWriteRow<RxDocType>[],\r\n        context: string\r\n    ): Promise<RxStorageBulkWriteResponse<RxDocType>> {\r\n        this.openWriteCount$.next(this.openWriteCount$.getValue() + 1);\r\n        const database = await this.internals.databasePromise;\r\n        const ret: RxStorageBulkWriteResponse<RxDocType> = {\r\n            error: []\r\n        };\r\n        const writePromises: Promise<any>[] = [];\r\n        let categorized: CategorizeBulkWriteRowsOutput<RxDocType> = {} as any;\r\n\r\n        if (\r\n            !shownNonPremiumLog &&\r\n            !(await hasPremiumFlag())\r\n        ) {\r\n            console.warn(\r\n                [\r\n                    '-------------- RxDB SQLite Trial Storage ---------------------------------',\r\n                    'You are using the free *trial* SQLite-based RxStorage implementation: https://rxdb.info/rx-storage-sqlite.html?console=sqlite-trial',\r\n                    'This storage is intended only for evaluation purposes and comes with strict limitations (no indexes, no attachments, and a ~300-document cap).',\r\n                    'For production use and optimal performance, we strongly recommend upgrading to the premium SQLite storage.',\r\n                    'Premium version: https://rxdb.info/premium/?console=sqlite',\r\n                    'If you already have premium access, you can disable this message by calling setPremiumFlag() from rxdb-premium/plugins/shared.',\r\n                    '----------------------------------------------------------------------------'\r\n                ].join('\\n')\r\n            );\r\n            shownNonPremiumLog = true;\r\n        } else {\r\n            shownNonPremiumLog = true;\r\n        }\r\n\r\n        await sqliteTransaction(\r\n            database,\r\n            this.sqliteBasics,\r\n            async () => {\r\n                if (this.closed) {\r\n                    this.openWriteCount$.next(this.openWriteCount$.getValue() - 1);\r\n                    throw new Error('SQLite.bulkWrite(' + context + ') already closed ' + this.tableName + ' context: ' + context);\r\n                }\r\n                const result = await this.all(\r\n                    database,\r\n                    {\r\n                        query: `SELECT data FROM \"${this.tableName}\"`,\r\n                        params: [],\r\n                        context: {\r\n                            method: 'bulkWrite',\r\n                            data: documentWrites\r\n                        }\r\n                    }\r\n                );\r\n\r\n                const docsInDb: Map<RxDocumentData<RxDocType>[StringKeys<RxDocType>], RxDocumentData<RxDocType>> = new Map();\r\n                result.forEach(docSQLResult => {\r\n                    const doc = JSON.parse(getDataFromResultRow(docSQLResult));\r\n                    const id = doc[this.primaryPath];\r\n                    docsInDb.set(id, doc);\r\n                });\r\n                categorized = categorizeBulkWriteRows(\r\n                    this,\r\n                    this.primaryPath,\r\n                    docsInDb,\r\n                    documentWrites,\r\n                    context\r\n                );\r\n                ret.error = categorized.errors;\r\n\r\n                if ((result.length + categorized.bulkInsertDocs.length) > 300) {\r\n                    throw newRxError('SQL2');\r\n                }\r\n\r\n                categorized.bulkInsertDocs.forEach(row => {\r\n                    const insertQuery = getSQLiteInsertSQL(\r\n                        this.tableName,\r\n                        this.primaryPath as any,\r\n                        row.document\r\n                    );\r\n                    writePromises.push(\r\n                        this.all(\r\n                            database,\r\n                            {\r\n                                query: insertQuery.query,\r\n                                params: insertQuery.params,\r\n                                context: {\r\n                                    method: 'bulkWrite',\r\n                                    data: categorized\r\n                                }\r\n                            }\r\n                        )\r\n                    );\r\n                });\r\n\r\n                categorized.bulkUpdateDocs.forEach(row => {\r\n                    const updateQuery = getSQLiteUpdateSQL<RxDocType>(\r\n                        this.tableName,\r\n                        this.primaryPath,\r\n                        row\r\n                    );\r\n                    writePromises.push(\r\n                        this.run(\r\n                            database,\r\n                            updateQuery\r\n                        )\r\n                    );\r\n                });\r\n\r\n                await Promise.all(writePromises);\r\n\r\n                // close transaction\r\n                if (this.closed) {\r\n                    this.openWriteCount$.next(this.openWriteCount$.getValue() - 1);\r\n                    return 'ROLLBACK';\r\n                } else {\r\n                    this.openWriteCount$.next(this.openWriteCount$.getValue() - 1);\r\n                    return 'COMMIT';\r\n                }\r\n            },\r\n            {\r\n                databaseName: this.databaseName,\r\n                collectionName: this.collectionName\r\n            }\r\n        );\r\n\r\n        if (categorized && categorized.eventBulk.events.length > 0) {\r\n            const lastState = ensureNotFalsy(categorized.newestRow).document;\r\n            categorized.eventBulk.checkpoint = {\r\n                id: lastState[this.primaryPath],\r\n                lwt: lastState._meta.lwt\r\n            };\r\n            this.changes$.next(categorized.eventBulk);\r\n        }\r\n\r\n        return ret;\r\n    }\r\n\r\n\r\n    async query(\r\n        originalPreparedQuery: PreparedQuery<RxDocType>\r\n    ): Promise<RxStorageQueryResult<RxDocType>> {\r\n\r\n        const database = await this.internals.databasePromise;\r\n\r\n\r\n\r\n        let result: RxDocumentData<RxDocType>[] = [];\r\n        const query = originalPreparedQuery.query;\r\n        const skip = query.skip ? query.skip : 0;\r\n        const limit = query.limit ? query.limit : Infinity;\r\n        const skipPlusLimit = skip + limit;\r\n        const queryMatcher = getQueryMatcher(\r\n            this.schema,\r\n            query as any\r\n        );\r\n        const subResult = await this.all(\r\n            database,\r\n            {\r\n                query: 'SELECT data FROM \"' + this.tableName + '\"',\r\n                params: [],\r\n                context: {\r\n                    method: 'query',\r\n                    data: originalPreparedQuery\r\n                }\r\n            }\r\n        );\r\n        subResult.forEach(row => {\r\n            const docData = JSON.parse(getDataFromResultRow(row));\r\n            if (queryMatcher(docData)) {\r\n                result.push(docData);\r\n            }\r\n        });\r\n        const sortComparator = getSortComparator(this.schema, query as any);\r\n        result = result.sort(sortComparator);\r\n        result = result.slice(skip, skipPlusLimit);\r\n        return {\r\n            documents: result\r\n        };\r\n    }\r\n    async count(\r\n        originalPreparedQuery: PreparedQuery<RxDocType>\r\n    ): Promise<RxStorageCountResult> {\r\n        const results = await this.query(originalPreparedQuery);\r\n        return {\r\n            count: results.documents.length,\r\n            mode: 'fast'\r\n        };\r\n    }\r\n\r\n\r\n    async findDocumentsById(\r\n        ids: string[],\r\n        withDeleted: boolean\r\n    ): Promise<RxDocumentData<RxDocType>[]> {\r\n        const database = await this.internals.databasePromise;\r\n\r\n        if (this.closed) {\r\n            throw new Error('SQLite.findDocumentsById() already closed ' + this.tableName);\r\n        }\r\n\r\n        const result = await this.all(\r\n            database,\r\n            {\r\n                query: `SELECT data FROM \"${this.tableName}\"`,\r\n                params: [],\r\n                context: {\r\n                    method: 'findDocumentsById',\r\n                    data: ids\r\n                }\r\n            }\r\n        );\r\n        const ret: RxDocumentData<RxDocType>[] = [];\r\n        for (let i = 0; i < result.length; ++i) {\r\n            const resultRow = result[i];\r\n            const doc: RxDocumentData<RxDocType> = JSON.parse(getDataFromResultRow(resultRow));\r\n            if (\r\n                ids.includes((doc as any)[this.primaryPath]) &&\r\n                (\r\n                    withDeleted || !doc._deleted\r\n                )\r\n            ) {\r\n                ret.push(doc);\r\n            }\r\n        }\r\n        return ret;\r\n    }\r\n\r\n    changeStream(): Observable<EventBulk<RxStorageChangeEvent<RxDocumentData<RxDocType>>, RxStorageDefaultCheckpoint>> {\r\n        return this.changes$.asObservable();\r\n    }\r\n\r\n    async cleanup(minimumDeletedTime: number): Promise<boolean> {\r\n        await promiseWait(0);\r\n        await promiseWait(0);\r\n        const database = await this.internals.databasePromise;\r\n\r\n        /**\r\n         * Purge deleted documents\r\n         */\r\n        const minTimestamp = new Date().getTime() - minimumDeletedTime;\r\n        await this.all(\r\n            database,\r\n            {\r\n                query: `\r\n                    DELETE FROM\r\n                        \"${this.tableName}\"\r\n                    WHERE\r\n                        deleted = 1\r\n                        AND\r\n                        lastWriteTime < ?\r\n                `,\r\n                params: [\r\n                    minTimestamp\r\n                ],\r\n                context: {\r\n                    method: 'cleanup',\r\n                    data: minimumDeletedTime\r\n                }\r\n            }\r\n        );\r\n        return true;\r\n    }\r\n\r\n    async getAttachmentData(_documentId: string, _attachmentId: string): Promise<Blob> {\r\n        throw newRxError('SQL1');\r\n    }\r\n\r\n    async remove(): Promise<void> {\r\n        if (this.closed) {\r\n            throw new Error('closed already');\r\n        }\r\n        const database = await this.internals.databasePromise;\r\n        const promises = [\r\n            this.run(\r\n                database,\r\n                {\r\n                    query: `DROP TABLE IF EXISTS \"${this.tableName}\"`,\r\n                    params: [],\r\n                    context: {\r\n                        method: 'remove',\r\n                        data: this.tableName\r\n                    }\r\n                }\r\n            )\r\n        ];\r\n        await Promise.all(promises);\r\n        return this.close();\r\n    }\r\n\r\n    async close(): Promise<void> {\r\n        const queue = TX_QUEUE_BY_DATABASE.get(await this.internals.databasePromise);\r\n        if (queue) {\r\n            await queue;\r\n        }\r\n\r\n        if (this.closed) {\r\n            return this.closed;\r\n        }\r\n        this.closed = (async () => {\r\n            await firstValueFrom(this.openWriteCount$.pipe(filter((v: number) => v === 0)));\r\n            const database = await this.internals.databasePromise;\r\n\r\n            /**\r\n             * First get a transaction\r\n             * to ensure currently running operations\r\n             * are finished\r\n             */\r\n            await sqliteTransaction(\r\n                database,\r\n                this.sqliteBasics,\r\n                () => {\r\n                    return Promise.resolve('COMMIT');\r\n                }\r\n            ).catch(() => { });\r\n            this.changes$.complete();\r\n            await closeDatabaseConnection(\r\n                this.databaseName,\r\n                this.storage.settings.sqliteBasics\r\n            );\r\n        })();\r\n        return this.closed;\r\n\r\n    }\r\n}\r\n\r\nexport async function createSQLiteTrialStorageInstance<RxDocType>(\r\n    storage: RxStorageSQLiteTrial,\r\n    params: RxStorageInstanceCreationParams<RxDocType, SQLiteInstanceCreationOptions>,\r\n    settings: SQLiteStorageSettings\r\n): Promise<RxStorageInstanceSQLite<RxDocType>> {\r\n    const sqliteBasics = settings.sqliteBasics;\r\n    const tableName = params.collectionName + '-' + params.schema.version;\r\n\r\n\r\n    if (params.schema.attachments) {\r\n        throw newRxError('SQL1');\r\n    }\r\n\r\n    const internals: Partial<SQLiteInternals> = {};\r\n    const useDatabaseName = (settings.databaseNamePrefix ? settings.databaseNamePrefix : '') + '_trial_' + params.databaseName;\r\n    internals.databasePromise = getDatabaseConnection(\r\n        storage.settings.sqliteBasics,\r\n        useDatabaseName\r\n    ).then(async (database) => {\r\n        await sqliteTransaction(\r\n            database,\r\n            sqliteBasics,\r\n            async () => {\r\n                const tableQuery = `\r\n                CREATE TABLE IF NOT EXISTS \"${tableName}\"(\r\n                    id TEXT NOT NULL PRIMARY KEY UNIQUE,\r\n                    revision TEXT,\r\n                    deleted BOOLEAN NOT NULL CHECK (deleted IN (0, 1)),\r\n                    lastWriteTime INTEGER NOT NULL,\r\n                    data json\r\n                );\r\n                `;\r\n                await sqliteBasics.run(\r\n                    database,\r\n                    {\r\n                        query: tableQuery,\r\n                        params: [],\r\n                        context: {\r\n                            method: 'createSQLiteStorageInstance create tables',\r\n                            data: params.databaseName\r\n                        }\r\n                    }\r\n                );\r\n                return 'COMMIT';\r\n            },\r\n            {\r\n                indexCreation: false,\r\n                databaseName: params.databaseName,\r\n                collectionName: params.collectionName\r\n            }\r\n        );\r\n        return database;\r\n    });\r\n\r\n    const instance = new RxStorageInstanceSQLite(\r\n        storage,\r\n        params.databaseName,\r\n        params.collectionName,\r\n        params.schema,\r\n        internals as any,\r\n        params.options,\r\n        settings,\r\n        tableName,\r\n        params.devMode\r\n    );\r\n\r\n    await addRxStorageMultiInstanceSupport(\r\n        RX_STORAGE_NAME_SQLITE,\r\n        params,\r\n        instance\r\n    );\r\n\r\n    return instance;\r\n}\r\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/plugins/storage-sqlite/sqlite-types.js

@@ -0,0 +1,3 @@
+export {};
+export {};
+//# sourceMappingURL=sqlite-types.js.map

package/dist/esm/plugins/storage-sqlite/sqlite-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-types.js","names":[],"sources":["../../../../src/plugins/storage-sqlite/sqlite-types.ts"],"sourcesContent":["import type {\r\n    MangoQuery,\r\n    RxDocumentData,\r\n    RxJsonSchema\r\n} from '../../index.ts';\r\n\r\n/**\r\n * Adding '@types/sqlite3' to the dependencies\r\n * causes many errors on npm install,\r\n * even if the users uses another SQLite implementation.\r\n * Therefore we just use the any type instead the one imported from 'sqlite3';\r\n */\r\nexport type Sqlite3Type = any;\r\nexport type SQLiteDatabaseClass = any;\r\n\r\n\r\nexport type SQLResultRow = {\r\n    id: string;\r\n    /**\r\n     * Because we store the document fields as json,\r\n     * just return a string here.\r\n     */\r\n    data: string;\r\n} | [string, string, number, number, string];\r\n\r\nexport type SQLiteBasics<SQLiteDatabaseType> = {\r\n    debugId?: string;\r\n\r\n    /**\r\n     * Opens a new database connection\r\n     */\r\n    open: (name: string) => Promise<SQLiteDatabaseType>;\r\n    /**\r\n     * Returns the query result rows\r\n     */\r\n    all(\r\n        db: SQLiteDatabaseType,\r\n        queryWithParams: SQLiteQueryWithParams\r\n    ): Promise<SQLResultRow[]>;\r\n    /**\r\n     * Run a query. Return nothing.\r\n     */\r\n    run(\r\n        db: SQLiteDatabaseType,\r\n        queryWithParams: SQLiteQueryWithParams\r\n    ): Promise<void>;\r\n    /**\r\n     * Sets a pragma like the WAL mode or other flags.\r\n     * This cannot be done in run() or all() because\r\n     * it does not return rows on some SQLite libraries\r\n     * which would throw an error.\r\n     * @link https://www.sqlite.org/pragma.html\r\n     */\r\n    setPragma(\r\n        db: SQLiteDatabaseType,\r\n        key: string,\r\n        value: string\r\n    ): Promise<void>;\r\n    // closes the database connection\r\n    close(db: SQLiteDatabaseType): Promise<void>;\r\n\r\n    /**\r\n     * [default=WAL2]\r\n     * If empty string is given, the journalMode will be left untouched.\r\n     * For example android has WAL as default, so we do not want to touch that setting.\r\n     */\r\n    journalMode: 'WAL' | 'WAL2' | 'DELETE' | 'TRUNCATE' | 'PERSIST' | 'MEMORY' | 'OFF' | '';\r\n}\r\nexport type SQLiteStorageSettings = {\r\n    sqliteBasics: SQLiteBasics<any>;\r\n    // [default=false]\r\n    storeAttachmentsAsBase64String?: boolean;\r\n\r\n    databaseNamePrefix?: string;\r\n\r\n    /**\r\n     * Can be used to modify the prepared query before\r\n     * sending it to SQLite when the storageInstance.query()\r\n     * is run.\r\n     * For example you could use it to replace a regex with\r\n     * %LIKE% expressions.\r\n     */\r\n    queryModifier?: RxStorageSQLiteQueryModifier<any>;\r\n\r\n    /**\r\n     * If you have problems, you can pass a log function here\r\n     * to debug stuff.\r\n     * It is recommended to use console.log.bind(console)\r\n     */\r\n    log?: typeof console.log;\r\n}\r\n\r\nexport type RxStorageSQLiteQueryModifier<RxDocType> = (\r\n    queryWithParams: SQLiteQueryWithParams,\r\n    preparedQuery: SQLitePreparedQuery<RxDocType>\r\n) => SQLiteQueryWithParams;\r\nexport type SQLiteInstanceCreationOptions = {};\r\nexport type SQLiteInternals = {\r\n    databasePromise: Promise<SQLiteDatabaseClass>;\r\n};\r\nexport type SQLitePreparedQuery<RxDocType> = {\r\n    schema: RxJsonSchema<RxDocumentData<RxDocType>>;\r\n    mangoQuery: MangoQuery<RxDocType>;\r\n    /**\r\n     * Contains the sql query,\r\n     * But only from the where clause.\r\n     * This ensures we can reuse the prepared query\r\n     * no mather what the name of the table is.\r\n     * Looks like 'WHERE .... SORT BY ...'.\r\n     */\r\n    sqlQuery: SQLiteQueryWithParams;\r\n\r\n    /**\r\n     * The same query but without the ORDER BY part.\r\n     * Used in count-queries for better performance.\r\n     */\r\n    queryWithoutSort: string;\r\n\r\n\r\n    /**\r\n     * If the query cannot be transformed to SQL,\r\n     * because it contains non-SQLite-native operators\r\n     * like $regex, we have use a normal query matching.\r\n     */\r\n    nonImplementedOperator?: string;\r\n}\r\n\r\nexport type SQLiteQueryWithParams = {\r\n    query: string;\r\n    /**\r\n     * Some SQLite version allow to use named params like $docId\r\n     * and then putting an object in here.\r\n     * But because not all environments support that,\r\n     * we have to use plain array params that use the '?' placeholder in the query string.\r\n     */\r\n    params: (string | number | boolean)[];\r\n\r\n    /**\r\n     * Context must be set, will be used during debugging and error logs\r\n     * to better show what is going wrong.\r\n     */\r\n    context: {\r\n        method: string;\r\n        data: any;\r\n    };\r\n}\r\n\r\nexport type SQLiteChangesCheckpoint = {\r\n    id: string;\r\n    lwt: number;\r\n};\r\n"],"mappings":"","ignoreList":[]}