@fluidframework/odsp-driver 2.0.0-dev-rc.1.0.0.228517 → 2.0.0-dev-rc.2.0.0.245554

package/src/odspSnapshotParser.ts

@@ -6,8 +6,8 @@
 import { stringToBuffer } from "@fluid-internal/client-utils";
 import { assert } from "@fluidframework/core-utils";
 import * as api from "@fluidframework/protocol-definitions";
-import { IOdspSnapshot, IOdspSnapshotCommit } from "./contracts";
-import { ISnapshotContents } from "./odspPublicUtils";
+import { ISnapshot } from "@fluidframework/driver-definitions";
+import { IOdspSnapshot, IOdspSnapshotCommit } from "./contracts.js";
 
 /**
  * Build a tree hierarchy base on a flat tree
@@ -36,6 +36,7 @@ function buildHierarchy(flatTree: IOdspSnapshotCommit): api.ISnapshotTree {
 				blobs: {},
 				trees: {},
 				unreferenced: entry.unreferenced,
+				groupId: entry.groupId,
 			};
 			node.trees[decodeURIComponent(entryPathBase)] = newTree;
 			lookup[entry.path] = newTree;
@@ -51,12 +52,10 @@ function buildHierarchy(flatTree: IOdspSnapshotCommit): api.ISnapshotTree {
  * Converts existing IOdspSnapshot to snapshot tree, blob array and ops
  * @param odspSnapshot - snapshot
  */
-export function convertOdspSnapshotToSnapshotTreeAndBlobs(
-	odspSnapshot: IOdspSnapshot,
-): ISnapshotContents {
+export function convertOdspSnapshotToSnapshotTreeAndBlobs(odspSnapshot: IOdspSnapshot): ISnapshot {
 	const blobsWithBufferContent = new Map<string, ArrayBuffer>();
 	if (odspSnapshot.blobs) {
-		odspSnapshot.blobs.forEach((blob) => {
+		for (const blob of odspSnapshot.blobs) {
 			assert(
 				blob.encoding === "base64" || blob.encoding === undefined,
 				0x0a4 /* Unexpected blob encoding type */,
@@ -65,13 +64,13 @@ export function convertOdspSnapshotToSnapshotTreeAndBlobs(
 				blob.id,
 				stringToBuffer(blob.content, blob.encoding ?? "utf8"),
 			);
-		});
+		}
 	}
 
 	const sequenceNumber = odspSnapshot?.trees[0].sequenceNumber;
 
-	const val: ISnapshotContents = {
-		blobs: blobsWithBufferContent,
+	const val: ISnapshot = {
+		blobContents: blobsWithBufferContent,
 		ops: odspSnapshot.ops?.map((op) => op.op) ?? [],
 		sequenceNumber,
 		snapshotTree: buildHierarchy(odspSnapshot.trees[0]),
@@ -79,6 +78,7 @@ export function convertOdspSnapshotToSnapshotTreeAndBlobs(
 			odspSnapshot.ops && odspSnapshot.ops.length > 0
 				? odspSnapshot.ops[odspSnapshot.ops.length - 1].sequenceNumber
 				: sequenceNumber,
+		snapshotFormatV: 1,
 	};
 	return val;
 }

package/src/odspSummaryUploadManager.ts

@@ -23,10 +23,10 @@ import {
 	IOdspSummaryTreeBaseEntry,
 	OdspSummaryTreeEntry,
 	OdspSummaryTreeValue,
-} from "./contracts";
-import { EpochTracker } from "./epochTracker";
-import { getUrlAndHeadersWithAuth } from "./getUrlAndHeadersWithAuth";
-import { getWithRetryForTokenRefresh } from "./odspUtils";
+} from "./contracts.js";
+import { EpochTracker } from "./epochTracker.js";
+import { getUrlAndHeadersWithAuth } from "./getUrlAndHeadersWithAuth.js";
+import { getWithRetryForTokenRefresh } from "./odspUtils.js";
 
 /**
  * This class manages a summary upload. When it receives a call to upload summary, it converts the summary tree into
@@ -48,7 +48,10 @@ export class OdspSummaryUploadManager {
 		this.mc = loggerToMonitoringContext(logger);
 	}
 
-	public async writeSummaryTree(tree: api.ISummaryTree, context: ISummaryContext) {
+	public async writeSummaryTree(
+		tree: api.ISummaryTree,
+		context: ISummaryContext,
+	): Promise<string> {
 		// If the last proposed handle is not the proposed handle of the acked summary(could happen when the last summary get nacked),
 		// then re-initialize the caches with the previous ones else just update the previous caches with the caches from acked summary.
 		// Don't bother logging if lastSummaryProposalHandle hasn't been set before; only log on a positive mismatch.
@@ -122,7 +125,7 @@ export class OdspSummaryUploadManager {
 					attempt: options.refresh ? 2 : 1,
 					hasClaims: !!options.claims,
 					hasTenantId: !!options.tenantId,
-					headers: Object.keys(headers).length !== 0 ? true : undefined,
+					headers: Object.keys(headers).length > 0 ? true : undefined,
 					blobs,
 					size: postBody.length,
 					referenceSequenceNumber,
@@ -163,7 +166,10 @@ export class OdspSummaryUploadManager {
 		markUnreferencedNodes: boolean = this.mc.config.getBoolean(
 			"Fluid.Driver.Odsp.MarkUnreferencedNodes",
 		) ?? true,
-	) {
+	): Promise<{
+		snapshotTree: IOdspSummaryTree;
+		blobs: number;
+	}> {
 		const snapshotTree: IOdspSummaryTree = {
 			type: "tree",
 			entries: [] as OdspSummaryTreeEntry[],
@@ -181,6 +187,7 @@ export class OdspSummaryUploadManager {
 			// property is not present, the tree entry is considered referenced. If the property is present and is
 			// true (which is the only value it can have), the tree entry is considered unreferenced.
 			let unreferenced: true | undefined;
+			let groupId: string | undefined;
 			switch (summaryObject.type) {
 				case api.SummaryType.Tree: {
 					const result = await this.convertSummaryToSnapshotTree(
@@ -190,6 +197,7 @@ export class OdspSummaryUploadManager {
 					);
 					value = result.snapshotTree;
 					unreferenced = markUnreferencedNodes ? summaryObject.unreferenced : undefined;
+					groupId = summaryObject.groupId;
 					blobs += result.blobs;
 					break;
 				}
@@ -211,7 +219,7 @@ export class OdspSummaryUploadManager {
 				}
 				case api.SummaryType.Handle: {
 					if (!parentHandle) {
-						throw Error("Parent summary does not exist to reference by handle.");
+						throw new Error("Parent summary does not exist to reference by handle.");
 					}
 					let handlePath = summaryObject.handle;
 					if (handlePath.length > 0 && !handlePath.startsWith("/")) {
@@ -226,7 +234,10 @@ export class OdspSummaryUploadManager {
 					break;
 				}
 				default: {
-					unreachableCase(summaryObject, `Unknown type: ${(summaryObject as any).type}`);
+					unreachableCase(
+						summaryObject,
+						`Unknown type: ${(summaryObject as api.SummaryObject).type}`,
+					);
 				}
 			}
 
@@ -246,6 +257,7 @@ export class OdspSummaryUploadManager {
 					value,
 					...baseEntry,
 					unreferenced,
+					groupId,
 				};
 			} else if (id) {
 				entry = {

package/src/odspUrlHelper.ts

@@ -49,7 +49,7 @@ export function isSpoUrl(url: string): boolean {
 
 	// Format: foo.sharepoint.com/_api/v2.1./drives/bar/items/baz and foo.sharepoint-df.com/...
 	const spoRegex = /(.*\.sharepoint(-df)*\.com)\/_api\/v2.1\/drives\/([^/]*)\/items\/([^/]*)/;
-	return !!spoRegex.exec(urlLower);
+	return spoRegex.test(urlLower);
 }
 
 /**
@@ -88,7 +88,7 @@ export async function getOdspUrlParts(url: URL): Promise<IOdspUrlParts | undefin
 	// Joinsession like URL
 	// Pick a regex based on the hostname
 	// TODO This will only support ODC using api.onedrive.com, update to handle the future (share links etc)
-	let joinSessionMatch;
+	let joinSessionMatch: RegExpExecArray | null;
 	if (isOdcOrigin(url.origin)) {
 		// Capture groups:
 		// 0: match
@@ -97,7 +97,6 @@ export async function getOdspUrlParts(url: URL): Promise<IOdspUrlParts | undefin
 		// 3: optional captured drive ID
 		// 4: Item ID
 		// 5: Drive ID portion of Item ID
-		// eslint-disable-next-line unicorn/no-unsafe-regex
 		joinSessionMatch = /(.*)\/v2\.1\/drive(s\/([\dA-Za-z]+))?\/items\/(([\dA-Za-z]+)!\d+)/.exec(
 			pathname,
 		);

package/src/odspUtils.ts

@@ -3,14 +3,15 @@
  * Licensed under the MIT License.
  */
 
-import { ITelemetryProperties, ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
-import { IResolvedUrl, DriverErrorType } from "@fluidframework/driver-definitions";
+import { ITelemetryBaseProperties, ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
+import { IResolvedUrl, ISnapshot } from "@fluidframework/driver-definitions";
 import {
 	isOnline,
 	OnlineStatus,
 	RetryableError,
 	NonRetryableError,
 	NetworkErrorBasic,
+	type AuthorizationError,
 } from "@fluidframework/driver-utils";
 import { performance } from "@fluid-internal/client-utils";
 import { assert } from "@fluidframework/core-utils";
@@ -20,20 +21,20 @@ import {
 	TelemetryDataTag,
 	createChildLogger,
 	wrapError,
+	type IFluidErrorBase,
 } from "@fluidframework/telemetry-utils";
 import {
 	fetchIncorrectResponse,
 	throwOdspNetworkError,
 	getSPOAndGraphRequestIdsFromResponse,
-} from "@fluidframework/odsp-doclib-utils";
+} from "@fluidframework/odsp-doclib-utils/internal";
 import {
 	IOdspResolvedUrl,
 	TokenFetchOptions,
-	OdspErrorType,
+	OdspErrorTypes,
 	tokenFromResponse,
 	isTokenFromCache,
 	OdspResourceTokenFetchOptions,
-	ShareLinkTypes,
 	ISharingLinkKind,
 	TokenFetcher,
 	ICacheEntry,
@@ -41,14 +42,18 @@ import {
 	InstrumentedStorageTokenFetcher,
 	IOdspUrlParts,
 } from "@fluidframework/odsp-driver-definitions";
-import { fetch } from "./fetch";
-import { pkgVersion as driverVersion } from "./packageVersion";
-import { IOdspSnapshot } from "./contracts";
+import { fetch } from "./fetch.js";
+import { pkgVersion as driverVersion } from "./packageVersion.js";
+import { IOdspSnapshot } from "./contracts.js";
+// eslint-disable-next-line import/no-deprecated
+import { ISnapshotContents } from "./odspPublicUtils.js";
 
 export const getWithRetryForTokenRefreshRepeat = "getWithRetryForTokenRefreshRepeat";
 
-/** Parse the given url and return the origin (host name) */
-export const getOrigin = (url: string) => new URL(url).origin;
+/**
+ * Parse the given url and return the origin (host name)
+ */
+export const getOrigin = (url: string): string => new URL(url).origin;
 
 /**
  * @alpha
@@ -56,16 +61,18 @@ export const getOrigin = (url: string) => new URL(url).origin;
 export interface IOdspResponse<T> {
 	content: T;
 	headers: Map<string, string>;
-	propsToLog: ITelemetryProperties;
+	propsToLog: ITelemetryBaseProperties;
 	duration: number;
 }
 
 export interface TokenFetchOptionsEx extends TokenFetchOptions {
-	/** previous error we hit in getWithRetryForTokenRefresh */
-	previousError?: any;
+	/**
+	 * The previous error we hit in {@link getWithRetryForTokenRefresh}.
+	 */
+	previousError?: unknown;
 }
 
-function headersToMap(headers: Headers) {
+function headersToMap(headers: Headers): Map<string, string> {
 	const newHeaders = new Map<string, string>();
 	for (const [key, value] of headers.entries()) {
 		newHeaders.set(key, value);
@@ -81,24 +88,30 @@ function headersToMap(headers: Headers) {
  */
 export async function getWithRetryForTokenRefresh<T>(
 	get: (options: TokenFetchOptionsEx) => Promise<T>,
-) {
-	return get({ refresh: false }).catch(async (e) => {
-		const options: TokenFetchOptionsEx = { refresh: true, previousError: e };
-		switch (e.errorType) {
+): Promise<T> {
+	return get({ refresh: false }).catch(async (error) => {
+		const options: TokenFetchOptionsEx = { refresh: true, previousError: error };
+		switch ((error as Partial<IFluidErrorBase>).errorType) {
 			// If the error is 401 or 403 refresh the token and try once more.
-			case DriverErrorType.authorizationError:
-				return get({ ...options, claims: e.claims, tenantId: e.tenantId });
+			case OdspErrorTypes.authorizationError: {
+				const authError = error as AuthorizationError;
+				return get({ ...options, claims: authError.claims, tenantId: authError.tenantId });
+			}
 
-			case DriverErrorType.incorrectServerResponse: // some error on the wire, retry once
-			case OdspErrorType.fetchTokenError: // If the token was null, then retry once.
+			case OdspErrorTypes.incorrectServerResponse: // some error on the wire, retry once
+			case OdspErrorTypes.fetchTokenError: {
+				// If the token was null, then retry once.
 				return get(options);
+			}
 
-			default:
+			default: {
 				// Caller may determine that it wants one retry
-				if (e[getWithRetryForTokenRefreshRepeat] === true) {
+				// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unnecessary-type-assertion, @typescript-eslint/no-explicit-any
+				if ((error as any)[getWithRetryForTokenRefreshRepeat] === true) {
 					return get(options);
 				}
-				throw e;
+				throw error;
+			}
 		}
 	});
 }
@@ -112,13 +125,13 @@ export async function fetchHelper(
 	// Node-fetch and dom have conflicting typing, force them to work by casting for now
 	return fetch(requestInfo, requestInit).then(
 		async (fetchResponse) => {
-			const response = fetchResponse as any as Response;
+			const response = fetchResponse as unknown as Response;
 			// Let's assume we can retry.
 			if (!response) {
 				throw new NonRetryableError(
 					// pre-0.58 error message: No response from fetch call
 					"No response from ODSP fetch call",
-					DriverErrorType.incorrectServerResponse,
+					OdspErrorTypes.incorrectServerResponse,
 					{ driverVersion },
 				);
 			}
@@ -153,14 +166,19 @@ export async function fetchHelper(
 			const redactedErrorText = taggedErrorMessage.value.replace(urlRegex, "REDACTED_URL");
 
 			// This error is thrown by fetch() when AbortSignal is provided and it gets cancelled
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 			if (error.name === "AbortError") {
-				throw new RetryableError("Fetch Timeout (AbortError)", OdspErrorType.fetchTimeout, {
-					driverVersion,
-				});
+				throw new RetryableError(
+					"Fetch Timeout (AbortError)",
+					OdspErrorTypes.fetchTimeout,
+					{
+						driverVersion,
+					},
+				);
 			}
 			// TCP/IP timeout
 			if (redactedErrorText.includes("ETIMEDOUT")) {
-				throw new RetryableError("Fetch Timeout (ETIMEDOUT)", OdspErrorType.fetchTimeout, {
+				throw new RetryableError("Fetch Timeout (ETIMEDOUT)", OdspErrorTypes.fetchTimeout, {
 					driverVersion,
 				});
 			}
@@ -170,7 +188,7 @@ export async function fetchHelper(
 				throw new RetryableError(
 					// pre-0.58 error message prefix: Offline
 					`ODSP fetch failure (Offline): ${redactedErrorText}`,
-					DriverErrorType.offlineError,
+					OdspErrorTypes.offlineError,
 					{
 						driverVersion,
 						rawErrorMessage: taggedErrorMessage,
@@ -182,7 +200,7 @@ export async function fetchHelper(
 				throw new RetryableError(
 					// pre-0.58 error message prefix: Fetch error
 					`ODSP fetch failure: ${redactedErrorText}`,
-					DriverErrorType.fetchFailure,
+					OdspErrorTypes.fetchFailure,
 					{
 						driverVersion,
 						rawErrorMessage: taggedErrorMessage,
@@ -206,7 +224,7 @@ export async function fetchArray(
 	let arrayBuffer: ArrayBuffer;
 	try {
 		arrayBuffer = await content.arrayBuffer();
-	} catch (e) {
+	} catch {
 		// Parsing can fail and message could contain full request URI, including
 		// tokens, etc. So do not log error object itself.
 		throwOdspNetworkError(
@@ -240,7 +258,7 @@ export async function fetchAndParseAsJSONHelper<T>(
 	let text: string | undefined;
 	try {
 		text = await content.text();
-	} catch (e) {
+	} catch {
 		// JSON.parse() can fail and message would container full request URI, including
 		// tokens... It fails for me with "Unexpected end of JSON input" quite often - an attempt to download big file
 		// (many ops) almost always ends up with this error - I'd guess 1% of op request end up here... It always
@@ -259,7 +277,7 @@ export async function fetchAndParseAsJSONHelper<T>(
 	propsToLog.bodySize = text.length;
 	const res = {
 		headers,
-		content: JSON.parse(text),
+		content: JSON.parse(text) as T,
 		propsToLog,
 		duration,
 	};
@@ -279,11 +297,8 @@ export interface INewFileInfo extends IFileInfoBase {
 	/**
 	 * application can request creation of a share link along with the creation of a new file
 	 * by passing in an optional param to specify the kind of sharing link
-	 * (at the time of adding this comment Sept/2021), odsp only supports csl
-	 * ShareLinkTypes will deprecated in future. Use ISharingLinkKind instead which specifies both
-	 * share link type and the role type.
 	 */
-	createLinkType?: ShareLinkTypes | ISharingLinkKind;
+	createLinkType?: ISharingLinkKind;
 }
 
 export interface IExistingFileInfo extends IFileInfoBase {
@@ -306,13 +321,15 @@ export function getOdspResolvedUrl(resolvedUrl: IResolvedUrl): IOdspResolvedUrl
 }
 
 /**
+ * Type narrowing utility to determine if the provided {@link @fluidframework/driver-definitions#IResolvedUrl}
+ * is an {@link @fluidframework/odsp-driver-definitions#IOdspResolvedUrl}.
  * @internal
  */
 export function isOdspResolvedUrl(resolvedUrl: IResolvedUrl): resolvedUrl is IOdspResolvedUrl {
 	return "odspResolvedUrl" in resolvedUrl && resolvedUrl.odspResolvedUrl === true;
 }
 
-export const createOdspLogger = (logger?: ITelemetryBaseLogger) =>
+export const createOdspLogger = (logger?: ITelemetryBaseLogger): ITelemetryLoggerExt =>
 	createChildLogger({
 		logger,
 		namespace: "OdspDriver",
@@ -323,7 +340,12 @@ export const createOdspLogger = (logger?: ITelemetryBaseLogger) =>
 		},
 	});
 
-export function evalBlobsAndTrees(snapshot: IOdspSnapshot) {
+export function evalBlobsAndTrees(snapshot: IOdspSnapshot): {
+	numTrees: number;
+	numBlobs: number;
+	encodedBlobsSize: number;
+	decodedBlobsSize: number;
+} {
 	let numTrees = 0;
 	let numBlobs = 0;
 	let encodedBlobsSize = 0;
@@ -391,7 +413,7 @@ export function toInstrumentedOdspTokenFetcher(
 							throw new NonRetryableError(
 								// pre-0.58 error message: Token is null for ${name} call
 								`The Host-provided token fetcher returned null`,
-								OdspErrorType.fetchTokenError,
+								OdspErrorTypes.fetchTokenError,
 								{ method: name, driverVersion },
 							);
 						}
@@ -400,13 +422,14 @@ export function toInstrumentedOdspTokenFetcher(
 					(error) => {
 						// There is an important but unofficial contract here where token providers can set canRetry: true
 						// to hook into the driver's retry logic (e.g. the retry loop when initiating a connection)
+						// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
 						const rawCanRetry = error?.canRetry;
 						const tokenError = wrapError(
 							error,
 							(errorMessage) =>
 								new NetworkErrorBasic(
 									`The Host-provided token fetcher threw an error`,
-									OdspErrorType.fetchTokenError,
+									OdspErrorTypes.fetchTokenError,
 									typeof rawCanRetry === "boolean"
 										? rawCanRetry
 										: false /* canRetry */,
@@ -444,18 +467,14 @@ export const maxUmpPostBodySize = 79872;
  * @returns A string of request parameters that can be concatenated with the base URI
  */
 export function buildOdspShareLinkReqParams(
-	shareLinkType: ShareLinkTypes | ISharingLinkKind | undefined,
-) {
+	shareLinkType: ISharingLinkKind | undefined,
+): string | undefined {
 	if (!shareLinkType) {
 		return;
 	}
-	const scope = (shareLinkType as ISharingLinkKind).scope;
-	if (!scope) {
-		// eslint-disable-next-line @typescript-eslint/no-base-to-string
-		return `createLinkType=${shareLinkType}`;
-	}
+	const scope = shareLinkType.scope;
 	let shareLinkRequestParams = `createLinkScope=${scope}`;
-	const role = (shareLinkType as ISharingLinkKind).role;
+	const role = shareLinkType.role;
 	shareLinkRequestParams = role
 		? `${shareLinkRequestParams}&createLinkRole=${role}`
 		: shareLinkRequestParams;
@@ -476,6 +495,36 @@ export async function measureP<T>(callback: () => Promise<T>): Promise<[T, numbe
 	return [result, time];
 }
 
-export function getJoinSessionCacheKey(odspResolvedUrl: IOdspResolvedUrl) {
+export function getJoinSessionCacheKey(odspResolvedUrl: IOdspResolvedUrl): string {
 	return `${odspResolvedUrl.hashedDocumentId}/joinsession`;
 }
+
+/**
+ * Utility API to check if the type of snapshot contents is `ISnapshot`.
+ * @internal
+ * @param obj - obj whose type needs to be identified.
+ */
+export function isInstanceOfISnapshot(
+	// eslint-disable-next-line import/no-deprecated
+	obj: ISnapshotContents | ISnapshot | undefined,
+): obj is ISnapshot {
+	return obj !== undefined && "snapshotFormatV" in obj && obj.snapshotFormatV === 1;
+}
+
+/**
+ * This tells whether request if for a specific loading group or not. The snapshot which
+ * we fetch on initial load, fetches all ungrouped content.
+ */
+export function isSnapshotFetchForLoadingGroup(loadingGroupIds: string[] | undefined): boolean {
+	return loadingGroupIds !== undefined && loadingGroupIds.length > 0;
+}
+
+/*
+ * This tells whether we are using legacy flow for fetching snapshot where we don't use
+ * groupId query param in the trees latest network call.
+ */
+export function useLegacyFlowWithoutGroupsForSnapshotFetch(
+	loadingGroupIds: string[] | undefined,
+): boolean {
+	return loadingGroupIds === undefined;
+}

package/src/opsCaching.ts

@@ -37,8 +37,8 @@ export class OpsCache {
 		private readonly logger: ITelemetryLoggerExt,
 		private readonly cache: ICache,
 		private readonly batchSize: number,
-		private readonly timerGranularity,
-		private totalOpsToCache,
+		private readonly timerGranularity: number,
+		private totalOpsToCache: number,
 	) {
 		/**
 		 * Initial batch is a special case because it will never be full - all ops prior (inclusive) to
@@ -55,7 +55,7 @@ export class OpsCache {
 		}
 	}
 
-	public dispose() {
+	public dispose(): void {
 		this.batches.clear();
 		if (this.timer !== undefined) {
 			clearTimeout(this.timer);
@@ -63,7 +63,7 @@ export class OpsCache {
 		}
 	}
 
-	public flushOps() {
+	public flushOps(): void {
 		for (const [key, value] of this.batches) {
 			// Don't flush if the batch has no ops, already flushed or has empty slots at both beginning and end.
 			if (
@@ -80,7 +80,7 @@ export class OpsCache {
 		}
 	}
 
-	public addOps(ops: IMessage[]) {
+	public addOps(ops: IMessage[]): void {
 		if (this.totalOpsToCache <= 0) {
 			return;
 		}
@@ -114,6 +114,7 @@ export class OpsCache {
 			if (currentBatch.remainingSlots === 0) {
 				// batch is full, flush to cache
 				this.write(batchNumber, currentBatch);
+				// eslint-disable-next-line unicorn/no-null
 				this.batches.set(batchNumber, null);
 			} else {
 				this.scheduleTimer();
@@ -144,7 +145,7 @@ export class OpsCache {
 			if (res === undefined) {
 				return messages;
 			}
-			const result: CacheEntry = JSON.parse(res);
+			const result: CacheEntry = JSON.parse(res) as CacheEntry;
 			const prevMessagesLength = messages.length;
 			for (const op of result) {
 				// Note that we write out undefined, but due to JSON.stringify, it turns into null!
@@ -160,7 +161,7 @@ export class OpsCache {
 						}
 					}
 					messages.push(op);
-				} else if (messages.length !== 0) {
+				} else if (messages.length > 0) {
 					// If there is any gap, return the messages till now.
 					return messages;
 				}
@@ -199,7 +200,7 @@ export class OpsCache {
 		return messages;
 	}
 
-	protected write(batchNumber: number, payload: IBatch) {
+	protected write(batchNumber: number, payload: IBatch): void {
 		// Errors are caught and logged by PersistedCacheWithErrorHandling that sits
 		// in the adapter chain of cache adapters
 		this.cache
@@ -209,7 +210,7 @@ export class OpsCache {
 			});
 	}
 
-	protected scheduleTimer() {
+	protected scheduleTimer(): void {
 		if (!this.timer && this.timerGranularity > 0) {
 			this.timer = setTimeout(() => {
 				this.timer = undefined;
@@ -218,15 +219,15 @@ export class OpsCache {
 		}
 	}
 
-	private getBatchNumber(sequenceNumber: number) {
+	private getBatchNumber(sequenceNumber: number): number {
 		return Math.floor(sequenceNumber / this.batchSize);
 	}
 
-	private getPositionInBatchArray(sequenceNumber: number) {
+	private getPositionInBatchArray(sequenceNumber: number): number {
 		return sequenceNumber % this.batchSize;
 	}
 
-	private initializeNewBatchDataArray() {
+	private initializeNewBatchDataArray(): IMessage[] {
 		const tempArray: IMessage[] = [];
 		tempArray.length = this.batchSize; // fill with empty, undefined elements
 		return tempArray;

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/odsp-driver";
-export const pkgVersion = "2.0.0-dev-rc.1.0.0.228517";
+export const pkgVersion = "2.0.0-dev-rc.2.0.0.245554";