@mtcute/postgres 0.29.1 → 0.29.2

package/README.md

@@ -35,9 +35,30 @@ console.log(`logged in as ${self.displayName}`)
 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)
+    // Whether to automatically close the client when the storage is destroyed (default: false)
     // Calls .end(), .release(), or .close() depending on what the client supports
     autoClose: true,
+    // Account tag for multi-account isolation within the same schema (default: 'default')
+    account: 'bot-1',
+})
+```
+
+## Multi-account
+
+Multiple clients can share the same database and schema by using different `account` tags.
+Each account's data is fully isolated from others:
+
+```ts
+const pool = new pg.Pool({ connectionString: 'postgres://localhost/mydb' })
+
+const bot1 = new TelegramClient({
+    storage: new PostgresStorage(pool, { account: 'bot-1' }),
+    // ...
+})
+
+const bot2 = new TelegramClient({
+    storage: new PostgresStorage(pool, { account: 'bot-2' }),
+    // ...
 })
 ```
 
@@ -72,8 +93,8 @@ 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.
+> **Note:** By default, mtcute does **not** close the client when the storage is destroyed.
+> Set `autoClose: true` if you want the storage to call `.end()`, `.release()`, or `.close()` automatically.
 
 ## Database schema
 

package/driver.cjs

@@ -9,16 +9,18 @@ const core = require("@mtcute/core");
 class PostgresStorageDriver extends core.BaseStorageDriver {
   client;
   schema;
+  account;
   _cleanup;
   _migrations = /* @__PURE__ */ new Map();
   _maxVersion = /* @__PURE__ */ new Map();
   _onLoadCallbacks = /* @__PURE__ */ new Set();
-  _autoClose = true;
+  _autoClose = false;
   constructor(client, options) {
     super();
     this.client = client;
     this.schema = options?.schema ?? "mtcute";
-    this._autoClose = options?.autoClose ?? true;
+    this.account = options?.account ?? "default";
+    this._autoClose = options?.autoClose ?? false;
   }
   /** Returns a schema-qualified table name, safe for interpolation into SQL */
   tableName(name) {

package/driver.d.cts

@@ -23,13 +23,20 @@ export interface PostgresStorageDriverOptions {
     /**
      * Whether to automatically close the client when the driver is destroyed.
      *
-     * @default true
+     * @default false
      */
     autoClose?: boolean;
+    /**
+     * Account tag used to isolate data when multiple clients share the same database and schema.
+     *
+     * @default 'default'
+     */
+    account?: string;
 }
 export declare class PostgresStorageDriver extends BaseStorageDriver {
     readonly client: PgClient;
     readonly schema: string;
+    readonly account: string;
     private _cleanup?;
     private _migrations;
     private _maxVersion;

package/driver.d.ts

@@ -23,13 +23,20 @@ export interface PostgresStorageDriverOptions {
     /**
      * Whether to automatically close the client when the driver is destroyed.
      *
-     * @default true
+     * @default false
      */
     autoClose?: boolean;
+    /**
+     * Account tag used to isolate data when multiple clients share the same database and schema.
+     *
+     * @default 'default'
+     */
+    account?: string;
 }
 export declare class PostgresStorageDriver extends BaseStorageDriver {
     readonly client: PgClient;
     readonly schema: string;
+    readonly account: string;
     private _cleanup?;
     private _migrations;
     private _maxVersion;

package/driver.js

@@ -2,16 +2,18 @@ import { BaseStorageDriver } from "@mtcute/core";
 class PostgresStorageDriver extends BaseStorageDriver {
   client;
   schema;
+  account;
   _cleanup;
   _migrations = /* @__PURE__ */ new Map();
   _maxVersion = /* @__PURE__ */ new Map();
   _onLoadCallbacks = /* @__PURE__ */ new Set();
-  _autoClose = true;
+  _autoClose = false;
   constructor(client, options) {
     super();
     this.client = client;
     this.schema = options?.schema ?? "mtcute";
-    this._autoClose = options?.autoClose ?? true;
+    this.account = options?.account ?? "default";
+    this._autoClose = options?.autoClose ?? false;
   }
   /** Returns a schema-qualified table name, safe for interpolation into SQL */
   tableName(name) {

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@mtcute/postgres",
     "type": "module",
-    "version": "0.29.1",
+    "version": "0.29.2",
     "description": "PostgreSQL storage for mtcute",
     "license": "MIT",
     "dependencies": {

package/repository/auth-keys.cjs

@@ -27,53 +27,71 @@ class PostgresAuthKeysRepository {
         );
       `);
     });
+    _driver.registerMigration("auth_keys", 2, async (client) => {
+      await client.query(`alter table ${this._authKeys} add column account text not null default 'default'`);
+      await client.query(`alter table ${this._authKeys} drop constraint auth_keys_pkey`);
+      await client.query(`alter table ${this._authKeys} add primary key (account, dc)`);
+      await client.query(`alter table ${this._tempAuthKeys} add column account text not null default 'default'`);
+      await client.query(`alter table ${this._tempAuthKeys} drop constraint temp_auth_keys_pkey`);
+      await client.query(`alter table ${this._tempAuthKeys} add primary key (account, dc, idx)`);
+    });
   }
   _authKeys;
   _tempAuthKeys;
+  get _account() {
+    return this._driver.account;
+  }
   async set(dc, key) {
     if (!key) {
-      await this._driver.client.query(`delete from ${this._authKeys} where dc = $1`, [dc]);
+      await this._driver.client.query(
+        `delete from ${this._authKeys} where account = $1 and dc = $2`,
+        [this._account, 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]
+      `insert into ${this._authKeys} (account, dc, key) values ($1, $2, $3)
+       on conflict (account, dc) do update set key = $3`,
+      [this._account, dc, key]
     );
   }
   async get(dc) {
-    const res = await this._driver.client.query(`select key from ${this._authKeys} where dc = $1`, [dc]);
+    const res = await this._driver.client.query(
+      `select key from ${this._authKeys} where account = $1 and dc = $2`,
+      [this._account, 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]
+        `delete from ${this._tempAuthKeys} where account = $1 and dc = $2 and idx = $3`,
+        [this._account, 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]
+      `insert into ${this._tempAuthKeys} (account, dc, idx, key, expires) values ($1, $2, $3, $4, $5)
+       on conflict (account, dc, idx) do update set key = $4, expires = $5`,
+      [this._account, 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]
+      `select key from ${this._tempAuthKeys} where account = $1 and dc = $2 and idx = $3 and expires > $4`,
+      [this._account, 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]);
+    await this._driver.client.query(`delete from ${this._authKeys} where account = $1 and dc = $2`, [this._account, dc]);
+    await this._driver.client.query(`delete from ${this._tempAuthKeys} where account = $1 and dc = $2`, [this._account, dc]);
   }
   async deleteAll() {
-    await this._driver.client.query(`delete from ${this._authKeys}`);
-    await this._driver.client.query(`delete from ${this._tempAuthKeys}`);
+    await this._driver.client.query(`delete from ${this._authKeys} where account = $1`, [this._account]);
+    await this._driver.client.query(`delete from ${this._tempAuthKeys} where account = $1`, [this._account]);
   }
 }
 exports.PostgresAuthKeysRepository = PostgresAuthKeysRepository;

package/repository/auth-keys.d.cts

@@ -5,6 +5,7 @@ export declare class PostgresAuthKeysRepository implements IAuthKeysRepository {
     private _authKeys;
     private _tempAuthKeys;
     constructor(_driver: PostgresStorageDriver);
+    private get _account();
     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>;

package/repository/auth-keys.d.ts

@@ -5,6 +5,7 @@ export declare class PostgresAuthKeysRepository implements IAuthKeysRepository {
     private _authKeys;
     private _tempAuthKeys;
     constructor(_driver: PostgresStorageDriver);
+    private get _account();
     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>;

package/repository/auth-keys.js

@@ -20,53 +20,71 @@ class PostgresAuthKeysRepository {
         );
       `);
     });
+    _driver.registerMigration("auth_keys", 2, async (client) => {
+      await client.query(`alter table ${this._authKeys} add column account text not null default 'default'`);
+      await client.query(`alter table ${this._authKeys} drop constraint auth_keys_pkey`);
+      await client.query(`alter table ${this._authKeys} add primary key (account, dc)`);
+      await client.query(`alter table ${this._tempAuthKeys} add column account text not null default 'default'`);
+      await client.query(`alter table ${this._tempAuthKeys} drop constraint temp_auth_keys_pkey`);
+      await client.query(`alter table ${this._tempAuthKeys} add primary key (account, dc, idx)`);
+    });
   }
   _authKeys;
   _tempAuthKeys;
+  get _account() {
+    return this._driver.account;
+  }
   async set(dc, key) {
     if (!key) {
-      await this._driver.client.query(`delete from ${this._authKeys} where dc = $1`, [dc]);
+      await this._driver.client.query(
+        `delete from ${this._authKeys} where account = $1 and dc = $2`,
+        [this._account, 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]
+      `insert into ${this._authKeys} (account, dc, key) values ($1, $2, $3)
+       on conflict (account, dc) do update set key = $3`,
+      [this._account, dc, key]
     );
   }
   async get(dc) {
-    const res = await this._driver.client.query(`select key from ${this._authKeys} where dc = $1`, [dc]);
+    const res = await this._driver.client.query(
+      `select key from ${this._authKeys} where account = $1 and dc = $2`,
+      [this._account, 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]
+        `delete from ${this._tempAuthKeys} where account = $1 and dc = $2 and idx = $3`,
+        [this._account, 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]
+      `insert into ${this._tempAuthKeys} (account, dc, idx, key, expires) values ($1, $2, $3, $4, $5)
+       on conflict (account, dc, idx) do update set key = $4, expires = $5`,
+      [this._account, 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]
+      `select key from ${this._tempAuthKeys} where account = $1 and dc = $2 and idx = $3 and expires > $4`,
+      [this._account, 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]);
+    await this._driver.client.query(`delete from ${this._authKeys} where account = $1 and dc = $2`, [this._account, dc]);
+    await this._driver.client.query(`delete from ${this._tempAuthKeys} where account = $1 and dc = $2`, [this._account, dc]);
   }
   async deleteAll() {
-    await this._driver.client.query(`delete from ${this._authKeys}`);
-    await this._driver.client.query(`delete from ${this._tempAuthKeys}`);
+    await this._driver.client.query(`delete from ${this._authKeys} where account = $1`, [this._account]);
+    await this._driver.client.query(`delete from ${this._tempAuthKeys} where account = $1`, [this._account]);
   }
 }
 export {

package/repository/kv.cjs

@@ -17,24 +17,39 @@ class PostgresKeyValueRepository {
         );
       `);
     });
+    _driver.registerMigration("kv", 2, async (client) => {
+      await client.query(`alter table ${this._table} add column account text not null default 'default'`);
+      await client.query(`alter table ${this._table} drop constraint key_value_pkey`);
+      await client.query(`alter table ${this._table} add primary key (account, key)`);
+    });
   }
   _table;
+  get _account() {
+    return this._driver.account;
+  }
   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]
+      `insert into ${this._table} (account, key, value) values ($1, $2, $3)
+       on conflict (account, key) do update set value = $3`,
+      [this._account, key, value]
     );
   }
   async get(key) {
-    const res = await this._driver.client.query(`select value from ${this._table} where key = $1`, [key]);
+    const res = await this._driver.client.query(
+      `select value from ${this._table} where account = $1 and key = $2`,
+      [this._account, 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]);
+    await this._driver.client.query(
+      `delete from ${this._table} where account = $1 and key = $2`,
+      [this._account, key]
+    );
   }
   async deleteAll() {
-    await this._driver.client.query(`delete from ${this._table}`);
+    await this._driver.client.query(`delete from ${this._table} where account = $1`, [this._account]);
   }
 }
 exports.PostgresKeyValueRepository = PostgresKeyValueRepository;

package/repository/kv.d.cts

@@ -4,6 +4,7 @@ export declare class PostgresKeyValueRepository implements IKeyValueRepository {
     readonly _driver: PostgresStorageDriver;
     private _table;
     constructor(_driver: PostgresStorageDriver);
+    private get _account();
     set(key: string, value: Uint8Array): Promise<void>;
     get(key: string): Promise<Uint8Array | null>;
     delete(key: string): Promise<void>;

package/repository/kv.d.ts

@@ -4,6 +4,7 @@ export declare class PostgresKeyValueRepository implements IKeyValueRepository {
     readonly _driver: PostgresStorageDriver;
     private _table;
     constructor(_driver: PostgresStorageDriver);
+    private get _account();
     set(key: string, value: Uint8Array): Promise<void>;
     get(key: string): Promise<Uint8Array | null>;
     delete(key: string): Promise<void>;

package/repository/kv.js

@@ -10,24 +10,39 @@ class PostgresKeyValueRepository {
         );
       `);
     });
+    _driver.registerMigration("kv", 2, async (client) => {
+      await client.query(`alter table ${this._table} add column account text not null default 'default'`);
+      await client.query(`alter table ${this._table} drop constraint key_value_pkey`);
+      await client.query(`alter table ${this._table} add primary key (account, key)`);
+    });
   }
   _table;
+  get _account() {
+    return this._driver.account;
+  }
   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]
+      `insert into ${this._table} (account, key, value) values ($1, $2, $3)
+       on conflict (account, key) do update set value = $3`,
+      [this._account, key, value]
     );
   }
   async get(key) {
-    const res = await this._driver.client.query(`select value from ${this._table} where key = $1`, [key]);
+    const res = await this._driver.client.query(
+      `select value from ${this._table} where account = $1 and key = $2`,
+      [this._account, 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]);
+    await this._driver.client.query(
+      `delete from ${this._table} where account = $1 and key = $2`,
+      [this._account, key]
+    );
   }
   async deleteAll() {
-    await this._driver.client.query(`delete from ${this._table}`);
+    await this._driver.client.query(`delete from ${this._table} where account = $1`, [this._account]);
   }
 }
 export {

package/repository/peers.cjs

@@ -38,12 +38,22 @@ class PostgresPeersRepository {
         create index if not exists idx_peers_phone on ${this._table} (phone);
       `);
     });
+    _driver.registerMigration("peers", 2, async (client) => {
+      await client.query(`alter table ${this._table} add column account text not null default 'default'`);
+      await client.query(`alter table ${this._table} drop constraint peers_pkey`);
+      await client.query(`alter table ${this._table} add primary key (account, id)`);
+      await client.query(`drop index if exists ${_driver.tableName("idx_peers_phone")}`);
+      await client.query(`create index idx_peers_phone on ${this._table} (account, phone)`);
+    });
     _driver.onLoad(() => {
       this._loaded = true;
     });
   }
   _loaded = false;
   _table;
+  get _account() {
+    return this._driver.account;
+  }
   _ensureLoaded() {
     if (!this._loaded) {
       throw new core.MtcuteError("Peers repository is not loaded. Have you called client.start() (or similar)?");
@@ -51,11 +61,12 @@ class PostgresPeersRepository {
   }
   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`,
+      `insert into ${this._table} (account, id, hash, is_min, usernames, updated, phone, complete)
+       values ($1, $2, $3, $4, $5, $6, $7, $8)
+       on conflict (account, id) do update set
+          hash = $3, is_min = $4, usernames = $5, updated = $6, phone = $7, complete = $8`,
       [
+        this._account,
         peer.id,
         peer.accessHash,
         peer.isMin,
@@ -68,15 +79,18 @@ class PostgresPeersRepository {
   }
   async getById(id) {
     this._ensureLoaded();
-    const res = await this._driver.client.query(`select * from ${this._table} where id = $1`, [id]);
+    const res = await this._driver.client.query(
+      `select * from ${this._table} where account = $1 and id = $2`,
+      [this._account, 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]
+      `select * from ${this._table} where account = $1 and usernames ? $2 and is_min = false`,
+      [this._account, username]
     );
     if (!res.rows[0]) return null;
     return mapPeerDto(res.rows[0]);
@@ -84,14 +98,14 @@ class PostgresPeersRepository {
   async getByPhone(phone) {
     this._ensureLoaded();
     const res = await this._driver.client.query(
-      `select * from ${this._table} where phone = $1 and is_min = false`,
-      [phone]
+      `select * from ${this._table} where account = $1 and phone = $2 and is_min = false`,
+      [this._account, phone]
     );
     if (!res.rows[0]) return null;
     return mapPeerDto(res.rows[0]);
   }
   async deleteAll() {
-    await this._driver.client.query(`delete from ${this._table}`);
+    await this._driver.client.query(`delete from ${this._table} where account = $1`, [this._account]);
   }
 }
 exports.PostgresPeersRepository = PostgresPeersRepository;

package/repository/peers.d.cts

@@ -5,6 +5,7 @@ export declare class PostgresPeersRepository implements IPeersRepository {
     private _loaded;
     private _table;
     constructor(_driver: PostgresStorageDriver);
+    private get _account();
     private _ensureLoaded;
     store(peer: IPeersRepository.PeerInfo): Promise<void>;
     getById(id: number): Promise<IPeersRepository.PeerInfo | null>;

package/repository/peers.d.ts

@@ -5,6 +5,7 @@ export declare class PostgresPeersRepository implements IPeersRepository {
     private _loaded;
     private _table;
     constructor(_driver: PostgresStorageDriver);
+    private get _account();
     private _ensureLoaded;
     store(peer: IPeersRepository.PeerInfo): Promise<void>;
     getById(id: number): Promise<IPeersRepository.PeerInfo | null>;

package/repository/peers.js

@@ -31,12 +31,22 @@ class PostgresPeersRepository {
         create index if not exists idx_peers_phone on ${this._table} (phone);
       `);
     });
+    _driver.registerMigration("peers", 2, async (client) => {
+      await client.query(`alter table ${this._table} add column account text not null default 'default'`);
+      await client.query(`alter table ${this._table} drop constraint peers_pkey`);
+      await client.query(`alter table ${this._table} add primary key (account, id)`);
+      await client.query(`drop index if exists ${_driver.tableName("idx_peers_phone")}`);
+      await client.query(`create index idx_peers_phone on ${this._table} (account, phone)`);
+    });
     _driver.onLoad(() => {
       this._loaded = true;
     });
   }
   _loaded = false;
   _table;
+  get _account() {
+    return this._driver.account;
+  }
   _ensureLoaded() {
     if (!this._loaded) {
       throw new MtcuteError("Peers repository is not loaded. Have you called client.start() (or similar)?");
@@ -44,11 +54,12 @@ class PostgresPeersRepository {
   }
   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`,
+      `insert into ${this._table} (account, id, hash, is_min, usernames, updated, phone, complete)
+       values ($1, $2, $3, $4, $5, $6, $7, $8)
+       on conflict (account, id) do update set
+          hash = $3, is_min = $4, usernames = $5, updated = $6, phone = $7, complete = $8`,
       [
+        this._account,
         peer.id,
         peer.accessHash,
         peer.isMin,
@@ -61,15 +72,18 @@ class PostgresPeersRepository {
   }
   async getById(id) {
     this._ensureLoaded();
-    const res = await this._driver.client.query(`select * from ${this._table} where id = $1`, [id]);
+    const res = await this._driver.client.query(
+      `select * from ${this._table} where account = $1 and id = $2`,
+      [this._account, 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]
+      `select * from ${this._table} where account = $1 and usernames ? $2 and is_min = false`,
+      [this._account, username]
     );
     if (!res.rows[0]) return null;
     return mapPeerDto(res.rows[0]);
@@ -77,14 +91,14 @@ class PostgresPeersRepository {
   async getByPhone(phone) {
     this._ensureLoaded();
     const res = await this._driver.client.query(
-      `select * from ${this._table} where phone = $1 and is_min = false`,
-      [phone]
+      `select * from ${this._table} where account = $1 and phone = $2 and is_min = false`,
+      [this._account, phone]
     );
     if (!res.rows[0]) return null;
     return mapPeerDto(res.rows[0]);
   }
   async deleteAll() {
-    await this._driver.client.query(`delete from ${this._table}`);
+    await this._driver.client.query(`delete from ${this._table} where account = $1`, [this._account]);
   }
 }
 export {

package/repository/ref-messages.cjs

@@ -21,18 +21,28 @@ class PostgresRefMessagesRepository {
       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);`);
     });
+    _driver.registerMigration("ref_messages", 2, async (client) => {
+      await client.query(`alter table ${this._table} add column account text not null default 'default'`);
+      await client.query(`drop index if exists ${_driver.tableName("idx_message_refs_peer")}`);
+      await client.query(`drop index if exists ${_driver.tableName("idx_message_refs")}`);
+      await client.query(`create index idx_message_refs_peer on ${this._table} (account, peer_id)`);
+      await client.query(`create index idx_message_refs on ${this._table} (account, chat_id, msg_id)`);
+    });
   }
   _table;
+  get _account() {
+    return this._driver.account;
+  }
   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]
+      `insert into ${this._table} (account, peer_id, chat_id, msg_id) values ($1, $2, $3, $4)`,
+      [this._account, 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]
+      `select chat_id, msg_id from ${this._table} where account = $1 and peer_id = $2 limit 1`,
+      [this._account, peerId]
     );
     if (!res.rows[0]) return null;
     const row = res.rows[0];
@@ -41,15 +51,18 @@ class PostgresRefMessagesRepository {
   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]
+      `delete from ${this._table} where account = $1 and chat_id = $2 and msg_id = any($3)`,
+      [this._account, chatId, msgIds]
     );
   }
   async deleteByPeer(peerId) {
-    await this._driver.client.query(`delete from ${this._table} where peer_id = $1`, [peerId]);
+    await this._driver.client.query(
+      `delete from ${this._table} where account = $1 and peer_id = $2`,
+      [this._account, peerId]
+    );
   }
   async deleteAll() {
-    await this._driver.client.query(`delete from ${this._table}`);
+    await this._driver.client.query(`delete from ${this._table} where account = $1`, [this._account]);
   }
 }
 exports.PostgresRefMessagesRepository = PostgresRefMessagesRepository;

package/repository/ref-messages.d.cts

@@ -4,6 +4,7 @@ export declare class PostgresRefMessagesRepository implements IReferenceMessages
     readonly _driver: PostgresStorageDriver;
     private _table;
     constructor(_driver: PostgresStorageDriver);
+    private get _account();
     store(peerId: number, chatId: number, msgId: number): Promise<void>;
     getByPeer(peerId: number): Promise<[number, number] | null>;
     delete(chatId: number, msgIds: number[]): Promise<void>;

package/repository/ref-messages.d.ts

@@ -4,6 +4,7 @@ export declare class PostgresRefMessagesRepository implements IReferenceMessages
     readonly _driver: PostgresStorageDriver;
     private _table;
     constructor(_driver: PostgresStorageDriver);
+    private get _account();
     store(peerId: number, chatId: number, msgId: number): Promise<void>;
     getByPeer(peerId: number): Promise<[number, number] | null>;
     delete(chatId: number, msgIds: number[]): Promise<void>;

package/repository/ref-messages.js

@@ -14,18 +14,28 @@ class PostgresRefMessagesRepository {
       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);`);
     });
+    _driver.registerMigration("ref_messages", 2, async (client) => {
+      await client.query(`alter table ${this._table} add column account text not null default 'default'`);
+      await client.query(`drop index if exists ${_driver.tableName("idx_message_refs_peer")}`);
+      await client.query(`drop index if exists ${_driver.tableName("idx_message_refs")}`);
+      await client.query(`create index idx_message_refs_peer on ${this._table} (account, peer_id)`);
+      await client.query(`create index idx_message_refs on ${this._table} (account, chat_id, msg_id)`);
+    });
   }
   _table;
+  get _account() {
+    return this._driver.account;
+  }
   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]
+      `insert into ${this._table} (account, peer_id, chat_id, msg_id) values ($1, $2, $3, $4)`,
+      [this._account, 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]
+      `select chat_id, msg_id from ${this._table} where account = $1 and peer_id = $2 limit 1`,
+      [this._account, peerId]
     );
     if (!res.rows[0]) return null;
     const row = res.rows[0];
@@ -34,15 +44,18 @@ class PostgresRefMessagesRepository {
   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]
+      `delete from ${this._table} where account = $1 and chat_id = $2 and msg_id = any($3)`,
+      [this._account, chatId, msgIds]
     );
   }
   async deleteByPeer(peerId) {
-    await this._driver.client.query(`delete from ${this._table} where peer_id = $1`, [peerId]);
+    await this._driver.client.query(
+      `delete from ${this._table} where account = $1 and peer_id = $2`,
+      [this._account, peerId]
+    );
   }
   async deleteAll() {
-    await this._driver.client.query(`delete from ${this._table}`);
+    await this._driver.client.query(`delete from ${this._table} where account = $1`, [this._account]);
   }
 }
 export {