@fluidframework/odsp-driver 1.4.0-121020 → 2.0.0-dev-rc.1.0.0.225277

package/src/getFileLink.ts

@@ -3,21 +3,23 @@
  * Licensed under the MIT License.
  */
 
-import { ITelemetryLogger } from "@fluidframework/common-definitions";
-import { assert } from "@fluidframework/common-utils";
-import { canRetryOnError, NonRetryableError } from "@fluidframework/driver-utils";
-import { PerformanceEvent } from "@fluidframework/telemetry-utils";
+import { ITelemetryLoggerExt, PerformanceEvent } from "@fluidframework/telemetry-utils";
+import { assert } from "@fluidframework/core-utils";
+import { NonRetryableError, runWithRetry } from "@fluidframework/driver-utils";
 import { DriverErrorType } from "@fluidframework/driver-definitions";
 import {
-    IOdspUrlParts,
-    OdspResourceTokenFetchOptions,
-    IdentityType,
-    TokenFetcher,
+	IOdspUrlParts,
+	OdspResourceTokenFetchOptions,
+	TokenFetcher,
 } from "@fluidframework/odsp-driver-definitions";
 import { getUrlAndHeadersWithAuth } from "./getUrlAndHeadersWithAuth";
-import { fetchHelper, getWithRetryForTokenRefresh, toInstrumentedOdspTokenFetcher } from "./odspUtils";
+import {
+	fetchHelper,
+	getWithRetryForTokenRefresh,
+	toInstrumentedOdspTokenFetcher,
+} from "./odspUtils";
 import { pkgVersion as driverVersion } from "./packageVersion";
-import { runWithRetry } from "./retryUtils";
+import { runWithRetry as runWithRetryForCoherencyAndServiceReadOnlyErrors } from "./retryUtils";
 
 // Store cached responses for the lifetime of web session as file link remains the same for given file item
 const fileLinkCache = new Map<string, Promise<string>>();
@@ -29,175 +31,212 @@ const fileLinkCache = new Map<string, Promise<string>>();
  * throttling error. In future, we are thinking of app allowing to pass some cancel token, with which
  * we would be able to stop retrying.
  * @param getToken - used to fetch access tokens needed to execute operation
- * @param siteUrl - url of the site that contains the file
- * @param driveId - drive where file is stored
- * @param itemId - file id
- * @param identityType - type of client account
+ * @param odspUrlParts - object describing file storage identity
  * @param logger - used to log results of operation, including any error
  * @returns Promise which resolves to file link url when successful; otherwise, undefined.
  */
 export async function getFileLink(
-    getToken: TokenFetcher<OdspResourceTokenFetchOptions>,
-    odspUrlParts: IOdspUrlParts,
-    identityType: IdentityType,
-    logger: ITelemetryLogger,
+	getToken: TokenFetcher<OdspResourceTokenFetchOptions>,
+	odspUrlParts: IOdspUrlParts,
+	logger: ITelemetryLoggerExt,
 ): Promise<string> {
-    const cacheKey = `${odspUrlParts.siteUrl}_${odspUrlParts.driveId}_${odspUrlParts.itemId}`;
-    const maybeFileLinkCacheEntry = fileLinkCache.get(cacheKey);
-    if (maybeFileLinkCacheEntry !== undefined) {
-        return maybeFileLinkCacheEntry;
-    }
+	const cacheKey = `${odspUrlParts.siteUrl}_${odspUrlParts.driveId}_${odspUrlParts.itemId}`;
+	const maybeFileLinkCacheEntry = fileLinkCache.get(cacheKey);
+	if (maybeFileLinkCacheEntry !== undefined) {
+		return maybeFileLinkCacheEntry;
+	}
 
-    const fileLinkGenerator = async function() {
-        let fileLinkCore: string;
-        try {
-            fileLinkCore = await runWithRetry(
-                async () => getFileLinkCore(getToken, odspUrlParts, identityType, logger),
-                "getFileLinkCore",
-                logger,
-            );
-        } catch (err) {
-            // runWithRetry throws a non retriable error after it hits the max # of attempts
-            // or encounters an unexpected error type
-            if (!canRetryOnError(err)) {
-                // Delete from the cache to permit retrying later.
-                fileLinkCache.delete(cacheKey);
-            }
-            throw err;
-        }
+	const fileLinkGenerator = async function () {
+		let fileLinkCore: string;
+		try {
+			let retryCount = 0;
+			fileLinkCore = await runWithRetry(
+				async () =>
+					runWithRetryForCoherencyAndServiceReadOnlyErrors(
+						async () => getFileLinkCore(getToken, odspUrlParts, logger),
+						"getFileLinkCore",
+						logger,
+					),
+				"getShareLink",
+				logger,
+				{
+					onRetry(delayInMs: number, error: any) {
+						retryCount++;
+						if (retryCount === 5) {
+							if (error !== undefined && typeof error === "object") {
+								error.canRetry = false;
+								throw error;
+							}
+							throw error;
+						}
+					},
+				},
+			);
+		} catch (err) {
+			// Delete from the cache to permit retrying later.
+			fileLinkCache.delete(cacheKey);
+			throw err;
+		}
 
-        // We are guaranteed to run the getFileLinkCore at least once with successful result (which must be a string)
-        assert(fileLinkCore !== undefined, 0x292 /* "Unexpected undefined result from getFileLinkCore" */);
-        return fileLinkCore;
-    };
-    const fileLink = fileLinkGenerator();
-    fileLinkCache.set(cacheKey, fileLink);
-    return fileLink;
+		// We are guaranteed to run the getFileLinkCore at least once with successful result (which must be a string)
+		assert(
+			fileLinkCore !== undefined,
+			0x292 /* "Unexpected undefined result from getFileLinkCore" */,
+		);
+		return fileLinkCore;
+	};
+	const fileLink = fileLinkGenerator();
+	fileLinkCache.set(cacheKey, fileLink);
+	return fileLink;
 }
 
 async function getFileLinkCore(
-    getToken: TokenFetcher<OdspResourceTokenFetchOptions>,
-    odspUrlParts: IOdspUrlParts,
-    identityType: IdentityType,
-    logger: ITelemetryLogger,
+	getToken: TokenFetcher<OdspResourceTokenFetchOptions>,
+	odspUrlParts: IOdspUrlParts,
+	logger: ITelemetryLoggerExt,
 ): Promise<string> {
-    const fileItem = await getFileItemLite(getToken, odspUrlParts, logger, identityType === "Consumer");
+	const fileItem = await getFileItemLite(getToken, odspUrlParts, logger, true);
+
+	// ODSP link requires extra call to return link that is resistant to file being renamed or moved to different folder
+	return PerformanceEvent.timedExecAsync(
+		logger,
+		{ eventName: "odspFileLink", requestName: "getSharingInformation" },
+		async (event) => {
+			let attempts = 0;
+			let additionalProps;
+			const fileLink = await getWithRetryForTokenRefresh(async (options) => {
+				attempts++;
+				const storageTokenFetcher = toInstrumentedOdspTokenFetcher(
+					logger,
+					odspUrlParts,
+					getToken,
+					true /* throwOnNullToken */,
+				);
+				const storageToken = await storageTokenFetcher(options, "GetFileLinkCore");
+				assert(
+					storageToken !== null,
+					0x2bb /* "Instrumented token fetcher with throwOnNullToken = true should never return null" */,
+				);
 
-    // ODSP link requires extra call to return link that is resistant to file being renamed or moved to different folder
-    return PerformanceEvent.timedExecAsync(
-        logger,
-        { eventName: "odspFileLink", requestName: "getSharingLink" },
-        async (event) => {
-            let attempts = 0;
-            let additionalProps;
-            const fileLink = await getWithRetryForTokenRefresh(async (options) => {
-                attempts++;
-                const storageTokenFetcher = toInstrumentedOdspTokenFetcher(
-                    logger,
-                    odspUrlParts,
-                    getToken,
-                    true /* throwOnNullToken */,
-                );
-                const storageToken = await storageTokenFetcher(options, "GetFileLinkCore");
-                assert(storageToken !== null,
-                    0x2bb /* "Instrumented token fetcher with throwOnNullToken = true should never return null" */);
+				// IMPORTANT: In past we were using GetFileByUrl() API to get to the list item that was corresponding
+				// to the file. This was intentionally replaced with GetFileById() to solve the following issue:
+				// GetFileByUrl() uses webDavUrl to locate list item. This API does not work for Consumer scenarios
+				// where webDavUrl is constructed using legacy ODC format for backward compatibility reasons.
+				// GetFileByUrl() does not understand that format and thus fails. GetFileById() relies on file item
+				// unique guid (sharepointIds.listItemUniqueId) and it works uniformly across Consumer and Commercial.
+				const { url, headers } = getUrlAndHeadersWithAuth(
+					`${
+						odspUrlParts.siteUrl
+					}/_api/web/GetFileById(@a1)/ListItemAllFields/GetSharingInformation?@a1=guid${encodeURIComponent(
+						`'${fileItem.sharepointIds.listItemUniqueId}'`,
+					)}`,
+					storageToken,
+					true,
+				);
+				const requestInit = {
+					method: "POST",
+					headers: {
+						"Content-Type": "application/json;odata=verbose",
+						"Accept": "application/json;odata=verbose",
+						...headers,
+					},
+				};
+				const response = await fetchHelper(url, requestInit);
+				additionalProps = response.propsToLog;
 
-                const { url, headers } = getUrlAndHeadersWithAuth(
-                    `${odspUrlParts.siteUrl}/_api/web/GetFileByServerRelativeUrl(@a1)/Linkingurl?@a1=${
-                        encodeURIComponent(`'${new URL(fileItem.webDavUrl).pathname}'`)
-                    }`,
-                    storageToken,
-                    false,
-                );
-                const requestInit = {
-                    method: "POST",
-                    headers: {
-                        "Content-Type": "application/json;odata=verbose",
-                        "Accept": "application/json;odata=verbose",
-                        ...headers,
-                    },
-                };
-                const response = await fetchHelper(url, requestInit);
-                additionalProps = response.propsToLog;
+				const sharingInfo = await response.content.json();
+				const directUrl = sharingInfo?.d?.directUrl;
+				if (typeof directUrl !== "string") {
+					// This will retry once in getWithRetryForTokenRefresh
+					throw new NonRetryableError(
+						"Malformed GetSharingInformation response",
+						DriverErrorType.incorrectServerResponse,
+						{ driverVersion },
+					);
+				}
+				return directUrl;
+			});
+			event.end({ ...additionalProps, attempts });
+			return fileLink;
+		},
+	);
+}
 
-                const sharingInfo = await response.content.json();
-                const linkingUrl = sharingInfo?.d?.LinkingUrl;
-                if (typeof linkingUrl !== "string") {
-                    // This will retry once in getWithRetryForTokenRefresh
-                    throw new NonRetryableError(
-                        "Malformed GetSharingLink response",
-                        DriverErrorType.incorrectServerResponse,
-                        { driverVersion });
-                }
-                return linkingUrl;
-            });
-            event.end({ ...additionalProps, attempts });
-            return fileLink;
-        },
-    );
+/**
+ * Sharepoint Ids Interface
+ */
+interface IGraphSharepointIds {
+	listId: string;
+	listItemId: string;
+	listItemUniqueId: string;
+	siteId: string;
+	siteUrl: string;
+	webId: string;
 }
 
 /**
- * This represents a lite version of file item containing only the webUrl and webDavUrl properties
+ * This represents a lite version of file item containing only select file properties
  */
 interface FileItemLite {
-    webUrl: string;
-    webDavUrl: string;
+	webUrl: string;
+	webDavUrl: string;
+	sharepointIds: IGraphSharepointIds;
 }
 
-const isFileItemLite = (maybeFileItemLite: any): maybeFileItemLite is FileItemLite => {
-    if (typeof maybeFileItemLite.webUrl !== "string" || typeof maybeFileItemLite.webDavUrl !== "string") {
-        return false;
-    }
-    return true;
-};
+const isFileItemLite = (maybeFileItemLite: any): maybeFileItemLite is FileItemLite =>
+	typeof maybeFileItemLite.webUrl === "string" &&
+	typeof maybeFileItemLite.webDavUrl === "string" &&
+	typeof maybeFileItemLite.sharepointIds === "object";
 
 async function getFileItemLite(
-    getToken: TokenFetcher<OdspResourceTokenFetchOptions>,
-    odspUrlParts: IOdspUrlParts,
-    logger: ITelemetryLogger,
-    forceAccessTokenViaAuthorizationHeader: boolean,
+	getToken: TokenFetcher<OdspResourceTokenFetchOptions>,
+	odspUrlParts: IOdspUrlParts,
+	logger: ITelemetryLoggerExt,
+	forceAccessTokenViaAuthorizationHeader: boolean,
 ): Promise<FileItemLite> {
-    return PerformanceEvent.timedExecAsync(
-        logger,
-        { eventName: "odspFileLink", requestName: "getFileItemLite" },
-        async (event) => {
-            let attempts = 0;
-            let additionalProps;
-            const fileItem = await getWithRetryForTokenRefresh(async (options) => {
-                attempts++;
-                const { siteUrl, driveId, itemId } = odspUrlParts;
-                const storageTokenFetcher = toInstrumentedOdspTokenFetcher(
-                    logger,
-                    odspUrlParts,
-                    getToken,
-                    true /* throwOnNullToken */,
-                );
-                const storageToken = await storageTokenFetcher(options, "GetFileItemLite");
-                assert(storageToken !== null,
-                    0x2bc /* "Instrumented token fetcher with throwOnNullToken =true should never return null" */);
+	return PerformanceEvent.timedExecAsync(
+		logger,
+		{ eventName: "odspFileLink", requestName: "getFileItemLite" },
+		async (event) => {
+			let attempts = 0;
+			let additionalProps;
+			const fileItem = await getWithRetryForTokenRefresh(async (options) => {
+				attempts++;
+				const { siteUrl, driveId, itemId } = odspUrlParts;
+				const storageTokenFetcher = toInstrumentedOdspTokenFetcher(
+					logger,
+					odspUrlParts,
+					getToken,
+					true /* throwOnNullToken */,
+				);
+				const storageToken = await storageTokenFetcher(options, "GetFileItemLite");
+				assert(
+					storageToken !== null,
+					0x2bc /* "Instrumented token fetcher with throwOnNullToken =true should never return null" */,
+				);
 
-                const { url, headers } = getUrlAndHeadersWithAuth(
-                    `${siteUrl}/_api/v2.0/drives/${driveId}/items/${itemId}?select=webUrl,webDavUrl`,
-                    storageToken,
-                    forceAccessTokenViaAuthorizationHeader,
-                );
-                const requestInit = { method: "GET", headers };
-                const response = await fetchHelper(url, requestInit);
-                additionalProps = response.propsToLog;
+				const { url, headers } = getUrlAndHeadersWithAuth(
+					`${siteUrl}/_api/v2.0/drives/${driveId}/items/${itemId}?select=webUrl,webDavUrl,sharepointIds`,
+					storageToken,
+					forceAccessTokenViaAuthorizationHeader,
+				);
+				const requestInit = { method: "GET", headers };
+				const response = await fetchHelper(url, requestInit);
+				additionalProps = response.propsToLog;
 
-                const responseJson = await response.content.json();
-                if (!isFileItemLite(responseJson)) {
-                    // This will retry once in getWithRetryForTokenRefresh
-                    throw new NonRetryableError(
-                        "Malformed getFileItemLite response",
-                        DriverErrorType.incorrectServerResponse,
-                        { driverVersion });
-                }
-                return responseJson;
-            });
-            event.end({ ...additionalProps, attempts });
-            return fileItem;
-        },
-    );
+				const responseJson = await response.content.json();
+				if (!isFileItemLite(responseJson)) {
+					// This will retry once in getWithRetryForTokenRefresh
+					throw new NonRetryableError(
+						"Malformed getFileItemLite response",
+						DriverErrorType.incorrectServerResponse,
+						{ driverVersion },
+					);
+				}
+				return responseJson;
+			});
+			event.end({ ...additionalProps, attempts });
+			return fileItem;
+		},
+	);
 }

package/src/getQueryString.ts

@@ -8,14 +8,16 @@ import { ISnapshotOptions } from "@fluidframework/odsp-driver-definitions";
  * Generates query string from the given query parameters.
  * @param queryParams - Query parameters from which to create a query.
  */
-export function getQueryString(queryParams: { [key: string]: string | number; } | ISnapshotOptions): string {
-    let queryString = "";
-    for (const key of Object.keys(queryParams)) {
-        if (queryParams[key] !== undefined) {
-            const startChar = queryString === "" ? "?" : "&";
-            queryString += `${startChar}${key}=${encodeURIComponent(queryParams[key])}`;
-        }
-    }
+export function getQueryString(
+	queryParams: { [key: string]: string | number } | ISnapshotOptions,
+): string {
+	let queryString = "";
+	for (const key of Object.keys(queryParams)) {
+		if (queryParams[key] !== undefined) {
+			const startChar = queryString === "" ? "?" : "&";
+			queryString += `${startChar}${key}=${encodeURIComponent(queryParams[key])}`;
+		}
+	}
 
-    return queryString;
+	return queryString;
 }

package/src/getUrlAndHeadersWithAuth.ts

@@ -4,39 +4,40 @@
  */
 
 export function getUrlAndHeadersWithAuth(
-    url: string,
-    token: string | null,
-    forceAccessTokenViaAuthorizationHeader: boolean,
-): { url: string; headers: { [index: string]: string; }; } {
-    if (!token || token.length === 0) {
-        return { url, headers: {} };
-    }
+	url: string,
+	// eslint-disable-next-line @rushstack/no-new-null
+	token: string | null,
+	forceAccessTokenViaAuthorizationHeader: boolean,
+): { url: string; headers: { [index: string]: string } } {
+	if (!token || token.length === 0) {
+		return { url, headers: {} };
+	}
 
-    if (!forceAccessTokenViaAuthorizationHeader) {
-        // Pass access token via query string: this will make request be treated as 'simple' request
-        // which does not require OPTIONS call as part of CORS check.
-        const urlWithAccessTokenInQueryString = new URL(url);
-        // IMPORTANT: Do not apply encodeURIComponent to token, param value is automatically encoded
-        // when set via URLSearchParams class
-        urlWithAccessTokenInQueryString.searchParams.set("access_token", token);
-        // ODSP APIs have a limitation that the query string cannot exceed 2048 characters.
-        // If the query string exceeds 2048, we have to fall back to sending the access token as a header, which
-        // has a negative performance implication as it adds a performance overhead.
-        // NOTE: URL.search.length value includes '?' symbol and it is unclear whether backend logic which enforces
-        // query length limit accounts for it. This logic errs on side of caution and includes that key in overall
-        // query length.
-        if (urlWithAccessTokenInQueryString.search.length <= 2048) {
-            return {
-                headers: {},
-                url: urlWithAccessTokenInQueryString.href,
-            };
-        }
-    }
+	if (!forceAccessTokenViaAuthorizationHeader) {
+		// Pass access token via query string: this will make request be treated as 'simple' request
+		// which does not require OPTIONS call as part of CORS check.
+		const urlWithAccessTokenInQueryString = new URL(url);
+		// IMPORTANT: Do not apply encodeURIComponent to token, param value is automatically encoded
+		// when set via URLSearchParams class
+		urlWithAccessTokenInQueryString.searchParams.set("access_token", token);
+		// ODSP APIs have a limitation that the query string cannot exceed 2048 characters.
+		// If the query string exceeds 2048, we have to fall back to sending the access token as a header, which
+		// has a negative performance implication as it adds a performance overhead.
+		// NOTE: URL.search.length value includes '?' symbol and it is unclear whether backend logic which enforces
+		// query length limit accounts for it. This logic errs on side of caution and includes that key in overall
+		// query length.
+		if (urlWithAccessTokenInQueryString.search.length <= 2048) {
+			return {
+				headers: {},
+				url: urlWithAccessTokenInQueryString.href,
+			};
+		}
+	}
 
-    return {
-        headers: {
-            Authorization: `Bearer ${token}`,
-        },
-        url,
-    };
+	return {
+		headers: {
+			Authorization: `Bearer ${token}`,
+		},
+		url,
+	};
 }

package/src/index.ts

@@ -4,34 +4,58 @@
  */
 
 // Constants
-export * from "./constants";
+export { OdcApiSiteOrigin, OdcFileSiteOrigin } from "./constants";
 
-export * from "./contractsPublic";
+export {
+	ClpCompliantAppHeader,
+	IClpCompliantAppHeader,
+	ISharingLinkHeader,
+	OdspFluidDataStoreLocator,
+	SharingLinkHeader,
+} from "./contractsPublic";
 
 // public utils
-export * from "./odspPublicUtils";
-export * from "./odspUrlHelper";
-export * from "./createOdspUrl";
-export * from "./checkUrl";
+export { checkUrl } from "./checkUrl";
+export { createOdspUrl } from "./createOdspUrl";
+export { getHashedDocumentId, ISnapshotContents } from "./odspPublicUtils";
+export { getApiRoot, getOdspUrlParts, isOdcOrigin, isOdcUrl, isSpoUrl } from "./odspUrlHelper";
 
 // prefetch latest snapshot before container load
-export * from "./prefetchLatestSnapshot";
+export { prefetchLatestSnapshot } from "./prefetchLatestSnapshot";
 
 // Factory
-export * from "./odspDocumentServiceFactoryCore";
-export * from "./odspDocumentServiceFactory";
-export * from "./odspDocumentServiceFactoryWithCodeSplit";
+export {
+	createLocalOdspDocumentServiceFactory,
+	OdspDocumentServiceFactory,
+} from "./odspDocumentServiceFactory";
+export { OdspDocumentServiceFactoryCore } from "./odspDocumentServiceFactoryCore";
+export { OdspDocumentServiceFactoryWithCodeSplit } from "./odspDocumentServiceFactoryWithCodeSplit";
 
 // File creation
-export * from "./createOdspCreateContainerRequest";
+export { createOdspCreateContainerRequest } from "./createOdspCreateContainerRequest";
 
 // URI Resolver functionality, URI management
-export * from "./odspDriverUrlResolverForShareLink";
-export * from "./odspDriverUrlResolver";
+export { OdspDriverUrlResolver } from "./odspDriverUrlResolver";
+export {
+	OdspDriverUrlResolverForShareLink,
+	ShareLinkFetcherProps,
+} from "./odspDriverUrlResolverForShareLink";
 
 // It's used by URL resolve code, but also has some public functions
-export * from "./odspFluidFileLink";
-
-// Wire format related
-export * from "./compactSnapshotParser";
-export * from "./ReadBufferUtils";
+export {
+	encodeOdspFluidDataStoreLocator,
+	getLocatorFromOdspUrl,
+	locatorQueryParamName,
+	storeLocatorInOdspUrl,
+} from "./odspFluidFileLink";
+
+export {
+	IOdspCache,
+	IPersistedFileCache,
+	INonPersistentCache,
+	IPrefetchSnapshotContents,
+} from "./odspCache";
+export { ICacheAndTracker, type EpochTracker, FetchType, FetchTypeInternal } from "./epochTracker";
+export { IOdspResponse, isOdspResolvedUrl } from "./odspUtils";
+export { SnapshotFormatSupportType } from "./fetchSnapshot";
+export { ISnapshotContentsWithProps, parseCompactSnapshotResponse } from "./compactSnapshotParser";

package/src/localOdspDriver/localOdspDeltaStorageService.ts

@@ -0,0 +1,49 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
+import { IDocumentDeltaStorageService, IStream } from "@fluidframework/driver-definitions";
+import { Queue, emptyMessageStream } from "@fluidframework/driver-utils";
+import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
+import { validateMessages } from "@fluidframework/driver-base";
+
+/**
+ * Implementation of IDocumentDeltaStorageService that will return snapshot ops when fetching messages
+ */
+export class LocalOdspDeltaStorageService implements IDocumentDeltaStorageService {
+	constructor(
+		private readonly logger: ITelemetryLoggerExt,
+		private snapshotOps: ISequencedDocumentMessage[],
+	) {}
+
+	public fetchMessages(
+		from: number,
+		to: number | undefined,
+		_abortSignal?: AbortSignal,
+		_cachedOnly?: boolean,
+		_fetchReason?: string,
+	): IStream<ISequencedDocumentMessage[]> {
+		if (this.snapshotOps.length === 0) {
+			return emptyMessageStream;
+		}
+
+		const queue = new Queue<ISequencedDocumentMessage[]>();
+		const messages = this.snapshotOps.filter(
+			(op) => op.sequenceNumber >= from && (to === undefined || op.sequenceNumber < to),
+		);
+		validateMessages("cached", messages, from, this.logger);
+
+		if (messages.length === 0 || messages[0].sequenceNumber !== from) {
+			this.snapshotOps = [];
+		}
+		this.snapshotOps = this.snapshotOps.filter(
+			(op) => to !== undefined && op.sequenceNumber >= to,
+		);
+
+		queue.pushValue(messages);
+		queue.pushDone();
+		return queue;
+	}
+}