@fluidframework/odsp-driver 1.2.7 → 2.0.0-dev.1.3.0.96595

package/src/odspDeltaStorageService.ts

@@ -31,17 +31,18 @@ export class OdspDeltaStorageService {
     }
 
     /**
-     * Retrieves ops from cache
+     * Retrieves ops from storage
      * @param from - inclusive
      * @param to - exclusive
      * @param telemetryProps - properties to add when issuing telemetry events
+     * @param scenarioName - reason for fetching ops
      * @returns ops retrieved & info if result was partial (i.e. more is available)
      */
      public async get(
         from: number,
         to: number,
         telemetryProps: ITelemetryProperties,
-        fetchReason?: string,
+        scenarioName?: string,
     ): Promise<IDeltasFetchResult> {
         return getWithRetryForTokenRefresh(async (options) => {
             // Note - this call ends up in getSocketStorageDiscovery() and can refresh token
@@ -78,16 +79,13 @@ export class OdspDeltaStorageService {
                 },
                 "ops",
                 true,
-                fetchReason,
+                scenarioName,
             );
             clearTimeout(timer);
             const deltaStorageResponse = response.content;
-            let messages: ISequencedDocumentMessage[];
-            if (deltaStorageResponse.value.length > 0 && "op" in deltaStorageResponse.value[0]) {
-                messages = (deltaStorageResponse.value as ISequencedDeltaOpMessage[]).map((operation) => operation.op);
-            } else {
-                messages = deltaStorageResponse.value as ISequencedDocumentMessage[];
-            }
+            const messages = deltaStorageResponse.value.length > 0 && "op" in deltaStorageResponse.value[0]
+                ? (deltaStorageResponse.value as ISequencedDeltaOpMessage[]).map((operation) => operation.op)
+                : deltaStorageResponse.value as ISequencedDocumentMessage[];
 
             this.logger.sendPerformanceEvent({
                 eventName: "OpsFetch",
@@ -99,6 +97,7 @@ export class OdspDeltaStorageService {
                 from,
                 to,
                 ...telemetryProps,
+                reason: scenarioName,
             });
 
             // It is assumed that server always returns all the ops that it has in the range that was requested.

package/src/odspDocumentDeltaConnection.ts

@@ -290,11 +290,9 @@ export class OdspDocumentDeltaConnection extends DocumentDeltaConnection {
         // Note: we suspect the incoming error object is either:
         // - a socketError: add it to the OdspError object for driver to be able to parse it and reason over it.
         // - anything else: let base class handle it
-        if (canRetry && Number.isInteger(error?.code) && typeof error?.message === "string") {
-            return errorObjectFromSocketError(error as IOdspSocketError, handler);
-        } else {
-            return super.createErrorObject(handler, error, canRetry);
-        }
+        return canRetry && Number.isInteger(error?.code) && typeof error?.message === "string"
+            ? errorObjectFromSocketError(error as IOdspSocketError, handler)
+            : super.createErrorObject(handler, error, canRetry);
     }
 
     /**

package/src/odspDocumentService.ts

@@ -4,7 +4,7 @@
  */
 
 import { ITelemetryLogger } from "@fluidframework/common-definitions";
-import { performance } from "@fluidframework/common-utils";
+import { assert, performance } from "@fluidframework/common-utils";
 import {
     ChildLogger,
     IFluidErrorBase,
@@ -21,12 +21,7 @@ import {
     IDocumentServicePolicies,
     DriverErrorType,
 } from "@fluidframework/driver-definitions";
-import {
-    canRetryOnError,
-    DeltaStreamConnectionForbiddenError,
-    NonRetryableError,
-} from "@fluidframework/driver-utils";
-import { IFacetCodes } from "@fluidframework/odsp-doclib-utils";
+import { canRetryOnError, DeltaStreamConnectionForbiddenError, NonRetryableError } from "@fluidframework/driver-utils";
 import {
     IClient,
     ISequencedDocumentMessage,
@@ -39,6 +34,7 @@ import {
     InstrumentedStorageTokenFetcher,
     OdspErrorType,
 } from "@fluidframework/odsp-driver-definitions";
+import { hasFacetCodes } from "@fluidframework/odsp-doclib-utils";
 import type { io as SocketIOClientStatic } from "socket.io-client";
 import { HostStoragePolicyInternal, ISocketStorageDiscovery } from "./contracts";
 import { IOdspCache } from "./odspCache";
@@ -113,6 +109,8 @@ export class OdspDocumentService implements IDocumentService {
 
     private currentConnection?: OdspDocumentDeltaConnection;
 
+    private relayServiceTenantAndSessionId: string | undefined;
+
     /**
      * @param odspResolvedUrl - resolved url identifying document that will be managed by this service instance.
      * @param getStorageToken - function that can provide the storage token. This is is also referred to as
@@ -178,7 +176,6 @@ export class OdspDocumentService implements IDocumentService {
                 this.odspResolvedUrl,
                 this.getStorageToken,
                 this.mc.logger,
-                true,
                 this.cache,
                 this.hostPolicy,
                 this.epochTracker,
@@ -189,6 +186,11 @@ export class OdspDocumentService implements IDocumentService {
                     }
                     throw new Error("Disconnected while uploading summary (attempt to perform flush())");
                 },
+                () => {
+                    assert(this.relayServiceTenantAndSessionId !== undefined,
+                        0x37b /* relayServiceTenantAndSessionId should be present */);
+                    return this.relayServiceTenantAndSessionId;
+                },
                 this.mc.config.getNumber("Fluid.Driver.Odsp.snapshotFormatFetchType"),
             );
         }
@@ -271,7 +273,7 @@ export class OdspDocumentService implements IDocumentService {
                     this.socketIoClientFactory().catch(annotateAndRethrowConnectionError("socketIoClientFactory")),
                 ]);
 
-            const finalWebsocketToken = websocketToken ?? (websocketEndpoint.socketToken || null);
+            const finalWebsocketToken = websocketToken ?? (websocketEndpoint.socketToken ?? null);
             if (finalWebsocketToken === null) {
                 throw this.annotateConnectionError(
                     new NonRetryableError(
@@ -344,10 +346,9 @@ export class OdspDocumentService implements IDocumentService {
         requestSocketToken: boolean,
         options: TokenFetchOptionsEx,
     ) {
-        return this.joinSessionCore(requestSocketToken, options).catch((e) => {
-            const likelyFacetCodes = e as IFacetCodes;
-            if (Array.isArray(likelyFacetCodes.facetCodes)) {
-                for (const code of likelyFacetCodes.facetCodes) {
+        const response = await this.joinSessionCore(requestSocketToken, options).catch((e) => {
+            if (hasFacetCodes(e) && e.facetCodes !== undefined) {
+                for (const code of e.facetCodes) {
                     switch (code) {
                         case "sessionForbiddenOnPreservedFiles":
                         case "sessionForbiddenOnModerationEnabledLibrary":
@@ -364,6 +365,8 @@ export class OdspDocumentService implements IDocumentService {
             }
             throw e;
         });
+        this.relayServiceTenantAndSessionId = `${response.tenantId}/${response.id}`;
+        return response;
     }
 
     private async joinSessionCore(

package/src/odspDocumentServiceFactoryCore.ts

@@ -26,6 +26,10 @@ import {
     HostStoragePolicy,
     IFileEntry,
     IOdspUrlParts,
+    SharingLinkScope,
+    SharingLinkRole,
+    ShareLinkTypes,
+    ISharingLinkKind,
 } from "@fluidframework/odsp-driver-definitions";
 import type { io as SocketIOClientStatic } from "socket.io-client";
 import { v4 as uuid } from "uuid";
@@ -84,15 +88,13 @@ export class OdspDocumentServiceFactoryCore implements IDocumentServiceFactory {
             }
         }
 
+        const createShareLinkParam = getSharingLinkParams(this.hostPolicy, searchParams);
         const newFileInfo: INewFileInfo = {
             driveId: odspResolvedUrl.driveId,
             siteUrl: odspResolvedUrl.siteUrl,
             filePath,
             filename: odspResolvedUrl.fileName,
-            // set createLinkType to undefined if enableShareLinkWithCreate is set to false,
-            // so that share link creation with create file can be enabled
-            createLinkType: this.hostPolicy.enableShareLinkWithCreate ?
-            odspResolvedUrl.shareLinkInfo?.createLink?.type : undefined,
+            createLinkType: createShareLinkParam,
         };
 
         const odspLogger = createOdspLogger(logger);
@@ -110,6 +112,10 @@ export class OdspDocumentServiceFactoryCore implements IDocumentServiceFactory {
             {
                 eventName: "CreateNew",
                 isWithSummaryUpload: true,
+                createShareLinkParam: JSON.stringify(createShareLinkParam),
+                enableShareLinkWithCreate: this.hostPolicy.enableShareLinkWithCreate,
+                enableSingleRequestForShareLinkWithCreate:
+                    this.hostPolicy.enableSingleRequestForShareLinkWithCreate,
             },
             async (event) => {
                 odspResolvedUrl = await createNewFluidFile(
@@ -127,6 +133,8 @@ export class OdspDocumentServiceFactoryCore implements IDocumentServiceFactory {
                     this.hostPolicy.cacheCreateNewSummary ?? true,
                     !!this.hostPolicy.sessionOptions?.forceAccessTokenViaAuthorizationHeader,
                     odspResolvedUrl.isClpCompliantApp,
+                    this.hostPolicy.enableSingleRequestForShareLinkWithCreate,
+                    this.hostPolicy.enableShareLinkWithCreate,
                 );
                 const docService = this.createDocumentServiceCore(odspResolvedUrl, odspLogger,
                     cacheAndTracker, clientIsSummarizer);
@@ -223,3 +231,31 @@ export class OdspDocumentServiceFactoryCore implements IDocumentServiceFactory {
         );
     }
 }
+
+/**
+ * Extract the sharing link kind from the resolved URL's query paramerters
+ */
+function getSharingLinkParams(
+    hostPolicy: HostStoragePolicy,
+    searchParams: URLSearchParams,
+): ShareLinkTypes | ISharingLinkKind | undefined {
+    // extract request parameters for creation of sharing link (if provided) if the feature is enabled
+    let createShareLinkParam: ShareLinkTypes | ISharingLinkKind | undefined;
+    if (hostPolicy.enableSingleRequestForShareLinkWithCreate) {
+        const createLinkScope = searchParams.get("createLinkScope");
+        const createLinkRole = searchParams.get("createLinkRole");
+        if (createLinkScope && SharingLinkScope[createLinkScope]) {
+            createShareLinkParam = {
+                scope: SharingLinkScope[createLinkScope],
+                ...(createLinkRole && SharingLinkRole[createLinkRole] ?
+                    { role: SharingLinkRole[createLinkRole] } : {}),
+            };
+        }
+    } else if (hostPolicy.enableShareLinkWithCreate) {
+        const createLinkType = searchParams.get("createLinkType");
+        if (createLinkType && ShareLinkTypes[createLinkType]) {
+            createShareLinkParam = ShareLinkTypes[createLinkType || ""];
+        }
+    }
+    return createShareLinkParam;
+}

package/src/odspDocumentStorageManager.ts

@@ -16,6 +16,7 @@ import * as api from "@fluidframework/protocol-definitions";
 import {
     ISummaryContext,
     DriverErrorType,
+    FetchSource,
 } from "@fluidframework/driver-definitions";
 import { RateLimiter, NonRetryableError } from "@fluidframework/driver-utils";
 import {
@@ -87,11 +88,11 @@ export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
         private readonly odspResolvedUrl: IOdspResolvedUrl,
         private readonly getStorageToken: InstrumentedStorageTokenFetcher,
         private readonly logger: ITelemetryLogger,
-        private readonly fetchFullSnapshot: boolean,
         private readonly cache: IOdspCache,
         private readonly hostPolicy: HostStoragePolicyInternal,
         private readonly epochTracker: EpochTracker,
         private readonly flushCallback: () => Promise<FlushResult>,
+        private readonly relayServiceTenantAndSessionId: () => string,
         private readonly snapshotFormatFetchType?: SnapshotFormatSupportType,
     ) {
         super();
@@ -107,6 +108,7 @@ export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
             logger,
             epochTracker,
             !!this.hostPolicy.sessionOptions?.forceAccessTokenViaAuthorizationHeader,
+            this.relayServiceTenantAndSessionId,
         );
     }
 
@@ -204,7 +206,7 @@ export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
         return super.getSnapshotTree(version, scenarioName);
     }
 
-    public async getVersions(blobid: string | null, count: number, scenarioName?: string): Promise<api.IVersion[]> {
+    public async getVersions(blobid: string | null, count: number, scenarioName?: string, fetchSource?: FetchSource): Promise<api.IVersion[]> {
         // Regular load workflow uses blobId === documentID to indicate "latest".
         if (blobid !== this.documentId && blobid) {
             // FluidFetch & FluidDebugger tools use empty sting to query for versions
@@ -225,19 +227,23 @@ export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
         }
 
         // If count is one, we can use the trees/latest API, which returns the latest version and trees in a single request for better performance
-        // Do it only once - we might get more here due to summarizer - it needs only container tree, not full snapshot.
-        if (this.firstVersionCall && count === 1 && (blobid === null || blobid === this.documentId)) {
+        if (count === 1 && (blobid === null || blobid === this.documentId)) {
             const hostSnapshotOptions = this.hostPolicy.snapshotOptions;
             const odspSnapshotCacheValue: ISnapshotContents = await PerformanceEvent.timedExecAsync(
                 this.logger,
-                { eventName: "ObtainSnapshot" },
+                { eventName: "ObtainSnapshot", fetchSource },
                 async (event: PerformanceEvent) => {
                     const props: GetVersionsTelemetryProps = {};
                     let retrievedSnapshot: ISnapshotContents | undefined;
-                    // Here's the logic to grab the persistent cache snapshot implemented by the host
-                    // Epoch tracker is responsible for communicating with the persistent cache, handling epochs and cache versions
-                    const cachedSnapshotP: Promise<ISnapshotContents | undefined> =
-                        this.epochTracker.get(createCacheSnapshotKey(this.odspResolvedUrl))
+
+                    let method: string;
+                    if (fetchSource === FetchSource.noCache) {
+                        retrievedSnapshot = await this.fetchSnapshot(hostSnapshotOptions, scenarioName);
+                        method = "networkOnly";
+                    } else {
+                        // Here's the logic to grab the persistent cache snapshot implemented by the host
+                        // Epoch tracker is responsible for communicating with the persistent cache, handling epochs and cache versions
+                        const cachedSnapshotP: Promise<ISnapshotContents | undefined> = this.epochTracker.get(createCacheSnapshotKey(this.odspResolvedUrl))
                             .then(async (snapshotCachedEntry: ISnapshotCachedEntry) => {
                                 if (snapshotCachedEntry !== undefined) {
                                     // If the cached entry does not contain the entry time, then assign it a default of 30 days old.
@@ -264,46 +270,56 @@ export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
                                 return snapshotCachedEntry;
                             });
 
-                    // Based on the concurrentSnapshotFetch policy:
-                    // Either retrieve both the network and cache snapshots concurrently and pick the first to return,
-                    // or grab the cache value and then the network value if the cache value returns undefined.
-                    let method: string;
-                    if (this.hostPolicy.concurrentSnapshotFetch && !this.hostPolicy.summarizerClient) {
-                        const networkSnapshotP = this.fetchSnapshot(hostSnapshotOptions, scenarioName);
-
-                        // Ensure that failures on both paths are ignored initially.
-                        // I.e. if cache fails for some reason, we will proceed with network result.
-                        // And vice versa - if (for example) client is offline and network request fails first, we
-                        // do want to attempt to succeed with cached data!
-                        const promiseRaceWinner = await promiseRaceWithWinner([
-                            cachedSnapshotP.catch(() => undefined),
-                            networkSnapshotP.catch(() => undefined),
-                        ]);
-                        retrievedSnapshot = promiseRaceWinner.value;
-                        method = promiseRaceWinner.index === 0 ? "cache" : "network";
-
-                        if (retrievedSnapshot === undefined) {
-                            // if network failed -> wait for cache ( then return network failure)
-                            // If cache returned empty or failed -> wait for network (success of failure)
-                            if (promiseRaceWinner.index === 1) {
-                                retrievedSnapshot = await cachedSnapshotP;
-                                method = "cache";
-                            }
+                        // Based on the concurrentSnapshotFetch policy:
+                        // Either retrieve both the network and cache snapshots concurrently and pick the first to return,
+                        // or grab the cache value and then the network value if the cache value returns undefined.
+                        // For summarizer which could call this during refreshing of summary parent, always use the cache
+                        // first. Also for other clients, if it is not critical path which is determined by firstVersionCall,
+                        // then also check the cache first.
+                        if (this.firstVersionCall && this.hostPolicy.concurrentSnapshotFetch && !this.hostPolicy.summarizerClient) {
+                            const networkSnapshotP = this.fetchSnapshot(hostSnapshotOptions, scenarioName);
+
+                            // Ensure that failures on both paths are ignored initially.
+                            // I.e. if cache fails for some reason, we will proceed with network result.
+                            // And vice versa - if (for example) client is offline and network request fails first, we
+                            // do want to attempt to succeed with cached data!
+                            const promiseRaceWinner = await promiseRaceWithWinner([
+                                cachedSnapshotP.catch(() => undefined),
+                                networkSnapshotP.catch(() => undefined),
+                            ]);
+                            retrievedSnapshot = promiseRaceWinner.value;
+                            method = promiseRaceWinner.index === 0 ? "cache" : "network";
+
                             if (retrievedSnapshot === undefined) {
-                                retrievedSnapshot = await networkSnapshotP;
-                                method = "network";
+                                // if network failed -> wait for cache ( then return network failure)
+                                // If cache returned empty or failed -> wait for network (success of failure)
+                                if (promiseRaceWinner.index === 1) {
+                                    retrievedSnapshot = await cachedSnapshotP;
+                                    method = "cache";
+                                }
+                                if (retrievedSnapshot === undefined) {
+                                    retrievedSnapshot = await networkSnapshotP;
+                                    method = "network";
+                                }
                             }
-                        }
-                    } else {
-                        // Note: There's a race condition here - another caller may come past the undefined check
-                        // while the first caller is awaiting later async code in this block.
-
-                        retrievedSnapshot = await cachedSnapshotP;
+                        } else {
+                            // Note: There's a race condition here - another caller may come past the undefined check
+                            // while the first caller is awaiting later async code in this block.
 
-                        method = retrievedSnapshot !== undefined ? "cache" : "network";
-
-                        if (retrievedSnapshot === undefined) {
-                            retrievedSnapshot = await this.fetchSnapshot(hostSnapshotOptions, scenarioName);
+                            retrievedSnapshot = await cachedSnapshotP;
+                            if (retrievedSnapshot !== undefined) {
+                                method = "cache";
+                            } else {
+                                method = "network";
+                                const options: ISnapshotOptions = { ...hostSnapshotOptions };
+                                // Don't fetch the blobs/deltas if it is not the first call. By default server will add
+                                // blobs and deltas to the response.
+                                if (!this.firstVersionCall) {
+                                    options.blobs = 0;
+                                    options.deltas = 0;
+                                }
+                                retrievedSnapshot = await this.fetchSnapshot(options, scenarioName);
+                            }
                         }
                     }
                     if (method === "network") {
@@ -314,10 +330,9 @@ export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
                 },
             );
 
-            // Successful call, make network calls only
+            // Don't override ops which were fetched during initial load, since we could still need them.
+            const id = this.initializeFromSnapshot(odspSnapshotCacheValue, this.firstVersionCall);
             this.firstVersionCall = false;
-            const id = this.initializeFromSnapshot(odspSnapshotCacheValue);
-
             return id ? [{ id, treeId: undefined! }] : [];
         }
 
@@ -537,7 +552,6 @@ export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
                 this.snapshotUrl!,
                 storageToken,
                 id,
-                this.fetchFullSnapshot,
                 !!this.hostPolicy.sessionOptions?.forceAccessTokenViaAuthorizationHeader,
                 this.logger,
                 snapshotDownloader,

package/src/odspDocumentStorageServiceBase.ts

@@ -244,7 +244,7 @@ export abstract class OdspDocumentStorageServiceBase implements IDocumentStorage
         return summarySnapshotTree;
     }
 
-    protected initializeFromSnapshot(odspSnapshotCacheValue: ISnapshotContents): string | undefined {
+    protected initializeFromSnapshot(odspSnapshotCacheValue: ISnapshotContents, cacheOps: boolean = true): string | undefined {
         this._snapshotSequenceNumber = odspSnapshotCacheValue.sequenceNumber;
         const { snapshotTree, blobs, ops } = odspSnapshotCacheValue;
 
@@ -260,7 +260,9 @@ export abstract class OdspDocumentStorageServiceBase implements IDocumentStorage
             this.initBlobsCache(blobs);
         }
 
-        this.ops = ops;
+        if (cacheOps) {
+            this.ops = ops;
+        }
         return id;
     }
 }

package/src/odspDriverUrlResolverForShareLink.ts

@@ -136,7 +136,7 @@ export class OdspDriverUrlResolverForShareLink implements IUrlResolver {
             // We need to remove the nav param if set by host when setting the sharelink as otherwise the shareLinkId
             // when redeeming the share link during the redeem fallback for trees latest call becomes greater than
             // the eligible length.
-            odspResolvedUrl.shareLinkInfo = Object.assign(odspResolvedUrl.shareLinkInfo || {},
+            odspResolvedUrl.shareLinkInfo = Object.assign(odspResolvedUrl.shareLinkInfo ?? {},
                 { sharingLinkToRedeem: this.removeNavParam(request.url) });
         }
         if (odspResolvedUrl.itemId) {
@@ -171,10 +171,7 @@ export class OdspDriverUrlResolverForShareLink implements IUrlResolver {
             return cachedLinkPromise;
         }
         const newLinkPromise = getFileLink(
-            this.shareLinkFetcherProps.tokenFetcher,
-            resolvedUrl,
-            this.shareLinkFetcherProps.identityType,
-            this.logger,
+            this.shareLinkFetcherProps.tokenFetcher, resolvedUrl, this.logger,
         ).catch((error) => {
             // This should imply that error is a non-retriable error.
             this.logger.sendErrorEvent({ eventName: "FluidFileUrlError" }, error);

package/src/odspFluidFileLink.ts

@@ -52,7 +52,7 @@ export function encodeOdspFluidDataStoreLocator(locator: OdspFluidDataStoreLocat
 /**
  * Decodes given encoded value representing Fluid data store locator extracted from ODSP Fluid file link
  * @param encodedLocatorValue - encoded Fluid data store locator value which was produced by
- *  encodeOdspFluidDataStoreLocator method
+ * {@link encodeOdspFluidDataStoreLocator} function
  * @param siteOriginUrl - site origin that will be appended to encoded relative path to form absolute file url
  * @returns object representing Fluid data store location in ODSP terms
  */

package/src/odspLocationRedirection.ts

@@ -0,0 +1,23 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { IFluidResolvedUrl } from "@fluidframework/driver-definitions";
+import { IOdspResolvedUrl } from "@fluidframework/odsp-driver-definitions";
+import { getOdspResolvedUrl } from "./odspUtils";
+
+/**
+ * It takes a resolved url with old siteUrl and creates a new resolved url with updated site url domain.
+ * @param resolvedUrl - Previous odsp resolved url with older site url.
+ * @param redirectLocation - Url at which the network call has to be made. It contains new site info.
+ * @returns - Resolved url after patching the correct siteUrl.
+ */
+export function patchOdspResolvedUrl(resolvedUrl: IFluidResolvedUrl, redirectLocation: string): IOdspResolvedUrl {
+    const odspResolvedUrl = { ...getOdspResolvedUrl(resolvedUrl) };
+    // Generate the new SiteUrl from the redirection location.
+    const newSiteDomain = new URL(redirectLocation).origin;
+    const newSiteUrl = `${newSiteDomain}${new URL(odspResolvedUrl.siteUrl).pathname}`;
+    odspResolvedUrl.siteUrl = newSiteUrl;
+    return odspResolvedUrl;
+}

package/src/odspSnapshotParser.ts

@@ -5,7 +5,7 @@
 
 import { assert, stringToBuffer } from "@fluidframework/common-utils";
 import * as api from "@fluidframework/protocol-definitions";
-import { IOdspSnapshot, IOdspSnapshotCommit, ISnapshotTreeEx } from "./contracts";
+import { IOdspSnapshot, IOdspSnapshotCommit } from "./contracts";
 import { ISnapshotContents } from "./odspPublicUtils";
 
 /**
@@ -18,7 +18,7 @@ import { ISnapshotContents } from "./odspPublicUtils";
 function buildHierarchy(flatTree: IOdspSnapshotCommit): api.ISnapshotTree {
     const lookup: { [path: string]: api.ISnapshotTree; } = {};
     // id is required for root tree as it will be used to determine the version we loaded from.
-    const root: ISnapshotTreeEx = { id: flatTree.id, blobs: {}, commits: {}, trees: {} };
+    const root: api.ISnapshotTree = { id: flatTree.id, blobs: {}, trees: {} };
     lookup[""] = root;
 
     for (const entry of flatTree.entries) {
@@ -31,10 +31,9 @@ function buildHierarchy(flatTree: IOdspSnapshotCommit): api.ISnapshotTree {
 
         // Add in either the blob or tree
         if (entry.type === "tree") {
-            const newTree: ISnapshotTreeEx = {
+            const newTree: api.ISnapshotTree = {
                 blobs: {},
                 trees: {},
-                commits: {},
                 unreferenced: entry.unreferenced,
             };
             node.trees[decodeURIComponent(entryPathBase)] = newTree;

package/src/odspSummaryUploadManager.ts

@@ -39,6 +39,7 @@ export class OdspSummaryUploadManager {
         logger: ITelemetryLogger,
         private readonly epochTracker: EpochTracker,
         private readonly forceAccessTokenViaAuthorizationHeader: boolean,
+        private readonly relayServiceTenantAndSessionId: () => string,
     ) {
         this.mc = loggerToMonitoringContext(logger);
     }
@@ -93,9 +94,8 @@ export class OdspSummaryUploadManager {
                 this.forceAccessTokenViaAuthorizationHeader,
             );
             headers["Content-Type"] = "application/json";
-            if (parentHandle) {
-                headers["If-Match"] = `fluid:containerid=${parentHandle}`;
-            }
+            headers["If-Match"] = `fluid:sessionid=${
+                this.relayServiceTenantAndSessionId()}${parentHandle ? `;containerid=${parentHandle}` : ""}`;
 
             const postBody = JSON.stringify(snapshot);
 
@@ -126,8 +126,10 @@ export class OdspSummaryUploadManager {
     }
 
     /**
-     * Following are the goals of this function.
-     *  a.) Converts the summary tree to a snapshot/odsp tree to be uploaded. Always upload full snapshot tree.
+     * Following are the goals of this function:
+     *
+     * a. Converts the summary tree to a snapshot/odsp tree to be uploaded. Always upload full snapshot tree.
+     *
      * @param parentHandle - Handle of the last uploaded summary or detach new summary.
      * @param tree - Summary Tree which will be converted to snapshot tree to be uploaded.
      * @param rootNodeName - Root node name of the summary tree.
@@ -169,19 +171,16 @@ export class OdspSummaryUploadManager {
                     break;
                 }
                 case api.SummaryType.Blob: {
-                    if (typeof summaryObject.content === "string") {
-                        value = {
+                    value = typeof summaryObject.content === "string"
+                        ? {
                             type: "blob",
                             content: summaryObject.content,
                             encoding: "utf-8",
-                        };
-                    } else {
-                        value = {
+                        } : {
                             type: "blob",
                             content: Uint8ArrayToString(summaryObject.content, "base64"),
                             encoding: "base64",
                         };
-                    }
                     blobs++;
                     break;
                 }

package/src/odspUrlHelper.ts

@@ -69,7 +69,7 @@ export function isOdcUrl(url: string | URL): boolean {
     // Format: /v2.1/drives('ABC123')/items('ABC123!123')
     const odcODataRegex = /\/v2.1\/drives\('[^/]+'\)\/items\('[\da-z]+!\d+'\)/;
 
-    return !!(odcRegex.exec(path) || odcODataRegex.exec(path));
+    return !!(odcRegex.exec(path) ?? odcODataRegex.exec(path));
 }
 
 /**