@fluidframework/fluid-static 2.0.0-internal.7.4.0 → 2.0.0-internal.8.0.0

package/src/index.ts

@@ -10,17 +10,13 @@
  */
 
 export {
-	FluidContainer,
 	createFluidContainer,
 	IFluidContainer,
 	IFluidContainerEvents,
 	InitialObjects,
 } from "./fluidContainer";
-export {
-	DOProviderContainerRuntimeFactory,
-	createDOProviderContainerRuntimeFactory,
-} from "./rootDataObject";
-export { ServiceAudience, createServiceAudience } from "./serviceAudience";
+export { createDOProviderContainerRuntimeFactory } from "./rootDataObject";
+export { createServiceAudience } from "./serviceAudience";
 export {
 	ContainerSchema,
 	DataObjectClass,

package/src/rootDataObject.ts

@@ -6,23 +6,27 @@ import {
 	BaseContainerRuntimeFactory,
 	DataObject,
 	DataObjectFactory,
-	// eslint-disable-next-line import/no-deprecated
-	defaultRouteRequestHandler,
 } from "@fluidframework/aqueduct";
 import { IContainerRuntime } from "@fluidframework/container-runtime-definitions";
-import { IFluidLoadable } from "@fluidframework/core-interfaces";
+import { IFluidLoadable, IRequest } from "@fluidframework/core-interfaces";
 import { FlushMode } from "@fluidframework/runtime-definitions";
 import { IRuntimeFactory } from "@fluidframework/container-definitions";
+import { RequestParser } from "@fluidframework/runtime-utils";
+import { ContainerRuntime } from "@fluidframework/container-runtime";
 import {
 	ContainerSchema,
-	DataObjectClass,
 	IRootDataObject,
 	LoadableObjectClass,
 	LoadableObjectClassRecord,
 	LoadableObjectRecord,
 	SharedObjectClass,
 } from "./types";
-import { isDataObjectClass, isSharedObjectClass, parseDataObjectsFromSharedObjects } from "./utils";
+import {
+	InternalDataObjectClass,
+	isDataObjectClass,
+	isSharedObjectClass,
+	parseDataObjectsFromSharedObjects,
+} from "./utils";
 
 /**
  * Input props for {@link RootDataObject.initializingFirstTime}.
@@ -123,7 +127,7 @@ class RootDataObject
 	}
 
 	private async createDataObject<T extends IFluidLoadable>(
-		dataObjectClass: DataObjectClass<T>,
+		dataObjectClass: InternalDataObjectClass<T>,
 	): Promise<T> {
 		const factory = dataObjectClass.factory;
 		const packagePath = [...this.context.packagePath, factory.type];
@@ -159,10 +163,10 @@ export function createDOProviderContainerRuntimeFactory(props: {
  *
  * This data object is dynamically customized (registry and initial objects) based on the schema provided.
  * to the container runtime factory.
- * @deprecated use {@link createDOProviderContainerRuntimeFactory} instead
+ *
  * @internal
  */
-export class DOProviderContainerRuntimeFactory extends BaseContainerRuntimeFactory {
+class DOProviderContainerRuntimeFactory extends BaseContainerRuntimeFactory {
 	private readonly rootDataObjectFactory: DataObjectFactory<
 		RootDataObject,
 		{
@@ -181,21 +185,32 @@ export class DOProviderContainerRuntimeFactory extends BaseContainerRuntimeFacto
 			{},
 			registryEntries,
 		);
+		const provideEntryPoint = async (containerRuntime: IContainerRuntime) => {
+			const entryPoint =
+				await containerRuntime.getAliasedDataStoreEntryPoint(rootDataStoreId);
+			if (entryPoint === undefined) {
+				throw new Error(`default dataStore [${rootDataStoreId}] must exist`);
+			}
+			return entryPoint.get();
+		};
+		const getDefaultObject = async (request: IRequest, runtime: IContainerRuntime) => {
+			const parser = RequestParser.create(request);
+			if (parser.pathParts.length === 0) {
+				// This cast is safe as ContainerRuntime.loadRuntime is called in the base class
+				return (runtime as ContainerRuntime).resolveHandle({
+					url: `/${rootDataStoreId}${parser.query}`,
+					headers: request.headers,
+				});
+			}
+			return undefined; // continue search
+		};
 		super({
 			registryEntries: [rootDataObjectFactory.registryEntry],
-			// eslint-disable-next-line import/no-deprecated
-			requestHandlers: [defaultRouteRequestHandler(rootDataStoreId)],
+			requestHandlers: [getDefaultObject],
 			// 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
 			runtimeOptions: { flushMode: FlushMode.Immediate },
-			provideEntryPoint: async (containerRuntime: IContainerRuntime) => {
-				const entryPoint =
-					await containerRuntime.getAliasedDataStoreEntryPoint(rootDataStoreId);
-				if (entryPoint === undefined) {
-					throw new Error(`default dataStore [${rootDataStoreId}] must exist`);
-				}
-				return entryPoint.get();
-			},
+			provideEntryPoint,
 		});
 		this.rootDataObjectFactory = rootDataObjectFactory;
 		this.initialObjects = schema.initialObjects;

package/src/serviceAudience.ts

@@ -15,13 +15,7 @@ export function createServiceAudience<M extends IMember = IMember>(props: {
 	container: IContainer;
 	createServiceMember: (audienceMember: IClient) => M;
 }): IServiceAudience<M> {
-	// todo: once ServiceAudience isn't exported, we can remove abstract from it, and just use that here
-	const c = class NewServiceAudience extends ServiceAudience<M> {
-		protected createServiceMember(audienceMember: IClient) {
-			return props.createServiceMember(audienceMember);
-		}
-	};
-	return new c(props.container);
+	return new ServiceAudience(props.container, props.createServiceMember);
 }
 
 /**
@@ -33,17 +27,16 @@ export function createServiceAudience<M extends IMember = IMember>(props: {
  * the user and client details returned in {@link IMember}.
  *
  * @typeParam M - A service-specific {@link IMember} implementation.
- * @deprecated use {@link createServiceAudience} and {@link IServiceAudience} instead
  * @internal
  */
-export abstract class ServiceAudience<M extends IMember = IMember>
+class ServiceAudience<M extends IMember = IMember>
 	extends TypedEventEmitter<IServiceAudienceEvents<M>>
 	implements IServiceAudience<M>
 {
 	/**
 	 * Audience object which includes all the existing members of the {@link IFluidContainer | container}.
 	 */
-	protected readonly audience: IAudience;
+	private readonly audience: IAudience;
 
 	/**
 	 * Retain the most recent member list.
@@ -62,13 +55,14 @@ export abstract class ServiceAudience<M extends IMember = IMember>
 	 * every `addMember` event. It is mapped `clientId` to `M` to be better work with what the {@link IServiceAudience}
 	 * events provide.
 	 */
-	protected lastMembers = new Map<string, M>();
+	private lastMembers = new Map<string, M>();
 
 	constructor(
 		/**
 		 * Fluid Container to read the audience from.
 		 */
-		protected readonly container: IContainer,
+		private readonly container: IContainer,
+		private readonly createServiceMember: (audienceMember: IClient) => M,
 	) {
 		super();
 		this.audience = container.audience;
@@ -95,13 +89,6 @@ export abstract class ServiceAudience<M extends IMember = IMember>
 		this.container.on("connected", () => this.emit("membersChanged"));
 	}
 
-	/**
-	 * Provides ability for inheriting class to modify/extend the audience object.
-	 *
-	 * @param audienceMember - Record of a specific audience member.
-	 */
-	protected abstract createServiceMember(audienceMember: IClient): M;
-
 	/**
 	 * {@inheritDoc IServiceAudience.getMembers}
 	 */
@@ -170,7 +157,7 @@ export abstract class ServiceAudience<M extends IMember = IMember>
 	 *
 	 * @param member - Member to be included/omitted.
 	 */
-	protected shouldIncludeAsMember(member: IClient): boolean {
+	private shouldIncludeAsMember(member: IClient): boolean {
 		// Include only human members
 		return member.details.capabilities.interactive;
 	}

package/src/types.ts

@@ -5,7 +5,6 @@
 
 import { IEvent, IEventProvider, IFluidLoadable } from "@fluidframework/core-interfaces";
 import { IChannelFactory } from "@fluidframework/datastore-definitions";
-import { IFluidDataStoreFactory } from "@fluidframework/runtime-definitions";
 
 /**
  * A mapping of string identifiers to instantiated `DataObject`s or `SharedObject`s.
@@ -38,7 +37,7 @@ export type LoadableObjectClass<T extends IFluidLoadable> =
  * @alpha
  */
 export type DataObjectClass<T extends IFluidLoadable> = {
-	readonly factory: IFluidDataStoreFactory;
+	readonly factory: { IFluidDataStoreFactory: DataObjectClass<T>["factory"] };
 } & LoadableObjectCtor<T>;
 
 /**
@@ -107,7 +106,7 @@ export interface ContainerSchema {
  * @internal
  */
 export interface IProvideRootDataObject {
-	readonly IRootDataObject?: IRootDataObject;
+	readonly IRootDataObject: IRootDataObject;
 }
 
 /**

package/src/utils.ts

@@ -4,14 +4,31 @@
  */
 
 import { IChannelFactory } from "@fluidframework/datastore-definitions";
-import { NamedFluidDataStoreRegistryEntry } from "@fluidframework/runtime-definitions";
+import {
+	IFluidDataStoreFactory,
+	NamedFluidDataStoreRegistryEntry,
+} from "@fluidframework/runtime-definitions";
+import { IFluidLoadable } from "@fluidframework/core-interfaces";
 import { ContainerSchema, DataObjectClass, LoadableObjectClass, SharedObjectClass } from "./types";
 
+/**
+ * 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 const isDataObjectClass = (obj: any): obj is DataObjectClass<any> => {
-	return obj?.factory !== undefined;
+export const isDataObjectClass = (obj: any): obj is InternalDataObjectClass<IFluidLoadable> => {
+	const maybe: Partial<InternalDataObjectClass<IFluidLoadable>> | undefined = obj;
+	return (
+		maybe?.factory?.IFluidDataStoreFactory !== undefined &&
+		maybe?.factory?.IFluidDataStoreFactory === maybe?.factory
+	);
 };
 
 /**