@mtcute/postgres 0.29.1

package/LICENSE

@@ -0,0 +1,8 @@
+Copyright 2023 alina sireneva
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

package/README.md

@@ -0,0 +1,89 @@
+# @mtcute/postgres
+
+PostgreSQL storage provider for mtcute. Uses any `pg`-compatible client (Pool, Client, or PoolClient).
+
+All tables are created in a dedicated schema (`mtcute` by default), with automatic migrations.
+
+## Installation
+
+```bash
+pnpm add @mtcute/postgres pg
+```
+
+## Usage
+
+```ts
+import { TelegramClient } from '@mtcute/node'
+import { PostgresStorage } from '@mtcute/postgres'
+import pg from 'pg'
+
+const pool = new pg.Pool({ connectionString: 'postgres://localhost/mydb' })
+
+const tg = new TelegramClient({
+    apiId: 12345,
+    apiHash: 'abcdef',
+    storage: new PostgresStorage(pool),
+})
+
+const self = await tg.start()
+console.log(`logged in as ${self.displayName}`)
+```
+
+## Options
+
+```ts
+new PostgresStorage(pool, {
+    // PostgreSQL schema to use for all tables (default: 'mtcute')
+    schema: 'my_schema',
+    // Whether to automatically close the client when the storage is destroyed (default: true)
+    // Calls .end(), .release(), or .close() depending on what the client supports
+    autoClose: true,
+})
+```
+
+## Using with PGlite
+
+You can use [PGlite](https://github.com/electric-sql/pglite) for an embedded PostgreSQL instance that requires no external server:
+
+```ts
+import { PGlite } from '@electric-sql/pglite'
+import { PostgresStorage } from '@mtcute/postgres'
+
+const pglite = await PGlite.create()
+const storage = new PostgresStorage(pglite)
+```
+
+PGlite satisfies the `PgClient` interface out of the box, so no adapters are needed.
+
+## Using with an existing connection
+
+You can pass any object that satisfies the `PgClient` interface (a `query` method matching `pg`'s signature):
+
+```ts
+import { PostgresStorage } from '@mtcute/postgres'
+
+// with a single client
+const client = new pg.Client({ connectionString: '...' })
+await client.connect()
+const storage = new PostgresStorage(client)
+
+// with a pool client
+const poolClient = await pool.connect()
+const storage = new PostgresStorage(poolClient)
+```
+
+> **Note:** By default, mtcute will automatically close the client (via `.end()`, `.release()`, or `.close()`)
+> when the storage is destroyed. Set `autoClose: false` if you want to manage the connection lifecycle yourself.
+
+## Database schema
+
+All tables are created under the configured schema (default `mtcute`). The following tables are used:
+
+| Table | Purpose |
+|-------|---------|
+| `migrations` | Tracks migration versions per repository |
+| `auth_keys` | Persistent authorization keys per DC |
+| `temp_auth_keys` | Temporary authorization keys with expiry |
+| `key_value` | General-purpose key-value store |
+| `peers` | Cached peer information (users, chats, channels) |
+| `message_refs` | Reference messages for peer access hash resolution |

package/_utils.cjs

@@ -0,0 +1,15 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[@mtcute/postgres] CommonJS bundles are deprecated. They will be removed completely in one of the upcoming releases. No support is provided for CommonJS users. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[@mtcute/postgres] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function parseBigint(value) {
+  return typeof value === "string" ? Number(value) : value;
+}
+function parseJsonb(value) {
+  return typeof value === "string" ? JSON.parse(value) : value;
+}
+exports.parseBigint = parseBigint;
+exports.parseJsonb = parseJsonb;

package/_utils.d.cts

@@ -0,0 +1,2 @@
+export declare function parseBigint(value: string | number): number;
+export declare function parseJsonb<T>(value: unknown): T;

package/_utils.d.ts

@@ -0,0 +1,2 @@
+export declare function parseBigint(value: string | number): number;
+export declare function parseJsonb<T>(value: unknown): T;

package/_utils.js

@@ -0,0 +1,10 @@
+function parseBigint(value) {
+  return typeof value === "string" ? Number(value) : value;
+}
+function parseJsonb(value) {
+  return typeof value === "string" ? JSON.parse(value) : value;
+}
+export {
+  parseBigint,
+  parseJsonb
+};

package/driver.cjs

@@ -0,0 +1,110 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[@mtcute/postgres] CommonJS bundles are deprecated. They will be removed completely in one of the upcoming releases. No support is provided for CommonJS users. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[@mtcute/postgres] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const core = require("@mtcute/core");
+class PostgresStorageDriver extends core.BaseStorageDriver {
+  client;
+  schema;
+  _cleanup;
+  _migrations = /* @__PURE__ */ new Map();
+  _maxVersion = /* @__PURE__ */ new Map();
+  _onLoadCallbacks = /* @__PURE__ */ new Set();
+  _autoClose = true;
+  constructor(client, options) {
+    super();
+    this.client = client;
+    this.schema = options?.schema ?? "mtcute";
+    this._autoClose = options?.autoClose ?? true;
+  }
+  /** Returns a schema-qualified table name, safe for interpolation into SQL */
+  tableName(name) {
+    return `"${this.schema}"."${name}"`;
+  }
+  setup(log, platform) {
+    super.setup(log, platform);
+    this._log = log.create("postgres");
+  }
+  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);
+    }
+  }
+  onLoad(cb) {
+    if (this.loaded) {
+      cb();
+    } else {
+      this._onLoadCallbacks.add(cb);
+    }
+  }
+  async _runMigrations() {
+    const migrationsTable = this.tableName("migrations");
+    await this.client.query(`create schema if not exists "${this.schema}"`);
+    await this.client.query(`
+      create table if not exists ${migrationsTable} (
+          repo text not null primary key,
+          version integer not null
+      )
+    `);
+    for (const repo of this._migrations.keys()) {
+      const res = await this.client.query(
+        `select version from ${migrationsTable} where repo = $1`,
+        [repo]
+      );
+      const startVersion = res.rows[0]?.version ?? 0;
+      let fromVersion = startVersion;
+      const migrations = this._migrations.get(repo);
+      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}`);
+        }
+        await migration(this.client);
+        fromVersion = nextVersion;
+      }
+      if (fromVersion !== startVersion) {
+        await this.client.query(
+          `insert into ${migrationsTable} (repo, version) values ($1, $2)
+           on conflict (repo) do update set version = $2`,
+          [repo, targetVer]
+        );
+      }
+    }
+  }
+  async _load() {
+    await this._runMigrations();
+    this._cleanup = this._platform.beforeExit(() => {
+      void this._destroy();
+    });
+    for (const cb of this._onLoadCallbacks) cb();
+  }
+  _save() {
+  }
+  async _destroy() {
+    this._cleanup?.();
+    this._cleanup = void 0;
+    if (this._autoClose) {
+      const fn = this.client.end ?? this.client.release ?? this.client.close;
+      if (fn) await fn.call(this.client);
+    }
+  }
+}
+exports.PostgresStorageDriver = PostgresStorageDriver;

package/driver.d.cts

@@ -0,0 +1,49 @@
+import { ICorePlatform, MaybePromise, BaseStorageDriver } from '@mtcute/core';
+import { Logger } from '@mtcute/core/utils.js';
+/**
+ * Minimal interface for a pg-compatible client.
+ * Satisfied by `pg.Pool`, `pg.Client`, and `pg.PoolClient`, as well as `PGlite`.
+ */
+export interface PgClient {
+    query<T>(query: string, values?: unknown[]): Promise<{
+        rows: T[];
+    }>;
+    close?(): MaybePromise<void>;
+    end?(): MaybePromise<void>;
+    release?(): MaybePromise<void>;
+}
+type MigrationFunction = (client: PgClient) => Promise<void>;
+export interface PostgresStorageDriverOptions {
+    /**
+     * PostgreSQL schema to use for all tables.
+     *
+     * @default 'mtcute'
+     */
+    schema?: string;
+    /**
+     * Whether to automatically close the client when the driver is destroyed.
+     *
+     * @default true
+     */
+    autoClose?: boolean;
+}
+export declare class PostgresStorageDriver extends BaseStorageDriver {
+    readonly client: PgClient;
+    readonly schema: string;
+    private _cleanup?;
+    private _migrations;
+    private _maxVersion;
+    private _onLoadCallbacks;
+    private _autoClose;
+    constructor(client: PgClient, options?: PostgresStorageDriverOptions);
+    /** Returns a schema-qualified table name, safe for interpolation into SQL */
+    tableName(name: string): string;
+    setup(log: Logger, platform: ICorePlatform): void;
+    registerMigration(repo: string, version: number, migration: MigrationFunction): void;
+    onLoad(cb: () => void): void;
+    private _runMigrations;
+    _load(): Promise<void>;
+    _save(): void;
+    _destroy(): Promise<void>;
+}
+export {};

package/driver.d.ts

@@ -0,0 +1,49 @@
+import { ICorePlatform, MaybePromise, BaseStorageDriver } from '@mtcute/core';
+import { Logger } from '@mtcute/core/utils.js';
+/**
+ * Minimal interface for a pg-compatible client.
+ * Satisfied by `pg.Pool`, `pg.Client`, and `pg.PoolClient`, as well as `PGlite`.
+ */
+export interface PgClient {
+    query<T>(query: string, values?: unknown[]): Promise<{
+        rows: T[];
+    }>;
+    close?(): MaybePromise<void>;
+    end?(): MaybePromise<void>;
+    release?(): MaybePromise<void>;
+}
+type MigrationFunction = (client: PgClient) => Promise<void>;
+export interface PostgresStorageDriverOptions {
+    /**
+     * PostgreSQL schema to use for all tables.
+     *
+     * @default 'mtcute'
+     */
+    schema?: string;
+    /**
+     * Whether to automatically close the client when the driver is destroyed.
+     *
+     * @default true
+     */
+    autoClose?: boolean;
+}
+export declare class PostgresStorageDriver extends BaseStorageDriver {
+    readonly client: PgClient;
+    readonly schema: string;
+    private _cleanup?;
+    private _migrations;
+    private _maxVersion;
+    private _onLoadCallbacks;
+    private _autoClose;
+    constructor(client: PgClient, options?: PostgresStorageDriverOptions);
+    /** Returns a schema-qualified table name, safe for interpolation into SQL */
+    tableName(name: string): string;
+    setup(log: Logger, platform: ICorePlatform): void;
+    registerMigration(repo: string, version: number, migration: MigrationFunction): void;
+    onLoad(cb: () => void): void;
+    private _runMigrations;
+    _load(): Promise<void>;
+    _save(): void;
+    _destroy(): Promise<void>;
+}
+export {};

package/driver.js

@@ -0,0 +1,105 @@
+import { BaseStorageDriver } from "@mtcute/core";
+class PostgresStorageDriver extends BaseStorageDriver {
+  client;
+  schema;
+  _cleanup;
+  _migrations = /* @__PURE__ */ new Map();
+  _maxVersion = /* @__PURE__ */ new Map();
+  _onLoadCallbacks = /* @__PURE__ */ new Set();
+  _autoClose = true;
+  constructor(client, options) {
+    super();
+    this.client = client;
+    this.schema = options?.schema ?? "mtcute";
+    this._autoClose = options?.autoClose ?? true;
+  }
+  /** Returns a schema-qualified table name, safe for interpolation into SQL */
+  tableName(name) {
+    return `"${this.schema}"."${name}"`;
+  }
+  setup(log, platform) {
+    super.setup(log, platform);
+    this._log = log.create("postgres");
+  }
+  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);
+    }
+  }
+  onLoad(cb) {
+    if (this.loaded) {
+      cb();
+    } else {
+      this._onLoadCallbacks.add(cb);
+    }
+  }
+  async _runMigrations() {
+    const migrationsTable = this.tableName("migrations");
+    await this.client.query(`create schema if not exists "${this.schema}"`);
+    await this.client.query(`
+      create table if not exists ${migrationsTable} (
+          repo text not null primary key,
+          version integer not null
+      )
+    `);
+    for (const repo of this._migrations.keys()) {
+      const res = await this.client.query(
+        `select version from ${migrationsTable} where repo = $1`,
+        [repo]
+      );
+      const startVersion = res.rows[0]?.version ?? 0;
+      let fromVersion = startVersion;
+      const migrations = this._migrations.get(repo);
+      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}`);
+        }
+        await migration(this.client);
+        fromVersion = nextVersion;
+      }
+      if (fromVersion !== startVersion) {
+        await this.client.query(
+          `insert into ${migrationsTable} (repo, version) values ($1, $2)
+           on conflict (repo) do update set version = $2`,
+          [repo, targetVer]
+        );
+      }
+    }
+  }
+  async _load() {
+    await this._runMigrations();
+    this._cleanup = this._platform.beforeExit(() => {
+      void this._destroy();
+    });
+    for (const cb of this._onLoadCallbacks) cb();
+  }
+  _save() {
+  }
+  async _destroy() {
+    this._cleanup?.();
+    this._cleanup = void 0;
+    if (this._autoClose) {
+      const fn = this.client.end ?? this.client.release ?? this.client.close;
+      if (fn) await fn.call(this.client);
+    }
+  }
+}
+export {
+  PostgresStorageDriver
+};

package/index.cjs

@@ -0,0 +1,32 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[@mtcute/postgres] CommonJS bundles are deprecated. They will be removed completely in one of the upcoming releases. No support is provided for CommonJS users. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[@mtcute/postgres] 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 PostgresStorage {
+  driver;
+  authKeys;
+  kv;
+  peers;
+  refMessages;
+  constructor(client, options) {
+    this.driver = new driver.PostgresStorageDriver(client, options);
+    this.authKeys = new authKeys.PostgresAuthKeysRepository(this.driver);
+    this.kv = new kv.PostgresKeyValueRepository(this.driver);
+    this.peers = new peers.PostgresPeersRepository(this.driver);
+    this.refMessages = new refMessages.PostgresRefMessagesRepository(this.driver);
+  }
+}
+exports.PostgresStorageDriver = driver.PostgresStorageDriver;
+exports.PostgresAuthKeysRepository = authKeys.PostgresAuthKeysRepository;
+exports.PostgresKeyValueRepository = kv.PostgresKeyValueRepository;
+exports.PostgresPeersRepository = peers.PostgresPeersRepository;
+exports.PostgresRefMessagesRepository = refMessages.PostgresRefMessagesRepository;
+exports.PostgresStorage = PostgresStorage;

package/index.d.cts

@@ -0,0 +1,20 @@
+import { IMtStorageProvider, ITelegramStorageProvider } from '@mtcute/core';
+import { PgClient, PostgresStorageDriverOptions, PostgresStorageDriver } from './driver.js';
+import { PostgresAuthKeysRepository } from './repository/auth-keys.js';
+import { PostgresKeyValueRepository } from './repository/kv.js';
+import { PostgresPeersRepository } from './repository/peers.js';
+import { PostgresRefMessagesRepository } from './repository/ref-messages.js';
+export type { PgClient, PostgresStorageDriverOptions } from './driver.js';
+export { PostgresStorageDriver } from './driver.js';
+export { PostgresAuthKeysRepository } from './repository/auth-keys.js';
+export { PostgresKeyValueRepository } from './repository/kv.js';
+export { PostgresPeersRepository } from './repository/peers.js';
+export { PostgresRefMessagesRepository } from './repository/ref-messages.js';
+export declare class PostgresStorage implements IMtStorageProvider, ITelegramStorageProvider {
+    readonly driver: PostgresStorageDriver;
+    readonly authKeys: PostgresAuthKeysRepository;
+    readonly kv: PostgresKeyValueRepository;
+    readonly peers: PostgresPeersRepository;
+    readonly refMessages: PostgresRefMessagesRepository;
+    constructor(client: PgClient, options?: PostgresStorageDriverOptions);
+}

package/index.d.ts

@@ -0,0 +1,20 @@
+import { IMtStorageProvider, ITelegramStorageProvider } from '@mtcute/core';
+import { PgClient, PostgresStorageDriverOptions, PostgresStorageDriver } from './driver.js';
+import { PostgresAuthKeysRepository } from './repository/auth-keys.js';
+import { PostgresKeyValueRepository } from './repository/kv.js';
+import { PostgresPeersRepository } from './repository/peers.js';
+import { PostgresRefMessagesRepository } from './repository/ref-messages.js';
+export type { PgClient, PostgresStorageDriverOptions } from './driver.js';
+export { PostgresStorageDriver } from './driver.js';
+export { PostgresAuthKeysRepository } from './repository/auth-keys.js';
+export { PostgresKeyValueRepository } from './repository/kv.js';
+export { PostgresPeersRepository } from './repository/peers.js';
+export { PostgresRefMessagesRepository } from './repository/ref-messages.js';
+export declare class PostgresStorage implements IMtStorageProvider, ITelegramStorageProvider {
+    readonly driver: PostgresStorageDriver;
+    readonly authKeys: PostgresAuthKeysRepository;
+    readonly kv: PostgresKeyValueRepository;
+    readonly peers: PostgresPeersRepository;
+    readonly refMessages: PostgresRefMessagesRepository;
+    constructor(client: PgClient, options?: PostgresStorageDriverOptions);
+}

package/index.js

@@ -0,0 +1,27 @@
+import { PostgresStorageDriver } from "./driver.js";
+import { PostgresAuthKeysRepository } from "./repository/auth-keys.js";
+import { PostgresKeyValueRepository } from "./repository/kv.js";
+import { PostgresPeersRepository } from "./repository/peers.js";
+import { PostgresRefMessagesRepository } from "./repository/ref-messages.js";
+class PostgresStorage {
+  driver;
+  authKeys;
+  kv;
+  peers;
+  refMessages;
+  constructor(client, options) {
+    this.driver = new PostgresStorageDriver(client, options);
+    this.authKeys = new PostgresAuthKeysRepository(this.driver);
+    this.kv = new PostgresKeyValueRepository(this.driver);
+    this.peers = new PostgresPeersRepository(this.driver);
+    this.refMessages = new PostgresRefMessagesRepository(this.driver);
+  }
+}
+export {
+  PostgresAuthKeysRepository,
+  PostgresKeyValueRepository,
+  PostgresPeersRepository,
+  PostgresRefMessagesRepository,
+  PostgresStorage,
+  PostgresStorageDriver
+};

package/package.json

@@ -0,0 +1,30 @@
+{
+    "name": "@mtcute/postgres",
+    "type": "module",
+    "version": "0.29.1",
+    "description": "PostgreSQL storage for mtcute",
+    "license": "MIT",
+    "dependencies": {
+        "@mtcute/core": "^0.29.1"
+    },
+    "exports": {
+        ".": {
+            "import": {
+                "types": "./index.d.ts",
+                "default": "./index.js"
+            },
+            "require": {
+                "types": "./index.d.cts",
+                "default": "./index.cjs"
+            }
+        }
+    },
+    "author": "alina sireneva <alina@tei.su>",
+    "sideEffects": false,
+    "homepage": "https://mtcute.dev",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/mtcute/mtcute.git"
+    },
+    "scripts": {}
+}

package/postgres.test-d.d.cts

@@ -0,0 +1 @@
+export {};

package/postgres.test-d.d.ts

@@ -0,0 +1 @@
+export {};

package/postgres.test.d.cts

@@ -0,0 +1 @@
+export {};

package/postgres.test.d.ts

@@ -0,0 +1 @@
+export {};

package/repository/auth-keys.cjs

@@ -0,0 +1,79 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[@mtcute/postgres] CommonJS bundles are deprecated. They will be removed completely in one of the upcoming releases. No support is provided for CommonJS users. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[@mtcute/postgres] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+class PostgresAuthKeysRepository {
+  constructor(_driver) {
+    this._driver = _driver;
+    this._authKeys = _driver.tableName("auth_keys");
+    this._tempAuthKeys = _driver.tableName("temp_auth_keys");
+    _driver.registerMigration("auth_keys", 1, async (client) => {
+      await client.query(`
+        create table if not exists ${this._authKeys} (
+            dc integer primary key,
+            key bytea not null
+        );
+      `);
+      await client.query(`
+        create table if not exists ${this._tempAuthKeys} (
+            dc integer not null,
+            idx integer not null,
+            key bytea not null,
+            expires integer not null,
+            primary key (dc, idx)
+        );
+      `);
+    });
+  }
+  _authKeys;
+  _tempAuthKeys;
+  async set(dc, key) {
+    if (!key) {
+      await this._driver.client.query(`delete from ${this._authKeys} where dc = $1`, [dc]);
+      return;
+    }
+    await this._driver.client.query(
+      `insert into ${this._authKeys} (dc, key) values ($1, $2) on conflict (dc) do update set key = $2`,
+      [dc, key]
+    );
+  }
+  async get(dc) {
+    const res = await this._driver.client.query(`select key from ${this._authKeys} where dc = $1`, [dc]);
+    if (!res.rows[0]) return null;
+    return new Uint8Array(res.rows[0].key);
+  }
+  async setTemp(dc, idx, key, expires) {
+    if (!key) {
+      await this._driver.client.query(
+        `delete from ${this._tempAuthKeys} where dc = $1 and idx = $2`,
+        [dc, idx]
+      );
+      return;
+    }
+    await this._driver.client.query(
+      `insert into ${this._tempAuthKeys} (dc, idx, key, expires) values ($1, $2, $3, $4)
+       on conflict (dc, idx) do update set key = $3, expires = $4`,
+      [dc, idx, key, expires]
+    );
+  }
+  async getTemp(dc, idx, now) {
+    const res = await this._driver.client.query(
+      `select key from ${this._tempAuthKeys} where dc = $1 and idx = $2 and expires > $3`,
+      [dc, idx, now]
+    );
+    if (!res.rows[0]) return null;
+    return new Uint8Array(res.rows[0].key);
+  }
+  async deleteByDc(dc) {
+    await this._driver.client.query(`delete from ${this._authKeys} where dc = $1`, [dc]);
+    await this._driver.client.query(`delete from ${this._tempAuthKeys} where dc = $1`, [dc]);
+  }
+  async deleteAll() {
+    await this._driver.client.query(`delete from ${this._authKeys}`);
+    await this._driver.client.query(`delete from ${this._tempAuthKeys}`);
+  }
+}
+exports.PostgresAuthKeysRepository = PostgresAuthKeysRepository;

package/repository/auth-keys.d.cts

@@ -0,0 +1,14 @@
+import { IAuthKeysRepository } from '@mtcute/core';
+import { PostgresStorageDriver } from '../driver.js';
+export declare class PostgresAuthKeysRepository implements IAuthKeysRepository {
+    readonly _driver: PostgresStorageDriver;
+    private _authKeys;
+    private _tempAuthKeys;
+    constructor(_driver: PostgresStorageDriver);
+    set(dc: number, key: Uint8Array | null): Promise<void>;
+    get(dc: number): Promise<Uint8Array | null>;
+    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/repository/auth-keys.d.ts

@@ -0,0 +1,14 @@
+import { IAuthKeysRepository } from '@mtcute/core';
+import { PostgresStorageDriver } from '../driver.js';
+export declare class PostgresAuthKeysRepository implements IAuthKeysRepository {
+    readonly _driver: PostgresStorageDriver;
+    private _authKeys;
+    private _tempAuthKeys;
+    constructor(_driver: PostgresStorageDriver);
+    set(dc: number, key: Uint8Array | null): Promise<void>;
+    get(dc: number): Promise<Uint8Array | null>;
+    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/repository/auth-keys.js

@@ -0,0 +1,74 @@
+class PostgresAuthKeysRepository {
+  constructor(_driver) {
+    this._driver = _driver;
+    this._authKeys = _driver.tableName("auth_keys");
+    this._tempAuthKeys = _driver.tableName("temp_auth_keys");
+    _driver.registerMigration("auth_keys", 1, async (client) => {
+      await client.query(`
+        create table if not exists ${this._authKeys} (
+            dc integer primary key,
+            key bytea not null
+        );
+      `);
+      await client.query(`
+        create table if not exists ${this._tempAuthKeys} (
+            dc integer not null,
+            idx integer not null,
+            key bytea not null,
+            expires integer not null,
+            primary key (dc, idx)
+        );
+      `);
+    });
+  }
+  _authKeys;
+  _tempAuthKeys;
+  async set(dc, key) {
+    if (!key) {
+      await this._driver.client.query(`delete from ${this._authKeys} where dc = $1`, [dc]);
+      return;
+    }
+    await this._driver.client.query(
+      `insert into ${this._authKeys} (dc, key) values ($1, $2) on conflict (dc) do update set key = $2`,
+      [dc, key]
+    );
+  }
+  async get(dc) {
+    const res = await this._driver.client.query(`select key from ${this._authKeys} where dc = $1`, [dc]);
+    if (!res.rows[0]) return null;
+    return new Uint8Array(res.rows[0].key);
+  }
+  async setTemp(dc, idx, key, expires) {
+    if (!key) {
+      await this._driver.client.query(
+        `delete from ${this._tempAuthKeys} where dc = $1 and idx = $2`,
+        [dc, idx]
+      );
+      return;
+    }
+    await this._driver.client.query(
+      `insert into ${this._tempAuthKeys} (dc, idx, key, expires) values ($1, $2, $3, $4)
+       on conflict (dc, idx) do update set key = $3, expires = $4`,
+      [dc, idx, key, expires]
+    );
+  }
+  async getTemp(dc, idx, now) {
+    const res = await this._driver.client.query(
+      `select key from ${this._tempAuthKeys} where dc = $1 and idx = $2 and expires > $3`,
+      [dc, idx, now]
+    );
+    if (!res.rows[0]) return null;
+    return new Uint8Array(res.rows[0].key);
+  }
+  async deleteByDc(dc) {
+    await this._driver.client.query(`delete from ${this._authKeys} where dc = $1`, [dc]);
+    await this._driver.client.query(`delete from ${this._tempAuthKeys} where dc = $1`, [dc]);
+  }
+  async deleteAll() {
+    await this._driver.client.query(`delete from ${this._authKeys}`);
+    await this._driver.client.query(`delete from ${this._tempAuthKeys}`);
+  }
+}
+export {
+  PostgresAuthKeysRepository
+};

package/repository/kv.cjs

@@ -0,0 +1,40 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[@mtcute/postgres] CommonJS bundles are deprecated. They will be removed completely in one of the upcoming releases. No support is provided for CommonJS users. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[@mtcute/postgres] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+class PostgresKeyValueRepository {
+  constructor(_driver) {
+    this._driver = _driver;
+    this._table = _driver.tableName("key_value");
+    _driver.registerMigration("kv", 1, async (client) => {
+      await client.query(`
+        create table if not exists ${this._table} (
+            key text primary key,
+            value bytea not null
+        );
+      `);
+    });
+  }
+  _table;
+  async set(key, value) {
+    await this._driver.client.query(
+      `insert into ${this._table} (key, value) values ($1, $2) on conflict (key) do update set value = $2`,
+      [key, value]
+    );
+  }
+  async get(key) {
+    const res = await this._driver.client.query(`select value from ${this._table} where key = $1`, [key]);
+    if (!res.rows[0]) return null;
+    return new Uint8Array(res.rows[0].value);
+  }
+  async delete(key) {
+    await this._driver.client.query(`delete from ${this._table} where key = $1`, [key]);
+  }
+  async deleteAll() {
+    await this._driver.client.query(`delete from ${this._table}`);
+  }
+}
+exports.PostgresKeyValueRepository = PostgresKeyValueRepository;

package/repository/kv.d.cts

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

package/repository/kv.d.ts

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

package/repository/kv.js

@@ -0,0 +1,35 @@
+class PostgresKeyValueRepository {
+  constructor(_driver) {
+    this._driver = _driver;
+    this._table = _driver.tableName("key_value");
+    _driver.registerMigration("kv", 1, async (client) => {
+      await client.query(`
+        create table if not exists ${this._table} (
+            key text primary key,
+            value bytea not null
+        );
+      `);
+    });
+  }
+  _table;
+  async set(key, value) {
+    await this._driver.client.query(
+      `insert into ${this._table} (key, value) values ($1, $2) on conflict (key) do update set value = $2`,
+      [key, value]
+    );
+  }
+  async get(key) {
+    const res = await this._driver.client.query(`select value from ${this._table} where key = $1`, [key]);
+    if (!res.rows[0]) return null;
+    return new Uint8Array(res.rows[0].value);
+  }
+  async delete(key) {
+    await this._driver.client.query(`delete from ${this._table} where key = $1`, [key]);
+  }
+  async deleteAll() {
+    await this._driver.client.query(`delete from ${this._table}`);
+  }
+}
+export {
+  PostgresKeyValueRepository
+};

package/repository/peers.cjs

@@ -0,0 +1,97 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[@mtcute/postgres] CommonJS bundles are deprecated. They will be removed completely in one of the upcoming releases. No support is provided for CommonJS users. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[@mtcute/postgres] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const core = require("@mtcute/core");
+const _utils = require("../_utils.cjs");
+function mapPeerDto(dto) {
+  return {
+    id: Number(dto.id),
+    accessHash: dto.hash,
+    isMin: dto.is_min,
+    usernames: _utils.parseJsonb(dto.usernames),
+    updated: _utils.parseBigint(dto.updated),
+    phone: dto.phone || void 0,
+    complete: new Uint8Array(dto.complete)
+  };
+}
+class PostgresPeersRepository {
+  constructor(_driver) {
+    this._driver = _driver;
+    this._table = _driver.tableName("peers");
+    _driver.registerMigration("peers", 1, async (client) => {
+      await client.query(`
+        create table if not exists ${this._table} (
+            id bigint primary key,
+            hash text not null,
+            is_min boolean not null default false,
+            usernames jsonb not null,
+            updated bigint not null,
+            phone text,
+            complete bytea
+        );
+      `);
+      await client.query(`
+        create index if not exists idx_peers_phone on ${this._table} (phone);
+      `);
+    });
+    _driver.onLoad(() => {
+      this._loaded = true;
+    });
+  }
+  _loaded = false;
+  _table;
+  _ensureLoaded() {
+    if (!this._loaded) {
+      throw new core.MtcuteError("Peers repository is not loaded. Have you called client.start() (or similar)?");
+    }
+  }
+  async store(peer) {
+    await this._driver.client.query(
+      `insert into ${this._table} (id, hash, is_min, usernames, updated, phone, complete)
+       values ($1, $2, $3, $4, $5, $6, $7)
+       on conflict (id) do update set
+          hash = $2, is_min = $3, usernames = $4, updated = $5, phone = $6, complete = $7`,
+      [
+        peer.id,
+        peer.accessHash,
+        peer.isMin,
+        JSON.stringify(peer.usernames),
+        peer.updated,
+        peer.phone ?? null,
+        peer.complete
+      ]
+    );
+  }
+  async getById(id) {
+    this._ensureLoaded();
+    const res = await this._driver.client.query(`select * from ${this._table} where id = $1`, [id]);
+    if (!res.rows[0]) return null;
+    return mapPeerDto(res.rows[0]);
+  }
+  async getByUsername(username) {
+    this._ensureLoaded();
+    const res = await this._driver.client.query(
+      `select * from ${this._table} where usernames ? $1 and is_min = false`,
+      [username]
+    );
+    if (!res.rows[0]) return null;
+    return mapPeerDto(res.rows[0]);
+  }
+  async getByPhone(phone) {
+    this._ensureLoaded();
+    const res = await this._driver.client.query(
+      `select * from ${this._table} where phone = $1 and is_min = false`,
+      [phone]
+    );
+    if (!res.rows[0]) return null;
+    return mapPeerDto(res.rows[0]);
+  }
+  async deleteAll() {
+    await this._driver.client.query(`delete from ${this._table}`);
+  }
+}
+exports.PostgresPeersRepository = PostgresPeersRepository;

package/repository/peers.d.cts

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

package/repository/peers.d.ts

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

package/repository/peers.js

@@ -0,0 +1,92 @@
+import { MtcuteError } from "@mtcute/core";
+import { parseBigint, parseJsonb } from "../_utils.js";
+function mapPeerDto(dto) {
+  return {
+    id: Number(dto.id),
+    accessHash: dto.hash,
+    isMin: dto.is_min,
+    usernames: parseJsonb(dto.usernames),
+    updated: parseBigint(dto.updated),
+    phone: dto.phone || void 0,
+    complete: new Uint8Array(dto.complete)
+  };
+}
+class PostgresPeersRepository {
+  constructor(_driver) {
+    this._driver = _driver;
+    this._table = _driver.tableName("peers");
+    _driver.registerMigration("peers", 1, async (client) => {
+      await client.query(`
+        create table if not exists ${this._table} (
+            id bigint primary key,
+            hash text not null,
+            is_min boolean not null default false,
+            usernames jsonb not null,
+            updated bigint not null,
+            phone text,
+            complete bytea
+        );
+      `);
+      await client.query(`
+        create index if not exists idx_peers_phone on ${this._table} (phone);
+      `);
+    });
+    _driver.onLoad(() => {
+      this._loaded = true;
+    });
+  }
+  _loaded = false;
+  _table;
+  _ensureLoaded() {
+    if (!this._loaded) {
+      throw new MtcuteError("Peers repository is not loaded. Have you called client.start() (or similar)?");
+    }
+  }
+  async store(peer) {
+    await this._driver.client.query(
+      `insert into ${this._table} (id, hash, is_min, usernames, updated, phone, complete)
+       values ($1, $2, $3, $4, $5, $6, $7)
+       on conflict (id) do update set
+          hash = $2, is_min = $3, usernames = $4, updated = $5, phone = $6, complete = $7`,
+      [
+        peer.id,
+        peer.accessHash,
+        peer.isMin,
+        JSON.stringify(peer.usernames),
+        peer.updated,
+        peer.phone ?? null,
+        peer.complete
+      ]
+    );
+  }
+  async getById(id) {
+    this._ensureLoaded();
+    const res = await this._driver.client.query(`select * from ${this._table} where id = $1`, [id]);
+    if (!res.rows[0]) return null;
+    return mapPeerDto(res.rows[0]);
+  }
+  async getByUsername(username) {
+    this._ensureLoaded();
+    const res = await this._driver.client.query(
+      `select * from ${this._table} where usernames ? $1 and is_min = false`,
+      [username]
+    );
+    if (!res.rows[0]) return null;
+    return mapPeerDto(res.rows[0]);
+  }
+  async getByPhone(phone) {
+    this._ensureLoaded();
+    const res = await this._driver.client.query(
+      `select * from ${this._table} where phone = $1 and is_min = false`,
+      [phone]
+    );
+    if (!res.rows[0]) return null;
+    return mapPeerDto(res.rows[0]);
+  }
+  async deleteAll() {
+    await this._driver.client.query(`delete from ${this._table}`);
+  }
+}
+export {
+  PostgresPeersRepository
+};

package/repository/ref-messages.cjs

@@ -0,0 +1,55 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[@mtcute/postgres] CommonJS bundles are deprecated. They will be removed completely in one of the upcoming releases. No support is provided for CommonJS users. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[@mtcute/postgres] 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");
+class PostgresRefMessagesRepository {
+  constructor(_driver) {
+    this._driver = _driver;
+    this._table = _driver.tableName("message_refs");
+    _driver.registerMigration("ref_messages", 1, async (client) => {
+      await client.query(`
+        create table if not exists ${this._table} (
+            peer_id bigint not null,
+            chat_id bigint not null,
+            msg_id integer not null
+        );
+      `);
+      await client.query(`create index if not exists idx_message_refs_peer on ${this._table} (peer_id);`);
+      await client.query(`create index if not exists idx_message_refs on ${this._table} (chat_id, msg_id);`);
+    });
+  }
+  _table;
+  async store(peerId, chatId, msgId) {
+    await this._driver.client.query(
+      `insert into ${this._table} (peer_id, chat_id, msg_id) values ($1, $2, $3)`,
+      [peerId, chatId, msgId]
+    );
+  }
+  async getByPeer(peerId) {
+    const res = await this._driver.client.query(
+      `select chat_id, msg_id from ${this._table} where peer_id = $1 limit 1`,
+      [peerId]
+    );
+    if (!res.rows[0]) return null;
+    const row = res.rows[0];
+    return [_utils.parseBigint(row.chat_id), row.msg_id];
+  }
+  async delete(chatId, msgIds) {
+    if (msgIds.length === 0) return;
+    await this._driver.client.query(
+      `delete from ${this._table} where chat_id = $1 and msg_id = any($2)`,
+      [chatId, msgIds]
+    );
+  }
+  async deleteByPeer(peerId) {
+    await this._driver.client.query(`delete from ${this._table} where peer_id = $1`, [peerId]);
+  }
+  async deleteAll() {
+    await this._driver.client.query(`delete from ${this._table}`);
+  }
+}
+exports.PostgresRefMessagesRepository = PostgresRefMessagesRepository;

package/repository/ref-messages.d.cts

@@ -0,0 +1,12 @@
+import { IReferenceMessagesRepository } from '@mtcute/core';
+import { PostgresStorageDriver } from '../driver.js';
+export declare class PostgresRefMessagesRepository implements IReferenceMessagesRepository {
+    readonly _driver: PostgresStorageDriver;
+    private _table;
+    constructor(_driver: PostgresStorageDriver);
+    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/repository/ref-messages.d.ts

@@ -0,0 +1,12 @@
+import { IReferenceMessagesRepository } from '@mtcute/core';
+import { PostgresStorageDriver } from '../driver.js';
+export declare class PostgresRefMessagesRepository implements IReferenceMessagesRepository {
+    readonly _driver: PostgresStorageDriver;
+    private _table;
+    constructor(_driver: PostgresStorageDriver);
+    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/repository/ref-messages.js

@@ -0,0 +1,50 @@
+import { parseBigint } from "../_utils.js";
+class PostgresRefMessagesRepository {
+  constructor(_driver) {
+    this._driver = _driver;
+    this._table = _driver.tableName("message_refs");
+    _driver.registerMigration("ref_messages", 1, async (client) => {
+      await client.query(`
+        create table if not exists ${this._table} (
+            peer_id bigint not null,
+            chat_id bigint not null,
+            msg_id integer not null
+        );
+      `);
+      await client.query(`create index if not exists idx_message_refs_peer on ${this._table} (peer_id);`);
+      await client.query(`create index if not exists idx_message_refs on ${this._table} (chat_id, msg_id);`);
+    });
+  }
+  _table;
+  async store(peerId, chatId, msgId) {
+    await this._driver.client.query(
+      `insert into ${this._table} (peer_id, chat_id, msg_id) values ($1, $2, $3)`,
+      [peerId, chatId, msgId]
+    );
+  }
+  async getByPeer(peerId) {
+    const res = await this._driver.client.query(
+      `select chat_id, msg_id from ${this._table} where peer_id = $1 limit 1`,
+      [peerId]
+    );
+    if (!res.rows[0]) return null;
+    const row = res.rows[0];
+    return [parseBigint(row.chat_id), row.msg_id];
+  }
+  async delete(chatId, msgIds) {
+    if (msgIds.length === 0) return;
+    await this._driver.client.query(
+      `delete from ${this._table} where chat_id = $1 and msg_id = any($2)`,
+      [chatId, msgIds]
+    );
+  }
+  async deleteByPeer(peerId) {
+    await this._driver.client.query(`delete from ${this._table} where peer_id = $1`, [peerId]);
+  }
+  async deleteAll() {
+    await this._driver.client.query(`delete from ${this._table}`);
+  }
+}
+export {
+  PostgresRefMessagesRepository
+};