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

package/src/blobCacheStorageService.ts

@@ -3,30 +3,33 @@
  * Licensed under the MIT License.
  */
 
-import { IDocumentStorageService, IDocumentStorageServicePolicies } from "@fluidframework/driver-definitions";
+import {
+	IDocumentStorageService,
+	IDocumentStorageServicePolicies,
+} from "@fluidframework/driver-definitions";
 import { DocumentStorageServiceProxy } from "./documentStorageServiceProxy";
 
 /**
  * IDocumentStorageService adapter with pre-cached blobs.
  */
 export class BlobCacheStorageService extends DocumentStorageServiceProxy {
-    constructor(
-        internalStorageService: IDocumentStorageService,
-        private readonly blobs: Map<string, ArrayBufferLike>,
-    ) {
-        super(internalStorageService);
-    }
+	constructor(
+		internalStorageService: IDocumentStorageService,
+		private readonly blobs: Map<string, ArrayBufferLike>,
+	) {
+		super(internalStorageService);
+	}
 
-    public get policies(): IDocumentStorageServicePolicies | undefined {
-        return this.internalStorageService.policies;
-    }
+	public get policies(): IDocumentStorageServicePolicies | undefined {
+		return this.internalStorageService.policies;
+	}
 
-    public async readBlob(id: string): Promise<ArrayBufferLike> {
-        const blob = this.blobs.get(id);
-        if (blob !== undefined) {
-            return blob;
-        }
+	public async readBlob(id: string): Promise<ArrayBufferLike> {
+		const blob = this.blobs.get(id);
+		if (blob !== undefined) {
+			return blob;
+		}
 
-        return this.internalStorageService.readBlob(id);
-    }
+		return this.internalStorageService.readBlob(id);
+	}
 }

package/src/buildSnapshotTree.ts

@@ -6,57 +6,60 @@
 import { assert, stringToBuffer } from "@fluidframework/common-utils";
 import * as git from "@fluidframework/gitresources";
 import {
-    FileMode,
-    ISnapshotTree,
-    ITreeEntry,
-    TreeEntry,
+	FileMode,
+	ISnapshotTree,
+	ITreeEntry,
+	TreeEntry,
 } from "@fluidframework/protocol-definitions";
 import { buildHierarchy } from "@fluidframework/protocol-base";
 import { v4 as uuid } from "uuid";
 
 function flattenCore(
-    path: string,
-    treeEntries: ITreeEntry[],
-    blobMap: Map<string, ArrayBufferLike>,
+	path: string,
+	treeEntries: ITreeEntry[],
+	blobMap: Map<string, ArrayBufferLike>,
 ): git.ITreeEntry[] {
-    const entries: git.ITreeEntry[] = [];
-    for (const treeEntry of treeEntries) {
-        const subPath = `${path}${treeEntry.path}`;
+	const entries: git.ITreeEntry[] = [];
+	for (const treeEntry of treeEntries) {
+		const subPath = `${path}${treeEntry.path}`;
 
-        if (treeEntry.type === TreeEntry.Blob) {
-            const blob = treeEntry.value;
-            const buffer = stringToBuffer(blob.contents, blob.encoding);
-            const id = uuid();
-            blobMap.set(id, buffer);
+		if (treeEntry.type === TreeEntry.Blob) {
+			const blob = treeEntry.value;
+			const buffer = stringToBuffer(blob.contents, blob.encoding);
+			const id = uuid();
+			blobMap.set(id, buffer);
 
-            const entry: git.ITreeEntry = {
-                mode: FileMode[treeEntry.mode],
-                path: subPath,
-                sha: id,
-                size: 0,
-                type: "blob",
-                url: "",
-            };
-            entries.push(entry);
-        } else if (treeEntry.type === TreeEntry.Tree) {
-            assert(treeEntry.type === TreeEntry.Tree, 0x101 /* "Unexpected tree entry type on flatten!" */);
-            const t = treeEntry.value;
-            const entry: git.ITreeEntry = {
-                mode: FileMode[treeEntry.mode],
-                path: subPath,
-                sha: "",
-                size: -1,
-                type: "tree",
-                url: "",
-            };
-            entries.push(entry);
+			const entry: git.ITreeEntry = {
+				mode: FileMode[treeEntry.mode],
+				path: subPath,
+				sha: id,
+				size: 0,
+				type: "blob",
+				url: "",
+			};
+			entries.push(entry);
+		} else if (treeEntry.type === TreeEntry.Tree) {
+			assert(
+				treeEntry.type === TreeEntry.Tree,
+				0x101 /* "Unexpected tree entry type on flatten!" */,
+			);
+			const t = treeEntry.value;
+			const entry: git.ITreeEntry = {
+				mode: FileMode[treeEntry.mode],
+				path: subPath,
+				sha: "",
+				size: -1,
+				type: "tree",
+				url: "",
+			};
+			entries.push(entry);
 
-            const subTreeEntries = flattenCore(`${subPath}/`, t.entries, blobMap);
-            entries.push(...subTreeEntries);
-        }
-    }
+			const subTreeEntries = flattenCore(`${subPath}/`, t.entries, blobMap);
+			entries.push(...subTreeEntries);
+		}
+	}
 
-    return entries;
+	return entries;
 }
 
 /**
@@ -67,12 +70,12 @@ function flattenCore(
  * @returns A flatten with of the ITreeEntry
  */
 function flatten(tree: ITreeEntry[], blobMap: Map<string, ArrayBufferLike>): git.ITree {
-    const entries = flattenCore("", tree, blobMap);
-    return {
-        sha: "",
-        tree: entries,
-        url: "",
-    };
+	const entries = flattenCore("", tree, blobMap);
+	return {
+		sha: "",
+		tree: entries,
+		url: "",
+	};
 }
 
 /**
@@ -84,9 +87,9 @@ function flatten(tree: ITreeEntry[], blobMap: Map<string, ArrayBufferLike>): git
  * @returns the hierarchical tree
  */
 export function buildSnapshotTree(
-    entries: ITreeEntry[],
-    blobMap: Map<string, ArrayBufferLike>,
+	entries: ITreeEntry[],
+	blobMap: Map<string, ArrayBufferLike>,
 ): ISnapshotTree {
-    const flattened = flatten(entries, blobMap);
-    return buildHierarchy(flattened);
+	const flattened = flatten(entries, blobMap);
+	return buildHierarchy(flattened);
 }

package/src/documentStorageServiceProxy.ts

@@ -4,62 +4,68 @@
  */
 
 import {
-    FetchSource,
-    IDocumentStorageService,
-    IDocumentStorageServicePolicies,
-    ISummaryContext,
+	FetchSource,
+	IDocumentStorageService,
+	IDocumentStorageServicePolicies,
+	ISummaryContext,
 } from "@fluidframework/driver-definitions";
 import {
-    ICreateBlobResponse,
-    ISnapshotTree,
-    ISummaryHandle,
-    ISummaryTree,
-    IVersion,
+	ICreateBlobResponse,
+	ISnapshotTree,
+	ISummaryHandle,
+	ISummaryTree,
+	IVersion,
 } from "@fluidframework/protocol-definitions";
 
 export class DocumentStorageServiceProxy implements IDocumentStorageService {
-    private _policies: IDocumentStorageServicePolicies | undefined;
+	private _policies: IDocumentStorageServicePolicies | undefined;
 
-    public set policies(policies: IDocumentStorageServicePolicies | undefined) {
-        this._policies = policies;
-    }
+	public set policies(policies: IDocumentStorageServicePolicies | undefined) {
+		this._policies = policies;
+	}
 
-    public get policies() {
-        return this._policies ?? this.internalStorageService.policies;
-    }
+	public get policies() {
+		return this._policies ?? this.internalStorageService.policies;
+	}
 
-    public get repositoryUrl(): string {
-        return this.internalStorageService.repositoryUrl;
-    }
+	public get repositoryUrl(): string {
+		return this.internalStorageService.repositoryUrl;
+	}
 
-    constructor(protected readonly internalStorageService: IDocumentStorageService) { }
+	constructor(protected readonly internalStorageService: IDocumentStorageService) {}
 
-    public async getSnapshotTree(version?: IVersion, scenarioName?: string): Promise<ISnapshotTree | null> {
-        return this.internalStorageService.getSnapshotTree(version, scenarioName);
-    }
+	public async getSnapshotTree(
+		version?: IVersion,
+		scenarioName?: string,
+	): Promise<ISnapshotTree | null> {
+		return this.internalStorageService.getSnapshotTree(version, scenarioName);
+	}
 
-    public async getVersions(
-        versionId: string | null,
-        count: number,
-        scenarioName?: string,
-        fetchSource?: FetchSource,
-    ): Promise<IVersion[]> {
-        return this.internalStorageService.getVersions(versionId, count, scenarioName, fetchSource);
-    }
+	public async getVersions(
+		versionId: string | null,
+		count: number,
+		scenarioName?: string,
+		fetchSource?: FetchSource,
+	): Promise<IVersion[]> {
+		return this.internalStorageService.getVersions(versionId, count, scenarioName, fetchSource);
+	}
 
-    public async uploadSummaryWithContext(summary: ISummaryTree, context: ISummaryContext): Promise<string> {
-        return this.internalStorageService.uploadSummaryWithContext(summary, context);
-    }
+	public async uploadSummaryWithContext(
+		summary: ISummaryTree,
+		context: ISummaryContext,
+	): Promise<string> {
+		return this.internalStorageService.uploadSummaryWithContext(summary, context);
+	}
 
-    public async downloadSummary(handle: ISummaryHandle): Promise<ISummaryTree> {
-        return this.internalStorageService.downloadSummary(handle);
-    }
+	public async downloadSummary(handle: ISummaryHandle): Promise<ISummaryTree> {
+		return this.internalStorageService.downloadSummary(handle);
+	}
 
-    public async createBlob(file: ArrayBufferLike): Promise<ICreateBlobResponse> {
-        return this.internalStorageService.createBlob(file);
-    }
+	public async createBlob(file: ArrayBufferLike): Promise<ICreateBlobResponse> {
+		return this.internalStorageService.createBlob(file);
+	}
 
-    public async readBlob(blobId: string): Promise<ArrayBufferLike> {
-        return this.internalStorageService.readBlob(blobId);
-    }
+	public async readBlob(blobId: string): Promise<ArrayBufferLike> {
+		return this.internalStorageService.readBlob(blobId);
+	}
 }

package/src/emptyDocumentDeltaStorageService.ts

@@ -11,14 +11,15 @@ import { Queue } from "./parallelRequests";
  * Implementation of IDocumentDeltaStorageService that will always return an empty message queue when fetching messages
  */
 export class EmptyDocumentDeltaStorageService implements IDocumentDeltaStorageService {
-    public fetchMessages(from: number,
-        _to: number | undefined,
-        _abortSignal?: AbortSignal,
-        _cachedOnly?: boolean,
-        _fetchReason?: string,
-    ): IStream<ISequencedDocumentMessage[]> {
-        const queue = new Queue<ISequencedDocumentMessage[]>();
-        queue.pushDone();
-        return queue;
-    }
+	public fetchMessages(
+		from: number,
+		_to: number | undefined,
+		_abortSignal?: AbortSignal,
+		_cachedOnly?: boolean,
+		_fetchReason?: string,
+	): IStream<ISequencedDocumentMessage[]> {
+		const queue = new Queue<ISequencedDocumentMessage[]>();
+		queue.pushDone();
+		return queue;
+	}
 }

package/src/error.ts

@@ -8,12 +8,10 @@ import { IFluidErrorBase, LoggingError } from "@fluidframework/telemetry-utils";
 
 /** Error indicating an API is being used improperly resulting in an invalid operation. */
 export class UsageError extends LoggingError implements IDriverErrorBase, IFluidErrorBase {
-    readonly errorType = DriverErrorType.usageError;
-    readonly canRetry = false;
+	readonly errorType = DriverErrorType.usageError;
+	readonly canRetry = false;
 
-    constructor(
-        message: string,
-    ) {
-        super(message, { usageError: true });
-    }
+	constructor(message: string) {
+		super(message, { usageError: true });
+	}
 }

package/src/fluidResolvedUrl.ts

@@ -5,11 +5,14 @@
 
 import { IResolvedUrl, IFluidResolvedUrl } from "@fluidframework/driver-definitions";
 
-export const isFluidResolvedUrl =
-    (resolved: IResolvedUrl | undefined): resolved is IFluidResolvedUrl => resolved?.type === "fluid";
+export const isFluidResolvedUrl = (
+	resolved: IResolvedUrl | undefined,
+): resolved is IFluidResolvedUrl => resolved?.type === "fluid";
 
-export function ensureFluidResolvedUrl(resolved: IResolvedUrl | undefined): asserts resolved is IFluidResolvedUrl {
-    if (!isFluidResolvedUrl(resolved)) {
-        throw new Error(`resolved is not a Fluid url. Type: ${resolved?.type}`);
-    }
+export function ensureFluidResolvedUrl(
+	resolved: IResolvedUrl | undefined,
+): asserts resolved is IFluidResolvedUrl {
+	if (!isFluidResolvedUrl(resolved)) {
+		throw new Error(`resolved is not a Fluid url. Type: ${resolved?.type}`);
+	}
 }

package/src/index.ts

@@ -59,4 +59,8 @@ export {
 	getQuorumValuesFromProtocolSummary,
 } from "./summaryForCreateNew";
 export { convertSummaryTreeToSnapshotITree } from "./treeConversions";
-export { convertSnapshotAndBlobsToSummaryTree, ISummaryTreeAssemblerProps, SummaryTreeAssembler } from "./treeUtils";
+export {
+	convertSnapshotAndBlobsToSummaryTree,
+	ISummaryTreeAssemblerProps,
+	SummaryTreeAssembler,
+} from "./treeUtils";

package/src/insecureUrlResolver.ts

@@ -7,10 +7,10 @@ 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 Axios from "axios";
 
@@ -29,128 +29,139 @@ import Axios from "axios";
  * works or a router inside of a single page app framework.
  */
 export class InsecureUrlResolver implements IUrlResolver {
-    private readonly cache = new Map<string, Promise<IResolvedUrl>>();
+	private readonly cache = new Map<string, Promise<IResolvedUrl>>();
 
-    constructor(
-        private readonly hostUrl: string,
-        private readonly ordererUrl: string,
-        private readonly storageUrl: string,
-        private readonly tenantId: string,
-        private readonly bearer: string,
-        private readonly isForNodeTest: boolean = false,
-    ) { }
+	constructor(
+		private readonly hostUrl: string,
+		private readonly ordererUrl: string,
+		private readonly storageUrl: string,
+		private readonly tenantId: string,
+		private readonly bearer: string,
+		private readonly isForNodeTest: boolean = false,
+	) {}
 
-    public async resolve(request: IRequest): Promise<IResolvedUrl | undefined> {
-        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-        if (request.headers?.[DriverHeader.createNew]) {
-            const [, queryString] = request.url.split("?");
-            const searchParams = new URLSearchParams(queryString);
-            const fileName = searchParams.get("fileName");
-            return this.resolveHelper(fileName);
-        }
-        const parsedUrl = new URL(request.url);
-        // If hosts match then we use the local tenant information. Otherwise we make a REST call out to the hosting
-        // service using our bearer token.
-        if (this.isForNodeTest) {
-            const [, documentId, tmpRelativePath] = parsedUrl.pathname.substr(1).split("/");
-            const relativePath = tmpRelativePath === undefined ? "" : tmpRelativePath;
-            return this.resolveHelper(documentId, relativePath, parsedUrl.search);
-        } else if (parsedUrl.host === window.location.host) {
-            const fullPath = parsedUrl.pathname.substr(1);
-            const documentId = fullPath.split("/")[0];
-            const documentRelativePath = fullPath.slice(documentId.length);
-            return this.resolveHelper(documentId, documentRelativePath);
-        } else {
-            const maybeResolvedUrl = this.cache.get(request.url);
-            if (maybeResolvedUrl) {
-                return maybeResolvedUrl;
-            }
+	public async resolve(request: IRequest): Promise<IResolvedUrl | undefined> {
+		// eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+		if (request.headers?.[DriverHeader.createNew]) {
+			const [, queryString] = request.url.split("?");
+			const searchParams = new URLSearchParams(queryString);
+			const fileName = searchParams.get("fileName");
+			return this.resolveHelper(fileName);
+		}
+		const parsedUrl = new URL(request.url);
+		// If hosts match then we use the local tenant information. Otherwise we make a REST call out to the hosting
+		// service using our bearer token.
+		if (this.isForNodeTest) {
+			const [, documentId, tmpRelativePath] = parsedUrl.pathname.substr(1).split("/");
+			const relativePath = tmpRelativePath === undefined ? "" : tmpRelativePath;
+			return this.resolveHelper(documentId, relativePath, parsedUrl.search);
+		} else if (parsedUrl.host === window.location.host) {
+			const fullPath = parsedUrl.pathname.substr(1);
+			const documentId = fullPath.split("/")[0];
+			const documentRelativePath = fullPath.slice(documentId.length);
+			return this.resolveHelper(documentId, documentRelativePath);
+		} else {
+			const maybeResolvedUrl = this.cache.get(request.url);
+			if (maybeResolvedUrl) {
+				return maybeResolvedUrl;
+			}
 
-            const headers = {
-                Authorization: `Bearer ${this.bearer}`,
-            };
-            const resolvedP = Axios.post<IResolvedUrl>(
-                `${this.hostUrl}/api/v1/load`,
-                {
-                    url: request.url,
-                },
-                {
-                    headers,
-                });
-            this.cache.set(request.url, resolvedP.then((resolved) => resolved.data));
+			const headers = {
+				Authorization: `Bearer ${this.bearer}`,
+			};
+			const resolvedP = Axios.post<IResolvedUrl>(
+				`${this.hostUrl}/api/v1/load`,
+				{
+					url: request.url,
+				},
+				{
+					headers,
+				},
+			);
+			this.cache.set(
+				request.url,
+				resolvedP.then((resolved) => resolved.data),
+			);
 
-            return this.cache.get(request.url);
-        }
-    }
+			return this.cache.get(request.url);
+		}
+	}
 
-    private resolveHelper(documentId: string | null, documentRelativePath: string = "", queryParams: string = "") {
-        const encodedTenantId = encodeURIComponent(this.tenantId);
-        const host = new URL(this.ordererUrl).host;
-        // when the document ID is not provided we need to resolve a special create new document URL.
-        // the actual container ID will be generated by the driver.
-        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-        if (!documentId) {
-            const createNewResponse: IFluidResolvedUrl = {
-                endpoints: {
-                    deltaStorageUrl: `${this.ordererUrl}/deltas/${encodedTenantId}/new`,
-                    ordererUrl: this.ordererUrl,
-                    storageUrl: `${this.storageUrl}/repos/${encodedTenantId}`,
-                },
-                // document ID is ignored by the driver for new container requests
-                id: "",
-                tokens: {},
-                type: "fluid",
-                url: `fluid://${host}/${encodedTenantId}/new`,
-            };
-            return createNewResponse;
-        }
-        const encodedDocId = encodeURIComponent(documentId);
-        const relativePath = !documentRelativePath || documentRelativePath.startsWith("/")
-            ? documentRelativePath : `/${documentRelativePath}`;
-        const documentUrl = `fluid://${host}/${encodedTenantId}/${encodedDocId}${relativePath}${queryParams}`;
+	private resolveHelper(
+		documentId: string | null,
+		documentRelativePath: string = "",
+		queryParams: string = "",
+	) {
+		const encodedTenantId = encodeURIComponent(this.tenantId);
+		const host = new URL(this.ordererUrl).host;
+		// when the document ID is not provided we need to resolve a special create new document URL.
+		// the actual container ID will be generated by the driver.
+		// eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+		if (!documentId) {
+			const createNewResponse: IFluidResolvedUrl = {
+				endpoints: {
+					deltaStorageUrl: `${this.ordererUrl}/deltas/${encodedTenantId}/new`,
+					ordererUrl: this.ordererUrl,
+					storageUrl: `${this.storageUrl}/repos/${encodedTenantId}`,
+				},
+				// document ID is ignored by the driver for new container requests
+				id: "",
+				tokens: {},
+				type: "fluid",
+				url: `fluid://${host}/${encodedTenantId}/new`,
+			};
+			return createNewResponse;
+		}
+		const encodedDocId = encodeURIComponent(documentId);
+		const relativePath =
+			!documentRelativePath || documentRelativePath.startsWith("/")
+				? documentRelativePath
+				: `/${documentRelativePath}`;
+		const documentUrl = `fluid://${host}/${encodedTenantId}/${encodedDocId}${relativePath}${queryParams}`;
 
-        const deltaStorageUrl = `${this.ordererUrl}/deltas/${encodedTenantId}/${encodedDocId}`;
-        const storageUrl = `${this.storageUrl}/repos/${encodedTenantId}`;
+		const deltaStorageUrl = `${this.ordererUrl}/deltas/${encodedTenantId}/${encodedDocId}`;
+		const storageUrl = `${this.storageUrl}/repos/${encodedTenantId}`;
 
-        const response: IFluidResolvedUrl = {
-            endpoints: {
-                deltaStorageUrl,
-                ordererUrl: this.ordererUrl,
-                storageUrl,
-            },
-            id: documentId,
-            tokens: {},
-            type: "fluid",
-            url: documentUrl,
-        };
-        return response;
-    }
+		const response: IFluidResolvedUrl = {
+			endpoints: {
+				deltaStorageUrl,
+				ordererUrl: this.ordererUrl,
+				storageUrl,
+			},
+			id: documentId,
+			tokens: {},
+			type: "fluid",
+			url: documentUrl,
+		};
+		return response;
+	}
 
-    public async getAbsoluteUrl(resolvedUrl: IResolvedUrl, relativeUrl: string): Promise<string> {
-        const fluidResolvedUrl = resolvedUrl as IFluidResolvedUrl;
+	public async getAbsoluteUrl(resolvedUrl: IResolvedUrl, relativeUrl: string): Promise<string> {
+		const fluidResolvedUrl = resolvedUrl as IFluidResolvedUrl;
 
-        const parsedUrl = parse(fluidResolvedUrl.url);
-        const [, , documentId] = parsedUrl.pathname?.split("/") ?? [];
-        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-        assert(!!documentId, 0x273 /* "Invalid document id from parsed URL" */);
+		const parsedUrl = parse(fluidResolvedUrl.url);
+		const [, , documentId] = parsedUrl.pathname?.split("/") ?? [];
+		// eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+		assert(!!documentId, 0x273 /* "Invalid document id from parsed URL" */);
 
-        let url = relativeUrl;
-        if (url.startsWith("/")) {
-            url = url.substr(1);
-        }
+		let url = relativeUrl;
+		if (url.startsWith("/")) {
+			url = url.substr(1);
+		}
 
-        return `${this.hostUrl}/${encodeURIComponent(
-            this.tenantId)}/${encodeURIComponent(documentId)}/${url}`;
-    }
+		return `${this.hostUrl}/${encodeURIComponent(this.tenantId)}/${encodeURIComponent(
+			documentId,
+		)}/${url}`;
+	}
 
-    public createCreateNewRequest(fileName?: string): IRequest {
-        const createNewRequest: IRequest = {
-            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-            url: fileName ? `${this.hostUrl}?fileName=${fileName}` : this.hostUrl,
-            headers: {
-                [DriverHeader.createNew]: true,
-            },
-        };
-        return createNewRequest;
-    }
+	public createCreateNewRequest(fileName?: string): IRequest {
+		const createNewRequest: IRequest = {
+			// eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+			url: fileName ? `${this.hostUrl}?fileName=${fileName}` : this.hostUrl,
+			headers: {
+				[DriverHeader.createNew]: true,
+			},
+		};
+		return createNewRequest;
+	}
 }