@fluidframework/datastore 2.0.0-internal.3.0.5 → 2.0.0-internal.3.1.1

package/src/channelDeltaConnection.ts

@@ -10,56 +10,62 @@ import { DataProcessingError } from "@fluidframework/container-utils";
 import { IFluidHandle } from "@fluidframework/core-interfaces";
 
 export class ChannelDeltaConnection implements IDeltaConnection {
-    private _handler: IDeltaHandler | undefined;
+	private _handler: IDeltaHandler | undefined;
 
-    private get handler(): IDeltaHandler {
-        assert(!!this._handler, 0x177 /* "Missing delta handler" */);
-        return this._handler;
-    }
-    public get connected(): boolean {
-        return this._connected;
-    }
+	private get handler(): IDeltaHandler {
+		assert(!!this._handler, 0x177 /* "Missing delta handler" */);
+		return this._handler;
+	}
+	public get connected(): boolean {
+		return this._connected;
+	}
 
-    constructor(
-        public objectId: string,
-        private _connected: boolean,
-        public readonly submit: (message: IDocumentMessage, localOpMetadata: unknown) => void,
-        public readonly dirty: () => void,
-        public readonly addedGCOutboundReference: (srcHandle: IFluidHandle, outboundHandle: IFluidHandle) => void) {
-    }
+	constructor(
+		public objectId: string,
+		private _connected: boolean,
+		public readonly submit: (message: IDocumentMessage, localOpMetadata: unknown) => void,
+		public readonly dirty: () => void,
+		public readonly addedGCOutboundReference: (
+			srcHandle: IFluidHandle,
+			outboundHandle: IFluidHandle,
+		) => void,
+	) {}
 
-    public attach(handler: IDeltaHandler) {
-        assert(this._handler === undefined, 0x178 /* "Missing delta handler on attach" */);
-        this._handler = handler;
-    }
+	public attach(handler: IDeltaHandler) {
+		assert(this._handler === undefined, 0x178 /* "Missing delta handler on attach" */);
+		this._handler = handler;
+	}
 
-    public setConnectionState(connected: boolean) {
-        this._connected = connected;
-        this.handler.setConnectionState(connected);
-    }
+	public setConnectionState(connected: boolean) {
+		this._connected = connected;
+		this.handler.setConnectionState(connected);
+	}
 
-    public process(message: ISequencedDocumentMessage, local: boolean, localOpMetadata: unknown) {
-        try {
-            // catches as data processing error whether or not they come from async pending queues
-            this.handler.process(message, local, localOpMetadata);
-        } catch (error) {
-            throw DataProcessingError.wrapIfUnrecognized(
-                error, "channelDeltaConnectionFailedToProcessMessage", message);
-        }
-    }
+	public process(message: ISequencedDocumentMessage, local: boolean, localOpMetadata: unknown) {
+		try {
+			// catches as data processing error whether or not they come from async pending queues
+			this.handler.process(message, local, localOpMetadata);
+		} catch (error) {
+			throw DataProcessingError.wrapIfUnrecognized(
+				error,
+				"channelDeltaConnectionFailedToProcessMessage",
+				message,
+			);
+		}
+	}
 
-    public reSubmit(content: any, localOpMetadata: unknown) {
-        this.handler.reSubmit(content, localOpMetadata);
-    }
+	public reSubmit(content: any, localOpMetadata: unknown) {
+		this.handler.reSubmit(content, localOpMetadata);
+	}
 
-    public rollback(content: any, localOpMetadata: unknown) {
-        if (this.handler.rollback === undefined) {
-            throw new Error("Handler doesn't support rollback");
-        }
-        this.handler.rollback(content, localOpMetadata);
-    }
+	public rollback(content: any, localOpMetadata: unknown) {
+		if (this.handler.rollback === undefined) {
+			throw new Error("Handler doesn't support rollback");
+		}
+		this.handler.rollback(content, localOpMetadata);
+	}
 
-    public applyStashedOp(message: ISequencedDocumentMessage): unknown {
-        return this.handler.applyStashedOp(message);
-    }
+	public applyStashedOp(message: ISequencedDocumentMessage): unknown {
+		return this.handler.applyStashedOp(message);
+	}
 }

package/src/channelStorageService.ts

@@ -10,68 +10,72 @@ import { getNormalizedObjectStoragePathParts } from "@fluidframework/runtime-uti
 import { ITelemetryLogger } from "@fluidframework/common-definitions";
 
 export class ChannelStorageService implements IChannelStorageService {
-    private static flattenTree(base: string, tree: ISnapshotTree, results: { [path: string]: string; }) {
-        // eslint-disable-next-line guard-for-in, no-restricted-syntax
-        for (const path in tree.trees) {
-            ChannelStorageService.flattenTree(`${base}${path}/`, tree.trees[path], results);
-        }
+	private static flattenTree(
+		base: string,
+		tree: ISnapshotTree,
+		results: { [path: string]: string },
+	) {
+		// eslint-disable-next-line guard-for-in, no-restricted-syntax
+		for (const path in tree.trees) {
+			ChannelStorageService.flattenTree(`${base}${path}/`, tree.trees[path], results);
+		}
 
-        // eslint-disable-next-line guard-for-in, no-restricted-syntax
-        for (const blob in tree.blobs) {
-            results[`${base}${blob}`] = tree.blobs[blob];
-        }
-    }
+		// eslint-disable-next-line guard-for-in, no-restricted-syntax
+		for (const blob in tree.blobs) {
+			results[`${base}${blob}`] = tree.blobs[blob];
+		}
+	}
 
-    private readonly flattenedTree: { [path: string]: string; };
+	private readonly flattenedTree: { [path: string]: string };
 
-    constructor(
-        private readonly tree: ISnapshotTree | undefined,
-        private readonly storage: Pick<IDocumentStorageService, "readBlob">,
-        private readonly logger: ITelemetryLogger,
-        private readonly extraBlobs?: Map<string, ArrayBufferLike>,
-    ) {
-        this.flattenedTree = {};
-        // Create a map from paths to blobs
-        if (tree !== undefined) {
-             ChannelStorageService.flattenTree("", tree, this.flattenedTree);
-        }
-    }
+	constructor(
+		private readonly tree: ISnapshotTree | undefined,
+		private readonly storage: Pick<IDocumentStorageService, "readBlob">,
+		private readonly logger: ITelemetryLogger,
+		private readonly extraBlobs?: Map<string, ArrayBufferLike>,
+	) {
+		this.flattenedTree = {};
+		// Create a map from paths to blobs
+		if (tree !== undefined) {
+			ChannelStorageService.flattenTree("", tree, this.flattenedTree);
+		}
+	}
 
-    public async contains(path: string): Promise<boolean> {
-        return this.flattenedTree[path] !== undefined;
-    }
+	public async contains(path: string): Promise<boolean> {
+		return this.flattenedTree[path] !== undefined;
+	}
 
-    public async readBlob(path: string): Promise<ArrayBufferLike> {
-        const id = await this.getIdForPath(path);
-        const blob = this.extraBlobs !== undefined
-            ? this.extraBlobs.get(id)
-            : undefined;
+	public async readBlob(path: string): Promise<ArrayBufferLike> {
+		const id = await this.getIdForPath(path);
+		const blob = this.extraBlobs !== undefined ? this.extraBlobs.get(id) : undefined;
 
-        if (blob !== undefined) {
-            return blob;
-        }
-        const blobP = this.storage.readBlob(id);
-        blobP.catch((error) => this.logger.sendErrorEvent({ eventName: "ChannelStorageBlobError" }, error));
+		if (blob !== undefined) {
+			return blob;
+		}
+		const blobP = this.storage.readBlob(id);
+		blobP.catch((error) =>
+			this.logger.sendErrorEvent({ eventName: "ChannelStorageBlobError" }, error),
+		);
 
-        return blobP;
-    }
+		return blobP;
+	}
 
-    public async list(path: string): Promise<string[]> {
-        let tree = this.tree;
-        const pathParts = getNormalizedObjectStoragePathParts(path);
-        while (tree !== undefined && pathParts.length > 0) {
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            const part = pathParts.shift()!;
-            tree = tree.trees[part];
-        }
-        if (tree === undefined || pathParts.length !== 0) {
-            throw new Error("path does not exist");
-        }
+	public async list(path: string): Promise<string[]> {
+		let tree = this.tree;
+		const pathParts = getNormalizedObjectStoragePathParts(path);
+		while (tree !== undefined && pathParts.length > 0) {
+			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+			const part = pathParts.shift()!;
+			tree = tree.trees[part];
+		}
+		if (tree === undefined || pathParts.length !== 0) {
+			throw new Error("path does not exist");
+		}
 
-        return Object.keys(tree?.blobs ?? {});
-    }
+		return Object.keys(tree?.blobs ?? {});
+	}
 
-    private async getIdForPath(path: string): Promise<string> {
-        return this.flattenedTree[path];
-    }
+	private async getIdForPath(path: string): Promise<string> {
+		return this.flattenedTree[path];
+	}
 }