Migrate DeviceIdentityStore to TypeScript

src/matrix/storage/idb/Transaction.js

@@ -27,7 +27,7 @@ import {RoomMemberStore} from "./stores/RoomMemberStore";
 import {TimelineFragmentStore} from "./stores/TimelineFragmentStore";
 import {PendingEventStore} from "./stores/PendingEventStore";
 import {UserIdentityStore} from "./stores/UserIdentityStore";
-import {DeviceIdentityStore} from "./stores/DeviceIdentityStore.js";
+import {DeviceIdentityStore} from "./stores/DeviceIdentityStore";
 import {OlmSessionStore} from "./stores/OlmSessionStore.js";
 import {InboundGroupSessionStore} from "./stores/InboundGroupSessionStore.js";
 import {OutboundGroupSessionStore} from "./stores/OutboundGroupSessionStore";

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

@@ -15,33 +15,46 @@ limitations under the License.
 */
 
 import {MAX_UNICODE, MIN_UNICODE} from "./common";
+import {Store} from "../Store";
 
-function encodeKey(userId, deviceId) {
+interface DeviceIdentity {
+    userId: string;
+    deviceId: string;
+    ed25519Key: string;
+    curve25519Key: string;
+    algorithms: string[];
+    displayName: string;
+    key: string;
+}
+
+function encodeKey(userId: string, deviceId: string): string {
     return `${userId}|${deviceId}`;
 }
 
-function decodeKey(key) {
+function decodeKey(key: string): { userId: string, deviceId: string } {
     const [userId, deviceId] = key.split("|");
     return {userId, deviceId};
 }
 
 export class DeviceIdentityStore {
-    constructor(store) {
+    private _store: Store<DeviceIdentity>;
+    
+    constructor(store: Store<DeviceIdentity>) {
         this._store = store;
     }
 
-    getAllForUserId(userId) {
+    getAllForUserId(userId: string): Promise<DeviceIdentity[]> {
         const range = this._store.IDBKeyRange.lowerBound(encodeKey(userId, ""));
         return this._store.selectWhile(range, device => {
             return device.userId === userId;
         });
     }
 
-    async getAllDeviceIds(userId) {
-        const deviceIds = [];
+    async getAllDeviceIds(userId: string): Promise<string[]> {
+        const deviceIds: string[] = [];
         const range = this._store.IDBKeyRange.lowerBound(encodeKey(userId, ""));
         await this._store.iterateKeys(range, key => {
-            const decodedKey = decodeKey(key);
+            const decodedKey = decodeKey(key as string);
             // prevent running into the next room
             if (decodedKey.userId === userId) {
                 deviceIds.push(decodedKey.deviceId);
@@ -52,27 +65,27 @@ export class DeviceIdentityStore {
         return deviceIds;
     }
 
-    get(userId, deviceId) {
+    get(userId: string, deviceId: string): Promise<DeviceIdentity | null> {
         return this._store.get(encodeKey(userId, deviceId));
     }
 
-    set(deviceIdentity) {
+    set(deviceIdentity: DeviceIdentity): Promise<IDBValidKey> {
         deviceIdentity.key = encodeKey(deviceIdentity.userId, deviceIdentity.deviceId);
-        this._store.put(deviceIdentity);
+        return this._store.put(deviceIdentity);
     }
 
-    getByCurve25519Key(curve25519Key) {
+    getByCurve25519Key(curve25519Key: string): Promise<DeviceIdentity | null> {
         return this._store.index("byCurve25519Key").get(curve25519Key);
     }
 
-    remove(userId, deviceId) {
-        this._store.delete(encodeKey(userId, deviceId));
+    remove(userId: string, deviceId: string): Promise<undefined> {
+        return this._store.delete(encodeKey(userId, deviceId));
     }
 
-    removeAllForUser(userId) {
+    removeAllForUser(userId: string): Promise<undefined> {
         // exclude both keys as they are theoretical min and max,
         // but we should't have a match for just the room id, or room id with max
         const range = this._store.IDBKeyRange.bound(encodeKey(userId, MIN_UNICODE), encodeKey(userId, MAX_UNICODE), true, true);
-        this._store.delete(range);
+        return this._store.delete(range);
     }
 }