@fluidframework/driver-utils 1.4.0-121020 → 2.0.0-dev-rc.1.0.0.224419

package/src/blob.ts

@@ -0,0 +1,77 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import {
+	FileMode,
+	IBlob,
+	IAttachment,
+	ITree,
+	TreeEntry,
+} from "@fluidframework/protocol-definitions";
+
+/**
+ * Basic implementation of a blob ITreeEntry
+ * @internal
+ */
+export class BlobTreeEntry {
+	public readonly mode = FileMode.File;
+	public readonly type = TreeEntry.Blob;
+	public readonly value: IBlob;
+
+	/**
+	 * Creates a blob ITreeEntry
+	 * @param path - path of entry
+	 * @param contents - blob contents
+	 * @param encoding - encoding of contents; defaults to utf-8
+	 */
+	constructor(
+		public readonly path: string,
+		contents: string,
+		encoding: "utf-8" | "base64" = "utf-8",
+	) {
+		this.value = { contents, encoding };
+	}
+}
+
+/**
+ * Basic implementation of a tree ITreeEntry
+ * @internal
+ */
+export class TreeTreeEntry {
+	public readonly mode = FileMode.Directory;
+	public readonly type = TreeEntry.Tree;
+
+	/**
+	 * Creates a tree ITreeEntry
+	 * @param path - path of entry
+	 * @param value - subtree
+	 */
+	constructor(
+		public readonly path: string,
+		public readonly value: ITree,
+	) {}
+}
+
+/**
+ * Basic implementation of an attachment ITreeEntry
+ * @internal
+ */
+export class AttachmentTreeEntry {
+	public readonly mode = FileMode.File;
+	public readonly type = TreeEntry.Attachment;
+	public readonly value: IAttachment;
+
+	/**
+	 * Creates an attachment ITreeEntry
+	 * @param path - path of entry
+	 * @param id - id of external blob attachment
+	 */
+	constructor(
+		public readonly path: string,
+		public readonly id: string,
+	) {
+		this.value = { id };
+	}
+}

package/src/buildSnapshotTree.ts

@@ -3,60 +3,64 @@
  * Licensed under the MIT License.
  */
 
-import { assert, stringToBuffer } from "@fluidframework/common-utils";
+import { stringToBuffer } from "@fluid-internal/client-utils";
+import { assert } from "@fluidframework/core-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 { buildGitTreeHierarchy } 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 +71,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: "",
+	};
 }
 
 /**
@@ -82,11 +86,12 @@ function flatten(tree: ITreeEntry[], blobMap: Map<string, ArrayBufferLike>): git
  * @param blobMap - a map of blob's sha1 to content that gets filled with content from entries
  * NOTE: blobMap's validity is contingent on the returned promise's resolution
  * @returns the hierarchical tree
+ * @internal
  */
 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 buildGitTreeHierarchy(flattened);
 }

package/src/documentServiceFactoryProxy.ts

@@ -0,0 +1,47 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
+import {
+	IDocumentService,
+	IDocumentServiceFactory,
+	IResolvedUrl,
+} from "@fluidframework/driver-definitions";
+import { ISummaryTree } from "@fluidframework/protocol-definitions";
+
+/**
+ * This abstract class implements IDocumentServiceFactory interface. It uses delegation pattern.
+ * It delegates all calls to IDocumentServiceFactory implementation passed to constructor.
+ */
+
+export abstract class DocumentServiceFactoryProxy implements IDocumentServiceFactory {
+	constructor(private readonly _serviceFactory: IDocumentServiceFactory) {}
+
+	public get serviceFactory(): IDocumentServiceFactory {
+		return this._serviceFactory;
+	}
+
+	public async createContainer(
+		createNewSummary: ISummaryTree | undefined,
+		createNewResolvedUrl: IResolvedUrl,
+		logger?: ITelemetryBaseLogger,
+		clientIsSummarizer?: boolean,
+	): Promise<IDocumentService> {
+		return this.serviceFactory.createContainer(
+			createNewSummary,
+			createNewResolvedUrl,
+			logger,
+			clientIsSummarizer,
+		);
+	}
+
+	public async createDocumentService(
+		resolvedUrl: IResolvedUrl,
+		logger?: ITelemetryBaseLogger,
+		clientIsSummarizer?: boolean,
+	): Promise<IDocumentService> {
+		return this.serviceFactory.createDocumentService(resolvedUrl, logger, clientIsSummarizer);
+	}
+}

package/src/documentServiceProxy.ts

@@ -0,0 +1,46 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import {
+	IDocumentDeltaConnection,
+	IDocumentDeltaStorageService,
+	IDocumentService,
+	IDocumentStorageService,
+	IResolvedUrl,
+} from "@fluidframework/driver-definitions";
+import { IClient } from "@fluidframework/protocol-definitions";
+
+/**
+ * This abstract class implements IDocumentService interface. It uses delegation pattern.
+ * It delegates all calls to IDocumentService implementation passed to constructor.
+ */
+
+export abstract class DocumentServiceProxy implements IDocumentService {
+	constructor(private readonly _service: IDocumentService) {}
+
+	public get service(): IDocumentService {
+		return this._service;
+	}
+
+	public async connectToStorage(): Promise<IDocumentStorageService> {
+		return this._service.connectToStorage();
+	}
+
+	public async connectToDeltaStorage(): Promise<IDocumentDeltaStorageService> {
+		return this._service.connectToDeltaStorage();
+	}
+
+	public async connectToDeltaStream(client: IClient): Promise<IDocumentDeltaConnection> {
+		return this._service.connectToDeltaStream(client);
+	}
+
+	public dispose(error?: any): void {
+		this._service.dispose(error);
+	}
+
+	public get resolvedUrl(): IResolvedUrl {
+		return this._service.resolvedUrl;
+	}
+}

package/src/documentStorageServiceProxy.ts

@@ -4,56 +4,71 @@
  */
 
 import {
-    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";
 
+/**
+ * @internal
+ */
 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): Promise<IVersion[]> {
-        return this.internalStorageService.getVersions(versionId, count, 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 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/error.ts

@@ -3,15 +3,20 @@
  * Licensed under the MIT License.
  */
 
+// eslint-disable-next-line import/no-deprecated
+import { DriverErrorType, IDriverErrorBase } from "@fluidframework/driver-definitions";
 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 IFluidErrorBase {
-    readonly errorType = "usageError";
+/**
+ * Error indicating an API is being used improperly resulting in an invalid operation.
+ * @internal
+ */
+export class UsageError extends LoggingError implements IDriverErrorBase, IFluidErrorBase {
+	// eslint-disable-next-line import/no-deprecated
+	readonly errorType = DriverErrorType.usageError;
+	readonly canRetry = false;
 
-    constructor(
-        message: string,
-    ) {
-        super(message, { usageError: true });
-    }
+	constructor(message: string) {
+		super(message, { usageError: true });
+	}
 }

package/src/index.ts

@@ -3,24 +3,54 @@
  * Licensed under the MIT License.
  */
 
-export * from "./blobCacheStorageService";
-export * from "./blobAggregationStorage";
-export * from "./buildSnapshotTree";
-export * from "./documentStorageServiceProxy";
-export * from "./insecureUrlResolver";
-export * from "./multiDocumentServiceFactory";
-export * from "./multiUrlResolver";
-export * from "./network";
-export * from "./readAndParse";
-export * from "./fluidResolvedUrl";
-export * from "./summaryForCreateNew";
-export * from "./parallelRequests";
-export * from "./prefetchDocumentStorageService";
-export * from "./networkUtils";
-export * from "./rateLimiter";
-export * from "./runWithRetry";
-export * from "./treeConversions";
-export * from "./treeUtils";
-export * from "./messageRecognition";
-export * from "./error";
-export * from "./emptyDocumentDeltaStorageService";
+export { buildSnapshotTree } from "./buildSnapshotTree";
+export { BlobTreeEntry, TreeTreeEntry, AttachmentTreeEntry } from "./blob";
+export { DocumentStorageServiceProxy } from "./documentStorageServiceProxy";
+export { UsageError } from "./error";
+export { InsecureUrlResolver } from "./insecureUrlResolver";
+export { canBeCoalescedByService, isRuntimeMessage, MessageType2 } from "./messageRecognition";
+export {
+	AuthorizationError,
+	canRetryOnError,
+	createGenericNetworkError,
+	createWriteError,
+	DeltaStreamConnectionForbiddenError,
+	DriverErrorTelemetryProps,
+	FluidInvalidSchemaError,
+	GenericNetworkError,
+	getRetryDelayFromError,
+	getRetryDelaySecondsFromError,
+	isOnline,
+	LocationRedirectionError,
+	NetworkErrorBasic,
+	NonRetryableError,
+	OnlineStatus,
+	RetryableError,
+	ThrottlingError,
+} from "./network";
+export { logNetworkFailure } from "./networkUtils";
+export {
+	emptyMessageStream,
+	ParallelRequests,
+	Queue,
+	requestOps,
+	streamFromMessages,
+	streamObserver,
+} from "./parallelRequests";
+export { PrefetchDocumentStorageService } from "./prefetchDocumentStorageService";
+export { RateLimiter } from "./rateLimiter";
+export { readAndParse } from "./readAndParse";
+export { calculateMaxWaitTime, IProgress, runWithRetry } from "./runWithRetry";
+export {
+	CombinedAppAndProtocolSummary,
+	getDocAttributesFromProtocolSummary,
+	getQuorumValuesFromProtocolSummary,
+	isCombinedAppAndProtocolSummary,
+} from "./summaryForCreateNew";
+export { convertSummaryTreeToSnapshotITree } from "./treeConversions";
+export {
+	applyStorageCompression,
+	ICompressionStorageConfig,
+	SummaryCompressionAlgorithm,
+	blobHeadersBlobName,
+} from "./adapters";