@connecttomahdi/rxdb 17.0.0-beta.17

package/dist/types/incremental-write.d.ts

@@ -0,0 +1,29 @@
+import type { ModifyFunction, MaybePromise, RxDocumentData, RxDocumentWriteData, RxError, RxStorageInstance, StringKeys } from './types/index.d.ts';
+export type IncrementalWriteModifier<RxDocType> = (doc: RxDocumentData<RxDocType>) => MaybePromise<RxDocumentData<RxDocType>> | MaybePromise<RxDocumentWriteData<RxDocType>>;
+type IncrementalWriteQueueItem<RxDocType> = {
+    lastKnownDocumentState: RxDocumentData<RxDocType>;
+    modifier: IncrementalWriteModifier<RxDocType>;
+    resolve: (d: RxDocumentData<RxDocType>) => void;
+    reject: (error: RxError) => void;
+};
+/**
+ * The incremental write queue
+ * batches up all incremental writes to a collection
+ * so that performance can be improved by:
+ * - Running only one write even when there are multiple modifications to the same document.
+ * - Run all writes ins a single bulkWrite() call even when there are writes to many documents.
+ */
+export declare class IncrementalWriteQueue<RxDocType> {
+    readonly storageInstance: RxStorageInstance<RxDocType, any, any>;
+    readonly primaryPath: StringKeys<RxDocumentData<RxDocType>>;
+    readonly preWrite: (newData: RxDocumentData<RxDocType>, oldData: RxDocumentData<RxDocType>) => MaybePromise<void>;
+    readonly postWrite: (docData: RxDocumentData<RxDocType>) => void;
+    queueByDocId: Map<string, IncrementalWriteQueueItem<RxDocType>[]>;
+    isRunning: boolean;
+    constructor(storageInstance: RxStorageInstance<RxDocType, any, any>, primaryPath: StringKeys<RxDocumentData<RxDocType>>, preWrite: (newData: RxDocumentData<RxDocType>, oldData: RxDocumentData<RxDocType>) => MaybePromise<void>, postWrite: (docData: RxDocumentData<RxDocType>) => void);
+    addWrite(lastKnownDocumentState: RxDocumentData<RxDocType>, modifier: IncrementalWriteModifier<RxDocType>): Promise<RxDocumentData<RxDocType>>;
+    triggerRun(): Promise<void>;
+}
+export declare function modifierFromPublicToInternal<RxDocType>(publicModifier: ModifyFunction<RxDocType>): IncrementalWriteModifier<RxDocType>;
+export declare function findNewestOfDocumentStates<RxDocType>(docs: RxDocumentData<RxDocType>[]): RxDocumentData<RxDocType>;
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,30 @@
+// @ts-nocheck
+        /**
+ * this is the main entry-point
+ * for when the you call "import from 'rxdb'".
+ */
+export * from './plugin.d.ts';
+export * from './rx-database.d.ts';
+export * from './rx-error.d.ts';
+export * from './rx-database-internal-store.d.ts';
+export * from './overwritable.d.ts';
+export * from './rx-collection.d.ts';
+export * from './rx-collection-helper.d.ts';
+export * from './rx-document.d.ts';
+export * from './rx-change-event.d.ts';
+export * from './rx-document-prototype-merge.d.ts';
+export * from './rx-query.d.ts';
+export * from './rx-query-single-result.d.ts';
+export * from './rx-query-helper.d.ts';
+export * from './rx-schema.d.ts';
+export * from './rx-schema-helper.d.ts';
+export * from './rx-storage-helper.d.ts';
+export * from './replication-protocol/index.d.ts';
+export * from './rx-storage-multiinstance.d.ts';
+export * from './custom-index.d.ts';
+export * from './query-planner.d.ts';
+export * from './plugin-helpers.d.ts';
+export * from './plugins/utils/index.d.ts';
+export * from './hooks.d.ts';
+export * from './query-cache.d.ts';
+export type * from './types/index.d.ts';

package/dist/types/overwritable.d.ts

@@ -0,0 +1,26 @@
+/**
+ * functions that can or should be overwritten by plugins
+ * IMPORTANT: Do not import any big stuff from RxDB here!
+ * An 'overwritable' can be used inside WebWorkers for RxStorage only,
+ * and we do not want to have the full RxDB lib bundled in them.
+ */
+import type { DeepReadonly } from './types/util.d.ts';
+export declare const overwritable: {
+    /**
+     * if this method is overwritten with one
+     * that returns true, we do additional checks
+     * which help the developer but have bad performance
+     */
+    isDevMode(): boolean;
+    /**
+     * Deep freezes and object when in dev-mode.
+     * Deep-Freezing has the same performance as deep-cloning, so we only do that in dev-mode.
+     * Also, we can ensure the readonly state via typescript
+     * @link https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Global_Objects/Object/freeze
+     */
+    deepFreezeWhenDevMode<T>(obj: T): DeepReadonly<T>;
+    /**
+     * overwritten to map error-codes to text-messages
+     */
+    tunnelErrorMessage(message: string): string;
+};

package/dist/types/plugin-helpers.d.ts

@@ -0,0 +1,30 @@
+import { WrappedRxStorageInstance } from './rx-storage-helper.ts';
+import type { RxDocumentData, RxDocumentWriteData, RxJsonSchema, RxStorage, RxStorageInstance, RxValidationError, MaybePromise } from './types/index.d.ts';
+type WrappedStorageFunction = <Internals, InstanceCreationOptions>(args: {
+    storage: RxStorage<Internals, InstanceCreationOptions>;
+}) => RxStorage<Internals, InstanceCreationOptions>;
+/**
+ * Returns the validation errors.
+ * If document is fully valid, returns an empty array.
+ */
+type ValidatorFunction = (docData: RxDocumentData<any>) => RxValidationError[];
+/**
+ * This factory is used in the validation plugins
+ * so that we can reuse the basic storage wrapping code.
+ */
+export declare function wrappedValidateStorageFactory(
+/**
+ * Returns a method that can be used to validate
+ * documents and throws when the document is not valid.
+ */
+getValidator: (schema: RxJsonSchema<any>) => ValidatorFunction, 
+/**
+ * A string to identify the validation library.
+ */
+validatorKey: string): WrappedStorageFunction;
+/**
+ * Used in plugins to easily modify all in- and outgoing
+ * data of that storage instance.
+ */
+export declare function wrapRxStorageInstance<RxDocType>(originalSchema: RxJsonSchema<RxDocumentData<RxDocType>>, instance: RxStorageInstance<RxDocType, any, any>, modifyToStorage: (docData: RxDocumentWriteData<RxDocType>) => MaybePromise<RxDocumentData<any>>, modifyFromStorage: (docData: RxDocumentData<any>) => MaybePromise<RxDocumentData<RxDocType>>, modifyAttachmentFromStorage?: (attachmentData: Blob) => MaybePromise<Blob>): WrappedRxStorageInstance<RxDocType, any, any>;
+export {};

package/dist/types/plugin.d.ts

@@ -0,0 +1,6 @@
+import type { RxPlugin } from './types/index.d.ts';
+/**
+ * Add a plugin to the RxDB library.
+ * Plugins are added globally and cannot be removed.
+ */
+export declare function addRxPlugin(plugin: RxPlugin): void;

package/dist/types/plugins/attachments/attachments-utils.d.ts

@@ -0,0 +1,10 @@
+import type { RxStorageInstance, WithDeletedAndAttachments } from '../../types/index.d.ts';
+export declare function ensureSchemaSupportsAttachments(doc: any): void;
+export declare function assignMethodsToAttachment(attachment: any): void;
+/**
+ * Fill up the missing attachment.data of the newDocument
+ * so that the new document can be sent to somewhere else
+ * which could then receive all required attachments data
+ * that it did not have before.
+ */
+export declare function fillWriteDataForAttachmentsChange<RxDocType>(primaryPath: string, storageInstance: RxStorageInstance<RxDocType, any, any, any>, newDocument: WithDeletedAndAttachments<RxDocType>, originalDocument?: WithDeletedAndAttachments<RxDocType>): Promise<WithDeletedAndAttachments<RxDocType>>;

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

@@ -0,0 +1,42 @@
+import type { RxDocument, RxPlugin, RxAttachmentData, RxDocumentData, RxAttachmentCreator, RxCollection, RxAttachmentCreatorBase64 } from '../../types/index.d.ts';
+/**
+ * an RxAttachment is basically just the attachment-stub
+ * wrapped so that you can access the attachment-data
+ */
+export declare class RxAttachment {
+    doc: RxDocument;
+    id: string;
+    type: string;
+    length: number;
+    digest: string;
+    constructor({ doc, id, type, length, digest }: any);
+    remove(): Promise<void>;
+    /**
+     * returns the data for the attachment
+     */
+    getData(): Promise<Blob>;
+    getStringData(): Promise<string>;
+    getDataBase64(): Promise<string>;
+}
+export declare function fromStorageInstanceResult<RxDocType>(id: string, attachmentData: RxAttachmentData, rxDocument: RxDocument<RxDocType>): RxAttachment;
+export declare function putAttachment<RxDocType>(this: RxDocument<RxDocType>, attachmentData: RxAttachmentCreator): Promise<RxAttachment>;
+export declare function putAttachmentBase64<RxDocType>(this: RxDocument<RxDocType>, attachmentData: RxAttachmentCreatorBase64): Promise<import("../../index.ts").RxAttachment<RxDocType, {}, unknown>>;
+/**
+ * Write multiple attachments in a single atomic operation.
+ */
+export declare function putAttachments<RxDocType>(this: RxDocument<RxDocType>, attachments: RxAttachmentCreator[]): Promise<RxAttachment[]>;
+/**
+ * get an attachment of the document by its id
+ */
+export declare function getAttachment(this: RxDocument, id: string): RxAttachment | null;
+/**
+ * returns all attachments of the document
+ */
+export declare function allAttachments(this: RxDocument): RxAttachment[];
+export declare function preMigrateDocument<RxDocType>(data: {
+    docData: RxDocumentData<RxDocType>;
+    oldCollection: RxCollection<RxDocType>;
+}): Promise<void>;
+export declare function postMigrateDocument(_action: any): Promise<void>;
+export declare const RxDBAttachmentsPlugin: RxPlugin;
+export * from './attachments-utils.ts';

package/dist/types/plugins/attachments-compression/index.d.ts

@@ -0,0 +1,38 @@
+import type { RxStorage, CompressionMode } from '../../types/index.d.ts';
+/**
+ * Default MIME type patterns that benefit from compression.
+ * Types like images (JPEG, PNG, WebP), videos, and audio
+ * are already compressed and should NOT be re-compressed.
+ */
+export declare const DEFAULT_COMPRESSIBLE_TYPES: string[];
+/**
+ * Checks if a given MIME type should be compressed,
+ * based on a list of type patterns. Supports wildcard suffix matching
+ * (e.g., 'text/*' matches 'text/plain', 'text/html', etc.).
+ *
+ * Deterministic: same type + same pattern list = same answer.
+ * No byte-level inspection needed.
+ */
+export declare function isCompressibleType(mimeType: string, compressibleTypes: string[]): boolean;
+/**
+ * Compress a Blob using streaming CompressionStream API.
+ * @link https://github.com/WICG/compression/blob/main/explainer.md
+ */
+export declare function compressBlob(mode: CompressionMode, blob: Blob): Promise<Blob>;
+/**
+ * Decompress a Blob using streaming DecompressionStream API.
+ */
+export declare function decompressBlob(mode: CompressionMode, blob: Blob): Promise<Blob>;
+/**
+ * A RxStorage wrapper that compresses attachment data on writes
+ * and decompresses the data on reads.
+ *
+ * Only compresses attachments whose MIME type is in the compressible list.
+ * Already-compressed formats (JPEG, PNG, MP4, etc.) are passed through as-is.
+ *
+ * This is using the CompressionStream API,
+ * @link https://caniuse.com/?search=compressionstream
+ */
+export declare function wrappedAttachmentsCompressionStorage<Internals, InstanceCreationOptions>(args: {
+    storage: RxStorage<Internals, InstanceCreationOptions>;
+}): RxStorage<Internals, InstanceCreationOptions>;

package/dist/types/plugins/backup/file-util.d.ts

@@ -0,0 +1,17 @@
+import type { BackupMetaFileContent, BackupOptions, RxDatabase } from '../../types/index.d.ts';
+/**
+ * ensure that the given folder exists
+ */
+export declare function ensureFolderExists(folderPath: string): void;
+/**
+ * deletes and recreates the folder
+ */
+export declare function clearFolder(folderPath: string): void;
+export declare function deleteFolder(folderPath: string): void;
+export declare function prepareFolders(database: RxDatabase, options: BackupOptions): void;
+export declare function writeToFile(location: string, data: string | Blob): Promise<void>;
+export declare function writeJsonToFile(location: string, data: any): Promise<void>;
+export declare function metaFileLocation(options: BackupOptions): string;
+export declare function getMeta(options: BackupOptions): Promise<BackupMetaFileContent>;
+export declare function setMeta(options: BackupOptions, meta: BackupMetaFileContent): Promise<void>;
+export declare function documentFolder(options: BackupOptions, docId: string): string;

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

@@ -0,0 +1,37 @@
+import { Observable } from 'rxjs';
+import type { BackupOptions, RxBackupWriteEvent, RxDatabase, RxDocument, RxPlugin } from '../../types/index.d.ts';
+/**
+ * Backups a single documents,
+ * returns the paths to all written files
+ */
+export declare function backupSingleDocument(rxDocument: RxDocument<any, any>, options: BackupOptions): Promise<string[]>;
+export declare class RxBackupState {
+    readonly database: RxDatabase;
+    readonly options: BackupOptions;
+    isStopped: boolean;
+    private subs;
+    private persistRunning;
+    private initialReplicationDone$;
+    private readonly internalWriteEvents$;
+    readonly writeEvents$: Observable<RxBackupWriteEvent>;
+    constructor(database: RxDatabase, options: BackupOptions);
+    /**
+     * Persists all data from all collections,
+     * beginning from the oldest sequence checkpoint
+     * to the newest one.
+     * Do not call this while it is already running.
+     * Returns true if there are more documents to process
+     */
+    persistOnce(): Promise<void>;
+    _persistOnce(): Promise<void>;
+    watchForChanges(): void;
+    /**
+     * Returns a promise that resolves when the initial backup is done
+     * and the filesystem is in sync with the database state
+     */
+    awaitInitialBackup(): Promise<boolean>;
+    cancel(): Promise<boolean>;
+}
+export declare function backup(this: RxDatabase, options: BackupOptions): RxBackupState;
+export * from './file-util.ts';
+export declare const RxDBBackupPlugin: RxPlugin;

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

@@ -0,0 +1,2 @@
+import type { RxCleanupPolicy } from '../../types/index.d.ts';
+export declare const DEFAULT_CLEANUP_POLICY: RxCleanupPolicy;

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

@@ -0,0 +1,7 @@
+import type { RxCleanupPolicy, RxState } from '../../types/index.d.ts';
+export declare function startCleanupForRxState(state: RxState<unknown, unknown>): Promise<void>;
+/**
+ * Runs the cleanup for a single RxState
+ */
+export declare function cleanupRxState(state: RxState<unknown, unknown>, cleanupPolicy: RxCleanupPolicy): Promise<void>;
+export declare function runCleanupAfterWrite(state: RxState<unknown, unknown>, cleanupPolicy: RxCleanupPolicy): Promise<void>;

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

@@ -0,0 +1,8 @@
+import type { RxCleanupPolicy, RxCollection } from '../../types/index.d.ts';
+export declare function startCleanupForRxCollection(rxCollection: RxCollection): Promise<void>;
+export declare function initialCleanupWait(collection: RxCollection, cleanupPolicy: RxCleanupPolicy): Promise<void>;
+/**
+ * Runs the cleanup for a single RxCollection
+ */
+export declare function cleanupRxCollection(rxCollection: RxCollection, cleanupPolicy: RxCleanupPolicy): Promise<void>;
+export declare function runCleanupAfterDelete(rxCollection: RxCollection, cleanupPolicy: RxCleanupPolicy): Promise<void>;

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

@@ -0,0 +1,4 @@
+import type { RxPlugin } from '../../types/index.d.ts';
+export declare const RxDBCleanupPlugin: RxPlugin;
+export * from './cleanup.ts';
+export * from './cleanup-helper.ts';

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

@@ -0,0 +1,12 @@
+import type { CRDTDocumentField, CRDTEntry, CRDTOperation, HashFunction, JsonSchema, RxConflictHandler, RxDocument, RxDocumentData, RxJsonSchema, RxPlugin, WithDeleted } from '../../types/index.d.ts';
+import { RxCollection } from '../../index.ts';
+export declare function updateCRDT<RxDocType>(this: RxDocument<RxDocType>, entry: CRDTEntry<RxDocType> | CRDTEntry<RxDocType>[]): Promise<RxDocument<RxDocType, {}, unknown>>;
+export declare function insertCRDT<RxDocType>(this: RxCollection<RxDocType>, entry: CRDTEntry<RxDocType> | CRDTEntry<RxDocType>[]): Promise<RxDocument<RxDocType, {}> | RxDocument<RxDocType, {}, unknown>>;
+export declare function sortOperationComparator<RxDocType>(a: CRDTOperation<RxDocType>, b: CRDTOperation<RxDocType>): 1 | -1;
+export declare function hashCRDTOperations(hashFunction: HashFunction, crdts: CRDTDocumentField<any>): Promise<string>;
+export declare function getCRDTSchemaPart<RxDocType>(): JsonSchema<CRDTDocumentField<RxDocType>>;
+export declare function mergeCRDTFields<RxDocType>(hashFunction: HashFunction, crdtsA: CRDTDocumentField<RxDocType>, crdtsB: CRDTDocumentField<RxDocType>): Promise<CRDTDocumentField<RxDocType>>;
+export declare function rebuildFromCRDT<RxDocType>(schema: RxJsonSchema<RxDocumentData<RxDocType>>, docData: WithDeleted<RxDocType> | RxDocType, crdts: CRDTDocumentField<RxDocType>): WithDeleted<RxDocType>;
+export declare function getCRDTConflictHandler<RxDocType>(hashFunction: HashFunction, schema: RxJsonSchema<RxDocumentData<RxDocType>>): RxConflictHandler<RxDocType>;
+export declare const RX_CRDT_CONTEXT = "rx-crdt";
+export declare const RxDBcrdtPlugin: RxPlugin;

package/dist/types/plugins/dev-mode/check-document.d.ts

@@ -0,0 +1,9 @@
+import type { BulkWriteRow, RxDocumentData, RxStorageInstance } from '../../types/index.d.ts';
+export declare function ensurePrimaryKeyValid(primaryKey: string, docData: RxDocumentData<any>): void;
+/**
+ * Deeply checks if the object contains an
+ * instance of the JavaScript Date class.
+ * @recursive
+ */
+export declare function containsDateInstance(obj: any): boolean;
+export declare function checkWriteRows<RxDocType>(storageInstance: RxStorageInstance<RxDocType, any, any, any>, rows: BulkWriteRow<RxDocType>[]): void;

package/dist/types/plugins/dev-mode/check-migration-strategies.d.ts

@@ -0,0 +1,6 @@
+import type { RxJsonSchema, NumberFunctionMap } from '../../types/index.d.ts';
+/**
+ * checks if the migrationStrategies are ok, throws if not
+ * @throws {Error|TypeError} if not ok
+ */
+export declare function checkMigrationStrategies(schema: RxJsonSchema<any>, migrationStrategies: NumberFunctionMap): boolean;

package/dist/types/plugins/dev-mode/check-orm.d.ts

@@ -0,0 +1,7 @@
+import type { KeyFunctionMap, RxJsonSchema } from '../../types/index.d.ts';
+/**
+ * checks if the given static methods are allowed
+ * @throws if not allowed
+ */
+export declare function checkOrmMethods(statics?: KeyFunctionMap): void;
+export declare function checkOrmDocumentMethods<RxDocType>(schema: RxJsonSchema<RxDocType>, methods?: any): void;

package/dist/types/plugins/dev-mode/check-query.d.ts

@@ -0,0 +1,21 @@
+import type { RxPluginPreCreateRxQueryArgs, RxPluginPrePrepareQueryArgs, FilledMangoQuery, RxJsonSchema, RxDocumentData, RxPluginPrePrepareRxQueryArgs } from '../../types/index.d.ts';
+/**
+ * accidentally passing a non-valid object into the query params
+ * is very hard to debug especially when queries are observed
+ * This is why we do some checks here in dev-mode
+ */
+export declare function checkQuery(args: RxPluginPreCreateRxQueryArgs): void;
+export declare function checkMangoQuery(args: RxPluginPrePrepareQueryArgs): void;
+export declare function areSelectorsSatisfiedByIndex<RxDocType>(schema: RxJsonSchema<RxDocumentData<RxDocType>>, query: FilledMangoQuery<RxDocType>): boolean;
+/**
+ * Ensures that the selector does not contain any RegExp instance.
+ * @recursive
+ */
+export declare function ensureObjectDoesNotContainRegExp(selector: any): void;
+/**
+ * People often use queries wrong
+ * so we have some checks here.
+ * For example people use numbers as primary keys
+ * which is not allowed.
+ */
+export declare function isQueryAllowed(args: RxPluginPrePrepareRxQueryArgs): void;

package/dist/types/plugins/dev-mode/check-schema.d.ts

@@ -0,0 +1,18 @@
+import type { RxJsonSchema } from '../../types/index.d.ts';
+/**
+ * checks if the fieldname is allowed
+ * this makes sure that the fieldnames can be transformed into javascript-vars
+ * and does not conquer the observe$ and populate_ fields
+ * @throws {Error}
+ */
+export declare function checkFieldNameRegex(fieldName: string): void;
+/**
+ * validate that all schema-related things are ok
+ */
+export declare function validateFieldsDeep(rxJsonSchema: RxJsonSchema<any>): true;
+export declare function checkPrimaryKey(jsonSchema: RxJsonSchema<any>): void;
+/**
+ * does the checking
+ * @throws {Error} if something is not ok
+ */
+export declare function checkSchema(jsonSchema: RxJsonSchema<any>): void;

package/dist/types/plugins/dev-mode/dev-mode-tracking.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Adds an iframe to track the results of marketing efforts.
+ */
+export declare function addDevModeTrackingIframe(): Promise<void>;

package/dist/types/plugins/dev-mode/entity-properties.d.ts

@@ -0,0 +1,3 @@
+export declare function rxCollectionProperties(): string[];
+export declare function rxDatabaseProperties(): string[];
+export declare function rxDocumentProperties(): string[];