@fluidframework/container-loader 2.0.0-internal.7.0.0 → 2.0.0-internal.7.2.0

package/src/container.ts

@@ -40,6 +40,7 @@ import {
 	IRuntime,
 	ReadOnlyInfo,
 	isFluidCodeDetails,
+	IGetPendingLocalStateProps,
 } from "@fluidframework/container-definitions";
 import {
 	IDocumentService,
@@ -134,6 +135,8 @@ const savedContainerEvent = "saved";
 
 const packageNotFactoryError = "Code package does not implement IRuntimeFactory";
 
+const hasBlobsSummaryTree = ".hasAttachmentBlobs";
+
 /**
  * @internal
  */
@@ -473,7 +476,11 @@ export class Container
 			container.mc.logger,
 			{ eventName: "RehydrateDetachedFromSnapshot" },
 			async (_event) => {
-				const deserializedSummary = JSON.parse(snapshot) as ISummaryTree;
+				const deserializedSummary = JSON.parse(snapshot);
+				if (!isCombinedAppAndProtocolSummary(deserializedSummary, hasBlobsSummaryTree)) {
+					throw new UsageError("Cannot rehydrate detached container. Incorrect format");
+				}
+
 				await container.rehydrateDetachedFromSnapshot(deserializedSummary);
 				return container;
 			},
@@ -580,6 +587,7 @@ export class Container
 	private readonly savedOps: ISequencedDocumentMessage[] = [];
 	private baseSnapshot?: ISnapshotTree;
 	private baseSnapshotBlobs?: ISerializableBlobContents;
+	private readonly _containerId: string;
 
 	private lastVisible: number | undefined;
 	private readonly visibilityEventHandler: (() => void) | undefined;
@@ -815,6 +823,8 @@ export class Container
 		const clientType = `${interactive ? "interactive" : "noninteractive"}${
 			type !== undefined && type !== "" ? `/${type}` : ""
 		}`;
+
+		this._containerId = uuid();
 		// Need to use the property getter for docId because for detached flow we don't have the docId initially.
 		// We assign the id later so property getter is used.
 		this.subLogger = createChildLogger({
@@ -822,7 +832,7 @@ export class Container
 			properties: {
 				all: {
 					clientType, // Differentiating summarizer container from main container
-					containerId: uuid(),
+					containerId: this._containerId,
 					docId: () => this.resolvedUrl?.id,
 					containerAttachState: () => this._attachState,
 					containerLifecycleState: () => this._lifecycleState,
@@ -1103,12 +1113,17 @@ export class Container
 		}
 	}
 
-	public async closeAndGetPendingLocalState(): Promise<string> {
+	public async closeAndGetPendingLocalState(
+		stopBlobAttachingSignal?: AbortSignal,
+	): Promise<string> {
 		// runtime matches pending ops to successful ones by clientId and client seq num, so we need to close the
 		// container at the same time we get pending state, otherwise this container could reconnect and resubmit with
 		// a new clientId and a future container using stale pending state without the new clientId would resubmit them
 		this.disconnectInternal({ text: "closeAndGetPendingLocalState" }); // TODO https://dev.azure.com/fluidframework/internal/_workitems/edit/5127
-		const pendingState = await this.getPendingLocalStateCore({ notifyImminentClosure: true });
+		const pendingState = await this.getPendingLocalStateCore({
+			notifyImminentClosure: true,
+			stopBlobAttachingSignal,
+		});
 		this.close();
 		return pendingState;
 	}
@@ -1117,7 +1132,7 @@ export class Container
 		return this.getPendingLocalStateCore({ notifyImminentClosure: false });
 	}
 
-	private async getPendingLocalStateCore(props: { notifyImminentClosure: boolean }) {
+	private async getPendingLocalStateCore(props: IGetPendingLocalStateProps) {
 		return PerformanceEvent.timedExecAsync(
 			this.mc.logger,
 			{
@@ -1178,7 +1193,7 @@ export class Container
 		const combinedSummary = combineAppAndProtocolSummary(appSummary, protocolSummary);
 
 		if (this.detachedBlobStorage && this.detachedBlobStorage.size > 0) {
-			combinedSummary.tree[".hasAttachmentBlobs"] = {
+			combinedSummary.tree[hasBlobsSummaryTree] = {
 				type: SummaryType.Blob,
 				content: "true",
 			};
@@ -1264,7 +1279,7 @@ export class Container
 							}, // progress
 						);
 					}
-					await this.storageAdapter.connectToService(this.service);
+					this.storageAdapter.connectToService(this.service);
 
 					if (hasAttachmentBlobs) {
 						// upload blobs to storage
@@ -1574,14 +1589,7 @@ export class Container
 			this.connectToDeltaStream(connectionArgs);
 		}
 
-		if (!pendingLocalState) {
-			await this.storageAdapter.connectToService(this.service);
-		} else {
-			// if we have pendingLocalState we can load without storage; don't wait for connection
-			this.storageAdapter.connectToService(this.service).catch((error) => {
-				this.close(error);
-			});
-		}
+		this.storageAdapter.connectToService(this.service);
 
 		this._attachState = AttachState.Attached;
 
@@ -1815,12 +1823,13 @@ export class Container
 	}
 
 	private async rehydrateDetachedFromSnapshot(detachedContainerSnapshot: ISummaryTree) {
-		if (detachedContainerSnapshot.tree[".hasAttachmentBlobs"] !== undefined) {
+		if (detachedContainerSnapshot.tree[hasBlobsSummaryTree] !== undefined) {
 			assert(
 				!!this.detachedBlobStorage && this.detachedBlobStorage.size > 0,
 				0x250 /* "serialized container with attachment blobs must be rehydrated with detached blob storage" */,
 			);
-			delete detachedContainerSnapshot.tree[".hasAttachmentBlobs"];
+			// eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+			delete detachedContainerSnapshot.tree[hasBlobsSummaryTree];
 		}
 
 		const snapshotTree = getSnapshotTreeFromSerializedContainer(detachedContainerSnapshot);
@@ -2007,6 +2016,7 @@ export class Container
 		client.details.environment = [
 			client.details.environment,
 			` loaderVersion:${pkgVersion}`,
+			` containerId:${this._containerId}`,
 		].join(";");
 		return client;
 	}
@@ -2335,8 +2345,8 @@ export class Container
 		this.emit("op", message);
 	}
 
-	private submitSignal(message: any) {
-		this._deltaManager.submitSignal(JSON.stringify(message));
+	private submitSignal(content: any, targetClientId?: string) {
+		this._deltaManager.submitSignal(JSON.stringify(content), targetClientId);
 	}
 
 	private processSignal(message: ISignalMessage) {
@@ -2430,7 +2440,7 @@ export class Container
 				this.submitSummaryMessage(summaryOp, referenceSequenceNumber),
 			(batch: IBatchMessage[], referenceSequenceNumber?: number) =>
 				this.submitBatch(batch, referenceSequenceNumber),
-			(message) => this.submitSignal(message),
+			(content, targetClientId) => this.submitSignal(content, targetClientId),
 			(error?: ICriticalContainerError) => this.dispose(error),
 			(error?: ICriticalContainerError) => this.close(error),
 			this.updateDirtyContainerState,
@@ -2513,7 +2523,7 @@ export class Container
 
 /**
  * IContainer interface that includes experimental features still under development.
- * @experimental
+ * @alpha
  */
 export interface IContainerExperimental extends IContainer {
 	/**
@@ -2521,7 +2531,7 @@ export interface IContainerExperimental extends IContainer {
 	 * submission and potential document corruption. The blob returned MUST be deleted if and when this
 	 * container emits a "connected" event.
 	 * @returns serialized blob that can be passed to Loader.resolve()
-	 * @experimental misuse of this API can result in duplicate op submission and potential document corruption
+	 * @alpha misuse of this API can result in duplicate op submission and potential document corruption
 	 * {@link https://github.com/microsoft/FluidFramework/blob/main/packages/loader/container-loader/closeAndGetPendingLocalState.md}
 	 */
 	getPendingLocalState?(): Promise<string>;
@@ -2529,8 +2539,8 @@ export interface IContainerExperimental extends IContainer {
 	/**
 	 * Closes the container and returns serialized local state intended to be
 	 * given to a newly loaded container.
-	 * @experimental
+	 * @alpha
 	 * {@link https://github.com/microsoft/FluidFramework/blob/main/packages/loader/container-loader/closeAndGetPendingLocalState.md}
 	 */
-	closeAndGetPendingLocalState?(): Promise<string>;
+	closeAndGetPendingLocalState?(stopBlobAttachingSignal?: AbortSignal): Promise<string>;
 }

package/src/containerContext.ts

@@ -85,7 +85,7 @@ export class ContainerContext implements IContainerContext {
 			batch: IBatchMessage[],
 			referenceSequenceNumber?: number,
 		) => number,
-		public readonly submitSignalFn: (contents: any) => void,
+		public readonly submitSignalFn: (content: any, targetClientId?: string) => void,
 		public readonly disposeFn: (error?: ICriticalContainerError) => void,
 		public readonly closeFn: (error?: ICriticalContainerError) => void,
 		public readonly updateDirtyContainerState: (dirty: boolean) => void,

package/src/containerStorageAdapter.ts

@@ -79,14 +79,14 @@ export class ContainerStorageAdapter implements IDocumentStorageService, IDispos
 		this.disposed = true;
 	}
 
-	public async connectToService(service: IDocumentService): Promise<void> {
+	public connectToService(service: IDocumentService): void {
 		if (!(this._storageService instanceof BlobOnlyStorage)) {
 			return;
 		}
 
-		const storageService = await service.connectToStorage();
+		const storageServiceP = service.connectToStorage();
 		const retriableStorage = (this._storageService = new RetriableDocumentStorageService(
-			storageService,
+			storageServiceP,
 			this.logger,
 		));
 

package/src/contracts.ts

@@ -100,7 +100,7 @@ export interface IConnectionManager {
 	 * Submits signal to relay service.
 	 * Called only when active connection is present.
 	 */
-	submitSignal(content: any): void;
+	submitSignal(content: any, targetClientId?: string): void;
 
 	/**
 	 * Submits messages to relay service.
@@ -133,10 +133,10 @@ export interface IConnectionManagerFactoryArgs {
 	readonly incomingOpHandler: (messages: ISequencedDocumentMessage[], reason: string) => void;
 
 	/**
-	 * Called by connection manager for each incoming signals.
-	 * Maybe called before connectHandler is called (initial signals on socket connection)
+	 * Called by connection manager for each incoming signal.
+	 * May be called before connectHandler is called (due to initial signals on socket connection)
 	 */
-	readonly signalHandler: (message: ISignalMessage) => void;
+	readonly signalHandler: (signals: ISignalMessage[]) => void;
 
 	/**
 	 * Called when connection manager experiences delay in connecting to relay service.

package/src/debugLogger.ts

@@ -60,7 +60,10 @@ export class DebugLogger implements ITelemetryBaseLogger {
 		});
 	}
 
-	private constructor(private readonly debug: IDebugger, private readonly debugErr: IDebugger) {}
+	private constructor(
+		private readonly debug: IDebugger,
+		private readonly debugErr: IDebugger,
+	) {}
 
 	/**
 	 * Send an event to debug loggers

package/src/deltaManager.ts

@@ -114,17 +114,6 @@ function isClientMessage(message: ISequencedDocumentMessage | IDocumentMessage):
 	}
 }
 
-/**
- * Type is used to cast AbortController to represent new version of DOM API and prevent build issues
- * TODO: Remove when typescript version of the repo contains the AbortSignal.reason property (AB#5045)
- */
-type AbortControllerReal = AbortController & { abort(reason?: any): void };
-/**
- * Type is used to cast AbortSignal to represent new version of DOM API and prevent build issues
- * TODO: Remove when typescript version of the repo contains the AbortSignal.reason property (AB#5045)
- */
-type AbortSignalReal = AbortSignal & { reason: any };
-
 /**
  * Manages the flow of both inbound and outbound messages. This class ensures that shared objects receive delta
  * messages in order regardless of possible network conditions or timings causing out of order delivery.
@@ -312,8 +301,8 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 		return message.clientSequenceNumber;
 	}
 
-	public submitSignal(content: any) {
-		return this.connectionManager.submitSignal(content);
+	public submitSignal(content: any, targetClientId?: string) {
+		return this.connectionManager.submitSignal(content, targetClientId);
 	}
 
 	public flush() {
@@ -402,7 +391,11 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 					this.close(normalizeError(error));
 				}
 			},
-			signalHandler: (message: ISignalMessage) => this._inboundSignal.push(message),
+			signalHandler: (signals: ISignalMessage[]) => {
+				for (const signal of signals) {
+					this._inboundSignal.push(signal);
+				}
+			},
 			reconnectionDelayHandler: (delayMs: number, error: unknown) =>
 				this.emitDelayInfo(this.deltaStreamDelayId, delayMs, error),
 			closeHandler: (error: any) => this.close(error),
@@ -663,8 +656,7 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 			// This is useless for known ranges (to is defined) as it means request is over either way.
 			// And it will cancel unbound request too early, not allowing us to learn where the end of the file is.
 			if (!opsFromFetch && cancelFetch(op)) {
-				// TODO: Remove when typescript version of the repo contains the AbortSignal.reason property (AB#5045)
-				(controller as AbortControllerReal).abort("DeltaManager getDeltas fetch cancelled");
+				controller.abort("DeltaManager getDeltas fetch cancelled");
 				this._inbound.off("push", opListener);
 			}
 		};
@@ -673,10 +665,7 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 			this._inbound.on("push", opListener);
 			assert(this.closeAbortController.signal.onabort === null, 0x1e8 /* "reentrancy" */);
 			this.closeAbortController.signal.onabort = () =>
-				// TODO: Remove when typescript version of the repo contains the AbortSignal.reason property (AB#5045)
-				(controller as AbortControllerReal).abort(
-					(this.closeAbortController.signal as AbortSignalReal).reason,
-				);
+				controller.abort(this.closeAbortController.signal.reason);
 
 			const stream = this.deltaStorage.fetchMessages(
 				from, // inclusive
@@ -704,8 +693,7 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 				this.logger.sendTelemetryEvent({
 					eventName: "DeltaManager_GetDeltasAborted",
 					fetchReason,
-					// TODO: Remove when typescript version of the repo contains the AbortSignal.reason property (AB#5045)
-					reason: (controller.signal as AbortSignalReal).reason,
+					reason: controller.signal.reason,
 				});
 			}
 			this.closeAbortController.signal.onabort = null;
@@ -762,8 +750,7 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 	}
 
 	private clearQueues() {
-		// TODO: Remove when typescript version of the repo contains the AbortSignal.reason property (AB#5045)
-		(this.closeAbortController as AbortControllerReal).abort("DeltaManager is closed");
+		this.closeAbortController.abort("DeltaManager is closed");
 
 		this._inbound.clear();
 		this._inboundSignal.clear();

package/src/index.ts

@@ -15,4 +15,9 @@ export {
 	Loader,
 	requestResolvedObjectFromContainer,
 } from "./loader";
+export {
+	isLocationRedirectionError,
+	resolveWithLocationRedirectionHandling,
+} from "./location-redirection-utilities";
 export { IProtocolHandler, ProtocolHandlerBuilder } from "./protocol";
+export { tryParseCompatibleResolvedUrl, IParsedUrl } from "./utils";

package/src/loader.ts

@@ -41,7 +41,7 @@ import {
 } from "@fluidframework/driver-definitions";
 import { IClientDetails } from "@fluidframework/protocol-definitions";
 import { Container, IPendingContainerState } from "./container";
-import { IParsedUrl, parseUrl } from "./utils";
+import { IParsedUrl, tryParseCompatibleResolvedUrl } from "./utils";
 import { pkgVersion } from "./packageVersion";
 import { ProtocolHandlerBuilder } from "./protocol";
 import { DebugLogger } from "./debugLogger";
@@ -63,7 +63,7 @@ export class RelativeLoader implements ILoader {
 	) {}
 
 	/**
-	 * @deprecated - Will be removed in future major release. Migrate all usage of IFluidRouter to the Container's IFluidRouter/request.
+	 * @deprecated Will be removed in future major release. Migrate all usage of IFluidRouter to the Container's IFluidRouter/request.
 	 */
 	// eslint-disable-next-line import/no-deprecated
 	public get IFluidRouter(): IFluidRouter {
@@ -94,7 +94,7 @@ export class RelativeLoader implements ILoader {
 	}
 
 	/**
-	 * @deprecated - Will be removed in future major release. Migrate all usage of IFluidRouter to the Container's IFluidRouter/request.
+	 * @deprecated Will be removed in future major release. Migrate all usage of IFluidRouter to the "entryPoint" pattern. Refer to Removing-IFluidRouter.md
 	 */
 	public async request(request: IRequest): Promise<IResponse> {
 		if (request.url.startsWith("/")) {
@@ -280,7 +280,7 @@ export async function requestResolvedObjectFromContainer(
 	headers?: IRequestHeader,
 ): Promise<IResponse> {
 	ensureResolvedUrlDefined(container.resolvedUrl);
-	const parsedUrl = parseUrl(container.resolvedUrl.url);
+	const parsedUrl = tryParseCompatibleResolvedUrl(container.resolvedUrl.url);
 
 	if (parsedUrl === undefined) {
 		throw new Error(`Invalid URL ${container.resolvedUrl.url}`);
@@ -347,7 +347,7 @@ export class Loader implements IHostLoader {
 	}
 
 	/**
-	 * @deprecated - Will be removed in future major release. Migrate all usage of IFluidRouter to the Container's IFluidRouter/request.
+	 * @deprecated Will be removed in future major release. Migrate all usage of IFluidRouter to the Container's IFluidRouter/request.
 	 */
 	// eslint-disable-next-line import/no-deprecated
 	public get IFluidRouter(): IFluidRouter {
@@ -398,7 +398,7 @@ export class Loader implements IHostLoader {
 	}
 
 	/**
-	 * @deprecated - Will be removed in future major release. Migrate all usage of IFluidRouter to the Container's IFluidRouter/request.
+	 * @deprecated Will be removed in future major release. Migrate all usage of IFluidRouter to the Container's IFluidRouter/request.
 	 */
 	public async request(request: IRequest): Promise<IResponse> {
 		return PerformanceEvent.timedExecAsync(
@@ -422,13 +422,13 @@ export class Loader implements IHostLoader {
 		ensureResolvedUrlDefined(resolvedAsFluid);
 
 		// Parse URL into data stores
-		const parsed = parseUrl(resolvedAsFluid.url);
+		const parsed = tryParseCompatibleResolvedUrl(resolvedAsFluid.url);
 		if (parsed === undefined) {
 			throw new Error(`Invalid URL ${resolvedAsFluid.url}`);
 		}
 
 		if (pendingLocalState !== undefined) {
-			const parsedPendingUrl = parseUrl(pendingLocalState.url);
+			const parsedPendingUrl = tryParseCompatibleResolvedUrl(pendingLocalState.url);
 			if (
 				parsedPendingUrl?.id !== parsed.id ||
 				parsedPendingUrl?.path.replace(/\/$/, "") !== parsed.path.replace(/\/$/, "")

package/src/location-redirection-utilities/index.ts

@@ -0,0 +1,9 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+export {
+	isLocationRedirectionError,
+	resolveWithLocationRedirectionHandling,
+} from "./resolveWithLocationRedirection";

package/src/location-redirection-utilities/resolveWithLocationRedirection.ts

@@ -0,0 +1,59 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { ITelemetryBaseLogger, IRequest } from "@fluidframework/core-interfaces";
+import {
+	DriverErrorTypes,
+	ILocationRedirectionError,
+	IUrlResolver,
+} from "@fluidframework/driver-definitions";
+import { createChildLogger } from "@fluidframework/telemetry-utils";
+
+/**
+ * Checks if the error is location redirection error.
+ * @param error - error whose type is to be determined.
+ * @returns `true` is the error is location redirection error, otherwise `false`.
+ */
+export function isLocationRedirectionError(error: any): error is ILocationRedirectionError {
+	return (
+		typeof error === "object" &&
+		error !== null &&
+		error.errorType === DriverErrorTypes.locationRedirection
+	);
+}
+
+/**
+ * Handles location redirection while fulfilling the loader request.
+ * @param api - Callback in which user can wrap the loader.resolve or loader.request call.
+ * @param request - request to be resolved.
+ * @param urlResolver - resolver used to resolve the url.
+ * @param logger - logger to send events.
+ * @returns Response from the API call.
+ */
+export async function resolveWithLocationRedirectionHandling<T>(
+	api: (request: IRequest) => Promise<T>,
+	request: IRequest,
+	urlResolver: IUrlResolver,
+	logger?: ITelemetryBaseLogger,
+): Promise<T> {
+	let req: IRequest = request;
+	const childLogger = createChildLogger({ logger, namespace: "LocationRedirection" });
+	for (;;) {
+		try {
+			return await api(req);
+		} catch (error: any) {
+			if (!isLocationRedirectionError(error)) {
+				throw error;
+			}
+			childLogger.sendTelemetryEvent({ eventName: "LocationRedirectionError" });
+			const resolvedUrl = error.redirectUrl;
+			// Generate the new request with new location details from the resolved url. For datastore/relative path,
+			// we don't need to pass "/" as host could have asked for a specific data store. So driver need to
+			// extract it from the resolved url.
+			const absoluteUrl = await urlResolver.getAbsoluteUrl(resolvedUrl, "", undefined);
+			req = { url: absoluteUrl, headers: req.headers };
+		}
+	}
+}

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/container-loader";
-export const pkgVersion = "2.0.0-internal.7.0.0";
+export const pkgVersion = "2.0.0-internal.7.2.0";

package/src/retriableDocumentStorageService.ts

@@ -23,13 +23,19 @@ import { runWithRetry } from "@fluidframework/driver-utils";
 
 export class RetriableDocumentStorageService implements IDocumentStorageService, IDisposable {
 	private _disposed = false;
+	private internalStorageService: IDocumentStorageService | undefined;
 	constructor(
-		private readonly internalStorageService: IDocumentStorageService,
+		private readonly internalStorageServiceP: Promise<IDocumentStorageService>,
 		private readonly logger: ITelemetryLoggerExt,
-	) {}
+	) {
+		this.internalStorageServiceP.then((s) => (this.internalStorageService = s)).catch(() => {});
+	}
 
 	public get policies(): IDocumentStorageServicePolicies | undefined {
-		return this.internalStorageService.policies;
+		if (this.internalStorageService) {
+			return this.internalStorageService.policies;
+		}
+		throw new Error("storage service not yet instantiated");
 	}
 	public get disposed() {
 		return this._disposed;
@@ -39,7 +45,10 @@ export class RetriableDocumentStorageService implements IDocumentStorageService,
 	}
 
 	public get repositoryUrl(): string {
-		return this.internalStorageService.repositoryUrl;
+		if (this.internalStorageService) {
+			return this.internalStorageService.repositoryUrl;
+		}
+		throw new Error("storage service not yet instantiated");
 	}
 
 	public async getSnapshotTree(
@@ -47,14 +56,17 @@ export class RetriableDocumentStorageService implements IDocumentStorageService,
 		scenarioName?: string,
 	): Promise<ISnapshotTree | null> {
 		return this.runWithRetry(
-			async () => this.internalStorageService.getSnapshotTree(version, scenarioName),
+			async () =>
+				this.internalStorageServiceP.then(async (s) =>
+					s.getSnapshotTree(version, scenarioName),
+				),
 			"storage_getSnapshotTree",
 		);
 	}
 
 	public async readBlob(id: string): Promise<ArrayBufferLike> {
 		return this.runWithRetry(
-			async () => this.internalStorageService.readBlob(id),
+			async () => this.internalStorageServiceP.then(async (s) => s.readBlob(id)),
 			"storage_readBlob",
 		);
 	}
@@ -67,11 +79,8 @@ export class RetriableDocumentStorageService implements IDocumentStorageService,
 	): Promise<IVersion[]> {
 		return this.runWithRetry(
 			async () =>
-				this.internalStorageService.getVersions(
-					versionId,
-					count,
-					scenarioName,
-					fetchSource,
+				this.internalStorageServiceP.then(async (s) =>
+					s.getVersions(versionId, count, scenarioName, fetchSource),
 				),
 			"storage_getVersions",
 		);
@@ -95,26 +104,31 @@ export class RetriableDocumentStorageService implements IDocumentStorageService,
 			0x251 /* "creation summary has to have seq=0 && handle === undefined" */,
 		);
 		if (context.referenceSequenceNumber !== 0) {
-			return this.internalStorageService.uploadSummaryWithContext(summary, context);
+			return this.internalStorageServiceP.then(async (s) =>
+				s.uploadSummaryWithContext(summary, context),
+			);
 		}
 
 		// Creation flow with attachment blobs - need to do retries!
 		return this.runWithRetry(
-			async () => this.internalStorageService.uploadSummaryWithContext(summary, context),
+			async () =>
+				this.internalStorageServiceP.then(async (s) =>
+					s.uploadSummaryWithContext(summary, context),
+				),
 			"storage_uploadSummaryWithContext",
 		);
 	}
 
 	public async downloadSummary(handle: ISummaryHandle): Promise<ISummaryTree> {
 		return this.runWithRetry(
-			async () => this.internalStorageService.downloadSummary(handle),
+			async () => this.internalStorageServiceP.then(async (s) => s.downloadSummary(handle)),
 			"storage_downloadSummary",
 		);
 	}
 
 	public async createBlob(file: ArrayBufferLike): Promise<ICreateBlobResponse> {
 		return this.runWithRetry(
-			async () => this.internalStorageService.createBlob(file),
+			async () => this.internalStorageServiceP.then(async (s) => s.createBlob(file)),
 			"storage_createBlob",
 		);
 	}

package/src/utils.ts

@@ -23,9 +23,23 @@ export interface ISnapshotTreeWithBlobContents extends ISnapshotTree {
 	trees: { [path: string]: ISnapshotTreeWithBlobContents };
 }
 
+/**
+ * Interface to represent the parsed parts of IResolvedUrl.url to help
+ * in getting info about different parts of the url.
+ * May not be compatible or relevant for any Url Resolver
+ */
 export interface IParsedUrl {
+	/**
+	 * It is combination of tenantid/docId part of the url.
+	 */
 	id: string;
+	/**
+	 * It is the deep link path in the url.
+	 */
 	path: string;
+	/**
+	 * Query string part of the url.
+	 */
 	query: string;
 	/**
 	 * Null means do not use snapshots, undefined means load latest snapshot
@@ -35,7 +49,15 @@ export interface IParsedUrl {
 	version: string | null | undefined;
 }
 
-export function parseUrl(url: string): IParsedUrl | undefined {
+/**
+ * Utility api to parse the IResolvedUrl.url into specific parts like querystring, path to get
+ * deep link info etc.
+ * Warning - This function may not be compatible with any Url Resolver's resolved url. It works
+ * with urls of type: protocol://<string>/.../..?<querystring>
+ * @param url - This is the IResolvedUrl.url part of the resolved url.
+ * @returns The IParsedUrl representing the input URL, or undefined if the format was not supported
+ */
+export function tryParseCompatibleResolvedUrl(url: string): IParsedUrl | undefined {
 	const parsed = parse(url, true);
 	if (typeof parsed.pathname !== "string") {
 		throw new LoggingError("Failed to parse pathname");