zapo-js 0.1.0

package/dist/esm/store/providers/sqlite/signal.store.js

@@ -0,0 +1,353 @@
+import { decodeSignalPreKeyRow, decodeSignalRegistrationRow, decodeSignalRemoteIdentity, decodeSignalSessionRecord, decodeSignalSignedPreKeyRow, encodeSignalSessionRecord, toSignalAddressParts } from '../../../signal/store/sqlite.js';
+import { BaseSqliteStore } from '../../providers/sqlite/BaseSqliteStore.js';
+import { asNumber, asOptionalNumber, asString, toBoolOrUndef, resolvePositive } from '../../../util/coercion.js';
+import { signalAddressKey } from '../../../util/signal-address.js';
+const DEFAULTS = Object.freeze({
+    preKeyBatchSize: 500,
+    hasSessionBatchSize: 250
+});
+export class WaSignalSqliteStore extends BaseSqliteStore {
+    constructor(options, storeOptions = {}) {
+        super(options, ['signal']);
+        this.preKeyBatchSize = resolvePositive(storeOptions.preKeyBatchSize, DEFAULTS.preKeyBatchSize, 'signal.sqlite.preKeyBatchSize');
+        this.hasSessionBatchSize = resolvePositive(storeOptions.hasSessionBatchSize, DEFAULTS.hasSessionBatchSize, 'signal.sqlite.hasSessionBatchSize');
+    }
+    async getRegistrationInfo() {
+        const db = await this.getConnection();
+        const row = db.get(`SELECT registration_id, identity_pub_key, identity_priv_key
+             FROM signal_registration
+             WHERE session_id = ?`, [this.options.sessionId]);
+        return row ? decodeSignalRegistrationRow(row) : null;
+    }
+    async setRegistrationInfo(info) {
+        const db = await this.getConnection();
+        db.run(`INSERT INTO signal_registration (
+                session_id,
+                registration_id,
+                identity_pub_key,
+                identity_priv_key
+            ) VALUES (?, ?, ?, ?)
+            ON CONFLICT(session_id) DO UPDATE SET
+                registration_id=excluded.registration_id,
+                identity_pub_key=excluded.identity_pub_key,
+                identity_priv_key=excluded.identity_priv_key`, [
+            this.options.sessionId,
+            info.registrationId,
+            info.identityKeyPair.pubKey,
+            info.identityKeyPair.privKey
+        ]);
+    }
+    async getSignedPreKey() {
+        const db = await this.getConnection();
+        const row = db.get(`SELECT key_id, pub_key, priv_key, signature, uploaded
+             FROM signal_signed_prekey
+             WHERE session_id = ?`, [this.options.sessionId]);
+        return row ? decodeSignalSignedPreKeyRow(row) : null;
+    }
+    async setSignedPreKey(record) {
+        const db = await this.getConnection();
+        db.run(`INSERT INTO signal_signed_prekey (
+                session_id,
+                key_id,
+                pub_key,
+                priv_key,
+                signature,
+                uploaded
+            ) VALUES (?, ?, ?, ?, ?, ?)
+            ON CONFLICT(session_id) DO UPDATE SET
+                key_id=excluded.key_id,
+                pub_key=excluded.pub_key,
+                priv_key=excluded.priv_key,
+                signature=excluded.signature,
+                uploaded=excluded.uploaded`, [
+            this.options.sessionId,
+            record.keyId,
+            record.keyPair.pubKey,
+            record.keyPair.privKey,
+            record.signature,
+            record.uploaded === true ? 1 : 0
+        ]);
+    }
+    async getSignedPreKeyById(keyId) {
+        const db = await this.getConnection();
+        const row = db.get(`SELECT key_id, pub_key, priv_key, signature, uploaded
+             FROM signal_signed_prekey
+             WHERE session_id = ? AND key_id = ?`, [this.options.sessionId, keyId]);
+        return row ? decodeSignalSignedPreKeyRow(row) : null;
+    }
+    async setSignedPreKeyRotationTs(value) {
+        const db = await this.getConnection();
+        this.ensureMetaRow(db);
+        db.run(`UPDATE signal_meta
+             SET signed_prekey_rotation_ts = ?
+             WHERE session_id = ?`, [value, this.options.sessionId]);
+    }
+    async getSignedPreKeyRotationTs() {
+        const db = await this.getConnection();
+        const meta = this.getMeta(db);
+        return meta.signedPreKeyRotationTs;
+    }
+    async putPreKey(record) {
+        const db = await this.getConnection();
+        this.ensureMetaRow(db);
+        this.upsertPreKey(db, record);
+        db.run(`UPDATE signal_meta
+             SET next_prekey_id = MAX(next_prekey_id, ?)
+             WHERE session_id = ?`, [record.keyId + 1, this.options.sessionId]);
+    }
+    async getOrGenPreKeys(count, generator) {
+        if (!Number.isSafeInteger(count) || count <= 0) {
+            throw new Error(`invalid prekey count: ${count}`);
+        }
+        return this.withTransaction(async (db) => {
+            this.ensureMetaRow(db);
+            const available = db
+                .all(`SELECT key_id, pub_key, priv_key, uploaded
+                     FROM signal_prekey
+                     WHERE session_id = ? AND uploaded = 0
+                     ORDER BY key_id ASC
+                     LIMIT ?`, [this.options.sessionId, count])
+                .map((row) => decodeSignalPreKeyRow(row));
+            if (available.length < count) {
+                let nextPreKeyId = this.getMeta(db).nextPreKeyId;
+                while (available.length < count) {
+                    const requestedKeyId = nextPreKeyId;
+                    const generated = await generator(requestedKeyId);
+                    this.upsertPreKey(db, generated);
+                    available.push(generated);
+                    nextPreKeyId = Math.max(requestedKeyId + 1, generated.keyId + 1);
+                }
+                db.run(`UPDATE signal_meta
+                     SET next_prekey_id = ?
+                     WHERE session_id = ?`, [nextPreKeyId, this.options.sessionId]);
+            }
+            return available;
+        });
+    }
+    async getPreKeyById(keyId) {
+        const db = await this.getConnection();
+        const row = db.get(`SELECT key_id, pub_key, priv_key, uploaded
+             FROM signal_prekey
+             WHERE session_id = ? AND key_id = ?`, [this.options.sessionId, keyId]);
+        return row ? decodeSignalPreKeyRow(row) : null;
+    }
+    async getPreKeysById(keyIds) {
+        if (keyIds.length === 0) {
+            return [];
+        }
+        const db = await this.getConnection();
+        const uniqueKeyIds = [...new Set(keyIds)];
+        const byId = new Map();
+        for (let start = 0; start < uniqueKeyIds.length; start += this.preKeyBatchSize) {
+            const end = Math.min(start + this.preKeyBatchSize, uniqueKeyIds.length);
+            const batchLength = end - start;
+            const placeholders = new Array(batchLength).fill('?').join(', ');
+            const params = [this.options.sessionId];
+            for (let index = start; index < end; index += 1) {
+                params.push(uniqueKeyIds[index]);
+            }
+            const rows = db.all(`SELECT key_id, pub_key, priv_key, uploaded
+                 FROM signal_prekey
+                 WHERE session_id = ? AND key_id IN (${placeholders})`, params);
+            for (const row of rows) {
+                const record = decodeSignalPreKeyRow(row);
+                byId.set(record.keyId, record);
+            }
+        }
+        return keyIds.map((keyId) => byId.get(keyId) ?? null);
+    }
+    async consumePreKeyById(keyId) {
+        return this.withTransaction((db) => {
+            const row = db.get(`SELECT key_id, pub_key, priv_key, uploaded
+                 FROM signal_prekey
+                 WHERE session_id = ? AND key_id = ?`, [this.options.sessionId, keyId]);
+            if (!row) {
+                return null;
+            }
+            db.run(`DELETE FROM signal_prekey
+                 WHERE session_id = ? AND key_id = ?`, [this.options.sessionId, keyId]);
+            return decodeSignalPreKeyRow(row);
+        });
+    }
+    async getOrGenSinglePreKey(generator) {
+        const records = await this.getOrGenPreKeys(1, generator);
+        return records[0];
+    }
+    async markKeyAsUploaded(keyId) {
+        const db = await this.getConnection();
+        const meta = this.getMeta(db);
+        if (keyId < 0 || keyId >= meta.nextPreKeyId) {
+            throw new Error(`prekey ${keyId} is out of boundary`);
+        }
+        db.run(`UPDATE signal_prekey
+             SET uploaded = 1
+             WHERE session_id = ? AND key_id <= ?`, [this.options.sessionId, keyId]);
+    }
+    async setServerHasPreKeys(value) {
+        const db = await this.getConnection();
+        this.ensureMetaRow(db);
+        db.run(`UPDATE signal_meta
+             SET server_has_prekeys = ?
+             WHERE session_id = ?`, [value ? 1 : 0, this.options.sessionId]);
+    }
+    async getServerHasPreKeys() {
+        const db = await this.getConnection();
+        const meta = this.getMeta(db);
+        return meta.serverHasPreKeys;
+    }
+    async hasSession(address) {
+        const db = await this.getConnection();
+        const target = toSignalAddressParts(address);
+        return (db.get(`SELECT 1 AS has_session
+                 FROM signal_session
+                 WHERE session_id = ? AND user = ? AND server = ? AND device = ?
+                 LIMIT 1`, [this.options.sessionId, target.user, target.server, target.device]) !== null);
+    }
+    async hasSessions(addresses) {
+        if (addresses.length === 0) {
+            return [];
+        }
+        const db = await this.getConnection();
+        const targets = addresses.map((address) => toSignalAddressParts(address));
+        const existingKeys = new Set();
+        for (let start = 0; start < targets.length; start += this.hasSessionBatchSize) {
+            const end = Math.min(start + this.hasSessionBatchSize, targets.length);
+            const batchLength = end - start;
+            const filters = new Array(batchLength)
+                .fill('(user = ? AND server = ? AND device = ?)')
+                .join(' OR ');
+            const params = [this.options.sessionId];
+            for (let index = start; index < end; index += 1) {
+                const target = targets[index];
+                params.push(target.user, target.server, target.device);
+            }
+            const rows = db.all(`SELECT user, server, device
+                 FROM signal_session
+                 WHERE session_id = ? AND (${filters})`, params);
+            for (const row of rows) {
+                existingKeys.add(signalAddressKey({
+                    user: asString(row.user, 'signal_session.user'),
+                    server: asString(row.server, 'signal_session.server'),
+                    device: asNumber(row.device, 'signal_session.device')
+                }));
+            }
+        }
+        return addresses.map((address) => existingKeys.has(signalAddressKey(address)));
+    }
+    async getSession(address) {
+        const db = await this.getConnection();
+        const target = toSignalAddressParts(address);
+        const row = db.get(`SELECT user, server, device, record
+             FROM signal_session
+             WHERE session_id = ? AND user = ? AND server = ? AND device = ?`, [this.options.sessionId, target.user, target.server, target.device]);
+        return row ? decodeSignalSessionRecord(row.record) : null;
+    }
+    async setSession(address, session) {
+        const db = await this.getConnection();
+        const target = toSignalAddressParts(address);
+        db.run(`INSERT INTO signal_session (
+                session_id,
+                user,
+                server,
+                device,
+                record
+            ) VALUES (?, ?, ?, ?, ?)
+            ON CONFLICT(session_id, user, server, device) DO UPDATE SET
+                record=excluded.record`, [
+            this.options.sessionId,
+            target.user,
+            target.server,
+            target.device,
+            encodeSignalSessionRecord(session)
+        ]);
+    }
+    async deleteSession(address) {
+        const db = await this.getConnection();
+        const target = toSignalAddressParts(address);
+        db.run(`DELETE FROM signal_session
+             WHERE session_id = ? AND user = ? AND server = ? AND device = ?`, [this.options.sessionId, target.user, target.server, target.device]);
+    }
+    async getRemoteIdentity(address) {
+        const db = await this.getConnection();
+        const target = toSignalAddressParts(address);
+        const row = db.get(`SELECT identity_key
+             FROM signal_identity
+             WHERE session_id = ? AND user = ? AND server = ? AND device = ?`, [this.options.sessionId, target.user, target.server, target.device]);
+        return row ? decodeSignalRemoteIdentity(row.identity_key) : null;
+    }
+    async setRemoteIdentity(address, identityKey) {
+        const db = await this.getConnection();
+        const target = toSignalAddressParts(address);
+        this.upsertRemoteIdentity(db, target, identityKey);
+    }
+    async setRemoteIdentities(entries) {
+        if (entries.length === 0) {
+            return;
+        }
+        await this.withTransaction((db) => {
+            for (const entry of entries) {
+                const target = toSignalAddressParts(entry.address);
+                this.upsertRemoteIdentity(db, target, entry.identityKey);
+            }
+        });
+    }
+    async clear() {
+        await this.withTransaction((db) => {
+            db.run('DELETE FROM signal_registration WHERE session_id = ?', [this.options.sessionId]);
+            db.run('DELETE FROM signal_signed_prekey WHERE session_id = ?', [this.options.sessionId]);
+            db.run('DELETE FROM signal_prekey WHERE session_id = ?', [this.options.sessionId]);
+            db.run('DELETE FROM signal_session WHERE session_id = ?', [this.options.sessionId]);
+            db.run('DELETE FROM signal_identity WHERE session_id = ?', [this.options.sessionId]);
+            db.run('DELETE FROM signal_meta WHERE session_id = ?', [this.options.sessionId]);
+        });
+    }
+    upsertPreKey(db, record) {
+        db.run(`INSERT INTO signal_prekey (
+                session_id,
+                key_id,
+                pub_key,
+                priv_key,
+                uploaded
+            ) VALUES (?, ?, ?, ?, ?)
+            ON CONFLICT(session_id, key_id) DO UPDATE SET
+                pub_key=excluded.pub_key,
+                priv_key=excluded.priv_key,
+                uploaded=excluded.uploaded`, [
+            this.options.sessionId,
+            record.keyId,
+            record.keyPair.pubKey,
+            record.keyPair.privKey,
+            record.uploaded === true ? 1 : 0
+        ]);
+    }
+    ensureMetaRow(db) {
+        db.run(`INSERT INTO signal_meta (
+                session_id,
+                server_has_prekeys,
+                next_prekey_id
+            ) VALUES (?, 0, 1)
+            ON CONFLICT(session_id) DO NOTHING`, [this.options.sessionId]);
+    }
+    getMeta(db) {
+        this.ensureMetaRow(db);
+        const row = db.get(`SELECT server_has_prekeys, next_prekey_id, signed_prekey_rotation_ts
+             FROM signal_meta
+             WHERE session_id = ?`, [this.options.sessionId]);
+        return {
+            serverHasPreKeys: toBoolOrUndef(row.server_has_prekeys) === true,
+            nextPreKeyId: asNumber(row.next_prekey_id, 'signal_meta.next_prekey_id'),
+            signedPreKeyRotationTs: asOptionalNumber(row.signed_prekey_rotation_ts, 'signal_meta.signed_prekey_rotation_ts') ?? null
+        };
+    }
+    upsertRemoteIdentity(db, target, identityKey) {
+        db.run(`INSERT INTO signal_identity (
+                session_id,
+                user,
+                server,
+                device,
+                identity_key
+            ) VALUES (?, ?, ?, ?, ?)
+            ON CONFLICT(session_id, user, server, device) DO UPDATE SET
+                identity_key=excluded.identity_key`, [this.options.sessionId, target.user, target.server, target.device, identityKey]);
+    }
+}

package/dist/esm/store/providers/sqlite/thread.store.js

@@ -0,0 +1,72 @@
+import { BaseSqliteStore } from '../../providers/sqlite/BaseSqliteStore.js';
+import { asOptionalNumber, asOptionalString, asString, toBoolOrUndef } from '../../../util/coercion.js';
+import { normalizeQueryLimit } from '../../../util/collections.js';
+const THREAD_COLUMNS = 'jid, name, unread_count, archived, pinned, mute_end_ms, marked_as_unread, ephemeral_expiration';
+function decodeThreadRow(row) {
+    return {
+        jid: asString(row.jid, 'mailbox_threads.jid'),
+        name: asOptionalString(row.name, 'mailbox_threads.name'),
+        unreadCount: asOptionalNumber(row.unread_count, 'mailbox_threads.unread_count'),
+        archived: toBoolOrUndef(row.archived),
+        pinned: asOptionalNumber(row.pinned, 'mailbox_threads.pinned'),
+        muteEndMs: asOptionalNumber(row.mute_end_ms, 'mailbox_threads.mute_end_ms'),
+        markedAsUnread: toBoolOrUndef(row.marked_as_unread),
+        ephemeralExpiration: asOptionalNumber(row.ephemeral_expiration, 'mailbox_threads.ephemeral_expiration')
+    };
+}
+export class WaThreadSqliteStore extends BaseSqliteStore {
+    constructor(options) {
+        super(options, ['mailbox']);
+    }
+    async upsert(record) {
+        const db = await this.getConnection();
+        db.run(`INSERT INTO mailbox_threads (
+                session_id, jid, name, unread_count, archived, pinned,
+                mute_end_ms, marked_as_unread, ephemeral_expiration
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT(session_id, jid) DO UPDATE SET
+                name=COALESCE(excluded.name, mailbox_threads.name),
+                unread_count=COALESCE(excluded.unread_count, mailbox_threads.unread_count),
+                archived=COALESCE(excluded.archived, mailbox_threads.archived),
+                pinned=COALESCE(excluded.pinned, mailbox_threads.pinned),
+                mute_end_ms=COALESCE(excluded.mute_end_ms, mailbox_threads.mute_end_ms),
+                marked_as_unread=COALESCE(excluded.marked_as_unread, mailbox_threads.marked_as_unread),
+                ephemeral_expiration=COALESCE(excluded.ephemeral_expiration, mailbox_threads.ephemeral_expiration)`, [
+            this.options.sessionId,
+            record.jid,
+            record.name ?? null,
+            record.unreadCount ?? null,
+            record.archived === undefined ? null : record.archived ? 1 : 0,
+            record.pinned ?? null,
+            record.muteEndMs ?? null,
+            record.markedAsUnread === undefined ? null : record.markedAsUnread ? 1 : 0,
+            record.ephemeralExpiration ?? null
+        ]);
+    }
+    async getByJid(jid) {
+        const db = await this.getConnection();
+        const row = db.get(`SELECT ${THREAD_COLUMNS}
+             FROM mailbox_threads
+             WHERE session_id = ? AND jid = ?`, [this.options.sessionId, jid]);
+        return row ? decodeThreadRow(row) : null;
+    }
+    async list(limit) {
+        const db = await this.getConnection();
+        const rows = db.all(`SELECT ${THREAD_COLUMNS}
+             FROM mailbox_threads
+             WHERE session_id = ?
+             LIMIT ?`, [this.options.sessionId, normalizeQueryLimit(limit, 100)]);
+        return rows.map(decodeThreadRow);
+    }
+    async deleteByJid(jid) {
+        const db = await this.getConnection();
+        db.run(`DELETE FROM mailbox_threads
+             WHERE session_id = ? AND jid = ?`, [this.options.sessionId, jid]);
+        const row = db.get('SELECT changes() AS total', []);
+        return row ? Number(row.total) : 0;
+    }
+    async clear() {
+        const db = await this.getConnection();
+        db.run('DELETE FROM mailbox_threads WHERE session_id = ?', [this.options.sessionId]);
+    }
+}

package/dist/esm/store/types.js

@@ -0,0 +1 @@
+export {};