@connecttomahdi/rxdb 17.0.0-beta.17

package/src/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/src/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;
+}

package/src/types/rx-error.d.ts

@@ -0,0 +1,222 @@
+import type { RxJsonSchema } from './rx-schema.d.ts';
+import {
+    RxSchema
+} from '../rx-schema.ts';
+import type { RxPlugin } from './rx-plugin.d.ts';
+import { ERROR_MESSAGES } from '../plugins/dev-mode/error-messages.ts';
+import type { RxReplicationWriteToMasterRow } from './replication-protocol.d.ts';
+import type { BulkWriteRow, RxDocumentData } from './rx-storage.d.ts';
+
+type KeyOf<T extends object> = Extract<keyof T, string>;
+export type RxErrorKey = KeyOf<typeof ERROR_MESSAGES>;
+
+export type {
+    RxError,
+    RxTypeError
+} from '../rx-error.ts';
+
+/**
+ * this lists all possible parameters
+ */
+export interface RxErrorParameters {
+    readonly error?: PlainJsonError;
+    readonly errors?: PlainJsonError[];
+    readonly errorText?: string;
+    readonly writeError?: RxStorageWriteError<any>;
+    readonly schemaPath?: string;
+    readonly objPath?: string;
+    readonly rootPath?: string;
+    readonly childpath?: string;
+    readonly ids?: string[];
+    readonly obj?: any;
+    readonly document?: any;
+    readonly schema?: Readonly<RxJsonSchema<any> | RxSchema>;
+    readonly schemaObj?: any;
+    readonly pluginKey?: string;
+    readonly originalDoc?: Readonly<any>;
+    readonly finalDoc?: Readonly<any>;
+    readonly regex?: string;
+    readonly fieldName?: string;
+    readonly id?: string;
+    readonly documentId?: string;
+    readonly data?: any;
+    readonly missingCollections?: string[];
+    readonly primaryPath?: string;
+    readonly primary?: string;
+    readonly primaryKey?: string;
+    readonly have?: any;
+    readonly should?: any;
+    readonly name?: string;
+    readonly adapter?: any;
+    readonly link?: string;
+    readonly path?: string;
+    readonly value?: any;
+    readonly givenName?: string;
+    readonly fromVersion?: number;
+    readonly toVersion?: number;
+    readonly version?: number;
+    readonly args?: any;
+    readonly opts?: any;
+    readonly dataBefore?: any;
+    readonly dataAfter?: any;
+    readonly pull?: boolean;
+    readonly push?: boolean;
+    readonly url?: string;
+    readonly key?: string;
+    readonly queryObj?: any;
+    readonly query?: any;
+    readonly op?: string;
+    readonly skip?: any;
+    readonly limit?: any;
+    readonly passwordHash?: string;
+    readonly existingPasswordHash?: string;
+    readonly password?: string | any;
+    readonly minPassLength?: number;
+    readonly own?: any;
+    readonly source?: any;
+    readonly method?: any;
+    readonly field?: string;
+    readonly ref?: string;
+    readonly funName?: string;
+    readonly functionName?: string;
+    readonly schemaHash?: string;
+    readonly previousSchema?: Readonly<RxJsonSchema<any>>;
+    readonly previousSchemaHash?: string;
+    readonly type?: string;
+    readonly when?: string;
+    readonly parallel?: boolean;
+    readonly collection?: any;
+    readonly database?: any;
+    readonly storage?: string;
+    readonly indexes?: Array<string | string[]> | Readonly<Array<string | string[]>>;
+    readonly index?: string | string[] | readonly string[];
+    readonly plugin?: RxPlugin | any;
+    readonly plugins?: Set<RxPlugin | any>;
+
+    // used in the replication plugin
+
+    /**
+     * The checkpoint of the response from the last successful
+     * pull by the client.
+     * Null if there was no pull operation before
+     * so that there is no last pulled checkpoint.
+     */
+    readonly checkpoint?: any;
+    /**
+     * The documents that failed to be pushed.
+     * Typed as 'any' because they might be modified by the push modifier.
+     */
+    readonly pushRows?: RxReplicationWriteToMasterRow<any>[];
+    readonly direction?: 'pull' | 'push';
+
+    // google-drive-replication
+    readonly folderPath?: string;
+    readonly folderName?: string;
+    readonly file?: any;
+    readonly parentId?: string;
+
+    // fetch
+    readonly body?: any;
+    readonly status?: number;
+    readonly statusText?: string;
+    readonly headers?: Record<string, any>;
+    readonly code?: string;
+}
+
+/**
+ * Error-Items which are created by the jsonschema-validator
+ */
+export type RxValidationError = {
+    readonly field: string;
+    readonly message: string;
+};
+
+/**
+ * Use to have a transferable error object
+ * in plain json instead of a JavaScript Error instance.
+ */
+export type PlainJsonError = {
+    name: string;
+    message: string;
+    rxdb?: true;
+    code?: RxErrorKey;
+    url?: string;
+    extensions?: Record<string, any>;
+    parameters?: RxErrorParameters;
+    stack?: string;
+};
+
+
+
+
+
+/**
+ * Error that can happen per document when
+ * RxStorage.bulkWrite() is called
+ */
+export type RxStorageWriteErrorBase<RxDocType> = {
+    status: number
+    | 409 // conflict
+    | 422 // schema validation error
+    | 510 // attachment data missing
+    ;
+
+    /**
+     * set this property to make it easy
+     * to detect if the object is a RxStorageBulkWriteError
+     */
+    isError: true;
+
+    // primary key of the document
+    documentId: string;
+
+    // the original document data that should have been written.
+    writeRow: BulkWriteRow<RxDocType>;
+
+    /**
+     * The context which was given to bulkWrite(),
+     * used for debugging.
+     */
+    context: string;
+};
+
+export type RxStorageWriteErrorConflict<RxDocType> = RxStorageWriteErrorBase<RxDocType> & {
+    status: 409;
+    /**
+     * A conflict error state must contain the
+     * document state in the database.
+     * This ensures that we can continue resolving a conflict
+     * without having to pull the document out of the db first.
+     * Is not set if the error happens on an insert.
+     */
+    documentInDb: RxDocumentData<RxDocType>;
+};
+
+export type RxStorageWriteErrorValidation<RxDocType> = RxStorageWriteErrorBase<RxDocType> & {
+    status: 422;
+    /**
+     * Other properties that give
+     * information about the error,
+     * for example a schema validation error
+     * might contain the exact error from the validator here.
+     * Must be plain JSON!
+     */
+    validationErrors: RxValidationError[];
+    /**
+     * For easier debugging,
+     * we directly put the schema into the error.
+     */
+    schema: RxJsonSchema<RxDocumentData<RxDocType>>;
+};
+
+export type RxStorageWriteErrorAttachment<RxDocType> = RxStorageWriteErrorBase<RxDocType> & {
+    status: 510;
+    attachmentId: string;
+    documentInDb?: RxDocumentData<RxDocType>;
+};
+
+
+export type RxStorageWriteError<RxDocType> =
+    RxStorageWriteErrorConflict<RxDocType> |
+    RxStorageWriteErrorValidation<RxDocType> |
+    RxStorageWriteErrorAttachment<RxDocType>;

package/src/types/rx-plugin.d.ts

@@ -0,0 +1,167 @@
+import type {
+    RxQuery,
+    RxQueryOP,
+    MangoQuery
+} from './rx-query.d.ts';
+import type {
+    RxCollection,
+    RxCollectionCreator
+} from './rx-collection.d.ts';
+import type {
+    RxStorageInstanceCreationParams
+} from './rx-storage.d.ts';
+import type {
+    DeepReadonly,
+    FilledMangoQuery,
+    RxDatabase,
+    RxDatabaseCreator,
+    RxDocument,
+    RxStorage,
+    RxReplicationWriteToMasterRow,
+    WithDeleted,
+    RxState,
+    BulkWriteRow,
+    RxStorageInstance
+} from './index.d.ts';
+import type { RxSchema } from '../rx-schema.d.ts';
+
+export type RxPluginPrePrepareRxQueryArgs = {
+    op: RxQueryOP;
+    queryObj: MangoQuery | string | number | Array<any>;
+    collection: RxCollection;
+};
+
+export type RxPluginPreCreateRxQueryArgs = {
+    op: RxQueryOP;
+    queryObj: MangoQuery;
+    collection: RxCollection;
+};
+
+export type RxPluginPreAddRxPluginArgs = {
+    // the plugin that is getting added
+    plugin: RxPlugin | any;
+    // previous added plugins
+    plugins: Set<RxPlugin | any>;
+};
+
+export type RxPluginPrePrepareQueryArgs = {
+    rxQuery: RxQuery<any>;
+    mangoQuery: FilledMangoQuery<any>;
+};
+
+
+/**
+ * Depending on which plugins are used together,
+ * it is important that the plugin is able to define if
+ * the hooks must be added as first or as last array item.
+ * For example the encryption plugin must run encryption
+ * before the key-compression changes the fieldnames.
+ */
+export type RxPluginHooks<Input> = {
+    /**
+     * Hook function that is added as first.
+     */
+    before?: (i: Input) => void;
+    /**
+     * Hook function that is added as last.
+     */
+    after?: (i: Input) => void;
+};
+
+export interface RxPlugin {
+    /**
+     * A string to uniquely identifies the plugin.
+     * Can be used to throw when different versions of the same plugin are used.
+     * And also other checks.
+     * Use kebab-case.
+     */
+    readonly name: string;
+
+    /**
+     * set this to true so RxDB
+     * knows that this object in a rxdb plugin
+     */
+    readonly rxdb: true;
+
+    /**
+     * Init function where dependent plugins could be added.
+     * (optional)
+     */
+    init?(): any;
+
+    prototypes?: {
+        RxSchema?: (proto: RxSchema) => void;
+        RxDocument?: (proto: RxDocument) => void;
+        RxQuery?: (proto: RxQuery) => void;
+        RxCollection?: (proto: RxCollection) => void;
+        RxDatabase?: (proto: RxDatabase) => void;
+    };
+    overwritable?: {
+        isDevMode?: () => boolean;
+        deepFreezeWhenDevMode?: <T>(obj: T) => DeepReadonly<T>;
+        validatePassword?: Function;
+        checkAdapter?: Function;
+        tunnelErrorMessage?: Function;
+    };
+    hooks?: {
+        preAddRxPlugin?: RxPluginHooks<RxPluginPreAddRxPluginArgs>;
+        preCreateRxDatabase?: RxPluginHooks<any>;
+        createRxDatabase?: RxPluginHooks<{
+            database: RxDatabase;
+            creator: RxDatabaseCreator;
+        }>;
+        preCloseRxDatabase?: RxPluginHooks<RxDatabase>;
+        postRemoveRxDatabase?: RxPluginHooks<{
+            databaseName: string;
+            storage: RxStorage<any, any>;
+        }>;
+        createRxCollection?: RxPluginHooks<{
+            collection: RxCollection;
+            creator: RxCollectionCreator;
+        }>;
+        createRxState?: RxPluginHooks<{
+            collection: RxCollection;
+            state: RxState<unknown, unknown>;
+        }>;
+        preCreateRxCollection?: RxPluginHooks<RxCollectionCreator<any> & {
+            name: string;
+            database: RxDatabase;
+        }>;
+        postCloseRxCollection?: RxPluginHooks<RxCollection>;
+        postRemoveRxCollection?: RxPluginHooks<{
+            storage: RxStorage<any, any>;
+            databaseName: string;
+            collectionName: string;
+        }>;
+        preCreateRxSchema?: RxPluginHooks<any>;
+        createRxSchema?: RxPluginHooks<any>;
+        prePrepareRxQuery?: RxPluginHooks<RxPluginPrePrepareRxQueryArgs>;
+        preCreateRxQuery?: RxPluginHooks<RxPluginPreCreateRxQueryArgs>;
+        prePrepareQuery?: RxPluginHooks<RxPluginPrePrepareQueryArgs>;
+        createRxQuery?: RxPluginHooks<RxQuery>;
+        createRxDocument?: RxPluginHooks<any>;
+        postCreateRxDocument?: RxPluginHooks<any>;
+        preCreateRxStorageInstance?: RxPluginHooks<RxStorageInstanceCreationParams<any, any>>;
+        /**
+         * Runs before a write to the storage instance of a RxCollection or RxDatabase.
+         */
+        preStorageWrite?: RxPluginHooks<{
+            storageInstance: RxStorageInstance<any, any, any, any>;
+            rows: BulkWriteRow<any>[];
+        }>;
+        preMigrateDocument?: RxPluginHooks<any>;
+        postMigrateDocument?: RxPluginHooks<any>;
+        postCleanup?: RxPluginHooks<{
+            databaseName: string;
+            collectionName: string;
+        }>;
+        preReplicationMasterWrite?: RxPluginHooks<{
+            rows: RxReplicationWriteToMasterRow<any>[];
+            collection: RxCollection;
+        }>;
+        preReplicationMasterWriteDocumentsHandle?: RxPluginHooks<{
+            result: WithDeleted<any>[];
+            collection: RxCollection;
+        }>;
+    };
+}