@fluidframework/local-driver 3.1.0 → 3.2.0

package/src/ephemeralService.ts

@@ -24,7 +24,6 @@ import {
 	type DataStoreRegistry,
 	type FluidContainerAttached,
 	type FluidContainerWithService,
-	type OldestSupportedServiceClientVersion,
 	type Registry,
 	type ServiceClient,
 	type ServiceOptions,
@@ -41,10 +40,13 @@ import {
 	LocalDeltaConnectionServer,
 	type ILocalDeltaConnectionServer,
 } from "@fluidframework/server-local-server";
+import type { ITestDbFactory } from "@fluidframework/server-test-utils";
 import { UsageError } from "@fluidframework/driver-utils/internal";
+import { v4 as uuid } from "uuid";
 
 import { LocalDocumentServiceFactory } from "./localDocumentServiceFactory.js";
 import { createLocalResolverCreateNewRequest, LocalResolver } from "./localResolver.js";
+import { LocalSessionStorageDbFactory } from "./localSessionStorageDb.js";
 import { pkgVersion } from "./packageVersion.js";
 
 /**
@@ -63,13 +65,39 @@ export function startEphemeralService(isDefault = true): EphemeralService {
 		throw new UsageError("A default EphemeralService is already running");
 	}
 
-	const service = new EphemeralServiceImplementation();
+	const service = new LocalServiceImplementation();
 	if (isDefault) {
 		defaultEphemeralService = service;
 	}
 	return service;
 }
 
+/**
+ * Gets the session-storage-backed local Fluid service for the current JavaScript realm, creating it on first use.
+ *
+ * @remarks
+ * Attached documents remain available after a page reload within the same browser tab. Repeated calls return
+ * the same service instance within the current JavaScript realm.
+ *
+ * This service is only available in browser environments that provide `sessionStorage`.
+ * @returns A local service backed by browser session storage.
+ * @alpha
+ */
+export function getSessionService(): SessionService {
+	if (typeof sessionStorage === "undefined") {
+		throw new UsageError("SessionService requires browser session storage");
+	}
+	return (sessionService ??= new LocalServiceImplementation(
+		new LocalSessionStorageDbFactory(),
+	));
+}
+
+/** Closes and clears the current session service for test isolation. */
+export async function resetSessionServiceForTesting(): Promise<void> {
+	await sessionService?.close();
+	sessionService = undefined;
+}
+
 /**
  * Cleans up the service passed in {@link startEphemeralService}, or the {@link getDefaultEphemeralService|default} if none is passed.
  * @remarks
@@ -102,24 +130,100 @@ export function getDefaultEphemeralService(): EphemeralService {
 }
 
 /**
- * Internal Options for creating an {@link EphemeralServiceClient}, extending {@link @fluidframework/driver-definitions#ServiceOptions}
- * with the {@link EphemeralService} the client should connect to.
+ * Internal options for creating a local service client, extending
+ * {@link @fluidframework/driver-definitions#ServiceOptions} with the service the client should connect to.
  * @input
  * @internal
  */
-export interface EphemeralServiceOptions extends ServiceOptions {
+export interface LocalServiceOptions<TService extends LocalService = LocalService>
+	extends ServiceOptions {
 	/**
-	 * {@inheritdoc @fluidframework/driver-definitions#ServiceOptions.oldestSupportedClient}
+	 * The service instance to connect to.
 	 */
-	readonly oldestSupportedClient: OldestSupportedServiceClientVersion;
+	readonly service: TService;
+}
+
+/**
+ * Internal options for creating a {@link LocalServiceClient} connected to an {@link EphemeralService}.
+ * @input
+ * @internal
+ */
+export interface EphemeralServiceOptions extends LocalServiceOptions<EphemeralService> {}
+
+/**
+ * A local Fluid service with an explicitly managed lifecycle.
+ * @remarks
+ * There are two implementations of this interface with different document lifetimes:
+ * {@link EphemeralService} and {@link SessionService}.
+ *
+ * @typeParam TClient - The type of client this service creates.
+ * @alpha @sealed
+ */
+export interface LocalService<out TClient extends ServiceClient = LocalServiceClient>
+	extends ErasedBaseType<readonly ["LocalService", TClient]> {
 	/**
-	 * The service instance to connect to.
+	 * Lists the IDs of documents currently stored by this service.
+	 */
+	listDocumentIds(): Promise<readonly string[]>;
+
+	/**
+	 * Deletes a stored document.
+	 *
+	 * @remarks
+	 * Deletion is only allowed when this service has no open containers because resetting the local
+	 * server invalidates all of its active connections. Content-addressed summary data shared with other
+	 * documents may be retained until {@link LocalService.deleteAllDocuments} is called.
+	 * Only one call to {@link LocalService.deleteDocument} or {@link LocalService.deleteAllDocuments}
+	 * may be in progress at a time.
+	 *
+	 * @param id - The ID of the document to delete.
+	 * @throws A `UsageError` if the service is closed, another document deletion is in progress, or the
+	 * service has open containers.
 	 */
-	readonly service: EphemeralService;
+	deleteDocument(id: string): Promise<void>;
+
+	/**
+	 * Deletes all documents stored by this service.
+	 *
+	 * @remarks
+	 * Deletion is only allowed when this service has no open containers because resetting the local
+	 * server invalidates all of its active connections.
+	 * Only one call to {@link LocalService.deleteDocument} or {@link LocalService.deleteAllDocuments}
+	 * may be in progress at a time.
+	 * @throws A `UsageError` if the service is closed, another document deletion is in progress, or the
+	 * service has open containers.
+	 */
+	deleteAllDocuments(): Promise<void>;
+
+	/**
+	 * Drives all containers connected to this service toward convergence, processing pending operations and
+	 * waiting for all dirty containers to save.
+	 *
+	 * @param timeoutMilliseconds - The maximum time to wait for containers to quiesce, in milliseconds. Defaults to 30_000.
+	 * @throws A `UsageError` if the containers do not quiesce before the timeout expires.
+	 *
+	 * @privateRemarks
+	 * This is a best-effort implementation simplified from `LoaderContainerTracker.ensureSynchronized`.
+	 * Currently it does not perform receiver-side sequence-number quiescence or wait for join/leave (audience) ops.
+	 * See `LoaderContainerTracker.ensureSynchronized` for the fuller version this is based on.
+	 */
+	synchronize(timeoutMilliseconds?: number): Promise<void>;
+
+	/**
+	 * Creates a client connected to this service.
+	 *
+	 * @param options - Collaboration options for the client.
+	 */
+	newClient(options: ServiceOptions): TClient;
+
+	/**
+	 * A client connected to this service using the default options.
+	 */
+	readonly defaultClient: TClient;
 }
 
 /**
- * An in-memory Fluid service that can produce connected {@link EphemeralServiceClient}s.
+ * An in-memory Fluid service that can produce connected {@link LocalServiceClient}s.
  * @remarks
  * All documents created through clients connected to a given `EphemeralService` are held in-memory by that service.
  * Closing the service (via {@link EphemeralService.close} or {@link cleanupEphemeralService}) closes the connections
@@ -137,20 +241,20 @@ export interface EphemeralServiceOptions extends ServiceOptions {
  * document with different `oldestSupportedClient` values.
  * This also exposes a place to put APIs for preloading and exporting document contents in the future.
  *
- * This is an erased type: its only implementation is the module-private {@link EphemeralServiceImplementation}, which holds
+ * This is an erased type: its only implementation is the module-private `LocalServiceImplementation`, which holds
  * the mutable server and container state so it does not appear on this public type.
  *
  * TODO: formalize this lifecycle with an interface which documents these stages.
  * Lifecycle:
  * The intended lifecycle of an {@link EphemeralService} follows roughly the same pattern as containers:
  *
- * 1. Open: accepts connections from {@link EphemeralServiceClient}s, which can create and load containers.
+ * 1. Open: accepts connections from {@link LocalServiceClient}s, which can create and load containers.
  * Might have timers and event registrations which can trigger asynchronous work, and retain the object in memory.
  *
  * 2. Closing: asynchronous transition from open to closed. New use should behave as it closed, but may be cleaning up or saving resources asynchronously.
  * Timers and event registrations may still be active, but should be cleaned up by the time the transition to closed completes.
  *
- * 3. Closed: no longer accepts connections from {@link EphemeralServiceClient}s, and all containers connected to it are closed.
+ * 3. Closed: no longer accepts connections from {@link LocalServiceClient}s, and all containers connected to it are closed.
  * Should have no subscriptions to events or timers which could retain it in memory or trigger asynchronous work.
  * The object can still be used in a limited capacity (typically just to inspect its status (e.g. `isClosed`), and to view (but not edit) the final state of any containers which were connected to it before it closed.)
  *
@@ -159,106 +263,106 @@ export interface EphemeralServiceOptions extends ServiceOptions {
  *
  * @alpha @sealed
  */
-export interface EphemeralService extends ErasedBaseType<readonly ["EphemeralService"]> {
-	/**
-	 * Close this service, which closes all containers connected to it and releases its resources.
-	 * @remarks
-	 * All documents held by this service are discarded, and any timers it (or its containers) were keeping alive
-	 * are cleaned up.
-	 * The returned promise resolves once all asynchronous cleanup (including shutting down the in-memory server)
-	 * has completed.
-	 * Closing is idempotent: calling it again after the service is closed resolves without doing anything.
-	 */
-	close(): Promise<void>;
-
+export interface EphemeralService extends LocalService<LocalServiceClient<EphemeralService>> {
 	/**
-	 * Drives all containers connected to this service toward convergence, processing pending operations and
-	 * waiting for all dirty containers to save.
-	 *
-	 * @param timeoutMilliseconds - The maximum time to wait for containers to quiesce, in milliseconds. Defaults to 30_000.
-	 *
-	 * @privateRemarks
-	 * This is a best-effort implementation simplified from `LoaderContainerTracker.ensureSynchronized`.
-	 * Currently it does not perform receiver-side sequence-number quiescence or wait for join/leave (audience) ops.
-	 * See `LoaderContainerTracker.ensureSynchronized` for the fuller version this is based on.
-	 * For the currently exposed API surface, this should be sufficient,
-	 * but users down casting to internal types might run into some limitations.
-	 */
-	synchronize(timeoutMilliseconds?: number): Promise<void>;
-
-	/**
-	 * Creates and returns a {@link EphemeralServiceClient} for an in-memory, ephemeral Fluid service.
-	 *
-	 * @param options - Options for the client. `oldestSupportedClient` may be omitted because all
-	 * clients are in the same process, so it defaults to the current version. `service` may be omitted to allocate a new
-	 * {@link EphemeralService} dedicated to this client, or provided to connect the client to an existing service instance.
+	 * Closes all containers connected to this service and releases its active resources.
 	 *
 	 * @remarks
-	 * The service is ephemeral and in-memory: all documents are held by the {@link EphemeralService} the client is
-	 * connected to, and live for as long as that service is open — independent of whether any container for them is open.
-	 * A document created and attached (obtaining an `id`) can be loaded by `id` for as long as its service remains open,
-	 * even after every container for it has been closed.
-	 * Closing the service (via {@link EphemeralService.close} or {@link cleanupEphemeralService}) discards all of its
-	 * documents and releases its resources; afterwards those `id`s can no longer be loaded.
-	 *
-	 * When no `service` is provided, a new one is allocated for this client (accessible via {@link EphemeralServiceClient.service}).
-	 * Provide the same {@link EphemeralService} to multiple clients (via `options.service`) to have them collaborate on the
-	 * same documents, and control that service's lifetime explicitly.
-	 *
-	 * Since a service holds timers while open, tests should close the services they use (e.g. via
-	 * {@link cleanupEphemeralService} in an `afterEach`) to avoid lingering timers that can hang test runners.
-	 *
-	 * @privateRemarks
-	 * TODO: We should provide a way to extract (for potential serialization as test data) and load documents into a service.
-	 * This is needed to use this API surface for testing reference documents.
-	 * Ideally we would provide a service agnostic way to do the export, but likely only support loading them into the local service.
-	 * This can be done via an API on FluidContainer (or a free function taking one) to do the export, then adding a
-	 * service specific API (on {@link EphemeralService}) to load from the export format and return the ID of the loaded document.
-	 */
-	newClient(options: ServiceOptions): EphemeralServiceClient;
-
-	/**
-	 * A client connected to this service using the default options.
+	 * Closing is idempotent. Closing an ephemeral service permanently discards all documents it holds,
+	 * so their IDs can no longer be loaded.
 	 */
-	readonly defaultClient: EphemeralServiceClient;
+	close(): Promise<void>;
 }
 
+/**
+ * A browser-local Fluid service that persists documents in session storage.
+ *
+ * @remarks
+ * Its attached documents remain available after a page reload within the same browser tab. The service is
+ * shared within the current JavaScript realm and intentionally has no close operation: its active resources
+ * live until the realm is unloaded.
+ *
+ * Session storage is shared more broadly than JavaScript module state. Separate same-origin realms, such as
+ * same-origin frames, or applications that load separate copies of this package can access the same stored
+ * documents while running independent local servers. Concurrently editing the same document from such realms
+ * is unsupported and may produce inconsistent stored state.
+ *
+ * Create one with {@link getSessionService}.
+ * @alpha @sealed
+ */
+export interface SessionService extends LocalService<LocalServiceClient<SessionService>> {}
+
 /**
  * The {@link defaultEphemeralService} if one has been {@link startEphemeralService|started}.
  */
-let defaultEphemeralService: EphemeralServiceImplementation | undefined;
+let defaultEphemeralService: LocalServiceImplementation | undefined;
 
 /**
- * The concrete implementation of {@link EphemeralService}.
+ * The lazily created session service for this JavaScript realm.
+ */
+let sessionService: LocalServiceImplementation | undefined;
+
+/**
+ * The concrete implementation of local services.
  * @remarks
  * Kept module-private so its mutable state and internal helpers are not part of the public API.
- * Narrow an {@link EphemeralService} to it with `EphemeralServiceImplementation.narrow`.
+ * Narrow a {@link LocalService} to it with `LocalServiceImplementation.narrow`.
  */
-class EphemeralServiceImplementation
-	extends ErasedTypeImplementation<EphemeralService>
-	implements EphemeralService
+class LocalServiceImplementation
+	extends ErasedTypeImplementation<
+		LocalService<LocalServiceClientImplementation<LocalServiceImplementation>>
+	>
+	implements LocalService<LocalServiceClientImplementation<LocalServiceImplementation>>
 {
-	// A single server is shared by all containers connected to this service so they can communicate with each other.
-	private readonly server: ILocalDeltaConnectionServer =
-		LocalDeltaConnectionServer.create(
-			// new LocalSessionStorageDbFactory(),
-		);
-	private readonly documentServiceFactory = new LocalDocumentServiceFactory(this.server);
+	/**
+	 * The active in-memory server shared by this service's containers so they can communicate.
+	 * Replaced after document maintenance resets the server.
+	 */
+	private server: ILocalDeltaConnectionServer;
+	/** The document service factory bound to the active {@link LocalServiceImplementation.server}. */
+	private documentServiceFactory: LocalDocumentServiceFactory;
+	/** The persistent database factory retained when the active server is replaced. */
+	private readonly databaseFactory: ITestDbFactory;
+	/** The open containers connected to this service. */
 	private readonly containers = new Set<EphemeralServiceContainer<unknown>>();
+	/** Whether this service has been permanently closed. */
 	private closed = false;
+	/** Whether document deletion is temporarily preventing other service operations. */
+	private maintenanceInProgress = false;
 
-	public constructor() {
+	public constructor(databaseFactory?: ITestDbFactory) {
 		super();
+		this.server = LocalDeltaConnectionServer.create(databaseFactory);
+		this.databaseFactory = this.server.testDbFactory;
+		this.documentServiceFactory = new LocalDocumentServiceFactory(this.server);
 		this.defaultClient = this.newClient();
 	}
-	public newClient(options?: Partial<ServiceOptions>): EphemeralServiceClient {
-		const finalOptions: EphemeralServiceOptions = {
+	public newClient(
+		options?: Partial<ServiceOptions>,
+	): LocalServiceClientImplementation<LocalServiceImplementation> {
+		const finalOptions: LocalServiceOptions<LocalServiceImplementation> = {
+			...options,
 			oldestSupportedClient: options?.oldestSupportedClient ?? featureVersion(pkgVersion),
 			service: this,
 		};
-		return new EphemeralServiceClientImplementation(finalOptions);
+		return new LocalServiceClientImplementation(finalOptions);
+	}
+	public readonly defaultClient: LocalServiceClientImplementation<LocalServiceImplementation>;
+
+	public async listDocumentIds(): Promise<readonly string[]> {
+		this.ensureAvailable();
+		const documentCollection = await this.server.databaseManager.getDocumentCollection();
+		const documents = await documentCollection.findAll();
+		return documents.map((document) => document.documentId);
+	}
+
+	public async deleteDocument(id: string): Promise<void> {
+		await this.deleteDocuments(id);
+	}
+
+	public async deleteAllDocuments(): Promise<void> {
+		await this.deleteDocuments();
 	}
-	public readonly defaultClient: EphemeralServiceClient;
 
 	public async close(): Promise<void> {
 		if (this.closed) {
@@ -279,6 +383,67 @@ class EphemeralServiceImplementation
 		await this.server.close();
 	}
 
+	private ensureAvailable(): void {
+		if (this.closed) {
+			throw new UsageError("Local service is closed");
+		}
+		if (this.maintenanceInProgress) {
+			throw new UsageError("Local service document maintenance is already in progress");
+		}
+	}
+
+	/**
+	 * Delete all documents unless `id` is specified, in which case only that document is deleted.
+	 */
+	private async deleteDocuments(id?: string): Promise<void> {
+		this.ensureAvailable();
+		if (this.containers.size > 0) {
+			throw new UsageError("Close all containers before deleting local service documents");
+		}
+
+		this.maintenanceInProgress = true;
+		let serverClosed = false;
+		try {
+			await this.server.close();
+			serverClosed = true;
+			const databaseManager = this.server.databaseManager;
+			const filter = id === undefined ? {} : { documentId: id };
+			const historianDatabase = this.databaseFactory.testDatabase;
+			const documentCollection = await databaseManager.getDocumentCollection();
+			const checkpointCollection = await databaseManager.getCheckpointCollection();
+			const deltaCollection = await databaseManager.getDeltaCollection(undefined, id);
+			const scribeDeltaCollection = await databaseManager.getScribeDeltaCollection(
+				undefined,
+				id,
+			);
+			const deletions = [
+				documentCollection.deleteMany(filter),
+				checkpointCollection.deleteMany(filter),
+				deltaCollection.deleteMany(filter),
+				scribeDeltaCollection.deleteMany(filter),
+				historianDatabase
+					.collection("refs")
+					.deleteMany(id === undefined ? {} : { _id: `heads/${id}` }),
+			];
+			if (id === undefined) {
+				const nodeCollection = await databaseManager.getNodeCollection();
+				deletions.push(
+					nodeCollection.deleteMany({}),
+					historianDatabase.collection("blobs").deleteMany({}),
+					historianDatabase.collection("commits").deleteMany({}),
+					historianDatabase.collection("trees").deleteMany({}),
+				);
+			}
+			await Promise.all(deletions);
+		} finally {
+			if (serverClosed) {
+				this.server = LocalDeltaConnectionServer.create(this.databaseFactory);
+				this.documentServiceFactory = new LocalDocumentServiceFactory(this.server);
+			}
+			this.maintenanceInProgress = false;
+		}
+	}
+
 	public async synchronize(timeoutMilliseconds = 30_000): Promise<void> {
 		// Timeout to allow for better errors in the case of hangs.
 		let timedOut = false;
@@ -366,6 +531,7 @@ class EphemeralServiceImplementation
 	 * @remarks Internal helper for {@link EphemeralServiceContainer}; not part of the public {@link EphemeralService} API.
 	 */
 	public getDocumentServiceFactory(): LocalDocumentServiceFactory {
+		this.ensureAvailable();
 		assert(
 			!this.closed,
 			0xd11 /* Cannot create or load containers on a closed EphemeralService */,
@@ -391,23 +557,27 @@ class EphemeralServiceImplementation
 }
 
 /**
- * A {@link @fluidframework/driver-definitions#ServiceClient} connected to a specific {@link EphemeralService}.
+ * A {@link @fluidframework/driver-definitions#ServiceClient} connected to a specific {@link LocalService}.
+ *
+ * @typeParam TService - The type of local service this client is connected to.
  * @alpha @sealed
  */
-export interface EphemeralServiceClient extends ServiceClient {
+export interface LocalServiceClient<
+	out TService extends LocalService<ServiceClient> = LocalService<ServiceClient>,
+> extends ServiceClient {
 	/**
 	 * The service instance this client is connected to.
 	 */
-	readonly service: EphemeralService;
+	readonly service: TService;
 }
 
-class EphemeralServiceClientImplementation
-	extends ServiceClientImplementation<EphemeralServiceOptions>
-	implements EphemeralServiceClient
+class LocalServiceClientImplementation<TService extends LocalService>
+	extends ServiceClientImplementation<LocalServiceOptions<TService>>
+	implements LocalServiceClient
 {
-	public readonly service: EphemeralService;
+	public readonly service: TService;
 
-	public constructor(options: EphemeralServiceOptions) {
+	public constructor(options: LocalServiceOptions<TService>) {
 		super(options, EphemeralServiceContainer);
 		this.service = options.service;
 	}
@@ -452,8 +622,6 @@ const createLoadExistingRequest = (documentId: string): IRequest => {
 	return { url: `http://localhost:3000/${documentId}` };
 };
 
-let documentIdCounter = 0;
-
 /**
  * A Fluid container backed by an ephemeral (in-memory) local service, implementing
  * {@link @fluidframework/driver-definitions#FluidContainerWithService}.
@@ -465,19 +633,20 @@ let documentIdCounter = 0;
  * @internal
  */
 export class EphemeralServiceContainer<TData>
-	extends ServiceContainerBase<TData, EphemeralServiceOptions>
+	extends ServiceContainerBase<TData, LocalServiceOptions>
 	implements FluidContainerWithService<TData>
 {
-	public readonly service: EphemeralService;
+	public readonly service: LocalService;
 
 	public static async createDetached<T>(
 		registry: DataStoreRegistry<T>,
-		options: EphemeralServiceOptions,
+		options: LocalServiceOptions,
 		root: DataStoreKind<T>,
 	): Promise<EphemeralServiceContainer<T>> {
-		EphemeralServiceImplementation.narrow(options.service);
+		LocalServiceImplementation.narrow(options.service);
 		const container: IContainer = await createDetachedContainer({
 			codeDetails: { package: "1.0" },
+			logger: options.logger,
 			urlResolver,
 			documentServiceFactory: options.service.getDocumentServiceFactory(),
 			codeLoader: makeCodeLoader(
@@ -499,12 +668,13 @@ export class EphemeralServiceContainer<TData>
 
 	public static async load<T>(
 		registry: DataStoreRegistry<T>,
-		options: EphemeralServiceOptions,
+		options: LocalServiceOptions,
 		id: string,
 	): Promise<EphemeralServiceContainer<T> & FluidContainerAttached<T>> {
-		EphemeralServiceImplementation.narrow(options.service);
+		LocalServiceImplementation.narrow(options.service);
 		const containerInner = await loadExistingContainer({
 			request: createLoadExistingRequest(id),
+			logger: options.logger,
 			urlResolver,
 			documentServiceFactory: options.service.getDocumentServiceFactory(),
 			codeLoader: makeCodeLoader(
@@ -530,26 +700,25 @@ export class EphemeralServiceContainer<TData>
 
 	private constructor(
 		registry: Registry<Promise<DataStoreKind<TData>>>,
-		options: EphemeralServiceOptions,
+		options: LocalServiceOptions,
 		container: IContainer,
 		data: TData,
 		id: string | undefined,
 	) {
 		super(registry, options, container, data, id);
 		this.service = options.service;
-		EphemeralServiceImplementation.narrow(this.service);
+		LocalServiceImplementation.narrow(this.service);
 		this.service.addContainer(this);
 	}
 
 	public override close(): void {
 		super.close();
 		// Remove this now-closed container from its service's set of open containers.
-		EphemeralServiceImplementation.narrow(this.service);
+		LocalServiceImplementation.narrow(this.service);
 		this.service.removeContainer(this);
 	}
 
 	protected createAttachRequest(): IRequest {
-		const documentId = (documentIdCounter++).toString();
-		return createLocalResolverCreateNewRequest(documentId);
+		return createLocalResolverCreateNewRequest(uuid());
 	}
 }

package/src/index.ts

@@ -16,11 +16,15 @@ export {
 export { LocalSessionStorageDbFactory } from "./localSessionStorageDb.js";
 export type {
 	EphemeralService,
-	EphemeralServiceClient,
 	EphemeralServiceOptions,
+	LocalService,
+	LocalServiceClient,
+	LocalServiceOptions,
+	SessionService,
 } from "./ephemeralService.js";
 export {
 	startEphemeralService,
+	getSessionService,
 	cleanupEphemeralService,
 	getDefaultEphemeralService,
 } from "./ephemeralService.js";

package/src/localSessionStorageDb.ts

@@ -8,15 +8,23 @@ import type { ICollection, IDb } from "@fluidframework/server-services-core";
 import type { ITestDbFactory } from "@fluidframework/server-test-utils";
 import { v4 as uuid } from "uuid";
 
+/** Namespace for all session-storage records owned by local-driver. */
+const sessionStorageKeyPrefix = "@fluidframework/local-driver:";
+
 /**
  * A collection for local session storage, where data is stored in the browser
  * Functions include database operations such as queries, insertion and update.
  */
 class LocalSessionStorageCollection<T> implements ICollection<T> {
+	/** Prefix that scopes session-storage records to this collection. */
+	private readonly storageKeyPrefix: string;
+
 	/**
 	 * @param collectionName - data type of the collection, e.g. blobs, deltas, trees, etc.
 	 */
-	constructor(private readonly collectionName: string) {}
+	constructor(collectionName: string) {
+		this.storageKeyPrefix = `${sessionStorageKeyPrefix}${collectionName}-`;
+	}
 
 	public aggregate(pipeline: any, options?: any): any {
 		throw new Error("Method Not Implemented");
@@ -194,14 +202,22 @@ class LocalSessionStorageCollection<T> implements ICollection<T> {
 	 * {@inheritDoc @fluidframework/server-services-core#ICollection.deleteOne}
 	 */
 	public async deleteOne(query: any): Promise<any> {
-		throw new Error("Method not implemented.");
+		const value = this.findOneInternal(query);
+		if (value !== null) {
+			sessionStorage.removeItem(`${this.storageKeyPrefix}${value._id}`);
+		}
+		return value;
 	}
 
 	/**
 	 * {@inheritDoc @fluidframework/server-services-core#ICollection.deleteMany}
 	 */
 	public async deleteMany(query: any): Promise<any> {
-		throw new Error("Method not implemented.");
+		const values = await this.find(query, undefined);
+		for (const value of values) {
+			sessionStorage.removeItem(`${this.storageKeyPrefix}${value._id}`);
+		}
+		return values;
 	}
 
 	/**
@@ -219,7 +235,7 @@ class LocalSessionStorageCollection<T> implements ICollection<T> {
 		for (let i = 0; i < sessionStorage.length; i++) {
 			const key = sessionStorage.key(i);
 			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-			if (key!.startsWith(this.collectionName)) {
+			if (key!.startsWith(this.storageKeyPrefix)) {
 				// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 				values.push(JSON.parse(sessionStorage.getItem(key!)!));
 			}
@@ -240,7 +256,7 @@ class LocalSessionStorageCollection<T> implements ICollection<T> {
 				if (!value._id) {
 					value._id = uuid();
 				}
-				sessionStorage.setItem(`${this.collectionName}-${value._id}`, JSON.stringify(value));
+				sessionStorage.setItem(`${this.storageKeyPrefix}${value._id}`, JSON.stringify(value));
 			}
 		}
 	}
@@ -254,7 +270,7 @@ class LocalSessionStorageCollection<T> implements ICollection<T> {
 	 */
 	private findOneInternal(query: any): any {
 		if (query._id) {
-			const json = sessionStorage.getItem(`${this.collectionName}-${query._id}`);
+			const json = sessionStorage.getItem(`${this.storageKeyPrefix}${query._id}`);
 			if (json) {
 				return JSON.parse(json);
 			}
@@ -263,7 +279,7 @@ class LocalSessionStorageCollection<T> implements ICollection<T> {
 			for (let i = 0; i < sessionStorage.length; i++) {
 				const ssKey = sessionStorage.key(i);
 				// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-				if (!ssKey!.startsWith(this.collectionName)) {
+				if (!ssKey!.startsWith(this.storageKeyPrefix)) {
 					continue;
 				}
 				// eslint-disable-next-line @typescript-eslint/no-non-null-assertion

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/local-driver";
-export const pkgVersion = "3.1.0";
+export const pkgVersion = "3.2.0";