@fluidframework/fluid-static 2.50.0 → 2.51.0-347100

package/src/utils.ts

@@ -4,13 +4,27 @@
  */
 
 import type { DataObjectKind } from "@fluidframework/aqueduct/internal";
-import type { IFluidLoadable } from "@fluidframework/core-interfaces";
-import type { IChannelFactory } from "@fluidframework/datastore-definitions/internal";
-import type { NamedFluidDataStoreRegistryEntry } from "@fluidframework/runtime-definitions/internal";
+import type { MinimumVersionForCollab } from "@fluidframework/container-runtime/internal";
+import type { FluidObjectKeys, IFluidLoadable } from "@fluidframework/core-interfaces";
+import { oob } from "@fluidframework/core-utils/internal";
+import type {
+	IChannelFactory,
+	IFluidDataStoreRuntime,
+} from "@fluidframework/datastore-definitions/internal";
+import type {
+	IFluidDataStoreContext,
+	NamedFluidDataStoreRegistryEntry,
+} from "@fluidframework/runtime-definitions/internal";
 import type { ISharedObjectKind } from "@fluidframework/shared-object-base/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
+import { SharedTreeFactoryType } from "@fluidframework/tree/internal";
 
-import type { ContainerSchema, LoadableObjectKind } from "./types.js";
+import type {
+	CompatibilityMode,
+	ContainerSchema,
+	LoadableObjectKind,
+	TreeContainerSchema,
+} from "./types.js";
 
 /**
  * Runtime check to determine if an object is a {@link DataObjectKind}.
@@ -94,3 +108,75 @@ export const parseDataObjectsFromSharedObjects = (
 
 	return [[...registryEntries], [...sharedObjects]];
 };
+
+/**
+ * Creates a new data object of the specified type.
+ */
+export async function createDataObject<T extends IFluidLoadable>(
+	dataObjectClass: DataObjectKind<T>,
+	context: IFluidDataStoreContext,
+): Promise<T> {
+	const factory = dataObjectClass.factory;
+	const packagePath = [...context.packagePath, factory.type];
+	const dataStore = await context.containerRuntime.createDataStore(packagePath);
+	const entryPoint = await dataStore.entryPoint.get();
+	return entryPoint as T;
+}
+
+/**
+ * Creates a new shared object of the specified type.
+ */
+export function createSharedObject<T extends IFluidLoadable>(
+	sharedObjectClass: ISharedObjectKind<T>,
+	runtime: IFluidDataStoreRuntime,
+): T {
+	const factory = sharedObjectClass.getFactory();
+	const obj = runtime.createChannel(undefined, factory.type);
+	return obj as unknown as T;
+}
+
+/**
+ * Creates a Fluid object that has a property with the key `providerKey` that points to itself.
+ * @remarks This is useful for creating objects that need to reference themselves, such as DataObjects.
+ */
+export function makeFluidObject<
+	T extends object,
+	K extends FluidObjectKeys<T> = FluidObjectKeys<T>,
+>(object: Omit<T, K>, providerKey: K): T {
+	return Object.defineProperty(object, providerKey, { value: object }) as T;
+}
+
+/**
+ * Maps CompatibilityMode to a semver valid string that can be passed to the container runtime.
+ */
+export const compatibilityModeToMinVersionForCollab = {
+	"1": "1.0.0",
+	"2": "2.0.0",
+} as const satisfies Record<CompatibilityMode, MinimumVersionForCollab>;
+
+/**
+ * Determines if the provided schema is a valid tree-based container schema.
+ * @internal
+ */
+export function isTreeContainerSchema(schema: ContainerSchema): schema is TreeContainerSchema {
+	const schemaEntries = Object.entries(schema.initialObjects);
+	if (schemaEntries.length !== 1) {
+		return false;
+	}
+
+	const entry = schemaEntries[0] ?? oob();
+	const key = entry[0];
+	if (key !== "tree") {
+		return false;
+	}
+
+	const objectKind = entry[1] as unknown as LoadableObjectKind;
+	if (
+		isSharedObjectKind(objectKind) &&
+		objectKind.getFactory().type === SharedTreeFactoryType
+	) {
+		return true;
+	}
+
+	return false;
+}