@fluidframework/container-loader 2.117.0 → 3.0.0

package/dist/container.js

@@ -4,7 +4,9 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.asLegacyAlpha = exports.Container = exports.waitContainerToCatchUp = void 0;
+exports.Container = void 0;
+exports.waitContainerToCatchUp = waitContainerToCatchUp;
+exports.asLegacyAlpha = asLegacyAlpha;
 /* eslint-disable unicorn/consistent-function-scoping, @typescript-eslint/prefer-nullish-coalescing, @typescript-eslint/prefer-optional-chain */
 const client_utils_1 = require("@fluid-internal/client-utils");
 const container_definitions_1 = require("@fluidframework/container-definitions");
@@ -18,13 +20,12 @@ const internal_5 = require("@fluidframework/telemetry-utils/internal");
 const uuid_1 = require("uuid");
 const attachment_js_1 = require("./attachment.js");
 const audience_js_1 = require("./audience.js");
-const connectionManager_js_1 = require("./connectionManager.js");
 const connectionState_js_1 = require("./connectionState.js");
 const connectionStateHandler_js_1 = require("./connectionStateHandler.js");
 const containerContext_js_1 = require("./containerContext.js");
 const containerStorageAdapter_js_1 = require("./containerStorageAdapter.js");
 const contracts_js_1 = require("./contracts.js");
-const deltaManager_js_1 = require("./deltaManager.js");
+const deltaManagerFactory_js_1 = require("./deltaManagerFactory.js");
 const loader_js_1 = require("./loader.js");
 const loaderLayerCompatState_js_1 = require("./loaderLayerCompatState.js");
 const memoryBlobStorage_js_1 = require("./memoryBlobStorage.js");
@@ -112,7 +113,6 @@ async function waitContainerToCatchUp(container) {
         }
     });
 }
-exports.waitContainerToCatchUp = waitContainerToCatchUp;
 const getCodeProposal = (quorum) => quorum.get("code") ?? quorum.get("code2");
 const summarizerClientType = "summarizer";
 class Container extends internal_5.EventEmitterWithErrorHandling {
@@ -181,6 +181,41 @@ class Container extends internal_5.EventEmitterWithErrorHandling {
             return container;
         }, { start: true, end: true, cancel: "generic" });
     }
+    // Tells if container can reconnect on losing fist connection
+    // If false, container gets closed on loss of connection.
+    _canReconnect;
+    clientDetailsOverride;
+    urlResolver;
+    serviceFactory;
+    codeLoader;
+    options;
+    scope;
+    subLogger;
+    detachedBlobStorage;
+    protocolHandlerBuilder;
+    signalAudience = new audience_js_1.Audience();
+    client;
+    mc;
+    /**
+     * Used by the RelativeLoader to spawn a new Container for the same document.  Used to create the summarizing client.
+     */
+    clone;
+    /**
+     * Lifecycle state of the container, used mainly to prevent re-entrancy and telemetry
+     *
+     * States are allowed to progress to further states:
+     * "loading" - "loaded" - "closing" - "disposing" - "closed" - "disposed"
+     *
+     * For example, moving from "closed" to "disposing" is not allowed since it is an earlier state.
+     *
+     * loading: Container has been created, but is not yet in normal/loaded state
+     * loaded: Container is in normal/loaded state
+     * closing: Container has started closing process (for re-entrancy prevention)
+     * disposing: Container has started disposing process (for re-entrancy prevention)
+     * closed: Container has closed
+     * disposed: Container has been disposed
+     */
+    _lifecycleState = "loading";
     setLoaded() {
         // It's conceivable the container could be closed when this is called
         // Only transition states if currently loading
@@ -227,18 +262,48 @@ class Container extends internal_5.EventEmitterWithErrorHandling {
     get disposed() {
         return this._lifecycleState === "disposing" || this._lifecycleState === "disposed";
     }
+    storageAdapter;
+    _deltaManager;
+    service;
+    fetchOps = async (from, to, abortSignal) => {
+        const deltaStorage = await this.service?.connectToDeltaStorage();
+        if (deltaStorage === undefined) {
+            throw new Error("Cannot fetch ops: delta storage is unavailable");
+        }
+        return deltaStorage.fetchMessages(from, to, abortSignal);
+    };
+    _runtime;
     get runtime() {
         if (this._runtime === undefined) {
             throw new Error("Attempted to access runtime before it was defined");
         }
         return this._runtime;
     }
+    _protocolHandler;
     get protocolHandler() {
         if (this._protocolHandler === undefined) {
             throw new Error("Attempted to access protocolHandler before it was defined");
         }
         return this._protocolHandler;
     }
+    /**
+     * During initialization we pause the inbound queues. We track this state to ensure we only call resume once
+     */
+    inboundQueuePausedFromInit = true;
+    connectionCount = 0;
+    connectionTransitionTimes = [];
+    _loadedFromVersion;
+    _dirtyContainer = false;
+    attachmentData = { state: container_definitions_1.AttachState.Detached };
+    serializedStateManager;
+    _containerId;
+    lastVisible;
+    visibilityEventHandler;
+    connectionStateHandler;
+    clientsWhoShouldHaveLeft = new Set();
+    _containerMetadata = {};
+    setAutoReconnectTime = (0, client_utils_1.performanceNow)();
+    noopHeuristic;
     get connectionMode() {
         return this._deltaManager.connectionManager.connectionMode;
     }
@@ -314,6 +379,7 @@ class Container extends internal_5.EventEmitterWithErrorHandling {
     getSpecifiedCodeDetails() {
         return this.getCodeDetailsFromQuorum();
     }
+    _loadedCodeDetails;
     /**
      * Get the code details that were used to load the container.
      * @returns The code details that were used to load the container if it is loaded, undefined if it is not yet
@@ -322,6 +388,7 @@ class Container extends internal_5.EventEmitterWithErrorHandling {
     getLoadedCodeDetails() {
         return this._loadedCodeDetails;
     }
+    _loadedModule;
     /**
      * Retrieves the audience associated with the document
      */
@@ -360,6 +427,7 @@ class Container extends internal_5.EventEmitterWithErrorHandling {
             this._lifecycleEvents.once("disposed", disposedHandler);
         });
     }
+    _lifecycleEvents = new client_utils_1.TypedEventEmitter();
     constructor(createProps, loadProps) {
         super((name, error) => {
             this.mc.logger.sendErrorEvent({
@@ -368,144 +436,22 @@ class Container extends internal_5.EventEmitterWithErrorHandling {
             }, error);
             this.close((0, internal_5.normalizeError)(error));
         });
-        this.signalAudience = new audience_js_1.Audience();
-        /**
-         * Lifecycle state of the container, used mainly to prevent re-entrancy and telemetry
-         *
-         * States are allowed to progress to further states:
-         * "loading" - "loaded" - "closing" - "disposing" - "closed" - "disposed"
-         *
-         * For example, moving from "closed" to "disposing" is not allowed since it is an earlier state.
-         *
-         * loading: Container has been created, but is not yet in normal/loaded state
-         * loaded: Container is in normal/loaded state
-         * closing: Container has started closing process (for re-entrancy prevention)
-         * disposing: Container has started disposing process (for re-entrancy prevention)
-         * closed: Container has closed
-         * disposed: Container has been disposed
-         */
-        this._lifecycleState = "loading";
-        this.fetchOps = async (from, to, abortSignal) => {
-            const deltaStorage = await this.service?.connectToDeltaStorage();
-            if (deltaStorage === undefined) {
-                throw new Error("Cannot fetch ops: delta storage is unavailable");
-            }
-            return deltaStorage.fetchMessages(from, to, abortSignal);
-        };
-        /**
-         * During initialization we pause the inbound queues. We track this state to ensure we only call resume once
-         */
-        this.inboundQueuePausedFromInit = true;
-        this.connectionCount = 0;
-        this.connectionTransitionTimes = [];
-        this._dirtyContainer = false;
-        this.attachmentData = { state: container_definitions_1.AttachState.Detached };
-        this.clientsWhoShouldHaveLeft = new Set();
-        this._containerMetadata = {};
-        this.setAutoReconnectTime = (0, client_utils_1.performanceNow)();
-        this._lifecycleEvents = new client_utils_1.TypedEventEmitter();
-        this.verifyClosedAfterCalls = 0;
-        this._disposed = false;
-        this.attach = (0, utils_js_1.runSingle)(async (request, attachProps) => {
-            await internal_5.PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "Attach" }, async () => {
-                if (this._lifecycleState !== "loaded" ||
-                    this.attachmentData.state === container_definitions_1.AttachState.Attached) {
-                    // pre-0.58 error message: containerNotValidForAttach
-                    throw new internal_5.UsageError(`The Container is not in a valid state for attach [${this._lifecycleState}] and [${this.attachState}]`);
-                }
-                const normalizeErrorAndClose = (error) => {
-                    const newError = (0, internal_5.normalizeError)(error);
-                    this.close(newError);
-                    // add resolved URL on error object so that host has the ability to find this document and delete it
-                    newError.addTelemetryProperties({
-                        resolvedUrl: this.service?.resolvedUrl?.url,
-                    });
-                    return newError;
-                };
-                const setAttachmentData = (attachmentData) => {
-                    const previousState = this.attachmentData.state;
-                    this.attachmentData = attachmentData;
-                    const state = this.attachmentData.state;
-                    if (state !== previousState && state !== container_definitions_1.AttachState.Detached) {
-                        try {
-                            this.runtime.setAttachState(state);
-                            this.emit(state.toLocaleLowerCase());
-                        }
-                        catch (error) {
-                            throw normalizeErrorAndClose(error);
-                        }
-                    }
-                };
-                const createAttachmentSummary = (redirectTable) => {
-                    try {
-                        (0, internal_2.assert)(this._deltaManager.inbound.length === 0, 0x0d6 /* "Inbound queue should be empty when attaching" */);
-                        return (0, utils_js_1.combineAppAndProtocolSummary)(this.runtime.createSummary(redirectTable), this.captureProtocolSummary());
-                    }
-                    catch (error) {
-                        throw normalizeErrorAndClose(error);
-                    }
-                };
-                const createOrGetStorageService = async (summary) => {
-                    // Actually go and create the resolved document
-                    if (this.service === undefined) {
-                        const createNewResolvedUrl = await this.urlResolver.resolve(request);
-                        (0, internal_2.assert)(this.client.details.type !== summarizerClientType &&
-                            createNewResolvedUrl !== undefined, 0x2c4 /* "client should not be summarizer before container is created" */);
-                        this.service = await this.createDocumentService(createNewResolvedUrl, {
-                            mode: "attach",
-                            summary,
-                        });
-                    }
-                    this.storageAdapter.connectToService(this.service);
-                    return this.storageAdapter;
-                };
-                let attachP = (0, attachment_js_1.runRetriableAttachProcess)({
-                    initialAttachmentData: this.attachmentData,
-                    detachedBlobStorage: this.detachedBlobStorage,
-                    setAttachmentData,
-                    createAttachmentSummary,
-                    createOrGetStorageService,
-                });
-                // only enable the new behavior if the config is set
-                if (this.mc.config.getBoolean("Fluid.Container.DisableCloseOnAttachFailure") !== true) {
-                    attachP = attachP.catch((error) => {
-                        throw normalizeErrorAndClose(error);
-                    });
-                }
-                // If offline load is enabled, attachP will return the attach summary (in Snapshot format) so we can initialize SerializedStateManager
-                const snapshotWithBlobs = await attachP;
-                this.serializedStateManager.setInitialSnapshot(snapshotWithBlobs);
-                if (!this.closed) {
-                    this.detachedBlobStorage?.dispose?.();
-                    this.handleDeltaConnectionArg(attachProps?.deltaConnection, {
-                        fetchOpsFromStorage: false,
-                        reason: { text: "createDetached" },
-                    });
-                }
-            }, { start: true, end: true, cancel: "generic" });
-        });
-        this.getAbsoluteUrl = async (relativeUrl) => {
-            if (this.resolvedUrl === undefined) {
-                return undefined;
-            }
-            return this.urlResolver.getAbsoluteUrl(this.resolvedUrl, relativeUrl, (0, contracts_js_1.getPackageName)(this._loadedCodeDetails));
-        };
-        this.metadataUpdateHandler = (metadata) => {
-            this._containerMetadata = { ...this._containerMetadata, ...metadata };
-            this.emit("metadataUpdate", metadata);
-        };
-        this.updateDirtyContainerState = (dirty) => {
-            if (this._dirtyContainer === dirty) {
-                return;
-            }
-            this._dirtyContainer = dirty;
-            this.emit(dirty ? dirtyContainerEvent : savedContainerEvent);
-        };
         const { canReconnect, clientDetailsOverride, urlResolver, documentServiceFactory, codeLoader, options, scope, subLogger, protocolHandlerBuilder, } = createProps;
-        // Validate that the Driver is compatible with this Loader.
-        const maybeDriverCompatDetails = documentServiceFactory;
-        (0, loaderLayerCompatState_js_1.validateDriverCompatibility)(maybeDriverCompatDetails.ILayerCompatDetails, (error) => { } /* disposeFn */, // There is nothing to dispose here, so just ignore the error.
-        (0, internal_5.createChildMonitoringContext)({ logger: subLogger, namespace: "Container" }));
+        const maybeDriverCompat = documentServiceFactory;
+        const driverCompatMonitoringContext = (0, internal_5.createChildMonitoringContext)({
+            logger: subLogger,
+            namespace: "Container",
+        });
+        // Validate that the Driver is compatible with this Loader. This is the standard direction: the Loader holds
+        // a reference to the Driver and validates it.
+        (0, loaderLayerCompatState_js_1.validateDriverCompatibility)(maybeDriverCompat.ILayerCompatDetails, (error) => { } /* disposeFn */, // There is nothing to dispose here, so just ignore the error.
+        driverCompatMonitoringContext);
+        // Validate that this Loader is compatible with the Driver. This is the reverse, non-standard direction: a
+        // layer normally validates the layer it holds a reference to, but the Driver has no reference to the Loader
+        // and so cannot validate it itself. The Driver instead publishes the requirements it has for the Loader (via
+        // ILayerCompatSupportRequirements), and the Loader validates itself against them here, on the Driver's behalf.
+        (0, loaderLayerCompatState_js_1.validateLoaderCompatibilityWithDriver)(maybeDriverCompat.ILayerCompatDetails, maybeDriverCompat.ILayerCompatSupportRequirements, (error) => { } /* disposeFn */, // There is nothing to dispose here, so just ignore the error.
+        driverCompatMonitoringContext);
         this.connectionTransitionTimes[connectionState_js_1.ConnectionState.Disconnected] = (0, client_utils_1.performanceNow)();
         const pendingLocalState = loadProps?.pendingLocalState;
         this._canReconnect = canReconnect ?? true;
@@ -686,6 +632,7 @@ class Container extends internal_5.EventEmitterWithErrorHandling {
         //    "closing" will lose that info (can also solve by tracking extra state).
         this.verifyClosedAfter(() => this._deltaManager.close(error));
     }
+    verifyClosedAfterCalls = 0;
     verifyClosedAfter(callback) {
         this.verifyClosedAfterCalls++;
         try {
@@ -740,6 +687,7 @@ class Container extends internal_5.EventEmitterWithErrorHandling {
             }
         }
     }
+    _disposed = false;
     disposeCore(error) {
         (0, internal_2.assert)(!this._disposed, 0x54c /* Container already disposed */);
         this._disposed = true;
@@ -826,6 +774,84 @@ class Container extends internal_5.EventEmitterWithErrorHandling {
         };
         return JSON.stringify(detachedContainerState);
     }
+    attach = (0, utils_js_1.runSingle)(async (request, attachProps) => {
+        await internal_5.PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "Attach" }, async () => {
+            if (this._lifecycleState !== "loaded" ||
+                this.attachmentData.state === container_definitions_1.AttachState.Attached) {
+                // pre-0.58 error message: containerNotValidForAttach
+                throw new internal_5.UsageError(`The Container is not in a valid state for attach [${this._lifecycleState}] and [${this.attachState}]`);
+            }
+            const normalizeErrorAndClose = (error) => {
+                const newError = (0, internal_5.normalizeError)(error);
+                this.close(newError);
+                // add resolved URL on error object so that host has the ability to find this document and delete it
+                newError.addTelemetryProperties({
+                    resolvedUrl: this.service?.resolvedUrl?.url,
+                });
+                return newError;
+            };
+            const setAttachmentData = (attachmentData) => {
+                const previousState = this.attachmentData.state;
+                this.attachmentData = attachmentData;
+                const state = this.attachmentData.state;
+                if (state !== previousState && state !== container_definitions_1.AttachState.Detached) {
+                    try {
+                        this.runtime.setAttachState(state);
+                        this.emit(state.toLocaleLowerCase());
+                    }
+                    catch (error) {
+                        throw normalizeErrorAndClose(error);
+                    }
+                }
+            };
+            const createAttachmentSummary = (redirectTable) => {
+                try {
+                    (0, internal_2.assert)(this._deltaManager.inbound.length === 0, 0x0d6 /* "Inbound queue should be empty when attaching" */);
+                    return (0, utils_js_1.combineAppAndProtocolSummary)(this.runtime.createSummary(redirectTable), this.captureProtocolSummary());
+                }
+                catch (error) {
+                    throw normalizeErrorAndClose(error);
+                }
+            };
+            const createOrGetStorageService = async (summary) => {
+                // Actually go and create the resolved document
+                if (this.service === undefined) {
+                    const createNewResolvedUrl = await this.urlResolver.resolve(request);
+                    (0, internal_2.assert)(this.client.details.type !== summarizerClientType &&
+                        createNewResolvedUrl !== undefined, 0x2c4 /* "client should not be summarizer before container is created" */);
+                    this.service = await this.createDocumentService(createNewResolvedUrl, {
+                        mode: "attach",
+                        summary,
+                    });
+                }
+                this.storageAdapter.connectToService(this.service);
+                return this.storageAdapter;
+            };
+            let attachP = (0, attachment_js_1.runRetriableAttachProcess)({
+                initialAttachmentData: this.attachmentData,
+                detachedBlobStorage: this.detachedBlobStorage,
+                setAttachmentData,
+                createAttachmentSummary,
+                createOrGetStorageService,
+            });
+            // only enable the new behavior if the config is set
+            if (this.mc.config.getBoolean("Fluid.Container.DisableCloseOnAttachFailure") !== true) {
+                attachP = attachP.catch((error) => {
+                    throw normalizeErrorAndClose(error);
+                });
+            }
+            // If offline load is enabled, attachP will return the attach summary (in Snapshot format) so we can initialize SerializedStateManager
+            const snapshotWithBlobs = await attachP;
+            this.serializedStateManager.setInitialSnapshot(snapshotWithBlobs);
+            if (!this.closed) {
+                this.detachedBlobStorage?.dispose?.();
+                this.handleDeltaConnectionArg(attachProps?.deltaConnection, {
+                    fetchOpsFromStorage: false,
+                    reason: { text: "createDetached" },
+                });
+            }
+        }, { start: true, end: true, cancel: "generic" });
+    });
     setAutoReconnectInternal(mode, reason) {
         const currentMode = this._deltaManager.connectionManager.reconnectMode;
         if (currentMode === mode) {
@@ -898,6 +924,12 @@ class Container extends internal_5.EventEmitterWithErrorHandling {
         // Ensure connection to web socket
         this.connectToDeltaStream(args);
     }
+    getAbsoluteUrl = async (relativeUrl) => {
+        if (this.resolvedUrl === undefined) {
+            return undefined;
+        }
+        return this.urlResolver.getAbsoluteUrl(this.resolvedUrl, relativeUrl, (0, contracts_js_1.getPackageName)(this._loadedCodeDetails));
+    };
     async proposeCodeDetails(codeDetails) {
         if (!(0, internal_1.isFluidCodeDetails)(codeDetails)) {
             throw new Error("Provided codeDetails are not IFluidCodeDetails");
@@ -966,6 +998,10 @@ class Container extends internal_5.EventEmitterWithErrorHandling {
         }
         this._deltaManager.connect(args);
     }
+    metadataUpdateHandler = (metadata) => {
+        this._containerMetadata = { ...this._containerMetadata, ...metadata };
+        this.emit("metadataUpdate", metadata);
+    };
     /**
      * Creates a document service during container attachment or loading.
      * @param resolvedUrl - The resolved URL of the container.
@@ -1287,7 +1323,15 @@ class Container extends internal_5.EventEmitterWithErrorHandling {
     createDeltaManager() {
         const serviceProvider = () => this.service;
         const disableLoadConnectionRetries = this.mc.config.getBoolean("Fluid.Container.DisableLoadConnectionRetries") === true;
-        const deltaManager = new deltaManager_js_1.DeltaManager(serviceProvider, (0, internal_5.createChildLogger)({ logger: this.subLogger, namespace: "DeltaManager" }), () => this.activeConnection(), (props) => new connectionManager_js_1.ConnectionManager(serviceProvider, () => this.isDirty, this.client, this._canReconnect, (0, internal_5.createChildLogger)({ logger: this.subLogger, namespace: "ConnectionManager" }), props, disableLoadConnectionRetries ? 1 : undefined /* maxInitialConnectionAttempts */));
+        const deltaManager = (0, deltaManagerFactory_js_1.createDeltaManager)({
+            serviceProvider,
+            logger: this.subLogger,
+            active: () => this.activeConnection(),
+            containerDirty: () => this.isDirty,
+            client: this.client,
+            reconnectAllowed: this._canReconnect,
+            maxInitialConnectionAttempts: disableLoadConnectionRetries ? 1 : undefined,
+        });
         // Disable inbound queues as Container is not ready to accept any ops until we are fully loaded!
         // eslint-disable-next-line @typescript-eslint/no-floating-promises
         deltaManager.inbound.pause();
@@ -1611,6 +1655,13 @@ class Container extends internal_5.EventEmitterWithErrorHandling {
             throw error;
         }
     }
+    updateDirtyContainerState = (dirty) => {
+        if (this._dirtyContainer === dirty) {
+            return;
+        }
+        this._dirtyContainer = dirty;
+        this.emit(dirty ? dirtyContainerEvent : savedContainerEvent);
+    };
     /**
      * Send the connected status to the runtime.
      * @param readonly - Is the container in readonly mode?
@@ -1728,5 +1779,4 @@ exports.Container = Container;
 function asLegacyAlpha(base) {
     return base;
 }
-exports.asLegacyAlpha = asLegacyAlpha;
 //# sourceMappingURL=container.js.map