@fluidframework/aqueduct 2.40.0-336023 → 2.41.0-337492

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fluidframework/aqueduct",
-  "version": "2.40.0-336023",
+  "version": "2.41.0-337492",
   "description": "A set of implementations for Fluid Framework interfaces.",
   "homepage": "https://fluidframework.com",
   "repository": {
@@ -69,27 +69,27 @@
     "temp-directory": "nyc/.nyc_output"
   },
   "dependencies": {
-    "@fluid-internal/client-utils": "2.40.0-336023",
-    "@fluidframework/container-definitions": "2.40.0-336023",
-    "@fluidframework/container-runtime": "2.40.0-336023",
-    "@fluidframework/container-runtime-definitions": "2.40.0-336023",
-    "@fluidframework/core-interfaces": "2.40.0-336023",
-    "@fluidframework/core-utils": "2.40.0-336023",
-    "@fluidframework/datastore": "2.40.0-336023",
-    "@fluidframework/datastore-definitions": "2.40.0-336023",
-    "@fluidframework/map": "2.40.0-336023",
-    "@fluidframework/request-handler": "2.40.0-336023",
-    "@fluidframework/runtime-definitions": "2.40.0-336023",
-    "@fluidframework/runtime-utils": "2.40.0-336023",
-    "@fluidframework/shared-object-base": "2.40.0-336023",
-    "@fluidframework/synthesize": "2.40.0-336023",
-    "@fluidframework/telemetry-utils": "2.40.0-336023",
-    "@fluidframework/tree": "2.40.0-336023"
+    "@fluid-internal/client-utils": "2.41.0-337492",
+    "@fluidframework/container-definitions": "2.41.0-337492",
+    "@fluidframework/container-runtime": "2.41.0-337492",
+    "@fluidframework/container-runtime-definitions": "2.41.0-337492",
+    "@fluidframework/core-interfaces": "2.41.0-337492",
+    "@fluidframework/core-utils": "2.41.0-337492",
+    "@fluidframework/datastore": "2.41.0-337492",
+    "@fluidframework/datastore-definitions": "2.41.0-337492",
+    "@fluidframework/map": "2.41.0-337492",
+    "@fluidframework/request-handler": "2.41.0-337492",
+    "@fluidframework/runtime-definitions": "2.41.0-337492",
+    "@fluidframework/runtime-utils": "2.41.0-337492",
+    "@fluidframework/shared-object-base": "2.41.0-337492",
+    "@fluidframework/synthesize": "2.41.0-337492",
+    "@fluidframework/telemetry-utils": "2.41.0-337492",
+    "@fluidframework/tree": "2.41.0-337492"
   },
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.17.1",
     "@biomejs/biome": "~1.9.3",
-    "@fluid-internal/mocha-test-setup": "2.40.0-336023",
+    "@fluid-internal/mocha-test-setup": "2.41.0-337492",
     "@fluid-tools/build-cli": "^0.55.0",
     "@fluidframework/aqueduct-previous": "npm:@fluidframework/aqueduct@2.33.0",
     "@fluidframework/build-common": "^2.0.3",

package/src/container-runtime-factories/baseContainerRuntimeFactory.ts

@@ -11,6 +11,7 @@ import {
 	FluidDataStoreRegistry,
 	loadContainerRuntime,
 	type IContainerRuntimeOptions,
+	type MinimumVersionForCollab,
 } from "@fluidframework/container-runtime/internal";
 import type { IContainerRuntime } from "@fluidframework/container-runtime-definitions/internal";
 import type { FluidObject } from "@fluidframework/core-interfaces";
@@ -61,6 +62,11 @@ export interface BaseContainerRuntimeFactoryProps {
 	 * created with this factory
 	 */
 	provideEntryPoint: (runtime: IContainerRuntime) => Promise<FluidObject>;
+	/**
+	 * The minVersionForCollab passed to the ContainerRuntime when instantiating it.
+	 * See {@link @fluidframework/container-runtime#LoadContainerRuntimeParams} for more details on this property.
+	 */
+	minVersionForCollab?: MinimumVersionForCollab | undefined;
 }
 
 /**
@@ -88,6 +94,7 @@ export class BaseContainerRuntimeFactory
 	// eslint-disable-next-line import/no-deprecated
 	private readonly requestHandlers: RuntimeRequestHandler[];
 	private readonly provideEntryPoint: (runtime: IContainerRuntime) => Promise<FluidObject>;
+	private readonly minVersionForCollab: MinimumVersionForCollab | undefined;
 
 	public constructor(props: BaseContainerRuntimeFactoryProps) {
 		super();
@@ -98,6 +105,7 @@ export class BaseContainerRuntimeFactory
 		this.provideEntryPoint = props.provideEntryPoint;
 		this.requestHandlers = props.requestHandlers ?? [];
 		this.registry = new FluidDataStoreRegistry(this.registryEntries);
+		this.minVersionForCollab = props.minVersionForCollab;
 	}
 
 	/**
@@ -146,6 +154,7 @@ export class BaseContainerRuntimeFactory
 			// eslint-disable-next-line import/no-deprecated
 			requestHandler: buildRuntimeRequestHandler(...this.requestHandlers),
 			provideEntryPoint: this.provideEntryPoint,
+			minVersionForCollab: this.minVersionForCollab,
 		});
 	}
 

package/src/data-object-factories/dataObjectFactory.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { FluidDataStoreRuntime } from "@fluidframework/datastore/internal";
+import type { FluidDataStoreRuntime } from "@fluidframework/datastore/internal";
 import type { IChannelFactory } from "@fluidframework/datastore-definitions/internal";
 import {
 	SharedMap,
@@ -16,7 +16,10 @@ import type { FluidObjectSymbolProvider } from "@fluidframework/synthesize/inter
 
 import type { DataObject, DataObjectTypes, IDataObjectProps } from "../data-objects/index.js";
 
-import { PureDataObjectFactory } from "./pureDataObjectFactory.js";
+import {
+	PureDataObjectFactory,
+	type DataObjectFactoryProps,
+} from "./pureDataObjectFactory.js";
 
 /**
  * DataObjectFactory is the IFluidDataStoreFactory for use with DataObjects.
@@ -32,28 +35,55 @@ export class DataObjectFactory<
 	TObj extends DataObject<I>,
 	I extends DataObjectTypes = DataObjectTypes,
 > extends PureDataObjectFactory<TObj, I> {
+	/**
+	 * @remarks Use the props object based constructor instead.
+	 * No new features will be added to this constructor,
+	 * and it will eventually be deprecated and removed.
+	 */
 	public constructor(
 		type: string,
 		ctor: new (props: IDataObjectProps<I>) => TObj,
-		sharedObjects: readonly IChannelFactory[] = [],
-		optionalProviders: FluidObjectSymbolProvider<I["OptionalProviders"]>,
+		sharedObjects?: readonly IChannelFactory[],
+		optionalProviders?: FluidObjectSymbolProvider<I["OptionalProviders"]>,
 		registryEntries?: NamedFluidDataStoreRegistryEntries,
-		runtimeFactory: typeof FluidDataStoreRuntime = FluidDataStoreRuntime,
+		runtimeFactory?: typeof FluidDataStoreRuntime,
+	);
+	public constructor(props: DataObjectFactoryProps<TObj, I>);
+	public constructor(
+		propsOrType: DataObjectFactoryProps<TObj, I> | string,
+		maybeCtor?: new (doProps: IDataObjectProps<I>) => TObj,
+		maybeSharedObjects?: readonly IChannelFactory[],
+		maybeOptionalProviders?: FluidObjectSymbolProvider<I["OptionalProviders"]>,
+		maybeRegistryEntries?: NamedFluidDataStoreRegistryEntries,
+		maybeRuntimeFactory?: typeof FluidDataStoreRuntime,
 	) {
-		const mergedObjects = [...sharedObjects];
+		const newProps =
+			typeof propsOrType === "string"
+				? {
+						type: propsOrType,
+						// both the arg and props base constructor require this param
+						// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+						ctor: maybeCtor!,
+						sharedObjects: maybeSharedObjects,
+						optionalProviders: maybeOptionalProviders,
+						registryEntries: maybeRegistryEntries,
+						runtimeClass: maybeRuntimeFactory,
+					}
+				: { ...propsOrType };
+
+		const sharedObjects = (newProps.sharedObjects = [...(newProps.sharedObjects ?? [])]);
 
 		if (!sharedObjects.some((factory) => factory.type === DirectoryFactory.Type)) {
 			// User did not register for directory
-			// eslint-disable-next-line import/no-deprecated
-			mergedObjects.push(SharedDirectory.getFactory());
+			sharedObjects.push(SharedDirectory.getFactory());
 		}
 
 		// TODO: Remove SharedMap factory when compatibility with SharedMap DataObject is no longer needed in 0.10
 		if (!sharedObjects.some((factory) => factory.type === MapFactory.Type)) {
 			// User did not register for map
-			mergedObjects.push(SharedMap.getFactory());
+			sharedObjects.push(SharedMap.getFactory());
 		}
 
-		super(type, ctor, mergedObjects, optionalProviders, registryEntries, runtimeFactory);
+		super(newProps);
 	}
 }

package/src/data-object-factories/index.ts

@@ -4,4 +4,7 @@
  */
 
 export { DataObjectFactory } from "./dataObjectFactory.js";
-export { PureDataObjectFactory } from "./pureDataObjectFactory.js";
+export {
+	type DataObjectFactoryProps,
+	PureDataObjectFactory,
+} from "./pureDataObjectFactory.js";

package/src/data-object-factories/pureDataObjectFactory.ts

@@ -23,6 +23,7 @@ import type {
 	IFluidDataStoreContext,
 	IFluidDataStoreContextDetached,
 	IFluidDataStoreFactory,
+	IFluidDataStorePolicies,
 	IFluidDataStoreRegistry,
 	IProvideFluidDataStoreRegistry,
 	NamedFluidDataStoreRegistryEntries,
@@ -48,6 +49,7 @@ interface CreateDataObjectProps<TObj extends PureDataObject, I extends DataObjec
 	runtimeClassArg: typeof FluidDataStoreRuntime;
 	existing: boolean;
 	initialState?: I["InitialState"];
+	policies?: Partial<IFluidDataStorePolicies>;
 }
 /**
  * Proxy over PureDataObject
@@ -64,6 +66,7 @@ async function createDataObject<
 	runtimeClassArg,
 	existing,
 	initialState: initProps,
+	policies,
 }: CreateDataObjectProps<TObj, I>): Promise<{
 	instance: TObj;
 	runtime: FluidDataStoreRuntime;
@@ -101,6 +104,7 @@ async function createDataObject<
 			await instance.finishInitialization(true);
 			return instance;
 		} /* provideEntryPoint */,
+		policies,
 	);
 
 	// Create object right away.
@@ -135,6 +139,58 @@ async function createDataObject<
 	return { instance, runtime };
 }
 
+/**
+ * Represents the properties required to create a DataObjectFactory.
+ * This includes the type identifier, constructor, shared objects, optional providers,
+ * registry entries, and the runtime class to use for the data object.
+ * @typeParam TObj - DataObject (concrete type)
+ * @typeParam I - The input types for the DataObject
+ * @legacy
+ * @alpha
+ */
+export interface DataObjectFactoryProps<
+	TObj extends PureDataObject<I>,
+	I extends DataObjectTypes = DataObjectTypes,
+> {
+	/**
+	 * The type identifier for the data object factory.
+	 */
+	readonly type: string;
+
+	/**
+	 * The constructor for the data object.
+	 */
+	readonly ctor: new (
+		props: IDataObjectProps<I>,
+	) => TObj;
+
+	/**
+	 * The shared objects (DDSes) to be registered with the data object.
+	 */
+	readonly sharedObjects?: readonly IChannelFactory[];
+
+	/**
+	 * Optional providers for dependency injection.
+	 */
+	readonly optionalProviders?: FluidObjectSymbolProvider<I["OptionalProviders"]>;
+
+	/**
+	 * Registry entries for named data stores.
+	 */
+	readonly registryEntries?: NamedFluidDataStoreRegistryEntries;
+
+	/**
+	 * The runtime class to use for the data object.
+	 */
+	readonly runtimeClass?: typeof FluidDataStoreRuntime;
+
+	/**
+	 * Optional policies that can be applied to the DataObject.
+	 * These policies define specific behaviors or constraints for the data object.
+	 */
+	readonly policies?: Partial<IFluidDataStorePolicies>;
+}
+
 /**
  * PureDataObjectFactory is a bare-bones IFluidDataStoreFactory for use with PureDataObject.
  * Consumers should typically use DataObjectFactory instead unless creating
@@ -153,30 +209,62 @@ export class PureDataObjectFactory<
 	private readonly registry: IFluidDataStoreRegistry | undefined;
 	private readonly createProps: Omit<CreateDataObjectProps<TObj, I>, "existing" | "context">;
 
+	/**
+	 * {@inheritDoc @fluidframework/runtime-definitions#IFluidDataStoreFactory."type"}
+	 */
+	public readonly type: string;
+
+	/**
+	 * @remarks Use the props object based constructor instead.
+	 * No new features will be added to this constructor,
+	 * and it will eventually be deprecated and removed.
+	 */
 	public constructor(
-		/**
-		 * {@inheritDoc @fluidframework/runtime-definitions#IFluidDataStoreFactory."type"}
-		 */
-		public readonly type: string,
+		type: string,
 		ctor: new (props: IDataObjectProps<I>) => TObj,
-		sharedObjects: readonly IChannelFactory[],
-		optionalProviders: FluidObjectSymbolProvider<I["OptionalProviders"]>,
+		sharedObjects?: readonly IChannelFactory[],
+		optionalProviders?: FluidObjectSymbolProvider<I["OptionalProviders"]>,
 		registryEntries?: NamedFluidDataStoreRegistryEntries,
-		runtimeClass: typeof FluidDataStoreRuntime = FluidDataStoreRuntime,
+		runtimeClass?: typeof FluidDataStoreRuntime,
+	);
+	public constructor(props: DataObjectFactoryProps<TObj, I>);
+	public constructor(
+		propsOrType: DataObjectFactoryProps<TObj, I> | string,
+		maybeCtor?: new (doProps: IDataObjectProps<I>) => TObj,
+		maybeSharedObjects?: readonly IChannelFactory[],
+		maybeOptionalProviders?: FluidObjectSymbolProvider<I["OptionalProviders"]>,
+		maybeRegistryEntries?: NamedFluidDataStoreRegistryEntries,
+		maybeRuntimeFactory?: typeof FluidDataStoreRuntime,
 	) {
-		if (this.type === "") {
+		const newProps =
+			typeof propsOrType === "string"
+				? {
+						type: propsOrType,
+						// both the arg and props base constructor require this param
+						// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+						ctor: maybeCtor!,
+						sharedObjects: maybeSharedObjects,
+						optionalProviders: maybeOptionalProviders,
+						registryEntries: maybeRegistryEntries,
+						runtimeClass: maybeRuntimeFactory,
+					}
+				: propsOrType;
+
+		if (newProps.type === "") {
 			throw new Error("undefined type member");
 		}
+		this.type = newProps.type;
 
 		this.createProps = {
-			ctor,
-			optionalProviders,
-			sharedObjectRegistry: new Map(sharedObjects.map((ext) => [ext.type, ext])),
-			runtimeClassArg: runtimeClass,
+			ctor: newProps.ctor,
+			optionalProviders: newProps.optionalProviders ?? {},
+			sharedObjectRegistry: new Map(newProps.sharedObjects?.map((ext) => [ext.type, ext])),
+			runtimeClassArg: newProps.runtimeClass ?? FluidDataStoreRuntime,
+			policies: newProps.policies,
 		};
 
-		if (registryEntries !== undefined) {
-			this.registry = new FluidDataStoreRegistry(registryEntries);
+		if (newProps.registryEntries !== undefined) {
+			this.registry = new FluidDataStoreRegistry(newProps.registryEntries);
 		}
 	}
 

package/src/index.ts

@@ -21,6 +21,7 @@
 export {
 	DataObjectFactory,
 	PureDataObjectFactory,
+	type DataObjectFactoryProps,
 } from "./data-object-factories/index.js";
 export {
 	DataObject,