@wirecat/cli-core 0.554.0 → 0.555.0

package/dist/store/sqlite/email-activity.d.ts

@@ -0,0 +1,62 @@
+import type { CacheDatabase } from "../driver.js";
+import type { Where } from "./query-filter.js";
+/** What decides whose turn a thread is, read from its newest email that is not a draft; never its text. */
+export interface NewestEmail {
+    externalId: string;
+    /** ms: when it was received, or sent when that is unknown. */
+    at: number;
+    outgoing: boolean;
+    /** The mailbox's own address is in To or Cc. */
+    addressed: boolean;
+    /** Filed in the mailbox of mail sent to many. */
+    bulk: boolean;
+    /** Carries a List-Id. */
+    list: boolean;
+    /** Recorded by an envelope rule, without its text. */
+    envelope: boolean;
+    /** Its sender's mail looks like spam, a scam or a robot (the sender score). */
+    demoted: boolean;
+}
+/** One thread with mail after a time: `tasks agenda` and `review` read this, never the emails' text. */
+export interface ThreadActivity {
+    /** The thread's external id: what a `chat:email/…` reference names. */
+    threadId: string;
+    subject: string | null;
+    /** ms. */
+    lastEmailAt: number;
+    emails: number;
+    /** `null` when every email of the thread is a draft. */
+    newest: NewestEmail | null;
+}
+/** What a reader sorts mail by, per email: never its text. */
+export interface EmailMarks {
+    /** Filed in the mailbox of mail sent to many. */
+    bulk: boolean;
+    listId: string | null;
+    /** The mail rule that decided how it is stored, by its id in `rules list`. */
+    ruleId: number | null;
+}
+export interface MailActivityStore {
+    /** Each live email's marks, by its Message-ID; one the store does not hold is left out. */
+    emailMarks(accountId: number, externalIds: readonly string[]): Promise<Map<string, EmailMarks>>;
+    /**
+     * Each live thread of the account whose newest email is after `since` (ms), newest first, with the facts of that
+     * email. `where` is a `tasks agenda` query compiled over `MAIL_AGENDA_COLUMNS`.
+     */
+    threadActivity(accountId: number, since: number, where?: Where): Promise<ThreadActivity[]>;
+}
+/** `tasks agenda` fields over `threadActivity`'s threads: an email thread counts as a dialog. */
+export declare const MAIL_AGENDA_COLUMNS: {
+    readonly chat_kind: {
+        readonly type: "enum";
+        readonly sql: "'dialog'";
+    };
+};
+export declare const threadActivity: (database: CacheDatabase, accountId: number, since: number, where?: Where) => ThreadActivity[];
+/** A thread's live emails, oldest first; `window` keeps those received in (after, until], in ms. */
+export declare const threadEmailIds: (database: CacheDatabase, accountId: number, thread: string, { after, until }?: {
+    after?: number;
+    until?: number;
+}) => number[];
+export declare const emailMarks: (database: CacheDatabase, accountId: number, externalIds: readonly string[]) => Map<string, EmailMarks>;
+export declare const mailActivity: (database: CacheDatabase) => MailActivityStore;

package/dist/store/sqlite/email-activity.js

@@ -0,0 +1,71 @@
+import { int, str } from "./events.js";
+/** `tasks agenda` fields over `threadActivity`'s threads: an email thread counts as a dialog. */
+export const MAIL_AGENDA_COLUMNS = { chat_kind: { type: "enum", sql: "'dialog'" } };
+// The thread's own time is the Date header where sync stored one, so a thread is picked by it; the newest email is
+// picked by when it arrived, which is what an answer follows.
+const ACTIVITY = `
+  SELECT t.external_id AS thread, t.subject, t.last_email_at, t.emails_count,
+    e.external_id, coalesce(e.received_at, e.sent_at) AS at,
+    coalesce(e.outgoing, lower(e.from_address) = lower(a.external_id)) AS outgoing,
+    EXISTS (SELECT 1 FROM email_recipients r WHERE r.email_id = e.id AND r.role IN ('to', 'cc')
+      AND lower(r.address) = lower(a.external_id)) AS addressed,
+    EXISTS (SELECT 1 FROM email_mailboxes m JOIN mailboxes b ON b.id = m.mailbox_id
+      WHERE m.email_id = e.id AND b.kind = 'bulk') AS bulk,
+    coalesce(json_extract(e.headers, '$."list-id"'), json_extract(e.metadata, '$.listId')) IS NOT NULL AS list,
+    EXISTS (SELECT 1 FROM email_mailboxes m JOIN mailboxes b ON b.id = m.mailbox_id
+      WHERE m.email_id = e.id AND b.kind = 'envelope') AS envelope,
+    EXISTS (SELECT 1 FROM account_identities ai WHERE ai.account_id = t.account_id
+      AND ai.identity_id = e.from_identity_id AND ai.mail_demoted = 1) AS demoted
+  FROM email_threads t JOIN accounts a ON a.id = t.account_id
+  LEFT JOIN emails e ON e.id = (SELECT f.id FROM emails f WHERE f.email_thread_id = t.id AND f.deleted_at IS NULL
+    AND coalesce(f.draft, 0) = 0 ORDER BY coalesce(f.received_at, f.sent_at) DESC, f.id DESC LIMIT 1)
+  WHERE t.account_id = ? AND t.deleted_at IS NULL AND t.last_email_at > ?`;
+export const threadActivity = (database, accountId, since, where) => database
+    .prepare(`${ACTIVITY}${where ? ` AND (${where.sql})` : ""} ORDER BY t.last_email_at DESC, t.id DESC`)
+    .all(accountId, since, ...(where?.params ?? []))
+    .map((row) => ({
+    threadId: String(row.thread),
+    subject: str(row.subject),
+    lastEmailAt: Number(row.last_email_at),
+    emails: Number(row.emails_count),
+    newest: row.external_id == null
+        ? null
+        : {
+            externalId: String(row.external_id),
+            at: int(row.at) ?? Number(row.last_email_at),
+            outgoing: Boolean(row.outgoing),
+            addressed: Boolean(row.addressed),
+            bulk: Boolean(row.bulk),
+            list: Boolean(row.list),
+            envelope: Boolean(row.envelope),
+            demoted: Boolean(row.demoted),
+        },
+}));
+/** A thread's live emails, oldest first; `window` keeps those received in (after, until], in ms. */
+export const threadEmailIds = (database, accountId, thread, { after, until } = {}) => database
+    .prepare(`SELECT e.id FROM emails e JOIN email_threads t ON t.id = e.email_thread_id
+        WHERE t.account_id = ? AND t.external_id = ? AND e.deleted_at IS NULL
+          AND coalesce(e.received_at, e.sent_at, 0) > coalesce(?, -1)
+          AND coalesce(e.received_at, e.sent_at, 0) <= coalesce(?, 9e15)
+        ORDER BY coalesce(e.sent_at, e.received_at), e.id`)
+    .all(accountId, thread, after ?? null, until ?? null)
+    .map(({ id }) => Number(id));
+const MARKS = `
+  SELECT e.mail_rule_id, coalesce(json_extract(e.headers, '$."list-id"'), json_extract(e.metadata, '$.listId')) AS list_id,
+    EXISTS (SELECT 1 FROM email_mailboxes m JOIN mailboxes b ON b.id = m.mailbox_id
+      WHERE m.email_id = e.id AND b.kind = 'bulk') AS bulk
+  FROM emails e WHERE e.account_id = ? AND e.external_id = ? AND e.deleted_at IS NULL`;
+export const emailMarks = (database, accountId, externalIds) => {
+    const one = database.prepare(MARKS);
+    const marks = new Map();
+    for (const id of externalIds) {
+        const row = one.get(accountId, id);
+        if (row)
+            marks.set(id, { bulk: Boolean(row.bulk), listId: str(row.list_id), ruleId: int(row.mail_rule_id) });
+    }
+    return marks;
+};
+export const mailActivity = (database) => ({
+    emailMarks: async (accountId, externalIds) => emailMarks(database, accountId, externalIds),
+    threadActivity: async (accountId, since, where) => threadActivity(database, accountId, since, where),
+});

package/dist/store/sqlite/emails.d.ts

@@ -3,6 +3,7 @@ import type { Attachment, Metadata } from "../../meetings/index.js";
 import type { Stemmer, Stemmers } from "../../search/stem.js";
 import type { CacheDatabase } from "../driver.js";
 import type { ConversationSummary, StoredHit } from "../types.js";
+import { type MailActivityStore } from "./email-activity.js";
 import { type EmailLocationInput, type FolderEmail, type PartialMailStore } from "./email-locations.js";
 import { type MailRulesStore } from "./mail-rules.js";
 import { type AttachmentInput } from "./meetings.js";
@@ -205,7 +206,7 @@ export interface SenderScore {
     demoted?: boolean;
 }
 /** Mail in tables of its own: threads, emails, recipients and mailboxes, keyed by account and Message-ID. */
-export interface MailStore extends PartialMailStore {
+export interface MailStore extends PartialMailStore, MailActivityStore {
     saveThread(input: ThreadSave): Promise<ThreadDetails>;
     /** Several threads and sync state in one transaction: a slice of mail commits with its resume point, or not at all. */
     saveThreads(inputs: ThreadSave[], states?: SyncStateSave[]): Promise<ThreadDetails[]>;
@@ -268,8 +269,11 @@ export interface MailStore extends PartialMailStore {
     }[]>;
     /** Live emails of one account by Message-ID, each placed in its thread; an unknown one is left out. */
     inThreads(accountId: number, externalIds: string[]): Promise<EmailInThread[]>;
-    /** A thread's live emails, oldest first, as search hits: whole text, people, labels and locator. */
-    threadHits(accountId: number, threadExternalId: string): Promise<StoredHit[]>;
+    /** A thread's live emails, oldest first, as search hits; `window` keeps those received in (after, until], in ms. */
+    threadHits(accountId: number, thread: string, window?: {
+        after?: number;
+        until?: number;
+    }): Promise<StoredHit[]>;
     /** The emails of one account nearest in meaning to `query`, each by its best chunk, best first. */
     nearest(model: string, query: Float32Array, options: {
         accountId: number;

package/dist/store/sqlite/emails.js

@@ -1,6 +1,7 @@
 import { formatLocator } from "../../domain/locator.js";
 import { formatReference } from "../../domain/references.js";
 import { fold, normalize } from "../normalize.js";
+import { mailActivity, threadEmailIds } from "./email-activity.js";
 import { chunkAttachments, drainEmailIndex, dropAttachmentChunks, MAIL_PIECES, queueThreads, threadPieces, titleOf, } from "./email-index.js";
 import { backfillSentAt, folderEmails, forgetLocations, locate, partialMail, setLocations, storedWhole, } from "./email-locations.js";
 import { markEmailsDeleted, markEmailsRestored, recountEmailThread as recount, setEmailFlags } from "./email-state.js";
@@ -472,6 +473,7 @@ export const mailStoreOver = ({ database, orm, now }, stemmerFor = stemmerCache(
         }));
     },
     ...partialMail(database),
+    ...mailActivity(database),
     async emailFacts(filter = {}) {
         const [where, params] = emailWhere(filter);
         return database
@@ -631,14 +633,8 @@ export const mailStoreOver = ({ database, orm, now }, stemmerFor = stemmerCache(
             return place ? [{ ...place, score }] : [];
         });
     },
-    async threadHits(accountId, threadExternalId) {
-        const ids = database
-            .prepare(`SELECT e.id FROM emails e JOIN email_threads t ON t.id = e.email_thread_id
-          WHERE t.account_id = ? AND t.external_id = ? AND e.deleted_at IS NULL
-          ORDER BY coalesce(e.sent_at, e.received_at), e.id`)
-            .all(accountId, threadExternalId)
-            .map(({ id }) => Number(id));
-        return emailHitsByPk(database, ids);
+    async threadHits(accountId, thread, window) {
+        return emailHitsByPk(database, threadEmailIds(database, accountId, thread, window));
     },
     async inThreads(accountId, externalIds) {
         const id = database.prepare("SELECT id FROM emails WHERE account_id = ? AND external_id = ? AND deleted_at IS NULL");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.554.0",
+  "version": "0.555.0",
   "description": "The messenger-neutral half of a messaging CLI: domain model, message locators, rendering, name resolution, the SQLite seam, the command skeleton and shared read commands, the send guard, run records and the message store",
   "license": "Apache-2.0",
   "author": "Viacheslav Ptsarev",