Enable Synchronous Child Datastore Creation

packages/runtime/container-runtime/src/dataStoreContext.ts

@@ -15,7 +15,12 @@ import {
 	type IEvent,
 } from "@fluidframework/core-interfaces";
 import { type IFluidHandleInternal } from "@fluidframework/core-interfaces/internal";
-import { assert, LazyPromise, unreachableCase } from "@fluidframework/core-utils/internal";
+import {
+	assert,
+	isPromiseLike,
+	LazyPromise,
+	unreachableCase,
+} from "@fluidframework/core-utils/internal";
 import { IClientDetails, IQuorumClients } from "@fluidframework/driver-definitions";
 import {
 	IDocumentStorageService,
@@ -55,6 +60,7 @@ import {
 	IInboundSignalMessage,
 	type IPendingMessagesState,
 	type IRuntimeMessageCollection,
+	type IFluidDataStoreFactory,
 } from "@fluidframework/runtime-definitions/internal";
 import {
 	addBlobToSummary,
@@ -65,6 +71,7 @@ import {
 	LoggingError,
 	MonitoringContext,
 	ThresholdCounter,
+	UsageError,
 	createChildMonitoringContext,
 	extractSafePropertiesFromMessage,
 	generateStack,
@@ -523,6 +530,43 @@ export abstract class FluidDataStoreContext
 		return factory;
 	}
 
+	createChildDataStoreSync<T extends IFluidDataStoreFactory>(
+		childFactory: T,
+	): ReturnType<Exclude<T["createDataStore"], undefined>> {
+		const maybe = this.registry?.get(childFactory.type);
+
+		const isUndefined = maybe === undefined;
+		const isPromise = isPromiseLike(maybe);
+		const diffInstance = isPromise || maybe?.IFluidDataStoreFactory !== childFactory;
+
+		if (isUndefined || isPromise || diffInstance) {
+			throw new UsageError(
+				"The provided factory instance must be synchronously available as a child of this datastore",
+				{ isUndefined, isPromise, diffInstance },
+			);
+		}
+		if (childFactory?.createDataStore === undefined) {
+			throw new UsageError("createDataStore must exist on the provided factory", {
+				noCreateDataStore: true,
+			});
+		}
+
+		const context = this._containerRuntime.createDetachedDataStore([
+			...this.packagePath,
+			childFactory.type,
+		]);
+		assert(
+			context instanceof LocalDetachedFluidDataStoreContext,
+			"must be a LocalDetachedFluidDataStoreContext",
+		);
+
+		const created = childFactory.createDataStore(context) as ReturnType<
+			Exclude<T["createDataStore"], undefined>
+		>;
+		context.unsafe_AttachRuntimeSync(created.runtime);
+		return created;
+	}
+
 	private async realizeCore(existing: boolean) {
 		const details = await this.getInitialSnapshotDetails();
 		// Base snapshot is the baseline where pending ops are applied to.
@@ -1428,6 +1472,24 @@ export class LocalDetachedFluidDataStoreContext
 		return this.channelToDataStoreFn(await this.channelP);
 	}
 
+	/**
+	 * This method provides a synchronous path for binding a runtime to the context.
+	 *
+	 * Due to its synchronous nature, it is unable to validate that the runtime
+	 * represents a datastore which is instantiable by remote clients. This could
+	 * happen if the runtime's package path does not return a factory when looked up
+	 * in the container runtime's registry, or if the runtime's entrypoint is not
+	 * properly initialized. As both of these validation's are asynchronous to preform.
+	 *
+	 * If used incorrectly, this function can result in permanent data corruption.
+	 */
+	public unsafe_AttachRuntimeSync(channel: IFluidDataStoreChannel) {
+		this.channelP = Promise.resolve(channel);
+		this.processPendingOps(channel);
+		this.completeBindingRuntime(channel);
+		return this.channelToDataStoreFn(channel);
+	}
+
 	public async getInitialSnapshotDetails(): Promise<ISnapshotDetails> {
 		if (this.detachedRuntimeCreation) {
 			throw new Error(

packages/runtime/container-runtime/src/test/createChildDataStoreSync.spec.ts

@@ -0,0 +1,172 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { strict as assert } from "assert";
+
+import { FluidErrorTypes } from "@fluidframework/core-interfaces/internal";
+import { LazyPromise } from "@fluidframework/core-utils/internal";
+import { IDocumentStorageService } from "@fluidframework/driver-definitions/internal";
+import {
+	IFluidDataStoreChannel,
+	IFluidDataStoreFactory,
+	IFluidDataStoreRegistry,
+	IFluidParentContext,
+	type NamedFluidDataStoreRegistryEntries,
+	type IContainerRuntimeBase,
+	type ISummarizerNodeWithGC,
+} from "@fluidframework/runtime-definitions/internal";
+import { isFluidError } from "@fluidframework/telemetry-utils/internal";
+import { MockFluidDataStoreRuntime } from "@fluidframework/test-runtime-utils/internal";
+
+import {
+	FluidDataStoreContext,
+	LocalDetachedFluidDataStoreContext,
+} from "../dataStoreContext.js";
+
+describe("createChildDataStoreSync", () => {
+	const throwNYI = () => {
+		throw new Error("Method not implemented.");
+	};
+	const testContext = class TestContext extends FluidDataStoreContext {
+		protected pkg = ["ParentDataStore"];
+		public registry: IFluidDataStoreRegistry | undefined;
+		public getInitialSnapshotDetails = throwNYI;
+		public setAttachState = throwNYI;
+		public getAttachSummary = throwNYI;
+		public getAttachGCData = throwNYI;
+		protected channel = new Proxy({} as any as IFluidDataStoreChannel, { get: throwNYI });
+		protected channelP = new LazyPromise(async () => this.channel);
+	};
+
+	const createRegistry = (
+		namedEntries?: NamedFluidDataStoreRegistryEntries,
+	): IFluidDataStoreRegistry => ({
+		get IFluidDataStoreRegistry() {
+			return this;
+		},
+		// eslint-disable-next-line @typescript-eslint/promise-function-async
+		get(name) {
+			return new Map(namedEntries).get(name);
+		},
+	});
+
+	const createContext = (namedEntries?: NamedFluidDataStoreRegistryEntries) => {
+		const registry = createRegistry(namedEntries);
+		const createSummarizerNodeFn = () =>
+			new Proxy({} as any as ISummarizerNodeWithGC, { get: throwNYI });
+		const storage = new Proxy({} as any as IDocumentStorageService, { get: throwNYI });
+
+		const parentContext = {
+			clientDetails: {
+				capabilities: { interactive: true },
+			},
+			containerRuntime: {
+				createDetachedDataStore(pkg, loadingGroupId) {
+					return new LocalDetachedFluidDataStoreContext({
+						channelToDataStoreFn: (channel) => ({
+							entryPoint: channel.entryPoint,
+							trySetAlias: throwNYI,
+						}),
+						createSummarizerNodeFn,
+						id: "child",
+						makeLocallyVisibleFn: throwNYI,
+						parentContext,
+						pkg,
+						scope: {},
+						snapshotTree: undefined,
+						storage,
+						loadingGroupId,
+					});
+				},
+			} satisfies Partial<IContainerRuntimeBase> as unknown as IContainerRuntimeBase,
+		} satisfies Partial<IFluidParentContext> as unknown as IFluidParentContext;
+
+		const context = new testContext(
+			{
+				createSummarizerNodeFn,
+				id: "parent",
+				parentContext,
+				scope: {},
+				storage,
+			},
+			false,
+			false,
+			throwNYI,
+		);
+		context.registry = registry;
+		return context;
+	};
+
+	const createFactory = (
+		createDataStore?: IFluidDataStoreFactory["createDataStore"],
+	): IFluidDataStoreFactory => ({
+		type: "ChildDataStore",
+		get IFluidDataStoreFactory() {
+			return this;
+		},
+		instantiateDataStore: throwNYI,
+		createDataStore,
+	});
+
+	it("Child factory does not support synchronous creation", async () => {
+		const factory = createFactory();
+		const context = createContext([[factory.type, factory]]);
+		try {
+			context.createChildDataStoreSync(factory);
+			assert.fail("should fail");
+		} catch (e) {
+			assert(isFluidError(e));
+			assert(e.errorType === FluidErrorTypes.usageError);
+			assert(e.getTelemetryProperties().noCreateDataStore === true);
+		}
+	});
+
+	it("Child factory not registered", async () => {
+		const factory = createFactory();
+		const context = createContext();
+		try {
+			context.createChildDataStoreSync(factory);
+			assert.fail("should fail");
+		} catch (e) {
+			assert(isFluidError(e));
+			assert(e.errorType === FluidErrorTypes.usageError);
+			assert(e.getTelemetryProperties().isUndefined === true);
+		}
+	});
+
+	it("Child factory is a promise", async () => {
+		const factory = createFactory();
+		const context = createContext([[factory.type, Promise.resolve(factory)]]);
+
+		try {
+			context.createChildDataStoreSync(factory);
+			assert.fail("should fail");
+		} catch (e) {
+			assert(isFluidError(e));
+			assert(e.errorType === FluidErrorTypes.usageError);
+			assert(e.getTelemetryProperties().isPromise === true);
+		}
+	});
+
+	it("Child factory is a different instance", async () => {
+		const factory = createFactory();
+		const context = createContext([[factory.type, createFactory()]]);
+
+		try {
+			context.createChildDataStoreSync(factory);
+			assert.fail("should fail");
+		} catch (e) {
+			assert(isFluidError(e));
+			assert(e.errorType === FluidErrorTypes.usageError);
+			assert(e.getTelemetryProperties().diffInstance === true);
+		}
+	});
+
+	it("createChildDataStoreSync", async () => {
+		const factory = createFactory(() => ({ runtime: new MockFluidDataStoreRuntime() }));
+		const context = createContext([[factory.type, factory]]);
+		context.createChildDataStoreSync(factory);
+	});
+});

packages/runtime/runtime-definitions/api-report/runtime-definitions.legacy.alpha.api.md

@@ -157,6 +157,7 @@ export interface IFluidDataStoreChannel extends IDisposable {
 export interface IFluidDataStoreContext extends IFluidParentContext {
     // (undocumented)
     readonly baseSnapshot: ISnapshotTree | undefined;
+    createChildDataStoreSync?<T extends IFluidDataStoreFactory>(childFactory: T): ReturnType<Exclude<T["createDataStore"], undefined>>;
     // @deprecated (undocumented)
     readonly createProps?: any;
     // @deprecated (undocumented)
@@ -177,6 +178,9 @@ export const IFluidDataStoreFactory: keyof IProvideFluidDataStoreFactory;
 
 // @alpha
 export interface IFluidDataStoreFactory extends IProvideFluidDataStoreFactory {
+    createDataStore?(context: IFluidDataStoreContext): {
+        readonly runtime: IFluidDataStoreChannel;
+    };
     instantiateDataStore(context: IFluidDataStoreContext, existing: boolean): Promise<IFluidDataStoreChannel>;
     type: string;
 }
@@ -186,8 +190,7 @@ export const IFluidDataStoreRegistry: keyof IProvideFluidDataStoreRegistry;
 
 // @alpha
 export interface IFluidDataStoreRegistry extends IProvideFluidDataStoreRegistry {
-    // (undocumented)
-    get(name: string): Promise<FluidDataStoreRegistryEntry | undefined>;
+    get(name: string): Promise<FluidDataStoreRegistryEntry | undefined> | FluidDataStoreRegistryEntry | undefined;
 }
 
 // @alpha
@@ -384,11 +387,17 @@ export interface LocalAttributionKey {
 }
 
 // @alpha
-export type NamedFluidDataStoreRegistryEntries = Iterable<NamedFluidDataStoreRegistryEntry>;
+export type NamedFluidDataStoreRegistryEntries = Iterable<NamedFluidDataStoreRegistryEntry2>;
 
 // @alpha
 export type NamedFluidDataStoreRegistryEntry = [string, Promise<FluidDataStoreRegistryEntry>];
 
+// @alpha
+export type NamedFluidDataStoreRegistryEntry2 = [
+string,
+Promise<FluidDataStoreRegistryEntry> | FluidDataStoreRegistryEntry
+];
+
 // @alpha
 export interface OpAttributionKey {
     seq: number;

packages/runtime/runtime-definitions/src/dataStoreContext.ts

@@ -28,7 +28,10 @@ import type {
 } from "@fluidframework/driver-definitions/internal";
 import type { IIdCompressor } from "@fluidframework/id-compressor";
 
-import type { IProvideFluidDataStoreFactory } from "./dataStoreFactory.js";
+import type {
+	IFluidDataStoreFactory,
+	IProvideFluidDataStoreFactory,
+} from "./dataStoreFactory.js";
 import type { IProvideFluidDataStoreRegistry } from "./dataStoreRegistry.js";
 import type {
 	IGarbageCollectionData,
@@ -610,6 +613,28 @@ export interface IFluidDataStoreContext extends IFluidParentContext {
 	 * and its children with the GC details from the previous summary.
 	 */
 	getBaseGCDetails(): Promise<IGarbageCollectionDetailsBase>;
+
+	/**
+	 * This function creates a detached child data store synchronously.
+	 *
+	 * The `createChildDataStoreSync` method allows for the synchronous creation of a child data store. This is particularly
+	 * useful in scenarios where immediate availability of the child data store is required, such as during the initialization
+	 * of a parent data store, or when creation is in response to synchronous user input.
+	 *
+	 * In order for this function to succeed:
+	 * 1. The parent data store's factory must also be an `IFluidDataStoreRegistry`.
+	 * 2. The parent data store's registry must include the same instance as the provided child factory.
+	 * 3. The parent data store's registry must synchronously provide the child factory.
+	 * 4. The child factory must implement the `createDataStore` method.
+	 *
+	 * These invariants ensure that the child data store can also be created by a remote client running the same code as this client.
+	 *
+	 * @param childFactory - The factory of the data store to be created.
+	 * @returns The created data store channel.
+	 */
+	createChildDataStoreSync?<T extends IFluidDataStoreFactory>(
+		childFactory: T,
+	): ReturnType<Exclude<T["createDataStore"], undefined>>;
 }
 
 /**