@remit/data-ports 0.0.46 → 0.0.48

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/data-ports",
-  "version": "0.0.46",
+  "version": "0.0.48",
   "type": "module",
   "main": "src/index.ts",
   "types": "src/index.ts",
@@ -25,10 +25,6 @@
       "types": "./src/account-settings.ts",
       "default": "./src/account-settings.ts"
     },
-    "./mailbox-role": {
-      "types": "./src/mailbox-role.ts",
-      "default": "./src/mailbox-role.ts"
-    },
     "./display-name": {
       "types": "./src/display-name.ts",
       "default": "./src/display-name.ts"

package/src/folder-role.ts

@@ -168,6 +168,21 @@ export const STALE_TRASH_FOLDER_REASON = `The folder appointed as this account's
  */
 export const UNCONFIRMED_TRASH_FOLDER_REASON = `Nobody has confirmed which folder is this account's Trash, so nothing was deleted. Appoint one under ${FOLDER_ROLES_SETTINGS_PATH}, then try again.`;
 
+/**
+ * The mailboxes holding Junk and Trash across a set of accounts, as ids. The
+ * shape a SQL predicate needs when it must ask "is this message in Junk"
+ * without spelling the rule a second time: resolution happens once, here, and
+ * SQL compares mailbox ids.
+ *
+ * A role resolves to at most one mailbox per account, so each list holds one id
+ * per account that has that folder — and no entry at all for an account that
+ * has none.
+ */
+export interface JunkRoleMailboxes {
+	readonly junkMailboxIds: readonly string[];
+	readonly trashMailboxIds: readonly string[];
+}
+
 /** The minimal mailbox shape role resolution reads. */
 export interface RoleMailboxCandidate extends MailboxNameCandidate {
 	specialUse?: readonly string[];

package/src/interfaces/address.ts

@@ -1,3 +1,4 @@
+import type { JunkRoleMailboxes } from "../folder-role.js";
 import type {
 	AddressItem,
 	CreateAddressInput,
@@ -13,7 +14,15 @@ export interface IAddressRepository {
 	upsertAddress(input: CreateAddressInput): Promise<AddressItem>;
 	upsertCorrespondentAddress(input: CreateAddressInput): Promise<AddressItem>;
 	upsertJunkAddress(input: CreateAddressInput): Promise<AddressItem>;
-	reconcileJunkOnlyForMessage(messageId: string): Promise<void>;
+	/**
+	 * `roles` covers every account under the message's config, resolved by the
+	 * caller once per batch: this runs inside the per-message sync loop, and
+	 * role resolution is deliberately uncached.
+	 */
+	reconcileJunkOnlyForMessage(
+		messageId: string,
+		roles: JunkRoleMailboxes,
+	): Promise<void>;
 	getAddress(accountConfigId: string, addressId: string): Promise<AddressItem>;
 	getAddress(
 		accountConfigId: string,

package/src/interfaces/mailbox-special-use.ts

@@ -1,4 +1,4 @@
-import type { RoleResolution } from "../folder-role.js";
+import type { JunkRoleMailboxes, RoleResolution } from "../folder-role.js";
 import type {
 	MailboxSpecialUseItem,
 	MailboxSpecialUseValue,
@@ -47,4 +47,14 @@ export interface IMailboxSpecialUseRepository {
 	findJunkMailbox(
 		accountId: string,
 	): Promise<{ mailboxId: string; fullPath: string } | null>;
+	/**
+	 * Junk and Trash for every account under one config, as mailbox ids. The
+	 * address book is keyed by config and an address carries sightings from all
+	 * of them, so a predicate over an address must weigh every account's Junk —
+	 * resolving only the account in hand withholds a sender on one and restores
+	 * it on the next.
+	 */
+	resolveJunkRolesForConfig(
+		accountConfigId: string,
+	): Promise<JunkRoleMailboxes>;
 }

package/src/interfaces/outbox-message.ts

@@ -59,6 +59,25 @@ export interface IOutboxMessageRepository {
 		outboxMessageId: string,
 		status: OutboxMessageItem["status"],
 	): Promise<OutboxMessageItem>;
+	/**
+	 * Write `input` only while the row still holds `expected`, and answer `null`
+	 * when it does not.
+	 *
+	 * Every status transition is a read the caller decided on followed by a
+	 * write, and the SMTP worker or a second request can move the row between
+	 * the two. Naming the status that decision was made against turns the write
+	 * into a compare-and-set: an edit no longer pulls a row back out of `queued`
+	 * while its send event is on the wire, and a settle no longer overwrites a
+	 * status the worker has already reached. `null` is the caller's to read —
+	 * a conflict for an action the user asked for, and nothing to do for a
+	 * settle that has been overtaken.
+	 */
+	updateIfStatus(
+		accountConfigId: string,
+		outboxMessageId: string,
+		expected: OutboxMessageItem["status"],
+		input: UpdateOutboxMessageInput,
+	): Promise<OutboxMessageItem | null>;
 	markSent(
 		accountConfigId: string,
 		outboxMessageId: string,

package/src/mailbox-role.ts

@@ -1,14 +0,0 @@
-import { CanonicalMailboxRole } from "@remit/domain-enums";
-import { ROLE_NAME_HINTS } from "./folder-role.js";
-
-/**
- * The conventional names for a role, taken from the one table every
- * special-folder lookup shares (`folder-role.ts`). Exported so the SQLite junk
- * repair can spell the same rule; a second list here is how `INBOX/Sent` and
- * `INBOX/Spam` came to be resolvable in one place and not another.
- */
-export const JUNK_FOLDER_NAMES: readonly string[] =
-	ROLE_NAME_HINTS[CanonicalMailboxRole.Junk] ?? [];
-
-export const TRASH_FOLDER_NAMES: readonly string[] =
-	ROLE_NAME_HINTS[CanonicalMailboxRole.Trash] ?? [];