@massalabs/gossip-sdk 0.0.2-dev.20260220142001 → 0.0.2-dev.20260223065033

package/dist/db/schema/userProfile.d.ts

@@ -0,0 +1,208 @@
+export declare const userProfile: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "userProfile";
+    schema: undefined;
+    columns: {
+        userId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "userId";
+            tableName: "userProfile";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        username: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "username";
+            tableName: "userProfile";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        avatar: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "avatar";
+            tableName: "userProfile";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        bio: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "bio";
+            tableName: "userProfile";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        status: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "status";
+            tableName: "userProfile";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        lastSeen: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "lastSeen";
+            tableName: "userProfile";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "createdAt";
+            tableName: "userProfile";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "updatedAt";
+            tableName: "userProfile";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        lastPublicKeyPush: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "lastPublicKeyPush";
+            tableName: "userProfile";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        security: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "security";
+            tableName: "userProfile";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        session: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "session";
+            tableName: "userProfile";
+            dataType: "custom";
+            columnType: "SQLiteCustomColumn";
+            data: Uint8Array<ArrayBufferLike>;
+            driverParam: Uint8Array<ArrayBufferLike>;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            sqliteColumnBuilderBrand: "SQLiteCustomColumnBuilderBrand";
+        }>;
+    };
+    dialect: "sqlite";
+}>;

package/dist/db/schema/userProfile.js

@@ -0,0 +1,20 @@
+import { sqliteTable, text, integer, index } from 'drizzle-orm/sqlite-core';
+import { bytes } from './_helpers';
+export const userProfile = sqliteTable('userProfile', {
+    userId: text('userId').primaryKey(),
+    username: text('username').notNull(),
+    avatar: text('avatar'),
+    bio: text('bio'),
+    status: text('status').notNull(),
+    lastSeen: integer('lastSeen', { mode: 'timestamp_ms' }).notNull(),
+    createdAt: integer('createdAt', { mode: 'timestamp_ms' }).notNull(),
+    updatedAt: integer('updatedAt', { mode: 'timestamp_ms' }).notNull(),
+    lastPublicKeyPush: integer('lastPublicKeyPush', {
+        mode: 'timestamp_ms',
+    }),
+    security: text('security').notNull(),
+    session: bytes('session').notNull(),
+}, table => [
+    index('userProfile_username_idx').on(table.username),
+    index('userProfile_status_idx').on(table.status),
+]);

package/dist/{sqlite-worker.js → db/sqlite-worker.js}

@@ -12,43 +12,15 @@
 import SQLiteESMFactory from 'wa-sqlite/dist/wa-sqlite.mjs';
 import * as SQLite from 'wa-sqlite';
 import { AccessHandlePoolVFS } from 'wa-sqlite/src/examples/AccessHandlePoolVFS.js';
+import { execStatements } from './exec-utils.js';
 let sqlite3 = null;
 let dbHandle = null;
 // Bind Worker's postMessage (avoids DOM lib signature mismatch at compile time)
 const post = globalThis.postMessage.bind(globalThis);
-function copyRow(row) {
-    return row.map(v => (v instanceof Uint8Array ? new Uint8Array(v) : v));
-}
 async function execSql(sql, params) {
     if (!sqlite3 || dbHandle === null)
         throw new Error('SQLite not initialized');
-    const rows = [];
-    if (params.length === 0) {
-        await sqlite3.exec(dbHandle, sql, (row) => {
-            rows.push(copyRow(row));
-        });
-    }
-    else {
-        const str = sqlite3.str_new(dbHandle, sql);
-        try {
-            const prepared = await sqlite3.prepare_v2(dbHandle, sqlite3.str_value(str));
-            if (prepared) {
-                try {
-                    sqlite3.bind_collection(prepared.stmt, params);
-                    while ((await sqlite3.step(prepared.stmt)) === SQLite.SQLITE_ROW) {
-                        rows.push(copyRow(sqlite3.row(prepared.stmt)));
-                    }
-                }
-                finally {
-                    await sqlite3.finalize(prepared.stmt);
-                }
-            }
-        }
-        finally {
-            sqlite3.str_finish(str);
-        }
-    }
-    // Only capture lastInsertRowId for INSERT statements (avoid unnecessary query on SELECT/UPDATE/DELETE)
+    const rows = await execStatements(sqlite3, dbHandle, sql, params);
     let lastInsertRowId = 0;
     if (sql.trimStart().toUpperCase().startsWith('INSERT')) {
         await sqlite3.exec(dbHandle, 'SELECT last_insert_rowid()', (row) => {

package/dist/db/sqlite.d.ts

@@ -0,0 +1,77 @@
+/**
+ * SQLite initialization module for the Gossip SDK.
+ *
+ * Uses wa-sqlite (WASM) with Drizzle ORM's sqlite-proxy driver.
+ * Two execution paths:
+ *   - Browser (opfsPath set): Web Worker + AccessHandlePoolVFS — OPFS persistence,
+ *     off the main thread. Uses the sync WASM build (wa-sqlite).
+ *   - In-memory (tests): :memory: in-process — no persistence, fast, isolated.
+ *     Uses the sync WASM build with wasmBinary passed directly.
+ *
+ * In Phase C the VFS will be swapped for the encrypted PlausibleDeniableVFS.
+ */
+import { type SqliteRemoteDatabase } from 'drizzle-orm/sqlite-proxy';
+import * as schema from './schema/index.js';
+export type GossipDatabase = SqliteRemoteDatabase<typeof schema>;
+export interface InitDbOptions {
+    /**
+     * OPFS directory path for persistent storage.
+     * When set, spawns a Web Worker with AccessHandlePoolVFS for OPFS persistence.
+     * When omitted, uses an in-memory database (for tests).
+     */
+    opfsPath?: string;
+    /**
+     * Pre-loaded WASM binary for environments where fetch() is unavailable
+     * (e.g. Node.js tests). When omitted, the factory uses fetch() to load
+     * the .wasm file (browser default).
+     */
+    wasmBinary?: ArrayBuffer;
+    /**
+     * URL to the wa-sqlite WASM file. Used in browser to tell the Emscripten
+     * factory where to fetch the WASM binary (needed when bundlers like Vite
+     * rewrite asset paths). When omitted, the factory uses its default path.
+     */
+    wasmUrl?: string;
+}
+/**
+ * Initialize wa-sqlite and create the Drizzle ORM instance.
+ * Idempotent — subsequent calls are no-ops.
+ *
+ * @param options.opfsPath - Set to persist via OPFS Worker (production).
+ *                           Omit for in-memory database (tests).
+ */
+export declare function initDb(options?: InitDbOptions): Promise<void>;
+/**
+ * Get the Drizzle ORM database instance.
+ * Throws if initDb() has not been called.
+ */
+export declare function getSqliteDb(): GossipDatabase;
+export declare function isSqliteOpen(): boolean;
+/**
+ * Run a callback inside a SQLite transaction (BEGIN / COMMIT / ROLLBACK).
+ * All Drizzle operations inside the callback share the same transaction
+ * and the same dbLock hold, so they cannot interleave with outside queries.
+ */
+export declare function withTransaction<T>(fn: () => Promise<T>): Promise<T>;
+export declare function clearAllTables(): Promise<void>;
+/**
+ * Clear only conversation-related tables (contacts, discussions, messages).
+ * Preserves user profiles and other data.
+ */
+export declare function clearConversationTables(): Promise<void>;
+/**
+ * Get the last auto-increment row ID inserted via this connection.
+ * Used after INSERT into tables with INTEGER PRIMARY KEY AUTOINCREMENT.
+ *
+ * Browser path: returns the cached value from the last Worker exec response
+ * (returned atomically with every exec — no race condition).
+ * Test path: queries directly (same connection, serialized by dbLock).
+ */
+export declare function getLastInsertRowId(): Promise<number>;
+/**
+ * Close the database and release all resources.
+ * Browser path: sends close to Worker, then terminates it.
+ * Test path: closes in-process database handle.
+ * Atomically resets all state by replacing with a fresh default.
+ */
+export declare function closeSqlite(): Promise<void>;

package/dist/db/sqlite.js

@@ -0,0 +1,254 @@
+/**
+ * SQLite initialization module for the Gossip SDK.
+ *
+ * Uses wa-sqlite (WASM) with Drizzle ORM's sqlite-proxy driver.
+ * Two execution paths:
+ *   - Browser (opfsPath set): Web Worker + AccessHandlePoolVFS — OPFS persistence,
+ *     off the main thread. Uses the sync WASM build (wa-sqlite).
+ *   - In-memory (tests): :memory: in-process — no persistence, fast, isolated.
+ *     Uses the sync WASM build with wasmBinary passed directly.
+ *
+ * In Phase C the VFS will be swapped for the encrypted PlausibleDeniableVFS.
+ */
+import SQLiteESMFactory from 'wa-sqlite/dist/wa-sqlite.mjs';
+import * as SQLite from 'wa-sqlite';
+import { drizzle } from 'drizzle-orm/sqlite-proxy';
+import * as schema from './schema/index.js';
+import { DDL } from './generated-ddl.js';
+import { execStatements } from './exec-utils.js';
+function createDefaultState() {
+    return {
+        worker: null,
+        msgId: 0,
+        pending: new Map(),
+        lastInsertRowIdCache: 0,
+        sqlite3: null,
+        dbHandle: null,
+        useWorker: false,
+        drizzleDb: null,
+        dbLock: Promise.resolve(),
+        inTransaction: false,
+    };
+}
+let db = createDefaultState();
+// ---------------------------------------------------------------------------
+// Worker communication (browser path)
+// ---------------------------------------------------------------------------
+function postToWorker(msg
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+    return new Promise((resolve, reject) => {
+        const id = ++db.msgId;
+        db.pending.set(id, { resolve, reject });
+        db.worker.postMessage({ ...msg, id });
+    });
+}
+function handleWorkerMessage(e) {
+    const { id, type, ...rest } = e.data;
+    const p = db.pending.get(id);
+    if (!p)
+        return;
+    db.pending.delete(id);
+    if (type === 'error') {
+        p.reject(new Error(rest.message));
+    }
+    else {
+        p.resolve(rest);
+    }
+}
+// ---------------------------------------------------------------------------
+// Drizzle instance factory
+// ---------------------------------------------------------------------------
+function createDrizzleInstance() {
+    return drizzle(async (sql, params, method) => {
+        const rows = await execRaw(sql, params);
+        if (method === 'get') {
+            return { rows: rows[0] };
+        }
+        return { rows };
+    }, { schema });
+}
+// ---------------------------------------------------------------------------
+// Raw SQL execution
+// ---------------------------------------------------------------------------
+async function execRaw(sql, params = []) {
+    // When inside a withTransaction(), the outer lock is already held —
+    // skip re-acquisition to avoid deadlock.
+    if (db.inTransaction) {
+        return execRawDirect(sql, params);
+    }
+    const prev = db.dbLock;
+    let release;
+    db.dbLock = new Promise(r => (release = r));
+    await prev;
+    try {
+        return await execRawDirect(sql, params);
+    }
+    finally {
+        release();
+    }
+}
+async function execRawDirect(sql, params = []) {
+    if (db.useWorker) {
+        const result = await postToWorker({ type: 'exec', sql, params });
+        db.lastInsertRowIdCache = result.lastInsertRowId;
+        return result.rows;
+    }
+    return execRawInProcess(sql, params);
+}
+async function execRawInProcess(sql, params = []) {
+    if (!db.sqlite3 || db.dbHandle === null) {
+        throw new Error('SQLite not initialized');
+    }
+    return execStatements(db.sqlite3, db.dbHandle, sql, params);
+}
+/** PRAGMAs applied before migrations. */
+const PRAGMAS = `
+  PRAGMA journal_mode=MEMORY;
+  PRAGMA temp_store=MEMORY;
+`;
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Initialize wa-sqlite and create the Drizzle ORM instance.
+ * Idempotent — subsequent calls are no-ops.
+ *
+ * @param options.opfsPath - Set to persist via OPFS Worker (production).
+ *                           Omit for in-memory database (tests).
+ */
+export async function initDb(options = {}) {
+    if (db.drizzleDb)
+        return;
+    if (options.opfsPath) {
+        // Browser path: spawn Worker with OPFS + AccessHandlePoolVFS.
+        // The sync WASM build runs in the Worker (no Asyncify needed).
+        db.worker = new Worker(new URL('./sqlite-worker.ts', import.meta.url), {
+            type: 'module',
+        });
+        db.worker.onmessage = handleWorkerMessage;
+        db.useWorker = true;
+        await postToWorker({
+            type: 'init',
+            opfsPath: options.opfsPath,
+            wasmUrl: options.wasmUrl,
+            initSql: PRAGMAS,
+        });
+    }
+    else {
+        // In-memory mode (tests): sync WASM build, in-process, fast, isolated.
+        const moduleArg = {};
+        if (options.wasmBinary) {
+            moduleArg.wasmBinary = options.wasmBinary;
+        }
+        const module = await SQLiteESMFactory(moduleArg);
+        db.sqlite3 = SQLite.Factory(module);
+        db.dbHandle = await db.sqlite3.open_v2(':memory:');
+        db.useWorker = false;
+        await db.sqlite3.exec(db.dbHandle, PRAGMAS);
+    }
+    db.drizzleDb = createDrizzleInstance();
+    // Run DDL (generated by npm run db:generate). Uses IF NOT EXISTS.
+    for (const stmt of DDL) {
+        await execRaw(stmt);
+    }
+}
+/**
+ * Get the Drizzle ORM database instance.
+ * Throws if initDb() has not been called.
+ */
+export function getSqliteDb() {
+    if (!db.drizzleDb) {
+        throw new Error('SQLite not initialized. Call initDb() first.');
+    }
+    return db.drizzleDb;
+}
+export function isSqliteOpen() {
+    return db.drizzleDb !== null;
+}
+/**
+ * Run a callback inside a SQLite transaction (BEGIN / COMMIT / ROLLBACK).
+ * All Drizzle operations inside the callback share the same transaction
+ * and the same dbLock hold, so they cannot interleave with outside queries.
+ */
+export async function withTransaction(fn) {
+    const prev = db.dbLock;
+    let release;
+    db.dbLock = new Promise(r => (release = r));
+    await prev;
+    try {
+        await execRawDirect('BEGIN');
+        db.inTransaction = true;
+        try {
+            const result = await fn();
+            await execRawDirect('COMMIT');
+            return result;
+        }
+        catch (e) {
+            await execRawDirect('ROLLBACK');
+            throw e;
+        }
+        finally {
+            db.inTransaction = false;
+        }
+    }
+    finally {
+        release();
+    }
+}
+export async function clearAllTables() {
+    await withTransaction(async () => {
+        const drizzleDb = getSqliteDb();
+        await drizzleDb.delete(schema.messages);
+        await drizzleDb.delete(schema.discussions);
+        await drizzleDb.delete(schema.contacts);
+        await drizzleDb.delete(schema.userProfile);
+        await drizzleDb.delete(schema.pendingEncryptedMessages);
+        await drizzleDb.delete(schema.pendingAnnouncements);
+        await drizzleDb.delete(schema.activeSeekers);
+        await drizzleDb.delete(schema.announcementCursors);
+    });
+}
+/**
+ * Clear only conversation-related tables (contacts, discussions, messages).
+ * Preserves user profiles and other data.
+ */
+export async function clearConversationTables() {
+    await withTransaction(async () => {
+        const drizzleDb = getSqliteDb();
+        await drizzleDb.delete(schema.messages);
+        await drizzleDb.delete(schema.discussions);
+        await drizzleDb.delete(schema.contacts);
+    });
+}
+/**
+ * Get the last auto-increment row ID inserted via this connection.
+ * Used after INSERT into tables with INTEGER PRIMARY KEY AUTOINCREMENT.
+ *
+ * Browser path: returns the cached value from the last Worker exec response
+ * (returned atomically with every exec — no race condition).
+ * Test path: queries directly (same connection, serialized by dbLock).
+ */
+export async function getLastInsertRowId() {
+    if (db.useWorker) {
+        return db.lastInsertRowIdCache;
+    }
+    const rows = await execRaw('SELECT last_insert_rowid()');
+    return rows[0][0];
+}
+/**
+ * Close the database and release all resources.
+ * Browser path: sends close to Worker, then terminates it.
+ * Test path: closes in-process database handle.
+ * Atomically resets all state by replacing with a fresh default.
+ */
+export async function closeSqlite() {
+    if (db.useWorker && db.worker) {
+        await postToWorker({ type: 'close' });
+        db.worker.terminate();
+    }
+    else if (db.dbHandle !== null && db.sqlite3) {
+        await db.sqlite3.close(db.dbHandle);
+    }
+    db = createDefaultState();
+}

package/dist/gossip.d.ts

@@ -1,44 +1,3 @@
-/**
- * GossipSdk - Singleton SDK with clean lifecycle API
- *
- * @example
- * ```typescript
- * import { gossipSdk } from '@massalabs/gossip-sdk';
- *
- * // Initialize once at app startup
- * await gossipSdk.init({
- *   db,
- *   protocolBaseUrl: 'https://api.example.com',
- * });
- *
- * // Open session (login) - SDK handles keys/session internally
- * await gossipSdk.openSession({
- *   mnemonic: 'word1 word2 ...',
- *   onPersist: async (blob) => { /* save to db *\/ },
- * });
- *
- * // Or restore existing session
- * await gossipSdk.openSession({
- *   mnemonic: 'word1 word2 ...',
- *   encryptedSession: savedBlob,
- *   encryptionKey: key,
- *   onPersist: async (blob) => { /* save to db *\/ },
- * });
- *
- * // Use clean API
- * await gossipSdk.messages.send(contactId, 'Hello!');
- * await gossipSdk.discussions.start(contact);
- * const contacts = await gossipSdk.contacts.list(ownerUserId);
- *
- * // Events
- * gossipSdk.on('message', (msg) => { ... });
- * gossipSdk.on('discussionRequest', (discussion, contact) => { ... });
- *
- * // Logout
- * await gossipSdk.closeSession();
- * ```
- */
-import { type Contact, type Discussion, type Message } from './db';
 import { type SdkConfig, type DeepPartial } from './config/sdk';
 import { SessionStatus, SessionConfig } from './assets/generated/wasm/gossip_wasm';
 import { EncryptionKey } from './wasm/encryption';
@@ -48,6 +7,7 @@ import { type MessageResult, type SendMessageResult } from './services/message';
 import { AuthService } from './services/auth';
 import type { DeleteContactResult, UpdateContactNameResult } from './utils/contacts';
 import { type ValidationResult } from './utils/validation';
+import { type Contact, type Discussion, type Message } from './db';
 import type { UserPublicKeys } from './wasm/bindings';
 import { SdkEventType, type SdkEventHandlers } from './core/SdkEventEmitter';
 import { AnnouncementPayload } from './utils/announcementPayload';