@fluidframework/routerlicious-driver 2.0.0-dev.3.1.0.125672 → 2.0.0-dev.4.1.0.148229

package/src/mapWithExpiration.ts

@@ -0,0 +1,124 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { assert } from "@fluidframework/common-utils";
+
+/**
+ * An extension of Map that expires (deletes) entries after a period of inactivity.
+ * The policy is based on the last time a key was written to.
+ */
+export class MapWithExpiration<TKey = any, TValue = any> extends Map<TKey, TValue> {
+	/** Timestamps (as epoch ms numbers) of when each key was last refreshed */
+	private readonly lastRefreshedTimes = new Map<TKey, number>();
+
+	constructor(private readonly expiryMs: number) {
+		super();
+	}
+
+	private refresh(key: TKey): void {
+		this.lastRefreshedTimes.set(key, new Date().valueOf());
+	}
+
+	/**
+	 * Returns true if the key is present and expired, false if it's not expired, and undefined if it's not found
+	 * If cleanUp is passed as true, then delete any expired entry before returning.
+	 */
+	private checkExpiry(key: TKey, cleanUp: boolean = false): boolean | undefined {
+		const refreshTime = this.lastRefreshedTimes.get(key);
+		assert(
+			(refreshTime !== undefined) === super.has(key),
+			0x50c /* freshness map out of sync */,
+		);
+
+		if (refreshTime === undefined) {
+			return undefined;
+		}
+		const expired = new Date().valueOf() - refreshTime >= this.expiryMs;
+		if (expired && cleanUp) {
+			this.delete(key);
+		}
+		return expired;
+	}
+
+	private clearExpiredEntries() {
+		// forEach clears out any expired entries
+		this.forEach(() => {});
+	}
+
+	get size(): number {
+		this.clearExpiredEntries();
+		return super.size;
+	}
+
+	has(key: TKey): boolean {
+		this.checkExpiry(key, true /* cleanUp */);
+		return super.has(key);
+	}
+
+	get(key: TKey): TValue | undefined {
+		this.checkExpiry(key, true /* cleanUp */);
+		return super.get(key);
+	}
+
+	set(key: TKey, value: TValue): this {
+		// Sliding window expiration policy (on write)
+		this.refresh(key);
+		return super.set(key, value);
+	}
+
+	delete(key: TKey): boolean {
+		this.lastRefreshedTimes.delete(key);
+		return super.delete(key);
+	}
+
+	clear(): void {
+		this.lastRefreshedTimes.clear();
+		super.clear();
+	}
+
+	forEach(
+		callbackfn: (value: TValue, key: TKey, map: Map<TKey, TValue>) => void,
+		thisArg?: any,
+	): void {
+		const expiredKeys: TKey[] = [];
+		super.forEach(
+			(v, k, m) => {
+				if (this.checkExpiry(k) === true) {
+					expiredKeys.push(k);
+				} else {
+					callbackfn.bind(thisArg)(v, k, m);
+				}
+			},
+			// Note we don't pass thisArg here, since we bind it directly to callbackFn and don't need it otherwise
+		);
+
+		// Clean up keys we know are expired now that we're done iterating
+		expiredKeys.forEach((key: TKey) => {
+			this.delete(key);
+		});
+	}
+
+	entries(): IterableIterator<[TKey, TValue]> {
+		this.clearExpiredEntries();
+		return super.entries();
+	}
+	keys(): IterableIterator<TKey> {
+		this.clearExpiredEntries();
+		return super.keys();
+	}
+	values(): IterableIterator<TValue> {
+		this.clearExpiredEntries();
+		return super.values();
+	}
+	[Symbol.iterator](): IterableIterator<[TKey, TValue]> {
+		this.clearExpiredEntries();
+		return super[Symbol.iterator]();
+	}
+
+	valueOf() {
+		this.clearExpiredEntries();
+		return super.valueOf();
+	}
+}

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/routerlicious-driver";
-export const pkgVersion = "2.0.0-dev.3.1.0.125672";
+export const pkgVersion = "2.0.0-dev.4.1.0.148229";

package/src/tokens.ts

@@ -6,9 +6,13 @@
 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.
  */
 export interface ITokenService {
+	/**
+	 * 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;
 }
 
@@ -19,8 +23,9 @@ export interface ITokenResponse {
 	jwt: string;
 
 	/**
-	 * Flag indicating whether token was obtained from local cache.
-	 * Undefined indicates that the source of the token could not be determined.
+	 * 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;
 }
@@ -32,11 +37,16 @@ export interface ITokenResponse {
 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.
+	 * 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,
@@ -46,11 +56,16 @@ export interface ITokenProvider {
 
 	/**
 	 * 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.
+	 * 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,
@@ -64,7 +79,9 @@ export interface ITokenProvider {
 	 * 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).
 	 *

package/src/treeUtils.ts

@@ -0,0 +1,107 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { assert, IsoBuffer } from "@fluidframework/common-utils";
+import {
+	SummaryType,
+	ISnapshotTree,
+	ISummaryTree,
+	SummaryObject,
+} from "@fluidframework/protocol-definitions";
+
+/**
+ * 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;
+}

package/src/wholeSummaryDocumentStorageService.ts

@@ -10,7 +10,6 @@ import {
 	ISummaryContext,
 	IDocumentStorageServicePolicies,
 } from "@fluidframework/driver-definitions";
-import { convertSnapshotAndBlobsToSummaryTree } from "@fluidframework/driver-utils";
 import {
 	ICreateBlobResponse,
 	ISnapshotTree,
@@ -28,6 +27,7 @@ import { PerformanceEvent } from "@fluidframework/telemetry-utils";
 import { ICache, InMemoryCache } from "./cache";
 import { ISnapshotTreeVersion } from "./definitions";
 import { IRouterliciousDriverPolicies } from "./policies";
+import { convertSnapshotAndBlobsToSummaryTree } from "./treeUtils";
 
 const latestSnapshotId: string = "latest";
 
@@ -248,19 +248,21 @@ export class WholeSummaryDocumentStorageService implements IDocumentStorageServi
 		);
 		const normalizedWholeSummary =
 			convertWholeFlatSummaryToSnapshotTreeAndBlobs(wholeFlatSummary);
+		assert(
+			normalizedWholeSummary.snapshotTree.id !== undefined,
+			0x275 /* "Root tree should contain the id" */,
+		);
 		const wholeFlatSummaryId: string = wholeFlatSummary.id;
-		const snapshotTreeId = normalizedWholeSummary.snapshotTree.id;
-		assert(snapshotTreeId !== undefined, 0x275 /* "Root tree should contain the id" */);
 		const snapshotTreeVersion = {
 			id: wholeFlatSummaryId,
 			snapshotTree: normalizedWholeSummary.snapshotTree,
 		};
 
 		const cachePs: Promise<any>[] = [
-			this.snapshotTreeCache.put(this.getCacheKey(snapshotTreeId), snapshotTreeVersion),
+			this.snapshotTreeCache.put(this.getCacheKey(wholeFlatSummaryId), snapshotTreeVersion),
 			this.initBlobCache(normalizedWholeSummary.blobs),
 		];
-		if (snapshotTreeId !== versionId) {
+		if (wholeFlatSummaryId !== versionId) {
 			// versionId could be "latest". When summarizer checks cache for "latest", we want it to be available.
 			// TODO: For in-memory cache, <latest,snapshotTree> will be a shared pointer with <snapshotId,snapshotTree>,
 			// However, for something like Redis, this will cache the same value twice. Alternatively, could we simply