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

package/src/odspDocumentStorageServiceBase.ts

@@ -11,12 +11,12 @@ import {
 	LoaderCachingPolicy,
 	FiveDaysMs,
 	FetchSource,
+	ISnapshot,
+	ISnapshotFetchOptions,
 } from "@fluidframework/driver-definitions";
+import { maximumCacheDurationMs } from "@fluidframework/odsp-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
 
 class BlobCache {
 	// Save the timeout so we can cancel and reschedule it as needed
@@ -42,14 +42,14 @@ class BlobCache {
 	// So for now, purging is disabled.
 	private readonly purgeEnabled = false;
 
-	public get value() {
+	public get value(): Map<string, ArrayBuffer> {
 		return this._blobCache;
 	}
 
-	public addBlobs(blobs: Map<string, ArrayBuffer>) {
-		blobs.forEach((value, blobId) => {
+	public addBlobs(blobs: Map<string, ArrayBuffer>): void {
+		for (const [blobId, value] of blobs.entries()) {
 			this._blobCache.set(blobId, value);
-		});
+		}
 		// Reset the timer on cache set
 		this.scheduleClearBlobsCache();
 	}
@@ -57,14 +57,14 @@ class BlobCache {
 	/**
 	 * Schedule a timer for clearing the blob cache or defer the current one.
 	 */
-	private scheduleClearBlobsCache() {
+	private scheduleClearBlobsCache(): void {
 		if (this.blobCacheTimeout !== undefined) {
 			// If we already have an outstanding timer, just signal that we should defer the clear
 			this.deferBlobCacheClear = true;
 		} else if (this.purgeEnabled) {
 			// If we don't have an outstanding timer, set a timer
 			// When the timer runs out, we'll decide whether to proceed with the cache clear or reset the timer
-			const clearCacheOrDefer = () => {
+			const clearCacheOrDefer = (): void => {
 				this.blobCacheTimeout = undefined;
 				if (this.deferBlobCacheClear) {
 					this.deferBlobCacheClear = false;
@@ -76,7 +76,9 @@ class BlobCache {
 					// We want to optimize both - memory footprint and number of future requests to storage.
 					// Note that Container can realize data store or DDS on-demand at any point in time, so we do not
 					// control when blobs will be used.
-					this._blobCache.forEach((_, blobId) => this.blobsEvicted.add(blobId));
+					for (const blobId of this._blobCache.keys()) {
+						this.blobsEvicted.add(blobId);
+					}
 					this._blobCache.clear();
 				}
 			};
@@ -87,7 +89,10 @@ class BlobCache {
 		}
 	}
 
-	public getBlob(blobId: string) {
+	public getBlob(blobId: string): {
+		blobContent: ArrayBuffer | undefined;
+		evicted: boolean;
+	} {
 		// Reset the timer on attempted cache read
 		this.scheduleClearBlobsCache();
 		const blobContent = this._blobCache.get(blobId);
@@ -95,7 +100,7 @@ class BlobCache {
 		return { blobContent, evicted };
 	}
 
-	public setBlob(blobId: string, blob: ArrayBuffer) {
+	public setBlob(blobId: string, blob: ArrayBuffer): Map<string, ArrayBuffer> | undefined {
 		// This API is called as result of cache miss and reading blob from storage.
 		// Runtime never reads same blob twice.
 		// The only reason we may get read request for same blob is blob de-duping in summaries.
@@ -136,8 +141,6 @@ export abstract class OdspDocumentStorageServiceBase implements IDocumentStorage
 	}
 	protected readonly commitCache: Map<string, api.ISnapshotTree> = new Map();
 
-	private readonly attributesBlobHandles: Set<string> = new Set();
-
 	private _ops: api.ISequencedDocumentMessage[] | undefined;
 
 	private _snapshotSequenceNumber: number | undefined;
@@ -153,12 +156,10 @@ export abstract class OdspDocumentStorageServiceBase implements IDocumentStorage
 		return this._ops;
 	}
 
-	public get snapshotSequenceNumber() {
+	public get snapshotSequenceNumber(): number | undefined {
 		return this._snapshotSequenceNumber;
 	}
 
-	public readonly repositoryUrl = "";
-
 	public abstract createBlob(file: ArrayBufferLike): Promise<api.ICreateBlobResponse>;
 
 	private async readBlobCore(blobId: string): Promise<ArrayBuffer> {
@@ -178,36 +179,29 @@ export abstract class OdspDocumentStorageServiceBase implements IDocumentStorage
 		// eslint-disable-next-line @rushstack/no-new-null
 	): Promise<api.ISnapshotTree | null> {
 		let id: string;
-		if (!version?.id) {
+		if (version?.id) {
+			id = version.id;
+		} else {
+			// eslint-disable-next-line unicorn/no-null
 			const versions = await this.getVersions(null, 1, scenarioName);
 			if (!versions || versions.length === 0) {
+				// eslint-disable-next-line unicorn/no-null
 				return null;
 			}
 			id = versions[0].id;
-		} else {
-			id = version.id;
 		}
 
 		const snapshotTree = await this.readTree(id, scenarioName);
 		if (!snapshotTree) {
+			// eslint-disable-next-line unicorn/no-null
 			return null;
 		}
 
-		if (snapshotTree.blobs) {
-			const attributesBlob = snapshotTree.blobs.attributes;
-			if (attributesBlob) {
-				this.attributesBlobHandles.add(attributesBlob);
-			}
-		}
-
-		// 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"];
-
-		return this.combineProtocolAndAppSnapshotTree(appTree, protocolTree);
+		return this.combineProtocolAndAppSnapshotTree(snapshotTree);
 	}
 
+	public abstract getSnapshot(snapshotFetchOptions?: ISnapshotFetchOptions): Promise<ISnapshot>;
+
 	public abstract getVersions(
 		// eslint-disable-next-line @rushstack/no-new-null
 		blobid: string | null,
@@ -225,11 +219,11 @@ export abstract class OdspDocumentStorageServiceBase implements IDocumentStorage
 		throw new Error("Not implemented yet");
 	}
 
-	protected setRootTree(id: string, tree: api.ISnapshotTree) {
+	protected setRootTree(id: string, tree: api.ISnapshotTree): void {
 		this.commitCache.set(id, tree);
 	}
 
-	protected initBlobsCache(blobs: Map<string, ArrayBuffer>) {
+	protected initBlobsCache(blobs: Map<string, ArrayBuffer>): void {
 		this.blobCache.addBlobs(blobs);
 	}
 
@@ -239,6 +233,7 @@ export abstract class OdspDocumentStorageServiceBase implements IDocumentStorage
 			tree = await this.fetchTreeFromSnapshot(id, scenarioName);
 		}
 
+		// eslint-disable-next-line unicorn/no-null
 		return tree ?? null;
 	}
 
@@ -247,42 +242,52 @@ export abstract class OdspDocumentStorageServiceBase implements IDocumentStorage
 		scenarioName?: string,
 	): Promise<api.ISnapshotTree | undefined>;
 
-	private combineProtocolAndAppSnapshotTree(
-		hierarchicalAppTree: api.ISnapshotTree,
-		hierarchicalProtocolTree: api.ISnapshotTree,
-	) {
+	protected combineProtocolAndAppSnapshotTree(
+		snapshotTree: api.ISnapshotTree,
+	): api.ISnapshotTree {
+		// 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 hierarchicalAppTree = snapshotTree.trees[".app"];
+		const hierarchicalProtocolTree = snapshotTree.trees[".protocol"];
 		const summarySnapshotTree: api.ISnapshotTree = {
 			blobs: {
 				...hierarchicalAppTree.blobs,
 			},
 			trees: {
 				...hierarchicalAppTree.trees,
-				// the app tree could have a .protocol
-				// in that case we want to server protocol to override it
-				".protocol": hierarchicalProtocolTree,
 			},
 		};
 
+		// The app tree could have a .protocol in that case we want to server protocol to override it.
+		// Snapshot which are for a loading GroupId, will not have a protocol tree.
+		if (hierarchicalProtocolTree !== undefined) {
+			summarySnapshotTree.trees[".protocol"] = hierarchicalProtocolTree;
+		}
+
 		return summarySnapshotTree;
 	}
 
 	protected initializeFromSnapshot(
-		odspSnapshotCacheValue: ISnapshotContents,
+		odspSnapshotCacheValue: ISnapshot,
 		cacheOps: boolean = true,
+		cacheSnapshot: 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;
 		if (snapshotTree) {
 			id = snapshotTree.id;
 			assert(id !== undefined, 0x221 /* "Root tree should contain the id" */);
-			this.setRootTree(id, snapshotTree);
+			if (cacheSnapshot) {
+				this.setRootTree(id, snapshotTree);
+			}
 		}
 
-		if (blobs) {
-			this.initBlobsCache(blobs);
+		// Currently always cache blobs as container runtime is not caching them.
+		if (blobContents !== undefined) {
+			this.initBlobsCache(blobContents);
 		}
 
 		if (cacheOps) {

package/src/odspDriverUrlResolver.ts

@@ -5,32 +5,37 @@
 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";
-import { getOdspResolvedUrl } from "./odspUtils";
-import { getHashedDocumentId } from "./odspPublicUtils";
-import { ClpCompliantAppHeader } from "./contractsPublic";
-import { pkgVersion } from "./packageVersion";
+import { createOdspUrl } from "./createOdspUrl.js";
+import { getApiRoot } from "./odspUrlHelper.js";
+import { getOdspResolvedUrl } from "./odspUtils.js";
+import { getHashedDocumentId } from "./odspPublicUtils.js";
+import { ClpCompliantAppHeader } from "./contractsPublic.js";
+import { pkgVersion } from "./packageVersion.js";
 
-function getUrlBase(siteUrl: string, driveId: string, itemId: string, fileVersion?: string) {
+function getUrlBase(
+	siteUrl: string,
+	driveId: string,
+	itemId: string,
+	fileVersion?: string,
+): string {
 	const siteOrigin = new URL(siteUrl).origin;
 	const version = fileVersion ? `versions/${fileVersion}/` : "";
 	return `${getApiRoot(siteOrigin)}/drives/${driveId}/items/${itemId}/${version}`;
 }
 
-function getSnapshotUrl(siteUrl: string, driveId: string, itemId: string, fileVersion?: string) {
+function getSnapshotUrl(
+	siteUrl: string,
+	driveId: string,
+	itemId: string,
+	fileVersion?: string,
+): string {
 	const urlBase = getUrlBase(siteUrl, driveId, itemId, fileVersion);
 	return `${urlBase}opStream/snapshots`;
 }
@@ -40,7 +45,7 @@ function getAttachmentPOSTUrl(
 	driveId: string,
 	itemId: string,
 	fileVersion?: string,
-) {
+): string {
 	const urlBase = getUrlBase(siteUrl, driveId, itemId, fileVersion);
 	return `${urlBase}opStream/attachment`;
 }
@@ -50,7 +55,7 @@ function getAttachmentGETUrl(
 	driveId: string,
 	itemId: string,
 	fileVersion?: string,
-) {
+): string {
 	const urlBase = getUrlBase(siteUrl, driveId, itemId, fileVersion);
 	return `${urlBase}opStream/attachments`;
 }
@@ -60,7 +65,7 @@ function getDeltaStorageUrl(
 	driveId: string,
 	itemId: string,
 	fileVersion?: string,
-) {
+): string {
 	const urlBase = getUrlBase(siteUrl, driveId, itemId, fileVersion);
 	return `${urlBase}opStream`;
 }
@@ -71,12 +76,16 @@ function getDeltaStorageUrl(
  */
 function removeBeginningSlash(str: string): string {
 	if (str.startsWith("/")) {
-		return str.substr(1);
+		return str.slice(1);
 	}
 
 	return str;
 }
 
+// back-compat: GitHub #9653
+const isFluidPackage = (pkg: Record<string, unknown>): boolean =>
+	typeof pkg === "object" && typeof pkg?.name === "string" && typeof pkg?.fluid === "object";
+
 /**
  * Resolver to resolve urls like the ones created by createOdspUrl which is driver inner
  * url format. Ex: `${siteUrl}?driveId=${driveId}&itemId=${itemId}&path=${path}`
@@ -86,34 +95,26 @@ export class OdspDriverUrlResolver implements IUrlResolver {
 	constructor() {}
 
 	/**
-	 * @alpha
+	 * {@inheritDoc @fluidframework/driver-definitions#IUrlResolver.resolve}
 	 */
 	public async resolve(request: IRequest): Promise<IOdspResolvedUrl> {
 		if (request.headers?.[DriverHeader.createNew]) {
 			const [siteURL, queryString] = request.url.split("?");
 
 			const searchParams = new URLSearchParams(queryString);
-			const fileName = request.headers[DriverHeader.createNew].fileName;
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
+			const fileName: string = request.headers[DriverHeader.createNew].fileName;
 			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,
+					"Proper new file params should be there",
+					OdspErrorTypes.genericError,
 					{ driverVersion: pkgVersion },
 				);
 			}
-			let shareLinkInfo: ShareLinkInfoType | undefined;
-			if (createLinkType && createLinkType in ShareLinkTypes) {
-				shareLinkInfo = {
-					createLink: {
-						type: ShareLinkTypes[createLinkType],
-					},
-				};
-			}
 			return {
 				endpoints: {
 					snapshotStorageUrl: "",
@@ -125,7 +126,7 @@ export class OdspDriverUrlResolver implements IUrlResolver {
 				type: "fluid",
 				odspResolvedUrl: true,
 				id: "odspCreateNew",
-				url: `fluid-odsp://${siteURL}?${queryString}&version=null`,
+				url: `https://${siteURL}?${queryString}&version=null`,
 				siteUrl: siteURL,
 				hashedDocumentId: "",
 				driveId: driveID,
@@ -136,7 +137,7 @@ export class OdspDriverUrlResolver implements IUrlResolver {
 					containerPackageName: packageName ?? undefined,
 				},
 				fileVersion: undefined,
-				shareLinkInfo,
+				shareLinkInfo: undefined,
 				isClpCompliantApp: request.headers?.[ClpCompliantAppHeader.isClpCompliantApp],
 			};
 		}
@@ -146,7 +147,7 @@ export class OdspDriverUrlResolver implements IUrlResolver {
 		const hashedDocumentId = await getHashedDocumentId(driveId, itemId);
 		assert(!hashedDocumentId.includes("/"), 0x0a8 /* "Docid should not contain slashes!!" */);
 
-		const documentUrl = `fluid-odsp://placeholder/placeholder/${hashedDocumentId}/${removeBeginningSlash(
+		const documentUrl = `https://placeholder/placeholder/${hashedDocumentId}/${removeBeginningSlash(
 			path,
 		)}`;
 
@@ -204,21 +205,20 @@ export class OdspDriverUrlResolver implements IUrlResolver {
 			dataStorePath = odspResolvedUrl.dataStorePath;
 		}
 		if (dataStorePath.startsWith("/")) {
-			dataStorePath = dataStorePath.substr(1);
+			dataStorePath = dataStorePath.slice(1);
 		}
 
-		// back-compat: GitHub #9653
-		const isFluidPackage = (pkg: any) =>
-			typeof pkg === "object" &&
-			typeof pkg?.name === "string" &&
-			typeof pkg?.fluid === "object";
-		let containerPackageName;
+		let containerPackageName: string | undefined;
 		if (packageInfoSource && "name" in packageInfoSource) {
 			containerPackageName = packageInfoSource.name;
 			// packageInfoSource is cast to any as it is typed to IContainerPackageInfo instead of IFluidCodeDetails
+			// TODO: use stronger type
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
 		} else if (isFluidPackage((packageInfoSource as any)?.package)) {
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
 			containerPackageName = (packageInfoSource as any)?.package.name;
 		} else {
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
 			containerPackageName = (packageInfoSource as any)?.package;
 		}
 		containerPackageName =

package/src/odspDriverUrlResolverForShareLink.ts

@@ -19,14 +19,13 @@ import {
 import {
 	getLocatorFromOdspUrl,
 	storeLocatorInOdspUrl,
-	encodeOdspFluidDataStoreLocator,
 	locatorQueryParamName,
-} from "./odspFluidFileLink";
-import { OdspFluidDataStoreLocator, SharingLinkHeader } from "./contractsPublic";
-import { createOdspUrl } from "./createOdspUrl";
-import { OdspDriverUrlResolver } from "./odspDriverUrlResolver";
-import { getOdspResolvedUrl, createOdspLogger } from "./odspUtils";
-import { getFileLink } from "./getFileLink";
+} from "./odspFluidFileLink.js";
+import { OdspFluidDataStoreLocator, SharingLinkHeader } from "./contractsPublic.js";
+import { createOdspUrl } from "./createOdspUrl.js";
+import { OdspDriverUrlResolver } from "./odspDriverUrlResolver.js";
+import { getOdspResolvedUrl, createOdspLogger } from "./odspUtils.js";
+import { getFileLink } from "./getFileLink.js";
 
 /**
  * Properties passed to the code responsible for fetching share link for a file.
@@ -43,6 +42,10 @@ export interface ShareLinkFetcherProps {
 	identityType: IdentityType;
 }
 
+// back-compat: GitHub #9653
+const isFluidPackage = (pkg: Record<string, unknown>): boolean =>
+	typeof pkg === "object" && typeof pkg?.name === "string" && typeof pkg?.fluid === "object";
+
 /**
  * Resolver to resolve urls like the ones created by createOdspUrl which is driver inner
  * url format and the ones which have things like driveId, siteId, itemId etc encoded in nav param.
@@ -102,9 +105,9 @@ export class OdspDriverUrlResolverForShareLink implements IUrlResolver {
 		// Determine if the caller is passing a query parameter or path since processing will be different.
 		if (pathToAppend.startsWith("/?") || pathToAppend.startsWith("?")) {
 			const queryParams = new URLSearchParams(pathToAppend);
-			queryParams.forEach((value: string, key: string) => {
+			for (const [key, value] of queryParams.entries()) {
 				parsingUrl.searchParams.append(key, value);
-			});
+			}
 			fluidInfo.dataStorePath = `${parsingUrl.pathname}${parsingUrl.search}`;
 		} else {
 			fluidInfo.dataStorePath = `${parsingUrl.pathname}${
@@ -214,34 +217,55 @@ export class OdspDriverUrlResolverForShareLink implements IUrlResolver {
 		const odspResolvedUrl = getOdspResolvedUrl(resolvedUrl);
 
 		const shareLink = await this.getShareLinkPromise(odspResolvedUrl);
-		const shareLinkUrl = new URL(shareLink);
 
-		let actualDataStorePath = dataStorePath;
+		return this.appendLocatorParams(shareLink, resolvedUrl, dataStorePath, packageInfoSource);
+	}
+
+	/**
+	 * Appends the store locator properties to the provided base URL. This function is useful for scenarios where an application
+	 * has a base URL (for example a sharing link) of the Fluid file, but does not have the locator information that would be used by Fluid
+	 * to load the file later.
+	 * @param baseUrl - The input URL on which the locator params will be appended.
+	 * @param resolvedUrl - odsp-driver's resolvedURL object.
+	 * @param dataStorePath - The relative data store path URL.
+	 * For requesting a driver URL, this value should always be '/'. If an empty string is passed, then dataStorePath
+	 * will be extracted from the resolved url if present.
+	 * @returns The provided base URL appended with odsp-specific locator information
+	 */
+	public async appendLocatorParams(
+		baseUrl: string,
+		resolvedUrl: IResolvedUrl,
+		dataStorePath: string,
+		packageInfoSource?: IContainerPackageInfo,
+	): Promise<string> {
+		const url = new URL(baseUrl);
+		const odspResolvedUrl = getOdspResolvedUrl(resolvedUrl);
+
 		// If the user has passed an empty dataStorePath, then extract it from the resolved url.
-		if (dataStorePath === "" && odspResolvedUrl.dataStorePath !== undefined) {
-			actualDataStorePath = odspResolvedUrl.dataStorePath;
-		}
+		const actualDataStorePath = dataStorePath || (odspResolvedUrl.dataStorePath ?? "");
 
-		// back-compat: GitHub #9653
-		const isFluidPackage = (pkg: any) =>
-			typeof pkg === "object" &&
-			typeof pkg?.name === "string" &&
-			typeof pkg?.fluid === "object";
-		let containerPackageName;
+		let containerPackageName: string | undefined;
 		if (packageInfoSource && "name" in packageInfoSource) {
 			containerPackageName = packageInfoSource.name;
 			// packageInfoSource is cast to any as it is typed to IContainerPackageInfo instead of IFluidCodeDetails
+			// TODO: use a stronger type
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
 		} else if (isFluidPackage((packageInfoSource as any)?.package)) {
+			// 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
 			containerPackageName = (packageInfoSource as any)?.package.name;
 		} else {
+			// 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
 			containerPackageName = (packageInfoSource as any)?.package;
 		}
+		// TODO: use a stronger type
 		containerPackageName =
 			containerPackageName ?? odspResolvedUrl.codeHint?.containerPackageName;
 
 		const context = await this.getContext?.(odspResolvedUrl, actualDataStorePath);
 
-		storeLocatorInOdspUrl(shareLinkUrl, {
+		storeLocatorInOdspUrl(url, {
 			siteUrl: odspResolvedUrl.siteUrl,
 			driveId: odspResolvedUrl.driveId,
 			itemId: odspResolvedUrl.itemId,
@@ -252,25 +276,20 @@ export class OdspDriverUrlResolverForShareLink implements IUrlResolver {
 			context,
 		});
 
-		return shareLinkUrl.href;
+		return url.href;
 	}
 
 	/**
 	 * Crafts a supported document/driver URL
 	 */
-	public static createDocumentUrl(baseUrl: string, driverInfo: OdspFluidDataStoreLocator) {
+	public static createDocumentUrl(
+		baseUrl: string,
+		driverInfo: OdspFluidDataStoreLocator,
+	): string {
 		const url = new URL(baseUrl);
 
 		storeLocatorInOdspUrl(url, driverInfo);
 
 		return url.href;
 	}
-
-	/**
-	 * Crafts a supported data store nav param
-	 * @deprecated encodeOdspFluidDataStoreLocator should be used instead
-	 */
-	public static createNavParam(locator: OdspFluidDataStoreLocator) {
-		return encodeOdspFluidDataStoreLocator(locator);
-	}
 }

package/src/odspError.ts

@@ -3,13 +3,12 @@
  * Licensed under the MIT License.
  */
 
-import { createOdspNetworkError } from "@fluidframework/odsp-doclib-utils";
-import { DriverErrorType } from "@fluidframework/driver-definitions";
+import { createOdspNetworkError } from "@fluidframework/odsp-doclib-utils/internal";
 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";
+import { IOdspSocketError } from "./contracts.js";
+import { pkgVersion as driverVersion } from "./packageVersion.js";
 
 /**
  * Returns network error based on error object from ODSP socket (IOdspSocketError)
@@ -34,10 +33,10 @@ export function errorObjectFromSocketError(
 
 		error.addTelemetryProperties({ odspError: true, relayServiceError: true });
 		return error;
-	} catch (error) {
+	} catch {
 		return new NonRetryableError(
 			"Internal error: errorObjectFromSocketError",
-			DriverErrorType.fileNotFoundOrAccessDeniedError,
+			OdspErrorTypes.fileNotFoundOrAccessDeniedError,
 			{ driverVersion },
 		);
 	}

package/src/odspFluidFileLink.ts

@@ -4,8 +4,8 @@
  */
 
 import { fromBase64ToUtf8, fromUtf8ToBase64 } from "@fluid-internal/client-utils";
-import { OdspFluidDataStoreLocator } from "./contractsPublic";
-import { OdcFileSiteOrigin, OdcApiSiteOrigin } from "./constants";
+import { OdspFluidDataStoreLocator } from "./contractsPublic.js";
+import { OdcFileSiteOrigin, OdcApiSiteOrigin } from "./constants.js";
 
 const fluidSignature = "1";
 const fluidSignatureParamName = "fluid";
@@ -122,7 +122,7 @@ export const locatorQueryParamName = "nav";
  * @param locator - object representing Fluid data store location in ODSP terms
  * @alpha
  */
-export function storeLocatorInOdspUrl(url: URL, locator: OdspFluidDataStoreLocator) {
+export function storeLocatorInOdspUrl(url: URL, locator: OdspFluidDataStoreLocator): void {
 	const encodedLocatorValue = encodeOdspFluidDataStoreLocator(locator);
 	// IMPORTANT: Do not apply encodeURIComponent to encodedLocatorValue, param value is automatically encoded
 	// when set via URLSearchParams class

package/src/odspLocationRedirection.ts

@@ -5,7 +5,7 @@
 
 import { IResolvedUrl } from "@fluidframework/driver-definitions";
 import { IOdspResolvedUrl } from "@fluidframework/odsp-driver-definitions";
-import { getOdspResolvedUrl } from "./odspUtils";
+import { getOdspResolvedUrl } from "./odspUtils.js";
 
 /**
  * It takes a resolved url with old siteUrl and creates a new resolved url with updated site url domain.

package/src/odspPublicUtils.ts

@@ -7,6 +7,9 @@ import { hashFile, IsoBuffer } from "@fluid-internal/client-utils";
 import { ISequencedDocumentMessage, ISnapshotTree } from "@fluidframework/protocol-definitions";
 
 /**
+ * Creates a unique and stable id for a document stored in ODSP which doesn't expose the driveId and itemId of
+ * said document.
+ *
  * @alpha
  */
 export async function getHashedDocumentId(driveId: string, itemId: string): Promise<string> {
@@ -16,6 +19,7 @@ export async function getHashedDocumentId(driveId: string, itemId: string): Prom
 
 /**
  * @alpha
+ * @deprecated - This is deprecated.
  */
 export interface ISnapshotContents {
 	snapshotTree: ISnapshotTree;