@fluidframework/container-runtime 2.13.0 → 2.21.0

package/src/pendingStateManager.ts

@@ -3,13 +3,14 @@
  * Licensed under the MIT License.
  */
 
-import { IDisposable } from "@fluidframework/core-interfaces";
+import { IDisposable, type ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
 import { assert, Lazy } from "@fluidframework/core-utils/internal";
 import {
 	ITelemetryLoggerExt,
 	DataProcessingError,
 	LoggingError,
 	extractSafePropertiesFromMessage,
+	createChildLogger,
 } from "@fluidframework/telemetry-utils/internal";
 import Deque from "double-ended-queue";
 import { v4 as uuid } from "uuid";
@@ -56,16 +57,22 @@ export interface IPendingMessage {
 		 * Or, -1 if it was never submitted (and clientId will be a random uuid)
 		 */
 		batchStartCsn: number;
-		/** length of the batch (how many runtime messages here) */
+		/**
+		 * length of the batch (how many runtime messages here)
+		 */
 		length: number;
-		/** If true, don't compare batchID of incoming batches to this. e.g. ID Allocation Batch IDs should be ignored */
+		/**
+		 * If true, don't compare batchID of incoming batches to this. e.g. ID Allocation Batch IDs should be ignored
+		 */
 		ignoreBatchId?: boolean;
 	};
 }
 
 type Patch<T, U> = U & Omit<T, keyof U>;
 
-/** First version of the type (pre-dates batchInfo) */
+/**
+ * First version of the type (pre-dates batchInfo)
+ */
 type IPendingMessageV0 = Patch<IPendingMessage, { batchInfo?: undefined }>;
 
 /**
@@ -82,7 +89,9 @@ export interface IPendingLocalState {
 	pendingStates: IPendingMessage[];
 }
 
-/** Info needed to replay/resubmit a pending message */
+/**
+ * Info needed to replay/resubmit a pending message
+ */
 export type PendingMessageResubmitData = Pick<
 	IPendingMessage,
 	"content" | "localOpMetadata" | "opMetadata"
@@ -98,7 +107,9 @@ export interface IRuntimeStateHandler {
 }
 
 function isEmptyBatchPendingMessage(message: IPendingMessageFromStash): boolean {
+	// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
 	const content = JSON.parse(message.content);
+	// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 	return content.type === "groupedBatch" && content.contents?.length === 0;
 }
 
@@ -132,7 +143,7 @@ function scrubAndStringify(
 }
 
 /**
- * @returns The index where the strings diverge, and the character at that index in each string (or undefined if not applicable)
+ * Finds and returns the index where the strings diverge, and the character at that index in each string (or undefined if not applicable)
  */
 export function findFirstCharacterMismatched(
 	a: string,
@@ -170,9 +181,13 @@ function withoutLocalOpMetadata(message: IPendingMessage): IPendingMessage {
  * It verifies that all the ops are acked, are received in the right order and batch information is correct.
  */
 export class PendingStateManager implements IDisposable {
-	/** Messages that will need to be resubmitted if not ack'd before the next reconnection */
+	/**
+	 * Messages that will need to be resubmitted if not ack'd before the next reconnection
+	 */
 	private readonly pendingMessages = new Deque<IPendingMessage>();
-	/** Messages stashed from a previous container, now being rehydrated. Need to be resubmitted. */
+	/**
+	 * Messages stashed from a previous container, now being rehydrated. Need to be resubmitted.
+	 */
 	private readonly initialMessages = new Deque<IPendingMessageFromStash>();
 
 	/**
@@ -180,12 +195,15 @@ export class PendingStateManager implements IDisposable {
 	 */
 	private savedOps: IPendingMessage[] = [];
 
+	// eslint-disable-next-line unicorn/consistent-function-scoping -- Property is defined once; no need to extract inner lambda
 	private readonly disposeOnce = new Lazy<void>(() => {
 		this.initialMessages.clear();
 		this.pendingMessages.clear();
 	});
 
-	/** Used to ensure we don't replay ops on the same connection twice */
+	/**
+	 * Used to ensure we don't replay ops on the same connection twice
+	 */
 	private clientIdFromLastReplay: string | undefined;
 
 	/**
@@ -228,36 +246,39 @@ export class PendingStateManager implements IDisposable {
 			);
 			return message.sequenceNumber > (snapshotSequenceNumber ?? 0);
 		});
-		this.pendingMessages.toArray().forEach((message) => {
+		for (const message of this.pendingMessages.toArray()) {
 			if (
 				snapshotSequenceNumber !== undefined &&
 				message.referenceSequenceNumber < snapshotSequenceNumber
 			) {
 				throw new LoggingError("trying to stash ops older than our latest snapshot");
 			}
-		});
+		}
 		return {
 			pendingStates: [
 				...newSavedOps,
-				...this.pendingMessages.toArray().map(withoutLocalOpMetadata),
+				...this.pendingMessages.toArray().map((message) => withoutLocalOpMetadata(message)),
 			],
 		};
 	}
 
+	private readonly logger: ITelemetryLoggerExt;
+
 	constructor(
 		private readonly stateHandler: IRuntimeStateHandler,
 		stashedLocalState: IPendingLocalState | undefined,
-		private readonly logger: ITelemetryLoggerExt,
+		logger: ITelemetryBaseLogger,
 	) {
+		this.logger = createChildLogger({ logger });
 		if (stashedLocalState?.pendingStates) {
 			this.initialMessages.push(...stashedLocalState.pendingStates);
 		}
 	}
 
-	public get disposed() {
+	public get disposed(): boolean {
 		return this.disposeOnce.evaluated;
 	}
-	public readonly dispose = () => this.disposeOnce.value;
+	public readonly dispose = (): void => this.disposeOnce.value;
 
 	/**
 	 * The given batch has been flushed, and needs to be tracked locally until the corresponding
@@ -271,7 +292,7 @@ export class PendingStateManager implements IDisposable {
 		batch: BatchMessage[],
 		clientSequenceNumber: number | undefined,
 		ignoreBatchId?: boolean,
-	) {
+	): void {
 		// clientId and batchStartCsn are used for generating the batchId so we can detect container forks
 		// where this batch was submitted by two different clients rehydrating from the same local state.
 		// In the typical case where the batch was actually sent, use the clientId and clientSequenceNumber.
@@ -310,7 +331,7 @@ export class PendingStateManager implements IDisposable {
 	 * Applies stashed ops at their reference sequence number so they are ready to be ACKed or resubmitted
 	 * @param seqNum - Sequence number at which to apply ops. Will apply all ops if seqNum is undefined.
 	 */
-	public async applyStashedOpsAt(seqNum?: number) {
+	public async applyStashedOpsAt(seqNum?: number): Promise<void> {
 		// apply stashed ops at sequence number
 		while (!this.initialMessages.isEmpty()) {
 			if (seqNum !== undefined) {
@@ -336,15 +357,15 @@ export class PendingStateManager implements IDisposable {
 				}
 				// applyStashedOp will cause the DDS to behave as if it has sent the op but not actually send it
 				const localOpMetadata = await this.stateHandler.applyStashedOp(nextMessage.content);
-				if (!this.stateHandler.isAttached()) {
-					if (localOpMetadata !== undefined) {
-						throw new Error("Local Op Metadata must be undefined when not attached");
-					}
-				} else {
+				if (this.stateHandler.isAttached()) {
 					nextMessage.localOpMetadata = localOpMetadata;
 					// then we push onto pendingMessages which will cause PendingStateManager to resubmit when we connect
 					patchbatchInfo(nextMessage); // Back compat
 					this.pendingMessages.push(nextMessage);
+				} else {
+					if (localOpMetadata !== undefined) {
+						throw new Error("Local Op Metadata must be undefined when not attached");
+					}
 				}
 			} catch (error) {
 				throw DataProcessingError.wrapIfUnrecognized(error, "applyStashedOp", nextMessage);
@@ -535,7 +556,7 @@ export class PendingStateManager implements IDisposable {
 	/**
 	 * Check if the incoming batch matches the batch info for the next pending message.
 	 */
-	private onLocalBatchBegin(batchStart: BatchStartInfo, batchLength?: number) {
+	private onLocalBatchBegin(batchStart: BatchStartInfo, batchLength?: number): void {
 		// Get the next message from the pending queue. Verify a message exists.
 		const pendingMessage = this.pendingMessages.peekFront();
 		assert(
@@ -594,7 +615,7 @@ export class PendingStateManager implements IDisposable {
 	 * states in its queue. This includes triggering resubmission of unacked ops.
 	 * ! Note: successfully resubmitting an op that has been successfully sequenced is not possible due to checks in the ConnectionStateHandler (Loader layer)
 	 */
-	public replayPendingStates() {
+	public replayPendingStates(): void {
 		assert(
 			this.stateHandler.connected(),
 			0x172 /* "The connection state is not consistent with the runtime" */,
@@ -638,7 +659,7 @@ export class PendingStateManager implements IDisposable {
 			/**
 			 * We must preserve the distinct batches on resubmit.
 			 * Note: It is not possible for the PendingStateManager to receive a partially acked batch. It will
-			 * either receive the whole batch ack or nothing at all.  @see ScheduleManager for how this works.
+			 * either receive the whole batch ack or nothing at all. See {@link InboundBatchAggregator} for how this works.
 			 */
 			if (batchMetadataFlag === undefined) {
 				// Single-message batch
@@ -705,7 +726,9 @@ export class PendingStateManager implements IDisposable {
 	}
 }
 
-/** For back-compat if trying to apply stashed ops that pre-date batchInfo */
+/**
+ * For back-compat if trying to apply stashed ops that pre-date batchInfo
+ */
 function patchbatchInfo(
 	message: IPendingMessageFromStash,
 ): asserts message is IPendingMessage {

package/src/summary/documentSchema.ts

@@ -15,6 +15,7 @@ import { pkgVersion } from "../packageVersion.js";
  * we want them to continue to collaborate alongside clients who support that capability, but such capability is shipping dark for now.
  * @legacy
  * @alpha
+ * @deprecated This type will be moved to internal in 2.30. External usage is not necessary or supported.
  */
 export type DocumentSchemaValueType = string | string[] | true | number | undefined;
 
@@ -59,6 +60,7 @@ export type IdCompressorMode = "on" | "delayed" | undefined;
  *
  * @legacy
  * @alpha
+ * @deprecated This type will be moved to internal in 2.30. External usage is not necessary or supported.
  */
 export interface IDocumentSchema {
 	// version that describes how data is stored in this structure.
@@ -80,6 +82,7 @@ export interface IDocumentSchema {
  * @see ContainerRuntimeDocumentSchemaMessage
  * @legacy
  * @alpha
+ * @deprecated This type will be moved to internal in 2.30. External usage is not necessary or supported.
  */
 export type IDocumentSchemaChangeMessage = IDocumentSchema;
 
@@ -91,6 +94,7 @@ export type IDocumentSchemaChangeMessage = IDocumentSchema;
  *
  * @legacy
  * @alpha
+ * @deprecated This type will be moved to internal in 2.30. External usage is not necessary or supported.
  */
 export interface IDocumentSchemaFeatures {
 	// Tells if client uses legacy behavior of changing schema.
@@ -121,6 +125,7 @@ export interface IDocumentSchemaFeatures {
  * Ex: Changing the 'document schema acceptance' mechanism from convert-and-swap to one requiring consensus does require changing this version.
  * @legacy
  * @alpha
+ * @deprecated This type will be moved to internal in 2.30. External usage is not necessary or supported.
  */
 export const currentDocumentVersionSchema = 1;
 
@@ -128,6 +133,7 @@ export const currentDocumentVersionSchema = 1;
  * Current document schema.
  * @legacy
  * @alpha
+ * @deprecated This type will be moved to internal in 2.30. External usage is not necessary or supported.
  */
 // eslint-disable-next-line @typescript-eslint/consistent-type-definitions
 export type IDocumentSchemaCurrent = {
@@ -148,21 +154,21 @@ interface IProperty<T = unknown> {
 }
 
 class TrueOrUndefined implements IProperty<true | undefined> {
-	public and(currentDocSchema?: true, desiredDocSchema?: true) {
+	public and(currentDocSchema?: true, desiredDocSchema?: true): true | undefined {
 		return currentDocSchema === true && desiredDocSchema === true ? true : undefined;
 	}
 
-	public or(currentDocSchema?: true, desiredDocSchema?: true) {
+	public or(currentDocSchema?: true, desiredDocSchema?: true): true | undefined {
 		return currentDocSchema === true || desiredDocSchema === true ? true : undefined;
 	}
 
-	public validate(t: unknown) {
+	public validate(t: unknown): t is true | undefined {
 		return t === undefined || t === true;
 	}
 }
 
 class TrueOrUndefinedMax extends TrueOrUndefined {
-	public and(currentDocSchema?: true, desiredDocSchema?: true) {
+	public and(currentDocSchema?: true, desiredDocSchema?: true): true | undefined {
 		return this.or(currentDocSchema, desiredDocSchema);
 	}
 }
@@ -170,7 +176,7 @@ class TrueOrUndefinedMax extends TrueOrUndefined {
 class MultiChoice implements IProperty<string | undefined> {
 	constructor(private readonly choices: string[]) {}
 
-	public and(currentDocSchema?: string, desiredDocSchema?: string) {
+	public and(currentDocSchema?: string, desiredDocSchema?: string): string | undefined {
 		if (currentDocSchema === undefined || desiredDocSchema === undefined) {
 			return undefined;
 		}
@@ -179,7 +185,7 @@ class MultiChoice implements IProperty<string | undefined> {
 		];
 	}
 
-	public or(currentDocSchema?: string, desiredDocSchema?: string) {
+	public or(currentDocSchema?: string, desiredDocSchema?: string): string | undefined {
 		if (currentDocSchema === undefined) {
 			return desiredDocSchema;
 		}
@@ -191,30 +197,36 @@ class MultiChoice implements IProperty<string | undefined> {
 		];
 	}
 
-	public validate(t: unknown) {
+	public validate(t: unknown): boolean {
 		return t === undefined || (typeof t === "string" && this.choices.includes(t));
 	}
 }
 
 class IdCompressorProperty extends MultiChoice {
 	// document schema always wins!
-	public and(currentDocSchema?: string, desiredDocSchema?: string) {
+	public and(currentDocSchema?: string, desiredDocSchema?: string): string | undefined {
 		return currentDocSchema;
 	}
 }
 
 class CheckVersions implements IProperty<string[] | undefined> {
-	public or(currentDocSchema: string[] = [], desiredDocSchema: string[] = []) {
+	public or(
+		currentDocSchema: string[] = [],
+		desiredDocSchema: string[] = [],
+	): string[] | undefined {
 		const set = new Set<string>([...currentDocSchema, ...desiredDocSchema]);
 		return arrayToProp([...set.values()]);
 	}
 
 	// Once version is there, it stays there forever.
-	public and(currentDocSchema: string[] = [], desiredDocSchema: string[] = []) {
+	public and(
+		currentDocSchema: string[] = [],
+		desiredDocSchema: string[] = [],
+	): string[] | undefined {
 		return this.or(currentDocSchema, desiredDocSchema);
 	}
 
-	public validate(t: unknown) {
+	public validate(t: unknown): boolean {
 		return t === undefined || (Array.isArray(t) && !t.includes(pkgVersion));
 	}
 }
@@ -238,7 +250,7 @@ const documentSchemaSupportedConfigs = {
 function checkRuntimeCompatibility(
 	documentSchema: IDocumentSchema | undefined,
 	schemaName: string,
-) {
+): void {
 	// Back-compat - we can't do anything about legacy documents.
 	// There is no way to validate them, so we are taking a guess that safe deployment processes used by a given app
 	// do not run into compat problems.
@@ -278,6 +290,7 @@ function checkRuntimeCompatibility(
 	}
 
 	if (unknownProperty !== undefined) {
+		// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
 		const value = documentSchema[unknownProperty];
 		throw DataProcessingError.create(
 			msg,
@@ -286,6 +299,7 @@ function checkRuntimeCompatibility(
 			{
 				codeVersion: currentDocumentVersionSchema,
 				property: unknownProperty,
+				// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
 				value,
 				schemaName,
 			},
@@ -354,11 +368,11 @@ function same(
 	return true;
 }
 
-function boolToProp(b: boolean) {
+function boolToProp(b: boolean): true | undefined {
 	return b ? true : undefined;
 }
 
-function arrayToProp(arr: string[]) {
+function arrayToProp(arr: string[]): string[] | undefined {
 	return arr.length === 0 ? undefined : arr;
 }
 
@@ -429,6 +443,7 @@ function arrayToProp(arr: string[]) {
  *
  * @legacy
  * @alpha
+ * @deprecated This type will be moved to internal in 2.30. External usage is not necessary or supported.
  * @sealed
  */
 export class DocumentsSchemaController {
@@ -488,9 +503,8 @@ export class DocumentsSchemaController {
 		// Schema coming from document metadata (snapshot we loaded from), or if no document exists
 		// (this is a new document) then this is the same as desiredSchema (same as session schema in such case).
 		// Latter is importnat sure that's what will go into summary.
-		this.documentSchema = !existing
-			? this.desiredSchema
-			: ((documentMetadataSchema as IDocumentSchemaCurrent) ??
+		this.documentSchema = existing
+			? ((documentMetadataSchema as IDocumentSchemaCurrent) ??
 				({
 					version: currentDocumentVersionSchema,
 					// see comment in summarizeDocumentSchema() on why it has to stay zero
@@ -500,7 +514,8 @@ export class DocumentsSchemaController {
 					runtime: {
 						explicitSchemaControl: boolToProp(!existing && features.explicitSchemaControl),
 					},
-				} satisfies IDocumentSchemaCurrent));
+				} satisfies IDocumentSchemaCurrent))
+			: this.desiredSchema;
 
 		checkRuntimeCompatibility(this.documentSchema, "document");
 		this.validateSeqNumber(this.documentSchema.refSeq, snapshotSequenceNumber, "summary");
@@ -580,7 +595,11 @@ export class DocumentsSchemaController {
 		}
 	}
 
-	private validateSeqNumber(schemaSeqNumber: number, lastKnowSeqNumber, message: string) {
+	private validateSeqNumber(
+		schemaSeqNumber: number,
+		lastKnowSeqNumber: number,
+		message: string,
+	): void {
 		if (!Number.isInteger(schemaSeqNumber) || !(schemaSeqNumber <= lastKnowSeqNumber)) {
 			throw DataProcessingError.create(
 				"DocSchema: Incorrect sequence number",
@@ -608,7 +627,7 @@ export class DocumentsSchemaController {
 		content: IDocumentSchemaChangeMessage,
 		local: boolean,
 		sequenceNumber: number,
-	) {
+	): boolean {
 		return this.processDocumentSchemaMessages([content], local, sequenceNumber);
 	}
 
@@ -624,7 +643,7 @@ export class DocumentsSchemaController {
 		contents: IDocumentSchemaChangeMessage[],
 		local: boolean,
 		sequenceNumber: number,
-	) {
+	): boolean {
 		for (const content of contents) {
 			this.validateSeqNumber(content.refSeq, this.documentSchema.refSeq, "content.refSeq");
 			this.validateSeqNumber(this.documentSchema.refSeq, sequenceNumber, "refSeq");
@@ -672,7 +691,7 @@ export class DocumentsSchemaController {
 		return true;
 	}
 
-	public onDisconnect() {
+	public onDisconnect(): void {
 		this.sendOp = true;
 	}
 }

package/src/summary/index.ts

@@ -44,12 +44,10 @@ export {
 	ISummarizeHeuristicData,
 	ISummarizer,
 	ISummarizeResults,
-	ISummarizerEvents,
 	ISummarizerInternalsProvider,
 	ISummarizerRuntime,
 	ISummaryCancellationToken,
 	SubmitSummaryResult,
-	SummarizerStopReason,
 	EnqueueSummarizeResult,
 	IAckSummaryResult,
 	IBaseSummarizeResult,
@@ -67,7 +65,6 @@ export {
 	SubmitSummaryFailureData,
 	SummaryStage,
 	IRetriableFailureError,
-	ISummarizeEventProps,
 } from "./summarizerTypes.js";
 export {
 	IAckedSummary,