@fluidframework/fluid-static 2.0.0-dev-rc.5.0.0.263932 → 2.0.0-dev-rc.5.0.0.267932

package/src/rootDataObject.ts

@@ -9,7 +9,7 @@ import {
 	DataObjectFactory,
 } from "@fluidframework/aqueduct/internal";
 import { type IRuntimeFactory } from "@fluidframework/container-definitions/internal";
-import { type ContainerRuntime } from "@fluidframework/container-runtime/internal";
+import type { ContainerRuntime } from "@fluidframework/container-runtime/internal";
 import { type IContainerRuntime } from "@fluidframework/container-runtime-definitions/internal";
 import {
 	type FluidObject,
@@ -18,19 +18,21 @@ import {
 	type IResponse,
 } from "@fluidframework/core-interfaces";
 import { type IDirectory } from "@fluidframework/map/internal";
-import { FlushMode } from "@fluidframework/runtime-definitions/internal";
 import { RequestParser } from "@fluidframework/runtime-utils/internal";
-import type { ISharedObjectKind } from "@fluidframework/shared-object-base";
-
-import {
-	type ContainerSchema,
-	type IRootDataObject,
-	type LoadableObjectClass,
-	type LoadableObjectClassRecord,
-	type LoadableObjectRecord,
+import type { SharedObjectKind } from "@fluidframework/shared-object-base";
+import type { ISharedObjectKind } from "@fluidframework/shared-object-base/internal";
+
+import { compatibilityModeRuntimeOptions } from "./compatibilityConfiguration.js";
+import type {
+	CompatibilityMode,
+	ContainerSchema,
+	DataObjectClass,
+	IRootDataObject,
+	LoadableObjectClass,
+	LoadableObjectClassRecord,
+	LoadableObjectRecord,
 } from "./types.js";
 import {
-	type InternalDataObjectClass,
 	isDataObjectClass,
 	isSharedObjectKind,
 	parseDataObjectsFromSharedObjects,
@@ -45,7 +47,7 @@ export interface RootDataObjectProps {
 	 *
 	 * @see {@link RootDataObject.initializingFirstTime}
 	 */
-	initialObjects: LoadableObjectClassRecord;
+	readonly initialObjects: LoadableObjectClassRecord;
 }
 
 /**
@@ -84,7 +86,9 @@ class RootDataObject
 		const initialObjectsP: Promise<void>[] = [];
 		for (const [id, objectClass] of Object.entries(props.initialObjects)) {
 			const createObject = async (): Promise<void> => {
-				const obj = await this.create<IFluidLoadable>(objectClass);
+				const obj = await this.create<IFluidLoadable>(
+					objectClass as SharedObjectKind<IFluidLoadable>,
+				);
 				this.initialObjectsDir.set(id, obj.handle);
 			};
 			initialObjectsP.push(createObject());
@@ -127,23 +131,24 @@ class RootDataObject
 	/**
 	 * {@inheritDoc IRootDataObject.create}
 	 */
-	public async create<T extends IFluidLoadable>(objectClass: LoadableObjectClass<T>): Promise<T> {
-		if (isDataObjectClass(objectClass)) {
-			return this.createDataObject(objectClass);
-		} else if (isSharedObjectKind(objectClass)) {
-			return this.createSharedObject(objectClass);
+	public async create<T>(objectClass: SharedObjectKind<T>): Promise<T> {
+		const internal = objectClass as unknown as LoadableObjectClass<T & IFluidLoadable>;
+		if (isDataObjectClass(internal)) {
+			return this.createDataObject(internal);
+		} else if (isSharedObjectKind(internal)) {
+			return this.createSharedObject(internal);
 		}
 		throw new Error("Could not create new Fluid object because an unknown object was passed");
 	}
 
 	private async createDataObject<T extends IFluidLoadable>(
-		dataObjectClass: InternalDataObjectClass<T>,
+		dataObjectClass: DataObjectClass<T>,
 	): Promise<T> {
 		const factory = dataObjectClass.factory;
 		const packagePath = [...this.context.packagePath, factory.type];
 		const dataStore = await this.context.containerRuntime.createDataStore(packagePath);
 		const entryPoint = await dataStore.entryPoint.get();
-		return entryPoint as unknown as T;
+		return entryPoint as T;
 	}
 
 	private createSharedObject<T extends IFluidLoadable>(
@@ -165,8 +170,9 @@ const rootDataStoreId = "rootDOId";
  */
 export function createDOProviderContainerRuntimeFactory(props: {
 	schema: ContainerSchema;
+	compatibilityMode: CompatibilityMode;
 }): IRuntimeFactory {
-	return new DOProviderContainerRuntimeFactory(props.schema);
+	return new DOProviderContainerRuntimeFactory(props.schema, props.compatibilityMode);
 }
 
 /**
@@ -189,7 +195,7 @@ class DOProviderContainerRuntimeFactory extends BaseContainerRuntimeFactory {
 
 	private readonly initialObjects: LoadableObjectClassRecord;
 
-	public constructor(schema: ContainerSchema) {
+	public constructor(schema: ContainerSchema, compatibilityMode: CompatibilityMode) {
 		const [registryEntries, sharedObjects] = parseDataObjectsFromSharedObjects(schema);
 		const rootDataObjectFactory = new DataObjectFactory(
 			"rootDO",
@@ -227,15 +233,7 @@ class DOProviderContainerRuntimeFactory extends BaseContainerRuntimeFactory {
 		super({
 			registryEntries: [rootDataObjectFactory.registryEntry],
 			requestHandlers: [getDefaultObject],
-			// WARNING: These settigs are not compatible with FF 1.3 clients!
-			runtimeOptions: {
-				// temporary workaround to disable message batching until the message batch size issue is resolved
-				// resolution progress is tracked by the Feature 465 work item in AzDO
-				flushMode: FlushMode.Immediate,
-				// The runtime compressor is required to be on to use @fluidframework/tree.
-				enableRuntimeIdCompressor: "on",
-				explicitSchemaControl: true,
-			},
+			runtimeOptions: compatibilityModeRuntimeOptions[compatibilityMode],
 			provideEntryPoint,
 		});
 		this.rootDataObjectFactory = rootDataObjectFactory;

package/src/serviceAudience.ts

@@ -6,7 +6,7 @@
 import { TypedEventEmitter } from "@fluid-internal/client-utils";
 import { type IAudience } from "@fluidframework/container-definitions";
 import { type IContainer } from "@fluidframework/container-definitions/internal";
-import { type IClient } from "@fluidframework/protocol-definitions";
+import { type IClient } from "@fluidframework/driver-definitions";
 
 import {
 	type IMember,

package/src/types.ts

@@ -8,7 +8,15 @@ import {
 	type IEventProvider,
 	type IFluidLoadable,
 } from "@fluidframework/core-interfaces";
-import { type ISharedObjectKind } from "@fluidframework/shared-object-base";
+import type { IFluidDataStoreFactory } from "@fluidframework/runtime-definitions/internal";
+import { type SharedObjectKind } from "@fluidframework/shared-object-base";
+import { type ISharedObjectKind } from "@fluidframework/shared-object-base/internal";
+
+/**
+ * Valid compatibility modes that may be specified when creating a DOProviderContainerRuntimeFactory.
+ * @public
+ */
+export type CompatibilityMode = "1" | "2";
 
 /**
  * A mapping of string identifiers to instantiated `DataObject`s or `SharedObject`s.
@@ -19,15 +27,13 @@ export type LoadableObjectRecord = Record<string, IFluidLoadable>;
 /**
  * A mapping of string identifiers to classes that will later be used to instantiate a corresponding `DataObject`
  * or `SharedObject`.
- * @public
  */
-export type LoadableObjectClassRecord = Record<string, LoadableObjectClass>;
+export type LoadableObjectClassRecord = Record<string, SharedObjectKind>;
 
 /**
  * A class object of `DataObject` or `SharedObject`.
  *
  * @typeParam T - The class of the `DataObject` or `SharedObject`.
- * @public
  *
  * @privateRemarks
  * There are some edge cases in TypeScript where the order of the members in a union matter.
@@ -46,19 +52,14 @@ export type LoadableObjectClass<T extends IFluidLoadable = IFluidLoadable> =
  *
  * @typeParam T - The class of the `DataObject`.
  * @privateRemarks
- * Having both `factory` and `LoadableObjectCtor` is redundant.
- * TODO: It appears the factory is what's used, so the constructor should be removed.
- * @public
+ * Having both `factory` and constructor is redundant.
+ * TODO: It appears the factory is what's used, so the constructor should be removed once factory provides strong typing.
  */
-export type DataObjectClass<T extends IFluidLoadable = IFluidLoadable> = {
-	/**
-	 * @privateRemarks
-	 * This has to implement {@link @fluidframework/runtime-definitions#IFluidDataStoreFactory}.
-	 * TODO: Gain type safety for this without leaking IFluidDataStoreFactory as public using type erasure.
-	 */
-	readonly factory: { readonly IFluidDataStoreFactory: DataObjectClass<T>["factory"] };
+export interface DataObjectClass<T extends IFluidLoadable> {
+	readonly factory: IFluidDataStoreFactory;
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-} & (new (...args: any[]) => T);
+	new (...args: any[]): T;
+}
 
 /**
  * Represents properties that can be attached to a container.
@@ -94,7 +95,7 @@ export interface ContainerSchema {
 	 * }
 	 * ```
 	 */
-	readonly initialObjects: LoadableObjectClassRecord;
+	readonly initialObjects: Record<string, SharedObjectKind>;
 
 	/**
 	 * Loadable objects that can be created after the initial {@link IFluidContainer | Container} creation.
@@ -106,7 +107,7 @@ export interface ContainerSchema {
 	 * For best practice it's recommended to define all the dynamic types you create even if they are
 	 * included via initialObjects.
 	 */
-	readonly dynamicObjectTypes?: readonly LoadableObjectClass[];
+	readonly dynamicObjectTypes?: readonly SharedObjectKind[];
 }
 
 /**
@@ -134,7 +135,7 @@ export interface IRootDataObject extends IProvideRootDataObject {
 	 *
 	 * @typeParam T - The class of the `DataObject` or `SharedObject`.
 	 */
-	create<T extends IFluidLoadable>(objectClass: LoadableObjectClass<T>): Promise<T>;
+	create<T>(objectClass: SharedObjectKind<T>): Promise<T>;
 }
 
 /**

package/src/utils.ts

@@ -4,46 +4,32 @@
  */
 
 import { type IFluidLoadable } from "@fluidframework/core-interfaces";
-import { type IChannelFactory } from "@fluidframework/datastore-definitions";
-import {
-	type IFluidDataStoreFactory,
-	type NamedFluidDataStoreRegistryEntry,
-} from "@fluidframework/runtime-definitions/internal";
-import type { ISharedObjectKind } from "@fluidframework/shared-object-base";
+import { type IChannelFactory } from "@fluidframework/datastore-definitions/internal";
+import { type NamedFluidDataStoreRegistryEntry } from "@fluidframework/runtime-definitions/internal";
+import type { ISharedObjectKind } from "@fluidframework/shared-object-base/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
 import { type ContainerSchema, type DataObjectClass, type LoadableObjectClass } from "./types.js";
 
-/**
- * An internal type used by the internal type guard isDataObjectClass to cast a
- * DataObjectClass to a type that is strongly coupled to IFluidDataStoreFactory.
- * Unlike the external and exported type DataObjectClass which is
- * weakly coupled to the IFluidDataStoreFactory to prevent leaking internals.
- */
-export type InternalDataObjectClass<T extends IFluidLoadable> = DataObjectClass<T> &
-	Record<"factory", IFluidDataStoreFactory>;
-
 /**
  * Runtime check to determine if a class is a DataObject type.
  */
 export function isDataObjectClass<T extends IFluidLoadable>(
 	obj: LoadableObjectClass<T>,
-): obj is InternalDataObjectClass<T>;
+): obj is DataObjectClass<T>;
 
 /**
  * Runtime check to determine if a class is a DataObject type.
  */
-export function isDataObjectClass(
-	obj: LoadableObjectClass,
-): obj is InternalDataObjectClass<IFluidLoadable>;
+export function isDataObjectClass(obj: LoadableObjectClass): obj is DataObjectClass<IFluidLoadable>;
 
 /**
  * Runtime check to determine if a class is a DataObject type.
  */
 export function isDataObjectClass(
 	obj: LoadableObjectClass,
-): obj is InternalDataObjectClass<IFluidLoadable> {
-	const maybe = obj as Partial<InternalDataObjectClass<IFluidLoadable>> | undefined;
+): obj is DataObjectClass<IFluidLoadable> {
+	const maybe = obj as Partial<DataObjectClass<IFluidLoadable>> | undefined;
 	const isDataObject =
 		maybe?.factory?.IFluidDataStoreFactory !== undefined &&
 		maybe.factory.IFluidDataStoreFactory === maybe.factory;
@@ -96,7 +82,7 @@ export const parseDataObjectsFromSharedObjects = (
 		...(schema.dynamicObjectTypes ?? []),
 	]);
 	for (const obj of dedupedObjects) {
-		tryAddObject(obj);
+		tryAddObject(obj as unknown as LoadableObjectClass);
 	}
 
 	if (registryEntries.size === 0 && sharedObjects.size === 0) {