@connecttomahdi/rxdb 17.0.0-beta.17

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>;
+}

package/dist/types/types/plugins/replication-graphql.d.ts

@@ -0,0 +1,98 @@
+import { ClientOptions } from 'graphql-ws';
+import { RxReplicationWriteToMasterRow } from '../replication-protocol.ts';
+import { ById, MaybePromise } from '../util.ts';
+import {
+    ReplicationOptions,
+    ReplicationPullHandlerResult,
+    ReplicationPullOptions,
+    ReplicationPushHandlerResult,
+    ReplicationPushOptions
+} from './replication.ts';
+
+export interface RxGraphQLReplicationQueryBuilderResponseObject {
+    query: string;
+    operationName?: string;
+    variables: any;
+}
+
+export type RxGraphQLReplicationClientState = {
+    headers: ById<string>;
+    credentials: RequestCredentials | undefined;
+};
+
+export type RxGraphQLReplicationQueryBuilderResponse =
+    RxGraphQLReplicationQueryBuilderResponseObject |
+    Promise<RxGraphQLReplicationQueryBuilderResponseObject>;
+export type RxGraphQLReplicationPushQueryBuilder = (
+    // typed 'any' because the data might be modified by the push.modifier.
+    rows: RxReplicationWriteToMasterRow<any>[]
+) => RxGraphQLReplicationQueryBuilderResponse;
+
+export type RxGraphQLPullWSOptions = Omit<ClientOptions, 'url' | 'shouldRetry' | 'webSocketImpl'>;
+
+export type RxGraphQLReplicationPullQueryBuilder<CheckpointType> = (
+    latestPulledCheckpoint: CheckpointType | undefined,
+    limit: number
+) => RxGraphQLReplicationQueryBuilderResponse;
+export type GraphQLSyncPullOptions<RxDocType, CheckpointType> = Omit<
+    ReplicationPullOptions<RxDocType, CheckpointType>,
+    'handler' | 'stream$'
+> & {
+    queryBuilder: RxGraphQLReplicationPullQueryBuilder<CheckpointType>;
+    streamQueryBuilder?: RxGraphQLReplicationPullStreamQueryBuilder;
+    /**
+     * The path to the data in the GraphQL response.
+     * If set, the data will be taken from the response at this path.
+     * @example ['data', 'foo', 'bar'] or 'data.foo.bar'
+     */
+    dataPath?: string | string[];
+    responseModifier?: RxGraphQLPullResponseModifier<RxDocType, CheckpointType>;
+    includeWsHeaders?: boolean;
+    wsOptions?: RxGraphQLPullWSOptions;
+};
+
+export type RxGraphQLPullResponseModifier<RxDocType, CheckpointType> = (
+    // the exact response that was returned from the server
+    plainResponse: ReplicationPullHandlerResult<RxDocType, CheckpointType> | any,
+    // either 'handler' if it came from the pull.handler, or 'stream' if it came from the pull.stream
+    origin: 'handler' | 'stream',
+    requestCheckpoint?: CheckpointType
+) => MaybePromise<ReplicationPullHandlerResult<RxDocType, CheckpointType>>;
+
+export type RxGraphQLPushResponseModifier<RxDocType> = (
+    // the exact response that was returned from the server
+    plainResponse: ReplicationPushHandlerResult<RxDocType> | any,
+) => MaybePromise<ReplicationPushHandlerResult<RxDocType>>;
+
+export type RxGraphQLReplicationPullStreamQueryBuilder = (headers: { [k: string]: string; }) => RxGraphQLReplicationQueryBuilderResponse;
+
+export type GraphQLSyncPushOptions<RxDocType> = Omit<
+    ReplicationPushOptions<RxDocType>,
+    'handler'
+> & {
+    queryBuilder: RxGraphQLReplicationPushQueryBuilder;
+    /**
+     * The path to the data in the GraphQL response.
+     * If set, the data will be taken from the response at this path.
+     * @example ['data', 'foo', 'bar'] or 'data.foo.bar'
+     */
+    dataPath?: string | string[];
+    responseModifier?: RxGraphQLPushResponseModifier<RxDocType>;
+};
+
+export type GraphQLServerUrl = {
+    http?: string;
+    ws?: string;
+};
+
+export type SyncOptionsGraphQL<RxDocType, CheckpointType> = Omit<
+    ReplicationOptions<RxDocType, CheckpointType>,
+    'pull' | 'push'
+> & {
+    url: GraphQLServerUrl;
+    fetch?: WindowOrWorkerGlobalScope['fetch'];
+    headers?: { [k: string]: string; }; // send with all requests to the endpoint
+    credentials?: RequestCredentials;
+    pull?: GraphQLSyncPullOptions<RxDocType, CheckpointType>;
+    push?: GraphQLSyncPushOptions<RxDocType>;
+};

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

@@ -0,0 +1,175 @@
+import { Observable } from 'rxjs';
+import type {
+    InternalStoreDocType,
+    MaybePromise,
+    RxCollection,
+    RxDocumentData,
+    RxReplicationPullStreamItem,
+    RxReplicationWriteToMasterRow,
+    WithDeleted
+} from '../../types/index.d.ts';
+
+
+export type InternalStoreReplicationPushDocType = InternalStoreDocType<{
+    checkpoint: any;
+}>;
+export type InternalStoreReplicationPullDocType<RxDocType> = InternalStoreDocType<{
+    lastPulledDoc: RxDocumentData<RxDocType>;
+}>;
+
+export type ReplicationPullHandlerResult<RxDocType, CheckpointType> = {
+    checkpoint: CheckpointType | undefined;
+    documents: WithDeleted<RxDocType>[];
+};
+
+export type ReplicationPushHandlerResult<RxDocType> = RxDocType[];
+
+export type ReplicationPullHandler<RxDocType, CheckpointType> = (
+    lastPulledCheckpoint: CheckpointType | undefined,
+    batchSize: number
+) => Promise<ReplicationPullHandlerResult<RxDocType, CheckpointType>>;
+
+export type ReplicationPullOptions<RxDocType, CheckpointType> = {
+    /**
+     * A handler that pulls the new remote changes
+     * from the remote actor.
+     */
+    handler: ReplicationPullHandler<RxDocType, CheckpointType>;
+
+
+    /**
+     * An observable that streams all document changes
+     * that are happening on the backend.
+     * Emits an document bulk together with the latest checkpoint of these documents.
+     * Also can emit a 'RESYNC' event when the client was offline and is online again.
+     *
+     * Not required for non-live replication.
+     */
+    stream$?: Observable<RxReplicationPullStreamItem<RxDocType, CheckpointType>>;
+
+    /**
+     * Amount of documents that the remote will send in one request.
+     * If the response contains less then [batchSize] documents,
+     * RxDB will assume there are no more changes on the backend
+     * that are not replicated.
+     * [default=100]
+     */
+    batchSize?: number;
+
+    /**
+     * A modifier that runs on all documents that are pulled,
+     * before they are used by RxDB.
+     * - the ones from the pull handler
+     * - the ones from the pull stream
+     */
+    modifier?: (docData: any) => MaybePromise<WithDeleted<RxDocType>>;
+
+    /**
+     * If set, the push replication
+     * will start from the given checkpoint.
+     */
+    initialCheckpoint?: any;
+};
+
+/**
+ * Gets the new write rows.
+ * Returns the current master state of all conflicting writes,
+ * so that they can be resolved on the client.
+ */
+export type ReplicationPushHandler<RxDocType> = (
+    docs: RxReplicationWriteToMasterRow<RxDocType>[]
+) => Promise<WithDeleted<RxDocType>[]>;
+export type ReplicationPushOptions<RxDocType> = {
+    /**
+     * A handler that sends the new local changes
+     * to the remote actor.
+     * On error, all documents are send again at later time.
+     */
+    handler: ReplicationPushHandler<RxDocType>;
+
+
+    /**
+     * A modifier that runs on all pushed documents before
+     * they are send into the push handler.
+     */
+    modifier?: (docData: WithDeleted<RxDocType>) => MaybePromise<any | null>;
+
+    /**
+     * How many local changes to process at once.
+     */
+    batchSize?: number;
+
+    /**
+     * If set, the push replication
+     * will start from the given checkpoint.
+     */
+    initialCheckpoint?: any;
+
+    /**
+     * When a local write happens, normally the replication will directly try to persist
+     * the change upstream.
+     *
+     * By providing a function here that returns a promise, the replication will wait until
+     * that promise resolves before running the next upstream persist cycle. This can be
+     * used to batch writes across multiple collections into a single push or to defer
+     * pushing until the CPU is idle (e.g. via requestIdleCallback).
+     *
+     * NOTE: The longer you wait here, the higher the risk of losing writes if the
+     * replication is closed unexpectedly.
+     */
+    waitBeforePersist?: () => Promise<any>;
+};
+
+
+export type ReplicationOptions<RxDocType, CheckpointType> = {
+    /**
+     * An id for the replication to identify it
+     * and so that RxDB is able to resume the replication on app reload.
+     * If you replicate with a remote server, it is recommended to put the
+     * server url into the replicationIdentifier.
+     * Like 'my-rest-replication-to-https://example.com/api/sync'
+     */
+    replicationIdentifier: string;
+    collection: RxCollection<RxDocType, unknown, unknown, unknown>;
+    /**
+     * Define a custom property that is used
+     * to flag a document as being deleted.
+     * @default '_deleted'
+     */
+    deletedField?: '_deleted' | string;
+    pull?: ReplicationPullOptions<RxDocType, CheckpointType>;
+    push?: ReplicationPushOptions<RxDocType>;
+    /**
+     * By default it will do an ongoing realtime replication.
+     * By settings live: false the replication will run once until the local state
+     * is in sync with the remote state, then it will cancel itself.
+     * @default true
+     */
+    live?: boolean;
+    /**
+     * Time in milliseconds after when a failed backend request
+     * has to be retried.
+     * This time will be skipped if a offline->online switch is detected
+     * via `navigator.onLine`
+     * @default 5000
+     */
+    retryTime?: number;
+    /**
+     * When multiInstance is `true`, like when you use RxDB in multiple browser tabs,
+     * the replication should always run in only one of the open browser tabs.
+     * If waitForLeadership is `true`, it will wait until the current instance is leader.
+     * If waitForLeadership is `false`, it will start replicating, even if it is not leader.
+     * @default true
+     */
+    waitForLeadership?: boolean;
+
+    toggleOnDocumentVisible?: boolean;
+
+    /**
+     * If this is set to `false`,
+     * the replication will not start automatically
+     * but will wait for `replicationState.start()` being called.
+     * @default true
+     */
+    autoStart?: boolean;
+};

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

@@ -0,0 +1,4 @@
+import type { RxStateBase } from '../../plugins/state/rx-state';
+import type { ExtendObservables, ExtendReactivity } from '../rx-document';
+
+export type RxState<T, Reactivity = unknown> = RxStateBase<T, Reactivity> & T & ExtendObservables<Required<T>> & ExtendReactivity<Required<T>, Reactivity>;

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

@@ -0,0 +1,23 @@
+import type { AnyKeys, AnyObject } from '../util.d.ts';
+
+// import type {
+//     UpdateExpression
+// } from 'mingo/updater';
+
+/**
+ * We use an own type here, copied from mongoose
+ * @link https://github.com/Automattic/mongoose/blob/eb292d2c4cc98ee315f118d6199a83938f06d901/types/index.d.ts#L466
+ * When the mingo library implements a schema-based type for UpdateExpression, we can use these typings instead.
+ */
+export type UpdateQuery<TSchema> = {
+    $min?: AnyKeys<TSchema> & AnyObject;
+    $max?: AnyKeys<TSchema> & AnyObject;
+    $inc?: AnyKeys<TSchema> & AnyObject;
+    $set?: AnyKeys<TSchema> & AnyObject;
+    $unset?: AnyKeys<TSchema> & AnyObject;
+    $push?: AnyKeys<TSchema> & AnyObject;
+    $addToSet?: AnyKeys<TSchema> & AnyObject;
+    $pop?: AnyKeys<TSchema> & AnyObject;
+    $pullAll?: AnyKeys<TSchema> & AnyObject;
+    $rename?: Record<string, string>;
+};

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

@@ -0,0 +1,40 @@
+import type {
+    RxDatabase,
+    RxCollection
+} from '../../index.d.ts';
+
+import type { Observable } from 'rxjs';
+
+export interface WebMCPOptions {
+    /**
+     * If true, modifier tools (insert, upsert, delete) will not be registered
+     * for this database or collection.
+     * @default false
+     */
+    readOnly?: boolean;
+    /**
+     * If true, delays queries until all replication states of the collection
+     * are in sync.
+     * @default true
+     */
+    awaitReplicationsInSync?: boolean;
+}
+
+export interface WebMCPLogEvent {
+    collectionName: string;
+    databaseName: string;
+    toolName: string;
+    args: any;
+    result?: any;
+    error?: any;
+}
+
+export interface RxWebMCPPlugin {
+    name: 'webmcp';
+    rxdb: true;
+    prototypes: {
+        RxDatabase: (proto: any) => void;
+        RxCollection: (proto: any) => void;
+    };
+    hooks?: any;
+}

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

@@ -0,0 +1,47 @@
+export type RxQueryPlanKey = string | number | undefined;
+
+export type RxQueryPlanerOpts = {
+    startKey: RxQueryPlanKey;
+    endKey: RxQueryPlanKey;
+    /**
+     * True if the first matching document
+     * must also be included into the result set.
+     */
+    inclusiveStart: boolean;
+    /**
+     * True if the last matching document
+     * must also be included into the result set.
+     */
+    inclusiveEnd: boolean;
+};
+
+export type RxQueryPlan = {
+    index: string[];
+    /**
+     * If the index does not match the sort params,
+     * we have to resort the query results manually
+     * after fetching them from the index.
+     */
+    sortSatisfiedByIndex: boolean;
+
+    /**
+     * If the whole selector matching is satisfied
+     * by the index, we do not have to run a does-document-data-match-query
+     * stuff.
+     */
+    selectorSatisfiedByIndex: boolean;
+
+    startKeys: RxQueryPlanKey[];
+    endKeys: RxQueryPlanKey[];
+    /**
+     * True if the first matching document
+     * must also be included into the result set.
+     */
+    inclusiveStart: boolean;
+    /**
+     * True if the last matching document
+     * must also be included into the result set.
+     */
+    inclusiveEnd: boolean;
+
+};