@connecttomahdi/rxdb 17.0.0-beta.17

package/dist/types/plugins/storage-remote/index.d.ts

@@ -0,0 +1,5 @@
+export * from './rx-storage-remote.ts';
+export * from './storage-remote-types.ts';
+export * from './storage-remote-helpers.ts';
+export * from './message-channel-cache.ts';
+export * from './remote.ts';

package/dist/types/plugins/storage-remote/message-channel-cache.d.ts

@@ -0,0 +1,13 @@
+import { RemoteMessageChannel, RxStorageRemoteSettings } from './storage-remote-types.ts';
+export type RemoteMessageChannelCacheItem = {
+    identifier: string;
+    cacheKey: string;
+    messageChannel: Promise<RemoteMessageChannel>;
+    refCount: number;
+    keepAlive: boolean;
+};
+export declare const MESSAGE_CHANNEL_CACHE_BY_IDENTIFIER: Map<string, Map<string, RemoteMessageChannelCacheItem>>;
+export declare const CACHE_ITEM_BY_MESSAGE_CHANNEL: WeakMap<RemoteMessageChannel, RemoteMessageChannelCacheItem>;
+export declare const OPEN_REMOTE_MESSAGE_CHANNELS: Set<RemoteMessageChannel>;
+export declare function getMessageChannel(settings: RxStorageRemoteSettings, cacheKeys: string[], keepAlive?: boolean): Promise<RemoteMessageChannel>;
+export declare function closeMessageChannel(messageChannel: RemoteMessageChannel): Promise<void>;

package/dist/types/plugins/storage-remote/remote.d.ts

@@ -0,0 +1,6 @@
+import type { RxStorageRemoteExposeSettings, RxStorageRemoteExposeType } from './storage-remote-types.ts';
+/**
+ * Run this on the 'remote' part,
+ * so that RxStorageMessageChannel can connect to it.
+ */
+export declare function exposeRxStorageRemote(settings: RxStorageRemoteExposeSettings): RxStorageRemoteExposeType;

package/dist/types/plugins/storage-remote/rx-storage-remote.d.ts

@@ -0,0 +1,43 @@
+import { Observable } from 'rxjs';
+import type { BulkWriteRow, EventBulk, RxDocumentData, RxJsonSchema, RxStorage, RxStorageBulkWriteResponse, RxStorageChangeEvent, RxStorageCountResult, RxStorageInstance, RxStorageInstanceCreationParams, RxStorageQueryResult } from '../../types/index.d.ts';
+import type { MessageFromRemote, RemoteMessageChannel, RxStorageRemoteInternals, RxStorageRemoteSettings } from './storage-remote-types.ts';
+export declare class RxStorageRemote implements RxStorage<RxStorageRemoteInternals, any> {
+    readonly settings: RxStorageRemoteSettings;
+    readonly name: string;
+    readonly rxdbVersion = "17.0.0-beta.17";
+    private seed;
+    private lastRequestId;
+    messageChannelIfOneMode?: Promise<RemoteMessageChannel>;
+    constructor(settings: RxStorageRemoteSettings);
+    getRequestId(): string;
+    createStorageInstance<RxDocType>(params: RxStorageInstanceCreationParams<RxDocType, any>): Promise<RxStorageInstanceRemote<RxDocType>>;
+    customRequest<In, Out>(data: In): Promise<Out>;
+}
+export declare class RxStorageInstanceRemote<RxDocType> implements RxStorageInstance<RxDocType, RxStorageRemoteInternals, any, any> {
+    readonly storage: RxStorageRemote;
+    readonly databaseName: string;
+    readonly collectionName: string;
+    readonly schema: Readonly<RxJsonSchema<RxDocumentData<RxDocType>>>;
+    readonly internals: RxStorageRemoteInternals;
+    readonly options: Readonly<any>;
+    private changes$;
+    private subs;
+    private closed?;
+    messages$: Observable<MessageFromRemote>;
+    constructor(storage: RxStorageRemote, databaseName: string, collectionName: string, schema: Readonly<RxJsonSchema<RxDocumentData<RxDocType>>>, internals: RxStorageRemoteInternals, options: Readonly<any>);
+    private requestRemote;
+    bulkWrite(documentWrites: BulkWriteRow<RxDocType>[], context: string): Promise<RxStorageBulkWriteResponse<RxDocType>>;
+    findDocumentsById(ids: string[], deleted: boolean): Promise<RxDocumentData<RxDocType>[]>;
+    query(preparedQuery: any): Promise<RxStorageQueryResult<RxDocType>>;
+    count(preparedQuery: any): Promise<RxStorageCountResult>;
+    getAttachmentData(documentId: string, attachmentId: string, digest: string): Promise<Blob>;
+    getChangedDocumentsSince(limit: number, checkpoint?: any): Promise<{
+        documents: RxDocumentData<RxDocType>[];
+        checkpoint: any;
+    }>;
+    changeStream(): Observable<EventBulk<RxStorageChangeEvent<RxDocumentData<RxDocType>>, any>>;
+    cleanup(minDeletedTime: number): Promise<boolean>;
+    close(): Promise<void>;
+    remove(): Promise<void>;
+}
+export declare function getRxStorageRemote(settings: RxStorageRemoteSettings): RxStorageRemote;

package/dist/types/plugins/storage-remote/storage-remote-helpers.d.ts

@@ -0,0 +1,4 @@
+import type { RxError, RxTypeError } from '../../types/index.d.ts';
+import type { MessageFromRemote, MessageToRemote } from './storage-remote-types.ts';
+export declare function createErrorAnswer(msg: MessageToRemote, error: Error | TypeError | RxError | RxTypeError): MessageFromRemote;
+export declare function createAnswer(msg: MessageToRemote, ret: any): MessageFromRemote;

package/dist/types/plugins/storage-remote/storage-remote-types.d.ts

@@ -0,0 +1,88 @@
+import type { Observable } from 'rxjs';
+import type { MaybePromise, PlainJsonError, RxDatabase, RxStorage, RxStorageInstance, RxStorageInstanceCreationParams } from '../../types/index.d.ts';
+export type MessageFromRemote = {
+    connectionId: string;
+    answerTo: string;
+    method: keyof RxStorageInstance<any, any, any> | 'create' | 'custom';
+    error?: PlainJsonError;
+    return?: any | string;
+};
+export type MessageToRemote = {
+    connectionId: string;
+    /**
+     * Unique ID of the request
+     */
+    requestId: string;
+    method: keyof RxStorageInstance<any, any, any> | 'create' | 'custom';
+    /**
+     * We send the RxDB version to the remote
+     * to ensure we are communicating with an RxDB instance
+     * of the same version. This is to prevent bugs
+     * when people forget to rebuild their workers.
+     */
+    version: string;
+    params: RxStorageInstanceCreationParams<any, any> | // used in the create call
+    any[] | // used to call RxStorageInstance methods
+    any;
+};
+/**
+ * A message channel represents a single
+ * channel that is able to communicate with the remote.
+ * For example a single websocket connection or WebWorker instance.
+ * The storage must be able to open and close MessageChannels
+ * according to the modes settings.
+ */
+export type RemoteMessageChannel = {
+    send(msg: MessageToRemote): void;
+    messages$: Observable<MessageFromRemote>;
+    close(): Promise<void>;
+};
+export type RxStorageRemoteSettings = {
+    identifier: string;
+    /**
+     * There are different modes
+     * that determine how many message channels are used.
+     * These modes can have different performance patterns.
+     *
+     * [default='storage']
+     */
+    mode?: 'one' | 'storage' | 'database' | 'collection';
+    messageChannelCreator: () => Promise<RemoteMessageChannel>;
+};
+export type RxStorageRemoteInternals = {
+    params: RxStorageInstanceCreationParams<any, any>;
+    connectionId: string;
+    messageChannel: RemoteMessageChannel;
+};
+export type RxStorageRemoteExposeSettingsBase = {
+    send(msg: MessageFromRemote): void;
+    messages$: Observable<MessageToRemote>;
+    customRequestHandler?: CustomRequestHandler<any, any>;
+    /**
+     * Used in tests to simulate what happens if the remote
+     * was build on a different RxDB version.
+     */
+    fakeVersion?: string;
+};
+export type RxStorageRemoteExposeSettingsRxDatabase = RxStorageRemoteExposeSettingsBase & {
+    /**
+     * The database which must be mapped to the remote storage server.
+     */
+    database: RxDatabase;
+};
+export type RxStorageRemoteExposeSettingsRxStorage = RxStorageRemoteExposeSettingsBase & {
+    /**
+     * The original storage
+     * which actually stores the data.
+     */
+    storage: RxStorage<any, any>;
+};
+export type RxStorageRemoteExposeSettings = RxStorageRemoteExposeSettingsRxDatabase | RxStorageRemoteExposeSettingsRxStorage;
+export type RxStorageRemoteExposeType = {
+    instanceByFullName: Map<string, any>;
+};
+/**
+ * If set, the clients can send RxDB-unrelated custom messages
+ * to the remote storage and it will  answer them.
+ */
+export type CustomRequestHandler<In, Out> = (data: In) => MaybePromise<Out>;

package/dist/types/plugins/storage-remote-websocket/index.d.ts

@@ -0,0 +1,4 @@
+import type { RxStorageRemoteWebsocketClient, RxStorageRemoteWebsocketClientOptions, RxStorageRemoteWebsocketServerOptions, RxStorageRemoteWebsocketServerState } from './types.ts';
+export declare function startRxStorageRemoteWebsocketServer(options: RxStorageRemoteWebsocketServerOptions): RxStorageRemoteWebsocketServerState;
+export declare function getRxStorageRemoteWebsocket(options: RxStorageRemoteWebsocketClientOptions): RxStorageRemoteWebsocketClient;
+export * from './types.ts';

package/dist/types/plugins/storage-remote-websocket/types.d.ts

@@ -0,0 +1,24 @@
+import type { WebsocketServerState } from '../replication-websocket/index.ts';
+import type { ServerOptions, ClientOptions } from 'ws';
+import type { RxDatabase, RxStorage } from '../../types/index.d.ts';
+import type { CustomRequestHandler, RxStorageRemoteExposeType, RxStorageRemoteSettings } from '../storage-remote/storage-remote-types.ts';
+import { RxStorageRemote } from '../storage-remote/index.ts';
+export type RxStorageRemoteWebsocketServerOptions = Omit<ServerOptions, 'perMessageDeflate'> & {
+    storage?: RxStorage<any, any>;
+    database?: RxDatabase<any, any, any>;
+    customRequestHandler?: CustomRequestHandler<any, any>;
+    /**
+     * Used in tests to simulate what happens if the remote
+     * was build on a different RxDB version.
+     */
+    fakeVersion?: string;
+};
+export type RxStorageRemoteWebsocketServerState = {
+    serverState: WebsocketServerState;
+    exposeState: RxStorageRemoteExposeType;
+};
+export type RxStorageRemoteWebsocketClientOptions = ClientOptions & {
+    url: string;
+    mode: RxStorageRemoteSettings['mode'];
+};
+export type RxStorageRemoteWebsocketClient = RxStorageRemote;

package/dist/types/plugins/storage-sqlite/index.d.ts

@@ -0,0 +1,15 @@
+import { RxStorage, RxStorageInstanceCreationParams } from '../../index.ts';
+import { RxStorageInstanceSQLite } from './sqlite-storage-instance.ts';
+import type { SQLiteInternals, SQLiteInstanceCreationOptions, SQLiteStorageSettings } from './sqlite-types.ts';
+export * from './sqlite-helpers.ts';
+export * from './sqlite-types.ts';
+export * from './sqlite-storage-instance.ts';
+export * from './sqlite-basics-helpers.ts';
+export declare class RxStorageSQLiteTrial implements RxStorage<SQLiteInternals, SQLiteInstanceCreationOptions> {
+    settings: SQLiteStorageSettings;
+    name: string;
+    readonly rxdbVersion = "17.0.0-beta.17";
+    constructor(settings: SQLiteStorageSettings);
+    createStorageInstance<RxDocType>(params: RxStorageInstanceCreationParams<RxDocType, SQLiteInstanceCreationOptions>): Promise<RxStorageInstanceSQLite<RxDocType>>;
+}
+export declare function getRxStorageSQLiteTrial(settings: SQLiteStorageSettings): RxStorageSQLiteTrial;

package/dist/types/plugins/storage-sqlite/sqlite-basics-helpers.d.ts

@@ -0,0 +1,53 @@
+import type { Sqlite3Type, SQLiteBasics, SQLiteDatabaseClass, SQLiteQueryWithParams } from './sqlite-types.ts';
+export declare function getSQLiteBasicsNode(sqlite3: Sqlite3Type): SQLiteBasics<SQLiteDatabaseClass>;
+/**
+ * Uses the native sqlite that comes sshipped with node version 22+
+ * @link https://nodejs.org/api/sqlite.html
+ */
+export declare function getSQLiteBasicsNodeNative(constructor: any): SQLiteBasics<any>;
+/**
+ * For unknown reason we cannot bind boolean values
+ * and have to map them to one and zero.
+ * TODO create an issue at Node.js
+ */
+export declare function mapNodeNativeParams(params: SQLiteQueryWithParams['params']): SQLiteQueryWithParams['params'];
+/**
+ * Promisified version of db.run()
+ */
+export declare function execSqlSQLiteNode(database: SQLiteDatabaseClass, queryWithParams: SQLiteQueryWithParams, operator: 'run' | 'all'): any;
+export declare function closeSQLiteDatabaseNode(database: SQLiteDatabaseClass): Promise<void>;
+type SQLiteCapacitorDatabase = any;
+type SQLiteConnection = any;
+export declare function getSQLiteBasicsCapacitor(sqlite: SQLiteConnection, capacitorCore: any): SQLiteBasics<SQLiteCapacitorDatabase>;
+type SQLiteQuickDatabase = any;
+export declare const EMPTY_FUNCTION: () => void;
+export declare function getSQLiteBasicsQuickSQLite(openDB: any): SQLiteBasics<SQLiteQuickDatabase>;
+/**
+ * @deprecated Use getSQLiteBasicsExpoSQLiteAsync() instead
+ */
+export declare function getSQLiteBasicsExpoSQLite(openDB: any, options?: any, directory?: any): SQLiteBasics<any>;
+/**
+ * @link https://docs.expo.dev/versions/latest/sdk/sqlite/
+ */
+export declare function getSQLiteBasicsExpoSQLiteAsync(openDB: any, options?: any, directory?: any): SQLiteBasics<any>;
+/**
+ * Build to be compatible with packages
+ * that use the websql npm package like:
+ * @link https://www.npmjs.com/package/react-native-sqlite-2
+ * @link https://www.npmjs.com/package/websql
+ * Use like:
+ * import SQLite from 'react-native-sqlite-2';
+ * getRxStorageSQLite({
+ *   sqliteBasics: getSQLiteBasicsWebSQL(SQLite.openDatabase)
+ * });
+ *
+ */
+export declare function getSQLiteBasicsWebSQL(openDB: any): SQLiteBasics<any>;
+export declare function webSQLExecuteQuery(db: any, queryWithParams: SQLiteQueryWithParams): Promise<any>;
+export type WasmSqliteDb = {
+    nr: number;
+    name: string;
+};
+export declare function getSQLiteBasicsWasm(sqlite3: any): SQLiteBasics<WasmSqliteDb>;
+export declare function getSQLiteBasicsTauri(sqlite3: Sqlite3Type): SQLiteBasics<any>;
+export {};

package/dist/types/plugins/storage-sqlite/sqlite-helpers.d.ts

@@ -0,0 +1,48 @@
+import { BulkWriteRow, RxDocumentData, MaybePromise } from '../../index.ts';
+import type { SQLResultRow, SQLiteBasics, SQLiteDatabaseClass, SQLiteQueryWithParams } from './sqlite-types.ts';
+export declare const NON_IMPLEMENTED_OPERATOR_QUERY_BATCH_SIZE = 50;
+export type DatabaseState = {
+    database: Promise<SQLiteDatabaseClass>;
+    openConnections: number;
+    sqliteBasics: SQLiteBasics<SQLiteDatabaseClass>;
+};
+export declare const DATABASE_STATE_BY_NAME: Map<string, DatabaseState>;
+export declare const RX_STORAGE_NAME_SQLITE = "sqlite";
+/**
+ * @link https://www.sqlite.org/inmemorydb.html
+ */
+export declare const SQLITE_IN_MEMORY_DB_NAME = ":memory:";
+export declare function getDatabaseConnection(sqliteBasics: SQLiteBasics<any>, databaseName: string): Promise<SQLiteDatabaseClass>;
+export declare function closeDatabaseConnection(databaseName: string, sqliteBasics: SQLiteBasics<any>): MaybePromise<void>;
+export declare function getDataFromResultRow(row: SQLResultRow): string;
+export declare function getSQLiteInsertSQL<RxDocType>(collectionName: string, primaryPath: keyof RxDocType, docData: RxDocumentData<RxDocType>): SQLiteQueryWithParams;
+export declare function getSQLiteUpdateSQL<RxDocType>(tableName: string, primaryPath: keyof RxDocType, writeRow: BulkWriteRow<RxDocType>): SQLiteQueryWithParams;
+export declare const TX_QUEUE_BY_DATABASE: WeakMap<SQLiteDatabaseClass, Promise<void>>;
+export declare function sqliteTransaction(database: SQLiteDatabaseClass, sqliteBasics: SQLiteBasics<any>, handler: () => Promise<'COMMIT' | 'ROLLBACK'>, 
+/**
+ * Context will be logged
+ * if the commit does error.
+ */
+context?: any): Promise<void>;
+/**
+ * TODO instead of doing a while loop, we should find a way to listen when the
+ * other transaction is committed.
+ */
+export declare function openSqliteTransaction(database: SQLiteDatabaseClass, sqliteBasics: SQLiteBasics<any>): Promise<void>;
+export declare function finishSqliteTransaction(database: SQLiteDatabaseClass, sqliteBasics: SQLiteBasics<any>, mode: 'COMMIT' | 'ROLLBACK', 
+/**
+ * Context will be logged
+ * if the commit does error.
+ */
+context?: any): Promise<void>;
+export declare const PARAM_KEY = "?";
+export declare function ensureParamsCountIsCorrect(queryWithParams: SQLiteQueryWithParams): void;
+/**
+ * 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 declare function boolParamsToInt(params: any[]): any[];

package/dist/types/plugins/storage-sqlite/sqlite-storage-instance.d.ts

@@ -0,0 +1,38 @@
+import { RxJsonSchema, RxStorageInstanceCreationParams, RxStorageInstance, EventBulk, RxStorageChangeEvent, RxDocumentData, BulkWriteRow, RxStorageBulkWriteResponse, RxStorageQueryResult, StringKeys, RxStorageDefaultCheckpoint, RxStorageCountResult, PreparedQuery } from '../../index.ts';
+import { BehaviorSubject, Observable } from 'rxjs';
+import type { RxStorageSQLiteTrial } from './index.ts';
+import type { SQLiteBasics, SQLiteInstanceCreationOptions, SQLiteInternals, SQLiteQueryWithParams, SQLiteStorageSettings } from './sqlite-types.ts';
+export declare class RxStorageInstanceSQLite<RxDocType> implements RxStorageInstance<RxDocType, SQLiteInternals, SQLiteInstanceCreationOptions, RxStorageDefaultCheckpoint> {
+    readonly storage: RxStorageSQLiteTrial;
+    readonly databaseName: string;
+    readonly collectionName: string;
+    readonly schema: Readonly<RxJsonSchema<RxDocumentData<RxDocType>>>;
+    readonly internals: SQLiteInternals;
+    readonly options: Readonly<SQLiteInstanceCreationOptions>;
+    readonly settings: SQLiteStorageSettings;
+    readonly tableName: string;
+    readonly devMode: boolean;
+    readonly primaryPath: StringKeys<RxDocType>;
+    private changes$;
+    readonly instanceId: number;
+    closed?: Promise<void>;
+    sqliteBasics: SQLiteBasics<any>;
+    readonly openWriteCount$: BehaviorSubject<number>;
+    private opCount;
+    constructor(storage: RxStorageSQLiteTrial, databaseName: string, collectionName: string, schema: Readonly<RxJsonSchema<RxDocumentData<RxDocType>>>, internals: SQLiteInternals, options: Readonly<SQLiteInstanceCreationOptions>, settings: SQLiteStorageSettings, tableName: string, devMode: boolean);
+    run(db: any, queryWithParams: SQLiteQueryWithParams): Promise<void>;
+    all(db: any, queryWithParams: SQLiteQueryWithParams): Promise<import("./sqlite-types.ts").SQLResultRow[]>;
+    /**
+     * @link https://medium.com/@JasonWyatt/squeezing-performance-from-sqlite-insertions-971aff98eef2
+     */
+    bulkWrite(documentWrites: BulkWriteRow<RxDocType>[], context: string): Promise<RxStorageBulkWriteResponse<RxDocType>>;
+    query(originalPreparedQuery: PreparedQuery<RxDocType>): Promise<RxStorageQueryResult<RxDocType>>;
+    count(originalPreparedQuery: PreparedQuery<RxDocType>): Promise<RxStorageCountResult>;
+    findDocumentsById(ids: string[], withDeleted: boolean): Promise<RxDocumentData<RxDocType>[]>;
+    changeStream(): Observable<EventBulk<RxStorageChangeEvent<RxDocumentData<RxDocType>>, RxStorageDefaultCheckpoint>>;
+    cleanup(minimumDeletedTime: number): Promise<boolean>;
+    getAttachmentData(_documentId: string, _attachmentId: string): Promise<Blob>;
+    remove(): Promise<void>;
+    close(): Promise<void>;
+}
+export declare function createSQLiteTrialStorageInstance<RxDocType>(storage: RxStorageSQLiteTrial, params: RxStorageInstanceCreationParams<RxDocType, SQLiteInstanceCreationOptions>, settings: SQLiteStorageSettings): Promise<RxStorageInstanceSQLite<RxDocType>>;

package/dist/types/plugins/storage-sqlite/sqlite-types.d.ts

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

package/dist/types/plugins/test-utils/config.d.ts

@@ -0,0 +1,16 @@
+import type { RxStorage, RxTestStorage } from '../../types';
+export type TestConfig = {
+    storage: RxTestStorage;
+};
+export declare const isDeno: boolean;
+export declare const isBun: boolean;
+export declare const isNode: boolean;
+export declare function setConfig(newConfig: TestConfig): void;
+export declare function getConfig(): TestConfig;
+export declare const ENV_VARIABLES: any;
+export declare const DEFAULT_STORAGE: string;
+export declare function isFastMode(): boolean;
+export declare function initTestEnvironment(): void;
+export declare function getEncryptedStorage(baseStorage?: RxStorage<any, any>): RxStorage<any, any>;
+export declare function isNotOneOfTheseStorages(storageNames: string[]): boolean;
+export declare function getPassword(): Promise<string>;

package/dist/types/plugins/test-utils/humans-collection.d.ts

@@ -0,0 +1,26 @@
+import * as schemaObjects from './schema-objects.ts';
+import { RxJsonSchema, RxCollection, RxDatabase, MigrationStrategies, RxAttachmentCreator, RxStorage, RxConflictHandler } from '../../index.ts';
+import { HumanDocumentType, PrimaryHumanDocType } from './schemas.ts';
+export declare function create(size?: number, collectionName?: string, multiInstance?: boolean, eventReduce?: boolean, storage?: RxStorage<any, any>): Promise<RxCollection<HumanDocumentType, {}, {}>>;
+export declare function createBySchema<RxDocumentType = {}>(schema: RxJsonSchema<RxDocumentType>, name?: string, storage?: RxStorage<any, any>, migrationStrategies?: MigrationStrategies): Promise<RxCollection<RxDocumentType, {}, {}>>;
+export declare function createAttachments(size?: number, name?: string, multiInstance?: boolean): Promise<RxCollection<HumanDocumentType, {}, {}>>;
+export declare function createNoCompression(size?: number, name?: string): Promise<RxCollection<HumanDocumentType>>;
+export declare function createAgeIndex(amount?: number): Promise<RxCollection<HumanDocumentType>>;
+export declare function multipleOnSameDB(size?: number): Promise<{
+    db: RxDatabase<{
+        human: RxCollection<HumanDocumentType>;
+        human2: RxCollection<HumanDocumentType>;
+    }>;
+    collection: RxCollection<HumanDocumentType>;
+    collection2: RxCollection<HumanDocumentType>;
+}>;
+export declare function createNested(amount?: number): Promise<RxCollection<schemaObjects.NestedHumanDocumentType>>;
+export declare function createDeepNested(amount?: number): Promise<RxCollection<schemaObjects.DeepNestedHumanDocumentType>>;
+export declare function createMultiInstance(name: string, amount?: number, password?: undefined, storage?: RxStorage<any, any>): Promise<RxCollection<HumanDocumentType, {}, {}>>;
+export declare function createPrimary(amount?: number, name?: string, multiInstance?: boolean): Promise<RxCollection<PrimaryHumanDocType>>;
+export declare function createHumanWithTimestamp(amount?: number, databaseName?: string, multiInstance?: boolean, storage?: RxStorage<any, any>, conflictHandler?: RxConflictHandler<any>): Promise<RxCollection<schemaObjects.HumanWithTimestampDocumentType>>;
+export declare function createMigrationCollection(amount?: number, addMigrationStrategies?: MigrationStrategies, name?: string, autoMigrate?: boolean, attachment?: RxAttachmentCreator): Promise<RxCollection<schemaObjects.SimpleHumanV3DocumentType>>;
+export declare function createRelated(name?: string): Promise<RxCollection<schemaObjects.RefHumanDocumentType>>;
+export declare function createRelatedNested(name?: string): Promise<RxCollection<schemaObjects.RefHumanNestedDocumentType>>;
+export declare function createIdAndAgeIndex(amount?: number): Promise<RxCollection<schemaObjects.HumanWithIdAndAgeIndexDocumentType>>;
+export declare function createHumanWithOwnership(amount?: number, databaseName?: string, multiInstance?: boolean, owner?: string, storage?: RxStorage<any, any>, conflictHandler?: RxConflictHandler<any>): Promise<RxCollection<schemaObjects.HumanWithOwnershipDocumentType>>;

package/dist/types/plugins/test-utils/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * This plugins contains thing that are needed for testing
+ * in RxDB related context. Mostly used in the unit tests and
+ * also in the tests for the premium and the server repository.
+ */
+export * from './config.ts';
+export * from './humans-collection.ts';
+export * from './revisions.ts';
+export * from './test-util.ts';
+export * from './schema-objects.ts';
+export * from './schemas.ts';
+export * from './replication.ts';
+export * from './replication-base-test-suite.ts';
+export * from './performance.ts';
+import * as humansCollectionConst from './humans-collection.ts';
+export declare const humansCollection: typeof humansCollectionConst;
+import * as schemasConst from './schemas.ts';
+export declare const schemas: typeof schemasConst;
+import * as schemaObjectsConst from './schema-objects.ts';
+export declare const schemaObjects: typeof schemaObjectsConst;

package/dist/types/plugins/test-utils/performance.d.ts

@@ -0,0 +1,68 @@
+import { RxStorage } from '../../index.ts';
+export type PerformanceTestConfig = {
+    /**
+     * How many times the test loop is run.
+     * More runs give more stable averages but take longer.
+     * @default 40
+     */
+    runs?: number;
+    /**
+     * Number of collections created per database.
+     * @default 4
+     */
+    collectionsAmount?: number;
+    /**
+     * Number of documents inserted in bulk per run.
+     * @default 3000
+     */
+    docsAmount?: number;
+    /**
+     * Number of documents inserted one-by-one (serial) per run.
+     * @default 50
+     */
+    serialDocsAmount?: number;
+    /**
+     * Number of parallel queries executed per run.
+     * @default 4
+     */
+    parallelQueryAmount?: number;
+    /**
+     * Number of batches used when doing bulk inserts.
+     * @default 6
+     */
+    insertBatches?: number;
+    /**
+     * Milliseconds to wait between test operations.
+     * Set to 0 to disable waiting (useful for smoke tests).
+     * @default 100
+     */
+    waitBetweenTests?: number;
+    /**
+     * Whether to log progress and results to the console.
+     * @default true
+     */
+    log?: boolean;
+};
+export type PerformanceTestResult = {
+    description: string;
+    collectionsAmount: number;
+    docsAmount: number;
+    [timingKey: string]: number | string;
+};
+/**
+ * Runs a performance benchmark against the given RxStorage.
+ * Useful for comparing different RxStorage implementations.
+ *
+ * @param storage - The RxStorage to benchmark.
+ * @param storageDescription - A human-readable description of the storage (used in results).
+ * @param config - Optional configuration to override the defaults.
+ * @returns An object with averaged timing values for each measured operation.
+ */
+export declare function runPerformanceTests(storage: RxStorage<any, any>, storageDescription: string, config?: PerformanceTestConfig): Promise<PerformanceTestResult>;
+export declare function averageOfTimeValues(times: number[], 
+/**
+ * To better account for anomalies
+ * during time measurements,
+ * we strip the highest x percent.
+ */
+striphighestXPercent: number): number;