@fluidframework/routerlicious-driver 1.4.0-115997 → 2.0.0-dev-rc.1.0.0.224419

package/src/tokens.ts

@@ -6,58 +6,93 @@
 import { ITokenClaims } from "@fluidframework/protocol-definitions";
 
 /**
- * The ITokenService abstracts the discovery of claims contained within a token
+ * Abstracts the discovery of claims contained within a token.
+ * @internal
  */
 export interface ITokenService {
-    extractClaims(token: string): ITokenClaims;
+	/**
+	 * Extracts the {@link @fluidframework/protocol-definitions#ITokenClaims | token claims} from the provided
+	 * {@link https://jwt.io/introduction/ | JSON Web Token (JWT)} string representation.
+	 */
+	extractClaims(token: string): ITokenClaims;
 }
 
+/**
+ * @public
+ */
 export interface ITokenResponse {
-    // JWT value
-    jwt: string;
+	/**
+	 * {@link https://jwt.io/introduction/ | JSON Web Token (JWT)} value.
+	 */
+	jwt: string;
 
-    // Flag indicating whether token was obtained from local cache
-    fromCache?: boolean;
+	/**
+	 * A flag indicating whether token was obtained from local cache.
+	 *
+	 * @remarks `undefined` indicates that the source of the token could not be determined.
+	 */
+	fromCache?: boolean;
 }
 
 /**
  * Abstracts the token fetching mechanism for a hosting application.
  * The hosting application is responsible for providing an implementation.
+ * @public
  */
 export interface ITokenProvider {
-    /**
-     * Fetches the orderer token from host.
-     * @param tenantId - Tenant ID.
-     * @param documentId - Optional. Document ID is only required for document-scoped requests.
-     * @param refresh - Optional flag indicating whether token fetch must bypass local cache.
-     * @returns TokenResponse object representing token value along with flag indicating
-     * whether token came from cache.
-     */
-    fetchOrdererToken(tenantId: string, documentId?: string, refresh?: boolean): Promise<ITokenResponse>;
+	/**
+	 * Fetches the orderer token from host.
+	 *
+	 * @param tenantId - Tenant ID.
+	 * @param documentId - Optional. Document ID is only required for document-scoped requests.
+	 * @param refresh - Optional flag indicating whether token fetch must bypass local cache.
+	 * This likely indicates that some previous request failed authorization due to an expired token,
+	 * and so a fresh token is required.
+	 *
+	 * Default: `false`.
+	 *
+	 * NOTE: This parameter will be made required in the future.
+	 */
+	fetchOrdererToken(
+		tenantId: string,
+		documentId?: string,
+		refresh?: boolean,
+	): Promise<ITokenResponse>;
 
-    /**
-     * Fetches the storage token from host.
-     * @param tenantId - Tenant ID.
-     * @param documentId - Document ID.
-     * @param refresh - Optional flag indicating whether token fetch must bypass local cache.
-     * @returns TokenResponse object representing token value along with flag indicating
-     * whether token came from cache.
-     */
-    fetchStorageToken(tenantId: string, documentId: string, refresh?: boolean): Promise<ITokenResponse>;
+	/**
+	 * Fetches the storage token from host.
+	 *
+	 * @param tenantId - Tenant ID.
+	 * @param documentId - Document ID.
+	 * @param refresh - Optional flag indicating whether token fetch must bypass local cache.
+	 * This likely indicates that some previous request failed authorization due to an expired token,
+	 * and so a fresh token is required.
+	 *
+	 * Default: `false`.
+	 *
+	 * NOTE: This parameter will be made required in the future.
+	 */
+	fetchStorageToken(
+		tenantId: string,
+		documentId: string,
+		refresh?: boolean,
+	): Promise<ITokenResponse>;
 
-    /**
-     * A callback triggered directly after creating the document. In this callback the client has the opportunity, to
-     * verify against an authorization service, if the user who claims to create the document is the same user who
-     * created it.
-     *
-     * @remarks Notes:
-     * * Using the callback may have performance impact on the document creation process.
-     * * Any exceptions thrown in the callback would fail the creation workflow
-     * (see {@link RouterliciousDocumentServiceFactory.createContainer} for more details).
-     *
-     * @param documentId - Document ID.
-     * @param creationToken - A special token that doesn't provide any kind of access, but it has the user's payload
-     * and document id. It can be used to validate the identity of the document creator.
-     */
-    documentPostCreateCallback?(documentId: string, creationToken: string): Promise<void>;
+	/**
+	 * A callback triggered directly after creating the document. In this callback the client has the opportunity, to
+	 * verify against an authorization service, if the user who claims to create the document is the same user who
+	 * created it.
+	 *
+	 * @remarks Notes:
+	 *
+	 * * Using the callback may have performance impact on the document creation process.
+	 *
+	 * * Any exceptions thrown in the callback would fail the creation workflow
+	 * (see {@link RouterliciousDocumentServiceFactory.createContainer} for more details).
+	 *
+	 * @param documentId - Document ID.
+	 * @param creationToken - A special token that doesn't provide any kind of access, but it has the user's payload
+	 * and document id. It can be used to validate the identity of the document creator.
+	 */
+	documentPostCreateCallback?(documentId: string, creationToken: string): Promise<void>;
 }

package/src/treeUtils.ts

@@ -0,0 +1,138 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { IsoBuffer } from "@fluid-internal/client-utils";
+import { assert } from "@fluidframework/core-utils";
+import {
+	SummaryType,
+	ISnapshotTree,
+	ISummaryTree,
+	SummaryObject,
+} from "@fluidframework/protocol-definitions";
+import { INormalizedWholeSnapshot } from "./contracts";
+
+/**
+ * Summary tree assembler props
+ */
+export interface ISummaryTreeAssemblerProps {
+	/**
+	 * Indicates that this tree is unreferenced. If this is not present, the tree is considered referenced.
+	 */
+	unreferenced?: true;
+}
+
+/**
+ * Summary tree assembler (without stats collection).
+ */
+export class SummaryTreeAssembler {
+	private attachmentCounter: number = 0;
+	private readonly summaryTree: { [path: string]: SummaryObject } = {};
+
+	constructor(private readonly props?: ISummaryTreeAssemblerProps) {}
+
+	/**
+	 * Get final summary
+	 */
+	public get summary(): ISummaryTree {
+		return {
+			type: SummaryType.Tree,
+			tree: { ...this.summaryTree },
+			unreferenced: this.props?.unreferenced,
+		};
+	}
+
+	/**
+	 * Add blob to summary
+	 */
+	public addBlob(key: string, content: string | Uint8Array): void {
+		this.summaryTree[key] = {
+			type: SummaryType.Blob,
+			content,
+		};
+	}
+
+	/**
+	 * Add handle to summary
+	 */
+	public addHandle(
+		key: string,
+		handleType: SummaryType.Tree | SummaryType.Blob | SummaryType.Attachment,
+		handle: string,
+	): void {
+		this.summaryTree[key] = {
+			type: SummaryType.Handle,
+			handleType,
+			handle,
+		};
+	}
+
+	/**
+	 * Add tree to summary
+	 */
+	public addTree(key: string, summary: ISummaryTree): void {
+		this.summaryTree[key] = summary;
+	}
+
+	/**
+	 * Add attachment to summary
+	 */
+	public addAttachment(id: string) {
+		this.summaryTree[this.attachmentCounter++] = { id, type: SummaryType.Attachment };
+	}
+}
+
+/**
+ * Helper function that converts ISnapshotTree and blobs to ISummaryTree
+ * @param snapshot - Source snapshot tree
+ * @param blobs - Blobs cache
+ * @returns Converted snapshot in ISummaryTree format
+ */
+export function convertSnapshotAndBlobsToSummaryTree(
+	snapshot: ISnapshotTree,
+	blobs: Map<string, ArrayBuffer>,
+): ISummaryTree {
+	const assembler = new SummaryTreeAssembler({
+		unreferenced: snapshot.unreferenced,
+	});
+	for (const [path, id] of Object.entries(snapshot.blobs)) {
+		const blob = blobs.get(id);
+		assert(blob !== undefined, 0x2dd /* "Cannot find blob for a given id" */);
+		assembler.addBlob(path, IsoBuffer.from(blob).toString("utf-8"));
+	}
+	for (const [key, tree] of Object.entries(snapshot.trees)) {
+		const subtree = convertSnapshotAndBlobsToSummaryTree(tree, blobs);
+		assembler.addTree(key, subtree);
+	}
+	return assembler.summary;
+}
+
+export function evalBlobsAndTrees(snapshot: INormalizedWholeSnapshot) {
+	const trees = countTreesInSnapshotTree(snapshot.snapshotTree);
+	const numBlobs = snapshot.blobs.size;
+	let encodedBlobsSize = 0;
+	for (const [_, blobContent] of snapshot.blobs) {
+		encodedBlobsSize += blobContent.byteLength;
+	}
+	return { trees, numBlobs, encodedBlobsSize };
+}
+
+export function validateBlobsAndTrees(snapshot: ISnapshotTree) {
+	assert(
+		snapshot.trees !== undefined,
+		0x5d0 /* Returned r11s snapshot is malformed. No trees! */,
+	);
+	assert(
+		snapshot.blobs !== undefined,
+		0x5d1 /* Returned r11s snapshot is malformed. No blobs! */,
+	);
+}
+
+function countTreesInSnapshotTree(snapshotTree: ISnapshotTree): number {
+	let numTrees = 0;
+	for (const [_, tree] of Object.entries(snapshotTree.trees)) {
+		numTrees += 1 + countTreesInSnapshotTree(tree);
+	}
+	return numTrees;
+}

package/src/urlUtils.ts

@@ -3,12 +3,12 @@
  * Licensed under the MIT License.
  */
 
-import { IFluidResolvedUrl } from "@fluidframework/driver-definitions";
+import { IResolvedUrl } from "@fluidframework/driver-definitions";
 import URLParse from "url-parse";
 import { ISession } from "@fluidframework/server-services-client";
 
 export const parseFluidUrl = (fluidUrl: string): URLParse => {
-    return new URLParse(fluidUrl, true);
+	return new URLParse(fluidUrl, true);
 };
 
 /**
@@ -18,33 +18,32 @@ export const parseFluidUrl = (fluidUrl: string): URLParse => {
  * TODO: Ideally we would be able to regenerate the resolvedUrl, rather than patching the current one.
  */
 export const replaceDocumentIdInPath = (urlPath: string, documentId: string): string =>
-    urlPath.split("/").slice(0, -1).concat([documentId]).join("/");
+	urlPath.split("/").slice(0, -1).concat([documentId]).join("/");
 
-export const getDiscoveredFluidResolvedUrl = (resolvedUrl: IFluidResolvedUrl, session: ISession): IFluidResolvedUrl => {
-    if (session) {
-        const discoveredOrdererUrl = new URLParse(session.ordererUrl);
-        const deltaStorageUrl = new URLParse(resolvedUrl.endpoints.deltaStorageUrl);
-        deltaStorageUrl.set("host", discoveredOrdererUrl.host);
+export const getDiscoveredFluidResolvedUrl = (
+	resolvedUrl: IResolvedUrl,
+	session: ISession,
+): IResolvedUrl => {
+	const discoveredOrdererUrl = new URLParse(session.ordererUrl);
+	const deltaStorageUrl = new URLParse(resolvedUrl.endpoints.deltaStorageUrl);
+	deltaStorageUrl.set("host", discoveredOrdererUrl.host);
 
-        const discoveredStorageUrl = new URLParse(session.historianUrl);
-        const storageUrl = new URLParse(resolvedUrl.endpoints.storageUrl);
-        storageUrl.set("host", discoveredStorageUrl.host);
+	const discoveredStorageUrl = new URLParse(session.historianUrl);
+	const storageUrl = new URLParse(resolvedUrl.endpoints.storageUrl);
+	storageUrl.set("host", discoveredStorageUrl.host);
 
-        const parsedUrl = parseFluidUrl(resolvedUrl.url);
-        const discoveredResolvedUrl: IFluidResolvedUrl = {
-            endpoints: {
-                deltaStorageUrl: deltaStorageUrl.toString(),
-                ordererUrl: session.ordererUrl,
-                storageUrl: storageUrl.toString(),
-            },
-            id: resolvedUrl.id,
-            tokens: resolvedUrl.tokens,
-            type: resolvedUrl.type,
-            url: new URLParse(`fluid://${discoveredOrdererUrl.host}${parsedUrl.pathname}`).toString(),
-        };
-
-        return discoveredResolvedUrl;
-    } else {
-        return resolvedUrl;
-    }
+	const parsedUrl = parseFluidUrl(resolvedUrl.url);
+	const discoveredResolvedUrl: IResolvedUrl = {
+		endpoints: {
+			deltaStorageUrl: deltaStorageUrl.toString(),
+			ordererUrl: session.ordererUrl,
+			deltaStreamUrl: session.deltaStreamUrl,
+			storageUrl: storageUrl.toString(),
+		},
+		id: resolvedUrl.id,
+		tokens: resolvedUrl.tokens,
+		type: resolvedUrl.type,
+		url: new URLParse(`fluid://${discoveredOrdererUrl.host}${parsedUrl.pathname}`).toString(),
+	};
+	return discoveredResolvedUrl;
 };