@fluidframework/fluid-static 2.0.0-rc.2.0.1 → 2.0.0-rc.3.0.0

package/src/rootDataObject.ts

@@ -2,23 +2,25 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
+
 import {
 	BaseContainerRuntimeFactory,
 	DataObject,
 	DataObjectFactory,
-} from "@fluidframework/aqueduct";
-import { type IContainerRuntime } from "@fluidframework/container-runtime-definitions";
+} from "@fluidframework/aqueduct/internal";
+import { type IRuntimeFactory } from "@fluidframework/container-definitions/internal";
+import { type ContainerRuntime } from "@fluidframework/container-runtime/internal";
+import { type IContainerRuntime } from "@fluidframework/container-runtime-definitions/internal";
 import {
 	type FluidObject,
 	type IFluidLoadable,
 	type IRequest,
 	type IResponse,
 } from "@fluidframework/core-interfaces";
-import { FlushMode } from "@fluidframework/runtime-definitions";
-import { type IRuntimeFactory } from "@fluidframework/container-definitions";
-import { RequestParser } from "@fluidframework/runtime-utils";
-import { type ContainerRuntime } from "@fluidframework/container-runtime";
-import { type IDirectory } from "@fluidframework/map";
+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,
@@ -26,12 +28,11 @@ import {
 	type LoadableObjectClass,
 	type LoadableObjectClassRecord,
 	type LoadableObjectRecord,
-	type SharedObjectClass,
 } from "./types.js";
 import {
 	type InternalDataObjectClass,
 	isDataObjectClass,
-	isSharedObjectClass,
+	isSharedObjectKind,
 	parseDataObjectsFromSharedObjects,
 } from "./utils.js";
 
@@ -128,9 +129,9 @@ class RootDataObject
 	 */
 	public async create<T extends IFluidLoadable>(objectClass: LoadableObjectClass<T>): Promise<T> {
 		if (isDataObjectClass(objectClass)) {
-			return this.createDataObject<T>(objectClass);
-		} else if (isSharedObjectClass(objectClass)) {
-			return this.createSharedObject<T>(objectClass);
+			return this.createDataObject(objectClass);
+		} else if (isSharedObjectKind(objectClass)) {
+			return this.createSharedObject(objectClass);
 		}
 		throw new Error("Could not create new Fluid object because an unknown object was passed");
 	}
@@ -146,7 +147,7 @@ class RootDataObject
 	}
 
 	private createSharedObject<T extends IFluidLoadable>(
-		sharedObjectClass: SharedObjectClass<T>,
+		sharedObjectClass: ISharedObjectKind<T>,
 	): T {
 		const factory = sharedObjectClass.getFactory();
 		const obj = this.runtime.createChannel(undefined, factory.type);
@@ -226,12 +227,14 @@ 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,
 			},
 			provideEntryPoint,
 		});

package/src/serviceAudience.ts

@@ -4,12 +4,14 @@
  */
 
 import { TypedEventEmitter } from "@fluid-internal/client-utils";
-import { type IAudience, type IContainer } from "@fluidframework/container-definitions";
+import { type IAudience } from "@fluidframework/container-definitions";
+import { type IContainer } from "@fluidframework/container-definitions/internal";
 import { type IClient } from "@fluidframework/protocol-definitions";
+
 import {
+	type IMember,
 	type IServiceAudience,
 	type IServiceAudienceEvents,
-	type IMember,
 	type Myself,
 } from "./types.js";
 

package/src/types.ts

@@ -8,7 +8,7 @@ import {
 	type IEventProvider,
 	type IFluidLoadable,
 } from "@fluidframework/core-interfaces";
-import { type IChannelFactory } from "@fluidframework/datastore-definitions";
+import { type ISharedObjectKind } from "@fluidframework/shared-object-base";
 
 /**
  * A mapping of string identifiers to instantiated `DataObject`s or `SharedObject`s.
@@ -33,11 +33,11 @@ export type LoadableObjectClassRecord = Record<string, LoadableObjectClass>;
  * There are some edge cases in TypeScript where the order of the members in a union matter.
  * Once such edge case is when multiple members of a generic union partially match, and the type parameter is being inferred.
  * In this case, its better to have the desired match and/or the simpler type first.
- * In this case placing SharedObjectClass fixed one usage and didn't break anything, and generally seems more likely to work than the reverse, so this is the order being used.
+ * In this case placing ISharedObjectKind fixed one usage and didn't break anything, and generally seems more likely to work than the reverse, so this is the order being used.
  * This is likely (a bug in TypeScript)[https://github.com/microsoft/TypeScript/issues/45809].
  */
 export type LoadableObjectClass<T extends IFluidLoadable = IFluidLoadable> =
-	| SharedObjectClass<T>
+	| ISharedObjectKind<T>
 	| DataObjectClass<T>;
 
 /**
@@ -45,33 +45,15 @@ export type LoadableObjectClass<T extends IFluidLoadable = IFluidLoadable> =
  * constructor that will return the type of the `DataObject`.
  *
  * @typeParam T - The class of the `DataObject`.
+ * @privateRemarks
+ * Having both `factory` and `LoadableObjectCtor` is redundant, and having `factory` not actually work as a factory is also strange.
+ * This may need some refinement.
  * @public
  */
-export type DataObjectClass<T extends IFluidLoadable> = {
-	readonly factory: { IFluidDataStoreFactory: DataObjectClass<T>["factory"] };
-} & LoadableObjectCtor<T>;
-
-/**
- * A factory that produces a factory that can create a DDSes (`SharedObject`s).
- *
- * @typeParam T - The class of the `SharedObject`.
- * @public
- */
-export interface SharedObjectClass<T extends IFluidLoadable> {
-	/**
-	 * Gets the factory this factory is a wrapper for.
-	 */
-	readonly getFactory: () => IChannelFactory<T>;
-}
-
-/**
- * An object with a constructor that will return an {@link @fluidframework/core-interfaces#IFluidLoadable}.
- *
- * @typeParam T - The class of the loadable object.
- * @public
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type LoadableObjectCtor<T extends IFluidLoadable> = new (...args: any[]) => T;
+export type DataObjectClass<T extends IFluidLoadable = IFluidLoadable> = {
+	readonly factory: { readonly IFluidDataStoreFactory: DataObjectClass<T>["factory"] };
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+} & (new (...args: any[]) => T);
 
 /**
  * Represents properties that can be attached to a container.
@@ -213,7 +195,7 @@ export interface IServiceAudience<M extends IMember>
 	 * member object.  The implementation may choose to exclude certain connections from the returned map.
 	 * E.g. ServiceAudience excludes non-interactive connections to represent only the roster of live users.
 	 */
-	getMembers(): Map<string, M>;
+	getMembers(): ReadonlyMap<string, M>;
 
 	/**
 	 * Returns the current active user on this client once they are connected. Otherwise, returns undefined.
@@ -231,12 +213,12 @@ export interface IConnection {
 	/**
 	 * A unique ID for the connection.  A single user may have multiple connections, each with a different ID.
 	 */
-	id: string;
+	readonly id: string;
 
 	/**
 	 * Whether the connection is in read or read/write mode.
 	 */
-	mode: "write" | "read";
+	readonly mode: "write" | "read";
 }
 
 /**
@@ -249,16 +231,16 @@ export interface IMember {
 	/**
 	 * An ID for the user, unique among each individual user connecting to the session.
 	 */
-	userId: string;
+	readonly userId: string;
 
 	/**
 	 * The set of connections the user has made, e.g. from multiple tabs or devices.
 	 */
-	connections: IConnection[];
+	readonly connections: IConnection[];
 }
 
 /**
  * An extended member object that includes currentConnection
  * @public
  */
-export type Myself<M extends IMember = IMember> = M & { currentConnection: string };
+export type Myself<M extends IMember = IMember> = M & { readonly currentConnection: string };

package/src/utils.ts

@@ -3,18 +3,16 @@
  * Licensed under the MIT License.
  */
 
+import { type IFluidLoadable } from "@fluidframework/core-interfaces";
 import { type IChannelFactory } from "@fluidframework/datastore-definitions";
 import {
 	type IFluidDataStoreFactory,
 	type NamedFluidDataStoreRegistryEntry,
-} from "@fluidframework/runtime-definitions";
-import { type IFluidLoadable } from "@fluidframework/core-interfaces";
-import {
-	type ContainerSchema,
-	type DataObjectClass,
-	type LoadableObjectClass,
-	type SharedObjectClass,
-} from "./types.js";
+} from "@fluidframework/runtime-definitions/internal";
+import type { ISharedObjectKind } from "@fluidframework/shared-object-base";
+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
@@ -35,26 +33,41 @@ export function isDataObjectClass<T extends IFluidLoadable>(
 /**
  * Runtime check to determine if a class is a DataObject type.
  */
-export function isDataObjectClass(obj: unknown): obj is InternalDataObjectClass<IFluidLoadable>;
+export function isDataObjectClass(
+	obj: LoadableObjectClass,
+): obj is InternalDataObjectClass<IFluidLoadable>;
 
 /**
  * Runtime check to determine if a class is a DataObject type.
  */
-export function isDataObjectClass(obj: unknown): obj is InternalDataObjectClass<IFluidLoadable> {
+export function isDataObjectClass(
+	obj: LoadableObjectClass,
+): obj is InternalDataObjectClass<IFluidLoadable> {
 	const maybe = obj as Partial<InternalDataObjectClass<IFluidLoadable>> | undefined;
-	return (
+	const isDataObject =
 		maybe?.factory?.IFluidDataStoreFactory !== undefined &&
-		maybe?.factory?.IFluidDataStoreFactory === maybe?.factory
-	);
+		maybe.factory.IFluidDataStoreFactory === maybe.factory;
+
+	if (
+		isDataObject ===
+		((obj as Partial<ISharedObjectKind<IFluidLoadable>>).getFactory !== undefined)
+	) {
+		// TODO: Currently nothing in the types or docs requires an actual DataObjectClass to not have a member called "getFactory" so there is a risk of this being a false positive.
+		// Refactoring the use of LoadableObjectClass such that explicit down casting is not required (for example by having a single factory API shared by both cases) could avoid problems like this.
+		throw new UsageError("Invalid LoadableObjectClass");
+	}
+
+	return isDataObject;
 }
 
 /**
  * Runtime check to determine if a class is a SharedObject type
  */
-export const isSharedObjectClass = (obj: unknown): obj is SharedObjectClass<IFluidLoadable> => {
-	const maybe = obj as Partial<SharedObjectClass<IFluidLoadable>> | undefined;
-	return maybe?.getFactory !== undefined;
-};
+export function isSharedObjectKind(
+	obj: LoadableObjectClass,
+): obj is ISharedObjectKind<IFluidLoadable> {
+	return !isDataObjectClass(obj);
+}
 
 /**
  * The ContainerSchema consists of initialObjects and dynamicObjectTypes. These types can be
@@ -67,8 +80,8 @@ export const parseDataObjectsFromSharedObjects = (
 	const registryEntries = new Set<NamedFluidDataStoreRegistryEntry>();
 	const sharedObjects = new Set<IChannelFactory>();
 
-	const tryAddObject = (obj: unknown): void => {
-		if (isSharedObjectClass(obj)) {
+	const tryAddObject = (obj: LoadableObjectClass): void => {
+		if (isSharedObjectKind(obj)) {
 			sharedObjects.add(obj.getFactory());
 		} else if (isDataObjectClass(obj)) {
 			registryEntries.add([obj.factory.type, Promise.resolve(obj.factory)]);

package/api-extractor-cjs.json

@@ -1,8 +0,0 @@
-{
-	"$schema": "https://developer.microsoft.com/json-schemas/api-extractor/v7/api-extractor.schema.json",
-	"extends": "../../../common/build/build-common/api-extractor-base.cjs.primary.json",
-	// CJS is actually secondary; so, no report.
-	"apiReport": {
-		"enabled": false
-	}
-}