surface-cli 0.1.0

package/dist/state/database.js

@@ -0,0 +1,731 @@
+import Database from "better-sqlite3";
+import { makeAccountId } from "../refs.js";
+import { nowIsoUtc } from "../lib/time.js";
+export class SurfaceDatabase {
+    connection;
+    constructor(path) {
+        this.connection = new Database(path);
+        this.connection.pragma("journal_mode = WAL");
+        this.connection.pragma("foreign_keys = ON");
+        this.migrate();
+    }
+    close() {
+        this.connection.close();
+    }
+    migrate() {
+        this.connection.exec(`
+      CREATE TABLE IF NOT EXISTS accounts (
+        account_id TEXT PRIMARY KEY,
+        name TEXT NOT NULL UNIQUE,
+        provider TEXT NOT NULL,
+        transport TEXT NOT NULL,
+        email TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS threads (
+        thread_ref TEXT PRIMARY KEY,
+        account_id TEXT NOT NULL,
+        subject TEXT,
+        mailbox TEXT,
+        participants_json TEXT NOT NULL DEFAULT '[]',
+        labels_json TEXT NOT NULL DEFAULT '[]',
+        received_at TEXT,
+        message_count INTEGER NOT NULL DEFAULT 0,
+        unread_count INTEGER NOT NULL DEFAULT 0,
+        has_attachments INTEGER NOT NULL DEFAULT 0,
+        first_seen_at TEXT NOT NULL,
+        last_synced_at TEXT NOT NULL,
+        FOREIGN KEY(account_id) REFERENCES accounts(account_id) ON DELETE CASCADE
+      );
+
+      CREATE TABLE IF NOT EXISTS messages (
+        message_ref TEXT PRIMARY KEY,
+        account_id TEXT NOT NULL,
+        thread_ref TEXT NOT NULL,
+        subject TEXT,
+        from_name TEXT,
+        from_email TEXT,
+        to_json TEXT NOT NULL DEFAULT '[]',
+        cc_json TEXT NOT NULL DEFAULT '[]',
+        sent_at TEXT,
+        received_at TEXT,
+        unread INTEGER NOT NULL DEFAULT 0,
+        snippet TEXT NOT NULL DEFAULT '',
+        body_cache_path TEXT,
+        body_cached INTEGER NOT NULL DEFAULT 0,
+        body_truncated INTEGER NOT NULL DEFAULT 0,
+        body_cached_bytes INTEGER NOT NULL DEFAULT 0,
+        invite_json TEXT,
+        first_seen_at TEXT NOT NULL,
+        last_synced_at TEXT NOT NULL,
+        FOREIGN KEY(account_id) REFERENCES accounts(account_id) ON DELETE CASCADE,
+        FOREIGN KEY(thread_ref) REFERENCES threads(thread_ref) ON DELETE CASCADE
+      );
+
+      CREATE TABLE IF NOT EXISTS thread_messages (
+        thread_ref TEXT NOT NULL,
+        message_ref TEXT NOT NULL,
+        position INTEGER NOT NULL,
+        PRIMARY KEY(thread_ref, message_ref),
+        FOREIGN KEY(thread_ref) REFERENCES threads(thread_ref) ON DELETE CASCADE,
+        FOREIGN KEY(message_ref) REFERENCES messages(message_ref) ON DELETE CASCADE
+      );
+
+      CREATE TABLE IF NOT EXISTS attachments (
+        attachment_id TEXT PRIMARY KEY,
+        message_ref TEXT NOT NULL,
+        filename TEXT NOT NULL,
+        mime_type TEXT NOT NULL,
+        size_bytes INTEGER,
+        inline INTEGER NOT NULL DEFAULT 0,
+        saved_to TEXT,
+        FOREIGN KEY(message_ref) REFERENCES messages(message_ref) ON DELETE CASCADE
+      );
+
+      CREATE TABLE IF NOT EXISTS provider_locators (
+        entity_kind TEXT NOT NULL,
+        entity_ref TEXT NOT NULL,
+        account_id TEXT NOT NULL,
+        provider_key TEXT NOT NULL,
+        locator_json TEXT NOT NULL,
+        PRIMARY KEY(entity_kind, entity_ref),
+        UNIQUE(entity_kind, account_id, provider_key)
+      );
+
+      CREATE TABLE IF NOT EXISTS summaries (
+        thread_ref TEXT PRIMARY KEY,
+        backend TEXT NOT NULL,
+        model TEXT NOT NULL,
+        brief TEXT NOT NULL,
+        needs_action INTEGER NOT NULL DEFAULT 0,
+        importance TEXT NOT NULL,
+        generated_at TEXT NOT NULL,
+        FOREIGN KEY(thread_ref) REFERENCES threads(thread_ref) ON DELETE CASCADE
+      );
+    `);
+        this.ensureColumn("threads", "participants_json", "TEXT NOT NULL DEFAULT '[]'");
+        this.ensureColumn("messages", "invite_json", "TEXT");
+        this.ensureProviderLocatorSchema();
+    }
+    tableColumns(tableName) {
+        return this.connection
+            .prepare(`PRAGMA table_info(${tableName})`)
+            .all().map((column) => column.name);
+    }
+    ensureColumn(tableName, columnName, definition) {
+        if (this.tableColumns(tableName).includes(columnName)) {
+            return;
+        }
+        this.connection.exec(`ALTER TABLE ${tableName} ADD COLUMN ${columnName} ${definition}`);
+    }
+    ensureProviderLocatorSchema() {
+        const columns = this.tableColumns("provider_locators");
+        if (columns.includes("account_id") && columns.includes("provider_key")) {
+            return;
+        }
+        this.connection.exec(`
+      ALTER TABLE provider_locators RENAME TO provider_locators_legacy;
+
+      CREATE TABLE provider_locators (
+        entity_kind TEXT NOT NULL,
+        entity_ref TEXT NOT NULL,
+        account_id TEXT NOT NULL,
+        provider_key TEXT NOT NULL,
+        locator_json TEXT NOT NULL,
+        PRIMARY KEY(entity_kind, entity_ref),
+        UNIQUE(entity_kind, account_id, provider_key)
+      );
+    `);
+        if (columns.length > 0) {
+            this.connection.exec(`
+        INSERT OR IGNORE INTO provider_locators (
+          entity_kind,
+          entity_ref,
+          account_id,
+          provider_key,
+          locator_json
+        )
+        SELECT
+          entity_kind,
+          entity_ref,
+          '',
+          entity_ref,
+          locator_json
+        FROM provider_locators_legacy;
+      `);
+        }
+        this.connection.exec("DROP TABLE IF EXISTS provider_locators_legacy;");
+    }
+    upsertAccount(input) {
+        const existing = this.findAccountByName(input.name);
+        const timestamp = nowIsoUtc();
+        if (existing) {
+            this.connection
+                .prepare(`
+          UPDATE accounts
+          SET provider = @provider,
+              transport = @transport,
+              email = @email,
+              updated_at = @updated_at
+          WHERE name = @name
+          `)
+                .run({
+                name: input.name,
+                provider: input.provider,
+                transport: input.transport,
+                email: input.email,
+                updated_at: timestamp,
+            });
+            return this.findAccountByName(input.name);
+        }
+        const account = {
+            account_id: makeAccountId(),
+            name: input.name,
+            provider: input.provider,
+            transport: input.transport,
+            email: input.email,
+            created_at: timestamp,
+            updated_at: timestamp,
+        };
+        this.connection
+            .prepare(`
+        INSERT INTO accounts (
+          account_id,
+          name,
+          provider,
+          transport,
+          email,
+          created_at,
+          updated_at
+        ) VALUES (
+          @account_id,
+          @name,
+          @provider,
+          @transport,
+          @email,
+          @created_at,
+          @updated_at
+        )
+        `)
+            .run(account);
+        return account;
+    }
+    listAccounts() {
+        return this.connection
+            .prepare(`
+        SELECT account_id, name, provider, transport, email, created_at, updated_at
+        FROM accounts
+        ORDER BY name ASC
+        `)
+            .all();
+    }
+    findAccountByName(name) {
+        return this.connection
+            .prepare(`
+        SELECT account_id, name, provider, transport, email, created_at, updated_at
+        FROM accounts
+        WHERE name = ?
+        LIMIT 1
+        `)
+            .get(name);
+    }
+    findAccountById(accountId) {
+        return this.connection
+            .prepare(`
+        SELECT account_id, name, provider, transport, email, created_at, updated_at
+        FROM accounts
+        WHERE account_id = ?
+        LIMIT 1
+        `)
+            .get(accountId);
+    }
+    removeAccountByName(name) {
+        const existing = this.findAccountByName(name);
+        if (!existing) {
+            return undefined;
+        }
+        this.connection.prepare("DELETE FROM accounts WHERE name = ?").run(name);
+        return existing;
+    }
+    transaction(work) {
+        return this.connection.transaction(work)();
+    }
+    findEntityRefByProviderKey(entityKind, accountId, providerKey) {
+        const row = this.connection
+            .prepare(`
+        SELECT entity_ref
+        FROM provider_locators
+        WHERE entity_kind = ?
+          AND account_id = ?
+          AND provider_key = ?
+        LIMIT 1
+        `)
+            .get(entityKind, accountId, providerKey);
+        return row?.entity_ref;
+    }
+    upsertProviderLocator(input) {
+        this.connection
+            .prepare(`
+        INSERT INTO provider_locators (
+          entity_kind,
+          entity_ref,
+          account_id,
+          provider_key,
+          locator_json
+        ) VALUES (
+          @entity_kind,
+          @entity_ref,
+          @account_id,
+          @provider_key,
+          @locator_json
+        )
+        ON CONFLICT(entity_kind, entity_ref) DO UPDATE SET
+          account_id = excluded.account_id,
+          provider_key = excluded.provider_key,
+          locator_json = excluded.locator_json
+        `)
+            .run(input);
+    }
+    findProviderLocator(entityKind, entityRef) {
+        return this.connection
+            .prepare(`
+        SELECT entity_kind, entity_ref, account_id, provider_key, locator_json
+        FROM provider_locators
+        WHERE entity_kind = ?
+          AND entity_ref = ?
+        LIMIT 1
+        `)
+            .get(entityKind, entityRef);
+    }
+    upsertThread(input) {
+        const timestamp = nowIsoUtc();
+        const existing = this.connection
+            .prepare("SELECT thread_ref FROM threads WHERE thread_ref = ? LIMIT 1")
+            .get(input.thread_ref);
+        if (!existing) {
+            this.connection
+                .prepare(`
+          INSERT INTO threads (
+            thread_ref,
+            account_id,
+            subject,
+            mailbox,
+            participants_json,
+            labels_json,
+            received_at,
+            message_count,
+            unread_count,
+            has_attachments,
+            first_seen_at,
+            last_synced_at
+          ) VALUES (
+            @thread_ref,
+            @account_id,
+            @subject,
+            @mailbox,
+            @participants_json,
+            @labels_json,
+            @received_at,
+            @message_count,
+            @unread_count,
+            @has_attachments,
+            @first_seen_at,
+            @last_synced_at
+          )
+          `)
+                .run({
+                ...input,
+                participants_json: JSON.stringify(input.participants),
+                labels_json: JSON.stringify(input.labels),
+                has_attachments: input.has_attachments ? 1 : 0,
+                first_seen_at: timestamp,
+                last_synced_at: timestamp,
+            });
+            return;
+        }
+        this.connection
+            .prepare(`
+        UPDATE threads
+        SET subject = @subject,
+            mailbox = @mailbox,
+            participants_json = @participants_json,
+            labels_json = @labels_json,
+            received_at = @received_at,
+            message_count = @message_count,
+            unread_count = @unread_count,
+            has_attachments = @has_attachments,
+            last_synced_at = @last_synced_at
+        WHERE thread_ref = @thread_ref
+        `)
+            .run({
+            ...input,
+            participants_json: JSON.stringify(input.participants),
+            labels_json: JSON.stringify(input.labels),
+            has_attachments: input.has_attachments ? 1 : 0,
+            last_synced_at: timestamp,
+        });
+    }
+    upsertMessage(input) {
+        const timestamp = nowIsoUtc();
+        const existing = this.connection
+            .prepare("SELECT message_ref FROM messages WHERE message_ref = ? LIMIT 1")
+            .get(input.message_ref);
+        const payload = {
+            ...input,
+            unread: input.unread ? 1 : 0,
+            body_cached: input.body_cached ? 1 : 0,
+            body_truncated: input.body_truncated ? 1 : 0,
+        };
+        if (!existing) {
+            this.connection
+                .prepare(`
+          INSERT INTO messages (
+            message_ref,
+            account_id,
+            thread_ref,
+            subject,
+            from_name,
+            from_email,
+            to_json,
+            cc_json,
+            sent_at,
+            received_at,
+            unread,
+            snippet,
+            body_cache_path,
+            body_cached,
+            body_truncated,
+            body_cached_bytes,
+            invite_json,
+            first_seen_at,
+            last_synced_at
+          ) VALUES (
+            @message_ref,
+            @account_id,
+            @thread_ref,
+            @subject,
+            @from_name,
+            @from_email,
+            @to_json,
+            @cc_json,
+            @sent_at,
+            @received_at,
+            @unread,
+            @snippet,
+            @body_cache_path,
+            @body_cached,
+            @body_truncated,
+            @body_cached_bytes,
+            @invite_json,
+            @first_seen_at,
+            @last_synced_at
+          )
+          `)
+                .run({
+                ...payload,
+                first_seen_at: timestamp,
+                last_synced_at: timestamp,
+            });
+            return;
+        }
+        this.connection
+            .prepare(`
+        UPDATE messages
+        SET thread_ref = @thread_ref,
+            subject = @subject,
+            from_name = @from_name,
+            from_email = @from_email,
+            to_json = @to_json,
+            cc_json = @cc_json,
+            sent_at = @sent_at,
+            received_at = @received_at,
+            unread = @unread,
+            snippet = @snippet,
+            body_cache_path = @body_cache_path,
+            body_cached = @body_cached,
+            body_truncated = @body_truncated,
+            body_cached_bytes = @body_cached_bytes,
+            invite_json = @invite_json,
+            last_synced_at = @last_synced_at
+        WHERE message_ref = @message_ref
+        `)
+            .run({
+            ...payload,
+            last_synced_at: timestamp,
+        });
+    }
+    replaceThreadMessages(threadRef, messageRefs) {
+        this.connection.prepare("DELETE FROM thread_messages WHERE thread_ref = ?").run(threadRef);
+        const insert = this.connection.prepare(`
+      INSERT INTO thread_messages (
+        thread_ref,
+        message_ref,
+        position
+      ) VALUES (?, ?, ?)
+      `);
+        for (const [index, messageRef] of messageRefs.entries()) {
+            insert.run(threadRef, messageRef, index);
+        }
+    }
+    replaceAttachments(messageRef, attachments) {
+        const existingSavedTo = new Map(this.listAttachmentsForMessage(messageRef).map((attachment) => [attachment.attachment_id, attachment.saved_to]));
+        this.connection.prepare("DELETE FROM attachments WHERE message_ref = ?").run(messageRef);
+        const insert = this.connection.prepare(`
+      INSERT INTO attachments (
+        attachment_id,
+        message_ref,
+        filename,
+        mime_type,
+        size_bytes,
+        inline,
+        saved_to
+      ) VALUES (
+        @attachment_id,
+        @message_ref,
+        @filename,
+        @mime_type,
+        @size_bytes,
+        @inline,
+        @saved_to
+      )
+      `);
+        for (const attachment of attachments) {
+            insert.run({
+                ...attachment,
+                message_ref: messageRef,
+                inline: attachment.inline ? 1 : 0,
+                saved_to: attachment.saved_to ?? existingSavedTo.get(attachment.attachment_id) ?? null,
+            });
+        }
+    }
+    updateAttachmentSavedTo(attachmentId, savedTo) {
+        this.connection
+            .prepare(`
+        UPDATE attachments
+        SET saved_to = ?
+        WHERE attachment_id = ?
+        `)
+            .run(savedTo, attachmentId);
+    }
+    upsertSummary(threadRef, summary) {
+        this.connection
+            .prepare(`
+        INSERT INTO summaries (
+          thread_ref,
+          backend,
+          model,
+          brief,
+          needs_action,
+          importance,
+          generated_at
+        ) VALUES (
+          @thread_ref,
+          @backend,
+          @model,
+          @brief,
+          @needs_action,
+          @importance,
+          @generated_at
+        )
+        ON CONFLICT(thread_ref) DO UPDATE SET
+          backend = excluded.backend,
+          model = excluded.model,
+          brief = excluded.brief,
+          needs_action = excluded.needs_action,
+          importance = excluded.importance,
+          generated_at = excluded.generated_at
+        `)
+            .run({
+            thread_ref: threadRef,
+            backend: summary.backend,
+            model: summary.model,
+            brief: summary.brief,
+            needs_action: summary.needs_action ? 1 : 0,
+            importance: summary.importance,
+            generated_at: nowIsoUtc(),
+        });
+    }
+    findSummary(threadRef) {
+        const row = this.connection
+            .prepare(`
+        SELECT backend, model, brief, needs_action, importance
+        FROM summaries
+        WHERE thread_ref = ?
+        LIMIT 1
+        `)
+            .get(threadRef);
+        if (!row) {
+            return null;
+        }
+        return {
+            backend: row.backend,
+            model: row.model,
+            brief: row.brief,
+            needs_action: Boolean(row.needs_action),
+            importance: row.importance,
+        };
+    }
+    listAttachmentsForMessage(messageRef) {
+        return this.connection
+            .prepare(`
+        SELECT attachment_id, filename, mime_type, size_bytes, inline, saved_to
+        FROM attachments
+        WHERE message_ref = ?
+        ORDER BY filename ASC
+        `)
+            .all(messageRef);
+    }
+    getStoredMessage(messageRef) {
+        return this.connection
+            .prepare(`
+        SELECT
+          message_ref,
+          account_id,
+          thread_ref,
+          subject,
+          from_name,
+          from_email,
+          to_json,
+          cc_json,
+          sent_at,
+          received_at,
+          unread,
+          snippet,
+          body_cache_path,
+          body_cached,
+          body_truncated,
+          body_cached_bytes,
+          invite_json
+        FROM messages
+        WHERE message_ref = ?
+        LIMIT 1
+        `)
+            .get(messageRef);
+    }
+    updateInviteStatusForThread(threadRef, responseStatus) {
+        const rows = this.connection
+            .prepare(`
+        SELECT message_ref, invite_json
+        FROM messages
+        WHERE thread_ref = ?
+          AND invite_json IS NOT NULL
+        `)
+            .all(threadRef);
+        if (rows.length === 0) {
+            return;
+        }
+        const update = this.connection.prepare(`
+      UPDATE messages
+      SET invite_json = @invite_json,
+          last_synced_at = @last_synced_at
+      WHERE message_ref = @message_ref
+      `);
+        const lastSyncedAt = nowIsoUtc();
+        for (const row of rows) {
+            const invite = JSON.parse(row.invite_json);
+            update.run({
+                message_ref: row.message_ref,
+                invite_json: JSON.stringify({
+                    ...invite,
+                    response_status: responseStatus,
+                }),
+                last_synced_at: lastSyncedAt,
+            });
+        }
+    }
+    listMessageRefsForThread(threadRef) {
+        return this.connection
+            .prepare(`
+          SELECT message_ref
+          FROM thread_messages
+          WHERE thread_ref = ?
+          ORDER BY position ASC
+          `)
+            .all(threadRef).map((row) => row.message_ref);
+    }
+    markThreadArchived(threadRef) {
+        this.connection
+            .prepare(`
+        UPDATE threads
+        SET mailbox = 'archive',
+            labels_json = '["archive"]',
+            last_synced_at = @last_synced_at
+        WHERE thread_ref = @thread_ref
+        `)
+            .run({
+            thread_ref: threadRef,
+            last_synced_at: nowIsoUtc(),
+        });
+    }
+    updateMessagesUnreadState(messageRefs, unread) {
+        if (messageRefs.length === 0) {
+            return;
+        }
+        const update = this.connection.prepare(`
+      UPDATE messages
+      SET unread = @unread,
+          last_synced_at = @last_synced_at
+      WHERE message_ref = @message_ref
+      `);
+        const lastSyncedAt = nowIsoUtc();
+        for (const messageRef of messageRefs) {
+            update.run({
+                message_ref: messageRef,
+                unread: unread ? 1 : 0,
+                last_synced_at: lastSyncedAt,
+            });
+        }
+    }
+    recomputeThreadUnreadCounts(threadRefs) {
+        if (threadRefs.length === 0) {
+            return;
+        }
+        const selectUnreadCount = this.connection.prepare(`
+      SELECT COUNT(*) AS unread_count
+      FROM messages
+      WHERE thread_ref = ?
+        AND unread = 1
+      `);
+        const updateThread = this.connection.prepare(`
+      UPDATE threads
+      SET unread_count = @unread_count,
+          labels_json = @labels_json,
+          last_synced_at = @last_synced_at
+      WHERE thread_ref = @thread_ref
+      `);
+        const lastSyncedAt = nowIsoUtc();
+        for (const threadRef of new Set(threadRefs)) {
+            const row = selectUnreadCount.get(threadRef);
+            const unreadCount = row?.unread_count ?? 0;
+            updateThread.run({
+                thread_ref: threadRef,
+                unread_count: unreadCount,
+                labels_json: JSON.stringify(unreadCount > 0 ? ["inbox", "unread"] : ["inbox"]),
+                last_synced_at: lastSyncedAt,
+            });
+        }
+    }
+    findMessageByRef(messageRef) {
+        return this.connection
+            .prepare(`
+        SELECT message_ref, thread_ref, account_id
+        FROM messages
+        WHERE message_ref = ?
+        LIMIT 1
+        `)
+            .get(messageRef);
+    }
+    findAttachmentById(attachmentId) {
+        return this.connection
+            .prepare(`
+        SELECT attachment_id, message_ref
+        FROM attachments
+        WHERE attachment_id = ?
+        LIMIT 1
+        `)
+            .get(attachmentId);
+    }
+}
+//# sourceMappingURL=database.js.map