@fluidframework/routerlicious-driver 0.57.2 → 0.58.1000

package/src/errorUtils.ts

@@ -48,7 +48,6 @@ export interface IR11sError {
 export type R11sError = DriverError | IR11sError;
 
 export function createR11sNetworkError(
-    fluidErrorCode: string,
     errorMessage: string,
     statusCode?: number,
     retryAfterMs?: number,
@@ -60,33 +59,31 @@ export function createR11sNetworkError(
             // a network error with no status code (e.g. err:ERR_CONN_REFUSED or err:ERR_FAILED) and
             // the error message will start with NetworkError as defined in restWrapper.ts
             return new GenericNetworkError(
-                fluidErrorCode, errorMessage, errorMessage.startsWith("NetworkError"), props);
+                errorMessage, errorMessage.startsWith("NetworkError"), props);
         case 401:
         case 403:
             return new AuthorizationError(
-                fluidErrorCode, errorMessage, undefined, undefined, props);
+                errorMessage, undefined, undefined, props);
         case 404:
             const errorType = R11sErrorType.fileNotFoundOrAccessDeniedError;
-            return new NonRetryableError(fluidErrorCode, errorMessage, errorType, props);
+            return new NonRetryableError(errorMessage, errorType, props);
         case 429:
             return createGenericNetworkError(
-                fluidErrorCode, errorMessage, { canRetry: true, retryAfterMs }, props);
+                errorMessage, { canRetry: true, retryAfterMs }, props);
         case 500:
-            return new GenericNetworkError(fluidErrorCode, errorMessage, true, props);
+            return new GenericNetworkError(errorMessage, true, props);
         default:
             const retryInfo = { canRetry: retryAfterMs !== undefined, retryAfterMs };
-            return createGenericNetworkError(fluidErrorCode, errorMessage, retryInfo, props);
+            return createGenericNetworkError(errorMessage, retryInfo, props);
     }
 }
 
 export function throwR11sNetworkError(
-    fluidErrorCode: string,
     errorMessage: string,
     statusCode?: number,
     retryAfterMs?: number,
 ): never {
     const networkError = createR11sNetworkError(
-        fluidErrorCode,
         errorMessage,
         statusCode,
         retryAfterMs);
@@ -99,9 +96,8 @@ export function throwR11sNetworkError(
  * Returns network error based on error object from R11s socket (IR11sSocketError)
  */
 export function errorObjectFromSocketError(socketError: IR11sSocketError, handler: string): R11sError {
-    const message = `R11sSocketError (${handler}): ${socketError.message}`;
+    const message = `R11s socket error (${handler}): ${socketError.message}`;
     return createR11sNetworkError(
-        "r11sSocketError",
         message,
         socketError.code,
         socketError.retryAfterMs,

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/routerlicious-driver";
-export const pkgVersion = "0.57.2";
+export const pkgVersion = "0.58.1000";

package/src/restWrapper.ts

@@ -16,7 +16,7 @@ import {
     RequestInfo as FetchRequestInfo,
     RequestInit as FetchRequestInit,
 } from "node-fetch";
-import type { AxiosRequestConfig } from "axios";
+import type { AxiosRequestConfig, AxiosRequestHeaders } from "axios";
 import safeStringify from "json-stringify-safe";
 import { v4 as uuid } from "uuid";
 import { throwR11sNetworkError } from "./errorUtils";
@@ -37,7 +37,9 @@ const axiosRequestConfigToFetchRequestConfig = (requestConfig: AxiosRequestConfi
         : requestConfig.url ?? "";
     const requestInit: RequestInit = {
         method: requestConfig.method,
-        headers: requestConfig.headers,
+        // NOTE: I believe that although the Axios type permits non-string values in the header, here we are
+        // guaranteed the requestConfig only has string values in its header.
+        headers: requestConfig.headers as Record<string, string>,
         body: requestConfig.data,
     };
     return [requestInfo, requestInit];
@@ -102,23 +104,25 @@ export class RouterliciousRestWrapper extends RestWrapper {
             }, responseBody.retryAfter * 1000));
         }
 
+        const responseSummary = responseBody !== undefined
+            ? typeof responseBody === "string" ? responseBody : safeStringify(responseBody)
+            : response.statusText;
         throwR11sNetworkError(
-            "r11sFetchError",
-            responseBody !== undefined
-                ? typeof responseBody === "string" ? responseBody : safeStringify(responseBody)
-                : response.statusText,
+            `R11s fetch error: ${responseSummary}`,
             response.status,
             responseBody?.retryAfter,
         );
     }
 
-    private generateHeaders(requestHeaders?: Record<string, unknown>): Record<string, unknown> {
+    private generateHeaders(requestHeaders?: AxiosRequestHeaders | undefined): Record<string, string> {
         const correlationId = requestHeaders?.["x-correlation-id"] || uuid();
 
         return {
             ...requestHeaders,
-            "x-correlation-id": correlationId,
-            "Authorization": this.authorizationHeader,
+            // NOTE: Can correlationId actually be number | true?
+            "x-correlation-id": correlationId as string,
+            // NOTE: If this.authorizationHeader is undefined, should "Authorization" be removed entirely?
+            "Authorization": this.authorizationHeader!,
         };
     }
 }

package/src/shreddedSummaryDocumentStorageService.ts

@@ -16,7 +16,6 @@ import {
 import { buildHierarchy } from "@fluidframework/protocol-base";
 import {
     ICreateBlobResponse,
-    ISnapshotTree,
     ISnapshotTreeEx,
     ISummaryHandle,
     ISummaryTree,
@@ -32,6 +31,7 @@ import { PerformanceEvent } from "@fluidframework/telemetry-utils";
 import { IRouterliciousDriverPolicies } from "./policies";
 import { ICache, InMemoryCache } from "./cache";
 import { RetriableGitManager } from "./retriableGitManager";
+import { ISnapshotTreeVersion } from "./definitions";
 
 const isNode = typeof window === "undefined";
 
@@ -45,7 +45,7 @@ export class ShreddedSummaryDocumentStorageService implements IDocumentStorageSe
     // empty strings as values.
     protected readonly blobsShaCache = new Map<string, string>();
     private readonly blobCache: ICache<ArrayBufferLike> | undefined;
-    private readonly snapshotTreeCache: ICache<ISnapshotTreeEx> | undefined;
+    private readonly snapshotTreeCache: ICache<ISnapshotTreeVersion> | undefined;
     private readonly summaryUploadManager: ISummaryUploadManager;
 
     public get repositoryUrl(): string {
@@ -59,7 +59,7 @@ export class ShreddedSummaryDocumentStorageService implements IDocumentStorageSe
         public readonly policies: IDocumentStorageServicePolicies = {},
         driverPolicies?: IRouterliciousDriverPolicies,
         blobCache?: ICache<ArrayBufferLike>,
-        snapshotTreeCache?: ICache<ISnapshotTree>) {
+        snapshotTreeCache?: ICache<ISnapshotTreeVersion>) {
         this.summaryUploadManager = new SummaryTreeUploadManager(
                 new RetriableGitManager(manager, logger),
                 this.blobsShaCache,
@@ -67,7 +67,7 @@ export class ShreddedSummaryDocumentStorageService implements IDocumentStorageSe
             );
         if (driverPolicies?.enableRestLess === true || isNode) {
             this.blobCache = blobCache ?? new InMemoryCache();
-            this.snapshotTreeCache = (snapshotTreeCache ?? new InMemoryCache()) as ICache<ISnapshotTreeEx>;
+            this.snapshotTreeCache = snapshotTreeCache ?? new InMemoryCache();
         }
     }
 
@@ -102,7 +102,7 @@ export class ShreddedSummaryDocumentStorageService implements IDocumentStorageSe
 
         const cachedSnapshotTree = await this.snapshotTreeCache?.get(requestVersion.treeId);
         if (cachedSnapshotTree) {
-            return cachedSnapshotTree;
+            return cachedSnapshotTree.snapshotTree as ISnapshotTreeEx;
         }
 
         const rawTree = await PerformanceEvent.timedExecAsync(
@@ -120,7 +120,7 @@ export class ShreddedSummaryDocumentStorageService implements IDocumentStorageSe
             },
         );
         const tree = buildHierarchy(rawTree, this.blobsShaCache, true);
-        await this.snapshotTreeCache?.put(tree.id, tree);
+        await this.snapshotTreeCache?.put(tree.id, { id: requestVersion.id, snapshotTree: tree });
         return tree;
     }
 

package/src/wholeSummaryDocumentStorageService.ts

@@ -30,6 +30,7 @@ import {
 } from "@fluidframework/server-services-client";
 import { PerformanceEvent } from "@fluidframework/telemetry-utils";
 import { ICache, InMemoryCache } from "./cache";
+import { ISnapshotTreeVersion } from "./definitions";
 
 const latestSnapshotId: string = "latest";
 
@@ -47,13 +48,13 @@ export class WholeSummaryDocumentStorageService implements IDocumentStorageServi
         protected readonly logger: ITelemetryLogger,
         public readonly policies: IDocumentStorageServicePolicies = {},
         private readonly blobCache: ICache<ArrayBufferLike> = new InMemoryCache(),
-        private readonly snapshotTreeCache: ICache<ISnapshotTree> = new InMemoryCache()) {
+        private readonly snapshotTreeCache: ICache<ISnapshotTreeVersion> = new InMemoryCache()) {
         this.summaryUploadManager = new WholeSummaryUploadManager(manager);
     }
 
     public async getVersions(versionId: string | null, count: number): Promise<IVersion[]> {
         if (versionId !== this.id && versionId !== null) {
-            // Blobs in this scenario will never have multiple versions, so return blobId as is
+            // Blobs/Trees in this scenario will never have multiple versions, so return versionId as is
             return [{
                 id: versionId,
                 treeId: undefined!,
@@ -63,9 +64,10 @@ export class WholeSummaryDocumentStorageService implements IDocumentStorageServi
         // Fetch latest summary, cache it, and return its id.
         if (this.firstVersionsCall && count === 1) {
             this.firstVersionsCall = false;
+            const { id, snapshotTree } = await this.fetchAndCacheSnapshotTree(latestSnapshotId);
             return [{
-                id: (await this.fetchAndCacheSnapshotTree(latestSnapshotId)).id,
-                treeId: undefined!,
+                id,
+                treeId: snapshotTree.id!,
             }];
         }
 
@@ -83,7 +85,7 @@ export class WholeSummaryDocumentStorageService implements IDocumentStorageServi
         return commits.map((commit) => ({
             date: commit.commit.author.date,
             id: commit.sha,
-            treeId: undefined!,
+            treeId: commit.commit.tree.sha,
         }));
     }
 
@@ -168,10 +170,10 @@ export class WholeSummaryDocumentStorageService implements IDocumentStorageServi
         );
     }
 
-    private async fetchAndCacheSnapshotTree(versionId: string): Promise<{ id: string, snapshotTree: ISnapshotTree }> {
-        const cachedSnapshotTree = await this.snapshotTreeCache.get(versionId);
-        if (cachedSnapshotTree !== undefined) {
-            return { id: cachedSnapshotTree.id!, snapshotTree: cachedSnapshotTree };
+    private async fetchAndCacheSnapshotTree(versionId: string): Promise<ISnapshotTreeVersion> {
+        const cachedSnapshotTreeVersion = await this.snapshotTreeCache.get(versionId);
+        if (cachedSnapshotTreeVersion !== undefined) {
+            return { id: cachedSnapshotTreeVersion.id, snapshotTree: cachedSnapshotTreeVersion.snapshotTree };
         }
 
         const wholeFlatSummary = await PerformanceEvent.timedExecAsync(
@@ -189,30 +191,32 @@ export class WholeSummaryDocumentStorageService implements IDocumentStorageServi
             },
         );
         const normalizedWholeSummary = convertWholeFlatSummaryToSnapshotTreeAndBlobs(wholeFlatSummary);
-        const snapshotId = normalizedWholeSummary.snapshotTree.id;
-        assert(snapshotId !== undefined, 0x275 /* "Root tree should contain the id" */);
+        const wholeFlatSummaryId: string = wholeFlatSummary.id;
+        const snapshotTreeId = normalizedWholeSummary.snapshotTree.id;
+        assert(snapshotTreeId !== undefined, 0x275 /* "Root tree should contain the id" */);
+        const snapshotTreeVersion = { id: wholeFlatSummaryId , snapshotTree: normalizedWholeSummary.snapshotTree };
 
         const cachePs: Promise<any>[] = [
             this.snapshotTreeCache.put(
-                snapshotId,
-                normalizedWholeSummary.snapshotTree,
+                snapshotTreeId,
+                snapshotTreeVersion,
             ),
             this.initBlobCache(normalizedWholeSummary.blobs),
         ];
-        if (snapshotId !== versionId) {
+        if (snapshotTreeId !== versionId) {
             // versionId could be "latest". When summarizer checks cache for "latest", we want it to be available.
             // TODO: For in-memory cache, <latest,snapshotTree> will be a shared pointer with <snapshotId,snapshotTree>,
             // However, for something like Redis, this will cache the same value twice. Alternatively, could we simply
             // cache with versionId?
             cachePs.push(this.snapshotTreeCache.put(
                 versionId,
-                normalizedWholeSummary.snapshotTree,
+                snapshotTreeVersion,
             ));
         }
 
         await Promise.all(cachePs);
 
-        return { id: snapshotId, snapshotTree: normalizedWholeSummary.snapshotTree};
+        return snapshotTreeVersion;
     }
 
     private async initBlobCache(blobs: Map<string, ArrayBuffer>): Promise<void> {