@fluidframework/routerlicious-driver 2.0.0-internal.3.0.1 → 2.0.0-internal.3.1.0

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,16 +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",
-    sslCertError = "sslCertError",
+/**
+ * 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",
 }
 
 /**
@@ -22,100 +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
-            // 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, R11sErrorType.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 = 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/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-internal.3.0.1";
+export const pkgVersion = "2.0.0-internal.3.1.0";

package/src/policies.ts

@@ -4,48 +4,48 @@
  */
 
 export interface IRouterliciousDriverPolicies {
-    /**
-     * Enable prefetching entire snapshot tree into memory before it is loaded by the runtime.
-     * Default: true
-     */
-    enablePrefetch: boolean;
-    /**
-     * Rate limit concurrent storage requests.
-     * Default: 100
-     */
-    maxConcurrentStorageRequests: number;
-    /**
-     * Rate limit concurrent orderer requests.
-     * Default: 100
-     */
-    maxConcurrentOrdererRequests: number;
-    /**
-     * Give hosts the option to change blob aggregation behavior to suit their needs.
-     * Larger number means fewer blob individual requests, but less blob-deduping.
-     * Smaller number means more blob individual requests, but more blob-deduping.
-     * Setting to `undefined` disables blob aggregration.
-     * Default: undefined
-     */
-    aggregateBlobsSmallerThanBytes: number | undefined;
-    /**
-     * Enable uploading entire summary tree as a IWholeSummaryPayload to storage.
-     * Default: false
-     */
-    enableWholeSummaryUpload: boolean;
-    /**
-     * Enable service endpoint discovery when creating or joining a session.
-     * Default: false
-     */
-    enableDiscovery?: boolean;
-    /**
-     * Enable using RestLess which avoids CORS preflight requests.
-     * Default: true
-     */
-    enableRestLess: boolean;
-    /**
-     * Enable internal cache of summaries/snapshots.
-     * Reduces Summarizer boot time and reduces server load in E2E tests.
-     * Default: true
-     */
-    enableInternalSummaryCaching: boolean;
+	/**
+	 * Enable prefetching entire snapshot tree into memory before it is loaded by the runtime.
+	 * Default: true
+	 */
+	enablePrefetch: boolean;
+	/**
+	 * Rate limit concurrent storage requests.
+	 * Default: 100
+	 */
+	maxConcurrentStorageRequests: number;
+	/**
+	 * Rate limit concurrent orderer requests.
+	 * Default: 100
+	 */
+	maxConcurrentOrdererRequests: number;
+	/**
+	 * Give hosts the option to change blob aggregation behavior to suit their needs.
+	 * Larger number means fewer blob individual requests, but less blob-deduping.
+	 * Smaller number means more blob individual requests, but more blob-deduping.
+	 * Setting to `undefined` disables blob aggregration.
+	 * Default: undefined
+	 */
+	aggregateBlobsSmallerThanBytes: number | undefined;
+	/**
+	 * Enable uploading entire summary tree as a IWholeSummaryPayload to storage.
+	 * Default: false
+	 */
+	enableWholeSummaryUpload: boolean;
+	/**
+	 * Enable service endpoint discovery when creating or joining a session.
+	 * Default: false
+	 */
+	enableDiscovery?: boolean;
+	/**
+	 * Enable using RestLess which avoids CORS preflight requests.
+	 * Default: true
+	 */
+	enableRestLess: boolean;
+	/**
+	 * Enable internal cache of summaries/snapshots.
+	 * Reduces Summarizer boot time and reduces server load in E2E tests.
+	 * Default: true
+	 */
+	enableInternalSummaryCaching: boolean;
 }