@fluidframework/odsp-driver 0.54.2 → 0.56.0-49831

package/src/createFile.ts

@@ -55,6 +55,7 @@ export async function createNewFluidFile(
     epochTracker: EpochTracker,
     fileEntry: IFileEntry,
     createNewCaching: boolean,
+    forceAccessTokenViaAuthorizationHeader: boolean,
 ): Promise<IOdspResolvedUrl> {
     // Check for valid filename before the request to create file is actually made.
     if (isInvalidFileName(newFileInfo.filename)) {
@@ -67,10 +68,17 @@ export async function createNewFluidFile(
     let sharingLink: string | undefined;
     let sharingLinkErrorReason: string | undefined;
     if (createNewSummary === undefined) {
-        itemId = await createNewEmptyFluidFile(getStorageToken, newFileInfo, logger, epochTracker);
+        itemId = await createNewEmptyFluidFile(
+            getStorageToken, newFileInfo, logger, epochTracker, forceAccessTokenViaAuthorizationHeader);
     } else {
         const content = await createNewFluidFileFromSummary(
-            getStorageToken, newFileInfo, logger, createNewSummary, epochTracker);
+            getStorageToken,
+            newFileInfo,
+            logger,
+            createNewSummary,
+            epochTracker,
+            forceAccessTokenViaAuthorizationHeader,
+        );
         itemId = content.itemId;
         summaryHandle = content.id;
         sharingLink = content.sharingLink;
@@ -108,6 +116,7 @@ export async function createNewEmptyFluidFile(
     newFileInfo: INewFileInfo,
     logger: ITelemetryLogger,
     epochTracker: EpochTracker,
+    forceAccessTokenViaAuthorizationHeader: boolean,
 ): Promise<string> {
     const filePath = newFileInfo.filePath ? encodeURIComponent(`/${newFileInfo.filePath}`) : "";
     // add .tmp extension to empty file (host is expected to rename)
@@ -123,7 +132,8 @@ export async function createNewEmptyFluidFile(
             logger,
             { eventName: "createNewEmptyFile" },
             async (event) => {
-                const { url, headers } = getUrlAndHeadersWithAuth(initialUrl, storageToken);
+                const { url, headers } = getUrlAndHeadersWithAuth(
+                    initialUrl, storageToken, forceAccessTokenViaAuthorizationHeader);
                 headers["Content-Type"] = "application/json";
 
                 const fetchResponse = await runWithRetry(
@@ -163,6 +173,7 @@ export async function createNewFluidFileFromSummary(
     logger: ITelemetryLogger,
     createNewSummary: ISummaryTree,
     epochTracker: EpochTracker,
+    forceAccessTokenViaAuthorizationHeader: boolean,
 ): Promise<ICreateFileResponse> {
     const filePath = newFileInfo.filePath ? encodeURIComponent(`/${newFileInfo.filePath}`) : "";
     const encodedFilename = encodeURIComponent(newFileInfo.filename);
@@ -181,7 +192,8 @@ export async function createNewFluidFileFromSummary(
             logger,
             { eventName: "createNewFile" },
             async (event) => {
-                const { url, headers } = getUrlAndHeadersWithAuth(initialUrl, storageToken);
+                const { url, headers } = getUrlAndHeadersWithAuth(
+                    initialUrl, storageToken, forceAccessTokenViaAuthorizationHeader);
                 headers["Content-Type"] = "application/json";
 
                 const fetchResponse = await runWithRetry(

package/src/epochTracker.ts

@@ -18,13 +18,14 @@ import {
 } from "@fluidframework/odsp-driver-definitions";
 import { DriverErrorType } from "@fluidframework/driver-definitions";
 import { PerformanceEvent, isFluidError, normalizeError } from "@fluidframework/telemetry-utils";
-import { fetchAndParseAsJSONHelper, fetchArray, IOdspResponse } from "./odspUtils";
+import { fetchAndParseAsJSONHelper, fetchArray, getOdspResolvedUrl, IOdspResponse } from "./odspUtils";
 import {
     IOdspCache,
     INonPersistentCache,
     IPersistedFileCache,
  } from "./odspCache";
 import { IVersionedValueWithEpoch, persistedCacheValueVersion } from "./contracts";
+import { ClpCompliantAppHeader } from "./contractsPublic";
 
 export type FetchType = "blob" | "createBlob" | "createFile" | "joinSession" | "ops" | "test" | "snapshotTree" |
     "treesLatest" | "uploadSummary" | "push" | "versions";
@@ -33,6 +34,7 @@ export type FetchTypeInternal = FetchType | "cache";
 
 export const Odsp409Error = "Odsp409Error";
 
+// Please update the README file in odsp-driver-definitions if you change the defaultCacheExpiryTimeoutMs.
 export const defaultCacheExpiryTimeoutMs: number = 2 * 24 * 60 * 60 * 1000;
 
 /**
@@ -169,8 +171,9 @@ export class EpochTracker implements IPersistedFileCache {
         fetchOptions: RequestInit,
         fetchType: FetchType,
         addInBody: boolean = false,
+        fetchReason?: string,
     ): Promise<IOdspResponse<T>> {
-        const clientCorrelationId = this.formatClientCorrelationId();
+        const clientCorrelationId = this.formatClientCorrelationId(fetchReason);
         // Add epoch in fetch request.
         this.addEpochInRequest(fetchOptions, addInBody, clientCorrelationId);
         let epochFromResponse: string | undefined;
@@ -210,8 +213,9 @@ export class EpochTracker implements IPersistedFileCache {
         fetchOptions: {[index: string]: any},
         fetchType: FetchType,
         addInBody: boolean = false,
+        fetchReason?: string,
     ) {
-        const clientCorrelationId = this.formatClientCorrelationId();
+        const clientCorrelationId = this.formatClientCorrelationId(fetchReason);
         // Add epoch in fetch request.
         this.addEpochInRequest(fetchOptions, addInBody, clientCorrelationId);
         let epochFromResponse: string | undefined;
@@ -244,12 +248,16 @@ export class EpochTracker implements IPersistedFileCache {
         addInBody: boolean,
         clientCorrelationId: string,
     ) {
+        const isClpCompliantApp = getOdspResolvedUrl(this.fileEntry.resolvedUrl).isClpCompliantApp;
         if (addInBody) {
             const headers: {[key: string]: string} = {};
             headers["X-RequestStats"] = clientCorrelationId;
             if (this.fluidEpoch !== undefined) {
                 headers["x-fluid-epoch"] = this.fluidEpoch;
             }
+            if (isClpCompliantApp) {
+                headers[ClpCompliantAppHeader.isClpCompliantApp] = isClpCompliantApp.toString();
+            }
             this.addParamInBody(fetchOptions, headers);
         } else {
             const addHeader = (key: string, val: string) => {
@@ -263,6 +271,9 @@ export class EpochTracker implements IPersistedFileCache {
             if (this.fluidEpoch !== undefined) {
                 addHeader("x-fluid-epoch", this.fluidEpoch);
             }
+            if (isClpCompliantApp) {
+                addHeader(ClpCompliantAppHeader.isClpCompliantApp, isClpCompliantApp.toString());
+            }
         }
     }
 
@@ -284,8 +295,12 @@ export class EpochTracker implements IPersistedFileCache {
         fetchOptions.body = formParams.join("\r\n");
     }
 
-    private formatClientCorrelationId() {
-        return `driverId=${this.driverId}, RequestNumber=${this.networkCallNumber++}`;
+    private formatClientCorrelationId(fetchReason?: string) {
+        const items: string[] = [`driverId=${this.driverId}`, `RequestNumber=${this.networkCallNumber++}`];
+        if (fetchReason !== undefined) {
+            items.push(`fetchReason=${fetchReason}`);
+        }
+        return items.join(", ");
     }
 
     protected validateEpochFromResponse(
@@ -394,13 +409,14 @@ export class EpochTrackerWithRedemption extends EpochTracker {
         fetchOptions: {[index: string]: any},
         fetchType: FetchType,
         addInBody: boolean = false,
+        fetchReason?: string,
     ): Promise<IOdspResponse<T>> {
         // Optimize the flow if we know that treesLatestDeferral was already completed by the timer we started
         // joinSession call. If we did - there is no reason to repeat the call as it will fail with same error.
         const completed = this.treesLatestDeferral.isCompleted;
 
         try {
-            return await super.fetchAndParseAsJSON<T>(url, fetchOptions, fetchType, addInBody);
+            return await super.fetchAndParseAsJSON<T>(url, fetchOptions, fetchType, addInBody, fetchReason);
         } catch (error) {
             // Only handling here treesLatest. If createFile failed, we should never try to do joinSession.
             // Similar, if getVersions failed, we should not do any further storage calls.
@@ -428,8 +444,8 @@ export class EpochTrackerWithRedemption extends EpochTracker {
             async (event) => {
                 const timeoutRes = 51; // anything will work here
                 let timer: ReturnType<typeof setTimeout>;
-                const timeoutP = new Promise<number>((accept) => {
-                    timer = setTimeout(() => { accept(timeoutRes); }, 15000);
+                const timeoutP = new Promise<number>((resolve) => {
+                    timer = setTimeout(() => { resolve(timeoutRes); }, 15000);
                 });
                 const res = await Promise.race([
                     timeoutP,

package/src/fetchSnapshot.ts

@@ -39,6 +39,7 @@ import { EpochTracker } from "./epochTracker";
  * @param storageFetchWrapper - Implementation of the get/post methods used to fetch the snapshot
  * @param versionId - id of specific snapshot to be fetched
  * @param fetchFullSnapshot - whether we want to fetch full snapshot(with blobs)
+ * @param forceAccessTokenViaAuthorizationHeader - whether to force passing given token via authorization header
  * @returns A promise of the snapshot and the status code of the response
  */
 export async function fetchSnapshot(
@@ -46,6 +47,7 @@ export async function fetchSnapshot(
     token: string | null,
     versionId: string,
     fetchFullSnapshot: boolean,
+    forceAccessTokenViaAuthorizationHeader: boolean,
     logger: ITelemetryLogger,
     snapshotDownloader: (url: string, fetchOptions: {[index: string]: any}) => Promise<IOdspResponse<unknown>>,
 ): Promise<ISnapshotContents> {
@@ -61,7 +63,8 @@ export async function fetchSnapshot(
     }
 
     const queryString = getQueryString(queryParams);
-    const { url, headers } = getUrlAndHeadersWithAuth(`${snapshotUrl}${path}${queryString}`, token);
+    const { url, headers } = getUrlAndHeadersWithAuth(
+        `${snapshotUrl}${path}${queryString}`, token, forceAccessTokenViaAuthorizationHeader);
     const response = await PerformanceEvent.timedExecAsync(
         logger,
         {
@@ -77,6 +80,7 @@ export async function fetchSnapshotWithRedeem(
     odspResolvedUrl: IOdspResolvedUrl,
     storageTokenFetcher: InstrumentedStorageTokenFetcher,
     snapshotOptions: ISnapshotOptions | undefined,
+    forceAccessTokenViaAuthorizationHeader: boolean,
     logger: ITelemetryLogger,
     snapshotDownloader: (
             finalOdspResolvedUrl: IOdspResolvedUrl,
@@ -88,6 +92,12 @@ export async function fetchSnapshotWithRedeem(
     removeEntries: () => Promise<void>,
     enableRedeemFallback?: boolean,
 ): Promise<ISnapshotContents> {
+    // back-compat: This block to be removed with #8784 when we only consume/consider odsp resolvers that are >= 0.51
+    const sharingLinkToRedeem = (odspResolvedUrl as any).sharingLinkToRedeem;
+    if(sharingLinkToRedeem) {
+        odspResolvedUrl.shareLinkInfo = {...odspResolvedUrl.shareLinkInfo, sharingLinkToRedeem}
+    }
+
     return fetchLatestSnapshotCore(
         odspResolvedUrl,
         storageTokenFetcher,
@@ -95,6 +105,7 @@ export async function fetchSnapshotWithRedeem(
         logger,
         snapshotDownloader,
         putInCache,
+        enableRedeemFallback,
     ).catch(async (error) => {
         if (enableRedeemFallback && isRedeemSharingLinkError(odspResolvedUrl, error)) {
             // Execute the redeem fallback
@@ -102,16 +113,15 @@ export async function fetchSnapshotWithRedeem(
                 eventName: "RedeemFallback",
                 errorType: error.errorType,
             }, error);
-            await redeemSharingLink(odspResolvedUrl, storageTokenFetcher, logger);
+            await redeemSharingLink(
+                odspResolvedUrl, storageTokenFetcher, logger, forceAccessTokenViaAuthorizationHeader);
             const odspResolvedUrlWithoutShareLink: IOdspResolvedUrl =
-                { ...odspResolvedUrl, sharingLinkToRedeem: undefined };
-
-            if(odspResolvedUrlWithoutShareLink.shareLinkInfo) {
-                odspResolvedUrlWithoutShareLink.shareLinkInfo = {
-                    ...odspResolvedUrlWithoutShareLink.shareLinkInfo,
-                    sharingLinkToRedeem: undefined,
+                { ...odspResolvedUrl,
+                    shareLinkInfo: {
+                        ...odspResolvedUrl.shareLinkInfo,
+                        sharingLinkToRedeem: undefined
+                    }
                 };
-            }
 
             return fetchLatestSnapshotCore(
                 odspResolvedUrlWithoutShareLink,
@@ -140,6 +150,7 @@ async function redeemSharingLink(
     odspResolvedUrl: IOdspResolvedUrl,
     storageTokenFetcher: InstrumentedStorageTokenFetcher,
     logger: ITelemetryLogger,
+    forceAccessTokenViaAuthorizationHeader: boolean,
 ) {
     return PerformanceEvent.timedExecAsync(
         logger,
@@ -147,12 +158,13 @@ async function redeemSharingLink(
             eventName: "RedeemShareLink",
         },
         async () => getWithRetryForTokenRefresh(async (tokenFetchOptions) => {
-                assert(!!odspResolvedUrl.sharingLinkToRedeem,
+                assert(!!odspResolvedUrl.shareLinkInfo?.sharingLinkToRedeem,
                     0x1ed /* "Share link should be present" */);
                 const storageToken = await storageTokenFetcher(tokenFetchOptions, "RedeemShareLink");
-                const encodedShareUrl = getEncodedShareUrl(odspResolvedUrl.sharingLinkToRedeem);
+                const encodedShareUrl = getEncodedShareUrl(odspResolvedUrl.shareLinkInfo?.sharingLinkToRedeem);
                 const redeemUrl = `${odspResolvedUrl.siteUrl}/_api/v2.0/shares/${encodedShareUrl}`;
-                const { url, headers } = getUrlAndHeadersWithAuth(redeemUrl, storageToken);
+                const { url, headers } = getUrlAndHeadersWithAuth(
+                    redeemUrl, storageToken, forceAccessTokenViaAuthorizationHeader);
                 headers.prefer = "redeemSharingLink";
                 return fetchAndParseAsJSONHelper(url, { headers });
         }),
@@ -171,6 +183,7 @@ async function fetchLatestSnapshotCore(
             controller?: AbortController,
         ) => Promise<ISnapshotRequestAndResponseOptions>,
     putInCache: (valueWithEpoch: IVersionedValueWithEpoch) => Promise<void>,
+    enableRedeemFallback?: boolean,
 ): Promise<ISnapshotContents> {
     return getWithRetryForTokenRefresh(async (tokenFetchOptions) => {
         const storageToken = await storageTokenFetcher(tokenFetchOptions, "TreesLatest", true);
@@ -187,6 +200,8 @@ async function fetchLatestSnapshotCore(
         const perfEvent = {
             eventName: "TreesLatest",
             attempts: tokenFetchOptions.refresh ? 2 : 1,
+            shareLinkPresent: odspResolvedUrl.shareLinkInfo?.sharingLinkToRedeem !== undefined,
+            redeemFallbackEnabled: enableRedeemFallback,
         };
         if (snapshotOptions !== undefined) {
             Object.entries(snapshotOptions).forEach(([key, value]) => {
@@ -344,30 +359,9 @@ async function fetchSnapshotContentsCoreV1(
 ): Promise<ISnapshotRequestAndResponseOptions> {
     const snapshotUrl = odspResolvedUrl.endpoints.snapshotStorageUrl;
     const url = `${snapshotUrl}/trees/latest?ump=1`;
-    const formBoundary = uuid();
-    const formParams: string[] = [];
-    formParams.push(`--${formBoundary}`);
-    formParams.push(`Authorization: Bearer ${storageToken}`);
-    formParams.push(`X-HTTP-Method-Override: GET`);
-    if (snapshotOptions !== undefined) {
-        Object.entries(snapshotOptions).forEach(([key, value]) => {
-            if (value !== undefined) {
-                formParams.push(`${key}: ${value}`);
-            }
-        });
-    }
-    if (odspResolvedUrl.sharingLinkToRedeem) {
-        formParams.push(`sl: ${odspResolvedUrl.sharingLinkToRedeem}`);
-    }
-    formParams.push(`_post: 1`);
-    formParams.push(`\r\n--${formBoundary}--`);
-    const postBody = formParams.join("\r\n");
-    const headers: {[index: string]: any} = {
-        "Content-Type": `multipart/form-data;boundary=${formBoundary}`,
-    };
-
+    const { body, headers } = getFormBodyAndHeaders(odspResolvedUrl, storageToken, snapshotOptions);
     const fetchOptions = {
-        body: postBody,
+        body,
         headers,
         signal: controller?.signal,
         method: "POST",
@@ -401,30 +395,57 @@ async function fetchSnapshotContentsCoreV2(
     epochTracker?: EpochTracker,
 ): Promise<ISnapshotRequestAndResponseOptions> {
     const fullUrl = `${odspResolvedUrl.siteUrl}/_api/v2.1/drives/${odspResolvedUrl.driveId}/items/${
-        odspResolvedUrl.itemId}/opStream/attachments/latest/content`;
-    const queryParams = { ...snapshotOptions };
-    if (odspResolvedUrl.sharingLinkToRedeem) {
-        // eslint-disable-next-line @typescript-eslint/dot-notation
-        queryParams["sl"] = odspResolvedUrl.sharingLinkToRedeem;
-    }
-    const queryString = getQueryString(queryParams);
-    const { url, headers } = getUrlAndHeadersWithAuth(`${fullUrl}${queryString}`, storageToken);
+        odspResolvedUrl.itemId}/opStream/attachments/latest/content?ump=1`;
+
+    const { body, headers } = getFormBodyAndHeaders(odspResolvedUrl, storageToken, snapshotOptions);
     const fetchOptions = {
+        body,
         headers,
         signal: controller?.signal,
+        method: "POST",
     };
-    const response = await (epochTracker?.fetchArray(url, fetchOptions, "treesLatest") ??
-        fetchArray(url, fetchOptions));
+
+    const response = await (epochTracker?.fetchArray(fullUrl, fetchOptions, "treesLatest", true) ??
+        fetchArray(fullUrl, fetchOptions));
     const snapshotContents: ISnapshotContents = parseCompactSnapshotResponse(
         new ReadBuffer(new Uint8Array(response.content)));
     const finalSnapshotContents: IOdspResponse<ISnapshotContents> = { ...response, content: snapshotContents };
     return  {
         odspSnapshotResponse: finalSnapshotContents,
         requestHeaders: headers,
-        requestUrl: url,
+        requestUrl: fullUrl,
     };
 }
 
+function getFormBodyAndHeaders(
+    odspResolvedUrl: IOdspResolvedUrl,
+    storageToken: string,
+    snapshotOptions: ISnapshotOptions | undefined,
+) {
+    const formBoundary = uuid();
+    const formParams: string[] = [];
+    formParams.push(`--${formBoundary}`);
+    formParams.push(`Authorization: Bearer ${storageToken}`);
+    formParams.push(`X-HTTP-Method-Override: GET`);
+    if (snapshotOptions !== undefined) {
+        Object.entries(snapshotOptions).forEach(([key, value]) => {
+            if (value !== undefined) {
+                formParams.push(`${key}: ${value}`);
+            }
+        });
+    }
+    if (odspResolvedUrl.shareLinkInfo?.sharingLinkToRedeem) {
+        formParams.push(`sl: ${odspResolvedUrl.shareLinkInfo?.sharingLinkToRedeem}`);
+    }
+    formParams.push(`_post: 1`);
+    formParams.push(`\r\n--${formBoundary}--`);
+    const postBody = formParams.join("\r\n");
+    const headers: {[index: string]: any} = {
+        "Content-Type": `multipart/form-data;boundary=${formBoundary}`,
+    };
+    return { body: postBody, headers };
+}
+
 function validateAndEvalBlobsAndTrees(snapshot: ISnapshotContents) {
     assert(snapshot.snapshotTree !== undefined,
         0x200 /* "Returned odsp snapshot is malformed. No trees!" */);
@@ -457,6 +478,12 @@ export async function downloadSnapshot(
     controller?: AbortController,
     epochTracker?: EpochTracker,
 ): Promise<ISnapshotRequestAndResponseOptions> {
+    // back-compat: This block to be removed with #8784 when we only consume/consider odsp resolvers that are >= 0.51
+    const sharingLinkToRedeem = (odspResolvedUrl as any).sharingLinkToRedeem;
+    if(sharingLinkToRedeem) {
+        odspResolvedUrl.shareLinkInfo = {...odspResolvedUrl.shareLinkInfo, sharingLinkToRedeem}
+    }
+
     if (fetchBinarySnapshotFormat) {
         // Logging an event here as it is not supposed to be used in production yet and only in experimental mode.
         logger.sendTelemetryEvent({ eventName: "BinarySnapshotFetched" });
@@ -467,7 +494,7 @@ export async function downloadSnapshot(
 }
 
 function isRedeemSharingLinkError(odspResolvedUrl: IOdspResolvedUrl, error: any) {
-    if (odspResolvedUrl.sharingLinkToRedeem !== undefined
+    if (odspResolvedUrl.shareLinkInfo?.sharingLinkToRedeem !== undefined
         && (typeof error === "object" && error !== null)
         && (error.errorType === DriverErrorType.authorizationError
         || error.errorType === DriverErrorType.fileNotFoundOrAccessDeniedError)) {

package/src/getFileLink.ts

@@ -84,7 +84,7 @@ async function getFileLinkCore(
     identityType: IdentityType,
     logger: ITelemetryLogger,
 ): Promise<string> {
-    const fileItem = await getFileItemLite(getToken, odspUrlParts, logger);
+    const fileItem = await getFileItemLite(getToken, odspUrlParts, logger, identityType === "Consumer");
 
     // ODC canonical link does not require any additional processing
     if (identityType === "Consumer") {
@@ -104,7 +104,10 @@ async function getFileLinkCore(
                 const { url, headers } = getUrlAndHeadersWithAuth(
                     `${odspUrlParts.siteUrl}/_api/web/GetFileByUrl(@a1)/ListItemAllFields/GetSharingInformation?@a1=${
                         encodeURIComponent(`'${fileItem.webDavUrl}'`)
-                    }`, tokenFromResponse(token));
+                    }`,
+                    tokenFromResponse(token),
+                    false,
+                );
                 const requestInit = {
                     method: "POST",
                     headers: {
@@ -152,6 +155,7 @@ async function getFileItemLite(
     getToken: TokenFetcher<OdspResourceTokenFetchOptions>,
     odspUrlParts: IOdspUrlParts,
     logger: ITelemetryLogger,
+    forceAccessTokenViaAuthorizationHeader: boolean,
 ): Promise<FileItemLite> {
     return PerformanceEvent.timedExecAsync(
         logger,
@@ -166,6 +170,7 @@ async function getFileItemLite(
                 const { url, headers } = getUrlAndHeadersWithAuth(
                     `${siteUrl}/_api/v2.0/drives/${driveId}/items/${itemId}?select=webUrl,webDavUrl`,
                     tokenFromResponse(token),
+                    forceAccessTokenViaAuthorizationHeader,
                 );
                 const requestInit = { method: "GET", headers };
                 const response = await fetchHelper(url, requestInit);

package/src/getUrlAndHeadersWithAuth.ts

@@ -3,48 +3,34 @@
  * Licensed under the MIT License.
  */
 
-/**
- * Gets the length of the query string portion of a url.
- * @param url The full url
- */
-function getQueryStringLength(url: string): number {
-    const queryParamStart = url.indexOf("?");
-
-    if (queryParamStart === -1) {
-        return 0;
-    }
-
-    return url.length - queryParamStart - 1;
-}
-
-// eslint-disable-next-line max-len
-export function getUrlAndHeadersWithAuth(url: string, token: string | null): { url: string, headers: { [index: string]: string } } {
+export function getUrlAndHeadersWithAuth(
+    url: string,
+    token: string | null,
+    forceAccessTokenViaAuthorizationHeader: boolean,
+): { url: string, headers: { [index: string]: string } } {
     if (!token || token.length === 0) {
         return { url, headers: {} };
     }
 
-    const queryParamStart = url.indexOf("?");
-
-    // Determine if we need to add ?, &, or nothing (if the url ends with ?)
-    let tokenQueryParam = queryParamStart === -1 ? "?" : (queryParamStart !== url.length - 1 ? `&` : "");
-
-    const tokenIsQueryParam = token.startsWith("?");
-    if (tokenIsQueryParam) {
-        // The token itself is a query param
-        tokenQueryParam += token.substring(1);
-    } else {
-        tokenQueryParam += `access_token=${encodeURIComponent(token)}`;
-    }
-
-    // ODSP APIs have a limitation that the query string cannot exceed 2048 characters.
-    // We try to stick the access token in the URL to make it a simple XHR request and avoid an options call.
-    // 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.
-    if (tokenIsQueryParam || getQueryStringLength(url + tokenQueryParam) <= 2048) {
-        return {
-            headers: {},
-            url: url + tokenQueryParam,
-        };
+    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 {

package/src/odspDeltaStorageService.ts

@@ -53,9 +53,6 @@ export class OdspDeltaStorageService {
             let postBody = `--${formBoundary}\r\n`;
             postBody += `Authorization: Bearer ${storageToken}\r\n`;
             postBody += `X-HTTP-Method-Override: GET\r\n`;
-            if (fetchReason !== undefined) {
-                postBody += `fetchReason: ${fetchReason}\r\n`;
-            }
 
             postBody += `_post: 1\r\n`;
             postBody += `\r\n--${formBoundary}--`;
@@ -81,6 +78,7 @@ export class OdspDeltaStorageService {
                 },
                 "ops",
                 true,
+                fetchReason,
             );
             clearTimeout(timer);
             const deltaStorageResponse = response.content;

package/src/odspDocumentDeltaConnection.ts

@@ -234,7 +234,7 @@ export class OdspDocumentDeltaConnection extends DocumentDeltaConnection {
 
         // Reference to this client supporting get_ops flow.
         connectMessage.supportedFeatures = { };
-        if (mc.config.getBoolean("Fluid.Driver.Odsp.GetOpsEnabled") === true) {
+        if (mc.config.getBoolean("Fluid.Driver.Odsp.GetOpsEnabled") !== false) {
             connectMessage.supportedFeatures[feature_get_ops] = true;
         }
 

package/src/odspDocumentService.ts

@@ -17,6 +17,7 @@ import {
     IResolvedUrl,
     IDocumentStorageService,
     IDocumentServicePolicies,
+    DriverErrorType,
 } from "@fluidframework/driver-definitions";
 import { DeltaStreamConnectionForbiddenError, NonRetryableError } from "@fluidframework/driver-utils";
 import { IFacetCodes } from "@fluidframework/odsp-doclib-utils";
@@ -281,6 +282,14 @@ export class OdspDocumentService implements IDocumentService {
                 connection.on("op", (documentId, ops: ISequencedDocumentMessage[]) => {
                     this.opsReceived(ops);
                 });
+                // On disconnect with 401/403 error code, we can just clear the joinSession cache as we will again
+                // get the auth error on reconnecting and face latency.
+                connection.on("disconnect", (error: any) => {
+                    if (typeof error === "object" && error !== null
+                        && error.errorType === DriverErrorType.authorizationError) {
+                        this.cache.sessionJoinCache.remove(this.joinSessionKey);
+                    }
+                });
                 this.currentConnection = connection;
                 return connection;
             } catch (error) {

package/src/odspDocumentServiceFactoryCore.ts

@@ -104,6 +104,7 @@ export class OdspDocumentServiceFactoryCore implements IDocumentServiceFactory {
                     cacheAndTracker.epochTracker,
                     fileEntry,
                     this.hostPolicy.cacheCreateNewSummary ?? true,
+                    !!this.hostPolicy.sessionOptions?.forceAccessTokenViaAuthorizationHeader,
                 );
                 const docService = this.createDocumentServiceCore(odspResolvedUrl, odspLogger, cacheAndTracker);
                 event.end({