@connecttomahdi/rxdb 17.0.0-beta.17 → 17.1.0

package/dist/cjs/rx-storage-helper.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.RX_DATABASE_LOCAL_DOCS_STORAGE_NAME = exports.INTERNAL_STORAGE_NAME = void 0;
+exports.RX_DATABASE_LOCAL_DOCS_STORAGE_NAME = exports.RX_COLLECTION_BULK_INSERT_CONTEXT = exports.INTERNAL_STORAGE_NAME = void 0;
 exports.attachmentWriteDataToNormalData = attachmentWriteDataToNormalData;
 exports.categorizeBulkWriteRows = categorizeBulkWriteRows;
 exports.ensureRxStorageInstanceParamsAreCorrect = ensureRxStorageInstanceParamsAreCorrect;
@@ -16,6 +16,7 @@ exports.getWrittenDocumentsFromBulkWriteResponse = getWrittenDocumentsFromBulkWr
 exports.hasEncryption = hasEncryption;
 exports.observeSingle = observeSingle;
 exports.randomDelayStorage = randomDelayStorage;
+exports.registerMutableWriteContext = registerMutableWriteContext;
 exports.stackCheckpoints = stackCheckpoints;
 exports.stripAttachmentsDataFromDocument = stripAttachmentsDataFromDocument;
 exports.stripAttachmentsDataFromRow = stripAttachmentsDataFromRow;
@@ -24,7 +25,7 @@ exports.writeSingle = writeSingle;
 var _overwritable = require("./overwritable.js");
 var _rxError = require("./rx-error.js");
 var _rxSchemaHelper = require("./rx-schema-helper.js");
-var _index3 = require("./plugins/utils/index.js");
+var _index4 = require("./plugins/utils/index.js");
 var _rxjs = require("rxjs");
 var _rxQueryHelper = require("./rx-query-helper.js");
 var _hooks = require("./hooks.js");
@@ -34,6 +35,35 @@ var _hooks = require("./hooks.js");
 
 var INTERNAL_STORAGE_NAME = exports.INTERNAL_STORAGE_NAME = '_rxdb_internal';
 var RX_DATABASE_LOCAL_DOCS_STORAGE_NAME = exports.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.
+ */
+var RX_COLLECTION_BULK_INSERT_CONTEXT = exports.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().
+ */
+var MUTABLE_DOCUMENT_WRITE_CONTEXTS = 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.
+ */
+function registerMutableWriteContext(context) {
+  MUTABLE_DOCUMENT_WRITE_CONTEXTS.add(context);
+}
 async function getSingleDocument(storageInstance, documentId) {
   var results = await storageInstance.findDocumentsById([documentId], false);
   var doc = results[0];
@@ -67,7 +97,7 @@ async function writeSingle(instance, writeRow, context) {
  */
 function observeSingle(storageInstance, documentId) {
   var firstFindPromise = getSingleDocument(storageInstance, documentId);
-  var ret = storageInstance.changeStream().pipe((0, _rxjs.map)(evBulk => evBulk.events.find(ev => ev.documentId === documentId)), (0, _rxjs.filter)(ev => !!ev), (0, _rxjs.map)(ev => Promise.resolve((0, _index3.ensureNotFalsy)(ev).documentData)), (0, _rxjs.startWith)(firstFindPromise), (0, _rxjs.switchMap)(v => v), (0, _rxjs.filter)(v => !!v));
+  var ret = storageInstance.changeStream().pipe((0, _rxjs.map)(evBulk => evBulk.events.find(ev => ev.documentId === documentId)), (0, _rxjs.filter)(ev => !!ev), (0, _rxjs.map)(ev => Promise.resolve((0, _index4.ensureNotFalsy)(ev).documentData)), (0, _rxjs.startWith)(firstFindPromise), (0, _rxjs.switchMap)(v => v), (0, _rxjs.filter)(v => !!v));
   return ret;
 }
 
@@ -106,7 +136,7 @@ function throwIfIsStorageWriteError(collection, documentId, writeData, error) {
  * Use a counter-based event bulk ID instead of randomToken()
  * for better performance. The prefix ensures uniqueness across instances.
  */
-var EVENT_BULK_ID_PREFIX = (0, _index3.randomToken)(10);
+var EVENT_BULK_ID_PREFIX = (0, _index4.randomToken)(10);
 var eventBulkCounter = 0;
 function nextEventBulkId() {
   return EVENT_BULK_ID_PREFIX + ++eventBulkCounter;
@@ -160,7 +190,7 @@ onInsert, onUpdate) {
    * @performance is really important in this loop!
    */
   var rowAmount = bulkWriteRows.length;
-  var _loop = function () {
+  for (var rowId = 0; rowId < rowAmount; rowId++) {
     var writeRow = bulkWriteRows[rowId];
 
     // use these variables to have less property accesses
@@ -173,15 +203,18 @@ onInsert, onUpdate) {
     if (hasDocsInDb) {
       documentInDb = docsInDb.get(docId);
     }
-    var attachmentError;
+    var attachmentError = void 0;
     if (!documentInDb) {
       /**
        * It is possible to insert already deleted documents,
        * this can happen on replication.
        */
-      var insertedIsDeleted = documentDeleted ? true : false;
       if (hasAttachments) {
-        Object.entries(document._attachments).forEach(([attachmentId, attachmentData]) => {
+        var atts = document._attachments;
+        var attKeys = Object.keys(atts);
+        for (var a = 0; a < attKeys.length; a++) {
+          var attachmentId = attKeys[a];
+          var attachmentData = atts[attachmentId];
           if (!attachmentData.data) {
             attachmentError = {
               documentId: docId,
@@ -200,27 +233,27 @@ onInsert, onUpdate) {
               digest: attachmentData.digest
             });
           }
-        });
+        }
       }
+      var insertedRow = void 0;
       if (!attachmentError) {
-        if (hasAttachments) {
-          bulkInsertDocs.push(stripAttachmentsDataFromRow(writeRow));
-          if (onInsert) {
-            onInsert(document);
-          }
-        } else {
-          bulkInsertDocs.push(writeRow);
-          if (onInsert) {
-            onInsert(document);
-          }
+        var row = hasAttachments ? stripAttachmentsDataFromRow(writeRow) : writeRow;
+        insertedRow = row;
+        bulkInsertDocs.push(row);
+        if (onInsert) {
+          onInsert(document);
         }
-        newestRow = writeRow;
+        newestRow = row;
       }
-      if (!insertedIsDeleted) {
+      if (!documentDeleted) {
+        var eventDocData = document;
+        if (hasAttachments) {
+          eventDocData = insertedRow ? insertedRow.document : stripAttachmentsDataFromDocument(document);
+        }
         var event = {
           documentId: docId,
           operation: 'INSERT',
-          documentData: hasAttachments ? stripAttachmentsDataFromDocument(document) : document,
+          documentData: eventDocData,
           previousDocumentData: hasAttachments && previous ? stripAttachmentsDataFromDocument(previous) : previous
         };
         eventBulkEvents.push(event);
@@ -243,7 +276,7 @@ onInsert, onUpdate) {
           context
         };
         errors.push(err);
-        return 1; // continue
+        continue;
       }
 
       // handle attachments data
@@ -255,90 +288,100 @@ onInsert, onUpdate) {
            * Deleted documents must have cleared all their attachments.
            */
           if (previous) {
-            Object.keys(previous._attachments).forEach(attachmentId => {
+            var prevAtts = previous._attachments;
+            var prevAttKeys = Object.keys(prevAtts);
+            for (var _a = 0; _a < prevAttKeys.length; _a++) {
+              var _attachmentId = prevAttKeys[_a];
               attachmentsRemove.push({
                 documentId: docId,
-                attachmentId,
-                digest: (0, _index3.ensureNotFalsy)(previous)._attachments[attachmentId].digest
+                attachmentId: _attachmentId,
+                digest: prevAtts[_attachmentId].digest
               });
-            });
+            }
           }
         } else {
           // first check for errors
-          Object.entries(document._attachments).find(([attachmentId, attachmentData]) => {
-            var previousAttachmentData = previous ? previous._attachments[attachmentId] : undefined;
-            if (!previousAttachmentData && !attachmentData.data) {
+          var docAtts = document._attachments;
+          var docAttKeys = Object.keys(docAtts);
+          for (var _a2 = 0; _a2 < docAttKeys.length; _a2++) {
+            var _attachmentId2 = docAttKeys[_a2];
+            var _attachmentData = docAtts[_attachmentId2];
+            var previousAttachmentData = previous ? previous._attachments[_attachmentId2] : undefined;
+            if (!previousAttachmentData && !_attachmentData.data) {
               attachmentError = {
                 documentId: docId,
                 documentInDb: documentInDb,
                 isError: true,
                 status: 510,
                 writeRow,
-                attachmentId,
+                attachmentId: _attachmentId2,
                 context
               };
+              break;
             }
-            return true;
-          });
+          }
           if (!attachmentError) {
-            Object.entries(document._attachments).forEach(([attachmentId, attachmentData]) => {
-              var previousAttachmentData = previous ? previous._attachments[attachmentId] : undefined;
-              if (!previousAttachmentData) {
+            for (var _a3 = 0; _a3 < docAttKeys.length; _a3++) {
+              var _attachmentId3 = docAttKeys[_a3];
+              var _attachmentData2 = docAtts[_attachmentId3];
+              var _previousAttachmentData = previous ? previous._attachments[_attachmentId3] : undefined;
+              if (!_previousAttachmentData) {
                 attachmentsAdd.push({
                   documentId: docId,
-                  attachmentId,
-                  attachmentData: attachmentData,
-                  digest: attachmentData.digest
+                  attachmentId: _attachmentId3,
+                  attachmentData: _attachmentData2,
+                  digest: _attachmentData2.digest
                 });
               } else {
-                var newDigest = updatedRow.document._attachments[attachmentId].digest;
-                if (attachmentData.data &&
+                var newDigest = updatedRow.document._attachments[_attachmentId3].digest;
+                if (_attachmentData2.data &&
                 /**
                  * Performance shortcut,
                  * do not update the attachment data if it did not change.
                  */
-                previousAttachmentData.digest !== newDigest) {
+                _previousAttachmentData.digest !== newDigest) {
                   attachmentsUpdate.push({
                     documentId: docId,
-                    attachmentId,
-                    attachmentData: attachmentData,
-                    digest: attachmentData.digest
+                    attachmentId: _attachmentId3,
+                    attachmentData: _attachmentData2,
+                    digest: _attachmentData2.digest
                   });
                 }
               }
-            });
+            }
           }
         }
       }
       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;
       }
-      var eventDocumentData;
+      var eventDocumentData = void 0;
       var previousEventDocumentData = null;
-      var operation;
+      var operation = void 0;
       if (previousDeleted && !documentDeleted) {
         operation = 'INSERT';
-        eventDocumentData = hasAttachments ? stripAttachmentsDataFromDocument(document) : document;
+        /**
+         * Reuse the already-stripped document from updatedRow
+         * instead of calling stripAttachmentsDataFromDocument() again.
+         */
+        eventDocumentData = hasAttachments ? updatedRow.document : document;
       } else if (previous && !previousDeleted && !documentDeleted) {
         operation = 'UPDATE';
-        eventDocumentData = hasAttachments ? stripAttachmentsDataFromDocument(document) : document;
+        eventDocumentData = hasAttachments ? updatedRow.document : document;
         previousEventDocumentData = previous;
       } else if (documentDeleted) {
         operation = 'DELETE';
-        eventDocumentData = (0, _index3.ensureNotFalsy)(document);
+        eventDocumentData = (0, _index4.ensureNotFalsy)(document);
         previousEventDocumentData = previous;
       } else {
         throw (0, _rxError.newRxError)('SNH', {
@@ -355,9 +398,6 @@ onInsert, onUpdate) {
       };
       eventBulkEvents.push(_event);
     }
-  };
-  for (var rowId = 0; rowId < rowAmount; rowId++) {
-    if (_loop()) continue;
   }
   return {
     bulkInsertDocs,
@@ -409,11 +449,14 @@ function stripAttachmentsDataFromDocument(doc) {
   if (!hasAnyAttachment) {
     return doc;
   }
-  var useDoc = (0, _index3.flatClone)(doc);
-  useDoc._attachments = {};
-  Object.entries(doc._attachments).forEach(([attachmentId, attachmentData]) => {
-    useDoc._attachments[attachmentId] = attachmentWriteDataToNormalData(attachmentData);
-  });
+  var useDoc = (0, _index4.flatClone)(doc);
+  var destAtts = {};
+  var attKeys = Object.keys(atts);
+  for (var i = 0; i < attKeys.length; i++) {
+    var attachmentId = attKeys[i];
+    destAtts[attachmentId] = attachmentWriteDataToNormalData(atts[attachmentId]);
+  }
+  useDoc._attachments = destAtts;
   return useDoc;
 }
 
@@ -424,9 +467,12 @@ function stripAttachmentsDataFromDocument(doc) {
  * during replication etc.
  */
 function flatCloneDocWithMeta(doc) {
-  return Object.assign({}, doc, {
-    _meta: (0, _index3.flatClone)(doc._meta)
-  });
+  return {
+    ...doc,
+    _meta: {
+      ...doc._meta
+    }
+  };
 }
 /**
  * Wraps the normal storageInstance of a RxCollection
@@ -451,43 +497,80 @@ rxJsonSchema) {
     options: storageInstance.options,
     async bulkWrite(rows, context) {
       var databaseToken = database.token;
-      var toStorageWriteRows = 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
        * is too costly.
        */
-      var time = (0, _index3.now)();
+      var time = (0, _index4.now)();
       /**
        * Pre-compute the first revision string for inserts (no previous document).
        * This avoids repeated string concatenation and getHeightOfRevision() calls
        * inside the hot loop.
        */
       var firstRevision = '1-' + databaseToken;
-      for (var index = 0; index < rows.length; index++) {
-        var writeRow = rows[index];
-        var previous = writeRow.previous;
-        var document = void 0;
-        if (previous) {
-          document = flatCloneDocWithMeta(writeRow.document);
-          document._meta.lwt = time;
-          document._rev = (0, _index3.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 = (0, _index3.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.
+       */
+      var 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.
+       */
+      var isMutableContext = MUTABLE_DOCUMENT_WRITE_CONTEXTS.has(context);
+      var toStorageWriteRows;
+      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 (var index = 0; index < rows.length; index++) {
+          var document = rows[index].document;
+          document._meta = insertMeta;
           document._rev = firstRevision;
         }
-        toStorageWriteRows[index] = {
-          document,
-          previous
-        };
+        toStorageWriteRows = rows;
+      } else {
+        toStorageWriteRows = new Array(rows.length);
+        for (var _index = 0; _index < rows.length; _index++) {
+          var writeRow = rows[_index];
+          var previous = writeRow.previous;
+          var _document = void 0;
+          if (previous) {
+            _document = flatCloneDocWithMeta(writeRow.document);
+            _document._meta.lwt = time;
+            _document._rev = (0, _index4.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 = (0, _index4.flatClone)(writeRow.document);
+            _document._meta = insertMeta;
+            _document._rev = firstRevision;
+          }
+          toStorageWriteRows[_index] = {
+            document: _document,
+            previous
+          };
+        }
       }
       if (_hooks.HOOKS.preStorageWrite.length > 0) {
         (0, _hooks.runPluginHooks)('preStorageWrite', {
@@ -522,7 +605,7 @@ rxJsonSchema) {
       // No need to check writeResult.error.length === 0 here because
       // the fast path above already returns early when there are no errors.
       var reInsertErrors = writeResult.error.filter(error => {
-        if (error.status === 409 && !error.writeRow.previous && !error.writeRow.document._deleted && (0, _index3.ensureNotFalsy)(error.documentInDb)._deleted) {
+        if (error.status === 409 && !error.writeRow.previous && !error.writeRow.document._deleted && (0, _index4.ensureNotFalsy)(error.documentInDb)._deleted) {
           return true;
         }
 
@@ -537,7 +620,7 @@ rxJsonSchema) {
           return {
             previous: error.documentInDb,
             document: Object.assign({}, error.writeRow.document, {
-              _rev: (0, _index3.createRevision)(database.token, error.documentInDb)
+              _rev: (0, _index4.createRevision)(database.token, error.documentInDb)
             })
           };
         });
@@ -563,7 +646,7 @@ rxJsonSchema) {
       return database.lockedRun(() => storageInstance.getAttachmentData(documentId, attachmentId, digest));
     },
     getChangedDocumentsSince: !storageInstance.getChangedDocumentsSince ? undefined : (limit, checkpoint) => {
-      return database.lockedRun(() => storageInstance.getChangedDocumentsSince((0, _index3.ensureNotFalsy)(limit), checkpoint));
+      return database.lockedRun(() => storageInstance.getChangedDocumentsSince((0, _index4.ensureNotFalsy)(limit), checkpoint));
     },
     cleanup(minDeletedTime) {
       return database.lockedRun(() => storageInstance.cleanup(minDeletedTime));
@@ -621,7 +704,7 @@ function hasEncryption(jsonSchema) {
 }
 function getChangedDocumentsSinceQuery(storageInstance, limit, checkpoint) {
   var primaryPath = (0, _rxSchemaHelper.getPrimaryFieldOfPrimaryKey)(storageInstance.schema.primaryKey);
-  var sinceLwt = checkpoint ? checkpoint.lwt : _index3.RX_META_LWT_MINIMUM;
+  var sinceLwt = checkpoint ? checkpoint.lwt : _index4.RX_META_LWT_MINIMUM;
   var sinceId = checkpoint ? checkpoint.id : '';
   return (0, _rxQueryHelper.normalizeMangoQuery)(storageInstance.schema, {
     selector: {
@@ -667,7 +750,7 @@ async function getChangedDocumentsSince(storageInstance, limit, checkpoint) {
   var query = (0, _rxQueryHelper.prepareQuery)(storageInstance.schema, getChangedDocumentsSinceQuery(storageInstance, limit, checkpoint));
   var result = await storageInstance.query(query);
   var documents = result.documents;
-  var lastDoc = (0, _index3.lastOfArray)(documents);
+  var lastDoc = (0, _index4.lastOfArray)(documents);
   return {
     documents: documents,
     checkpoint: lastDoc ? {
@@ -687,7 +770,7 @@ var BULK_WRITE_SUCCESS_MAP = new WeakMap();
  * because most of the time we do not need the results, only the errors.
  */
 function getWrittenDocumentsFromBulkWriteResponse(primaryPath, writeRows, response, reInsertIds) {
-  return (0, _index3.getFromMapOrCreate)(BULK_WRITE_SUCCESS_MAP, response, () => {
+  return (0, _index4.getFromMapOrCreate)(BULK_WRITE_SUCCESS_MAP, response, () => {
     var ret = [];
     var realWriteRows = BULK_WRITE_ROWS_BY_RESPONSE.get(response);
     if (!realWriteRows) {
@@ -699,8 +782,8 @@ function getWrittenDocumentsFromBulkWriteResponse(primaryPath, writeRows, respon
         var error = response.error[index];
         errorIds.add(error.documentId);
       }
-      for (var _index = 0; _index < realWriteRows.length; _index++) {
-        var doc = realWriteRows[_index].document;
+      for (var _index2 = 0; _index2 < realWriteRows.length; _index2++) {
+        var doc = realWriteRows[_index2].document;
         if (!errorIds.has(doc[primaryPath])) {
           ret.push(stripAttachmentsDataFromDocument(doc));
         }
@@ -708,9 +791,9 @@ function getWrittenDocumentsFromBulkWriteResponse(primaryPath, writeRows, respon
     } else {
       // pre-set array size for better performance
       ret.length = writeRows.length - response.error.length;
-      for (var _index2 = 0; _index2 < realWriteRows.length; _index2++) {
-        var _doc = realWriteRows[_index2].document;
-        ret[_index2] = stripAttachmentsDataFromDocument(_doc);
+      for (var _index3 = 0; _index3 < realWriteRows.length; _index3++) {
+        var _doc = realWriteRows[_index3].document;
+        ret[_index3] = stripAttachmentsDataFromDocument(_doc);
       }
     }
     return ret;
@@ -726,14 +809,14 @@ function randomDelayStorage(input) {
    * Ensure writes to a delay storage
    * are still correctly run in order.
    */
-  var randomDelayStorageWriteQueue = _index3.PROMISE_RESOLVE_TRUE;
+  var randomDelayStorageWriteQueue = _index4.PROMISE_RESOLVE_TRUE;
   var retStorage = {
     name: 'random-delay-' + input.storage.name,
-    rxdbVersion: _index3.RXDB_VERSION,
+    rxdbVersion: _index4.RXDB_VERSION,
     async createStorageInstance(params) {
-      await (0, _index3.promiseWait)(input.delayTimeBefore());
+      await (0, _index4.promiseWait)(input.delayTimeBefore());
       var storageInstance = await input.storage.createStorageInstance(params);
-      await (0, _index3.promiseWait)(input.delayTimeAfter());
+      await (0, _index4.promiseWait)(input.delayTimeAfter());
       return {
         databaseName: storageInstance.databaseName,
         internals: storageInstance.internals,
@@ -742,62 +825,62 @@ function randomDelayStorage(input) {
         collectionName: storageInstance.collectionName,
         bulkWrite(a, b) {
           randomDelayStorageWriteQueue = randomDelayStorageWriteQueue.then(async () => {
-            await (0, _index3.promiseWait)(input.delayTimeBefore());
+            await (0, _index4.promiseWait)(input.delayTimeBefore());
             var response = await storageInstance.bulkWrite(a, b);
-            await (0, _index3.promiseWait)(input.delayTimeAfter());
+            await (0, _index4.promiseWait)(input.delayTimeAfter());
             return response;
           });
           var ret = randomDelayStorageWriteQueue;
           return ret;
         },
         async findDocumentsById(a, b) {
-          await (0, _index3.promiseWait)(input.delayTimeBefore());
+          await (0, _index4.promiseWait)(input.delayTimeBefore());
           var ret = await storageInstance.findDocumentsById(a, b);
-          await (0, _index3.promiseWait)(input.delayTimeAfter());
+          await (0, _index4.promiseWait)(input.delayTimeAfter());
           return ret;
         },
         async query(a) {
-          await (0, _index3.promiseWait)(input.delayTimeBefore());
+          await (0, _index4.promiseWait)(input.delayTimeBefore());
           var ret = await storageInstance.query(a);
           return ret;
         },
         async count(a) {
-          await (0, _index3.promiseWait)(input.delayTimeBefore());
+          await (0, _index4.promiseWait)(input.delayTimeBefore());
           var ret = await storageInstance.count(a);
-          await (0, _index3.promiseWait)(input.delayTimeAfter());
+          await (0, _index4.promiseWait)(input.delayTimeAfter());
           return ret;
         },
         async getAttachmentData(a, b, c) {
-          await (0, _index3.promiseWait)(input.delayTimeBefore());
+          await (0, _index4.promiseWait)(input.delayTimeBefore());
           var ret = await storageInstance.getAttachmentData(a, b, c);
-          await (0, _index3.promiseWait)(input.delayTimeAfter());
+          await (0, _index4.promiseWait)(input.delayTimeAfter());
           return ret;
         },
         getChangedDocumentsSince: !storageInstance.getChangedDocumentsSince ? undefined : async (a, b) => {
-          await (0, _index3.promiseWait)(input.delayTimeBefore());
-          var ret = await (0, _index3.ensureNotFalsy)(storageInstance.getChangedDocumentsSince)(a, b);
-          await (0, _index3.promiseWait)(input.delayTimeAfter());
+          await (0, _index4.promiseWait)(input.delayTimeBefore());
+          var ret = await (0, _index4.ensureNotFalsy)(storageInstance.getChangedDocumentsSince)(a, b);
+          await (0, _index4.promiseWait)(input.delayTimeAfter());
           return ret;
         },
         changeStream() {
           return storageInstance.changeStream();
         },
         async cleanup(a) {
-          await (0, _index3.promiseWait)(input.delayTimeBefore());
+          await (0, _index4.promiseWait)(input.delayTimeBefore());
           var ret = await storageInstance.cleanup(a);
-          await (0, _index3.promiseWait)(input.delayTimeAfter());
+          await (0, _index4.promiseWait)(input.delayTimeAfter());
           return ret;
         },
         async close() {
-          await (0, _index3.promiseWait)(input.delayTimeBefore());
+          await (0, _index4.promiseWait)(input.delayTimeBefore());
           var ret = await storageInstance.close();
-          await (0, _index3.promiseWait)(input.delayTimeAfter());
+          await (0, _index4.promiseWait)(input.delayTimeAfter());
           return ret;
         },
         async remove() {
-          await (0, _index3.promiseWait)(input.delayTimeBefore());
+          await (0, _index4.promiseWait)(input.delayTimeBefore());
           var ret = await storageInstance.remove();
-          await (0, _index3.promiseWait)(input.delayTimeAfter());
+          await (0, _index4.promiseWait)(input.delayTimeAfter());
           return ret;
         }
       };