@fluidframework/driver-utils 1.2.3-83900 → 2.0.0-internal.1.0.0

package/src/network.ts

@@ -8,6 +8,8 @@ import {
     IDriverErrorBase,
     IAuthorizationError,
     DriverErrorType,
+    ILocationRedirectionError,
+    IResolvedUrl,
 } from "@fluidframework/driver-definitions";
 import { ITelemetryProperties } from "@fluidframework/common-definitions";
 import { IFluidErrorBase, LoggingError } from "@fluidframework/telemetry-utils";
@@ -91,6 +93,19 @@ export class AuthorizationError extends LoggingError implements IAuthorizationEr
     }
 }
 
+export class LocationRedirectionError extends LoggingError implements ILocationRedirectionError, IFluidErrorBase {
+    readonly errorType = DriverErrorType.locationRedirection;
+    readonly canRetry = false;
+
+    constructor(
+        message: string,
+        readonly redirectUrl: IResolvedUrl,
+        props: DriverErrorTelemetryProps,
+    ) {
+        super(message, props);
+    }
+}
+
 export class NetworkErrorBasic<T extends string> extends LoggingError implements IFluidErrorBase {
     constructor(
         message: string,

package/src/packageVersion.ts

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

package/src/parallelRequests.ts

@@ -23,7 +23,7 @@ type WorkingState = "working" | "done" | "canceled";
  * data in the right order. Take a look at UT for examples.
  * @param concurrency - level of concurrency
  * @param from - starting point of fetching data (inclusive)
- * @param to  - ending point of fetching data. exclusive, or undefined if unknown
+ * @param to - ending point of fetching data. exclusive, or undefined if unknown
  * @param payloadSize - batch size
  * @param logger - logger to use
  * @param requestCallback - callback to request batches
@@ -354,6 +354,9 @@ export class Queue<T> implements IStream<T> {
  * @param telemetryEvent - telemetry event used to track consecutive batch of requests
  * @param strongTo - tells if ops in range from...to have to be there and have to be retrieved.
  * If false, returning less ops would mean we reached end of file.
+ * @param logger - logger object to use to log progress & errors
+ * @param signal - cancelation signal
+ * @param scenarioName - reason for fetching ops
  * @returns - an object with resulting ops and cancellation / partial result flags
  */
 async function getSingleOpBatch(
@@ -362,7 +365,7 @@ async function getSingleOpBatch(
     strongTo: boolean,
     logger: ITelemetryLogger,
     signal?: AbortSignal,
-    fetchReason?: string):
+    scenarioName?: string):
         Promise<{ partial: boolean; cancel: boolean; payload: ISequencedDocumentMessage[]; }> {
     let lastSuccessTime: number | undefined;
 
@@ -426,7 +429,7 @@ async function getSingleOpBatch(
                     retry,
                     duration: performance.now() - startTime,
                     retryAfter,
-                    fetchReason,
+                    reason: scenarioName,
                 },
                 error);
 
@@ -446,6 +449,18 @@ async function getSingleOpBatch(
     return nothing;
 }
 
+/**
+ * Request ops from storage
+ * @param get - Getter callback to get individual batches
+ * @param concurrency - Number of concurrent requests to make
+ * @param fromTotal - starting sequence number to fetch (inclusive)
+ * @param toTotal - max (exclusive) sequence number to fetch
+ * @param payloadSize - Payload size
+ * @param logger - Logger to log progress and errors
+ * @param signal - Cancelation signal
+ * @param scenarioName - Reason for fetching ops
+ * @returns - Messages fetched
+ */
 export function requestOps(
     get: (from: number, to: number, telemetryProps: ITelemetryProperties) => Promise<IDeltasFetchResult>,
     concurrency: number,
@@ -454,7 +469,7 @@ export function requestOps(
     payloadSize: number,
     logger: ITelemetryLogger,
     signal?: AbortSignal,
-    fetchReason?: string,
+    scenarioName?: string,
 ): IStream<ISequencedDocumentMessage[]> {
     let requests = 0;
     let lastFetch: number | undefined;
@@ -469,7 +484,7 @@ export function requestOps(
     const telemetryEvent = PerformanceEvent.start(logger, {
         eventName: "GetDeltas",
         ...propsTotal,
-        fetchReason,
+        reason: scenarioName,
     });
 
     const manager = new ParallelRequests<ISequencedDocumentMessage>(
@@ -485,7 +500,7 @@ export function requestOps(
                 strongTo,
                 logger,
                 signal,
-                fetchReason,
+                scenarioName,
             );
         },
         (deltas: ISequencedDocumentMessage[]) => {

package/src/readAndParse.ts

@@ -7,11 +7,16 @@ import { bufferToString } from "@fluidframework/common-utils";
 import { IDocumentStorageService } from "@fluidframework/driver-definitions";
 
 /**
- * Read a blob from IDocumentStorageService and JSON.parse it into object of type T
+ * Read a blob from {@link @fluidframework/driver-definitions#IDocumentStorageService} and
+ * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse | JSON.parse}
+ * it into object of type `T`.
  *
- * @param storage - the IDocumentStorageService to read from
- * @param id - the id of the blob to read and parse
- * @returns the object that we decoded and JSON.parse
+ * @param storage - The `DocumentStorageService` to read from.
+ * @param id - The ID of the blob to read and parse.
+ *
+ * @typeParam T - Output type matching JSON format of inpyt blob data.
+ *
+ * @returns The object that we decoded and parsed via `JSON.parse`.
  */
 export async function readAndParse<T>(storage: Pick<IDocumentStorageService, "readBlob">, id: string): Promise<T> {
     const blob = await storage.readBlob(id);