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

package/src/insecureUrlResolver.ts

@@ -7,10 +7,10 @@ import { parse } from "url";
 import { assert } from "@fluidframework/common-utils";
 import { IRequest } from "@fluidframework/core-interfaces";
 import {
-    IFluidResolvedUrl,
-    IResolvedUrl,
-    IUrlResolver,
-    DriverHeader,
+	IFluidResolvedUrl,
+	IResolvedUrl,
+	IUrlResolver,
+	DriverHeader,
 } from "@fluidframework/driver-definitions";
 import Axios from "axios";
 
@@ -29,128 +29,139 @@ import Axios from "axios";
  * works or a router inside of a single page app framework.
  */
 export class InsecureUrlResolver implements IUrlResolver {
-    private readonly cache = new Map<string, Promise<IResolvedUrl>>();
+	private readonly cache = new Map<string, Promise<IResolvedUrl>>();
 
-    constructor(
-        private readonly hostUrl: string,
-        private readonly ordererUrl: string,
-        private readonly storageUrl: string,
-        private readonly tenantId: string,
-        private readonly bearer: string,
-        private readonly isForNodeTest: boolean = false,
-    ) { }
+	constructor(
+		private readonly hostUrl: string,
+		private readonly ordererUrl: string,
+		private readonly storageUrl: string,
+		private readonly tenantId: string,
+		private readonly bearer: string,
+		private readonly isForNodeTest: boolean = false,
+	) {}
 
-    public async resolve(request: IRequest): Promise<IResolvedUrl | undefined> {
-        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-        if (request.headers?.[DriverHeader.createNew]) {
-            const [, queryString] = request.url.split("?");
-            const searchParams = new URLSearchParams(queryString);
-            const fileName = searchParams.get("fileName");
-            return this.resolveHelper(fileName);
-        }
-        const parsedUrl = new URL(request.url);
-        // If hosts match then we use the local tenant information. Otherwise we make a REST call out to the hosting
-        // service using our bearer token.
-        if (this.isForNodeTest) {
-            const [, documentId, tmpRelativePath] = parsedUrl.pathname.substr(1).split("/");
-            const relativePath = tmpRelativePath === undefined ? "" : tmpRelativePath;
-            return this.resolveHelper(documentId, relativePath, parsedUrl.search);
-        } else if (parsedUrl.host === window.location.host) {
-            const fullPath = parsedUrl.pathname.substr(1);
-            const documentId = fullPath.split("/")[0];
-            const documentRelativePath = fullPath.slice(documentId.length);
-            return this.resolveHelper(documentId, documentRelativePath);
-        } else {
-            const maybeResolvedUrl = this.cache.get(request.url);
-            if (maybeResolvedUrl) {
-                return maybeResolvedUrl;
-            }
+	public async resolve(request: IRequest): Promise<IResolvedUrl | undefined> {
+		// eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+		if (request.headers?.[DriverHeader.createNew]) {
+			const [, queryString] = request.url.split("?");
+			const searchParams = new URLSearchParams(queryString);
+			const fileName = searchParams.get("fileName");
+			return this.resolveHelper(fileName);
+		}
+		const parsedUrl = new URL(request.url);
+		// If hosts match then we use the local tenant information. Otherwise we make a REST call out to the hosting
+		// service using our bearer token.
+		if (this.isForNodeTest) {
+			const [, documentId, tmpRelativePath] = parsedUrl.pathname.substr(1).split("/");
+			const relativePath = tmpRelativePath === undefined ? "" : tmpRelativePath;
+			return this.resolveHelper(documentId, relativePath, parsedUrl.search);
+		} else if (parsedUrl.host === window.location.host) {
+			const fullPath = parsedUrl.pathname.substr(1);
+			const documentId = fullPath.split("/")[0];
+			const documentRelativePath = fullPath.slice(documentId.length);
+			return this.resolveHelper(documentId, documentRelativePath);
+		} else {
+			const maybeResolvedUrl = this.cache.get(request.url);
+			if (maybeResolvedUrl) {
+				return maybeResolvedUrl;
+			}
 
-            const headers = {
-                Authorization: `Bearer ${this.bearer}`,
-            };
-            const resolvedP = Axios.post<IResolvedUrl>(
-                `${this.hostUrl}/api/v1/load`,
-                {
-                    url: request.url,
-                },
-                {
-                    headers,
-                });
-            this.cache.set(request.url, resolvedP.then((resolved) => resolved.data));
+			const headers = {
+				Authorization: `Bearer ${this.bearer}`,
+			};
+			const resolvedP = Axios.post<IResolvedUrl>(
+				`${this.hostUrl}/api/v1/load`,
+				{
+					url: request.url,
+				},
+				{
+					headers,
+				},
+			);
+			this.cache.set(
+				request.url,
+				resolvedP.then((resolved) => resolved.data),
+			);
 
-            return this.cache.get(request.url);
-        }
-    }
+			return this.cache.get(request.url);
+		}
+	}
 
-    private resolveHelper(documentId: string | null, documentRelativePath: string = "", queryParams: string = "") {
-        const encodedTenantId = encodeURIComponent(this.tenantId);
-        const host = new URL(this.ordererUrl).host;
-        // when the document ID is not provided we need to resolve a special create new document URL.
-        // the actual container ID will be generated by the driver.
-        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-        if (!documentId) {
-            const createNewResponse: IFluidResolvedUrl = {
-                endpoints: {
-                    deltaStorageUrl: `${this.ordererUrl}/deltas/${encodedTenantId}/new`,
-                    ordererUrl: this.ordererUrl,
-                    storageUrl: `${this.storageUrl}/repos/${encodedTenantId}`,
-                },
-                // document ID is ignored by the driver for new container requests
-                id: "",
-                tokens: {},
-                type: "fluid",
-                url: `fluid://${host}/${encodedTenantId}/new`,
-            };
-            return createNewResponse;
-        }
-        const encodedDocId = encodeURIComponent(documentId);
-        const relativePath = !documentRelativePath || documentRelativePath.startsWith("/")
-            ? documentRelativePath : `/${documentRelativePath}`;
-        const documentUrl = `fluid://${host}/${encodedTenantId}/${encodedDocId}${relativePath}${queryParams}`;
+	private resolveHelper(
+		documentId: string | null,
+		documentRelativePath: string = "",
+		queryParams: string = "",
+	) {
+		const encodedTenantId = encodeURIComponent(this.tenantId);
+		const host = new URL(this.ordererUrl).host;
+		// when the document ID is not provided we need to resolve a special create new document URL.
+		// the actual container ID will be generated by the driver.
+		// eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+		if (!documentId) {
+			const createNewResponse: IFluidResolvedUrl = {
+				endpoints: {
+					deltaStorageUrl: `${this.ordererUrl}/deltas/${encodedTenantId}/new`,
+					ordererUrl: this.ordererUrl,
+					storageUrl: `${this.storageUrl}/repos/${encodedTenantId}`,
+				},
+				// document ID is ignored by the driver for new container requests
+				id: "",
+				tokens: {},
+				type: "fluid",
+				url: `fluid://${host}/${encodedTenantId}/new`,
+			};
+			return createNewResponse;
+		}
+		const encodedDocId = encodeURIComponent(documentId);
+		const relativePath =
+			!documentRelativePath || documentRelativePath.startsWith("/")
+				? documentRelativePath
+				: `/${documentRelativePath}`;
+		const documentUrl = `fluid://${host}/${encodedTenantId}/${encodedDocId}${relativePath}${queryParams}`;
 
-        const deltaStorageUrl = `${this.ordererUrl}/deltas/${encodedTenantId}/${encodedDocId}`;
-        const storageUrl = `${this.storageUrl}/repos/${encodedTenantId}`;
+		const deltaStorageUrl = `${this.ordererUrl}/deltas/${encodedTenantId}/${encodedDocId}`;
+		const storageUrl = `${this.storageUrl}/repos/${encodedTenantId}`;
 
-        const response: IFluidResolvedUrl = {
-            endpoints: {
-                deltaStorageUrl,
-                ordererUrl: this.ordererUrl,
-                storageUrl,
-            },
-            id: documentId,
-            tokens: {},
-            type: "fluid",
-            url: documentUrl,
-        };
-        return response;
-    }
+		const response: IFluidResolvedUrl = {
+			endpoints: {
+				deltaStorageUrl,
+				ordererUrl: this.ordererUrl,
+				storageUrl,
+			},
+			id: documentId,
+			tokens: {},
+			type: "fluid",
+			url: documentUrl,
+		};
+		return response;
+	}
 
-    public async getAbsoluteUrl(resolvedUrl: IResolvedUrl, relativeUrl: string): Promise<string> {
-        const fluidResolvedUrl = resolvedUrl as IFluidResolvedUrl;
+	public async getAbsoluteUrl(resolvedUrl: IResolvedUrl, relativeUrl: string): Promise<string> {
+		const fluidResolvedUrl = resolvedUrl as IFluidResolvedUrl;
 
-        const parsedUrl = parse(fluidResolvedUrl.url);
-        const [, , documentId] = parsedUrl.pathname?.split("/") ?? [];
-        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-        assert(!!documentId, 0x273 /* "Invalid document id from parsed URL" */);
+		const parsedUrl = parse(fluidResolvedUrl.url);
+		const [, , documentId] = parsedUrl.pathname?.split("/") ?? [];
+		// eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+		assert(!!documentId, 0x273 /* "Invalid document id from parsed URL" */);
 
-        let url = relativeUrl;
-        if (url.startsWith("/")) {
-            url = url.substr(1);
-        }
+		let url = relativeUrl;
+		if (url.startsWith("/")) {
+			url = url.substr(1);
+		}
 
-        return `${this.hostUrl}/${encodeURIComponent(
-            this.tenantId)}/${encodeURIComponent(documentId)}/${url}`;
-    }
+		return `${this.hostUrl}/${encodeURIComponent(this.tenantId)}/${encodeURIComponent(
+			documentId,
+		)}/${url}`;
+	}
 
-    public createCreateNewRequest(fileName?: string): IRequest {
-        const createNewRequest: IRequest = {
-            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-            url: fileName ? `${this.hostUrl}?fileName=${fileName}` : this.hostUrl,
-            headers: {
-                [DriverHeader.createNew]: true,
-            },
-        };
-        return createNewRequest;
-    }
+	public createCreateNewRequest(fileName?: string): IRequest {
+		const createNewRequest: IRequest = {
+			// eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+			url: fileName ? `${this.hostUrl}?fileName=${fileName}` : this.hostUrl,
+			headers: {
+				[DriverHeader.createNew]: true,
+			},
+		};
+		return createNewRequest;
+	}
 }

package/src/messageRecognition.ts

@@ -2,62 +2,32 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { IDocumentMessage, ISequencedDocumentMessage, MessageType } from "@fluidframework/protocol-definitions";
+import {
+	IDocumentMessage,
+	ISequencedDocumentMessage,
+	MessageType,
+} from "@fluidframework/protocol-definitions";
 
 /**
  * Tells if message was sent by container runtime
  * @privateRemarks ADO #1385: To be moved to container-definitions
  * @returns whether the message is a runtime message
  */
-export function isRuntimeMessage(message: { type: string; }): boolean {
-    return message.type === MessageType.Operation;
-}
-
-enum RuntimeMessage {
-    FluidDataStoreOp = "component",
-    Attach = "attach",
-    ChunkedOp = "chunkedOp",
-    BlobAttach = "blobAttach",
-    Rejoin = "rejoin",
-    Alias = "alias",
-    Operation = "op",
-}
-
-/**
- * Determines whether or not the message type is one of the following: (legacy)
- *
- * - "component"
- *
- * - "attach"
- *
- * - "chunkedOp"
- *
- * - "blobAttach"
- *
- * - "rejoin"
- *
- * - "alias"
- *
- * - "op"
- *
- * @deprecated This API should not be used.
- */
-export function isUnpackedRuntimeMessage(message: ISequencedDocumentMessage): boolean {
-    if ((Object.values(RuntimeMessage) as string[]).includes(message.type)) {
-        return true;
-    }
-    return false;
+export function isRuntimeMessage(message: { type: string }): boolean {
+	return message.type === MessageType.Operation;
 }
 
 // ADO #1385: staging code changes across layers.
 // Eventually to be replaced by MessageType.accept
 export enum MessageType2 {
-    Accept = "accept",
+	Accept = "accept",
 }
 
 // ADO #1385: To be moved to packages/protocol-base/src/protocol.ts
-export function canBeCoalescedByService(message: ISequencedDocumentMessage | IDocumentMessage): boolean {
-    // This assumes that in the future relay service may implement coalescing of accept messages,
-    // same way it was doing coalescing of immediate noops in the past.
-    return message.type === MessageType.NoOp || message.type === MessageType2.Accept;
+export function canBeCoalescedByService(
+	message: ISequencedDocumentMessage | IDocumentMessage,
+): boolean {
+	// This assumes that in the future relay service may implement coalescing of accept messages,
+	// same way it was doing coalescing of immediate noops in the past.
+	return message.type === MessageType.NoOp || message.type === MessageType2.Accept;
 }

package/src/network.ts

@@ -4,180 +4,166 @@
  */
 
 import {
-    IThrottlingWarning,
-    IDriverErrorBase,
-    IAuthorizationError,
-    DriverErrorType,
-    ILocationRedirectionError,
-    IResolvedUrl,
+	IThrottlingWarning,
+	IDriverErrorBase,
+	IAuthorizationError,
+	DriverErrorType,
+	ILocationRedirectionError,
+	IResolvedUrl,
 } from "@fluidframework/driver-definitions";
 import { ITelemetryProperties } from "@fluidframework/common-definitions";
 import { IFluidErrorBase, LoggingError } from "@fluidframework/telemetry-utils";
 
 export enum OnlineStatus {
-    Offline,
-    Online,
-    Unknown,
+	Offline,
+	Online,
+	Unknown,
 }
 
 // It tells if we have local connection only - we might not have connection to web.
 // No solution for node.js (other than resolve dns names / ping specific sites)
 // Can also use window.addEventListener("online" / "offline")
 export function isOnline(): OnlineStatus {
-    if (typeof navigator === "object" && navigator !== null && typeof navigator.onLine === "boolean") {
-        return navigator.onLine ? OnlineStatus.Online : OnlineStatus.Offline;
-    }
-    return OnlineStatus.Unknown;
-}
-
-/**
- * Interface describing errors and warnings raised by any driver code.
- * Not expected to be implemented by a class or an object literal, but rather used in place of
- * any or unknown in various function signatures that pass errors around.
- *
- * "Any" in the interface name is a nod to the fact that errorType has lost its type constraint.
- * It will be either DriverErrorType or the specific driver's specialized error type enum,
- * but we can't reference a specific driver's error type enum in this code.
- *
- * @deprecated - In favour of {@link @fluidframework/driver-definitions#IAnyDriverError} so that
- * it can used from the base to upper layers.
-*/
-export interface IAnyDriverError extends Omit<IDriverErrorBase, "errorType"> {
-    readonly errorType: string;
+	if (
+		typeof navigator === "object" &&
+		navigator !== null &&
+		typeof navigator.onLine === "boolean"
+	) {
+		return navigator.onLine ? OnlineStatus.Online : OnlineStatus.Offline;
+	}
+	return OnlineStatus.Unknown;
 }
 
 /** Telemetry props with driver-specific required properties */
-export type DriverErrorTelemetryProps = ITelemetryProperties & { driverVersion: string | undefined; };
+export type DriverErrorTelemetryProps = ITelemetryProperties & {
+	driverVersion: string | undefined;
+};
 
 /**
  * Generic network error class.
  */
 export class GenericNetworkError extends LoggingError implements IDriverErrorBase, IFluidErrorBase {
-    readonly errorType = DriverErrorType.genericNetworkError;
-
-    constructor(
-        message: string,
-        readonly canRetry: boolean,
-        props: DriverErrorTelemetryProps,
-    ) {
-        super(message, props);
-    }
+	readonly errorType = DriverErrorType.genericNetworkError;
+
+	constructor(message: string, readonly canRetry: boolean, props: DriverErrorTelemetryProps) {
+		super(message, props);
+	}
 }
 
 /**
  * FluidInvalidSchema error class.
  */
- export class FluidInvalidSchemaError extends LoggingError implements IDriverErrorBase, IFluidErrorBase {
-    readonly errorType = DriverErrorType.fluidInvalidSchema;
-    readonly canRetry = false;
-
-    constructor(
-        message: string,
-        props: DriverErrorTelemetryProps,
-    ) {
-        super(message, props);
-    }
+export class FluidInvalidSchemaError
+	extends LoggingError
+	implements IDriverErrorBase, IFluidErrorBase
+{
+	readonly errorType = DriverErrorType.fluidInvalidSchema;
+	readonly canRetry = false;
+
+	constructor(message: string, props: DriverErrorTelemetryProps) {
+		super(message, props);
+	}
 }
 
-export class DeltaStreamConnectionForbiddenError extends LoggingError implements IDriverErrorBase, IFluidErrorBase {
-    static readonly errorType = DriverErrorType.deltaStreamConnectionForbidden;
-    readonly errorType = DeltaStreamConnectionForbiddenError.errorType;
-    readonly canRetry = false;
-
-    constructor(message: string, props: DriverErrorTelemetryProps) {
-        super(message, { ...props, statusCode: 400 });
-    }
+export class DeltaStreamConnectionForbiddenError
+	extends LoggingError
+	implements IDriverErrorBase, IFluidErrorBase
+{
+	static readonly errorType = DriverErrorType.deltaStreamConnectionForbidden;
+	readonly errorType = DeltaStreamConnectionForbiddenError.errorType;
+	readonly canRetry = false;
+
+	constructor(message: string, props: DriverErrorTelemetryProps) {
+		super(message, { ...props, statusCode: 400 });
+	}
 }
 
-export class AuthorizationError extends LoggingError implements IAuthorizationError, IFluidErrorBase {
-    readonly errorType = DriverErrorType.authorizationError;
-    readonly canRetry = false;
-
-    constructor(
-        message: string,
-        readonly claims: string | undefined,
-        readonly tenantId: string | undefined,
-        props: DriverErrorTelemetryProps,
-    ) {
-        // don't log claims or tenantId
-        super(message, props, new Set(["claims", "tenantId"]));
-    }
+export class AuthorizationError
+	extends LoggingError
+	implements IAuthorizationError, IFluidErrorBase
+{
+	readonly errorType = DriverErrorType.authorizationError;
+	readonly canRetry = false;
+
+	constructor(
+		message: string,
+		readonly claims: string | undefined,
+		readonly tenantId: string | undefined,
+		props: DriverErrorTelemetryProps,
+	) {
+		// don't log claims or tenantId
+		super(message, props, new Set(["claims", "tenantId"]));
+	}
 }
 
-export class LocationRedirectionError extends LoggingError implements ILocationRedirectionError, IFluidErrorBase {
-    readonly errorType = DriverErrorType.locationRedirection;
-    readonly canRetry = false;
-
-    constructor(
-        message: string,
-        readonly redirectUrl: IResolvedUrl,
-        props: DriverErrorTelemetryProps,
-    ) {
-        // do not log redirectURL
-        super(message, props, new Set(["redirectUrl"]));
-    }
+export class LocationRedirectionError
+	extends LoggingError
+	implements ILocationRedirectionError, IFluidErrorBase
+{
+	readonly errorType = DriverErrorType.locationRedirection;
+	readonly canRetry = false;
+
+	constructor(
+		message: string,
+		readonly redirectUrl: IResolvedUrl,
+		props: DriverErrorTelemetryProps,
+	) {
+		// do not log redirectURL
+		super(message, props, new Set(["redirectUrl"]));
+	}
 }
 
 export class NetworkErrorBasic<T extends string> extends LoggingError implements IFluidErrorBase {
-    constructor(
-        message: string,
-        readonly errorType: T,
-        readonly canRetry: boolean,
-        props: DriverErrorTelemetryProps,
-    ) {
-        super(message, props);
-    }
+	constructor(
+		message: string,
+		readonly errorType: T,
+		readonly canRetry: boolean,
+		props: DriverErrorTelemetryProps,
+	) {
+		super(message, props);
+	}
 }
 
 export class NonRetryableError<T extends string> extends NetworkErrorBasic<T> {
-    constructor(
-        message: string,
-        readonly errorType: T,
-        props: DriverErrorTelemetryProps,
-    ) {
-        super(message, errorType, false, props);
-    }
+	constructor(message: string, readonly errorType: T, props: DriverErrorTelemetryProps) {
+		super(message, errorType, false, props);
+	}
 }
 
 export class RetryableError<T extends string> extends NetworkErrorBasic<T> {
-    constructor(
-        message: string,
-        readonly errorType: T,
-        props: DriverErrorTelemetryProps,
-    ) {
-        super(message, errorType, true, props);
-    }
+	constructor(message: string, readonly errorType: T, props: DriverErrorTelemetryProps) {
+		super(message, errorType, true, props);
+	}
 }
 
 /**
  * Throttling error class - used to communicate all throttling errors
  */
 export class ThrottlingError extends LoggingError implements IThrottlingWarning, IFluidErrorBase {
-    readonly errorType = DriverErrorType.throttlingError;
-    readonly canRetry = true;
-
-    constructor(
-        message: string,
-        readonly retryAfterSeconds: number,
-        props: DriverErrorTelemetryProps,
-    ) {
-        super(message, props);
-    }
+	readonly errorType = DriverErrorType.throttlingError;
+	readonly canRetry = true;
+
+	constructor(
+		message: string,
+		readonly retryAfterSeconds: number,
+		props: DriverErrorTelemetryProps,
+	) {
+		super(message, props);
+	}
 }
 
 export const createWriteError = (message: string, props: DriverErrorTelemetryProps) =>
-    new NonRetryableError(message, DriverErrorType.writeError, props);
+	new NonRetryableError(message, DriverErrorType.writeError, props);
 
 export function createGenericNetworkError(
-    message: string,
-    retryInfo: { canRetry: boolean; retryAfterMs?: number; },
-    props: DriverErrorTelemetryProps,
+	message: string,
+	retryInfo: { canRetry: boolean; retryAfterMs?: number },
+	props: DriverErrorTelemetryProps,
 ): ThrottlingError | GenericNetworkError {
-    if (retryInfo.retryAfterMs !== undefined && retryInfo.canRetry) {
-        return new ThrottlingError(
-            message, retryInfo.retryAfterMs / 1000, props);
-    }
-    return new GenericNetworkError(message, retryInfo.canRetry, props);
+	if (retryInfo.retryAfterMs !== undefined && retryInfo.canRetry) {
+		return new ThrottlingError(message, retryInfo.retryAfterMs / 1000, props);
+	}
+	return new GenericNetworkError(message, retryInfo.canRetry, props);
 }
 
 /**
@@ -189,8 +175,8 @@ export const canRetryOnError = (error: any): boolean => error?.canRetry === true
 
 /** Check retryAfterSeconds property on error */
 export const getRetryDelaySecondsFromError = (error: any): number | undefined =>
-    error?.retryAfterSeconds as number | undefined;
+	error?.retryAfterSeconds as number | undefined;
 
 /** Check retryAfterSeconds property on error and convert to ms */
-export const getRetryDelayFromError = (error: any): number | undefined => error?.retryAfterSeconds !== undefined ?
-    error.retryAfterSeconds * 1000 : undefined;
+export const getRetryDelayFromError = (error: any): number | undefined =>
+	error?.retryAfterSeconds !== undefined ? error.retryAfterSeconds * 1000 : undefined;