matrix-js-sdk 41.7.0 → 41.8.0

package/src/store/indexeddb-remote-backend.ts

@@ -29,7 +29,7 @@ export class RemoteIndexedDBStoreBackend implements IIndexedDBBackend {
     private inFlight: Record<number, PromiseWithResolvers<any>> = {}; // seq: promise
     // Once we start connecting, we keep the promise and re-use it
     // if we try to connect again
-    private startPromise?: Promise<void>;
+    private startPromiseResolvers?: PromiseWithResolvers<void>;
     // Callback for when the IndexedDB gets closed unexpectedly
     private onClose?(): void;
 
@@ -158,17 +158,31 @@ export class RemoteIndexedDBStoreBackend implements IIndexedDBBackend {
         await this.doCmd("removeUserProfiles", [userIds]);
     }
 
+    public async removeEventsFromRoom(roomId: string, eventIds: string[]): Promise<void> {
+        await this.doCmd("removeEventsFromRoom", [roomId, eventIds]);
+    }
+
     private ensureStarted(): Promise<void> {
-        if (!this.startPromise) {
-            this.worker = this.workerFactory();
+        if (!this.startPromiseResolvers) {
+            this.startPromiseResolvers = Promise.withResolvers();
+
+            try {
+                this.worker = this.workerFactory();
+            } catch (e) {
+                logger.error("IndexedDB worker failed to start", e);
+                this.startPromiseResolvers.reject(new Error("IndexedDB worker failed to start"));
+                return this.startPromiseResolvers.promise;
+            }
             this.worker.onmessage = this.onWorkerMessage;
+            this.worker.onerror = this.onWorkerError;
 
             // tell the worker the db name.
-            this.startPromise = this.doCmd("setupWorker", [this.dbName]).then(() => {
+            this.doCmd("setupWorker", [this.dbName]).then(() => {
                 logger.log("IndexedDB worker is ready");
+                this.startPromiseResolvers?.resolve();
             });
         }
-        return this.startPromise;
+        return this.startPromiseResolvers.promise;
     }
 
     private doCmd<T>(command: string, args?: any): Promise<T> {
@@ -186,6 +200,11 @@ export class RemoteIndexedDBStoreBackend implements IIndexedDBBackend {
         });
     }
 
+    private onWorkerError = (ev: ErrorEvent): void => {
+        logger.error("IndexedDB worker failed to connect", ev);
+        this.startPromiseResolvers?.reject(ev.message ?? new Error("IndexedDB worker failed to connect"));
+    };
+
     private onWorkerMessage = (ev: MessageEvent): void => {
         const msg = ev.data;
 

package/src/store/indexeddb.ts

@@ -64,11 +64,7 @@ export class IndexedDBStore extends MemoryStore {
         return LocalIndexedDBStoreBackend.exists(indexedDB, dbName);
     }
 
-    /**
-     * The backend instance.
-     * Call through to this API if you need to perform specific indexeddb actions like deleting the database.
-     */
-    public readonly backend: IIndexedDBBackend;
+    public _backend: IIndexedDBBackend;
 
     private startedUp = false;
     private syncTs = 0;
@@ -105,7 +101,7 @@ export class IndexedDBStore extends MemoryStore {
      *
      * @param opts - Options object.
      */
-    public constructor(opts: IOpts) {
+    public constructor(private readonly opts: IOpts) {
         super(opts);
 
         if (!opts.indexedDB) {
@@ -113,12 +109,20 @@ export class IndexedDBStore extends MemoryStore {
         }
 
         if (opts.workerFactory) {
-            this.backend = new RemoteIndexedDBStoreBackend(opts.workerFactory, opts.dbName);
+            this._backend = new RemoteIndexedDBStoreBackend(opts.workerFactory, opts.dbName);
         } else {
-            this.backend = new LocalIndexedDBStoreBackend(opts.indexedDB, opts.dbName);
+            this._backend = new LocalIndexedDBStoreBackend(opts.indexedDB, opts.dbName);
         }
     }
 
+    /**
+     * The backend instance.
+     * Call through to this API if you need to perform specific indexeddb actions like deleting the database.
+     */
+    public get backend(): IIndexedDBBackend {
+        return this._backend;
+    }
+
     /** Re-exports `TypedEventEmitter.on` */
     public on(event: EventEmitterEvents | "degraded" | "closed", handler: (...args: any[]) => void): void {
         this.emitter.on(event, handler);
@@ -136,6 +140,14 @@ export class IndexedDBStore extends MemoryStore {
         logger.log(`IndexedDBStore.startup: connecting to backend`);
         return this.backend
             .connect(this.onClose)
+            .catch((e) => {
+                if (this.opts.workerFactory) {
+                    logger.log("Falling back to local indexeddb backend");
+                    this._backend = new LocalIndexedDBStoreBackend(this.opts.indexedDB!, this.opts.dbName);
+                    return this.backend.connect(this.onClose);
+                }
+                throw e;
+            })
             .then(() => {
                 logger.log(`IndexedDBStore.startup: loading presence events`);
                 return this.backend.getUserPresenceEvents();

package/src/store/memory.ts

@@ -455,6 +455,10 @@ export class MemoryStore implements IStore {
         userIds.forEach((userId) => this.userProfiles.delete(userId));
     }
 
+    public async removeEventsFromRoom(roomId: string, eventIds: string[]): Promise<void> {
+        // Can ignore as there is no backing store.
+    }
+
     public async destroy(): Promise<void> {
         // Nothing to do
     }

package/src/store/stub.ts

@@ -289,4 +289,7 @@ export class StubStore implements IStore {
     public async destroy(): Promise<void> {
         // Nothing to do
     }
+    public async removeEventsFromRoom(roomId: string, eventIds: string[]): Promise<void> {
+        // Nothing to do
+    }
 }

package/src/sync-accumulator.ts

@@ -781,6 +781,15 @@ export class SyncAccumulator {
     public getNextBatchToken(): string {
         return this.nextBatch!;
     }
+
+    public removeEventsFromRoom(roomId: string, eventIds: string[]): void {
+        this.joinRooms[roomId]._timeline = this.joinRooms[roomId]._timeline.filter(
+            (ev) => !eventIds.includes(ev.event.event_id),
+        );
+        this.joinRooms[roomId]._stickyEvents = this.joinRooms[roomId]._stickyEvents.filter(
+            (ev) => !eventIds.includes(ev.event.event_id),
+        );
+    }
 }
 
 function setState(eventMap: Record<string, Record<string, IStateEvent>>, event: IRoomEvent | IStateEvent): void {