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

package/dist/queries/discussions.js

@@ -0,0 +1,73 @@
+import { eq, and, gt, sql } from 'drizzle-orm';
+import * as schema from '../schema';
+import { getSqliteDb, getLastInsertRowId } from '../sqlite';
+export async function getDiscussionByOwnerAndContact(ownerUserId, contactUserId) {
+    return getSqliteDb()
+        .select()
+        .from(schema.discussions)
+        .where(and(eq(schema.discussions.ownerUserId, ownerUserId), eq(schema.discussions.contactUserId, contactUserId)))
+        .get();
+}
+export async function getDiscussionsByOwner(ownerUserId) {
+    return getSqliteDb()
+        .select()
+        .from(schema.discussions)
+        .where(eq(schema.discussions.ownerUserId, ownerUserId))
+        .all();
+}
+export async function getDiscussionById(id) {
+    return getSqliteDb()
+        .select()
+        .from(schema.discussions)
+        .where(eq(schema.discussions.id, id))
+        .get();
+}
+export async function insertDiscussion(values) {
+    await getSqliteDb().insert(schema.discussions).values(values);
+    return getLastInsertRowId();
+}
+export async function updateDiscussionById(id, data) {
+    await getSqliteDb()
+        .update(schema.discussions)
+        .set(data)
+        .where(eq(schema.discussions.id, id));
+}
+export async function deleteDiscussionById(id) {
+    await getSqliteDb()
+        .delete(schema.discussions)
+        .where(eq(schema.discussions.id, id));
+}
+export async function deleteDiscussionsByOwnerAndContact(ownerUserId, contactUserId) {
+    await getSqliteDb()
+        .delete(schema.discussions)
+        .where(and(eq(schema.discussions.ownerUserId, ownerUserId), eq(schema.discussions.contactUserId, contactUserId)));
+}
+/**
+ * Atomically increment unreadCount by 1.
+ */
+export async function incrementUnreadCount(discussionId) {
+    await getSqliteDb()
+        .update(schema.discussions)
+        .set({
+        unreadCount: sql `${schema.discussions.unreadCount} + 1`,
+    })
+        .where(eq(schema.discussions.id, discussionId));
+}
+/**
+ * Atomically decrement unreadCount by 1, ensuring it never goes below 0.
+ */
+export async function decrementUnreadCount(discussionId) {
+    await getSqliteDb()
+        .update(schema.discussions)
+        .set({
+        unreadCount: sql `MAX(${schema.discussions.unreadCount} - 1, 0)`,
+    })
+        .where(and(eq(schema.discussions.id, discussionId), gt(schema.discussions.unreadCount, 0)));
+}
+export async function getDiscussionsByOwnerAndStatus(ownerUserId, status) {
+    return getSqliteDb()
+        .select()
+        .from(schema.discussions)
+        .where(and(eq(schema.discussions.ownerUserId, ownerUserId), eq(schema.discussions.status, status)))
+        .all();
+}

package/dist/queries/index.d.ts

@@ -0,0 +1,7 @@
+export * from './contacts';
+export * from './discussions';
+export * from './messages';
+export * from './userProfile';
+export * from './pendingAnnouncements';
+export * from './announcementCursors';
+export * from './activeSeekers';

package/dist/queries/index.js

@@ -0,0 +1,7 @@
+export * from './contacts';
+export * from './discussions';
+export * from './messages';
+export * from './userProfile';
+export * from './pendingAnnouncements';
+export * from './announcementCursors';
+export * from './activeSeekers';

package/dist/queries/messages.d.ts

@@ -0,0 +1,27 @@
+import * as schema from '../schema';
+import { MessageStatus } from '../db';
+export type MessageRow = typeof schema.messages.$inferSelect;
+export type MessageInsert = typeof schema.messages.$inferInsert;
+export declare function getMessageById(id: number): Promise<MessageRow | undefined>;
+export declare function getMessagesByOwnerAndContact(ownerUserId: string, contactUserId: string): Promise<MessageRow[]>;
+export declare function getMessageByOwnerAndSeeker(ownerUserId: string, seeker: Uint8Array): Promise<MessageRow | undefined>;
+export declare function findMessageByMessageId(ownerUserId: string, contactUserId: string, messageId: Uint8Array): Promise<MessageRow | undefined>;
+export declare function insertMessage(values: MessageInsert): Promise<number>;
+export declare function batchInsertMessages(values: MessageInsert[]): Promise<void>;
+export declare function updateMessageById(id: number, data: Partial<MessageInsert>): Promise<void>;
+export declare function deleteMessagesByOwnerAndContact(ownerUserId: string, contactUserId: string): Promise<void>;
+export declare function deleteDeliveredKeepAliveMessages(ownerUserId: string): Promise<void>;
+export declare function getOutgoingSentMessagesByOwner(ownerUserId: string): Promise<MessageRow[]>;
+export declare function getWaitingMessageCount(ownerUserId: string, contactUserId: string): Promise<number>;
+export declare function getSendQueueMessages(ownerUserId: string, contactUserId: string): Promise<MessageRow[]>;
+export declare function getMessagesByStatus(status: MessageStatus): Promise<MessageRow[]>;
+/**
+ * Reset outgoing messages to WAITING_SESSION, clearing encryption data.
+ * @param statuses - If provided, only reset messages with these statuses.
+ *                   If omitted, reset ALL outgoing messages for the contact.
+ */
+export declare function resetSendQueueMessages(ownerUserId: string, contactUserId: string, statuses?: MessageStatus[]): Promise<void>;
+export declare function getAnnouncementMessagesByContact(ownerUserId: string, contactUserId: string): Promise<MessageRow[]>;
+export declare function findDuplicateIncomingMessage(ownerUserId: string, contactUserId: string, content: string, windowStart: Date, windowEnd: Date): Promise<{
+    id: number;
+} | undefined>;

package/dist/queries/messages.js

@@ -0,0 +1,120 @@
+import { eq, and, sql, inArray, asc } from 'drizzle-orm';
+import * as schema from '../schema';
+import { getSqliteDb, getLastInsertRowId } from '../sqlite';
+import { MessageDirection, MessageStatus, MessageType } from '../db';
+export async function getMessageById(id) {
+    return getSqliteDb()
+        .select()
+        .from(schema.messages)
+        .where(eq(schema.messages.id, id))
+        .get();
+}
+export async function getMessagesByOwnerAndContact(ownerUserId, contactUserId) {
+    return getSqliteDb()
+        .select()
+        .from(schema.messages)
+        .where(and(eq(schema.messages.ownerUserId, ownerUserId), eq(schema.messages.contactUserId, contactUserId)))
+        .orderBy(asc(schema.messages.timestamp), asc(schema.messages.id))
+        .all();
+}
+export async function getMessageByOwnerAndSeeker(ownerUserId, seeker) {
+    return getSqliteDb()
+        .select()
+        .from(schema.messages)
+        .where(and(eq(schema.messages.ownerUserId, ownerUserId), eq(schema.messages.seeker, seeker)))
+        .get();
+}
+export async function findMessageByMessageId(ownerUserId, contactUserId, messageId) {
+    return getSqliteDb()
+        .select()
+        .from(schema.messages)
+        .where(and(eq(schema.messages.ownerUserId, ownerUserId), eq(schema.messages.contactUserId, contactUserId), eq(schema.messages.messageId, messageId)))
+        .get();
+}
+export async function insertMessage(values) {
+    await getSqliteDb().insert(schema.messages).values(values);
+    return getLastInsertRowId();
+}
+export async function batchInsertMessages(values) {
+    if (values.length === 0)
+        return;
+    await getSqliteDb().insert(schema.messages).values(values);
+}
+export async function updateMessageById(id, data) {
+    await getSqliteDb()
+        .update(schema.messages)
+        .set(data)
+        .where(eq(schema.messages.id, id));
+}
+export async function deleteMessagesByOwnerAndContact(ownerUserId, contactUserId) {
+    await getSqliteDb()
+        .delete(schema.messages)
+        .where(and(eq(schema.messages.ownerUserId, ownerUserId), eq(schema.messages.contactUserId, contactUserId)));
+}
+export async function deleteDeliveredKeepAliveMessages(ownerUserId) {
+    await getSqliteDb()
+        .delete(schema.messages)
+        .where(and(eq(schema.messages.ownerUserId, ownerUserId), eq(schema.messages.status, MessageStatus.DELIVERED), eq(schema.messages.type, MessageType.KEEP_ALIVE)));
+}
+export async function getOutgoingSentMessagesByOwner(ownerUserId) {
+    return getSqliteDb()
+        .select()
+        .from(schema.messages)
+        .where(and(eq(schema.messages.ownerUserId, ownerUserId), eq(schema.messages.direction, MessageDirection.OUTGOING), eq(schema.messages.status, MessageStatus.SENT)))
+        .all();
+}
+export async function getWaitingMessageCount(ownerUserId, contactUserId) {
+    const result = await getSqliteDb()
+        .select({ count: sql `count(*)` })
+        .from(schema.messages)
+        .where(and(eq(schema.messages.ownerUserId, ownerUserId), eq(schema.messages.contactUserId, contactUserId), eq(schema.messages.status, MessageStatus.WAITING_SESSION)))
+        .get();
+    return result?.count ?? 0;
+}
+export async function getSendQueueMessages(ownerUserId, contactUserId) {
+    return getSqliteDb()
+        .select()
+        .from(schema.messages)
+        .where(and(eq(schema.messages.ownerUserId, ownerUserId), eq(schema.messages.contactUserId, contactUserId), eq(schema.messages.direction, MessageDirection.OUTGOING), inArray(schema.messages.status, [
+        MessageStatus.WAITING_SESSION,
+        MessageStatus.READY,
+    ])))
+        .orderBy(asc(schema.messages.timestamp), asc(schema.messages.id))
+        .all();
+}
+export async function getMessagesByStatus(status) {
+    return getSqliteDb()
+        .select()
+        .from(schema.messages)
+        .where(eq(schema.messages.status, status))
+        .all();
+}
+/**
+ * Reset outgoing messages to WAITING_SESSION, clearing encryption data.
+ * @param statuses - If provided, only reset messages with these statuses.
+ *                   If omitted, reset ALL outgoing messages for the contact.
+ */
+export async function resetSendQueueMessages(ownerUserId, contactUserId, statuses) {
+    await getSqliteDb()
+        .update(schema.messages)
+        .set({
+        status: MessageStatus.WAITING_SESSION,
+        encryptedMessage: null,
+        seeker: null,
+    })
+        .where(and(eq(schema.messages.ownerUserId, ownerUserId), eq(schema.messages.contactUserId, contactUserId), eq(schema.messages.direction, MessageDirection.OUTGOING), statuses ? inArray(schema.messages.status, statuses) : undefined));
+}
+export async function getAnnouncementMessagesByContact(ownerUserId, contactUserId) {
+    return getSqliteDb()
+        .select()
+        .from(schema.messages)
+        .where(and(eq(schema.messages.ownerUserId, ownerUserId), eq(schema.messages.contactUserId, contactUserId), eq(schema.messages.direction, MessageDirection.INCOMING), eq(schema.messages.type, MessageType.ANNOUNCEMENT)))
+        .all();
+}
+export async function findDuplicateIncomingMessage(ownerUserId, contactUserId, content, windowStart, windowEnd) {
+    return getSqliteDb()
+        .select({ id: schema.messages.id })
+        .from(schema.messages)
+        .where(and(eq(schema.messages.ownerUserId, ownerUserId), eq(schema.messages.contactUserId, contactUserId), eq(schema.messages.direction, MessageDirection.INCOMING), eq(schema.messages.content, content), sql `${schema.messages.timestamp} >= ${windowStart.getTime()}`, sql `${schema.messages.timestamp} <= ${windowEnd.getTime()}`))
+        .get();
+}

package/dist/queries/pendingAnnouncements.d.ts

@@ -0,0 +1,4 @@
+import * as schema from '../schema';
+export type PendingAnnouncementRow = typeof schema.pendingAnnouncements.$inferSelect;
+export declare function getAllPendingAnnouncements(): Promise<PendingAnnouncementRow[]>;
+export declare function deletePendingAnnouncementsByIds(ids: number[]): Promise<void>;

package/dist/queries/pendingAnnouncements.js

@@ -0,0 +1,11 @@
+import { inArray } from 'drizzle-orm';
+import * as schema from '../schema';
+import { getSqliteDb } from '../sqlite';
+export async function getAllPendingAnnouncements() {
+    return getSqliteDb().select().from(schema.pendingAnnouncements).all();
+}
+export async function deletePendingAnnouncementsByIds(ids) {
+    await getSqliteDb()
+        .delete(schema.pendingAnnouncements)
+        .where(inArray(schema.pendingAnnouncements.id, ids));
+}

package/dist/queries/userProfile.d.ts

@@ -0,0 +1,22 @@
+import * as schema from '../schema';
+import type { UserProfile } from '../db';
+export type UserProfileRow = typeof schema.userProfile.$inferSelect;
+export type UserProfileInsert = typeof schema.userProfile.$inferInsert;
+/** Convert a DB row (security as JSON string) to a domain UserProfile. */
+export declare function rowToUserProfile(row: UserProfileRow): UserProfile;
+/** Convert a domain UserProfile to a DB-ready insert row (security as JSON string). */
+export declare function userProfileToRow(profile: UserProfile): UserProfileInsert;
+export declare function getUserProfileField(userId: string): Promise<UserProfileRow | undefined>;
+export declare function updateUserProfileById(userId: string, data: Partial<UserProfileInsert>): Promise<void>;
+export declare function getUserProfileByUsernameLower(username: string): Promise<{
+    userId: string;
+} | undefined>;
+export declare function getMostRecentUserProfile(): Promise<UserProfileRow | undefined>;
+export declare function getAllUserProfiles(): Promise<UserProfileRow[]>;
+export declare function getUserProfileCount(): Promise<number>;
+export declare function insertUserProfile(values: UserProfileInsert): Promise<void>;
+export declare function deleteUserProfile(userId: string): Promise<void>;
+export declare function getUserProfileByUsernameLowerExcluding(username: string, excludeUserId: string): Promise<{
+    userId: string;
+} | undefined>;
+export declare function upsertUserProfile(values: UserProfileInsert): Promise<void>;

package/dist/queries/userProfile.js

@@ -0,0 +1,116 @@
+import { and, desc, eq, ne, sql } from 'drizzle-orm';
+import * as schema from '../schema';
+import { getSqliteDb } from '../sqlite';
+/**
+ * Restore a Uint8Array from JSON-parsed data.
+ * Handles: number[] (correct format), {0:x, 1:y, ...} (corrupted from
+ * bare JSON.stringify of Uint8Array), or already a Uint8Array.
+ */
+function toUint8Array(val) {
+    if (val instanceof Uint8Array)
+        return val;
+    if (Array.isArray(val))
+        return new Uint8Array(val);
+    if (typeof val === 'object' && val !== null) {
+        const obj = val;
+        const len = Object.keys(obj).length;
+        const arr = new Uint8Array(len);
+        for (let i = 0; i < len; i++)
+            arr[i] = obj[String(i)];
+        return arr;
+    }
+    return new Uint8Array();
+}
+/** Convert a DB row (security as JSON string) to a domain UserProfile. */
+export function rowToUserProfile(row) {
+    const raw = typeof row.security === 'string' ? JSON.parse(row.security) : row.security;
+    const security = {
+        ...raw,
+        encKeySalt: toUint8Array(raw.encKeySalt),
+        mnemonicBackup: {
+            ...raw.mnemonicBackup,
+            encryptedMnemonic: toUint8Array(raw.mnemonicBackup.encryptedMnemonic),
+            createdAt: new Date(raw.mnemonicBackup.createdAt),
+        },
+    };
+    return { ...row, security };
+}
+/** Convert a domain UserProfile to a DB-ready insert row (security as JSON string). */
+export function userProfileToRow(profile) {
+    const security = {
+        ...profile.security,
+        encKeySalt: Array.from(profile.security.encKeySalt),
+        mnemonicBackup: {
+            ...profile.security.mnemonicBackup,
+            encryptedMnemonic: Array.from(profile.security.mnemonicBackup.encryptedMnemonic),
+        },
+    };
+    return {
+        ...profile,
+        security: JSON.stringify(security),
+        lastPublicKeyPush: profile.lastPublicKeyPush ?? null,
+    };
+}
+export async function getUserProfileField(userId) {
+    return getSqliteDb()
+        .select()
+        .from(schema.userProfile)
+        .where(eq(schema.userProfile.userId, userId))
+        .get();
+}
+export async function updateUserProfileById(userId, data) {
+    await getSqliteDb()
+        .update(schema.userProfile)
+        .set(data)
+        .where(eq(schema.userProfile.userId, userId));
+}
+export async function getUserProfileByUsernameLower(username) {
+    return getSqliteDb()
+        .select({ userId: schema.userProfile.userId })
+        .from(schema.userProfile)
+        .where(sql `LOWER(${schema.userProfile.username}) = ${username.trim().toLowerCase()}`)
+        .get();
+}
+export async function getMostRecentUserProfile() {
+    return getSqliteDb()
+        .select()
+        .from(schema.userProfile)
+        .orderBy(desc(schema.userProfile.lastSeen))
+        .limit(1)
+        .get();
+}
+export async function getAllUserProfiles() {
+    return getSqliteDb().select().from(schema.userProfile).all();
+}
+export async function getUserProfileCount() {
+    const result = await getSqliteDb()
+        .select({ count: sql `count(*)` })
+        .from(schema.userProfile)
+        .get();
+    return result?.count ?? 0;
+}
+export async function insertUserProfile(values) {
+    await getSqliteDb().insert(schema.userProfile).values(values);
+}
+export async function deleteUserProfile(userId) {
+    await getSqliteDb()
+        .delete(schema.userProfile)
+        .where(eq(schema.userProfile.userId, userId));
+}
+export async function getUserProfileByUsernameLowerExcluding(username, excludeUserId) {
+    return getSqliteDb()
+        .select({ userId: schema.userProfile.userId })
+        .from(schema.userProfile)
+        .where(and(sql `LOWER(${schema.userProfile.username}) = ${username.trim().toLowerCase()}`, ne(schema.userProfile.userId, excludeUserId)))
+        .get();
+}
+export async function upsertUserProfile(values) {
+    const { userId: _, ...rest } = values;
+    await getSqliteDb()
+        .insert(schema.userProfile)
+        .values(values)
+        .onConflictDoUpdate({
+        target: schema.userProfile.userId,
+        set: rest,
+    });
+}