@fluidframework/odsp-driver 1.1.0 → 1.2.0-77818

package/src/localOdspDriver/localOdspDocumentServiceFactory.ts

@@ -0,0 +1,67 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { IDocumentService, IResolvedUrl } from "@fluidframework/driver-definitions";
+import { UsageError } from "@fluidframework/driver-utils";
+import { TelemetryLogger } from "@fluidframework/telemetry-utils";
+import { ISummaryTree } from "@fluidframework/protocol-definitions";
+import { ITelemetryBaseLogger } from "@fluidframework/common-definitions";
+import { createOdspLogger, getOdspResolvedUrl } from "../odspUtils";
+import { ICacheAndTracker } from "../epochTracker";
+import { OdspDocumentServiceFactoryCore } from "../odspDocumentServiceFactoryCore";
+import { LocalOdspDocumentService } from "./localOdspDocumentService";
+
+/**
+ * Factory for creating sharepoint document service with a provided snapshot.
+ * Use if you don't want to connect to any kind of external/internal storages and want to provide
+ * content directly.
+ */
+export class LocalOdspDocumentServiceFactory extends OdspDocumentServiceFactoryCore {
+    private logger: TelemetryLogger | undefined;
+
+    constructor(
+        private readonly localSnapshot: Uint8Array | string,
+    ) {
+        super(
+            (_options) => this.throwUnsupportedUsageError("Getting storage token"),
+            (_options) => this.throwUnsupportedUsageError("Getting websocket token"),
+            () => this.throwUnsupportedUsageError("Getting SocketIO Client"),
+        );
+    }
+
+    private throwUnsupportedUsageError(unsupportedFuncName: string): never {
+        const toThrow = new UsageError(
+            `${unsupportedFuncName} is not supported by LocalOdspDocumentServiceFactory`);
+        this.logger?.sendErrorEvent({ eventName: "UnsupportedUsage" }, toThrow);
+        throw toThrow;
+    }
+
+    public createContainer(
+        _createNewSummary: ISummaryTree | undefined,
+        _createNewResolvedUrl: IResolvedUrl,
+        logger?: ITelemetryBaseLogger,
+        _clientIsSummarizer?: boolean,
+    ): never {
+        const toThrow = new UsageError("\"createContainer\" is not supported by LocalOdspDocumentServiceFactory");
+        createOdspLogger(logger).sendErrorEvent({ eventName: "UnsupportedUsage" }, toThrow);
+        throw toThrow;
+    }
+
+    protected async createDocumentServiceCore(
+        resolvedUrl: IResolvedUrl,
+        odspLogger: TelemetryLogger,
+        _cacheAndTrackerArg?: ICacheAndTracker,
+        _clientIsSummarizer?: boolean,
+    ): Promise<IDocumentService> {
+        if (_cacheAndTrackerArg !== undefined) {
+            throw new UsageError("Invalid usage. \"_cacheAndTrackerArg\" should not be provided");
+        }
+        if (_clientIsSummarizer) {
+            throw new UsageError("Invalid usage. \"_clientIsSummarizer\" should not be provided");
+        }
+        this.logger = odspLogger;
+        return new LocalOdspDocumentService(getOdspResolvedUrl(resolvedUrl), odspLogger, this.localSnapshot);
+    }
+}

package/src/localOdspDriver/localOdspDocumentStorageManager.ts

@@ -0,0 +1,83 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { assert } from "@fluidframework/common-utils";
+import { ITelemetryLogger } from "@fluidframework/common-definitions";
+import { ISummaryContext } from "@fluidframework/driver-definitions";
+import { UsageError } from "@fluidframework/driver-utils";
+import * as api from "@fluidframework/protocol-definitions";
+import { OdspDocumentStorageServiceBase } from "../odspDocumentStorageServiceBase";
+import { ISnapshotContents } from "../odspPublicUtils";
+import { IOdspSnapshot } from "../contracts";
+import { convertOdspSnapshotToSnapshotTreeAndBlobs } from "../odspSnapshotParser";
+import { parseCompactSnapshotResponse } from "../compactSnapshotParser";
+import { ReadBuffer } from "../ReadBufferUtils";
+
+/**
+ * ODSP document storage service that works on a provided snapshot for all its processing.
+ * Attempting to use unsupported actions/methods will result in errors being thrown.
+ */
+export class LocalOdspDocumentStorageService extends OdspDocumentStorageServiceBase {
+    private snapshotTreeId: string | undefined;
+
+    constructor(
+        private readonly logger: ITelemetryLogger,
+        private readonly localSnapshot: Uint8Array | string,
+    ) {
+        super();
+    }
+
+    private calledGetVersions = false;
+
+    public async getVersions(blobid: string | null, count: number, _scenarioName?: string): Promise<api.IVersion[]> {
+        assert(blobid === null, "Invalid usage. \"blobid\" should always be null");
+        assert(count === 1, "Invalid usage. \"count\" should always be 1");
+
+        // No reason to re-parse the data since it will never change
+        if (this.calledGetVersions) {
+            return this.getSnapshotVersion();
+        }
+        this.calledGetVersions = true;
+
+        let snapshotContents: ISnapshotContents;
+
+        if (typeof this.localSnapshot === "string") {
+            const content: IOdspSnapshot = JSON.parse(this.localSnapshot);
+            snapshotContents = convertOdspSnapshotToSnapshotTreeAndBlobs(content);
+        } else {
+            snapshotContents = parseCompactSnapshotResponse(
+                new ReadBuffer(this.localSnapshot));
+        }
+
+        this.snapshotTreeId = this.initializeFromSnapshot(snapshotContents);
+        return this.getSnapshotVersion();
+    }
+
+    private getSnapshotVersion(): api.IVersion[] {
+        return this.snapshotTreeId ? [{ id: this.snapshotTreeId, treeId: undefined! }] : [];
+    }
+
+    protected fetchTreeFromSnapshot(_id: string, _scenarioName?: string): never {
+        this.throwUsageError("fetchTreeFromSnapshot");
+    }
+
+    protected fetchBlobFromStorage(_blobId: string, _evicted: boolean): never {
+        this.throwUsageError("fetchBlobFromStorage");
+    }
+
+    public uploadSummaryWithContext(_summary: api.ISummaryTree, _context: ISummaryContext): never {
+        this.throwUsageError("uploadSummaryWithContext");
+    }
+
+    public createBlob(_file: ArrayBufferLike): never {
+        this.throwUsageError("createBlob");
+    }
+
+    private throwUsageError(methodName: string): never {
+        const toThrow = new UsageError(`"${methodName}" is not supported by LocalOdspDocumentStorageService`);
+        this.logger.sendErrorEvent({ eventName: "UnsupportedUsage" }, toThrow);
+        throw toThrow;
+    }
+}

package/src/odspDeltaStorageService.ts

@@ -236,5 +236,5 @@ export class OdspDeltaStorageWithCache implements IDocumentDeltaStorageService {
                 });
             }
         });
-}
+    }
 }

package/src/odspDocumentService.ts

@@ -21,7 +21,11 @@ import {
     IDocumentServicePolicies,
     DriverErrorType,
 } from "@fluidframework/driver-definitions";
-import { canRetryOnError, DeltaStreamConnectionForbiddenError, NonRetryableError } from "@fluidframework/driver-utils";
+import {
+    canRetryOnError,
+    DeltaStreamConnectionForbiddenError,
+    NonRetryableError,
+} from "@fluidframework/driver-utils";
 import { IFacetCodes } from "@fluidframework/odsp-doclib-utils";
 import {
     IClient,

package/src/odspDocumentServiceFactory.ts

@@ -12,14 +12,14 @@ import {
 } from "@fluidframework/odsp-driver-definitions";
 import { OdspDocumentServiceFactoryCore } from "./odspDocumentServiceFactoryCore";
 import { getSocketIo } from "./getSocketIo";
+// eslint-disable-next-line import/no-internal-modules
+import { LocalOdspDocumentServiceFactory } from "./localOdspDriver/localOdspDocumentServiceFactory";
 
 /**
  * Factory for creating the sharepoint document service. Use this if you want to
  * use the sharepoint implementation.
  */
-export class OdspDocumentServiceFactory
-    extends OdspDocumentServiceFactoryCore
-    implements IDocumentServiceFactory {
+export class OdspDocumentServiceFactory extends OdspDocumentServiceFactoryCore {
     constructor(
         getStorageToken: TokenFetcher<OdspResourceTokenFetchOptions>,
         getWebsocketToken: TokenFetcher<OdspResourceTokenFetchOptions> | undefined,
@@ -35,3 +35,7 @@ export class OdspDocumentServiceFactory
         );
     }
 }
+
+export function createLocalOdspDocumentServiceFactory(localSnapshot: Uint8Array | string): IDocumentServiceFactory {
+    return new LocalOdspDocumentServiceFactory(localSnapshot);
+}

package/src/odspDocumentServiceFactoryCore.ts

@@ -174,7 +174,7 @@ export class OdspDocumentServiceFactoryCore implements IDocumentServiceFactory {
         return this.createDocumentServiceCore(resolvedUrl, createOdspLogger(logger), undefined, clientIsSummarizer);
     }
 
-    private async createDocumentServiceCore(
+    protected async createDocumentServiceCore(
         resolvedUrl: IResolvedUrl,
         odspLogger: TelemetryLogger,
         cacheAndTrackerArg?: ICacheAndTracker,