@connecttomahdi/rxdb 17.1.0 → 17.1.1

package/dist/types/types/rx-attachment.d.ts

@@ -0,0 +1,46 @@
+import type {
+    RxDocument
+} from './rx-document.d.ts';
+
+declare type Buffer = any;
+
+export type RxAttachmentCreator = {
+    id: string;
+    /**
+     * Content type like 'plain/text'
+     */
+    type: string;
+    /**
+     * The data of the attachment.
+     */
+    data: Blob;
+};
+
+export type RxAttachmentCreatorBase64 = {
+    id: string;
+    /**
+     * Content type like 'plain/text'
+     */
+    type: string;
+    /**
+     * The data of the attachment as base64.
+     */
+    data: string;
+
+    // must be set manually
+    length: number;
+};
+
+export declare class RxAttachment<RxDocumentType, OrmMethods = {}, Reactivity = unknown> {
+    readonly doc: RxDocument<RxDocumentType, OrmMethods, Reactivity>;
+    readonly id: string;
+    readonly type: string;
+    readonly length: number;
+    readonly digest: string;
+    readonly rev: string;
+
+    remove(): Promise<void>;
+    getData(): Promise<Blob>;
+    getDataBase64(): Promise<string>;
+    getStringData(): Promise<string>;
+}

package/dist/types/types/rx-change-event.d.ts

@@ -0,0 +1,85 @@
+import type {
+    RxDocumentData,
+    RxStorageChangeEvent,
+    RxStorageDefaultCheckpoint
+} from './rx-storage.d.ts';
+
+
+export type RxChangeEventBase<RxDocType> = {
+    operation: 'INSERT' | 'UPDATE' | 'DELETE';
+
+    readonly documentId: string;
+
+    // optional, does not exist on changes to localdocs of the database
+    readonly collectionName?: string;
+
+    // true if the event is about a local document, false if not.
+    readonly isLocal: boolean;
+
+    documentData: RxDocumentData<RxDocType>;
+};
+
+export type RxChangeEventInsert<RxDocType> = RxChangeEventBase<RxDocType> & {
+    operation: 'INSERT';
+    previousDocumentData: undefined;
+};
+
+export type RxChangeEventUpdate<RxDocType> = RxChangeEventBase<RxDocType> & {
+    operation: 'UPDATE';
+    previousDocumentData: RxDocumentData<RxDocType>;
+};
+
+export type RxChangeEventDelete<RxDocType> = RxChangeEventBase<RxDocType> & {
+    operation: 'DELETE';
+    previousDocumentData: RxDocumentData<RxDocType>;
+};
+
+export type RxChangeEvent<RxDocType> = RxChangeEventInsert<RxDocType> | RxChangeEventUpdate<RxDocType> | RxChangeEventDelete<RxDocType>;
+
+/**
+ * Internally, all events are processed via bulks
+ * to save performance when sending them over a transport layer
+ * or de-duplicating them.
+ */
+export type RxChangeEventBulk<RxDocType, CheckpointType = RxStorageDefaultCheckpoint> = {
+    /**
+     * Unique id of the bulk,
+     * used to detect duplicate bulks
+     * that have already been processed.
+     */
+    id: string;
+
+    // optional, not given for changes to local documents of a RxDatabase.
+    collectionName?: string;
+
+    isLocal: boolean;
+
+    events: RxStorageChangeEvent<RxDocType>[];
+    /**
+     * Required for replication.
+     * Passing this checkpoint into getChangedDocumentsSince()
+     * must return all items that have been modified AFTER this write event.
+     */
+    checkpoint: CheckpointType;
+
+    /**
+     * The context that was given at the call to bulkWrite()
+     * that caused this EventBulk.
+     */
+    context: string;
+    /**
+     * Token of the database instance that created the events.
+     * Used to determine if the events came from another instance over the BroadcastChannel.
+     */
+    databaseToken: string;
+    /**
+     * The storageToken of the RxDatabase that created the events.
+     * Used to ensure we do not process events of other RxDatabases.
+     */
+    storageToken: string;
+    /**
+     * If true, the events belong to some internal stuff like from plugins.
+     * Internal events are not emitted to the outside over the .$ Observables.
+     */
+    internal: boolean;
+};

package/dist/types/types/rx-collection.d.ts

@@ -0,0 +1,117 @@
+import type {
+    RxJsonSchema,
+    RxDocument,
+    MigrationStrategies,
+    RxConflictHandler
+} from './index.d.ts';
+import type {
+    RxCollectionBase
+} from '../rx-collection.d.ts';
+import type { QueryCache } from '../query-cache.d.ts';
+import type { RxLocalDocumentMutation } from './rx-database.d.ts';
+
+export interface KeyFunctionMap {
+    [key: string]: Function;
+}
+export interface NumberFunctionMap {
+    [key: number]: Function;
+}
+
+
+/**
+ * Params to create a new collection.
+ * Notice the name of the collection is set one level higher
+ * when calling addCollections()
+ */
+export type RxCollectionCreator<RxDocType = any> = {
+    schema: RxJsonSchema<RxDocType>;
+    instanceCreationOptions?: any;
+    migrationStrategies?: MigrationStrategies;
+    autoMigrate?: boolean;
+    statics?: KeyFunctionMap;
+    methods?: KeyFunctionMap;
+    attachments?: KeyFunctionMap;
+    options?: any;
+    /**
+     * Set this to true if you want to store local documents
+     * in the RxCollection instance.
+     */
+    localDocuments?: boolean;
+    cacheReplacementPolicy?: RxCacheReplacementPolicy;
+
+    /**
+     * Depending on which plugins or storage is used,
+     * the RxCollection might need a way to resolve conflicts
+     * which is done by this conflict handler.
+     * If no conflict handler is provided, a master-always-wins handler
+     * will be used as default
+     */
+    conflictHandler?: RxConflictHandler<RxDocType>;
+};
+
+export type RxCacheReplacementPolicy = (collection: RxCollection, queryCache: QueryCache) => void;
+
+export type RxCollectionHookCallback<
+    RxDocumentType,
+    OrmMethods,
+    Reactivity
+> = (
+    data: RxDocumentType,
+    instance: RxDocument<RxDocumentType, OrmMethods, Reactivity>
+) => void | Promise<void> | any;
+export type RxCollectionHookNoInstance<RxDocumentType> = (data: RxDocumentType) => void | Promise<void> | any;
+export type RxCollectionHookCallbackNonAsync<RxDocumentType, OrmMethods, Reactivity> = (
+    data: RxDocumentType,
+    instance: RxDocument<RxDocumentType, OrmMethods, Reactivity>
+) => void | any;
+export type RxCollectionHookNoInstanceCallback<
+    RxDocumentType,
+    OrmMethods,
+    Reactivity
+> = (
+    data: RxDocumentType,
+    instance: RxCollection<RxDocumentType, OrmMethods, Reactivity>
+) => Promise<void> | void | any;
+
+export type RxCollection<
+    RxDocumentType = any,
+    OrmMethods = {},
+    StaticMethods = {},
+    InstanceCreationOptions = {},
+    Reactivity = unknown
+> = StaticMethods &
+    RxCollectionBase<InstanceCreationOptions, RxDocumentType, OrmMethods, StaticMethods, Reactivity> &
+    RxCollectionGenerated<RxDocumentType, OrmMethods, Reactivity>;
+
+export interface RxCollectionGenerated<RxDocumentType = any, OrmMethods = {}, Reactivity = unknown> extends RxLocalDocumentMutation<RxCollection<RxDocumentType, OrmMethods, any, any, Reactivity>> {
+
+    // HOOKS
+    preInsert(fun: RxCollectionHookNoInstanceCallback<RxDocumentType, OrmMethods, Reactivity>, parallel: boolean): void;
+    preSave(fun: RxCollectionHookCallback<RxDocumentType, OrmMethods, Reactivity>, parallel: boolean): void;
+    preRemove(fun: RxCollectionHookCallback<RxDocumentType, OrmMethods, Reactivity>, parallel: boolean): void;
+    postInsert(fun: RxCollectionHookCallback<RxDocumentType, OrmMethods, Reactivity>, parallel: boolean): void;
+    postSave(fun: RxCollectionHookCallback<RxDocumentType, OrmMethods, Reactivity>, parallel: boolean): void;
+    postRemove(fun: RxCollectionHookCallback<RxDocumentType, OrmMethods, Reactivity>, parallel: boolean): void;
+    postCreate(fun: RxCollectionHookCallbackNonAsync<RxDocumentType, OrmMethods, Reactivity>): void;
+
+    // only inMemory-collections
+    awaitPersistence(): Promise<void>;
+}
+
+/**
+ * Previously all properties were typed as any because they could be encrypted.
+ * This is no longer needed so the type now preserves the original property types.
+ */
+export type RxDumpCollectionAsAny<T> = T;
+
+interface RxDumpCollectionBase {
+    name: string;
+    passwordHash?: string;
+    schemaHash: string;
+}
+export interface RxDumpCollection<RxDocumentType> extends RxDumpCollectionBase {
+    docs: RxDocumentType[];
+}
+export interface RxDumpCollectionAny<RxDocumentType> extends RxDumpCollectionBase {
+    docs: RxDumpCollectionAsAny<RxDocumentType>[];
+}

package/dist/types/types/rx-database-internal-store.d.ts

@@ -0,0 +1,54 @@
+import type {
+    RxMigrationStatus
+} from '../plugins/migration-schema/index.ts';
+import type { RxJsonSchema } from './rx-schema.d.ts';
+
+export type InternalStoreDocType<Data = any> = {
+    id: string;
+    key: string;
+    context: string;
+    data: Data;
+};
+
+/**
+ * Stores information about the collections.
+ * The collection.name is the 'key' value.
+ */
+export type InternalStoreStorageTokenDocType = InternalStoreDocType<{
+    rxdbVersion: string;
+    token: string;
+    instanceToken: string;
+    passwordHash?: string;
+}>;
+
+/**
+ * Stores information about the collections.
+ * The collection.name is the 'key' value.
+ */
+export type InternalStoreCollectionDocType = InternalStoreDocType<{
+    /**
+     * Plain name of the collection
+     */
+    name: string;
+    schema: RxJsonSchema<any>;
+    schemaHash: string;
+    version: number;
+
+    /**
+     * Storages that are connected to this collection
+     * so that when the collection is removed,
+     * these storages must also be removed.
+     * For example the replication meta storage
+     * must be reset when the collection is removed.
+     */
+    connectedStorages: {
+        collectionName: string;
+        schema: RxJsonSchema<any>;
+    }[];
+
+    /**
+     * Contains the migration status
+     * only if a migration has been started.
+     */
+    migrationStatus?: RxMigrationStatus;
+}>;

package/dist/types/types/rx-database.d.ts

@@ -0,0 +1,124 @@
+import type {
+    RxCollection,
+    RxDumpCollection,
+    RxDumpCollectionAsAny
+} from './rx-collection.d.ts';
+import type {
+    RxDatabaseBase
+} from '../rx-database.d.ts';
+import { Observable } from 'rxjs';
+import type { RxStorage } from './rx-storage.interface.d.ts';
+import type { RxLocalDocument } from './plugins/local-documents.d.ts';
+import type { RxCleanupPolicy } from './plugins/cleanup.d.ts';
+import type { ById, HashFunction } from './util.d.ts';
+import type { RxReactivityFactory } from './plugins/reactivity.d.ts';
+
+export interface RxDatabaseCreator<Internals = any, InstanceCreationOptions = any, Reactivity = unknown> {
+    storage: RxStorage<Internals, InstanceCreationOptions>;
+    instanceCreationOptions?: InstanceCreationOptions;
+    name: string;
+    /**
+     * Typed as `any` because different encryption plugins
+     * may use passwords that are not strings.
+     */
+    password?: string | any;
+    multiInstance?: boolean;
+    eventReduce?: boolean;
+    ignoreDuplicate?: boolean;
+    options?: any;
+    cleanupPolicy?: Partial<RxCleanupPolicy>;
+    closeDuplicates?: boolean;
+    /**
+     * Set this to true if you want to store local documents
+     * in the RxDatabase instance.
+     */
+    localDocuments?: boolean;
+
+    /**
+     * Hash method used to hash strings and json-stringified objects.
+     * This hash does not have to be cryptographically secure,
+     * but it is very important that is does have not create
+     * collisions.
+     * Default is the sha256 from crypto.subtle.digest('SHA-256', data)
+     */
+    hashFunction?: HashFunction;
+
+    /**
+     * By default, count() queries in 'slow' mode are not allowed.
+     */
+    allowSlowCount?: boolean;
+
+    /**
+     * Can be used to add a custom reactivity Factory
+     * that is used on all getters and values that end with the double $$.
+     * For example you can use the signals api of your framework and vuejs ref()
+     */
+    reactivity?: RxReactivityFactory<Reactivity>;
+}
+
+export type CollectionsOfDatabase = ById<RxCollection>;
+export type RxDatabase<
+    Collections = CollectionsOfDatabase,
+    Internals = any,
+    InstanceCreationOptions = any,
+    Reactivity = any
+> = RxDatabaseBase<
+    Internals,
+    InstanceCreationOptions,
+    Collections,
+    Reactivity
+> & Collections & RxDatabaseGenerated<Collections, Reactivity>;
+
+
+export interface RxLocalDocumentMutation<StorageType, Reactivity = unknown> {
+    insertLocal<LocalDocType = any>(id: string, data: LocalDocType): Promise<
+        RxLocalDocument<StorageType, LocalDocType, Reactivity>
+    >;
+    upsertLocal<LocalDocType = any>(id: string, data: LocalDocType): Promise<
+        RxLocalDocument<StorageType, LocalDocType, Reactivity>
+    >;
+    getLocal<LocalDocType = any>(id: string): Promise<
+        RxLocalDocument<StorageType, LocalDocType, Reactivity> | null
+    >;
+    getLocal$<LocalDocType = any>(id: string): Observable<
+        RxLocalDocument<StorageType, LocalDocType, Reactivity> | null
+    >;
+}
+
+export interface RxDatabaseGenerated<Collections, Reactivity> extends RxLocalDocumentMutation<RxDatabase<Collections, any, any, Reactivity>> { }
+
+/**
+ * Extract the **DocumentType** of a collection.
+ */
+type ExtractDTcol<P> = P extends RxCollection<infer T> ? T : { [prop: string]: any; };
+
+interface RxDumpDatabaseBase {
+    instanceToken: string;
+    name: string;
+    passwordHash: string | null;
+}
+export interface RxDumpDatabase<Col> extends RxDumpDatabaseBase {
+    collections: RxDumpCollection<ExtractDTcol<Col[keyof Col]>>[];
+}
+export interface RxDumpDatabaseAny<Col> extends RxDumpDatabaseBase {
+    collections: RxDumpCollection<RxDumpCollectionAsAny<ExtractDTcol<Col[keyof Col]>>>[];
+}
+
+
+
+export type RxCollectionCreatedEvent = {
+    type: 'ADDED';
+    collection: RxCollection;
+};
+
+export type RxCollectionClosedEvent = {
+    type: 'CLOSED';
+    collection: RxCollection;
+};
+
+/**
+ * Fired on RxDatabase.collection$
+ */
+export type RxCollectionEvent =
+    | RxCollectionCreatedEvent
+    | RxCollectionClosedEvent;

package/dist/types/types/rx-document.d.ts

@@ -0,0 +1,160 @@
+import {
+    Observable
+} from 'rxjs';
+
+import type {
+    RxCollection,
+} from './rx-collection.d.ts';
+import type {
+    RxAttachment,
+    RxAttachmentCreator,
+    RxAttachmentCreatorBase64
+} from './rx-attachment.d.ts';
+import type { RxDocumentData, WithDeleted } from './rx-storage.d.ts';
+import type { RxChangeEvent } from './rx-change-event.d.ts';
+import type { DeepReadonly, MaybePromise, PlainJsonValue } from './util.d.ts';
+import type { UpdateQuery } from './plugins/update.d.ts';
+import type { CRDTEntry } from './plugins/crdt.d.ts';
+import type { Reactified } from './plugins/reactivity.d.ts';
+
+
+
+export type RxDocument<RxDocumentType = {}, OrmMethods = {}, Reactivity = unknown> = RxDocumentBase<
+    RxDocumentType,
+    OrmMethods,
+    Reactivity
+> & RxDocumentType & OrmMethods & ExtendObservables<RxDocumentType> & ExtendReactivity<RxDocumentType, Reactivity>;
+
+
+/**
+ * Extend the base properties by the property$ fields
+ * so it knows that RxDocument.age also has RxDocument.age$ which is
+ * an observable.
+ * TODO how to do this for the nested fields?
+ */
+type ExtendObservables<RxDocumentType> = {
+    [P in keyof RxDocumentType as `${string & P}$`]: Observable<RxDocumentType[P]>;
+};
+
+type ExtendReactivity<RxDocumentType, Reactivity> = {
+    [P in keyof RxDocumentType as `${string & P}$$`]: Reactified<Reactivity, RxDocumentType[P]>;
+};
+
+/**
+ * The public facing modify update function.
+ * It only gets the document parts as input, that
+ * are mutateable by the user.
+ */
+export type ModifyFunction<RxDocumentType> = (
+    doc: WithDeleted<RxDocumentType>
+) => MaybePromise<WithDeleted<RxDocumentType>> | MaybePromise<RxDocumentType>;
+
+/**
+ * Meta data that is attached to each document by RxDB.
+ */
+export type RxDocumentMeta = {
+    /**
+     * Last write time.
+     * Unix epoch in milliseconds.
+     */
+    lwt: number;
+
+    /**
+     * The replication plugins "tags" the origin
+     * of writes to later know if a write came from
+     * the replication or was done locally.
+     */
+    o?: {
+        hash: string;
+        _rev: number;
+    };
+
+    /**
+     * Any other value can be attached to the _meta data.
+     * Mostly done by plugins to mark documents.
+     */
+    [k: string]: PlainJsonValue | undefined;
+
+
+};
+
+export declare interface RxDocumentBase<RxDocType, OrmMethods = {}, Reactivity = unknown> {
+    isInstanceOfRxDocument: true;
+    collection: RxCollection<RxDocType, OrmMethods, Reactivity>;
+    readonly deleted: boolean;
+
+    readonly $: Observable<RxDocument<RxDocType, OrmMethods, Reactivity>>;
+    readonly $$: Reactified<Reactivity, RxDocument<RxDocType, OrmMethods, Reactivity>>;
+    readonly deleted$: Observable<boolean>;
+    readonly deleted$$: Reactified<Reactivity, boolean>;
+
+    readonly primary: string;
+    readonly allAttachments$: Observable<RxAttachment<RxDocType, OrmMethods, Reactivity>[]>;
+
+    // internal things
+    _data: RxDocumentData<RxDocType>;
+    primaryPath: string;
+    revision: string;
+    /**
+     * Used to de-duplicate the enriched property objects
+     * of the document. Lazily initialized on first property access.
+     */
+    _propertyCache: Map<string, any> | undefined;
+    $emit(cE: RxChangeEvent<RxDocType>): void;
+    _saveData(newData: any, oldData: RxDocumentData<RxDocType>): Promise<RxDocument<RxDocType, OrmMethods, Reactivity>>;
+    // /internal things
+
+    // Returns the latest state of the document
+    getLatest(): RxDocument<RxDocType, OrmMethods, Reactivity>;
+
+
+    get$(path: string): Observable<any>;
+    get$$(path: string): Reactified<Reactivity, any>;
+    get(objPath: string): DeepReadonly<any>;
+    populate(objPath: string): Promise<RxDocument<RxDocType, OrmMethods, Reactivity> | any | null>;
+
+    /**
+     * mutate the document with a function
+     */
+    modify(mutationFunction: ModifyFunction<RxDocType>, context?: string): Promise<RxDocument<RxDocType, OrmMethods, Reactivity>>;
+    incrementalModify(mutationFunction: ModifyFunction<RxDocType>, context?: string): Promise<RxDocument<RxDocType, OrmMethods, Reactivity>>;
+
+    /**
+     * patches the given properties
+     */
+    patch(patch: Partial<RxDocType>): Promise<RxDocument<RxDocType, OrmMethods, Reactivity>>;
+    incrementalPatch(patch: Partial<RxDocType>): Promise<RxDocument<RxDocType, OrmMethods, Reactivity>>;
+
+    update(updateObj: UpdateQuery<RxDocType>): Promise<RxDocument<RxDocType, OrmMethods, Reactivity>>;
+    incrementalUpdate(updateObj: UpdateQuery<RxDocType>): Promise<RxDocument<RxDocType, OrmMethods, Reactivity>>;
+
+    updateCRDT(updateObj: CRDTEntry<RxDocType> | CRDTEntry<RxDocType>[]): Promise<RxDocument<RxDocType, OrmMethods, Reactivity>>;
+
+    remove(): Promise<RxDocument<RxDocType, OrmMethods, Reactivity>>;
+    incrementalRemove(): Promise<RxDocument<RxDocType, OrmMethods, Reactivity>>;
+
+    // only for temporary documents
+    set(objPath: string, value: any): RxDocument<RxDocType, OrmMethods, Reactivity>;
+    save(): Promise<boolean>;
+
+    // attachments
+    putAttachment(
+        creator: RxAttachmentCreator
+    ): Promise<RxAttachment<RxDocType, OrmMethods, Reactivity>>;
+    putAttachmentBase64(
+        creator: RxAttachmentCreatorBase64
+    ): Promise<RxAttachment<RxDocType, OrmMethods, Reactivity>>;
+    putAttachments(
+        creators: RxAttachmentCreator[]
+    ): Promise<RxAttachment<RxDocType, OrmMethods, Reactivity>[]>;
+    getAttachment(id: string): RxAttachment<RxDocType, OrmMethods, Reactivity> | null;
+    allAttachments(): RxAttachment<RxDocType, OrmMethods, Reactivity>[];
+
+    toJSON(withRevAndAttachments: true): DeepReadonly<RxDocumentData<RxDocType>>;
+    toJSON(withRevAndAttachments?: false): DeepReadonly<RxDocType>;
+
+    toMutableJSON(withRevAndAttachments: true): RxDocumentData<RxDocType>;
+    toMutableJSON(withRevAndAttachments?: false): RxDocType;
+
+    close(): void;
+}