@liveblocks/server 1.1.1-pnpmtest1 → 1.2.0

package/dist/index.cjs

@@ -1448,7 +1448,7 @@ var YjsStorage = class {
     let encodedTargetVector;
     try {
       encodedTargetVector = stateVector.length > 0 ? _jsbase64.Base64.toUint8Array(stateVector) : void 0;
-    } catch (e) {
+    } catch (e2) {
       logger.warn(
         "Could not get update from passed vector, returning all updates"
       );
@@ -1722,6 +1722,7 @@ var BrowserSession = class {
     // Metadata sent to client in ROOM_STATE message's "meta" field
     __privateAdd(this, __socket);
     __privateAdd(this, __debug);
+    /** Updated on every incoming message (including pings) via handleData(). Used for idle timeout detection. */
     __privateAdd(this, __lastActiveAt);
     // We keep a status in-memory in the session of whether we already sent a rejected ops message to the client.
     __privateAdd(this, __hasNotifiedClientStorageUpdateError);
@@ -1733,15 +1734,15 @@ var BrowserSession = class {
     this.publicMeta = ticket.publicMeta;
     __privateSet(this, __socket, socket);
     __privateSet(this, __debug, debug);
-    const now = _nullishCoalesce(createdAt, () => ( /* @__PURE__ */ new Date()));
+    const now = _nullishCoalesce(_optionalChain([createdAt, 'optionalAccess', _49 => _49.getTime, 'call', _50 => _50()]), () => ( Date.now()));
     this.createdAt = now;
     __privateSet(this, __lastActiveAt, now);
     __privateSet(this, __hasNotifiedClientStorageUpdateError, false);
   }
   get lastActiveAt() {
-    const lastPing = _optionalChain([__privateGet, 'call', _49 => _49(this, __socket), 'access', _50 => _50.getLastPongTimestamp, 'optionalCall', _51 => _51()]);
-    if (lastPing && lastPing > __privateGet(this, __lastActiveAt)) {
-      return lastPing;
+    const lastPing = _optionalChain([__privateGet, 'call', _51 => _51(this, __socket), 'access', _52 => _52.getLastPongTimestamp, 'optionalCall', _53 => _53()]);
+    if (lastPing && lastPing.getTime() > __privateGet(this, __lastActiveAt)) {
+      return lastPing.getTime();
     } else {
       return __privateGet(this, __lastActiveAt);
     }
@@ -1749,10 +1750,9 @@ var BrowserSession = class {
   get hasNotifiedClientStorageUpdateError() {
     return __privateGet(this, __hasNotifiedClientStorageUpdateError);
   }
-  markActive(now = /* @__PURE__ */ new Date()) {
-    if (now > __privateGet(this, __lastActiveAt)) {
-      __privateSet(this, __lastActiveAt, now);
-    }
+  /** @internal - This should have to be called only from Room, never externally */
+  markActive(now) {
+    __privateSet(this, __lastActiveAt, now ? now.getTime() : Date.now());
   }
   setHasNotifiedClientStorageUpdateError() {
     __privateSet(this, __hasNotifiedClientStorageUpdateError, true);
@@ -1824,6 +1824,15 @@ var Room = class {
     __publicField(this, "meta");
     __publicField(this, "driver");
     __publicField(this, "logger");
+    /**
+     * While a room is in "maintenance mode", all WebSocket connections to the
+     * room should be rejected until it's pulled out of maintenance mode again.
+     * Maintenance mode should only last a couple of milliseconds, typically.
+     *
+     * This mutex ensures that concurrent destructive operations (like
+     * init-storage, storage-reset, etc.) cannot interfere with one another.
+     */
+    __publicField(this, "_maintenanceMode", new (0, _asyncmutex.Mutex)());
     __publicField(this, "_loadData$", null);
     __publicField(this, "_data", null);
     __publicField(this, "_qsize", 0);
@@ -1831,28 +1840,28 @@ var Room = class {
     __publicField(this, "hooks");
     __privateAdd(this, __debug2);
     __privateAdd(this, __allowStreaming);
-    const driver = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _52 => _52.storage]), () => ( makeNewInMemoryDriver()));
+    const driver = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _54 => _54.storage]), () => ( makeNewInMemoryDriver()));
     this.meta = meta;
     this.driver = driver;
-    this.logger = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _53 => _53.logger]), () => ( BLACK_HOLE));
-    __privateSet(this, __allowStreaming, _nullishCoalesce(_optionalChain([options, 'optionalAccess', _54 => _54.allowStreaming]), () => ( true)));
+    this.logger = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _55 => _55.logger]), () => ( BLACK_HOLE));
+    __privateSet(this, __allowStreaming, _nullishCoalesce(_optionalChain([options, 'optionalAccess', _56 => _56.allowStreaming]), () => ( true)));
     this.hooks = {
-      isClientMsgAllowed: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _55 => _55.hooks, 'optionalAccess', _56 => _56.isClientMsgAllowed]), () => ( (() => {
+      isClientMsgAllowed: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _57 => _57.hooks, 'optionalAccess', _58 => _58.isClientMsgAllowed]), () => ( (() => {
         return {
           allowed: true
         };
       }))),
       // YYY .load() isn't called on the RoomServer yet! As soon as it does, these hooks will get called
-      onRoomWillLoad: _optionalChain([options, 'optionalAccess', _57 => _57.hooks, 'optionalAccess', _58 => _58.onRoomWillLoad]),
-      onRoomDidLoad: _optionalChain([options, 'optionalAccess', _59 => _59.hooks, 'optionalAccess', _60 => _60.onRoomDidLoad]),
-      onRoomWillUnload: _optionalChain([options, 'optionalAccess', _61 => _61.hooks, 'optionalAccess', _62 => _62.onRoomWillUnload]),
-      onRoomDidUnload: _optionalChain([options, 'optionalAccess', _63 => _63.hooks, 'optionalAccess', _64 => _64.onRoomDidUnload]),
-      onSessionDidStart: _optionalChain([options, 'optionalAccess', _65 => _65.hooks, 'optionalAccess', _66 => _66.onSessionDidStart]),
-      onSessionDidEnd: _optionalChain([options, 'optionalAccess', _67 => _67.hooks, 'optionalAccess', _68 => _68.onSessionDidEnd]),
-      postClientMsgStorageDidUpdate: _optionalChain([options, 'optionalAccess', _69 => _69.hooks, 'optionalAccess', _70 => _70.postClientMsgStorageDidUpdate]),
-      postClientMsgYdocDidUpdate: _optionalChain([options, 'optionalAccess', _71 => _71.hooks, 'optionalAccess', _72 => _72.postClientMsgYdocDidUpdate])
+      onRoomWillLoad: _optionalChain([options, 'optionalAccess', _59 => _59.hooks, 'optionalAccess', _60 => _60.onRoomWillLoad]),
+      onRoomDidLoad: _optionalChain([options, 'optionalAccess', _61 => _61.hooks, 'optionalAccess', _62 => _62.onRoomDidLoad]),
+      onRoomWillUnload: _optionalChain([options, 'optionalAccess', _63 => _63.hooks, 'optionalAccess', _64 => _64.onRoomWillUnload]),
+      onRoomDidUnload: _optionalChain([options, 'optionalAccess', _65 => _65.hooks, 'optionalAccess', _66 => _66.onRoomDidUnload]),
+      onSessionDidStart: _optionalChain([options, 'optionalAccess', _67 => _67.hooks, 'optionalAccess', _68 => _68.onSessionDidStart]),
+      onSessionDidEnd: _optionalChain([options, 'optionalAccess', _69 => _69.hooks, 'optionalAccess', _70 => _70.onSessionDidEnd]),
+      postClientMsgStorageDidUpdate: _optionalChain([options, 'optionalAccess', _71 => _71.hooks, 'optionalAccess', _72 => _72.postClientMsgStorageDidUpdate]),
+      postClientMsgYdocDidUpdate: _optionalChain([options, 'optionalAccess', _73 => _73.hooks, 'optionalAccess', _74 => _74.postClientMsgYdocDidUpdate])
     };
-    __privateSet(this, __debug2, _nullishCoalesce(_optionalChain([options, 'optionalAccess', _73 => _73.enableDebugLogging]), () => ( false)));
+    __privateSet(this, __debug2, _nullishCoalesce(_optionalChain([options, 'optionalAccess', _75 => _75.enableDebugLogging]), () => ( false)));
   }
   get loadingState() {
     if (this._loadData$ === null) {
@@ -1884,6 +1893,24 @@ var Room = class {
   }
   // prettier-ignore
   // ------------------------------------------------------------------------------------
+  // Maintenance mode
+  // ------------------------------------------------------------------------------------
+  /**
+   * Returns true if the room is currently in maintenance mode.
+   * When in maintenance mode, callers should refuse new WebSocket connections.
+   */
+  get isInMaintenance() {
+    return this._maintenanceMode.isLocked();
+  }
+  /**
+   * Tries to enter maintenance mode and run the given callback exclusively.
+   * If the room is already in maintenance mode, throws E_ALREADY_LOCKED
+   * immediately instead of queuing the request.
+   */
+  async runInMaintenanceMode(callback) {
+    return _asyncmutex.tryAcquire.call(void 0, this._maintenanceMode).runExclusive(callback);
+  }
+  // ------------------------------------------------------------------------------------
   // Public API
   // ------------------------------------------------------------------------------------
   /**
@@ -1908,13 +1935,13 @@ var Room = class {
    * room will be reloaded from storage.
    */
   unload(ctx) {
-    _optionalChain([this, 'access', _74 => _74.hooks, 'access', _75 => _75.onRoomWillUnload, 'optionalCall', _76 => _76(ctx)]);
+    _optionalChain([this, 'access', _76 => _76.hooks, 'access', _77 => _77.onRoomWillUnload, 'optionalCall', _78 => _78(ctx)]);
     if (this._data) {
       this.storage.unload();
       this.yjsStorage.unload();
     }
     this._loadData$ = null;
-    _optionalChain([this, 'access', _77 => _77.hooks, 'access', _78 => _78.onRoomDidUnload, 'optionalCall', _79 => _79(ctx)]);
+    _optionalChain([this, 'access', _79 => _79.hooks, 'access', _80 => _80.onRoomDidUnload, 'optionalCall', _81 => _81(ctx)]);
   }
   /**
    * Issues a Ticket with a new/unique actor ID
@@ -1928,17 +1955,17 @@ var Room = class {
    * unused Ticket will simply get garbage collected.
    */
   async createTicket(options) {
-    const actor$ = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _80 => _80.actor]), () => ( this.getNextActor()));
+    const actor$ = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _82 => _82.actor]), () => ( this.getNextActor()));
     const sessionKey = _nanoid.nanoid.call(void 0, );
-    const info = _optionalChain([options, 'optionalAccess', _81 => _81.info]);
+    const info = _optionalChain([options, 'optionalAccess', _83 => _83.info]);
     const ticket = {
-      version: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _82 => _82.version]), () => ( HIGHEST_PROTOCOL_VERSION)),
+      version: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _84 => _84.version]), () => ( HIGHEST_PROTOCOL_VERSION)),
       actor: await actor$,
       sessionKey,
-      meta: _optionalChain([options, 'optionalAccess', _83 => _83.meta]),
-      publicMeta: _optionalChain([options, 'optionalAccess', _84 => _84.publicMeta]),
-      user: _optionalChain([options, 'optionalAccess', _85 => _85.id]) ? { id: options.id, info } : { anonymousId: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _86 => _86.anonymousId]), () => ( _nanoid.nanoid.call(void 0, ))), info },
-      scopes: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _87 => _87.scopes]), () => ( ["room:write"]))
+      meta: _optionalChain([options, 'optionalAccess', _85 => _85.meta]),
+      publicMeta: _optionalChain([options, 'optionalAccess', _86 => _86.publicMeta]),
+      user: _optionalChain([options, 'optionalAccess', _87 => _87.id]) ? { id: options.id, info } : { anonymousId: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _88 => _88.anonymousId]), () => ( _nanoid.nanoid.call(void 0, ))), info },
+      scopes: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _89 => _89.scopes]), () => ( ["room:write"]))
     };
     if (__privateGet(this, __debug2)) {
       console.log(`new ticket created: ${JSON.stringify(ticket)}`);
@@ -2072,7 +2099,7 @@ var Room = class {
       ctx,
       defer
     );
-    const p$ = _optionalChain([this, 'access', _88 => _88.hooks, 'access', _89 => _89.onSessionDidStart, 'optionalCall', _90 => _90(newSession, ctx)]);
+    const p$ = _optionalChain([this, 'access', _90 => _90.hooks, 'access', _91 => _91.onSessionDidStart, 'optionalCall', _92 => _92(newSession, ctx)]);
     if (p$) defer(p$);
   }
   /**
@@ -2096,7 +2123,7 @@ var Room = class {
       for (const other of this.otherSessions(key)) {
         other.send({ type: _core.ServerMsgCode.USER_LEFT, actor: session.actor });
       }
-      const p$ = _optionalChain([this, 'access', _91 => _91.hooks, 'access', _92 => _92.onSessionDidEnd, 'optionalCall', _93 => _93(session, ctx)]);
+      const p$ = _optionalChain([this, 'access', _93 => _93.hooks, 'access', _94 => _94.onSessionDidEnd, 'optionalCall', _95 => _95(session, ctx)]);
       if (p$) defer(p$);
     }
   }
@@ -2127,6 +2154,7 @@ var Room = class {
     );
   }) {
     const text = typeof data === "string" ? data : _core.raise.call(void 0, "Unsupported message format");
+    _optionalChain([this, 'access', _96 => _96.sessions, 'access', _97 => _97.get, 'call', _98 => _98(key), 'optionalAccess', _99 => _99.markActive, 'call', _100 => _100()]);
     if (text === "ping") {
       await this.handlePing(key, ctx);
     } else {
@@ -2400,7 +2428,7 @@ var Room = class {
   }
   // Don't ever manually call this!
   async _load(ctx) {
-    await _optionalChain([this, 'access', _94 => _94.hooks, 'access', _95 => _95.onRoomWillLoad, 'optionalCall', _96 => _96(ctx)]);
+    await _optionalChain([this, 'access', _101 => _101.hooks, 'access', _102 => _102.onRoomWillLoad, 'optionalCall', _103 => _103(ctx)]);
     const storage = await this._loadStorage();
     const yjsStorage = await this._loadYjsStorage();
     this._data = {
@@ -2408,7 +2436,7 @@ var Room = class {
       storage,
       yjsStorage
     };
-    await _optionalChain([this, 'access', _97 => _97.hooks, 'access', _98 => _98.onRoomDidLoad, 'optionalCall', _99 => _99(ctx)]);
+    await _optionalChain([this, 'access', _104 => _104.hooks, 'access', _105 => _105.onRoomDidLoad, 'optionalCall', _106 => _106(ctx)]);
   }
   /**
    * Returns a new, unique, actor ID.
@@ -2449,7 +2477,7 @@ var Room = class {
     }
     const sent = session.sendPong();
     if (sent !== 0) {
-      await _optionalChain([this, 'access', _100 => _100.hooks, 'access', _101 => _101.onDidPong, 'optionalCall', _102 => _102(ctx)]);
+      await _optionalChain([this, 'access', _107 => _107.hooks, 'access', _108 => _108.onDidPong, 'optionalCall', _109 => _109(ctx)]);
     }
   }
   async _processClientMsg_withExclusiveAccess(sessionKey, messages, ctx, defer) {
@@ -2588,7 +2616,7 @@ var Room = class {
         break;
       }
       case _core.ClientMsgCode.UPDATE_STORAGE: {
-        _optionalChain([this, 'access', _103 => _103.driver, 'access', _104 => _104.bump_storage_version, 'optionalCall', _105 => _105()]);
+        _optionalChain([this, 'access', _110 => _110.driver, 'access', _111 => _111.bump_storage_version, 'optionalCall', _112 => _112()]);
         const result = await this.storage.applyOps(msg.ops);
         const opsToForward = result.flatMap(
           (r) => r.action === "accepted" ? [r.op] : []
@@ -2620,7 +2648,7 @@ var Room = class {
           });
         }
         if (opsToForward.length > 0) {
-          const p$ = _optionalChain([this, 'access', _106 => _106.hooks, 'access', _107 => _107.postClientMsgStorageDidUpdate, 'optionalCall', _108 => _108(ctx)]);
+          const p$ = _optionalChain([this, 'access', _113 => _113.hooks, 'access', _114 => _114.postClientMsgStorageDidUpdate, 'optionalCall', _115 => _115(ctx)]);
           if (p$) defer(p$);
         }
         break;
@@ -2671,7 +2699,7 @@ var Room = class {
           defer
         );
         if (result.isUpdated) {
-          const p$ = _optionalChain([this, 'access', _109 => _109.hooks, 'access', _110 => _110.postClientMsgYdocDidUpdate, 'optionalCall', _111 => _111(ctx, session)]);
+          const p$ = _optionalChain([this, 'access', _116 => _116.hooks, 'access', _117 => _117.postClientMsgYdocDidUpdate, 'optionalCall', _118 => _118(ctx, session)]);
           if (p$) defer(p$);
         }
         break;
@@ -2679,7 +2707,7 @@ var Room = class {
       default: {
         try {
           return _core.assertNever.call(void 0, msg, "Unrecognized client msg");
-        } catch (e2) {
+        } catch (e3) {
         }
       }
     }