@wirecat/cli-core 0.486.0 → 0.488.0

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

@@ -6,3 +6,5 @@ export declare const setEmailFlags: (database: CacheDatabase, accountId: number,
     read?: boolean;
     flagged?: boolean;
 }>, now: number) => number;
+export declare const markEmailsDeleted: (database: CacheDatabase, accountId: number, externalIds: string[], now: number) => number;
+export declare const markEmailsRestored: (database: CacheDatabase, accountId: number, externalIds: string[], now: number) => number;

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

@@ -1,4 +1,6 @@
+import { dropAttachmentChunks } from "./email-index.js";
 import { flag } from "./events.js";
+import { dropUnusedVectors } from "./vector-index.js";
 export const recountEmailThread = (database, threadId, now) => database
     .prepare(`UPDATE email_threads SET
          emails_count = (SELECT count(*) FROM emails WHERE email_thread_id = ? AND deleted_at IS NULL),
@@ -23,3 +25,29 @@ export const setEmailFlags = (database, accountId, flags, now) => {
     }
     return changed;
 };
+export const markEmailsDeleted = (database, accountId, externalIds, now) => {
+    const mark = database.prepare(`UPDATE emails SET deleted_at = ?, body_text = NULL, body_html = NULL, snippet = NULL, updated_at = ?
+       WHERE account_id = ? AND external_id = ? AND deleted_at IS NULL
+       RETURNING id, email_thread_id`);
+    const forget = database.prepare("UPDATE attachments SET text = NULL, normalized_text = NULL WHERE attachable_type = 'email' AND attachable_id = ?");
+    const unlocate = database.prepare("DELETE FROM email_locations WHERE email_id = ?");
+    const threads = externalIds.flatMap((id) => mark.all(now, now, accountId, id).map((r) => {
+        const pieces = dropAttachmentChunks(database, Number(r.id));
+        forget.run(Number(r.id));
+        unlocate.run(Number(r.id));
+        dropUnusedVectors(database, pieces);
+        return Number(r.email_thread_id);
+    }));
+    for (const id of new Set(threads))
+        recountEmailThread(database, id, now);
+    return threads.length;
+};
+export const markEmailsRestored = (database, accountId, externalIds, now) => {
+    const unmark = database.prepare(`UPDATE emails SET deleted_at = NULL, updated_at = ?
+       WHERE account_id = ? AND external_id = ? AND deleted_at IS NOT NULL
+       RETURNING email_thread_id`);
+    const threads = externalIds.flatMap((id) => unmark.all(now, accountId, id).map((r) => Number(r.email_thread_id)));
+    for (const id of new Set(threads))
+        recountEmailThread(database, id, now);
+    return threads.length;
+};

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

@@ -3,9 +3,11 @@ 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 EmailLocationInput, type FolderEmail } from "./email-locations.js";
 import { type MailRulesStore } from "./mail-rules.js";
 import { type AttachmentInput } from "./meetings.js";
 import type { StoreContext } from "./open.js";
+export type { EmailLocationInput, FolderEmail };
 export interface EmailAddress {
     address: string;
     name: string | null;
@@ -43,6 +45,8 @@ export interface EmailInput {
     mailRuleId?: number | null;
     /** Added to the mailboxes the email is already in; one scan sees one folder, so none is taken away. */
     mailboxes?: MailboxInput[];
+    /** Added to the locations the email has; a UID already known in that folder now points here. */
+    locations?: EmailLocationInput[];
     /** Replaced when given; the text is word-indexed. */
     attachments?: AttachmentInput[];
 }
@@ -228,6 +232,15 @@ export interface MailStore {
         read?: boolean;
         flagged?: boolean;
     }>, now: number): Promise<number>;
+    /** The live emails whose location in `folder` has this UIDVALIDITY, oldest UID first. */
+    folderEmails(accountId: number, folder: string, uidvalidity: string): Promise<FolderEmail[]>;
+    /**
+     * Records where emails the store holds are in `folder`, by Message-ID; one it does not hold is left out. Locations
+     * of the folder under another UIDVALIDITY are dropped: its UIDs mean nothing now.
+     */
+    setLocations(accountId: number, folder: string, uidvalidity: string, found: ReadonlyMap<string, number[]>): Promise<number>;
+    /** Forgets that these UIDs of `folder` hold anything; an email left with no location there leaves the folder too. */
+    forgetLocations(accountId: number, folder: string, uidvalidity: string, uids: number[]): Promise<void>;
     /** Marks emails gone at the source and drops their text; saving one again brings it back. Answers how many changed. */
     markDeleted(accountId: number, externalIds: string[], now: number): Promise<number>;
     /**

package/dist/store/sqlite/emails.js

@@ -2,7 +2,8 @@ import { formatLocator } from "../../domain/locator.js";
 import { formatReference } from "../../domain/references.js";
 import { fold, normalize } from "../normalize.js";
 import { chunkAttachments, drainEmailIndex, dropAttachmentChunks, MAIL_PIECES, queueThreads, threadPieces, titleOf, } from "./email-index.js";
-import { recountEmailThread as recount, setEmailFlags } from "./email-state.js";
+import { folderEmails, forgetLocations, locate, setLocations, } from "./email-locations.js";
+import { markEmailsDeleted, markEmailsRestored, recountEmailThread as recount, setEmailFlags } from "./email-state.js";
 import { bool, flag, fromJson, int, page, str, toJson } from "./events.js";
 import { folded } from "./folded.js";
 import { ensurePerson } from "./identities.js";
@@ -228,6 +229,8 @@ const saveEmail = (database, orm, accountId, threadId, mail, now) => {
     }
     for (const box of mail.mailboxes ?? [])
         join(database, emailId, mailboxPk(database, accountId, box, now), now);
+    for (const where of mail.locations ?? [])
+        locate(database, accountId, emailId, where);
     if (mail.attachments !== undefined) {
         const before = dropAttachmentChunks(database, emailId);
         const positions = mail.attachments.map(({ position }) => position);
@@ -545,34 +548,11 @@ export const mailStoreOver = ({ database, orm }, stemmerFor = stemmerCache()) =>
             return setEmailFlags(database, accountId, flags, now);
         });
     },
-    async markDeleted(accountId, externalIds, now) {
-        return write(database, () => {
-            const mark = database.prepare(`UPDATE emails SET deleted_at = ?, body_text = NULL, body_html = NULL, snippet = NULL, updated_at = ?
-           WHERE account_id = ? AND external_id = ? AND deleted_at IS NULL
-           RETURNING id, email_thread_id`);
-            const forget = database.prepare("UPDATE attachments SET text = NULL, normalized_text = NULL WHERE attachable_type = 'email' AND attachable_id = ?");
-            const threads = externalIds.flatMap((id) => mark.all(now, now, accountId, id).map((r) => {
-                const pieces = dropAttachmentChunks(database, Number(r.id));
-                forget.run(Number(r.id));
-                dropUnusedVectors(database, pieces);
-                return Number(r.email_thread_id);
-            }));
-            for (const id of new Set(threads))
-                recount(database, id, now);
-            return threads.length;
-        });
-    },
-    async markRestored(accountId, externalIds, now) {
-        return write(database, () => {
-            const unmark = database.prepare(`UPDATE emails SET deleted_at = NULL, updated_at = ?
-           WHERE account_id = ? AND external_id = ? AND deleted_at IS NOT NULL
-           RETURNING email_thread_id`);
-            const threads = externalIds.flatMap((id) => unmark.all(now, accountId, id).map((r) => Number(r.email_thread_id)));
-            for (const id of new Set(threads))
-                recount(database, id, now);
-            return threads.length;
-        });
-    },
+    folderEmails: async (accountId, folder, uidvalidity) => folderEmails(database, accountId, folder, uidvalidity),
+    setLocations: async (accountId, folder, uidvalidity, found) => write(database, () => setLocations(database, accountId, folder, uidvalidity, found)),
+    forgetLocations: async (accountId, folder, uidvalidity, uids) => write(database, () => forgetLocations(database, accountId, folder, uidvalidity, uids)),
+    markDeleted: async (accountId, externalIds, now) => write(database, () => markEmailsDeleted(database, accountId, externalIds, now)),
+    markRestored: async (accountId, externalIds, now) => write(database, () => markEmailsRestored(database, accountId, externalIds, now)),
     async chunksToEmbed(model, { after, limit }) {
         drainEmailIndex(database, stemmerFor);
         const file = database.prepare("SELECT text FROM attachments WHERE id = ?");

package/dist/store/sqlite/manifest.js

@@ -52,6 +52,7 @@ export const MANIFEST = [
     { name: "20261029181000_version-37-contact-mention-triggers", version: 37, minCompatible: 34 },
     { name: "20261029224106_version-38-folded-names", version: 38, minCompatible: 34 },
     { name: "20261029224107_version-38-folded-triggers", version: 38, minCompatible: 34 },
+    { name: "20261030114008_version-39-email-locations", version: 39, minCompatible: 34 },
 ];
 export const generatedMigrations = (manifest = MANIFEST, generated = GENERATED) => {
     const migrations = [];

package/dist/store/sqlite/migrations.generated.js

@@ -830,5 +830,12 @@ export const GENERATED = [
             "CREATE TRIGGER email_threads_subject_folded_au AFTER UPDATE OF subject ON email_threads\n  WHEN new.subject IS NOT old.subject AND new.subject_folded IS old.subject_folded BEGIN\n  UPDATE email_threads SET subject_folded = NULL WHERE id = new.id;\nEND;",
             "CREATE TRIGGER mailboxes_name_folded_au AFTER UPDATE OF name ON mailboxes\n  WHEN new.name IS NOT old.name AND new.name_folded IS old.name_folded BEGIN\n  UPDATE mailboxes SET name_folded = NULL WHERE id = new.id;\nEND;"
         ]
+    },
+    {
+        "name": "20261030114008_version-39-email-locations",
+        "statements": [
+            "CREATE TABLE `email_locations` (\n\t`mailbox_id` integer NOT NULL,\n\t`uidvalidity` text NOT NULL,\n\t`uid` integer NOT NULL,\n\t`email_id` integer NOT NULL,\n\tCONSTRAINT `email_locations_pk` PRIMARY KEY(`mailbox_id`, `uidvalidity`, `uid`),\n\tCONSTRAINT `fk_email_locations_mailbox_id_mailboxes_id_fk` FOREIGN KEY (`mailbox_id`) REFERENCES `mailboxes`(`id`),\n\tCONSTRAINT `fk_email_locations_email_id_emails_id_fk` FOREIGN KEY (`email_id`) REFERENCES `emails`(`id`)\n);",
+            "CREATE INDEX `email_locations_by_email_id` ON `email_locations` (`email_id`);"
+        ]
     }
 ];

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

@@ -6172,6 +6172,78 @@ export declare const emailMailboxes: import("drizzle-orm/sqlite-core").SQLiteTab
     dialect: 'sqlite';
     isAlias: false;
 }>;
+export declare const emailLocations: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "email_locations";
+    schema: undefined;
+    columns: {
+        mailboxId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "email_locations";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        uidvalidity: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "email_locations";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        uid: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "email_locations";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        emailId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "email_locations";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+    };
+    dialect: 'sqlite';
+    isAlias: false;
+}>;
 export declare const emailIndexPending: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
     name: "email_index_pending";
     schema: undefined;

package/dist/store/sqlite/schema.js

@@ -695,6 +695,19 @@ export const emailMailboxes = sqliteTable("email_mailboxes", {
     primaryKey({ columns: [table.emailId, table.mailboxId] }),
     index("email_mailboxes_by_mailbox_id").on(table.mailboxId),
 ]);
+export const emailLocations = sqliteTable("email_locations", {
+    mailboxId: integer("mailbox_id")
+        .notNull()
+        .references(() => mailboxes.id),
+    uidvalidity: text("uidvalidity").notNull(),
+    uid: integer("uid").notNull(),
+    emailId: integer("email_id")
+        .notNull()
+        .references(() => emails.id),
+}, (table) => [
+    primaryKey({ columns: [table.mailboxId, table.uidvalidity, table.uid] }),
+    index("email_locations_by_email_id").on(table.emailId),
+]);
 export const emailIndexPending = sqliteTable("email_index_pending", {
     id: integer("id").notNull(),
     indexableType: text("indexable_type").notNull(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.486.0",
+  "version": "0.488.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",