@fluidframework/odsp-driver 2.0.0-dev-rc.1.0.0.228517 → 2.0.0-dev-rc.2.0.0.245554

package/dist/odspDocumentStorageManager.js

@@ -13,13 +13,13 @@ const driver_base_1 = require("@fluidframework/driver-base");
 const driver_definitions_1 = require("@fluidframework/driver-definitions");
 const driver_utils_1 = require("@fluidframework/driver-utils");
 const odsp_driver_definitions_1 = require("@fluidframework/odsp-driver-definitions");
-const fetchSnapshot_1 = require("./fetchSnapshot");
-const getUrlAndHeadersWithAuth_1 = require("./getUrlAndHeadersWithAuth");
-const odspUtils_1 = require("./odspUtils");
-const packageVersion_1 = require("./packageVersion");
-const odspDocumentStorageServiceBase_1 = require("./odspDocumentStorageServiceBase");
+const fetchSnapshot_js_1 = require("./fetchSnapshot.js");
+const getUrlAndHeadersWithAuth_js_1 = require("./getUrlAndHeadersWithAuth.js");
+const odspUtils_js_1 = require("./odspUtils.js");
+const packageVersion_js_1 = require("./packageVersion.js");
+const odspDocumentStorageServiceBase_js_1 = require("./odspDocumentStorageServiceBase.js");
 exports.defaultSummarizerCacheExpiryTimeout = 60 * 1000; // 60 seconds.
-class OdspDocumentStorageService extends odspDocumentStorageServiceBase_1.OdspDocumentStorageServiceBase {
+class OdspDocumentStorageService extends odspDocumentStorageServiceBase_js_1.OdspDocumentStorageServiceBase {
     constructor(odspResolvedUrl, getStorageToken, logger, fetchFullSnapshot, cache, hostPolicy, epochTracker, flushCallback, relayServiceTenantAndSessionId, snapshotFormatFetchType) {
         super((0, telemetry_utils_1.loggerToMonitoringContext)(logger).config);
         this.odspResolvedUrl = odspResolvedUrl;
@@ -33,7 +33,7 @@ class OdspDocumentStorageService extends odspDocumentStorageServiceBase_1.OdspDo
         this.relayServiceTenantAndSessionId = relayServiceTenantAndSessionId;
         this.snapshotFormatFetchType = snapshotFormatFetchType;
         this.odspSummaryModuleLoaded = false;
-        this.firstVersionCall = true;
+        this.firstSnapshotFetchCall = true;
         // Driver specified limits for snapshot size and time.
         /**
          * NOTE: While commit cfff6e3 added restrictions to prevent large payloads, snapshot failures will continue to
@@ -54,9 +54,9 @@ class OdspDocumentStorageService extends odspDocumentStorageServiceBase_1.OdspDo
     }
     async createBlob(file) {
         this.checkAttachmentPOSTUrl();
-        const response = await (0, odspUtils_1.getWithRetryForTokenRefresh)(async (options) => {
+        const response = await (0, odspUtils_js_1.getWithRetryForTokenRefresh)(async (options) => {
             const storageToken = await this.getStorageToken(options, "CreateBlob");
-            const { url, headers } = (0, getUrlAndHeadersWithAuth_1.getUrlAndHeadersWithAuth)(`${this.attachmentPOSTUrl}/content`, storageToken, !!this.hostPolicy.sessionOptions?.forceAccessTokenViaAuthorizationHeader);
+            const { url, headers } = (0, getUrlAndHeadersWithAuth_js_1.getUrlAndHeadersWithAuth)(`${this.attachmentPOSTUrl}/content`, storageToken, !!this.hostPolicy.sessionOptions?.forceAccessTokenViaAuthorizationHeader);
             headers["Content-Type"] = "application/octet-stream";
             return telemetry_utils_1.PerformanceEvent.timedExecAsync(this.logger, {
                 eventName: "createBlob",
@@ -79,15 +79,15 @@ class OdspDocumentStorageService extends odspDocumentStorageServiceBase_1.OdspDo
     }
     async fetchBlobFromStorage(blobId, evicted) {
         this.checkAttachmentGETUrl();
-        const blob = await (0, odspUtils_1.getWithRetryForTokenRefresh)(async (options) => {
+        const blob = await (0, odspUtils_js_1.getWithRetryForTokenRefresh)(async (options) => {
             const storageToken = await this.getStorageToken(options, "GetBlob");
             const unAuthedUrl = `${this.attachmentGETUrl}/${encodeURIComponent(blobId)}/content`;
-            const { url, headers } = (0, getUrlAndHeadersWithAuth_1.getUrlAndHeadersWithAuth)(unAuthedUrl, storageToken, !!this.hostPolicy.sessionOptions?.forceAccessTokenViaAuthorizationHeader);
+            const { url, headers } = (0, getUrlAndHeadersWithAuth_js_1.getUrlAndHeadersWithAuth)(unAuthedUrl, storageToken, !!this.hostPolicy.sessionOptions?.forceAccessTokenViaAuthorizationHeader);
             return telemetry_utils_1.PerformanceEvent.timedExecAsync(this.logger, {
                 eventName: "readDataBlob",
                 blobId,
                 evicted,
-                headers: Object.keys(headers).length !== 0 ? true : undefined,
+                headers: Object.keys(headers).length > 0 ? true : undefined,
                 waitQueueLength: this.epochTracker.rateLimiter.waitQueueLength,
             }, async (event) => {
                 const res = await this.epochTracker.fetchArray(url, { headers }, "blob");
@@ -114,10 +114,186 @@ class OdspDocumentStorageService extends odspDocumentStorageServiceBase_1.OdspDo
     }
     async getSnapshotTree(version, scenarioName) {
         if (!this.snapshotUrl) {
+            // eslint-disable-next-line unicorn/no-null
             return null;
         }
         return super.getSnapshotTree(version, scenarioName);
     }
+    /**
+     * Fetches and returns the snapshot. If no loadingGroupIds or empty loadingGroupIds is provided, then snapshot for all
+     * ungrouped data will be provided.
+     * @param snapshotFetchOptions - fetch options for snapshot.
+     */
+    async getSnapshot(snapshotFetchOptions) {
+        // Don't consult cache if request is not for a particular loading group.
+        const { snapshot } = await this.fetchSnapshot({
+            ...snapshotFetchOptions,
+            fetchSource: (0, odspUtils_js_1.isSnapshotFetchForLoadingGroup)(snapshotFetchOptions?.loadingGroupIds)
+                ? driver_definitions_1.FetchSource.noCache
+                : snapshotFetchOptions?.fetchSource,
+            loadingGroupIds: snapshotFetchOptions?.loadingGroupIds ?? [],
+        });
+        return {
+            ...snapshot,
+            snapshotTree: this.combineProtocolAndAppSnapshotTree(snapshot.snapshotTree),
+        };
+    }
+    async fetchSnapshot(snapshotFetchOptions) {
+        const hostSnapshotOptions = this.hostPolicy.snapshotOptions;
+        const odspSnapshotCacheValue = await telemetry_utils_1.PerformanceEvent.timedExecAsync(this.logger, {
+            eventName: (0, odspUtils_js_1.isSnapshotFetchForLoadingGroup)(snapshotFetchOptions.loadingGroupIds)
+                ? "ObtainSnapshotForGroup"
+                : "ObtainSnapshot",
+            fetchSource: snapshotFetchOptions?.fetchSource,
+        }, async (event) => {
+            const props = {};
+            let cacheLookupTimeInSerialFetch = 0;
+            let retrievedSnapshot;
+            let method;
+            let prefetchWaitStartTime = client_utils_1.performance.now();
+            if (snapshotFetchOptions.fetchSource === driver_definitions_1.FetchSource.noCache) {
+                retrievedSnapshot = await this.fetchSnapshotFromNetwork(hostSnapshotOptions, snapshotFetchOptions.loadingGroupIds, snapshotFetchOptions.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 = this.epochTracker
+                    .get((0, odspUtils_js_1.createCacheSnapshotKey)(this.odspResolvedUrl))
+                    .then(async (
+                // eslint-disable-next-line import/no-deprecated
+                snapshotCachedEntry) => {
+                    if (snapshotCachedEntry !== undefined) {
+                        // If the cached entry does not contain the entry time, then assign it a default of 30 days old.
+                        const age = Date.now() -
+                            (snapshotCachedEntry.cacheEntryTime ??
+                                Date.now() - 30 * 24 * 60 * 60 * 1000);
+                        // In order to decrease the number of times we have to execute a snapshot refresh,
+                        // if this is the summarizer and we have a cache entry but it is past the defaultSummarizerCacheExpiryTimeout,
+                        // force the network retrieval instead as there might be a more recent snapshot available.
+                        // See: https://github.com/microsoft/FluidFramework/issues/8995 for additional information.
+                        if (this.hostPolicy.summarizerClient) {
+                            if (age > exports.defaultSummarizerCacheExpiryTimeout) {
+                                props.cacheSummarizerExpired = true;
+                                return undefined;
+                            }
+                            else {
+                                props.cacheSummarizerExpired = false;
+                            }
+                        }
+                        // Record the cache age
+                        props.cacheEntryAge = age;
+                        // Snapshot from cache could be in older format, so transform that before returning.
+                        if ((0, odspUtils_js_1.isInstanceOfISnapshot)(snapshotCachedEntry)) {
+                            return snapshotCachedEntry;
+                        }
+                        else {
+                            const snapshot = {
+                                snapshotTree: snapshotCachedEntry.snapshotTree,
+                                blobContents: snapshotCachedEntry.blobs,
+                                ops: snapshotCachedEntry.ops,
+                                latestSequenceNumber: snapshotCachedEntry.latestSequenceNumber,
+                                sequenceNumber: snapshotCachedEntry.sequenceNumber,
+                                snapshotFormatV: 1,
+                            };
+                            return snapshot;
+                        }
+                    }
+                });
+                // 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 firstSnapshotFetchCall,
+                // then also check the cache first.
+                if (this.firstSnapshotFetchCall &&
+                    this.hostPolicy.concurrentSnapshotFetch &&
+                    !this.hostPolicy.summarizerClient) {
+                    const networkSnapshotP = this.fetchSnapshotFromNetwork(hostSnapshotOptions, snapshotFetchOptions.loadingGroupIds, snapshotFetchOptions.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 (0, driver_base_1.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)
+                        try {
+                            if (promiseRaceWinner.index === 1) {
+                                retrievedSnapshot = await cachedSnapshotP;
+                                method = "cache";
+                            }
+                            if (retrievedSnapshot === undefined) {
+                                retrievedSnapshot = await networkSnapshotP;
+                                method = "network";
+                            }
+                        }
+                        catch (error) {
+                            // The call stacks of any errors thrown by cached snapshot or network snapshot aren't very useful:
+                            // they get truncated at this stack frame due to the promise race and how v8 tracks async stack traces--
+                            // see https://v8.dev/docs/stack-trace-api#async-stack-traces and the "zero-cost async stack traces" document
+                            // linked there. https://v8.dev/blog/fast-async#await-under-the-hood may also be helpful for context on internals.
+                            // Regenerating the stack at this level provides more information for logged errors.
+                            // Once FF uses an ES2021 target, we could convert the above promise race to use `Promise.any` + AggregateError and
+                            // get similar quality stacks with less hand-crafted code.
+                            const innerStack = error.stack;
+                            const normalizedError = (0, telemetry_utils_1.normalizeError)(error);
+                            normalizedError.addTelemetryProperties({ innerStack });
+                            const newStack = `<<STACK TRUNCATED: see innerStack property>> \n${(0, telemetry_utils_1.generateStack)()}`;
+                            (0, telemetry_utils_1.overwriteStack)(normalizedError, newStack);
+                            throw normalizedError;
+                        }
+                    }
+                }
+                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.
+                    const startTime = client_utils_1.performance.now();
+                    retrievedSnapshot = await cachedSnapshotP;
+                    cacheLookupTimeInSerialFetch = client_utils_1.performance.now() - startTime;
+                    method = retrievedSnapshot === undefined ? "network" : "cache";
+                    if (retrievedSnapshot === undefined) {
+                        prefetchWaitStartTime = client_utils_1.performance.now();
+                        retrievedSnapshot = await this.fetchSnapshotFromNetwork(hostSnapshotOptions, snapshotFetchOptions.loadingGroupIds, snapshotFetchOptions.scenarioName);
+                    }
+                }
+            }
+            if (method === "network") {
+                props.cacheEntryAge = undefined;
+            }
+            if (this.firstSnapshotFetchCall) {
+                this._isFirstSnapshotFromNetwork = method === "cache" ? false : true;
+            }
+            const prefetchStartTime = retrievedSnapshot.prefetchStartTime;
+            event.end({
+                ...props,
+                method,
+                fetchSnapshotForInitialLoad: this.firstSnapshotFetchCall,
+                useLegacyFlowWithoutGroups: (0, odspUtils_js_1.useLegacyFlowWithoutGroupsForSnapshotFetch)(snapshotFetchOptions.loadingGroupIds),
+                avoidPrefetchSnapshotCache: this.hostPolicy.avoidPrefetchSnapshotCache,
+                ...(0, fetchSnapshot_js_1.evalBlobsAndTrees)(retrievedSnapshot),
+                cacheLookupTimeInSerialFetch,
+                prefetchSavedDuration: prefetchStartTime !== undefined && method !== "cache"
+                    ? prefetchWaitStartTime - prefetchStartTime
+                    : undefined,
+            });
+            return retrievedSnapshot;
+        });
+        const stTime = client_utils_1.performance.now();
+        // Don't override ops which were fetched during initial load, since we could still need them.
+        const id = this.initializeFromSnapshot(odspSnapshotCacheValue, this.firstSnapshotFetchCall, snapshotFetchOptions?.cacheSnapshot ?? this.firstSnapshotFetchCall);
+        this.logger.sendTelemetryEvent({
+            eventName: "SnapshotInitializeTime",
+            duration: client_utils_1.performance.now() - stTime,
+        }, undefined, core_interfaces_1.LogLevel.verbose);
+        this.firstSnapshotFetchCall = false;
+        return { snapshot: odspSnapshotCacheValue, id };
+    }
     async getVersions(
     // eslint-disable-next-line @rushstack/no-new-null
     blobid, count, scenarioName, fetchSource) {
@@ -140,152 +316,28 @@ class OdspDocumentStorageService extends odspDocumentStorageServiceBase_1.OdspDo
         }
         // 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
         if (count === 1 && (blobid === null || blobid === this.documentId)) {
-            const hostSnapshotOptions = this.hostPolicy.snapshotOptions;
-            const odspSnapshotCacheValue = await telemetry_utils_1.PerformanceEvent.timedExecAsync(this.logger, { eventName: "ObtainSnapshot", fetchSource }, async (event) => {
-                const props = {};
-                let cacheLookupTimeInSerialFetch = 0;
-                let retrievedSnapshot;
-                let method;
-                let prefetchWaitStartTime = client_utils_1.performance.now();
-                if (fetchSource === driver_definitions_1.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 = this.epochTracker
-                        .get((0, odspUtils_1.createCacheSnapshotKey)(this.odspResolvedUrl))
-                        .then(async (snapshotCachedEntry) => {
-                        if (snapshotCachedEntry !== undefined) {
-                            // If the cached entry does not contain the entry time, then assign it a default of 30 days old.
-                            const age = Date.now() -
-                                (snapshotCachedEntry.cacheEntryTime ??
-                                    Date.now() - 30 * 24 * 60 * 60 * 1000);
-                            // In order to decrease the number of times we have to execute a snapshot refresh,
-                            // if this is the summarizer and we have a cache entry but it is past the defaultSummarizerCacheExpiryTimeout,
-                            // force the network retrieval instead as there might be a more recent snapshot available.
-                            // See: https://github.com/microsoft/FluidFramework/issues/8995 for additional information.
-                            if (this.hostPolicy.summarizerClient) {
-                                if (age > exports.defaultSummarizerCacheExpiryTimeout) {
-                                    props.cacheSummarizerExpired = true;
-                                    return undefined;
-                                }
-                                else {
-                                    props.cacheSummarizerExpired = false;
-                                }
-                            }
-                            // Record the cache age
-                            props.cacheEntryAge = age;
-                        }
-                        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.
-                    // 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 (0, driver_base_1.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)
-                            try {
-                                if (promiseRaceWinner.index === 1) {
-                                    retrievedSnapshot = await cachedSnapshotP;
-                                    method = "cache";
-                                }
-                                if (retrievedSnapshot === undefined) {
-                                    retrievedSnapshot = await networkSnapshotP;
-                                    method = "network";
-                                }
-                            }
-                            catch (err) {
-                                // The call stacks of any errors thrown by cached snapshot or network snapshot aren't very useful:
-                                // they get truncated at this stack frame due to the promise race and how v8 tracks async stack traces--
-                                // see https://v8.dev/docs/stack-trace-api#async-stack-traces and the "zero-cost async stack traces" document
-                                // linked there. https://v8.dev/blog/fast-async#await-under-the-hood may also be helpful for context on internals.
-                                // Regenerating the stack at this level provides more information for logged errors.
-                                // Once FF uses an ES2021 target, we could convert the above promise race to use `Promise.any` + AggregateError and
-                                // get similar quality stacks with less hand-crafted code.
-                                const innerStack = err.stack;
-                                const normalizedError = (0, telemetry_utils_1.normalizeError)(err);
-                                normalizedError.addTelemetryProperties({ innerStack });
-                                const newStack = `<<STACK TRUNCATED: see innerStack property>> \n${(0, telemetry_utils_1.generateStack)()}`;
-                                (0, telemetry_utils_1.overwriteStack)(normalizedError, newStack);
-                                throw normalizedError;
-                            }
-                        }
-                    }
-                    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.
-                        const startTime = client_utils_1.performance.now();
-                        retrievedSnapshot = await cachedSnapshotP;
-                        cacheLookupTimeInSerialFetch = client_utils_1.performance.now() - startTime;
-                        method = retrievedSnapshot !== undefined ? "cache" : "network";
-                        if (retrievedSnapshot === undefined) {
-                            prefetchWaitStartTime = client_utils_1.performance.now();
-                            retrievedSnapshot = await this.fetchSnapshot(hostSnapshotOptions, scenarioName);
-                        }
-                    }
-                }
-                if (method === "network") {
-                    props.cacheEntryAge = undefined;
-                }
-                if (this.firstVersionCall) {
-                    this._isFirstSnapshotFromNetwork = method === "cache" ? false : true;
-                }
-                const prefetchStartTime = retrievedSnapshot.prefetchStartTime;
-                event.end({
-                    ...props,
-                    method,
-                    avoidPrefetchSnapshotCache: this.hostPolicy.avoidPrefetchSnapshotCache,
-                    ...(0, fetchSnapshot_1.evalBlobsAndTrees)(retrievedSnapshot),
-                    cacheLookupTimeInSerialFetch,
-                    prefetchSavedDuration: prefetchStartTime !== undefined && method !== "cache"
-                        ? prefetchWaitStartTime - prefetchStartTime
-                        : undefined,
-                });
-                return retrievedSnapshot;
+            const { id } = await this.fetchSnapshot({
+                cacheSnapshot: true,
+                scenarioName,
+                versionId: blobid ?? undefined,
+                fetchSource,
             });
-            const stTime = client_utils_1.performance.now();
-            // Don't override ops which were fetched during initial load, since we could still need them.
-            const id = this.initializeFromSnapshot(odspSnapshotCacheValue, this.firstVersionCall);
-            this.logger.sendTelemetryEvent({
-                eventName: "SnapshotInitializeTime",
-                duration: client_utils_1.performance.now() - stTime,
-            }, undefined, core_interfaces_1.LogLevel.verbose);
-            this.firstVersionCall = false;
             return id ? [{ id, treeId: undefined }] : [];
         }
-        return (0, odspUtils_1.getWithRetryForTokenRefresh)(async (options) => {
+        return (0, odspUtils_js_1.getWithRetryForTokenRefresh)(async (options) => {
             const storageToken = await this.getStorageToken(options, "GetVersions");
-            const { url, headers } = (0, getUrlAndHeadersWithAuth_1.getUrlAndHeadersWithAuth)(`${this.snapshotUrl}/versions?top=${count}`, storageToken, !!this.hostPolicy.sessionOptions?.forceAccessTokenViaAuthorizationHeader);
+            const { url, headers } = (0, getUrlAndHeadersWithAuth_js_1.getUrlAndHeadersWithAuth)(`${this.snapshotUrl}/versions?top=${count}`, storageToken, !!this.hostPolicy.sessionOptions?.forceAccessTokenViaAuthorizationHeader);
             // Fetch the latest snapshot versions for the document
             const response = await telemetry_utils_1.PerformanceEvent.timedExecAsync(this.logger, {
                 eventName: "getVersions",
-                headers: Object.keys(headers).length !== 0 ? true : undefined,
+                headers: Object.keys(headers).length > 0 ? true : undefined,
             }, async () => this.epochTracker.fetchAndParseAsJSON(url, { headers }, "versions", undefined, scenarioName));
             const versionsResponse = response.content;
             if (!versionsResponse) {
-                throw new driver_utils_1.NonRetryableError("No response from /versions endpoint", driver_definitions_1.DriverErrorType.genericNetworkError, { driverVersion: packageVersion_1.pkgVersion });
+                throw new driver_utils_1.NonRetryableError("No response from /versions endpoint", odsp_driver_definitions_1.OdspErrorTypes.genericNetworkError, { driverVersion: packageVersion_js_1.pkgVersion });
             }
             if (!Array.isArray(versionsResponse.value)) {
-                throw new driver_utils_1.NonRetryableError("Incorrect response from /versions endpoint, expected an array", driver_definitions_1.DriverErrorType.genericNetworkError, { driverVersion: packageVersion_1.pkgVersion });
+                throw new driver_utils_1.NonRetryableError("Incorrect response from /versions endpoint, expected an array", odsp_driver_definitions_1.OdspErrorTypes.genericNetworkError, { driverVersion: packageVersion_js_1.pkgVersion });
             }
             return versionsResponse.value.map((version) => {
                 return {
@@ -295,23 +347,25 @@ class OdspDocumentStorageService extends odspDocumentStorageServiceBase_1.OdspDo
             });
         });
     }
-    async fetchSnapshot(hostSnapshotOptions, scenarioName) {
-        return this.fetchSnapshotCore(hostSnapshotOptions, scenarioName).catch((error) => {
+    async fetchSnapshotFromNetwork(hostSnapshotOptions, loadingGroupIds, scenarioName) {
+        return this.fetchSnapshotFromNetworkCore(hostSnapshotOptions, loadingGroupIds, scenarioName).catch((error) => {
             // Issue #5895:
             // If we are offline, this error is retryable. But that means that RetriableDocumentStorageService
             // will run in circles calling getSnapshotTree, which would result in OdspDocumentStorageService class
             // going getVersions / individual blob download path. This path is very slow, and will not work with
             // delay-loaded data stores and ODSP storage deleting old snapshots and blobs.
             if (typeof error === "object" && error !== null) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
                 error.canRetry = false;
             }
             throw error;
         });
     }
-    async fetchSnapshotCore(hostSnapshotOptions, scenarioName) {
-        // Don't look into cache, if the host specifically tells us so.
-        if (!this.hostPolicy.avoidPrefetchSnapshotCache) {
-            const prefetchCacheKey = (0, odsp_driver_definitions_1.getKeyForCacheEntry)((0, odspUtils_1.createCacheSnapshotKey)(this.odspResolvedUrl));
+    async fetchSnapshotFromNetworkCore(hostSnapshotOptions, loadingGroupIds, scenarioName) {
+        // Don't look into cache, if the host specifically tells us so. Also, if request is
+        // for initial snapshot, don't consult the prefetch cache.
+        if (!this.hostPolicy.avoidPrefetchSnapshotCache && this.firstSnapshotFetchCall) {
+            const prefetchCacheKey = (0, odsp_driver_definitions_1.getKeyForCacheEntry)((0, odspUtils_js_1.createCacheSnapshotKey)(this.odspResolvedUrl));
             const result = await this.cache.snapshotPrefetchResultCache
                 ?.get(prefetchCacheKey)
                 ?.then(async (response) => {
@@ -321,11 +375,11 @@ class OdspDocumentStorageService extends odspDocumentStorageServiceBase_1.OdspDo
                 await this.epochTracker.validateEpoch(response.fluidEpoch, "treesLatest");
                 return response;
             })
-                .catch(async (err) => {
+                .catch(async (error) => {
                 this.logger.sendTelemetryEvent({
                     eventName: "PrefetchSnapshotError",
                     concurrentSnapshotFetch: this.hostPolicy.concurrentSnapshotFetch,
-                }, err);
+                }, error);
                 return undefined;
             });
             // If the prefetch call, is successful, then return the contents otherwise as backup for now, just
@@ -346,33 +400,36 @@ class OdspDocumentStorageService extends odspDocumentStorageServiceBase_1.OdspDo
             snapshotOptions.mds = undefined;
             snapshotOptions.timeout = undefined;
         }
-        const snapshotDownloader = async (finalOdspResolvedUrl, storageToken, options, controller) => {
-            return (0, fetchSnapshot_1.downloadSnapshot)(finalOdspResolvedUrl, storageToken, this.logger, options, this.snapshotFormatFetchType, controller, this.epochTracker, scenarioName);
+        const snapshotDownloader = async (finalOdspResolvedUrl, storageToken, loadingGroupId, options, controller) => {
+            return (0, fetchSnapshot_js_1.downloadSnapshot)(finalOdspResolvedUrl, storageToken, loadingGroupId, options, this.snapshotFormatFetchType, controller, this.epochTracker, scenarioName);
         };
         const putInCache = async (valueWithEpoch) => {
-            return this.cache.persistedCache.put((0, odspUtils_1.createCacheSnapshotKey)(this.odspResolvedUrl), 
+            return this.cache.persistedCache.put((0, odspUtils_js_1.createCacheSnapshotKey)(this.odspResolvedUrl), 
             // Epoch tracker will add the epoch and version to the value here. So just send value to cache.
             valueWithEpoch.value);
         };
         const removeEntries = async () => this.cache.persistedCache.removeEntries();
         try {
-            const odspSnapshot = await (0, fetchSnapshot_1.fetchSnapshotWithRedeem)(this.odspResolvedUrl, this.getStorageToken, snapshotOptions, !!this.hostPolicy.sessionOptions?.forceAccessTokenViaAuthorizationHeader, this.logger, snapshotDownloader, putInCache, removeEntries, this.hostPolicy.enableRedeemFallback);
+            const odspSnapshot = await (0, fetchSnapshot_js_1.fetchSnapshotWithRedeem)(this.odspResolvedUrl, this.getStorageToken, snapshotOptions, !!this.hostPolicy.sessionOptions?.forceAccessTokenViaAuthorizationHeader, this.logger, snapshotDownloader, putInCache, removeEntries, loadingGroupIds, this.hostPolicy.enableRedeemFallback);
             return odspSnapshot;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
         }
         catch (error) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
             const errorType = error.errorType;
             // If the snapshot size is too big and the host specified the size limitation(specified in hostSnapshotOptions), then don't try to fetch the snapshot again.
-            if (errorType === odsp_driver_definitions_1.OdspErrorType.snapshotTooBig &&
+            if (errorType === odsp_driver_definitions_1.OdspErrorTypes.snapshotTooBig &&
                 hostSnapshotOptions?.mds !== undefined &&
                 this.hostPolicy.summarizerClient !== true) {
                 throw error;
             }
             // If the first snapshot request was with blobs and we either timed out or the size was too big, then try to fetch without blobs.
-            if ((errorType === odsp_driver_definitions_1.OdspErrorType.snapshotTooBig ||
-                errorType === odsp_driver_definitions_1.OdspErrorType.fetchTimeout) &&
+            if ((errorType === odsp_driver_definitions_1.OdspErrorTypes.snapshotTooBig ||
+                errorType === odsp_driver_definitions_1.OdspErrorTypes.fetchTimeout) &&
                 snapshotOptions.blobs) {
                 this.logger.sendErrorEvent({
                     eventName: "TreeLatest_SecondCall",
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
                     errorType,
                 });
                 const snapshotOptionsWithoutBlobs = {
@@ -381,7 +438,7 @@ class OdspDocumentStorageService extends odspDocumentStorageServiceBase_1.OdspDo
                     mds: undefined,
                     timeout: undefined,
                 };
-                const odspSnapshot = await (0, fetchSnapshot_1.fetchSnapshotWithRedeem)(this.odspResolvedUrl, this.getStorageToken, snapshotOptionsWithoutBlobs, !!this.hostPolicy.sessionOptions?.forceAccessTokenViaAuthorizationHeader, this.logger, snapshotDownloader, putInCache, removeEntries, this.hostPolicy.enableRedeemFallback);
+                const odspSnapshot = await (0, fetchSnapshot_js_1.fetchSnapshotWithRedeem)(this.odspResolvedUrl, this.getStorageToken, snapshotOptionsWithoutBlobs, !!this.hostPolicy.sessionOptions?.forceAccessTokenViaAuthorizationHeader, this.logger, snapshotDownloader, putInCache, removeEntries, loadingGroupIds, this.hostPolicy.enableRedeemFallback);
                 return odspSnapshot;
             }
             throw error;
@@ -453,34 +510,34 @@ class OdspDocumentStorageService extends odspDocumentStorageServiceBase_1.OdspDo
     }
     checkSnapshotUrl() {
         if (!this.snapshotUrl) {
-            throw new driver_utils_1.NonRetryableError("Method failed because no snapshot url was available", driver_definitions_1.DriverErrorType.genericError, { driverVersion: packageVersion_1.pkgVersion });
+            throw new driver_utils_1.NonRetryableError("Method failed because no snapshot url was available", odsp_driver_definitions_1.OdspErrorTypes.genericError, { driverVersion: packageVersion_js_1.pkgVersion });
         }
     }
     checkAttachmentPOSTUrl() {
         if (!this.attachmentPOSTUrl) {
-            throw new driver_utils_1.NonRetryableError("Method failed because no attachment POST url was available", driver_definitions_1.DriverErrorType.genericError, { driverVersion: packageVersion_1.pkgVersion });
+            throw new driver_utils_1.NonRetryableError("Method failed because no attachment POST url was available", odsp_driver_definitions_1.OdspErrorTypes.genericError, { driverVersion: packageVersion_js_1.pkgVersion });
         }
     }
     checkAttachmentGETUrl() {
         if (!this.attachmentGETUrl) {
-            throw new driver_utils_1.NonRetryableError("Method failed because no attachment GET url was available", driver_definitions_1.DriverErrorType.genericError, { driverVersion: packageVersion_1.pkgVersion });
+            throw new driver_utils_1.NonRetryableError("Method failed because no attachment GET url was available", odsp_driver_definitions_1.OdspErrorTypes.genericError, { driverVersion: packageVersion_js_1.pkgVersion });
         }
     }
     async fetchTreeFromSnapshot(id, scenarioName) {
-        return (0, odspUtils_1.getWithRetryForTokenRefresh)(async (options) => {
+        return (0, odspUtils_js_1.getWithRetryForTokenRefresh)(async (options) => {
             const storageToken = await this.getStorageToken(options, "ReadCommit");
             const snapshotDownloader = async (url, fetchOptions) => {
                 return this.epochTracker.fetchAndParseAsJSON(url, fetchOptions, "snapshotTree", undefined, scenarioName);
             };
-            const snapshot = await (0, fetchSnapshot_1.fetchSnapshot)(this.snapshotUrl, storageToken, id, this.fetchFullSnapshot, !!this.hostPolicy.sessionOptions?.forceAccessTokenViaAuthorizationHeader, this.logger, snapshotDownloader);
+            const snapshot = await (0, fetchSnapshot_js_1.fetchSnapshot)(this.snapshotUrl, storageToken, id, this.fetchFullSnapshot, !!this.hostPolicy.sessionOptions?.forceAccessTokenViaAuthorizationHeader, this.logger, snapshotDownloader);
             let treeId = "";
             if (snapshot.snapshotTree) {
                 (0, core_utils_1.assert)(snapshot.snapshotTree.id !== undefined, 0x222 /* "Root tree should contain the id!!" */);
                 treeId = snapshot.snapshotTree.id;
                 this.setRootTree(treeId, snapshot.snapshotTree);
             }
-            if (snapshot.blobs) {
-                this.initBlobsCache(snapshot.blobs);
+            if (snapshot.blobContents) {
+                this.initBlobsCache(snapshot.blobContents);
             }
             // If the version id doesn't match with the id of the tree, then use the id of first tree which in that case
             // will be the actual id of tree to be fetched.