@remit/web-client 0.0.34 → 0.0.35

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/web-client",
-  "version": "0.0.34",
+  "version": "0.0.35",
   "type": "module",
   "description": "Remit web client, published as composable primitives — the app shell, auth shells, and runtime config. A distributor imports what it composes and bundles it.",
   "exports": {

package/src/lib/bulk-delete.test.ts

@@ -4,7 +4,6 @@ import {
 	BULK_DELETE_CHUNK_SIZE,
 	chunkIds,
 	countMatches,
-	type DeleteBatchResult,
 	type FetchIdsPageResult,
 	honestProgress,
 	resolveSelectionAfterDelete,
@@ -90,36 +89,16 @@ describe("runChunkedDelete", () => {
 		assert.deepEqual(outcome.failedIds, []);
 	});
 
-	test("the count deleted matches exactly what the batches reported succeeded", async () => {
+	test("a returned batch counts every id in it as accepted", async () => {
 		const input = ids(5);
 		const outcome = await runChunkedDelete(
 			input,
-			async (chunk) => ({
-				successCount: chunk.length - 2,
-				failureCount: 2,
-				failedIds: chunk.slice(0, 2),
-			}),
-			noopProgress,
-			neverCancelled,
-		);
-		assert.equal(outcome.done, 3);
-		assert.deepEqual(outcome.failedIds, input.slice(0, 2));
-	});
-
-	test("partial failure: failed ids are reported, not rolled into done", async () => {
-		const input = ids(3);
-		const outcome = await runChunkedDelete(
-			input,
-			async (chunk) => ({
-				successCount: 2,
-				failureCount: 1,
-				failedIds: [chunk[1]],
-			}),
+			async (chunk) => ({ successCount: chunk.length, failureCount: 0 }),
 			noopProgress,
 			neverCancelled,
 		);
-		assert.equal(outcome.done, 2);
-		assert.deepEqual(outcome.failedIds, [input[1]]);
+		assert.equal(outcome.done, input.length);
+		assert.deepEqual(outcome.failedIds, []);
 	});
 
 	test("cancelling mid-run folds every unreached chunk into failedIds", async () => {
@@ -264,27 +243,6 @@ describe("runPredicateDelete", () => {
 		assert.equal(outcome.done, 4);
 	});
 
-	test("partial failure across pages accumulates failedIds without rolling into done", async () => {
-		const fetch = pagedFetcher([
-			{ ids: ["a", "b"], continuationToken: "t1" },
-			{ ids: ["c"] },
-		]);
-		const outcome = await runPredicateDelete(
-			fetch,
-			3,
-			async (chunk): Promise<DeleteBatchResult> => {
-				if (chunk.includes("b")) {
-					return { successCount: 1, failureCount: 1, failedIds: ["b"] };
-				}
-				return { successCount: chunk.length, failureCount: 0 };
-			},
-			noopProgress,
-			neverCancelled,
-		);
-		assert.equal(outcome.done, 2);
-		assert.deepEqual(outcome.failedIds, ["b"]);
-	});
-
 	test("cancelling mid-delete stops paging without inventing failedIds for unfetched pages", async () => {
 		let fetchCalls = 0;
 		let cancelled = false;
@@ -409,7 +367,7 @@ describe("resolveSelectionAfterDelete", () => {
 		);
 	});
 
-	test("explicit failures stay selected for a precise retry, even alongside a clean stop", () => {
+	test("unreached ids stay selected for a precise retry, even alongside a clean stop", () => {
 		assert.deepEqual(
 			resolveSelectionAfterDelete({
 				done: 3072,
@@ -431,7 +389,7 @@ describe("resolveSelectionAfterDelete", () => {
 		);
 	});
 
-	test("an infra failure with no explicit per-item failures still keeps selection mode open", () => {
+	test("an infra failure with nothing left unreached still keeps selection mode open", () => {
 		assert.deepEqual(
 			resolveSelectionAfterDelete({
 				done: 0,

package/src/lib/bulk-delete.ts

@@ -3,9 +3,16 @@
  *
  * The bulk endpoint caps a call at 100 ids (`BulkMessageInput.messageIds`,
  * `@maxItems(100)`); a delete over a search result can run to thousands. These
- * helpers sequence the calls and tally what actually happened rather than what
- * was requested, so a caller can always ask "what's still not deleted" instead
- * of trusting the request it sent.
+ * helpers sequence the calls and tally which ids the run actually reached, so a
+ * caller can always ask "what's still not deleted" instead of trusting the
+ * request it sent.
+ *
+ * The endpoint enqueues the IMAP delete and returns; it does not apply it. So a
+ * returned call means every id in it was accepted for deletion, not that the
+ * mail server removed it — there is no per-id success/failure in the response
+ * to read. The only failure this layer can observe is a thrown call: an
+ * infrastructure failure (auth, the write, or the enqueue) that takes out the
+ * whole batch and stops the run.
  *
  * Pure, framework-agnostic, and independently testable — no React, no fetch.
  * `useEscalatedDelete.ts` supplies the real `DeleteBatch`/`FetchIdsPage`
@@ -46,7 +53,6 @@ export const chunkIds = (
 export interface DeleteBatchResult {
 	successCount: number;
 	failureCount: number;
-	failedIds?: string[];
 }
 
 /** Sends one bulk-delete call for the given ids (≤100). */
@@ -64,9 +70,12 @@ export interface BulkDeleteOutcome {
 	/** Ids confirmed deleted (server-reported success, not merely "sent"). */
 	done: number;
 	/**
-	 * Ids not confirmed deleted: explicit per-batch failures. Does NOT include
-	 * ids from chunks the run never reached (cancelled or stopped by an
-	 * error) — see the per-function doc for how each source handles that.
+	 * Ids the run did not reach and are therefore not confirmed deleted: on
+	 * cancellation or a thrown error, the chunks the bounded run never attempted
+	 * (see `runChunkedDelete`). Empty in the predicate case, which re-resolves on
+	 * every run rather than handing back a remainder (see `runPredicateDelete`).
+	 * There is no per-id failure source: a returned batch call counts every id in
+	 * it as accepted (see the module header).
 	 */
 	failedIds: string[];
 	cancelled: boolean;
@@ -106,9 +115,7 @@ export const runChunkedDelete = async (
 			onProgress({ done, total });
 			return { done, failedIds, cancelled: false, error: attempted.error };
 		}
-		const failedInChunk = new Set(attempted.value.failedIds ?? []);
-		done += chunk.length - failedInChunk.size;
-		failedIds.push(...chunk.filter((id) => failedInChunk.has(id)));
+		done += chunk.length;
 		onProgress({ done, total });
 	}
 
@@ -165,9 +172,7 @@ export const runPredicateDelete = async (
 			if (!attempted.ok) {
 				return { done, failedIds, cancelled: false, error: attempted.error };
 			}
-			const failedInPage = new Set(attempted.value.failedIds ?? []);
-			done += page.ids.length - failedInPage.size;
-			failedIds.push(...page.ids.filter((id) => failedInPage.has(id)));
+			done += page.ids.length;
 			onProgress({ done, total });
 		}
 
@@ -250,11 +255,10 @@ export interface SelectionAfterDelete {
 
 /**
  * What a caller does with selection once a run ends, for any reason. Every id
- * not confirmed deleted — an explicit failure, or a chunk the run never
- * reached because it was stopped or errored — belongs in `retryIds`: it is
- * exactly what Retry should resend, and it is what stays selected so the
- * count on screen never claims more was deleted than actually was (#92
- * requirement 8).
+ * not confirmed deleted — a chunk the bounded run never reached because it was
+ * stopped or errored — belongs in `retryIds`: it is exactly what Retry should
+ * resend, and it is what stays selected so the count on screen never claims
+ * more was deleted than actually was (#92 requirement 8).
  */
 export const resolveSelectionAfterDelete = (
 	outcome: DeleteRunOutcome,