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

package/src/odspDelayLoadedDeltaStream.ts

@@ -4,6 +4,7 @@
  */
 
 import { performance } from "@fluid-internal/client-utils";
+import { ISignalEnvelope } from "@fluidframework/core-interfaces";
 import { assert } from "@fluidframework/core-utils";
 import {
 	IFluidErrorBase,
@@ -14,20 +15,23 @@ import {
 	IDocumentDeltaConnection,
 	IResolvedUrl,
 	IDocumentServicePolicies,
-	DriverErrorType,
 } from "@fluidframework/driver-definitions";
 import {
 	DeltaStreamConnectionForbiddenError,
 	NonRetryableError,
 } from "@fluidframework/driver-utils";
-import { IClient, ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
+import {
+	IClient,
+	ISequencedDocumentMessage,
+	ISignalMessage,
+} from "@fluidframework/protocol-definitions";
 import {
 	IOdspResolvedUrl,
 	TokenFetchOptions,
 	HostStoragePolicy,
 	InstrumentedStorageTokenFetcher,
 	ISocketStorageDiscovery,
-	OdspErrorType,
+	OdspErrorTypes,
 } from "@fluidframework/odsp-driver-definitions";
 import { hasFacetCodes } from "@fluidframework/odsp-doclib-utils";
 import { IOdspCache } from "./odspCache";
@@ -40,6 +44,7 @@ import {
 import { fetchJoinSession } from "./vroom";
 import { EpochTracker } from "./epochTracker";
 import { pkgVersion as driverVersion } from "./packageVersion";
+import { policyLabelsUpdatesSignalType } from "./contracts";
 
 /**
  * This OdspDelayLoadedDeltaStream is used by OdspDocumentService.ts to delay load the delta connection
@@ -55,6 +60,12 @@ export class OdspDelayLoadedDeltaStream {
 
 	private _relayServiceTenantAndSessionId: string | undefined;
 
+	// Tracks the time at which the Policy Labels were updated the last time. This is used to resolve race conditions
+	// between label updates from the join session and the Fluid signals and they could have same or different timestamps.
+	// So this timestamp is updated with timestamp from the service/signals with the most recent timestamp. We could also
+	// receive stale data from join session as that call is made at intervals, so we need to update with only most recent data.
+	private labelUpdateTimestamp: number = -1;
+
 	/**
 	 * @param odspResolvedUrl - resolved url identifying document that will be managed by this service instance.
 	 * @param policies - Document service policies.
@@ -82,6 +93,7 @@ export class OdspDelayLoadedDeltaStream {
 		private readonly hostPolicy: HostStoragePolicy,
 		private readonly epochTracker: EpochTracker,
 		private readonly opsReceived: (ops: ISequencedDocumentMessage[]) => void,
+		private readonly metadataUpdateHandler: (metadata: Record<string, string>) => void,
 		private readonly socketReferenceKeyPrefix?: string,
 	) {
 		this.joinSessionKey = getJoinSessionCacheKey(this.odspResolvedUrl);
@@ -155,13 +167,18 @@ export class OdspDelayLoadedDeltaStream {
 				throw this.annotateConnectionError(
 					new NonRetryableError(
 						"Websocket token is null",
-						OdspErrorType.fetchTokenError,
+						OdspErrorTypes.fetchTokenError,
 						{ driverVersion },
 					),
 					"getWebsocketToken",
 					!requestWebsocketTokenFromJoinSession,
 				);
 			}
+			if (websocketEndpoint.sensitivityLabelsInfo !== undefined) {
+				this.emitMetaDataUpdateEvent({
+					sensitivityLabelsInfo: websocketEndpoint.sensitivityLabelsInfo,
+				});
+			}
 			try {
 				const connection = await this.createDeltaConnection(
 					websocketEndpoint.tenantId,
@@ -173,6 +190,9 @@ export class OdspDelayLoadedDeltaStream {
 				connection.on("op", (documentId, ops: ISequencedDocumentMessage[]) => {
 					this.opsReceived(ops);
 				});
+				connection.on("signal", this.signalHandler);
+				// Also process the initial signals
+				this.signalHandler(connection.initialSignals);
 				// On disconnect with 401/403 error code, we can just clear the joinSession cache as we will again
 				// get the auth error on reconnecting and face latency.
 				connection.once("disconnect", (error: any) => {
@@ -181,7 +201,7 @@ export class OdspDelayLoadedDeltaStream {
 					if (
 						typeof error === "object" &&
 						error !== null &&
-						error.errorType === DriverErrorType.authorizationError
+						error.errorType === OdspErrorTypes.authorizationError
 					) {
 						this.cache.sessionJoinCache.remove(this.joinSessionKey);
 					}
@@ -211,6 +231,26 @@ export class OdspDelayLoadedDeltaStream {
 		});
 	}
 
+	private readonly signalHandler = (signalsArg: ISignalMessage | ISignalMessage[]) => {
+		const signals = Array.isArray(signalsArg) ? signalsArg : [signalsArg];
+		signals.forEach((signal: ISignalMessage) => {
+			// Make sure it is not for a specific client as `PolicyLabelsUpdate` is meant for all clients.
+			if (signal.clientId === null) {
+				// We could have some issues/irregularities in parsing signals, so put it in try/catch block
+				// and ignore the error as we can have labels update later on through join session response.
+				let envelope: ISignalEnvelope | undefined;
+				try {
+					envelope = JSON.parse(signal.content as string) as ISignalEnvelope;
+				} catch (err) {}
+				if (envelope?.contents?.type === policyLabelsUpdatesSignalType) {
+					this.emitMetaDataUpdateEvent({
+						sensitivityLabelsInfo: JSON.stringify(envelope.contents.content),
+					});
+				}
+			}
+		});
+	};
+
 	private clearJoinSessionTimer() {
 		if (this.joinSessionRefreshTimer !== undefined) {
 			clearTimeout(this.joinSessionRefreshTimer);
@@ -273,7 +313,7 @@ export class OdspDelayLoadedDeltaStream {
 			this.clearJoinSessionTimer();
 			throw new NonRetryableError(
 				"JoinSessionRefreshTimerNotCancelled",
-				DriverErrorType.genericError,
+				OdspErrorTypes.genericError,
 				{
 					driverVersion,
 					details: JSON.stringify({
@@ -339,6 +379,12 @@ export class OdspDelayLoadedDeltaStream {
 				isRefreshingJoinSession,
 				this.hostPolicy.sessionOptions?.unauthenticatedUserDisplayName,
 			);
+			// Emit event only in case it is fetched from the network.
+			if (joinSessionResponse.sensitivityLabelsInfo !== undefined) {
+				this.emitMetaDataUpdateEvent({
+					sensitivityLabelsInfo: joinSessionResponse.sensitivityLabelsInfo,
+				});
+			}
 			return {
 				entryTime: Date.now(),
 				joinSessionResponse,
@@ -402,6 +448,21 @@ export class OdspDelayLoadedDeltaStream {
 		return response.joinSessionResponse;
 	}
 
+	private emitMetaDataUpdateEvent(metadata: Record<string, string>) {
+		const label = JSON.parse(metadata.sensitivityLabelsInfo) as {
+			labels: unknown;
+			timestamp: number;
+		};
+		const time = label.timestamp;
+		assert(time > 0, "time should be positive");
+		if (time > this.labelUpdateTimestamp) {
+			this.labelUpdateTimestamp = time;
+			this.metadataUpdateHandler({
+				sensitivityLabelsInfo: metadata.sensitivityLabelsInfo,
+			});
+		}
+	}
+
 	private calculateJoinSessionRefreshDelta(
 		responseFetchTime: number,
 		refreshSessionDurationSeconds: number,

package/src/odspDocumentService.ts

@@ -8,6 +8,7 @@ import {
 	createChildMonitoringContext,
 	MonitoringContext,
 } from "@fluidframework/telemetry-utils";
+import { TypedEventEmitter } from "@fluid-internal/client-utils";
 import { assert } from "@fluidframework/core-utils";
 import {
 	IDocumentDeltaConnection,
@@ -16,6 +17,7 @@ import {
 	IResolvedUrl,
 	IDocumentStorageService,
 	IDocumentServicePolicies,
+	IDocumentServiceEvents,
 } from "@fluidframework/driver-definitions";
 import { IClient, ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
 import {
@@ -40,7 +42,10 @@ import type { OdspDelayLoadedDeltaStream } from "./odspDelayLoadedDeltaStream";
  * The DocumentService manages the Socket.IO connection and manages routing requests to connected
  * clients
  */
-export class OdspDocumentService implements IDocumentService {
+export class OdspDocumentService
+	extends TypedEventEmitter<IDocumentServiceEvents>
+	implements IDocumentService
+{
 	private readonly _policies: IDocumentServicePolicies;
 
 	// Promise to load socket module only once.
@@ -123,6 +128,7 @@ export class OdspDocumentService implements IDocumentService {
 		private readonly socketReferenceKeyPrefix?: string,
 		private readonly clientIsSummarizer?: boolean,
 	) {
+		super();
 		this._policies = {
 			// load in storage-only mode if a file version is specified
 			storageOnly: odspResolvedUrl.fileVersion !== undefined,
@@ -141,6 +147,7 @@ export class OdspDocumentService implements IDocumentService {
 		});
 
 		this.hostPolicy = hostPolicy;
+		this.hostPolicy.supportGetSnapshotApi = this._policies.supportGetSnapshotApi;
 		if (this.clientIsSummarizer) {
 			this.hostPolicy = { ...this.hostPolicy, summarizerClient: true };
 		}
@@ -282,6 +289,7 @@ export class OdspDocumentService implements IDocumentService {
 			this.hostPolicy,
 			this.epochTracker,
 			(ops: ISequencedDocumentMessage[]) => this.opsReceived(ops),
+			(metadata: Record<string, string>) => this.emit("metadataUpdate", metadata),
 			this.socketReferenceKeyPrefix,
 		);
 		return this.odspDelayLoadedDeltaStream;
@@ -289,7 +297,7 @@ export class OdspDocumentService implements IDocumentService {
 
 	public dispose(error?: any) {
 		// Error might indicate mismatch between client & server knowledge about file
-		// (DriverErrorType.fileOverwrittenInStorage).
+		// (OdspErrorTypes.fileOverwrittenInStorage).
 		// For example, file might have been overwritten in storage without generating new epoch
 		// In such case client cached info is stale and has to be removed.
 		if (error !== undefined) {

package/src/odspDocumentServiceFactoryCore.ts

@@ -26,7 +26,6 @@ import {
 	IOdspUrlParts,
 	SharingLinkScope,
 	SharingLinkRole,
-	ShareLinkTypes,
 	ISharingLinkKind,
 	ISocketStorageDiscovery,
 	IRelaySessionAwareDriverFactory,
@@ -102,7 +101,7 @@ export class OdspDocumentServiceFactoryCore
 		};
 
 		let fileInfo: INewFileInfo | IExistingFileInfo;
-		let createShareLinkParam: ShareLinkTypes | ISharingLinkKind | undefined;
+		let createShareLinkParam: ISharingLinkKind | undefined;
 		if (odspResolvedUrl.itemId) {
 			fileInfo = {
 				type: "Existing",
@@ -161,7 +160,6 @@ export class OdspDocumentServiceFactoryCore
 				createShareLinkParam: createShareLinkParam
 					? JSON.stringify(createShareLinkParam)
 					: undefined,
-				enableShareLinkWithCreate: this.hostPolicy.enableShareLinkWithCreate,
 				enableSingleRequestForShareLinkWithCreate:
 					this.hostPolicy.enableSingleRequestForShareLinkWithCreate,
 			},
@@ -202,7 +200,6 @@ export class OdspDocumentServiceFactoryCore
 								?.forceAccessTokenViaAuthorizationHeader,
 							odspResolvedUrl.isClpCompliantApp,
 							this.hostPolicy.enableSingleRequestForShareLinkWithCreate,
-							this.hostPolicy.enableShareLinkWithCreate,
 					  )
 					: await module.createNewContainerOnExistingFile(
 							getStorageToken,
@@ -330,9 +327,9 @@ export class OdspDocumentServiceFactoryCore
 function getSharingLinkParams(
 	hostPolicy: HostStoragePolicy,
 	searchParams: URLSearchParams,
-): ShareLinkTypes | ISharingLinkKind | undefined {
+): ISharingLinkKind | undefined {
 	// extract request parameters for creation of sharing link (if provided) if the feature is enabled
-	let createShareLinkParam: ShareLinkTypes | ISharingLinkKind | undefined;
+	let createShareLinkParam: ISharingLinkKind | undefined;
 	if (hostPolicy.enableSingleRequestForShareLinkWithCreate) {
 		const createLinkScope = searchParams.get("createLinkScope");
 		const createLinkRole = searchParams.get("createLinkRole");
@@ -344,11 +341,6 @@ function getSharingLinkParams(
 					: {}),
 			};
 		}
-	} else if (hostPolicy.enableShareLinkWithCreate) {
-		const createLinkType = searchParams.get("createLinkType");
-		if (createLinkType && ShareLinkTypes[createLinkType]) {
-			createShareLinkParam = ShareLinkTypes[createLinkType || ""];
-		}
 	}
 	return createShareLinkParam;
 }

package/src/odspDocumentStorageManager.ts

@@ -16,12 +16,17 @@ import { assert, delay } from "@fluidframework/core-utils";
 import { LogLevel } from "@fluidframework/core-interfaces";
 import * as api from "@fluidframework/protocol-definitions";
 import { promiseRaceWithWinner } from "@fluidframework/driver-base";
-import { ISummaryContext, DriverErrorType, FetchSource } from "@fluidframework/driver-definitions";
+import {
+	ISummaryContext,
+	FetchSource,
+	ISnapshot,
+	ISnapshotFetchOptions,
+} from "@fluidframework/driver-definitions";
 import { RateLimiter, NonRetryableError } from "@fluidframework/driver-utils";
 import {
 	IOdspResolvedUrl,
 	ISnapshotOptions,
-	OdspErrorType,
+	OdspErrorTypes,
 	InstrumentedStorageTokenFetcher,
 	getKeyForCacheEntry,
 } from "@fluidframework/odsp-driver-definitions";
@@ -30,6 +35,7 @@ import {
 	HostStoragePolicyInternal,
 	IVersionedValueWithEpoch,
 	ISnapshotCachedEntry,
+	ISnapshotCachedEntry2,
 } from "./contracts";
 import {
 	downloadSnapshot,
@@ -40,8 +46,11 @@ import {
 } from "./fetchSnapshot";
 import { getUrlAndHeadersWithAuth } from "./getUrlAndHeadersWithAuth";
 import { IOdspCache, IPrefetchSnapshotContents } from "./odspCache";
-import { createCacheSnapshotKey, getWithRetryForTokenRefresh } from "./odspUtils";
-import { ISnapshotContents } from "./odspPublicUtils";
+import {
+	createCacheSnapshotKey,
+	getWithRetryForTokenRefresh,
+	isInstanceOfISnapshot,
+} from "./odspUtils";
 import { EpochTracker } from "./epochTracker";
 import type { OdspSummaryUploadManager } from "./odspSummaryUploadManager";
 import { FlushResult } from "./odspDocumentDeltaConnection";
@@ -204,6 +213,15 @@ export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
 		return super.getSnapshotTree(version, scenarioName);
 	}
 
+	public async getSnapshot(snapshotFetchOptions?: ISnapshotFetchOptions): Promise<ISnapshot> {
+		assert(this.hostPolicy.supportGetSnapshotApi !== true, "api should not be called yet");
+		// This is just temporary as this api is not yet enabled in service policies.
+		return this.fetchSnapshot(
+			this.hostPolicy.snapshotOptions,
+			snapshotFetchOptions?.scenarioName,
+		);
+	}
+
 	public async getVersions(
 		// eslint-disable-next-line @rushstack/no-new-null
 		blobid: string | null,
@@ -233,16 +251,13 @@ export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
 		// If count is one, we can use the trees/latest API, which returns the latest version and trees in a single request for better performance
 		if (count === 1 && (blobid === null || blobid === this.documentId)) {
 			const hostSnapshotOptions = this.hostPolicy.snapshotOptions;
-			const odspSnapshotCacheValue: ISnapshotContents = await PerformanceEvent.timedExecAsync(
+			const odspSnapshotCacheValue: ISnapshot = await PerformanceEvent.timedExecAsync(
 				this.logger,
 				{ eventName: "ObtainSnapshot", fetchSource },
 				async (event: PerformanceEvent) => {
 					const props: GetVersionsTelemetryProps = {};
 					let cacheLookupTimeInSerialFetch = 0;
-					let retrievedSnapshot:
-						| ISnapshotContents
-						| IPrefetchSnapshotContents
-						| undefined;
+					let retrievedSnapshot: ISnapshot | IPrefetchSnapshotContents | undefined;
 
 					let method: string;
 					let prefetchWaitStartTime: number = performance.now();
@@ -255,10 +270,14 @@ export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
 					} else {
 						// Here's the logic to grab the persistent cache snapshot implemented by the host
 						// Epoch tracker is responsible for communicating with the persistent cache, handling epochs and cache versions
-						const cachedSnapshotP: Promise<ISnapshotContents | undefined> =
-							this.epochTracker
-								.get(createCacheSnapshotKey(this.odspResolvedUrl))
-								.then(async (snapshotCachedEntry: ISnapshotCachedEntry) => {
+						const cachedSnapshotP: Promise<ISnapshot | undefined> = this.epochTracker
+							.get(createCacheSnapshotKey(this.odspResolvedUrl))
+							.then(
+								async (
+									snapshotCachedEntry:
+										| ISnapshotCachedEntry
+										| ISnapshotCachedEntry2,
+								) => {
 									if (snapshotCachedEntry !== undefined) {
 										// If the cached entry does not contain the entry time, then assign it a default of 30 days old.
 										const age =
@@ -281,10 +300,24 @@ export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
 
 										// Record the cache age
 										props.cacheEntryAge = age;
+										// Snapshot from cache could be in older format, so transform that before returning.
+										if (isInstanceOfISnapshot(snapshotCachedEntry)) {
+											return snapshotCachedEntry;
+										} else {
+											const snapshot: ISnapshot = {
+												snapshotTree: snapshotCachedEntry.snapshotTree,
+												blobContents: snapshotCachedEntry.blobs,
+												ops: snapshotCachedEntry.ops,
+												latestSequenceNumber:
+													snapshotCachedEntry.latestSequenceNumber,
+												sequenceNumber: snapshotCachedEntry.sequenceNumber,
+												snapshotFormatV: 1,
+											};
+											return snapshot;
+										}
 									}
-
-									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.
@@ -427,14 +460,14 @@ export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
 			if (!versionsResponse) {
 				throw new NonRetryableError(
 					"No response from /versions endpoint",
-					DriverErrorType.genericNetworkError,
+					OdspErrorTypes.genericNetworkError,
 					{ driverVersion },
 				);
 			}
 			if (!Array.isArray(versionsResponse.value)) {
 				throw new NonRetryableError(
 					"Incorrect response from /versions endpoint, expected an array",
-					DriverErrorType.genericNetworkError,
+					OdspErrorTypes.genericNetworkError,
 					{ driverVersion },
 				);
 			}
@@ -467,7 +500,7 @@ export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
 	private async fetchSnapshotCore(
 		hostSnapshotOptions: ISnapshotOptions | undefined,
 		scenarioName?: string,
-	): Promise<ISnapshotContents | IPrefetchSnapshotContents> {
+	): Promise<ISnapshot | IPrefetchSnapshotContents> {
 		// Don't look into cache, if the host specifically tells us so.
 		if (!this.hostPolicy.avoidPrefetchSnapshotCache) {
 			const prefetchCacheKey = getKeyForCacheEntry(
@@ -554,7 +587,7 @@ export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
 			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 === OdspErrorType.snapshotTooBig &&
+				errorType === OdspErrorTypes.snapshotTooBig &&
 				hostSnapshotOptions?.mds !== undefined &&
 				this.hostPolicy.summarizerClient !== true
 			) {
@@ -562,8 +595,8 @@ export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
 			}
 			// 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 === OdspErrorType.snapshotTooBig ||
-					errorType === OdspErrorType.fetchTimeout) &&
+				(errorType === OdspErrorTypes.snapshotTooBig ||
+					errorType === OdspErrorTypes.fetchTimeout) &&
 				snapshotOptions.blobs
 			) {
 				this.logger.sendErrorEvent({
@@ -684,7 +717,7 @@ export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
 		if (!this.snapshotUrl) {
 			throw new NonRetryableError(
 				"Method failed because no snapshot url was available",
-				DriverErrorType.genericError,
+				OdspErrorTypes.genericError,
 				{ driverVersion },
 			);
 		}
@@ -694,7 +727,7 @@ export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
 		if (!this.attachmentPOSTUrl) {
 			throw new NonRetryableError(
 				"Method failed because no attachment POST url was available",
-				DriverErrorType.genericError,
+				OdspErrorTypes.genericError,
 				{ driverVersion },
 			);
 		}
@@ -704,7 +737,7 @@ export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
 		if (!this.attachmentGETUrl) {
 			throw new NonRetryableError(
 				"Method failed because no attachment GET url was available",
-				DriverErrorType.genericError,
+				OdspErrorTypes.genericError,
 				{ driverVersion },
 			);
 		}
@@ -746,8 +779,8 @@ export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
 				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.

package/src/odspDocumentStorageServiceBase.ts

@@ -11,10 +11,11 @@ import {
 	LoaderCachingPolicy,
 	FiveDaysMs,
 	FetchSource,
+	ISnapshot,
+	ISnapshotFetchOptions,
 } from "@fluidframework/driver-definitions";
 import * as api from "@fluidframework/protocol-definitions";
 import { IConfigProvider } from "@fluidframework/telemetry-utils";
-import { ISnapshotContents } from "./odspPublicUtils";
 
 const maximumCacheDurationMs: FiveDaysMs = 432000000; // 5 * 24 * 60 * 60 * 1000 = 5 days in ms
 
@@ -208,6 +209,8 @@ export abstract class OdspDocumentStorageServiceBase implements IDocumentStorage
 		return this.combineProtocolAndAppSnapshotTree(appTree, protocolTree);
 	}
 
+	public abstract getSnapshot(snapshotFetchOptions?: ISnapshotFetchOptions): Promise<ISnapshot>;
+
 	public abstract getVersions(
 		// eslint-disable-next-line @rushstack/no-new-null
 		blobid: string | null,
@@ -267,11 +270,11 @@ export abstract class OdspDocumentStorageServiceBase implements IDocumentStorage
 	}
 
 	protected initializeFromSnapshot(
-		odspSnapshotCacheValue: ISnapshotContents,
+		odspSnapshotCacheValue: ISnapshot,
 		cacheOps: boolean = true,
 	): string | undefined {
 		this._snapshotSequenceNumber = odspSnapshotCacheValue.sequenceNumber;
-		const { snapshotTree, blobs, ops } = odspSnapshotCacheValue;
+		const { snapshotTree, blobContents, ops } = odspSnapshotCacheValue;
 
 		// id should be undefined in case of just ops in snapshot.
 		let id: string | undefined;
@@ -281,8 +284,8 @@ export abstract class OdspDocumentStorageServiceBase implements IDocumentStorage
 			this.setRootTree(id, snapshotTree);
 		}
 
-		if (blobs) {
-			this.initBlobsCache(blobs);
+		if (blobContents) {
+			this.initBlobsCache(blobContents);
 		}
 
 		if (cacheOps) {

package/src/odspDriverUrlResolver.ts

@@ -5,17 +5,12 @@
 import { assert } from "@fluidframework/core-utils";
 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 { IOdspResolvedUrl, OdspErrorTypes } from "@fluidframework/odsp-driver-definitions";
 import { NonRetryableError } from "@fluidframework/driver-utils";
 import { createOdspUrl } from "./createOdspUrl";
 import { getApiRoot } from "./odspUrlHelper";
@@ -97,23 +92,14 @@ export class OdspDriverUrlResolver implements IUrlResolver {
 			const driveID = searchParams.get("driveId");
 			const filePath = searchParams.get("path");
 			const packageName = searchParams.get("containerPackageName");
-			const createLinkType = searchParams.get("createLinkType");
 			// eslint-disable-next-line @typescript-eslint/prefer-optional-chain -- false positive
 			if (!(fileName && siteURL && driveID && filePath !== null && filePath !== undefined)) {
 				throw new NonRetryableError(
 					"Proper new file params should be there!!",
-					DriverErrorType.genericError,
+					OdspErrorTypes.genericError,
 					{ driverVersion: pkgVersion },
 				);
 			}
-			let shareLinkInfo: ShareLinkInfoType | undefined;
-			if (createLinkType && createLinkType in ShareLinkTypes) {
-				shareLinkInfo = {
-					createLink: {
-						type: ShareLinkTypes[createLinkType],
-					},
-				};
-			}
 			return {
 				endpoints: {
 					snapshotStorageUrl: "",
@@ -136,7 +122,7 @@ export class OdspDriverUrlResolver implements IUrlResolver {
 					containerPackageName: packageName ?? undefined,
 				},
 				fileVersion: undefined,
-				shareLinkInfo,
+				shareLinkInfo: undefined,
 				isClpCompliantApp: request.headers?.[ClpCompliantAppHeader.isClpCompliantApp],
 			};
 		}

package/src/odspError.ts

@@ -4,9 +4,8 @@
  */
 
 import { createOdspNetworkError } from "@fluidframework/odsp-doclib-utils";
-import { DriverErrorType } from "@fluidframework/driver-definitions";
 import { NonRetryableError } from "@fluidframework/driver-utils";
-import { OdspError } from "@fluidframework/odsp-driver-definitions";
+import { OdspError, OdspErrorTypes } from "@fluidframework/odsp-driver-definitions";
 import { getCircularReplacer, IFluidErrorBase } from "@fluidframework/telemetry-utils";
 import { IOdspSocketError } from "./contracts";
 import { pkgVersion as driverVersion } from "./packageVersion";
@@ -37,7 +36,7 @@ export function errorObjectFromSocketError(
 	} catch (error) {
 		return new NonRetryableError(
 			"Internal error: errorObjectFromSocketError",
-			DriverErrorType.fileNotFoundOrAccessDeniedError,
+			OdspErrorTypes.fileNotFoundOrAccessDeniedError,
 			{ driverVersion },
 		);
 	}

package/src/odspPublicUtils.ts

@@ -16,6 +16,7 @@ export async function getHashedDocumentId(driveId: string, itemId: string): Prom
 
 /**
  * @alpha
+ * @deprecated - This is deprecated.
  */
 export interface ISnapshotContents {
 	snapshotTree: ISnapshotTree;

package/src/odspSnapshotParser.ts

@@ -6,8 +6,8 @@
 import { stringToBuffer } from "@fluid-internal/client-utils";
 import { assert } from "@fluidframework/core-utils";
 import * as api from "@fluidframework/protocol-definitions";
+import { ISnapshot } from "@fluidframework/driver-definitions";
 import { IOdspSnapshot, IOdspSnapshotCommit } from "./contracts";
-import { ISnapshotContents } from "./odspPublicUtils";
 
 /**
  * Build a tree hierarchy base on a flat tree
@@ -51,9 +51,7 @@ function buildHierarchy(flatTree: IOdspSnapshotCommit): api.ISnapshotTree {
  * Converts existing IOdspSnapshot to snapshot tree, blob array and ops
  * @param odspSnapshot - snapshot
  */
-export function convertOdspSnapshotToSnapshotTreeAndBlobs(
-	odspSnapshot: IOdspSnapshot,
-): ISnapshotContents {
+export function convertOdspSnapshotToSnapshotTreeAndBlobs(odspSnapshot: IOdspSnapshot): ISnapshot {
 	const blobsWithBufferContent = new Map<string, ArrayBuffer>();
 	if (odspSnapshot.blobs) {
 		odspSnapshot.blobs.forEach((blob) => {
@@ -70,8 +68,8 @@ export function convertOdspSnapshotToSnapshotTreeAndBlobs(
 
 	const sequenceNumber = odspSnapshot?.trees[0].sequenceNumber;
 
-	const val: ISnapshotContents = {
-		blobs: blobsWithBufferContent,
+	const val: ISnapshot = {
+		blobContents: blobsWithBufferContent,
 		ops: odspSnapshot.ops?.map((op) => op.op) ?? [],
 		sequenceNumber,
 		snapshotTree: buildHierarchy(odspSnapshot.trees[0]),
@@ -79,6 +77,7 @@ export function convertOdspSnapshotToSnapshotTreeAndBlobs(
 			odspSnapshot.ops && odspSnapshot.ops.length > 0
 				? odspSnapshot.ops[odspSnapshot.ops.length - 1].sequenceNumber
 				: sequenceNumber,
+		snapshotFormatV: 1,
 	};
 	return val;
 }