@signe/room 3.0.0 → 3.0.1

package/dist/index.d.ts

@@ -42,6 +42,21 @@ declare function RoomGuard(guards: RoomGuardFn[]): (target: any) => void;
  */
 declare function Guard(guards: GuardFn[]): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
 
+type StorageRestoreContext<TSnapshot = any> = {
+    snapshot: TSnapshot;
+    room: Room$1;
+    server: Server;
+    legacy: boolean;
+};
+type UserStorageRestoreContext<TUser = any, TSnapshot = any> = {
+    userSnapshot: TSnapshot;
+    user: TUser | undefined;
+    publicId: string;
+    usersPropName: string;
+    room: Room$1;
+    server: Server;
+    legacy: boolean;
+};
 type SessionData = {
     publicId: string;
     state?: any;
@@ -109,6 +124,11 @@ declare class Server implements Server$1 {
     private putStorageEntries;
     private deleteStorageKeys;
     private deleteStatePath;
+    private containsDeleteToken;
+    private compactStateStorage;
+    private createUserFromClassType;
+    private restoreUsersStorageSnapshot;
+    private restoreStorageSnapshot;
     private createStorageMetrics;
     private getTransferExpiryTime;
     private getPrivateId;
@@ -806,4 +826,4 @@ declare function createRequireSessionGuard(storage: Storage$1): (sender: Connect
  */
 declare const requireSession: (sender: Connection, value: any, room: Room$1) => Promise<boolean>;
 
-export { Action, ClientIo, Guard, MockConnection, Request, type RequestOptions, Room, RoomGuard, type RoomInterceptorPacket, type RoomMethods, type RoomOnJoin, type RoomOnLeave, type RoomOptions, Server, ServerIo, ServerResponse, Shard, type ShardOptions, UnhandledAction, WorldRoom, createRequireSessionGuard, request, requireSession, testRoom, tick };
+export { Action, ClientIo, Guard, MockConnection, Request, type RequestOptions, Room, RoomGuard, type RoomInterceptorPacket, type RoomMethods, type RoomOnJoin, type RoomOnLeave, type RoomOptions, Server, ServerIo, ServerResponse, Shard, type ShardOptions, type StorageRestoreContext, UnhandledAction, type UserStorageRestoreContext, WorldRoom, createRequireSessionGuard, request, requireSession, testRoom, tick };

package/dist/index.js

@@ -544,15 +544,114 @@ var Server = class {
     const descendantEntries = await this.listStorage(`${stateKey}.`);
     await this.deleteStorageKeys([
       ...Array.from(descendantEntries.keys()),
-      path
+      stateKey
     ]);
     await this.saveStatePath(path, DELETE_TOKEN);
   }
+  containsDeleteToken(value) {
+    if (value === DELETE_TOKEN) {
+      return true;
+    }
+    if (!value || typeof value !== "object") {
+      return false;
+    }
+    if (Array.isArray(value)) {
+      return value.some((item) => this.containsDeleteToken(item));
+    }
+    return Object.values(value).some((item) => this.containsDeleteToken(item));
+  }
+  async compactStateStorage(instance) {
+    const entries = await this.listStorage(STATE_PREFIX);
+    const keys = Array.from(entries.keys());
+    if (keys.length === 0) {
+      return;
+    }
+    const snapshot = createStatesSnapshotDeep(instance);
+    await this.deleteStorageKeys(keys);
+    await this.saveStatePath(".", snapshot);
+    const metrics = instance.$storageMetrics;
+    if (metrics) {
+      metrics.stateCompactions += 1;
+      metrics.stateCompactionDeletes += keys.length;
+    }
+  }
+  createUserFromClassType(classType, ...args) {
+    if (!classType) {
+      return void 0;
+    }
+    return isClass(classType) ? new classType() : classType(...args);
+  }
+  async restoreUsersStorageSnapshot(instance, snapshot, options) {
+    if (!snapshot || typeof snapshot !== "object" || Array.isArray(snapshot)) {
+      return snapshot;
+    }
+    const restoreUser = instance["onUserStorageRestore"];
+    if (typeof restoreUser !== "function") {
+      return snapshot;
+    }
+    const signal2 = this.getUsersProperty(instance);
+    const usersPropName = this.getUsersPropName(instance);
+    if (!signal2 || !usersPropName) {
+      return snapshot;
+    }
+    const usersSnapshot = snapshot[usersPropName];
+    if (!usersSnapshot || typeof usersSnapshot !== "object" || Array.isArray(usersSnapshot)) {
+      return snapshot;
+    }
+    const { classType } = signal2.options || {};
+    let nextSnapshot = snapshot;
+    let nextUsersSnapshot = usersSnapshot;
+    for (const [publicId, userSnapshot] of Object.entries(usersSnapshot)) {
+      const user = this.createUserFromClassType(classType, publicId);
+      const restoredUserSnapshot = await awaitReturn(
+        restoreUser.call(instance, {
+          userSnapshot,
+          user,
+          publicId,
+          usersPropName,
+          room: this.room,
+          server: this,
+          legacy: options.legacy
+        })
+      );
+      if (restoredUserSnapshot !== void 0 && restoredUserSnapshot !== userSnapshot) {
+        if (nextSnapshot === snapshot) {
+          nextSnapshot = { ...snapshot };
+        }
+        if (nextUsersSnapshot === usersSnapshot) {
+          nextUsersSnapshot = { ...usersSnapshot };
+          nextSnapshot[usersPropName] = nextUsersSnapshot;
+        }
+        nextUsersSnapshot[publicId] = restoredUserSnapshot;
+      }
+    }
+    return nextSnapshot;
+  }
+  async restoreStorageSnapshot(instance, snapshot, options) {
+    const restoreSnapshot = instance["onStorageRestore"];
+    let restoredSnapshot = snapshot;
+    if (typeof restoreSnapshot === "function") {
+      const result = await awaitReturn(
+        restoreSnapshot.call(instance, {
+          snapshot,
+          room: this.room,
+          server: this,
+          legacy: options.legacy
+        })
+      );
+      if (result !== void 0) {
+        restoredSnapshot = result;
+      }
+    }
+    return this.restoreUsersStorageSnapshot(instance, restoredSnapshot, options);
+  }
   createStorageMetrics() {
     return {
       loadMs: 0,
       loadStateKeys: 0,
       loadLegacyKeys: 0,
+      stateCompactions: 0,
+      stateCompactionDeletes: 0,
       persistFlushes: 0,
       persistWrites: 0,
       persistDeletes: 0,
@@ -868,14 +967,26 @@ var Server = class {
             migratedEntries.map(([path, value]) => [this.stateKey(path), value])
           )
         );
-        if (legacyRoot !== void 0) {
+        if (legacyDeleteKeys.length > 0) {
           await this.deleteStorageKeys(legacyDeleteKeys);
         }
-        load(instance, legacyObject, true);
+        const restoredLegacyObject = await this.restoreStorageSnapshot(instance, legacyObject, {
+          legacy: true
+        });
+        load(instance, restoredLegacyObject, true);
+        if (this.containsDeleteToken(restoredLegacyObject)) {
+          await this.compactStateStorage(instance);
+        }
         metrics.loadMs = Date.now() - startedAt;
         return;
       }
-      load(instance, tmpObject, true);
+      const restoredObject = await this.restoreStorageSnapshot(instance, tmpObject, {
+        legacy: false
+      });
+      load(instance, restoredObject, true);
+      if (this.containsDeleteToken(restoredObject)) {
+        await this.compactStateStorage(instance);
+      }
       metrics.loadMs = Date.now() - startedAt;
     };
     instance.$memoryAll = {};
@@ -996,17 +1107,15 @@ var Server = class {
       );
       values.clear();
     };
-    const persistCb = async (values) => {
-      if (initPersist) {
-        values.clear();
-        return;
-      }
+    const flushPersist = async (values) => {
       const startedAt = Date.now();
       const stateWrites = {};
       const deleteTasks = [];
+      let hasDeletes = false;
       for (let [path, value] of values) {
         const _instance = path == "." ? instance : getByPath(instance, path);
         if (value == DELETE_TOKEN) {
+          hasDeletes = true;
           deleteTasks.push(this.deleteStatePath(path));
         } else {
           const itemValue = _instance?.$snapshot ? createStatesSnapshot(_instance) : value;
@@ -1017,6 +1126,9 @@ var Server = class {
         this.putStorageEntries(stateWrites),
         ...deleteTasks
       ]);
+      if (hasDeletes) {
+        await this.compactStateStorage(instance);
+      }
       const metrics = instance.$storageMetrics;
       if (metrics) {
         metrics.persistFlushes += 1;
@@ -1024,7 +1136,20 @@ var Server = class {
         metrics.persistDeletes += deleteTasks.length;
         metrics.persistLastFlushMs = Date.now() - startedAt;
       }
+    };
+    let persistQueue = Promise.resolve();
+    const persistCb = async (values) => {
+      if (initPersist) {
+        values.clear();
+        return;
+      }
+      const valuesSnapshot = new Map(values);
       values.clear();
+      persistQueue = persistQueue.then(
+        () => flushPersist(valuesSnapshot),
+        () => flushPersist(valuesSnapshot)
+      );
+      await persistQueue;
     };
     const debouncePersist = (wait) => {
       let timeout = null;
@@ -1343,7 +1468,7 @@ var Server = class {
         if (transferData?.restored && signal2()[publicId]) {
           user = signal2()[publicId];
         } else {
-          user = isClass(classType) ? new classType() : classType(conn, ctx);
+          user = this.createUserFromClassType(classType, conn, ctx);
           signal2()[publicId] = user;
           const snapshot = createStatesSnapshotDeep(user);
           await this.saveStatePath(`${usersPropName}.${publicId}`, snapshot);
@@ -1775,7 +1900,7 @@ var Server = class {
         const usersPropName = this.getUsersPropName(subRoom);
         if (signal2 && usersPropName) {
           const { classType } = signal2.options;
-          const user = isClass(classType) ? new classType() : classType();
+          const user = this.createUserFromClassType(classType);
           const hydratedSnapshot = await awaitReturn(
             subRoom["onSessionRestore"]?.({
               userSnapshot,