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

package/src/odspDeltaStorageService.ts

@@ -4,7 +4,7 @@
  */
 
 import { v4 as uuid } from "uuid";
-import { ITelemetryProperties } from "@fluidframework/core-interfaces";
+import { ITelemetryBaseProperties } from "@fluidframework/core-interfaces";
 import { validateMessages } from "@fluidframework/driver-base";
 import { ITelemetryLoggerExt, PerformanceEvent } from "@fluidframework/telemetry-utils";
 import { assert } from "@fluidframework/core-utils";
@@ -13,12 +13,13 @@ import { InstrumentedStorageTokenFetcher } from "@fluidframework/odsp-driver-def
 import {
 	IDeltasFetchResult,
 	IDocumentDeltaStorageService,
+	type IStream,
 } from "@fluidframework/driver-definitions";
 import { requestOps, streamObserver } from "@fluidframework/driver-utils";
-import { IDeltaStorageGetResponse, ISequencedDeltaOpMessage } from "./contracts";
-import { EpochTracker } from "./epochTracker";
-import { getWithRetryForTokenRefresh } from "./odspUtils";
-import { OdspDocumentStorageService } from "./odspDocumentStorageManager";
+import { IDeltaStorageGetResponse, ISequencedDeltaOpMessage } from "./contracts.js";
+import { EpochTracker } from "./epochTracker.js";
+import { getWithRetryForTokenRefresh } from "./odspUtils.js";
+import { OdspDocumentStorageService } from "./odspDocumentStorageManager.js";
 
 /**
  * Provides access to the underlying delta storage on the server for sharepoint driver.
@@ -42,7 +43,7 @@ export class OdspDeltaStorageService {
 	public async get(
 		from: number,
 		to: number,
-		telemetryProps: ITelemetryProperties,
+		telemetryProps: ITelemetryBaseProperties,
 		scenarioName?: string,
 	): Promise<IDeltasFetchResult> {
 		return getWithRetryForTokenRefresh(async (options) => {
@@ -69,7 +70,7 @@ export class OdspDeltaStorageService {
 
 					postBody += `_post: 1\r\n`;
 					postBody += `\r\n--${formBoundary}--`;
-					const headers: { [index: string]: any } = {
+					const headers: { [index: string]: string } = {
 						"Content-Type": `multipart/form-data;boundary=${formBoundary}`,
 					};
 
@@ -105,7 +106,7 @@ export class OdspDeltaStorageService {
 							: (deltaStorageResponse.value as ISequencedDocumentMessage[]);
 
 					event.end({
-						headers: Object.keys(headers).length !== 0 ? true : undefined,
+						headers: Object.keys(headers).length > 0 ? true : undefined,
 						length: messages.length,
 						...response.propsToLog,
 					});
@@ -118,7 +119,7 @@ export class OdspDeltaStorageService {
 		});
 	}
 
-	public buildUrl(from: number, to: number) {
+	public buildUrl(from: number, to: number): string {
 		const filter = encodeURIComponent(
 			`sequenceNumber ge ${from} and sequenceNumber le ${to - 1}`,
 		);
@@ -138,7 +139,7 @@ export class OdspDeltaStorageWithCache implements IDocumentDeltaStorageService {
 		private readonly getFromStorage: (
 			from: number,
 			to: number,
-			telemetryProps: ITelemetryProperties,
+			telemetryProps: ITelemetryBaseProperties,
 			fetchReason?: string,
 		) => Promise<IDeltasFetchResult>,
 		private readonly getCached: (
@@ -156,7 +157,7 @@ export class OdspDeltaStorageWithCache implements IDocumentDeltaStorageService {
 		abortSignal?: AbortSignal,
 		cachedOnly?: boolean,
 		fetchReason?: string,
-	) {
+	): IStream<ISequencedDocumentMessage[]> {
 		// We do not control what's in the cache. Current API assumes that fetchMessages() keeps banging on
 		// storage / cache until it gets ops it needs. This would result in deadlock if fixed range is asked from
 		// cache and it's not there.
@@ -174,9 +175,9 @@ export class OdspDeltaStorageWithCache implements IDocumentDeltaStorageService {
 		const requestCallback = async (
 			from: number,
 			to: number,
-			telemetryProps: ITelemetryProperties,
-		) => {
-			if (this.snapshotOps !== undefined && this.snapshotOps.length !== 0) {
+			telemetryProps: ITelemetryBaseProperties,
+		): Promise<IDeltasFetchResult> => {
+			if (this.snapshotOps !== undefined && this.snapshotOps.length > 0) {
 				const messages = this.snapshotOps.filter(
 					(op) => op.sequenceNumber >= from && op.sequenceNumber < to,
 				);
@@ -200,7 +201,7 @@ export class OdspDeltaStorageWithCache implements IDocumentDeltaStorageService {
 				// Set the firstCacheMiss as true in case we didn't get all the ops.
 				// This will save an extra cache read on "DocumentOpen" or "PostDocumentOpen".
 				this.useCacheForOps = from + messagesFromCache.length >= to;
-				if (messagesFromCache.length !== 0) {
+				if (messagesFromCache.length > 0) {
 					opsFromCache += messagesFromCache.length;
 					return {
 						messages: messagesFromCache,
@@ -221,7 +222,7 @@ export class OdspDeltaStorageWithCache implements IDocumentDeltaStorageService {
 		};
 
 		const stream = requestOps(
-			async (from: number, to: number, telemetryProps: ITelemetryProperties) => {
+			async (from: number, to: number, telemetryProps: ITelemetryBaseProperties) => {
 				const result = await requestCallback(from, to, telemetryProps);
 				// Catch all case, just in case
 				validateMessages("catch all", result.messages, from, this.logger);

package/src/odspDocumentDeltaConnection.ts

@@ -26,11 +26,11 @@ import {
 import { Socket } from "socket.io-client";
 import { v4 as uuid } from "uuid";
 import { createGenericNetworkError } from "@fluidframework/driver-utils";
-import { IOdspSocketError, IGetOpsResponse, IFlushOpsResponse } from "./contracts";
-import { EpochTracker } from "./epochTracker";
-import { errorObjectFromSocketError } from "./odspError";
-import { SocketIOClientStatic } from "./socketModule";
-import { pkgVersion } from "./packageVersion";
+import { IOdspSocketError, IGetOpsResponse, IFlushOpsResponse } from "./contracts.js";
+import { EpochTracker } from "./epochTracker.js";
+import { errorObjectFromSocketError } from "./odspError.js";
+import { SocketIOClientStatic } from "./socketModule.js";
+import { pkgVersion } from "./packageVersion.js";
 
 const protocolVersions = ["^0.4.0", "^0.3.0", "^0.2.0", "^0.1.0"];
 const feature_get_ops = "api_get_ops";
@@ -67,7 +67,7 @@ class SocketReference extends TypedEventEmitter<ISocketEvents> {
 	// Map of all existing socket io sockets. [url, tenantId, documentId] -> socket
 	private static readonly socketIoSockets: Map<string, SocketReference> = new Map();
 
-	public static find(key: string, logger: ITelemetryLoggerExt) {
+	public static find(key: string, logger: ITelemetryLoggerExt): SocketReference | undefined {
 		const socketReference = SocketReference.socketIoSockets.get(key);
 
 		// Verify the socket is healthy before reusing it
@@ -90,7 +90,7 @@ class SocketReference extends TypedEventEmitter<ISocketEvents> {
 	 * Removes a reference for the given key
 	 * Once the ref count hits 0, the socket is disconnected and removed
 	 */
-	public removeSocketIoReference() {
+	public removeSocketIoReference(): void {
 		assert(this.references > 0, 0x09f /* "No more socketIO refs to remove!" */);
 		this.references--;
 
@@ -114,7 +114,7 @@ class SocketReference extends TypedEventEmitter<ISocketEvents> {
 		}
 	}
 
-	public get socket() {
+	public get socket(): Socket {
 		if (!this._socket) {
 			throw new Error(`Invalid socket for key "${this.key}`);
 		}
@@ -140,7 +140,7 @@ class SocketReference extends TypedEventEmitter<ISocketEvents> {
 	private readonly serverDisconnectEventHandler = (
 		socketError: IOdspSocketError,
 		clientId?: string,
-	) => {
+	): void => {
 		// Treat all errors as recoverable, and rely on joinSession / reconnection flow to
 		// filter out retryable vs. non-retryable cases.
 		const error = errorObjectFromSocketError(socketError, "server_disconnect");
@@ -161,14 +161,14 @@ class SocketReference extends TypedEventEmitter<ISocketEvents> {
 		}
 	};
 
-	private clearTimer() {
+	private clearTimer(): void {
 		if (this.delayDeleteTimeout !== undefined) {
 			clearTimeout(this.delayDeleteTimeout);
 			this.delayDeleteTimeout = undefined;
 		}
 	}
 
-	public closeSocket(error?: IAnyDriverError) {
+	public closeSocket(error?: IAnyDriverError): void {
 		if (!this._socket) {
 			return;
 		}
@@ -211,7 +211,7 @@ class SocketReference extends TypedEventEmitter<ISocketEvents> {
 		socket.disconnect();
 	}
 
-	public get disconnected() {
+	public get disconnected(): boolean {
 		if (this._socket === undefined) {
 			return true;
 		}
@@ -319,8 +319,9 @@ export class OdspDocumentDeltaConnection extends DocumentDeltaConnection {
 		try {
 			await deltaConnection.initialize(connectMessage, timeoutMs);
 			await epochTracker.validateEpoch(deltaConnection.details.epoch, "push");
-		} catch (errorObject: any) {
-			if (errorObject !== null && typeof errorObject === "object") {
+			// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		} catch (error: any) {
+			if (error !== null && typeof error === "object") {
 				// We have to special-case error types here in terms of what is re-triable.
 				// These errors have to re-retried, we just need new joinSession result to connect to right server:
 				//    400: Invalid tenant or document id. The WebSocket is connected to a different document
@@ -334,11 +335,13 @@ export class OdspDocumentDeltaConnection extends DocumentDeltaConnection {
 				//    401/403: Code will retry once with new token either way, then it becomes fatal - on this path
 				//         and on join Session path.
 				//    501: (Fluid not enabled): this is fine either way, as joinSession is gatekeeper
-				if (errorObject.statusCode === 400 || errorObject.statusCode === 404) {
-					errorObject.canRetry = true;
+				// eslint-disable-next-line unicorn/no-lonely-if, @typescript-eslint/no-unsafe-member-access
+				if (error.statusCode === 400 || error.statusCode === 404) {
+					// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+					error.canRetry = true;
 				}
 			}
-			throw errorObject;
+			throw error;
 		}
 
 		return deltaConnection;
@@ -357,10 +360,12 @@ export class OdspDocumentDeltaConnection extends DocumentDeltaConnection {
 	/**
 	 * Error raising for socket.io issues
 	 */
+	// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
 	protected createErrorObject(handler: string, error?: any, canRetry = true): IAnyDriverError {
 		// Note: we suspect the incoming error object is either:
 		// - a socketError: add it to the OdspError object for driver to be able to parse it and reason over it.
 		// - anything else: let base class handle it
+		// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 		return canRetry && Number.isInteger(error?.code) && typeof error?.message === "string"
 			? errorObjectFromSocketError(error as IOdspSocketError, handler)
 			: super.createErrorObject(handler, error, canRetry);
@@ -378,6 +383,7 @@ export class OdspDocumentDeltaConnection extends DocumentDeltaConnection {
 		documentId: string,
 		logger: ITelemetryLoggerExt,
 	): SocketReference {
+		// eslint-disable-next-line unicorn/no-array-callback-reference, unicorn/no-array-method-this-argument
 		const existingSocketReference = SocketReference.find(key, logger);
 		if (existingSocketReference) {
 			return existingSocketReference;
@@ -422,7 +428,7 @@ export class OdspDocumentDeltaConnection extends DocumentDeltaConnection {
 	 * @param to - exclusive
 	 * @returns ops retrieved
 	 */
-	public requestOps(from: number, to: number) {
+	public requestOps(from: number, to: number): void {
 		assert(!this.socketReference?.disconnected, 0x413 /* non-active socket */);
 
 		// Given that to is exclusive, we should be asking for at least something!
@@ -430,6 +436,7 @@ export class OdspDocumentDeltaConnection extends DocumentDeltaConnection {
 
 		// PUSH may disable this functionality
 		// back-compat: remove cast to any once latest version of IConnected is consumed
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
 		if ((this.details as any).supportedFeatures?.[feature_get_ops] !== true) {
 			return;
 		}
@@ -481,6 +488,7 @@ export class OdspDocumentDeltaConnection extends DocumentDeltaConnection {
 		assert(!this.socketReference?.disconnected, 0x414 /* non-active socket */);
 
 		// back-compat: remove cast to any once latest version of IConnected is consumed
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
 		if ((this.details as any).supportedFeatures?.[feature_flush_ops] !== true) {
 			// Once single-commit summary is enabled end-to-end, flush support is a must!
 			// The only alternative is change in design where SPO fetches ops from PUSH OR
@@ -511,7 +519,7 @@ export class OdspDocumentDeltaConnection extends DocumentDeltaConnection {
 		return this.flushDeferred.promise;
 	}
 
-	protected disconnectHandler = (error: IFluidErrorBase & OdspError, clientId?: string) => {
+	protected disconnectHandler = (error: IFluidErrorBase & OdspError, clientId?: string): void => {
 		if (clientId === undefined || clientId === this.clientId) {
 			this.logger.sendTelemetryEvent(
 				{
@@ -527,7 +535,7 @@ export class OdspDocumentDeltaConnection extends DocumentDeltaConnection {
 		}
 	};
 
-	protected async initialize(connectMessage: IConnect, timeout: number) {
+	protected async initialize(connectMessage: IConnect, timeout: number): Promise<void> {
 		assert(!this.socketReference?.disconnected, 0x415 /* non-active socket */);
 
 		if (this.enableMultiplexing) {
@@ -535,7 +543,7 @@ export class OdspDocumentDeltaConnection extends DocumentDeltaConnection {
 			this.earlyOpHandler = (
 				messageDocumentId: string,
 				msgs: ISequencedDocumentMessage[],
-			) => {
+			): void => {
 				if (this.documentId === messageDocumentId) {
 					this.queuedMessages.push(...msgs);
 				}
@@ -544,7 +552,7 @@ export class OdspDocumentDeltaConnection extends DocumentDeltaConnection {
 			this.earlySignalHandler = (
 				msg: ISignalMessage | ISignalMessage[],
 				messageDocumentId?: string,
-			) => {
+			): void => {
 				if (messageDocumentId === undefined || messageDocumentId === this.documentId) {
 					if (Array.isArray(msg)) {
 						this.queuedSignals.push(...msg);
@@ -599,14 +607,17 @@ export class OdspDocumentDeltaConnection extends DocumentDeltaConnection {
 				if (result.lastPersistedSequenceNumber === undefined || result.code !== 200) {
 					switch (result.code) {
 						case 409:
-						case 429:
+						case 429: {
 							category = "error";
 							break;
-						case 204:
+						}
+						case 204: {
 							break;
-						default:
+						}
+						default: {
 							category = "error";
 							break;
+						}
 					}
 				}
 				this.logger.sendTelemetryEvent({
@@ -629,10 +640,11 @@ export class OdspDocumentDeltaConnection extends DocumentDeltaConnection {
 		});
 	}
 
-	protected addTrackedListener(event: string, listener: (...args: any[]) => void) {
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	protected addTrackedListener(event: string, listener: (...args: any[]) => void): void {
 		// override some event listeners in order to support multiple documents/clients over the same websocket
 		switch (event) {
-			case "op":
+			case "op": {
 				// per document op handling
 				super.addTrackedListener(
 					event,
@@ -643,8 +655,9 @@ export class OdspDocumentDeltaConnection extends DocumentDeltaConnection {
 					},
 				);
 				break;
+			}
 
-			case "signal":
+			case "signal": {
 				// per document signal handling
 				super.addTrackedListener(
 					event,
@@ -659,8 +672,9 @@ export class OdspDocumentDeltaConnection extends DocumentDeltaConnection {
 					},
 				);
 				break;
+			}
 
-			case "nack":
+			case "nack": {
 				// per client / document nack handling
 				super.addTrackedListener(event, (clientIdOrDocumentId: string, nacks: INack[]) => {
 					const handle =
@@ -687,16 +701,19 @@ export class OdspDocumentDeltaConnection extends DocumentDeltaConnection {
 					}
 				});
 				break;
+			}
 
-			default:
+			default: {
 				super.addTrackedListener(event, listener);
 				break;
+			}
 		}
 	}
 
-	public get disposed() {
+	public get disposed(): boolean {
 		if (!(this._disposed || this.socket.connected)) {
 			// Send error event if this connection is not yet disposed after socket is disconnected for 15s.
+			// eslint-disable-next-line unicorn/no-lonely-if
 			if (this.connectionNotYetDisposedTimeout === undefined) {
 				this.connectionNotYetDisposedTimeout = setTimeout(() => {
 					if (!this._disposed) {
@@ -723,7 +740,7 @@ export class OdspDocumentDeltaConnection extends DocumentDeltaConnection {
 		return !this.disposed && this.socket.connected;
 	}
 
-	protected emitMessages(type: string, messages: IDocumentMessage[][]) {
+	protected emitMessages(type: string, messages: IDocumentMessage[][]): void {
 		// Only submit the op/signals if we are connected.
 		if (this.connected) {
 			this.socket.emit(type, this.clientId, messages);
@@ -751,6 +768,7 @@ export class OdspDocumentDeltaConnection extends DocumentDeltaConnection {
 		};
 
 		// back-compat: the typing for this method and emitMessages is incorrect, will be fixed in a future PR
+		// eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-explicit-any
 		this.emitMessages("submitSignal", [signal] as any);
 	}
 
@@ -758,7 +776,7 @@ export class OdspDocumentDeltaConnection extends DocumentDeltaConnection {
 	 * Critical path where we need to also close the socket for an error.
 	 * @param error - Error causing the socket to close.
 	 */
-	protected closeSocketCore(error: IAnyDriverError) {
+	protected closeSocketCore(error: IAnyDriverError): void {
 		const socket = this.socketReference;
 		assert(socket !== undefined, 0x416 /* reentrancy not supported in close socket */);
 		socket.closeSocket(error);
@@ -771,7 +789,7 @@ export class OdspDocumentDeltaConnection extends DocumentDeltaConnection {
 	/**
 	 * Disconnect from the websocket
 	 */
-	protected disconnectCore() {
+	protected disconnectCore(): void {
 		const socket = this.socketReference;
 		assert(socket !== undefined, 0x0a2 /* "reentrancy not supported!" */);
 		this.socketReference = undefined;

package/src/odspDocumentService.ts

@@ -8,6 +8,7 @@ import {
 	createChildMonitoringContext,
 	MonitoringContext,
 } from "@fluidframework/telemetry-utils";
+import { TypedEventEmitter } from "@fluid-internal/client-utils";
 import { assert } from "@fluidframework/core-utils";
 import {
 	IDocumentDeltaConnection,
@@ -16,6 +17,7 @@ import {
 	IResolvedUrl,
 	IDocumentStorageService,
 	IDocumentServicePolicies,
+	IDocumentServiceEvents,
 } from "@fluidframework/driver-definitions";
 import { IClient, ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
 import {
@@ -25,22 +27,25 @@ import {
 	HostStoragePolicy,
 	InstrumentedStorageTokenFetcher,
 } from "@fluidframework/odsp-driver-definitions";
-import { HostStoragePolicyInternal } from "./contracts";
-import { IOdspCache } from "./odspCache";
-import { OdspDeltaStorageService, OdspDeltaStorageWithCache } from "./odspDeltaStorageService";
-import { OdspDocumentStorageService } from "./odspDocumentStorageManager";
-import { getOdspResolvedUrl } from "./odspUtils";
-import { isOdcOrigin } from "./odspUrlHelper";
-import { EpochTracker } from "./epochTracker";
-import { OpsCache } from "./opsCaching";
-import { RetryErrorsStorageAdapter } from "./retryErrorsStorageAdapter";
-import type { OdspDelayLoadedDeltaStream } from "./odspDelayLoadedDeltaStream";
+import { HostStoragePolicyInternal } from "./contracts.js";
+import { IOdspCache } from "./odspCache.js";
+import { OdspDeltaStorageService, OdspDeltaStorageWithCache } from "./odspDeltaStorageService.js";
+import { OdspDocumentStorageService } from "./odspDocumentStorageManager.js";
+import { getOdspResolvedUrl } from "./odspUtils.js";
+import { isOdcOrigin } from "./odspUrlHelper.js";
+import { EpochTracker } from "./epochTracker.js";
+import { OpsCache } from "./opsCaching.js";
+import { RetryErrorsStorageAdapter } from "./retryErrorsStorageAdapter.js";
+import type { OdspDelayLoadedDeltaStream } from "./odspDelayLoadedDeltaStream.js";
 
 /**
  * The DocumentService manages the Socket.IO connection and manages routing requests to connected
  * clients
  */
-export class OdspDocumentService implements IDocumentService {
+export class OdspDocumentService
+	extends TypedEventEmitter<IDocumentServiceEvents>
+	implements IDocumentService
+{
 	private readonly _policies: IDocumentServicePolicies;
 
 	// Promise to load socket module only once.
@@ -51,6 +56,8 @@ export class OdspDocumentService implements IDocumentService {
 	private odspSocketModuleLoaded: boolean = false;
 
 	/**
+	 * Creates a new OdspDocumentService instance.
+	 *
 	 * @param resolvedUrl - resolved url identifying document that will be managed by returned service instance.
 	 * @param getStorageToken - function that can provide the storage token. This is is also referred to as
 	 * the "Vroom" token in SPO.
@@ -123,10 +130,12 @@ export class OdspDocumentService implements IDocumentService {
 		private readonly socketReferenceKeyPrefix?: string,
 		private readonly clientIsSummarizer?: boolean,
 	) {
+		super();
 		this._policies = {
 			// load in storage-only mode if a file version is specified
 			storageOnly: odspResolvedUrl.fileVersion !== undefined,
 			summarizeProtocolTree: true,
+			supportGetSnapshotApi: true,
 		};
 
 		this.mc = createChildMonitoringContext({
@@ -141,6 +150,7 @@ export class OdspDocumentService implements IDocumentService {
 		});
 
 		this.hostPolicy = hostPolicy;
+		this.hostPolicy.supportGetSnapshotApi = this._policies.supportGetSnapshotApi;
 		if (this.clientIsSummarizer) {
 			this.hostPolicy = { ...this.hostPolicy, summarizerClient: true };
 		}
@@ -149,7 +159,7 @@ export class OdspDocumentService implements IDocumentService {
 	public get resolvedUrl(): IResolvedUrl {
 		return this.odspResolvedUrl;
 	}
-	public get policies() {
+	public get policies(): IDocumentServicePolicies {
 		return this._policies;
 	}
 
@@ -259,7 +269,7 @@ export class OdspDocumentService implements IDocumentService {
 	 * import this later on when required.
 	 * @returns The delta stream object.
 	 */
-	private async getDelayLoadedDeltaStream() {
+	private async getDelayLoadedDeltaStream(): Promise<OdspDelayLoadedDeltaStream> {
 		assert(this.odspSocketModuleLoaded === false, 0x507 /* Should be loaded only once */);
 		const module = await import(
 			/* webpackChunkName: "socketModule" */ "./odspDelayLoadedDeltaStream.js"
@@ -282,27 +292,28 @@ export class OdspDocumentService implements IDocumentService {
 			this.hostPolicy,
 			this.epochTracker,
 			(ops: ISequencedDocumentMessage[]) => this.opsReceived(ops),
+			(metadata: Record<string, string>) => this.emit("metadataUpdate", metadata),
 			this.socketReferenceKeyPrefix,
 		);
 		return this.odspDelayLoadedDeltaStream;
 	}
 
-	public dispose(error?: any) {
+	public dispose(error?: unknown): void {
 		// Error might indicate mismatch between client & server knowledge about file
-		// (DriverErrorType.fileOverwrittenInStorage).
+		// (OdspErrorTypes.fileOverwrittenInStorage).
 		// For example, file might have been overwritten in storage without generating new epoch
 		// In such case client cached info is stale and has to be removed.
-		if (error !== undefined) {
-			this.epochTracker.removeEntries().catch(() => {});
-		} else {
+		if (error === undefined) {
 			this._opsCache?.flushOps();
+		} else {
+			this.epochTracker.removeEntries().catch(() => {});
 		}
 		this._opsCache?.dispose();
 		// Only need to dipose this, if it is already loaded.
 		this.odspDelayLoadedDeltaStream?.dispose();
 	}
 
-	protected get opsCache() {
+	protected get opsCache(): OpsCache | undefined {
 		if (this._opsCache) {
 			return this._opsCache;
 		}
@@ -321,11 +332,11 @@ export class OdspDocumentService implements IDocumentService {
 			this.mc.logger,
 			// ICache
 			{
-				write: async (key: string, opsData: string) => {
+				write: async (key: string, opsData: string): Promise<void> => {
 					return this.cache.persistedCache.put({ ...opsKey, key }, opsData);
 				},
 				read: async (key: string) => this.cache.persistedCache.get({ ...opsKey, key }),
-				remove: () => {
+				remove: (): void => {
 					this.cache.persistedCache.removeEntries().catch(() => {});
 				},
 			},
@@ -338,7 +349,7 @@ export class OdspDocumentService implements IDocumentService {
 
 	// Called whenever re receive ops through any channel for this document (snapshot, delta connection, delta storage)
 	// We use it to notify caching layer of how stale is snapshot stored in cache.
-	protected opsReceived(ops: ISequencedDocumentMessage[]) {
+	protected opsReceived(ops: ISequencedDocumentMessage[]): void {
 		// No need for two clients to save same ops
 		if (ops.length === 0 || this.odspResolvedUrl.summarizer) {
 			return;

package/src/odspDocumentServiceFactory.ts

@@ -10,9 +10,9 @@ import {
 	IPersistedCache,
 	HostStoragePolicy,
 } from "@fluidframework/odsp-driver-definitions";
-import { OdspDocumentServiceFactoryCore } from "./odspDocumentServiceFactoryCore";
+import { OdspDocumentServiceFactoryCore } from "./odspDocumentServiceFactoryCore.js";
 // eslint-disable-next-line import/no-internal-modules
-import { LocalOdspDocumentServiceFactory } from "./localOdspDriver/localOdspDocumentServiceFactory";
+import { LocalOdspDocumentServiceFactory } from "./localOdspDriver/localOdspDocumentServiceFactory.js";
 
 /**
  * Factory for creating the sharepoint document service. Use this if you want to
@@ -31,6 +31,11 @@ export class OdspDocumentServiceFactory extends OdspDocumentServiceFactoryCore {
 }
 
 /**
+ * Creates a factory instance for creating a sharepoint document service from a provided snapshot.
+ *
+ * @remarks Use if you don't want to connect to any kind of external/internal storages and want to provide
+ * content directly.
+ *
  * @alpha
  */
 export function createLocalOdspDocumentServiceFactory(