@remit/web-client 0.0.118 → 0.0.119

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/web-client",
-  "version": "0.0.118",
+  "version": "0.0.119",
   "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/components/mail/SelectionWizardHost.tsx

@@ -719,7 +719,10 @@ function SelectionWizardSession({
 				state,
 				matched: progress.matchedCount,
 				applied: progress.appliedCount,
-				failed: state === "backApplyFailed" ? progress.failedCount : 0,
+				failed:
+					state === "backApplyFailed" || state === "backApplyRestartFailed"
+						? progress.failedCount
+						: 0,
 				failures: [],
 			};
 		},

package/src/components/mail/organize-run-state.test.ts

@@ -59,6 +59,24 @@ describe("organizeRunState", () => {
 		);
 	});
 
+	it("keeps a finished pass's ending when the retry over it could not be started", () => {
+		// #552: the retry is a second create, and a create that failed over a pass
+		// that already moved mail is not a pass that never ran.
+		for (const ruleSaved of [true, false]) {
+			assert.equal(
+				organizeRunState(
+					reading({
+						ruleSaved,
+						isDone: true,
+						failedCount: 84,
+						failure: { kind: "restartFailed", error: new Error("offline") },
+					}),
+				),
+				"backApplyRestartFailed",
+			);
+		}
+	});
+
 	it("says nothing happened only when the create itself failed", () => {
 		assert.equal(
 			organizeRunState(

package/src/components/mail/organize-run-state.ts

@@ -20,6 +20,10 @@ export interface OrganizeJobReading {
  * not a job that never started (#526), so what the job is doing is read before
  * what failed: a dropped poll leaves a running pass running and a finished one
  * finished, and only a create that never returned an id says nothing happened.
+ *
+ * A create that failed over a pass that already ran is that same distinction on
+ * the create path (#552): the counts of the pass that ran stand, and what failed
+ * is the retry.
  */
 export const organizeRunState = ({
 	failure,
@@ -29,6 +33,7 @@ export const organizeRunState = ({
 	failedCount,
 	ruleSaved,
 }: OrganizeJobReading): RunState => {
+	if (failure?.kind === "restartFailed") return "backApplyRestartFailed";
 	if (failure?.kind === "startFailed") {
 		return ruleSaved ? "backApplyStartFailed" : "commitFailed";
 	}

package/src/hooks/useOrganizeJob.render.test.ts

@@ -1,8 +1,9 @@
 /**
- * useOrganizeJob — the back-apply job seam. It reports two failures that are not
- * the same fact (#526): a create that never returned a job id, and a status poll
- * that could not be read over a job the server is already running. Looking at
- * that job again is a separate move from starting one.
+ * useOrganizeJob — the back-apply job seam. It reports three failures that are
+ * not the same fact (#526, #552): a create that never returned a job id, that
+ * same create over a pass that already ran, and a status poll that could not be
+ * read over a job the server is already running. Looking at that job again is a
+ * separate move from starting one.
  */
 
 import assert from "node:assert/strict";
@@ -75,6 +76,36 @@ const startJob = async (status: () => unknown): Promise<void> => {
 	await settle();
 };
 
+const COMPLETED_PASS = {
+	organizeJobId: JOB,
+	state: "Complete",
+	matchedCount: 1284,
+	appliedCount: 1200,
+	failedCount: 84,
+};
+
+/** Run one pass to a finish, then answer the next create with `restart`. */
+const restartAfterPass = async (restart: () => unknown): Promise<void> => {
+	let created = false;
+	http = mockFetch((call) => {
+		if (call.method !== "POST") return COMPLETED_PASS;
+		if (created) return restart();
+		created = true;
+		return { organizeJobId: JOB, state: "Pending" };
+	});
+	harness = createDomHarness();
+	harness.renderApp(createElement(Probe));
+	await act(async () => {
+		current().start(DRAFT);
+	});
+	await settle();
+	assert.equal(current().isDone, true, "the first pass never finished");
+	await act(async () => {
+		current().start(DRAFT);
+	});
+	await settle();
+};
+
 const posts = (): number =>
 	(http?.calls ?? []).filter((call) => call.method === "POST").length;
 
@@ -128,6 +159,23 @@ describe("useOrganizeJob status reporting", () => {
 		assert.equal(current().progress.matchedCount, 1284);
 	});
 
+	it("reads a create that failed over a finished pass as a restart, with that pass's counts", async () => {
+		await restartAfterPass(dropped);
+		assert.equal(current().failure?.kind, "restartFailed");
+		assert.equal(current().progress.matchedCount, 1284);
+		assert.equal(current().progress.appliedCount, 1200);
+		assert.equal(current().progress.failedCount, 84);
+		assert.equal(current().isDone, true);
+	});
+
+	it("reports a restart that is under way as its own pass, not the one before it", async () => {
+		await restartAfterPass(() => new Promise<never>(() => {}));
+		assert.equal(current().isStarting, true);
+		assert.equal(current().isDone, false);
+		assert.equal(current().failure, undefined);
+		assert.equal(current().progress.matchedCount, 0);
+	});
+
 	it("stops reporting a job as running once it reaches a terminal state", async () => {
 		await startJob(() => ({
 			organizeJobId: JOB,

package/src/hooks/useOrganizeJob.ts

@@ -23,20 +23,28 @@ export interface OrganizeJobProgress {
 }
 
 /**
- * Why the job is not reporting, which is two separate facts (#526). A create
- * that never returned an id means nothing was started; a status read that
- * failed means a job is out there and this client cannot see how far it got.
+ * Why the job is not reporting, which is three separate facts (#526, #552). A
+ * create that never returned an id means nothing was started; the same create
+ * over a pass that already ran means that pass stands and only the retry never
+ * left; a status read that failed means a job is out there and this client
+ * cannot see how far it got.
  */
 export interface OrganizeJobFailure {
-	kind: "startFailed" | "statusUnreadable";
+	kind: "startFailed" | "restartFailed" | "statusUnreadable";
 	error: unknown;
 }
 
 const organizeJobFailure = (
 	createError: unknown,
 	statusError: unknown,
+	passAlreadyRun: boolean,
 ): OrganizeJobFailure | undefined => {
-	if (createError) return { kind: "startFailed", error: createError };
+	if (createError) {
+		return {
+			kind: passAlreadyRun ? "restartFailed" : "startFailed",
+			error: createError,
+		};
+	}
 	if (statusError) return { kind: "statusUnreadable", error: statusError };
 	return undefined;
 };
@@ -76,7 +84,6 @@ export const useOrganizeJob = (accountId: string | undefined) => {
 	const start = useCallback(
 		(draft: OrganizeDraft) => {
 			if (!accountId) return;
-			setOrganizeJobId(undefined);
 			createJob({
 				path: { accountId },
 				body: buildOrganizeInput(draft),
@@ -92,7 +99,11 @@ export const useOrganizeJob = (accountId: string | undefined) => {
 		void refetch();
 	}, [refetch]);
 
-	const job = jobQuery.data;
+	// The last pass this client read. A restart replaces it only once the server
+	// hands back a job id: while the create is in flight those counts are not this
+	// pass's, and a create that fails leaves them standing (#552).
+	const lastPass = jobQuery.data;
+	const job = createMutation.isPending ? undefined : lastPass;
 	const state = job?.state ?? createMutation.data?.state;
 	const isDone = isTerminalJobState(job?.state);
 
@@ -111,6 +122,10 @@ export const useOrganizeJob = (accountId: string | undefined) => {
 		isStarting: createMutation.isPending,
 		isRunning: !!organizeJobId && !isDone,
 		isDone,
-		failure: organizeJobFailure(createMutation.error, jobQuery.error),
+		failure: organizeJobFailure(
+			createMutation.error,
+			jobQuery.error,
+			!!lastPass,
+		),
 	};
 };