@mtcute/core 0.1.1 → 0.2.0

package/cjs/network/transports/websocket.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket.test.js","sourceRoot":"","sources":["../../../../src/network/transports/websocket.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { describe, expect, it, Mock, MockedObject, vi } from 'vitest'\n\nimport { defaultTestCryptoProvider, u8HexDecode } from '@mtcute/test'\n\nimport { defaultProductionDc, hexDecodeToBuffer, LogManager } from '../../utils/index.js'\nimport { TransportState } from './abstract.js'\nimport { WebSocketTransport } from './websocket.js'\n\ndescribe('WebSocketTransport', () => {\n    const create = async () => {\n        const fakeWs = vi.fn().mockImplementation(() => ({\n            addEventListener: vi.fn().mockImplementation((event: string, cb: () => void) => {\n                if (event === 'open') {\n                    cb()\n                }\n            }),\n            removeEventListener: vi.fn(),\n            close: vi.fn(),\n            send: vi.fn(),\n        }))\n\n        const transport = new WebSocketTransport({ ws: fakeWs })\n        const logger = new LogManager()\n        logger.level = 0\n        transport.setup(await defaultTestCryptoProvider(), logger)\n\n        return [transport, fakeWs] as const\n    }\n\n    const getLastSocket = (ws: Mock) => {\n        return ws.mock.results[ws.mock.results.length - 1].value as MockedObject<WebSocket>\n    }\n\n    it('should initiate a websocket connection to the given dc', async () => {\n        const [t, ws] = await create()\n\n        t.connect(defaultProductionDc.main, false)\n\n        expect(ws).toHaveBeenCalledOnce()\n        expect(ws).toHaveBeenCalledWith('wss://venus.web.telegram.org/apiws', 'binary')\n        await vi.waitFor(() => expect(t.state()).toEqual(TransportState.Ready))\n    })\n\n    it('should set up event handlers', async () => {\n        const [t, ws] = await create()\n\n        t.connect(defaultProductionDc.main, false)\n        const socket = getLastSocket(ws)\n\n        expect(socket.addEventListener).toHaveBeenCalledWith('message', expect.any(Function))\n        expect(socket.addEventListener).toHaveBeenCalledWith('error', expect.any(Function))\n        expect(socket.addEventListener).toHaveBeenCalledWith('close', expect.any(Function))\n    })\n\n    it('should write packet codec tag to the socket', async () => {\n        const [t, ws] = await create()\n\n        t.connect(defaultProductionDc.main, false)\n        const socket = getLastSocket(ws)\n\n        await vi.waitFor(() =>\n            expect(socket.send).toHaveBeenCalledWith(\n                u8HexDecode(\n                    '29afd26df40fb8ed10b6b4ad6d56ef5df9453f88e6ee6adb6e0544ba635dc6a8a990c9b8b980c343936b33fa7f97bae025102532233abb26d4a1fe6d34f1ba08',\n                ),\n            ),\n        )\n    })\n\n    it('should write to the underlying socket', async () => {\n        const [t, ws] = await create()\n\n        t.connect(defaultProductionDc.main, false)\n        const socket = getLastSocket(ws)\n        await vi.waitFor(() => expect(t.state()).toEqual(TransportState.Ready))\n\n        await t.send(hexDecodeToBuffer('00010203040506070809'))\n\n        expect(socket.send).toHaveBeenCalledWith(hexDecodeToBuffer('af020630c8ef14bcf53af33853ea'))\n    })\n\n    it('should correctly close', async () => {\n        const [t, ws] = await create()\n\n        t.connect(defaultProductionDc.main, false)\n        const socket = getLastSocket(ws)\n        await vi.waitFor(() => expect(t.state()).toEqual(TransportState.Ready))\n\n        t.close()\n\n        expect(socket.removeEventListener).toHaveBeenCalled()\n        expect(socket.close).toHaveBeenCalled()\n    })\n\n    it('should correctly handle incoming messages', async () => {\n        const [t, ws] = await create()\n\n        const feedSpy = vi.spyOn(t._packetCodec, 'feed')\n\n        t.connect(defaultProductionDc.main, false)\n        const socket = getLastSocket(ws)\n        await vi.waitFor(() => expect(t.state()).toEqual(TransportState.Ready))\n\n        const data = hexDecodeToBuffer('00010203040506070809')\n        const message = new MessageEvent('message', { data })\n\n        const onMessageCall = socket.addEventListener.mock.calls.find(([event]) => event === 'message') as unknown as [\n            string,\n            (evt: MessageEvent) => void,\n        ]\n        onMessageCall[1](message)\n\n        expect(feedSpy).toHaveBeenCalledWith(u8HexDecode('00010203040506070809'))\n    })\n\n    it('should propagate errors', async () => {\n        const [t, ws] = await create()\n\n        const spyEmit = vi.spyOn(t, 'emit').mockImplementation(() => true)\n\n        t.connect(defaultProductionDc.main, false)\n        const socket = getLastSocket(ws)\n        await vi.waitFor(() => expect(t.state()).toEqual(TransportState.Ready))\n\n        const error = new Error('test')\n        const onErrorCall = socket.addEventListener.mock.calls.find(([event]) => event === 'error') as unknown as [\n            string,\n            (evt: { error: Error }) => void,\n        ]\n        onErrorCall[1]({ error })\n\n        expect(spyEmit).toHaveBeenCalledWith('error', error)\n    })\n})\n"]}

package/cjs/storage/abstract.d.ts

@@ -124,6 +124,10 @@ export interface ITelegramStorage {
     updatePeers(peers: ITelegramStorage.PeerInfo[]): MaybeAsync<void>;
     /**
      * Find a peer in local database by its marked ID
+     *
+     * If no peer was found, the storage should try searching its
+     * reference messages database. If a reference message is found,
+     * a `inputPeer*FromMessage` constructor should be returned
      */
     getPeerById(peerId: number): MaybeAsync<tl.TypeInputPeer | null>;
     /**
@@ -134,6 +138,20 @@ export interface ITelegramStorage {
      * Find a peer in local database by its phone number
      */
     getPeerByPhone(phone: string): MaybeAsync<tl.TypeInputPeer | null>;
+    /**
+     * For `*FromMessage` constructors: store a reference to a `peerId` -
+     * it was seen in message `messageId` in chat `chatId`.
+     *
+     * `peerId` and `chatId` are marked peer IDs.
+     *
+     * Learn more: https://core.telegram.org/api/min
+     */
+    saveReferenceMessage(peerId: number, chatId: number, messageId: number): MaybeAsync<void>;
+    /**
+     * For `*FromMessage` constructors: messages `messageIds` in chat `chatId` were deleted,
+     * so remove any stored peer references to them.
+     */
+    deleteReferenceMessages(chatId: number, messageIds: number[]): MaybeAsync<void>;
     /**
      * Get updates state (if available), represented as a tuple
      * containing: `pts, qts, date, seq`

package/cjs/storage/abstract.js.map

@@ -1 +1 @@
-{"version":3,"file":"abstract.js","sourceRoot":"","sources":["../../../src/storage/abstract.ts"],"names":[],"mappings":"","sourcesContent":["import { tl } from '@mtcute/tl'\nimport { TlReaderMap, TlWriterMap } from '@mtcute/tl-runtime'\n\nimport { BasicPeerType, MaybeAsync } from '../types/index.js'\nimport { Logger } from '../utils/index.js'\n\n// eslint-disable-next-line @typescript-eslint/no-namespace\nexport namespace ITelegramStorage {\n    /** Information about a cached peer */\n    export interface PeerInfo {\n        /** Peer marked ID */\n        id: number\n        /** Peer access hash */\n        accessHash: tl.Long\n        /** Peer type */\n        type: BasicPeerType\n        /** Peer username, if any */\n        username?: string\n        /** Peer phone number, if available */\n        phone?: string\n\n        /** Full TL object with the cached entity */\n        full: tl.TypeUser | tl.TypeChat\n    }\n\n    /** Information about currently logged in user */\n    export interface SelfInfo {\n        /** Whether this is a bot */\n        isBot: boolean\n        /** Current user's ID */\n        userId: number\n    }\n\n    /** Information about preferred DC-s for the user */\n    export interface DcOptions {\n        /** Main DC */\n        main: tl.RawDcOption\n        /** Media DC. Can be the same as main */\n        media: tl.RawDcOption\n    }\n}\n\n/**\n * Abstract interface for persistent storage.\n *\n * In some cases you may want to extend existing MemorySession\n * and override save()/load()/destroy() methods, but you are also free\n * to implement your own session (be sure to refer to MemorySession\n * source code to avoid shooting your leg though)\n *\n * Note that even though set methods *can* be async, you should only\n * write updates to the disk when `save()` is called.\n */\nexport interface ITelegramStorage {\n    /**\n     * This method is called before any other.\n     * For storages that use logging, logger instance.\n     * For storages that use binary storage, binary maps\n     */\n    setup?(log: Logger, readerMap: TlReaderMap, writerMap: TlWriterMap): void\n\n    /**\n     * Load session from some external storage.\n     * Should be used either to load session content from file/network/etc\n     * to memory, or to open required connections to fetch session content later\n     */\n    load?(): MaybeAsync<void>\n    /**\n     * Save session to some external storage.\n     * Should be used to commit pending changes in the session.\n     * For example, saving session content to file/network/etc,\n     * or committing a database transaction\n     */\n    save?(): MaybeAsync<void>\n    /**\n     * Cleanup session and release all used resources.\n     */\n    destroy?(): MaybeAsync<void>\n\n    /**\n     * Reset session to its default state, optionally resetting auth keys\n     *\n     * @param [withAuthKeys=false]  Whether to also reset auth keys\n     */\n    reset(withAuthKeys?: boolean): void\n\n    /**\n     * Set default datacenter to use with this session.\n     */\n    setDefaultDcs(dcs: ITelegramStorage.DcOptions | null): MaybeAsync<void>\n    /**\n     * Get default datacenter for this session\n     * (by default should return null)\n     */\n    getDefaultDcs(): MaybeAsync<ITelegramStorage.DcOptions | null>\n\n    /**\n     * Get auth_key for a given DC\n     * (returning null will start authorization)\n     * For temp keys: should also return null if the key has expired\n     *\n     * @param dcId DC ID\n     * @param tempIndex  Index of the temporary key (usually 0, used for multi-connections)\n     */\n    getAuthKeyFor(dcId: number, tempIndex?: number): MaybeAsync<Uint8Array | null>\n    /**\n     * Set auth_key for a given DC\n     */\n    setAuthKeyFor(dcId: number, key: Uint8Array | null): MaybeAsync<void>\n    /**\n     * Set temp_auth_key for a given DC\n     * expiresAt is unix time in ms\n     */\n    setTempAuthKeyFor(dcId: number, index: number, key: Uint8Array | null, expiresAt: number): MaybeAsync<void>\n    /**\n     * Remove all saved auth keys (both temp and perm)\n     * for the given DC. Used when perm_key becomes invalid,\n     * meaning all temp_keys also become invalid\n     */\n    dropAuthKeysFor(dcId: number): MaybeAsync<void>\n\n    /**\n     * Get information about currently logged in user (if available)\n     */\n    getSelf(): MaybeAsync<ITelegramStorage.SelfInfo | null>\n    /**\n     * Save information about currently logged in user\n     */\n    setSelf(self: ITelegramStorage.SelfInfo | null): MaybeAsync<void>\n\n    /**\n     * Update local database of input peers from the peer info list\n     *\n     * Client will call `.save()` after all updates-related methods\n     * are called, so you can safely batch these updates\n     */\n    updatePeers(peers: ITelegramStorage.PeerInfo[]): MaybeAsync<void>\n    /**\n     * Find a peer in local database by its marked ID\n     */\n    getPeerById(peerId: number): MaybeAsync<tl.TypeInputPeer | null>\n    /**\n     * Find a peer in local database by its username\n     */\n    getPeerByUsername(username: string): MaybeAsync<tl.TypeInputPeer | null>\n    /**\n     * Find a peer in local database by its phone number\n     */\n    getPeerByPhone(phone: string): MaybeAsync<tl.TypeInputPeer | null>\n\n    /**\n     * Get updates state (if available), represented as a tuple\n     * containing: `pts, qts, date, seq`\n     */\n    getUpdatesState(): MaybeAsync<[number, number, number, number] | null>\n\n    /**\n     * Set common `pts` value\n     *\n     * Client will call `.save()` after all updates-related methods\n     * are called, so you can safely batch these updates\n     */\n    setUpdatesPts(val: number): MaybeAsync<void>\n    /**\n     * Set common `qts` value\n     *\n     * Client will call `.save()` after all updates-related methods\n     * are called, so you can safely batch these updates\n     */\n    setUpdatesQts(val: number): MaybeAsync<void>\n    /**\n     * Set updates `date` value\n     *\n     * Client will call `.save()` after all updates-related methods\n     * are called, so you can safely batch these updates\n     */\n    setUpdatesDate(val: number): MaybeAsync<void>\n    /**\n     * Set updates `seq` value\n     *\n     * Client will call `.save()` after all updates-related methods\n     * are called, so you can safely batch these updates\n     */\n    setUpdatesSeq(val: number): MaybeAsync<void>\n\n    /**\n     * Get channel `pts` value\n     */\n    getChannelPts(entityId: number): MaybeAsync<number | null>\n    /**\n     * Set channels `pts` values in batch.\n     *\n     * Storage is supposed to replace stored channel `pts` values\n     * with given in the object (key is unmarked peer id, value is the `pts`)\n     *\n     * Client will call `.save()` after all updates-related methods\n     * are called, so you can safely batch these updates\n     */\n    setManyChannelPts(values: Map<number, number>): MaybeAsync<void>\n\n    /**\n     * Get cached peer information by their marked ID.\n     * Return `null` if caching is not supported, or the entity\n     * is not cached (yet).\n     *\n     * This is primarily used when a `min` entity is encountered\n     * in an update, or when a *short* update is encountered.\n     * Returning `null` will require re-fetching that\n     * update with the peers added, which might not be very efficient.\n     */\n    getFullPeerById(id: number): MaybeAsync<tl.TypeUser | tl.TypeChat | null>\n}\n"]}
+{"version":3,"file":"abstract.js","sourceRoot":"","sources":["../../../src/storage/abstract.ts"],"names":[],"mappings":"","sourcesContent":["import { tl } from '@mtcute/tl'\nimport { TlReaderMap, TlWriterMap } from '@mtcute/tl-runtime'\n\nimport { BasicPeerType, MaybeAsync } from '../types/index.js'\nimport { Logger } from '../utils/index.js'\n\n// eslint-disable-next-line @typescript-eslint/no-namespace\nexport namespace ITelegramStorage {\n    /** Information about a cached peer */\n    export interface PeerInfo {\n        /** Peer marked ID */\n        id: number\n        /** Peer access hash */\n        accessHash: tl.Long\n        /** Peer type */\n        type: BasicPeerType\n        /** Peer username, if any */\n        username?: string\n        /** Peer phone number, if available */\n        phone?: string\n\n        /** Full TL object with the cached entity */\n        full: tl.TypeUser | tl.TypeChat\n    }\n\n    /** Information about currently logged in user */\n    export interface SelfInfo {\n        /** Whether this is a bot */\n        isBot: boolean\n        /** Current user's ID */\n        userId: number\n    }\n\n    /** Information about preferred DC-s for the user */\n    export interface DcOptions {\n        /** Main DC */\n        main: tl.RawDcOption\n        /** Media DC. Can be the same as main */\n        media: tl.RawDcOption\n    }\n}\n\n/**\n * Abstract interface for persistent storage.\n *\n * In some cases you may want to extend existing MemorySession\n * and override save()/load()/destroy() methods, but you are also free\n * to implement your own session (be sure to refer to MemorySession\n * source code to avoid shooting your leg though)\n *\n * Note that even though set methods *can* be async, you should only\n * write updates to the disk when `save()` is called.\n */\nexport interface ITelegramStorage {\n    /**\n     * This method is called before any other.\n     * For storages that use logging, logger instance.\n     * For storages that use binary storage, binary maps\n     */\n    setup?(log: Logger, readerMap: TlReaderMap, writerMap: TlWriterMap): void\n\n    /**\n     * Load session from some external storage.\n     * Should be used either to load session content from file/network/etc\n     * to memory, or to open required connections to fetch session content later\n     */\n    load?(): MaybeAsync<void>\n    /**\n     * Save session to some external storage.\n     * Should be used to commit pending changes in the session.\n     * For example, saving session content to file/network/etc,\n     * or committing a database transaction\n     */\n    save?(): MaybeAsync<void>\n    /**\n     * Cleanup session and release all used resources.\n     */\n    destroy?(): MaybeAsync<void>\n\n    /**\n     * Reset session to its default state, optionally resetting auth keys\n     *\n     * @param [withAuthKeys=false]  Whether to also reset auth keys\n     */\n    reset(withAuthKeys?: boolean): void\n\n    /**\n     * Set default datacenter to use with this session.\n     */\n    setDefaultDcs(dcs: ITelegramStorage.DcOptions | null): MaybeAsync<void>\n    /**\n     * Get default datacenter for this session\n     * (by default should return null)\n     */\n    getDefaultDcs(): MaybeAsync<ITelegramStorage.DcOptions | null>\n\n    /**\n     * Get auth_key for a given DC\n     * (returning null will start authorization)\n     * For temp keys: should also return null if the key has expired\n     *\n     * @param dcId DC ID\n     * @param tempIndex  Index of the temporary key (usually 0, used for multi-connections)\n     */\n    getAuthKeyFor(dcId: number, tempIndex?: number): MaybeAsync<Uint8Array | null>\n    /**\n     * Set auth_key for a given DC\n     */\n    setAuthKeyFor(dcId: number, key: Uint8Array | null): MaybeAsync<void>\n    /**\n     * Set temp_auth_key for a given DC\n     * expiresAt is unix time in ms\n     */\n    setTempAuthKeyFor(dcId: number, index: number, key: Uint8Array | null, expiresAt: number): MaybeAsync<void>\n    /**\n     * Remove all saved auth keys (both temp and perm)\n     * for the given DC. Used when perm_key becomes invalid,\n     * meaning all temp_keys also become invalid\n     */\n    dropAuthKeysFor(dcId: number): MaybeAsync<void>\n\n    /**\n     * Get information about currently logged in user (if available)\n     */\n    getSelf(): MaybeAsync<ITelegramStorage.SelfInfo | null>\n    /**\n     * Save information about currently logged in user\n     */\n    setSelf(self: ITelegramStorage.SelfInfo | null): MaybeAsync<void>\n\n    /**\n     * Update local database of input peers from the peer info list\n     *\n     * Client will call `.save()` after all updates-related methods\n     * are called, so you can safely batch these updates\n     */\n    updatePeers(peers: ITelegramStorage.PeerInfo[]): MaybeAsync<void>\n\n    /**\n     * Find a peer in local database by its marked ID\n     *\n     * If no peer was found, the storage should try searching its\n     * reference messages database. If a reference message is found,\n     * a `inputPeer*FromMessage` constructor should be returned\n     */\n    getPeerById(peerId: number): MaybeAsync<tl.TypeInputPeer | null>\n\n    /**\n     * Find a peer in local database by its username\n     */\n    getPeerByUsername(username: string): MaybeAsync<tl.TypeInputPeer | null>\n\n    /**\n     * Find a peer in local database by its phone number\n     */\n    getPeerByPhone(phone: string): MaybeAsync<tl.TypeInputPeer | null>\n\n    /**\n     * For `*FromMessage` constructors: store a reference to a `peerId` -\n     * it was seen in message `messageId` in chat `chatId`.\n     *\n     * `peerId` and `chatId` are marked peer IDs.\n     *\n     * Learn more: https://core.telegram.org/api/min\n     */\n    saveReferenceMessage(peerId: number, chatId: number, messageId: number): MaybeAsync<void>\n\n    /**\n     * For `*FromMessage` constructors: messages `messageIds` in chat `chatId` were deleted,\n     * so remove any stored peer references to them.\n     */\n    deleteReferenceMessages(chatId: number, messageIds: number[]): MaybeAsync<void>\n\n    /**\n     * Get updates state (if available), represented as a tuple\n     * containing: `pts, qts, date, seq`\n     */\n    getUpdatesState(): MaybeAsync<[number, number, number, number] | null>\n\n    /**\n     * Set common `pts` value\n     *\n     * Client will call `.save()` after all updates-related methods\n     * are called, so you can safely batch these updates\n     */\n    setUpdatesPts(val: number): MaybeAsync<void>\n    /**\n     * Set common `qts` value\n     *\n     * Client will call `.save()` after all updates-related methods\n     * are called, so you can safely batch these updates\n     */\n    setUpdatesQts(val: number): MaybeAsync<void>\n    /**\n     * Set updates `date` value\n     *\n     * Client will call `.save()` after all updates-related methods\n     * are called, so you can safely batch these updates\n     */\n    setUpdatesDate(val: number): MaybeAsync<void>\n    /**\n     * Set updates `seq` value\n     *\n     * Client will call `.save()` after all updates-related methods\n     * are called, so you can safely batch these updates\n     */\n    setUpdatesSeq(val: number): MaybeAsync<void>\n\n    /**\n     * Get channel `pts` value\n     */\n    getChannelPts(entityId: number): MaybeAsync<number | null>\n    /**\n     * Set channels `pts` values in batch.\n     *\n     * Storage is supposed to replace stored channel `pts` values\n     * with given in the object (key is unmarked peer id, value is the `pts`)\n     *\n     * Client will call `.save()` after all updates-related methods\n     * are called, so you can safely batch these updates\n     */\n    setManyChannelPts(values: Map<number, number>): MaybeAsync<void>\n\n    /**\n     * Get cached peer information by their marked ID.\n     * Return `null` if caching is not supported, or the entity\n     * is not cached (yet).\n     *\n     * This is primarily used when a `min` entity is encountered\n     * in an update, or when a *short* update is encountered.\n     * Returning `null` will require re-fetching that\n     * update with the peers added, which might not be very efficient.\n     */\n    getFullPeerById(id: number): MaybeAsync<tl.TypeUser | tl.TypeChat | null>\n}\n"]}

package/cjs/storage/idb.d.ts

@@ -0,0 +1,101 @@
+import { tl } from '@mtcute/tl';
+import { TlReaderMap, TlWriterMap } from '@mtcute/tl-runtime';
+import { Logger } from '../utils/logger.js';
+import { ITelegramStorage } from './abstract.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 ITelegramStorage {
+    readonly _dbName: string;
+    private _cache?;
+    private _vacuumTimeout?;
+    private _vacuumInterval;
+    constructor(_dbName: string, params?: {
+        /**
+         * Entities cache size, in number of entities.
+         *
+         * Recently encountered entities are cached in memory,
+         * to avoid redundant database calls. Set to 0 to
+         * disable caching (not recommended)
+         *
+         * Note that by design in-memory cached is only
+         * used when finding peer by ID, since other
+         * kinds of lookups (phone, username) may get stale quickly
+         *
+         * @default  `100`
+         */
+        cacheSize?: number;
+        /**
+         * Updates to already cached in-memory entities are only
+         * applied in DB once in a while, to avoid redundant
+         * DB calls.
+         *
+         * If you are having issues with this, you can set this to `0`
+         *
+         * @default  `30000` (30 sec)
+         */
+        unimportantSavesDelay?: number;
+        /**
+         * Interval in milliseconds for vacuuming the storage.
+         *
+         * When vacuuming, the storage will remove expired FSM
+         * states to reduce disk and memory usage.
+         *
+         * @default  `300_000` (5 minutes)
+         */
+        vacuumInterval?: number;
+    });
+    db: IDBDatabase;
+    private _upgradeDb;
+    private log;
+    private readerMap;
+    private writerMap;
+    private _reader;
+    setup(log: Logger, readerMap: TlReaderMap, writerMap: TlWriterMap): void;
+    private _pendingWrites;
+    private _pendingWritesOses;
+    private _writeLater;
+    private _readFullPeer;
+    load(): Promise<void>;
+    save(): Promise<void>;
+    private _vacuum;
+    destroy(): void;
+    reset(withAuthKeys?: boolean | undefined): Promise<void>;
+    private _getFromKv;
+    private _setToKv;
+    setDefaultDcs(dcs: ITelegramStorage.DcOptions | null): Promise<void>;
+    getDefaultDcs(): Promise<ITelegramStorage.DcOptions | null>;
+    getAuthKeyFor(dcId: number, tempIndex?: number | undefined): Promise<Uint8Array | null>;
+    setAuthKeyFor(dcId: number, key: Uint8Array | null): Promise<void>;
+    setTempAuthKeyFor(dcId: number, index: number, key: Uint8Array | null, expiresAt: number): Promise<void>;
+    dropAuthKeysFor(dcId: number): Promise<void>;
+    private _cachedSelf?;
+    getSelf(): Promise<ITelegramStorage.SelfInfo | null>;
+    setSelf(self: ITelegramStorage.SelfInfo | null): Promise<void>;
+    getUpdatesState(): Promise<[number, number, number, number] | null>;
+    setUpdatesPts(val: number): Promise<void>;
+    setUpdatesQts(val: number): Promise<void>;
+    setUpdatesDate(val: number): Promise<void>;
+    setUpdatesSeq(val: number): Promise<void>;
+    getChannelPts(entityId: number): Promise<number | null>;
+    setManyChannelPts(values: Map<number, number>): Promise<void>;
+    updatePeers(peers: ITelegramStorage.PeerInfo[]): void;
+    private _findPeerByReference;
+    getPeerById(peerId: number, allowRefs?: boolean): Promise<tl.TypeInputPeer | null>;
+    getPeerByUsername(username: string): Promise<tl.TypeInputPeer | null>;
+    getPeerByPhone(phone: string): Promise<tl.TypeInputPeer | null>;
+    getFullPeerById(peerId: number): Promise<tl.TypeUser | tl.TypeChat | null>;
+    saveReferenceMessage(peerId: number, chatId: number, messageId: number): Promise<void>;
+    deleteReferenceMessages(chatId: number, messageIds: number[]): Promise<void>;
+    getState(key: string): Promise<unknown>;
+    setState(key: string, state: unknown, ttl?: number): Promise<void>;
+    deleteState(key: string): Promise<void>;
+    getCurrentScene(key: string): Promise<string | null>;
+    setCurrentScene(key: string, scene: string, ttl?: number): Promise<void>;
+    deleteCurrentScene(key: string): Promise<void>;
+    getRateLimit(key: string, limit: number, window: number): Promise<[number, number]>;
+    resetRateLimit(key: string): Promise<void>;
+}

package/cjs/storage/idb.js

@@ -0,0 +1,458 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdbStorage = void 0;
+const tl_runtime_1 = require("@mtcute/tl-runtime");
+const long_utils_js_1 = require("../utils/long-utils.js");
+const lru_map_js_1 = require("../utils/lru-map.js");
+const peer_utils_js_1 = require("../utils/peer-utils.js");
+const CURRENT_VERSION = 1;
+const TABLES = {
+    kv: 'kv',
+    state: 'state',
+    authKeys: 'auth_keys',
+    tempAuthKeys: 'temp_auth_keys',
+    pts: 'pts',
+    entities: 'entities',
+    messageRefs: 'message_refs',
+};
+const EMPTY_BUFFER = new Uint8Array(0);
+function txToPromise(tx) {
+    return new Promise((resolve, reject) => {
+        tx.oncomplete = () => resolve();
+        tx.onerror = () => reject(tx.error);
+    });
+}
+function reqToPromise(req) {
+    return new Promise((resolve, reject) => {
+        req.onsuccess = () => resolve(req.result);
+        req.onerror = () => reject(req.error);
+    });
+}
+function getInputPeer(row) {
+    const id = row.id;
+    switch (row.type) {
+        case 'user':
+            return {
+                _: 'inputPeerUser',
+                userId: id,
+                accessHash: 'accessHash' in row ? row.accessHash : (0, long_utils_js_1.longFromFastString)(row.hash),
+            };
+        case 'chat':
+            return {
+                _: 'inputPeerChat',
+                chatId: -id,
+            };
+        case 'channel':
+            return {
+                _: 'inputPeerChannel',
+                channelId: (0, peer_utils_js_1.toggleChannelIdMark)(id),
+                accessHash: 'accessHash' in row ? row.accessHash : (0, long_utils_js_1.longFromFastString)(row.hash),
+            };
+    }
+    throw new Error(`Invalid peer type: ${row.type}`);
+}
+/**
+ * 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.
+ */
+class IdbStorage {
+    constructor(_dbName, params) {
+        this._dbName = _dbName;
+        this._pendingWrites = [];
+        this._pendingWritesOses = new Set();
+        if (params?.cacheSize !== 0) {
+            this._cache = new lru_map_js_1.LruMap(params?.cacheSize ?? 100);
+        }
+        this._vacuumInterval = params?.vacuumInterval ?? 300000;
+    }
+    _upgradeDb(db, oldVer, newVer) {
+        while (oldVer < newVer) {
+            switch (oldVer) {
+                case 0: {
+                    db.createObjectStore(TABLES.kv, { keyPath: 'key' });
+                    db.createObjectStore(TABLES.authKeys, { keyPath: 'dc' });
+                    db.createObjectStore(TABLES.tempAuthKeys, { keyPath: ['dc', 'idx'] });
+                    db.createObjectStore(TABLES.pts, { keyPath: 'channelId' });
+                    const stateOs = db.createObjectStore(TABLES.state, { keyPath: 'key' });
+                    stateOs.createIndex('by_expires', 'expires');
+                    const entitiesOs = db.createObjectStore(TABLES.entities, { keyPath: 'id' });
+                    entitiesOs.createIndex('by_username', 'username');
+                    entitiesOs.createIndex('by_phone', 'phone');
+                    const msgRefsOs = db.createObjectStore(TABLES.messageRefs, { keyPath: 'peerId' });
+                    msgRefsOs.createIndex('by_msg', ['chatId', 'msgId']);
+                    oldVer++;
+                }
+            }
+        }
+        if (newVer !== CURRENT_VERSION)
+            throw new Error(`Invalid db version: ${newVer}`);
+    }
+    setup(log, readerMap, writerMap) {
+        this.log = log.create('idb');
+        this.readerMap = readerMap;
+        this.writerMap = writerMap;
+        this._reader = new tl_runtime_1.TlBinaryReader(readerMap, EMPTY_BUFFER);
+    }
+    _writeLater(table, obj) {
+        this._pendingWrites.push([table, obj]);
+        this._pendingWritesOses.add(table);
+    }
+    _readFullPeer(data) {
+        this._reader = new tl_runtime_1.TlBinaryReader(this.readerMap, data);
+        let obj;
+        try {
+            obj = this._reader.object();
+        }
+        catch (e) {
+            // object might be from an older tl layer, in which case it will be ignored
+            obj = null;
+        }
+        return obj;
+    }
+    async load() {
+        this.db = await new Promise((resolve, reject) => {
+            const req = indexedDB.open(this._dbName, CURRENT_VERSION);
+            req.onerror = () => reject(req.error);
+            req.onsuccess = () => resolve(req.result);
+            req.onupgradeneeded = (event) => this._upgradeDb(req.result, event.oldVersion, event.newVersion || CURRENT_VERSION);
+        });
+        this._vacuumTimeout = setInterval(() => {
+            this._vacuum().catch((e) => {
+                this.log.warn('Failed to vacuum database: %s', e);
+            });
+        }, this._vacuumInterval);
+    }
+    async save() {
+        if (this._pendingWritesOses.size === 0)
+            return;
+        const writes = this._pendingWrites;
+        const oses = this._pendingWritesOses;
+        this._pendingWrites = [];
+        this._pendingWritesOses = new Set();
+        const tx = this.db.transaction(oses, 'readwrite');
+        const osMap = 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);
+    }
+    async _vacuum() {
+        const tx = this.db.transaction(TABLES.state, 'readwrite');
+        const os = tx.objectStore(TABLES.state);
+        const keys = await reqToPromise(os.index('by_expires').getAllKeys(IDBKeyRange.upperBound(Date.now())));
+        for (const key of keys) {
+            os.delete(key);
+        }
+        return txToPromise(tx);
+    }
+    destroy() {
+        this.db.close();
+        clearInterval(this._vacuumTimeout);
+    }
+    async reset(withAuthKeys) {
+        this._cache?.clear();
+        const tx = this.db.transaction(Object.values(TABLES), 'readwrite');
+        for (const table of Object.values(TABLES)) {
+            if (table === TABLES.authKeys && !withAuthKeys)
+                continue;
+            if (table === TABLES.tempAuthKeys && !withAuthKeys)
+                continue;
+            tx.objectStore(table).clear();
+        }
+        return txToPromise(tx);
+    }
+    async _getFromKv(key) {
+        const tx = this.db.transaction(TABLES.kv);
+        const store = tx.objectStore(TABLES.kv);
+        const res = await reqToPromise(store.get(key));
+        if (res === undefined)
+            return null;
+        return JSON.parse(res.value);
+    }
+    async _setToKv(key, value, now = false) {
+        const dto = { key, value: JSON.stringify(value) };
+        if (!now) {
+            this._writeLater(TABLES.kv, dto);
+            return;
+        }
+        const tx = this.db.transaction(TABLES.kv, 'readwrite');
+        const store = tx.objectStore(TABLES.kv);
+        await reqToPromise(store.put(dto));
+    }
+    setDefaultDcs(dcs) {
+        return this._setToKv('dcs', dcs, true);
+    }
+    getDefaultDcs() {
+        return this._getFromKv('dcs');
+    }
+    async getAuthKeyFor(dcId, tempIndex) {
+        let row;
+        if (tempIndex !== undefined) {
+            const os = this.db.transaction(TABLES.tempAuthKeys).objectStore(TABLES.tempAuthKeys);
+            row = await reqToPromise(os.get([dcId, tempIndex]));
+            if (row === undefined || row.expiresAt < Date.now())
+                return null;
+        }
+        else {
+            const os = this.db.transaction(TABLES.authKeys).objectStore(TABLES.authKeys);
+            row = await reqToPromise(os.get(dcId));
+            if (row === undefined)
+                return null;
+        }
+        return row.key;
+    }
+    async setAuthKeyFor(dcId, key) {
+        const os = this.db.transaction(TABLES.authKeys, 'readwrite').objectStore(TABLES.authKeys);
+        if (key === null) {
+            return reqToPromise(os.delete(dcId));
+        }
+        await reqToPromise(os.put({ dc: dcId, key }));
+    }
+    async setTempAuthKeyFor(dcId, index, key, expiresAt) {
+        const os = this.db.transaction(TABLES.tempAuthKeys, 'readwrite').objectStore(TABLES.tempAuthKeys);
+        if (key === null) {
+            return reqToPromise(os.delete([dcId, index]));
+        }
+        await reqToPromise(os.put({ dc: dcId, idx: index, key, expiresAt }));
+    }
+    async dropAuthKeysFor(dcId) {
+        const tx = this.db.transaction([TABLES.authKeys, TABLES.tempAuthKeys], 'readwrite');
+        tx.objectStore(TABLES.authKeys).delete(dcId);
+        // IndexedDB sucks
+        const tempOs = tx.objectStore(TABLES.tempAuthKeys);
+        const keys = await reqToPromise(tempOs.getAllKeys());
+        for (const key of keys) {
+            if (key[0] === dcId) {
+                tempOs.delete(key);
+            }
+        }
+    }
+    async getSelf() {
+        if (this._cachedSelf !== undefined)
+            return this._cachedSelf;
+        const self = await this._getFromKv('self');
+        this._cachedSelf = self;
+        return self;
+    }
+    async setSelf(self) {
+        this._cachedSelf = self;
+        return this._setToKv('self', self, true);
+    }
+    async getUpdatesState() {
+        const os = this.db.transaction(TABLES.kv).objectStore(TABLES.kv);
+        const [pts, qts, date, seq] = await Promise.all([
+            reqToPromise(os.get('pts')),
+            reqToPromise(os.get('qts')),
+            reqToPromise(os.get('date')),
+            reqToPromise(os.get('seq')),
+        ]);
+        if (pts === undefined || qts === undefined || date === undefined || seq === undefined)
+            return null;
+        return [Number(pts.value), Number(qts.value), Number(date.value), Number(seq.value)];
+    }
+    setUpdatesPts(val) {
+        return this._setToKv('pts', val);
+    }
+    setUpdatesQts(val) {
+        return this._setToKv('qts', val);
+    }
+    setUpdatesDate(val) {
+        return this._setToKv('date', val);
+    }
+    setUpdatesSeq(val) {
+        return this._setToKv('seq', val);
+    }
+    async getChannelPts(entityId) {
+        const os = this.db.transaction(TABLES.pts).objectStore(TABLES.pts);
+        const row = await reqToPromise(os.get(entityId));
+        if (row === undefined)
+            return null;
+        return row.pts;
+    }
+    async setManyChannelPts(values) {
+        const tx = this.db.transaction(TABLES.pts, 'readwrite');
+        const os = tx.objectStore(TABLES.pts);
+        for (const [id, pts] of values) {
+            os.put({ channelId: id, pts });
+        }
+        return txToPromise(tx);
+    }
+    updatePeers(peers) {
+        for (const peer of peers) {
+            const dto = {
+                id: peer.id,
+                hash: (0, long_utils_js_1.longToFastString)(peer.accessHash),
+                type: peer.type,
+                username: peer.username,
+                phone: peer.phone,
+                updated: Date.now(),
+                full: tl_runtime_1.TlBinaryWriter.serializeObject(this.writerMap, peer.full),
+            };
+            this._writeLater(TABLES.entities, dto);
+            if (!this._cachedSelf?.isBot) {
+                this._writeLater(TABLES.messageRefs, null);
+            }
+            this._cache?.set(peer.id, {
+                peer: getInputPeer(peer),
+                full: peer.full,
+            });
+        }
+    }
+    async _findPeerByReference(os, peerId) {
+        const row = await reqToPromise(os.get(peerId));
+        if (row === undefined)
+            return null;
+        const chat = await this.getPeerById(row.chatId, false);
+        if (chat === null)
+            return null;
+        if (peerId > 0) {
+            return {
+                _: 'inputPeerUserFromMessage',
+                userId: peerId,
+                peer: chat,
+                msgId: row.msgId,
+            };
+        }
+        return {
+            _: 'inputPeerChannelFromMessage',
+            channelId: (0, peer_utils_js_1.toggleChannelIdMark)(peerId),
+            peer: chat,
+            msgId: row.msgId,
+        };
+    }
+    async getPeerById(peerId, allowRefs = true) {
+        const cached = this._cache?.get(peerId);
+        if (cached)
+            return cached.peer;
+        const tx = this.db.transaction([TABLES.entities, TABLES.messageRefs]);
+        const entOs = tx.objectStore(TABLES.entities);
+        const row = await reqToPromise(entOs.get(peerId));
+        if (row) {
+            return getInputPeer(row);
+        }
+        if (allowRefs) {
+            return this._findPeerByReference(tx.objectStore(TABLES.messageRefs), peerId);
+        }
+        return null;
+    }
+    async getPeerByUsername(username) {
+        const tx = this.db.transaction(TABLES.entities);
+        const os = tx.objectStore(TABLES.entities);
+        const row = await reqToPromise(os.index('by_username').get(username));
+        if (row === undefined)
+            return null;
+        return getInputPeer(row);
+    }
+    async getPeerByPhone(phone) {
+        const tx = this.db.transaction(TABLES.entities);
+        const os = tx.objectStore(TABLES.entities);
+        const row = await reqToPromise(os.index('by_phone').get(phone));
+        if (row === undefined)
+            return null;
+        return getInputPeer(row);
+    }
+    async getFullPeerById(peerId) {
+        const cached = this._cache?.get(peerId);
+        if (cached)
+            return cached.full;
+        const tx = this.db.transaction(TABLES.entities);
+        const os = tx.objectStore(TABLES.entities);
+        const row = await reqToPromise(os.get(peerId));
+        if (row === undefined)
+            return null;
+        return this._readFullPeer(row.full);
+    }
+    async saveReferenceMessage(peerId, chatId, messageId) {
+        const os = this.db.transaction(TABLES.messageRefs, 'readwrite').objectStore(TABLES.messageRefs);
+        await reqToPromise(os.put({ peerId, chatId, msgId: messageId }));
+    }
+    async deleteReferenceMessages(chatId, messageIds) {
+        const tx = this.db.transaction(TABLES.messageRefs, 'readwrite');
+        const os = tx.objectStore(TABLES.messageRefs);
+        const index = os.index('by_msg');
+        for (const msgId of messageIds) {
+            const key = await reqToPromise(index.getKey([chatId, msgId]));
+            if (key === undefined)
+                continue;
+            os.delete(key);
+        }
+        return txToPromise(tx);
+    }
+    // IStateStorage implementation
+    async getState(key) {
+        const tx = this.db.transaction(TABLES.state, 'readwrite');
+        const os = tx.objectStore(TABLES.state);
+        const row = await reqToPromise(os.get(key));
+        if (!row)
+            return null;
+        if (row.expires && row.expires < Date.now()) {
+            await reqToPromise(os.delete(key));
+            return null;
+        }
+        return JSON.parse(row.value);
+    }
+    async setState(key, state, ttl) {
+        const tx = this.db.transaction(TABLES.state, 'readwrite');
+        const os = tx.objectStore(TABLES.state);
+        const dto = {
+            key,
+            value: JSON.stringify(state),
+            expires: ttl ? Date.now() + ttl * 1000 : undefined,
+        };
+        await reqToPromise(os.put(dto));
+    }
+    async deleteState(key) {
+        const tx = this.db.transaction(TABLES.state, 'readwrite');
+        const os = tx.objectStore(TABLES.state);
+        await reqToPromise(os.delete(key));
+    }
+    getCurrentScene(key) {
+        return this.getState(`$current_scene_${key}`);
+    }
+    setCurrentScene(key, scene, ttl) {
+        return this.setState(`$current_scene_${key}`, scene, ttl);
+    }
+    deleteCurrentScene(key) {
+        return this.deleteState(`$current_scene_${key}`);
+    }
+    async getRateLimit(key, limit, window) {
+        // leaky bucket
+        const now = Date.now();
+        const tx = this.db.transaction(TABLES.state, 'readwrite');
+        const os = tx.objectStore(TABLES.state);
+        const row = await reqToPromise(os.get(`$rate_limit_${key}`));
+        if (!row || row.expires < now) {
+            // expired or does not exist
+            const dto = {
+                key: `$rate_limit_${key}`,
+                value: limit.toString(),
+                expires: now + window * 1000,
+            };
+            await reqToPromise(os.put(dto));
+            return [limit, dto.expires];
+        }
+        let value = Number(row.value);
+        if (value > 0) {
+            value -= 1;
+            row.value = value.toString();
+            await reqToPromise(os.put(row));
+        }
+        return [value, row.expires];
+    }
+    resetRateLimit(key) {
+        return this.deleteState(`$rate_limit_${key}`);
+    }
+}
+exports.IdbStorage = IdbStorage;
+//# sourceMappingURL=idb.js.map