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

package/src/network.ts

@@ -4,30 +4,34 @@
  */
 
 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;
+	if (
+		typeof navigator === "object" &&
+		navigator !== null &&
+		typeof navigator.onLine === "boolean"
+	) {
+		return navigator.onLine ? OnlineStatus.Online : OnlineStatus.Offline;
+	}
+	return OnlineStatus.Unknown;
 }
 
 /**
@@ -41,143 +45,141 @@ export function isOnline(): OnlineStatus {
  *
  * @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;
+	readonly errorType: string;
 }
 
 /** 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 +191,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;

package/src/networkUtils.ts

@@ -6,25 +6,28 @@
 import { ITelemetryErrorEvent, ITelemetryLogger } from "@fluidframework/common-definitions";
 import { isOnline, OnlineStatus, canRetryOnError } from "./network";
 
-export function logNetworkFailure(logger: ITelemetryLogger, event: ITelemetryErrorEvent, error?: any) {
-    const newEvent = { ...event };
+export function logNetworkFailure(
+	logger: ITelemetryLogger,
+	event: ITelemetryErrorEvent,
+	error?: any,
+) {
+	const newEvent = { ...event };
 
-    const errorOnlineProp = error.online;
-    newEvent.online = typeof errorOnlineProp === "string"
-        ? errorOnlineProp
-        : OnlineStatus[isOnline()];
+	const errorOnlineProp = error.online;
+	newEvent.online =
+		typeof errorOnlineProp === "string" ? errorOnlineProp : OnlineStatus[isOnline()];
 
-    if (typeof navigator === "object" && navigator !== null) {
-        const nav = navigator as any;
-        const connection = nav.connection ?? nav.mozConnection ?? nav.webkitConnection;
-        if (connection !== null && typeof connection === "object") {
-            newEvent.connectionType = connection.type;
-        }
-    }
+	if (typeof navigator === "object" && navigator !== null) {
+		const nav = navigator as any;
+		const connection = nav.connection ?? nav.mozConnection ?? nav.webkitConnection;
+		if (connection !== null && typeof connection === "object") {
+			newEvent.connectionType = connection.type;
+		}
+	}
 
-    // non-retryable errors are fatal and should be logged as errors
-    newEvent.category = canRetryOnError(error) ? "generic" : "error";
-    logger.sendTelemetryEvent(newEvent, error);
+	// non-retryable errors are fatal and should be logged as errors
+	newEvent.category = canRetryOnError(error) ? "generic" : "error";
+	logger.sendTelemetryEvent(newEvent, error);
 }
 
 /**
@@ -38,23 +41,23 @@ export function logNetworkFailure(logger: ITelemetryLogger, event: ITelemetryErr
  */
 // eslint-disable-next-line @typescript-eslint/promise-function-async
 export function waitForConnectedState(minDelay: number): Promise<void> {
-    // Use this frequency to poll even when we are offline and able to setup online/offline listener
-    // This is mostly safety net
-    const offlinePollFrequency = 30000;
+	// Use this frequency to poll even when we are offline and able to setup online/offline listener
+	// This is mostly safety net
+	const offlinePollFrequency = 30000;
 
-    return new Promise((resolve) => {
-        let listener: () => void = resolve;
-        let delay = minDelay;
-        if (isOnline() === OnlineStatus.Offline) {
-            if (window?.addEventListener !== undefined) {
-                listener = () => {
-                    resolve();
-                    window.removeEventListener("online", listener);
-                };
-                window.addEventListener("online", listener, false);
-                delay = Math.max(minDelay, offlinePollFrequency);
-            }
-        }
-        setTimeout(listener, delay);
-    });
+	return new Promise((resolve) => {
+		let listener: () => void = resolve;
+		let delay = minDelay;
+		if (isOnline() === OnlineStatus.Offline) {
+			if (window?.addEventListener !== undefined) {
+				listener = () => {
+					resolve();
+					window.removeEventListener("online", listener);
+				};
+				window.addEventListener("online", listener, false);
+				delay = Math.max(minDelay, offlinePollFrequency);
+			}
+		}
+		setTimeout(listener, delay);
+	});
 }

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/driver-utils";
-export const pkgVersion = "2.0.0-internal.3.0.1";
+export const pkgVersion = "2.0.0-internal.3.1.0";