@fluidframework/map 2.0.0-internal.3.3.2 → 2.0.0-internal.3.4.0

package/lib/directory.js

@@ -92,7 +92,7 @@ export class SharedDirectory extends SharedObject {
         /**
          * Root of the SharedDirectory, most operations on the SharedDirectory itself act on the root.
          */
-        this.root = new SubDirectory(this, this.runtime, this.serializer, posix.sep);
+        this.root = new SubDirectory(0, new Set(), this, this.runtime, this.serializer, posix.sep);
         /**
          * Mapping of op types to message handlers.
          */
@@ -348,7 +348,10 @@ export class SharedDirectory extends SharedObject {
                 for (const [subdirName, subdirObject] of Object.entries(currentSubDirObject.subdirectories)) {
                     let newSubDir = currentSubDir.getSubDirectory(subdirName);
                     if (!newSubDir) {
-                        newSubDir = new SubDirectory(this, this.runtime, this.serializer, posix.join(currentSubDir.absolutePath, subdirName));
+                        const createInfo = subdirObject.ci;
+                        newSubDir = new SubDirectory(createInfo !== undefined ? 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);
                     }
                     stack.push([newSubDir, subdirObject]);
@@ -371,7 +374,7 @@ export class SharedDirectory extends SharedObject {
             const op = message.contents;
             const handler = this.messageHandlers.get(op.type);
             assert(handler !== undefined, 0x00e /* Missing message handler for message type */);
-            handler.process(op, local, localOpMetadata);
+            handler.process(message, op, local, localOpMetadata);
         }
     }
     /**
@@ -407,15 +410,41 @@ export class SharedDirectory extends SharedObject {
             serializable.type === ValueType[ValueType.Shared], 0x1e4 /* "Unexpected serializable type" */);
         return this.localValueMaker.fromSerializable(serializable);
     }
+    /**
+     * This checks if there is pending delete op for local delete for a subdirectory.
+     * @param relativePath - path of sub directory.
+     * @returns - true if there is pending delete.
+     */
+    isSubDirectoryDeletePending(relativePath) {
+        const parentSubDir = this.getParentDirectory(relativePath);
+        const index = relativePath.lastIndexOf(posix.sep);
+        const dirName = relativePath.substring(index + 1);
+        return !!(parentSubDir === null || parentSubDir === void 0 ? void 0 : parentSubDir.isSubDirectoryDeletePending(dirName));
+    }
+    /**
+     * Gets the parent directory of a sub directory.
+     * @param relativePath - path of sub directory of which parent needs to be find out.
+     */
+    getParentDirectory(relativePath) {
+        const absolutePath = this.makeAbsolute(relativePath);
+        if (absolutePath === posix.sep) {
+            return undefined;
+        }
+        const index = absolutePath.lastIndexOf(posix.sep);
+        const parentAbsPath = absolutePath.substring(0, index);
+        return this.getWorkingDirectory(parentAbsPath);
+    }
     /**
      * Set the message handlers for the directory.
      */
     setMessageHandlers() {
         this.messageHandlers.set("clear", {
-            process: (op, local, localOpMetadata) => {
+            process: (msg, op, local, localOpMetadata) => {
                 const subdir = this.getWorkingDirectory(op.path);
-                if (subdir) {
-                    subdir.processClearMessage(op, local, localOpMetadata);
+                // If there is pending delete op for this subDirectory, then don't apply the this op as we are going
+                // to delete this subDirectory.
+                if (subdir && !this.isSubDirectoryDeletePending(op.path)) {
+                    subdir.processClearMessage(msg, op, local, localOpMetadata);
                 }
             },
             submit: (op, localOpMetadata) => {
@@ -432,10 +461,12 @@ export class SharedDirectory extends SharedObject {
             },
         });
         this.messageHandlers.set("delete", {
-            process: (op, local, localOpMetadata) => {
+            process: (msg, op, local, localOpMetadata) => {
                 const subdir = this.getWorkingDirectory(op.path);
-                if (subdir) {
-                    subdir.processDeleteMessage(op, local, localOpMetadata);
+                // If there is pending delete op for this subDirectory, then don't apply the this op as we are going
+                // to delete this subDirectory.
+                if (subdir && !this.isSubDirectoryDeletePending(op.path)) {
+                    subdir.processDeleteMessage(msg, op, local, localOpMetadata);
                 }
             },
             submit: (op, localOpMetadata) => {
@@ -452,11 +483,13 @@ export class SharedDirectory extends SharedObject {
             },
         });
         this.messageHandlers.set("set", {
-            process: (op, local, localOpMetadata) => {
+            process: (msg, op, local, localOpMetadata) => {
                 const subdir = this.getWorkingDirectory(op.path);
-                if (subdir) {
+                // If there is pending delete op for this subDirectory, then don't apply the this op as we are going
+                // to delete this subDirectory.
+                if (subdir && !this.isSubDirectoryDeletePending(op.path)) {
                     const context = local ? undefined : this.makeLocal(op.key, op.path, op.value);
-                    subdir.processSetMessage(op, context, local, localOpMetadata);
+                    subdir.processSetMessage(msg, op, context, local, localOpMetadata);
                 }
             },
             submit: (op, localOpMetadata) => {
@@ -474,10 +507,10 @@ export class SharedDirectory extends SharedObject {
             },
         });
         this.messageHandlers.set("createSubDirectory", {
-            process: (op, local, localOpMetadata) => {
+            process: (msg, op, local, localOpMetadata) => {
                 const parentSubdir = this.getWorkingDirectory(op.path);
                 if (parentSubdir) {
-                    parentSubdir.processCreateSubDirectoryMessage(op, local, localOpMetadata);
+                    parentSubdir.processCreateSubDirectoryMessage(msg, op, local, localOpMetadata);
                 }
             },
             submit: (op, localOpMetadata) => {
@@ -495,10 +528,10 @@ export class SharedDirectory extends SharedObject {
             },
         });
         this.messageHandlers.set("deleteSubDirectory", {
-            process: (op, local, localOpMetadata) => {
+            process: (msg, op, local, localOpMetadata) => {
                 const parentSubdir = this.getWorkingDirectory(op.path);
                 if (parentSubdir) {
-                    parentSubdir.processDeleteSubDirectoryMessage(op, local, localOpMetadata);
+                    parentSubdir.processDeleteSubDirectoryMessage(msg, op, local, localOpMetadata);
                 }
             },
             submit: (op, localOpMetadata) => {
@@ -538,6 +571,7 @@ export class SharedDirectory extends SharedObject {
         while (stack.length > 0) {
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             const [currentSubDir, currentSubDirObject] = stack.pop();
+            currentSubDirObject.ci = currentSubDir.getSerializableCreateInfo();
             for (const [key, value] of currentSubDir.getSerializedStorage(serializer)) {
                 if (!currentSubDirObject.storage) {
                     currentSubDirObject.storage = {};
@@ -598,8 +632,7 @@ function isClearLocalOpMetadata(metadata) {
 function isSubDirLocalOpMetadata(metadata) {
     return (metadata !== undefined &&
         typeof metadata.pendingMessageId === "number" &&
-        ((metadata.type === "createSubDir" && typeof metadata.previouslyExisted === "boolean") ||
-            metadata.type === "deleteSubDir"));
+        (metadata.type === "createSubDir" || metadata.type === "deleteSubDir"));
 }
 function isDirectoryLocalOpMetadata(metadata) {
     return (metadata !== undefined &&
@@ -607,7 +640,7 @@ function isDirectoryLocalOpMetadata(metadata) {
         (metadata.type === "edit" ||
             metadata.type === "deleteSubDir" ||
             (metadata.type === "clear" && typeof metadata.previousStorage === "object") ||
-            (metadata.type === "createSubDir" && typeof metadata.previouslyExisted === "boolean")));
+            metadata.type === "createSubDir"));
 }
 /* eslint-enable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access */
 /**
@@ -617,13 +650,17 @@ function isDirectoryLocalOpMetadata(metadata) {
 class SubDirectory extends TypedEventEmitter {
     /**
      * Constructor.
+     * @param sequenceNumber - Message seq number at which this was created.
+     * @param clientIds - Ids of client which created this directory.
      * @param directory - Reference back to the SharedDirectory to perform operations
      * @param runtime - The data store runtime this directory is associated with
      * @param serializer - The serializer to serialize / parse handles
      * @param absolutePath - The absolute path of this IDirectory
      */
-    constructor(directory, runtime, serializer, absolutePath) {
+    constructor(sequenceNumber, clientIds, directory, runtime, serializer, absolutePath) {
         super();
+        this.sequenceNumber = sequenceNumber;
+        this.clientIds = clientIds;
         this.directory = directory;
         this.runtime = runtime;
         this.serializer = serializer;
@@ -649,9 +686,14 @@ class SubDirectory extends TypedEventEmitter {
          */
         this.pendingKeys = new Map();
         /**
-         * Subdirectories that have been modified locally but not yet ack'd from the server.
+         * Subdirectories that have been created/deleted locally but not yet ack'd from the server.
          */
         this.pendingSubDirectories = 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.
+         */
+        this.pendingDeleteSubDirectoriesCount = new Map();
         /**
          * This is used to assign a unique id to every outgoing operation and helps in tracking unack'd ops.
          */
@@ -734,6 +776,7 @@ class SubDirectory extends TypedEventEmitter {
      * {@inheritDoc IDirectory.createSubDirectory}
      */
     createSubDirectory(subdirName) {
+        var _c;
         this.throwIfDisposed();
         // Undefined/null subdirectory names can't be serialized to JSON in the manner we currently snapshot.
         if (subdirName === undefined || subdirName === null) {
@@ -743,19 +786,22 @@ class SubDirectory extends TypedEventEmitter {
             throw new Error(`SubDirectory name may not contain ${posix.sep}`);
         }
         // Create the sub directory locally first.
-        const isNew = this.createSubDirectoryCore(subdirName, true);
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const isNew = this.createSubDirectoryCore(subdirName, true, -1, (_c = this.runtime.clientId) !== null && _c !== void 0 ? _c : "detached");
         const subDir = this._subdirectories.get(subdirName);
+        assert(subDir !== undefined, 0x5aa /* subdirectory should exist after creation */);
         // If we are not attached, don't submit the op.
         if (!this.directory.isAttached()) {
             return subDir;
         }
-        const op = {
-            path: this.absolutePath,
-            subdirName,
-            type: "createSubDirectory",
-        };
-        this.submitCreateSubDirectoryMessage(op, !isNew);
+        // Only submit the op, if it is newly created.
+        if (isNew) {
+            const op = {
+                path: this.absolutePath,
+                subdirName,
+                type: "createSubDirectory",
+            };
+            this.submitCreateSubDirectoryMessage(op);
+        }
         return subDir;
     }
     /**
@@ -783,12 +829,15 @@ class SubDirectory extends TypedEventEmitter {
         if (!this.directory.isAttached()) {
             return subDir !== undefined;
         }
-        const op = {
-            path: this.absolutePath,
-            subdirName,
-            type: "deleteSubDirectory",
-        };
-        this.submitDeleteSubDirectoryMessage(op, subDir);
+        // Only submit the op, if the directory existed and we deleted it.
+        if (subDir !== undefined) {
+            const op = {
+                path: this.absolutePath,
+                subdirName,
+                type: "deleteSubDirectory",
+            };
+            this.submitDeleteSubDirectoryMessage(op, subDir);
+        }
         return subDir !== undefined;
     }
     /**
@@ -805,6 +854,18 @@ class SubDirectory extends TypedEventEmitter {
         this.throwIfDisposed();
         return this.directory.getWorkingDirectory(this.makeAbsolute(relativePath));
     }
+    /**
+     * This checks if there is pending delete op for local delete for a given child subdirectory.
+     * @param subDirName - directory name.
+     * @returns - true if there is pending delete.
+     */
+    isSubDirectoryDeletePending(subDirName) {
+        const pendingDeleteSubDirectory = this.pendingDeleteSubDirectoriesCount.get(subDirName);
+        if (pendingDeleteSubDirectory !== undefined && pendingDeleteSubDirectory > 0) {
+            return true;
+        }
+        return false;
+    }
     /**
      * Deletes the given key from within this IDirectory.
      * @param key - The key to delete
@@ -920,14 +981,18 @@ class SubDirectory extends TypedEventEmitter {
     }
     /**
      * Process a clear operation.
+     * @param msg - The message from the server to apply.
      * @param op - The op to process
      * @param local - Whether the message originated from the local client
      * @param localOpMetadata - For local client messages, this is the metadata that was submitted with the message.
      * For messages from a remote client, this will be undefined.
      * @internal
      */
-    processClearMessage(op, local, localOpMetadata) {
+    processClearMessage(msg, op, local, localOpMetadata) {
         this.throwIfDisposed();
+        if (!this.isMessageForCurrentInstanceOfSubDirectory(msg)) {
+            return;
+        }
         if (local) {
             assert(isClearLocalOpMetadata(localOpMetadata), 0x00f /* pendingMessageId is missing from the local client's operation */);
             const pendingClearMessageId = this.pendingClearMessageIds.shift();
@@ -956,15 +1021,17 @@ class SubDirectory extends TypedEventEmitter {
     }
     /**
      * Process a delete operation.
+     * @param msg - The message from the server to apply.
      * @param op - The op to process
      * @param local - Whether the message originated from the local client
      * @param localOpMetadata - For local client messages, this is the metadata that was submitted with the message.
      * For messages from a remote client, this will be undefined.
      * @internal
      */
-    processDeleteMessage(op, local, localOpMetadata) {
+    processDeleteMessage(msg, op, local, localOpMetadata) {
         this.throwIfDisposed();
-        if (!this.needProcessStorageOperation(op, local, localOpMetadata)) {
+        if (!(this.isMessageForCurrentInstanceOfSubDirectory(msg) &&
+            this.needProcessStorageOperation(op, local, localOpMetadata))) {
             return;
         }
         this.deleteCore(op.key, local);
@@ -987,15 +1054,17 @@ class SubDirectory extends TypedEventEmitter {
     }
     /**
      * Process a set operation.
+     * @param msg - The message from the server to apply.
      * @param op - The op to process
      * @param local - Whether the message originated from the local client
      * @param localOpMetadata - For local client messages, this is the metadata that was submitted with the message.
      * For messages from a remote client, this will be undefined.
      * @internal
      */
-    processSetMessage(op, context, local, localOpMetadata) {
+    processSetMessage(msg, op, context, local, localOpMetadata) {
         this.throwIfDisposed();
-        if (!this.needProcessStorageOperation(op, local, localOpMetadata)) {
+        if (!(this.isMessageForCurrentInstanceOfSubDirectory(msg) &&
+            this.needProcessStorageOperation(op, local, localOpMetadata))) {
             return;
         }
         // needProcessStorageOperation should have returned false if local is true
@@ -1023,18 +1092,19 @@ class SubDirectory extends TypedEventEmitter {
     }
     /**
      * Process a create subdirectory operation.
+     * @param msg - The message from the server to apply.
      * @param op - The op to process
      * @param local - Whether the message originated from the local client
      * @param localOpMetadata - For local client messages, this is the metadata that was submitted with the message.
      * For messages from a remote client, this will be undefined.
      * @internal
      */
-    processCreateSubDirectoryMessage(op, local, localOpMetadata) {
+    processCreateSubDirectoryMessage(msg, op, local, localOpMetadata) {
         this.throwIfDisposed();
-        if (!this.needProcessSubDirectoryOperation(op, local, localOpMetadata)) {
+        if (!this.needProcessSubDirectoryOperation(msg, op, local, localOpMetadata)) {
             return;
         }
-        this.createSubDirectoryCore(op.subdirName, local);
+        this.createSubDirectoryCore(op.subdirName, local, msg.sequenceNumber, msg.clientId);
     }
     /**
      * Apply createSubDirectory operation locally and generate metadata
@@ -1042,28 +1112,30 @@ class SubDirectory extends TypedEventEmitter {
      * @returns metadata generated for stahed op
      */
     applyStashedCreateSubDirMessage(op) {
+        var _c;
         this.throwIfDisposed();
         // Create the sub directory locally first.
-        const isNew = this.createSubDirectoryCore(op.subdirName, true);
+        this.createSubDirectoryCore(op.subdirName, true, -1, (_c = this.runtime.clientId) !== null && _c !== void 0 ? _c : "detached");
         const newMessageId = this.getSubDirMessageId(op);
         const localOpMetadata = {
             type: "createSubDir",
             pendingMessageId: newMessageId,
-            previouslyExisted: !isNew,
         };
         return localOpMetadata;
     }
     /**
      * Process a delete subdirectory operation.
+     * @param msg - The message from the server to apply.
      * @param op - The op to process
      * @param local - Whether the message originated from the local client
      * @param localOpMetadata - For local client messages, this is the metadata that was submitted with the message.
      * For messages from a remote client, this will be undefined.
      * @internal
      */
-    processDeleteSubDirectoryMessage(op, local, localOpMetadata) {
+    processDeleteSubDirectoryMessage(msg, op, local, localOpMetadata) {
         this.throwIfDisposed();
-        if (!this.needProcessSubDirectoryOperation(op, local, localOpMetadata)) {
+        if (!(this.isMessageForCurrentInstanceOfSubDirectory(msg) &&
+            this.needProcessSubDirectoryOperation(msg, op, local, localOpMetadata))) {
             return;
         }
         this.deleteSubDirectoryCore(op.subdirName, local);
@@ -1159,6 +1231,7 @@ class SubDirectory extends TypedEventEmitter {
      * Get a new pending message id for the op and cache it to track the pending op
      */
     getSubDirMessageId(op) {
+        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);
@@ -1168,20 +1241,22 @@ class SubDirectory extends TypedEventEmitter {
         else {
             this.pendingSubDirectories.set(op.subdirName, [newMessageId]);
         }
+        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);
+        }
         return newMessageId;
     }
     /**
      * Submit a create subdirectory operation.
      * @param op - The operation
-     * @param prevExisted - Whether the subdirectory existed before the op
      */
-    submitCreateSubDirectoryMessage(op, prevExisted) {
+    submitCreateSubDirectoryMessage(op) {
         this.throwIfDisposed();
         const newMessageId = this.getSubDirMessageId(op);
         const localOpMetadata = {
             type: "createSubDir",
             pendingMessageId: newMessageId,
-            previouslyExisted: prevExisted,
         };
         this.directory.submitDirectoryMessage(op, localOpMetadata);
     }
@@ -1217,7 +1292,7 @@ class SubDirectory extends TypedEventEmitter {
             this.pendingSubDirectories.delete(op.subdirName);
         }
         if (localOpMetadata.type === "createSubDir") {
-            this.submitCreateSubDirectoryMessage(op, localOpMetadata.previouslyExisted);
+            this.submitCreateSubDirectoryMessage(op);
         }
         else {
             this.submitDeleteSubDirectoryMessage(op, localOpMetadata.subDirectory);
@@ -1237,6 +1312,14 @@ class SubDirectory extends TypedEventEmitter {
             yield res;
         }
     }
+    getSerializableCreateInfo() {
+        this.throwIfDisposed();
+        const createInfo = {
+            csn: this.sequenceNumber,
+            ccIds: Array.from(this.clientIds),
+        };
+        return createInfo;
+    }
     /**
      * Populate a key value in this subdirectory's storage, to be used when loading from snapshot.
      * @param key - The key to populate
@@ -1314,9 +1397,7 @@ class SubDirectory extends TypedEventEmitter {
             this.rollbackPendingMessageId(this.pendingKeys, op.key, localOpMetadata.pendingMessageId);
         }
         else if (op.type === "createSubDirectory" && localOpMetadata.type === "createSubDir") {
-            if (!localOpMetadata.previouslyExisted) {
-                this.deleteSubDirectoryCore(op.subdirName, true);
-            }
+            this.deleteSubDirectoryCore(op.subdirName, true);
             this.rollbackPendingMessageId(this.pendingSubDirectories, op.subdirName, localOpMetadata.pendingMessageId);
         }
         else if (op.type === "deleteSubDirectory" && localOpMetadata.type === "deleteSubDir") {
@@ -1327,6 +1408,12 @@ class SubDirectory extends TypedEventEmitter {
                 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);
+            }
         }
         else {
             throw new Error("Unsupported op for rollback");
@@ -1356,6 +1443,22 @@ class SubDirectory extends TypedEventEmitter {
                 assert(localOpMetadata !== undefined &&
                     isKeyEditLocalOpMetadata(localOpMetadata) &&
                     localOpMetadata.pendingMessageId < this.pendingClearMessageIds[0], 0x010 /* "Received out of order storage op when there is an unackd clear message" */);
+                // Remove all pendingMessageIds lower than first pendingClearMessageId.
+                const lowestPendingClearMessageId = this.pendingClearMessageIds[0];
+                const pendingKeyMessageIdArray = this.pendingKeys.get(op.key);
+                if (pendingKeyMessageIdArray !== undefined) {
+                    let index = 0;
+                    while (pendingKeyMessageIdArray[index] < lowestPendingClearMessageId) {
+                        index += 1;
+                    }
+                    const newPendingKeyMessageId = pendingKeyMessageIdArray.splice(index);
+                    if (newPendingKeyMessageId.length === 0) {
+                        this.pendingKeys.delete(op.key);
+                    }
+                    else {
+                        this.pendingKeys.set(op.key, newPendingKeyMessageId);
+                    }
+                }
             }
             // If I have a NACK clear, we can ignore all ops.
             return false;
@@ -1379,6 +1482,19 @@ class SubDirectory extends TypedEventEmitter {
         // If we don't have a NACK op on the key, we need to process the remote ops.
         return !local;
     }
+    /**
+     * This return true if the message is for the current instance of this sub directory. As the sub directory
+     * can be deleted and created again, then this finds if the message is for current instance of directory or not.
+     * @param msg - message for the directory
+     */
+    isMessageForCurrentInstanceOfSubDirectory(msg) {
+        // If the message is either from the creator of directory or this directory was created when
+        // container was detached or in case this directory is already live(known to other clients)
+        // and the op was created after the directory was created then apply this op.
+        return (this.clientIds.has(msg.clientId) ||
+            this.clientIds.has("detached") ||
+            (this.sequenceNumber !== -1 && this.sequenceNumber <= msg.referenceSequenceNumber));
+    }
     /**
      * If our local operations that have not yet been ack'd will eventually overwrite an incoming operation, we should
      * not process the incoming operation.
@@ -1389,7 +1505,7 @@ class SubDirectory extends TypedEventEmitter {
      * For messages from a remote client, this will be undefined.
      * @returns True if the operation should be processed, false otherwise
      */
-    needProcessSubDirectoryOperation(op, local, localOpMetadata) {
+    needProcessSubDirectoryOperation(msg, op, local, localOpMetadata) {
         const pendingSubDirectoryMessageId = this.pendingSubDirectories.get(op.subdirName);
         if (pendingSubDirectoryMessageId !== undefined) {
             if (local) {
@@ -1401,6 +1517,40 @@ class SubDirectory extends TypedEventEmitter {
                 if (pendingMessageIds.length === 0) {
                     this.pendingSubDirectories.delete(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 (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
+                    // 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();
+                }
+            }
+            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);
+                }
             }
             return false;
         }
@@ -1414,8 +1564,11 @@ class SubDirectory extends TypedEventEmitter {
         // we will get the value for the pendingKeys and clear the map
         const temp = new Map();
         for (const [key] of this.pendingKeys) {
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            temp.set(key, this._storage.get(key));
+            const value = this._storage.get(key);
+            // If this key is already deleted, then we don't need to add it again.
+            if (value !== undefined) {
+                temp.set(key, value);
+            }
         }
         this.clearCore(local);
         for (const [key, value] of temp.entries()) {
@@ -1469,17 +1622,23 @@ class SubDirectory extends TypedEventEmitter {
      * Create subdirectory implementation used for both locally sourced creation as well as incoming remote creation.
      * @param subdirName - The name of the subdirectory being created
      * @param local - Whether the message originated from the local client
+     * @param seq - Sequence number at which this directory is created
+     * @param clientId - Id of client which created this directory.
      * @returns - True if is newly created, false if it already existed.
      */
-    createSubDirectoryCore(subdirName, local) {
-        if (!this._subdirectories.has(subdirName)) {
+    createSubDirectoryCore(subdirName, local, seq, clientId) {
+        const subdir = this._subdirectories.get(subdirName);
+        if (subdir === undefined) {
             const absolutePath = posix.join(this.absolutePath, subdirName);
-            const subDir = new SubDirectory(this.directory, this.runtime, this.serializer, absolutePath);
+            const subDir = new SubDirectory(seq, new Set([clientId]), this.directory, this.runtime, this.serializer, absolutePath);
             this.registerEventsOnSubDirectory(subDir, subdirName);
             this._subdirectories.set(subdirName, subDir);
             this.emit("subDirectoryCreated", subdirName, local, this);
             return true;
         }
+        else {
+            subdir.clientIds.add(clientId);
+        }
         return false;
     }
     registerEventsOnSubDirectory(subDirectory, subDirName) {