@fluidframework/odsp-driver 0.59.2001 → 0.59.3000

package/src/createFile.ts

@@ -87,13 +87,13 @@ export async function createNewFluidFile(
         sharingLinkErrorReason = content.sharingLinkErrorReason;
     }
 
-    const odspUrl = createOdspUrl({... newFileInfo, itemId, dataStorePath: "/"});
+    const odspUrl = createOdspUrl({ ... newFileInfo, itemId, dataStorePath: "/" });
     const resolver = new OdspDriverUrlResolver();
     const odspResolvedUrl = await resolver.resolve({ url: odspUrl });
     fileEntry.docId = odspResolvedUrl.hashedDocumentId;
     fileEntry.resolvedUrl = odspResolvedUrl;
 
-    if(sharingLink || sharingLinkErrorReason) {
+    if (sharingLink || sharingLinkErrorReason) {
         odspResolvedUrl.shareLinkInfo = {
             createLink: {
                 type: newFileInfo.createLinkType,

package/src/epochTracker.ts

@@ -198,8 +198,8 @@ export class EpochTracker implements IPersistedFileCache {
 
     private async fetchCore<T>(
         url: string,
-        fetchOptions: {[index: string]: any},
-        fetcher: (url: string, fetchOptions: {[index: string]: any}) => Promise<IOdspResponse<T>>,
+        fetchOptions: { [index: string]: any; },
+        fetcher: (url: string, fetchOptions: { [index: string]: any; }) => Promise<IOdspResponse<T>>,
         fetchType: FetchType,
         addInBody: boolean = false,
         fetchReason?: string,
@@ -224,7 +224,7 @@ export class EpochTracker implements IPersistedFileCache {
             await this.checkForEpochError(error, epochFromResponse, fetchType);
             throw error;
         }).catch((error) => {
-            const fluidError = normalizeError(error, { props: { XRequestStatsHeader: clientCorrelationId }});
+            const fluidError = normalizeError(error, { props: { XRequestStatsHeader: clientCorrelationId } });
             throw fluidError;
         });
     }
@@ -239,7 +239,7 @@ export class EpochTracker implements IPersistedFileCache {
      */
     public async fetchArray(
         url: string,
-        fetchOptions: {[index: string]: any},
+        fetchOptions: { [index: string]: any; },
         fetchType: FetchType,
         addInBody: boolean = false,
         fetchReason?: string,
@@ -254,7 +254,7 @@ export class EpochTracker implements IPersistedFileCache {
     ) {
         const isClpCompliantApp = getOdspResolvedUrl(this.fileEntry.resolvedUrl).isClpCompliantApp;
         if (addInBody) {
-            const headers: {[key: string]: string} = {};
+            const headers: { [key: string]: string; } = {};
             headers["X-RequestStats"] = clientCorrelationId;
             if (this.fluidEpoch !== undefined) {
                 headers["x-fluid-epoch"] = this.fluidEpoch;
@@ -281,14 +281,14 @@ export class EpochTracker implements IPersistedFileCache {
         }
     }
 
-    private addParamInBody(fetchOptions: RequestInit, headers: {[key: string]: string}) {
+    private addParamInBody(fetchOptions: RequestInit, headers: { [key: string]: string; }) {
         // We use multi part form request for post body where we want to use this.
         // So extract the form boundary to mark the end of form.
         const body = fetchOptions.body;
         assert(typeof body === "string", 0x21d /* "body is not string" */);
         const splitBody = body.split("\r\n");
         const firstLine = splitBody.shift();
-        assert(firstLine !== undefined && firstLine.startsWith("--"), 0x21e /* "improper boundary format" */);
+        assert(firstLine?.startsWith("--") === true, 0x21e /* "improper boundary format" */);
         const formParams = [firstLine];
         Object.entries(headers).forEach(([key, value]) => {
             formParams.push(`${key}: ${value}`);
@@ -412,7 +412,7 @@ export class EpochTrackerWithRedemption extends EpochTracker {
 
     public async fetchAndParseAsJSON<T>(
         url: string,
-        fetchOptions: {[index: string]: any},
+        fetchOptions: { [index: string]: any; },
         fetchType: FetchType,
         addInBody: boolean = false,
         fetchReason?: string,
@@ -475,8 +475,7 @@ export function createOdspCacheAndTracker(
     persistedCacheArg: IPersistedCache,
     nonpersistentCache: INonPersistentCache,
     fileEntry: IFileEntry,
-    logger: ITelemetryLogger): ICacheAndTracker
-{
+    logger: ITelemetryLogger): ICacheAndTracker {
     const epochTracker = new EpochTrackerWithRedemption(persistedCacheArg, fileEntry, logger);
     return {
         cache: {

package/src/fetchSnapshot.ts

@@ -59,7 +59,7 @@ export async function fetchSnapshot(
     fetchFullSnapshot: boolean,
     forceAccessTokenViaAuthorizationHeader: boolean,
     logger: ITelemetryLogger,
-    snapshotDownloader: (url: string, fetchOptions: {[index: string]: any}) => Promise<IOdspResponse<unknown>>,
+    snapshotDownloader: (url: string, fetchOptions: { [index: string]: any; }) => Promise<IOdspResponse<unknown>>,
 ): Promise<ISnapshotContents> {
     const path = `/trees/${versionId}`;
     let queryParams: ISnapshotOptions = {};
@@ -104,7 +104,7 @@ export async function fetchSnapshotWithRedeem(
 ): Promise<ISnapshotContents> {
     // back-compat: This block to be removed with #8784 when we only consume/consider odsp resolvers that are >= 0.51
     const sharingLinkToRedeem = (odspResolvedUrl as any).sharingLinkToRedeem;
-    if(sharingLinkToRedeem) {
+    if (sharingLinkToRedeem) {
         odspResolvedUrl.shareLinkInfo = { ...odspResolvedUrl.shareLinkInfo, sharingLinkToRedeem };
     }
 
@@ -323,7 +323,7 @@ async function fetchLatestSnapshotCore(
                     encodedBlobsSize,
                     sequenceNumber,
                     ops: snapshot.ops?.length ?? 0,
-                    nonSysOps:  snapshot.ops?.filter((op) => !isSystemMessage(op)).length ?? 0,
+                    nonSysOps: snapshot.ops?.filter((op) => !isSystemMessage(op)).length ?? 0,
                     headers: Object.keys(response.requestHeaders).length !== 0 ? true : undefined,
                     // Interval between the first fetch until the last byte of the last redirect.
                     redirectTime,
@@ -366,16 +366,16 @@ async function fetchLatestSnapshotCore(
 }
 
 interface ISnapshotRequestAndResponseOptions {
-    odspSnapshotResponse: IOdspResponse<ISnapshotContents>,
-    requestUrl: string,
-    requestHeaders: {[index: string]: any},
+    odspSnapshotResponse: IOdspResponse<ISnapshotContents>;
+    requestUrl: string;
+    requestHeaders: { [index: string]: any; };
 }
 
 function getFormBodyAndHeaders(
     odspResolvedUrl: IOdspResolvedUrl,
     storageToken: string,
     snapshotOptions: ISnapshotOptions | undefined,
-    headers?: {[index: string]: string},
+    headers?: { [index: string]: string; },
 ) {
     const formBoundary = uuid();
     const formParams: string[] = [];
@@ -402,7 +402,7 @@ function getFormBodyAndHeaders(
     formParams.push(`_post: 1`);
     formParams.push(`\r\n--${formBoundary}--`);
     const postBody = formParams.join("\r\n");
-    const header: {[index: string]: any} = {
+    const header: { [index: string]: any; } = {
         "Content-Type": `multipart/form-data;boundary=${formBoundary}`,
     };
     return { body: postBody, headers: header };
@@ -453,7 +453,7 @@ export async function downloadSnapshot(
 ): Promise<ISnapshotRequestAndResponseOptions> {
     // back-compat: This block to be removed with #8784 when we only consume/consider odsp resolvers that are >= 0.51
     const sharingLinkToRedeem = (odspResolvedUrl as any).sharingLinkToRedeem;
-    if(sharingLinkToRedeem) {
+    if (sharingLinkToRedeem) {
         odspResolvedUrl.shareLinkInfo = { ...odspResolvedUrl.shareLinkInfo, sharingLinkToRedeem };
     }
 
@@ -463,7 +463,7 @@ export async function downloadSnapshot(
     // 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 header = { prefer: "manualredirect" };
     const { body, headers } = getFormBodyAndHeaders(
         odspResolvedUrl, storageToken, snapshotOptions, header);
     const fetchOptions = {

package/src/getFileLink.ts

@@ -94,7 +94,7 @@ async function getFileLinkCore(
     // ODSP link requires extra call to return link that is resistant to file being renamed or moved to different folder
     return PerformanceEvent.timedExecAsync(
         logger,
-        { eventName: "odspFileLink", requestName: "getSharingInformation" },
+        { eventName: "odspFileLink", requestName: "getSharingLink" },
         async (event) => {
             let attempts = 0;
             let additionalProps;
@@ -106,13 +106,13 @@ async function getFileLinkCore(
                     getToken,
                     true /* throwOnNullToken */,
                 );
-                const storageToken = await storageTokenFetcher(options,"GetFileLinkCore");
+                const storageToken = await storageTokenFetcher(options, "GetFileLinkCore");
                 assert(storageToken !== null,
                     0x2bb /* "Instrumented token fetcher with throwOnNullToken = true should never return null" */);
 
                 const { url, headers } = getUrlAndHeadersWithAuth(
-                    `${odspUrlParts.siteUrl}/_api/web/GetFileByUrl(@a1)/ListItemAllFields/GetSharingInformation?@a1=${
-                        encodeURIComponent(`'${fileItem.webDavUrl}'`)
+                    `${odspUrlParts.siteUrl}/_api/web/GetFileByServerRelativeUrl(@a1)/Linkingurl?@a1=${
+                        encodeURIComponent(`'${new URL(fileItem.webDavUrl).pathname}'`)
                     }`,
                     storageToken,
                     false,
@@ -129,15 +129,15 @@ async function getFileLinkCore(
                 additionalProps = response.propsToLog;
 
                 const sharingInfo = await response.content.json();
-                const directUrl = sharingInfo?.d?.directUrl;
-                if (typeof directUrl !== "string") {
+                const linkingUrl = sharingInfo?.d?.LinkingUrl;
+                if (typeof linkingUrl !== "string") {
                     // This will retry once in getWithRetryForTokenRefresh
                     throw new NonRetryableError(
-                        "Malformed GetSharingInformation response",
+                        "Malformed GetSharingLink response",
                         DriverErrorType.incorrectServerResponse,
                         { driverVersion });
                 }
-                return directUrl;
+                return linkingUrl;
             });
             event.end({ ...additionalProps, attempts });
             return fileLink;
@@ -174,14 +174,14 @@ async function getFileItemLite(
             let additionalProps;
             const fileItem = await getWithRetryForTokenRefresh(async (options) => {
                 attempts++;
-                const {siteUrl, driveId, itemId} = odspUrlParts;
+                const { siteUrl, driveId, itemId } = odspUrlParts;
                 const storageTokenFetcher = toInstrumentedOdspTokenFetcher(
                     logger,
                     odspUrlParts,
                     getToken,
                     true /* throwOnNullToken */,
                 );
-                const storageToken = await storageTokenFetcher(options,"GetFileItemLite");
+                const storageToken = await storageTokenFetcher(options, "GetFileItemLite");
                 assert(storageToken !== null,
                     0x2bc /* "Instrumented token fetcher with throwOnNullToken =true should never return null" */);
 

package/src/getQueryString.ts

@@ -8,7 +8,7 @@ import { ISnapshotOptions } from "@fluidframework/odsp-driver-definitions";
  * Generates query string from the given query parameters.
  * @param queryParams - Query parameters from which to create a query.
  */
-export function getQueryString(queryParams: { [key: string]: string | number } | ISnapshotOptions): string {
+export function getQueryString(queryParams: { [key: string]: string | number; } | ISnapshotOptions): string {
     let queryString = "";
     for (const key of Object.keys(queryParams)) {
         if (queryParams[key] !== undefined) {

package/src/getUrlAndHeadersWithAuth.ts

@@ -7,7 +7,7 @@ export function getUrlAndHeadersWithAuth(
     url: string,
     token: string | null,
     forceAccessTokenViaAuthorizationHeader: boolean,
-): { url: string, headers: { [index: string]: string } } {
+): { url: string; headers: { [index: string]: string; }; } {
     if (!token || token.length === 0) {
         return { url, headers: {} };
     }

package/src/odspCache.ts

@@ -100,7 +100,7 @@ export interface INonPersistentCache {
      * Cache of joined/joining session info
      */
     readonly sessionJoinCache: PromiseCache<string,
-        { entryTime: number, joinSessionResponse: ISocketStorageDiscovery }>;
+        { entryTime: number; joinSessionResponse: ISocketStorageDiscovery; }>;
 
     /**
      * Cache of resolved/resolving file URLs
@@ -120,7 +120,7 @@ export interface IOdspCache extends INonPersistentCache {
 
 export class NonPersistentCache implements INonPersistentCache {
     public readonly sessionJoinCache =
-        new PromiseCache<string, { entryTime: number, joinSessionResponse: ISocketStorageDiscovery }>();
+        new PromiseCache<string, { entryTime: number; joinSessionResponse: ISocketStorageDiscovery; }>();
 
     public readonly fileUrlCache = new PromiseCache<string, IOdspResolvedUrl>();
 }

package/src/odspDeltaStorageService.ts

@@ -56,7 +56,7 @@ export class OdspDeltaStorageService {
 
             postBody += `_post: 1\r\n`;
             postBody += `\r\n--${formBoundary}--`;
-            const headers: {[index: string]: any} = {
+            const headers: { [index: string]: any; } = {
                 "Content-Type": `multipart/form-data;boundary=${formBoundary}`,
             };
 
@@ -139,11 +139,11 @@ export class OdspDeltaStorageWithCache implements IDocumentDeltaStorageService {
             const length = messages.length;
             const last = messages[length - 1].sequenceNumber;
             if (start !== from) {
-                this.logger.sendErrorEvent({ eventName: "OpsFetchViolation", reason, from, start, last, length});
+                this.logger.sendErrorEvent({ eventName: "OpsFetchViolation", reason, from, start, last, length });
                 messages.length = 0;
             }
             if (last + 1 !== from + length) {
-                this.logger.sendErrorEvent({ eventName: "OpsFetchViolation", reason, from, start, last, length});
+                this.logger.sendErrorEvent({ eventName: "OpsFetchViolation", reason, from, start, last, length });
                 // we can do better here by finding consecutive sub-block and return it
                 messages.length = 0;
             }
@@ -155,8 +155,7 @@ export class OdspDeltaStorageWithCache implements IDocumentDeltaStorageService {
         toTotal: number | undefined,
         abortSignal?: AbortSignal,
         cachedOnly?: boolean,
-        fetchReason?: string)
-    {
+        fetchReason?: string) {
         // We do not control what's in the cache. Current API assumes that fetchMessages() keeps banging on
         // storage / cache until it gets ops it needs. This would result in deadlock if fixed range is asked from
         // cache and it's not there.

package/src/odspDocumentDeltaConnection.ts

@@ -58,7 +58,7 @@ class SocketReference extends TypedEventEmitter<ISocketEvents> {
         const socketReference = SocketReference.socketIoSockets.get(key);
 
         // Verify the socket is healthy before reusing it
-        if (socketReference && socketReference.disconnected) {
+        if (socketReference?.disconnected) {
             // The socket is in a bad state. fully remove the reference
             socketReference.closeSocket();
             return undefined;
@@ -279,7 +279,7 @@ export class OdspDocumentDeltaConnection extends DocumentDeltaConnection {
 
     private readonly requestOpsNoncePrefix: string;
     private pushCallCounter = 0;
-    private readonly getOpsMap: Map<string, { start: number, from: number, to: number }> = new Map();
+    private readonly getOpsMap: Map<string, { start: number; from: number; to: number; }> = new Map();
     private flushOpNonce: string | undefined;
     private flushDeferred: Deferred<FlushResult> | undefined;
 

package/src/odspDocumentService.ts

@@ -237,7 +237,7 @@ export class OdspDocumentService implements IDocumentService {
         return normalizeError(error, { props: {
             failedConnectionStep,
             separateTokenRequest,
-        }});
+        } });
     }
 
     /**
@@ -309,7 +309,7 @@ export class OdspDocumentService implements IDocumentService {
                     "createDeltaConnection",
                     !requestWebsocketTokenFromJoinSession);
                 if (typeof error === "object" && error !== null) {
-                    normalizedError.addTelemetryProperties({socketDocumentId: websocketEndpoint.id});
+                    normalizedError.addTelemetryProperties({ socketDocumentId: websocketEndpoint.id });
                 }
                 throw normalizedError;
             }
@@ -351,7 +351,7 @@ export class OdspDocumentService implements IDocumentService {
                             // This document can only be opened in storage-only mode.
                             // DeltaManager will recognize this error
                             // and load without a delta stream connection.
-                            this._policies = {...this._policies,storageOnly: true};
+                            this._policies = { ...this._policies, storageOnly: true };
                             throw new DeltaStreamConnectionForbiddenError(code, { driverVersion });
                         default:
                             continue;
@@ -515,9 +515,9 @@ export class OdspDocumentService implements IDocumentService {
             // ICache
             {
                 write: async (key: string, opsData: string) => {
-                    return this.cache.persistedCache.put({...opsKey, key}, opsData);
+                    return this.cache.persistedCache.put({ ...opsKey, key }, opsData);
                 },
-                read: async (key: string) => this.cache.persistedCache.get({...opsKey, key}),
+                read: async (key: string) => this.cache.persistedCache.get({ ...opsKey, key }),
                 remove: () => { this.cache.persistedCache.removeEntries().catch(() => {}); },
             },
             batchSize,

package/src/odspDocumentServiceFactoryCore.ts

@@ -14,7 +14,10 @@ import {
     TelemetryLogger,
     PerformanceEvent,
 } from "@fluidframework/telemetry-utils";
-import { ensureFluidResolvedUrl } from "@fluidframework/driver-utils";
+import {
+    getDocAttributesFromProtocolSummary,
+    ensureFluidResolvedUrl,
+} from "@fluidframework/driver-utils";
 import {
     TokenFetchOptions,
     OdspResourceTokenFetchOptions,
@@ -72,6 +75,15 @@ export class OdspDocumentServiceFactoryCore implements IDocumentServiceFactory {
         if (filePath === undefined || filePath === null) {
             throw new Error("File path should be provided!!");
         }
+
+        const protocolSummary = createNewSummary?.tree[".protocol"];
+        if (protocolSummary) {
+            const documentAttributes = getDocAttributesFromProtocolSummary(protocolSummary as ISummaryTree);
+            if (documentAttributes?.sequenceNumber !== 0) {
+                throw new Error("Seq number in detached ODSP container should be 0");
+            }
+        }
+
         const newFileInfo: INewFileInfo = {
             driveId: odspResolvedUrl.driveId,
             siteUrl: odspResolvedUrl.siteUrl,

package/src/odspDocumentStorageManager.ts

@@ -45,10 +45,12 @@ import { OdspSummaryUploadManager } from "./odspSummaryUploadManager";
 import { FlushResult } from "./odspDocumentDeltaConnection";
 import { pkgVersion as driverVersion } from "./packageVersion";
 
+export const defaultSummarizerCacheExpiryTimeout: number = 60 * 1000; // 60 seconds.
+
 /* eslint-disable max-len */
 
 // An implementation of Promise.race that gives you the winner of the promise race
-async function promiseRaceWithWinner<T>(promises: Promise<T>[]): Promise<{ index: number, value: T }> {
+async function promiseRaceWithWinner<T>(promises: Promise<T>[]): Promise<{ index: number; value: T; }> {
     return new Promise((resolve, reject) => {
         promises.forEach((p, index) => {
             p.then((v) => resolve({ index, value: v })).catch(reject);
@@ -152,6 +154,10 @@ class BlobCache {
     }
 }
 
+interface GetVersionsTelemetryProps {
+    cacheEntryAge?: number;
+    cacheSummarizerExpired?: boolean;
+}
 export class OdspDocumentStorageService implements IDocumentStorageService {
     readonly policies = {
         // By default, ODSP tells the container not to prefetch/cache.
@@ -401,7 +407,7 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
                 this.logger,
                 { eventName: "ObtainSnapshot" },
                 async (event: PerformanceEvent) => {
-                    const props = {};
+                    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
@@ -413,9 +419,21 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
                                     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 > defaultSummarizerCacheExpiryTimeout) {
+                                            props.cacheSummarizerExpired = true;
+                                            return undefined;
+                                        } else {
+                                            props.cacheSummarizerExpired = false;
+                                        }
+                                    }
+
                                     // Record the cache age
-                                    // eslint-disable-next-line @typescript-eslint/dot-notation
-                                    props["cacheEntryAge"] = age;
+                                    props.cacheEntryAge = age;
                                 }
 
                                 return snapshotCachedEntry;
@@ -464,8 +482,7 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
                         }
                     }
                     if (method === "network") {
-                        // eslint-disable-next-line @typescript-eslint/dot-notation
-                        props["cacheEntryAge"] = undefined;
+                        props.cacheEntryAge = undefined;
                     }
                     event.end({ ...props, method });
                     return retrievedSnapshot;
@@ -495,7 +512,7 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
         return getWithRetryForTokenRefresh(async (options) => {
             const storageToken = await this.getStorageToken(options, "GetVersions");
             const { url, headers } = getUrlAndHeadersWithAuth(
-                `${this.snapshotUrl}/versions?count=${count}`,
+                `${this.snapshotUrl}/versions?top=${count}`,
                 storageToken,
                 !!this.hostPolicy.sessionOptions?.forceAccessTokenViaAuthorizationHeader,
             );
@@ -523,17 +540,7 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
                     { driverVersion });
             }
             return versionsResponse.value.map((version) => {
-                // Parse the date from the message
-                let date: string | undefined;
-                for (const rec of version.message.split("\n")) {
-                    const index = rec.indexOf(":");
-                    if (index !== -1 && rec.substr(0, index) === "Date") {
-                        date = rec.substr(index + 1).trim();
-                        break;
-                    }
-                }
                 return {
-                    date,
                     id: version.id,
                     treeId: undefined!,
                 };
@@ -727,7 +734,7 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
         if (!tree) {
             tree = await getWithRetryForTokenRefresh(async (options) => {
                 const storageToken = await this.getStorageToken(options, "ReadCommit");
-                const snapshotDownloader = async (url: string, fetchOptions: {[index: string]: any}) => {
+                const snapshotDownloader = async (url: string, fetchOptions: { [index: string]: any; }) => {
                     return this.epochTracker.fetchAndParseAsJSON(
                         url,
                         fetchOptions,

package/src/odspDriverUrlResolver.ts

@@ -66,7 +66,7 @@ export class OdspDriverUrlResolver implements IUrlResolver {
     constructor() { }
 
     public async resolve(request: IRequest): Promise<IOdspResolvedUrl> {
-        if (request.headers && request.headers[DriverHeader.createNew]) {
+        if (request.headers?.[DriverHeader.createNew]) {
             const [siteURL, queryString] = request.url.split("?");
 
             const searchParams = new URLSearchParams(queryString);
@@ -82,7 +82,7 @@ export class OdspDriverUrlResolver implements IUrlResolver {
                     { driverVersion: pkgVersion });
             }
             let shareLinkInfo: ShareLinkInfoType | undefined;
-            if(createLinkType && createLinkType in ShareLinkTypes) {
+            if (createLinkType && createLinkType in ShareLinkTypes) {
                 shareLinkInfo = {
                     createLink: {
                         type: ShareLinkTypes[createLinkType],

package/src/odspDriverUrlResolverForShareLink.ts

@@ -133,7 +133,7 @@ export class OdspDriverUrlResolverForShareLink implements IUrlResolver {
             // 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 || {},
-                {sharingLinkToRedeem: this.removeNavParam(request.url)});
+                { sharingLinkToRedeem: this.removeNavParam(request.url) });
         }
         if (odspResolvedUrl.itemId) {
             // Kick start the sharing link request if we don't have it already as a performance optimization.

package/src/odspSnapshotParser.ts

@@ -16,7 +16,7 @@ import { ISnapshotContents } from "./odspUtils";
  * @returns the hierarchical tree
  */
 function buildHierarchy(flatTree: IOdspSnapshotCommit): api.ISnapshotTree {
-    const lookup: { [path: string]: 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: {}, trees: {} };
     lookup[""] = root;
@@ -64,7 +64,7 @@ export function convertOdspSnapshotToSnapsohtTreeAndBlobs(
     const val: ISnapshotContents = {
         blobs: blobsWithBufferContent,
         ops: odspSnapshot.ops?.map((op) => op.op) ?? [],
-        sequenceNumber: odspSnapshot.trees && (odspSnapshot.trees[0]).sequenceNumber,
+        sequenceNumber: odspSnapshot?.trees[0].sequenceNumber,
         snapshotTree: buildHierarchy(odspSnapshot.trees[0]),
     };
     return val;

package/src/odspUtils.ts

@@ -44,17 +44,17 @@ export const getWithRetryForTokenRefreshRepeat = "getWithRetryForTokenRefreshRep
 export const getOrigin = (url: string) => new URL(url).origin;
 
 export interface ISnapshotContents {
-    snapshotTree: ISnapshotTree,
-    blobs: Map<string, ArrayBuffer>,
-    ops: ISequencedDocumentMessage[],
-    sequenceNumber: number | undefined,
+    snapshotTree: ISnapshotTree;
+    blobs: Map<string, ArrayBuffer>;
+    ops: ISequencedDocumentMessage[];
+    sequenceNumber: number | undefined;
 }
 
 export interface IOdspResponse<T> {
     content: T;
     headers: Map<string, string>;
     propsToLog: ITelemetryProperties;
-    duration: number,
+    duration: number;
 }
 
 export interface TokenFetchOptionsEx extends TokenFetchOptions {
@@ -246,7 +246,7 @@ export const createOdspLogger = (logger?: ITelemetryBaseLogger) =>
     ChildLogger.create(
         logger,
         "OdspDriver",
-        { all :
+        { all:
             {
                 driverVersion,
             },

package/src/opsCaching.ts

@@ -47,7 +47,7 @@ export class OpsCache {
         if (remainingSlots !== 0) {
             this.batches.set(this.getBatchNumber(startingSequenceNumber), {
                 remainingSlots,
-                batchData : this.initializeNewBatchDataArray(),
+                batchData: this.initializeNewBatchDataArray(),
                 dirty: false,
             });
         }
@@ -109,7 +109,7 @@ export class OpsCache {
 
             this.totalOpsToCache--;
             if (this.totalOpsToCache === 0) {
-                this.logger.sendPerformanceEvent({ eventName: "CacheOpsLimitHit"});
+                this.logger.sendPerformanceEvent({ eventName: "CacheOpsLimitHit" });
                 this.cache.remove();
                 this.dispose();
                 break;

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/odsp-driver";
-export const pkgVersion = "0.59.2001";
+export const pkgVersion = "0.59.3000";

package/src/retryErrorsStorageAdapter.ts

@@ -31,7 +31,7 @@ export class RetryErrorsStorageAdapter implements IDocumentStorageService, IDisp
     public get policies(): IDocumentStorageServicePolicies | undefined {
         return this.internalStorageService.policies;
     }
-    public get disposed() {return this._disposed;}
+    public get disposed() { return this._disposed; }
     public dispose() {
         this._disposed = true;
     }

package/src/vroom.ts

@@ -83,7 +83,7 @@ export async function fetchJoinSession(
                 postBody += `\r\n${JSON.stringify(body)}\r\n`;
             }
             postBody += `\r\n--${formBoundary}--`;
-            const headers: {[index: string]: string} = {
+            const headers: { [index: string]: string; } = {
                 "Content-Type": `multipart/form-data;boundary=${formBoundary}`,
             };