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

package/src/directory.ts

@@ -654,7 +654,10 @@ export class SharedDirectory
 					if (!newSubDir) {
 						const createInfo = subdirObject.ci;
 						newSubDir = new SubDirectory(
-							createInfo !== undefined ? createInfo.csn : 0,
+							// 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<string>(createInfo.ccIds)
 								: new Set(),
@@ -1015,12 +1018,10 @@ interface IClearLocalOpMetadata {
 
 interface ICreateSubDirLocalOpMetadata {
 	type: "createSubDir";
-	pendingMessageId: number;
 }
 
 interface IDeleteSubDirLocalOpMetadata {
 	type: "deleteSubDir";
-	pendingMessageId: number;
 	subDirectory: SubDirectory | undefined;
 }
 
@@ -1052,19 +1053,15 @@ function isClearLocalOpMetadata(metadata: any): metadata is IClearLocalOpMetadat
 function isSubDirLocalOpMetadata(metadata: any): metadata is SubDirLocalOpMetadata {
 	return (
 		metadata !== undefined &&
-		typeof metadata.pendingMessageId === "number" &&
 		(metadata.type === "createSubDir" || metadata.type === "deleteSubDir")
 	);
 }
 
 function isDirectoryLocalOpMetadata(metadata: any): metadata is DirectoryLocalOpMetadata {
 	return (
-		metadata !== undefined &&
-		typeof metadata.pendingMessageId === "number" &&
-		(metadata.type === "edit" ||
-			metadata.type === "deleteSubDir" ||
-			(metadata.type === "clear" && typeof metadata.previousStorage === "object") ||
-			metadata.type === "createSubDir")
+		isKeyEditLocalOpMetadata(metadata) ||
+		isClearLocalOpMetadata(metadata) ||
+		isSubDirLocalOpMetadata(metadata)
 	);
 }
 
@@ -1100,20 +1097,26 @@ class SubDirectory extends TypedEventEmitter<IDirectoryEvents> implements IDirec
 	private readonly _subdirectories: Map<string, SubDirectory> = 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.
 	 */
 	private readonly pendingKeys: Map<string, number[]> = 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.
 	 */
-	private readonly pendingSubDirectories: Map<string, number[]> = new Map();
+	private readonly pendingDeleteSubDirectoriesTracker: Map<string, number> = 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.
 	 */
-	private readonly pendingDeleteSubDirectoriesCount: Map<string, number> = new Map();
+	private readonly pendingCreateSubDirectoriesTracker: Map<string, number> = new Map();
 
 	/**
 	 * This is used to assign a unique id to every outgoing operation and helps in tracking unack'd ops.
@@ -1335,8 +1338,7 @@ class SubDirectory extends TypedEventEmitter<IDirectoryEvents> implements IDirec
 	 * @returns - true if there is pending delete.
 	 */
 	public isSubDirectoryDeletePending(subDirName: string): boolean {
-		const pendingDeleteSubDirectory = this.pendingDeleteSubDirectoriesCount.get(subDirName);
-		if (pendingDeleteSubDirectory !== undefined && pendingDeleteSubDirectory > 0) {
+		if (this.pendingDeleteSubDirectoriesTracker.has(subDirName)) {
 			return true;
 		}
 		return false;
@@ -1637,7 +1639,12 @@ class SubDirectory extends TypedEventEmitter<IDirectoryEvents> implements IDirec
 		localOpMetadata: unknown,
 	): void {
 		this.throwIfDisposed();
-		if (!this.needProcessSubDirectoryOperation(msg, op, local, localOpMetadata)) {
+		if (
+			!(
+				this.isMessageForCurrentInstanceOfSubDirectory(msg) &&
+				this.needProcessSubDirectoryOperation(msg, op, local, localOpMetadata)
+			)
+		) {
 			return;
 		}
 		assertNonNullClientId(msg.clientId);
@@ -1655,11 +1662,10 @@ class SubDirectory extends TypedEventEmitter<IDirectoryEvents> implements IDirec
 		this.throwIfDisposed();
 		// Create the sub directory locally first.
 		this.createSubDirectoryCore(op.subdirName, true, -1, this.runtime.clientId ?? "detached");
-		const newMessageId = this.getSubDirMessageId(op);
+		this.updatePendingSubDirMessageCount(op);
 
 		const localOpMetadata: ICreateSubDirLocalOpMetadata = {
 			type: "createSubDir",
-			pendingMessageId: newMessageId,
 		};
 		return localOpMetadata;
 	}
@@ -1701,10 +1707,9 @@ class SubDirectory extends TypedEventEmitter<IDirectoryEvents> implements IDirec
 	): IDeleteSubDirLocalOpMetadata {
 		this.throwIfDisposed();
 		const subDir = this.deleteSubDirectoryCore(op.subdirName, true);
-		const newMessageId = this.getSubDirMessageId(op);
+		this.updatePendingSubDirMessageCount(op);
 		const metadata: IDeleteSubDirLocalOpMetadata = {
 			type: "deleteSubDir",
-			pendingMessageId: newMessageId,
 			subDirectory: subDir,
 		};
 		return metadata;
@@ -1741,11 +1746,11 @@ class SubDirectory extends TypedEventEmitter<IDirectoryEvents> implements IDirec
 		);
 		// 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);
+		}
 	}
 
 	/**
@@ -1789,36 +1794,49 @@ class SubDirectory extends TypedEventEmitter<IDirectoryEvents> implements IDirec
 
 		// clear the old pending message id
 		const pendingMessageIds = this.pendingKeys.get(op.key);
-		assert(
+		// 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,
-			0x32e /* Unexpected pending message received */,
-		);
-		pendingMessageIds.shift();
-		if (pendingMessageIds.length === 0) {
-			this.pendingKeys.delete(op.key);
+			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);
+	private incrementPendingSubDirCount(map: Map<string, number>, subDirName: string) {
+		const count = map.get(subDirName) ?? 0;
+		map.set(subDirName, count + 1);
+	}
+
+	private decrementPendingSubDirCount(map: Map<string, number>, subDirName: string) {
+		const count = map.get(subDirName) ?? 0;
+		map.set(subDirName, count - 1);
+		if (count <= 1) {
+			map.delete(subDirName);
+		}
 	}
 
 	/**
-	 * Get a new pending message id for the op and cache it to track the pending op
+	 * 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.
 	 */
-	private getSubDirMessageId(op: IDirectorySubDirectoryOperation): number {
-		// 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]);
-		}
+	private updatePendingSubDirMessageCount(op: IDirectorySubDirectoryOperation) {
 		if (op.type === "deleteSubDirectory") {
-			const count = this.pendingDeleteSubDirectoriesCount.get(op.subdirName) ?? 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;
 	}
 
 	/**
@@ -1827,11 +1845,10 @@ class SubDirectory extends TypedEventEmitter<IDirectoryEvents> implements IDirec
 	 */
 	private submitCreateSubDirectoryMessage(op: IDirectorySubDirectoryOperation): void {
 		this.throwIfDisposed();
-		const newMessageId = this.getSubDirMessageId(op);
+		this.updatePendingSubDirMessageCount(op);
 
 		const localOpMetadata: ICreateSubDirLocalOpMetadata = {
 			type: "createSubDir",
-			pendingMessageId: newMessageId,
 		};
 		this.directory.submitDirectoryMessage(op, localOpMetadata);
 	}
@@ -1846,11 +1863,10 @@ class SubDirectory extends TypedEventEmitter<IDirectoryEvents> implements IDirec
 		subDir: SubDirectory | undefined,
 	): void {
 		this.throwIfDisposed();
-		const newMessageId = this.getSubDirMessageId(op);
+		this.updatePendingSubDirMessageCount(op);
 
 		const localOpMetadata: IDeleteSubDirLocalOpMetadata = {
 			type: "deleteSubDir",
-			pendingMessageId: newMessageId,
 			subDirectory: subDir,
 		};
 		this.directory.submitDirectoryMessage(op, localOpMetadata);
@@ -1871,21 +1887,31 @@ class SubDirectory extends TypedEventEmitter<IDirectoryEvents> implements IDirec
 			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);
 		}
 	}
@@ -2010,10 +2036,9 @@ class SubDirectory extends TypedEventEmitter<IDirectoryEvents> implements IDirec
 		} else if (op.type === "createSubDirectory" && localOpMetadata.type === "createSubDir") {
 			this.deleteSubDirectoryCore(op.subdirName as string, true);
 
-			this.rollbackPendingMessageId(
-				this.pendingSubDirectories,
+			this.decrementPendingSubDirCount(
+				this.pendingCreateSubDirectoriesTracker,
 				op.subdirName as string,
-				localOpMetadata.pendingMessageId,
 			);
 		} else if (op.type === "deleteSubDirectory" && localOpMetadata.type === "deleteSubDir") {
 			if (localOpMetadata.subDirectory !== undefined) {
@@ -2023,17 +2048,10 @@ class SubDirectory extends TypedEventEmitter<IDirectoryEvents> implements IDirec
 				this.emit("subDirectoryCreated", op.subdirName, true, this);
 			}
 
-			this.rollbackPendingMessageId(
-				this.pendingSubDirectories,
-				op.subdirName as string,
-				localOpMetadata.pendingMessageId,
+			this.decrementPendingSubDirCount(
+				this.pendingDeleteSubDirectoriesTracker,
+				op.subDirName as string,
 			);
-			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");
 		}
@@ -2152,61 +2170,81 @@ class SubDirectory extends TypedEventEmitter<IDirectoryEvents> implements IDirec
 		local: boolean,
 		localOpMetadata: unknown,
 	): boolean {
-		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 (op.type === "deleteSubDirectory") {
-					const count = this.pendingDeleteSubDirectoriesCount.get(op.subdirName);
+				if (localOpMetadata.type === "deleteSubDir") {
 					assert(
-						count !== undefined && count > 0,
-						0x5ac /* should have record for delete op */,
+						pendingDeleteCount !== undefined && pendingDeleteCount > 0,
+						0x6c2 /* pendingDeleteCount should exist */,
+					);
+					this.decrementPendingSubDirCount(
+						this.pendingDeleteSubDirectoriesTracker,
+						op.subdirName,
+					);
+				} else if (localOpMetadata.type === "createSubDir") {
+					assert(
+						pendingCreateCount !== undefined && pendingCreateCount > 0,
+						0x6c3 /* pendingCreateCount should exist */,
+					);
+					this.decrementPendingSubDirCount(
+						this.pendingCreateSubDirectoriesTracker,
+						op.subdirName,
 					);
-					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
+			}
+			if (op.type === "deleteSubDirectory") {
+				const resetSubDirectoryTree = (directory: SubDirectory | undefined): void => {
+					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 as SubDirectory);
+							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?.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?.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;

package/src/interfaces.ts

@@ -4,12 +4,8 @@
  */
 
 import { ISharedObject, ISharedObjectEvents } from "@fluidframework/shared-object-base";
-import {
-	IDisposable,
-	IEvent,
-	IEventProvider,
-	IEventThisPlaceHolder,
-} from "@fluidframework/common-definitions";
+import { IEvent, IEventProvider, IEventThisPlaceHolder } from "@fluidframework/common-definitions";
+import { IDisposable } from "@fluidframework/core-interfaces";
 
 /**
  * Type of "valueChanged" event parameter.

package/src/mapKernel.ts

@@ -342,6 +342,9 @@ export class MapKernel {
 		// Clear the data locally first.
 		this.clearCore(true);
 
+		// Clear the pendingKeys immediately, the local unack'd operations are aborted
+		this.pendingKeys.clear();
+
 		// If we are not attached, don't submit the op.
 		if (!this.isAttached()) {
 			return;
@@ -547,8 +550,11 @@ export class MapKernel {
 		// we will get the value for the pendingKeys and clear the map
 		const temp = new Map<string, ILocalValue>();
 		for (const key of this.pendingKeys.keys()) {
-			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-			temp.set(key, this.data.get(key)!);
+			// Verify if the most recent pending operation is a delete op, no need to retain it if so.
+			// This ensures the map size remains consistent.
+			if (this.data.has(key)) {
+				temp.set(key, this.data.get(key) as ILocalValue);
+			}
 		}
 		this.clearCore(false);
 		for (const [key, value] of temp.entries()) {
@@ -771,13 +777,16 @@ export class MapKernel {
 			0x2fe /* Invalid localOpMetadata in submit */,
 		);
 
-		// clear the old pending message id
+		// no need to submit messages for op's that have been aborted
 		const pendingMessageIds = this.pendingKeys.get(op.key);
-		assert(
-			pendingMessageIds !== undefined &&
-				pendingMessageIds[0] === localOpMetadata.pendingMessageId,
-			0x2ff /* Unexpected pending message received */,
-		);
+		if (
+			pendingMessageIds === undefined ||
+			pendingMessageIds[0] !== localOpMetadata.pendingMessageId
+		) {
+			return;
+		}
+
+		// clear the old pending message id
 		pendingMessageIds.shift();
 		if (pendingMessageIds.length === 0) {
 			this.pendingKeys.delete(op.key);

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/map";
-export const pkgVersion = "2.0.0-dev.4.4.0.162574";
+export const pkgVersion = "2.0.0-dev.5.3.2.178189";