@fluidframework/routerlicious-driver 0.54.2 → 0.56.0-49831

package/src/restWrapper.ts

@@ -11,7 +11,12 @@ import {
     RestLessClient,
     RestWrapper,
 } from "@fluidframework/server-services-client";
-import Axios, { AxiosError, AxiosRequestConfig } from "axios";
+import {
+    default as nodeFetch,
+    RequestInfo as FetchRequestInfo,
+    RequestInit as FetchRequestInit,
+} from "node-fetch";
+import type { AxiosRequestConfig } from "axios";
 import safeStringify from "json-stringify-safe";
 import { v4 as uuid } from "uuid";
 import { throwR11sNetworkError } from "./errorUtils";
@@ -19,12 +24,31 @@ import { ITokenProvider } from "./tokens";
 
 type AuthorizationHeaderGetter = (refresh?: boolean) => Promise<string | undefined>;
 
+// Borrowed from @fluidframework/odsp-driver's fetch.ts
+// The only purpose of this helper is to work around the slight misalignments between the
+// Browser's fetch API and the 'node-fetch' package by wrapping the call to the 'node-fetch' API
+// in the browser's types from 'lib.dom.d.ts'.
+export const fetch = async (request: RequestInfo, config?: RequestInit): Promise<Response> =>
+    nodeFetch(request as FetchRequestInfo, config as FetchRequestInit) as unknown as Response;
+
+const axiosRequestConfigToFetchRequestConfig = (requestConfig: AxiosRequestConfig): [RequestInfo, RequestInit] => {
+    const requestInfo: string = requestConfig.baseURL !== undefined
+        ? `${requestConfig.baseURL}${requestConfig.url ?? ""}`
+        : requestConfig.url ?? "";
+    const requestInit: RequestInit = {
+        method: requestConfig.method,
+        headers: requestConfig.headers,
+        body: requestConfig.data,
+    };
+    return [requestInfo, requestInit];
+};
+
 export class RouterliciousRestWrapper extends RestWrapper {
     private authorizationHeader: string | undefined;
     private readonly restLess = new RestLessClient();
 
     constructor(
-        private readonly logger: ITelemetryLogger,
+        logger: ITelemetryLogger,
         private readonly rateLimiter: RateLimiter,
         private readonly getAuthorizationHeader: AuthorizationHeaderGetter,
         private readonly useRestLess: boolean,
@@ -45,46 +69,47 @@ export class RouterliciousRestWrapper extends RestWrapper {
         };
 
         const translatedConfig = this.useRestLess ? this.restLess.translate(config) : config;
-
-        try {
-            const response = await this.rateLimiter.schedule(async () => Axios.request<T>(translatedConfig));
-            return response.data;
-        } catch (reason: any) {
-            if (!reason || !reason?.isAxiosError) {
-                // Unknown error, treat as critical error and immediately throw as non-retriable
-                this.logger.sendErrorEvent({
-                    eventName: "CriticalRequestError",
-                    correlationId: config.headers["x-correlation-id"] as string,
-                }, reason);
-                throwR11sNetworkError("r11sRequestFailed", `Unknown Error on [${config.method}] to [${config.url}]: ${
-                    safeStringify(reason)
-                }`);
-            }
-
-            const axiosError = reason as AxiosError;
-            if (axiosError.response?.status === statusCode) {
-                // Axios misinterpreted as error, return as successful response
-                return axiosError.response.data as T;
-            }
-
-            if (axiosError.response?.status === 401 && canRetry) {
-                // Refresh Authorization header and retry once
-                this.authorizationHeader = await this.getAuthorizationHeader(true);
-                return this.request<T>(config, statusCode, false);
-            }
-
-            if (axiosError.response?.status === 429 && axiosError.response.data?.retryAfter > 0) {
-                // Retry based on retryAfter[Seconds]
-                return new Promise<T>((resolve, reject) => setTimeout(() => {
-                    this.request<T>(config, statusCode)
-                        .then(resolve)
-                        .catch(reject);
-                }, axiosError.response!.data.retryAfter * 1000));
-            }
-
-            // Allow anything else to be handled upstream
-            throwR11sNetworkError("r11sAxiosError", axiosError.message, axiosError.response?.status);
+        const fetchRequestConfig = axiosRequestConfigToFetchRequestConfig(translatedConfig);
+
+        const response: Response = await this.rateLimiter.schedule(async () => fetch(...fetchRequestConfig)
+            .catch(async (error) => {
+                // Fetch throws a TypeError on network error
+                const isNetworkError = error instanceof TypeError;
+                throwR11sNetworkError(
+                    "r11sFetchError",
+                    isNetworkError ? `NetworkError: ${error.message}` : safeStringify(error));
+            }));
+
+        const responseBody: any = await response.clone().json().catch(async () => response.text());
+
+        // Success
+        if (response.ok || response.status === statusCode) {
+            const result: T = responseBody;
+            return result;
+        }
+        // Failure
+        if (response.status === 401 && canRetry) {
+            // Refresh Authorization header and retry once
+            this.authorizationHeader = await this.getAuthorizationHeader(true);
+            return this.request<T>(config, statusCode, false);
         }
+        if (response.status === 429 && responseBody?.retryAfter > 0) {
+            // Retry based on retryAfter[Seconds]
+            return new Promise<T>((resolve, reject) => setTimeout(() => {
+                this.request<T>(config, statusCode)
+                    .then(resolve)
+                    .catch(reject);
+            }, responseBody.retryAfter * 1000));
+        }
+
+        throwR11sNetworkError(
+            "r11sFetchError",
+            responseBody !== undefined
+                ? typeof responseBody === "string" ? responseBody : safeStringify(responseBody)
+                : response.statusText,
+            response.status,
+            responseBody?.retryAfter,
+        );
     }
 
     private generateHeaders(requestHeaders?: Record<string, unknown>): Record<string, unknown> {

package/src/shreddedSummaryDocumentStorageService.ts

@@ -72,7 +72,7 @@ export class ShreddedSummaryDocumentStorageService implements IDocumentStorageSe
         }
     }
 
-    public async getVersions(versionId: string, count: number): Promise<IVersion[]> {
+    public async getVersions(versionId: string | null, count: number): Promise<IVersion[]> {
         const id = versionId ? versionId : this.id;
         const commits = await PerformanceEvent.timedExecAsync(
             this.logger,