@massalabs/gossip-sdk 0.0.2-dev.20260128094509 → 0.0.2-dev.20260128160824

package/dist/db.d.ts

@@ -0,0 +1,190 @@
+/**
+ * Gossip Database
+ *
+ * IndexedDB database implementation using Dexie for the Gossip messenger.
+ * Provides tables for contacts, messages, discussions, user profiles, and more.
+ */
+import Dexie, { Table } from 'dexie';
+export type AuthMethod = 'capacitor' | 'webauthn' | 'password';
+export interface Contact {
+    id?: number;
+    ownerUserId: string;
+    userId: string;
+    name: string;
+    avatar?: string;
+    publicKeys: Uint8Array;
+    isOnline: boolean;
+    lastSeen: Date;
+    createdAt: Date;
+}
+export interface Message {
+    id?: number;
+    ownerUserId: string;
+    contactUserId: string;
+    content: string;
+    serializedContent?: Uint8Array;
+    type: MessageType;
+    direction: MessageDirection;
+    status: MessageStatus;
+    timestamp: Date;
+    metadata?: Record<string, unknown>;
+    seeker?: Uint8Array;
+    replyTo?: {
+        originalContent?: string;
+        originalSeeker: Uint8Array;
+    };
+    forwardOf?: {
+        originalContent?: string;
+        originalSeeker: Uint8Array;
+    };
+    encryptedMessage?: Uint8Array;
+}
+export interface UserProfile {
+    userId: string;
+    username: string;
+    avatar?: string;
+    security: {
+        encKeySalt: Uint8Array;
+        authMethod: AuthMethod;
+        webauthn?: {
+            credentialId?: string;
+        };
+        iCloudSync?: boolean;
+        mnemonicBackup: {
+            encryptedMnemonic: Uint8Array;
+            createdAt: Date;
+            backedUp: boolean;
+        };
+    };
+    session: Uint8Array;
+    bio?: string;
+    status: 'online' | 'away' | 'busy' | 'offline';
+    lastSeen: Date;
+    createdAt: Date;
+    updatedAt: Date;
+    lastPublicKeyPush?: Date;
+    lastBulletinCounter?: string;
+}
+export declare enum DiscussionStatus {
+    PENDING = "pending",
+    ACTIVE = "active",
+    CLOSED = "closed",// closed by the user
+    BROKEN = "broken",// The session is killed. Need to be reinitiated
+    SEND_FAILED = "sendFailed",// The discussion was initiated by the session manager but could not be broadcasted on network
+    RECONNECTING = "reconnecting"
+}
+export declare enum MessageDirection {
+    INCOMING = "incoming",
+    OUTGOING = "outgoing"
+}
+export declare enum MessageStatus {
+    WAITING_SESSION = "waiting_session",// Waiting for active session with peer
+    SENDING = "sending",
+    SENT = "sent",
+    DELIVERED = "delivered",
+    READ = "read",
+    FAILED = "failed"
+}
+export declare enum DiscussionDirection {
+    INITIATED = "initiated",
+    RECEIVED = "received"
+}
+export declare enum MessageType {
+    TEXT = "text",
+    KEEP_ALIVE = "keep_alive",
+    IMAGE = "image",
+    FILE = "file",
+    AUDIO = "audio",
+    VIDEO = "video"
+}
+export interface Discussion {
+    id?: number;
+    ownerUserId: string;
+    contactUserId: string;
+    direction: DiscussionDirection;
+    status: DiscussionStatus;
+    nextSeeker?: Uint8Array;
+    initiationAnnouncement?: Uint8Array;
+    announcementMessage?: string;
+    lastSyncTimestamp?: Date;
+    customName?: string;
+    lastMessageId?: number;
+    lastMessageContent?: string;
+    lastMessageTimestamp?: Date;
+    unreadCount: number;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface PendingEncryptedMessage {
+    id?: number;
+    seeker: Uint8Array;
+    ciphertext: Uint8Array;
+    fetchedAt: Date;
+}
+export interface PendingAnnouncement {
+    id?: number;
+    announcement: Uint8Array;
+    fetchedAt: Date;
+    counter?: string;
+}
+export interface ActiveSeeker {
+    id?: number;
+    seeker: Uint8Array;
+}
+export declare class GossipDatabase extends Dexie {
+    contacts: Table<Contact>;
+    messages: Table<Message>;
+    userProfile: Table<UserProfile>;
+    discussions: Table<Discussion>;
+    pendingEncryptedMessages: Table<PendingEncryptedMessage>;
+    pendingAnnouncements: Table<PendingAnnouncement>;
+    activeSeekers: Table<ActiveSeeker>;
+    constructor();
+    /** CONTACTS */
+    getContactsByOwner(ownerUserId: string): Promise<Contact[]>;
+    getContactByOwnerAndUserId(ownerUserId: string, userId: string): Promise<Contact | undefined>;
+    /** DISCUSSIONS */
+    getDiscussionsByOwner(ownerUserId: string): Promise<Discussion[]>;
+    getUnreadCountByOwner(ownerUserId: string): Promise<number>;
+    getDiscussionByOwnerAndContact(ownerUserId: string, contactUserId: string): Promise<Discussion | undefined>;
+    /**
+     * Get all active discussions with their sync status
+     * @returns Array of active discussions
+     */
+    getActiveDiscussionsByOwner(ownerUserId: string): Promise<Discussion[]>;
+    markMessagesAsRead(ownerUserId: string, contactUserId: string): Promise<void>;
+    getMessagesForContactByOwner(ownerUserId: string, contactUserId: string, limit?: number): Promise<Message[]>;
+    addMessage(message: Omit<Message, 'id'>): Promise<number>;
+    /**
+     * Update the last sync timestamp for a discussion
+     * @param discussionId - The discussion ID
+     * @param timestamp - The sync timestamp
+     */
+    updateLastSyncTimestamp(discussionId: number, timestamp: Date): Promise<void>;
+    deleteDb(): Promise<void>;
+    /**
+     * Set all active seekers, replacing any existing ones
+     * @param seekers - Array of seeker Uint8Arrays to store
+     */
+    setActiveSeekers(seekers: Uint8Array[]): Promise<void>;
+    /**
+     * Get all active seekers from the database
+     * @returns Array of seeker Uint8Arrays
+     */
+    getActiveSeekers(): Promise<Uint8Array[]>;
+}
+/**
+ * Get the database instance.
+ * Creates a default instance if none was set via setDb().
+ */
+export declare function getDb(): GossipDatabase;
+/**
+ * Set the database instance.
+ * Call this before using any SDK functions if you need a custom db instance.
+ */
+export declare function setDb(database: GossipDatabase): void;
+/**
+ * Get the database instance.
+ * Creates a default instance if none was set via setDb().
+ */
+export declare const db: GossipDatabase;

package/dist/db.js

@@ -0,0 +1,311 @@
+/**
+ * Gossip Database
+ *
+ * IndexedDB database implementation using Dexie for the Gossip messenger.
+ * Provides tables for contacts, messages, discussions, user profiles, and more.
+ */
+import Dexie from 'dexie';
+// Unified discussion interface combining protocol state and UI metadata
+export var DiscussionStatus;
+(function (DiscussionStatus) {
+    DiscussionStatus["PENDING"] = "pending";
+    DiscussionStatus["ACTIVE"] = "active";
+    DiscussionStatus["CLOSED"] = "closed";
+    DiscussionStatus["BROKEN"] = "broken";
+    DiscussionStatus["SEND_FAILED"] = "sendFailed";
+    DiscussionStatus["RECONNECTING"] = "reconnecting";
+})(DiscussionStatus || (DiscussionStatus = {}));
+export var MessageDirection;
+(function (MessageDirection) {
+    MessageDirection["INCOMING"] = "incoming";
+    MessageDirection["OUTGOING"] = "outgoing";
+})(MessageDirection || (MessageDirection = {}));
+export var MessageStatus;
+(function (MessageStatus) {
+    MessageStatus["WAITING_SESSION"] = "waiting_session";
+    MessageStatus["SENDING"] = "sending";
+    MessageStatus["SENT"] = "sent";
+    MessageStatus["DELIVERED"] = "delivered";
+    MessageStatus["READ"] = "read";
+    MessageStatus["FAILED"] = "failed";
+})(MessageStatus || (MessageStatus = {}));
+export var DiscussionDirection;
+(function (DiscussionDirection) {
+    DiscussionDirection["INITIATED"] = "initiated";
+    DiscussionDirection["RECEIVED"] = "received";
+})(DiscussionDirection || (DiscussionDirection = {}));
+export var MessageType;
+(function (MessageType) {
+    MessageType["TEXT"] = "text";
+    MessageType["KEEP_ALIVE"] = "keep_alive";
+    MessageType["IMAGE"] = "image";
+    MessageType["FILE"] = "file";
+    MessageType["AUDIO"] = "audio";
+    MessageType["VIDEO"] = "video";
+})(MessageType || (MessageType = {}));
+// Define the database class
+export class GossipDatabase extends Dexie {
+    constructor() {
+        super('GossipDatabase');
+        // Define tables
+        Object.defineProperty(this, "contacts", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "messages", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "userProfile", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "discussions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "pendingEncryptedMessages", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "pendingAnnouncements", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "activeSeekers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.version(13).stores({
+            contacts: '++id, ownerUserId, userId, name, isOnline, lastSeen, createdAt, [ownerUserId+userId] , [ownerUserId+name]',
+            messages: '++id, ownerUserId, contactUserId, type, direction, status, timestamp, seeker, [ownerUserId+contactUserId], [ownerUserId+status], [ownerUserId+contactUserId+status], [ownerUserId+seeker], [ownerUserId+contactUserId+direction], [ownerUserId+direction+status]',
+            userProfile: 'userId, username, status, lastSeen',
+            discussions: '++id, ownerUserId, &[ownerUserId+contactUserId], status, [ownerUserId+status], lastSyncTimestamp, unreadCount, lastMessageTimestamp, createdAt, updatedAt',
+            pendingEncryptedMessages: '++id, fetchedAt, seeker',
+            pendingAnnouncements: '++id, fetchedAt, &announcement',
+            activeSeekers: '++id, seeker',
+        });
+        // Add hooks for automatic timestamps
+        this.contacts.hook('creating', function (_primKey, obj, _trans) {
+            obj.createdAt = new Date();
+        });
+        this.userProfile.hook('creating', function (_primKey, obj, _trans) {
+            obj.createdAt = new Date();
+            obj.updatedAt = new Date();
+        });
+        this.userProfile.hook('updating', function (modifications, _primKey, _obj, _trans) {
+            modifications.updatedAt = new Date();
+        });
+        this.discussions.hook('creating', function (_primKey, obj, _trans) {
+            obj.createdAt = new Date();
+            obj.updatedAt = new Date();
+        });
+        this.discussions.hook('updating', function (modifications, _primKey, _obj, _trans) {
+            modifications.updatedAt = new Date();
+        });
+    }
+    // Helper methods for common operations
+    /** CONTACTS */
+    async getContactsByOwner(ownerUserId) {
+        return await this.contacts
+            .where('ownerUserId')
+            .equals(ownerUserId)
+            .toArray();
+    }
+    async getContactByOwnerAndUserId(ownerUserId, userId) {
+        return await this.contacts
+            .where('[ownerUserId+userId]')
+            .equals([ownerUserId, userId])
+            .first();
+    }
+    /** DISCUSSIONS */
+    async getDiscussionsByOwner(ownerUserId) {
+        const all = await this.discussions
+            .where('ownerUserId')
+            .equals(ownerUserId)
+            .toArray();
+        return all.sort((a, b) => {
+            if (a.lastMessageTimestamp && b.lastMessageTimestamp) {
+                return (b.lastMessageTimestamp.getTime() - a.lastMessageTimestamp.getTime());
+            }
+            if (a.lastMessageTimestamp)
+                return -1;
+            if (b.lastMessageTimestamp)
+                return 1;
+            return b.createdAt.getTime() - a.createdAt.getTime();
+        });
+    }
+    async getUnreadCountByOwner(ownerUserId) {
+        const discussions = await this.discussions
+            .where('ownerUserId')
+            .equals(ownerUserId)
+            .toArray();
+        return discussions.reduce((total, d) => total + d.unreadCount, 0);
+    }
+    async getDiscussionByOwnerAndContact(ownerUserId, contactUserId) {
+        if (!ownerUserId || !contactUserId) {
+            return undefined;
+        }
+        return await this.discussions
+            .where('[ownerUserId+contactUserId]')
+            .equals([ownerUserId, contactUserId])
+            .first();
+    }
+    /**
+     * Get all active discussions with their sync status
+     * @returns Array of active discussions
+     */
+    async getActiveDiscussionsByOwner(ownerUserId) {
+        return await this.discussions
+            .where('[ownerUserId+status]')
+            .equals([ownerUserId, DiscussionStatus.ACTIVE])
+            .toArray();
+    }
+    async markMessagesAsRead(ownerUserId, contactUserId) {
+        await this.messages
+            .where('[ownerUserId+contactUserId+status]')
+            .equals([ownerUserId, contactUserId, MessageStatus.DELIVERED])
+            .and(msg => msg.direction === MessageDirection.INCOMING)
+            .modify({ status: MessageStatus.READ });
+        await this.discussions
+            .where('[ownerUserId+contactUserId]')
+            .equals([ownerUserId, contactUserId])
+            .modify({ unreadCount: 0 });
+    }
+    async getMessagesForContactByOwner(ownerUserId, contactUserId, limit = 50) {
+        return await this.messages
+            .where('[ownerUserId+contactUserId]')
+            .equals([ownerUserId, contactUserId])
+            .reverse()
+            .limit(limit)
+            .toArray();
+    }
+    async addMessage(message) {
+        const messageId = await this.messages.add(message);
+        // Get existing discussion
+        const discussion = await this.getDiscussionByOwnerAndContact(message.ownerUserId, message.contactUserId);
+        if (discussion) {
+            await this.discussions.update(discussion.id, {
+                lastMessageId: messageId,
+                lastMessageContent: message.content,
+                lastMessageTimestamp: message.timestamp,
+                unreadCount: message.direction === MessageDirection.INCOMING
+                    ? discussion.unreadCount + 1
+                    : discussion.unreadCount,
+                updatedAt: new Date(),
+            });
+        }
+        else {
+            // Note: For new messages, a discussion should already exist from the protocol
+            // If not, we'll create a minimal one (this shouldn't normally happen)
+            console.log('Warning: Creating discussion for contact without protocol setup:', message.contactUserId);
+            await this.discussions.put({
+                ownerUserId: message.ownerUserId,
+                contactUserId: message.contactUserId,
+                direction: message.direction === MessageDirection.INCOMING
+                    ? DiscussionDirection.RECEIVED
+                    : DiscussionDirection.INITIATED,
+                status: DiscussionStatus.PENDING,
+                nextSeeker: undefined,
+                lastMessageId: messageId,
+                lastMessageContent: message.content,
+                lastMessageTimestamp: message.timestamp,
+                unreadCount: message.direction === MessageDirection.INCOMING ? 1 : 0,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+            });
+        }
+        return messageId;
+    }
+    /**
+     * Update the last sync timestamp for a discussion
+     * @param discussionId - The discussion ID
+     * @param timestamp - The sync timestamp
+     */
+    async updateLastSyncTimestamp(discussionId, timestamp) {
+        await this.discussions.update(discussionId, {
+            lastSyncTimestamp: timestamp,
+            updatedAt: new Date(),
+        });
+    }
+    async deleteDb() {
+        await this.close();
+        await this.delete();
+    }
+    /**
+     * Set all active seekers, replacing any existing ones
+     * @param seekers - Array of seeker Uint8Arrays to store
+     */
+    async setActiveSeekers(seekers) {
+        await this.transaction('rw', this.activeSeekers, async () => {
+            // Clear all existing seekers
+            await this.activeSeekers.clear();
+            // Bulk add all new seekers
+            if (seekers.length > 0) {
+                await this.activeSeekers.bulkAdd(seekers.map(seeker => ({
+                    seeker,
+                })));
+            }
+        });
+    }
+    /**
+     * Get all active seekers from the database
+     * @returns Array of seeker Uint8Arrays
+     */
+    async getActiveSeekers() {
+        const activeSeekers = await this.activeSeekers.toArray();
+        return activeSeekers.map(item => item.seeker);
+    }
+}
+// Database instance - initialized lazily or via setDb()
+let _db = null;
+let _warnedGlobalDbAccess = false;
+/**
+ * Get the database instance.
+ * Creates a default instance if none was set via setDb().
+ */
+export function getDb() {
+    if (!_db) {
+        _db = new GossipDatabase();
+    }
+    return _db;
+}
+/**
+ * Set the database instance.
+ * Call this before using any SDK functions if you need a custom db instance.
+ */
+export function setDb(database) {
+    _db = database;
+}
+/**
+ * Get the database instance.
+ * Creates a default instance if none was set via setDb().
+ */
+export const db = new Proxy({}, {
+    get(_target, prop) {
+        if (!_warnedGlobalDbAccess) {
+            _warnedGlobalDbAccess = true;
+            console.warn('[GossipSdk] Global db access is deprecated. Use createGossipSdk() or setDb().');
+        }
+        const target = getDb();
+        const value = Reflect.get(target, prop);
+        if (typeof value === 'function') {
+            return value.bind(target);
+        }
+        return value;
+    },
+});