@connecttomahdi/rxdb 17.1.0 → 17.1.1

package/dist/types/types/couchdb.d.ts

@@ -0,0 +1,293 @@
+import type {
+    MangoQuery,
+    MangoQuerySelector,
+    MangoQuerySortPart
+} from './rx-query.d.ts';
+import type { BulkWriteRow } from './rx-storage.d.ts';
+
+/**
+ * This file contains types that are CouchDB specific
+ */
+
+export interface CouchReplicationOptions {
+    live?: boolean;
+    retry?: boolean;
+    filter?: Function;
+    doc_ids?: string[];
+    query_params?: any;
+    view?: any;
+    since?: number | 'now';
+    heartbeat?: number;
+    timeout?: number;
+    batch_size?: number;
+    batches_limit?: number;
+    back_off_function?: Function;
+    checkpoint?: false | 'source' | 'target';
+    include_docs?: boolean;
+    limit?: number;
+}
+
+export interface CouchChangesOptionsBase {
+    include_docs?: boolean;
+    conflicts?: boolean;
+    attachments?: boolean;
+    binary?: boolean;
+    descending?: boolean;
+    since?: any;
+    limit?: number;
+    timeout?: any;
+    heartbeat?: number | boolean;
+    filter?: any;
+    doc_ids?: string | string[];
+    query_param?: any;
+    view?: any;
+    return_docs?: boolean;
+    batch_size?: number;
+    style?: string;
+}
+
+export interface CouchChangesOptionsLive extends CouchChangesOptionsBase {
+    live: true;
+}
+
+export interface CouchChangesOptionsNonLive extends CouchChangesOptionsBase {
+    live: false;
+}
+interface CouchChangesOnChangeEvent {
+    on: (eventName: string, handler: Function) => void;
+    off: (eventName: string, handler: Function) => void;
+    cancel(): void;
+}
+
+export type CouchWriteError = {
+    /**
+      * status code from couchdb
+      * 409 for 'conflict'
+    */
+    status: number;
+    error: true;
+    /**
+     * primary key value of the errored document
+     */
+    id: string;
+};
+
+/**
+ * possible couch-settings
+ * @link https://couchdb.com/api.html#create_database
+ */
+export interface CouchSettings {
+    auto_compaction?: boolean;
+    revs_limit?: number;
+    ajax?: any;
+    fetch?: any;
+    auth?: any;
+    skip_setup?: boolean;
+    storage?: any;
+    size?: number;
+    location?: string;
+    iosDatabaseLocation?: string;
+}
+
+/**
+ * options for couch.allDocs()
+ * @link https://couchdb.com/api.html#batch_fetch
+ */
+export type CouchAllDocsOptions = {
+    include_docs?: boolean;
+    conflicts?: boolean;
+    attachments?: boolean;
+    binary?: boolean;
+    startkey?: string;
+    endkey?: string;
+    inclusive_end?: boolean;
+    limit?: number;
+    skip?: number;
+    descending?: boolean;
+    key?: string;
+    keys?: string[];
+    update_seq?: string;
+
+    // undocument but needed
+    revs?: boolean;
+    deleted?: 'ok';
+};
+
+export type CouchSyncHandlerEvents = 'change' | 'paused' | 'active' | 'error' | 'complete';
+export type CouchSyncHandler = {
+    on(ev: CouchSyncHandlerEvents, fn: (el: any) => void): void;
+    off(ev: CouchSyncHandlerEvents, fn: any): void;
+    cancel(): void;
+};
+
+export type CouchChangeRow = {
+    id: string;
+    seq: number;
+    deleted?: true;
+    changes: {
+        rev: 'string';
+    }[];
+    /**
+     * only if include_docs === true
+     */
+    doc?: CouchChangeDoc;
+};
+
+export type CouchAttachmentMeta = {
+    digest: string;
+    content_type: string;
+    length: number;
+    stub: boolean;
+
+    /**
+     * 'revpos indicates the generation number (numeric prefix in the revID) at which the attachment was last altered'
+     *  @link https://github.com/couchbase/couchbase-lite-ios/issues/1200#issuecomment-206444554
+     */
+    revpos: number;
+};
+
+export type CouchAttachmentWithData = CouchAttachmentMeta & {
+    /**
+     * Base64 string with the data
+     * or directly a buffer
+     */
+    data: Blob;
+    type: string;
+    /**
+     * If set, must be false
+     * because we have the full data and not only a stub.
+     */
+    stub?: false;
+};
+
+export type CouchChangeDoc = {
+    _id: string;
+    _rev: string;
+    /**
+     * True if the document is deleted.
+     */
+    _deleted?: boolean;
+    _attachments: {
+        [attachmentId: string]: CouchAttachmentMeta;
+    };
+};
+
+export type WithAttachments<Data> = Data & {
+    /**
+     * Intentional optional,
+     * if the document has no attachments,
+     * we do NOT have an empty object.
+     */
+    _attachments?: {
+        [attachmentId: string]: CouchAttachmentMeta;
+    };
+};
+export type WithAttachmentsData<Data> = Data & {
+    /**
+     * Intentional optional,
+     * if the document has no attachments,
+     * we do NOT have an empty object.
+     */
+    _attachments?: {
+        [attachmentId: string]: CouchAttachmentWithData;
+    };
+};
+
+
+export type WithCouchMeta<Data> = Data & {
+    _rev: string;
+    _attachments?: {
+        [attachmentId: string]: CouchAttachmentMeta;
+    };
+    _deleted?: boolean;
+};
+
+export type CouchdbChangesResult = {
+    results: CouchChangeRow[];
+    last_seq: number;
+};
+
+declare type Debug = {
+    enable(what: string): void;
+    disable(): void;
+};
+
+export type CouchDbSorting = (string | string[] | { [k: string]: 'asc' | 'desc' | 1 | -1; })[];
+
+// this is not equal to the standard MangoQuery
+// because of different sorting
+export type CouchdbQuery = MangoQuery & {
+    sort?: CouchDbSorting;
+};
+
+export type CouchBulkDocResultRow = {
+    ok: boolean;
+    id: string;
+    rev: string;
+
+    error?: 'conflict';
+    reason?: string;
+};
+
+export type CouchCheckpoint = {
+    sequence: number;
+};
+
+export type CouchBulkDocOptions = {
+    new_edits?: boolean;
+
+    // custom options for RxDB
+    isDeeper?: boolean;
+    custom?: {
+        primaryPath: string;
+        writeRowById: Map<string, BulkWriteRow<any>>;
+        insertDocsById: Map<string, any>;
+        previousDocsInDb: Map<string, any>;
+        context: string;
+    };
+};
+
+export type CouchMangoQuery<DocType> = MangoQuery<DocType> & {
+    index: undefined;
+    use_index?: string;
+};
+
+export type ExplainedCouchQuery<DocType> = {
+    dbname: string;
+    index: {
+        ddoc: string | null;
+        name: string; // 'idx-rxdb-index-age,_id'
+        type: 'json';
+        def: {
+            fields: MangoQuerySortPart<DocType>[];
+        };
+    };
+    selector: MangoQuerySelector<DocType>;
+    range: {
+        start_key: any[];
+        end_key: any[];
+    };
+    opts: {
+        use_index: string[];
+        bookmark: string;
+        sort: MangoQuerySortPart<DocType>[];
+        conflicts: boolean;
+        r: any[];
+    };
+    skip: number;
+};
+
+export type CouchAllDocsResponse = {
+    offset: number;
+    rows: {
+        id: string;
+        doc: any;
+        key: string;
+        value: {
+            rev: string;
+            deleted?: boolean;
+        };
+        error?: 'not_found' | string;
+    }[];
+    total_rows: number;
+};

package/dist/types/types/index.d.ts

@@ -0,0 +1,32 @@
+export type * from './couchdb.d.ts';
+export type * from './rx-attachment.d.ts';
+export type * from './rx-collection.d.ts';
+export type * from './rx-database.d.ts';
+export type * from './rx-database-internal-store.d.ts';
+export type * from './rx-document.d.ts';
+export type * from './rx-error.d.ts';
+export type * from './rx-plugin.d.ts';
+export type * from './rx-query.d.ts';
+export type * from './rx-schema.d.ts';
+export type * from './rx-storage.d.ts';
+export type * from './rx-storage.interface.d.ts';
+export type * from './replication-protocol.d.ts';
+export type * from './conflict-handling.d.ts';
+export type * from './rx-change-event.d.ts';
+export type * from './query-planner.d.ts';
+export type * from './util.d.ts';
+
+// plugins
+export type * from './plugins/replication.d.ts';
+export type * from './plugins/replication-graphql.d.ts';
+export type * from './plugins/replication.d.ts';
+export type * from './plugins/local-documents.d.ts';
+export type * from './plugins/migration.d.ts';
+export type * from './plugins/backup.d.ts';
+export type * from './plugins/cleanup.d.ts';
+export type * from './plugins/dexie.d.ts';
+export type * from './plugins/reactivity.d.ts';
+export type * from './plugins/update.d.ts';
+export type * from './plugins/crdt.d.ts';
+export type * from './plugins/state.d.ts';
+export type * from './plugins/webmcp.d.ts';

package/dist/types/types/modules/mocha.parallel.d.ts

@@ -0,0 +1 @@
+declare module 'mocha.parallel';

package/dist/types/types/plugins/backup.d.ts

@@ -0,0 +1,35 @@
+export type BackupOptions = {
+    live: boolean;
+    directory: string;
+    /**
+     * If true,
+     * attachments will also be saved
+     */
+    attachments?: boolean;
+    /**
+     * How many documents can be processed in one batch
+     * [default=10]
+     */
+    batchSize?: number;
+    /**
+     * If not set, all collections will be backed up.
+     */
+    collections?: string[];
+};
+
+export type BackupMetaFileContent = {
+    createdAt: number;
+    updatedAt: number;
+    collectionStates: {
+        [collectionName: string]: {
+            checkpoint?: any;
+        };
+    };
+};
+
+export type RxBackupWriteEvent = {
+    collectionName: string;
+    documentId: string;
+    files: string[];
+    deleted: boolean;
+};

package/dist/types/types/plugins/cleanup.d.ts

@@ -0,0 +1,38 @@
+export type RxCleanupPolicy = {
+    /**
+     * The minimum time in milliseconds
+     * of how long a document must have been deleted
+     * until it is purged by the cleanup.
+     * This should be higher then the time you expect
+     * your user to be offline for.
+     * If this is too low, deleted documents might not
+     * replicate their deletion state.
+     */
+    minimumDeletedTime: number;
+    /**
+     * The minimum amount of time that the RxCollection must have existed.
+     * This ensures that at the initial page load, more important
+     * tasks are not slowed down because a cleanup process is running.
+     */
+    minimumCollectionAge: number;
+    /**
+     * After the initial cleanup is done,
+     * a new cleanup is started after [runEach] milliseconds
+     */
+    runEach: number;
+    /**
+     * If set to true,
+     * RxDB will await all running replications
+     * to not have a replication cycle running.
+     * This ensures we do not remove deleted documents
+     * when they might not have already been replicated.
+     */
+    awaitReplicationsInSync: boolean;
+    /**
+     * If true, it will only start the cleanup
+     * when the current instance is also the leader.
+     * This ensures that when RxDB is used in multiInstance mode,
+     * only one instance will start the cleanup.
+     */
+    waitForLeadership: boolean;
+};

package/dist/types/types/plugins/crdt.d.ts

@@ -0,0 +1,76 @@
+import type { MangoQuerySelector } from '../rx-query.d.ts';
+import type { StringKeys } from '../util.d.ts';
+import type { UpdateQuery } from './update.d.ts';
+
+
+export type CRDTEntry<RxDocType> = {
+    selector?: MangoQuerySelector<RxDocType>;
+    ifMatch?: UpdateQuery<RxDocType>;
+    ifNotMatch?: UpdateQuery<RxDocType>;
+};
+
+/**
+ * Options for the crdt plugin.
+ * We set these in the schema because changing them
+ * is not possible on the fly because it would
+ * close the document state in an unpredictable way.
+ */
+export type CRDTSchemaOptions<RxDocType> = {
+    /**
+     * Determines which field of the document must be used
+     * to store the crdt operations.
+     * The given field must exist with the content of "CRDT_FIELD_SCHEMA" in the
+     * properties part of your schema.
+     */
+    field: StringKeys<RxDocType> | string;
+
+    /**
+     * After BOTH of the limits
+     * maxOperations/maxTTL is reached,
+     * the document will clean up the stored operations
+     * and merged them together to ensure
+     * that not too many operations are stored which could slow down the
+     * database operations.
+     */
+    // TODO not implemented yet, make a pull request if you need that.
+    // maxOperations: number;
+    // maxTTL: number;
+};
+
+
+export type CRDTOperation<RxDocType> = {
+    body: CRDTEntry<RxDocType>[];
+    /**
+     * A string to uniquely represent the creator
+     * of this operation.
+     * Mostly you would use the RxDatabase().storageToken().
+     */
+    creator: string;
+
+    /**
+     * Unix time in milliseconds
+     * that determines when the operation was created.
+     * Used to properly clean up old operations.
+     */
+    time: number;
+};
+
+
+export type CRDTDocumentField<RxDocType> = {
+    /**
+     * An array with arrays of CRDT operations.
+     * The index of the top level array is equal
+     * to the revision height where the operations
+     * belong to.
+     * Sorted by revision height ascending.
+     * If we have a conflict and we need a rebuild,
+     * the operations will be run in the revision height
+     * sort order to make everything deterministic.
+     */
+    operations: CRDTOperation<RxDocType>[][];
+
+    /**
+     * A hash to uniquely define the whole operations state.
+     */
+    hash: string;
+};

package/dist/types/types/plugins/dexie.d.ts

@@ -0,0 +1,30 @@
+import type {
+    Dexie,
+    DexieOptions,
+    Table as DexieTable
+} from 'dexie';
+import type { MaybePromise } from '../util';
+
+export type DexieSettings = DexieOptions & {
+    onCreate?: (db: Dexie, dbName: string) => MaybePromise<void>;
+};
+
+/**
+ * The internals is a Promise that resolves
+ * when the database has fully opened
+ * and Dexie.on.ready was called
+ * @link https://dexie.org/docs/Dexie/Dexie.on.ready
+ *
+ */
+export type DexieStorageInternals = Promise<{
+    dexieDb: Dexie;
+    /**
+     * Contains all normal documents. Deleted ones and non-deleted ones.
+     */
+    dexieTable: DexieTable;
+    // contains the attachments data
+    dexieAttachmentsTable: DexieTable;
+
+    // these must be transformed because indexeddb does not allow boolean indexing
+    booleanIndexes: string[];
+}>;

package/dist/types/types/plugins/local-documents.d.ts

@@ -0,0 +1,49 @@
+import type { Observable } from 'rxjs';
+import type { DocumentCache } from '../../doc-cache.d.ts';
+import type { IncrementalWriteQueue } from '../../incremental-write.d.ts';
+import type { RxCollection } from '../rx-collection.d.ts';
+import type { RxDatabase } from '../rx-database.d.ts';
+import type { RxDocumentBase } from '../rx-document.d.ts';
+import type { RxStorageInstance } from '../rx-storage.interface.d.ts';
+import type { Override } from '../util.d.ts';
+
+export type LocalDocumentParent = RxDatabase | RxCollection;
+export type LocalDocumentState = {
+    database: RxDatabase;
+    parent: LocalDocumentParent;
+    storageInstance: RxStorageInstance<RxLocalDocumentData, any, any>;
+    docCache: DocumentCache<RxLocalDocumentData, {}>;
+    incrementalWriteQueue: IncrementalWriteQueue<RxLocalDocumentData>;
+};
+export type RxLocalDocumentData<
+    Data = {
+        // local documents are schemaless and contain any data
+        [key: string]: any;
+    }
+> = {
+    id: string;
+    data: Data;
+};
+
+declare type LocalDocumentModifyFunction<Data> = (
+    doc: Data,
+    rxLocalDocument: RxLocalDocument<any, Data>
+) => Data | Promise<Data>;
+
+
+export declare type RxLocalDocument<Parent, Data = any, Reactivity = unknown> = Override<
+    RxDocumentBase<RxLocalDocumentData<Data>, {}, Reactivity>,
+    {
+        readonly parent: Parent;
+        isLocal(): true;
+
+        /**
+             * Because local documents store their relevant data inside of the 'data' property,
+             * the incremental mutation methods are changed a bit to only allow to change parts of the data property.
+             */
+        incrementalModify(mutationFunction: LocalDocumentModifyFunction<Data>): Promise<RxLocalDocument<Parent, Data, Reactivity>>;
+        incrementalPatch(patch: Partial<Data>): Promise<RxLocalDocument<Parent, Data, Reactivity>>;
+
+        $: Observable<RxLocalDocument<Parent, Data, Reactivity>>;
+    }
+>;

package/dist/types/types/plugins/migration.d.ts

@@ -0,0 +1,14 @@
+import type {
+    WithAttachments
+} from '../couchdb.d.ts';
+import type { RxCollection } from '../rx-collection.d.ts';
+import type { MaybePromise } from '../util.d.ts';
+
+export type MigrationStrategy<DocData = any> = (
+    oldDocumentData: WithAttachments<DocData>,
+    collection: RxCollection
+) => MaybePromise<WithAttachments<DocData> | null>;
+
+export type MigrationStrategies<DocData = any> = {
+    [toVersion: number]: MigrationStrategy<DocData>;
+};

package/dist/types/types/plugins/reactivity.d.ts

@@ -0,0 +1,40 @@
+import type { Observable } from 'rxjs';
+import type { RxDatabase } from '../rx-database';
+
+/**
+ * Base interface for encoding Higher Kinded Types (HKT) in TypeScript.
+ * Reactivity plugins extend this to define a type-level function
+ * that maps a data type T to a reactive container (e.g. Signal<T>, Ref<T>).
+ *
+ * @example
+ * // Preact signals plugin defines:
+ * interface PreactSignalReactivityLambda extends ReactivityLambda {
+ *     readonly _result: Signal<this['_data']>;
+ * }
+ */
+export interface ReactivityLambda {
+    readonly _data: unknown;
+    readonly _result: unknown;
+}
+
+/**
+ * Applies a reactivity type-level function to a data type.
+ * Given a ReactivityLambda and a data type T, returns the concrete
+ * reactive container type (e.g. Signal<T>, Ref<T>).
+ *
+ * For backwards compatibility, if the Reactivity parameter is not
+ * a ReactivityLambda (e.g. it is `Signal<any>` directly), it is
+ * returned as-is.
+ */
+export type Reactified<Reactivity, T> =
+    Reactivity extends ReactivityLambda
+        ? (Reactivity & { readonly _data: T })['_result']
+        : Reactivity;
+
+export interface RxReactivityFactory<Reactivity> {
+    fromObservable<Data, InitData>(
+        obs: Observable<Data>,
+        initialValue: InitData,
+        rxDatabase: RxDatabase<any, any, any, Reactivity>
+    ): Reactified<Reactivity, Data | InitData>;
+}