@massalabs/gossip-sdk 0.0.2-dev.20260223131319 → 0.0.2-dev.20260224143454

package/dist/db/generated-migrations.d.ts

@@ -0,0 +1,7 @@
+export interface EmbeddedMigration {
+    idx: number;
+    tag: string;
+    when: number;
+    statements: string[];
+}
+export declare const MIGRATIONS: EmbeddedMigration[];

package/dist/db/generated-migrations.js

@@ -0,0 +1,45 @@
+// Auto-generated from drizzle migrations — do not edit manually.
+// Regenerate with: npm run db:generate
+export const MIGRATIONS = [
+    {
+        idx: 0,
+        tag: '0000_nifty_molly_hayes',
+        when: 1771825473415,
+        statements: [
+            'CREATE TABLE `activeSeekers` (\n\t`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,\n\t`seeker` blob NOT NULL\n);',
+            'CREATE INDEX `active_seekers_seeker_idx` ON `activeSeekers` (`seeker`);',
+            'CREATE TABLE `announcementCursors` (\n\t`userId` text PRIMARY KEY NOT NULL,\n\t`counter` text NOT NULL\n);',
+            'CREATE TABLE `contacts` (\n\t`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,\n\t`ownerUserId` text NOT NULL,\n\t`userId` text NOT NULL,\n\t`name` text NOT NULL,\n\t`avatar` text,\n\t`publicKeys` blob NOT NULL,\n\t`isOnline` integer NOT NULL,\n\t`lastSeen` integer NOT NULL,\n\t`createdAt` integer NOT NULL\n);',
+            'CREATE INDEX `contacts_owner_user_idx` ON `contacts` (`ownerUserId`,`userId`);',
+            'CREATE INDEX `contacts_owner_name_idx` ON `contacts` (`ownerUserId`,`name`);',
+            'CREATE TABLE `discussions` (\n\t`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,\n\t`ownerUserId` text NOT NULL,\n\t`contactUserId` text NOT NULL,\n\t`weAccepted` integer DEFAULT false NOT NULL,\n\t`sendAnnouncement` text,\n\t`direction` text NOT NULL,\n\t`status` text NOT NULL,\n\t`nextSeeker` blob,\n\t`initiationAnnouncement` blob,\n\t`announcementMessage` text,\n\t`lastSyncTimestamp` integer,\n\t`customName` text,\n\t`lastMessageId` integer,\n\t`lastMessageContent` text,\n\t`lastMessageTimestamp` integer,\n\t`unreadCount` integer DEFAULT 0 NOT NULL,\n\t`createdAt` integer NOT NULL,\n\t`updatedAt` integer NOT NULL\n);',
+            'CREATE UNIQUE INDEX `discussions_owner_contact_idx` ON `discussions` (`ownerUserId`,`contactUserId`);',
+            'CREATE INDEX `discussions_owner_status_idx` ON `discussions` (`ownerUserId`,`status`);',
+            'CREATE TABLE `messages` (\n\t`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,\n\t`ownerUserId` text NOT NULL,\n\t`contactUserId` text NOT NULL,\n\t`messageId` blob,\n\t`content` text NOT NULL,\n\t`serializedContent` blob,\n\t`type` text NOT NULL,\n\t`direction` text NOT NULL,\n\t`status` text NOT NULL,\n\t`timestamp` integer NOT NULL,\n\t`metadata` text,\n\t`seeker` blob,\n\t`replyTo` text,\n\t`forwardOf` text,\n\t`encryptedMessage` blob,\n\t`whenToSend` integer\n);',
+            'CREATE INDEX `messages_owner_contact_idx` ON `messages` (`ownerUserId`,`contactUserId`);',
+            'CREATE INDEX `messages_owner_status_idx` ON `messages` (`ownerUserId`,`status`);',
+            'CREATE INDEX `messages_owner_contact_status_idx` ON `messages` (`ownerUserId`,`contactUserId`,`status`);',
+            'CREATE INDEX `messages_owner_seeker_idx` ON `messages` (`ownerUserId`,`seeker`);',
+            'CREATE INDEX `messages_owner_contact_dir_idx` ON `messages` (`ownerUserId`,`contactUserId`,`direction`);',
+            'CREATE INDEX `messages_owner_dir_status_idx` ON `messages` (`ownerUserId`,`direction`,`status`);',
+            'CREATE INDEX `messages_timestamp_idx` ON `messages` (`timestamp`);',
+            'CREATE TABLE `pendingAnnouncements` (\n\t`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,\n\t`announcement` blob NOT NULL,\n\t`fetchedAt` integer NOT NULL,\n\t`counter` text\n);',
+            'CREATE UNIQUE INDEX `pending_announcements_announcement_idx` ON `pendingAnnouncements` (`announcement`);',
+            'CREATE INDEX `pending_announcements_fetchedAt_idx` ON `pendingAnnouncements` (`fetchedAt`);',
+            'CREATE TABLE `pendingEncryptedMessages` (\n\t`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,\n\t`seeker` blob NOT NULL,\n\t`ciphertext` blob NOT NULL,\n\t`fetchedAt` integer NOT NULL\n);',
+            'CREATE INDEX `pending_encrypted_seeker_idx` ON `pendingEncryptedMessages` (`seeker`);',
+            'CREATE INDEX `pending_encrypted_fetchedAt_idx` ON `pendingEncryptedMessages` (`fetchedAt`);',
+            'CREATE TABLE `userProfile` (\n\t`userId` text PRIMARY KEY NOT NULL,\n\t`username` text NOT NULL,\n\t`avatar` text,\n\t`bio` text,\n\t`status` text NOT NULL,\n\t`lastSeen` integer NOT NULL,\n\t`createdAt` integer NOT NULL,\n\t`updatedAt` integer NOT NULL,\n\t`lastPublicKeyPush` integer,\n\t`security` text NOT NULL,\n\t`session` blob NOT NULL\n);',
+            'CREATE INDEX `userProfile_username_idx` ON `userProfile` (`username`);',
+            'CREATE INDEX `userProfile_status_idx` ON `userProfile` (`status`);',
+        ],
+    },
+    {
+        idx: 1,
+        tag: '0001_flowery_storm',
+        when: 1771827090330,
+        statements: [
+            'CREATE INDEX `messages_owner_contact_msgid_idx` ON `messages` (`ownerUserId`,`contactUserId`,`messageId`);',
+        ],
+    },
+];

package/dist/db/migrate.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Migration runner for the Gossip SDK SQLite database.
+ *
+ * Tracks applied migrations in a `_migrations` table and runs only
+ * pending ones. Each migration executes in its own transaction so
+ * a failure at migration N leaves 0..N-1 committed.
+ */
+type ExecRaw = (sql: string, params?: unknown[]) => Promise<unknown[][]>;
+type WithTransaction = <T>(fn: () => Promise<T>) => Promise<T>;
+export declare function runMigrations(execRaw: ExecRaw, withTransaction: WithTransaction): Promise<void>;
+export {};

package/dist/db/migrate.js

@@ -0,0 +1,26 @@
+/**
+ * Migration runner for the Gossip SDK SQLite database.
+ *
+ * Tracks applied migrations in a `_migrations` table and runs only
+ * pending ones. Each migration executes in its own transaction so
+ * a failure at migration N leaves 0..N-1 committed.
+ */
+import { MIGRATIONS } from './generated-migrations.js';
+export async function runMigrations(execRaw, withTransaction) {
+    await execRaw(`CREATE TABLE IF NOT EXISTS _migrations (
+      idx INTEGER PRIMARY KEY,
+      tag TEXT NOT NULL,
+      applied_at INTEGER NOT NULL
+    )`);
+    const rows = await execRaw('SELECT MAX(idx) FROM _migrations');
+    const maxApplied = rows[0][0];
+    const pending = MIGRATIONS.filter(m => m.idx > (maxApplied ?? -1));
+    for (const migration of pending) {
+        await withTransaction(async () => {
+            for (const stmt of migration.statements) {
+                await execRaw(stmt);
+            }
+            await execRaw('INSERT INTO _migrations (idx, tag, applied_at) VALUES (?, ?, ?)', [migration.idx, migration.tag, Date.now()]);
+        });
+    }
+}

package/dist/db/node-fs-vfs.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Node.js file-system VFS for wa-sqlite.
+ *
+ * Extends VFS.Base using Node.js `fs` sync APIs for file persistence.
+ * Follows the MemoryVFS pattern but writes to real files on disk.
+ *
+ * Locking: inherited no-ops from VFS.Base (sufficient for single-process).
+ * This VFS will later be replaceable by the encrypted VFS from the storage branch.
+ */
+import * as VFS from 'wa-sqlite/src/VFS.js';
+export declare class NodeFsVFS extends VFS.Base {
+    name: string;
+    private directory;
+    private mapIdToFile;
+    constructor(directory: string);
+    private resolvePath;
+    xOpen(name: string | null, fileId: number, flags: number, pOutFlags: DataView): number;
+    xClose(fileId: number): number;
+    xRead(fileId: number, pData_: {
+        size: number;
+        value: Uint8Array;
+    }, iOffset: number): number;
+    xWrite(fileId: number, pData_: {
+        size: number;
+        value: Uint8Array;
+    }, iOffset: number): number;
+    xTruncate(fileId: number, iSize: number): number;
+    xSync(fileId: number, _flags: number): number;
+    xFileSize(fileId: number, pSize64: DataView): number;
+    xDelete(name: string, _syncDir: number): number;
+    xAccess(name: string, _flags: number, pResOut: DataView): number;
+}

package/dist/db/node-fs-vfs.js

@@ -0,0 +1,165 @@
+/**
+ * Node.js file-system VFS for wa-sqlite.
+ *
+ * Extends VFS.Base using Node.js `fs` sync APIs for file persistence.
+ * Follows the MemoryVFS pattern but writes to real files on disk.
+ *
+ * Locking: inherited no-ops from VFS.Base (sufficient for single-process).
+ * This VFS will later be replaceable by the encrypted VFS from the storage branch.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as VFS from 'wa-sqlite/src/VFS.js';
+export class NodeFsVFS extends VFS.Base {
+    constructor(directory) {
+        super();
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'node-fs'
+        });
+        Object.defineProperty(this, "directory", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "mapIdToFile", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        this.mxPathName = 255;
+        this.directory = directory;
+        fs.mkdirSync(directory, { recursive: true });
+    }
+    resolvePath(name) {
+        return path.join(this.directory, name);
+    }
+    xOpen(name, fileId, flags, pOutFlags) {
+        name =
+            name || Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(36);
+        const filePath = this.resolvePath(name);
+        let openFlags = fs.constants.O_RDWR;
+        if (flags & VFS.SQLITE_OPEN_CREATE) {
+            openFlags |= fs.constants.O_CREAT;
+        }
+        try {
+            const fd = fs.openSync(filePath, openFlags, 0o644);
+            this.mapIdToFile.set(fileId, { name, fd, flags });
+            pOutFlags.setInt32(0, flags, true);
+            return VFS.SQLITE_OK;
+        }
+        catch {
+            return VFS.SQLITE_CANTOPEN;
+        }
+    }
+    xClose(fileId) {
+        const file = this.mapIdToFile.get(fileId);
+        if (!file)
+            return VFS.SQLITE_OK;
+        this.mapIdToFile.delete(fileId);
+        try {
+            fs.closeSync(file.fd);
+        }
+        catch {
+            // ignore close errors
+        }
+        if (file.flags & VFS.SQLITE_OPEN_DELETEONCLOSE) {
+            try {
+                fs.unlinkSync(this.resolvePath(file.name));
+            }
+            catch {
+                // ignore delete errors
+            }
+        }
+        return VFS.SQLITE_OK;
+    }
+    // wa-sqlite d.ts declares pData as { size; value } but runtime passes
+    // a plain Uint8Array. Cast to match the base class signature.
+    xRead(fileId, pData_, iOffset) {
+        const pData = pData_;
+        const file = this.mapIdToFile.get(fileId);
+        if (!file)
+            return VFS.SQLITE_IOERR;
+        try {
+            const nRead = fs.readSync(file.fd, pData, 0, pData.byteLength, iOffset);
+            if (nRead < pData.byteLength) {
+                pData.fill(0, nRead);
+                return VFS.SQLITE_IOERR_SHORT_READ;
+            }
+            return VFS.SQLITE_OK;
+        }
+        catch {
+            return VFS.SQLITE_IOERR;
+        }
+    }
+    xWrite(fileId, pData_, iOffset) {
+        const pData = pData_;
+        const file = this.mapIdToFile.get(fileId);
+        if (!file)
+            return VFS.SQLITE_IOERR;
+        try {
+            fs.writeSync(file.fd, pData, 0, pData.byteLength, iOffset);
+            return VFS.SQLITE_OK;
+        }
+        catch {
+            return VFS.SQLITE_IOERR;
+        }
+    }
+    xTruncate(fileId, iSize) {
+        const file = this.mapIdToFile.get(fileId);
+        if (!file)
+            return VFS.SQLITE_IOERR;
+        try {
+            fs.ftruncateSync(file.fd, iSize);
+            return VFS.SQLITE_OK;
+        }
+        catch {
+            return VFS.SQLITE_IOERR;
+        }
+    }
+    xSync(fileId, _flags) {
+        const file = this.mapIdToFile.get(fileId);
+        if (!file)
+            return VFS.SQLITE_IOERR;
+        try {
+            fs.fsyncSync(file.fd);
+            return VFS.SQLITE_OK;
+        }
+        catch {
+            return VFS.SQLITE_IOERR;
+        }
+    }
+    xFileSize(fileId, pSize64) {
+        const file = this.mapIdToFile.get(fileId);
+        if (!file)
+            return VFS.SQLITE_IOERR;
+        try {
+            const size = fs.fstatSync(file.fd).size;
+            pSize64.setBigInt64(0, BigInt(size), true);
+            return VFS.SQLITE_OK;
+        }
+        catch {
+            return VFS.SQLITE_IOERR;
+        }
+    }
+    xDelete(name, _syncDir) {
+        try {
+            fs.unlinkSync(this.resolvePath(name));
+        }
+        catch (e) {
+            if (e.code !== 'ENOENT') {
+                return VFS.SQLITE_IOERR;
+            }
+        }
+        return VFS.SQLITE_OK;
+    }
+    xAccess(name, _flags, pResOut) {
+        const exists = fs.existsSync(this.resolvePath(name));
+        pResOut.setInt32(0, exists ? 1 : 0, true);
+        return VFS.SQLITE_OK;
+    }
+}

package/dist/db/queries/activeSeekers.d.ts

@@ -1 +1,6 @@
-export declare function replaceActiveSeekers(seekers: Uint8Array[]): Promise<void>;
+import type { DatabaseConnection } from '../sqlite';
+export declare class ActiveSeekerQueries {
+    private conn;
+    constructor(conn: DatabaseConnection);
+    replaceAll(seekers: Uint8Array[]): Promise<void>;
+}

package/dist/db/queries/activeSeekers.js

@@ -1,13 +1,21 @@
 import * as schema from '../schema';
-import { getSqliteDb, withTransaction } from '../sqlite';
-export async function replaceActiveSeekers(seekers) {
-    await withTransaction(async () => {
-        const db = getSqliteDb();
-        await db.delete(schema.activeSeekers);
-        if (seekers.length > 0) {
-            await db
-                .insert(schema.activeSeekers)
-                .values(seekers.map(seeker => ({ seeker })));
-        }
-    });
+export class ActiveSeekerQueries {
+    constructor(conn) {
+        Object.defineProperty(this, "conn", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: conn
+        });
+    }
+    async replaceAll(seekers) {
+        await this.conn.withTransaction(async () => {
+            await this.conn.db.delete(schema.activeSeekers);
+            if (seekers.length > 0) {
+                await this.conn.db
+                    .insert(schema.activeSeekers)
+                    .values(seekers.map(seeker => ({ seeker })));
+            }
+        });
+    }
 }

package/dist/db/queries/announcementCursors.d.ts

@@ -1,2 +1,7 @@
-export declare function getAnnouncementCursor(userId: string): Promise<string | undefined>;
-export declare function upsertAnnouncementCursor(userId: string, counter: string): Promise<void>;
+import type { DatabaseConnection } from '../sqlite';
+export declare class AnnouncementCursorQueries {
+    private conn;
+    constructor(conn: DatabaseConnection);
+    get(userId: string): Promise<string | undefined>;
+    upsert(userId: string, counter: string): Promise<void>;
+}

package/dist/db/queries/announcementCursors.js

@@ -1,20 +1,29 @@
 import { eq } from 'drizzle-orm';
 import * as schema from '../schema';
-import { getSqliteDb } from '../sqlite';
-export async function getAnnouncementCursor(userId) {
-    const row = await getSqliteDb()
-        .select({ counter: schema.announcementCursors.counter })
-        .from(schema.announcementCursors)
-        .where(eq(schema.announcementCursors.userId, userId))
-        .get();
-    return row?.counter;
-}
-export async function upsertAnnouncementCursor(userId, counter) {
-    await getSqliteDb()
-        .insert(schema.announcementCursors)
-        .values({ userId, counter })
-        .onConflictDoUpdate({
-        target: schema.announcementCursors.userId,
-        set: { counter },
-    });
+export class AnnouncementCursorQueries {
+    constructor(conn) {
+        Object.defineProperty(this, "conn", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: conn
+        });
+    }
+    async get(userId) {
+        const row = await this.conn.db
+            .select({ counter: schema.announcementCursors.counter })
+            .from(schema.announcementCursors)
+            .where(eq(schema.announcementCursors.userId, userId))
+            .get();
+        return row?.counter;
+    }
+    async upsert(userId, counter) {
+        await this.conn.db
+            .insert(schema.announcementCursors)
+            .values({ userId, counter })
+            .onConflictDoUpdate({
+            target: schema.announcementCursors.userId,
+            set: { counter },
+        });
+    }
 }

package/dist/db/queries/contacts.d.ts

@@ -1,13 +1,18 @@
 import * as schema from '../schema';
+import type { DatabaseConnection } from '../sqlite';
 import { Contact } from '../db';
 export type ContactRow = typeof schema.contacts.$inferSelect;
 type ContactInsert = typeof schema.contacts.$inferInsert;
-export declare function getContactByOwnerAndUser(ownerUserId: string, userId: string): Promise<ContactRow | undefined>;
-export declare function getContactsByOwner(ownerUserId: string): Promise<Contact[]>;
-export declare function insertContact(values: ContactInsert): Promise<number>;
-export declare function updateContactByOwnerAndUser(ownerUserId: string, userId: string, data: Partial<ContactInsert>): Promise<void>;
-export declare function deleteContactByOwnerAndUser(ownerUserId: string, userId: string): Promise<void>;
-export declare function getContactNamesByPrefix(ownerUserId: string, prefix: string): Promise<{
-    name: string;
-}[]>;
+export declare class ContactQueries {
+    private conn;
+    constructor(conn: DatabaseConnection);
+    getByOwnerAndUser(ownerUserId: string, userId: string): Promise<ContactRow | undefined>;
+    getByOwner(ownerUserId: string): Promise<Contact[]>;
+    insert(values: ContactInsert): Promise<number>;
+    updateByOwnerAndUser(ownerUserId: string, userId: string, data: Partial<ContactInsert>): Promise<void>;
+    deleteByOwnerAndUser(ownerUserId: string, userId: string): Promise<void>;
+    getNamesByPrefix(ownerUserId: string, prefix: string): Promise<{
+        name: string;
+    }[]>;
+}
 export {};

package/dist/db/queries/contacts.js

@@ -1,43 +1,52 @@
 import { eq, and, sql } from 'drizzle-orm';
 import * as schema from '../schema';
-import { getSqliteDb, getLastInsertRowId } from '../sqlite';
-export async function getContactByOwnerAndUser(ownerUserId, userId) {
-    return getSqliteDb()
-        .select()
-        .from(schema.contacts)
-        .where(and(eq(schema.contacts.ownerUserId, ownerUserId), eq(schema.contacts.userId, userId)))
-        .get();
-}
-export async function getContactsByOwner(ownerUserId) {
-    return getSqliteDb()
-        .select()
-        .from(schema.contacts)
-        .where(eq(schema.contacts.ownerUserId, ownerUserId))
-        .all();
-}
-export async function insertContact(values) {
-    await getSqliteDb().insert(schema.contacts).values(values);
-    return getLastInsertRowId();
-}
-export async function updateContactByOwnerAndUser(ownerUserId, userId, data) {
-    await getSqliteDb()
-        .update(schema.contacts)
-        .set(data)
-        .where(and(eq(schema.contacts.ownerUserId, ownerUserId), eq(schema.contacts.userId, userId)));
-}
-export async function deleteContactByOwnerAndUser(ownerUserId, userId) {
-    await getSqliteDb()
-        .delete(schema.contacts)
-        .where(and(eq(schema.contacts.ownerUserId, ownerUserId), eq(schema.contacts.userId, userId)));
-}
 /** Escape LIKE wildcard characters so they match literally. */
 function escapeLike(value) {
     return value.replace(/[%_]/g, '\\$&');
 }
-export async function getContactNamesByPrefix(ownerUserId, prefix) {
-    return getSqliteDb()
-        .select({ name: schema.contacts.name })
-        .from(schema.contacts)
-        .where(and(eq(schema.contacts.ownerUserId, ownerUserId), sql `${schema.contacts.name} LIKE ${escapeLike(prefix) + '%'} ESCAPE '\\'`))
-        .all();
+export class ContactQueries {
+    constructor(conn) {
+        Object.defineProperty(this, "conn", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: conn
+        });
+    }
+    async getByOwnerAndUser(ownerUserId, userId) {
+        return this.conn.db
+            .select()
+            .from(schema.contacts)
+            .where(and(eq(schema.contacts.ownerUserId, ownerUserId), eq(schema.contacts.userId, userId)))
+            .get();
+    }
+    async getByOwner(ownerUserId) {
+        return this.conn.db
+            .select()
+            .from(schema.contacts)
+            .where(eq(schema.contacts.ownerUserId, ownerUserId))
+            .all();
+    }
+    async insert(values) {
+        await this.conn.db.insert(schema.contacts).values(values);
+        return this.conn.getLastInsertRowId();
+    }
+    async updateByOwnerAndUser(ownerUserId, userId, data) {
+        await this.conn.db
+            .update(schema.contacts)
+            .set(data)
+            .where(and(eq(schema.contacts.ownerUserId, ownerUserId), eq(schema.contacts.userId, userId)));
+    }
+    async deleteByOwnerAndUser(ownerUserId, userId) {
+        await this.conn.db
+            .delete(schema.contacts)
+            .where(and(eq(schema.contacts.ownerUserId, ownerUserId), eq(schema.contacts.userId, userId)));
+    }
+    async getNamesByPrefix(ownerUserId, prefix) {
+        return this.conn.db
+            .select({ name: schema.contacts.name })
+            .from(schema.contacts)
+            .where(and(eq(schema.contacts.ownerUserId, ownerUserId), sql `${schema.contacts.name} LIKE ${escapeLike(prefix) + '%'} ESCAPE '\\'`))
+            .all();
+    }
 }

package/dist/db/queries/discussions.d.ts

@@ -1,21 +1,20 @@
 import * as schema from '../schema';
+import type { DatabaseConnection } from '../sqlite';
 import type { DiscussionStatus } from '../db';
 export type DiscussionRow = typeof schema.discussions.$inferSelect;
 type DiscussionInsert = typeof schema.discussions.$inferInsert;
-export declare function getDiscussionByOwnerAndContact(ownerUserId: string, contactUserId: string): Promise<DiscussionRow | undefined>;
-export declare function getDiscussionsByOwner(ownerUserId: string): Promise<DiscussionRow[]>;
-export declare function getDiscussionById(id: number): Promise<DiscussionRow | undefined>;
-export declare function insertDiscussion(values: DiscussionInsert): Promise<number>;
-export declare function updateDiscussionById(id: number, data: Partial<DiscussionInsert>): Promise<void>;
-export declare function deleteDiscussionById(id: number): Promise<void>;
-export declare function deleteDiscussionsByOwnerAndContact(ownerUserId: string, contactUserId: string): Promise<void>;
-/**
- * Atomically increment unreadCount by 1.
- */
-export declare function incrementUnreadCount(discussionId: number): Promise<void>;
-/**
- * Atomically decrement unreadCount by 1, ensuring it never goes below 0.
- */
-export declare function decrementUnreadCount(discussionId: number): Promise<void>;
-export declare function getDiscussionsByOwnerAndStatus(ownerUserId: string, status: DiscussionStatus): Promise<DiscussionRow[]>;
+export declare class DiscussionQueries {
+    private conn;
+    constructor(conn: DatabaseConnection);
+    getByOwnerAndContact(ownerUserId: string, contactUserId: string): Promise<DiscussionRow | undefined>;
+    getByOwner(ownerUserId: string): Promise<DiscussionRow[]>;
+    getById(id: number): Promise<DiscussionRow | undefined>;
+    insert(values: DiscussionInsert): Promise<number>;
+    updateById(id: number, data: Partial<DiscussionInsert>): Promise<void>;
+    deleteById(id: number): Promise<void>;
+    deleteByOwnerAndContact(ownerUserId: string, contactUserId: string): Promise<void>;
+    incrementUnreadCount(discussionId: number): Promise<void>;
+    decrementUnreadCount(discussionId: number): Promise<void>;
+    getByOwnerAndStatus(ownerUserId: string, status: DiscussionStatus): Promise<DiscussionRow[]>;
+}
 export {};