Update odsp driver for new header

packages/drivers/odsp-driver-definitions/api-report/odsp-driver-definitions.legacy.alpha.api.md

@@ -241,6 +241,7 @@ export interface ShareLinkInfoType {
         error?: any;
         shareId?: string;
     };
+    isRedemptionNonDurable?: boolean;
     sharingLinkToRedeem?: string;
 }
 

packages/drivers/odsp-driver-definitions/src/resolvedUrl.ts

@@ -95,6 +95,14 @@ export interface ShareLinkInfoType {
 	 * permission then this link can be redeemed for the permissions in the same network call.
 	 */
 	sharingLinkToRedeem?: string;
+
+	/**
+	 * When a sharingLinkToRedeem is used, this parameter can be set to make the request with
+	 * the redemption expire after a certain time period.
+	 * The duration of the redemption is not set by Fluid.
+	 * @defaultValue false
+	 */
+	isRedemptionNonDurable?: boolean;
 }
 /**
  * @legacy

packages/drivers/odsp-driver/src/contractsPublic.ts

@@ -21,16 +21,24 @@ export interface OdspFluidDataStoreLocator extends IOdspUrlParts {
  * @internal
  */
 export enum SharingLinkHeader {
-	// Can be used in request made to resolver, to tell the resolver that the passed in URL is a sharing link
-	// which can be redeemed at server to get permissions.
+	/**
+	 * Can be used in request made to resolver, to tell the resolver that the passed in URL is a sharing link
+	 * which can be redeemed at server to get permissions.
+	 */
 	isSharingLinkToRedeem = "isSharingLinkToRedeem",
+	/**
+	 * When isSharingLinkToRedeem is true, this header can be used to tell the server that the redemption of the sharing link
+	 * is meant to be non-durable.
+	 */
+	isRedemptionNonDurable = "isRedemptionNonDurable",
 }
 
 /**
  * @internal
  */
 export interface ISharingLinkHeader {
 	[SharingLinkHeader.isSharingLinkToRedeem]: boolean;
+	[SharingLinkHeader.isRedemptionNonDurable]: boolean;
 }
 /**
  * @internal

packages/drivers/odsp-driver/src/fetchSnapshot.ts

@@ -224,6 +224,9 @@ async function redeemSharingLink(
 				odspResolvedUrl.shareLinkInfo?.sharingLinkToRedeem,
 			);
 
+			const isRedemptionNonDurable: boolean =
+				odspResolvedUrl.shareLinkInfo?.isRedemptionNonDurable === true;
+
 			let redeemUrl: string | undefined;
 			async function callSharesAPI(baseUrl: string): Promise<void> {
 				await getWithRetryForTokenRefresh(async (tokenFetchOptions) => {
@@ -240,7 +243,7 @@ async function redeemSharingLink(
 						"RedeemShareLink",
 					);
 					const headers = getHeadersWithAuth(authHeader);
-					headers.prefer = "redeemSharingLink";
+					headers.prefer = isRedemptionNonDurable ? "nonDurableRedeem" : "redeemSharingLink";
 					await fetchAndParseAsJSONHelper(url, { headers, method });
 				});
 			}
@@ -251,6 +254,7 @@ async function redeemSharingLink(
 				queryParamsLength: new URL(odspResolvedUrl.shareLinkInfo?.sharingLinkToRedeem).search
 					.length,
 				useHeaders: true,
+				isRedemptionNonDurable,
 			});
 			// There is an issue where if we use the siteUrl in /shares, then the allowed length of url is just a few hundred characters(300-400)
 			// and we fail to do the redeem. But if we use the tenant domain in the url, then the allowed length becomes 2048. So,
@@ -287,6 +291,8 @@ async function fetchLatestSnapshotCore(
 		const fetchSnapshotForLoadingGroup = isSnapshotFetchForLoadingGroup(loadingGroupIds);
 		const eventName = fetchSnapshotForLoadingGroup ? "TreesLatestForGroup" : "TreesLatest";
 		const internalFarmType = checkForKnownServerFarmType(odspResolvedUrl.siteUrl);
+		const isRedemptionNonDurable: boolean =
+			odspResolvedUrl.shareLinkInfo?.isRedemptionNonDurable === true;
 
 		const perfEvent = {
 			eventName,
@@ -296,6 +302,8 @@ async function fetchLatestSnapshotCore(
 			redeemFallbackEnabled: enableRedeemFallback,
 			details: {
 				internalFarmType,
+				// Whether the redemption used is non-durable or not.
+				isRedemptionNonDurable,
 			},
 		};
 		if (snapshotOptions !== undefined) {
@@ -724,11 +732,16 @@ export const downloadSnapshot = mockify(
 		const queryString = getQueryString(queryParams);
 		const url = `${snapshotUrl}/trees/latest${queryString}`;
 		const method = "POST";
+		const isRedemptionNonDurable: boolean =
+			odspResolvedUrl.shareLinkInfo?.isRedemptionNonDurable === true;
 		// The location of file can move on Spo in which case server returns 308(Permanent Redirect) error.
 		// Adding below header will make VROOM API return 404 instead of 308 and browser can intercept it.
 		// This error thrown by server will contain the new redirect location. Look at the 404 error parsing
 		// for further reference here: \packages\utils\odsp-doclib-utils\src\odspErrorUtils.ts
-		const header = { prefer: "manualredirect" };
+		// If the share link is non-durable, we will add the nonDurableRedeem header to the header.prefer.
+		const header = isRedemptionNonDurable
+			? { prefer: "manualredirect, nonDurableRedeem" }
+			: { prefer: "manualredirect" };
 		const authHeader = await getAuthHeader(
 			{ ...tokenFetchOptions, request: { url, method } },
 			"downloadSnapshot",

packages/drivers/odsp-driver/src/odspDriverUrlResolverForShareLink.ts

@@ -137,6 +137,8 @@ export class OdspDriverUrlResolverForShareLink implements IUrlResolver {
 		const requestToBeResolved = { headers: request.headers, url: request.url };
 		const isSharingLinkToRedeem =
 			requestToBeResolved.headers?.[SharingLinkHeader.isSharingLinkToRedeem];
+		const isRedemptionNonDurable =
+			requestToBeResolved.headers?.[SharingLinkHeader.isRedemptionNonDurable];
 		try {
 			const url = new URL(request.url);
 
@@ -167,6 +169,7 @@ export class OdspDriverUrlResolverForShareLink implements IUrlResolver {
 			// the eligible length.
 			odspResolvedUrl.shareLinkInfo = Object.assign(odspResolvedUrl.shareLinkInfo ?? {}, {
 				sharingLinkToRedeem: this.removeNavParam(request.url),
+				isRedemptionNonDurable: isRedemptionNonDurable ?? false,
 			});
 		}
 		if (odspResolvedUrl.itemId) {

packages/drivers/odsp-driver/src/test/fetchSnapshot.spec.ts

@@ -561,7 +561,60 @@ describe("Tests1 for snapshot fetch", () => {
 		assert(
 			mockLogger.matchEvents([
 				{ eventName: "TreesLatest_cancel", shareLinkPresent: true },
-				{ eventName: "RedeemShareLink_end" },
+				{
+					eventName: "RedeemShareLink_end",
+					details:
+						'{"shareLinkUrlLength":45,"queryParamsLength":0,"useHeaders":true,"isRedemptionNonDurable":false}',
+				},
+				{ eventName: "RedeemFallback", errorType: "fileNotFoundOrAccessDeniedError" },
+				{ eventName: "TreesLatest_end" },
+			]),
+		);
+	});
+
+	it("nonDurableRedeem header is set during RedeemFallback behavior", async () => {
+		resolved.shareLinkInfo = {
+			sharingLinkToRedeem: "https://microsoft.sharepoint-df.com/sharelink",
+			isRedemptionNonDurable: true,
+		};
+		hostPolicy.enableRedeemFallback = true;
+
+		const snapshot: ISnapshot = {
+			blobContents,
+			snapshotTree: snapshotTreeWithGroupId,
+			ops: [],
+			latestSequenceNumber: 0,
+			sequenceNumber: 0,
+			snapshotFormatV: 1,
+		};
+		const response = (await createResponse(
+			{ "x-fluid-epoch": "epoch1", "content-type": "application/ms-fluid" },
+			convertToCompactSnapshot(snapshot),
+			200,
+		)) as unknown as Response;
+
+		await assert.doesNotReject(
+			async () =>
+				mockFetchMultiple(
+					async () => service.getSnapshot({}),
+					[
+						notFound,
+						async (): Promise<MockResponse> => okResponse({}, {}),
+						async (): Promise<Response> => {
+							return response;
+						},
+					],
+				),
+			"Should succeed",
+		);
+		assert(
+			mockLogger.matchEvents([
+				{ eventName: "TreesLatest_cancel", shareLinkPresent: true },
+				{
+					eventName: "RedeemShareLink_end",
+					details:
+						'{"shareLinkUrlLength":45,"queryParamsLength":0,"useHeaders":true,"isRedemptionNonDurable":true}',
+				},
 				{ eventName: "RedeemFallback", errorType: "fileNotFoundOrAccessDeniedError" },
 				{ eventName: "TreesLatest_end" },
 			]),

packages/drivers/odsp-driver/src/test/odspDriverUrlResolverForShareLink.spec.ts

@@ -356,6 +356,41 @@ describe("Tests for OdspDriverUrlResolverForShareLink resolver", () => {
 		);
 	});
 
+	it("isNonDurableRedeem should be set when isNonDurableRedeem header is set", async () => {
+		const url = new URL(sharelink);
+		const resolvedUrl = await mockGetFileLink(Promise.resolve(sharelink), async () => {
+			storeLocatorInOdspUrl(url, { siteUrl, driveId, itemId, dataStorePath });
+			return urlResolverWithShareLinkFetcher.resolve({
+				url: url.toString(),
+				headers: {
+					[SharingLinkHeader.isSharingLinkToRedeem]: true,
+					[SharingLinkHeader.isRedemptionNonDurable]: true,
+				},
+			});
+		});
+		assert(
+			resolvedUrl.shareLinkInfo?.isRedemptionNonDurable === true,
+			"isRedemptionNonDurable should be set in shareLinkInfo of resolved url",
+		);
+	});
+
+	it("isNonDurableRedeem should not be set when isSharingLinkToRedeem header is not set", async () => {
+		const url = new URL(sharelink);
+		const resolvedUrl = await mockGetFileLink(Promise.resolve(sharelink), async () => {
+			storeLocatorInOdspUrl(url, { siteUrl, driveId, itemId, dataStorePath });
+			return urlResolverWithShareLinkFetcher.resolve({
+				url: url.toString(),
+				headers: {
+					[SharingLinkHeader.isRedemptionNonDurable]: true,
+				},
+			});
+		});
+		assert(
+			resolvedUrl.shareLinkInfo?.isRedemptionNonDurable === undefined,
+			"isRedemptionNonDurable should not be set in shareLinkInfo and shareLinkInfo should be undefined",
+		);
+	});
+
 	it("Encode and decode nav param", async () => {
 		const encodedUrl = new URL(sharelink);
 		storeLocatorInOdspUrl(encodedUrl, {