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

package/src/index.ts

@@ -4,7 +4,7 @@
  */
 
 // Constants
-export { OdcApiSiteOrigin, OdcFileSiteOrigin } from "./constants";
+export { OdcApiSiteOrigin, OdcFileSiteOrigin } from "./constants.js";
 
 export {
 	ClpCompliantAppHeader,
@@ -12,34 +12,34 @@ export {
 	ISharingLinkHeader,
 	OdspFluidDataStoreLocator,
 	SharingLinkHeader,
-} from "./contractsPublic";
+} from "./contractsPublic.js";
 
 // public utils
-export { checkUrl } from "./checkUrl";
-export { createOdspUrl } from "./createOdspUrl";
-export { getHashedDocumentId, ISnapshotContents } from "./odspPublicUtils";
-export { getApiRoot, getOdspUrlParts, isOdcOrigin, isOdcUrl, isSpoUrl } from "./odspUrlHelper";
+export { checkUrl } from "./checkUrl.js";
+export { createOdspUrl } from "./createOdspUrl.js";
+export { getHashedDocumentId, ISnapshotContents } from "./odspPublicUtils.js";
+export { getApiRoot, getOdspUrlParts, isOdcOrigin, isOdcUrl, isSpoUrl } from "./odspUrlHelper.js";
 
 // prefetch latest snapshot before container load
-export { prefetchLatestSnapshot } from "./prefetchLatestSnapshot";
+export { prefetchLatestSnapshot } from "./prefetchLatestSnapshot.js";
 
 // Factory
 export {
 	createLocalOdspDocumentServiceFactory,
 	OdspDocumentServiceFactory,
-} from "./odspDocumentServiceFactory";
-export { OdspDocumentServiceFactoryCore } from "./odspDocumentServiceFactoryCore";
-export { OdspDocumentServiceFactoryWithCodeSplit } from "./odspDocumentServiceFactoryWithCodeSplit";
+} from "./odspDocumentServiceFactory.js";
+export { OdspDocumentServiceFactoryCore } from "./odspDocumentServiceFactoryCore.js";
+export { OdspDocumentServiceFactoryWithCodeSplit } from "./odspDocumentServiceFactoryWithCodeSplit.js";
 
 // File creation
-export { createOdspCreateContainerRequest } from "./createOdspCreateContainerRequest";
+export { createOdspCreateContainerRequest } from "./createOdspCreateContainerRequest.js";
 
 // URI Resolver functionality, URI management
-export { OdspDriverUrlResolver } from "./odspDriverUrlResolver";
+export { OdspDriverUrlResolver } from "./odspDriverUrlResolver.js";
 export {
 	OdspDriverUrlResolverForShareLink,
 	ShareLinkFetcherProps,
-} from "./odspDriverUrlResolverForShareLink";
+} from "./odspDriverUrlResolverForShareLink.js";
 
 // It's used by URL resolve code, but also has some public functions
 export {
@@ -47,15 +47,23 @@ export {
 	getLocatorFromOdspUrl,
 	locatorQueryParamName,
 	storeLocatorInOdspUrl,
-} from "./odspFluidFileLink";
+} from "./odspFluidFileLink.js";
 
 export {
 	IOdspCache,
 	IPersistedFileCache,
 	INonPersistentCache,
 	IPrefetchSnapshotContents,
-} from "./odspCache";
-export { ICacheAndTracker, type EpochTracker, FetchType, FetchTypeInternal } from "./epochTracker";
-export { IOdspResponse, isOdspResolvedUrl } from "./odspUtils";
-export { SnapshotFormatSupportType } from "./fetchSnapshot";
-export { ISnapshotContentsWithProps, parseCompactSnapshotResponse } from "./compactSnapshotParser";
+} from "./odspCache.js";
+export {
+	ICacheAndTracker,
+	type EpochTracker,
+	FetchType,
+	FetchTypeInternal,
+} from "./epochTracker.js";
+export { IOdspResponse, isOdspResolvedUrl } from "./odspUtils.js";
+export { SnapshotFormatSupportType } from "./fetchSnapshot.js";
+export {
+	ISnapshotContentsWithProps,
+	parseCompactSnapshotResponse,
+} from "./compactSnapshotParser.js";

package/src/localOdspDriver/localOdspDocumentService.ts

@@ -3,23 +3,28 @@
  * Licensed under the MIT License.
  */
 
+import { TypedEventEmitter } from "@fluid-internal/client-utils";
 import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
 import {
 	IDocumentDeltaStorageService,
 	IDocumentService,
+	IDocumentServiceEvents,
 	IDocumentStorageService,
 	IResolvedUrl,
 } from "@fluidframework/driver-definitions";
 import { UsageError } from "@fluidframework/driver-utils";
 import { IOdspResolvedUrl } from "@fluidframework/odsp-driver-definitions";
 import { IClient } from "@fluidframework/protocol-definitions";
-import { LocalOdspDeltaStorageService } from "./localOdspDeltaStorageService";
-import { LocalOdspDocumentStorageService } from "./localOdspDocumentStorageManager";
+import { LocalOdspDeltaStorageService } from "./localOdspDeltaStorageService.js";
+import { LocalOdspDocumentStorageService } from "./localOdspDocumentStorageManager.js";
 
 /**
  * IDocumentService implementation that provides explicit snapshot to the document storage service.
  */
-export class LocalOdspDocumentService implements IDocumentService {
+export class LocalOdspDocumentService
+	extends TypedEventEmitter<IDocumentServiceEvents>
+	implements IDocumentService
+{
 	public policies = { storageOnly: true };
 	private storageManager?: LocalOdspDocumentStorageService;
 
@@ -27,7 +32,9 @@ export class LocalOdspDocumentService implements IDocumentService {
 		private readonly odspResolvedUrl: IOdspResolvedUrl,
 		private readonly logger: ITelemetryLoggerExt,
 		private readonly localSnapshot: Uint8Array | string,
-	) {}
+	) {
+		super();
+	}
 
 	public get resolvedUrl(): IResolvedUrl {
 		return this.odspResolvedUrl;
@@ -50,7 +57,7 @@ export class LocalOdspDocumentService implements IDocumentService {
 		throw toThrow;
 	}
 
-	public dispose(_error?: any): void {
+	public dispose(error?: unknown): void {
 		// Do nothing
 	}
 }

package/src/localOdspDriver/localOdspDocumentServiceFactory.ts

@@ -6,19 +6,21 @@
 import { IDocumentService, IResolvedUrl } from "@fluidframework/driver-definitions";
 import { UsageError } from "@fluidframework/driver-utils";
 import { ISummaryTree } from "@fluidframework/protocol-definitions";
-import { ITelemetryBaseLogger, ITelemetryLogger } from "@fluidframework/core-interfaces";
-import { createOdspLogger, getOdspResolvedUrl } from "../odspUtils";
-import { ICacheAndTracker } from "../epochTracker";
-import { OdspDocumentServiceFactoryCore } from "../odspDocumentServiceFactoryCore";
-import { LocalOdspDocumentService } from "./localOdspDocumentService";
+import { ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
+import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
+import { createOdspLogger, getOdspResolvedUrl } from "../odspUtils.js";
+import { ICacheAndTracker } from "../epochTracker.js";
+import { OdspDocumentServiceFactoryCore } from "../odspDocumentServiceFactoryCore.js";
+import { LocalOdspDocumentService } from "./localOdspDocumentService.js";
 
 /**
  * Factory for creating sharepoint document service with a provided snapshot.
- * Use if you don't want to connect to any kind of external/internal storages and want to provide
+ *
+ * @remarks Use if you don't want to connect to any kind of external/internal storages and want to provide
  * content directly.
  */
 export class LocalOdspDocumentServiceFactory extends OdspDocumentServiceFactoryCore {
-	private logger: ITelemetryLogger | undefined;
+	private readonly logger: ITelemetryLoggerExt = createOdspLogger();
 
 	constructor(private readonly localSnapshot: Uint8Array | string) {
 		super(
@@ -31,7 +33,7 @@ export class LocalOdspDocumentServiceFactory extends OdspDocumentServiceFactoryC
 		const toThrow = new UsageError(
 			`${unsupportedFuncName} is not supported by LocalOdspDocumentServiceFactory`,
 		);
-		this.logger?.sendErrorEvent({ eventName: "UnsupportedUsage" }, toThrow);
+		this.logger.sendErrorEvent({ eventName: "UnsupportedUsage" }, toThrow);
 		throw toThrow;
 	}
 
@@ -44,13 +46,13 @@ export class LocalOdspDocumentServiceFactory extends OdspDocumentServiceFactoryC
 		const toThrow = new UsageError(
 			'"createContainer" is not supported by LocalOdspDocumentServiceFactory',
 		);
-		createOdspLogger(logger).sendErrorEvent({ eventName: "UnsupportedUsage" }, toThrow);
+		this.logger.sendErrorEvent({ eventName: "UnsupportedUsage" }, toThrow);
 		throw toThrow;
 	}
 
 	protected async createDocumentServiceCore(
 		resolvedUrl: IResolvedUrl,
-		odspLogger: ITelemetryLogger,
+		odspLogger: ITelemetryLoggerExt,
 		_cacheAndTrackerArg?: ICacheAndTracker,
 		_clientIsSummarizer?: boolean,
 	): Promise<IDocumentService> {
@@ -60,7 +62,6 @@ export class LocalOdspDocumentServiceFactory extends OdspDocumentServiceFactoryC
 		if (_clientIsSummarizer) {
 			throw new UsageError('Invalid usage. "_clientIsSummarizer" should not be provided');
 		}
-		this.logger = odspLogger;
 		return new LocalOdspDocumentService(
 			getOdspResolvedUrl(resolvedUrl),
 			odspLogger,

package/src/localOdspDriver/localOdspDocumentStorageManager.ts

@@ -5,14 +5,17 @@
 
 import { assert } from "@fluidframework/core-utils";
 import { ITelemetryLoggerExt, loggerToMonitoringContext } from "@fluidframework/telemetry-utils";
-import { ISummaryContext } from "@fluidframework/driver-definitions";
+import {
+	ISnapshot,
+	ISnapshotFetchOptions,
+	ISummaryContext,
+} from "@fluidframework/driver-definitions";
 import { UsageError } from "@fluidframework/driver-utils";
 import * as api from "@fluidframework/protocol-definitions";
-import { OdspDocumentStorageServiceBase } from "../odspDocumentStorageServiceBase";
-import { ISnapshotContents } from "../odspPublicUtils";
-import { IOdspSnapshot } from "../contracts";
-import { convertOdspSnapshotToSnapshotTreeAndBlobs } from "../odspSnapshotParser";
-import { parseCompactSnapshotResponse } from "../compactSnapshotParser";
+import { OdspDocumentStorageServiceBase } from "../odspDocumentStorageServiceBase.js";
+import { IOdspSnapshot } from "../contracts.js";
+import { convertOdspSnapshotToSnapshotTreeAndBlobs } from "../odspSnapshotParser.js";
+import { parseCompactSnapshotResponse } from "../compactSnapshotParser.js";
 
 /**
  * ODSP document storage service that works on a provided snapshot for all its processing.
@@ -45,10 +48,10 @@ export class LocalOdspDocumentStorageService extends OdspDocumentStorageServiceB
 		}
 		this.calledGetVersions = true;
 
-		let snapshotContents: ISnapshotContents;
+		let snapshotContents: ISnapshot;
 
 		if (typeof this.localSnapshot === "string") {
-			const content: IOdspSnapshot = JSON.parse(this.localSnapshot);
+			const content: IOdspSnapshot = JSON.parse(this.localSnapshot) as IOdspSnapshot;
 			snapshotContents = convertOdspSnapshotToSnapshotTreeAndBlobs(content);
 		} else {
 			snapshotContents = parseCompactSnapshotResponse(this.localSnapshot, this.logger);
@@ -58,6 +61,10 @@ export class LocalOdspDocumentStorageService extends OdspDocumentStorageServiceB
 		return this.getSnapshotVersion();
 	}
 
+	public async getSnapshot(snapshotFetchOptions?: ISnapshotFetchOptions): Promise<ISnapshot> {
+		this.throwUsageError("getSnapshot");
+	}
+
 	private getSnapshotVersion(): api.IVersion[] {
 		return this.snapshotTreeId ? [{ id: this.snapshotTreeId, treeId: undefined! }] : [];
 	}

package/src/odspCache.ts

@@ -12,14 +12,18 @@ import {
 	ISocketStorageDiscovery,
 	getKeyForCacheEntry,
 } from "@fluidframework/odsp-driver-definitions";
-import { ISnapshotContents } from "./odspPublicUtils";
+import { ISnapshot } from "@fluidframework/driver-definitions";
 
 /**
  * Similar to IPersistedCache, but exposes cache interface for single file
  * @alpha
  */
 export interface IPersistedFileCache {
+	// TODO: use a stronger type
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	get(entry: IEntry): Promise<any>;
+	// TODO: use a stronger type
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	put(entry: IEntry, value: any): Promise<void>;
 	removeEntries(): Promise<void>;
 }
@@ -29,19 +33,18 @@ export interface IPersistedFileCache {
  * used if no persisted cache is provided by the host
  */
 export class LocalPersistentCache implements IPersistedCache {
-	private readonly cache = new Map<string, any>();
+	private readonly cache = new Map<string, unknown>();
 	// For every document id there will be a single expiration entry inspite of the number of cache entries.
 	private readonly docIdExpirationMap = new Map<string, ReturnType<typeof setTimeout>>();
 
 	public constructor(private readonly snapshotExpiryPolicy = 3600 * 1000) {}
 
-	async get(entry: ICacheEntry): Promise<any> {
+	async get(entry: ICacheEntry): Promise<unknown> {
 		const key = getKeyForCacheEntry(entry);
-		// eslint-disable-next-line @typescript-eslint/no-unsafe-return
 		return this.cache.get(key);
 	}
 
-	async put(entry: ICacheEntry, value: any) {
+	async put(entry: ICacheEntry, value: unknown): Promise<void> {
 		const key = getKeyForCacheEntry(entry);
 		this.cache.set(key, value);
 		this.updateExpirationEntry(entry.file.docId);
@@ -51,9 +54,9 @@ export class LocalPersistentCache implements IPersistedCache {
 		this.removeDocIdEntriesFromCache(file.docId);
 	}
 
-	private removeDocIdEntriesFromCache(docId: string) {
+	private removeDocIdEntriesFromCache(docId: string): void[] {
 		this.removeExpirationEntry(docId);
-		return Array.from(this.cache)
+		return [...this.cache]
 			.filter(([cachekey]) => {
 				const docIdFromKey = cachekey.split("_");
 				if (docIdFromKey[0] === docId) {
@@ -65,7 +68,7 @@ export class LocalPersistentCache implements IPersistedCache {
 			});
 	}
 
-	private removeExpirationEntry(docId: string) {
+	private removeExpirationEntry(docId: string): void {
 		const timeout = this.docIdExpirationMap.get(docId);
 		if (timeout !== undefined) {
 			clearTimeout(timeout);
@@ -73,7 +76,7 @@ export class LocalPersistentCache implements IPersistedCache {
 		}
 	}
 
-	private updateExpirationEntry(docId: string) {
+	private updateExpirationEntry(docId: string): void {
 		this.removeExpirationEntry(docId);
 		this.docIdExpirationMap.set(
 			docId,
@@ -84,7 +87,7 @@ export class LocalPersistentCache implements IPersistedCache {
 	}
 }
 export class PromiseCacheWithOneHourSlidingExpiry<T> extends PromiseCache<string, T> {
-	constructor(removeOnError?: (e: any) => boolean) {
+	constructor(removeOnError?: (error: unknown) => boolean) {
 		super({ expiry: { policy: "sliding", durationMs: 3600000 }, removeOnError });
 	}
 }
@@ -142,7 +145,7 @@ export class NonPersistentCache implements INonPersistentCache {
 /**
  * @alpha
  */
-export interface IPrefetchSnapshotContents extends ISnapshotContents {
+export interface IPrefetchSnapshotContents extends ISnapshot {
 	fluidEpoch: string;
 	prefetchStartTime: number;
 }

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,32 +15,37 @@ 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,
+	type IOdspError,
 } from "@fluidframework/odsp-driver-definitions";
-import { hasFacetCodes } from "@fluidframework/odsp-doclib-utils";
-import { IOdspCache } from "./odspCache";
-import { OdspDocumentDeltaConnection } from "./odspDocumentDeltaConnection";
+import { hasFacetCodes } from "@fluidframework/odsp-doclib-utils/internal";
+import { IOdspCache } from "./odspCache.js";
+import { OdspDocumentDeltaConnection } from "./odspDocumentDeltaConnection.js";
 import {
 	getJoinSessionCacheKey,
 	getWithRetryForTokenRefresh,
 	TokenFetchOptionsEx,
-} from "./odspUtils";
-import { fetchJoinSession } from "./vroom";
-import { EpochTracker } from "./epochTracker";
-import { pkgVersion as driverVersion } from "./packageVersion";
+} from "./odspUtils.js";
+import { fetchJoinSession } from "./vroom.js";
+import { EpochTracker } from "./epochTracker.js";
+import { pkgVersion as driverVersion } from "./packageVersion.js";
+import { policyLabelsUpdatesSignalType } from "./contracts.js";
 
 /**
  * This OdspDelayLoadedDeltaStream is used by OdspDocumentService.ts to delay load the delta connection
@@ -55,6 +61,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 +94,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);
@@ -99,9 +112,11 @@ export class OdspDelayLoadedDeltaStream {
 		return this._relayServiceTenantAndSessionId;
 	}
 
-	/** Annotate the given error indicating which connection step failed */
+	/**
+	 * Annotate the given error indicating which connection step failed
+	 */
 	private annotateConnectionError(
-		error: any,
+		error: unknown,
 		failedConnectionStep: string,
 		separateTokenRequest: boolean,
 	): IFluidErrorBase {
@@ -129,10 +144,11 @@ export class OdspDelayLoadedDeltaStream {
 			// websocket token or whether it is returned with joinSession response payload
 			const requestWebsocketTokenFromJoinSession = this.getWebsocketToken === undefined;
 			const websocketTokenPromise = requestWebsocketTokenFromJoinSession
-				? Promise.resolve(null)
+				? // eslint-disable-next-line unicorn/no-null
+				  Promise.resolve(null)
 				: this.getWebsocketToken!(options);
 
-			const annotateAndRethrowConnectionError = (step: string) => (error: any) => {
+			const annotateAndRethrowConnectionError = (step: string) => (error: unknown) => {
 				throw this.annotateConnectionError(
 					error,
 					step,
@@ -150,18 +166,24 @@ export class OdspDelayLoadedDeltaStream {
 				websocketTokenPromise.catch(annotateAndRethrowConnectionError("getWebsocketToken")),
 			]);
 
+			// eslint-disable-next-line unicorn/no-null
 			const finalWebsocketToken = websocketToken ?? websocketEndpoint.socketToken ?? null;
 			if (finalWebsocketToken === null) {
 				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,15 +195,19 @@ 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) => {
+				connection.once("disconnect", (error: unknown) => {
 					// Clear the join session refresh timer so that it can be restarted on reconnection.
 					this.clearJoinSessionTimer();
 					if (
 						typeof error === "object" &&
 						error !== null &&
-						error.errorType === DriverErrorType.authorizationError
+						(error as Partial<IOdspError>).errorType ===
+							OdspErrorTypes.authorizationError
 					) {
 						this.cache.sessionJoinCache.remove(this.joinSessionKey);
 					}
@@ -211,7 +237,29 @@ export class OdspDelayLoadedDeltaStream {
 		});
 	}
 
-	private clearJoinSessionTimer() {
+	private readonly signalHandler = (signalsArg: ISignalMessage | ISignalMessage[]): void => {
+		const signals = Array.isArray(signalsArg) ? signalsArg : [signalsArg];
+		for (const signal of signals) {
+			// 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 {
+					// Drop error
+				}
+				if (envelope?.contents?.type === policyLabelsUpdatesSignalType) {
+					this.emitMetaDataUpdateEvent({
+						sensitivityLabelsInfo: JSON.stringify(envelope.contents.content),
+					});
+				}
+			}
+		}
+	};
+
+	private clearJoinSessionTimer(): void {
 		if (this.joinSessionRefreshTimer !== undefined) {
 			clearTimeout(this.joinSessionRefreshTimer);
 			this.joinSessionRefreshTimer = undefined;
@@ -222,10 +270,13 @@ export class OdspDelayLoadedDeltaStream {
 		delta: number,
 		requestSocketToken: boolean,
 		clientId: string | undefined,
-	) {
+	): Promise<void> {
 		if (this.joinSessionRefreshTimer !== undefined) {
 			this.clearJoinSessionTimer();
+			// TODO: use a stronger type
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
 			const originalStackTraceLimit = (Error as any).stackTraceLimit;
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
 			(Error as any).stackTraceLimit = 50;
 			this.mc.logger.sendTelemetryEvent(
 				{
@@ -233,6 +284,7 @@ export class OdspDelayLoadedDeltaStream {
 				},
 				new Error("DuplicateJoinSessionRefresh"),
 			);
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
 			(Error as any).stackTraceLimit = originalStackTraceLimit;
 		}
 
@@ -260,7 +312,7 @@ export class OdspDelayLoadedDeltaStream {
 		options: TokenFetchOptionsEx,
 		isRefreshingJoinSession: boolean,
 		clientId?: string,
-	) {
+	): Promise<ISocketStorageDiscovery> {
 		// If this call is to refresh the join session for the current connection but we are already disconnected in
 		// the meantime or disconnected and then reconnected then do not make the call. However, we should not have
 		// come here if that is the case because timer should have been disposed, but due to race condition with the
@@ -273,7 +325,7 @@ export class OdspDelayLoadedDeltaStream {
 			this.clearJoinSessionTimer();
 			throw new NonRetryableError(
 				"JoinSessionRefreshTimerNotCancelled",
-				DriverErrorType.genericError,
+				OdspErrorTypes.genericError,
 				{
 					driverVersion,
 					details: JSON.stringify({
@@ -287,16 +339,16 @@ export class OdspDelayLoadedDeltaStream {
 			requestSocketToken,
 			options,
 			isRefreshingJoinSession,
-		).catch((e) => {
-			if (hasFacetCodes(e) && e.facetCodes !== undefined) {
-				for (const code of e.facetCodes) {
+		).catch((error) => {
+			if (hasFacetCodes(error) && error.facetCodes !== undefined) {
+				for (const code of error.facetCodes) {
 					switch (code) {
 						case "sessionForbidden":
 						case "sessionForbiddenOnPreservedFiles":
 						case "sessionForbiddenOnModerationEnabledLibrary":
 						case "sessionForbiddenOnRequireCheckout":
 						case "sessionForbiddenOnCheckoutFile":
-						case "sessionForbiddenOnInvisibleMinorVersion":
+						case "sessionForbiddenOnInvisibleMinorVersion": {
 							// This document can only be opened in storage-only mode.
 							// DeltaManager will recognize this error
 							// and load without a delta stream connection.
@@ -306,12 +358,14 @@ export class OdspDelayLoadedDeltaStream {
 								{ driverVersion },
 								code,
 							);
-						default:
+						}
+						default: {
 							continue;
+						}
 					}
 				}
 			}
-			throw e;
+			throw error;
 		});
 		this._relayServiceTenantAndSessionId = `${response.tenantId}/${response.id}`;
 		return response;
@@ -325,7 +379,10 @@ export class OdspDelayLoadedDeltaStream {
 		const disableJoinSessionRefresh = this.mc.config.getBoolean(
 			"Fluid.Driver.Odsp.disableJoinSessionRefresh",
 		);
-		const executeFetch = async () => {
+		const executeFetch = async (): Promise<{
+			entryTime: number;
+			joinSessionResponse: ISocketStorageDiscovery;
+		}> => {
 			const joinSessionResponse = await fetchJoinSession(
 				this.odspResolvedUrl,
 				"opStream/joinSession",
@@ -339,13 +396,23 @@ 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,
 			};
 		};
 
-		const getResponseAndRefreshAfterDeltaMs = async () => {
+		const getResponseAndRefreshAfterDeltaMs = async (): Promise<{
+			refreshAfterDeltaMs: number;
+			entryTime: number;
+			joinSessionResponse: ISocketStorageDiscovery;
+		}> => {
 			const _response = await this.cache.sessionJoinCache.addOrGet(
 				this.joinSessionKey,
 				executeFetch,
@@ -402,10 +469,25 @@ export class OdspDelayLoadedDeltaStream {
 		return response.joinSessionResponse;
 	}
 
+	private emitMetaDataUpdateEvent(metadata: Record<string, string>): void {
+		const label = JSON.parse(metadata.sensitivityLabelsInfo) as {
+			labels: unknown;
+			timestamp: number;
+		};
+		const time = label.timestamp;
+		assert(time > 0, 0x8e0 /* time should be positive */);
+		if (time > this.labelUpdateTimestamp) {
+			this.labelUpdateTimestamp = time;
+			this.metadataUpdateHandler({
+				sensitivityLabelsInfo: metadata.sensitivityLabelsInfo,
+			});
+		}
+	}
+
 	private calculateJoinSessionRefreshDelta(
 		responseFetchTime: number,
 		refreshSessionDurationSeconds: number,
-	) {
+	): number {
 		// 30 seconds is buffer time to refresh the session.
 		return responseFetchTime + (refreshSessionDurationSeconds * 1000 - 30000) - Date.now();
 	}
@@ -451,7 +533,7 @@ export class OdspDelayLoadedDeltaStream {
 		return connection;
 	}
 
-	public dispose(error?: any) {
+	public dispose(error?: unknown): void {
 		this.clearJoinSessionTimer();
 		this.currentConnection?.dispose();
 		this.currentConnection = undefined;