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

package/src/odspUtils.ts

@@ -3,35 +3,43 @@
  * Licensed under the MIT License.
  */
 
-import { ITelemetryProperties, ITelemetryBaseLogger, ITelemetryLogger } from "@fluidframework/common-definitions";
+import { ITelemetryProperties, ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
 import { IResolvedUrl, DriverErrorType } from "@fluidframework/driver-definitions";
 import {
-    isOnline,
-    OnlineStatus,
-    RetryableError,
-    NonRetryableError,
-    NetworkErrorBasic,
+	isOnline,
+	OnlineStatus,
+	RetryableError,
+	NonRetryableError,
+	NetworkErrorBasic,
 } from "@fluidframework/driver-utils";
-import { assert, performance } from "@fluidframework/common-utils";
-import { ChildLogger, PerformanceEvent, wrapError } from "@fluidframework/telemetry-utils";
+import { performance } from "@fluid-internal/client-utils";
+import { assert } from "@fluidframework/core-utils";
 import {
-    fetchIncorrectResponse,
-    throwOdspNetworkError,
-    getSPOAndGraphRequestIdsFromResponse,
+	ITelemetryLoggerExt,
+	PerformanceEvent,
+	TelemetryDataTag,
+	createChildLogger,
+	wrapError,
+} from "@fluidframework/telemetry-utils";
+import {
+	fetchIncorrectResponse,
+	throwOdspNetworkError,
+	getSPOAndGraphRequestIdsFromResponse,
 } from "@fluidframework/odsp-doclib-utils";
 import {
-    IOdspResolvedUrl,
-    TokenFetchOptions,
-    OdspErrorType,
-    tokenFromResponse,
-    isTokenFromCache,
-    OdspResourceTokenFetchOptions,
-    ShareLinkTypes,
-    TokenFetcher,
-    ICacheEntry,
-    snapshotKey,
-    InstrumentedStorageTokenFetcher,
-    IOdspUrlParts,
+	IOdspResolvedUrl,
+	TokenFetchOptions,
+	OdspErrorType,
+	tokenFromResponse,
+	isTokenFromCache,
+	OdspResourceTokenFetchOptions,
+	ShareLinkTypes,
+	ISharingLinkKind,
+	TokenFetcher,
+	ICacheEntry,
+	snapshotKey,
+	InstrumentedStorageTokenFetcher,
+	IOdspUrlParts,
 } from "@fluidframework/odsp-driver-definitions";
 import { fetch } from "./fetch";
 import { pkgVersion as driverVersion } from "./packageVersion";
@@ -42,24 +50,27 @@ export const getWithRetryForTokenRefreshRepeat = "getWithRetryForTokenRefreshRep
 /** Parse the given url and return the origin (host name) */
 export const getOrigin = (url: string) => new URL(url).origin;
 
+/**
+ * @alpha
+ */
 export interface IOdspResponse<T> {
-    content: T;
-    headers: Map<string, string>;
-    propsToLog: ITelemetryProperties;
-    duration: number;
+	content: T;
+	headers: Map<string, string>;
+	propsToLog: ITelemetryProperties;
+	duration: number;
 }
 
 export interface TokenFetchOptionsEx extends TokenFetchOptions {
-    /** previous error we hit in getWithRetryForTokenRefresh */
-    previousError?: any;
+	/** previous error we hit in getWithRetryForTokenRefresh */
+	previousError?: any;
 }
 
 function headersToMap(headers: Headers) {
-    const newHeaders = new Map<string, string>();
-    for (const [key, value] of headers.entries()) {
-        newHeaders.set(key, value);
-    }
-    return newHeaders;
+	const newHeaders = new Map<string, string>();
+	for (const [key, value] of headers.entries()) {
+		newHeaders.set(key, value);
+	}
+	return newHeaders;
 }
 
 /**
@@ -68,90 +79,118 @@ function headersToMap(headers: Headers) {
  * token on failure. Only specific cases get retry call with refresh = true, all other / unknown errors
  * simply propagate to caller
  */
-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) {
-            // If the error is 401 or 403 refresh the token and try once more.
-            case DriverErrorType.authorizationError:
-                return get({ ...options, claims: e.claims, tenantId: e.tenantId });
-
-            case DriverErrorType.incorrectServerResponse: // some error on the wire, retry once
-            case OdspErrorType.fetchTokenError: // If the token was null, then retry once.
-                return get(options);
-
-            default:
-                // Caller may determine that it wants one retry
-                if (e[getWithRetryForTokenRefreshRepeat] === true) {
-                    return get(options);
-                }
-                throw e;
-        }
-    });
+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) {
+			// If the error is 401 or 403 refresh the token and try once more.
+			case DriverErrorType.authorizationError:
+				return get({ ...options, claims: e.claims, tenantId: e.tenantId });
+
+			case DriverErrorType.incorrectServerResponse: // some error on the wire, retry once
+			case OdspErrorType.fetchTokenError: // If the token was null, then retry once.
+				return get(options);
+
+			default:
+				// Caller may determine that it wants one retry
+				if (e[getWithRetryForTokenRefreshRepeat] === true) {
+					return get(options);
+				}
+				throw e;
+		}
+	});
 }
 
 export async function fetchHelper(
-    requestInfo: RequestInfo,
-    requestInit: RequestInit | undefined,
+	requestInfo: RequestInfo,
+	requestInit: RequestInit | undefined,
 ): Promise<IOdspResponse<Response>> {
-    const start = performance.now();
-
-    // 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;
-        // Let's assume we can retry.
-        if (!response) {
-            throw new NonRetryableError(
-                // pre-0.58 error message: No response from fetch call
-                "No response from ODSP fetch call",
-                DriverErrorType.incorrectServerResponse,
-                { driverVersion });
-        }
-        if (!response.ok || response.status < 200 || response.status >= 300) {
-            throwOdspNetworkError(
-                // pre-0.58 error message prefix: odspFetchError
-                `ODSP fetch error [${response.status}]`, response.status, response, await response.text());
-        }
-
-        const headers = headersToMap(response.headers);
-        return {
-            content: response,
-            headers,
-            propsToLog: getSPOAndGraphRequestIdsFromResponse(headers),
-            duration: performance.now() - start,
-        };
-    }, (error) => {
-        const online = isOnline();
-        const errorText = `${error}`;
-
-        // This error is thrown by fetch() when AbortSignal is provided and it gets cancelled
-        if (error.name === "AbortError") {
-            throw new RetryableError(
-                "Fetch Timeout (AbortError)", OdspErrorType.fetchTimeout, { driverVersion });
-        }
-        // TCP/IP timeout
-        if (errorText.includes("ETIMEDOUT")) {
-            throw new RetryableError(
-                "Fetch Timeout (ETIMEDOUT)", OdspErrorType.fetchTimeout, { driverVersion });
-        }
-
-        //
-        // WARNING: Do not log error object itself or any of its properties!
-        // It could contain PII, like URI in message itself, or token in properties.
-        // It is also non-serializable object due to circular references.
-        //
-        if (online === OnlineStatus.Offline) {
-            throw new RetryableError(
-                // pre-0.58 error message prefix: Offline
-                `ODSP fetch failure (Offline): ${errorText}`, DriverErrorType.offlineError, { driverVersion });
-        } else {
-            // It is perhaps still possible that this is due to being offline, the error does not reveal enough
-            // information to conclude.  Could also be DNS errors, malformed fetch request, CSP violation, etc.
-            throw new RetryableError(
-                // pre-0.58 error message prefix: Fetch error
-                `ODSP fetch failure: ${errorText}`, DriverErrorType.fetchFailure, { driverVersion });
-        }
-    });
+	const start = performance.now();
+
+	// 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;
+			// Let's assume we can retry.
+			if (!response) {
+				throw new NonRetryableError(
+					// pre-0.58 error message: No response from fetch call
+					"No response from ODSP fetch call",
+					DriverErrorType.incorrectServerResponse,
+					{ driverVersion },
+				);
+			}
+			if (!response.ok || response.status < 200 || response.status >= 300) {
+				throwOdspNetworkError(
+					// pre-0.58 error message prefix: odspFetchError
+					`ODSP fetch error [${response.status}]`,
+					response.status,
+					response,
+					await response.text(),
+				);
+			}
+
+			const headers = headersToMap(response.headers);
+			return {
+				content: response,
+				headers,
+				propsToLog: getSPOAndGraphRequestIdsFromResponse(headers),
+				duration: performance.now() - start,
+			};
+		},
+		(error) => {
+			const online = isOnline();
+
+			// The error message may not be suitable to log for privacy reasons, so tag it as such
+			const taggedErrorMessage = {
+				value: `${error}`, // This uses toString for objects, which often results in `${error.name}: ${error.message}`
+				tag: TelemetryDataTag.UserData,
+			};
+			// After redacting URLs we believe the error message is safe to log
+			const urlRegex = /((http|https):\/\/(\S*))/i;
+			const redactedErrorText = taggedErrorMessage.value.replace(urlRegex, "REDACTED_URL");
+
+			// This error is thrown by fetch() when AbortSignal is provided and it gets cancelled
+			if (error.name === "AbortError") {
+				throw new RetryableError("Fetch Timeout (AbortError)", OdspErrorType.fetchTimeout, {
+					driverVersion,
+				});
+			}
+			// TCP/IP timeout
+			if (redactedErrorText.includes("ETIMEDOUT")) {
+				throw new RetryableError("Fetch Timeout (ETIMEDOUT)", OdspErrorType.fetchTimeout, {
+					driverVersion,
+				});
+			}
+
+			// eslint-disable-next-line unicorn/prefer-ternary
+			if (online === OnlineStatus.Offline) {
+				throw new RetryableError(
+					// pre-0.58 error message prefix: Offline
+					`ODSP fetch failure (Offline): ${redactedErrorText}`,
+					DriverErrorType.offlineError,
+					{
+						driverVersion,
+						rawErrorMessage: taggedErrorMessage,
+					},
+				);
+			} else {
+				// It is perhaps still possible that this is due to being offline, the error does not reveal enough
+				// information to conclude.  Could also be DNS errors, malformed fetch request, CSP violation, etc.
+				throw new RetryableError(
+					// pre-0.58 error message prefix: Fetch error
+					`ODSP fetch failure: ${redactedErrorText}`,
+					DriverErrorType.fetchFailure,
+					{
+						driverVersion,
+						rawErrorMessage: taggedErrorMessage,
+					},
+				);
+			}
+		},
+	);
 }
 
 /**
@@ -160,19 +199,32 @@ export async function fetchHelper(
  * @param requestInit - fetch requestInit
  */
 export async function fetchArray(
-    requestInfo: RequestInfo,
-    requestInit: RequestInit | undefined,
+	requestInfo: RequestInfo,
+	requestInit: RequestInit | undefined,
 ): Promise<IOdspResponse<ArrayBuffer>> {
-    const { content, headers, propsToLog, duration } = await fetchHelper(requestInfo, requestInit);
-
-    const arrayBuffer = await content.arrayBuffer();
-    propsToLog.bodySize = arrayBuffer.byteLength;
-    return {
-        headers,
-        content: arrayBuffer,
-        propsToLog,
-        duration,
-    };
+	const { content, headers, propsToLog, duration } = await fetchHelper(requestInfo, requestInit);
+	let arrayBuffer: ArrayBuffer;
+	try {
+		arrayBuffer = await content.arrayBuffer();
+	} catch (e) {
+		// Parsing can fail and message could contain full request URI, including
+		// tokens, etc. So do not log error object itself.
+		throwOdspNetworkError(
+			"Error while parsing fetch response",
+			fetchIncorrectResponse,
+			content, // response
+			undefined, // response text
+			propsToLog,
+		);
+	}
+
+	propsToLog.bodySize = arrayBuffer.byteLength;
+	return {
+		headers,
+		content: arrayBuffer,
+		propsToLog,
+		duration,
+	};
 }
 
 /**
@@ -181,159 +233,249 @@ export async function fetchArray(
  * @param requestInit - fetch requestInit
  */
 export async function fetchAndParseAsJSONHelper<T>(
-    requestInfo: RequestInfo,
-    requestInit: RequestInit | undefined,
+	requestInfo: RequestInfo,
+	requestInit: RequestInit | undefined,
 ): Promise<IOdspResponse<T>> {
-    const { content, headers, propsToLog, duration } = await fetchHelper(requestInfo, requestInit);
-    let text: string | undefined;
-    try {
-        text = await content.text();
-    } catch (e) {
-        // 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
-        // succeeds on retry.
-        // So do not log error object itself.
-        throwOdspNetworkError(
-            // pre-0.58 error message: errorWhileParsingFetchResponse
-            "Error while parsing fetch response",
-            fetchIncorrectResponse,
-            content, // response
-            text,
-        );
-    }
-
-    propsToLog.bodySize = text.length;
-    const res = {
-        headers,
-        content: JSON.parse(text),
-        propsToLog,
-        duration,
-    };
-    return res;
+	const { content, headers, propsToLog, duration } = await fetchHelper(requestInfo, requestInit);
+	let text: string | undefined;
+	try {
+		text = await content.text();
+	} catch (e) {
+		// 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
+		// succeeds on retry.
+		// So do not log error object itself.
+		throwOdspNetworkError(
+			// pre-0.58 error message: errorWhileParsingFetchResponse
+			"Error while parsing fetch response",
+			fetchIncorrectResponse,
+			content, // response
+			text,
+			propsToLog,
+		);
+	}
+
+	propsToLog.bodySize = text.length;
+	const res = {
+		headers,
+		content: JSON.parse(text),
+		propsToLog,
+		duration,
+	};
+	return res;
+}
+
+export interface IFileInfoBase {
+	type: "New" | "Existing";
+	siteUrl: string;
+	driveId: string;
+}
+
+export interface INewFileInfo extends IFileInfoBase {
+	type: "New";
+	filename: string;
+	filePath: string;
+	/**
+	 * application can request creation of a share link along with the creation of a new file
+	 * by passing in an optional param to specify the kind of sharing link
+	 * (at the time of adding this comment Sept/2021), odsp only supports csl
+	 * ShareLinkTypes will deprecated in future. Use ISharingLinkKind instead which specifies both
+	 * share link type and the role type.
+	 */
+	createLinkType?: ShareLinkTypes | ISharingLinkKind;
 }
 
-export interface INewFileInfo {
-    siteUrl: string;
-    driveId: string;
-    filename: string;
-    filePath: string;
-    /**
-     * application can request creation of a share link along with the creation of a new file
-     * by passing in an optional param to specify the kind of sharing link
-     * (at the time of adding this comment Sept/2021), odsp only supports csl
-     */
-    createLinkType?: ShareLinkTypes;
+export interface IExistingFileInfo extends IFileInfoBase {
+	type: "Existing";
+	itemId: string;
+}
+
+export function isNewFileInfo(
+	fileInfo: INewFileInfo | IExistingFileInfo,
+): fileInfo is INewFileInfo {
+	return fileInfo.type === undefined || fileInfo.type === "New";
 }
 
 export function getOdspResolvedUrl(resolvedUrl: IResolvedUrl): IOdspResolvedUrl {
-    assert((resolvedUrl as IOdspResolvedUrl).odspResolvedUrl === true, 0x1de /* "Not an ODSP resolved url" */);
-    return resolvedUrl as IOdspResolvedUrl;
+	assert(
+		(resolvedUrl as IOdspResolvedUrl).odspResolvedUrl === true,
+		0x1de /* "Not an ODSP resolved url" */,
+	);
+	return resolvedUrl as IOdspResolvedUrl;
+}
+
+/**
+ * @internal
+ */
+export function isOdspResolvedUrl(resolvedUrl: IResolvedUrl): resolvedUrl is IOdspResolvedUrl {
+	return "odspResolvedUrl" in resolvedUrl && resolvedUrl.odspResolvedUrl === true;
 }
 
 export const createOdspLogger = (logger?: ITelemetryBaseLogger) =>
-    ChildLogger.create(
-        logger,
-        "OdspDriver",
-        {
-            all:
-            {
-                driverVersion,
-            },
-        });
+	createChildLogger({
+		logger,
+		namespace: "OdspDriver",
+		properties: {
+			all: {
+				driverVersion,
+			},
+		},
+	});
 
 export function evalBlobsAndTrees(snapshot: IOdspSnapshot) {
-    let numTrees = 0;
-    let numBlobs = 0;
-    let encodedBlobsSize = 0;
-    let decodedBlobsSize = 0;
-    for (const tree of snapshot.trees) {
-        for (const treeEntry of tree.entries) {
-            if (treeEntry.type === "blob") {
-                numBlobs++;
-            } else if (treeEntry.type === "tree") {
-                numTrees++;
-            }
-        }
-    }
-    if (snapshot.blobs !== undefined) {
-        for (const blob of snapshot.blobs) {
-            decodedBlobsSize += blob.size;
-            encodedBlobsSize += blob.content.length;
-        }
-    }
-    return { numTrees, numBlobs, encodedBlobsSize, decodedBlobsSize };
+	let numTrees = 0;
+	let numBlobs = 0;
+	let encodedBlobsSize = 0;
+	let decodedBlobsSize = 0;
+	for (const tree of snapshot.trees) {
+		for (const treeEntry of tree.entries) {
+			if (treeEntry.type === "blob") {
+				numBlobs++;
+			} else if (treeEntry.type === "tree") {
+				numTrees++;
+			}
+		}
+	}
+	if (snapshot.blobs !== undefined) {
+		for (const blob of snapshot.blobs) {
+			decodedBlobsSize += blob.size;
+			encodedBlobsSize += blob.content.length;
+		}
+	}
+	return { numTrees, numBlobs, encodedBlobsSize, decodedBlobsSize };
 }
 
 export function toInstrumentedOdspTokenFetcher(
-    logger: ITelemetryLogger,
-    resolvedUrlParts: IOdspUrlParts,
-    tokenFetcher: TokenFetcher<OdspResourceTokenFetchOptions>,
-    throwOnNullToken: boolean,
+	logger: ITelemetryLoggerExt,
+	resolvedUrlParts: IOdspUrlParts,
+	tokenFetcher: TokenFetcher<OdspResourceTokenFetchOptions>,
+	throwOnNullToken: boolean,
 ): InstrumentedStorageTokenFetcher {
-    return async (options: TokenFetchOptions, name: string, alwaysRecordTokenFetchTelemetry: boolean = false) => {
-        // Telemetry note: if options.refresh is true, there is a potential perf issue:
-        // Host should optimize and provide non-expired tokens on all critical paths.
-        // Exceptions: race conditions around expiration, revoked tokens, host that does not care
-        // (fluid-fetcher)
-        return PerformanceEvent.timedExecAsync(
-            logger,
-            {
-                eventName: `${name}_GetToken`,
-                attempts: options.refresh ? 2 : 1,
-                hasClaims: !!options.claims,
-                hasTenantId: !!options.tenantId,
-            },
-            async (event) => tokenFetcher({
-                ...options,
-                ...resolvedUrlParts,
-            }).then((tokenResponse) => {
-                const token = tokenFromResponse(tokenResponse);
-                // This event alone generates so many events that is materially impacts cost of telemetry
-                // Thus do not report end event when it comes back quickly.
-                // Note that most of the hosts do not report if result is comming from cache or not,
-                // so we can't rely on that here. But always record if specified explicitly for cases such as
-                // calling trees/latest during load.
-                if (alwaysRecordTokenFetchTelemetry || event.duration >= 32) {
-                    event.end({ fromCache: isTokenFromCache(tokenResponse), isNull: token === null });
-                }
-                if (token === null && throwOnNullToken) {
-                    throw new NonRetryableError(
-                        // pre-0.58 error message: Token is null for ${name} call
-                        `The Host-provided token fetcher returned null`,
-                        OdspErrorType.fetchTokenError,
-                        { method: name, driverVersion });
-                }
-                return token;
-            }, (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)
-                const rawCanRetry = error?.canRetry;
-                const tokenError = wrapError(
-                    error,
-                    (errorMessage) => new NetworkErrorBasic(
-                        `The Host-provided token fetcher threw an error: ${errorMessage}`,
-                        OdspErrorType.fetchTokenError,
-                        typeof rawCanRetry === "boolean" ? rawCanRetry : false /* canRetry */,
-                        { method: name, driverVersion }));
-                throw tokenError;
-            }),
-            { cancel: "generic" });
-    };
+	return async (
+		options: TokenFetchOptions,
+		name: string,
+		alwaysRecordTokenFetchTelemetry: boolean = false,
+	) => {
+		// Telemetry note: if options.refresh is true, there is a potential perf issue:
+		// Host should optimize and provide non-expired tokens on all critical paths.
+		// Exceptions: race conditions around expiration, revoked tokens, host that does not care
+		// (fluid-fetcher)
+		return PerformanceEvent.timedExecAsync(
+			logger,
+			{
+				eventName: `${name}_GetToken`,
+				attempts: options.refresh ? 2 : 1,
+				hasClaims: !!options.claims,
+				hasTenantId: !!options.tenantId,
+			},
+			async (event) =>
+				tokenFetcher({
+					...options,
+					...resolvedUrlParts,
+				}).then(
+					(tokenResponse) => {
+						const token = tokenFromResponse(tokenResponse);
+						// This event alone generates so many events that is materially impacts cost of telemetry
+						// Thus do not report end event when it comes back quickly.
+						// Note that most of the hosts do not report if result is comming from cache or not,
+						// so we can't rely on that here. But always record if specified explicitly for cases such as
+						// calling trees/latest during load.
+						if (alwaysRecordTokenFetchTelemetry || event.duration >= 32) {
+							event.end({
+								fromCache: isTokenFromCache(tokenResponse),
+								isNull: token === null,
+							});
+						}
+						if (token === null && throwOnNullToken) {
+							throw new NonRetryableError(
+								// pre-0.58 error message: Token is null for ${name} call
+								`The Host-provided token fetcher returned null`,
+								OdspErrorType.fetchTokenError,
+								{ method: name, driverVersion },
+							);
+						}
+						return token;
+					},
+					(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)
+						const rawCanRetry = error?.canRetry;
+						const tokenError = wrapError(
+							error,
+							(errorMessage) =>
+								new NetworkErrorBasic(
+									`The Host-provided token fetcher threw an error`,
+									OdspErrorType.fetchTokenError,
+									typeof rawCanRetry === "boolean"
+										? rawCanRetry
+										: false /* canRetry */,
+									{ method: name, errorMessage, driverVersion },
+								),
+						);
+						throw tokenError;
+					},
+				),
+			{ cancel: "generic" },
+		);
+	};
 }
 
 export function createCacheSnapshotKey(odspResolvedUrl: IOdspResolvedUrl): ICacheEntry {
-    const cacheEntry: ICacheEntry = {
-        type: snapshotKey,
-        key: "",
-        file: {
-            resolvedUrl: odspResolvedUrl,
-            docId: odspResolvedUrl.hashedDocumentId,
-        },
-    };
-    return cacheEntry;
+	const cacheEntry: ICacheEntry = {
+		type: snapshotKey,
+		key: odspResolvedUrl.fileVersion ?? "",
+		file: {
+			resolvedUrl: odspResolvedUrl,
+			docId: odspResolvedUrl.hashedDocumentId,
+		},
+	};
+	return cacheEntry;
 }
 
 // 80KB is the max body size that we can put in ump post body for server to be able to accept it.
 // Keeping it 78KB to be a little cautious. As per the telemetry 99p is less than 78KB.
 export const maxUmpPostBodySize = 79872;
+
+/**
+ * Build request parameters to request for the creation of a sharing link along with the creation of the file
+ * through the /snapshot api call.
+ * @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: ShareLinkTypes | ISharingLinkKind | undefined,
+) {
+	if (!shareLinkType) {
+		return;
+	}
+	const scope = (shareLinkType as ISharingLinkKind).scope;
+	if (!scope) {
+		// eslint-disable-next-line @typescript-eslint/no-base-to-string
+		return `createLinkType=${shareLinkType}`;
+	}
+	let shareLinkRequestParams = `createLinkScope=${scope}`;
+	const role = (shareLinkType as ISharingLinkKind).role;
+	shareLinkRequestParams = role
+		? `${shareLinkRequestParams}&createLinkRole=${role}`
+		: shareLinkRequestParams;
+	return shareLinkRequestParams;
+}
+
+export function measure<T>(callback: () => T): [T, number] {
+	const start = performance.now();
+	const result = callback();
+	const time = performance.now() - start;
+	return [result, time];
+}
+
+export async function measureP<T>(callback: () => Promise<T>): Promise<[T, number]> {
+	const start = performance.now();
+	const result = await callback();
+	const time = performance.now() - start;
+	return [result, time];
+}
+
+export function getJoinSessionCacheKey(odspResolvedUrl: IOdspResolvedUrl) {
+	return `${odspResolvedUrl.hashedDocumentId}/joinsession`;
+}