@connecttomahdi/rxdb 17.0.0-beta.17

package/dist/types/plugins/storage-denokv/rx-storage-instance-denokv.d.ts

@@ -0,0 +1,41 @@
+import type { RxStorageInstance, RxStorageChangeEvent, RxDocumentData, BulkWriteRow, RxStorageBulkWriteResponse, RxStorageQueryResult, RxJsonSchema, RxStorageInstanceCreationParams, EventBulk, StringKeys, RxStorageDefaultCheckpoint, RxStorageCountResult, PreparedQuery } from '../../types/index.d.ts';
+import type { DenoKVSettings, DenoKVStorageInternals } from './denokv-types.ts';
+import { RxStorageDenoKV } from './index.ts';
+export declare class RxStorageInstanceDenoKV<RxDocType> implements RxStorageInstance<RxDocType, DenoKVStorageInternals<RxDocType>, DenoKVSettings, RxStorageDefaultCheckpoint> {
+    readonly storage: RxStorageDenoKV;
+    readonly databaseName: string;
+    readonly collectionName: string;
+    readonly schema: Readonly<RxJsonSchema<RxDocumentData<RxDocType>>>;
+    readonly internals: DenoKVStorageInternals<RxDocType>;
+    readonly options: Readonly<DenoKVSettings>;
+    readonly settings: DenoKVSettings;
+    readonly keySpace: string;
+    readonly kvOptions: {
+        consistency: "strong" | "eventual";
+    };
+    readonly primaryPath: StringKeys<RxDocumentData<RxDocType>>;
+    private changes$;
+    closed?: Promise<void>;
+    readonly kvPromise: Promise<any>;
+    writeQueue: Promise<any>;
+    constructor(storage: RxStorageDenoKV, databaseName: string, collectionName: string, schema: Readonly<RxJsonSchema<RxDocumentData<RxDocType>>>, internals: DenoKVStorageInternals<RxDocType>, options: Readonly<DenoKVSettings>, settings: DenoKVSettings, keySpace?: string, kvOptions?: {
+        consistency: "strong" | "eventual";
+    });
+    /**
+     * DenoKV has no transactions
+     * so we have to ensure that there is no write in between our queries
+     * which would confuse RxDB and return wrong query results.
+     */
+    retryUntilNoWriteInBetween<T>(fn: () => Promise<T>): Promise<T>;
+    bulkWrite(documentWrites: BulkWriteRow<RxDocType>[], context: string): Promise<RxStorageBulkWriteResponse<RxDocType>>;
+    _bulkWrite(documentWrites: BulkWriteRow<RxDocType>[], context: string): Promise<RxStorageBulkWriteResponse<RxDocType>>;
+    findDocumentsById(ids: string[], withDeleted: boolean): Promise<RxDocumentData<RxDocType>[]>;
+    query(preparedQuery: PreparedQuery<RxDocType>): Promise<RxStorageQueryResult<RxDocType>>;
+    count(preparedQuery: PreparedQuery<RxDocType>): Promise<RxStorageCountResult>;
+    getAttachmentData(documentId: string, attachmentId: string, digest: string): Promise<Blob>;
+    changeStream(): import("rxjs").Observable<EventBulk<RxStorageChangeEvent<RxDocumentData<RxDocType>>, RxStorageDefaultCheckpoint>>;
+    cleanup(minimumDeletedTime: number): Promise<boolean>;
+    close(): Promise<void>;
+    remove(): Promise<void>;
+}
+export declare function createDenoKVStorageInstance<RxDocType>(storage: RxStorageDenoKV, params: RxStorageInstanceCreationParams<RxDocType, DenoKVSettings>, settings: DenoKVSettings): Promise<RxStorageInstanceDenoKV<RxDocType>>;

package/dist/types/plugins/storage-dexie/dexie-helper.d.ts

@@ -0,0 +1,40 @@
+import type { DexieStorageInternals, RxDocumentData, RxJsonSchema } from '../../types/index.d.ts';
+import type { DexieSettings } from '../../types/index.d.ts';
+export declare const DEXIE_DOCS_TABLE_NAME = "docs";
+export declare const DEXIE_CHANGES_TABLE_NAME = "changes";
+export declare const DEXIE_ATTACHMENTS_TABLE_NAME = "attachments";
+export declare const RX_STORAGE_NAME_DEXIE = "dexie";
+export declare function getDexieDbWithTables(databaseName: string, collectionName: string, settings: DexieSettings, schema: RxJsonSchema<any>): DexieStorageInternals;
+export declare function closeDexieDb(statePromise: DexieStorageInternals): Promise<void>;
+/**
+ * It is not possible to set non-javascript-variable-syntax
+ * keys as IndexedDB indexes. So we have to substitute the pipe-char
+ * which comes from the key-compression plugin.
+ */
+export declare const DEXIE_PIPE_SUBSTITUTE = "__";
+export declare function dexieReplaceIfStartsWithPipe(str: string): string;
+export declare function dexieReplaceIfStartsWithPipeRevert(str: string): string;
+/**
+ * IndexedDB does not support boolean indexing.
+ * So we have to replace true/false with '1'/'0'
+ * @param d
+ */
+export declare function fromStorageToDexie<RxDocType>(booleanIndexes: string[], inputDoc: RxDocumentData<RxDocType>): any;
+export declare function fromDexieToStorage<RxDocType>(booleanIndexes: string[], d: any): RxDocumentData<RxDocType>;
+/**
+ * @recursive
+ */
+export declare function fromStorageToDexieField(documentData: RxDocumentData<any>): any;
+export declare function fromDexieToStorageField(documentData: any): RxDocumentData<any>;
+/**
+ * Creates a string that can be used to create the dexie store.
+ * @link https://dexie.org/docs/API-Reference#quick-reference
+ */
+export declare function getDexieStoreSchema(rxJsonSchema: RxJsonSchema<any>): string;
+/**
+ * Returns all documents in the database.
+ * Non-deleted plus deleted ones.
+ */
+export declare function getDocsInDb<RxDocType>(internals: DexieStorageInternals, docIds: string[]): Promise<RxDocumentData<RxDocType>[]>;
+export declare function attachmentObjectId(documentId: string, attachmentId: string): string;
+export declare function getBooleanIndexes(schema: RxJsonSchema<any>): string[];

package/dist/types/plugins/storage-dexie/dexie-query.d.ts

@@ -0,0 +1,9 @@
+import type { PreparedQuery, RxQueryPlan, RxStorageQueryResult } from '../../types/index.d.ts';
+import type { RxStorageInstanceDexie } from './rx-storage-instance-dexie.ts';
+export declare function mapKeyForKeyRange(k: any): any;
+export declare function getKeyRangeByQueryPlan(booleanIndexes: string[], queryPlan: RxQueryPlan, IDBKeyRange?: any): any;
+/**
+ * Runs mango queries over the Dexie.js database.
+ */
+export declare function dexieQuery<RxDocType>(instance: RxStorageInstanceDexie<RxDocType>, preparedQuery: PreparedQuery<RxDocType>): Promise<RxStorageQueryResult<RxDocType>>;
+export declare function dexieCount<RxDocType>(instance: RxStorageInstanceDexie<RxDocType>, preparedQuery: PreparedQuery<RxDocType>): Promise<number>;

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

@@ -0,0 +1,4 @@
+export * from './rx-storage-dexie.ts';
+export * from './rx-storage-instance-dexie.ts';
+export * from './dexie-helper.ts';
+export * from './dexie-query.ts';

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

@@ -0,0 +1,11 @@
+import type { RxStorage, RxStorageInstanceCreationParams } from '../../types/index.d.ts';
+import type { DexieSettings, DexieStorageInternals } from '../../types/plugins/dexie.d.ts';
+import { RxStorageInstanceDexie } from './rx-storage-instance-dexie.ts';
+export declare class RxStorageDexie implements RxStorage<DexieStorageInternals, DexieSettings> {
+    settings: DexieSettings;
+    name: string;
+    readonly rxdbVersion = "17.0.0-beta.17";
+    constructor(settings: DexieSettings);
+    createStorageInstance<RxDocType>(params: RxStorageInstanceCreationParams<RxDocType, DexieSettings>): Promise<RxStorageInstanceDexie<RxDocType>>;
+}
+export declare function getRxStorageDexie(settings?: DexieSettings): RxStorageDexie;

package/dist/types/plugins/storage-dexie/rx-storage-instance-dexie.d.ts

@@ -0,0 +1,29 @@
+import { Observable } from 'rxjs';
+import type { RxStorageInstance, RxStorageChangeEvent, RxDocumentData, BulkWriteRow, RxStorageBulkWriteResponse, RxStorageQueryResult, RxJsonSchema, RxStorageInstanceCreationParams, EventBulk, StringKeys, RxStorageDefaultCheckpoint, RxStorageCountResult, PreparedQuery } from '../../types/index.d.ts';
+import type { DexieSettings, DexieStorageInternals } from '../../types/plugins/dexie.d.ts';
+import { RxStorageDexie } from './rx-storage-dexie.ts';
+export declare class RxStorageInstanceDexie<RxDocType> implements RxStorageInstance<RxDocType, DexieStorageInternals, DexieSettings, RxStorageDefaultCheckpoint> {
+    readonly storage: RxStorageDexie;
+    readonly databaseName: string;
+    readonly collectionName: string;
+    readonly schema: Readonly<RxJsonSchema<RxDocumentData<RxDocType>>>;
+    readonly internals: DexieStorageInternals;
+    readonly options: Readonly<DexieSettings>;
+    readonly settings: DexieSettings;
+    readonly devMode: boolean;
+    readonly primaryPath: StringKeys<RxDocumentData<RxDocType>>;
+    private changes$;
+    readonly instanceId: number;
+    closed?: Promise<void>;
+    constructor(storage: RxStorageDexie, databaseName: string, collectionName: string, schema: Readonly<RxJsonSchema<RxDocumentData<RxDocType>>>, internals: DexieStorageInternals, options: Readonly<DexieSettings>, settings: DexieSettings, devMode: boolean);
+    bulkWrite(documentWrites: BulkWriteRow<RxDocType>[], context: string): Promise<RxStorageBulkWriteResponse<RxDocType>>;
+    findDocumentsById(ids: string[], deleted: boolean): Promise<RxDocumentData<RxDocType>[]>;
+    query(preparedQuery: PreparedQuery<RxDocType>): Promise<RxStorageQueryResult<RxDocType>>;
+    count(preparedQuery: PreparedQuery<RxDocType>): Promise<RxStorageCountResult>;
+    changeStream(): Observable<EventBulk<RxStorageChangeEvent<RxDocumentData<RxDocType>>, RxStorageDefaultCheckpoint>>;
+    cleanup(minimumDeletedTime: number): Promise<boolean>;
+    getAttachmentData(documentId: string, attachmentId: string, _digest: string): Promise<Blob>;
+    remove(): Promise<void>;
+    close(): Promise<void>;
+}
+export declare function createDexieStorageInstance<RxDocType>(storage: RxStorageDexie, params: RxStorageInstanceCreationParams<RxDocType, DexieSettings>, settings: DexieSettings): Promise<RxStorageInstanceDexie<RxDocType>>;

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

@@ -0,0 +1,3 @@
+export declare function getFoundationDBIndexName(index: string[]): string;
+export declare const CLEANUP_INDEX: string[];
+export declare const FOUNDATION_DB_WRITE_BATCH_SIZE = 2000;

package/dist/types/plugins/storage-foundationdb/foundationdb-query.d.ts

@@ -0,0 +1,3 @@
+import type { PreparedQuery, RxStorageQueryResult } from '../../types/index.d.ts';
+import { RxStorageInstanceFoundationDB } from './rx-storage-instance-foundationdb.ts';
+export declare function queryFoundationDB<RxDocType>(instance: RxStorageInstanceFoundationDB<RxDocType>, preparedQuery: PreparedQuery<RxDocType>): Promise<RxStorageQueryResult<RxDocType>>;

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

@@ -0,0 +1,46 @@
+import type { EventBulk, RxDocumentData, RxStorage, RxStorageChangeEvent, RxStorageDefaultCheckpoint } from '../../types/index.d.ts';
+export type RxStorageFoundationDBSettings = {
+    /**
+     * Version of the API of the foundationDB server.
+     */
+    apiVersion: number;
+    /**
+     * Path to the foundationDB cluster file
+     * like '/path/to/fdb.cluster'
+     * (optional)
+     */
+    clusterFile?: string;
+    batchSize?: number;
+};
+export type RxStorageFoundationDBInstanceCreationOptions = {
+    batchSize?: number;
+};
+/**
+ * We cannot import types from 'foundationdb'
+ * because 'foundationdb' is an optional peer dependency
+ * this is NOT also in the devDependencies.
+ * This is because it requires to install the foundationdb client cli
+ * which would mean everyone that wants to develop RxDB must have this installed manually.
+ */
+export type FoundationDBIndexMeta<RxDocType> = {
+    indexName: string;
+    index: string[];
+    getIndexableString: (doc: RxDocumentData<RxDocType>) => string;
+    db: FoundationDBDatabase<string>;
+};
+export type FoundationDBConnection = any;
+export type FoundationDBDatabase<RxDocType> = any;
+export type FoundationDBTransaction<RxDocType> = any;
+export type FoundationDBStorageInternals<RxDocType> = {
+    connection: FoundationDBConnection;
+    dbsPromise: Promise<{
+        root: FoundationDBDatabase<any>;
+        main: FoundationDBDatabase<RxDocType>;
+        attachments: FoundationDBDatabase<Buffer>;
+        events: FoundationDBDatabase<EventBulk<RxStorageChangeEvent<RxDocumentData<RxDocType>>, RxStorageDefaultCheckpoint>>;
+        indexes: {
+            [indexName: string]: FoundationDBIndexMeta<RxDocType>;
+        };
+    }>;
+};
+export type RxStorageFoundationDB = RxStorage<FoundationDBStorageInternals<any>, RxStorageFoundationDBInstanceCreationOptions> & {};

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

@@ -0,0 +1,4 @@
+import type { RxStorageFoundationDB, RxStorageFoundationDBSettings } from './foundationdb-types.ts';
+export declare function getRxStorageFoundationDB(settings: RxStorageFoundationDBSettings): RxStorageFoundationDB;
+export * from './foundationdb-types.ts';
+export * from './foundationdb-helpers.ts';

package/dist/types/plugins/storage-foundationdb/rx-storage-instance-foundationdb.d.ts

@@ -0,0 +1,26 @@
+import { Observable } from 'rxjs';
+import type { BulkWriteRow, EventBulk, PreparedQuery, RxDocumentData, RxJsonSchema, RxStorageBulkWriteResponse, RxStorageChangeEvent, RxStorageCountResult, RxStorageDefaultCheckpoint, RxStorageInstance, RxStorageInstanceCreationParams, RxStorageQueryResult, StringKeys } from '../../types/index.d.ts';
+import type { FoundationDBStorageInternals, RxStorageFoundationDB, RxStorageFoundationDBInstanceCreationOptions, RxStorageFoundationDBSettings } from './foundationdb-types.ts';
+export declare class RxStorageInstanceFoundationDB<RxDocType> implements RxStorageInstance<RxDocType, FoundationDBStorageInternals<RxDocType>, RxStorageFoundationDBInstanceCreationOptions, RxStorageDefaultCheckpoint> {
+    readonly storage: RxStorageFoundationDB;
+    readonly databaseName: string;
+    readonly collectionName: string;
+    readonly schema: Readonly<RxJsonSchema<RxDocumentData<RxDocType>>>;
+    readonly internals: FoundationDBStorageInternals<RxDocType>;
+    readonly options: Readonly<RxStorageFoundationDBInstanceCreationOptions>;
+    readonly settings: RxStorageFoundationDBSettings;
+    readonly primaryPath: StringKeys<RxDocumentData<RxDocType>>;
+    closed?: Promise<void>;
+    private changes$;
+    constructor(storage: RxStorageFoundationDB, databaseName: string, collectionName: string, schema: Readonly<RxJsonSchema<RxDocumentData<RxDocType>>>, internals: FoundationDBStorageInternals<RxDocType>, options: Readonly<RxStorageFoundationDBInstanceCreationOptions>, settings: RxStorageFoundationDBSettings);
+    bulkWrite(documentWrites: BulkWriteRow<RxDocType>[], context: string): Promise<RxStorageBulkWriteResponse<RxDocType>>;
+    findDocumentsById(ids: string[], withDeleted: boolean): Promise<RxDocumentData<RxDocType>[]>;
+    query(preparedQuery: PreparedQuery<RxDocType>): Promise<RxStorageQueryResult<RxDocType>>;
+    count(preparedQuery: PreparedQuery<RxDocType>): Promise<RxStorageCountResult>;
+    getAttachmentData(documentId: string, attachmentId: string, _digest: string): Promise<Blob>;
+    changeStream(): Observable<EventBulk<RxStorageChangeEvent<RxDocType>, RxStorageDefaultCheckpoint>>;
+    remove(): Promise<void>;
+    cleanup(minimumDeletedTime: number): Promise<boolean>;
+    close(): Promise<void>;
+}
+export declare function createFoundationDBStorageInstance<RxDocType>(storage: RxStorageFoundationDB, params: RxStorageInstanceCreationParams<RxDocType, RxStorageFoundationDBInstanceCreationOptions>, settings: RxStorageFoundationDBSettings): Promise<RxStorageInstanceFoundationDB<RxDocType>>;

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

@@ -0,0 +1,11 @@
+import type { RxStorage, RxStorageInstanceCreationParams } from '../../types/index';
+import { LocalstorageInstanceCreationOptions, LocalstorageStorageInternals, LocalstorageStorageSettings, RxStorageInstanceLocalstorage } from './rx-storage-instance-localstorage.ts';
+export * from './localstorage-mock.ts';
+export declare class RxStorageLocalstorage implements RxStorage<LocalstorageStorageInternals, LocalstorageInstanceCreationOptions> {
+    settings: LocalstorageStorageSettings;
+    name: string;
+    readonly rxdbVersion = "17.0.0-beta.17";
+    constructor(settings: LocalstorageStorageSettings);
+    createStorageInstance<RxDocType>(params: RxStorageInstanceCreationParams<RxDocType, LocalstorageInstanceCreationOptions>): Promise<RxStorageInstanceLocalstorage<RxDocType>>;
+}
+export declare function getRxStorageLocalstorage(settings?: Partial<LocalstorageStorageSettings>): RxStorageLocalstorage;

package/dist/types/plugins/storage-localstorage/localstorage-mock.d.ts

@@ -0,0 +1 @@
+export declare function getLocalStorageMock(): typeof localStorage;

package/dist/types/plugins/storage-localstorage/rx-storage-instance-localstorage.d.ts

@@ -0,0 +1,84 @@
+import { Observable, Subject } from 'rxjs';
+import type { BulkWriteRow, ById, EventBulk, PreparedQuery, RxDocumentData, RxDocumentWriteData, RxJsonSchema, RxStorageBulkWriteResponse, RxStorageChangeEvent, RxStorageCountResult, RxStorageDefaultCheckpoint, RxStorageInstance, RxStorageInstanceCreationParams, RxStorageQueryResult, StringKeys } from '../../types/index';
+import type { RxStorageLocalstorage } from './index.ts';
+export declare const RX_STORAGE_NAME_LOCALSTORAGE = "localstorage";
+export type LocalstorageStorageInternals<RxDocType = any> = {
+    indexes: ById<IndexMeta<RxDocType>>;
+};
+export type LocalstorageInstanceCreationOptions = {};
+export type LocalstorageStorageSettings = {
+    localStorage?: typeof localStorage;
+};
+export type LocalstorageIndex = string[][];
+export type ChangeStreamStoredData<RxDocType> = {
+    databaseInstanceToken: string;
+    eventBulk: EventBulk<RxStorageChangeEvent<RxDocumentData<RxDocType>>, any>;
+};
+/**
+ * StorageEvents are not sent to the same
+ * browser tab where they were created.
+ * This makes it hard to write unit tests
+ * so we redistribute the events here instead.
+ */
+export declare const storageEventStream$: Subject<{
+    fromStorageEvent: boolean;
+    key: string;
+    newValue: string | null;
+    databaseInstanceToken?: string;
+}>;
+export declare function getStorageEventStream(): Observable<{
+    fromStorageEvent: boolean;
+    key: string;
+    newValue: string | null;
+    databaseInstanceToken?: string;
+}>;
+export declare class RxStorageInstanceLocalstorage<RxDocType> implements RxStorageInstance<RxDocType, LocalstorageStorageInternals, LocalstorageInstanceCreationOptions, RxStorageDefaultCheckpoint> {
+    readonly storage: RxStorageLocalstorage;
+    readonly databaseName: string;
+    readonly collectionName: string;
+    readonly schema: Readonly<RxJsonSchema<RxDocumentData<RxDocType>>>;
+    readonly internals: LocalstorageStorageInternals;
+    readonly options: Readonly<LocalstorageInstanceCreationOptions>;
+    readonly settings: LocalstorageStorageSettings;
+    readonly multiInstance: boolean;
+    readonly databaseInstanceToken: string;
+    readonly primaryPath: StringKeys<RxDocType>;
+    /**
+     * Under this key the whole state
+     * will be stored as stringified json
+     * inside of the localstorage.
+     */
+    readonly docsKey: string;
+    readonly attachmentsKey: string;
+    readonly changestreamStorageKey: string;
+    readonly indexesKey: string;
+    private changeStreamSub;
+    private changes$;
+    closed?: Promise<void>;
+    readonly localStorage: typeof localStorage;
+    removed: boolean;
+    readonly instanceId: number;
+    constructor(storage: RxStorageLocalstorage, databaseName: string, collectionName: string, schema: Readonly<RxJsonSchema<RxDocumentData<RxDocType>>>, internals: LocalstorageStorageInternals, options: Readonly<LocalstorageInstanceCreationOptions>, settings: LocalstorageStorageSettings, multiInstance: boolean, databaseInstanceToken: string);
+    getDoc(docId: string | RxDocumentWriteData<RxDocType>[StringKeys<RxDocType>]): RxDocumentData<RxDocType> | undefined;
+    setDoc(doc: RxDocumentData<RxDocType>): void;
+    getIndex(index: string[]): LocalstorageIndex;
+    setIndex(index: string[], value: LocalstorageIndex): void;
+    bulkWrite(documentWrites: BulkWriteRow<RxDocType>[], context: string): Promise<RxStorageBulkWriteResponse<RxDocType>>;
+    findDocumentsById(docIds: string[], withDeleted: boolean): Promise<RxDocumentData<RxDocType>[]>;
+    query(preparedQuery: PreparedQuery<RxDocType>): Promise<RxStorageQueryResult<RxDocType>>;
+    count(preparedQuery: PreparedQuery<RxDocType>): Promise<RxStorageCountResult>;
+    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 createLocalstorageStorageInstance<RxDocType>(storage: RxStorageLocalstorage, params: RxStorageInstanceCreationParams<RxDocType, LocalstorageInstanceCreationOptions>, settings: LocalstorageStorageSettings): Promise<RxStorageInstanceLocalstorage<RxDocType>>;
+export declare function getIndexName(index: string[]): string;
+export declare const CLEANUP_INDEX: string[];
+export type IndexMeta<RxDocType> = {
+    indexId: string;
+    indexName: string;
+    index: string[];
+    getIndexableString: (doc: RxDocumentData<RxDocType>) => string;
+};

package/dist/types/plugins/storage-memory/binary-search-bounds.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Everything in this file was copied and adapted from
+ * @link https://github.com/mikolalysenko/binary-search-bounds
+ *
+ * We should use the original npm module instead when this bug is fixed:
+ * @link https://github.com/mikolalysenko/binary-search-bounds/pull/14
+ */
+type Compare<T> = ((a: T, b: T) => number | null | undefined);
+export declare function boundGE<T>(a: T[], y: T, c: Compare<T>, l?: any, h?: any): any;
+export declare function boundGT<T>(a: T[], y: T, c: Compare<T>, l?: any, h?: any): any;
+export declare function boundLT<T>(a: T[], y: T, c: Compare<T>, l?: any, h?: any): any;
+export declare function boundLE<T>(a: T[], y: T, c: Compare<T>, l?: any, h?: any): any;
+export declare function boundEQ<T>(a: T[], y: T, c: Compare<T>, l?: any, h?: any): any;
+export {};

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

@@ -0,0 +1,7 @@
+import type { RxStorageMemory, RxStorageMemorySettings } from './memory-types.ts';
+export declare function getRxStorageMemory(settings?: RxStorageMemorySettings): RxStorageMemory;
+export * from './memory-helper.ts';
+export * from './binary-search-bounds.ts';
+export * from './memory-types.ts';
+export * from './memory-indexes.ts';
+export * from './rx-storage-instance-memory.ts';

package/dist/types/plugins/storage-memory/memory-helper.d.ts

@@ -0,0 +1,22 @@
+import type { RxDocumentData, RxJsonSchema } from '../../types/index.d.ts';
+import type { DocWithIndexString, MemoryStorageInternals, MemoryStorageInternalsByIndex } from './memory-types.ts';
+import type { RxStorageInstanceMemory } from './rx-storage-instance-memory.ts';
+export declare function getMemoryCollectionKey(databaseName: string, collectionName: string, schemaVersion: number): string;
+export declare function ensureNotRemoved(instance: RxStorageInstanceMemory<any>): void;
+export declare function attachmentMapKey(documentId: string, attachmentId: string): string;
+/**
+ * @hotPath
+ */
+export declare function putWriteRowToState<RxDocType>(docId: string, state: MemoryStorageInternals<RxDocType>, stateByIndex: MemoryStorageInternalsByIndex<RxDocType>[], document: RxDocumentData<RxDocType>, docInState?: RxDocumentData<RxDocType>): void;
+/**
+ * @hotPath
+ * Efficiently inserts multiple documents into the state at once.
+ * Instead of inserting one-by-one with Array.splice() (O(n) per insert),
+ * this pre-computes all index entries, sorts them, and merges them into
+ * the existing sorted arrays in a single pass (O(n log n + n + m)).
+ */
+export declare function bulkInsertToState<RxDocType>(primaryPath: string, state: MemoryStorageInternals<RxDocType>, stateByIndex: MemoryStorageInternalsByIndex<RxDocType>[], docs: {
+    document: RxDocumentData<RxDocType>;
+}[]): void;
+export declare function removeDocFromState<RxDocType>(primaryPath: string, schema: RxJsonSchema<RxDocumentData<RxDocType>>, state: MemoryStorageInternals<RxDocType>, doc: RxDocumentData<RxDocType>): void;
+export declare function compareDocsWithIndex<RxDocType>(a: DocWithIndexString<RxDocType>, b: DocWithIndexString<RxDocType>): 1 | 0 | -1;

package/dist/types/plugins/storage-memory/memory-indexes.d.ts

@@ -0,0 +1,4 @@
+import type { RxDocumentData, RxJsonSchema } from '../../types/index.d.ts';
+import type { MemoryStorageInternals } from './memory-types.ts';
+export declare function addIndexesToInternalsState<RxDocType>(state: MemoryStorageInternals<RxDocType>, schema: RxJsonSchema<RxDocumentData<RxDocType>>): void;
+export declare function getMemoryIndexName(index: string[]): string;

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

@@ -0,0 +1,72 @@
+import { Subject } from 'rxjs';
+import type { CategorizeBulkWriteRowsOutput, EventBulk, RxAttachmentWriteData, RxDocumentData, RxJsonSchema, RxStorage, RxStorageChangeEvent, RxStorageDefaultCheckpoint } from '../../types/index.d.ts';
+export type RxStorageMemorySettings = {};
+export type RxStorageMemoryInstanceCreationOptions = {};
+export type RxStorageMemory = RxStorage<MemoryStorageInternals<any>, RxStorageMemoryInstanceCreationOptions> & {
+    /**
+     * State by collectionKey
+     */
+    collectionStates: Map<string, MemoryStorageInternals<any>>;
+};
+export type MemoryStorageInternalsByIndex<RxDocType> = {
+    index: string[];
+    docsWithIndex: DocWithIndexString<RxDocType>[];
+    getIndexableString: (docData: RxDocumentData<RxDocType>) => string;
+};
+/**
+ * The internals are shared between multiple storage instances
+ * that have been created with the same [databaseName+collectionName] combination.
+ */
+export type MemoryStorageInternals<RxDocType> = {
+    id: string;
+    /**
+     * Schema of the first instance created with the given settings.
+     * Used to ensure that the same storage is not re-created with
+     * a different schema.
+     */
+    schema: RxJsonSchema<RxDocumentData<RxDocType>>;
+    /**
+     * We reuse the memory state when multiple instances
+     * are created with the same params.
+     * If refCount becomes 0, we can delete the state.
+     */
+    refCount: number;
+    /**
+     * If this becomes true,
+     * it means that an instance has called remove()
+     * so all other instances should also not work anymore.
+     */
+    removed: boolean;
+    documents: Map<string, RxDocumentData<RxDocType>>;
+    /**
+     * Attachments data, indexed by a combined string
+     * consisting of [documentId + '||' + attachmentId]
+     */
+    attachments: Map<string, {
+        writeData: RxAttachmentWriteData;
+        digest: string;
+    }>;
+    byIndex: {
+        /**
+         * Because RxDB requires a deterministic sorting
+         * on all indexes, we can be sure that the composed index key
+         * of each document is unique, because it contains the primaryKey
+         * as last index part.
+         * So we do not have to store the index-position when we want to do fast
+         * writes. Instead we can do a binary search over the existing array
+         * because RxDB also knows the previous state of the document when we do a bulkWrite().
+         */
+        [indexName: string]: MemoryStorageInternalsByIndex<RxDocType>;
+    };
+    /**
+     * We need these to do lazy writes.
+     */
+    ensurePersistenceTask?: CategorizeBulkWriteRowsOutput<RxDocType>;
+    ensurePersistenceIdlePromise?: Promise<void>;
+    changes$: Subject<EventBulk<RxStorageChangeEvent<RxDocumentData<RxDocType>>, RxStorageDefaultCheckpoint>>;
+};
+export type DocWithIndexString<RxDocType> = [
+    string,
+    RxDocumentData<RxDocType>,
+    string
+];

package/dist/types/plugins/storage-memory/rx-storage-instance-memory.d.ts

@@ -0,0 +1,47 @@
+import { Observable } from 'rxjs';
+import type { BulkWriteRow, CategorizeBulkWriteRowsOutput, EventBulk, PreparedQuery, RxDocumentData, RxJsonSchema, RxStorageBulkWriteResponse, RxStorageChangeEvent, RxStorageCountResult, RxStorageDefaultCheckpoint, RxStorageInstance, RxStorageInstanceCreationParams, RxStorageQueryResult, StringKeys } from '../../types/index.d.ts';
+import type { MemoryStorageInternals, RxStorageMemory, RxStorageMemoryInstanceCreationOptions, RxStorageMemorySettings } from './memory-types.ts';
+/**
+ * Used in tests to ensure everything
+ * is closed correctly
+ */
+export declare const OPEN_MEMORY_INSTANCES: Set<RxStorageInstanceMemory<any>>;
+export declare class RxStorageInstanceMemory<RxDocType> implements RxStorageInstance<RxDocType, MemoryStorageInternals<RxDocType>, RxStorageMemoryInstanceCreationOptions, RxStorageDefaultCheckpoint> {
+    readonly storage: RxStorageMemory;
+    readonly databaseName: string;
+    readonly collectionName: string;
+    readonly schema: Readonly<RxJsonSchema<RxDocumentData<RxDocType>>>;
+    readonly internals: MemoryStorageInternals<RxDocType>;
+    readonly options: Readonly<RxStorageMemoryInstanceCreationOptions>;
+    readonly settings: RxStorageMemorySettings;
+    readonly devMode: boolean;
+    readonly primaryPath: StringKeys<RxDocumentData<RxDocType>>;
+    closed: boolean;
+    /**
+     * Used by some plugins and storage wrappers
+     * to find out details about the internals of a write operation.
+     * For example if you want to know which documents really have been replaced
+     * or newly inserted.
+     */
+    categorizedByWriteInput: WeakMap<BulkWriteRow<RxDocType>[], CategorizeBulkWriteRowsOutput<RxDocType>>;
+    constructor(storage: RxStorageMemory, databaseName: string, collectionName: string, schema: Readonly<RxJsonSchema<RxDocumentData<RxDocType>>>, internals: MemoryStorageInternals<RxDocType>, options: Readonly<RxStorageMemoryInstanceCreationOptions>, settings: RxStorageMemorySettings, devMode: boolean);
+    bulkWrite(documentWrites: BulkWriteRow<RxDocType>[], context: string): Promise<RxStorageBulkWriteResponse<RxDocType>>;
+    /**
+     * Instead of directly inserting the documents into all indexes,
+     * we do it lazy in the background. This gives the application time
+     * to directly work with the write-result and to do stuff like rendering DOM
+     * notes and processing RxDB queries.
+     * Then in some later time, or just before the next read/write,
+     * it is ensured that the indexes have been written.
+     */
+    ensurePersistence(): void;
+    findDocumentsById(docIds: string[], withDeleted: boolean): Promise<RxDocumentData<RxDocType>[]>;
+    query(preparedQuery: PreparedQuery<RxDocType>): Promise<RxStorageQueryResult<RxDocType>>;
+    count(preparedQuery: PreparedQuery<RxDocType>): Promise<RxStorageCountResult>;
+    cleanup(minimumDeletedTime: number): Promise<boolean>;
+    getAttachmentData(documentId: string, attachmentId: string, digest: string): Promise<Blob>;
+    changeStream(): Observable<EventBulk<RxStorageChangeEvent<RxDocumentData<RxDocType>>, RxStorageDefaultCheckpoint>>;
+    remove(): Promise<void>;
+    close(): Promise<void>;
+}
+export declare function createMemoryStorageInstance<RxDocType>(storage: RxStorageMemory, params: RxStorageInstanceCreationParams<RxDocType, RxStorageMemoryInstanceCreationOptions>, settings: RxStorageMemorySettings): Promise<RxStorageInstanceMemory<RxDocType>>;

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

@@ -0,0 +1,4 @@
+export * from './rx-storage-mongodb.ts';
+export * from './rx-storage-instance-mongodb.ts';
+export * from './mongodb-helper.ts';
+export * from './mongodb-types.ts';

package/dist/types/plugins/storage-mongodb/mongodb-helper.d.ts

@@ -0,0 +1,22 @@
+import type { FilledMangoQuery, MangoQuerySelector, MangoQuerySortPart, RxDocumentData, RxJsonSchema } from '../../types/index.d.ts';
+import { Sort as MongoSort } from 'mongodb';
+import { MongoDBPreparedQuery, MongoQuerySelector } from './mongodb-types.ts';
+export declare const RX_STORAGE_NAME_MONGODB = "mongodb";
+export declare const MONGO_OPTIONS_DRIVER_INFO: {
+    driverInfo: {
+        name: string;
+        version: string;
+    };
+};
+/**
+ * MongoDB uses the _id field by itself (max 12 bytes)
+ * so we have to substitute the _id field if
+ * it is used in the RxDocType.
+ */
+export declare const MONGO_ID_SUBSTITUTE_FIELDNAME = "__id";
+export declare function primarySwapMongoDBQuerySelector<RxDocType>(primaryKey: keyof RxDocType, selector: MangoQuerySelector<RxDocType>): MongoQuerySelector<RxDocType>;
+export declare function prepareMongoDBQuery<RxDocType>(schema: RxJsonSchema<RxDocumentData<RxDocType>>, mutateableQuery: FilledMangoQuery<RxDocType>): MongoDBPreparedQuery<RxDocType>;
+export declare function swapMongoToRxDoc<RxDocType>(docData: any): RxDocumentData<RxDocType>;
+export declare function swapRxDocToMongo<RxDocType>(docData: RxDocumentData<RxDocType>): any;
+export declare function swapToMongoSort<RxDocType>(sort: MangoQuerySortPart<RxDocType>[]): MongoSort;
+export declare function getMongoDBIndexName(index: string[]): string;

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

@@ -0,0 +1,21 @@
+import type { Filter as MongoQueryFilter, Sort as MongoSort, TransactionOptions } from 'mongodb';
+import type { FilledMangoQuery, RxDocumentData } from '../../types/index.d.ts';
+/**
+ * MongoDB ConnectionString
+ * Example: mongodb://localhost:<port>
+ */
+export type MongoDBConnectionString = string | 'mongodb://localhost:27017';
+export type MongoQuerySelector<RxDocType> = MongoQueryFilter<RxDocType | any>;
+export type MongoDBDatabaseSettings = {
+    connection: MongoDBConnectionString;
+    transactionOptions?: TransactionOptions;
+};
+export type MongoDBPreparedQuery<RxDocType> = {
+    query: FilledMangoQuery<RxDocType>;
+    mongoSelector: MongoQuerySelector<RxDocumentData<RxDocType>>;
+    mongoSort: MongoSort;
+};
+export type MongoDBSettings = {};
+export type MongoDBStorageInternals = {};
+export type RxStorageMongoDBInstanceCreationOptions = {};
+export type RxStorageMongoDBSettings = {};

package/dist/types/plugins/storage-mongodb/rx-storage-instance-mongodb.d.ts

@@ -0,0 +1,52 @@
+import { BehaviorSubject, Observable } from 'rxjs';
+import type { BulkWriteRow, EventBulk, PreparedQuery, RxDocumentData, RxJsonSchema, RxStorageBulkWriteResponse, RxStorageChangeEvent, RxStorageCountResult, RxStorageDefaultCheckpoint, RxStorageInstance, RxStorageInstanceCreationParams, RxStorageQueryResult, StringKeys } from '../../types/index.d.ts';
+import { MongoDBStorageInternals, RxStorageMongoDBInstanceCreationOptions, RxStorageMongoDBSettings } from './mongodb-types.ts';
+import { RxStorageMongoDB } from './rx-storage-mongodb.ts';
+import { Db as MongoDatabase, Collection as MongoCollection, MongoClient, ObjectId, ClientSession } from 'mongodb';
+export declare class RxStorageInstanceMongoDB<RxDocType> implements RxStorageInstance<RxDocType, MongoDBStorageInternals, RxStorageMongoDBInstanceCreationOptions, RxStorageDefaultCheckpoint> {
+    readonly storage: RxStorageMongoDB;
+    readonly databaseName: string;
+    readonly collectionName: string;
+    readonly schema: Readonly<RxJsonSchema<RxDocumentData<RxDocType>>>;
+    readonly internals: MongoDBStorageInternals;
+    readonly options: Readonly<RxStorageMongoDBInstanceCreationOptions>;
+    readonly settings: RxStorageMongoDBSettings;
+    readonly primaryPath: StringKeys<RxDocumentData<RxDocType>>;
+    readonly inMongoPrimaryPath: string;
+    closed?: Promise<void>;
+    private readonly changes$;
+    readonly mongoClient: MongoClient;
+    readonly mongoDatabase: MongoDatabase;
+    readonly mongoCollectionPromise: Promise<MongoCollection<RxDocumentData<RxDocType> | any>>;
+    /**
+     * Closing the connection must not happen when
+     * an operation is running, otherwise we get an error.
+     * So we store all running operations here so that
+     * they can be awaited.
+     */
+    readonly runningOperations: BehaviorSubject<number>;
+    writeQueue: Promise<any>;
+    /**
+     * We use this to be able to still fetch
+     * the objectId after transforming the document from mongo-style (with _id)
+     * to RxDB
+     */
+    readonly mongoObjectIdCache: WeakMap<RxDocumentData<RxDocType>, ObjectId>;
+    constructor(storage: RxStorageMongoDB, databaseName: string, collectionName: string, schema: Readonly<RxJsonSchema<RxDocumentData<RxDocType>>>, internals: MongoDBStorageInternals, options: Readonly<RxStorageMongoDBInstanceCreationOptions>, settings: RxStorageMongoDBSettings);
+    /**
+     * Bulk writes on the mongodb storage.
+     * Notice that MongoDB does not support cross-document transactions
+     * so we have to do a update-if-previous-is-correct like operations.
+     * (Similar to what RxDB does with the revision system)
+     */
+    bulkWrite(documentWrites: BulkWriteRow<RxDocType>[], context: string): Promise<RxStorageBulkWriteResponse<RxDocType>>;
+    findDocumentsById(docIds: string[], withDeleted: boolean, session?: ClientSession): Promise<RxDocumentData<RxDocType>[]>;
+    query(originalPreparedQuery: PreparedQuery<RxDocType>): Promise<RxStorageQueryResult<RxDocType>>;
+    count(originalPreparedQuery: PreparedQuery<RxDocType>): Promise<RxStorageCountResult>;
+    cleanup(minimumDeletedTime: number): Promise<boolean>;
+    getAttachmentData(_documentId: string, _attachmentId: string, _digest: string): Promise<Blob>;
+    changeStream(): Observable<EventBulk<RxStorageChangeEvent<RxDocumentData<RxDocType>>, RxStorageDefaultCheckpoint>>;
+    remove(): Promise<void>;
+    close(): Promise<void>;
+}
+export declare function createMongoDBStorageInstance<RxDocType>(storage: RxStorageMongoDB, params: RxStorageInstanceCreationParams<RxDocType, RxStorageMongoDBInstanceCreationOptions>, settings: RxStorageMongoDBSettings): Promise<RxStorageInstanceMongoDB<RxDocType>>;

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

@@ -0,0 +1,11 @@
+import type { RxStorage, RxStorageInstanceCreationParams } from '../../types/index.d.ts';
+import type { MongoDBDatabaseSettings, MongoDBSettings, MongoDBStorageInternals } from './mongodb-types.ts';
+import { RxStorageInstanceMongoDB } from './rx-storage-instance-mongodb.ts';
+export declare class RxStorageMongoDB implements RxStorage<MongoDBStorageInternals, MongoDBSettings> {
+    databaseSettings: MongoDBDatabaseSettings;
+    name: string;
+    readonly rxdbVersion = "17.0.0-beta.17";
+    constructor(databaseSettings: MongoDBDatabaseSettings);
+    createStorageInstance<RxDocType>(params: RxStorageInstanceCreationParams<RxDocType, MongoDBSettings>): Promise<RxStorageInstanceMongoDB<RxDocType>>;
+}
+export declare function getRxStorageMongoDB(databaseSettings: MongoDBDatabaseSettings): RxStorageMongoDB;