@remit/data-ports 0.0.62 → 0.0.64

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/data-ports",
-  "version": "0.0.62",
+  "version": "0.0.64",
   "type": "module",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/index.ts

@@ -138,6 +138,7 @@ export type {
 	ResultList,
 	SearchOptions,
 	SenderSignerStandingItem,
+	ThreadMessageFieldTerm,
 	ThreadMessageItem,
 	UpdateAccountConfigInput,
 	UpdateAccountExportRequestInput,

package/src/interfaces/thread-message.ts

@@ -2,6 +2,7 @@ import type {
 	CreateThreadMessageInput,
 	ResultList,
 	SearchOptions,
+	ThreadMessageFieldTerm,
 	ThreadMessageItem,
 	UpdateThreadMessageInput,
 } from "../types.js";
@@ -85,6 +86,42 @@ export interface IThreadMessageRepository {
 			excludeDeleted?: boolean;
 		},
 	): Promise<ResultList<ThreadMessageItem>>;
+	/**
+	 * Rows of a config whose sender, subject or `List-Id` column matches a set
+	 * of substring terms, newest first, across every mailbox — the store-side
+	 * narrowing a rule back-apply reads with.
+	 *
+	 * The terms are evaluated in the query, so `limit` is a page size over
+	 * MATCHES and the scan reaches the whole config however old the matching
+	 * mail is. Paging a date-ordered listing and filtering the rows it returned
+	 * is what makes a rule for a quiet sender report a handful of matches on a
+	 * mailbox holding thousands (#459).
+	 *
+	 * `operator` combines the terms — `"and"` requires every one, `"or"` any.
+	 * An empty `terms` narrows nothing under either operator: the whole config,
+	 * newest first.
+	 *
+	 * A term an implementation cannot evaluate faithfully is IGNORED, never
+	 * approximated: the result may be wider than the terms asked for and never
+	 * narrower, so the caller's own matcher stays the judge.
+	 *
+	 * Matching follows `searchByMailbox`: accent- and case-insensitive
+	 * substring over the same folded columns.
+	 *
+	 * Rows are per mailbox, not per conversation: the same mail filed in two
+	 * folders is two rows sharing a `threadId`.
+	 */
+	listByFieldTerms(
+		accountConfigId: string,
+		terms: readonly ThreadMessageFieldTerm[],
+		options?: {
+			operator?: "and" | "or";
+			order?: "asc" | "desc";
+			limit?: number;
+			continuationToken?: string;
+			excludeDeleted?: boolean;
+		},
+	): Promise<ResultList<ThreadMessageItem>>;
 	/**
 	 * List starred rows for a config, newest first, across every mailbox.
 	 *

package/src/message-settlement.ts

@@ -33,13 +33,12 @@ export type MessageSettlementFields = Pick<
  * those handlers `status` stays at its in-flight value (`moving`, `deleting`),
  * which is what separates them from the pair above.
  *
- * Three give-ups this cannot see, and must not pretend to:
+ * Two give-ups this cannot see, and must not pretend to:
  *
- * - A MOVE that gave up leaves `moving` + `failed`, the same pair a first
- *   dropped connection writes. Nothing persisted tells the two apart.
- * - A DELETE that exhausted its retries settles `active` + `synced` (#1143's
- *   `resolveExhaustedMessageDeleteFailure` repairs the row to where the message
- *   actually is), so it reads as fully settled here.
+ * - A MOVE or a DELETE that exhausted its retries settles `active` + `synced`
+ *   (`resolveExhaustedMessageMoveFailure` and
+ *   `resolveExhaustedMessageDeleteFailure` repair the row to where the message
+ *   actually is — #1098, #1005), so both read as fully settled here.
  * - `flag-push` and `placement-move-push` never write either field at all.
  *   Their give-up state lives on their own marker rows.
  */

package/src/types.ts

@@ -488,6 +488,22 @@ export type UpdateThreadMessageInput = Partial<
 	Omit<CreateThreadMessageInput, "accountConfigId" | "threadId" | "messageId">
 >;
 
+/**
+ * One substring criterion over a text column of a ThreadMessage row, named by
+ * the column it selects on rather than by whatever rule derived it. `sender`
+ * covers the From address and display name together, the same pair
+ * `SearchOptions.from` reads.
+ *
+ * Matching is accent- and case-insensitive substring, identical to the search
+ * predicates, so a term is a NARROWING a caller refines further in memory. It
+ * may return more than the criterion it stands for and never less — a term an
+ * implementation cannot evaluate faithfully is dropped, not approximated.
+ */
+export type ThreadMessageFieldTerm = {
+	field: "sender" | "subject" | "listId";
+	contains: string;
+};
+
 export type SearchOptions = {
 	query?: string;
 	subject?: string;