@fluidframework/map 2.0.0-dev.4.4.0.162574 → 2.0.0-dev.5.3.2.178189

package/lib/directory.js

@@ -349,7 +349,11 @@ export class SharedDirectory extends SharedObject {
                     let newSubDir = currentSubDir.getSubDirectory(subdirName);
                     if (!newSubDir) {
                         const createInfo = subdirObject.ci;
-                        newSubDir = new SubDirectory(createInfo !== undefined ? createInfo.csn : 0, createInfo !== undefined
+                        newSubDir = new SubDirectory(
+                        // If csn is -1, then initialize it with 0, otherwise we will never process ops for this
+                        // sub directory. This could be done at serialization time too, but we need to maintain
+                        // back compat too and also we will actually know the state when it was serialized.
+                        createInfo !== undefined && createInfo.csn > -1 ? createInfo.csn : 0, createInfo !== undefined
                             ? new Set(createInfo.ccIds)
                             : new Set(), this, this.runtime, this.serializer, posix.join(currentSubDir.absolutePath, subdirName));
                         currentSubDir.populateSubDirectory(subdirName, newSubDir);
@@ -637,16 +641,12 @@ function isClearLocalOpMetadata(metadata) {
 }
 function isSubDirLocalOpMetadata(metadata) {
     return (metadata !== undefined &&
-        typeof metadata.pendingMessageId === "number" &&
         (metadata.type === "createSubDir" || metadata.type === "deleteSubDir"));
 }
 function isDirectoryLocalOpMetadata(metadata) {
-    return (metadata !== undefined &&
-        typeof metadata.pendingMessageId === "number" &&
-        (metadata.type === "edit" ||
-            metadata.type === "deleteSubDir" ||
-            (metadata.type === "clear" && typeof metadata.previousStorage === "object") ||
-            metadata.type === "createSubDir"));
+    return (isKeyEditLocalOpMetadata(metadata) ||
+        isClearLocalOpMetadata(metadata) ||
+        isSubDirLocalOpMetadata(metadata));
 }
 /* eslint-enable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access */
 function assertNonNullClientId(clientId) {
@@ -691,18 +691,24 @@ class SubDirectory extends TypedEventEmitter {
          */
         this._subdirectories = new Map();
         /**
-         * Keys that have been modified locally but not yet ack'd from the server.
+         * Keys that have been modified locally but not yet ack'd from the server. This is for operations on keys like
+         * set/delete operations on keys. The value of this map is list of pendingMessageIds at which that key
+         * was modified. We don't store the type of ops, and behaviour of key ops are different from behaviour of sub
+         * directory ops, so we have separate map from subDirectories tracker.
          */
         this.pendingKeys = new Map();
         /**
-         * Subdirectories that have been created/deleted locally but not yet ack'd from the server.
+         * Subdirectories that have been deleted locally but not yet ack'd from the server. This maintains the record
+         * of delete op that are pending or yet to be acked from server. This is maintained just to track the locally
+         * deleted sub directory.
          */
-        this.pendingSubDirectories = new Map();
+        this.pendingDeleteSubDirectoriesTracker = new Map();
         /**
-         * Subdirectories that have been deleted locally but not yet ack'd from the server. This maintains the count
-         * of delete op that are pending or yet to be acked from server.
+         * Subdirectories that have been created locally but not yet ack'd from the server. This maintains the record
+         * of create op that are pending or yet to be acked from server. This is maintained just to track the locally
+         * created sub directory.
          */
-        this.pendingDeleteSubDirectoriesCount = new Map();
+        this.pendingCreateSubDirectoriesTracker = new Map();
         /**
          * This is used to assign a unique id to every outgoing operation and helps in tracking unack'd ops.
          */
@@ -869,8 +875,7 @@ class SubDirectory extends TypedEventEmitter {
      * @returns - true if there is pending delete.
      */
     isSubDirectoryDeletePending(subDirName) {
-        const pendingDeleteSubDirectory = this.pendingDeleteSubDirectoriesCount.get(subDirName);
-        if (pendingDeleteSubDirectory !== undefined && pendingDeleteSubDirectory > 0) {
+        if (this.pendingDeleteSubDirectoriesTracker.has(subDirName)) {
             return true;
         }
         return false;
@@ -1110,7 +1115,8 @@ class SubDirectory extends TypedEventEmitter {
      */
     processCreateSubDirectoryMessage(msg, op, local, localOpMetadata) {
         this.throwIfDisposed();
-        if (!this.needProcessSubDirectoryOperation(msg, op, local, localOpMetadata)) {
+        if (!(this.isMessageForCurrentInstanceOfSubDirectory(msg) &&
+            this.needProcessSubDirectoryOperation(msg, op, local, localOpMetadata))) {
             return;
         }
         assertNonNullClientId(msg.clientId);
@@ -1126,10 +1132,9 @@ class SubDirectory extends TypedEventEmitter {
         this.throwIfDisposed();
         // Create the sub directory locally first.
         this.createSubDirectoryCore(op.subdirName, true, -1, (_c = this.runtime.clientId) !== null && _c !== void 0 ? _c : "detached");
-        const newMessageId = this.getSubDirMessageId(op);
+        this.updatePendingSubDirMessageCount(op);
         const localOpMetadata = {
             type: "createSubDir",
-            pendingMessageId: newMessageId,
         };
         return localOpMetadata;
     }
@@ -1158,10 +1163,9 @@ class SubDirectory extends TypedEventEmitter {
     applyStashedDeleteSubDirMessage(op) {
         this.throwIfDisposed();
         const subDir = this.deleteSubDirectoryCore(op.subdirName, true);
-        const newMessageId = this.getSubDirMessageId(op);
+        this.updatePendingSubDirMessageCount(op);
         const metadata = {
             type: "deleteSubDir",
-            pendingMessageId: newMessageId,
             subDirectory: subDir,
         };
         return metadata;
@@ -1190,8 +1194,11 @@ class SubDirectory extends TypedEventEmitter {
         assert(isClearLocalOpMetadata(localOpMetadata), 0x32b /* Invalid localOpMetadata for clear */);
         // We don't reuse the metadata pendingMessageId but send a new one on each submit.
         const pendingClearMessageId = this.pendingClearMessageIds.shift();
-        assert(pendingClearMessageId === localOpMetadata.pendingMessageId, 0x32c /* pendingMessageId does not match */);
-        this.submitClearMessage(op, localOpMetadata.previousStorage);
+        // Only submit the op, if we have record for it, otherwise it is possible that the older instance
+        // is already deleted, in which case we don't need to submit the op.
+        if (pendingClearMessageId === localOpMetadata.pendingMessageId) {
+            this.submitClearMessage(op, localOpMetadata.previousStorage);
+        }
     }
     /**
      * Get a new pending message id for the op and cache it to track the pending op
@@ -1229,33 +1236,41 @@ class SubDirectory extends TypedEventEmitter {
         assert(isKeyEditLocalOpMetadata(localOpMetadata), 0x32d /* Invalid localOpMetadata in submit */);
         // clear the old pending message id
         const pendingMessageIds = this.pendingKeys.get(op.key);
-        assert(pendingMessageIds !== undefined &&
-            pendingMessageIds[0] === localOpMetadata.pendingMessageId, 0x32e /* Unexpected pending message received */);
-        pendingMessageIds.shift();
-        if (pendingMessageIds.length === 0) {
-            this.pendingKeys.delete(op.key);
+        // Only submit the op, if we have record for it, otherwise it is possible that the older instance
+        // is already deleted, in which case we don't need to submit the op.
+        if (pendingMessageIds !== undefined &&
+            pendingMessageIds[0] === localOpMetadata.pendingMessageId) {
+            pendingMessageIds.shift();
+            if (pendingMessageIds.length === 0) {
+                this.pendingKeys.delete(op.key);
+            }
+            this.submitKeyMessage(op, localOpMetadata.previousValue);
         }
-        this.submitKeyMessage(op, localOpMetadata.previousValue);
     }
-    /**
-     * Get a new pending message id for the op and cache it to track the pending op
-     */
-    getSubDirMessageId(op) {
+    incrementPendingSubDirCount(map, subDirName) {
         var _c;
-        // We don't reuse the metadata pendingMessageId but send a new one on each submit.
-        const newMessageId = ++this.pendingMessageId;
-        const pendingMessageIds = this.pendingSubDirectories.get(op.subdirName);
-        if (pendingMessageIds !== undefined) {
-            pendingMessageIds.push(newMessageId);
-        }
-        else {
-            this.pendingSubDirectories.set(op.subdirName, [newMessageId]);
+        const count = (_c = map.get(subDirName)) !== null && _c !== void 0 ? _c : 0;
+        map.set(subDirName, count + 1);
+    }
+    decrementPendingSubDirCount(map, subDirName) {
+        var _c;
+        const count = (_c = map.get(subDirName)) !== null && _c !== void 0 ? _c : 0;
+        map.set(subDirName, count - 1);
+        if (count <= 1) {
+            map.delete(subDirName);
         }
+    }
+    /**
+     * Update the count for pending create/delete of the sub directory so that it can be validated on receiving op
+     * or while resubmitting the op.
+     */
+    updatePendingSubDirMessageCount(op) {
         if (op.type === "deleteSubDirectory") {
-            const count = (_c = this.pendingDeleteSubDirectoriesCount.get(op.subdirName)) !== null && _c !== void 0 ? _c : 0;
-            this.pendingDeleteSubDirectoriesCount.set(op.subdirName, count + 1);
+            this.incrementPendingSubDirCount(this.pendingDeleteSubDirectoriesTracker, op.subdirName);
+        }
+        else if (op.type === "createSubDirectory") {
+            this.incrementPendingSubDirCount(this.pendingCreateSubDirectoriesTracker, op.subdirName);
         }
-        return newMessageId;
     }
     /**
      * Submit a create subdirectory operation.
@@ -1263,10 +1278,9 @@ class SubDirectory extends TypedEventEmitter {
      */
     submitCreateSubDirectoryMessage(op) {
         this.throwIfDisposed();
-        const newMessageId = this.getSubDirMessageId(op);
+        this.updatePendingSubDirMessageCount(op);
         const localOpMetadata = {
             type: "createSubDir",
-            pendingMessageId: newMessageId,
         };
         this.directory.submitDirectoryMessage(op, localOpMetadata);
     }
@@ -1277,10 +1291,9 @@ class SubDirectory extends TypedEventEmitter {
      */
     submitDeleteSubDirectoryMessage(op, subDir) {
         this.throwIfDisposed();
-        const newMessageId = this.getSubDirMessageId(op);
+        this.updatePendingSubDirMessageCount(op);
         const localOpMetadata = {
             type: "deleteSubDir",
-            pendingMessageId: newMessageId,
             subDirectory: subDir,
         };
         this.directory.submitDirectoryMessage(op, localOpMetadata);
@@ -1293,18 +1306,22 @@ class SubDirectory extends TypedEventEmitter {
      */
     resubmitSubDirectoryMessage(op, localOpMetadata) {
         assert(isSubDirLocalOpMetadata(localOpMetadata), 0x32f /* Invalid localOpMetadata for sub directory op */);
-        // clear the old pending message id
-        const pendingMessageIds = this.pendingSubDirectories.get(op.subdirName);
-        assert(pendingMessageIds !== undefined &&
-            pendingMessageIds[0] === localOpMetadata.pendingMessageId, 0x330 /* Unexpected pending message received */);
-        pendingMessageIds.shift();
-        if (pendingMessageIds.length === 0) {
-            this.pendingSubDirectories.delete(op.subdirName);
+        // Only submit the op, if we have record for it, otherwise it is possible that the older instance
+        // is already deleted, in which case we don't need to submit the op.
+        if (localOpMetadata.type === "createSubDir" &&
+            !this.pendingCreateSubDirectoriesTracker.has(op.subdirName)) {
+            return;
+        }
+        else if (localOpMetadata.type === "deleteSubDir" &&
+            !this.pendingDeleteSubDirectoriesTracker.has(op.subdirName)) {
+            return;
         }
         if (localOpMetadata.type === "createSubDir") {
+            this.decrementPendingSubDirCount(this.pendingCreateSubDirectoriesTracker, op.subdirName);
             this.submitCreateSubDirectoryMessage(op);
         }
         else {
+            this.decrementPendingSubDirCount(this.pendingDeleteSubDirectoriesTracker, op.subdirName);
             this.submitDeleteSubDirectoryMessage(op, localOpMetadata.subDirectory);
         }
     }
@@ -1408,7 +1425,7 @@ class SubDirectory extends TypedEventEmitter {
         }
         else if (op.type === "createSubDirectory" && localOpMetadata.type === "createSubDir") {
             this.deleteSubDirectoryCore(op.subdirName, true);
-            this.rollbackPendingMessageId(this.pendingSubDirectories, op.subdirName, localOpMetadata.pendingMessageId);
+            this.decrementPendingSubDirCount(this.pendingCreateSubDirectoriesTracker, op.subdirName);
         }
         else if (op.type === "deleteSubDirectory" && localOpMetadata.type === "deleteSubDir") {
             if (localOpMetadata.subDirectory !== undefined) {
@@ -1417,13 +1434,7 @@ class SubDirectory extends TypedEventEmitter {
                 this._subdirectories.set(op.subdirName, localOpMetadata.subDirectory);
                 this.emit("subDirectoryCreated", op.subdirName, true, this);
             }
-            this.rollbackPendingMessageId(this.pendingSubDirectories, op.subdirName, localOpMetadata.pendingMessageId);
-            const count = this.pendingDeleteSubDirectoriesCount.get(op.subdirName);
-            assert(count !== undefined && count > 0, 0x5ab /* should have record for delete op */);
-            this.pendingDeleteSubDirectoriesCount.set(op.subdirName, count - 1);
-            if (count === 1) {
-                this.pendingDeleteSubDirectoriesCount.delete(op.subdirName);
-            }
+            this.decrementPendingSubDirCount(this.pendingDeleteSubDirectoriesTracker, op.subDirName);
         }
         else {
             throw new Error("Unsupported op for rollback");
@@ -1516,51 +1527,63 @@ class SubDirectory extends TypedEventEmitter {
      * @returns True if the operation should be processed, false otherwise
      */
     needProcessSubDirectoryOperation(msg, op, local, localOpMetadata) {
-        const pendingSubDirectoryMessageId = this.pendingSubDirectories.get(op.subdirName);
         assertNonNullClientId(msg.clientId);
-        if (pendingSubDirectoryMessageId !== undefined) {
+        const pendingDeleteCount = this.pendingDeleteSubDirectoriesTracker.get(op.subdirName);
+        const pendingCreateCount = this.pendingCreateSubDirectoriesTracker.get(op.subdirName);
+        if ((pendingDeleteCount !== undefined && pendingDeleteCount > 0) ||
+            (pendingCreateCount !== undefined && pendingCreateCount > 0)) {
             if (local) {
                 assert(isSubDirLocalOpMetadata(localOpMetadata), 0x012 /* pendingMessageId is missing from the local client's operation */);
-                const pendingMessageIds = this.pendingSubDirectories.get(op.subdirName);
-                assert(pendingMessageIds !== undefined &&
-                    pendingMessageIds[0] === localOpMetadata.pendingMessageId, 0x332 /* Unexpected pending message received */);
-                pendingMessageIds.shift();
-                if (pendingMessageIds.length === 0) {
-                    this.pendingSubDirectories.delete(op.subdirName);
+                if (localOpMetadata.type === "deleteSubDir") {
+                    assert(pendingDeleteCount !== undefined && pendingDeleteCount > 0, 0x6c2 /* pendingDeleteCount should exist */);
+                    this.decrementPendingSubDirCount(this.pendingDeleteSubDirectoriesTracker, op.subdirName);
                 }
-                if (op.type === "deleteSubDirectory") {
-                    const count = this.pendingDeleteSubDirectoriesCount.get(op.subdirName);
-                    assert(count !== undefined && count > 0, 0x5ac /* should have record for delete op */);
-                    this.pendingDeleteSubDirectoriesCount.set(op.subdirName, count - 1);
-                    if (count === 1) {
-                        this.pendingDeleteSubDirectoriesCount.delete(op.subdirName);
-                    }
+                else if (localOpMetadata.type === "createSubDir") {
+                    assert(pendingCreateCount !== undefined && pendingCreateCount > 0, 0x6c3 /* pendingCreateCount should exist */);
+                    this.decrementPendingSubDirCount(this.pendingCreateSubDirectoriesTracker, op.subdirName);
                 }
             }
-            else if (op.type === "deleteSubDirectory") {
-                // If this is remote delete op and we have keys in this subDirectory, then we need to delete these
-                // keys except the pending ones as they will be sequenced after this delete.
-                const subDirectory = this._subdirectories.get(op.subdirName);
-                if (subDirectory) {
-                    subDirectory.clearExceptPendingKeys(local);
-                    // In case of remote delete op, we need to reset the creation seq number and client ids of
+            if (op.type === "deleteSubDirectory") {
+                const resetSubDirectoryTree = (directory) => {
+                    if (!directory) {
+                        return;
+                    }
+                    // If this is delete op and we have keys in this subDirectory, then we need to delete these
+                    // keys except the pending ones as they will be sequenced after this delete.
+                    directory.clearExceptPendingKeys(local);
+                    // In case of delete op, we need to reset the creation seq number and client ids of
                     // creators as the previous directory is getting deleted and we will initialize again when
                     // we will receive op for the create again.
-                    subDirectory.sequenceNumber = -1;
-                    subDirectory.clientIds.clear();
-                }
+                    directory.sequenceNumber = -1;
+                    directory.clientIds.clear();
+                    // Do the same thing for the subtree of the directory. If create is not pending for a child, then just
+                    // delete it.
+                    const subDirectories = directory.subdirectories();
+                    for (const [subDirName, subDir] of subDirectories) {
+                        if (directory.pendingCreateSubDirectoriesTracker.has(subDirName)) {
+                            resetSubDirectoryTree(subDir);
+                            continue;
+                        }
+                        directory.deleteSubDirectoryCore(subDirName, false);
+                    }
+                };
+                const subDirectory = this._subdirectories.get(op.subdirName);
+                resetSubDirectoryTree(subDirectory);
             }
             if (op.type === "createSubDirectory") {
                 const dir = this._subdirectories.get(op.subdirName);
-                if ((dir === null || dir === void 0 ? void 0 : dir.sequenceNumber) === -1) {
-                    // Only set the seq on the first message, could be more
-                    dir.sequenceNumber = msg.sequenceNumber;
-                }
-                // The client created the dir at or after the dirs seq, so list its client id as a creator.
-                if (dir !== undefined &&
-                    !dir.clientIds.has(msg.clientId) &&
-                    dir.sequenceNumber <= msg.sequenceNumber) {
-                    dir.clientIds.add(msg.clientId);
+                // Child sub directory create seq number can't be lower than the parent subdirectory.
+                if (this.sequenceNumber !== -1 && this.sequenceNumber < msg.sequenceNumber) {
+                    if ((dir === null || dir === void 0 ? void 0 : dir.sequenceNumber) === -1) {
+                        // Only set the seq on the first message, could be more
+                        dir.sequenceNumber = msg.sequenceNumber;
+                    }
+                    // The client created the dir at or after the dirs seq, so list its client id as a creator.
+                    if (dir !== undefined &&
+                        !dir.clientIds.has(msg.clientId) &&
+                        dir.sequenceNumber <= msg.sequenceNumber) {
+                        dir.clientIds.add(msg.clientId);
+                    }
                 }
             }
             return false;