@fluidframework/fluid-static 2.0.0-internal.3.0.2 → 2.0.0-internal.3.2.0

package/src/rootDataObject.ts

@@ -3,22 +3,22 @@
  * Licensed under the MIT License.
  */
 import {
-    BaseContainerRuntimeFactory,
-    DataObject,
-    DataObjectFactory,
-    defaultRouteRequestHandler,
+	BaseContainerRuntimeFactory,
+	DataObject,
+	DataObjectFactory,
+	defaultRouteRequestHandler,
 } from "@fluidframework/aqueduct";
 import { IContainerRuntime } from "@fluidframework/container-runtime-definitions";
 import { IFluidLoadable } from "@fluidframework/core-interfaces";
 import { FlushMode } from "@fluidframework/runtime-definitions";
 import {
-    ContainerSchema,
-    DataObjectClass,
-    IRootDataObject,
-    LoadableObjectClass,
-    LoadableObjectClassRecord,
-    LoadableObjectRecord,
-    SharedObjectClass,
+	ContainerSchema,
+	DataObjectClass,
+	IRootDataObject,
+	LoadableObjectClass,
+	LoadableObjectClassRecord,
+	LoadableObjectRecord,
+	SharedObjectClass,
 } from "./types";
 import { isDataObjectClass, isSharedObjectClass, parseDataObjectsFromSharedObjects } from "./utils";
 
@@ -26,111 +26,114 @@ import { isDataObjectClass, isSharedObjectClass, parseDataObjectsFromSharedObjec
  * Input props for {@link RootDataObject.initializingFirstTime}.
  */
 export interface RootDataObjectProps {
-    /**
-     * Initial object structure with which the {@link RootDataObject} will be first-time initialized.
-     *
-     * @see {@link RootDataObject.initializingFirstTime}
-     */
-    initialObjects: LoadableObjectClassRecord;
+	/**
+	 * Initial object structure with which the {@link RootDataObject} will be first-time initialized.
+	 *
+	 * @see {@link RootDataObject.initializingFirstTime}
+	 */
+	initialObjects: LoadableObjectClassRecord;
 }
 
 /**
  * The entry-point/root collaborative object of the {@link IFluidContainer | Fluid Container}.
  * Abstracts the dynamic code required to build a Fluid Container into a static representation for end customers.
  */
-export class RootDataObject extends DataObject<{ InitialState: RootDataObjectProps; }> implements IRootDataObject {
-    private readonly initialObjectsDirKey = "initial-objects-key";
-    private readonly _initialObjects: LoadableObjectRecord = {};
-
-    private get initialObjectsDir() {
-        const dir = this.root.getSubDirectory(this.initialObjectsDirKey);
-        if (dir === undefined) {
-            throw new Error("InitialObjects sub-directory was not initialized");
-        }
-        return dir;
-    }
-
-    /**
-     * The first time this object is initialized, creates each object identified in
-     * {@link RootDataObjectProps.initialObjects} and stores them as unique values in the root directory.
-     *
-     * @see {@link @fluidframework/aqueduct#PureDataObject.initializingFirstTime}
-     */
-    protected async initializingFirstTime(props: RootDataObjectProps) {
-        this.root.createSubDirectory(this.initialObjectsDirKey);
-
-        // Create initial objects provided by the developer
-        const initialObjectsP: Promise<void>[] = [];
-        Object.entries(props.initialObjects).forEach(([id, objectClass]) => {
-            const createObject = async () => {
-                const obj = await this.create(objectClass);
-                this.initialObjectsDir.set(id, obj.handle);
-            };
-            initialObjectsP.push(createObject());
-        });
-
-        await Promise.all(initialObjectsP);
-    }
-
-    /**
-     * Every time an instance is initialized, loads all of the initial objects in the root directory so they can be
-     * accessed immediately.
-     *
-     * @see {@link @fluidframework/aqueduct#PureDataObject.hasInitialized}
-     */
-    protected async hasInitialized() {
-        // We will always load the initial objects so they are available to the developer
-        const loadInitialObjectsP: Promise<void>[] = [];
-        for (const [key, value] of Array.from(this.initialObjectsDir.entries())) {
-            const loadDir = async () => {
-                const obj = await value.get();
-                Object.assign(this._initialObjects, { [key]: obj });
-            };
-            loadInitialObjectsP.push(loadDir());
-        }
-
-        await Promise.all(loadInitialObjectsP);
-    }
-
-    /**
-     * {@inheritDoc IRootDataObject.initialObjects}
-     */
-    public get initialObjects(): LoadableObjectRecord {
-        if (Object.keys(this._initialObjects).length === 0) {
-            throw new Error("Initial Objects were not correctly initialized");
-        }
-        return this._initialObjects;
-    }
-
-    /**
-     * {@inheritDoc IRootDataObject.create}
-     */
-    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);
-        }
-        throw new Error("Could not create new Fluid object because an unknown object was passed");
-    }
-
-    private async createDataObject<T extends IFluidLoadable>(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;
-    }
-
-    private createSharedObject<T extends IFluidLoadable>(
-        sharedObjectClass: SharedObjectClass<T>,
-    ): T {
-        const factory = sharedObjectClass.getFactory();
-        const obj = this.runtime.createChannel(undefined, factory.type);
-        return obj as unknown as T;
-    }
+export class RootDataObject
+	extends DataObject<{ InitialState: RootDataObjectProps }>
+	implements IRootDataObject
+{
+	private readonly initialObjectsDirKey = "initial-objects-key";
+	private readonly _initialObjects: LoadableObjectRecord = {};
+
+	private get initialObjectsDir() {
+		const dir = this.root.getSubDirectory(this.initialObjectsDirKey);
+		if (dir === undefined) {
+			throw new Error("InitialObjects sub-directory was not initialized");
+		}
+		return dir;
+	}
+
+	/**
+	 * The first time this object is initialized, creates each object identified in
+	 * {@link RootDataObjectProps.initialObjects} and stores them as unique values in the root directory.
+	 *
+	 * @see {@link @fluidframework/aqueduct#PureDataObject.initializingFirstTime}
+	 */
+	protected async initializingFirstTime(props: RootDataObjectProps) {
+		this.root.createSubDirectory(this.initialObjectsDirKey);
+
+		// Create initial objects provided by the developer
+		const initialObjectsP: Promise<void>[] = [];
+		Object.entries(props.initialObjects).forEach(([id, objectClass]) => {
+			const createObject = async () => {
+				const obj = await this.create(objectClass);
+				this.initialObjectsDir.set(id, obj.handle);
+			};
+			initialObjectsP.push(createObject());
+		});
+
+		await Promise.all(initialObjectsP);
+	}
+
+	/**
+	 * Every time an instance is initialized, loads all of the initial objects in the root directory so they can be
+	 * accessed immediately.
+	 *
+	 * @see {@link @fluidframework/aqueduct#PureDataObject.hasInitialized}
+	 */
+	protected async hasInitialized() {
+		// We will always load the initial objects so they are available to the developer
+		const loadInitialObjectsP: Promise<void>[] = [];
+		for (const [key, value] of Array.from(this.initialObjectsDir.entries())) {
+			const loadDir = async () => {
+				const obj = await value.get();
+				Object.assign(this._initialObjects, { [key]: obj });
+			};
+			loadInitialObjectsP.push(loadDir());
+		}
+
+		await Promise.all(loadInitialObjectsP);
+	}
+
+	/**
+	 * {@inheritDoc IRootDataObject.initialObjects}
+	 */
+	public get initialObjects(): LoadableObjectRecord {
+		if (Object.keys(this._initialObjects).length === 0) {
+			throw new Error("Initial Objects were not correctly initialized");
+		}
+		return this._initialObjects;
+	}
+
+	/**
+	 * {@inheritDoc IRootDataObject.create}
+	 */
+	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);
+		}
+		throw new Error("Could not create new Fluid object because an unknown object was passed");
+	}
+
+	private async createDataObject<T extends IFluidLoadable>(
+		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;
+	}
+
+	private createSharedObject<T extends IFluidLoadable>(
+		sharedObjectClass: SharedObjectClass<T>,
+	): T {
+		const factory = sharedObjectClass.getFactory();
+		const obj = this.runtime.createChannel(undefined, factory.type);
+		return obj as unknown as T;
+	}
 }
 
 const rootDataStoreId = "rootDOId";
@@ -144,42 +147,43 @@ const rootDataStoreId = "rootDOId";
  * to the container runtime factory.
  */
 export class DOProviderContainerRuntimeFactory extends BaseContainerRuntimeFactory {
-    private readonly rootDataObjectFactory: DataObjectFactory<RootDataObject, {
-        InitialState: RootDataObjectProps;
-    }>;
-
-    private readonly initialObjects: LoadableObjectClassRecord;
-
-    constructor(schema: ContainerSchema) {
-        const [registryEntries, sharedObjects] = parseDataObjectsFromSharedObjects(schema);
-        const rootDataObjectFactory =
-            new DataObjectFactory(
-                "rootDO",
-                RootDataObject,
-                sharedObjects,
-                {},
-                registryEntries,
-            );
-        super(
-            [rootDataObjectFactory.registryEntry],
-            undefined,
-            [defaultRouteRequestHandler(rootDataStoreId)],
-            // 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 },
-        );
-        this.rootDataObjectFactory = rootDataObjectFactory;
-        this.initialObjects = schema.initialObjects;
-    }
-
-    /**
-     * {@inheritDoc @fluidframework/aqueduct#BaseContainerRuntimeFactory.containerInitializingFirstTime}
-     */
-    protected async containerInitializingFirstTime(runtime: IContainerRuntime) {
-        // The first time we create the container we create the RootDataObject
-        await this.rootDataObjectFactory.createRootInstance(
-            rootDataStoreId,
-            runtime,
-            { initialObjects: this.initialObjects });
-    }
+	private readonly rootDataObjectFactory: DataObjectFactory<
+		RootDataObject,
+		{
+			InitialState: RootDataObjectProps;
+		}
+	>;
+
+	private readonly initialObjects: LoadableObjectClassRecord;
+
+	constructor(schema: ContainerSchema) {
+		const [registryEntries, sharedObjects] = parseDataObjectsFromSharedObjects(schema);
+		const rootDataObjectFactory = new DataObjectFactory(
+			"rootDO",
+			RootDataObject,
+			sharedObjects,
+			{},
+			registryEntries,
+		);
+		super(
+			[rootDataObjectFactory.registryEntry],
+			undefined,
+			[defaultRouteRequestHandler(rootDataStoreId)],
+			// 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 },
+		);
+		this.rootDataObjectFactory = rootDataObjectFactory;
+		this.initialObjects = schema.initialObjects;
+	}
+
+	/**
+	 * {@inheritDoc @fluidframework/aqueduct#BaseContainerRuntimeFactory.containerInitializingFirstTime}
+	 */
+	protected async containerInitializingFirstTime(runtime: IContainerRuntime) {
+		// The first time we create the container we create the RootDataObject
+		await this.rootDataObjectFactory.createRootInstance(rootDataStoreId, runtime, {
+			initialObjects: this.initialObjects,
+		});
+	}
 }

package/src/serviceAudience.ts

@@ -19,138 +19,141 @@ import { IServiceAudience, IServiceAudienceEvents, IMember, Myself } from "./typ
  * @typeParam M - A service-specific {@link IMember} implementation.
  */
 export abstract 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;
-
-  /**
-   * Retain the most recent member list.
-   *
-   * @remarks
-   *
-   * This is so we have more information about a member leaving the audience in the `removeMember` event.
-   *
-   * It allows us to match the behavior of the `addMember` event where it only fires on a change to the members this
-   * class exposes (and would actually produce a change in what `getMembers` returns).
-   *
-   * It also allows us to provide the client details in the event which makes it easier to find that client connection
-   * in a map keyed on the `userId` and not `clientId`.
-   *
-   * This map will always be up-to-date in a `removeMember` event because it is set once at construction and in
-   * every `addMember` event. It is mapped `clientId` to `M` to be better work with what the {@link IServiceAudience}
-   * events provide.
-   */
-  protected lastMembers: Map<string, M> = new Map();
-
-  constructor(
-    /**
-     * Fluid Container to read the audience from.
-     */
-    protected readonly container: IContainer,
-  ) {
-    super();
-    this.audience = container.audience;
-
-    // getMembers will assign lastMembers so the removeMember event has what it needs
-    // in case it would fire before getMembers otherwise gets called the first time
-    this.getMembers();
-
-    this.audience.on("addMember", (clientId: string, details: IClient) => {
-      if (this.shouldIncludeAsMember(details)) {
-        const member = this.getMember(clientId);
-        this.emit("memberAdded", clientId, member);
-        this.emit("membersChanged");
-      }
-    });
-
-    this.audience.on("removeMember", (clientId: string) => {
-      if (this.lastMembers.has(clientId)) {
-        this.emit("memberRemoved", clientId, this.lastMembers.get(clientId));
-        this.emit("membersChanged");
-      }
-    });
-
-    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}
-   */
-  public getMembers(): Map<string, M> {
-    const users = new Map<string, M>();
-    const clientMemberMap = new Map<string, M>();
-    // Iterate through the members and get the user specifics.
-    this.audience.getMembers().forEach((member: IClient, clientId: string) => {
-      if (this.shouldIncludeAsMember(member)) {
-        const userId = member.user.id;
-        // Ensure we're tracking the user
-        let user = users.get(userId);
-        if (user === undefined) {
-          user = this.createServiceMember(member);
-          users.set(userId, user);
-        }
-
-        // Add this connection to their collection
-        user.connections.push({ id: clientId, mode: member.mode });
-        clientMemberMap.set(clientId, user);
-      }
-    });
-    this.lastMembers = clientMemberMap;
-    return users;
-  }
-
-  /**
-   * {@inheritDoc IServiceAudience.getMyself}
-   */
-  public getMyself(): Myself<M> | undefined {
-    const clientId = this.container.clientId;
-    if (clientId === undefined) {
-      return undefined;
-    }
-
-    const member = this.getMember(clientId);
-    if (member === undefined) {
-        return undefined;
-      }
-
-    const myself: Myself<M> = { ...member, currentConnection: clientId };
-
-    return myself;
-  }
-
-  private getMember(clientId: string): M | undefined {
-    // Fetch the user ID assoicated with this client ID from the runtime
-    const internalAudienceMember = this.audience.getMember(clientId);
-    if (internalAudienceMember === undefined) {
-      return undefined;
-    }
-    // Return the member object with any other clients associated for this user
-    const allMembers = this.getMembers();
-    const member = allMembers.get(internalAudienceMember?.user.id);
-    if (member === undefined) {
-      throw Error(`Attempted to fetch client ${clientId} that is not part of the current member list`);
-    }
-    return member;
-  }
-
-  /**
-   * Provides ability for the inheriting class to include/omit specific members.
-   * An example use case is omitting the summarizer client.
-   *
-   * @param member - Member to be included/omitted.
-   */
-  protected shouldIncludeAsMember(member: IClient): boolean {
-    // Include only human members
-    return member.details.capabilities.interactive;
-  }
+	extends TypedEventEmitter<IServiceAudienceEvents<M>>
+	implements IServiceAudience<M>
+{
+	/**
+	 * Audience object which includes all the existing members of the {@link IFluidContainer | container}.
+	 */
+	protected readonly audience: IAudience;
+
+	/**
+	 * Retain the most recent member list.
+	 *
+	 * @remarks
+	 *
+	 * This is so we have more information about a member leaving the audience in the `removeMember` event.
+	 *
+	 * It allows us to match the behavior of the `addMember` event where it only fires on a change to the members this
+	 * class exposes (and would actually produce a change in what `getMembers` returns).
+	 *
+	 * It also allows us to provide the client details in the event which makes it easier to find that client connection
+	 * in a map keyed on the `userId` and not `clientId`.
+	 *
+	 * This map will always be up-to-date in a `removeMember` event because it is set once at construction and in
+	 * every `addMember` event. It is mapped `clientId` to `M` to be better work with what the {@link IServiceAudience}
+	 * events provide.
+	 */
+	protected lastMembers: Map<string, M> = new Map();
+
+	constructor(
+		/**
+		 * Fluid Container to read the audience from.
+		 */
+		protected readonly container: IContainer,
+	) {
+		super();
+		this.audience = container.audience;
+
+		// getMembers will assign lastMembers so the removeMember event has what it needs
+		// in case it would fire before getMembers otherwise gets called the first time
+		this.getMembers();
+
+		this.audience.on("addMember", (clientId: string, details: IClient) => {
+			if (this.shouldIncludeAsMember(details)) {
+				const member = this.getMember(clientId);
+				this.emit("memberAdded", clientId, member);
+				this.emit("membersChanged");
+			}
+		});
+
+		this.audience.on("removeMember", (clientId: string) => {
+			if (this.lastMembers.has(clientId)) {
+				this.emit("memberRemoved", clientId, this.lastMembers.get(clientId));
+				this.emit("membersChanged");
+			}
+		});
+
+		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}
+	 */
+	public getMembers(): Map<string, M> {
+		const users = new Map<string, M>();
+		const clientMemberMap = new Map<string, M>();
+		// Iterate through the members and get the user specifics.
+		this.audience.getMembers().forEach((member: IClient, clientId: string) => {
+			if (this.shouldIncludeAsMember(member)) {
+				const userId = member.user.id;
+				// Ensure we're tracking the user
+				let user = users.get(userId);
+				if (user === undefined) {
+					user = this.createServiceMember(member);
+					users.set(userId, user);
+				}
+
+				// Add this connection to their collection
+				user.connections.push({ id: clientId, mode: member.mode });
+				clientMemberMap.set(clientId, user);
+			}
+		});
+		this.lastMembers = clientMemberMap;
+		return users;
+	}
+
+	/**
+	 * {@inheritDoc IServiceAudience.getMyself}
+	 */
+	public getMyself(): Myself<M> | undefined {
+		const clientId = this.container.clientId;
+		if (clientId === undefined) {
+			return undefined;
+		}
+
+		const member = this.getMember(clientId);
+		if (member === undefined) {
+			return undefined;
+		}
+
+		const myself: Myself<M> = { ...member, currentConnection: clientId };
+
+		return myself;
+	}
+
+	private getMember(clientId: string): M | undefined {
+		// Fetch the user ID assoicated with this client ID from the runtime
+		const internalAudienceMember = this.audience.getMember(clientId);
+		if (internalAudienceMember === undefined) {
+			return undefined;
+		}
+		// Return the member object with any other clients associated for this user
+		const allMembers = this.getMembers();
+		const member = allMembers.get(internalAudienceMember?.user.id);
+		if (member === undefined) {
+			throw Error(
+				`Attempted to fetch client ${clientId} that is not part of the current member list`,
+			);
+		}
+		return member;
+	}
+
+	/**
+	 * Provides ability for the inheriting class to include/omit specific members.
+	 * An example use case is omitting the summarizer client.
+	 *
+	 * @param member - Member to be included/omitted.
+	 */
+	protected shouldIncludeAsMember(member: IClient): boolean {
+		// Include only human members
+		return member.details.capabilities.interactive;
+	}
 }