@fluidframework/driver-utils 1.4.0-115997 → 2.0.0-dev-rc.1.0.0.224419

package/src/network.ts

@@ -4,166 +4,244 @@
  */
 
 import {
-    IThrottlingWarning,
-    IDriverErrorBase,
-    IAuthorizationError,
-    DriverErrorType,
+	IThrottlingWarning,
+	IDriverErrorBase,
+	IAuthorizationError,
+	// eslint-disable-next-line import/no-deprecated
+	DriverErrorType,
+	ILocationRedirectionError,
+	IResolvedUrl,
+	DriverErrorTypes,
 } from "@fluidframework/driver-definitions";
-import { ITelemetryProperties } from "@fluidframework/common-definitions";
+import { ITelemetryProperties } from "@fluidframework/core-interfaces";
 import { IFluidErrorBase, LoggingError } from "@fluidframework/telemetry-utils";
 
+/**
+ * @internal
+ */
 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")
+/**
+ * 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")
+ * @internal
+ */
 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;
 }
 
 /**
- * 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.
+ * Telemetry props with driver-specific required properties
+ * @internal
  */
- export interface IAnyDriverError extends Omit<IDriverErrorBase, "errorType"> {
-    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.
+ * @internal
  */
 export class GenericNetworkError extends LoggingError implements IDriverErrorBase, IFluidErrorBase {
-    readonly errorType = DriverErrorType.genericNetworkError;
-
-    constructor(
-        message: string,
-        readonly canRetry: boolean,
-        props: DriverErrorTelemetryProps,
-    ) {
-        super(message, props);
-    }
+	// eslint-disable-next-line import/no-deprecated
+	readonly errorType = DriverErrorType.genericNetworkError;
+
+	constructor(
+		message: string,
+		readonly canRetry: boolean,
+		props: DriverErrorTelemetryProps,
+	) {
+		super(message, props);
+	}
+}
+
+/**
+ * FluidInvalidSchema error class.
+ * @internal
+ */
+export class FluidInvalidSchemaError
+	extends LoggingError
+	implements IDriverErrorBase, IFluidErrorBase
+{
+	// eslint-disable-next-line import/no-deprecated
+	readonly errorType = DriverErrorType.fluidInvalidSchema;
+	readonly canRetry = false;
+
+	constructor(message: string, props: DriverErrorTelemetryProps) {
+		super(message, props);
+	}
+}
+
+/**
+ * @internal
+ */
+export class DeltaStreamConnectionForbiddenError
+	extends LoggingError
+	implements IDriverErrorBase, IFluidErrorBase
+{
+	// eslint-disable-next-line import/no-deprecated
+	static readonly errorType = DriverErrorType.deltaStreamConnectionForbidden;
+	readonly errorType = DeltaStreamConnectionForbiddenError.errorType;
+	readonly canRetry = false;
+	readonly storageOnlyReason: string | undefined;
+
+	constructor(message: string, props: DriverErrorTelemetryProps, storageOnlyReason?: string) {
+		super(message, { ...props, statusCode: 400 });
+		this.storageOnlyReason = storageOnlyReason;
+	}
 }
 
-// Todo GH #6214: Remove after next drive def bump. This is necessary as there is no
-// compatible way to augment an enum, as it can't be optional. So for now
-// we need to duplicate the value here. We likely need to rethink our
-// DriverErrorType strategy so that it supports extension with optional
-// value.
-const deltaStreamConnectionForbiddenStr = "deltaStreamConnectionForbidden";
-export class DeltaStreamConnectionForbiddenError extends LoggingError implements IFluidErrorBase {
-    static readonly errorType: string =
-        DriverErrorType[deltaStreamConnectionForbiddenStr] ?? deltaStreamConnectionForbiddenStr;
-    readonly errorType: string = DeltaStreamConnectionForbiddenError.errorType;
-    readonly canRetry = false;
-
-    constructor(message: string, props: DriverErrorTelemetryProps) {
-        super(message, { ...props, statusCode: 400 });
-    }
+/**
+ * @internal
+ */
+export class AuthorizationError
+	extends LoggingError
+	implements IAuthorizationError, IFluidErrorBase
+{
+	// eslint-disable-next-line import/no-deprecated
+	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"]));
-    }
+/**
+ * @internal
+ */
+export class LocationRedirectionError
+	extends LoggingError
+	implements ILocationRedirectionError, IFluidErrorBase
+{
+	// eslint-disable-next-line import/no-deprecated
+	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"]));
+	}
 }
 
+/**
+ * @internal
+ */
 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);
+	}
 }
 
+/**
+ * @internal
+ */
 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);
+	}
 }
 
+/**
+ * @internal
+ */
 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
+ * @internal
  */
 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);
-    }
+	// eslint-disable-next-line import/no-deprecated
+	readonly errorType = DriverErrorType.throttlingError;
+	readonly canRetry = true;
+
+	constructor(
+		message: string,
+		readonly retryAfterSeconds: number,
+		props: DriverErrorTelemetryProps,
+	) {
+		super(message, props);
+	}
 }
 
+/**
+ * @internal
+ */
 export const createWriteError = (message: string, props: DriverErrorTelemetryProps) =>
-    new NonRetryableError(message, DriverErrorType.writeError, props);
+	new NonRetryableError(message, DriverErrorTypes.writeError, props);
 
+/**
+ * @internal
+ */
 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);
 }
 
 /**
  * Check if a connection error can be retried.  Unless explicitly allowed, retry is disallowed.
  * I.e. asserts or unexpected exceptions in our code result in container failure.
  * @param error - The error to inspect for ability to retry
+ * @internal
  */
 export const canRetryOnError = (error: any): boolean => error?.canRetry === true;
 
-/** Check retryAfterSeconds property on error */
+/**
+ * Check retryAfterSeconds property on error
+ * @internal
+ */
 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;
+/**
+ * Check retryAfterSeconds property on error and convert to ms
+ * @internal
+ */
+export const getRetryDelayFromError = (error: any): number | undefined =>
+	error?.retryAfterSeconds !== undefined ? error.retryAfterSeconds * 1000 : undefined;

package/src/networkUtils.ts

@@ -3,58 +3,33 @@
  * Licensed under the MIT License.
  */
 
-import { ITelemetryErrorEvent, ITelemetryLogger } from "@fluidframework/common-definitions";
+import { ITelemetryErrorEvent } from "@fluidframework/core-interfaces";
+import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
 import { isOnline, OnlineStatus, canRetryOnError } from "./network";
 
-export function logNetworkFailure(logger: ITelemetryLogger, event: ITelemetryErrorEvent, error?: any) {
-    const newEvent = { ...event };
-
-    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;
-        }
-    }
-
-    // non-retryable errors are fatal and should be logged as errors
-    newEvent.category = canRetryOnError(error) ? "generic" : "error";
-    logger.sendTelemetryEvent(newEvent, error);
-}
-
 /**
- * Wait for browser to get to connected state.
- * If connected, waits minimum of minDelay anyway (between network retries)
- * If disconnected, polls every 30 seconds anyway, to make sure we are not getting stuck because of wrong signal
- * Note that browsers will have false positives (like having Hyper-V adapter on machine,
- * or machine connected to router that is not connected to internet)
- * But there should be no false negatives.
- * The only exception - Opera returns false when user enters "Work Offline" mode, regardless of actual connectivity.
+ * @internal
  */
-// 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;
+export function logNetworkFailure(
+	logger: ITelemetryLoggerExt,
+	event: ITelemetryErrorEvent,
+	error?: any,
+) {
+	const newEvent = { ...event };
+
+	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;
+		}
+	}
 
-    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);
-    });
+	// non-retryable errors are fatal and should be logged as errors
+	newEvent.category = canRetryOnError(error) ? "generic" : "error";
+	logger.sendTelemetryEvent(newEvent, error);
 }

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/driver-utils";
-export const pkgVersion = "1.4.0-115997";
+export const pkgVersion = "2.0.0-dev-rc.1.0.0.224419";