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

package/src/documentStorageService.ts

@@ -5,18 +5,16 @@
 
 import type { ITelemetryLogger } from "@fluidframework/common-definitions";
 import {
-    IDocumentStorageService,
-    IDocumentStorageServicePolicies,
-    LoaderCachingPolicy,
+	IDocumentStorageService,
+	IDocumentStorageServicePolicies,
+	LoaderCachingPolicy,
 } from "@fluidframework/driver-definitions";
+import { ISnapshotTree, IVersion } from "@fluidframework/protocol-definitions";
+import { GitManager } from "@fluidframework/server-services-client";
 import {
-    ISnapshotTree,
-    IVersion,
-} from "@fluidframework/protocol-definitions";
-import {
-    GitManager,
-} from "@fluidframework/server-services-client";
-import { DocumentStorageServiceProxy, PrefetchDocumentStorageService } from "@fluidframework/driver-utils";
+	DocumentStorageServiceProxy,
+	PrefetchDocumentStorageService,
+} from "@fluidframework/driver-utils";
 import { IRouterliciousDriverPolicies } from "./policies";
 import { ICache } from "./cache";
 import { WholeSummaryDocumentStorageService } from "./wholeSummaryDocumentStorageService";
@@ -24,81 +22,87 @@ import { ShreddedSummaryDocumentStorageService } from "./shreddedSummaryDocument
 import { ISnapshotTreeVersion } from "./definitions";
 
 export class DocumentStorageService extends DocumentStorageServiceProxy {
-    private _logTailSha: string | undefined = undefined;
+	private _logTailSha: string | undefined = undefined;
 
-    public get logTailSha(): string | undefined {
-        return this._logTailSha;
-    }
+	public get logTailSha(): string | undefined {
+		return this._logTailSha;
+	}
 
-    private static loadInternalDocumentStorageService(
-        id: string,
-        manager: GitManager,
-        logger: ITelemetryLogger,
-        policies: IDocumentStorageServicePolicies,
-        driverPolicies?: IRouterliciousDriverPolicies,
-        blobCache?: ICache<ArrayBufferLike>,
-        snapshotTreeCache?: ICache<ISnapshotTreeVersion>,
-        noCacheGitManager?: GitManager,
-        getStorageManager?: (disableCache?: boolean) => Promise<GitManager>,
-    ): IDocumentStorageService {
-        const storageService = driverPolicies?.enableWholeSummaryUpload ?
-            new WholeSummaryDocumentStorageService(
-                id,
-                manager,
-                logger,
-                policies,
-                driverPolicies,
-                blobCache,
-                snapshotTreeCache,
-                noCacheGitManager,
-                getStorageManager,
-            ) :
-            new ShreddedSummaryDocumentStorageService(
-                id,
-                manager,
-                logger,
-                policies,
-                driverPolicies,
-                blobCache,
-                snapshotTreeCache,
-                getStorageManager,
-            );
-        // TODO: worth prefetching latest summary making version + snapshot call with WholeSummary storage?
-        if (!driverPolicies?.enableWholeSummaryUpload && policies.caching === LoaderCachingPolicy.Prefetch) {
-            return new PrefetchDocumentStorageService(storageService);
-        }
-        return storageService;
-    }
+	private static loadInternalDocumentStorageService(
+		id: string,
+		manager: GitManager,
+		logger: ITelemetryLogger,
+		policies: IDocumentStorageServicePolicies,
+		driverPolicies?: IRouterliciousDriverPolicies,
+		blobCache?: ICache<ArrayBufferLike>,
+		snapshotTreeCache?: ICache<ISnapshotTreeVersion>,
+		noCacheGitManager?: GitManager,
+		getStorageManager?: (disableCache?: boolean) => Promise<GitManager>,
+	): IDocumentStorageService {
+		const storageService = driverPolicies?.enableWholeSummaryUpload
+			? new WholeSummaryDocumentStorageService(
+					id,
+					manager,
+					logger,
+					policies,
+					driverPolicies,
+					blobCache,
+					snapshotTreeCache,
+					noCacheGitManager,
+					getStorageManager,
+			  )
+			: new ShreddedSummaryDocumentStorageService(
+					id,
+					manager,
+					logger,
+					policies,
+					driverPolicies,
+					blobCache,
+					snapshotTreeCache,
+					getStorageManager,
+			  );
+		// TODO: worth prefetching latest summary making version + snapshot call with WholeSummary storage?
+		if (
+			!driverPolicies?.enableWholeSummaryUpload &&
+			policies.caching === LoaderCachingPolicy.Prefetch
+		) {
+			return new PrefetchDocumentStorageService(storageService);
+		}
+		return storageService;
+	}
 
-    constructor(
-        public readonly id: string,
-        public manager: GitManager,
-        logger: ITelemetryLogger,
-        policies: IDocumentStorageServicePolicies = {},
-        driverPolicies?: IRouterliciousDriverPolicies,
-        blobCache?: ICache<ArrayBufferLike>,
-        snapshotTreeCache?: ICache<ISnapshotTreeVersion>,
-        public noCacheGitManager?: GitManager,
-        getStorageManager?: (disableCache?: boolean) => Promise<GitManager>,
-    ) {
-        super(DocumentStorageService.loadInternalDocumentStorageService(
-            id,
-            manager,
-            logger,
-            policies,
-            driverPolicies,
-            blobCache,
-            snapshotTreeCache,
-            noCacheGitManager,
-            getStorageManager,
-        ));
-    }
+	constructor(
+		public readonly id: string,
+		public manager: GitManager,
+		logger: ITelemetryLogger,
+		policies: IDocumentStorageServicePolicies,
+		driverPolicies?: IRouterliciousDriverPolicies,
+		blobCache?: ICache<ArrayBufferLike>,
+		snapshotTreeCache?: ICache<ISnapshotTreeVersion>,
+		public noCacheGitManager?: GitManager,
+		getStorageManager?: (disableCache?: boolean) => Promise<GitManager>,
+	) {
+		super(
+			DocumentStorageService.loadInternalDocumentStorageService(
+				id,
+				manager,
+				logger,
+				policies,
+				driverPolicies,
+				blobCache,
+				snapshotTreeCache,
+				noCacheGitManager,
+				getStorageManager,
+			),
+		);
+	}
 
-    public async getSnapshotTree(version?: IVersion): Promise<ISnapshotTree | null> {
-        const tree = await this.internalStorageService.getSnapshotTree(version);
-        if (tree !== null) {
-            this._logTailSha = ".logTail" in tree.trees ? tree.trees[".logTail"].blobs.logTail : undefined;
-        }
-        return tree;
-    }
+	public async getSnapshotTree(version?: IVersion): Promise<ISnapshotTree | null> {
+		const tree = await this.internalStorageService.getSnapshotTree(version);
+		if (tree !== null) {
+			this._logTailSha =
+				".logTail" in tree.trees ? tree.trees[".logTail"].blobs.logTail : undefined;
+		}
+		return tree;
+	}
 }

package/src/errorUtils.ts

@@ -5,15 +5,24 @@
 
 import { DriverError } from "@fluidframework/driver-definitions";
 import {
-    NonRetryableError,
-    GenericNetworkError,
-    createGenericNetworkError,
-    AuthorizationError,
+	NonRetryableError,
+	GenericNetworkError,
+	createGenericNetworkError,
+	AuthorizationError,
 } from "@fluidframework/driver-utils";
 import { pkgVersion as driverVersion } from "./packageVersion";
 
-export enum R11sErrorType {
-    fileNotFoundOrAccessDeniedError = "fileNotFoundOrAccessDeniedError",
+/**
+ * Routerlicious Error types
+ * Different error types that may be thrown by the routerlicious driver
+ */
+export enum RouterliciousErrorType {
+	/**
+	 * File not found, or file deleted during session
+	 */
+	fileNotFoundOrAccessDeniedError = "fileNotFoundOrAccessDeniedError",
+
+	sslCertError = "sslCertError",
 }
 
 /**
@@ -21,96 +30,102 @@ export enum R11sErrorType {
  * Intended to be compatible with output from {@link NetworkError.toJSON}
  */
 export interface IR11sSocketError {
-    /**
-     * An error code number for the error that occurred.
-     * It will be a valid HTTP status code.
-     */
-    code: number;
+	/**
+	 * An error code number for the error that occurred.
+	 * It will be a valid HTTP status code.
+	 */
+	code: number;
 
-    /**
-     * A message about the error that occurred for debugging / logging purposes.
-     * This should not be displayed to the user directly.
-     */
-    message: string;
+	/**
+	 * A message about the error that occurred for debugging / logging purposes.
+	 * This should not be displayed to the user directly.
+	 */
+	message: string;
 
-    /**
-     * Optional Retry-After time in seconds.
-     * The client should wait this many seconds before retrying its request.
-     */
-    retryAfter?: number;
+	/**
+	 * Optional Retry-After time in seconds.
+	 * The client should wait this many seconds before retrying its request.
+	 */
+	retryAfter?: number;
 
-    /**
-     * Optional Retry-After time in milliseconds.
-     * The client should wait this many milliseconds before retrying its request.
-     */
-    retryAfterMs?: number;
+	/**
+	 * Optional Retry-After time in milliseconds.
+	 * The client should wait this many milliseconds before retrying its request.
+	 */
+	retryAfterMs?: number;
 }
 
 export interface IR11sError {
-    readonly errorType: R11sErrorType;
-    readonly message: string;
-    canRetry: boolean;
+	readonly errorType: RouterliciousErrorType;
+	readonly message: string;
+	canRetry: boolean;
 }
 
 export type R11sError = DriverError | IR11sError;
 
 export function createR11sNetworkError(
-    errorMessage: string,
-    statusCode?: number,
-    retryAfterMs?: number,
+	errorMessage: string,
+	statusCode?: number,
+	retryAfterMs?: number,
 ): R11sError {
-    const props = { statusCode, driverVersion };
-    switch (statusCode) {
-        case undefined:
-            // If a service is temporarily down or a browser resource limit is reached, RestWrapper will throw
-            // a network error with no status code (e.g. err:ERR_CONN_REFUSED or err:ERR_FAILED) and
-            // the error message will start with NetworkError as defined in restWrapper.ts
-            return new GenericNetworkError(
-                errorMessage, errorMessage.startsWith("NetworkError"), props);
-        case 401:
-            // The first 401 is manually retried in RouterliciousRestWrapper with a refreshed token,
-            // so we treat repeat 401s the same as 403.
-        case 403:
-            return new AuthorizationError(
-                errorMessage, undefined, undefined, props);
-        case 404:
-            const errorType = R11sErrorType.fileNotFoundOrAccessDeniedError;
-            return new NonRetryableError(errorMessage, errorType, props);
-        case 429:
-            return createGenericNetworkError(
-                errorMessage, { canRetry: true, retryAfterMs }, props);
-        case 500:
-        case 502:
-            return new GenericNetworkError(errorMessage, true, props);
-        default:
-            const retryInfo = { canRetry: retryAfterMs !== undefined, retryAfterMs };
-            return createGenericNetworkError(errorMessage, retryInfo, props);
-    }
+	const props = { statusCode, driverVersion };
+	switch (statusCode) {
+		case undefined:
+			// If a service is temporarily down or a browser resource limit is reached, RestWrapper will throw
+			// a network error with no status code (e.g. err:ERR_CONN_REFUSED or err:ERR_FAILED) and
+			// the error message will start with NetworkError as defined in restWrapper.ts
+			// If there exists a self-signed SSL certificates error, throw a NonRetryableError
+			// TODO: instead of relying on string matching, filter error based on the error code like we do for websocket connections
+			if (errorMessage.includes("failed, reason: self signed certificate")) {
+				return new NonRetryableError(
+					errorMessage,
+					RouterliciousErrorType.sslCertError,
+					props,
+				);
+			}
+			return new GenericNetworkError(
+				errorMessage,
+				errorMessage.startsWith("NetworkError"),
+				props,
+			);
+		case 401:
+		// The first 401 is manually retried in RouterliciousRestWrapper with a refreshed token,
+		// so we treat repeat 401s the same as 403.
+		case 403:
+			return new AuthorizationError(errorMessage, undefined, undefined, props);
+		case 404:
+			const errorType = RouterliciousErrorType.fileNotFoundOrAccessDeniedError;
+			return new NonRetryableError(errorMessage, errorType, props);
+		case 429:
+			return createGenericNetworkError(errorMessage, { canRetry: true, retryAfterMs }, props);
+		case 500:
+		case 502:
+			return new GenericNetworkError(errorMessage, true, props);
+		default:
+			const retryInfo = { canRetry: retryAfterMs !== undefined, retryAfterMs };
+			return createGenericNetworkError(errorMessage, retryInfo, props);
+	}
 }
 
 export function throwR11sNetworkError(
-    errorMessage: string,
-    statusCode?: number,
-    retryAfterMs?: number,
+	errorMessage: string,
+	statusCode?: number,
+	retryAfterMs?: number,
 ): never {
-    const networkError = createR11sNetworkError(
-        errorMessage,
-        statusCode,
-        retryAfterMs);
+	const networkError = createR11sNetworkError(errorMessage, statusCode, retryAfterMs);
 
-    // eslint-disable-next-line @typescript-eslint/no-throw-literal
-    throw networkError;
+	// eslint-disable-next-line @typescript-eslint/no-throw-literal
+	throw networkError;
 }
 
 /**
  * Returns network error based on error object from R11s socket (IR11sSocketError)
  */
-export function errorObjectFromSocketError(socketError: IR11sSocketError, handler: string): R11sError {
-    // pre-0.58 error message prefix: R11sSocketError
-    const message = `R11s socket error (${handler}): ${socketError.message}`;
-    return createR11sNetworkError(
-        message,
-        socketError.code,
-        socketError.retryAfterMs,
-    );
+export function errorObjectFromSocketError(
+	socketError: IR11sSocketError,
+	handler: string,
+): R11sError {
+	// pre-0.58 error message prefix: R11sSocketError
+	const message = `R11s socket error (${handler}): ${socketError.message}`;
+	return createR11sNetworkError(message, socketError.code, socketError.retryAfterMs);
 }

package/src/index.ts

@@ -7,8 +7,14 @@
 export { DefaultTokenProvider } from "./defaultTokenProvider";
 export { ITokenProvider, ITokenResponse, ITokenService } from "./tokens";
 
+// Errors
+export { RouterliciousErrorType } from "./errorUtils";
+
 // Factory
-export { DocumentPostCreateError, RouterliciousDocumentServiceFactory } from "./documentServiceFactory";
+export {
+	DocumentPostCreateError,
+	RouterliciousDocumentServiceFactory,
+} from "./documentServiceFactory";
 
 // Configuration
 export { IRouterliciousDriverPolicies } from "./policies";

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/nullBlobStorageService.ts

@@ -11,30 +11,33 @@ import * as api from "@fluidframework/protocol-definitions";
  * Does not read/write anything.
  */
 export class NullBlobStorageService implements IDocumentStorageService {
-    public get repositoryUrl(): string {
-        throw new Error("Invalid operation");
-    }
+	public get repositoryUrl(): string {
+		throw new Error("Invalid operation");
+	}
 
-    public async getSnapshotTree(version?: api.IVersion): Promise<api.ISnapshotTree | null> {
-        return version ? Promise.reject(new Error("Invalid operation")) : null;
-    }
+	public async getSnapshotTree(version?: api.IVersion): Promise<api.ISnapshotTree | null> {
+		return version ? Promise.reject(new Error("Invalid operation")) : null;
+	}
 
-    public async getVersions(versionId: string | null, count: number): Promise<api.IVersion[]> {
-        return [];
-    }
+	public async getVersions(versionId: string | null, count: number): Promise<api.IVersion[]> {
+		return [];
+	}
 
-    public async uploadSummaryWithContext(summary: api.ISummaryTree, context: ISummaryContext): Promise<string> {
-        return Promise.reject(new Error("Invalid operation"));
-    }
+	public async uploadSummaryWithContext(
+		summary: api.ISummaryTree,
+		context: ISummaryContext,
+	): Promise<string> {
+		return Promise.reject(new Error("Invalid operation"));
+	}
 
-    public async downloadSummary(handle: api.ISummaryHandle): Promise<api.ISummaryTree> {
-        return Promise.reject(new Error("Invalid operation"));
-    }
+	public async downloadSummary(handle: api.ISummaryHandle): Promise<api.ISummaryTree> {
+		return Promise.reject(new Error("Invalid operation"));
+	}
 
-    public async createBlob(file: ArrayBufferLike): Promise<api.ICreateBlobResponse> {
-        return Promise.reject(new Error("Null blob storage can not create blob"));
-    }
-    public async readBlob(blobId: string): Promise<ArrayBufferLike> {
-        return Promise.reject(new Error("Null blob storage can not read blob"));
-    }
+	public async createBlob(file: ArrayBufferLike): Promise<api.ICreateBlobResponse> {
+		return Promise.reject(new Error("Null blob storage can not create blob"));
+	}
+	public async readBlob(blobId: string): Promise<ArrayBufferLike> {
+		return Promise.reject(new Error("Null blob storage can not read blob"));
+	}
 }

package/src/packageVersion.ts

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