@bobfrankston/mailx-store 0.1.80 → 0.1.82

package/db.d.ts

@@ -19,6 +19,25 @@ export declare function cleanContactName(name: string): string;
 /** User-configured patterns from contacts.jsonc `denylistPatterns`. Compiled
  *  once on settings load; invalid regexes are skipped with a warning. */
 export declare function setContactsDenyPatterns(patterns: string[]): void;
+/** Contact-card columns beyond name/email. Kept as one list so the schema,
+ *  the SELECT, the upsert and the Google People mapping can't drift apart —
+ *  adding a field means touching this array and the People mapping, nothing
+ *  else. `organization` predates the rest (v2); the others arrived with v3. */
+export declare const CONTACT_FIELD_COLUMNS: readonly ["organization", "phone", "title", "address", "website", "notes", "birthday"];
+export type ContactFieldColumn = typeof CONTACT_FIELD_COLUMNS[number];
+export type ContactFields = Record<ContactFieldColumn, string>;
+/** A contact as the address book and autocomplete see it. */
+export interface ContactCard extends ContactFields {
+    name: string;
+    email: string;
+    source: string;
+    googleId: string | null;
+    useCount: number;
+    lastUsed: number;
+}
+/** Map a contacts row to a ContactCard, defaulting every optional field to
+ *  "" so callers never have to null-check a card field. */
+export declare function rowToContactCard(r: any): ContactCard;
 export declare class MailxDB {
     private db;
     /** True for the DB read-worker's connection. Read-only handles never run
@@ -770,20 +789,21 @@ export declare class MailxDB {
     }[];
     /** List all contacts (address-book view) with pagination + optional filter. */
     listContacts(query: string, page?: number, pageSize?: number): {
-        items: {
-            name: string;
-            email: string;
-            source: string;
-            googleId: string | null;
-            useCount: number;
-            lastUsed: number;
-        }[];
+        items: ContactCard[];
         total: number;
         page: number;
         pageSize: number;
     };
-    /** Update or insert a contact manually (from the address book UI). */
-    upsertContact(name: string, email: string): void;
+    /** Update or insert a contact manually (from the address book UI, or
+     *  from an AI-extracted proposal the user accepted).
+     *
+     *  `fields` is OPTIONAL and PARTIAL by design: an undefined member
+     *  leaves the stored value alone rather than blanking it. The
+     *  address book edits one field at a time, and mail-derived proposals
+     *  only ever know a subset — neither should wipe what Google People
+     *  already knew about the person. Pass an explicit empty string to
+     *  clear a field. */
+    upsertContact(name: string, email: string, fields?: Partial<ContactFields>): void;
     /** Delete a contact by email (address book UI). */
     deleteContact(email: string): void;
     /** Delete contact rows by Google People resourceName. Used by the

package/db.js

@@ -202,6 +202,16 @@ const SCHEMA = `
         name TEXT DEFAULT '',
         email TEXT NOT NULL,
         organization TEXT DEFAULT '',
+        -- Full contact card (v3). Google People carries all of these; before
+        -- v3 we stored only name/email/organization and threw the rest away
+        -- on every sync, so a phone number in a signature had nowhere to land
+        -- (Bob 2026-08-07: "extend the contact support for all fields").
+        phone TEXT DEFAULT '',
+        title TEXT DEFAULT '',
+        address TEXT DEFAULT '',
+        website TEXT DEFAULT '',
+        notes TEXT DEFAULT '',
+        birthday TEXT DEFAULT '',
         last_used INTEGER DEFAULT 0,
         use_count INTEGER DEFAULT 0,
         updated_at INTEGER NOT NULL,
@@ -432,6 +442,28 @@ const SCHEMA = `
 function sleepSync(ms) {
     Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 }
+/** Contact-card columns beyond name/email. Kept as one list so the schema,
+ *  the SELECT, the upsert and the Google People mapping can't drift apart —
+ *  adding a field means touching this array and the People mapping, nothing
+ *  else. `organization` predates the rest (v2); the others arrived with v3. */
+export const CONTACT_FIELD_COLUMNS = [
+    "organization", "phone", "title", "address", "website", "notes", "birthday",
+];
+/** Map a contacts row to a ContactCard, defaulting every optional field to
+ *  "" so callers never have to null-check a card field. */
+export function rowToContactCard(r) {
+    const card = {
+        name: r.name || "",
+        email: r.email || "",
+        source: r.source || "",
+        googleId: r.google_id || null,
+        useCount: r.use_count || 0,
+        lastUsed: r.last_used || 0,
+    };
+    for (const col of CONTACT_FIELD_COLUMNS)
+        card[col] = r[col] || "";
+    return card;
+}
 export class MailxDB {
     db;
     /** True for the DB read-worker's connection. Read-only handles never run
@@ -907,6 +939,54 @@ export class MailxDB {
                 console.error(`  [db] contacts v2 reset failed: ${e.message}`);
             }
         }
+        // contacts v3: the full contact card. v2 kept only name / email /
+        // organization, so every phone number, job title, address, website,
+        // note and birthday Google People had was discarded on every sync,
+        // and a phone number read out of a signature block had nowhere to
+        // land (Bob 2026-08-07: "extend the contact support for all fields").
+        // Same recreate-the-table shape as v2 rather than an ALTER, but the
+        // EXISTING ROWS ARE CARRIED ACROSS. v2 dropped them outright, which is
+        // fine for google rows (one resync restores them) and wrong for the
+        // rest: sent/received/manual rows and their use_count ordering come
+        // from local mail and the user, and Google would never hand them back.
+        // The new columns simply arrive empty and fill in on the next sync.
+        const contactsV3Flag = this.getKv("schema", "contacts_v3");
+        if (!contactsV3Flag) {
+            try {
+                const carried = this.db.prepare("SELECT source, google_id, name, email, organization, last_used, use_count, updated_at FROM contacts").all();
+                this.db.exec("DROP TABLE IF EXISTS contacts");
+                this.db.exec(`
+                    CREATE TABLE contacts (
+                        id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        source TEXT NOT NULL DEFAULT 'discovered',
+                        google_id TEXT,
+                        name TEXT DEFAULT '',
+                        email TEXT NOT NULL,
+                        organization TEXT DEFAULT '',
+                        phone TEXT DEFAULT '',
+                        title TEXT DEFAULT '',
+                        address TEXT DEFAULT '',
+                        website TEXT DEFAULT '',
+                        notes TEXT DEFAULT '',
+                        birthday TEXT DEFAULT '',
+                        last_used INTEGER DEFAULT 0,
+                        use_count INTEGER DEFAULT 0,
+                        updated_at INTEGER NOT NULL,
+                        UNIQUE(source, email, name)
+                    );
+                    CREATE INDEX IF NOT EXISTS idx_contacts_email ON contacts(email);
+                    CREATE INDEX IF NOT EXISTS idx_contacts_name ON contacts(name);
+                `);
+                const ins = this.db.prepare("INSERT OR IGNORE INTO contacts (source, google_id, name, email, organization, last_used, use_count, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)");
+                for (const m of carried)
+                    ins.run(m.source || "discovered", m.google_id || null, m.name || "", m.email, m.organization || "", m.last_used || 0, m.use_count || 0, m.updated_at || Date.now());
+                this.setKv("schema", "contacts_v3", String(Date.now()));
+                console.log(`  [db] contacts table reset to v3 schema (full contact card); carried ${carried.length} row(s)`);
+            }
+            catch (e) {
+                console.error(`  [db] contacts v3 reset failed: ${e.message}`);
+            }
+        }
         // 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
@@ -3651,32 +3731,50 @@ 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, google_id, use_count, last_used FROM contacts
+        const rows = this.db.prepare(`SELECT name, email, source, google_id, use_count, last_used,
+                    organization, phone, title, address, website, notes, birthday 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,
-                googleId: r.google_id || null,
-                useCount: r.use_count, lastUsed: r.last_used,
-            })),
+            items: rows.map(r => rowToContactCard(r)),
             total: totalRow?.c || 0,
             page, pageSize,
         };
     }
-    /** Update or insert a contact manually (from the address book UI). */
-    upsertContact(name, email) {
+    /** Update or insert a contact manually (from the address book UI, or
+     *  from an AI-extracted proposal the user accepted).
+     *
+     *  `fields` is OPTIONAL and PARTIAL by design: an undefined member
+     *  leaves the stored value alone rather than blanking it. The
+     *  address book edits one field at a time, and mail-derived proposals
+     *  only ever know a subset — neither should wipe what Google People
+     *  already knew about the person. Pass an explicit empty string to
+     *  clear a field. */
+    upsertContact(name, email, fields) {
         if (!email || !/^[^\s<>@]+@[^\s<>@]+\.[^\s<>@]+$/.test(email)) {
             throw new Error(`Invalid email: ${email}`);
         }
         const now = Date.now();
         const existing = this.db.prepare("SELECT id FROM contacts WHERE email = ?").get(email);
+        // Only touch the columns the caller actually supplied.
+        const sets = [];
+        const vals = [];
+        for (const col of CONTACT_FIELD_COLUMNS) {
+            const v = fields?.[col];
+            if (v === undefined)
+                continue;
+            sets.push(`${col} = ?`);
+            vals.push(v);
+        }
         if (existing) {
-            this.db.prepare("UPDATE contacts SET name = ?, updated_at = ? WHERE email = ?").run(name, now, email);
+            this.db.prepare(`UPDATE contacts SET name = ?, ${sets.length ? sets.join(", ") + "," : ""} updated_at = ? WHERE email = ?`).run(name, ...vals, now, email);
         }
         else {
-            this.db.prepare("INSERT INTO contacts (source, name, email, last_used, use_count, updated_at) VALUES ('manual', ?, ?, ?, 0, ?)").run(name, email, now, now);
+            const cols = CONTACT_FIELD_COLUMNS.filter(c => fields?.[c] !== undefined);
+            const colSql = cols.length ? `, ${cols.join(", ")}` : "";
+            const phSql = cols.length ? `, ${cols.map(() => "?").join(", ")}` : "";
+            this.db.prepare(`INSERT INTO contacts (source, name, email, last_used, use_count, updated_at${colSql}) VALUES ('manual', ?, ?, ?, 0, ?${phSql})`).run(name, email, now, now, ...cols.map(c => fields[c]));
         }
     }
     /** Delete a contact by email (address book UI). */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx-store",
-  "version": "0.1.80",
+  "version": "0.1.82",
   "type": "module",
   "main": "index.js",
   "types": "index.d.ts",