Add type annotations to PendingEventStore

src/matrix/storage/idb/stores/PendingEventStore.ts

@@ -16,23 +16,39 @@ limitations under the License.
 
 import { encodeUint32, decodeUint32 } from "../utils";
 import {KeyLimits} from "../../common";
+import {Store} from "../Store"
 
-function encodeKey(roomId, queueIndex) {
+interface PendingEntry {
+    roomId: string
+    queueIndex: number
+    eventType: string
+    content: any
+    relatexTxnId: string | null
+    relatedEventId: string | null
+    txnId?: string
+    needsEncryption: boolean
+    needsUpload: boolean
+    key: string
+}
+
+function encodeKey(roomId: string, queueIndex: number): string {
     return `${roomId}|${encodeUint32(queueIndex)}`;
 }
 
-function decodeKey(key) {
+function decodeKey(key: string): { roomId: string, queueIndex: number } {
     const [roomId, encodedQueueIndex] = key.split("|");
     const queueIndex = decodeUint32(encodedQueueIndex);
     return {roomId, queueIndex};
 }
 
 export class PendingEventStore {
-    constructor(eventStore) {
+    private _eventStore: Store<PendingEntry>
+
+    constructor(eventStore: Store<PendingEntry>) {
         this._eventStore = eventStore;
     }
 
-    async getMaxQueueIndex(roomId) {
+    async getMaxQueueIndex(roomId: string): Promise<number | undefined> {
         const range = this._eventStore.IDBKeyRange.bound(
             encodeKey(roomId, KeyLimits.minStorageKey),
             encodeKey(roomId, KeyLimits.maxStorageKey),
@@ -41,38 +57,38 @@ export class PendingEventStore {
         );
         const maxKey = await this._eventStore.findMaxKey(range);
         if (maxKey) {
-            return decodeKey(maxKey).queueIndex;
+            return decodeKey(maxKey as string).queueIndex;
         }
     }
 
-    remove(roomId, queueIndex) {
+    remove(roomId: string, queueIndex: number): Promise<undefined> {
         const keyRange = this._eventStore.IDBKeyRange.only(encodeKey(roomId, queueIndex));
-        this._eventStore.delete(keyRange);
+        return this._eventStore.delete(keyRange);
     }
 
-    async exists(roomId, queueIndex) {
+    async exists(roomId: string, queueIndex: number): Promise<boolean> {
         const keyRange = this._eventStore.IDBKeyRange.only(encodeKey(roomId, queueIndex));
         const key = await this._eventStore.getKey(keyRange);
         return !!key;
     }
     
-    add(pendingEvent) {
+    add(pendingEvent: PendingEntry): Promise<IDBValidKey> {
         pendingEvent.key = encodeKey(pendingEvent.roomId, pendingEvent.queueIndex);
-        this._eventStore.add(pendingEvent);
+        return this._eventStore.add(pendingEvent);
     }
 
-    update(pendingEvent) {
+    update(pendingEvent: PendingEntry): Promise<IDBValidKey> {
-        this._eventStore.put(pendingEvent);
+        return this._eventStore.put(pendingEvent);
     }
 
-    getAll() {
+    getAll(): Promise<PendingEntry[]> {
         return this._eventStore.selectAll();
     }
 
-    removeAllForRoom(roomId) {
+    removeAllForRoom(roomId: string): Promise<undefined> {
         const minKey = encodeKey(roomId, KeyLimits.minStorageKey);
         const maxKey = encodeKey(roomId, KeyLimits.maxStorageKey);
         const range = this._eventStore.IDBKeyRange.bound(minKey, maxKey);
-        this._eventStore.delete(range);
+        return this._eventStore.delete(range);
     }
 }