@fluidframework/local-driver 2.0.0-internal.3.0.2 → 2.0.0-internal.3.2.0

package/src/localDocumentService.ts

@@ -4,103 +4,110 @@
  */
 
 import {
-    IDocumentDeltaConnection,
-    IDocumentDeltaStorageService,
-    IDocumentService,
-    IDocumentServicePolicies,
-    IDocumentStorageService,
-    IResolvedUrl,
+	IDocumentDeltaConnection,
+	IDocumentDeltaStorageService,
+	IDocumentService,
+	IDocumentServicePolicies,
+	IDocumentStorageService,
+	IResolvedUrl,
 } from "@fluidframework/driver-definitions";
 import { IClient } from "@fluidframework/protocol-definitions";
 import { ITokenProvider } from "@fluidframework/routerlicious-driver";
 import { GitManager } from "@fluidframework/server-services-client";
 import { TestHistorian } from "@fluidframework/server-test-utils";
 import { ILocalDeltaConnectionServer } from "@fluidframework/server-local-server";
-import { LocalDeltaStorageService, LocalDocumentDeltaConnection, LocalDocumentStorageService } from ".";
+import {
+	LocalDeltaStorageService,
+	LocalDocumentDeltaConnection,
+	LocalDocumentStorageService,
+} from ".";
 /**
  * Basic implementation of a document service for local use.
  */
 export class LocalDocumentService implements IDocumentService {
-    /**
-     * @param localDeltaConnectionServer - delta connection server for ops
-     * @param tokenProvider - token provider
-     * @param tenantId - ID of tenant
-     * @param documentId - ID of document
-     */
-    constructor(
-        public readonly resolvedUrl: IResolvedUrl,
-        private readonly localDeltaConnectionServer: ILocalDeltaConnectionServer,
-        private readonly tokenProvider: ITokenProvider,
-        private readonly tenantId: string,
-        private readonly documentId: string,
-        private readonly documentDeltaConnectionsMap: Map<string, LocalDocumentDeltaConnection>,
-        public readonly policies: IDocumentServicePolicies = {},
-        private readonly innerDocumentService?: IDocumentService,
-    ) { }
+	/**
+	 * @param localDeltaConnectionServer - delta connection server for ops
+	 * @param tokenProvider - token provider
+	 * @param tenantId - ID of tenant
+	 * @param documentId - ID of document
+	 */
+	constructor(
+		public readonly resolvedUrl: IResolvedUrl,
+		private readonly localDeltaConnectionServer: ILocalDeltaConnectionServer,
+		private readonly tokenProvider: ITokenProvider,
+		private readonly tenantId: string,
+		private readonly documentId: string,
+		private readonly documentDeltaConnectionsMap: Map<string, LocalDocumentDeltaConnection>,
+		public readonly policies: IDocumentServicePolicies = {},
+		private readonly innerDocumentService?: IDocumentService,
+	) {}
 
-    public dispose() { }
+	public dispose() {}
 
-    /**
-     * Creates and returns a document storage service for local use.
-     */
-    public async connectToStorage(): Promise<IDocumentStorageService> {
-        return new LocalDocumentStorageService(
-            this.documentId,
-            new GitManager(new TestHistorian(this.localDeltaConnectionServer.testDbFactory.testDatabase)),
-            {
-                minBlobSize: 2048, // Test blob aggregation
-                maximumCacheDurationMs: 432_000_000, // 5 days in ms. Not actually enforced but shouldn't matter for any local driver scenario
-            },
-        );
-    }
+	/**
+	 * Creates and returns a document storage service for local use.
+	 */
+	public async connectToStorage(): Promise<IDocumentStorageService> {
+		return new LocalDocumentStorageService(
+			this.documentId,
+			new GitManager(
+				new TestHistorian(this.localDeltaConnectionServer.testDbFactory.testDatabase),
+			),
+			{
+				minBlobSize: 2048, // Test blob aggregation
+				maximumCacheDurationMs: 432_000_000, // 5 days in ms. Not actually enforced but shouldn't matter for any local driver scenario
+			},
+		);
+	}
 
-    /**
-     * Creates and returns a delta storage service for local use.
-     */
-    public async connectToDeltaStorage(): Promise<IDocumentDeltaStorageService> {
-        if (this.innerDocumentService) {
-            return this.innerDocumentService.connectToDeltaStorage();
-        }
-        return new LocalDeltaStorageService(
-            this.tenantId,
-            this.documentId,
-            this.localDeltaConnectionServer.databaseManager);
-    }
+	/**
+	 * Creates and returns a delta storage service for local use.
+	 */
+	public async connectToDeltaStorage(): Promise<IDocumentDeltaStorageService> {
+		if (this.innerDocumentService) {
+			return this.innerDocumentService.connectToDeltaStorage();
+		}
+		return new LocalDeltaStorageService(
+			this.tenantId,
+			this.documentId,
+			this.localDeltaConnectionServer.databaseManager,
+		);
+	}
 
-    /**
-     * Creates and returns a delta stream for local use.
-     * @param client - client data
-     */
-    public async connectToDeltaStream(client: IClient): Promise<IDocumentDeltaConnection> {
-        if (this.policies.storageOnly === true) {
-            throw new Error("can't connect to delta stream in storage-only mode");
-        }
-        if (this.innerDocumentService) {
-            return this.innerDocumentService.connectToDeltaStream(client);
-        }
-        const ordererToken = await this.tokenProvider.fetchOrdererToken(
-            this.tenantId,
-            this.documentId,
-        );
-        const documentDeltaConnection = await LocalDocumentDeltaConnection.create(
-            this.tenantId,
-            this.documentId,
-            ordererToken.jwt,
-            client,
-            this.localDeltaConnectionServer.webSocketServer,
-        );
-        const clientId = documentDeltaConnection.clientId;
+	/**
+	 * Creates and returns a delta stream for local use.
+	 * @param client - client data
+	 */
+	public async connectToDeltaStream(client: IClient): Promise<IDocumentDeltaConnection> {
+		if (this.policies.storageOnly === true) {
+			throw new Error("can't connect to delta stream in storage-only mode");
+		}
+		if (this.innerDocumentService) {
+			return this.innerDocumentService.connectToDeltaStream(client);
+		}
+		const ordererToken = await this.tokenProvider.fetchOrdererToken(
+			this.tenantId,
+			this.documentId,
+		);
+		const documentDeltaConnection = await LocalDocumentDeltaConnection.create(
+			this.tenantId,
+			this.documentId,
+			ordererToken.jwt,
+			client,
+			this.localDeltaConnectionServer.webSocketServer,
+		);
+		const clientId = documentDeltaConnection.clientId;
 
-        // Add this document service for the clientId in the document service factory.
-        this.documentDeltaConnectionsMap.set(clientId, documentDeltaConnection);
+		// Add this document service for the clientId in the document service factory.
+		this.documentDeltaConnectionsMap.set(clientId, documentDeltaConnection);
 
-        // Add a listener to remove this document service when the client is disconnected.
-        documentDeltaConnection.on("disconnect", () => {
-            this.documentDeltaConnectionsMap.delete(clientId);
-        });
+		// Add a listener to remove this document service when the client is disconnected.
+		documentDeltaConnection.on("disconnect", () => {
+			this.documentDeltaConnectionsMap.delete(clientId);
+		});
 
-        return documentDeltaConnection;
-    }
+		return documentDeltaConnection;
+	}
 }
 
 /**
@@ -111,22 +118,23 @@ export class LocalDocumentService implements IDocumentService {
  * @param documentId - ID of document
  */
 export function createLocalDocumentService(
-    resolvedUrl: IResolvedUrl,
-    localDeltaConnectionServer: ILocalDeltaConnectionServer,
-    tokenProvider: ITokenProvider,
-    tenantId: string,
-    documentId: string,
-    documentDeltaConnectionsMap: Map<string, LocalDocumentDeltaConnection>,
-    policies?: IDocumentServicePolicies,
-    innerDocumentService?: IDocumentService): IDocumentService {
-    return new LocalDocumentService(
-        resolvedUrl,
-        localDeltaConnectionServer,
-        tokenProvider,
-        tenantId,
-        documentId,
-        documentDeltaConnectionsMap,
-        policies,
-        innerDocumentService,
-    );
+	resolvedUrl: IResolvedUrl,
+	localDeltaConnectionServer: ILocalDeltaConnectionServer,
+	tokenProvider: ITokenProvider,
+	tenantId: string,
+	documentId: string,
+	documentDeltaConnectionsMap: Map<string, LocalDocumentDeltaConnection>,
+	policies?: IDocumentServicePolicies,
+	innerDocumentService?: IDocumentService,
+): IDocumentService {
+	return new LocalDocumentService(
+		resolvedUrl,
+		localDeltaConnectionServer,
+		tokenProvider,
+		tenantId,
+		documentId,
+		documentDeltaConnectionsMap,
+		policies,
+		innerDocumentService,
+	);
 }

package/src/localDocumentServiceFactory.ts

@@ -5,18 +5,21 @@
 
 import { parse } from "url";
 import {
-    IDocumentService,
-    IDocumentServiceFactory,
-    IDocumentServicePolicies,
-    IResolvedUrl,
+	IDocumentService,
+	IDocumentServiceFactory,
+	IDocumentServicePolicies,
+	IResolvedUrl,
 } from "@fluidframework/driver-definitions";
 import { ITelemetryBaseLogger } from "@fluidframework/common-definitions";
 import { DefaultTokenProvider } from "@fluidframework/routerlicious-driver";
-import { ILocalDeltaConnectionServer, LocalDeltaConnectionServer } from "@fluidframework/server-local-server";
 import {
-    ensureFluidResolvedUrl,
-    getDocAttributesFromProtocolSummary,
-    getQuorumValuesFromProtocolSummary,
+	ILocalDeltaConnectionServer,
+	LocalDeltaConnectionServer,
+} from "@fluidframework/server-local-server";
+import {
+	ensureFluidResolvedUrl,
+	getDocAttributesFromProtocolSummary,
+	getQuorumValuesFromProtocolSummary,
 } from "@fluidframework/driver-utils";
 import { ISummaryTree, NackErrorType } from "@fluidframework/protocol-definitions";
 import { defaultHash } from "@fluidframework/server-services-client";
@@ -27,124 +30,130 @@ import { createLocalDocumentService } from "./localDocumentService";
  * Implementation of document service factory for local use.
  */
 export class LocalDocumentServiceFactory implements IDocumentServiceFactory {
-    public readonly protocolName = "fluid-test:";
+	public readonly protocolName = "fluid-test:";
 
-    // A map of clientId to LocalDocumentService.
-    private readonly documentDeltaConnectionsMap: Map<string, LocalDocumentDeltaConnection> = new Map();
+	// A map of clientId to LocalDocumentService.
+	private readonly documentDeltaConnectionsMap: Map<string, LocalDocumentDeltaConnection> =
+		new Map();
 
-    /**
-     * @param localDeltaConnectionServer - delta connection server for ops
-     */
-    constructor(
-        private readonly localDeltaConnectionServer: ILocalDeltaConnectionServer,
-        private readonly policies?: IDocumentServicePolicies,
-        private readonly innerDocumentService?: IDocumentService) { }
+	/**
+	 * @param localDeltaConnectionServer - delta connection server for ops
+	 */
+	constructor(
+		private readonly localDeltaConnectionServer: ILocalDeltaConnectionServer,
+		private readonly policies?: IDocumentServicePolicies,
+		private readonly innerDocumentService?: IDocumentService,
+	) {}
 
-    public async createContainer(
-        createNewSummary: ISummaryTree | undefined,
-        resolvedUrl: IResolvedUrl,
-        logger?: ITelemetryBaseLogger,
-        clientIsSummarizer?: boolean,
-    ): Promise<IDocumentService> {
-        ensureFluidResolvedUrl(resolvedUrl);
-        if (createNewSummary === undefined) {
-            throw new Error("Empty file summary creation isn't supported in this driver.");
-        }
-        const pathName = new URL(resolvedUrl.url).pathname;
-        const pathArr = pathName.split("/");
-        const tenantId = pathArr[pathArr.length - 2];
-        const id = pathArr[pathArr.length - 1];
-        if (!this.localDeltaConnectionServer) {
-            throw new Error("Provide the localDeltaConnectionServer!!");
-        }
-        const documentStorage = (this.localDeltaConnectionServer as LocalDeltaConnectionServer).documentStorage;
+	public async createContainer(
+		createNewSummary: ISummaryTree | undefined,
+		resolvedUrl: IResolvedUrl,
+		logger?: ITelemetryBaseLogger,
+		clientIsSummarizer?: boolean,
+	): Promise<IDocumentService> {
+		ensureFluidResolvedUrl(resolvedUrl);
+		if (createNewSummary === undefined) {
+			throw new Error("Empty file summary creation isn't supported in this driver.");
+		}
+		const pathName = new URL(resolvedUrl.url).pathname;
+		const pathArr = pathName.split("/");
+		const tenantId = pathArr[pathArr.length - 2];
+		const id = pathArr[pathArr.length - 1];
+		if (!this.localDeltaConnectionServer) {
+			throw new Error("Provide the localDeltaConnectionServer!!");
+		}
+		const documentStorage = (this.localDeltaConnectionServer as LocalDeltaConnectionServer)
+			.documentStorage;
 
-        const protocolSummary = createNewSummary.tree[".protocol"] as ISummaryTree;
-        const appSummary = createNewSummary.tree[".app"] as ISummaryTree;
-        if (!(protocolSummary && appSummary)) {
-            throw new Error("Protocol and App Summary required in the full summary");
-        }
-        const documentAttributes = getDocAttributesFromProtocolSummary(protocolSummary);
-        const quorumValues = getQuorumValuesFromProtocolSummary(protocolSummary);
-        const sequenceNumber = documentAttributes.sequenceNumber;
-        await documentStorage.createDocument(
-            tenantId,
-            id,
-            appSummary,
-            sequenceNumber,
-            documentAttributes.term ?? 1,
-            defaultHash,
-            resolvedUrl.endpoints.ordererUrl ?? "",
-            resolvedUrl.endpoints.storageUrl ?? "",
-            resolvedUrl.endpoints.deltaStorageUrl ?? "",
-            quorumValues,
-            false, /* enableDiscovery */
-        );
-        return this.createDocumentService(resolvedUrl, logger, clientIsSummarizer);
-    }
+		const protocolSummary = createNewSummary.tree[".protocol"] as ISummaryTree;
+		const appSummary = createNewSummary.tree[".app"] as ISummaryTree;
+		if (!(protocolSummary && appSummary)) {
+			throw new Error("Protocol and App Summary required in the full summary");
+		}
+		const documentAttributes = getDocAttributesFromProtocolSummary(protocolSummary);
+		const quorumValues = getQuorumValuesFromProtocolSummary(protocolSummary);
+		const sequenceNumber = documentAttributes.sequenceNumber;
+		await documentStorage.createDocument(
+			tenantId,
+			id,
+			appSummary,
+			sequenceNumber,
+			documentAttributes.term ?? 1,
+			defaultHash,
+			resolvedUrl.endpoints.ordererUrl ?? "",
+			resolvedUrl.endpoints.storageUrl ?? "",
+			resolvedUrl.endpoints.deltaStorageUrl ?? "",
+			quorumValues,
+			false /* enableDiscovery */,
+		);
+		return this.createDocumentService(resolvedUrl, logger, clientIsSummarizer);
+	}
 
-    /**
-     * Creates and returns a document service for testing using the given resolved
-     * URL for the tenant ID, document ID, and token.
-     * @param resolvedUrl - resolved URL of document
-     */
-    public async createDocumentService(
-        resolvedUrl: IResolvedUrl,
-        logger?: ITelemetryBaseLogger,
-        clientIsSummarizer?: boolean,
-    ): Promise<IDocumentService> {
-        ensureFluidResolvedUrl(resolvedUrl);
+	/**
+	 * Creates and returns a document service for testing using the given resolved
+	 * URL for the tenant ID, document ID, and token.
+	 * @param resolvedUrl - resolved URL of document
+	 */
+	public async createDocumentService(
+		resolvedUrl: IResolvedUrl,
+		logger?: ITelemetryBaseLogger,
+		clientIsSummarizer?: boolean,
+	): Promise<IDocumentService> {
+		ensureFluidResolvedUrl(resolvedUrl);
 
-        const parsedUrl = parse(resolvedUrl.url);
-        const [, tenantId, documentId] = parsedUrl.path ? parsedUrl.path.split("/") : [];
-        if (!documentId || !tenantId) {
-            throw new Error(`Couldn't parse resolved url. [documentId:${documentId}][tenantId:${tenantId}]`);
-        }
+		const parsedUrl = parse(resolvedUrl.url);
+		const [, tenantId, documentId] = parsedUrl.path ? parsedUrl.path.split("/") : [];
+		if (!documentId || !tenantId) {
+			throw new Error(
+				`Couldn't parse resolved url. [documentId:${documentId}][tenantId:${tenantId}]`,
+			);
+		}
 
-        const fluidResolvedUrl = resolvedUrl;
-        const jwtToken = fluidResolvedUrl.tokens.jwt;
-        if (!jwtToken) {
-            throw new Error(`Token was not provided.`);
-        }
+		const fluidResolvedUrl = resolvedUrl;
+		const jwtToken = fluidResolvedUrl.tokens.jwt;
+		if (!jwtToken) {
+			throw new Error(`Token was not provided.`);
+		}
 
-        const tokenProvider = new DefaultTokenProvider(jwtToken);
+		const tokenProvider = new DefaultTokenProvider(jwtToken);
 
-        return createLocalDocumentService(
-            resolvedUrl,
-            this.localDeltaConnectionServer,
-            tokenProvider,
-            tenantId,
-            documentId,
-            this.documentDeltaConnectionsMap,
-            this.policies,
-            this.innerDocumentService);
-    }
+		return createLocalDocumentService(
+			resolvedUrl,
+			this.localDeltaConnectionServer,
+			tokenProvider,
+			tenantId,
+			documentId,
+			this.documentDeltaConnectionsMap,
+			this.policies,
+			this.innerDocumentService,
+		);
+	}
 
-    /**
-     * Gets the document delta connection for the clientId and asks it to disconnect the client.
-     * @param clientId - The ID of the client to be disconnected.
-     * @param disconnectReason - The reason of the disconnection.
-     */
-    public disconnectClient(clientId: string, disconnectReason: string) {
-        const documentDeltaConnection = this.documentDeltaConnectionsMap.get(clientId);
-        if (documentDeltaConnection === undefined) {
-            throw new Error(`No client with the id: ${clientId}`);
-        }
-        documentDeltaConnection.disconnectClient(disconnectReason);
-    }
+	/**
+	 * Gets the document delta connection for the clientId and asks it to disconnect the client.
+	 * @param clientId - The ID of the client to be disconnected.
+	 * @param disconnectReason - The reason of the disconnection.
+	 */
+	public disconnectClient(clientId: string, disconnectReason: string) {
+		const documentDeltaConnection = this.documentDeltaConnectionsMap.get(clientId);
+		if (documentDeltaConnection === undefined) {
+			throw new Error(`No client with the id: ${clientId}`);
+		}
+		documentDeltaConnection.disconnectClient(disconnectReason);
+	}
 
-    /**
-     * Gets the document delta connection for the clientId and asks it to nack the client.
-     * @param clientId - The ID of the client to be Nack'd.
-     * @param code - An error code number that represents the error. It will be a valid HTTP error code.
-     * @param type - Type of the Nack.
-     * @param message - A message about the nack for debugging/logging/telemetry purposes.
-     */
-    public nackClient(clientId: string, code?: number, type?: NackErrorType, message?: any) {
-        const documentDeltaConnection = this.documentDeltaConnectionsMap.get(clientId);
-        if (documentDeltaConnection === undefined) {
-            throw new Error(`No client with the id: ${clientId}`);
-        }
-        documentDeltaConnection.nackClient(code, type, message);
-    }
+	/**
+	 * Gets the document delta connection for the clientId and asks it to nack the client.
+	 * @param clientId - The ID of the client to be Nack'd.
+	 * @param code - An error code number that represents the error. It will be a valid HTTP error code.
+	 * @param type - Type of the Nack.
+	 * @param message - A message about the nack for debugging/logging/telemetry purposes.
+	 */
+	public nackClient(clientId: string, code?: number, type?: NackErrorType, message?: any) {
+		const documentDeltaConnection = this.documentDeltaConnectionsMap.get(clientId);
+		if (documentDeltaConnection === undefined) {
+			throw new Error(`No client with the id: ${clientId}`);
+		}
+		documentDeltaConnection.nackClient(code, type, message);
+	}
 }

package/src/localDocumentStorageService.ts

@@ -17,7 +17,11 @@ import {
 	IVersion,
 } from "@fluidframework/protocol-definitions";
 import { buildHierarchy } from "@fluidframework/protocol-base";
-import { GitManager, ISummaryUploadManager, SummaryTreeUploadManager } from "@fluidframework/server-services-client";
+import {
+	GitManager,
+	ISummaryUploadManager,
+	SummaryTreeUploadManager,
+} from "@fluidframework/server-services-client";
 
 export class LocalDocumentStorageService implements IDocumentStorageService {
 	// The values of this cache is useless. We only need the keys. So we are always putting
@@ -74,7 +78,10 @@ export class LocalDocumentStorageService implements IDocumentStorageService {
 		return bufferContent;
 	}
 
-	public async uploadSummaryWithContext(summary: ISummaryTree, context: ISummaryContext): Promise<string> {
+	public async uploadSummaryWithContext(
+		summary: ISummaryTree,
+		context: ISummaryContext,
+	): Promise<string> {
 		return this.summaryTreeUploadManager.writeSummaryTree(
 			summary,
 			context.ackHandle ?? "",
@@ -84,24 +91,24 @@ export class LocalDocumentStorageService implements IDocumentStorageService {
 
 	public async createBlob(file: ArrayBufferLike): Promise<ICreateBlobResponse> {
 		const uint8ArrayFile = new Uint8Array(file);
-		return this.manager.createBlob(
-			Uint8ArrayToString(
-				uint8ArrayFile, "base64"),
-			"base64").then((r) => ({ id: r.sha, url: r.url }));
+		return this.manager
+			.createBlob(Uint8ArrayToString(uint8ArrayFile, "base64"), "base64")
+			.then((r) => ({ id: r.sha, url: r.url }));
 	}
 
 	public async downloadSummary(handle: ISummaryHandle): Promise<ISummaryTree> {
 		throw new Error("NOT IMPLEMENTED!");
 	}
 
-	private async getPreviousFullSnapshot(parentHandle: string): Promise<ISnapshotTreeEx | null | undefined> {
+	private async getPreviousFullSnapshot(
+		parentHandle: string,
+	): Promise<ISnapshotTreeEx | null | undefined> {
 		return parentHandle
-			? this.getVersions(parentHandle, 1)
-				.then(async (versions) => {
+			? this.getVersions(parentHandle, 1).then(async (versions) => {
 					// Clear the cache as the getSnapshotTree call will fill the cache.
 					this.blobsShaCache.clear();
 					return this.getSnapshotTree(versions[0]);
-				})
+			  })
 			: undefined;
 	}
 }