@fluidframework/fluid-static 2.101.1 → 2.102.0

package/src/treeRootDataObject.ts

@@ -31,8 +31,9 @@ import type {
 } from "@fluidframework/runtime-definitions/internal";
 import type { SharedObjectKind } from "@fluidframework/shared-object-base/internal";
 
-import { compatibilityModeRuntimeOptions } from "./compatibilityConfiguration.js";
+import { defaultRuntimeOptionsForMinVersion } from "./compatibilityConfiguration.js";
 import type {
+	// eslint-disable-next-line import-x/no-deprecated
 	CompatibilityMode,
 	IRootDataObject,
 	IStaticEntryPoint,
@@ -41,13 +42,13 @@ import type {
 	TreeContainerSchema,
 } from "./types.js";
 import {
-	compatibilityModeToMinVersionForCollab,
 	createDataObject,
 	createSharedObject,
 	isDataObjectKind,
 	isSharedObjectKind,
 	makeFluidObject,
 	parseDataObjectsFromSharedObjects,
+	resolveCompatibilityModeToMinVersionForCollab,
 } from "./utils.js";
 
 /**
@@ -135,23 +136,20 @@ class TreeContainerRuntimeFactory extends BaseContainerRuntimeFactory {
 	readonly #treeRootDataObjectFactory: TreeDataObjectFactory<TreeRootDataObject>;
 
 	public constructor(
-		compatibilityMode: CompatibilityMode,
 		treeRootDataObjectFactory: TreeDataObjectFactory<TreeRootDataObject>,
-		overrides?: Partial<{
-			runtimeOptions: Partial<IContainerRuntimeOptions>;
+		config: {
 			minVersionForCollab: MinimumVersionForCollab;
-		}>,
+			runtimeOptions?: Partial<IContainerRuntimeOptions>;
+		},
 	) {
 		super({
 			registryEntries: [treeRootDataObjectFactory.registryEntry],
 			runtimeOptions: {
-				...compatibilityModeRuntimeOptions[compatibilityMode],
-				...overrides?.runtimeOptions,
+				...defaultRuntimeOptionsForMinVersion(config.minVersionForCollab),
+				...config.runtimeOptions,
 			},
 			provideEntryPoint,
-			minVersionForCollab:
-				overrides?.minVersionForCollab ??
-				compatibilityModeToMinVersionForCollab[compatibilityMode],
+			minVersionForCollab: config.minVersionForCollab,
 		});
 		this.#treeRootDataObjectFactory = treeRootDataObjectFactory;
 	}
@@ -211,8 +209,45 @@ export function createTreeContainerRuntimeFactory(props: {
 	readonly schema: TreeContainerSchema;
 
 	/**
-	 * See {@link CompatibilityMode} and compatibilityModeRuntimeOptions for more details.
+	 * Minimum Fluid Framework version required for collaboration as a
+	 * {@link @fluidframework/runtime-definitions#MinimumVersionForCollab} SemVer string.
+	 */
+	readonly minVersionForCollaboration: MinimumVersionForCollab;
+	/**
+	 * Optional registry of data stores to pass to the DataObject factory.
+	 * If not provided, one will be created based on the schema.
 	 */
+	readonly rootDataStoreRegistry?: IFluidDataStoreRegistry;
+	/**
+	 * Optional overrides for the container runtime options.
+	 * If not provided, only the default options for the given minVersionForCollaboration will be used.
+	 */
+	readonly runtimeOptionOverrides?: Partial<IContainerRuntimeOptions>;
+}): IRuntimeFactory;
+
+/**
+ * Creates an {@link @fluidframework/aqueduct#IRuntimeFactory} which constructs containers
+ * with an entry point containing single tree-based root data object.
+ *
+ * @remarks
+ * The entry point is opaque to caller.
+ * The root data object's registry and shared objects are configured based on the provided
+ * SharedTree and optional data store registry.
+ *
+ * @deprecated Pass `minVersionForCollaboration` directly instead of using `compatibilityMode`.
+ *
+ * @legacy @beta
+ */
+export function createTreeContainerRuntimeFactory(props: {
+	/**
+	 * The schema for the container.
+	 */
+	readonly schema: TreeContainerSchema;
+
+	/**
+	 * Legacy compatibility mode for the container.
+	 */
+	// eslint-disable-next-line import-x/no-deprecated
 	readonly compatibilityMode: CompatibilityMode;
 	/**
 	 * Optional registry of data stores to pass to the DataObject factory.
@@ -225,30 +260,54 @@ export function createTreeContainerRuntimeFactory(props: {
 	 */
 	readonly runtimeOptionOverrides?: Partial<IContainerRuntimeOptions>;
 	/**
-	 * Optional override for minimum version for collab.
-	 * If not provided, the default for the given compatibilityMode will be used.
+	 * Optional override for minimum version for collaboration.
 	 * @remarks
-	 * This is useful when runtime options are overridden and change the minimum version for collab.
+	 * If not provided, the default for the given compatibilityMode will be used.
+	 * Rather than defining this, omit `compatibilityMode` and pass `minVersionForCollaboration` directly.
 	 */
 	readonly minVersionForCollabOverride?: MinimumVersionForCollab;
+}): IRuntimeFactory;
+
+// Implementation
+export function createTreeContainerRuntimeFactory(props: {
+	readonly schema: TreeContainerSchema;
+	// eslint-disable-next-line import-x/no-deprecated
+	readonly compatibilityMode?: CompatibilityMode;
+	readonly minVersionForCollaboration?: MinimumVersionForCollab;
+	readonly rootDataStoreRegistry?: IFluidDataStoreRegistry;
+	readonly runtimeOptionOverrides?: Partial<IContainerRuntimeOptions>;
+	readonly minVersionForCollabOverride?: MinimumVersionForCollab;
 }): IRuntimeFactory {
 	const {
 		compatibilityMode,
+		minVersionForCollaboration,
 		minVersionForCollabOverride,
 		rootDataStoreRegistry,
 		runtimeOptionOverrides,
 		schema,
 	} = props;
 
+	let minVersionForCollab: MinimumVersionForCollab;
+	if (minVersionForCollaboration !== undefined) {
+		minVersionForCollab = minVersionForCollaboration;
+	} else if (compatibilityMode === undefined) {
+		throw new Error(
+			"Either minVersionForCollaboration or compatibilityMode (deprecated) must be provided.",
+		);
+	} else {
+		minVersionForCollab =
+			minVersionForCollabOverride ??
+			resolveCompatibilityModeToMinVersionForCollab(compatibilityMode);
+	}
+
 	const [registryEntries, sharedObjects] = parseDataObjectsFromSharedObjects(schema);
 	const registry = rootDataStoreRegistry ?? new FluidDataStoreRegistry(registryEntries);
 
 	return new TreeContainerRuntimeFactory(
-		compatibilityMode,
 		new TreeRootDataObjectFactory(sharedObjects, registry),
 		{
 			runtimeOptions: runtimeOptionOverrides,
-			minVersionForCollab: minVersionForCollabOverride,
+			minVersionForCollab,
 		},
 	);
 }

package/src/types.ts

@@ -22,6 +22,12 @@ import type { ITree } from "@fluidframework/tree";
  * In "1" mode we support full interop between 2.x clients and 1.x clients,
  * while in "2" mode we only support interop between 2.x clients.
  *
+ * @deprecated Specify the minimum Fluid Framework version directly via the
+ * `minVersionForCollab` parameter, which accepts a
+ * {@link @fluidframework/runtime-definitions#MinimumVersionForCollab} SemVer string. The
+ * legacy mode "1" is equivalent to `minVersionForCollab: "1.0.0"`; mode "2" is
+ * equivalent to `"2.0.0"`.
+ *
  * @public
  */
 export type CompatibilityMode = "1" | "2";

package/src/utils.ts

@@ -20,6 +20,7 @@ import { UsageError } from "@fluidframework/telemetry-utils/internal";
 import { SharedTreeFactoryType } from "@fluidframework/tree/internal";
 
 import type {
+	// eslint-disable-next-line import-x/no-deprecated
 	CompatibilityMode,
 	ContainerSchema,
 	LoadableObjectKind,
@@ -147,12 +148,24 @@ export function makeFluidObject<
 }
 
 /**
- * Maps CompatibilityMode to a semver valid string that can be passed to the container runtime.
+ * Resolves the `compatibilityMode` input — either a `MinimumVersionForCollab`
+ * SemVer string or a legacy `CompatibilityMode` value — into a precise
+ * `MinimumVersionForCollab`.
+ *
+ * TODO: AB#73679: This can be removed when the deprecated CompatibilityMode is removed
+ *
+ * @internal
  */
-export const compatibilityModeToMinVersionForCollab = {
-	"1": "1.0.0",
-	"2": "2.0.0",
-} as const satisfies Record<CompatibilityMode, MinimumVersionForCollab>;
+export function resolveCompatibilityModeToMinVersionForCollab(
+	// eslint-disable-next-line import-x/no-deprecated
+	compatibilityMode: MinimumVersionForCollab | CompatibilityMode,
+): MinimumVersionForCollab {
+	return compatibilityMode === "1"
+		? "1.0.0"
+		: compatibilityMode === "2"
+			? "2.0.0"
+			: compatibilityMode;
+}
 
 /**
  * Determines if the provided schema is a valid tree-based container schema.