@bobfrankston/mailx-sync 0.1.7 → 0.1.9

package/gmail.d.ts

@@ -51,6 +51,18 @@ export declare class GmailApiProvider implements MailProvider {
      *  remove so the end state matches regardless of what was there before,
      *  which makes the call idempotent and safe to retry. */
     setFlags(folder: string, uid: number, flags: string[]): Promise<void>;
+    /** Move a message to the trash label. Gmail treats trash as a label, not
+     *  as a destination folder — `POST /messages/{id}/trash` is the native
+     *  path (equivalent to setting TRASH and removing INBOX in one op).
+     *  Used by mailx's delete/trash path. */
+    trashMessage(folder: string, uid: number): Promise<void>;
+    /** Move between "folders" == swap one label for another via modifyLabels.
+     *  System labels (INBOX/SENT/TRASH/SPAM) are translated from the folder
+     *  path; user labels use the folder path verbatim as the label id. */
+    moveMessage(fromFolder: string, uid: number, toFolder: string): Promise<void>;
+    /** Folder path → Gmail label id. System folders map to uppercase label
+     *  constants; anything else is treated as a user label (identical name). */
+    private folderPathToLabelId;
     getUids(folder: string): Promise<number[]>;
     close(): Promise<void>;
     /** Map folder path to Gmail label query term */

package/gmail.js

@@ -207,11 +207,15 @@ export class GmailApiProvider {
      *  real messages from the local DB. Returning [] silently caused the
      *  "INBOX empty in mailx" bug when a rate-limit hit mid-pagination. */
     async listMessageIds(query, maxResults = 500) {
+        // maxResults === 0 → unlimited (for date-bounded queries where the
+        // query itself caps the result set).
+        const unlimited = maxResults === 0;
         const ids = [];
         let pageToken = "";
         let truncated = false;
         while (true) {
-            const params = new URLSearchParams({ q: query, maxResults: String(Math.min(maxResults - ids.length, 500)) });
+            const pageSize = unlimited ? 500 : Math.min(maxResults - ids.length, 500);
+            const params = new URLSearchParams({ q: query, maxResults: String(pageSize) });
             if (pageToken)
                 params.set("pageToken", pageToken);
             const data = await this.fetch(`/messages?${params}`);
@@ -220,7 +224,7 @@ export class GmailApiProvider {
             }
             if (!data.nextPageToken)
                 break;
-            if (ids.length >= maxResults) {
+            if (!unlimited && ids.length >= maxResults) {
                 // Hit the caller's cap but the server has more. Flag it so
                 // reconcile-style callers can refuse to treat this as complete.
                 truncated = true;
@@ -299,19 +303,27 @@ export class GmailApiProvider {
     async fetchSince(folder, sinceUid, options = {}) {
         // Gmail message IDs are hash-derived, NOT monotonic — filtering by
         // `uid > sinceUid` silently drops new messages whose hash happens to
-        // fall below the high-water mark. Fetch the most recent page and let
-        // upsertMessage dedupe by (account, folder, uid). The sinceUid arg is
-        // kept for interface compatibility but no longer used for filtering.
+        // fall below the high-water mark. Fetch by date (when caller supplied
+        // a `since` window) or fall back to the recent-200 page.
         void sinceUid;
-        const query = `in:${this.folderToLabel(folder)}`;
-        const ids = await this.listMessageIds(query, 200);
+        let query = `in:${this.folderToLabel(folder)}`;
+        if (options.since) {
+            // after: is inclusive at day granularity; filter precisely on the
+            // client side since Gmail's search is whole-day.
+            query += ` after:${this.formatDate(options.since)}`;
+        }
+        // When the caller bounded by date, let pagination run — the query
+        // is self-limiting. Otherwise cap at the recent 200.
+        const cap = options.since ? 0 : 200;
+        const ids = await this.listMessageIds(query, cap);
         return this.batchFetch(ids, options);
     }
     async fetchByDate(folder, since, before, options = {}, onChunk) {
         const afterDate = this.formatDate(since);
         const beforeDate = this.formatDate(before);
         const query = `in:${this.folderToLabel(folder)} after:${afterDate} before:${beforeDate}`;
-        const ids = await this.listMessageIds(query);
+        // Date-bounded — let pagination drain the full range instead of stopping at 500.
+        const ids = await this.listMessageIds(query, 0);
         return this.batchFetch(ids, options, onChunk);
     }
     async fetchByUids(folder, uids, options = {}) {
@@ -427,6 +439,61 @@ export class GmailApiProvider {
             body: JSON.stringify({ addLabelIds, removeLabelIds }),
         });
     }
+    /** Move a message to the trash label. Gmail treats trash as a label, not
+     *  as a destination folder — `POST /messages/{id}/trash` is the native
+     *  path (equivalent to setting TRASH and removing INBOX in one op).
+     *  Used by mailx's delete/trash path. */
+    async trashMessage(folder, uid) {
+        const query = `in:${this.folderToLabel(folder)}`;
+        const ids = await this.listMessageIds(query, 1000);
+        const id = ids.find(id => idToUid(id) === uid);
+        if (!id)
+            throw new Error(`Gmail trashMessage: UID ${uid} not found in ${folder}`);
+        await this.fetch(`/messages/${id}/trash`, { method: "POST" });
+    }
+    /** Move between "folders" == swap one label for another via modifyLabels.
+     *  System labels (INBOX/SENT/TRASH/SPAM) are translated from the folder
+     *  path; user labels use the folder path verbatim as the label id. */
+    async moveMessage(fromFolder, uid, toFolder) {
+        const query = `in:${this.folderToLabel(fromFolder)}`;
+        const ids = await this.listMessageIds(query, 1000);
+        const id = ids.find(id => idToUid(id) === uid);
+        if (!id)
+            throw new Error(`Gmail moveMessage: UID ${uid} not found in ${fromFolder}`);
+        // Map the folder path to the label id. System labels are uppercased
+        // aliases; user labels are passed through as-is (Gmail's label ids
+        // for user-created labels match the visible label name).
+        const toLabel = this.folderPathToLabelId(toFolder);
+        const fromLabel = this.folderPathToLabelId(fromFolder);
+        const addLabelIds = [];
+        const removeLabelIds = [];
+        if (toLabel)
+            addLabelIds.push(toLabel);
+        if (fromLabel && fromLabel !== toLabel)
+            removeLabelIds.push(fromLabel);
+        await this.fetch(`/messages/${id}/modify`, {
+            method: "POST",
+            body: JSON.stringify({ addLabelIds, removeLabelIds }),
+        });
+    }
+    /** Folder path → Gmail label id. System folders map to uppercase label
+     *  constants; anything else is treated as a user label (identical name). */
+    folderPathToLabelId(path) {
+        const lower = path.toLowerCase();
+        if (lower === "inbox")
+            return "INBOX";
+        if (lower === "sent" || lower === "[gmail]/sent mail")
+            return "SENT";
+        if (lower === "drafts" || lower === "[gmail]/drafts")
+            return "DRAFT";
+        if (lower === "trash" || lower === "[gmail]/trash")
+            return "TRASH";
+        if (lower === "spam" || lower === "junk email" || lower === "[gmail]/spam")
+            return "SPAM";
+        if (lower === "archive" || lower === "[gmail]/all mail")
+            return ""; // no-op — archive is absence-of-INBOX
+        return path; // user label — name-as-id
+    }
     async getUids(folder) {
         const query = `in:${this.folderToLabel(folder)}`;
         const ids = await this.listMessageIds(query, 10000);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx-sync",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "Platform-agnostic mail provider implementations + sync orchestration. Single source of truth for Gmail/IMAP/Outlook protocol code, consumed by both desktop (Node) and Android (WebView) — eliminates the parallel mailx-imap/mailx-store-web Gmail providers that drifted in practice.",
   "main": "index.js",
   "types": "index.ts",
@@ -19,7 +19,7 @@
   "author": "Bob Frankston",
   "license": "ISC",
   "dependencies": {
-    "@bobfrankston/iflow-direct": "^0.1.23",
+    "@bobfrankston/iflow-direct": "^0.1.26",
     "@bobfrankston/tcp-transport": "^0.1.4"
   },
   "exports": {
@@ -44,7 +44,7 @@
   },
   ".transformedSnapshot": {
     "dependencies": {
-      "@bobfrankston/iflow-direct": "^0.1.23",
+      "@bobfrankston/iflow-direct": "^0.1.26",
       "@bobfrankston/tcp-transport": "^0.1.4"
     }
   }

package/types.d.ts

@@ -43,6 +43,10 @@ export interface ProviderMessage {
 export interface FetchOptions {
     source?: boolean;
     providerId?: string;
+    /** Lower bound for "since" queries — bounds the result set by date so
+     *  the default page-count cap doesn't silently truncate a large folder
+     *  to the last ~200 messages. */
+    since?: Date;
 }
 /**
  * A mail provider that can list folders, fetch messages, and perform actions.