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

package/lib/{dataStores.js → dataStores.mjs}

@@ -2,35 +2,35 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { DataCorruptionError, extractSafePropertiesFromMessage } from "@fluidframework/container-utils";
 import { FluidObjectHandle } from "@fluidframework/datastore";
 import { channelsTreeName, CreateSummarizerNodeSource, } from "@fluidframework/runtime-definitions";
-import { convertSnapshotTreeToSummaryTree, convertToSummaryTree, create404Response, responseToException, SummaryTreeBuilder, } from "@fluidframework/runtime-utils";
-import { ChildLogger, LoggingError, TelemetryDataTag } from "@fluidframework/telemetry-utils";
+import { convertSnapshotTreeToSummaryTree, convertToSummaryTree, create404Response, createResponseError, GCDataBuilder, responseToException, SummaryTreeBuilder, unpackChildNodesUsedRoutes, } from "@fluidframework/runtime-utils";
+import { createChildMonitoringContext, DataCorruptionError, DataProcessingError, extractSafePropertiesFromMessage, LoggingError, tagCodeArtifacts, } from "@fluidframework/telemetry-utils";
 import { AttachState } from "@fluidframework/container-definitions";
-import { BlobCacheStorageService, buildSnapshotTree } from "@fluidframework/driver-utils";
-import { assert, Lazy, LazyPromise } from "@fluidframework/common-utils";
+import { buildSnapshotTree } from "@fluidframework/driver-utils";
+import { assert, Lazy } from "@fluidframework/core-utils";
 import { v4 as uuid } from "uuid";
-import { GCDataBuilder, unpackChildNodesUsedRoutes } from "@fluidframework/garbage-collector";
-import { DataStoreContexts } from "./dataStoreContexts";
-import { RemoteFluidDataStoreContext, LocalFluidDataStoreContext, createAttributesBlob, LocalDetachedFluidDataStoreContext, } from "./dataStoreContext";
-import { nonDataStorePaths, rootHasIsolatedChannels } from "./summaryFormat";
-import { isDataStoreAliasMessage } from "./dataStore";
-import { GCNodeType } from "./garbageCollection";
+import { DataStoreContexts } from "./dataStoreContexts.mjs";
+import { defaultRuntimeHeaderData } from "./containerRuntime.mjs";
+import { RemoteFluidDataStoreContext, LocalFluidDataStoreContext, createAttributesBlob, LocalDetachedFluidDataStoreContext, } from "./dataStoreContext.mjs";
+import { StorageServiceWithAttachBlobs } from "./storageServiceWithAttachBlobs.mjs";
+import { isDataStoreAliasMessage } from "./dataStore.mjs";
+import { GCNodeType, disableDatastoreSweepKey } from "./gc/index.mjs";
+import { nonDataStorePaths, rootHasIsolatedChannels } from "./summary/index.mjs";
 /**
  * This class encapsulates data store handling. Currently it is only used by the container runtime,
  * but eventually could be hosted on any channel once we formalize the channel api boundary.
  */
 export class DataStores {
-    constructor(baseSnapshot, runtime, submitAttachFn, getCreateChildSummarizerNodeFn, deleteChildSummarizerNodeFn, baseLogger, getBaseGCDetails, gcNodeUpdated, aliasMap, writeGCDataAtRoot, contexts = new DataStoreContexts(baseLogger)) {
+    constructor(baseSnapshot, runtime, submitAttachFn, getCreateChildSummarizerNodeFn, deleteChildSummarizerNodeFn, baseLogger, gcNodeUpdated, isDataStoreDeleted, aliasMap, contexts = new DataStoreContexts(baseLogger)) {
         this.baseSnapshot = baseSnapshot;
         this.runtime = runtime;
         this.submitAttachFn = submitAttachFn;
         this.getCreateChildSummarizerNodeFn = getCreateChildSummarizerNodeFn;
         this.deleteChildSummarizerNodeFn = deleteChildSummarizerNodeFn;
         this.gcNodeUpdated = gcNodeUpdated;
+        this.isDataStoreDeleted = isDataStoreDeleted;
         this.aliasMap = aliasMap;
-        this.writeGCDataAtRoot = writeGCDataAtRoot;
         this.contexts = contexts;
         // Stores tracked by the Domain
         this.pendingAttach = new Map();
@@ -40,17 +40,10 @@ export class DataStores {
         // Stores the ids of new data stores between two GC runs. This is used to notify the garbage collector of new
         // root data stores that are added.
         this.dataStoresSinceLastGC = [];
+        this.pendingAliasMap = new Map();
         this.dispose = () => this.disposeOnce.value;
-        this.logger = ChildLogger.create(baseLogger);
+        this.mc = createChildMonitoringContext({ logger: baseLogger });
         this.containerRuntimeHandle = new FluidObjectHandle(this.runtime, "/", this.runtime.IFluidHandleContext);
-        const baseGCDetailsP = new LazyPromise(async () => {
-            return getBaseGCDetails();
-        });
-        // Returns the base GC details for the data store with the given id.
-        const dataStoreBaseGCDetails = async (dataStoreId) => {
-            const baseGCDetails = await baseGCDetailsP;
-            return baseGCDetails.get(dataStoreId);
-        };
         // Extract stores stored inside the snapshot
         const fluidDataStores = new Map();
         if (baseSnapshot) {
@@ -71,13 +64,12 @@ export class DataStores {
                 dataStoreContext = new RemoteFluidDataStoreContext({
                     id: key,
                     snapshotTree: value,
-                    getBaseGCDetails: async () => dataStoreBaseGCDetails(key),
                     runtime: this.runtime,
                     storage: this.runtime.storage,
                     scope: this.runtime.scope,
-                    createSummarizerNodeFn: this.getCreateChildSummarizerNodeFn(key, { type: CreateSummarizerNodeSource.FromSummary }),
-                    writeGCDataAtRoot: this.writeGCDataAtRoot,
-                    disableIsolatedChannels: this.runtime.disableIsolatedChannels,
+                    createSummarizerNodeFn: this.getCreateChildSummarizerNodeFn(key, {
+                        type: CreateSummarizerNodeSource.FromSummary,
+                    }),
                 });
             }
             else {
@@ -91,12 +83,12 @@ export class DataStores {
                     runtime: this.runtime,
                     storage: this.runtime.storage,
                     scope: this.runtime.scope,
-                    createSummarizerNodeFn: this.getCreateChildSummarizerNodeFn(key, { type: CreateSummarizerNodeSource.FromSummary }),
+                    createSummarizerNodeFn: this.getCreateChildSummarizerNodeFn(key, {
+                        type: CreateSummarizerNodeSource.FromSummary,
+                    }),
                     makeLocallyVisibleFn: () => this.makeDataStoreLocallyVisible(key),
                     snapshotTree,
                     isRootDataStore: undefined,
-                    writeGCDataAtRoot: this.writeGCDataAtRoot,
-                    disableIsolatedChannels: this.runtime.disableIsolatedChannels,
                 });
             }
             this.contexts.addBoundOrRemoted(dataStoreContext);
@@ -106,17 +98,23 @@ export class DataStores {
             referencedDataStoreCount: fluidDataStores.size - unreferencedDataStoreCount,
         };
     }
-    aliases() {
+    get aliases() {
         return this.aliasMap;
     }
+    get pendingAliases() {
+        return this.pendingAliasMap;
+    }
+    async waitIfPendingAlias(maybeAlias) {
+        const pendingAliasPromise = this.pendingAliases.get(maybeAlias);
+        return pendingAliasPromise ?? "Success";
+    }
     processAttachMessage(message, local) {
-        var _a, _b;
         const attachMessage = message.contents;
         this.dataStoresSinceLastGC.push(attachMessage.id);
         // The local object has already been attached
         if (local) {
             assert(this.pendingAttach.has(attachMessage.id), 0x15e /* "Local object does not have matching attach message id" */);
-            (_a = this.contexts.get(attachMessage.id)) === null || _a === void 0 ? void 0 : _a.emit("attached");
+            this.contexts.get(attachMessage.id)?.emit("attached");
             this.pendingAttach.delete(attachMessage.id);
             return;
         }
@@ -125,16 +123,16 @@ export class DataStores {
             // TODO: dataStoreId may require a different tag from PackageData #7488
             const error = new DataCorruptionError(
             // pre-0.58 error message: duplicateDataStoreCreatedWithExistingId
-            "Duplicate DataStore created with existing id", Object.assign(Object.assign({}, extractSafePropertiesFromMessage(message)), { dataStoreId: {
-                    value: attachMessage.id,
-                    tag: TelemetryDataTag.PackageData,
-                } }));
+            "Duplicate DataStore created with existing id", {
+                ...extractSafePropertiesFromMessage(message),
+                ...tagCodeArtifacts({ dataStoreId: attachMessage.id }),
+            });
             throw error;
         }
-        const flatBlobs = new Map();
+        const flatAttachBlobs = new Map();
         let snapshotTree;
         if (attachMessage.snapshot) {
-            snapshotTree = buildSnapshotTree(attachMessage.snapshot.entries, flatBlobs);
+            snapshotTree = buildSnapshotTree(attachMessage.snapshot.entries, flatAttachBlobs);
         }
         // Include the type of attach message which is the pkg of the store to be
         // used by RemoteFluidDataStoreContext in case it is not in the snapshot.
@@ -142,20 +140,16 @@ export class DataStores {
         const remoteFluidDataStoreContext = new RemoteFluidDataStoreContext({
             id: attachMessage.id,
             snapshotTree,
-            // New data stores begin with empty GC details since GC hasn't run on them yet.
-            getBaseGCDetails: async () => { return {}; },
             runtime: this.runtime,
-            storage: new BlobCacheStorageService(this.runtime.storage, flatBlobs),
+            storage: new StorageServiceWithAttachBlobs(this.runtime.storage, flatAttachBlobs),
             scope: this.runtime.scope,
             createSummarizerNodeFn: this.getCreateChildSummarizerNodeFn(attachMessage.id, {
                 type: CreateSummarizerNodeSource.FromAttach,
                 sequenceNumber: message.sequenceNumber,
-                snapshot: (_b = attachMessage.snapshot) !== null && _b !== void 0 ? _b : {
-                    entries: [createAttributesBlob(pkg, true /* isRootDataStore */, this.runtime.disableIsolatedChannels)],
+                snapshot: attachMessage.snapshot ?? {
+                    entries: [createAttributesBlob(pkg, true /* isRootDataStore */)],
                 },
             }),
-            writeGCDataAtRoot: this.writeGCDataAtRoot,
-            disableIsolatedChannels: this.runtime.disableIsolatedChannels,
             pkg,
         });
         this.contexts.addBoundOrRemoted(remoteFluidDataStoreContext);
@@ -163,7 +157,9 @@ export class DataStores {
     processAliasMessage(message, localOpMetadata, local) {
         const aliasMessage = message.contents;
         if (!isDataStoreAliasMessage(aliasMessage)) {
-            throw new DataCorruptionError("malformedDataStoreAliasMessage", Object.assign({}, extractSafePropertiesFromMessage(message)));
+            throw new DataCorruptionError("malformedDataStoreAliasMessage", {
+                ...extractSafePropertiesFromMessage(message),
+            });
         }
         const resolve = localOpMetadata;
         const aliasResult = this.processAliasMessageCore(aliasMessage);
@@ -176,8 +172,13 @@ export class DataStores {
             return false;
         }
         const context = this.contexts.get(aliasMessage.internalId);
+        // If the data store has been deleted, log an error and ignore this message. This helps prevent document
+        // corruption in case a deleted data store accidentally submitted a signal.
+        if (this.checkAndLogIfDeleted(aliasMessage.internalId, context, "Changed", "processAliasMessageCore")) {
+            return false;
+        }
         if (context === undefined) {
-            this.logger.sendErrorEvent({
+            this.mc.logger.sendErrorEvent({
                 eventName: "AliasFluidDataStoreNotFound",
                 fluidDataStoreId: aliasMessage.internalId,
             });
@@ -222,17 +223,17 @@ export class DataStores {
             runtime: this.runtime,
             storage: this.runtime.storage,
             scope: this.runtime.scope,
-            createSummarizerNodeFn: this.getCreateChildSummarizerNodeFn(id, { type: CreateSummarizerNodeSource.Local }),
+            createSummarizerNodeFn: this.getCreateChildSummarizerNodeFn(id, {
+                type: CreateSummarizerNodeSource.Local,
+            }),
             makeLocallyVisibleFn: () => this.makeDataStoreLocallyVisible(id),
             snapshotTree: undefined,
             isRootDataStore: isRoot,
-            writeGCDataAtRoot: this.writeGCDataAtRoot,
-            disableIsolatedChannels: this.runtime.disableIsolatedChannels,
         });
         this.contexts.addUnbound(context);
         return context;
     }
-    _createFluidDataStoreContext(pkg, id, isRoot, props) {
+    _createFluidDataStoreContext(pkg, id, props) {
         assert(!id.includes("/"), 0x30d /* Id cannot contain slashes */);
         const context = new LocalFluidDataStoreContext({
             id,
@@ -240,33 +241,53 @@ export class DataStores {
             runtime: this.runtime,
             storage: this.runtime.storage,
             scope: this.runtime.scope,
-            createSummarizerNodeFn: this.getCreateChildSummarizerNodeFn(id, { type: CreateSummarizerNodeSource.Local }),
+            createSummarizerNodeFn: this.getCreateChildSummarizerNodeFn(id, {
+                type: CreateSummarizerNodeSource.Local,
+            }),
             makeLocallyVisibleFn: () => this.makeDataStoreLocallyVisible(id),
             snapshotTree: undefined,
-            isRootDataStore: isRoot,
-            writeGCDataAtRoot: this.writeGCDataAtRoot,
-            disableIsolatedChannels: this.runtime.disableIsolatedChannels,
+            isRootDataStore: false,
             createProps: props,
         });
         this.contexts.addUnbound(context);
         return context;
     }
-    get disposed() { return this.disposeOnce.evaluated; }
-    resubmitDataStoreOp(content, localOpMetadata) {
-        const envelope = content;
+    get disposed() {
+        return this.disposeOnce.evaluated;
+    }
+    resubmitDataStoreOp(envelope, localOpMetadata) {
         const context = this.contexts.get(envelope.address);
+        // If the data store has been deleted, log an error and throw an error. If there are local changes for a
+        // deleted data store, it can otherwise lead to inconsistent state when compared to other clients.
+        if (this.checkAndLogIfDeleted(envelope.address, context, "Changed", "resubmitDataStoreOp")) {
+            throw new DataCorruptionError("Context is deleted!", {
+                callSite: "resubmitDataStoreOp",
+                ...tagCodeArtifacts({ id: envelope.address }),
+            });
+        }
         assert(!!context, 0x160 /* "There should be a store context for the op" */);
         context.reSubmit(envelope.contents, localOpMetadata);
     }
-    rollbackDataStoreOp(content, localOpMetadata) {
-        const envelope = content;
+    rollbackDataStoreOp(envelope, localOpMetadata) {
         const context = this.contexts.get(envelope.address);
+        // If the data store has been deleted, log an error and throw an error. If there are local changes for a
+        // deleted data store, it can otherwise lead to inconsistent state when compared to other clients.
+        if (this.checkAndLogIfDeleted(envelope.address, context, "Changed", "rollbackDataStoreOp")) {
+            throw new DataCorruptionError("Context is deleted!", {
+                callSite: "rollbackDataStoreOp",
+                ...tagCodeArtifacts({ id: envelope.address }),
+            });
+        }
         assert(!!context, 0x2e8 /* "There should be a store context for the op" */);
         context.rollback(envelope.contents, localOpMetadata);
     }
-    async applyStashedOp(content) {
-        const envelope = content;
+    async applyStashedOp(envelope) {
         const context = this.contexts.get(envelope.address);
+        // If the data store has been deleted, log an error and ignore this message. This helps prevent document
+        // corruption in case the data store that stashed the op is deleted.
+        if (this.checkAndLogIfDeleted(envelope.address, context, "Changed", "applyStashedOp")) {
+            return undefined;
+        }
         assert(!!context, 0x161 /* "There should be a store context for the op" */);
         return context.applyStashedOp(envelope.contents);
     }
@@ -277,16 +298,27 @@ export class DataStores {
     }
     processFluidDataStoreOp(message, local, localMessageMetadata) {
         const envelope = message.contents;
-        const transformed = Object.assign(Object.assign({}, message), { contents: envelope.contents });
+        const transformed = { ...message, contents: envelope.contents };
         const context = this.contexts.get(envelope.address);
+        // If the data store has been deleted, log an error and ignore this message. This helps prevent document
+        // corruption in case a deleted data store accidentally submitted an op.
+        if (this.checkAndLogIfDeleted(envelope.address, context, "Changed", "processFluidDataStoreOp")) {
+            return;
+        }
         assert(!!context, 0x162 /* "There should be a store context for the op" */);
         context.process(transformed, local, localMessageMetadata);
         // Notify that a GC node for the data store changed. This is used to detect if a deleted data store is
         // being used.
         this.gcNodeUpdated(`/${envelope.address}`, message.timestamp, context.isLoaded ? context.packagePath : undefined);
     }
-    async getDataStore(id, wait) {
-        const context = await this.contexts.getBoundOrRemoted(id, wait);
+    async getDataStore(id, requestHeaderData) {
+        const headerData = { ...defaultRuntimeHeaderData, ...requestHeaderData };
+        if (this.checkAndLogIfDeleted(id, this.contexts.get(id), "Requested", "getDataStore", requestHeaderData)) {
+            // The requested data store has been deleted by gc. Create a 404 response exception.
+            const request = { url: id };
+            throw responseToException(createResponseError(404, "DataStore was deleted", request), request);
+        }
+        const context = await this.contexts.getBoundOrRemoted(id, headerData.wait);
         if (context === undefined) {
             // The requested data store does not exits. Throw a 404 response exception.
             const request = { url: id };
@@ -294,44 +326,85 @@ export class DataStores {
         }
         return context;
     }
-    processSignal(address, message, local) {
-        const context = this.contexts.get(address);
+    /**
+     * Returns the data store requested with the given id if available. Otherwise, returns undefined.
+     */
+    async getDataStoreIfAvailable(id, requestHeaderData) {
+        // If the data store has been deleted, log an error and return undefined.
+        if (this.checkAndLogIfDeleted(id, this.contexts.get(id), "Requested", "getDataStoreIfAvailable", requestHeaderData)) {
+            return undefined;
+        }
+        const headerData = { ...defaultRuntimeHeaderData, ...requestHeaderData };
+        const context = await this.contexts.getBoundOrRemoted(id, headerData.wait);
+        if (context === undefined) {
+            return undefined;
+        }
+        return context;
+    }
+    /**
+     * Checks if the data store has been deleted by GC. If so, log an error.
+     * @param id - The data store's id.
+     * @param context - The data store context.
+     * @param callSite - The function name this is called from.
+     * @param requestHeaderData - The request header information to log if the data store is deleted.
+     * @returns true if the data store is deleted. Otherwise, returns false.
+     */
+    checkAndLogIfDeleted(id, context, deletedLogSuffix, callSite, requestHeaderData) {
+        const dataStoreNodePath = `/${id}`;
+        if (!this.isDataStoreDeleted(dataStoreNodePath)) {
+            return false;
+        }
+        this.mc.logger.sendErrorEvent({
+            eventName: `GC_Deleted_DataStore_${deletedLogSuffix}`,
+            ...tagCodeArtifacts({ id }),
+            callSite,
+            headers: JSON.stringify(requestHeaderData),
+            exists: context !== undefined,
+        });
+        return true;
+    }
+    processSignal(fluidDataStoreId, message, local) {
+        const context = this.contexts.get(fluidDataStoreId);
+        // If the data store has been deleted, log an error and ignore this message. This helps prevent document
+        // corruption in case a deleted data store accidentally submitted a signal.
+        if (this.checkAndLogIfDeleted(fluidDataStoreId, context, "Changed", "processSignal")) {
+            return;
+        }
         if (!context) {
             // Attach message may not have been processed yet
             assert(!local, 0x163 /* "Missing datastore for local signal" */);
-            this.logger.sendTelemetryEvent({
+            this.mc.logger.sendTelemetryEvent({
                 eventName: "SignalFluidDataStoreNotFound",
-                fluidDataStoreId: {
-                    value: address,
-                    tag: TelemetryDataTag.PackageData,
-                },
+                ...tagCodeArtifacts({
+                    fluidDataStoreId,
+                }),
             });
             return;
         }
         context.processSignal(message, local);
     }
     setConnectionState(connected, clientId) {
-        for (const [fluidDataStore, context] of this.contexts) {
+        for (const [fluidDataStoreId, context] of this.contexts) {
             try {
                 context.setConnectionState(connected, clientId);
             }
             catch (error) {
-                this.logger.sendErrorEvent({
+                this.mc.logger.sendErrorEvent({
                     eventName: "SetConnectionStateError",
                     clientId,
-                    fluidDataStore,
+                    ...tagCodeArtifacts({
+                        fluidDataStoreId,
+                    }),
+                    details: JSON.stringify({
+                        runtimeConnected: this.runtime.connected,
+                        connected,
+                    }),
                 }, error);
             }
         }
     }
     setAttachState(attachState) {
-        let eventName;
-        if (attachState === AttachState.Attaching) {
-            eventName = "attaching";
-        }
-        else {
-            eventName = "attached";
-        }
+        const eventName = attachState === AttachState.Attaching ? "attaching" : "attached";
         for (const [, context] of this.contexts) {
             // Fire only for bounded stores.
             if (!this.contexts.isNotBound(context.id)) {
@@ -347,10 +420,17 @@ export class DataStores {
         // Iterate over each store and ask it to snapshot
         await Promise.all(Array.from(this.contexts)
             .filter(([_, context]) => {
-            // Summarizer works only with clients with no local changes!
-            assert(context.attachState !== AttachState.Attaching, 0x165 /* "Summarizer cannot work if client has local changes" */);
+            // Summarizer works only with clients with no local changes. A data store in attaching
+            // state indicates an op was sent to attach a local data store, and the the attach op
+            // had not yet round tripped back to the client.
+            if (context.attachState === AttachState.Attaching) {
+                // Formerly assert 0x588
+                const error = DataProcessingError.create("Local data store detected in attaching state during summarize", "summarize");
+                throw error;
+            }
             return context.attachState === AttachState.Attached;
-        }).map(async ([contextId, context]) => {
+        })
+            .map(async ([contextId, context]) => {
             const contextSummary = await context.summarize(fullTree, trackState, telemetryContext);
             summaryBuilder.addWithStats(contextId, contextSummary);
         }));
@@ -370,9 +450,9 @@ export class DataStores {
             // Take summary of bounded data stores only, make sure we haven't summarized them already
             // and no attach op has been fired for that data store because for loader versions <= 0.24
             // we set attach state as "attaching" before taking createNew summary.
-            !(this.contexts.isNotBound(key)
-                || builderTree[key]
-                || this.attachOpFiredForDataStore.has(key)))
+            !(this.contexts.isNotBound(key) ||
+                builderTree[key] ||
+                this.attachOpFiredForDataStore.has(key)))
                 .map(([key, value]) => {
                 let dataStoreSummary;
                 if (value.isLoaded) {
@@ -409,11 +489,15 @@ export class DataStores {
     }
     /**
      * Generates data used for garbage collection. It does the following:
+     *
      * 1. Calls into each child data store context to get its GC data.
+     *
      * 2. Prefixes the child context's id to the GC nodes in the child's GC data. This makes sure that the node can be
-     *    identified as belonging to the child.
+     * identified as belonging to the child.
+     *
      * 3. Adds a GC node for this channel to the nodes received from the children. All these nodes together represent
-     *    the GC data of this channel.
+     * the GC data of this channel.
+     *
      * @param fullGC - true to bypass optimizations and force full generation of GC data.
      */
     async getGCData(fullGC = false) {
@@ -421,10 +505,17 @@ export class DataStores {
         // Iterate over each store and get their GC data.
         await Promise.all(Array.from(this.contexts)
             .filter(([_, context]) => {
-            // Get GC data only for attached contexts. Detached contexts are not connected in the GC reference
-            // graph so any references they might have won't be connected as well.
+            // Summarizer client and hence GC works only with clients with no local changes. A data store in
+            // attaching state indicates an op was sent to attach a local data store, and the the attach op
+            // had not yet round tripped back to the client.
+            // Formerly assert 0x589
+            if (context.attachState === AttachState.Attaching) {
+                const error = DataProcessingError.create("Local data store detected in attaching state while running GC", "getGCData");
+                throw error;
+            }
             return context.attachState === AttachState.Attached;
-        }).map(async ([contextId, context]) => {
+        })
+            .map(async ([contextId, context]) => {
             const contextGCData = await context.getGCData(fullGC);
             // Prefix the child's id to the ids of its GC nodes so they can be identified as belonging to the child.
             // This also gradually builds the id of each node to be a path from the root.
@@ -437,11 +528,8 @@ export class DataStores {
     /**
      * After GC has run, called to notify this Container's data stores of routes that are used in it.
      * @param usedRoutes - The routes that are used in all data stores in this Container.
-     * @param gcTimestamp - The time when GC was run that generated these used routes. If any node node becomes
-     * unreferenced as part of this GC run, this should be used to update the time when it happens.
      */
-    updateUsedRoutes(usedRoutes, gcTimestamp) {
-        var _a;
+    updateUsedRoutes(usedRoutes) {
         // Get a map of data store ids to routes used in it.
         const usedDataStoreRoutes = unpackChildNodesUsedRoutes(usedRoutes);
         // Verify that the used routes are correct.
@@ -450,15 +538,14 @@ export class DataStores {
         }
         // Update the used routes in each data store. Used routes is empty for unused data stores.
         for (const [contextId, context] of this.contexts) {
-            context.updateUsedRoutes((_a = usedDataStoreRoutes.get(contextId)) !== null && _a !== void 0 ? _a : [], gcTimestamp);
+            context.updateUsedRoutes(usedDataStoreRoutes.get(contextId) ?? []);
         }
     }
     /**
-     * When running GC in test mode, this is called to delete objects whose routes are unused. This enables testing
-     * scenarios with accessing deleted content.
+     * This is called to update objects whose routes are unused. The unused objects are deleted.
      * @param unusedRoutes - The routes that are unused in all data stores in this Container.
      */
-    deleteUnusedRoutes(unusedRoutes) {
+    updateUnusedRoutes(unusedRoutes) {
         for (const route of unusedRoutes) {
             const pathParts = route.split("/");
             // Delete data store only if its route (/datastoreId) is in unusedRoutes. We don't want to delete a data
@@ -474,6 +561,66 @@ export class DataStores {
             this.deleteChildSummarizerNodeFn(dataStoreId);
         }
     }
+    /**
+     * Delete data stores and its objects that are sweep ready.
+     * @param sweepReadyDataStoreRoutes - The routes of data stores and its objects that are sweep ready and should
+     * be deleted.
+     * @returns The routes of data stores and its objects that were deleted.
+     */
+    deleteSweepReadyNodes(sweepReadyDataStoreRoutes) {
+        // If sweep for data stores is not enabled, return empty list indicating nothing is deleted.
+        if (this.mc.config.getBoolean(disableDatastoreSweepKey) === true) {
+            return [];
+        }
+        for (const route of sweepReadyDataStoreRoutes) {
+            const pathParts = route.split("/");
+            const dataStoreId = pathParts[1];
+            // Ignore sub-data store routes because a data store and its sub-routes are deleted together, so, we only
+            // need to delete the data store.
+            if (pathParts.length > 2) {
+                continue;
+            }
+            const dataStoreContext = this.contexts.get(dataStoreId);
+            if (dataStoreContext === undefined) {
+                this.mc.logger.sendErrorEvent({
+                    eventName: "DeletedDataStoreNotFound",
+                    ...tagCodeArtifacts({ id: dataStoreId }),
+                    details: {
+                        alreadyDeleted: this.isDataStoreDeleted(dataStoreId),
+                    },
+                });
+                continue;
+            }
+            dataStoreContext.delete();
+            // Delete the contexts of sweep ready data stores.
+            this.contexts.delete(dataStoreId);
+            // Delete the summarizer node of the sweep ready data stores.
+            this.deleteChildSummarizerNodeFn(dataStoreId);
+        }
+        return Array.from(sweepReadyDataStoreRoutes);
+    }
+    /**
+     * This is called to update objects whose routes are tombstones. Tombstoned datastore contexts enable testing
+     * scenarios with accessing deleted content without actually deleting content from summaries.
+     * @param tombstonedRoutes - The routes that are tombstones in all data stores in this Container.
+     */
+    updateTombstonedRoutes(tombstonedRoutes) {
+        const tombstonedDataStoresSet = new Set();
+        for (const route of tombstonedRoutes) {
+            const pathParts = route.split("/");
+            // Tombstone data store only if its route (/datastoreId) is directly in tombstoneRoutes.
+            if (pathParts.length > 2) {
+                continue;
+            }
+            const dataStoreId = pathParts[1];
+            assert(this.contexts.has(dataStoreId), 0x510 /* No data store with specified id */);
+            tombstonedDataStoresSet.add(dataStoreId);
+        }
+        // Update the used routes in each data store. Used routes is empty for unused data stores.
+        for (const [contextId, context] of this.contexts) {
+            context.setTombstone(tombstonedDataStoresSet.has(contextId));
+        }
+    }
     /**
      * Returns the outbound routes of this channel. Only root data stores are considered referenced and their paths are
      * part of outbound routes.
@@ -492,11 +639,10 @@ export class DataStores {
      * Called by GC to retrieve the package path of a data store node with the given path.
      */
     async getDataStorePackagePath(nodePath) {
-        var _a;
         // If the node belongs to a data store, return its package path. For DDSes, we return the package path of the
         // data store that contains it.
         const context = this.contexts.get(nodePath.split("/")[1]);
-        return (_a = (await (context === null || context === void 0 ? void 0 : context.getInitialSnapshotDetails()))) === null || _a === void 0 ? void 0 : _a.pkg;
+        return (await context?.getInitialSnapshotDetails())?.pkg;
     }
     /**
      * Called by GC to determine if a node is for a data store or for an object within a data store (for e.g. DDS).
@@ -532,7 +678,10 @@ export function getSummaryForDatastores(snapshot, metadata) {
                 datastoresTrees[key] = value;
             }
         }
-        return Object.assign(Object.assign({}, snapshot), { trees: datastoresTrees });
+        return {
+            ...snapshot,
+            trees: datastoresTrees,
+        };
     }
 }
-//# sourceMappingURL=dataStores.js.map
+//# sourceMappingURL=dataStores.mjs.map