@massalabs/gossip-sdk 0.0.2-dev.20260220052333 → 0.0.2-dev.20260220053835

package/dist/gossip.js

@@ -1,25 +1,24 @@
 /**
- * GossipSdk
+ * GossipSdk - Singleton SDK with clean lifecycle API
  *
  * @example
  * ```typescript
- * import { createGossipSdk } from '@massalabs/gossip-sdk';
- *
- * const sdk = createGossipSdk();
+ * import { gossipSdk } from '@massalabs/gossip-sdk';
  *
  * // Initialize once at app startup
- * await sdk.init({
+ * await gossipSdk.init({
+ *   db,
  *   protocolBaseUrl: 'https://api.example.com',
  * });
  *
  * // Open session (login) - SDK handles keys/session internally
- * await sdk.openSession({
+ * await gossipSdk.openSession({
  *   mnemonic: 'word1 word2 ...',
  *   onPersist: async (blob) => { /* save to db *\/ },
  * });
  *
  * // Or restore existing session
- * await sdk.openSession({
+ * await gossipSdk.openSession({
  *   mnemonic: 'word1 word2 ...',
  *   encryptedSession: savedBlob,
  *   encryptionKey: key,
@@ -27,36 +26,37 @@
  * });
  *
  * // Use clean API
- * await sdk.messages.send(contactId, 'Hello!');
- * await sdk.discussions.start(contact);
- * const contacts = await sdk.contacts.list(ownerUserId);
+ * await gossipSdk.messages.send(contactId, 'Hello!');
+ * await gossipSdk.discussions.start(contact);
+ * const contacts = await gossipSdk.contacts.list(ownerUserId);
  *
  * // Events
- * sdk.on('message', (msg) => { ... });
- * sdk.on('discussionRequest', (discussion, contact) => { ... });
+ * gossipSdk.on('message', (msg) => { ... });
+ * gossipSdk.on('discussionRequest', (discussion, contact) => { ... });
  *
  * // Logout
- * await sdk.closeSession();
+ * await gossipSdk.closeSession();
  * ```
  */
-import { gossipDb, } from './db';
+import { MessageStatus, } from './db';
+import { toDiscussion, toSortedDiscussions } from './utils/discussions';
 import { createMessageProtocol } from './api/messageProtocol';
 import { setProtocolBaseUrl } from './config/protocol';
 import { defaultSdkConfig, mergeConfig, } from './config/sdk';
 import { startWasmInitialization, ensureWasmInitialized } from './wasm/loader';
 import { generateUserKeys } from './wasm/userKeys';
 import { SessionModule } from './wasm/session';
-import { generateEncryptionKeyFromSeed, } from './wasm/encryption';
 import { AnnouncementService, } from './services/announcement';
 import { DiscussionService, } from './services/discussion';
-import { MessageService, } from './services/message';
+import { MessageService, rowToMessage, } from './services/message';
 import { RefreshService } from './services/refresh';
 import { AuthService } from './services/auth';
 import { validateUserIdFormat, validateUsernameFormat, } from './utils/validation';
 import { QueueManager } from './utils/queue';
 import { encodeUserId, decodeUserId } from './utils/userId';
+import { initDb } from './sqlite';
+import { getMessageById as queryGetMessageById, getMessagesByOwnerAndContact, getMessagesByStatus, updateMessageById, getDiscussionsByOwner, getDiscussionByOwnerAndContact, } from './queries';
 import { getContacts, getContact, addContact, updateContactName, deleteContact, } from './contacts';
-import { SessionManagerWrapper, } from './wasm/bindings';
 import { SdkEventEmitter, SdkEventType, } from './core/SdkEventEmitter';
 import { SdkPolling } from './core/SdkPolling';
 export { SdkEventType };
@@ -164,19 +164,24 @@ class GossipSdk {
             console.warn('[GossipSdk] Already initialized');
             return;
         }
+        console.log('[GossipSdk] Initializing SDK');
         // Merge config with defaults
-        const config = mergeConfig(options?.config);
+        const config = mergeConfig(options.config);
         // Configure protocol URL (prefer explicit option, then config)
-        const baseUrl = options?.protocolBaseUrl ?? config.protocol.baseUrl;
+        const baseUrl = options.protocolBaseUrl ?? config.protocol.baseUrl;
         if (baseUrl) {
             setProtocolBaseUrl(baseUrl);
         }
         // Start WASM initialization
         startWasmInitialization();
+        console.log('[GossipSdk] Initializing SQLite');
+        // Initialize SQLite (idempotent — no-op if already initialized).
+        await initDb({ wasmUrl: options.wasmUrl, opfsPath: options.opfsPath });
+        console.log('[GossipSdk] SQLite initialized');
         // Create message protocol
         const messageProtocol = createMessageProtocol();
         // Create auth service (doesn't need session)
-        this._auth = new AuthService(this.db, messageProtocol);
+        this._auth = new AuthService(messageProtocol);
         this.state = {
             status: SdkStatus.INITIALIZED,
             messageProtocol,
@@ -194,24 +199,23 @@ class GossipSdk {
         if (this.state.status === SdkStatus.SESSION_OPEN) {
             throw new Error('Session already open. Call closeSession() first.');
         }
-        if (!options.encryptionKey) {
-            console.warn('[GossipSdk] No encryptionKey provided. Creating a new one from mnemonic.');
+        // Validate session restore options - must have both or neither
+        if (options.encryptedSession && !options.encryptionKey) {
+            throw new Error('encryptionKey is required when encryptedSession is provided.');
         }
-        const encryptionKey = options.encryptionKey ??
-            (await generateEncryptionKeyFromSeed(options.mnemonic, new Uint8Array(32).fill(0)));
-        // Ensure WASM is ready before using any WASM-backed helpers
-        await ensureWasmInitialized();
-        // Validate that encryptedSession can be decrypted with the provided key
-        if (options.encryptedSession) {
-            try {
-                const sessionManager = SessionManagerWrapper.from_encrypted_blob(options.encryptedSession, encryptionKey);
-                // We only create this wrapper for validation, free it immediately
-                sessionManager.free();
-            }
-            catch {
-                throw new Error('[GossipSdk] Failed to load encrypted session. Please provide a valid encryptedSession and encryptionKey.');
-            }
+        if (options.encryptionKey && !options.encryptedSession) {
+            console.warn('[GossipSdk] encryptionKey provided without encryptedSession - key will be ignored');
+        }
+        // Validate persistence options
+        if (options.onPersist && !options.persistEncryptionKey) {
+            throw new Error('persistEncryptionKey is required when onPersist is provided.');
         }
+        if (options.persistEncryptionKey && !options.onPersist) {
+            console.warn('[GossipSdk] persistEncryptionKey provided without onPersist callback - key will be unused');
+        }
+        const { messageProtocol } = this.state;
+        // Ensure WASM is ready
+        await ensureWasmInitialized();
         // Generate keys from mnemonic
         const userKeys = await generateUserKeys(options.mnemonic);
         // Create session with persistence callback
@@ -220,30 +224,39 @@ class GossipSdk {
             await this.handleSessionPersist();
         }, options.sessionConfig);
         // Restore existing session state if provided
-        if (options.encryptedSession) {
-            session.load(options.encryptedSession, encryptionKey);
+        if (options.encryptedSession && options.encryptionKey) {
+            session.load(options.encryptedSession, options.encryptionKey);
         }
-        const db = this.db;
-        this._announcement = new AnnouncementService(db, this.state.messageProtocol, session, this.eventEmitter, this.config);
-        this._discussion = new DiscussionService(db, this._announcement, session, this.eventEmitter);
-        this._message = new MessageService(db, this.state.messageProtocol, session, this._discussion, this.eventEmitter, this.config);
-        this._refresh = new RefreshService(db, this._message, this._discussion, this._announcement, session, this.eventEmitter);
-        // Publish gossip ID so the user is discoverable (fire-and-forget — don't block login)
-        this._auth.ensurePublicKeyPublished(session.ourPk, session.userIdEncoded).catch(err => console.warn('[GossipSdk] Failed to publish public key:', err));
+        // Get config from initialized state
+        const { config } = this.state;
+        // Create services with config (refreshService will be set after creation)
+        this._announcement = new AnnouncementService(messageProtocol, session, this.eventEmitter, config);
+        this._discussion = new DiscussionService(this._announcement, session, this.eventEmitter);
+        this._message = new MessageService(messageProtocol, session, this.eventEmitter, config);
+        this._refresh = new RefreshService(this._message, this._discussion, this._announcement, session, this.eventEmitter);
+        // Publish gossip ID (public key) on messageProtocol so the user is discoverable
+        await this._auth.ensurePublicKeyPublished(session.ourPk, session.userIdEncoded);
+        // Now set refreshService on services (circular dependency resolved via setter)
+        this._discussion.setRefreshService(this._refresh);
+        this._message.setRefreshService(this._refresh);
+        this._announcement.setRefreshService(this._refresh);
+        // Reset any messages stuck in SENDING status to WAITING_SESSION
+        // This handles app crash/close during message send
+        await this.resetStuckSendingMessages();
         // Update SDK state to reflect the newly opened session.
         this.state = {
             status: SdkStatus.SESSION_OPEN,
-            messageProtocol: this.state.messageProtocol,
-            config: this.state.config,
+            messageProtocol,
+            config,
             session,
             userKeys,
-            encryptionKey,
+            persistEncryptionKey: options.persistEncryptionKey,
             onPersist: options.onPersist,
         };
         // Create cached service API wrappers
-        this.createServiceAPIWrappers(session, db);
+        this.createServiceAPIWrappers(session);
         // Auto-start polling if enabled in config
-        if (this.config.polling.enabled) {
+        if (config.polling.enabled) {
             this.startPolling();
         }
     }
@@ -251,68 +264,50 @@ class GossipSdk {
      * Create cached service API wrappers.
      * Called once during openSession to avoid creating new objects on each getter access.
      */
-    createServiceAPIWrappers(session, db) {
+    createServiceAPIWrappers(session) {
         this._messagesAPI = {
-            get: id => db.messages.get(id),
+            get: async (id) => {
+                const row = await queryGetMessageById(id);
+                return row ? rowToMessage(row) : undefined;
+            },
             getMessages: async (contactUserId) => {
                 const state = this.requireSession();
-                return await db.messages
-                    .where('[ownerUserId+contactUserId]')
-                    .equals([state.session.userIdEncoded, contactUserId])
-                    .toArray();
+                const rows = await getMessagesByOwnerAndContact(state.session.userIdEncoded, contactUserId);
+                return rows.map(rowToMessage);
             },
-            send: message => this.messageQueues.enqueue(message.contactUserId, async () => {
-                const result = await this._message.sendMessage(message);
-                if (result.success)
-                    await this._refresh?.stateUpdate();
-                return result;
-            }),
+            send: message => this.messageQueues.enqueue(message.contactUserId, () => this._message.sendMessage(message)),
             fetch: () => this._message.fetchMessages(),
             findByMsgId: (messageId, ownerUserId, contactUserId) => this._message.findMessageByMsgId(messageId, ownerUserId, contactUserId),
             markAsRead: id => this._message.markAsRead(id),
         };
         this._discussionsAPI = {
-            start: async (contact, payload) => {
-                const result = await this._discussion.initialize(contact, payload);
-                if (result.success)
-                    await this._refresh?.stateUpdate();
-                return result;
-            },
-            accept: async (discussion) => {
-                const result = await this._discussion.accept(discussion);
-                if (result.success)
-                    await this._refresh?.stateUpdate();
-                return result;
-            },
-            renew: async (contactUserId) => {
-                const result = await this._discussion.createSessionForContact(contactUserId, new Uint8Array(0));
-                if (result.success)
-                    await this._refresh?.stateUpdate();
-                return result;
-            },
+            start: (contact, payload) => this._discussion.initialize(contact, payload),
+            accept: (discussion) => this._discussion.accept(discussion),
+            renew: (contactUserId) => this._discussion.createSessionForContact(contactUserId, new Uint8Array(0)),
             getStatus: (contactUserId) => {
                 if (this.state.status !== SdkStatus.SESSION_OPEN)
                     throw new Error('No session open. Call openSession() first.');
                 return this.state.session.peerSessionStatus(decodeUserId(contactUserId));
             },
-            list: ownerUserId => db.getDiscussionsByOwner(ownerUserId),
-            get: (ownerUserId, contactUserId) => db.getDiscussionByOwnerAndContact(ownerUserId, contactUserId),
+            list: async (ownerUserId) => {
+                const all = await getDiscussionsByOwner(ownerUserId);
+                return toSortedDiscussions(all);
+            },
+            get: async (ownerUserId, contactUserId) => {
+                const row = await getDiscussionByOwnerAndContact(ownerUserId, contactUserId);
+                return row ? toDiscussion(row) : undefined;
+            },
         };
         this._announcementsAPI = {
-            fetch: async () => {
-                const result = await this._announcement.fetchAndProcessAnnouncements();
-                if (result.newAnnouncementsCount)
-                    await this._refresh?.stateUpdate();
-                return result;
-            },
+            fetch: () => this._announcement.fetchAndProcessAnnouncements(),
             skipHistorical: () => this._announcement.skipHistoricalAnnouncements(),
         };
         this._contactsAPI = {
-            list: ownerUserId => getContacts(ownerUserId, db),
-            get: (ownerUserId, contactUserId) => getContact(ownerUserId, contactUserId, db),
-            add: (ownerUserId, userId, name, publicKeys) => addContact(ownerUserId, userId, name, publicKeys, db),
-            updateName: (ownerUserId, contactUserId, newName) => updateContactName(ownerUserId, contactUserId, newName, db),
-            delete: (ownerUserId, contactUserId) => deleteContact(ownerUserId, contactUserId, db, session),
+            list: ownerUserId => getContacts(ownerUserId),
+            get: (ownerUserId, contactUserId) => getContact(ownerUserId, contactUserId),
+            add: (ownerUserId, userId, name, publicKeys) => addContact(ownerUserId, userId, name, publicKeys),
+            updateName: (ownerUserId, contactUserId, newName) => updateContactName(ownerUserId, contactUserId, newName),
+            delete: (ownerUserId, contactUserId) => deleteContact(ownerUserId, contactUserId, session),
         };
     }
     /**
@@ -375,12 +370,28 @@ class GossipSdk {
      * Get encrypted session blob for persistence.
      * Throws if no session is open.
      */
-    getEncryptedSession() {
+    getEncryptedSession(encryptionKey) {
         const state = this.requireSession();
-        if (!state.encryptionKey) {
-            throw new Error('No encryption key found. Call openSession() first.');
+        return state.session.toEncryptedBlob(encryptionKey);
+    }
+    /**
+     * Configure session persistence after session is opened.
+     * Use this when you need to set up persistence after account creation.
+     *
+     * @param encryptionKey - Key to encrypt session blob
+     * @param onPersist - Callback to save encrypted session blob
+     */
+    configurePersistence(encryptionKey, onPersist) {
+        if (this.state.status !== SdkStatus.SESSION_OPEN) {
+            throw new Error('No session open. Call openSession() first.');
         }
-        return state.session.toEncryptedBlob(state.encryptionKey);
+        // Update state with persistence config
+        this.state = {
+            ...this.state,
+            persistEncryptionKey: encryptionKey,
+            onPersist,
+        };
+        console.log('[GossipSdk] Session persistence configured');
     }
     // ─────────────────────────────────────────────────────────────────
     // Services (accessible only when session is open)
@@ -424,9 +435,6 @@ class GossipSdk {
         }
         return this._contactsAPI;
     }
-    get db() {
-        return gossipDb();
-    }
     /**
      * Update state for all discussions:
      * - Cleanup orphaned peers
@@ -477,26 +485,17 @@ class GossipSdk {
             console.warn('[GossipSdk] Cannot start polling - no session open');
             return;
         }
-        const { config, session } = this.state;
+        const { config } = this.state;
         this.pollingManager.start(config, {
             fetchMessages: async () => {
                 await this._message?.fetchMessages();
             },
             fetchAnnouncements: async () => {
-                const result = await this._announcement?.fetchAndProcessAnnouncements();
-                if (result?.newAnnouncementsCount)
-                    this._refresh?.stateUpdate();
+                await this._announcement?.fetchAndProcessAnnouncements();
             },
             handleSessionRefresh: async () => {
-                // Retry public key publish if it failed during openSession()
-                this._auth
-                    ?.ensurePublicKeyPublished(session.ourPk, session.userIdEncoded)
-                    .catch(() => { });
                 await this.updateState();
             },
-            getActiveDiscussions: async () => {
-                return this.db.getDiscussionsByOwner(session.userIdEncoded);
-            },
         }, this.eventEmitter);
     }
     // ─────────────────────────────────────────────────────────────────
@@ -526,24 +525,54 @@ class GossipSdk {
     async handleSessionPersist() {
         if (this.state.status !== SdkStatus.SESSION_OPEN)
             return;
-        const { onPersist, encryptionKey, session } = this.state;
-        if (!onPersist || !encryptionKey)
+        const { onPersist, persistEncryptionKey, session } = this.state;
+        if (!onPersist || !persistEncryptionKey)
             return;
         try {
-            const blob = session.toEncryptedBlob(encryptionKey);
+            const blob = session.toEncryptedBlob(persistEncryptionKey);
             console.log(`[SessionPersist] Saving session blob (${blob.length} bytes)`);
-            await onPersist(blob, encryptionKey);
+            await onPersist(blob, persistEncryptionKey);
         }
         catch (error) {
             this.eventEmitter.emit(SdkEventType.ERROR, error instanceof Error ? error : new Error(String(error)), 'session_persist');
         }
     }
+    /**
+     * Reset messages stuck in SENDING status to WAITING_SESSION.
+     *
+     * Per spec: SENDING is a transient state that should never be persisted.
+     * If the app crashes/closes during a send, the message would be stuck forever.
+     *
+     * By resetting to WAITING_SESSION:
+     * - Message will be re-encrypted with current session keys
+     * - Message will be automatically sent when session is active
+     * - No manual user intervention required
+     *
+     * We also clear encryptedMessage and seeker since they may be stale.
+     */
+    async resetStuckSendingMessages() {
+        try {
+            const stuck = await getMessagesByStatus(MessageStatus.SENDING);
+            for (const m of stuck) {
+                await updateMessageById(m.id, {
+                    status: MessageStatus.WAITING_SESSION,
+                    encryptedMessage: null,
+                    seeker: null,
+                });
+            }
+            if (stuck.length > 0) {
+                console.log(`[GossipSdk] Reset ${stuck.length} stuck SENDING message(s) to WAITING_SESSION for auto-retry`);
+            }
+        }
+        catch (error) {
+            console.error('[GossipSdk] Failed to reset stuck messages:', error);
+        }
+    }
 }
 // ─────────────────────────────────────────────────────────────────────────────
-// Factory & Class Export
+// Singleton Export
 // ─────────────────────────────────────────────────────────────────────────────
-/** Create a new GossipSdk instance. The consumer manages the instance lifecycle. */
-export function createGossipSdk() {
-    return new GossipSdk();
-}
+/** The singleton GossipSdk instance */
+export const gossipSdk = new GossipSdk();
+// Also export the class for testing
 export { GossipSdk };

package/dist/index.d.ts

@@ -1,13 +1,20 @@
 /**
  * Gossip SDK
  *
+ * Main entry point for the Gossip SDK.
+ * Works in both browser and Node.js environments.
+ *
+ * WASM is loaded via the web target build with runtime detection:
+ * - Browser: init() uses import.meta.url + fetch
+ * - Node.js / Jiti: init(bytes) reads the .wasm file from disk
+ *
  * @example
  * ```typescript
- * import { createGossipSdk } from '@massalabs/gossip-sdk';
+ * import { gossipSdk } from '@massalabs/gossip-sdk';
  *
- * const sdk = createGossipSdk();
- * await sdk.init();
- * await sdk.openSession({ mnemonic: '...' });
+ * await gossipSdk.init({ db, protocolBaseUrl: 'https://api.example.com' });
+ * await gossipSdk.openSession({ mnemonic: '...' });
+ * await gossipSdk.messages.send(contactId, 'Hello!');
  * ```
  *
  * @packageDocumentation
@@ -16,5 +23,7 @@ export * from './api';
 export * from './crypto';
 export * from './db';
 export * from './gossip';
+export * from './queries';
 export * from './utils';
 export * from './wasm';
+export { initDb, closeSqlite, getSqliteDb, clearAllTables, clearConversationTables, isSqliteOpen, } from './sqlite';

package/dist/index.js

@@ -1,13 +1,20 @@
 /**
  * Gossip SDK
  *
+ * Main entry point for the Gossip SDK.
+ * Works in both browser and Node.js environments.
+ *
+ * WASM is loaded via the web target build with runtime detection:
+ * - Browser: init() uses import.meta.url + fetch
+ * - Node.js / Jiti: init(bytes) reads the .wasm file from disk
+ *
  * @example
  * ```typescript
- * import { createGossipSdk } from '@massalabs/gossip-sdk';
+ * import { gossipSdk } from '@massalabs/gossip-sdk';
  *
- * const sdk = createGossipSdk();
- * await sdk.init();
- * await sdk.openSession({ mnemonic: '...' });
+ * await gossipSdk.init({ db, protocolBaseUrl: 'https://api.example.com' });
+ * await gossipSdk.openSession({ mnemonic: '...' });
+ * await gossipSdk.messages.send(contactId, 'Hello!');
  * ```
  *
  * @packageDocumentation
@@ -16,5 +23,7 @@ export * from './api';
 export * from './crypto';
 export * from './db';
 export * from './gossip';
+export * from './queries';
 export * from './utils';
 export * from './wasm';
+export { initDb, closeSqlite, getSqliteDb, clearAllTables, clearConversationTables, isSqliteOpen, } from './sqlite';

package/dist/queries/activeSeekers.d.ts

@@ -0,0 +1,2 @@
+export declare function setOnSeekersUpdated(cb: ((seekers: Uint8Array[]) => void) | null): void;
+export declare function replaceActiveSeekers(seekers: Uint8Array[]): Promise<void>;

package/dist/queries/activeSeekers.js

@@ -0,0 +1,18 @@
+import * as schema from '../schema';
+import { getSqliteDb, withTransaction } from '../sqlite';
+let onSeekersUpdated = null;
+export function setOnSeekersUpdated(cb) {
+    onSeekersUpdated = cb;
+}
+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 })));
+        }
+    });
+    onSeekersUpdated?.(seekers);
+}

package/dist/queries/announcementCursors.d.ts

@@ -0,0 +1,2 @@
+export declare function getAnnouncementCursor(userId: string): Promise<string | undefined>;
+export declare function upsertAnnouncementCursor(userId: string, counter: string): Promise<void>;

package/dist/queries/announcementCursors.js

@@ -0,0 +1,20 @@
+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 },
+    });
+}

package/dist/queries/contacts.d.ts

@@ -0,0 +1,13 @@
+import * as schema from '../schema';
+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 {};

package/dist/queries/contacts.js

@@ -0,0 +1,43 @@
+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();
+}

package/dist/queries/discussions.d.ts

@@ -0,0 +1,21 @@
+import * as schema from '../schema';
+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 {};