zapo-js 0.1.2 → 0.2.0

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

@@ -1,245 +0,0 @@
-import { createSqliteTableNameSqlResolver, resolveSqliteTableNames, serializeSqliteTableNames } from '../../providers/sqlite/table-names.js';
-import { toSafeNumber } from '../../../util/primitives.js';
-import { isBunRuntime } from '../../../util/runtime.js';
-const BETTER_SQLITE3_MODULE = 'better-sqlite3';
-const BUN_SQLITE_MODULE = 'bun:sqlite';
-const SQLITE_PRAGMA_TOKEN_PATTERN = /^[A-Za-z0-9_+-]+$/;
-const DEFAULT_SQLITE_PRAGMAS = Object.freeze({
-    journal_mode: 'WAL',
-    synchronous: 'normal',
-    busy_timeout: 5000
-});
-const ALLOWED_SQLITE_PRAGMAS = {
-    auto_vacuum: 'token_or_int',
-    busy_timeout: 'int',
-    cache_size: 'int',
-    foreign_keys: 'token_or_int',
-    journal_mode: 'token',
-    journal_size_limit: 'int',
-    legacy_alter_table: 'token_or_int',
-    locking_mode: 'token',
-    mmap_size: 'int',
-    page_size: 'int',
-    recursive_triggers: 'token_or_int',
-    secure_delete: 'token_or_int',
-    synchronous: 'token_or_int',
-    temp_store: 'token_or_int',
-    wal_autocheckpoint: 'int'
-};
-function asConstructor(loaded) {
-    if (typeof loaded === 'function') {
-        return loaded;
-    }
-    if (loaded && typeof loaded === 'object') {
-        const candidate = loaded.default;
-        if (typeof candidate === 'function') {
-            return candidate;
-        }
-    }
-    throw new Error('invalid sqlite driver export');
-}
-function statementFor(db, sql) {
-    const prepare = db.prepare ?? db.query;
-    if (!prepare) {
-        throw new Error('sqlite driver does not expose prepare/query method');
-    }
-    const statement = prepare.call(db, sql);
-    if (!statement ||
-        typeof statement.run !== 'function' ||
-        typeof statement.get !== 'function' ||
-        typeof statement.all !== 'function') {
-        throw new Error('invalid sqlite statement API');
-    }
-    return statement;
-}
-function wrapConnection(db, driver, resolveSql, onClose) {
-    const statementCache = new Map();
-    const cachedStatementFor = (sql) => {
-        const resolvedSql = resolveSql(sql);
-        const cached = statementCache.get(resolvedSql);
-        if (cached) {
-            return cached;
-        }
-        const statement = statementFor(db, resolvedSql);
-        statementCache.set(resolvedSql, statement);
-        return statement;
-    };
-    return {
-        driver,
-        exec(sql) {
-            db.exec(resolveSql(sql));
-        },
-        run(sql, params) {
-            const statement = cachedStatementFor(sql);
-            if (!params || params.length === 0) {
-                statement.run();
-                return;
-            }
-            statement.run(...params);
-        },
-        get(sql, params) {
-            const statement = cachedStatementFor(sql);
-            const row = !params || params.length === 0 ? statement.get() : statement.get(...params);
-            return row ?? null;
-        },
-        all(sql, params) {
-            const statement = cachedStatementFor(sql);
-            const rows = !params || params.length === 0 ? statement.all() : statement.all(...params);
-            return Array.isArray(rows) ? rows : [];
-        },
-        close() {
-            statementCache.clear();
-            try {
-                db.close();
-            }
-            finally {
-                onClose?.();
-            }
-        }
-    };
-}
-function pragmaEntries(options) {
-    return Object.entries(mergePragmas(options.pragmas));
-}
-function mergePragmas(pragmas) {
-    return {
-        ...DEFAULT_SQLITE_PRAGMAS,
-        ...(pragmas ?? {})
-    };
-}
-const ALLOWED_SQLITE_PRAGMA_LIST = Object.keys(ALLOWED_SQLITE_PRAGMAS).sort().join(', ');
-function normalizePragmaKey(rawKey) {
-    const key = rawKey.trim().toLowerCase();
-    if (!Object.prototype.hasOwnProperty.call(ALLOWED_SQLITE_PRAGMAS, key)) {
-        throw new Error(`unsupported sqlite pragma "${rawKey}". Allowed pragmas: ${ALLOWED_SQLITE_PRAGMA_LIST}`);
-    }
-    return key;
-}
-function normalizePragmaToken(key, rawValue) {
-    const value = rawValue.trim();
-    if (value.length === 0 || !SQLITE_PRAGMA_TOKEN_PATTERN.test(value)) {
-        throw new Error(`invalid sqlite pragma "${key}" value "${rawValue}". Allowed token pattern: ${SQLITE_PRAGMA_TOKEN_PATTERN}`);
-    }
-    return value;
-}
-function normalizePragmaValue(key, rawValue) {
-    const kind = ALLOWED_SQLITE_PRAGMAS[key];
-    if (kind === 'int') {
-        if (typeof rawValue !== 'number') {
-            throw new Error(`sqlite pragma "${key}" must be a number`);
-        }
-        return String(toSafeNumber(rawValue, `sqlite pragma "${key}"`));
-    }
-    if (kind === 'token') {
-        if (typeof rawValue !== 'string') {
-            throw new Error(`sqlite pragma "${key}" must be a string token`);
-        }
-        return normalizePragmaToken(key, rawValue);
-    }
-    if (typeof rawValue === 'number') {
-        return String(toSafeNumber(rawValue, `sqlite pragma "${key}"`));
-    }
-    return normalizePragmaToken(key, rawValue);
-}
-function applyPragmas(db, options) {
-    for (const [rawKey, rawValue] of pragmaEntries(options)) {
-        const key = normalizePragmaKey(rawKey);
-        const value = normalizePragmaValue(key, rawValue);
-        const statement = `${key}=${value}`;
-        if (db.pragma) {
-            db.pragma(statement);
-            continue;
-        }
-        db.exec(`PRAGMA ${statement}`);
-    }
-}
-function closeDatabaseSafely(db) {
-    try {
-        db.close();
-    }
-    catch {
-        return;
-    }
-}
-async function openBetterSqlite(options, resolveSql, onClose) {
-    let loaded;
-    try {
-        loaded = await import(BETTER_SQLITE3_MODULE);
-    }
-    catch {
-        throw new Error('optional dependency "better-sqlite3" is not installed. Install with: npm i better-sqlite3');
-    }
-    const Database = asConstructor(loaded);
-    const db = new Database(options.path);
-    try {
-        applyPragmas(db, options);
-    }
-    catch (error) {
-        closeDatabaseSafely(db);
-        throw error;
-    }
-    return wrapConnection(db, 'better-sqlite3', resolveSql, onClose);
-}
-async function openBunSqlite(options, resolveSql, onClose) {
-    let loaded;
-    try {
-        loaded = await import(BUN_SQLITE_MODULE);
-    }
-    catch {
-        throw new Error('bun runtime sqlite module "bun:sqlite" is unavailable. Run this in Bun or set storage.sqlite.driver to "better-sqlite3".');
-    }
-    if (!loaded || typeof loaded !== 'object') {
-        throw new Error('invalid bun sqlite module export');
-    }
-    const ctor = loaded.Database;
-    if (typeof ctor !== 'function') {
-        throw new Error('invalid bun sqlite module export');
-    }
-    const db = new ctor(options.path);
-    try {
-        applyPragmas(db, options);
-    }
-    catch (error) {
-        closeDatabaseSafely(db);
-        throw error;
-    }
-    return wrapConnection(db, 'bun', resolveSql, onClose);
-}
-function resolveDriver(requested) {
-    if (requested && requested !== 'auto') {
-        return requested;
-    }
-    return isBunRuntime() ? 'bun' : 'better-sqlite3';
-}
-export async function openSqliteConnection(options) {
-    const driver = resolveDriver(options.driver);
-    const resolvedTableNames = resolveSqliteTableNames(options.tableNames);
-    const resolveSql = createSqliteTableNameSqlResolver(resolvedTableNames);
-    const normalizedOptions = {
-        ...options,
-        driver,
-        pragmas: mergePragmas(options.pragmas),
-        tableNames: resolvedTableNames
-    };
-    const cacheKey = `${driver}|${options.path}|${Object.entries(normalizedOptions.pragmas ?? {})
-        .sort(([left], [right]) => left.localeCompare(right))
-        .map(([key, value]) => `${key}=${String(value)}`)
-        .join(';')}|${serializeSqliteTableNames(resolvedTableNames)}`;
-    const cached = SQLITE_CONNECTION_CACHE.get(cacheKey);
-    if (cached) {
-        return cached;
-    }
-    const onClose = () => {
-        SQLITE_CONNECTION_CACHE.delete(cacheKey);
-    };
-    const created = driver === 'bun'
-        ? openBunSqlite(normalizedOptions, resolveSql, onClose)
-        : openBetterSqlite(normalizedOptions, resolveSql, onClose);
-    const guarded = created.catch((error) => {
-        SQLITE_CONNECTION_CACHE.delete(cacheKey);
-        throw error;
-    });
-    SQLITE_CONNECTION_CACHE.set(cacheKey, guarded);
-    return guarded;
-}
-const SQLITE_CONNECTION_CACHE = new Map();

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

@@ -1,74 +0,0 @@
-import { BaseSqliteStore } from '../../providers/sqlite/BaseSqliteStore.js';
-import { asNumber, asOptionalString, asString } from '../../../util/coercion.js';
-function decodeContactRow(row) {
-    return {
-        jid: asString(row.jid, 'mailbox_contacts.jid'),
-        displayName: asOptionalString(row.display_name, 'mailbox_contacts.display_name'),
-        pushName: asOptionalString(row.push_name, 'mailbox_contacts.push_name'),
-        lid: asOptionalString(row.lid, 'mailbox_contacts.lid'),
-        phoneNumber: asOptionalString(row.phone_number, 'mailbox_contacts.phone_number'),
-        lastUpdatedMs: asNumber(row.last_updated_ms, 'mailbox_contacts.last_updated_ms')
-    };
-}
-export class WaContactSqliteStore extends BaseSqliteStore {
-    constructor(options) {
-        super(options, ['mailbox']);
-    }
-    async upsert(record) {
-        const db = await this.getConnection();
-        this.upsertContactRow(db, record);
-    }
-    async upsertBatch(records) {
-        if (records.length === 0) {
-            return;
-        }
-        await this.withTransaction((db) => {
-            for (const record of records) {
-                this.upsertContactRow(db, record);
-            }
-        });
-    }
-    async getByJid(jid) {
-        const db = await this.getConnection();
-        const row = db.get(`SELECT jid, display_name, push_name, lid, phone_number, last_updated_ms
-             FROM mailbox_contacts
-             WHERE session_id = ? AND jid = ?`, [this.options.sessionId, jid]);
-        return row ? decodeContactRow(row) : null;
-    }
-    async deleteByJid(jid) {
-        const db = await this.getConnection();
-        db.run(`DELETE FROM mailbox_contacts
-             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_contacts WHERE session_id = ?', [this.options.sessionId]);
-    }
-    upsertContactRow(db, record) {
-        db.run(`INSERT INTO mailbox_contacts (
-                session_id,
-                jid,
-                display_name,
-                push_name,
-                lid,
-                phone_number,
-                last_updated_ms
-            ) VALUES (?, ?, ?, ?, ?, ?, ?)
-            ON CONFLICT(session_id, jid) DO UPDATE SET
-                display_name=COALESCE(excluded.display_name, mailbox_contacts.display_name),
-                push_name=COALESCE(excluded.push_name, mailbox_contacts.push_name),
-                lid=COALESCE(excluded.lid, mailbox_contacts.lid),
-                phone_number=COALESCE(excluded.phone_number, mailbox_contacts.phone_number),
-                last_updated_ms=excluded.last_updated_ms`, [
-            this.options.sessionId,
-            record.jid,
-            record.displayName ?? null,
-            record.pushName ?? null,
-            record.lid ?? null,
-            record.phoneNumber ?? null,
-            record.lastUpdatedMs
-        ]);
-    }
-}

package/dist/esm/store/providers/sqlite/device-list.store.js

@@ -1,127 +0,0 @@
-import { BaseSqliteStore } from '../../providers/sqlite/BaseSqliteStore.js';
-import { asNumber, asString, resolvePositive } from '../../../util/coercion.js';
-const DEFAULTS = Object.freeze({
-    ttlMs: 5 * 60 * 1000,
-    batchSize: 500
-});
-export class WaDeviceListSqliteStore extends BaseSqliteStore {
-    constructor(options, ttlMs = DEFAULTS.ttlMs, batchSize) {
-        super(options, ['deviceList']);
-        this.ttlMs = ttlMs;
-        this.batchSize = resolvePositive(batchSize, DEFAULTS.batchSize, 'deviceList.sqlite.batchSize');
-    }
-    async upsertUserDevicesBatch(snapshots) {
-        if (snapshots.length === 0) {
-            return;
-        }
-        await this.withTransaction((db) => {
-            for (const snapshot of snapshots) {
-                this.upsertUserDevicesRow(db, snapshot);
-            }
-        });
-    }
-    async getUserDevicesBatch(userJids, nowMs = Date.now()) {
-        if (userJids.length === 0) {
-            return [];
-        }
-        const uniqueUserJids = [...new Set(userJids)];
-        return this.withTransaction((db) => {
-            const activeByUserJid = new Map();
-            const expiredUserJids = [];
-            for (let start = 0; start < uniqueUserJids.length; start += this.batchSize) {
-                const end = Math.min(start + this.batchSize, uniqueUserJids.length);
-                const batchLength = end - start;
-                const placeholders = '?, '.repeat(batchLength).slice(0, -2);
-                const params = [this.options.sessionId];
-                for (let index = start; index < end; index += 1) {
-                    params.push(uniqueUserJids[index]);
-                }
-                const rows = db.all(`SELECT user_jid, device_jids_json, updated_at_ms, expires_at_ms
-                     FROM device_list_cache
-                     WHERE session_id = ? AND user_jid IN (${placeholders})`, params);
-                for (const row of rows) {
-                    const userJid = asString(row.user_jid, 'device_list_cache.user_jid');
-                    const expiresAtMs = asNumber(row.expires_at_ms, 'device_list_cache.expires_at_ms');
-                    if (expiresAtMs <= nowMs) {
-                        expiredUserJids.push(userJid);
-                        continue;
-                    }
-                    activeByUserJid.set(userJid, {
-                        userJid,
-                        deviceJids: decodeDeviceJids(row.device_jids_json),
-                        updatedAtMs: asNumber(row.updated_at_ms, 'device_list_cache.updated_at_ms')
-                    });
-                }
-            }
-            if (expiredUserJids.length > 0) {
-                this.deleteUserDevicesByJids(db, expiredUserJids);
-            }
-            return userJids.map((userJid) => activeByUserJid.get(userJid) ?? null);
-        });
-    }
-    async deleteUserDevices(userJid) {
-        const db = await this.getConnection();
-        db.run(`DELETE FROM device_list_cache
-             WHERE session_id = ? AND user_jid = ?`, [this.options.sessionId, userJid]);
-        const row = db.get('SELECT changes() AS total', []);
-        return row ? Number(row.total) : 0;
-    }
-    async cleanupExpired(nowMs) {
-        const db = await this.getConnection();
-        db.run(`DELETE FROM device_list_cache
-             WHERE session_id = ? AND expires_at_ms <= ?`, [this.options.sessionId, nowMs]);
-        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 device_list_cache WHERE session_id = ?', [this.options.sessionId]);
-    }
-    upsertUserDevicesRow(db, snapshot) {
-        db.run(`INSERT INTO device_list_cache (
-                session_id,
-                user_jid,
-                device_jids_json,
-                updated_at_ms,
-                expires_at_ms
-            ) VALUES (?, ?, ?, ?, ?)
-            ON CONFLICT(session_id, user_jid) DO UPDATE SET
-                device_jids_json=excluded.device_jids_json,
-                updated_at_ms=excluded.updated_at_ms,
-                expires_at_ms=excluded.expires_at_ms`, [
-            this.options.sessionId,
-            snapshot.userJid,
-            JSON.stringify(snapshot.deviceJids),
-            snapshot.updatedAtMs,
-            snapshot.updatedAtMs + this.ttlMs
-        ]);
-    }
-    deleteUserDevicesByJids(db, userJids) {
-        if (userJids.length === 0) {
-            return;
-        }
-        for (let start = 0; start < userJids.length; start += this.batchSize) {
-            const end = Math.min(start + this.batchSize, userJids.length);
-            const batchLength = end - start;
-            const placeholders = '?, '.repeat(batchLength).slice(0, -2);
-            const params = [this.options.sessionId];
-            for (let index = start; index < end; index += 1) {
-                params.push(userJids[index]);
-            }
-            db.run(`DELETE FROM device_list_cache
-                 WHERE session_id = ? AND user_jid IN (${placeholders})`, params);
-        }
-    }
-}
-function decodeDeviceJids(raw) {
-    const json = asString(raw, 'device_list_cache.device_jids_json');
-    const parsed = JSON.parse(json);
-    if (!Array.isArray(parsed)) {
-        throw new Error('device_list_cache.device_jids_json must be an array');
-    }
-    const deviceJids = new Array(parsed.length);
-    for (let index = 0; index < parsed.length; index += 1) {
-        deviceJids[index] = asString(parsed[index], 'device_list_cache.device_jids_json entry');
-    }
-    return deviceJids;
-}

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

@@ -1,132 +0,0 @@
-import { BaseSqliteStore } from '../../providers/sqlite/BaseSqliteStore.js';
-import { asOptionalBytes, asOptionalNumber, asOptionalString, asString } from '../../../util/coercion.js';
-import { normalizeQueryLimit } from '../../../util/collections.js';
-function decodeMessageRow(row) {
-    return {
-        id: asString(row.message_id, 'mailbox_messages.message_id'),
-        threadJid: asString(row.thread_jid, 'mailbox_messages.thread_jid'),
-        senderJid: asOptionalString(row.sender_jid, 'mailbox_messages.sender_jid'),
-        participantJid: asOptionalString(row.participant_jid, 'mailbox_messages.participant_jid'),
-        fromMe: Number(row.from_me) === 1,
-        timestampMs: asOptionalNumber(row.timestamp_ms, 'mailbox_messages.timestamp_ms'),
-        encType: asOptionalString(row.enc_type, 'mailbox_messages.enc_type'),
-        plaintext: asOptionalBytes(row.plaintext, 'mailbox_messages.plaintext'),
-        messageBytes: asOptionalBytes(row.message_bytes, 'mailbox_messages.message_bytes')
-    };
-}
-export class WaMessageSqliteStore extends BaseSqliteStore {
-    constructor(options) {
-        super(options, ['mailbox']);
-    }
-    async upsert(record) {
-        const db = await this.getConnection();
-        this.upsertMessageRow(db, record);
-    }
-    async upsertBatch(records) {
-        if (records.length === 0) {
-            return;
-        }
-        await this.withTransaction((db) => {
-            for (const record of records) {
-                this.upsertMessageRow(db, record);
-            }
-        });
-    }
-    async getById(id) {
-        const db = await this.getConnection();
-        const row = db.get(`SELECT
-                message_id,
-                thread_jid,
-                sender_jid,
-                participant_jid,
-                from_me,
-                timestamp_ms,
-                enc_type,
-                plaintext,
-                message_bytes
-             FROM mailbox_messages
-             WHERE session_id = ? AND message_id = ?`, [this.options.sessionId, id]);
-        return row ? decodeMessageRow(row) : null;
-    }
-    async listByThread(threadJid, limit, beforeTimestampMs) {
-        const db = await this.getConnection();
-        const normalizedLimit = normalizeQueryLimit(limit, 50);
-        const rows = beforeTimestampMs === undefined
-            ? db.all(`SELECT
-                          message_id,
-                          thread_jid,
-                          sender_jid,
-                          participant_jid,
-                          from_me,
-                          timestamp_ms,
-                          enc_type,
-                          plaintext,
-                          message_bytes
-                       FROM mailbox_messages
-                       WHERE session_id = ? AND thread_jid = ?
-                       ORDER BY timestamp_ms DESC, message_id DESC
-                       LIMIT ?`, [this.options.sessionId, threadJid, normalizedLimit])
-            : db.all(`SELECT
-                          message_id,
-                          thread_jid,
-                          sender_jid,
-                          participant_jid,
-                          from_me,
-                          timestamp_ms,
-                          enc_type,
-                          plaintext,
-                          message_bytes
-                       FROM mailbox_messages
-                       WHERE session_id = ?
-                         AND thread_jid = ?
-                         AND timestamp_ms < ?
-                       ORDER BY timestamp_ms DESC, message_id DESC
-                       LIMIT ?`, [this.options.sessionId, threadJid, beforeTimestampMs, normalizedLimit]);
-        return rows.map(decodeMessageRow);
-    }
-    async deleteById(id) {
-        const db = await this.getConnection();
-        db.run(`DELETE FROM mailbox_messages
-             WHERE session_id = ? AND message_id = ?`, [this.options.sessionId, id]);
-        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_messages WHERE session_id = ?', [this.options.sessionId]);
-    }
-    upsertMessageRow(db, record) {
-        db.run(`INSERT INTO mailbox_messages (
-                session_id,
-                message_id,
-                thread_jid,
-                sender_jid,
-                participant_jid,
-                from_me,
-                timestamp_ms,
-                enc_type,
-                plaintext,
-                message_bytes
-            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-            ON CONFLICT(session_id, message_id) DO UPDATE SET
-                thread_jid=excluded.thread_jid,
-                sender_jid=excluded.sender_jid,
-                participant_jid=excluded.participant_jid,
-                from_me=excluded.from_me,
-                timestamp_ms=excluded.timestamp_ms,
-                enc_type=excluded.enc_type,
-                plaintext=excluded.plaintext,
-                message_bytes=excluded.message_bytes`, [
-            this.options.sessionId,
-            record.id,
-            record.threadJid,
-            record.senderJid ?? null,
-            record.participantJid ?? null,
-            record.fromMe ? 1 : 0,
-            record.timestampMs ?? null,
-            record.encType ?? null,
-            record.plaintext ?? null,
-            record.messageBytes ?? null
-        ]);
-    }
-}