@connecttomahdi/rxdb 17.0.0-beta.17

package/dist/types/plugins/webmcp/nosql-query-schema.d.ts

@@ -0,0 +1,549 @@
+export declare const NOSQL_QUERY_JSON_SCHEMA: {
+    $schema: string;
+    title: string;
+    description: string;
+    type: string;
+    additionalProperties: boolean;
+    required: string[];
+    properties: {
+        selector: {
+            $ref: string;
+        };
+        sort: {
+            $ref: string;
+        };
+        limit: {
+            type: string;
+            minimum: number;
+            examples: number[];
+        };
+        skip: {
+            type: string;
+            minimum: number;
+            examples: number[];
+        };
+    };
+    examples: ({
+        selector: {
+            age: {
+                $gt: number;
+            };
+            status: string;
+            $or?: undefined;
+            "address.country"?: undefined;
+        };
+        sort: {
+            createdAt: string;
+        }[];
+        limit: number;
+    } | {
+        selector: {
+            $or: ({
+                "company.name": {
+                    $regex: string;
+                    $options: string;
+                };
+                tags?: undefined;
+            } | {
+                tags: {
+                    $in: string[];
+                };
+                "company.name"?: undefined;
+            })[];
+            "address.country": string;
+            age?: undefined;
+            status?: undefined;
+        };
+        limit: number;
+        sort?: undefined;
+    })[];
+    default: {
+        selector: {};
+        sort: never[];
+        limit: number;
+        skip: number;
+    };
+    $defs: {
+        sort: {
+            description: string;
+            type: string;
+            items: {
+                type: string;
+                minProperties: number;
+                additionalProperties: boolean;
+                patternProperties: {
+                    "^(?!\\$).+$": {
+                        type: string;
+                        enum: string[];
+                    };
+                };
+            };
+            examples: ({
+                lastName: string;
+                createdAt?: undefined;
+            } | {
+                createdAt: string;
+                lastName?: undefined;
+            })[][];
+        };
+        expression: {
+            anyOf: {
+                $ref: string;
+            }[];
+        };
+        logicalExpression: {
+            type: string;
+            additionalProperties: boolean;
+            properties: {
+                $and: {
+                    type: string;
+                    minItems: number;
+                    items: {
+                        $ref: string;
+                    };
+                    examples: ({
+                        status: string;
+                        age?: undefined;
+                    } | {
+                        age: {
+                            $gte: number;
+                        };
+                        status?: undefined;
+                    })[][];
+                };
+                $or: {
+                    type: string;
+                    minItems: number;
+                    items: {
+                        $ref: string;
+                    };
+                    examples: {
+                        role: string;
+                    }[][];
+                };
+                $nor: {
+                    type: string;
+                    minItems: number;
+                    items: {
+                        $ref: string;
+                    };
+                    examples: ({
+                        archived: boolean;
+                        deleted?: undefined;
+                    } | {
+                        deleted: boolean;
+                        archived?: undefined;
+                    })[][];
+                };
+                $not: {
+                    $ref: string;
+                    examples: ({
+                        age: {
+                            $lt: number;
+                        };
+                        name?: undefined;
+                    } | {
+                        name: {
+                            $regex: string;
+                        };
+                        age?: undefined;
+                    })[];
+                };
+            };
+            anyOf: {
+                required: string[];
+            }[];
+            examples: ({
+                $and: ({
+                    status: string;
+                    age?: undefined;
+                } | {
+                    age: {
+                        $gte: number;
+                    };
+                    status?: undefined;
+                })[];
+                $or?: undefined;
+                $nor?: undefined;
+                $not?: undefined;
+            } | {
+                $or: ({
+                    tier: string;
+                    trial?: undefined;
+                } | {
+                    trial: boolean;
+                    tier?: undefined;
+                })[];
+                $and?: undefined;
+                $nor?: undefined;
+                $not?: undefined;
+            } | {
+                $nor: ({
+                    deleted: boolean;
+                    blocked?: undefined;
+                } | {
+                    blocked: boolean;
+                    deleted?: undefined;
+                })[];
+                $and?: undefined;
+                $or?: undefined;
+                $not?: undefined;
+            } | {
+                $not: {
+                    age: {
+                        $gte: number;
+                    };
+                };
+                $and?: undefined;
+                $or?: undefined;
+                $nor?: undefined;
+            })[];
+        };
+        fieldExpression: {
+            type: string;
+            minProperties: number;
+            additionalProperties: boolean;
+            patternProperties: {
+                "^(?!\\$).+$": {
+                    anyOf: {
+                        $ref: string;
+                    }[];
+                };
+            };
+            examples: ({
+                status: string;
+                age?: undefined;
+                tags?: undefined;
+            } | {
+                age: {
+                    $gte: number;
+                };
+                status?: undefined;
+                tags?: undefined;
+            } | {
+                tags: {
+                    $in: string[];
+                };
+                status?: undefined;
+                age?: undefined;
+            })[];
+        };
+        fieldOperatorExpression: {
+            type: string;
+            minProperties: number;
+            additionalProperties: boolean;
+            properties: {
+                $eq: {
+                    $ref: string;
+                    examples: (string | number | null)[];
+                };
+                $ne: {
+                    $ref: string;
+                    examples: (string | number)[];
+                };
+                $gt: {
+                    $ref: string;
+                    examples: number[];
+                };
+                $gte: {
+                    $ref: string;
+                    examples: number[];
+                };
+                $lt: {
+                    $ref: string;
+                    examples: number[];
+                };
+                $lte: {
+                    $ref: string;
+                    examples: number[];
+                };
+                $in: {
+                    type: string;
+                    items: {
+                        $ref: string;
+                    };
+                    examples: (number[] | string[])[];
+                };
+                $nin: {
+                    type: string;
+                    items: {
+                        $ref: string;
+                    };
+                    examples: (number[] | string[])[];
+                };
+                $exists: {
+                    type: string;
+                    examples: boolean[];
+                };
+                $regex: {
+                    type: string;
+                    examples: string[];
+                };
+                $options: {
+                    type: string;
+                    examples: string[];
+                };
+                $type: {
+                    oneOf: ({
+                        type: string;
+                        items?: undefined;
+                    } | {
+                        type: string;
+                        items: {
+                            oneOf: {
+                                type: string;
+                            }[];
+                        };
+                    })[];
+                    examples: (string | number | string[])[];
+                };
+                $size: {
+                    type: string;
+                    minimum: number;
+                    examples: number[];
+                };
+                $mod: {
+                    type: string;
+                    minItems: number;
+                    maxItems: number;
+                    items: {
+                        type: string;
+                    };
+                    examples: number[][];
+                };
+                $elemMatch: {
+                    $ref: string;
+                    examples: ({
+                        qty: {
+                            $gte: number;
+                        };
+                        type?: undefined;
+                    } | {
+                        type: string;
+                        qty?: undefined;
+                    })[];
+                };
+            };
+            examples: ({
+                $eq: string;
+                $ne?: undefined;
+                $gt?: undefined;
+                $gte?: undefined;
+                $lt?: undefined;
+                $lte?: undefined;
+                $in?: undefined;
+                $nin?: undefined;
+                $exists?: undefined;
+                $regex?: undefined;
+                $type?: undefined;
+                $size?: undefined;
+                $mod?: undefined;
+                $elemMatch?: undefined;
+            } | {
+                $ne: string;
+                $eq?: undefined;
+                $gt?: undefined;
+                $gte?: undefined;
+                $lt?: undefined;
+                $lte?: undefined;
+                $in?: undefined;
+                $nin?: undefined;
+                $exists?: undefined;
+                $regex?: undefined;
+                $type?: undefined;
+                $size?: undefined;
+                $mod?: undefined;
+                $elemMatch?: undefined;
+            } | {
+                $gt: number;
+                $eq?: undefined;
+                $ne?: undefined;
+                $gte?: undefined;
+                $lt?: undefined;
+                $lte?: undefined;
+                $in?: undefined;
+                $nin?: undefined;
+                $exists?: undefined;
+                $regex?: undefined;
+                $type?: undefined;
+                $size?: undefined;
+                $mod?: undefined;
+                $elemMatch?: undefined;
+            } | {
+                $gte: number;
+                $eq?: undefined;
+                $ne?: undefined;
+                $gt?: undefined;
+                $lt?: undefined;
+                $lte?: undefined;
+                $in?: undefined;
+                $nin?: undefined;
+                $exists?: undefined;
+                $regex?: undefined;
+                $type?: undefined;
+                $size?: undefined;
+                $mod?: undefined;
+                $elemMatch?: undefined;
+            } | {
+                $lt: number;
+                $eq?: undefined;
+                $ne?: undefined;
+                $gt?: undefined;
+                $gte?: undefined;
+                $lte?: undefined;
+                $in?: undefined;
+                $nin?: undefined;
+                $exists?: undefined;
+                $regex?: undefined;
+                $type?: undefined;
+                $size?: undefined;
+                $mod?: undefined;
+                $elemMatch?: undefined;
+            } | {
+                $lte: number;
+                $eq?: undefined;
+                $ne?: undefined;
+                $gt?: undefined;
+                $gte?: undefined;
+                $lt?: undefined;
+                $in?: undefined;
+                $nin?: undefined;
+                $exists?: undefined;
+                $regex?: undefined;
+                $type?: undefined;
+                $size?: undefined;
+                $mod?: undefined;
+                $elemMatch?: undefined;
+            } | {
+                $in: string[];
+                $eq?: undefined;
+                $ne?: undefined;
+                $gt?: undefined;
+                $gte?: undefined;
+                $lt?: undefined;
+                $lte?: undefined;
+                $nin?: undefined;
+                $exists?: undefined;
+                $regex?: undefined;
+                $type?: undefined;
+                $size?: undefined;
+                $mod?: undefined;
+                $elemMatch?: undefined;
+            } | {
+                $nin: string[];
+                $eq?: undefined;
+                $ne?: undefined;
+                $gt?: undefined;
+                $gte?: undefined;
+                $lt?: undefined;
+                $lte?: undefined;
+                $in?: undefined;
+                $exists?: undefined;
+                $regex?: undefined;
+                $type?: undefined;
+                $size?: undefined;
+                $mod?: undefined;
+                $elemMatch?: undefined;
+            } | {
+                $exists: boolean;
+                $eq?: undefined;
+                $ne?: undefined;
+                $gt?: undefined;
+                $gte?: undefined;
+                $lt?: undefined;
+                $lte?: undefined;
+                $in?: undefined;
+                $nin?: undefined;
+                $regex?: undefined;
+                $type?: undefined;
+                $size?: undefined;
+                $mod?: undefined;
+                $elemMatch?: undefined;
+            } | {
+                $regex: string;
+                $eq?: undefined;
+                $ne?: undefined;
+                $gt?: undefined;
+                $gte?: undefined;
+                $lt?: undefined;
+                $lte?: undefined;
+                $in?: undefined;
+                $nin?: undefined;
+                $exists?: undefined;
+                $type?: undefined;
+                $size?: undefined;
+                $mod?: undefined;
+                $elemMatch?: undefined;
+            } | {
+                $type: string;
+                $eq?: undefined;
+                $ne?: undefined;
+                $gt?: undefined;
+                $gte?: undefined;
+                $lt?: undefined;
+                $lte?: undefined;
+                $in?: undefined;
+                $nin?: undefined;
+                $exists?: undefined;
+                $regex?: undefined;
+                $size?: undefined;
+                $mod?: undefined;
+                $elemMatch?: undefined;
+            } | {
+                $size: number;
+                $eq?: undefined;
+                $ne?: undefined;
+                $gt?: undefined;
+                $gte?: undefined;
+                $lt?: undefined;
+                $lte?: undefined;
+                $in?: undefined;
+                $nin?: undefined;
+                $exists?: undefined;
+                $regex?: undefined;
+                $type?: undefined;
+                $mod?: undefined;
+                $elemMatch?: undefined;
+            } | {
+                $mod: number[];
+                $eq?: undefined;
+                $ne?: undefined;
+                $gt?: undefined;
+                $gte?: undefined;
+                $lt?: undefined;
+                $lte?: undefined;
+                $in?: undefined;
+                $nin?: undefined;
+                $exists?: undefined;
+                $regex?: undefined;
+                $type?: undefined;
+                $size?: undefined;
+                $elemMatch?: undefined;
+            } | {
+                $elemMatch: {
+                    qty: {
+                        $gte: number;
+                    };
+                };
+                $eq?: undefined;
+                $ne?: undefined;
+                $gt?: undefined;
+                $gte?: undefined;
+                $lt?: undefined;
+                $lte?: undefined;
+                $in?: undefined;
+                $nin?: undefined;
+                $exists?: undefined;
+                $regex?: undefined;
+                $type?: undefined;
+                $size?: undefined;
+                $mod?: undefined;
+            })[];
+        };
+        literal: {
+            oneOf: {
+                type: string;
+            }[];
+        };
+    };
+};

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

@@ -0,0 +1,12 @@
+import type { RxCollection, RxDatabase } from '../../index.d.ts';
+import type { RxWebMCPPlugin, WebMCPOptions, WebMCPLogEvent } from '../../types/plugins/webmcp.d.ts';
+import { Subject } from 'rxjs';
+export declare function registerWebMCPDatabase(this: RxDatabase, options?: WebMCPOptions): {
+    error$: Subject<Error>;
+    log$: Subject<WebMCPLogEvent>;
+};
+export declare function registerWebMCPCollection(this: RxCollection, options?: WebMCPOptions): {
+    error$: Subject<Error>;
+    log$: Subject<WebMCPLogEvent>;
+};
+export declare const RxDBWebMCPPlugin: RxWebMCPPlugin;

package/dist/types/query-cache.d.ts

@@ -0,0 +1,35 @@
+/**
+ * the query-cache makes sure that on every query-state, exactly one instance can exist
+ * if you use the same mango-query more than once, it will reuse the first RxQuery
+ */
+import type { RxQuery, RxCacheReplacementPolicy, RxCollection } from './types/index.d.ts';
+export declare class QueryCache {
+    _map: Map<string, RxQuery>;
+    /**
+     * check if an equal query is in the cache,
+     * if true, return the cached one,
+     * if false, save the given one and return it
+     */
+    getByQuery(rxQuery: RxQuery): RxQuery;
+}
+export declare function createQueryCache(): QueryCache;
+export declare function uncacheRxQuery(queryCache: QueryCache, rxQuery: RxQuery): void;
+export declare function countRxQuerySubscribers(rxQuery: RxQuery): number;
+export declare const DEFAULT_TRY_TO_KEEP_MAX = 100;
+export declare const DEFAULT_UNEXECUTED_LIFETIME: number;
+/**
+ * The default cache replacement policy
+ * See docs-src/query-cache.md to learn how it should work.
+ * Notice that this runs often and should block the cpu as less as possible
+ * This is a monad which makes it easier to unit test
+ */
+export declare const defaultCacheReplacementPolicyMonad: (tryToKeepMax: number, unExecutedLifetime: number) => RxCacheReplacementPolicy;
+export declare const defaultCacheReplacementPolicy: RxCacheReplacementPolicy;
+export declare const COLLECTIONS_WITH_RUNNING_CLEANUP: WeakSet<RxCollection>;
+/**
+ * Triggers the cache replacement policy after waitTime has passed.
+ * We do not run this directly because at exactly the time a query is created,
+ * we need all CPU to minimize latency.
+ * Also this should not be triggered multiple times when waitTime is still waiting.
+ */
+export declare function triggerCacheReplacement(rxCollection: RxCollection): void;

package/dist/types/query-planner.d.ts

@@ -0,0 +1,30 @@
+import type { FilledMangoQuery, MangoQuerySelector, RxDocumentData, RxJsonSchema, RxQueryPlan, RxQueryPlanKey, RxQueryPlanerOpts } from './types/index.d.ts';
+export declare const INDEX_MAX: string;
+/**
+ * Do not use -Infinity here because it would be
+ * transformed to null on JSON.stringify() which can break things
+ * when the query plan is sent to the storage as json.
+ * @link https://stackoverflow.com/a/16644751
+ * Notice that for IndexedDB IDBKeyRange we have
+ * to transform the value back to -Infinity
+ * before we can use it in IDBKeyRange.bound.
+ */
+export declare const INDEX_MIN: number;
+/**
+ * Returns the query plan which contains
+ * information about how to run the query
+ * and which indexes to use.
+ *
+ * This is used in some storage like Memory, dexie.js and IndexedDB.
+ */
+export declare function getQueryPlan<RxDocType>(schema: RxJsonSchema<RxDocumentData<RxDocType>>, query: FilledMangoQuery<RxDocType>): RxQueryPlan;
+export declare const LOGICAL_OPERATORS: Set<string>;
+export declare const LOWER_BOUND_LOGICAL_OPERATORS: Set<string>;
+export declare const UPPER_BOUND_LOGICAL_OPERATORS: Set<string>;
+export declare function isSelectorSatisfiedByIndex(index: string[], selector: MangoQuerySelector<any>, startKeys: RxQueryPlanKey[], endKeys: RxQueryPlanKey[]): boolean;
+export declare function getMatcherQueryOpts(operator: string, operatorValue: any): Partial<RxQueryPlanerOpts>;
+/**
+ * Returns a number that determines the quality of the query plan.
+ * Higher number means better query plan.
+ */
+export declare function rateQueryPlan<RxDocType>(schema: RxJsonSchema<RxDocumentData<RxDocType>>, query: FilledMangoQuery<RxDocType>, queryPlan: RxQueryPlan): number;

package/dist/types/replication-protocol/checkpoint.d.ts

@@ -0,0 +1,8 @@
+import type { RxStorageInstanceReplicationInput, RxStorageInstanceReplicationState, RxStorageReplicationDirection } from '../types/index.d.ts';
+export declare function getLastCheckpointDoc<RxDocType, CheckpointType>(state: RxStorageInstanceReplicationState<RxDocType>, direction: RxStorageReplicationDirection): Promise<undefined | CheckpointType>;
+/**
+ * Sets the checkpoint,
+ * automatically resolves conflicts that appear.
+ */
+export declare function setCheckpoint<RxDocType, CheckpointType>(state: RxStorageInstanceReplicationState<RxDocType>, direction: RxStorageReplicationDirection, checkpoint: CheckpointType): Promise<void>;
+export declare function getCheckpointKey<RxDocType>(input: RxStorageInstanceReplicationInput<RxDocType>): Promise<string>;

package/dist/types/replication-protocol/conflicts.d.ts

@@ -0,0 +1,10 @@
+import type { RxConflictHandlerInput, RxDocumentData, RxStorageInstanceReplicationState } from '../types/index.d.ts';
+/**
+ * Resolves a conflict error or determines that the given document states are equal.
+ * Returns the resolved document that must be written to the fork.
+ * Then the new document state can be pushed upstream.
+ * If document is not in conflict, returns undefined.
+ * If error is non-409, it throws an error.
+ * Conflicts are only solved in the upstream, never in the downstream.
+ */
+export declare function resolveConflictError<RxDocType>(state: RxStorageInstanceReplicationState<RxDocType>, input: RxConflictHandlerInput<RxDocType>, forkState: RxDocumentData<RxDocType>): Promise<RxDocumentData<RxDocType> | undefined>;

package/dist/types/replication-protocol/default-conflict-handler.d.ts

@@ -0,0 +1,2 @@
+import type { RxConflictHandler } from '../types';
+export declare const defaultConflictHandler: RxConflictHandler<any>;

package/dist/types/replication-protocol/downstream.d.ts

@@ -0,0 +1,10 @@
+import type { RxStorageInstanceReplicationState } from '../types/index.d.ts';
+/**
+ * Writes all documents from the master to the fork.
+ * The downstream has two operation modes
+ * - Sync by iterating over the checkpoints via downstreamResyncOnce()
+ * - Sync by listening to the changestream via downstreamProcessChanges()
+ * We need this to be able to do initial syncs
+ * and still can have fast event based sync when the client is not offline.
+ */
+export declare function startReplicationDownstream<RxDocType, CheckpointType = any>(state: RxStorageInstanceReplicationState<RxDocType>): Promise<void>;

package/dist/types/replication-protocol/helper.d.ts

@@ -0,0 +1,5 @@
+import type { BulkWriteRow, RxDocumentData, RxDocumentWriteData, RxStorageInstance, RxStorageInstanceReplicationState, RxStorageReplicationMeta, WithDeletedAndAttachments } from '../types/index.d.ts';
+export declare function docStateToWriteDoc<RxDocType>(databaseInstanceToken: string, hasAttachments: boolean, keepMeta: boolean, docState: WithDeletedAndAttachments<RxDocType>, previous?: RxDocumentData<RxDocType>): RxDocumentWriteData<RxDocType>;
+export declare function writeDocToDocState<RxDocType>(writeDoc: RxDocumentData<RxDocType>, keepAttachments: boolean, keepMeta: boolean): WithDeletedAndAttachments<RxDocType>;
+export declare function stripAttachmentsDataFromMetaWriteRows<RxDocType>(state: RxStorageInstanceReplicationState<any>, rows: BulkWriteRow<RxStorageReplicationMeta<RxDocType, any>>[]): BulkWriteRow<RxStorageReplicationMeta<RxDocType, any>>[];
+export declare function getUnderlyingPersistentStorage<RxDocType>(instance: RxStorageInstance<RxDocType, any, any, any>): RxStorageInstance<RxDocType, any, any, any>;