@vex-chat/libvex 0.27.1 → 1.0.0-rc.1

package/dist/Storage.js

@@ -1,47 +1,38 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Storage = void 0;
-const sleep_1 = require("@extrahash/sleep");
-const crypto_1 = require("@vex-chat/crypto");
-const events_1 = require("events");
-const knex_1 = __importDefault(require("knex"));
-const parse_duration_1 = __importDefault(require("parse-duration"));
-const tweetnacl_1 = __importDefault(require("tweetnacl"));
-const createLogger_1 = require("./utils/createLogger");
-const sqlSessionToCrypto_1 = require("./utils/sqlSessionToCrypto");
+import { sleep } from "@extrahash/sleep";
+import { XKeyConvert, XUtils } from "@vex-chat/crypto";
+import { EventEmitter } from "events";
+import knex, {} from "knex";
+import parseDuration from "parse-duration";
+import nacl from "tweetnacl";
+import winston from "winston";
+import { createLogger } from "./utils/createLogger.js";
+import { sqlSessionToCrypto } from "./utils/sqlSessionToCrypto.js";
 /**
  * The default IStorage() implementation, using knex and sqlite3 driver
  *
  * @hidden
  */
-class Storage extends events_1.EventEmitter {
+export class Storage extends EventEmitter {
+    ready = false;
+    closing = false;
+    dbPath;
+    db;
+    log;
+    idKeys;
+    saveHistory;
     constructor(dbPath, SK, options) {
         super();
-        this.ready = false;
-        this.closing = false;
-        this.log = createLogger_1.createLogger("db", (options === null || options === void 0 ? void 0 : options.dbLogLevel) || (options === null || options === void 0 ? void 0 : options.logLevel));
-        const idKeys = crypto_1.XKeyConvert.convertKeyPair(tweetnacl_1.default.sign.keyPair.fromSecretKey(crypto_1.XUtils.decodeHex(SK)));
+        this.log = createLogger("db", options?.dbLogLevel || options?.logLevel);
+        const idKeys = XKeyConvert.convertKeyPair(nacl.sign.keyPair.fromSecretKey(XUtils.decodeHex(SK)));
         if (!idKeys) {
             throw new Error("Can't convert SK!");
         }
-        this.saveHistory = (options === null || options === void 0 ? void 0 : options.saveHistory) || true;
+        this.saveHistory = options?.saveHistory || true;
         this.idKeys = idKeys;
         this.dbPath = dbPath;
         this.log.info("Opening database file at " + this.dbPath);
-        this.db = knex_1.default({
-            client: "sqlite3",
+        this.db = knex({
+            client: "better-sqlite3",
             connection: {
                 filename: this.dbPath,
             },
@@ -49,461 +40,416 @@ class Storage extends events_1.EventEmitter {
         });
         this.init();
     }
-    close() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.closing = true;
-            this.log.info("Closing database.");
-            yield this.db.destroy();
-        });
+    async close() {
+        this.closing = true;
+        this.log.info("Closing database.");
+        await this.db.destroy();
     }
-    saveMessage(message) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.saveHistory) {
-                return;
-            }
-            if (this.closing) {
-                this.log.warn("Database is closing, saveMessage() will not complete.");
-                return;
-            }
-            const copy = Object.assign({}, message);
-            // encrypt plaintext with our idkey before it gets saved to disk
-            copy.message = crypto_1.XUtils.encodeHex(tweetnacl_1.default.secretbox(crypto_1.XUtils.decodeUTF8(message.message), crypto_1.XUtils.decodeHex(message.nonce), this.idKeys.secretKey));
-            try {
-                yield this.db("messages").insert(copy);
-            }
-            catch (err) {
-                if (err.errno !== 19) {
-                    throw err;
-                }
-                this.log.warn("Attempted to insert duplicate nonce into message table.");
+    async saveMessage(message) {
+        if (!this.saveHistory) {
+            return;
+        }
+        if (this.closing) {
+            this.log.warn("Database is closing, saveMessage() will not complete.");
+            return;
+        }
+        const copy = { ...message };
+        // encrypt plaintext with our idkey before it gets saved to disk
+        copy.message = XUtils.encodeHex(nacl.secretbox(XUtils.decodeUTF8(message.message), XUtils.decodeHex(message.nonce), this.idKeys.secretKey));
+        try {
+            await this.db("messages").insert(copy);
+        }
+        catch (err) {
+            if (err.errno !== 19) {
+                throw err;
             }
-        });
+            this.log.warn("Attempted to insert duplicate nonce into message table.");
+        }
     }
-    deleteMessage(mailID) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.closing) {
-                this.log.warn("Database is closing, saveMessage() will not complete.");
-                return;
-            }
-            yield this.db
-                .from("messages")
-                .where({ mailID })
-                .del();
-        });
+    async deleteMessage(mailID) {
+        if (this.closing) {
+            this.log.warn("Database is closing, saveMessage() will not complete.");
+            return;
+        }
+        await this.db
+            .from("messages")
+            .where({ mailID })
+            .del();
     }
-    markSessionVerified(sessionID, status = true) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.closing) {
-                this.log.warn("Database is closing, markSessionVerified() will not complete.");
-                return;
-            }
-            yield this.db("sessions")
-                .where({ sessionID })
-                .update({ verified: status });
-        });
+    async markSessionVerified(sessionID, status = true) {
+        if (this.closing) {
+            this.log.warn("Database is closing, markSessionVerified() will not complete.");
+            return;
+        }
+        await this.db("sessions")
+            .where({ sessionID })
+            .update({ verified: status });
     }
-    getMessageHistory(userID) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.closing) {
-                this.log.warn("Database is closing, getMessageHistory() will not complete.");
-                return [];
-            }
-            const messages = yield this.db("messages")
-                .select()
-                .where({ direction: "incoming", authorID: userID, group: null })
-                .orWhere({ direction: "outgoing", readerID: userID, group: null })
-                .orderBy("timestamp", "desc");
-            const fixedMessages = messages.reverse().map((message) => {
-                // some cleanup because of how knex serializes the data
-                message.timestamp = new Date(message.timestamp);
-                // decrypt
-                message.decrypted = Boolean(message.decrypted);
-                if (message.decrypted) {
-                    const localDecrypt = tweetnacl_1.default.secretbox.open(crypto_1.XUtils.decodeHex(message.message), crypto_1.XUtils.decodeHex(message.nonce), this.idKeys.secretKey);
-                    if (localDecrypt) {
-                        message.message = crypto_1.XUtils.encodeUTF8(localDecrypt);
-                    }
-                    else {
-                        throw new Error("Couldn't decrypt messages on disk!");
-                    }
+    async getMessageHistory(userID) {
+        if (this.closing) {
+            this.log.warn("Database is closing, getMessageHistory() will not complete.");
+            return [];
+        }
+        const messages = await this.db("messages")
+            .select()
+            .where({ direction: "incoming", authorID: userID, group: null })
+            .orWhere({ direction: "outgoing", readerID: userID, group: null })
+            .orderBy("timestamp", "desc");
+        const fixedMessages = messages.reverse().map((message) => {
+            // some cleanup because of how knex serializes the data
+            message.timestamp = new Date(message.timestamp);
+            // decrypt
+            message.decrypted = Boolean(message.decrypted);
+            if (message.decrypted) {
+                const localDecrypt = nacl.secretbox.open(XUtils.decodeHex(message.message), XUtils.decodeHex(message.nonce), this.idKeys.secretKey);
+                if (localDecrypt) {
+                    message.message = XUtils.encodeUTF8(localDecrypt);
                 }
-                return message;
-            });
-            this.log.debug("getMessageHistory() => " + JSON.stringify(fixedMessages, null, 4));
-            return fixedMessages;
+                else {
+                    throw new Error("Couldn't decrypt messages on disk!");
+                }
+            }
+            return message;
         });
+        this.log.debug("getMessageHistory() => " + JSON.stringify(fixedMessages, null, 4));
+        return fixedMessages;
     }
-    getGroupHistory(channelID) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.closing) {
-                this.log.warn("Database is closing, getGroupHistory() will not complete.");
-                return [];
-            }
-            const messages = yield this.db("messages")
-                .select()
-                .where({ group: channelID })
-                .orderBy("timestamp", "desc");
-            const fixedMessages = messages.reverse().map((message) => {
-                // some cleanup because of how knex serializes the data
-                message.timestamp = new Date(message.timestamp);
-                // decrypt
-                message.decrypted = Boolean(message.decrypted);
-                if (message.decrypted) {
-                    const localDecrypt = tweetnacl_1.default.secretbox.open(crypto_1.XUtils.decodeHex(message.message), crypto_1.XUtils.decodeHex(message.nonce), this.idKeys.secretKey);
-                    if (localDecrypt) {
-                        message.message = crypto_1.XUtils.encodeUTF8(localDecrypt);
-                    }
-                    else {
-                        throw new Error("Couldn't decrypt messages on disk!");
-                    }
+    async getGroupHistory(channelID) {
+        if (this.closing) {
+            this.log.warn("Database is closing, getGroupHistory() will not complete.");
+            return [];
+        }
+        const messages = await this.db("messages")
+            .select()
+            .where({ group: channelID })
+            .orderBy("timestamp", "desc");
+        const fixedMessages = messages.reverse().map((message) => {
+            // some cleanup because of how knex serializes the data
+            message.timestamp = new Date(message.timestamp);
+            // decrypt
+            message.decrypted = Boolean(message.decrypted);
+            if (message.decrypted) {
+                const localDecrypt = nacl.secretbox.open(XUtils.decodeHex(message.message), XUtils.decodeHex(message.nonce), this.idKeys.secretKey);
+                if (localDecrypt) {
+                    message.message = XUtils.encodeUTF8(localDecrypt);
                 }
-                return message;
-            });
-            this.log.debug("getGroupHistory() => " + JSON.stringify(fixedMessages, null, 4));
-            return fixedMessages;
+                else {
+                    throw new Error("Couldn't decrypt messages on disk!");
+                }
+            }
+            return message;
         });
+        this.log.debug("getGroupHistory() => " + JSON.stringify(fixedMessages, null, 4));
+        return fixedMessages;
     }
-    savePreKeys(preKeys, oneTime) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const addedIndexes = [];
-            yield this.untilReady();
-            if (this.closing) {
-                this.log.warn("Database is closing, savePreKeys() will not complete.");
-                return [];
-            }
-            for (const preKey of preKeys) {
-                const index = yield this.db(oneTime ? "oneTimeKeys" : "preKeys").insert({
-                    privateKey: crypto_1.XUtils.encodeHex(preKey.keyPair.secretKey),
-                    publicKey: crypto_1.XUtils.encodeHex(preKey.keyPair.publicKey),
-                    signature: crypto_1.XUtils.encodeHex(preKey.signature),
-                });
-                addedIndexes.push(index[0]);
-            }
-            const addedKeys = (yield this.db
-                .from(oneTime ? "oneTimeKeys" : "preKeys")
-                .select()
-                .whereIn("index", addedIndexes)).map((key) => {
-                delete key.privateKey;
-                return key;
+    async savePreKeys(preKeys, oneTime) {
+        const addedIndexes = [];
+        await this.untilReady();
+        if (this.closing) {
+            this.log.warn("Database is closing, savePreKeys() will not complete.");
+            return [];
+        }
+        for (const preKey of preKeys) {
+            const index = await this.db(oneTime ? "oneTimeKeys" : "preKeys").insert({
+                privateKey: XUtils.encodeHex(preKey.keyPair.secretKey),
+                publicKey: XUtils.encodeHex(preKey.keyPair.publicKey),
+                signature: XUtils.encodeHex(preKey.signature),
             });
-            this.log.silly("savePreKeys() => " + JSON.stringify(addedKeys, null, 4));
-            return addedKeys;
+            addedIndexes.push(index[0]);
+        }
+        const addedKeys = (await this.db
+            .from(oneTime ? "oneTimeKeys" : "preKeys")
+            .select()
+            .whereIn("index", addedIndexes)).map((key) => {
+            delete key.privateKey;
+            return key;
         });
+        this.log.silly("savePreKeys() => " + JSON.stringify(addedKeys, null, 4));
+        return addedKeys;
     }
-    getSessionByPublicKey(publicKey) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.closing) {
-                this.log.warn("Database is closing, getGroupHistory() will not complete.");
-                return null;
-            }
-            const str = crypto_1.XUtils.encodeHex(publicKey);
-            const rows = yield this.db
-                .from("sessions")
-                .select()
-                .where({ publicKey: str })
-                .limit(1);
-            if (rows.length === 0) {
-                this.log.warn(`getSessionByPublicKey(${crypto_1.XUtils.encodeHex(publicKey)}) => ` +
-                    JSON.stringify(null, null, 4));
-                return null;
-            }
-            const [session] = rows;
-            const wsSession = sqlSessionToCrypto_1.sqlSessionToCrypto(session);
-            this.log.debug("getSessionByPublicKey() => " + JSON.stringify(wsSession, null, 4));
-            return wsSession;
-        });
+    async getSessionByPublicKey(publicKey) {
+        if (this.closing) {
+            this.log.warn("Database is closing, getGroupHistory() will not complete.");
+            return null;
+        }
+        const str = XUtils.encodeHex(publicKey);
+        const rows = await this.db
+            .from("sessions")
+            .select()
+            .where({ publicKey: str })
+            .limit(1);
+        if (rows.length === 0) {
+            this.log.warn(`getSessionByPublicKey(${XUtils.encodeHex(publicKey)}) => ` +
+                JSON.stringify(null, null, 4));
+            return null;
+        }
+        const [session] = rows;
+        const wsSession = sqlSessionToCrypto(session);
+        this.log.debug("getSessionByPublicKey() => " + JSON.stringify(wsSession, null, 4));
+        return wsSession;
     }
-    markSessionUsed(sessionID) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.closing) {
-                this.log.warn("Database is closing, markSessionUsed() will not complete.");
-                return;
-            }
-            yield this.db
-                .from("sessions")
-                .update({ lastUsed: new Date(Date.now()) })
-                .where({ sessionID });
-        });
+    async markSessionUsed(sessionID) {
+        if (this.closing) {
+            this.log.warn("Database is closing, markSessionUsed() will not complete.");
+            return;
+        }
+        await this.db
+            .from("sessions")
+            .update({ lastUsed: new Date(Date.now()) })
+            .where({ sessionID });
     }
-    getAllSessions() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.closing) {
-                this.log.warn("Database is closing, getAllSessions() will not complete.");
-                return [];
-            }
-            const rows = yield this.db
-                .from("sessions")
-                .select()
-                .orderBy("lastUsed", "desc");
-            const fixedRows = rows.map((session) => {
-                session.verified = Boolean(session.verified);
-                return session;
-            });
-            this.log.debug("getAllSessions() => " + JSON.stringify(fixedRows, null, 4));
-            return fixedRows;
+    async getAllSessions() {
+        if (this.closing) {
+            this.log.warn("Database is closing, getAllSessions() will not complete.");
+            return [];
+        }
+        const rows = await this.db
+            .from("sessions")
+            .select()
+            .orderBy("lastUsed", "desc");
+        const fixedRows = rows.map((session) => {
+            session.verified = Boolean(session.verified);
+            return session;
         });
+        this.log.debug("getAllSessions() => " + JSON.stringify(fixedRows, null, 4));
+        return fixedRows;
     }
-    getSessionByDeviceID(deviceID) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.closing) {
-                this.log.warn("Database is closing, getSessionByUserID() will not complete.");
-                return null;
-            }
-            const rows = yield this.db
-                .from("sessions")
-                .select()
-                .where({ deviceID })
-                .limit(1)
-                .orderBy("lastUsed", "desc");
-            if (rows.length === 0) {
-                this.log.debug("getSession() => " + JSON.stringify(null, null, 4));
-                return null;
-            }
-            const [session] = rows;
-            const wsSession = {
-                sessionID: session.sessionID,
-                userID: session.userID,
-                mode: session.mode,
-                SK: crypto_1.XUtils.decodeHex(session.SK),
-                publicKey: crypto_1.XUtils.decodeHex(session.publicKey),
-                lastUsed: session.lastUsed,
-                fingerprint: crypto_1.XUtils.decodeHex(session.fingerprint),
-            };
-            this.log.debug("getSession() => " + JSON.stringify(wsSession, null, 4));
-            return wsSession;
-        });
+    async getSessionByDeviceID(deviceID) {
+        if (this.closing) {
+            this.log.warn("Database is closing, getSessionByUserID() will not complete.");
+            return null;
+        }
+        const rows = await this.db
+            .from("sessions")
+            .select()
+            .where({ deviceID })
+            .limit(1)
+            .orderBy("lastUsed", "desc");
+        if (rows.length === 0) {
+            this.log.debug("getSession() => " + JSON.stringify(null, null, 4));
+            return null;
+        }
+        const [session] = rows;
+        const wsSession = {
+            sessionID: session.sessionID,
+            userID: session.userID,
+            mode: session.mode,
+            SK: XUtils.decodeHex(session.SK),
+            publicKey: XUtils.decodeHex(session.publicKey),
+            lastUsed: session.lastUsed,
+            fingerprint: XUtils.decodeHex(session.fingerprint),
+        };
+        this.log.debug("getSession() => " + JSON.stringify(wsSession, null, 4));
+        return wsSession;
     }
-    getPreKeys() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.untilReady();
-            if (this.closing) {
-                this.log.warn("Database is closing, getPreKeys() will not complete.");
-                return null;
-            }
-            const rows = yield this.db
-                .from("preKeys")
-                .select();
-            if (rows.length === 0) {
-                this.log.debug("getPreKeys() => " + JSON.stringify(null, null, 4));
-                return null;
-            }
-            const [preKeyInfo] = rows;
-            const preKeys = {
-                keyPair: tweetnacl_1.default.box.keyPair.fromSecretKey(crypto_1.XUtils.decodeHex(preKeyInfo.privateKey)),
-                signature: crypto_1.XUtils.decodeHex(preKeyInfo.signature),
-            };
-            this.log.debug("getPreKeys() => " + JSON.stringify(preKeys, null, 4));
-            return preKeys;
-        });
+    async getPreKeys() {
+        await this.untilReady();
+        if (this.closing) {
+            this.log.warn("Database is closing, getPreKeys() will not complete.");
+            return null;
+        }
+        const rows = await this.db
+            .from("preKeys")
+            .select();
+        if (rows.length === 0) {
+            this.log.debug("getPreKeys() => " + JSON.stringify(null, null, 4));
+            return null;
+        }
+        const [preKeyInfo] = rows;
+        const preKeys = {
+            keyPair: nacl.box.keyPair.fromSecretKey(XUtils.decodeHex(preKeyInfo.privateKey)),
+            signature: XUtils.decodeHex(preKeyInfo.signature),
+        };
+        this.log.debug("getPreKeys() => " + JSON.stringify(preKeys, null, 4));
+        return preKeys;
     }
-    getOneTimeKey(index) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.untilReady();
-            if (this.closing) {
-                this.log.warn("Database is closing, getOneTimeKey() will not complete.");
-                return null;
-            }
-            const rows = yield this.db
-                .from("oneTimeKeys")
-                .select()
-                .where({ index });
-            if (rows.length === 0) {
-                this.log.debug("getOneTimeKey() => " + JSON.stringify(null, null, 4));
-                return null;
-            }
-            const [otkInfo] = rows;
-            const otk = {
-                keyPair: tweetnacl_1.default.box.keyPair.fromSecretKey(crypto_1.XUtils.decodeHex(otkInfo.privateKey)),
-                signature: crypto_1.XUtils.decodeHex(otkInfo.signature),
-                index: otkInfo.index,
-            };
-            this.log.debug("getOneTimeKey() => " + JSON.stringify(otk, null, 4));
-            return otk;
-        });
+    async getOneTimeKey(index) {
+        await this.untilReady();
+        if (this.closing) {
+            this.log.warn("Database is closing, getOneTimeKey() will not complete.");
+            return null;
+        }
+        const rows = await this.db
+            .from("oneTimeKeys")
+            .select()
+            .where({ index });
+        if (rows.length === 0) {
+            this.log.debug("getOneTimeKey() => " + JSON.stringify(null, null, 4));
+            return null;
+        }
+        const [otkInfo] = rows;
+        const otk = {
+            keyPair: nacl.box.keyPair.fromSecretKey(XUtils.decodeHex(otkInfo.privateKey)),
+            signature: XUtils.decodeHex(otkInfo.signature),
+            index: otkInfo.index,
+        };
+        this.log.debug("getOneTimeKey() => " + JSON.stringify(otk, null, 4));
+        return otk;
     }
-    deleteOneTimeKey(index) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.closing) {
-                this.log.warn("Database is closing, deleteOneTimeKey() will not complete.");
-                return;
-            }
-            // delete the otk
-            yield this.db
-                .from("oneTimeKeys")
-                .delete()
-                .where({ index });
-        });
+    async deleteOneTimeKey(index) {
+        if (this.closing) {
+            this.log.warn("Database is closing, deleteOneTimeKey() will not complete.");
+            return;
+        }
+        // delete the otk
+        await this.db
+            .from("oneTimeKeys")
+            .delete()
+            .where({ index });
     }
-    saveSession(session) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.closing) {
-                this.log.warn("Database is closing, deleteOneTimeKey() will not complete.");
+    async saveSession(session) {
+        if (this.closing) {
+            this.log.warn("Database is closing, deleteOneTimeKey() will not complete.");
+            return;
+        }
+        try {
+            await this.db("sessions").insert(session);
+        }
+        catch (err) {
+            if (err.errno === 19) {
+                this.log.warn("Attempted to insert duplicate SK");
                 return;
             }
-            try {
-                yield this.db("sessions").insert(session);
-            }
-            catch (err) {
-                if (err.errno === 19) {
-                    this.log.warn("Attempted to insert duplicate SK");
-                    return;
-                }
-                else {
-                    throw err;
-                }
+            else {
+                throw err;
             }
-        });
+        }
     }
-    getDevice(deviceID) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const rows = yield this.db
-                .from("devices")
-                .select()
-                .where({ deviceID });
-            if (rows.length === 0) {
-                return null;
-            }
-            return rows[0];
-        });
+    async getDevice(deviceID) {
+        const rows = await this.db
+            .from("devices")
+            .select()
+            .where({ deviceID });
+        if (rows.length === 0) {
+            return null;
+        }
+        return rows[0];
     }
-    purgeHistory() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.db.from("messages").truncate();
-        });
+    async purgeHistory() {
+        await this.db.from("messages").truncate();
     }
-    purgeKeyData() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.db.from("sessions").truncate();
-            yield this.db.from("oneTimeKeys").truncate();
-            yield this.db.from("preKeys").truncate();
-            yield this.db.from("messages").truncate();
-        });
+    async purgeKeyData() {
+        await this.db.from("sessions").truncate();
+        await this.db.from("oneTimeKeys").truncate();
+        await this.db.from("preKeys").truncate();
+        await this.db.from("messages").truncate();
+    }
+    async deleteHistory(channelOrUserID, olderThan) {
+        if (!olderThan) {
+            await this.db
+                .from("messages")
+                .where({ group: channelOrUserID })
+                .orWhere({ group: null, authorID: channelOrUserID })
+                .orWhere({ group: null, readerID: channelOrUserID })
+                .delete();
+        }
+        else {
+            const duration = parseDuration(olderThan);
+            if (!duration) {
+                throw new Error("Bad duration. See parse-duration library for more details.");
+            }
+            console.log(duration);
+            const res = await this.db
+                .from("messages")
+                .where("time", "<", new Date(Date.now() - duration).toISOString());
+            console.log(res);
+        }
     }
-    deleteHistory(channelOrUserID, olderThan) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!olderThan) {
-                yield this.db
-                    .from("messages")
-                    .where({ group: channelOrUserID })
-                    .orWhere({ group: null, authorID: channelOrUserID })
-                    .orWhere({ group: null, readerID: channelOrUserID })
-                    .delete();
+    async saveDevice(device) {
+        if (this.closing) {
+            this.log.warn("Database is closing, saveDevice() will not complete.");
+            return;
+        }
+        try {
+            await this.db("devices").insert(device);
+        }
+        catch (err) {
+            if (err.errno === 19) {
+                this.log.warn("Attempted to insert duplicate deviceID");
+                return;
             }
             else {
-                const duration = parse_duration_1.default(olderThan);
-                if (!duration) {
-                    throw new Error("Bad duration. See parse-duration library for more details.");
-                }
-                console.log(duration);
-                const res = yield this.db
-                    .from("messages")
-                    .where("time", "<", new Date(Date.now() - duration).toISOString());
-                console.log(res);
+                throw err;
             }
-        });
+        }
     }
-    saveDevice(device) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.closing) {
-                this.log.warn("Database is closing, saveDevice() will not complete.");
-                return;
+    async init() {
+        this.log.info("Initializing database tables.");
+        try {
+            if (!(await this.db.schema.hasTable("messages"))) {
+                await this.db.schema.createTable("messages", (table) => {
+                    table.string("nonce").primary();
+                    table.string("sender").index();
+                    table.string("recipient").index();
+                    table.string("group").index();
+                    table.string("mailID");
+                    table.string("message");
+                    table.string("direction");
+                    table.date("timestamp");
+                    table.boolean("decrypted");
+                    table.boolean("forward");
+                    table.string("authorID");
+                    table.string("readerID");
+                });
             }
-            try {
-                yield this.db("devices").insert(device);
+            if (!(await this.db.schema.hasTable("devices"))) {
+                await this.db.schema.createTable("devices", (table) => {
+                    table.string("deviceID").primary();
+                    table.string("owner").index();
+                    table.string("signKey");
+                    table.string("name");
+                    table.string("lastLogin");
+                    table.boolean("deleted");
+                });
             }
-            catch (err) {
-                if (err.errno === 19) {
-                    this.log.warn("Attempted to insert duplicate deviceID");
-                    return;
-                }
-                else {
-                    throw err;
-                }
+            if (!(await this.db.schema.hasTable("sessions"))) {
+                await this.db.schema.createTable("sessions", (table) => {
+                    table.string("sessionID").primary();
+                    table.string("userID");
+                    table.string("deviceID");
+                    table.string("SK").unique();
+                    table.string("publicKey");
+                    table.string("fingerprint");
+                    table.string("mode");
+                    table.date("lastUsed");
+                    table.boolean("verified");
+                });
             }
-        });
-    }
-    init() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.log.info("Initializing database tables.");
-            try {
-                if (!(yield this.db.schema.hasTable("messages"))) {
-                    yield this.db.schema.createTable("messages", (table) => {
-                        table.string("nonce").primary();
-                        table.string("sender").index();
-                        table.string("recipient").index();
-                        table.string("group").index();
-                        table.string("mailID");
-                        table.string("message");
-                        table.string("direction");
-                        table.date("timestamp");
-                        table.boolean("decrypted");
-                        table.boolean("forward");
-                        table.string("authorID");
-                        table.string("readerID");
-                    });
-                }
-                if (!(yield this.db.schema.hasTable("devices"))) {
-                    yield this.db.schema.createTable("devices", (table) => {
-                        table.string("deviceID").primary();
-                        table.string("owner").index();
-                        table.string("signKey");
-                        table.string("name");
-                        table.string("lastLogin");
-                        table.boolean("deleted");
-                    });
-                }
-                if (!(yield this.db.schema.hasTable("sessions"))) {
-                    yield this.db.schema.createTable("sessions", (table) => {
-                        table.string("sessionID").primary();
-                        table.string("userID");
-                        table.string("deviceID");
-                        table.string("SK").unique();
-                        table.string("publicKey");
-                        table.string("fingerprint");
-                        table.string("mode");
-                        table.date("lastUsed");
-                        table.boolean("verified");
-                    });
-                }
-                if (!(yield this.db.schema.hasTable("preKeys"))) {
-                    yield this.db.schema.createTable("preKeys", (table) => {
-                        table.increments("index");
-                        table.string("keyID").unique();
-                        table.string("userID");
-                        table.string("deviceID");
-                        table.string("privateKey");
-                        table.string("publicKey");
-                        table.string("signature");
-                    });
-                }
-                if (!(yield this.db.schema.hasTable("oneTimeKeys"))) {
-                    yield this.db.schema.createTable("oneTimeKeys", (table) => {
-                        table.increments("index");
-                        table.string("keyID").unique();
-                        table.string("userID");
-                        table.string("deviceID");
-                        table.string("privateKey");
-                        table.string("publicKey");
-                        table.string("signature");
-                    });
-                }
-                this.ready = true;
-                this.emit("ready");
+            if (!(await this.db.schema.hasTable("preKeys"))) {
+                await this.db.schema.createTable("preKeys", (table) => {
+                    table.increments("index");
+                    table.string("keyID").unique();
+                    table.string("userID");
+                    table.string("deviceID");
+                    table.string("privateKey");
+                    table.string("publicKey");
+                    table.string("signature");
+                });
             }
-            catch (err) {
-                this.emit("error", err);
+            if (!(await this.db.schema.hasTable("oneTimeKeys"))) {
+                await this.db.schema.createTable("oneTimeKeys", (table) => {
+                    table.increments("index");
+                    table.string("keyID").unique();
+                    table.string("userID");
+                    table.string("deviceID");
+                    table.string("privateKey");
+                    table.string("publicKey");
+                    table.string("signature");
+                });
             }
-        });
+            this.ready = true;
+            this.emit("ready");
+        }
+        catch (err) {
+            this.emit("error", err);
+        }
     }
-    untilReady() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let timeout = 1;
-            while (!this.ready) {
-                yield sleep_1.sleep(timeout);
-                timeout *= 2;
-            }
-        });
+    async untilReady() {
+        let timeout = 1;
+        while (!this.ready) {
+            await sleep(timeout);
+            timeout *= 2;
+        }
     }
 }
-exports.Storage = Storage;
 //# sourceMappingURL=Storage.js.map