@remit/mailbox-service 0.0.81 → 0.0.82

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/mailbox-service",
-  "version": "0.0.81",
+  "version": "0.0.82",
   "type": "module",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/message-sync-repoint.test.ts

@@ -49,6 +49,12 @@ const JUNK = mailboxAt("INBOX/Rubbish");
 const TRASH = mailboxAt("Trash");
 const ALL_MAIL = mailboxAt("[Gmail]/All Mail", ["All"]);
 
+/**
+ * `pending` is what an ordinary inbound row carries: `upsertWithStatus` is
+ * called without a `syncStatus` and the repository defaults to it, and nothing
+ * on the sync path ever promotes it (#1096). The fixture states the reachable
+ * state, not the one the gate used to demand.
+ */
 const storedIn = (
 	mailbox: MailboxItem,
 	overrides: Partial<MessageItem> = {},
@@ -57,7 +63,7 @@ const storedIn = (
 		mailboxId: mailbox.mailboxId,
 		uid: 7,
 		status: MessageStatus.active,
-		syncStatus: MessageSyncStatus.synced,
+		syncStatus: MessageSyncStatus.pending,
 		...overrides,
 	}) as MessageItem;
 
@@ -310,6 +316,26 @@ describe("repointsOnSighting", () => {
 		);
 	});
 
+	it("accepts an ordinary inbound row the sync path left pending", () => {
+		assert.equal(
+			repointsOnSighting(
+				JUNK,
+				storedIn(INBOX, { syncStatus: MessageSyncStatus.pending }),
+			),
+			true,
+		);
+	});
+
+	it("accepts a row a settled mutation marked synced", () => {
+		assert.equal(
+			repointsOnSighting(
+				JUNK,
+				storedIn(INBOX, { syncStatus: MessageSyncStatus.synced }),
+			),
+			true,
+		);
+	});
+
 	it("refuses a row whose move failed and has not been re-tried", () => {
 		assert.equal(
 			repointsOnSighting(
@@ -319,4 +345,30 @@ describe("repointsOnSighting", () => {
 			false,
 		);
 	});
+
+	it("refuses a row whose own move is still in flight", () => {
+		assert.equal(
+			repointsOnSighting(
+				JUNK,
+				storedIn(INBOX, {
+					status: MessageStatus.moving,
+					syncStatus: MessageSyncStatus.pending,
+				}),
+			),
+			false,
+		);
+	});
+
+	it("refuses a row whose own delete is still in flight", () => {
+		assert.equal(
+			repointsOnSighting(
+				JUNK,
+				storedIn(INBOX, {
+					status: MessageStatus.deleting,
+					syncStatus: MessageSyncStatus.pending,
+				}),
+			),
+			false,
+		);
+	});
 });

package/src/message-sync.ts

@@ -145,8 +145,17 @@ export const addressSightingIn = (
  * filing locations; following one would empty every other folder's listing. And
  * a row whose own mutation has not settled is in flight, not stale
  * (imap-mutations R1): the server's answer predates the move reader is still
- * waiting on, so taking it would undo the optimistic write. That sighting is
- * reconciled by the next one after the mutation settles.
+ * waiting on, so taking it would undo the optimistic write. The sync path
+ * reconciles rather than waits (imap-mutations R2): it never blocks on a
+ * mutation, it re-reads the row on the next sighting after the move settles.
+ *
+ * In flight is read off `status`, never off `syncStatus` (#1096). Every
+ * outbound mutation writes `moving` or `deleting` and only settling returns the
+ * row to `active`, while an ordinary inbound row stays `pending` for its whole
+ * life because nothing on the sync path promotes it — so demanding `synced`
+ * here meant ordinary mail never re-pointed at all. `failed` is still refused:
+ * a mutation that gave up leaves it set on a row put back to `active`, and
+ * nothing routine settles that row afterwards.
  */
 export const repointsOnSighting = (
 	mailbox: MailboxItem,
@@ -154,10 +163,8 @@ export const repointsOnSighting = (
 ): boolean => {
 	if (message.mailboxId === mailbox.mailboxId) return false;
 	if (isVirtualCopyMailbox(mailbox)) return false;
-	return (
-		message.status === MessageStatus.active &&
-		message.syncStatus === MessageSyncStatus.synced
-	);
+	if (message.status !== MessageStatus.active) return false;
+	return message.syncStatus !== MessageSyncStatus.failed;
 };
 
 /**