@connecttomahdi/rxdb 17.0.0-beta.17 → 17.1.0

package/src/rx-storage-helper.ts

@@ -51,6 +51,37 @@ import { HOOKS, runPluginHooks } from './hooks.ts';
 export const INTERNAL_STORAGE_NAME = '_rxdb_internal';
 export const RX_DATABASE_LOCAL_DOCS_STORAGE_NAME = 'rxdatabase_storage_local';
 
+/**
+ * Context string used by RxCollection.bulkInsert().
+ * Documents written with this context are already cloned
+ * by fillObjectDataBeforeInsert(), so the wrapped storage
+ * can safely mutate them in place instead of cloning again.
+ */
+export const RX_COLLECTION_BULK_INSERT_CONTEXT = 'rx-collection-bulk-insert';
+
+/**
+ * Set of bulkWrite context strings whose documents
+ * are already cloned by the caller and can be safely
+ * mutated in place (skip flatClone in the insert path).
+ *
+ * Plugins can register additional contexts via
+ * registerMutableWriteContext().
+ */
+const MUTABLE_DOCUMENT_WRITE_CONTEXTS: Set<string> = new Set([
+    RX_COLLECTION_BULK_INSERT_CONTEXT
+]);
+
+/**
+ * Register a bulkWrite context string as "mutable",
+ * meaning the caller guarantees that insert documents
+ * are already cloned and safe to mutate in place.
+ * This allows the wrapped storage to skip a redundant
+ * flatClone() call on the insert hot path.
+ */
+export function registerMutableWriteContext(context: string): void {
+    MUTABLE_DOCUMENT_WRITE_CONTEXTS.add(context);
+}
+
 export async function getSingleDocument<RxDocType>(
     storageInstance: RxStorageInstance<RxDocType, any, any>,
     documentId: string
@@ -253,54 +284,54 @@ export function categorizeBulkWriteRows<RxDocType>(
              * It is possible to insert already deleted documents,
              * this can happen on replication.
              */
-            const insertedIsDeleted = documentDeleted ? true : false;
             if (hasAttachments) {
-                Object
-                    .entries(document._attachments)
-                    .forEach(([attachmentId, attachmentData]) => {
-                        if (
-                            !(attachmentData as RxAttachmentWriteData).data
-                        ) {
-                            attachmentError = {
-                                documentId: docId,
-                                isError: true,
-                                status: 510,
-                                writeRow,
-                                attachmentId,
-                                context
-                            };
-                            errors.push(attachmentError);
-                        } else {
-                            attachmentsAdd.push({
-                                documentId: docId,
-                                attachmentId,
-                                attachmentData: attachmentData as any,
-                                digest: attachmentData.digest
-                            });
-                        }
-                    });
+                const atts = document._attachments;
+                const attKeys = Object.keys(atts);
+                for (let a = 0; a < attKeys.length; a++) {
+                    const attachmentId = attKeys[a];
+                    const attachmentData = atts[attachmentId];
+                    if (
+                        !(attachmentData as RxAttachmentWriteData).data
+                    ) {
+                        attachmentError = {
+                            documentId: docId,
+                            isError: true,
+                            status: 510,
+                            writeRow,
+                            attachmentId,
+                            context
+                        };
+                        errors.push(attachmentError);
+                    } else {
+                        attachmentsAdd.push({
+                            documentId: docId,
+                            attachmentId,
+                            attachmentData: attachmentData as any,
+                            digest: attachmentData.digest
+                        });
+                    }
+                }
             }
+            let insertedRow: BulkWriteRowProcessed<RxDocType> | undefined;
             if (!attachmentError) {
-                if (hasAttachments) {
-                    bulkInsertDocs.push(stripAttachmentsDataFromRow(writeRow));
-                    if (onInsert) {
-                        onInsert(document);
-                    }
-                } else {
-                    bulkInsertDocs.push(writeRow as any);
-                    if (onInsert) {
-                        onInsert(document);
-                    }
+                const row: BulkWriteRowProcessed<RxDocType> = hasAttachments ? stripAttachmentsDataFromRow(writeRow) : writeRow as any;
+                insertedRow = row;
+                bulkInsertDocs.push(row);
+                if (onInsert) {
+                    onInsert(document);
                 }
-
-                newestRow = writeRow as any;
+                newestRow = row;
             }
 
-            if (!insertedIsDeleted) {
+            if (!documentDeleted) {
+                let eventDocData = document as RxDocumentData<RxDocType>;
+                if (hasAttachments) {
+                    eventDocData = insertedRow ? insertedRow.document : stripAttachmentsDataFromDocument(document);
+                }
                 const event = {
                     documentId: docId,
                     operation: 'INSERT' as const,
-                    documentData: hasAttachments ? stripAttachmentsDataFromDocument(document) : document as any,
+                    documentData: eventDocData,
                     previousDocumentData: hasAttachments && previous ? stripAttachmentsDataFromDocument(previous) : previous as any
                 };
                 eventBulkEvents.push(event);
@@ -343,69 +374,72 @@ export function categorizeBulkWriteRows<RxDocType>(
                      * Deleted documents must have cleared all their attachments.
                      */
                     if (previous) {
-                        Object
-                            .keys(previous._attachments)
-                            .forEach(attachmentId => {
-                                attachmentsRemove.push({
-                                    documentId: docId,
-                                    attachmentId,
-                                    digest: ensureNotFalsy(previous)._attachments[attachmentId].digest
-                                });
+                        const prevAtts = previous._attachments;
+                        const prevAttKeys = Object.keys(prevAtts);
+                        for (let a = 0; a < prevAttKeys.length; a++) {
+                            const attachmentId = prevAttKeys[a];
+                            attachmentsRemove.push({
+                                documentId: docId,
+                                attachmentId,
+                                digest: prevAtts[attachmentId].digest
                             });
+                        }
                     }
                 } else {
                     // first check for errors
-                    Object
-                        .entries(document._attachments)
-                        .find(([attachmentId, attachmentData]) => {
+                    const docAtts = document._attachments;
+                    const docAttKeys = Object.keys(docAtts);
+                    for (let a = 0; a < docAttKeys.length; a++) {
+                        const attachmentId = docAttKeys[a];
+                        const attachmentData = docAtts[attachmentId];
+                        const previousAttachmentData = previous ? previous._attachments[attachmentId] : undefined;
+                        if (
+                            !previousAttachmentData &&
+                            !(attachmentData as RxAttachmentWriteData).data
+                        ) {
+                            attachmentError = {
+                                documentId: docId,
+                                documentInDb: documentInDb as any,
+                                isError: true,
+                                status: 510,
+                                writeRow,
+                                attachmentId,
+                                context
+                            };
+                            break;
+                        }
+                    }
+                    if (!attachmentError) {
+                        for (let a = 0; a < docAttKeys.length; a++) {
+                            const attachmentId = docAttKeys[a];
+                            const attachmentData = docAtts[attachmentId];
                             const previousAttachmentData = previous ? previous._attachments[attachmentId] : undefined;
-                            if (
-                                !previousAttachmentData &&
-                                !(attachmentData as RxAttachmentWriteData).data
-                            ) {
-                                attachmentError = {
+                            if (!previousAttachmentData) {
+                                attachmentsAdd.push({
                                     documentId: docId,
-                                    documentInDb: documentInDb as any,
-                                    isError: true,
-                                    status: 510,
-                                    writeRow,
                                     attachmentId,
-                                    context
-                                };
-                            }
-                            return true;
-                        });
-                    if (!attachmentError) {
-                        Object
-                            .entries(document._attachments)
-                            .forEach(([attachmentId, attachmentData]) => {
-                                const previousAttachmentData = previous ? previous._attachments[attachmentId] : undefined;
-                                if (!previousAttachmentData) {
-                                    attachmentsAdd.push({
+                                    attachmentData: attachmentData as any,
+                                    digest: attachmentData.digest
+                                });
+                            } else {
+                                const newDigest = updatedRow.document._attachments[attachmentId].digest;
+                                if (
+                                    (attachmentData as RxAttachmentWriteData).data &&
+                                    /**
+                                     * Performance shortcut,
+                                     * do not update the attachment data if it did not change.
+                                     */
+                                    previousAttachmentData.digest !== newDigest
+                                ) {
+                                    attachmentsUpdate.push({
                                         documentId: docId,
                                         attachmentId,
-                                        attachmentData: attachmentData as any,
+                                        attachmentData: attachmentData as RxAttachmentWriteData,
                                         digest: attachmentData.digest
                                     });
-                                } else {
-                                    const newDigest = updatedRow.document._attachments[attachmentId].digest;
-                                    if (
-                                        (attachmentData as RxAttachmentWriteData).data &&
-                                        /**
-                                         * Performance shortcut,
-                                         * do not update the attachment data if it did not change.
-                                         */
-                                        previousAttachmentData.digest !== newDigest
-                                    ) {
-                                        attachmentsUpdate.push({
-                                            documentId: docId,
-                                            attachmentId,
-                                            attachmentData: attachmentData as RxAttachmentWriteData,
-                                            digest: attachmentData.digest
-                                        });
-                                    }
                                 }
-                            });
+                            }
+                        }
                     }
                 }
             }
@@ -413,16 +447,13 @@ export function categorizeBulkWriteRows<RxDocType>(
             if (attachmentError) {
                 errors.push(attachmentError);
             } else {
-                if (hasAttachments) {
-                    bulkUpdateDocs.push(stripAttachmentsDataFromRow(updatedRow));
-                    if (onUpdate) {
-                        onUpdate(document);
-                    }
-                } else {
-                    bulkUpdateDocs.push(updatedRow);
-                    if (onUpdate) {
-                        onUpdate(document);
-                    }
+                /**
+                 * updatedRow already has attachments stripped (line above),
+                 * so push it directly without stripping again.
+                 */
+                bulkUpdateDocs.push(updatedRow);
+                if (onUpdate) {
+                    onUpdate(document);
                 }
                 newestRow = updatedRow as any;
             }
@@ -433,10 +464,14 @@ export function categorizeBulkWriteRows<RxDocType>(
 
             if (previousDeleted && !documentDeleted) {
                 operation = 'INSERT';
-                eventDocumentData = hasAttachments ? stripAttachmentsDataFromDocument(document) : document as any;
+                /**
+                 * Reuse the already-stripped document from updatedRow
+                 * instead of calling stripAttachmentsDataFromDocument() again.
+                 */
+                eventDocumentData = hasAttachments ? updatedRow.document : document as any;
             } else if (previous && !previousDeleted && !documentDeleted) {
                 operation = 'UPDATE';
-                eventDocumentData = hasAttachments ? stripAttachmentsDataFromDocument(document) : document as any;
+                eventDocumentData = hasAttachments ? updatedRow.document : document as any;
                 previousEventDocumentData = previous;
             } else if (documentDeleted) {
                 operation = 'DELETE';
@@ -510,12 +545,13 @@ export function stripAttachmentsDataFromDocument<RxDocType>(doc: RxDocumentWrite
     }
 
     const useDoc: RxDocumentData<RxDocType> = flatClone(doc) as any;
-    useDoc._attachments = {};
-    Object
-        .entries(doc._attachments)
-        .forEach(([attachmentId, attachmentData]) => {
-            useDoc._attachments[attachmentId] = attachmentWriteDataToNormalData(attachmentData);
-        });
+    const destAtts: Record<string, RxAttachmentData> = {};
+    const attKeys = Object.keys(atts);
+    for (let i = 0; i < attKeys.length; i++) {
+        const attachmentId = attKeys[i];
+        destAtts[attachmentId] = attachmentWriteDataToNormalData(atts[attachmentId]);
+    }
+    useDoc._attachments = destAtts;
     return useDoc;
 }
 
@@ -528,13 +564,10 @@ export function stripAttachmentsDataFromDocument<RxDocType>(doc: RxDocumentWrite
 export function flatCloneDocWithMeta<RxDocType>(
     doc: RxDocumentData<RxDocType>
 ): RxDocumentData<RxDocType> {
-    return Object.assign(
-        {},
-        doc,
-        {
-            _meta: flatClone(doc._meta)
-        }
-    );
+    return {
+        ...doc,
+        _meta: { ...doc._meta }
+    } as any;
 }
 
 export type WrappedRxStorageInstance<RxDocumentType, Internals, InstanceCreationOptions> = RxStorageInstance<RxDocumentType, any, InstanceCreationOptions> & {
@@ -577,7 +610,6 @@ export function getWrappedStorageInstance<
             context: string
         ) {
             const databaseToken = database.token;
-            const toStorageWriteRows: BulkWriteRow<RxDocType>[] = new Array(rows.length);
             /**
              * Use the same timestamp for all docs of this rows-set.
              * This improves performance because calling Date.now() inside of the now() function
@@ -590,31 +622,70 @@ export function getWrappedStorageInstance<
              * inside the hot loop.
              */
             const firstRevision = '1-' + databaseToken;
-            for (let index = 0; index < rows.length; index++) {
-                const writeRow = rows[index];
-                const previous = writeRow.previous;
-                let document;
-                if (previous) {
-                    document = flatCloneDocWithMeta(writeRow.document);
-                    document._meta.lwt = time;
-                    document._rev = createRevision(
-                        databaseToken,
-                        previous
-                    );
-                } else {
-                    /**
-                     * Optimized insert path:
-                     * - Skip cloning _meta since we overwrite it entirely with { lwt: time }
-                     * - Use pre-computed firstRevision instead of calling createRevision()
-                     */
-                    document = flatClone(writeRow.document);
-                    document._meta = { lwt: time };
+            /**
+             * Share a single _meta object for all insert rows in this batch.
+             * All inserts in the same bulkWrite share the same timestamp,
+             * so we avoid creating a new { lwt: time } object per row.
+             * This shared reference is safe because:
+             * - All documents in one batch receive identical metadata values.
+             * - When a document is later updated, flatCloneDocWithMeta() creates
+             *   a new _meta object, so the shared reference is never mutated.
+             */
+            const insertMeta = { lwt: time };
+
+            /**
+             * When the caller has already cloned the documents (registered
+             * via MUTABLE_DOCUMENT_WRITE_CONTEXTS), we can mutate them
+             * in place and reuse the input array, avoiding redundant
+             * flatClone() and wrapper-object allocations on every insert row.
+             */
+            const isMutableContext = MUTABLE_DOCUMENT_WRITE_CONTEXTS.has(context);
+            let toStorageWriteRows: BulkWriteRow<RxDocType>[];
+
+            if (isMutableContext) {
+                /**
+                 * Fast path: documents are already cloned by the caller.
+                 * Set _meta/_rev directly on the document and reuse the
+                 * input rows array without allocating wrapper objects.
+                 */
+                for (let index = 0; index < rows.length; index++) {
+                    const document = rows[index].document;
+                    document._meta = insertMeta;
                     document._rev = firstRevision;
                 }
-                toStorageWriteRows[index] = {
-                    document,
-                    previous
-                };
+                toStorageWriteRows = rows;
+            } else {
+                toStorageWriteRows = new Array(rows.length);
+                for (let index = 0; index < rows.length; index++) {
+                    const writeRow = rows[index];
+                    const previous = writeRow.previous;
+                    let document;
+                    if (previous) {
+                        document = flatCloneDocWithMeta(writeRow.document);
+                        document._meta.lwt = time;
+                        document._rev = createRevision(
+                            databaseToken,
+                            previous
+                        );
+                    } else {
+                        /**
+                         * Insert path: flatClone is required because the input document
+                         * may be a direct reference to another storage's internal data
+                         * (e.g., during migration, query results from the old storage are
+                         * passed directly as insert rows to the new storage).
+                         *
+                         * Use a shared insertMeta object instead of allocating { lwt: time }
+                         * per row, since all inserts in the same batch share the same timestamp.
+                         */
+                        document = flatClone(writeRow.document);
+                        document._meta = insertMeta;
+                        document._rev = firstRevision;
+                    }
+                    toStorageWriteRows[index] = {
+                        document,
+                        previous
+                    };
+                }
             }
 
             if (HOOKS.preStorageWrite.length > 0) {

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

@@ -28,6 +28,7 @@ export interface RxErrorParameters {
     readonly rootPath?: string;
     readonly childpath?: string;
     readonly ids?: string[];
+    readonly duplicateIds?: string[];
     readonly obj?: any;
     readonly document?: any;
     readonly schema?: Readonly<RxJsonSchema<any> | RxSchema>;
@@ -71,6 +72,8 @@ export interface RxErrorParameters {
     readonly passwordHash?: string;
     readonly existingPasswordHash?: string;
     readonly password?: string | any;
+    readonly passwordType?: string;
+    readonly passwordLength?: number;
     readonly minPassLength?: number;
     readonly own?: any;
     readonly source?: any;

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

@@ -50,6 +50,11 @@ export type JsonSchema<RxDocType = any> = {
     maxProperties?: number;
     maximum?: number;
     minimum?: number;
+    /**
+     * Having a large maxLength for indexed fields and primary keys can negatively
+     * impact performance on many storages. Therefore, you should only set it
+     * as big as needed.
+     */
     maxLength?: number;
     minLength?: number;
     maxItems?: number;

package/dist/esm/package.json

@@ -1 +0,0 @@
-{ "type": "module", "sideEffects": false }

package/dist/types/types/conflict-handling.d.ts

@@ -1,48 +0,0 @@
-import type { WithDeleted } from './rx-storage.d.ts';
-
-/**
- * Notice that the conflict handler input/output
- * does not work on RxDocumentData<RxDocType>, but only on WithDeleted<RxDocType>.
- * This is because the _meta attributes are meant for the local storing of document data, they not replicated
- * and therefore cannot be used to resolve conflicts.
- */
-export type RxConflictHandlerInput<RxDocType> = {
-    assumedMasterState?: WithDeleted<RxDocType>;
-    realMasterState: WithDeleted<RxDocType>;
-    newDocumentState: WithDeleted<RxDocType>;
-};
-
-/**
- * The conflict handler either returns:
- * - The resolved new document state
- * - A flag to identify the given 'realMasterState' and 'newDocumentState'
- *   as being exactly equal, so no conflict has to be resolved.
- */
-export type RxConflictHandlerOutput<RxDocType> = {
-    isEqual: false;
-    documentData: WithDeleted<RxDocType>;
-} | {
-    isEqual: true;
-};
-
-export type RxConflictHandlerOld<RxDocType> = (
-    i: RxConflictHandlerInput<RxDocType>,
-    context: string
-) => Promise<RxConflictHandlerOutput<RxDocType>>;
-
-
-export type RxConflictHandler<RxDocType> = {
-    /**
-     * This must be non-async
-     * because it will be called very often and must be fast.
-     */
-    isEqual: (
-        a: WithDeleted<RxDocType>,
-        b: WithDeleted<RxDocType>,
-        context: string
-    ) => boolean;
-    resolve: (
-        i: RxConflictHandlerInput<RxDocType>,
-        context: string
-    ) => Promise<WithDeleted<RxDocType>>;
-};