@fluidframework/datastore 1.4.0-121020 → 2.0.0-dev-rc.1.0.0.224419

package/src/remoteChannelContext.ts

@@ -3,313 +3,250 @@
  * Licensed under the MIT License.
  */
 
-import { ITelemetryLogger } from "@fluidframework/common-definitions";
-import { assert } from "@fluidframework/common-utils";
-import { DataCorruptionError } from "@fluidframework/container-utils";
+import { assert, LazyPromise } from "@fluidframework/core-utils";
 import { IFluidHandle } from "@fluidframework/core-interfaces";
-import {
-    IChannel,
-    IChannelAttributes,
-    IFluidDataStoreRuntime,
-    IChannelFactory,
-} from "@fluidframework/datastore-definitions";
+import { IChannel, IFluidDataStoreRuntime } from "@fluidframework/datastore-definitions";
 import { IDocumentStorageService } from "@fluidframework/driver-definitions";
-import { readAndParse } from "@fluidframework/driver-utils";
-import {
-    ISequencedDocumentMessage,
-    ISnapshotTree,
-} from "@fluidframework/protocol-definitions";
+import { ISequencedDocumentMessage, ISnapshotTree } from "@fluidframework/protocol-definitions";
 import {
-    CreateChildSummarizerNodeFn,
-    IFluidDataStoreContext,
-    IGarbageCollectionData,
-    IGarbageCollectionDetailsBase,
-    ISummarizeInternalResult,
-    ISummarizeResult,
-    ISummarizerNodeWithGC,
-    ITelemetryContext,
+	CreateChildSummarizerNodeFn,
+	IFluidDataStoreContext,
+	IGarbageCollectionData,
+	IExperimentalIncrementalSummaryContext,
+	ISummarizeInternalResult,
+	ISummarizeResult,
+	ISummarizerNodeWithGC,
+	ITelemetryContext,
 } from "@fluidframework/runtime-definitions";
-import { ChildLogger, TelemetryDataTag, ThresholdCounter } from "@fluidframework/telemetry-utils";
 import {
-    attributesBlobKey,
-    createServiceEndpoints,
-    IChannelContext,
-    summarizeChannelAsync,
+	createChildLogger,
+	ITelemetryLoggerExt,
+	ThresholdCounter,
+} from "@fluidframework/telemetry-utils";
+import {
+	ChannelServiceEndpoints,
+	createChannelServiceEndpoints,
+	IChannelContext,
+	loadChannel,
+	loadChannelFactoryAndAttributes,
+	summarizeChannelAsync,
 } from "./channelContext";
-import { ChannelDeltaConnection } from "./channelDeltaConnection";
-import { ChannelStorageService } from "./channelStorageService";
 import { ISharedObjectRegistry } from "./dataStoreRuntime";
 
 export class RemoteChannelContext implements IChannelContext {
-    private isLoaded = false;
-    private pending: ISequencedDocumentMessage[] | undefined = [];
-    private channelP: Promise<IChannel> | undefined;
-    private channel: IChannel | undefined;
-    private readonly services: {
-        readonly deltaConnection: ChannelDeltaConnection;
-        readonly objectStorage: ChannelStorageService;
-    };
-    private readonly summarizerNode: ISummarizerNodeWithGC;
-    private readonly subLogger: ITelemetryLogger;
-    private readonly thresholdOpsCounter: ThresholdCounter;
-    private static readonly pendingOpsCountThreshold = 1000;
-
-    constructor(
-        private readonly runtime: IFluidDataStoreRuntime,
-        private readonly dataStoreContext: IFluidDataStoreContext,
-        storageService: IDocumentStorageService,
-        submitFn: (content: any, localOpMetadata: unknown) => void,
-        dirtyFn: (address: string) => void,
-        addedGCOutboundReferenceFn: (srcHandle: IFluidHandle, outboundHandle: IFluidHandle) => void,
-        private readonly id: string,
-        baseSnapshot: ISnapshotTree,
-        private readonly registry: ISharedObjectRegistry,
-        extraBlobs: Map<string, ArrayBufferLike> | undefined,
-        createSummarizerNode: CreateChildSummarizerNodeFn,
-        getBaseGCDetails: () => Promise<IGarbageCollectionDetailsBase>,
-        private readonly attachMessageType?: string,
-    ) {
-        assert(!this.id.includes("/"), 0x310 /* Channel context ID cannot contain slashes */);
-
-        this.subLogger = ChildLogger.create(this.runtime.logger, "RemoteChannelContext");
-
-        this.services = createServiceEndpoints(
-            this.id,
-            this.dataStoreContext.connected,
-            submitFn,
-            () => dirtyFn(this.id),
-            addedGCOutboundReferenceFn,
-            storageService,
-            this.subLogger,
-            baseSnapshot,
-            extraBlobs);
-
-        const thisSummarizeInternal =
-            async (fullTree: boolean, trackState: boolean, telemetryContext?: ITelemetryContext) =>
-            this.summarizeInternal(fullTree, trackState, telemetryContext);
-
-        this.summarizerNode = createSummarizerNode(
-            thisSummarizeInternal,
-            async (fullGC?: boolean) => this.getGCDataInternal(fullGC),
-            async () => getBaseGCDetails(),
-        );
-
-        this.thresholdOpsCounter = new ThresholdCounter(
-            RemoteChannelContext.pendingOpsCountThreshold,
-            this.subLogger,
-        );
-    }
-
-    // eslint-disable-next-line @typescript-eslint/promise-function-async
-    public getChannel(): Promise<IChannel> {
-        if (this.channelP === undefined) {
-            this.channelP = this.loadChannel();
-        }
-
-        return this.channelP;
-    }
-
-    public setConnectionState(connected: boolean, clientId?: string) {
-        // Connection events are ignored if the data store is not yet loaded
-        if (!this.isLoaded) {
-            return;
-        }
-
-        this.services.deltaConnection.setConnectionState(connected);
-    }
-
-    public applyStashedOp(message: ISequencedDocumentMessage): unknown {
-        assert(this.isLoaded, 0x194 /* "Remote channel must be loaded when rebasing op" */);
-        return this.services.deltaConnection.applyStashedOp(message);
-    }
-
-    public processOp(message: ISequencedDocumentMessage, local: boolean, localOpMetadata: unknown): void {
-        this.summarizerNode.invalidate(message.sequenceNumber);
-
-        if (this.isLoaded) {
-            this.services.deltaConnection.process(message, local, localOpMetadata);
-        } else {
-            assert(!local, 0x195 /* "Remote channel must not be local when processing op" */);
-            assert(this.pending !== undefined, 0x23e /* "pending is undefined" */);
-            this.pending.push(message);
-            this.thresholdOpsCounter.sendIfMultiple("StorePendingOps", this.pending.length);
-        }
-    }
-
-    public reSubmit(content: any, localOpMetadata: unknown) {
-        assert(this.isLoaded, 0x196 /* "Remote channel must be loaded when resubmitting op" */);
-
-        this.services.deltaConnection.reSubmit(content, localOpMetadata);
-    }
-
-    public rollback(content: any, localOpMetadata: unknown) {
-        assert(this.isLoaded, 0x2f0 /* "Remote channel must be loaded when rolling back op" */);
-
-        this.services.deltaConnection.rollback(content, localOpMetadata);
-    }
-
-    /**
-     * Returns a summary at the current sequence number.
-     * @param fullTree - true to bypass optimizations and force a full summary tree
-     * @param trackState - This tells whether we should track state from this summary.
-     * @param telemetryContext - summary data passed through the layers for telemetry purposes
-     */
-    public async summarize(
-        fullTree: boolean = false,
-        trackState: boolean = true,
-        telemetryContext?: ITelemetryContext,
-    ): Promise<ISummarizeResult> {
-        return this.summarizerNode.summarize(fullTree, trackState, telemetryContext);
-    }
-
-    private async summarizeInternal(
-        fullTree: boolean,
-        trackState: boolean,
-        telemetryContext?: ITelemetryContext,
-    ): Promise<ISummarizeInternalResult> {
-        const channel = await this.getChannel();
-        const summarizeResult = await summarizeChannelAsync(channel, fullTree, trackState, telemetryContext);
-        return { ...summarizeResult, id: this.id };
-    }
-
-    private async loadChannel(): Promise<IChannel> {
-        assert(!this.isLoaded, 0x197 /* "Remote channel must not already be loaded when loading" */);
-
-        let attributes: IChannelAttributes | undefined;
-        if (await this.services.objectStorage.contains(attributesBlobKey)) {
-            attributes = await readAndParse<IChannelAttributes | undefined>(
-                this.services.objectStorage,
-                attributesBlobKey);
-        }
-
-        let factory: IChannelFactory | undefined;
-        // this is a backward compatibility case where
-        // the attach message doesn't include
-        // the attributes. Since old attach messages
-        // will not have attributes we need to keep
-        // this as long as we support old attach messages
-        if (attributes === undefined) {
-            if (this.attachMessageType === undefined) {
-                // TODO: dataStoreId may require a different tag from PackageData #7488
-                throw new DataCorruptionError("channelTypeNotAvailable", {
-                    channelId: {
-                        value: this.id,
-                        tag: TelemetryDataTag.PackageData,
-                    },
-                    dataStoreId: {
-                        value: this.dataStoreContext.id,
-                        tag: TelemetryDataTag.PackageData,
-                    },
-                    dataStorePackagePath: this.dataStoreContext.packagePath.join("/"),
-                });
-            }
-            factory = this.registry.get(this.attachMessageType);
-            if (factory === undefined) {
-                // TODO: dataStoreId may require a different tag from PackageData #7488
-                throw new DataCorruptionError("channelFactoryNotRegisteredForAttachMessageType", {
-                    channelId: {
-                        value: this.id,
-                        tag: TelemetryDataTag.PackageData,
-                    },
-                    dataStoreId: {
-                        value: this.dataStoreContext.id,
-                        tag: TelemetryDataTag.PackageData,
-                    },
-                    dataStorePackagePath: this.dataStoreContext.packagePath.join("/"),
-                    channelFactoryType: this.attachMessageType,
-                });
-            }
-            attributes = factory.attributes;
-        } else {
-            factory = this.registry.get(attributes.type);
-            if (factory === undefined) {
-                // TODO: dataStoreId may require a different tag from PackageData #7488
-                throw new DataCorruptionError("channelFactoryNotRegisteredForGivenType", {
-                    channelId: {
-                        value: this.id,
-                        tag: TelemetryDataTag.PackageData,
-                    },
-                    dataStoreId: {
-                        value: this.dataStoreContext.id,
-                        tag: TelemetryDataTag.PackageData,
-                    },
-                    dataStorePackagePath: this.dataStoreContext.packagePath.join("/"),
-                    channelFactoryType: attributes.type,
-                });
-            }
-        }
-
-        // Compare snapshot version to collaborative object version
-        if (attributes.snapshotFormatVersion !== undefined
-            && attributes.snapshotFormatVersion !== factory.attributes.snapshotFormatVersion) {
-                this.subLogger.sendTelemetryEvent(
-                    {
-                        eventName: "ChannelAttributesVersionMismatch",
-                        channelType: { value: attributes.type, tag: TelemetryDataTag.PackageData },
-                        channelSnapshotVersion: {
-                            value: `${attributes.snapshotFormatVersion}@${attributes.packageVersion}`,
-                            tag: TelemetryDataTag.PackageData,
-                        },
-                        channelCodeVersion: {
-                            value: `${factory.attributes.snapshotFormatVersion}@${factory.attributes.packageVersion}`,
-                            tag: TelemetryDataTag.PackageData,
-                        },
-                    },
-                );
-        }
-
-        const channel = await factory.load(
-            this.runtime,
-            this.id,
-            this.services,
-            attributes);
-
-        // Send all pending messages to the channel
-        assert(this.pending !== undefined, 0x23f /* "pending undefined" */);
-        for (const message of this.pending) {
-            this.services.deltaConnection.process(message, false, undefined /* localOpMetadata */);
-        }
-        this.thresholdOpsCounter.send("ProcessPendingOps", this.pending.length);
-
-        // Commit changes.
-        this.channel = channel;
-        this.pending = undefined;
-        this.isLoaded = true;
-
-        // Because have some await between we created the service and here, the connection state might have changed
-        // and we don't propagate the connection state when we are not loaded.  So we have to set it again here.
-        this.services.deltaConnection.setConnectionState(this.dataStoreContext.connected);
-        return this.channel;
-    }
-
-    /**
-     * Returns the data used for garbage collection. This includes a list of GC nodes that represent this context.
-     * Each node has a set of outbound routes to other GC nodes in the document.
-     * If there is no new data in this context since the last summary, previous GC data is used.
-     * If there is new data, the GC data is generated again (by calling getGCDataInternal).
-     * @param fullGC - true to bypass optimizations and force full generation of GC data.
-     */
-    public async getGCData(fullGC: boolean = false): Promise<IGarbageCollectionData> {
-        return this.summarizerNode.getGCData(fullGC);
-    }
-
-    /**
-     * Generates the data used for garbage collection. This is called when there is new data since last summary. It
-     * loads the context and calls into the channel to get its GC data.
-     * @param fullGC - true to bypass optimizations and force full generation of GC data.
-     */
-    private async getGCDataInternal(fullGC: boolean = false): Promise<IGarbageCollectionData> {
-        const channel = await this.getChannel();
-        return channel.getGCData(fullGC);
-    }
-
-    public updateUsedRoutes(usedRoutes: string[], gcTimestamp?: number) {
-        /**
-         * Currently, DDSes are always considered referenced and are not garbage collected. Update the summarizer node's
-         * used routes to contain a route to this channel context.
-         * Once we have GC at DDS level, this will be updated to use the passed usedRoutes. See -
-         * https://github.com/microsoft/FluidFramework/issues/4611
-         */
-        this.summarizerNode.updateUsedRoutes([""]);
-    }
+	private isLoaded = false;
+	private pending: ISequencedDocumentMessage[] | undefined = [];
+	private readonly channelP: Promise<IChannel>;
+	private channel: IChannel | undefined;
+	private readonly services: ChannelServiceEndpoints;
+	private readonly summarizerNode: ISummarizerNodeWithGC;
+	private readonly subLogger: ITelemetryLoggerExt;
+	private readonly thresholdOpsCounter: ThresholdCounter;
+	private static readonly pendingOpsCountThreshold = 1000;
+
+	constructor(
+		runtime: IFluidDataStoreRuntime,
+		dataStoreContext: IFluidDataStoreContext,
+		storageService: IDocumentStorageService,
+		submitFn: (content: any, localOpMetadata: unknown) => void,
+		dirtyFn: (address: string) => void,
+		addedGCOutboundReferenceFn: (srcHandle: IFluidHandle, outboundHandle: IFluidHandle) => void,
+		private readonly id: string,
+		baseSnapshot: ISnapshotTree,
+		registry: ISharedObjectRegistry,
+		extraBlobs: Map<string, ArrayBufferLike> | undefined,
+		createSummarizerNode: CreateChildSummarizerNodeFn,
+		attachMessageType?: string,
+	) {
+		assert(!this.id.includes("/"), 0x310 /* Channel context ID cannot contain slashes */);
+
+		this.subLogger = createChildLogger({
+			logger: runtime.logger,
+			namespace: "RemoteChannelContext",
+		});
+
+		this.services = createChannelServiceEndpoints(
+			dataStoreContext.connected,
+			submitFn,
+			() => dirtyFn(this.id),
+			addedGCOutboundReferenceFn,
+			storageService,
+			this.subLogger,
+			baseSnapshot,
+			extraBlobs,
+		);
+
+		this.channelP = new LazyPromise<IChannel>(async () => {
+			const { attributes, factory } = await loadChannelFactoryAndAttributes(
+				dataStoreContext,
+				this.services,
+				this.id,
+				registry,
+				attachMessageType,
+			);
+
+			const channel = await loadChannel(
+				runtime,
+				attributes,
+				factory,
+				this.services,
+				this.subLogger,
+				this.id,
+			);
+
+			// Send all pending messages to the channel
+			assert(this.pending !== undefined, 0x23f /* "pending undefined" */);
+			for (const message of this.pending) {
+				this.services.deltaConnection.process(
+					message,
+					false,
+					undefined /* localOpMetadata */,
+				);
+			}
+			this.thresholdOpsCounter.send("ProcessPendingOps", this.pending.length);
+
+			// Commit changes.
+			this.channel = channel;
+			this.pending = undefined;
+			this.isLoaded = true;
+
+			// Because have some await between we created the service and here, the connection state might have changed
+			// and we don't propagate the connection state when we are not loaded.  So we have to set it again here.
+			this.services.deltaConnection.setConnectionState(dataStoreContext.connected);
+			return this.channel;
+		});
+
+		const thisSummarizeInternal = async (
+			fullTree: boolean,
+			trackState: boolean,
+			telemetryContext?: ITelemetryContext,
+			incrementalSummaryContext?: IExperimentalIncrementalSummaryContext,
+		) =>
+			this.summarizeInternal(
+				fullTree,
+				trackState,
+				telemetryContext,
+				incrementalSummaryContext,
+			);
+
+		this.summarizerNode = createSummarizerNode(
+			thisSummarizeInternal,
+			async (fullGC?: boolean) => this.getGCDataInternal(fullGC),
+		);
+
+		this.thresholdOpsCounter = new ThresholdCounter(
+			RemoteChannelContext.pendingOpsCountThreshold,
+			this.subLogger,
+		);
+	}
+
+	// eslint-disable-next-line @typescript-eslint/promise-function-async
+	public getChannel(): Promise<IChannel> {
+		return this.channelP;
+	}
+
+	public setConnectionState(connected: boolean, clientId?: string) {
+		// Connection events are ignored if the data store is not yet loaded
+		if (!this.isLoaded) {
+			return;
+		}
+
+		this.services.deltaConnection.setConnectionState(connected);
+	}
+
+	public applyStashedOp(content: any): unknown {
+		assert(this.isLoaded, 0x194 /* "Remote channel must be loaded when rebasing op" */);
+		return this.services.deltaConnection.applyStashedOp(content);
+	}
+
+	public processOp(
+		message: ISequencedDocumentMessage,
+		local: boolean,
+		localOpMetadata: unknown,
+	): void {
+		this.summarizerNode.invalidate(message.sequenceNumber);
+
+		if (this.isLoaded) {
+			this.services.deltaConnection.process(message, local, localOpMetadata);
+		} else {
+			assert(!local, 0x195 /* "Remote channel must not be local when processing op" */);
+			assert(this.pending !== undefined, 0x23e /* "pending is undefined" */);
+			this.pending.push(message);
+			this.thresholdOpsCounter.sendIfMultiple("StorePendingOps", this.pending.length);
+		}
+	}
+
+	public reSubmit(content: any, localOpMetadata: unknown) {
+		assert(this.isLoaded, 0x196 /* "Remote channel must be loaded when resubmitting op" */);
+
+		this.services.deltaConnection.reSubmit(content, localOpMetadata);
+	}
+
+	public rollback(content: any, localOpMetadata: unknown) {
+		assert(this.isLoaded, 0x2f0 /* "Remote channel must be loaded when rolling back op" */);
+
+		this.services.deltaConnection.rollback(content, localOpMetadata);
+	}
+
+	/**
+	 * Returns a summary at the current sequence number.
+	 * @param fullTree - true to bypass optimizations and force a full summary tree
+	 * @param trackState - This tells whether we should track state from this summary.
+	 * @param telemetryContext - summary data passed through the layers for telemetry purposes
+	 */
+	public async summarize(
+		fullTree: boolean = false,
+		trackState: boolean = true,
+		telemetryContext?: ITelemetryContext,
+	): Promise<ISummarizeResult> {
+		return this.summarizerNode.summarize(fullTree, trackState, telemetryContext);
+	}
+
+	private async summarizeInternal(
+		fullTree: boolean,
+		trackState: boolean,
+		telemetryContext?: ITelemetryContext,
+		incrementalSummaryContext?: IExperimentalIncrementalSummaryContext,
+	): Promise<ISummarizeInternalResult> {
+		const channel = await this.getChannel();
+		const summarizeResult = await summarizeChannelAsync(
+			channel,
+			fullTree,
+			trackState,
+			telemetryContext,
+			incrementalSummaryContext,
+		);
+		return { ...summarizeResult, id: this.id };
+	}
+
+	/**
+	 * Returns the data used for garbage collection. This includes a list of GC nodes that represent this context.
+	 * Each node has a set of outbound routes to other GC nodes in the document.
+	 * If there is no new data in this context since the last summary, previous GC data is used.
+	 * If there is new data, the GC data is generated again (by calling getGCDataInternal).
+	 * @param fullGC - true to bypass optimizations and force full generation of GC data.
+	 */
+	public async getGCData(fullGC: boolean = false): Promise<IGarbageCollectionData> {
+		return this.summarizerNode.getGCData(fullGC);
+	}
+
+	/**
+	 * Generates the data used for garbage collection. This is called when there is new data since last summary. It
+	 * loads the context and calls into the channel to get its GC data.
+	 * @param fullGC - true to bypass optimizations and force full generation of GC data.
+	 */
+	private async getGCDataInternal(fullGC: boolean = false): Promise<IGarbageCollectionData> {
+		const channel = await this.getChannel();
+		return channel.getGCData(fullGC);
+	}
+
+	public updateUsedRoutes(usedRoutes: string[]) {
+		/**
+		 * Currently, DDSes are always considered referenced and are not garbage collected. Update the summarizer node's
+		 * used routes to contain a route to this channel context.
+		 * Once we have GC at DDS level, this will be updated to use the passed usedRoutes. See -
+		 * https://github.com/microsoft/FluidFramework/issues/4611
+		 */
+		this.summarizerNode.updateUsedRoutes([""]);
+	}
 }

package/tsc-multi.test.json

@@ -0,0 +1,4 @@
+{
+	"targets": [{ "extname": ".cjs", "module": "CommonJS", "moduleResolution": "Node16" }],
+	"projects": ["./tsconfig.json", "./src/test/tsconfig.json"]
+}

package/tsconfig.json

@@ -1,14 +1,12 @@
 {
-    "extends": "@fluidframework/build-common/ts-common-config.json",
-    "compilerOptions": {
-        "composite": true,
-        "rootDir": "./src",
-        "outDir": "./dist"
-    },
-    "include": [
-        "src/**/*"
-    ],
-    "exclude": [
-        "src/test/**/*"
-    ]
-}
+	"extends": [
+		"../../../common/build/build-common/tsconfig.base.json",
+		"../../../common/build/build-common/tsconfig.cjs.json",
+	],
+	"include": ["src/**/*"],
+	"exclude": ["src/test/**/*"],
+	"compilerOptions": {
+		"rootDir": "./src",
+		"outDir": "./dist",
+	},
+}

package/dist/channelContext.js

@@ -1,35 +0,0 @@
-"use strict";
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.summarizeChannelAsync = exports.summarizeChannel = exports.createServiceEndpoints = exports.attributesBlobKey = void 0;
-const runtime_utils_1 = require("@fluidframework/runtime-utils");
-const channelDeltaConnection_1 = require("./channelDeltaConnection");
-const channelStorageService_1 = require("./channelStorageService");
-exports.attributesBlobKey = ".attributes";
-function createServiceEndpoints(id, connected, submitFn, dirtyFn, addedGCOutboundReferenceFn, storageService, logger, tree, extraBlobs) {
-    const deltaConnection = new channelDeltaConnection_1.ChannelDeltaConnection(id, connected, (message, localOpMetadata) => submitFn(message, localOpMetadata), dirtyFn, addedGCOutboundReferenceFn);
-    const objectStorage = new channelStorageService_1.ChannelStorageService(tree, storageService, logger, extraBlobs);
-    return {
-        deltaConnection,
-        objectStorage,
-    };
-}
-exports.createServiceEndpoints = createServiceEndpoints;
-function summarizeChannel(channel, fullTree = false, trackState = false, telemetryContext) {
-    const summarizeResult = channel.getAttachSummary(fullTree, trackState, telemetryContext);
-    // Add the channel attributes to the returned result.
-    (0, runtime_utils_1.addBlobToSummary)(summarizeResult, exports.attributesBlobKey, JSON.stringify(channel.attributes));
-    return summarizeResult;
-}
-exports.summarizeChannel = summarizeChannel;
-async function summarizeChannelAsync(channel, fullTree = false, trackState = false, telemetryContext) {
-    const summarizeResult = await channel.summarize(fullTree, trackState, telemetryContext);
-    // Add the channel attributes to the returned result.
-    (0, runtime_utils_1.addBlobToSummary)(summarizeResult, exports.attributesBlobKey, JSON.stringify(channel.attributes));
-    return summarizeResult;
-}
-exports.summarizeChannelAsync = summarizeChannelAsync;
-//# sourceMappingURL=channelContext.js.map

package/dist/channelContext.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"channelContext.js","sourceRoot":"","sources":["../src/channelContext.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAaH,iEAAiE;AACjE,qEAAkE;AAClE,mEAAgE;AAEnD,QAAA,iBAAiB,GAAG,aAAa,CAAC;AAsC/C,SAAgB,sBAAsB,CAClC,EAAU,EACV,SAAkB,EAClB,QAA0D,EAC1D,OAAmB,EACnB,0BAA2F,EAC3F,cAAuC,EACvC,MAAwB,EACxB,IAAoB,EACpB,UAAyC;IAEzC,MAAM,eAAe,GAAG,IAAI,+CAAsB,CAC9C,EAAE,EACF,SAAS,EACT,CAAC,OAAO,EAAE,eAAe,EAAE,EAAE,CAAC,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC,EAChE,OAAO,EACP,0BAA0B,CAAC,CAAC;IAChC,MAAM,aAAa,GAAG,IAAI,6CAAqB,CAAC,IAAI,EAAE,cAAc,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC;IAE1F,OAAO;QACH,eAAe;QACf,aAAa;KAChB,CAAC;AACN,CAAC;AAvBD,wDAuBC;AAED,SAAgB,gBAAgB,CAC5B,OAAiB,EACjB,WAAoB,KAAK,EACzB,aAAsB,KAAK,EAC3B,gBAAoC;IAEpC,MAAM,eAAe,GAAG,OAAO,CAAC,gBAAgB,CAAC,QAAQ,EAAE,UAAU,EAAE,gBAAgB,CAAC,CAAC;IAEzF,qDAAqD;IACrD,IAAA,gCAAgB,EAAC,eAAe,EAAE,yBAAiB,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC;IACzF,OAAO,eAAe,CAAC;AAC3B,CAAC;AAXD,4CAWC;AAEM,KAAK,UAAU,qBAAqB,CACvC,OAAiB,EACjB,WAAoB,KAAK,EACzB,aAAsB,KAAK,EAC3B,gBAAoC;IAEpC,MAAM,eAAe,GAAG,MAAM,OAAO,CAAC,SAAS,CAAC,QAAQ,EAAE,UAAU,EAAE,gBAAgB,CAAC,CAAC;IAExF,qDAAqD;IACrD,IAAA,gCAAgB,EAAC,eAAe,EAAE,yBAAiB,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC;IACzF,OAAO,eAAe,CAAC;AAC3B,CAAC;AAXD,sDAWC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { ITelemetryLogger } from \"@fluidframework/common-definitions\";\nimport { IFluidHandle } from \"@fluidframework/core-interfaces\";\nimport { IChannel } from \"@fluidframework/datastore-definitions\";\nimport { IDocumentStorageService } from \"@fluidframework/driver-definitions\";\nimport { ISequencedDocumentMessage, ISnapshotTree } from \"@fluidframework/protocol-definitions\";\nimport {\n    IGarbageCollectionData,\n    ISummarizeResult,\n    ISummaryTreeWithStats,\n    ITelemetryContext,\n} from \"@fluidframework/runtime-definitions\";\nimport { addBlobToSummary } from \"@fluidframework/runtime-utils\";\nimport { ChannelDeltaConnection } from \"./channelDeltaConnection\";\nimport { ChannelStorageService } from \"./channelStorageService\";\n\nexport const attributesBlobKey = \".attributes\";\n\nexport interface IChannelContext {\n    getChannel(): Promise<IChannel>;\n\n    setConnectionState(connected: boolean, clientId?: string);\n\n    processOp(message: ISequencedDocumentMessage, local: boolean, localOpMetadata?: unknown): void;\n\n    summarize(\n        fullTree?: boolean,\n        trackState?: boolean,\n        telemetryContext?: ITelemetryContext,\n    ): Promise<ISummarizeResult>;\n\n    reSubmit(content: any, localOpMetadata: unknown): void;\n\n    applyStashedOp(content: any): unknown;\n\n    rollback(message: any, localOpMetadata: unknown): void;\n\n    /**\n     * Returns the data used for garbage collection. This includes a list of GC nodes that represent this context\n     * including any of its children. Each node has a set of outbound routes to other GC nodes in the document.\n     * @param fullGC - true to bypass optimizations and force full generation of GC data.\n     */\n    getGCData(fullGC?: boolean): Promise<IGarbageCollectionData>;\n\n    /**\n     * After GC has run, called to notify this context of routes that are used in it. These are used for the following:\n     * 1. To identify if this context is being referenced in the document or not.\n     * 2. To identify if this context or any of its children's used routes changed since last summary.\n     * 3. They are added to the summary generated by this context.\n     * 4. To update the timestamp when this context is marked as unreferenced.\n     */\n    updateUsedRoutes(usedRoutes: string[], gcTimestamp?: number): void;\n}\n\nexport function createServiceEndpoints(\n    id: string,\n    connected: boolean,\n    submitFn: (content: any, localOpMetadata: unknown) => void,\n    dirtyFn: () => void,\n    addedGCOutboundReferenceFn: (srcHandle: IFluidHandle, outboundHandle: IFluidHandle) => void,\n    storageService: IDocumentStorageService,\n    logger: ITelemetryLogger,\n    tree?: ISnapshotTree,\n    extraBlobs?: Map<string, ArrayBufferLike>,\n) {\n    const deltaConnection = new ChannelDeltaConnection(\n        id,\n        connected,\n        (message, localOpMetadata) => submitFn(message, localOpMetadata),\n        dirtyFn,\n        addedGCOutboundReferenceFn);\n    const objectStorage = new ChannelStorageService(tree, storageService, logger, extraBlobs);\n\n    return {\n        deltaConnection,\n        objectStorage,\n    };\n}\n\nexport function summarizeChannel(\n    channel: IChannel,\n    fullTree: boolean = false,\n    trackState: boolean = false,\n    telemetryContext?: ITelemetryContext,\n): ISummaryTreeWithStats {\n    const summarizeResult = channel.getAttachSummary(fullTree, trackState, telemetryContext);\n\n    // Add the channel attributes to the returned result.\n    addBlobToSummary(summarizeResult, attributesBlobKey, JSON.stringify(channel.attributes));\n    return summarizeResult;\n}\n\nexport async function summarizeChannelAsync(\n    channel: IChannel,\n    fullTree: boolean = false,\n    trackState: boolean = false,\n    telemetryContext?: ITelemetryContext,\n): Promise<ISummaryTreeWithStats> {\n    const summarizeResult = await channel.summarize(fullTree, trackState, telemetryContext);\n\n    // Add the channel attributes to the returned result.\n    addBlobToSummary(summarizeResult, attributesBlobKey, JSON.stringify(channel.attributes));\n    return summarizeResult;\n}\n"]}