@fluidframework/local-driver 2.0.0-dev.2.3.0.115467 → 2.0.0-dev.4.1.0.148229

package/src/localDocumentServiceFactory.ts

@@ -5,146 +5,118 @@
 
 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,
-} from "@fluidframework/driver-utils";
+import { ILocalDeltaConnectionServer } from "@fluidframework/server-local-server";
+import { ensureFluidResolvedUrl } from "@fluidframework/driver-utils";
 import { ISummaryTree, NackErrorType } from "@fluidframework/protocol-definitions";
-import { defaultHash } from "@fluidframework/server-services-client";
 import { LocalDocumentDeltaConnection } from "./localDocumentDeltaConnection";
 import { createLocalDocumentService } from "./localDocumentService";
+import { createDocument } from "./localCreateDocument";
 
 /**
  * Implementation of document service factory for local use.
  */
 export class LocalDocumentServiceFactory implements IDocumentServiceFactory {
-    public readonly protocolName = "fluid-test:";
-
-    // 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) { }
+	// A map of clientId to LocalDocumentService.
+	private readonly documentDeltaConnectionsMap: Map<string, LocalDocumentDeltaConnection> =
+		new Map();
 
-    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;
+	/**
+	 * @param localDeltaConnectionServer - delta connection server for ops
+	 */
+	constructor(
+		private readonly localDeltaConnectionServer: ILocalDeltaConnectionServer,
+		private readonly policies?: IDocumentServicePolicies,
+		private readonly innerDocumentService?: IDocumentService,
+	) {}
 
-        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);
-    }
+	public async createContainer(
+		createNewSummary: ISummaryTree | undefined,
+		resolvedUrl: IResolvedUrl,
+		logger?: ITelemetryBaseLogger,
+		clientIsSummarizer?: boolean,
+	): Promise<IDocumentService> {
+		if (!this.localDeltaConnectionServer) {
+			throw new Error("Provide the localDeltaConnectionServer!!");
+		}
+		if (createNewSummary !== undefined) {
+			ensureFluidResolvedUrl(resolvedUrl);
+			await createDocument(this.localDeltaConnectionServer, resolvedUrl, createNewSummary);
+		}
+		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

@@ -7,6 +7,7 @@ import { stringToBuffer, Uint8ArrayToString } from "@fluidframework/common-utils
 import {
 	IDocumentStorageService,
 	IDocumentStorageServicePolicies,
+	IResolvedUrl,
 	ISummaryContext,
 } from "@fluidframework/driver-definitions";
 import {
@@ -17,7 +18,14 @@ 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";
+import { ILocalDeltaConnectionServer } from "@fluidframework/server-local-server";
+import { ensureFluidResolvedUrl } from "@fluidframework/driver-utils";
+import { createDocument } from "./localCreateDocument";
 
 export class LocalDocumentStorageService implements IDocumentStorageService {
 	// The values of this cache is useless. We only need the keys. So we are always putting
@@ -32,7 +40,9 @@ export class LocalDocumentStorageService implements IDocumentStorageService {
 	constructor(
 		private readonly id: string,
 		private readonly manager: GitManager,
-		public readonly policies: IDocumentStorageServicePolicies = {},
+		public readonly policies: IDocumentStorageServicePolicies,
+		private readonly localDeltaConnectionServer?: ILocalDeltaConnectionServer,
+		private readonly resolvedUrl?: IResolvedUrl,
 	) {
 		this.summaryTreeUploadManager = new SummaryTreeUploadManager(
 			manager,
@@ -74,7 +84,21 @@ 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> {
+		if (context.referenceSequenceNumber === 0) {
+			if (this.localDeltaConnectionServer === undefined || this.resolvedUrl === undefined) {
+				throw new Error(
+					"Insufficient constructor parameters. An ILocalDeltaConnectionServer and IResolvedUrl required",
+				);
+			}
+			ensureFluidResolvedUrl(this.resolvedUrl);
+			await createDocument(this.localDeltaConnectionServer, this.resolvedUrl, summary);
+			const version = await this.getVersions(this.id, 1);
+			return version[0].id;
+		}
 		return this.summaryTreeUploadManager.writeSummaryTree(
 			summary,
 			context.ackHandle ?? "",
@@ -84,24 +108,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;
 	}
 }

package/src/localResolver.ts

@@ -7,22 +7,22 @@ import { parse } from "url";
 import { assert } from "@fluidframework/common-utils";
 import { IRequest } from "@fluidframework/core-interfaces";
 import {
-    IFluidResolvedUrl,
-    IResolvedUrl,
-    IUrlResolver,
-    DriverHeader,
+	IFluidResolvedUrl,
+	IResolvedUrl,
+	IUrlResolver,
+	DriverHeader,
 } from "@fluidframework/driver-definitions";
 import { ScopeType } from "@fluidframework/protocol-definitions";
 import { generateToken } from "./auth";
 
 export function createLocalResolverCreateNewRequest(documentId: string): IRequest {
-    const createNewRequest: IRequest = {
-        url: `http://localhost:3000/${documentId}`,
-        headers: {
-            [DriverHeader.createNew]: true,
-        },
-    };
-    return createNewRequest;
+	const createNewRequest: IRequest = {
+		url: `http://localhost:3000/${documentId}`,
+		headers: {
+			[DriverHeader.createNew]: true,
+		},
+	};
+	return createNewRequest;
 }
 
 /**
@@ -30,55 +30,55 @@ export function createLocalResolverCreateNewRequest(documentId: string): IReques
  * related local classes.
  */
 export class LocalResolver implements IUrlResolver {
-    private readonly tenantId = "tenantId";
-    private readonly tokenKey = "tokenKey";
+	private readonly tenantId = "tenantId";
+	private readonly tokenKey = "tokenKey";
 
-    constructor() { }
+	constructor() {}
 
-    /**
-     * Resolves URL requests by providing fake URLs with an actually generated
-     * token from constant test strings. The root of the URL is fake, but the
-     * remaining relative URL can still be parsed.
-     * @param request - request to handle
-     */
-    public async resolve(request: IRequest): Promise<IResolvedUrl> {
-        const parsedUrl = new URL(request.url);
-        const fullPath = `${parsedUrl.pathname.substr(1)}${parsedUrl.search}`;
-        const documentId = fullPath.split("/")[0];
-        const scopes = [ScopeType.DocRead, ScopeType.DocWrite, ScopeType.SummaryWrite];
-        const resolved: IFluidResolvedUrl = {
-            endpoints: {
-                deltaStorageUrl: `http://localhost:3000/deltas/${this.tenantId}/${documentId}`,
-                ordererUrl: "http://localhost:3000",
-                storageUrl: `http://localhost:3000/repos/${this.tenantId}`,
-            },
-            id: documentId,
-            tokens: { jwt: generateToken(this.tenantId, documentId, this.tokenKey, scopes) },
-            type: "fluid",
-            url: `fluid-test://localhost:3000/${this.tenantId}/${fullPath}`,
-        };
+	/**
+	 * Resolves URL requests by providing fake URLs with an actually generated
+	 * token from constant test strings. The root of the URL is fake, but the
+	 * remaining relative URL can still be parsed.
+	 * @param request - request to handle
+	 */
+	public async resolve(request: IRequest): Promise<IResolvedUrl> {
+		const parsedUrl = new URL(request.url);
+		const fullPath = `${parsedUrl.pathname.substr(1)}${parsedUrl.search}`;
+		const documentId = fullPath.split("/")[0];
+		const scopes = [ScopeType.DocRead, ScopeType.DocWrite, ScopeType.SummaryWrite];
+		const resolved: IFluidResolvedUrl = {
+			endpoints: {
+				deltaStorageUrl: `http://localhost:3000/deltas/${this.tenantId}/${documentId}`,
+				ordererUrl: "http://localhost:3000",
+				storageUrl: `http://localhost:3000/repos/${this.tenantId}`,
+			},
+			id: documentId,
+			tokens: { jwt: generateToken(this.tenantId, documentId, this.tokenKey, scopes) },
+			type: "fluid",
+			url: `fluid-test://localhost:3000/${this.tenantId}/${fullPath}`,
+		};
 
-        return resolved;
-    }
+		return resolved;
+	}
 
-    public async getAbsoluteUrl(resolvedUrl: IResolvedUrl, relativeUrl: string): Promise<string> {
-        let url = relativeUrl;
-        if (url.startsWith("/")) {
-            url = url.substr(1);
-        }
-        const fluidResolvedUrl = resolvedUrl as IFluidResolvedUrl;
+	public async getAbsoluteUrl(resolvedUrl: IResolvedUrl, relativeUrl: string): Promise<string> {
+		let url = relativeUrl;
+		if (url.startsWith("/")) {
+			url = url.substr(1);
+		}
+		const fluidResolvedUrl = resolvedUrl as IFluidResolvedUrl;
 
-        const parsedUrl = parse(fluidResolvedUrl.url);
-        if (parsedUrl.pathname === null) {
-            throw new Error("Url should contain tenant and docId!!");
-        }
-        const [, , documentId] = parsedUrl.pathname.split("/");
-        assert(!!documentId, 0x09a /* "'documentId' must be a defined, non-zero length string." */);
+		const parsedUrl = parse(fluidResolvedUrl.url);
+		if (parsedUrl.pathname === null) {
+			throw new Error("Url should contain tenant and docId!!");
+		}
+		const [, , documentId] = parsedUrl.pathname.split("/");
+		assert(!!documentId, 0x09a /* "'documentId' must be a defined, non-zero length string." */);
 
-        return `http://localhost:3000/${documentId}/${url}`;
-    }
+		return `http://localhost:3000/${documentId}/${url}`;
+	}
 
-    public createCreateNewRequest(documentId: string): IRequest {
-        return createLocalResolverCreateNewRequest(documentId);
-    }
+	public createCreateNewRequest(documentId: string): IRequest {
+		return createLocalResolverCreateNewRequest(documentId);
+	}
 }