@bobfrankston/mailx 1.0.377 → 1.0.379

package/packages/mailx-store/db.js

@@ -142,6 +142,72 @@ const SCHEMA = `
         PRIMARY KEY (account_id, message_id)
     );
     CREATE INDEX IF NOT EXISTS idx_tombstones_deleted_at ON tombstones(deleted_at);
+
+    -- Calendar events: two-way cache of Google Calendar / local events.
+    -- uuid = local stable identity (survives provider_id rebinds).
+    -- provider_id = Google Calendar event id when known (null for local-only
+    -- events that haven't been pushed yet).
+    -- deleted = tombstone marker; drainer removes row from server then deletes
+    -- the row locally.
+    CREATE TABLE IF NOT EXISTS calendar_events (
+        uuid TEXT PRIMARY KEY,
+        account_id TEXT NOT NULL,
+        provider_id TEXT,
+        calendar_id TEXT DEFAULT 'primary',
+        title TEXT NOT NULL DEFAULT '',
+        start_ms INTEGER NOT NULL,
+        end_ms INTEGER NOT NULL,
+        all_day INTEGER DEFAULT 0,
+        location TEXT DEFAULT '',
+        notes TEXT DEFAULT '',
+        etag TEXT,
+        last_synced INTEGER DEFAULT 0,
+        dirty INTEGER DEFAULT 0,
+        deleted INTEGER DEFAULT 0,
+        updated_at INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_calendar_events_start ON calendar_events(account_id, start_ms);
+    CREATE INDEX IF NOT EXISTS idx_calendar_events_dirty ON calendar_events(dirty) WHERE dirty = 1;
+
+    -- Tasks: two-way cache of Google Tasks / local tasks. Same shape as
+    -- calendar_events minus the time range.
+    CREATE TABLE IF NOT EXISTS tasks (
+        uuid TEXT PRIMARY KEY,
+        account_id TEXT NOT NULL,
+        provider_id TEXT,
+        list_id TEXT DEFAULT '@default',
+        title TEXT NOT NULL DEFAULT '',
+        notes TEXT DEFAULT '',
+        due_ms INTEGER,
+        completed_ms INTEGER,
+        etag TEXT,
+        last_synced INTEGER DEFAULT 0,
+        dirty INTEGER DEFAULT 0,
+        deleted INTEGER DEFAULT 0,
+        updated_at INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_tasks_account ON tasks(account_id);
+    CREATE INDEX IF NOT EXISTS idx_tasks_dirty ON tasks(dirty) WHERE dirty = 1;
+
+    -- Generic store-sync queue for domains OTHER than messages. Messages
+    -- use sync_actions above. This table queues push-to-server actions
+    -- for calendar / tasks / contacts / allowlist. Kind identifies the
+    -- domain; op is "create" / "update" / "delete"; payload is JSON the
+    -- drainer posts to the provider. Target URL isn't stored — the
+    -- drainer knows the provider endpoint from kind + payload.
+    CREATE TABLE IF NOT EXISTS store_sync (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        kind TEXT NOT NULL,
+        op TEXT NOT NULL,
+        account_id TEXT NOT NULL,
+        target_uuid TEXT NOT NULL,
+        payload TEXT,
+        attempts INTEGER DEFAULT 0,
+        last_error TEXT,
+        created_at INTEGER NOT NULL,
+        UNIQUE(kind, target_uuid, op)
+    );
+    CREATE INDEX IF NOT EXISTS idx_store_sync_account ON store_sync(account_id, kind);
 `;
 export class MailxDB {
     db;
@@ -182,6 +248,34 @@ export class MailxDB {
         // this column landed. One UPDATE + an id roundtrip per row — cheap
         // at our row counts, runs once per DB upgrade.
         this.backfillUuids();
+        // Post-migration sanity check: verify the columns we actually read in
+        // SELECTs exist. If any migration silently failed (stale driver, DB
+        // file locked, permission error), later code would throw cryptic
+        // "no such column" errors buried deep in a sync run. Fail loud here
+        // with a clear "run mailx -rebuild" message. C32 on Linux was exactly
+        // this — old mailx-store that predated thread_id/uuid migrations.
+        this.verifySchema();
+    }
+    /** Fail loud + early if expected columns are missing. Cheap (PRAGMA only
+     *  runs at startup). The user-facing message names the recovery command. */
+    verifySchema() {
+        const required = {
+            messages: ["thread_id", "provider_id", "uuid"],
+        };
+        for (const [table, cols] of Object.entries(required)) {
+            let actual;
+            try {
+                actual = this.db.prepare(`PRAGMA table_info(${table})`).all();
+            }
+            catch (e) {
+                throw new Error(`[mailx-store] schema check failed for "${table}": ${e.message}. Run 'mailx -rebuild' to rebuild the local store.`);
+            }
+            const names = new Set(actual.map(r => r.name));
+            const missing = cols.filter(c => !names.has(c));
+            if (missing.length > 0) {
+                throw new Error(`[mailx-store] table "${table}" is missing columns [${missing.join(", ")}] — schema migration did not complete. Run 'mailx -rebuild' to rebuild the local store.`);
+            }
+        }
     }
     /** One-time: assign UUIDs to every `messages` row that's missing one.
      *  Runs on every startup but the WHERE clause makes it a no-op after the
@@ -275,6 +369,152 @@ export class MailxDB {
             return 0;
         }
     }
+    // ── Calendar events (two-way cache) ──
+    upsertCalendarEvent(ev) {
+        const uuid = ev.uuid || randomUUID().replace(/-/g, "");
+        this.db.prepare(`
+            INSERT INTO calendar_events
+                (uuid, account_id, provider_id, calendar_id, title, start_ms, end_ms,
+                 all_day, location, notes, etag, last_synced, dirty, deleted, updated_at)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, ?)
+            ON CONFLICT(uuid) DO UPDATE SET
+                account_id=excluded.account_id, provider_id=excluded.provider_id,
+                calendar_id=excluded.calendar_id, title=excluded.title,
+                start_ms=excluded.start_ms, end_ms=excluded.end_ms,
+                all_day=excluded.all_day, location=excluded.location,
+                notes=excluded.notes, etag=excluded.etag,
+                last_synced=excluded.last_synced, dirty=excluded.dirty,
+                updated_at=excluded.updated_at
+        `).run(uuid, ev.accountId, ev.providerId || null, ev.calendarId || "primary", ev.title, ev.startMs, ev.endMs, ev.allDay ? 1 : 0, ev.location || "", ev.notes || "", ev.etag || null, ev.dirty ? 0 : Date.now(), ev.dirty ? 1 : 0, Date.now());
+        return uuid;
+    }
+    getCalendarEvents(accountId, fromMs, toMs) {
+        const rows = this.db.prepare(`
+            SELECT * FROM calendar_events
+            WHERE account_id = ? AND deleted = 0 AND start_ms >= ? AND start_ms < ?
+            ORDER BY start_ms ASC
+        `).all(accountId, fromMs, toMs);
+        return rows.map(this.calendarRowToObject);
+    }
+    getDirtyCalendarEvents(accountId) {
+        const rows = this.db.prepare(`
+            SELECT * FROM calendar_events WHERE account_id = ? AND (dirty = 1 OR deleted = 1)
+        `).all(accountId);
+        return rows.map(this.calendarRowToObject);
+    }
+    calendarRowToObject(r) {
+        return {
+            uuid: r.uuid, accountId: r.account_id, providerId: r.provider_id,
+            calendarId: r.calendar_id, title: r.title, startMs: r.start_ms,
+            endMs: r.end_ms, allDay: !!r.all_day, location: r.location, notes: r.notes,
+            etag: r.etag, lastSynced: r.last_synced, dirty: !!r.dirty, deleted: !!r.deleted,
+        };
+    }
+    markCalendarEventClean(uuid, providerId, etag) {
+        this.db.prepare(`
+            UPDATE calendar_events SET dirty=0, provider_id=?, etag=?, last_synced=? WHERE uuid=?
+        `).run(providerId, etag, Date.now(), uuid);
+    }
+    deleteCalendarEventLocal(uuid) {
+        this.db.prepare("UPDATE calendar_events SET deleted=1, dirty=1, updated_at=? WHERE uuid=?").run(Date.now(), uuid);
+    }
+    purgeCalendarEvent(uuid) {
+        this.db.prepare("DELETE FROM calendar_events WHERE uuid=?").run(uuid);
+    }
+    // ── Tasks (two-way cache) ──
+    upsertTask(t) {
+        const uuid = t.uuid || randomUUID().replace(/-/g, "");
+        this.db.prepare(`
+            INSERT INTO tasks
+                (uuid, account_id, provider_id, list_id, title, notes, due_ms, completed_ms,
+                 etag, last_synced, dirty, deleted, updated_at)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, ?)
+            ON CONFLICT(uuid) DO UPDATE SET
+                account_id=excluded.account_id, provider_id=excluded.provider_id,
+                list_id=excluded.list_id, title=excluded.title, notes=excluded.notes,
+                due_ms=excluded.due_ms, completed_ms=excluded.completed_ms,
+                etag=excluded.etag, last_synced=excluded.last_synced,
+                dirty=excluded.dirty, updated_at=excluded.updated_at
+        `).run(uuid, t.accountId, t.providerId || null, t.listId || "@default", t.title, t.notes || "", t.dueMs || null, t.completedMs || null, t.etag || null, t.dirty ? 0 : Date.now(), t.dirty ? 1 : 0, Date.now());
+        return uuid;
+    }
+    getTasks(accountId, includeCompleted = false) {
+        const where = includeCompleted
+            ? "account_id = ? AND deleted = 0"
+            : "account_id = ? AND deleted = 0 AND completed_ms IS NULL";
+        const rows = this.db.prepare(`SELECT * FROM tasks WHERE ${where} ORDER BY COALESCE(due_ms, updated_at) ASC`).all(accountId);
+        return rows.map(this.taskRowToObject);
+    }
+    getDirtyTasks(accountId) {
+        const rows = this.db.prepare(`SELECT * FROM tasks WHERE account_id = ? AND (dirty = 1 OR deleted = 1)`).all(accountId);
+        return rows.map(this.taskRowToObject);
+    }
+    taskRowToObject(r) {
+        return {
+            uuid: r.uuid, accountId: r.account_id, providerId: r.provider_id,
+            listId: r.list_id, title: r.title, notes: r.notes, dueMs: r.due_ms,
+            completedMs: r.completed_ms, etag: r.etag, lastSynced: r.last_synced,
+            dirty: !!r.dirty, deleted: !!r.deleted,
+        };
+    }
+    markTaskClean(uuid, providerId, etag) {
+        this.db.prepare(`UPDATE tasks SET dirty=0, provider_id=?, etag=?, last_synced=? WHERE uuid=?`)
+            .run(providerId, etag, Date.now(), uuid);
+    }
+    deleteTaskLocal(uuid) {
+        this.db.prepare("UPDATE tasks SET deleted=1, dirty=1, updated_at=? WHERE uuid=?").run(Date.now(), uuid);
+    }
+    purgeTask(uuid) {
+        this.db.prepare("DELETE FROM tasks WHERE uuid=?").run(uuid);
+    }
+    // ── Contacts two-way: existing upsertContact / deleteContact handle the
+    //     local side; the service layer adds store_sync push-queue entries.
+    //     (No extra methods needed here — upsertContact/deleteContact at the
+    //     regular contact-management section are the two-way cache's local
+    //     writers.)
+    /** Local delete for the two-way cache drainer (symmetric with calendar/tasks). */
+    deleteContactLocal(email) { this.deleteContact(email); }
+    // ── Store-sync queue (calendar / tasks / contacts / allowlist) ──
+    enqueueStoreSync(kind, op, accountId, targetUuid, payload) {
+        try {
+            this.db.prepare(`
+                INSERT OR REPLACE INTO store_sync (kind, op, account_id, target_uuid, payload, created_at)
+                VALUES (?, ?, ?, ?, ?, ?)
+            `).run(kind, op, accountId, targetUuid, JSON.stringify(payload), Date.now());
+        }
+        catch (e) {
+            console.error(`  [store_sync] enqueue ${kind}/${op}/${targetUuid} failed: ${e.message}`);
+        }
+    }
+    getStoreSyncQueue(kind, accountId) {
+        let sql = "SELECT * FROM store_sync";
+        const params = [];
+        const wh = [];
+        if (kind) {
+            wh.push("kind = ?");
+            params.push(kind);
+        }
+        if (accountId) {
+            wh.push("account_id = ?");
+            params.push(accountId);
+        }
+        if (wh.length)
+            sql += " WHERE " + wh.join(" AND ");
+        sql += " ORDER BY created_at ASC";
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map(r => ({
+            id: r.id, kind: r.kind, op: r.op, accountId: r.account_id,
+            targetUuid: r.target_uuid,
+            payload: r.payload ? JSON.parse(r.payload) : null,
+            attempts: r.attempts, lastError: r.last_error,
+        }));
+    }
+    completeStoreSync(id) {
+        this.db.prepare("DELETE FROM store_sync WHERE id = ?").run(id);
+    }
+    failStoreSync(id, error) {
+        this.db.prepare("UPDATE store_sync SET attempts = attempts + 1, last_error = ? WHERE id = ?").run(error, id);
+    }
     /** Idempotently add a column to a table if it's missing. */
     addColumnIfMissing(table, column, sqlType) {
         try {
@@ -772,12 +1012,16 @@ export class MailxDB {
         const params = hasQuery ? [q, q] : [];
         const totalRow = this.db.prepare(`SELECT COUNT(*) as c FROM contacts ${whereClause}`).get(...params);
         const offset = (page - 1) * pageSize;
-        const rows = this.db.prepare(`SELECT name, email, source, use_count, last_used FROM contacts
+        const rows = this.db.prepare(`SELECT name, email, source, google_id, use_count, last_used FROM contacts
              ${whereClause}
              ORDER BY use_count DESC, last_used DESC
              LIMIT ? OFFSET ?`).all(...params, pageSize, offset);
         return {
-            items: rows.map(r => ({ name: r.name, email: r.email, source: r.source, useCount: r.use_count, lastUsed: r.last_used })),
+            items: rows.map(r => ({
+                name: r.name, email: r.email, source: r.source,
+                googleId: r.google_id || null,
+                useCount: r.use_count, lastUsed: r.last_used,
+            })),
             total: totalRow?.c || 0,
             page, pageSize,
         };

package/packages/mailx-store-web/android-bootstrap.js

@@ -983,6 +983,25 @@ function installBridge() {
         syncAll: async () => { await service.syncAll(); return { ok: true }; },
         syncAccount: async (accountId) => { await service.syncAccount(accountId); return { ok: true }; },
         getSyncPending: () => service.getSyncPending(),
+        getPrimaryAccount: (feature) => {
+            // Resolve primary account for a feature (calendar/tasks/contacts):
+            // per-feature flag → catch-all `primary` → first account.
+            const all = db.getAccountConfigs().map(r => {
+                try {
+                    return { id: r.id, name: r.name, email: r.email, ...JSON.parse(r.configJson) };
+                }
+                catch {
+                    return { id: r.id, name: r.name, email: r.email };
+                }
+            });
+            if (feature) {
+                const key = "primary" + feature.charAt(0).toUpperCase() + feature.slice(1);
+                const perFeature = all.find((a) => a[key]);
+                if (perFeature)
+                    return perFeature;
+            }
+            return all.find((a) => a.primary) || all[0] || null;
+        },
         reauthenticate: async (accountId) => ({ ok: await service.reauthenticate(accountId) }),
         markFolderRead: (_accountId, folderId) => { service.markFolderRead(folderId); return { ok: true }; },
         createFolder: async () => ({ ok: false, error: "Not supported on mobile" }),

package/packages/mailx-types/index.d.ts

@@ -29,7 +29,10 @@ export interface AccountConfig {
         password?: string;
     };
     enabled: boolean;
-    primary?: boolean; /** Designates the account that supplies Calendar / Tasks / Contacts data. At most one per user; first one wins if multiple set. */
+    primary?: boolean; /** Catch-all "this is my main account" — default source for Calendar / Tasks / Contacts when no per-feature override set. */
+    primaryCalendar?: boolean; /** Per-feature override: use this account's Google Calendar. Falls back to `primary` if unset. */
+    primaryTasks?: boolean; /** Per-feature override: use this account's Google Tasks. Falls back to `primary` if unset. */
+    primaryContacts?: boolean; /** Per-feature override: use this account's Google Contacts. Falls back to `primary` if unset. */
     defaultSend?: boolean; /** Use this account's SMTP when From doesn't match any account */
     syncContacts?: boolean; /** Sync contacts even when account is disabled (contacts-only Gmail) */
     relayDomains?: string[]; /** Domains to skip in Delivered-To chain (e.g., ["m.connectivity.xyz"]) */