@fluidframework/container-runtime 2.4.0 → 2.5.0

package/src/opLifecycle/outbox.ts

@@ -145,6 +145,18 @@ export class Outbox {
 		return this.mainBatch.length + this.blobAttachBatch.length + this.idAllocationBatch.length;
 	}
 
+	public get mainBatchMessageCount(): number {
+		return this.mainBatch.length;
+	}
+
+	public get blobAttachBatchMessageCount(): number {
+		return this.blobAttachBatch.length;
+	}
+
+	public get idAllocationBatchMessageCount(): number {
+		return this.idAllocationBatch.length;
+	}
+
 	public get isEmpty(): boolean {
 		return this.messageCount === 0;
 	}

package/src/opLifecycle/remoteMessageProcessor.ts

@@ -59,6 +59,7 @@ export type InboundMessageResult =
 			messages: InboundSequencedContainerRuntimeMessage[];
 			batchStart: BatchStartInfo;
 			length: number;
+			groupedBatch: boolean; // Messages in a grouped batches are sent to the runtime in bunches.
 	  }
 	| {
 			type: "batchStartingMessage";
@@ -171,6 +172,7 @@ export class RemoteMessageProcessor {
 					keyMessage: groupedMessages[0] ?? message, // For an empty batch, this is the empty grouped batch message. Needed for sequence numbers for this batch
 				},
 				length: groupedMessages.length, // Will be 0 for an empty batch
+				groupedBatch: true,
 			};
 		}
 
@@ -220,6 +222,7 @@ export class RemoteMessageProcessor {
 					keyMessage: message,
 				},
 				length: 1,
+				groupedBatch: false,
 			};
 		}
 		assert(batchMetadataFlag !== true, 0x9d6 /* Unexpected batch start marker */);

package/src/opProperties.ts

@@ -12,7 +12,7 @@ export const opSize = (op: ISequencedDocumentMessage): number => {
 	// Some messages may already have string contents,
 	// so stringifying them again will add inaccurate overhead.
 	const content =
-		typeof op.contents === "string" ? op.contents : JSON.stringify(op.contents) ?? "";
+		typeof op.contents === "string" ? op.contents : (JSON.stringify(op.contents) ?? "");
 	const data = opHasData(op) ? op.data : "";
 	return content.length + data.length;
 };

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/container-runtime";
-export const pkgVersion = "2.4.0";
+export const pkgVersion = "2.5.0";

package/src/summary/documentSchema.ts

@@ -429,6 +429,7 @@ function arrayToProp(arr: string[]) {
  *
  * @legacy
  * @alpha
+ * @sealed
  */
 export class DocumentsSchemaController {
 	private explicitSchemaControl: boolean;
@@ -489,7 +490,7 @@ export class DocumentsSchemaController {
 		// Latter is importnat sure that's what will go into summary.
 		this.documentSchema = !existing
 			? this.desiredSchema
-			: (documentMetadataSchema as IDocumentSchemaCurrent) ??
+			: ((documentMetadataSchema as IDocumentSchemaCurrent) ??
 				({
 					version: currentDocumentVersionSchema,
 					// see comment in summarizeDocumentSchema() on why it has to stay zero
@@ -499,7 +500,7 @@ export class DocumentsSchemaController {
 					runtime: {
 						explicitSchemaControl: boolToProp(!existing && features.explicitSchemaControl),
 					},
-				} satisfies IDocumentSchemaCurrent);
+				} satisfies IDocumentSchemaCurrent));
 
 		checkRuntimeCompatibility(this.documentSchema, "document");
 		this.validateSeqNumber(this.documentSchema.refSeq, snapshotSequenceNumber, "summary");
@@ -601,55 +602,73 @@ export class DocumentsSchemaController {
 	 * @param local - whether op is local
 	 * @param sequenceNumber - sequence number of the op
 	 * @returns - true if schema was accepted, otherwise false (rejected due to failed CAS)
+	 * @deprecated It has been replaced by processDocumentSchemaMessages instead.
 	 */
 	public processDocumentSchemaOp(
 		content: IDocumentSchemaChangeMessage,
 		local: boolean,
 		sequenceNumber: number,
 	) {
-		this.validateSeqNumber(content.refSeq, this.documentSchema.refSeq, "content.refSeq");
-		this.validateSeqNumber(this.documentSchema.refSeq, sequenceNumber, "refSeq");
-		// validate is strickly less, not equal
-		assert(
-			this.documentSchema.refSeq < sequenceNumber,
-			0x950 /* time should move forward only! */,
-		);
-
-		if (content.refSeq !== this.documentSchema.refSeq) {
-			// CAS failed
-			return false;
-		}
-
-		// This assert should be after checking for successful CAS above.
-		// This will ensure we do not trip on our own messages that are no longer wanted as we processed someone else schema change message.
-		assert(
-			!local || (this.explicitSchemaControl && this.futureSchema !== undefined),
-			0x951 /* not sending ops */,
-		);
+		return this.processDocumentSchemaMessages([content], local, sequenceNumber);
+	}
 
-		// Changes are in effect. Immediately check that this client understands these changes
-		checkRuntimeCompatibility(content, "change");
+	/**
+	 * Process document schema change messages
+	 * Called by ContainerRuntime whenever it sees document schema messages.
+	 * @param contents - contents of the messages
+	 * @param local - whether op is local
+	 * @param sequenceNumber - sequence number of the op
+	 * @returns - true if schema was accepted, otherwise false (rejected due to failed CAS)
+	 */
+	public processDocumentSchemaMessages(
+		contents: IDocumentSchemaChangeMessage[],
+		local: boolean,
+		sequenceNumber: number,
+	) {
+		for (const content of contents) {
+			this.validateSeqNumber(content.refSeq, this.documentSchema.refSeq, "content.refSeq");
+			this.validateSeqNumber(this.documentSchema.refSeq, sequenceNumber, "refSeq");
+			// validate is strickly less, not equal
+			assert(
+				this.documentSchema.refSeq < sequenceNumber,
+				0x950 /* time should move forward only! */,
+			);
 
-		const schema: IDocumentSchema = { ...content, refSeq: sequenceNumber };
-		this.documentSchema = schema as IDocumentSchemaCurrent;
-		this.sessionSchema = and(this.documentSchema, this.desiredSchema);
-		assert(this.sessionSchema.refSeq === sequenceNumber, 0x97d /* seq# */);
+			if (content.refSeq !== this.documentSchema.refSeq) {
+				// CAS failed
+				return false;
+			}
 
-		// legacy behavior is automatically off for the document once someone sends a schema op -
-		// from now on it's fully controlled by ops.
-		// This is very important, as summarizeDocumentSchema() should use this new schema!
-		this.explicitSchemaControl = true;
+			// This assert should be after checking for successful CAS above.
+			// This will ensure we do not trip on our own messages that are no longer wanted as we processed someone else schema change message.
+			assert(
+				!local || (this.explicitSchemaControl && this.futureSchema !== undefined),
+				0x951 /* not sending ops */,
+			);
 
-		// Stop attempting changing schema.
-		// If it was local op, then we succeeded and do not need to try again.
-		// If it was remote op, then some changes happened to schema.
-		// We would need to recalculate this.futureSchema by merging changes that we just received.
-		// Avoid this complexity for now - a new client session (loading from new summary with these changes)
-		// will automatically do this recalculation and will figure out
-		this.futureSchema = undefined;
+			// Changes are in effect. Immediately check that this client understands these changes
+			checkRuntimeCompatibility(content, "change");
 
-		this.onSchemaChange(this.sessionSchema);
+			const schema: IDocumentSchema = { ...content, refSeq: sequenceNumber };
+			this.documentSchema = schema as IDocumentSchemaCurrent;
+			this.sessionSchema = and(this.documentSchema, this.desiredSchema);
+			assert(this.sessionSchema.refSeq === sequenceNumber, 0x97d /* seq# */);
+
+			// legacy behavior is automatically off for the document once someone sends a schema op -
+			// from now on it's fully controlled by ops.
+			// This is very important, as summarizeDocumentSchema() should use this new schema!
+			this.explicitSchemaControl = true;
+
+			// Stop attempting changing schema.
+			// If it was local op, then we succeeded and do not need to try again.
+			// If it was remote op, then some changes happened to schema.
+			// We would need to recalculate this.futureSchema by merging changes that we just received.
+			// Avoid this complexity for now - a new client session (loading from new summary with these changes)
+			// will automatically do this recalculation and will figure out
+			this.futureSchema = undefined;
 
+			this.onSchemaChange(this.sessionSchema);
+		}
 		return true;
 	}