@fluidframework/odsp-driver 2.0.0-dev-rc.1.0.0.232845 → 2.0.0-dev-rc.2.0.0.246488

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,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { ITelemetryProperties, ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
+import { ITelemetryBaseProperties, ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
 import { IResolvedUrl, ISnapshot } from "@fluidframework/driver-definitions";
 import {
 	isOnline,
@@ -11,6 +11,7 @@ import {
 	RetryableError,
 	NonRetryableError,
 	NetworkErrorBasic,
+	type AuthorizationError,
 } from "@fluidframework/driver-utils";
 import { performance } from "@fluid-internal/client-utils";
 import { assert } from "@fluidframework/core-utils";
@@ -20,12 +21,13 @@ 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,
@@ -40,15 +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 { ISnapshotContents } from "./odspPublicUtils";
+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 OdspErrorTypes.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 OdspErrorTypes.incorrectServerResponse: // some error on the wire, retry once
-			case OdspErrorTypes.fetchTokenError: // If the token was null, then 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,7 +125,7 @@ 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(
@@ -153,6 +166,7 @@ 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)",
@@ -210,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(
@@ -244,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
@@ -263,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,
 	};
@@ -307,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",
@@ -324,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;
@@ -401,6 +422,7 @@ 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,
@@ -444,7 +466,9 @@ export const maxUmpPostBodySize = 79872;
  * @param shareLinkType - Kind of sharing link requested
  * @returns A string of request parameters that can be concatenated with the base URI
  */
-export function buildOdspShareLinkReqParams(shareLinkType: ISharingLinkKind | undefined) {
+export function buildOdspShareLinkReqParams(
+	shareLinkType: ISharingLinkKind | undefined,
+): string | undefined {
 	if (!shareLinkType) {
 		return;
 	}
@@ -471,7 +495,7 @@ 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`;
 }
 
@@ -481,7 +505,26 @@ export function getJoinSessionCacheKey(odspResolvedUrl: IOdspResolvedUrl) {
  * @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.232845";
+export const pkgVersion = "2.0.0-dev-rc.2.0.0.246488";

package/src/prefetchLatestSnapshot.ts

@@ -16,21 +16,22 @@ import {
 	IOdspUrlParts,
 	getKeyForCacheEntry,
 } from "@fluidframework/odsp-driver-definitions";
-import { createChildLogger, PerformanceEvent } from "@fluidframework/telemetry-utils";
+import { createChildMonitoringContext, PerformanceEvent } from "@fluidframework/telemetry-utils";
 import {
 	createCacheSnapshotKey,
 	createOdspLogger,
 	getOdspResolvedUrl,
 	toInstrumentedOdspTokenFetcher,
-} from "./odspUtils";
+} from "./odspUtils.js";
 import {
 	downloadSnapshot,
 	fetchSnapshotWithRedeem,
+	ISnapshotRequestAndResponseOptions,
 	SnapshotFormatSupportType,
-} from "./fetchSnapshot";
-import { IVersionedValueWithEpoch } from "./contracts";
-import { IPrefetchSnapshotContents } from "./odspCache";
-import { OdspDocumentServiceFactory } from "./odspDocumentServiceFactory";
+} from "./fetchSnapshot.js";
+import { IVersionedValueWithEpoch } from "./contracts.js";
+import { IPrefetchSnapshotContents } from "./odspCache.js";
+import { OdspDocumentServiceFactory } from "./odspDocumentServiceFactory.js";
 
 /**
  * Function to prefetch the snapshot and cached it in the persistant cache, so that when the container is loaded
@@ -66,9 +67,14 @@ export async function prefetchLatestSnapshot(
 	snapshotFormatFetchType?: SnapshotFormatSupportType,
 	odspDocumentServiceFactory?: OdspDocumentServiceFactory,
 ): Promise<boolean> {
-	const odspLogger = createOdspLogger(
-		createChildLogger({ logger, namespace: "PrefetchSnapshot" }),
+	const mc = createChildMonitoringContext({ logger, namespace: "PrefetchSnapshot" });
+	const odspLogger = createOdspLogger(mc.logger);
+	const useGroupIdsForSnapshotFetch = mc.config.getBoolean(
+		"Fluid.Container.UseLoadingGroupIdForSnapshotFetch",
 	);
+	// For prefetch, we just want to fetch the ungrouped data and want to use the new API if the
+	// feature gate is set, so provide an empty array.
+	const loadingGroupIds = useGroupIdsForSnapshotFetch ? [] : undefined;
 	const odspResolvedUrl = getOdspResolvedUrl(resolvedUrl);
 
 	const resolvedUrlData: IOdspUrlParts = {
@@ -86,13 +92,14 @@ export async function prefetchLatestSnapshot(
 	const snapshotDownloader = async (
 		finalOdspResolvedUrl: IOdspResolvedUrl,
 		storageToken: string,
+		loadingGroupId: string[] | undefined,
 		snapshotOptions: ISnapshotOptions | undefined,
 		controller?: AbortController,
-	) => {
+	): Promise<ISnapshotRequestAndResponseOptions> => {
 		return downloadSnapshot(
 			finalOdspResolvedUrl,
 			storageToken,
-			odspLogger,
+			loadingGroupId,
 			snapshotOptions,
 			undefined,
 			controller,
@@ -101,12 +108,13 @@ export async function prefetchLatestSnapshot(
 	const snapshotKey = createCacheSnapshotKey(odspResolvedUrl);
 	let cacheP: Promise<void> | undefined;
 	let snapshotEpoch: string | undefined;
-	const putInCache = async (valueWithEpoch: IVersionedValueWithEpoch) => {
+	const putInCache = async (valueWithEpoch: IVersionedValueWithEpoch): Promise<void> => {
 		snapshotEpoch = valueWithEpoch.fluidEpoch;
 		cacheP = persistedCache.put(snapshotKey, valueWithEpoch);
 		return cacheP;
 	};
-	const removeEntries = async () => persistedCache.removeEntries(snapshotKey.file);
+
+	const removeEntries = async (): Promise<void> => persistedCache.removeEntries(snapshotKey.file);
 	return PerformanceEvent.timedExecAsync(
 		odspLogger,
 		{ eventName: "PrefetchLatestSnapshot" },
@@ -130,6 +138,7 @@ export async function prefetchLatestSnapshot(
 				snapshotDownloader,
 				putInCache,
 				removeEntries,
+				loadingGroupIds,
 				enableRedeemFallback,
 			)
 				.then(async (value) => {
@@ -157,11 +166,11 @@ export async function prefetchLatestSnapshot(
 						snapshotNonPersistentCache?.remove(nonPersistentCacheKey);
 					}, 5000);
 				})
-				.catch((err) => {
+				.catch((error) => {
 					// Remove it from the non persistent cache if an error occured.
 					snapshotNonPersistentCache?.remove(nonPersistentCacheKey);
-					snapshotContentsWithEpochP.reject(err);
-					throw err;
+					snapshotContentsWithEpochP.reject(error);
+					throw error;
 				});
 			return true;
 		},

package/src/retryErrorsStorageAdapter.ts

@@ -20,7 +20,7 @@ import {
 	IVersion,
 } from "@fluidframework/protocol-definitions";
 import { IDisposable } from "@fluidframework/core-interfaces";
-import { runWithRetry } from "./retryUtils";
+import { runWithRetry } from "./retryUtils.js";
 
 export class RetryErrorsStorageAdapter implements IDocumentStorageService, IDisposable {
 	private _disposed = false;
@@ -32,17 +32,13 @@ export class RetryErrorsStorageAdapter implements IDocumentStorageService, IDisp
 	public get policies(): IDocumentStorageServicePolicies | undefined {
 		return this.internalStorageService.policies;
 	}
-	public get disposed() {
+	public get disposed(): boolean {
 		return this._disposed;
 	}
-	public dispose() {
+	public dispose(): void {
 		this._disposed = true;
 	}
 
-	public get repositoryUrl(): string {
-		return this.internalStorageService.repositoryUrl;
-	}
-
 	// eslint-disable-next-line @rushstack/no-new-null
 	public async getSnapshotTree(version?: IVersion): Promise<ISnapshotTree | null> {
 		return this.runWithRetry(
@@ -111,7 +107,7 @@ export class RetryErrorsStorageAdapter implements IDocumentStorageService, IDisp
 		);
 	}
 
-	private checkStorageDisposed() {
+	private checkStorageDisposed(): void {
 		if (this._disposed) {
 			// pre-0.58 error message: storageServiceDisposedCannotRetry
 			throw new LoggingError("Storage Service is disposed. Cannot retry", {

package/src/retryUtils.ts

@@ -8,7 +8,7 @@ import { performance } from "@fluid-internal/client-utils";
 import { delay } from "@fluidframework/core-utils";
 import { canRetryOnError, getRetryDelayFromError } from "@fluidframework/driver-utils";
 import { OdspErrorTypes } from "@fluidframework/odsp-driver-definitions";
-import { Odsp409Error } from "./epochTracker";
+import { Odsp409Error } from "./epochTracker.js";
 
 /**
  * This method retries only for retriable coherency and service read only errors.
@@ -21,7 +21,7 @@ export async function runWithRetry<T>(
 ): Promise<T> {
 	let retryAfter = 1000;
 	const start = performance.now();
-	let lastError: any;
+	let lastError: unknown;
 	for (let attempts = 1; ; attempts++) {
 		if (checkDisposed !== undefined) {
 			checkDisposed();
@@ -40,10 +40,13 @@ export async function runWithRetry<T>(
 				);
 			}
 			return result;
+			// eslint-disable-next-line @typescript-eslint/no-explicit-any
 		} catch (error: any) {
 			const canRetry = canRetryOnError(error);
 
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 			const coherencyError = error?.[Odsp409Error] === true;
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 			const serviceReadonlyError = error?.errorType === OdspErrorTypes.serviceReadOnly;
 
 			// logging the first failed retry instead of every attempt. We want to avoid filling telemetry
@@ -84,6 +87,7 @@ export async function runWithRetry<T>(
 					error,
 				);
 				// Fail hard.
+				// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 				error.canRetry = false;
 				throw error;
 			}

package/src/socketModule.ts

@@ -5,4 +5,6 @@
 
 import { io } from "socket.io-client";
 
+// Import is required for side-effects.
+// eslint-disable-next-line unicorn/prefer-export-from
 export const SocketIOClientStatic = io;