@fluidframework/odsp-driver 0.58.2002 → 0.59.1000

package/src/createNewUtils.ts

@@ -36,7 +36,6 @@ function convertCreateNewSummaryTreeToTreeAndBlobsCore(
     const treeNode: ISnapshotTree = {
         blobs: {},
         trees: {},
-        commits: {},
         unreferenced: summary.unreferenced,
     };
     const keys = Object.keys(summary.tree);

package/src/epochTracker.ts

@@ -18,7 +18,7 @@ import {
 } from "@fluidframework/odsp-driver-definitions";
 import { DriverErrorType } from "@fluidframework/driver-definitions";
 import { PerformanceEvent, isFluidError, normalizeError } from "@fluidframework/telemetry-utils";
-import { fetchAndParseAsJSONHelper, fetchArray, getOdspResolvedUrl, IOdspResponse } from "./odspUtils";
+import { fetchAndParseAsJSONHelper, fetchArray, fetchHelper, getOdspResolvedUrl, IOdspResponse } from "./odspUtils";
 import {
     IOdspCache,
     INonPersistentCache,
@@ -166,6 +166,7 @@ export class EpochTracker implements IPersistedFileCache {
      * @param fetchOptions - fetch options for request containing body, headers etc.
      * @param fetchType - method for which fetch is called.
      * @param addInBody - Pass True if caller wants to add epoch in post body.
+     * @param fetchReason - fetch reason to add to the request.
      */
     public async fetchAndParseAsJSON<T>(
         url: string,
@@ -174,12 +175,41 @@ export class EpochTracker implements IPersistedFileCache {
         addInBody: boolean = false,
         fetchReason?: string,
     ): Promise<IOdspResponse<T>> {
+        return this.fetchCore<T>(url, fetchOptions, fetchAndParseAsJSONHelper, fetchType, addInBody, fetchReason);
+    }
+
+    /**
+     * Api to fetch the response for given request and parse it as json.
+     * @param url - url of the request
+     * @param fetchOptions - fetch options for request containing body, headers etc.
+     * @param fetchType - method for which fetch is called.
+     * @param addInBody - Pass True if caller wants to add epoch in post body.
+     * @param fetchReason - fetch reason to add to the request.
+     */
+    public async fetch(
+        url: string,
+        fetchOptions: RequestInit,
+        fetchType: FetchType,
+        addInBody: boolean = false,
+        fetchReason?: string,
+    ) {
+        return this.fetchCore<Response>(url, fetchOptions, fetchHelper, fetchType, addInBody, fetchReason);
+    }
+
+    private async fetchCore<T>(
+        url: string,
+        fetchOptions: {[index: string]: any},
+        fetcher: (url: string, fetchOptions: {[index: string]: any}) => Promise<IOdspResponse<T>>,
+        fetchType: FetchType,
+        addInBody: boolean = false,
+        fetchReason?: string,
+    ) {
         const clientCorrelationId = this.formatClientCorrelationId(fetchReason);
         // Add epoch in fetch request.
         this.addEpochInRequest(fetchOptions, addInBody, clientCorrelationId);
         let epochFromResponse: string | undefined;
         return this.rateLimiter.schedule(
-            async () => fetchAndParseAsJSONHelper<T>(url, fetchOptions),
+            async () => fetcher(url, fetchOptions),
         ).then((response) => {
             epochFromResponse = response.headers.get("x-fluid-epoch");
             this.validateEpochFromResponse(epochFromResponse, fetchType);
@@ -205,6 +235,7 @@ export class EpochTracker implements IPersistedFileCache {
      * @param fetchOptions - fetch options for request containing body, headers etc.
      * @param fetchType - method for which fetch is called.
      * @param addInBody - Pass True if caller wants to add epoch in post body.
+     * @param fetchReason - fetch reason to add to the request.
      */
     public async fetchArray(
         url: string,
@@ -213,29 +244,7 @@ export class EpochTracker implements IPersistedFileCache {
         addInBody: boolean = false,
         fetchReason?: string,
     ) {
-        const clientCorrelationId = this.formatClientCorrelationId(fetchReason);
-        // Add epoch in fetch request.
-        this.addEpochInRequest(fetchOptions, addInBody, clientCorrelationId);
-        let epochFromResponse: string | undefined;
-        return this.rateLimiter.schedule(
-            async () => fetchArray(url, fetchOptions),
-        ).then((response) => {
-            epochFromResponse = response.headers.get("x-fluid-epoch");
-            this.validateEpochFromResponse(epochFromResponse, fetchType);
-            response.propsToLog.XRequestStatsHeader = clientCorrelationId;
-            return response;
-        }).catch(async (error) => {
-            // Get the server epoch from error in case we don't have it as if undefined we won't be able
-            // to mark it as epoch error.
-            if (epochFromResponse === undefined) {
-                epochFromResponse = (error as IOdspError).serverEpoch;
-            }
-            await this.checkForEpochError(error, epochFromResponse, fetchType);
-            throw error;
-        }).catch((error) => {
-            const fluidError = normalizeError(error, { props: { XRequestStatsHeader: clientCorrelationId }});
-            throw fluidError;
-        });
+        return this.fetchCore<ArrayBuffer>(url, fetchOptions, fetchArray, fetchType, addInBody, fetchReason);
     }
 
     private addEpochInRequest(

package/src/fetchSnapshot.ts

@@ -22,14 +22,14 @@ import { getQueryString } from "./getQueryString";
 import { getUrlAndHeadersWithAuth } from "./getUrlAndHeadersWithAuth";
 import {
     fetchAndParseAsJSONHelper,
-    fetchArray,
+    fetchHelper,
     getWithRetryForTokenRefresh,
     getWithRetryForTokenRefreshRepeat,
     IOdspResponse,
     ISnapshotContents,
 } from "./odspUtils";
 import { convertOdspSnapshotToSnapsohtTreeAndBlobs } from "./odspSnapshotParser";
-import { parseCompactSnapshotResponse } from "./compactSnapshotParser";
+import { currentReadVersion, parseCompactSnapshotResponse } from "./compactSnapshotParser";
 import { ReadBuffer } from "./ReadBufferUtils";
 import { EpochTracker } from "./epochTracker";
 
@@ -362,89 +362,6 @@ interface ISnapshotRequestAndResponseOptions {
     requestHeaders: {[index: string]: any},
 }
 
-/**
- * This function fetches the older snapshot format which is the json format(IOdspSnapshot).
- * @param odspResolvedUrl - resolved odsp url.
- * @param storageToken - token to do the auth for network request.
- * @param snapshotOptions - Options used to specify how and what to fetch in the snapshot.
- * @param controller - abort controller if caller needs to abort the network call.
- * @param epochTracker - epoch tracker used to add/validate epoch in the network call.
- * @returns fetched snapshot.
- */
-async function fetchSnapshotContentsCoreV1(
-    odspResolvedUrl: IOdspResolvedUrl,
-    storageToken: string,
-    snapshotOptions: ISnapshotOptions | undefined,
-    controller?: AbortController,
-    epochTracker?: EpochTracker,
-): Promise<ISnapshotRequestAndResponseOptions> {
-    const snapshotUrl = odspResolvedUrl.endpoints.snapshotStorageUrl;
-    const url = `${snapshotUrl}/trees/latest?ump=1`;
-    // 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 futher reference here: \packages\utils\odsp-doclib-utils\src\odspErrorUtils.ts
-    const header = { prefer: "manualredirect" };
-    const { body, headers } = getFormBodyAndHeaders(
-        odspResolvedUrl, storageToken, snapshotOptions, header);
-    headers.accept = "application/json";
-    const fetchOptions = {
-        body,
-        headers,
-        signal: controller?.signal,
-        method: "POST",
-    };
-    const response = await (epochTracker?.fetchAndParseAsJSON<IOdspSnapshot>(url, fetchOptions, "treesLatest", true) ??
-        fetchAndParseAsJSONHelper<IOdspSnapshot>(url, fetchOptions));
-    const snapshotContents: ISnapshotContents = convertOdspSnapshotToSnapsohtTreeAndBlobs(response.content);
-    const finalSnapshotContents: IOdspResponse<ISnapshotContents> = { ...response, content: snapshotContents };
-    return {
-        odspSnapshotResponse: finalSnapshotContents,
-        requestHeaders: headers,
-        requestUrl: url,
-    };
-}
-
-/**
- * This function fetches the binary compact snapshot format. This is an experimental feature
- * and is behind a feature flag.
- * @param odspResolvedUrl - resolved odsp url.
- * @param storageToken - token to do the auth for network request.
- * @param snapshotOptions - Options used to specify how and what to fetch in the snapshot.
- * @param controller - abort controller if caller needs to abort the network call.
- * @param epochTracker - epoch tracker used to add/validate epoch in the network call.
- * @returns fetched snapshot.
- */
-async function fetchSnapshotContentsCoreV2(
-    odspResolvedUrl: IOdspResolvedUrl,
-    storageToken: string,
-    snapshotOptions: ISnapshotOptions | undefined,
-    controller?: AbortController,
-    epochTracker?: EpochTracker,
-): Promise<ISnapshotRequestAndResponseOptions> {
-    const fullUrl = `${odspResolvedUrl.siteUrl}/_api/v2.1/drives/${odspResolvedUrl.driveId}/items/${
-        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(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: fullUrl,
-    };
-}
-
 function getFormBodyAndHeaders(
     odspResolvedUrl: IOdspResolvedUrl,
     storageToken: string,
@@ -505,6 +422,17 @@ function countTreesInSnapshotTree(snapshotTree: ISnapshotTree): number {
     return numTrees;
 }
 
+/**
+ * This function fetches the snapshot and parse it according to what is mentioned in response headers.
+ * @param odspResolvedUrl - resolved odsp url.
+ * @param storageToken - token to do the auth for network request.
+ * @param snapshotOptions - Options used to specify how and what to fetch in the snapshot.
+ * @param logger - logger
+ * @param fetchBinarySnapshotFormat - whether to fetch binary snapshot or not.
+ * @param controller - abort controller if caller needs to abort the network call.
+ * @param epochTracker - epoch tracker used to add/validate epoch in the network call.
+ * @returns fetched snapshot.
+ */
 export async function downloadSnapshot(
     odspResolvedUrl: IOdspResolvedUrl,
     storageToken: string,
@@ -520,13 +448,53 @@ export async function downloadSnapshot(
         odspResolvedUrl.shareLinkInfo = { ...odspResolvedUrl.shareLinkInfo, sharingLinkToRedeem };
     }
 
+    const snapshotUrl = odspResolvedUrl.endpoints.snapshotStorageUrl;
+    const url = `${snapshotUrl}/trees/latest?ump=1`;
+    // 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 futher reference here: \packages\utils\odsp-doclib-utils\src\odspErrorUtils.ts
+    const header = {prefer: "manualredirect"};
+    const { body, headers } = getFormBodyAndHeaders(
+        odspResolvedUrl, storageToken, snapshotOptions, header);
+    const fetchOptions = {
+        body,
+        headers,
+        signal: controller?.signal,
+        method: "POST",
+    };
+    // For now we are keeping both json and ms-fluid values in accept header while fetching as we want to let
+    // the server decide what format it wants to send to the client as we roll it out slowly.
     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" });
-        return fetchSnapshotContentsCoreV2(odspResolvedUrl, storageToken, snapshotOptions, controller, epochTracker);
+        headers.accept = `application/json, application/ms-fluid; v=${currentReadVersion}`;
+    } else {
+        headers.accept = "application/json";
+    }
+    const response = await (epochTracker?.fetch(url, fetchOptions, "treesLatest", true) ??
+        fetchHelper(url, fetchOptions));
+
+    let finalSnapshotContents: IOdspResponse<ISnapshotContents>;
+    const contentType = response.headers.get("content-type");
+    if (contentType === "application/json") {
+        const text = await response.content.text();
+        const content: IOdspSnapshot = JSON.parse(text);
+        response.propsToLog.bodySize = text.length;
+        const snapshotContents: ISnapshotContents = convertOdspSnapshotToSnapsohtTreeAndBlobs(content);
+        finalSnapshotContents = { ...response, content: snapshotContents };
     } else {
-        return fetchSnapshotContentsCoreV1(odspResolvedUrl, storageToken, snapshotOptions, controller, epochTracker);
+        assert(contentType === "application/ms-fluid", 0x2c3 /* "Content type should be application/ms-fluid" */);
+        const content = await response.content.arrayBuffer();
+        response.propsToLog.bodySize = content.byteLength;
+        const snapshotContents: ISnapshotContents = parseCompactSnapshotResponse(
+            new ReadBuffer(new Uint8Array(content)));
+        finalSnapshotContents = { ...response, content: snapshotContents };
     }
+    response.propsToLog.contentType = contentType;
+    return {
+        odspSnapshotResponse: finalSnapshotContents,
+        requestHeaders: headers,
+        requestUrl: url,
+    };
 }
 
 function isRedeemSharingLinkError(odspResolvedUrl: IOdspResolvedUrl, error: any) {

package/src/odspDocumentService.ts

@@ -81,6 +81,7 @@ export class OdspDocumentService implements IDocumentService {
         hostPolicy: HostStoragePolicy,
         epochTracker: EpochTracker,
         socketReferenceKeyPrefix?: string,
+        clientIsSummarizer?: boolean,
     ): Promise<IDocumentService> {
         return new OdspDocumentService(
             getOdspResolvedUrl(resolvedUrl),
@@ -92,6 +93,7 @@ export class OdspDocumentService implements IDocumentService {
             hostPolicy,
             epochTracker,
             socketReferenceKeyPrefix,
+            clientIsSummarizer,
         );
     }
 
@@ -131,6 +133,7 @@ export class OdspDocumentService implements IDocumentService {
         hostPolicy: HostStoragePolicy,
         private readonly epochTracker: EpochTracker,
         private readonly socketReferenceKeyPrefix?: string,
+        private readonly clientIsSummarizer?: boolean,
     ) {
         this._policies = {
             // load in storage-only mode if a file version is specified
@@ -150,7 +153,7 @@ export class OdspDocumentService implements IDocumentService {
         this.hostPolicy = hostPolicy;
         this.hostPolicy.fetchBinarySnapshotFormat ??=
             this.mc.config.getBoolean("Fluid.Driver.Odsp.binaryFormatSnapshot");
-        if (this.odspResolvedUrl.summarizer) {
+        if (this.clientIsSummarizer) {
             this.hostPolicy = { ...this.hostPolicy, summarizerClient: true };
         }
     }
@@ -385,7 +388,7 @@ export class OdspDocumentService implements IDocumentService {
         };
 
         const getResponseAndRefreshAfterDeltaMs = async () => {
-            let _response = await this.cache.sessionJoinCache.addOrGet(this.joinSessionKey, executeFetch);
+            const _response = await this.cache.sessionJoinCache.addOrGet(this.joinSessionKey, executeFetch);
             // If the response does not contain refreshSessionDurationSeconds, then treat it as old flow and let the
             // cache entry to be treated as expired after 1 hour.
             _response.joinSessionResponse.refreshSessionDurationSeconds =
@@ -415,16 +418,16 @@ export class OdspDocumentService implements IDocumentService {
                     .catch((error) => {
                         this.mc.logger.sendErrorEvent({
                                 eventName: "JoinSessionRefreshError",
-                                ...props,
+                                details: JSON.stringify(props),
                             },
                             error,
                         );
                     });
             } else {
                 // Logging just for informational purposes to help with debugging as this is a new feature.
-                this.mc.logger.sendErrorEvent({
+                this.mc.logger.sendTelemetryEvent({
                     eventName: "JoinSessionRefreshNotScheduled",
-                    ...props,
+                    details: JSON.stringify(props),
                 });
             }
         }

package/src/odspDocumentServiceFactoryCore.ts

@@ -55,6 +55,7 @@ export class OdspDocumentServiceFactoryCore implements IDocumentServiceFactory {
         createNewSummary: ISummaryTree | undefined,
         createNewResolvedUrl: IResolvedUrl,
         logger?: ITelemetryBaseLogger,
+        clientIsSummarizer?: boolean,
     ): Promise<IDocumentService> {
         ensureFluidResolvedUrl(createNewResolvedUrl);
 
@@ -113,7 +114,8 @@ export class OdspDocumentServiceFactoryCore implements IDocumentServiceFactory {
                     this.hostPolicy.cacheCreateNewSummary ?? true,
                     !!this.hostPolicy.sessionOptions?.forceAccessTokenViaAuthorizationHeader,
                 );
-                const docService = this.createDocumentServiceCore(odspResolvedUrl, odspLogger, cacheAndTracker);
+                const docService = this.createDocumentServiceCore(odspResolvedUrl, odspLogger,
+                    cacheAndTracker, clientIsSummarizer);
                 event.end({
                     docId: odspResolvedUrl.hashedDocumentId,
                 });
@@ -147,14 +149,16 @@ export class OdspDocumentServiceFactoryCore implements IDocumentServiceFactory {
     public async createDocumentService(
         resolvedUrl: IResolvedUrl,
         logger?: ITelemetryBaseLogger,
+        clientIsSummarizer?: boolean,
     ): Promise<IDocumentService> {
-        return this.createDocumentServiceCore(resolvedUrl, createOdspLogger(logger));
+        return this.createDocumentServiceCore(resolvedUrl, createOdspLogger(logger), undefined, clientIsSummarizer);
     }
 
     private async createDocumentServiceCore(
         resolvedUrl: IResolvedUrl,
         odspLogger: TelemetryLogger,
         cacheAndTrackerArg?: ICacheAndTracker,
+        clientIsSummarizer?: boolean,
     ): Promise<IDocumentService> {
         const odspResolvedUrl = getOdspResolvedUrl(resolvedUrl);
         const resolvedUrlData: IOdspUrlParts = {
@@ -194,6 +198,7 @@ export class OdspDocumentServiceFactoryCore implements IDocumentServiceFactory {
             this.hostPolicy,
             cacheAndTracker.epochTracker,
             this.socketReferenceKeyPrefix,
+            clientIsSummarizer,
         );
     }
 }

package/src/odspDocumentStorageManager.ts

@@ -356,38 +356,20 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
         if (!snapshotTree) {
             return null;
         }
-        // Decode commit paths
-        const commits = {};
 
-        for (const key of Object.keys(snapshotTree.commits)) {
-            commits[decodeURIComponent(key)] = snapshotTree.commits[key];
-        }
-
-        let finalTree: api.ISnapshotTree;
-        // For container loaded from detach new summary, we will not have a commit for ".app" in downloaded summary as the client uploaded both
-        // ".app" and ".protocol" trees by itself. For other summaries, we will have ".app" as commit because client previously only uploaded the
-        // app summary.
-        if (commits && commits[".app"]) {
-            // The latest snapshot is a summary
-            // attempt to read .protocol from commits for backwards compat
-            finalTree = await this.readSummaryTree(commits[".protocol"] || snapshotTree.trees[".protocol"], commits[".app"] as string);
-        } else {
-            if (snapshotTree.blobs) {
-                const attributesBlob = snapshotTree.blobs.attributes;
-                if (attributesBlob) {
-                    this.attributesBlobHandles.add(attributesBlob);
-                }
+        if (snapshotTree.blobs) {
+            const attributesBlob = snapshotTree.blobs.attributes;
+            if (attributesBlob) {
+                this.attributesBlobHandles.add(attributesBlob);
             }
+        }
 
-            snapshotTree.commits = commits;
+        // When we upload the container snapshot, we upload appTree in ".app" and protocol tree in ".protocol"
+        // So when we request the snapshot we get ".app" as tree and not as commit node as in the case just above.
+        const appTree = snapshotTree.trees[".app"];
+        const protocolTree = snapshotTree.trees[".protocol"];
 
-            // When we upload the container snapshot, we upload appTree in ".app" and protocol tree in ".protocol"
-            // So when we request the snapshot we get ".app" as tree and not as commit node as in the case just above.
-            const appTree = snapshotTree.trees[".app"];
-            const protocolTree = snapshotTree.trees[".protocol"];
-            finalTree = this.combineProtocolAndAppSnapshotTree(appTree, protocolTree);
-        }
-        return finalTree;
+        return this.combineProtocolAndAppSnapshotTree(appTree, protocolTree);
     }
 
     public async getVersions(blobid: string | null, count: number): Promise<api.IVersion[]> {
@@ -782,39 +764,6 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
         return tree;
     }
 
-    /**
-     * Reads a summary tree
-     * @param protocolTreeOrId - Protocol snapshot tree or id of the protocol tree
-     * @param appTreeId - Id of the app tree
-     */
-    private async readSummaryTree(protocolTreeOrId: api.ISnapshotTree | string, appTreeId: string): Promise<api.ISnapshotTree> {
-        // Load the app and protocol trees and return them
-        let hierarchicalProtocolTree: api.ISnapshotTree | null;
-        if (typeof (protocolTreeOrId) === "string") {
-            // Backwards compat for older summaries
-            hierarchicalProtocolTree = await this.readTree(protocolTreeOrId);
-        } else {
-            hierarchicalProtocolTree = protocolTreeOrId;
-        }
-
-        const hierarchicalAppTree = await this.readTree(appTreeId);
-        if (!hierarchicalProtocolTree) {
-            throw new Error("Invalid protocol tree");
-        }
-
-        if (!hierarchicalAppTree) {
-            throw new Error("Invalid app tree");
-        }
-
-        if (hierarchicalProtocolTree.blobs) {
-            const attributesBlob = hierarchicalProtocolTree.blobs.attributes;
-            if (attributesBlob) {
-                this.attributesBlobHandles.add(attributesBlob);
-            }
-        }
-        return this.combineProtocolAndAppSnapshotTree(hierarchicalAppTree, hierarchicalProtocolTree);
-    }
-
     private combineProtocolAndAppSnapshotTree(
         hierarchicalAppTree: api.ISnapshotTree,
         hierarchicalProtocolTree: api.ISnapshotTree,
@@ -823,9 +772,6 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
             blobs: {
                 ...hierarchicalAppTree.blobs,
             },
-            commits: {
-                ...hierarchicalAppTree.commits,
-            },
             trees: {
                 ...hierarchicalAppTree.trees,
                 // the app tree could have a .protocol

package/src/odspDriverUrlResolver.ts

@@ -2,21 +2,23 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-
 import { assert } from "@fluidframework/common-utils";
-import { IFluidCodeDetails, IRequest, isFluidPackage } from "@fluidframework/core-interfaces";
+import { IRequest } from "@fluidframework/core-interfaces";
 import {
+    DriverErrorType,
     DriverHeader,
     IContainerPackageInfo,
     IResolvedUrl,
     IUrlResolver,
 } from "@fluidframework/driver-definitions";
 import { IOdspResolvedUrl, ShareLinkTypes, ShareLinkInfoType } from "@fluidframework/odsp-driver-definitions";
+import { NonRetryableError } from "@fluidframework/driver-utils";
 import { createOdspUrl } from "./createOdspUrl";
 import { getApiRoot } from "./odspUrlHelper";
 import { getOdspResolvedUrl } from "./odspUtils";
 import { getHashedDocumentId } from "./odspPublicUtils";
 import { ClpCompliantAppHeader } from "./contractsPublic";
+import { pkgVersion } from "./packageVersion";
 
 function getUrlBase(siteUrl: string, driveId: string, itemId: string, fileVersion?: string) {
     const siteOrigin = new URL(siteUrl).origin;
@@ -74,7 +76,10 @@ export class OdspDriverUrlResolver implements IUrlResolver {
             const packageName = searchParams.get("containerPackageName");
             const createLinkType = searchParams.get("createLinkType");
             if (!(fileName && siteURL && driveID && filePath !== null && filePath !== undefined)) {
-                throw new Error("Proper new file params should be there!!");
+                throw new NonRetryableError(
+                    "Proper new file params should be there!!",
+                    DriverErrorType.genericError,
+                    { driverVersion: pkgVersion });
             }
             let shareLinkInfo: ShareLinkInfoType | undefined;
             if(createLinkType && createLinkType in ShareLinkTypes) {
@@ -156,22 +161,26 @@ export class OdspDriverUrlResolver implements IUrlResolver {
     public async getAbsoluteUrl(
         resolvedUrl: IResolvedUrl,
         relativeUrl: string,
-        packageInfoSource?: IContainerPackageInfo | IFluidCodeDetails,
+        packageInfoSource?: IContainerPackageInfo,
     ): Promise<string> {
         let dataStorePath = relativeUrl;
         if (dataStorePath.startsWith("/")) {
             dataStorePath = dataStorePath.substr(1);
         }
         const odspResolvedUrl = getOdspResolvedUrl(resolvedUrl);
-
-        // back-compat: IFluidCodeDetails usage to be removed in 0.58.0
+        // back-compat: GitHub #9653
+        const isFluidPackage = (pkg: any) =>
+            typeof pkg === "object"
+            && typeof pkg?.name === "string"
+            && typeof pkg?.fluid === "object";
         let containerPackageName;
         if (packageInfoSource && "name" in packageInfoSource) {
             containerPackageName = packageInfoSource.name;
-        } else if (isFluidPackage(packageInfoSource?.package)) {
-            containerPackageName = packageInfoSource?.package.name;
+            // packageInfoSource is cast to any as it is typed to IContainerPackageInfo instead of IFluidCodeDetails
+        } else if (isFluidPackage((packageInfoSource as any)?.package)) {
+            containerPackageName = (packageInfoSource as any)?.package.name;
         } else {
-            containerPackageName = packageInfoSource?.package;
+            containerPackageName = (packageInfoSource as any)?.package;
         }
         containerPackageName = containerPackageName ?? odspResolvedUrl.codeHint?.containerPackageName;
 

package/src/odspDriverUrlResolverForShareLink.ts

@@ -2,9 +2,8 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-
 import { PromiseCache } from "@fluidframework/common-utils";
-import { IFluidCodeDetails, IRequest, isFluidPackage } from "@fluidframework/core-interfaces";
+import { IRequest } from "@fluidframework/core-interfaces";
 import {
     IContainerPackageInfo,
     IResolvedUrl,
@@ -191,20 +190,24 @@ export class OdspDriverUrlResolverForShareLink implements IUrlResolver {
     public async getAbsoluteUrl(
         resolvedUrl: IResolvedUrl,
         dataStorePath: string,
-        packageInfoSource?: IContainerPackageInfo | IFluidCodeDetails,
+        packageInfoSource?: IContainerPackageInfo,
     ): Promise<string> {
         const odspResolvedUrl = getOdspResolvedUrl(resolvedUrl);
         const shareLink = await this.getShareLinkPromise(odspResolvedUrl);
         const shareLinkUrl = new URL(shareLink);
-
-        // back-compat: IFluidCodeDetails usage to be removed in 0.58.0
+        // back-compat: GitHub #9653
+        const isFluidPackage = (pkg: any) =>
+            typeof pkg === "object"
+            && typeof pkg?.name === "string"
+            && typeof pkg?.fluid === "object";
         let containerPackageName;
         if (packageInfoSource && "name" in packageInfoSource) {
             containerPackageName = packageInfoSource.name;
-        } else if (isFluidPackage(packageInfoSource?.package)) {
-            containerPackageName = packageInfoSource?.package.name;
+            // packageInfoSource is cast to any as it is typed to IContainerPackageInfo instead of IFluidCodeDetails
+        } else if (isFluidPackage((packageInfoSource as any)?.package)) {
+            containerPackageName = (packageInfoSource as any)?.package.name;
         } else {
-            containerPackageName = packageInfoSource?.package;
+            containerPackageName = (packageInfoSource as any)?.package;
         }
         containerPackageName = containerPackageName ?? odspResolvedUrl.codeHint?.containerPackageName;
 

package/src/odspSnapshotParser.ts

@@ -18,7 +18,7 @@ import { ISnapshotContents } from "./odspUtils";
 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: api.ISnapshotTree = { id: flatTree.id, blobs: {}, commits: {}, trees: {} };
+    const root: api.ISnapshotTree = { id: flatTree.id, blobs: {}, trees: {} };
     lookup[""] = root;
 
     for (const entry of flatTree.entries) {
@@ -33,7 +33,6 @@ function buildHierarchy(flatTree: IOdspSnapshotCommit): api.ISnapshotTree {
         if (entry.type === "tree") {
             const newTree: api.ISnapshotTree = {
                 blobs: {},
-                commits: {},
                 trees: {},
                 unreferenced: entry.unreferenced,
             };
@@ -41,8 +40,6 @@ function buildHierarchy(flatTree: IOdspSnapshotCommit): api.ISnapshotTree {
             lookup[entry.path] = newTree;
         } else if (entry.type === "blob") {
             node.blobs[decodeURIComponent(entryPathBase)] = entry.id;
-        } else if (entry.type === "commit") {
-            node.commits[decodeURIComponent(entryPathBase)] = entry.id;
         }
     }