@mtcute/web 0.17.0 → 0.18.0

package/idb/driver.js

@@ -0,0 +1,118 @@
+import { BaseStorageDriver, MtUnsupportedError } from "@mtcute/core";
+import { txToPromise } from "./utils.js";
+const REPO_VERSION_PREFIX = "__version:";
+class IdbStorageDriver extends BaseStorageDriver {
+  constructor(_dbName) {
+    super();
+    this._dbName = _dbName;
+    if (typeof indexedDB === "undefined") {
+      throw new MtUnsupportedError("IndexedDB is not available");
+    }
+  }
+  db;
+  _pendingWrites = [];
+  _pendingWritesOses = /* @__PURE__ */ new Set();
+  _migrations = /* @__PURE__ */ new Map();
+  _maxVersion = /* @__PURE__ */ new Map();
+  registerMigration(repo, version, migration) {
+    if (this.loaded) {
+      throw new Error("Cannot register migrations after loading");
+    }
+    let map = this._migrations.get(repo);
+    if (!map) {
+      map = /* @__PURE__ */ new Map();
+      this._migrations.set(repo, map);
+    }
+    if (map.has(version)) {
+      throw new Error(`Migration for ${repo} version ${version} is already registered`);
+    }
+    map.set(version, migration);
+    const prevMax = this._maxVersion.get(repo) ?? 0;
+    if (version > prevMax) {
+      this._maxVersion.set(repo, version);
+    }
+  }
+  writeLater(os, obj) {
+    this._pendingWrites.push([os, obj]);
+    this._pendingWritesOses.add(os);
+  }
+  async _load() {
+    this.db = await new Promise((resolve, reject) => {
+      const req = indexedDB.open(this._dbName, Date.now());
+      req.onerror = () => reject(req.error);
+      const postUpgrade = [];
+      req.onsuccess = async () => {
+        try {
+          for (const cb of postUpgrade) {
+            await cb(req.result);
+          }
+          resolve(req.result);
+        } catch (e) {
+          reject(e);
+        }
+      };
+      req.onupgradeneeded = () => {
+        const db = req.result;
+        const didUpgrade = /* @__PURE__ */ new Set();
+        const doUpgrade = (repo, fromVersion) => {
+          const migrations = this._migrations.get(repo);
+          if (!migrations) return;
+          const targetVer = this._maxVersion.get(repo);
+          while (fromVersion < targetVer) {
+            const nextVersion = fromVersion + 1;
+            const migration = migrations.get(nextVersion);
+            if (!migration) {
+              throw new Error(`No migration for ${repo} to version ${nextVersion}`);
+            }
+            const result = migration(db);
+            if (result) {
+              postUpgrade.push(result);
+            }
+            fromVersion = nextVersion;
+          }
+          didUpgrade.add(repo);
+          db.createObjectStore(`${REPO_VERSION_PREFIX}${repo}:${targetVer}`);
+        };
+        for (const key of db.objectStoreNames) {
+          if (!key.startsWith(REPO_VERSION_PREFIX)) continue;
+          const [, repo, version] = key.split(":");
+          const currentVer = Number(version);
+          db.deleteObjectStore(key);
+          doUpgrade(repo, currentVer);
+          didUpgrade.add(repo);
+        }
+        for (const repo of this._migrations.keys()) {
+          if (didUpgrade.has(repo)) continue;
+          doUpgrade(repo, 0);
+        }
+      };
+    });
+  }
+  async _save() {
+    if (this._pendingWritesOses.size === 0) return;
+    const writes = this._pendingWrites;
+    const oses = this._pendingWritesOses;
+    this._pendingWrites = [];
+    this._pendingWritesOses = /* @__PURE__ */ new Set();
+    const tx = this.db.transaction(oses, "readwrite");
+    const osMap = /* @__PURE__ */ new Map();
+    for (const table of oses) {
+      osMap.set(table, tx.objectStore(table));
+    }
+    for (const [table, obj] of writes) {
+      const os = osMap.get(table);
+      if (obj === null) {
+        os.delete(table);
+      } else {
+        os.put(obj);
+      }
+    }
+    await txToPromise(tx);
+  }
+  _destroy() {
+    this.db.close();
+  }
+}
+export {
+  IdbStorageDriver
+};

package/idb/index.cjs

@@ -0,0 +1,29 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const driver = require("./driver.cjs");
+const authKeys = require("./repository/auth-keys.cjs");
+const kv = require("./repository/kv.cjs");
+const peers = require("./repository/peers.cjs");
+const refMessages = require("./repository/ref-messages.cjs");
+class IdbStorage {
+  constructor(dbName) {
+    this.dbName = dbName;
+    this.driver = new driver.IdbStorageDriver(this.dbName);
+    this.kv = new kv.IdbKvRepository(this.driver);
+    this.authKeys = new authKeys.IdbAuthKeysRepository(this.driver);
+    this.peers = new peers.IdbPeersRepository(this.driver);
+    this.refMessages = new refMessages.IdbRefMsgRepository(this.driver);
+  }
+  driver;
+  kv;
+  authKeys;
+  peers;
+  refMessages;
+}
+exports.IdbStorageDriver = driver.IdbStorageDriver;
+exports.IdbStorage = IdbStorage;

package/idb/index.d.cts

@@ -0,0 +1,22 @@
+import { IMtStorageProvider } from '@mtcute/core';
+import { IdbStorageDriver } from './driver.js';
+import { IdbAuthKeysRepository } from './repository/auth-keys.js';
+import { IdbKvRepository } from './repository/kv.js';
+import { IdbPeersRepository } from './repository/peers.js';
+import { IdbRefMsgRepository } from './repository/ref-messages.js';
+export { IdbStorageDriver } from './driver.js';
+/**
+ * mtcute storage that uses IndexedDB as a backend.
+ *
+ * This storage is the default one for browsers, and is generally
+ * recommended over local storage based one.
+ */
+export declare class IdbStorage implements IMtStorageProvider {
+    readonly dbName: string;
+    readonly driver: IdbStorageDriver;
+    readonly kv: IdbKvRepository;
+    readonly authKeys: IdbAuthKeysRepository;
+    readonly peers: IdbPeersRepository;
+    readonly refMessages: IdbRefMsgRepository;
+    constructor(dbName: string);
+}

package/idb/index.js

@@ -0,0 +1,24 @@
+import { IdbStorageDriver } from "./driver.js";
+import { IdbAuthKeysRepository } from "./repository/auth-keys.js";
+import { IdbKvRepository } from "./repository/kv.js";
+import { IdbPeersRepository } from "./repository/peers.js";
+import { IdbRefMsgRepository } from "./repository/ref-messages.js";
+class IdbStorage {
+  constructor(dbName) {
+    this.dbName = dbName;
+    this.driver = new IdbStorageDriver(this.dbName);
+    this.kv = new IdbKvRepository(this.driver);
+    this.authKeys = new IdbAuthKeysRepository(this.driver);
+    this.peers = new IdbPeersRepository(this.driver);
+    this.refMessages = new IdbRefMsgRepository(this.driver);
+  }
+  driver;
+  kv;
+  authKeys;
+  peers;
+  refMessages;
+}
+export {
+  IdbStorage,
+  IdbStorageDriver
+};

package/idb/repository/auth-keys.cjs

@@ -0,0 +1,70 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const utils = require("../utils.cjs");
+const TABLE_AUTH_KEYS = "authKeys";
+const TABLE_TEMP_AUTH_KEYS = "tempAuthKeys";
+class IdbAuthKeysRepository {
+  constructor(_driver) {
+    this._driver = _driver;
+    _driver.registerMigration(TABLE_AUTH_KEYS, 1, (db) => {
+      db.createObjectStore(TABLE_AUTH_KEYS, { keyPath: "dc" });
+      db.createObjectStore(TABLE_TEMP_AUTH_KEYS, { keyPath: ["dc", "idx"] });
+    });
+  }
+  os(mode) {
+    return this._driver.db.transaction(TABLE_AUTH_KEYS, mode).objectStore(TABLE_AUTH_KEYS);
+  }
+  async set(dc, key) {
+    const os = this.os("readwrite");
+    if (key === null) {
+      return utils.reqToPromise(os.delete(dc));
+    }
+    await utils.reqToPromise(os.put({ dc, key }));
+  }
+  async get(dc) {
+    const os = this.os();
+    const it = await utils.reqToPromise(os.get(dc));
+    if (it === void 0) return null;
+    return it.key;
+  }
+  osTemp(mode) {
+    return this._driver.db.transaction(TABLE_TEMP_AUTH_KEYS, mode).objectStore(TABLE_TEMP_AUTH_KEYS);
+  }
+  async setTemp(dc, idx, key, expires) {
+    const os = this.osTemp("readwrite");
+    if (!key) {
+      return utils.reqToPromise(os.delete([dc, idx]));
+    }
+    await utils.reqToPromise(os.put({ dc, idx, key, expiresAt: expires }));
+  }
+  async getTemp(dc, idx, now) {
+    const os = this.osTemp();
+    const row = await utils.reqToPromise(os.get([dc, idx]));
+    if (row === void 0 || row.expiresAt < now) return null;
+    return row.key;
+  }
+  async deleteByDc(dc) {
+    const tx = this._driver.db.transaction([TABLE_AUTH_KEYS, TABLE_TEMP_AUTH_KEYS], "readwrite");
+    tx.objectStore(TABLE_AUTH_KEYS).delete(dc);
+    const tempOs = tx.objectStore(TABLE_TEMP_AUTH_KEYS);
+    const keys = await utils.reqToPromise(tempOs.getAllKeys());
+    for (const key of keys) {
+      if (key[0] === dc) {
+        tempOs.delete(key);
+      }
+    }
+    await utils.txToPromise(tx);
+  }
+  deleteAll() {
+    const tx = this._driver.db.transaction([TABLE_AUTH_KEYS, TABLE_TEMP_AUTH_KEYS], "readwrite");
+    tx.objectStore(TABLE_AUTH_KEYS).clear();
+    tx.objectStore(TABLE_TEMP_AUTH_KEYS).clear();
+    return utils.txToPromise(tx);
+  }
+}
+exports.IdbAuthKeysRepository = IdbAuthKeysRepository;

package/idb/repository/auth-keys.d.cts

@@ -0,0 +1,14 @@
+import { IAuthKeysRepository } from '@mtcute/core';
+import { IdbStorageDriver } from '../driver.js';
+export declare class IdbAuthKeysRepository implements IAuthKeysRepository {
+    readonly _driver: IdbStorageDriver;
+    constructor(_driver: IdbStorageDriver);
+    private os;
+    set(dc: number, key: Uint8Array | null): Promise<void>;
+    get(dc: number): Promise<Uint8Array | null>;
+    private osTemp;
+    setTemp(dc: number, idx: number, key: Uint8Array | null, expires: number): Promise<void>;
+    getTemp(dc: number, idx: number, now: number): Promise<Uint8Array | null>;
+    deleteByDc(dc: number): Promise<void>;
+    deleteAll(): Promise<void>;
+}

package/idb/repository/auth-keys.js

@@ -0,0 +1,65 @@
+import { reqToPromise, txToPromise } from "../utils.js";
+const TABLE_AUTH_KEYS = "authKeys";
+const TABLE_TEMP_AUTH_KEYS = "tempAuthKeys";
+class IdbAuthKeysRepository {
+  constructor(_driver) {
+    this._driver = _driver;
+    _driver.registerMigration(TABLE_AUTH_KEYS, 1, (db) => {
+      db.createObjectStore(TABLE_AUTH_KEYS, { keyPath: "dc" });
+      db.createObjectStore(TABLE_TEMP_AUTH_KEYS, { keyPath: ["dc", "idx"] });
+    });
+  }
+  os(mode) {
+    return this._driver.db.transaction(TABLE_AUTH_KEYS, mode).objectStore(TABLE_AUTH_KEYS);
+  }
+  async set(dc, key) {
+    const os = this.os("readwrite");
+    if (key === null) {
+      return reqToPromise(os.delete(dc));
+    }
+    await reqToPromise(os.put({ dc, key }));
+  }
+  async get(dc) {
+    const os = this.os();
+    const it = await reqToPromise(os.get(dc));
+    if (it === void 0) return null;
+    return it.key;
+  }
+  osTemp(mode) {
+    return this._driver.db.transaction(TABLE_TEMP_AUTH_KEYS, mode).objectStore(TABLE_TEMP_AUTH_KEYS);
+  }
+  async setTemp(dc, idx, key, expires) {
+    const os = this.osTemp("readwrite");
+    if (!key) {
+      return reqToPromise(os.delete([dc, idx]));
+    }
+    await reqToPromise(os.put({ dc, idx, key, expiresAt: expires }));
+  }
+  async getTemp(dc, idx, now) {
+    const os = this.osTemp();
+    const row = await reqToPromise(os.get([dc, idx]));
+    if (row === void 0 || row.expiresAt < now) return null;
+    return row.key;
+  }
+  async deleteByDc(dc) {
+    const tx = this._driver.db.transaction([TABLE_AUTH_KEYS, TABLE_TEMP_AUTH_KEYS], "readwrite");
+    tx.objectStore(TABLE_AUTH_KEYS).delete(dc);
+    const tempOs = tx.objectStore(TABLE_TEMP_AUTH_KEYS);
+    const keys = await reqToPromise(tempOs.getAllKeys());
+    for (const key of keys) {
+      if (key[0] === dc) {
+        tempOs.delete(key);
+      }
+    }
+    await txToPromise(tx);
+  }
+  deleteAll() {
+    const tx = this._driver.db.transaction([TABLE_AUTH_KEYS, TABLE_TEMP_AUTH_KEYS], "readwrite");
+    tx.objectStore(TABLE_AUTH_KEYS).clear();
+    tx.objectStore(TABLE_TEMP_AUTH_KEYS).clear();
+    return txToPromise(tx);
+  }
+}
+export {
+  IdbAuthKeysRepository
+};

package/idb/repository/kv.cjs

@@ -0,0 +1,36 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const utils = require("../utils.cjs");
+const KV_TABLE = "kv";
+class IdbKvRepository {
+  constructor(_driver) {
+    this._driver = _driver;
+    _driver.registerMigration(KV_TABLE, 1, (db) => {
+      db.createObjectStore(KV_TABLE, { keyPath: "key" });
+    });
+  }
+  set(key, value) {
+    this._driver.writeLater(KV_TABLE, { key, value });
+  }
+  os(mode) {
+    return this._driver.db.transaction(KV_TABLE, mode).objectStore(KV_TABLE);
+  }
+  async get(key) {
+    const os = this.os();
+    const res = await utils.reqToPromise(os.get(key));
+    if (res === void 0) return null;
+    return res.value;
+  }
+  async delete(key) {
+    await utils.reqToPromise(this.os("readwrite").delete(key));
+  }
+  async deleteAll() {
+    await utils.reqToPromise(this.os("readwrite").clear());
+  }
+}
+exports.IdbKvRepository = IdbKvRepository;

package/idb/repository/kv.d.cts

@@ -0,0 +1,11 @@
+import { IKeyValueRepository } from '@mtcute/core';
+import { IdbStorageDriver } from '../driver.js';
+export declare class IdbKvRepository implements IKeyValueRepository {
+    readonly _driver: IdbStorageDriver;
+    constructor(_driver: IdbStorageDriver);
+    set(key: string, value: Uint8Array): void;
+    private os;
+    get(key: string): Promise<Uint8Array | null>;
+    delete(key: string): Promise<void>;
+    deleteAll(): Promise<void>;
+}

package/idb/repository/kv.js

@@ -0,0 +1,31 @@
+import { reqToPromise } from "../utils.js";
+const KV_TABLE = "kv";
+class IdbKvRepository {
+  constructor(_driver) {
+    this._driver = _driver;
+    _driver.registerMigration(KV_TABLE, 1, (db) => {
+      db.createObjectStore(KV_TABLE, { keyPath: "key" });
+    });
+  }
+  set(key, value) {
+    this._driver.writeLater(KV_TABLE, { key, value });
+  }
+  os(mode) {
+    return this._driver.db.transaction(KV_TABLE, mode).objectStore(KV_TABLE);
+  }
+  async get(key) {
+    const os = this.os();
+    const res = await reqToPromise(os.get(key));
+    if (res === void 0) return null;
+    return res.value;
+  }
+  async delete(key) {
+    await reqToPromise(this.os("readwrite").delete(key));
+  }
+  async deleteAll() {
+    await reqToPromise(this.os("readwrite").clear());
+  }
+}
+export {
+  IdbKvRepository
+};

package/idb/repository/peers.cjs

@@ -0,0 +1,47 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const utils = require("../utils.cjs");
+const TABLE = "peers";
+class IdbPeersRepository {
+  constructor(_driver) {
+    this._driver = _driver;
+    _driver.registerMigration(TABLE, 1, (db) => {
+      const os = db.createObjectStore(TABLE, { keyPath: "id" });
+      os.createIndex("by_username", "usernames", { unique: true, multiEntry: true });
+      os.createIndex("by_phone", "phone", { unique: true });
+    });
+  }
+  store(peer) {
+    this._driver.writeLater(TABLE, peer);
+  }
+  os(mode) {
+    return this._driver.db.transaction(TABLE, mode).objectStore(TABLE);
+  }
+  async getById(id, allowMin) {
+    const it = await utils.reqToPromise(this.os().get(id));
+    if (!it) return null;
+    if (it.isMin && !allowMin) return null;
+    return it;
+  }
+  async getByUsername(username) {
+    const it = await utils.reqToPromise(
+      this.os().index("by_username").get(username)
+    );
+    if (!it || it.isMin) return null;
+    return it;
+  }
+  async getByPhone(phone) {
+    const it = await utils.reqToPromise(this.os().index("by_phone").get(phone));
+    if (!it || it.isMin) return null;
+    return it;
+  }
+  deleteAll() {
+    return utils.reqToPromise(this.os("readwrite").clear());
+  }
+}
+exports.IdbPeersRepository = IdbPeersRepository;

package/idb/repository/peers.d.cts

@@ -0,0 +1,12 @@
+import { IPeersRepository } from '@mtcute/core';
+import { IdbStorageDriver } from '../driver.js';
+export declare class IdbPeersRepository implements IPeersRepository {
+    readonly _driver: IdbStorageDriver;
+    constructor(_driver: IdbStorageDriver);
+    store(peer: IPeersRepository.PeerInfo): void;
+    private os;
+    getById(id: number, allowMin: boolean): Promise<IPeersRepository.PeerInfo | null>;
+    getByUsername(username: string): Promise<IPeersRepository.PeerInfo | null>;
+    getByPhone(phone: string): Promise<IPeersRepository.PeerInfo | null>;
+    deleteAll(): Promise<void>;
+}

package/idb/repository/peers.js

@@ -0,0 +1,42 @@
+import { reqToPromise } from "../utils.js";
+const TABLE = "peers";
+class IdbPeersRepository {
+  constructor(_driver) {
+    this._driver = _driver;
+    _driver.registerMigration(TABLE, 1, (db) => {
+      const os = db.createObjectStore(TABLE, { keyPath: "id" });
+      os.createIndex("by_username", "usernames", { unique: true, multiEntry: true });
+      os.createIndex("by_phone", "phone", { unique: true });
+    });
+  }
+  store(peer) {
+    this._driver.writeLater(TABLE, peer);
+  }
+  os(mode) {
+    return this._driver.db.transaction(TABLE, mode).objectStore(TABLE);
+  }
+  async getById(id, allowMin) {
+    const it = await reqToPromise(this.os().get(id));
+    if (!it) return null;
+    if (it.isMin && !allowMin) return null;
+    return it;
+  }
+  async getByUsername(username) {
+    const it = await reqToPromise(
+      this.os().index("by_username").get(username)
+    );
+    if (!it || it.isMin) return null;
+    return it;
+  }
+  async getByPhone(phone) {
+    const it = await reqToPromise(this.os().index("by_phone").get(phone));
+    if (!it || it.isMin) return null;
+    return it;
+  }
+  deleteAll() {
+    return reqToPromise(this.os("readwrite").clear());
+  }
+}
+export {
+  IdbPeersRepository
+};

package/idb/repository/ref-messages.cjs

@@ -0,0 +1,62 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const utils = require("../utils.cjs");
+const TABLE = "messageRefs";
+class IdbRefMsgRepository {
+  constructor(_driver) {
+    this._driver = _driver;
+    _driver.registerMigration(TABLE, 1, (db) => {
+      const os = db.createObjectStore(TABLE, { keyPath: ["peerId", "chatId", "msgId"] });
+      os.createIndex("by_peer", "peerId");
+      os.createIndex("by_msg", ["chatId", "msgId"]);
+    });
+  }
+  os(mode) {
+    return this._driver.db.transaction(TABLE, mode).objectStore(TABLE);
+  }
+  async store(peerId, chatId, msgId) {
+    const os = this.os("readwrite");
+    await utils.reqToPromise(os.put({ peerId, chatId, msgId }));
+  }
+  async getByPeer(peerId) {
+    const os = this.os();
+    const index = os.index("by_peer");
+    const it = await utils.reqToPromise(index.get(peerId));
+    if (!it) return null;
+    return [it.chatId, it.msgId];
+  }
+  async delete(chatId, msgIds) {
+    const tx = this._driver.db.transaction(TABLE, "readwrite");
+    const os = tx.objectStore(TABLE);
+    const index = os.index("by_msg");
+    for (const msgId of msgIds) {
+      const keys = await utils.reqToPromise(index.getAllKeys([chatId, msgId]));
+      for (const key of keys) {
+        os.delete(key);
+      }
+    }
+    return utils.txToPromise(tx);
+  }
+  async deleteByPeer(peerId) {
+    const tx = this._driver.db.transaction(TABLE, "readwrite");
+    const os = tx.objectStore(TABLE);
+    const index = os.index("by_peer");
+    const req = index.openCursor(peerId);
+    let cursor = await utils.reqToPromise(req);
+    while (cursor) {
+      cursor.delete();
+      cursor.continue();
+      cursor = await utils.reqToPromise(req);
+    }
+    return utils.txToPromise(tx);
+  }
+  async deleteAll() {
+    await utils.reqToPromise(this.os("readwrite").clear());
+  }
+}
+exports.IdbRefMsgRepository = IdbRefMsgRepository;

package/idb/repository/ref-messages.d.cts

@@ -0,0 +1,12 @@
+import { IReferenceMessagesRepository } from '@mtcute/core';
+import { IdbStorageDriver } from '../driver.js';
+export declare class IdbRefMsgRepository implements IReferenceMessagesRepository {
+    readonly _driver: IdbStorageDriver;
+    constructor(_driver: IdbStorageDriver);
+    private os;
+    store(peerId: number, chatId: number, msgId: number): Promise<void>;
+    getByPeer(peerId: number): Promise<[number, number] | null>;
+    delete(chatId: number, msgIds: number[]): Promise<void>;
+    deleteByPeer(peerId: number): Promise<void>;
+    deleteAll(): Promise<void>;
+}

package/idb/repository/ref-messages.js

@@ -0,0 +1,57 @@
+import { reqToPromise, txToPromise } from "../utils.js";
+const TABLE = "messageRefs";
+class IdbRefMsgRepository {
+  constructor(_driver) {
+    this._driver = _driver;
+    _driver.registerMigration(TABLE, 1, (db) => {
+      const os = db.createObjectStore(TABLE, { keyPath: ["peerId", "chatId", "msgId"] });
+      os.createIndex("by_peer", "peerId");
+      os.createIndex("by_msg", ["chatId", "msgId"]);
+    });
+  }
+  os(mode) {
+    return this._driver.db.transaction(TABLE, mode).objectStore(TABLE);
+  }
+  async store(peerId, chatId, msgId) {
+    const os = this.os("readwrite");
+    await reqToPromise(os.put({ peerId, chatId, msgId }));
+  }
+  async getByPeer(peerId) {
+    const os = this.os();
+    const index = os.index("by_peer");
+    const it = await reqToPromise(index.get(peerId));
+    if (!it) return null;
+    return [it.chatId, it.msgId];
+  }
+  async delete(chatId, msgIds) {
+    const tx = this._driver.db.transaction(TABLE, "readwrite");
+    const os = tx.objectStore(TABLE);
+    const index = os.index("by_msg");
+    for (const msgId of msgIds) {
+      const keys = await reqToPromise(index.getAllKeys([chatId, msgId]));
+      for (const key of keys) {
+        os.delete(key);
+      }
+    }
+    return txToPromise(tx);
+  }
+  async deleteByPeer(peerId) {
+    const tx = this._driver.db.transaction(TABLE, "readwrite");
+    const os = tx.objectStore(TABLE);
+    const index = os.index("by_peer");
+    const req = index.openCursor(peerId);
+    let cursor = await reqToPromise(req);
+    while (cursor) {
+      cursor.delete();
+      cursor.continue();
+      cursor = await reqToPromise(req);
+    }
+    return txToPromise(tx);
+  }
+  async deleteAll() {
+    await reqToPromise(this.os("readwrite").clear());
+  }
+}
+export {
+  IdbRefMsgRepository
+};