@fluidframework/odsp-driver 2.10.0 → 2.12.0

package/src/contracts.ts

@@ -189,6 +189,13 @@ export interface ICreateFileResponse {
 	"sharing"?: any;
 	"sharingLink"?: string;
 	"sharingLinkErrorReason"?: string;
+	"name": string;
+}
+
+export interface IRenameFileResponse {
+	"@odata.context": string;
+	"id": string;
+	"name": string;
 }
 
 export interface IVersionedValueWithEpoch {

package/src/createFile/createFile.ts

@@ -13,6 +13,7 @@ import {
 	InstrumentedStorageTokenFetcher,
 	OdspErrorTypes,
 	ShareLinkInfoType,
+	type IOdspUrlParts,
 } from "@fluidframework/odsp-driver-definitions/internal";
 import {
 	ITelemetryLoggerExt,
@@ -20,15 +21,16 @@ import {
 	PerformanceEvent,
 } from "@fluidframework/telemetry-utils/internal";
 
-import { ICreateFileResponse } from "./../contracts.js";
+import { ICreateFileResponse, type IRenameFileResponse } from "./../contracts.js";
 import { ClpCompliantAppHeader } from "./../contractsPublic.js";
 import { createOdspUrl } from "./../createOdspUrl.js";
 import { EpochTracker } from "./../epochTracker.js";
 import { getHeadersWithAuth } from "./../getUrlAndHeadersWithAuth.js";
 import { OdspDriverUrlResolver } from "./../odspDriverUrlResolver.js";
-import { getApiRoot } from "./../odspUrlHelper.js";
+import { checkForKnownServerFarmType, getApiRoot } from "./../odspUrlHelper.js";
 import {
 	INewFileInfo,
+	appendNavParam,
 	buildOdspShareLinkReqParams,
 	createCacheSnapshotKey,
 	getWithRetryForTokenRefresh,
@@ -62,6 +64,7 @@ export async function createNewFluidFile(
 	forceAccessTokenViaAuthorizationHeader: boolean,
 	isClpCompliantApp?: boolean,
 	enableSingleRequestForShareLinkWithCreate?: boolean,
+	resolvedUrl?: IOdspResolvedUrl,
 ): Promise<IOdspResolvedUrl> {
 	// Check for valid filename before the request to create file is actually made.
 	if (isInvalidFileName(newFileInfo.filename)) {
@@ -74,10 +77,18 @@ export async function createNewFluidFile(
 	}
 
 	let itemId: string;
+	let pendingRename: string | undefined;
 	let summaryHandle: string = "";
 	let shareLinkInfo: ShareLinkInfoType | undefined;
 	if (createNewSummary === undefined) {
-		itemId = await createNewEmptyFluidFile(getAuthHeader, newFileInfo, logger, epochTracker);
+		const content = await createNewEmptyFluidFile(
+			getAuthHeader,
+			newFileInfo,
+			logger,
+			epochTracker,
+		);
+		itemId = content.itemId;
+		pendingRename = newFileInfo.filename;
 	} else {
 		const content = await createNewFluidFileFromSummary(
 			getAuthHeader,
@@ -102,7 +113,23 @@ export async function createNewFluidFile(
 	fileEntry.docId = odspResolvedUrl.hashedDocumentId;
 	fileEntry.resolvedUrl = odspResolvedUrl;
 
+	odspResolvedUrl.context = resolvedUrl?.context;
+	odspResolvedUrl.appName = resolvedUrl?.appName;
+	odspResolvedUrl.codeHint = resolvedUrl?.codeHint;
+
+	if (shareLinkInfo?.createLink?.link) {
+		let newWebUrl = shareLinkInfo.createLink.link.webUrl;
+		newWebUrl = appendNavParam(
+			newWebUrl,
+			odspResolvedUrl,
+			odspResolvedUrl.dataStorePath ?? "/",
+			odspResolvedUrl.codeHint?.containerPackageName,
+		);
+		shareLinkInfo.createLink.link.webUrl = newWebUrl;
+	}
+
 	odspResolvedUrl.shareLinkInfo = shareLinkInfo;
+	odspResolvedUrl.pendingRename = pendingRename;
 
 	if (createNewSummary !== undefined && createNewCaching) {
 		assert(summaryHandle !== undefined, 0x203 /* "Summary handle is undefined" */);
@@ -178,9 +205,8 @@ export async function createNewEmptyFluidFile(
 	newFileInfo: INewFileInfo,
 	logger: ITelemetryLoggerExt,
 	epochTracker: EpochTracker,
-): Promise<string> {
+): Promise<{ itemId: string; fileName: string }> {
 	const filePath = encodeFilePath(newFileInfo.filePath);
-	// add .tmp extension to empty file (host is expected to rename)
 	const encodedFilename = encodeURIComponent(`${newFileInfo.filename}.tmp`);
 	const initialUrl = `${getApiRoot(new URL(newFileInfo.siteUrl))}/drives/${
 		newFileInfo.driveId
@@ -193,10 +219,16 @@ export async function createNewEmptyFluidFile(
 			{ ...options, request: { url, method } },
 			"CreateNewFile",
 		);
+		const internalFarmType = checkForKnownServerFarmType(newFileInfo.siteUrl);
 
 		return PerformanceEvent.timedExecAsync(
 			logger,
-			{ eventName: "createNewEmptyFile" },
+			{
+				eventName: "createNewEmptyFile",
+				details: {
+					internalFarmType,
+				},
+			},
 			async (event) => {
 				const headers = getHeadersWithAuth(authHeader);
 				headers["Content-Type"] = "application/json";
@@ -228,7 +260,68 @@ export async function createNewEmptyFluidFile(
 				event.end({
 					...fetchResponse.propsToLog,
 				});
-				return content.id;
+				return { itemId: content.id, fileName: content.name };
+			},
+			{ end: true, cancel: "error" },
+		);
+	});
+}
+
+export async function renameEmptyFluidFile(
+	getAuthHeader: InstrumentedStorageTokenFetcher,
+	odspParts: IOdspUrlParts,
+	requestedFileName: string,
+	logger: ITelemetryLoggerExt,
+	epochTracker: EpochTracker,
+): Promise<IRenameFileResponse> {
+	const initialUrl = `${getApiRoot(new URL(odspParts.siteUrl))}/drives/${
+		odspParts.driveId
+	}/items/${odspParts.itemId}?@name.conflictBehavior=rename`;
+
+	return getWithRetryForTokenRefresh(async (options) => {
+		const url = initialUrl;
+		const method = "PATCH";
+		const authHeader = await getAuthHeader(
+			{ ...options, request: { url, method } },
+			"renameFile",
+		);
+
+		return PerformanceEvent.timedExecAsync(
+			logger,
+			{ eventName: "renameFile" },
+			async (event) => {
+				const headers = getHeadersWithAuth(authHeader);
+				headers["Content-Type"] = "application/json";
+
+				const fetchResponse = await runWithRetry(
+					async () =>
+						epochTracker.fetchAndParseAsJSON<IRenameFileResponse>(
+							url,
+							{
+								body: JSON.stringify({
+									name: requestedFileName,
+								}),
+								headers,
+								method: "PATCH",
+							},
+							"renameFile",
+						),
+					"renameFile",
+					logger,
+				);
+
+				const content = fetchResponse.content;
+				if (!content?.id) {
+					throw new NonRetryableError(
+						"ODSP RenameFile call returned no item ID (for empty file)",
+						OdspErrorTypes.incorrectServerResponse,
+						{ driverVersion },
+					);
+				}
+				event.end({
+					...fetchResponse.propsToLog,
+				});
+				return content;
 			},
 			{ end: true, cancel: "error" },
 		);

package/src/createFile/createNewModule.ts

@@ -3,6 +3,6 @@
  * Licensed under the MIT License.
  */
 
-export { createNewFluidFile } from "./createFile.js";
+export { createNewFluidFile, renameEmptyFluidFile } from "./createFile.js";
 export { createNewContainerOnExistingFile } from "./createNewContainerOnExistingFile.js";
 export { convertCreateNewSummaryTreeToTreeAndBlobs } from "./createNewUtils.js";

package/src/createFile/createNewUtils.ts

@@ -32,6 +32,7 @@ import {
 } from "./../contracts.js";
 import { EpochTracker, FetchType } from "./../epochTracker.js";
 import { getHeadersWithAuth } from "./../getUrlAndHeadersWithAuth.js";
+import { checkForKnownServerFarmType } from "./../odspUrlHelper.js";
 import { getWithRetryForTokenRefresh, maxUmpPostBodySize } from "./../odspUtils.js";
 import { runWithRetry } from "./../retryUtils.js";
 
@@ -222,11 +223,12 @@ export async function createNewFluidContainerCore<T>(args: {
 		fetchType,
 		validateResponseCallback,
 	} = args;
+	const internalFarmType = checkForKnownServerFarmType(initialUrl);
 
 	return getWithRetryForTokenRefresh(async (options) => {
 		return PerformanceEvent.timedExecAsync(
 			logger,
-			{ eventName: telemetryName },
+			{ eventName: telemetryName, details: { internalFarmType } },
 			async (event) => {
 				const snapshotBody = JSON.stringify(containerSnapshot);
 				let url: string;

package/src/createOdspCreateContainerRequest.ts

@@ -4,10 +4,13 @@
  */
 
 import { IRequest } from "@fluidframework/core-interfaces";
-import { DriverHeader } from "@fluidframework/driver-definitions/internal";
+import {
+	DriverHeader,
+	type IContainerPackageInfo,
+} from "@fluidframework/driver-definitions/internal";
 import { ISharingLinkKind } from "@fluidframework/odsp-driver-definitions/internal";
 
-import { buildOdspShareLinkReqParams } from "./odspUtils.js";
+import { buildOdspShareLinkReqParams, getContainerPackageName } from "./odspUtils.js";
 
 /**
  * Create the request object with url and headers for creating a new file on OneDrive Sharepoint
@@ -17,6 +20,8 @@ import { buildOdspShareLinkReqParams } from "./odspUtils.js";
  * @param fileName - name of the new file to be created
  * @param createShareLinkType - type of sharing link you would like to create for this file. ShareLinkTypes
  * will be deprecated soon, so for any new implementation please provide createShareLinkType of type ShareLink
+ * @param containerPackageInfo - container package information which will be used to extract the container package name.
+ * If not given that means that the container package does not have a name.
  * @legacy
  * @alpha
  */
@@ -26,12 +31,13 @@ export function createOdspCreateContainerRequest(
 	filePath: string,
 	fileName: string,
 	createShareLinkType?: ISharingLinkKind,
+	containerPackageInfo?: IContainerPackageInfo | undefined,
 ): IRequest {
 	const shareLinkRequestParams = buildOdspShareLinkReqParams(createShareLinkType);
 	const createNewRequest: IRequest = {
 		url: `${siteUrl}?driveId=${encodeURIComponent(driveId)}&path=${encodeURIComponent(
 			filePath,
-		)}${shareLinkRequestParams ? `&${shareLinkRequestParams}` : ""}`,
+		)}${containerPackageInfo ? `&containerPackageName=${getContainerPackageName(containerPackageInfo)}` : ""}${shareLinkRequestParams ? `&${shareLinkRequestParams}` : ""}`,
 		headers: {
 			[DriverHeader.createNew]: {
 				fileName,

package/src/epochTracker.ts

@@ -61,7 +61,8 @@ export type FetchType =
 	| "treesLatest"
 	| "uploadSummary"
 	| "push"
-	| "versions";
+	| "versions"
+	| "renameFile";
 
 /**
  * @legacy

package/src/fetchSnapshot.ts

@@ -47,6 +47,7 @@ import { EpochTracker } from "./epochTracker.js";
 import { getQueryString } from "./getQueryString.js";
 import { getHeadersWithAuth } from "./getUrlAndHeadersWithAuth.js";
 import { convertOdspSnapshotToSnapshotTreeAndBlobs } from "./odspSnapshotParser.js";
+import { checkForKnownServerFarmType } from "./odspUrlHelper.js";
 import {
 	IOdspResponse,
 	fetchAndParseAsJSONHelper,
@@ -297,6 +298,7 @@ async function fetchLatestSnapshotCore(
 	return getWithRetryForTokenRefresh(async (tokenFetchOptions) => {
 		const fetchSnapshotForLoadingGroup = isSnapshotFetchForLoadingGroup(loadingGroupIds);
 		const eventName = fetchSnapshotForLoadingGroup ? "TreesLatestForGroup" : "TreesLatest";
+		const internalFarmType = checkForKnownServerFarmType(odspResolvedUrl.siteUrl);
 
 		const perfEvent = {
 			eventName,
@@ -304,6 +306,9 @@ async function fetchLatestSnapshotCore(
 			shareLinkPresent: odspResolvedUrl.shareLinkInfo?.sharingLinkToRedeem !== undefined,
 			isSummarizer: odspResolvedUrl.summarizer,
 			redeemFallbackEnabled: enableRedeemFallback,
+			details: {
+				internalFarmType,
+			},
 		};
 		if (snapshotOptions !== undefined) {
 			for (const [key, value] of Object.entries(snapshotOptions)) {

package/src/odspDocumentDeltaConnection.ts

@@ -699,6 +699,10 @@ export class OdspDocumentDeltaConnection extends DocumentDeltaConnection {
 						);
 
 						if (filteredMsgs.length > 0) {
+							// This ternary is needed for signal-based layer compat tests to pass,
+							// specifically the layer version combination where you have an old loader and the most recent driver layer.
+							// Old loader doesn't send or receive batched signals (ISignalMessage[]),
+							// so only individual ISignalMessage's should be passed when there's one element for backcompat.
 							listener(filteredMsgs.length === 1 ? filteredMsgs[0] : filteredMsgs, documentId);
 						}
 					},

package/src/odspDocumentStorageManager.ts

@@ -43,6 +43,7 @@ import {
 	ISnapshotCachedEntry2,
 	IVersionedValueWithEpoch,
 } from "./contracts.js";
+import { useCreateNewModule } from "./createFile/index.js";
 import { EpochTracker } from "./epochTracker.js";
 import {
 	ISnapshotRequestAndResponseOptions,
@@ -769,6 +770,33 @@ export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
 			0x56e /* summary upload manager should have been initialized */,
 		);
 		const id = await this.odspSummaryUploadManager.writeSummaryTree(summary, context);
+		const { pendingRename } = this.odspResolvedUrl;
+		if (
+			pendingRename !== undefined &&
+			this.config.getBoolean("Fluid.Driver.Odsp.disablePendingRename") !== true
+		) {
+			// This is a temporary file, so we need to rename it to remove the .tmp extension
+			// This should only happen for the initial summary upload for a new file
+			assert(
+				context.ackHandle === undefined &&
+					context.proposalHandle === undefined &&
+					context.referenceSequenceNumber === 0,
+				0xa88 /* temporaryFileName should only be set for new file creation in the empty file create flow */,
+			);
+
+			const renameResponse = await useCreateNewModule(this.logger, async (m) =>
+				m.renameEmptyFluidFile(
+					this.getAuthHeader,
+					this.odspResolvedUrl,
+					pendingRename,
+					this.logger,
+					this.epochTracker,
+				),
+			);
+			this.odspResolvedUrl.pendingRename = undefined;
+			this.odspResolvedUrl.fileName = renameResponse.name;
+		}
+
 		return id;
 	}
 

package/src/odspDriverUrlResolverForShareLink.ts

@@ -27,7 +27,12 @@ import {
 	locatorQueryParamName,
 	storeLocatorInOdspUrl,
 } from "./odspFluidFileLink.js";
-import { createOdspLogger, getOdspResolvedUrl } from "./odspUtils.js";
+import {
+	appendNavParam,
+	createOdspLogger,
+	getOdspResolvedUrl,
+	getContainerPackageName,
+} from "./odspUtils.js";
 
 /**
  * Properties passed to the code responsible for fetching share link for a file.
@@ -45,10 +50,6 @@ 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.
@@ -147,6 +148,13 @@ export class OdspDriverUrlResolverForShareLink implements IUrlResolver {
 
 		const odspResolvedUrl = await new OdspDriverUrlResolver().resolve(requestToBeResolved);
 
+		odspResolvedUrl.context = await this.getContext?.(
+			odspResolvedUrl,
+			odspResolvedUrl.dataStorePath ?? "",
+		);
+
+		odspResolvedUrl.appName = this.appName;
+
 		if (isSharingLinkToRedeem) {
 			// We need to remove the nav param if set by host when setting the sharelink as otherwise the shareLinkId
 			// when redeeming the share link during the redeem fallback for trees latest call becomes greater than
@@ -240,45 +248,20 @@ export class OdspDriverUrlResolverForShareLink implements IUrlResolver {
 		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.
 		const actualDataStorePath = dataStorePath || (odspResolvedUrl.dataStorePath ?? "");
 
-		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(url, {
-			siteUrl: odspResolvedUrl.siteUrl,
-			driveId: odspResolvedUrl.driveId,
-			itemId: odspResolvedUrl.itemId,
-			dataStorePath: actualDataStorePath,
-			appName: this.appName,
-			containerPackageName,
-			fileVersion: odspResolvedUrl.fileVersion,
-			context,
-		});
+		odspResolvedUrl.context = await this.getContext?.(odspResolvedUrl, actualDataStorePath);
 
-		return url.href;
+		const containerPackageName: string | undefined =
+			getContainerPackageName(packageInfoSource) ??
+			odspResolvedUrl.codeHint?.containerPackageName;
+
+		odspResolvedUrl.appName = this.appName;
+
+		return appendNavParam(baseUrl, odspResolvedUrl, actualDataStorePath, containerPackageName);
 	}
 
 	/**

package/src/odspUrlHelper.ts

@@ -126,3 +126,21 @@ export async function getOdspUrlParts(url: URL): Promise<IOdspUrlParts | undefin
 		return { siteUrl: `${url.origin}${url.pathname}`, driveId, itemId };
 	}
 }
+
+/**
+ * Inspect the ODSP siteUrl to guess if this document is in SPDF or MSIT, to aid livesite investigations
+ * @param urlOnSite - The URL of the site or a resource on the site
+ * @returns undefined if the URL doesn't match known SPDF/MSIT patterns, "SPDF" if it's SPDF, "MSIT" if it's MSIT
+ */
+export function checkForKnownServerFarmType(urlOnSite: string): "SPDF" | "MSIT" | undefined {
+	const domain = new URL(urlOnSite).hostname.toLowerCase();
+	if (domain.endsWith(".sharepoint-df.com")) {
+		return "SPDF";
+	} else if (
+		domain === "microsoft.sharepoint.com" ||
+		domain === "microsoft-my.sharepoint.com"
+	) {
+		return "MSIT";
+	}
+	return undefined;
+}

package/src/odspUtils.ts

@@ -9,7 +9,11 @@ import {
 	ITelemetryBaseProperties,
 } from "@fluidframework/core-interfaces";
 import { assert } from "@fluidframework/core-utils/internal";
-import { IResolvedUrl, ISnapshot } from "@fluidframework/driver-definitions/internal";
+import {
+	IResolvedUrl,
+	ISnapshot,
+	IContainerPackageInfo,
+} from "@fluidframework/driver-definitions/internal";
 import {
 	type AuthorizationError,
 	NetworkErrorBasic,
@@ -51,6 +55,7 @@ import {
 } from "@fluidframework/telemetry-utils/internal";
 
 import { fetch } from "./fetch.js";
+import { storeLocatorInOdspUrl } from "./odspFluidFileLink.js";
 // eslint-disable-next-line import/no-deprecated
 import { ISnapshotContents } from "./odspPublicUtils.js";
 import { pkgVersion as driverVersion } from "./packageVersion.js";
@@ -335,7 +340,8 @@ export function getOdspResolvedUrl(resolvedUrl: IResolvedUrl): IOdspResolvedUrl
 /**
  * Type narrowing utility to determine if the provided {@link @fluidframework/driver-definitions#IResolvedUrl}
  * is an {@link @fluidframework/odsp-driver-definitions#IOdspResolvedUrl}.
- * @internal
+ * @legacy
+ * @alpha
  */
 export function isOdspResolvedUrl(resolvedUrl: IResolvedUrl): resolvedUrl is IOdspResolvedUrl {
 	return "odspResolvedUrl" in resolvedUrl && resolvedUrl.odspResolvedUrl === true;
@@ -550,3 +556,70 @@ export function useLegacyFlowWithoutGroupsForSnapshotFetch(
 ): boolean {
 	return loadingGroupIds === undefined;
 }
+
+// back-compat: GitHub #9653
+const isFluidPackage = (pkg: Record<string, unknown>): boolean =>
+	typeof pkg === "object" && typeof pkg?.name === "string" && typeof pkg?.fluid === "object";
+
+/**
+ * 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.
+ * @param containerPackageName - Name of the package to be included in the URL.
+ * @returns The provided base URL appended with odsp-specific locator information
+ */
+export function appendNavParam(
+	baseUrl: string,
+	odspResolvedUrl: IOdspResolvedUrl,
+	dataStorePath: string,
+	containerPackageName?: string,
+): string {
+	const url = new URL(baseUrl);
+
+	// If the user has passed an empty dataStorePath, then extract it from the resolved url.
+	const actualDataStorePath = dataStorePath || (odspResolvedUrl.dataStorePath ?? "");
+
+	storeLocatorInOdspUrl(url, {
+		siteUrl: odspResolvedUrl.siteUrl,
+		driveId: odspResolvedUrl.driveId,
+		itemId: odspResolvedUrl.itemId,
+		dataStorePath: actualDataStorePath,
+		appName: odspResolvedUrl.appName,
+		containerPackageName,
+		fileVersion: odspResolvedUrl.fileVersion,
+		context: odspResolvedUrl.context,
+	});
+
+	return url.href;
+}
+
+/**
+ * Returns the package name of the container package information.
+ * @param packageInfoSource - Information of the package connected to the URL
+ * @returns The package name of the container package
+ */
+export function getContainerPackageName(
+	packageInfoSource: IContainerPackageInfo | undefined,
+): string | undefined {
+	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;
+	}
+	return containerPackageName;
+}

package/src/packageVersion.ts

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