@remit/web-client 0.0.245 → 0.0.247

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/web-client",
-  "version": "0.0.245",
+  "version": "0.0.247",
   "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/config-import/ConfigImportWizard.tsx

@@ -565,6 +565,9 @@ export function ConfigImportWizard({ onDone }: ConfigImportWizardProps) {
 					results={sectionResults(report)}
 					message={failed?.message ?? "The import stopped before it finished."}
 					raw={`${failed?.code ?? WRITE_FAILURE_CODE}: ${failed?.message ?? "no message"}`}
+					// `applied` is the server's answer to what survived: false means the
+					// write was undone whole, and no section may read as landed.
+					undone={!report.applied}
 					onBack={goToFile}
 					onNext={() => runImport("apply", "merge")}
 				/>

package/src/components/config-import/config-import.fixtures.ts

@@ -181,6 +181,32 @@ export const partialImportReport: RemitImapConfigImportReport = report({
 	warnings: folderWarnings,
 });
 
+/**
+ * The same stop on a backend that imports inside one transaction (#1093):
+ * `applied` is false and `items` holds only the rejected entry, because the
+ * rollback emptied the rest. No section may read as landed.
+ */
+export const rolledBackImportReport: RemitImapConfigImportReport = report({
+	applied: false,
+	items: [
+		item(
+			"filters",
+			"Bonnetjes",
+			"rejected",
+			"the filter store refused the write",
+		),
+	],
+	errors: [
+		{
+			code: "import_write_failed",
+			message:
+				"the filter store refused the write Nothing was written; the import stopped here.",
+			details: { section: "filters", key: "Bonnetjes" },
+		},
+	],
+	warnings: [],
+});
+
 export const importedAccounts: ImportedAccount[] = [
 	{
 		accountId: "acct-ischen",

package/src/components/config-import/config-import.stories.tsx

@@ -21,6 +21,7 @@ import {
 	importedAccounts,
 	partialImportReport,
 	rejectedReports,
+	rolledBackImportReport,
 } from "./config-import.fixtures";
 import {
 	AccountCredentialsList,
@@ -432,6 +433,26 @@ export const PartiallyLandedImport: Story = {
 	),
 };
 
+/**
+ * The same stop on a transactional backend: nothing landed, and the screen
+ * says the import was undone rather than counting sections (#1093).
+ */
+export const RolledBackImport: Story = {
+	render: () => (
+		<StepPartialImport
+			results={sectionResults(rolledBackImportReport)}
+			message={
+				writeFailure(rolledBackImportReport)?.message ??
+				"The import stopped before it finished."
+			}
+			raw={`import_write_failed: ${
+				writeFailure(rolledBackImportReport)?.message ?? "no message"
+			}`}
+			undone={!rolledBackImportReport.applied}
+		/>
+	),
+};
+
 /** Settings → Advanced: the export half of the pair. */
 export const ExportCard: Story = {
 	render: () => (

package/src/components/config-import/steps.tsx

@@ -706,11 +706,14 @@ export function StepFileRejected({
 /**
  * A section nobody can vouch for reads as failed, never as pending. Pending
  * says "still coming"; this section is finished and its outcome is unknown,
- * which is the row the reader has to go and check for themselves.
+ * which is the row the reader has to go and check for themselves. A rolled-
+ * back section is the same answer from the server's side: it is not coming,
+ * because the transaction that wrote it undid itself.
  */
 function resultState(state: SectionResult["state"]) {
 	if (state === "landed") return "ok" as const;
-	if (state === "failed" || state === "unknown") return "failed" as const;
+	if (state === "failed" || state === "unknown" || state === "rolled-back")
+		return "failed" as const;
 	return "pending" as const;
 }
 
@@ -718,6 +721,7 @@ export function StepPartialImport({
 	results,
 	message,
 	raw,
+	undone,
 	onBack,
 	onNext,
 }: {
@@ -725,6 +729,8 @@ export function StepPartialImport({
 	/** The server's own account of what survived, which only it knows. */
 	message: string;
 	raw: string;
+	/** `report.applied === false`: the import ran in a transaction and wrote nothing, so no section landed. */
+	undone?: boolean;
 } & StepNav) {
 	const landed = results.filter((result) => result.state === "landed").length;
 	const unknown = results.some((result) => result.state === "unknown");
@@ -734,9 +740,11 @@ export function StepPartialImport({
 			activeStep={1}
 			title="The import stopped part-way"
 			subtitle={
-				unknown
-					? "It did not say how far it got, so check Settings before importing again."
-					: `${landed} of ${results.length} sections landed.`
+				undone
+					? "Nothing was written — the whole import was undone."
+					: unknown
+						? "It did not say how far it got, so check Settings before importing again."
+						: `${landed} of ${results.length} sections landed.`
 			}
 			footer={
 				<>

package/src/components/mail/IntelligencePane.render.test.ts

@@ -58,23 +58,6 @@ const UndoHarness = () => {
 let harness: DomHarness | undefined;
 let http: HttpMock;
 
-const waitFor = async (
-	predicate: () => boolean,
-	timeoutMs = 2000,
-): Promise<void> => {
-	if (!harness) throw new Error("nothing mounted");
-	const deadline = Date.now() + timeoutMs;
-	while (!predicate()) {
-		if (Date.now() > deadline) {
-			throw new Error(
-				`waitFor: condition never became true within ${timeoutMs}ms`,
-			);
-		}
-		await harness.flush();
-		await harness.wait(5);
-	}
-};
-
 afterEach(() => {
 	harness?.close();
 	harness = undefined;
@@ -95,14 +78,14 @@ describe("the spam quick action disables itself for the duration of its own requ
 
 		const button = harness.byText("button", "Report spam") as HTMLButtonElement;
 		harness.click(button);
-		await waitFor(() => button.textContent === "Reporting…");
+		await harness.waitFor(() => button.textContent === "Reporting…");
 
 		assert.equal(button.disabled, true, "a control mid-request must disable");
 		harness.click(button);
 
 		assert.ok(resolveRequest, "the request never reached the mock");
 		resolveRequest?.();
-		await waitFor(() => button.textContent === "Report spam");
+		await harness.waitFor(() => button.textContent === "Report spam");
 
 		assert.equal(http.to("/messages/report-spam").length, 1);
 	});
@@ -120,14 +103,14 @@ describe("the spam quick action disables itself for the duration of its own requ
 
 		const button = harness.byText("button", "Not spam") as HTMLButtonElement;
 		harness.click(button);
-		await waitFor(() => button.textContent === "Undoing…");
+		await harness.waitFor(() => button.textContent === "Undoing…");
 
 		assert.equal(button.disabled, true, "a control mid-request must disable");
 		harness.click(button);
 
 		assert.ok(resolveRequest, "the request never reached the mock");
 		resolveRequest?.();
-		await waitFor(() => button.textContent === "Not spam");
+		await harness.waitFor(() => button.textContent === "Not spam");
 
 		assert.equal(http.to("/messages/not-spam").length, 1);
 	});

package/src/components/mail/intelligence-semantic-off.render.test.ts

@@ -62,23 +62,6 @@ const respond =
 let harness: DomHarness | undefined;
 let http: HttpMock;
 
-const waitFor = async (
-	predicate: () => boolean,
-	timeoutMs = 2000,
-): Promise<void> => {
-	if (!harness) throw new Error("nothing mounted");
-	const deadline = Date.now() + timeoutMs;
-	while (!predicate()) {
-		if (Date.now() > deadline) {
-			throw new Error(
-				`waitFor: condition never became true within ${timeoutMs}ms`,
-			);
-		}
-		await harness.flush();
-		await harness.wait(5);
-	}
-};
-
 afterEach(() => {
 	harness?.close();
 	harness = undefined;
@@ -91,7 +74,7 @@ describe("the Similar messages section on an instance with semantic search off",
 		harness = createDomHarness();
 		harness.renderApp(createElement(SimilarHarness));
 
-		await waitFor(
+		await harness.waitFor(
 			() => harness?.text().includes("Semantic search is off") === true,
 		);
 
@@ -107,7 +90,7 @@ describe("the Similar messages section on an instance with semantic search off",
 		harness = createDomHarness();
 		harness.renderApp(createElement(SimilarHarness));
 
-		await waitFor(
+		await harness.waitFor(
 			() => harness?.text().includes("Semantic search is off") === true,
 		);
 		await harness.wait(30);
@@ -121,7 +104,7 @@ describe("the Similar messages section on an instance with semantic search off",
 		harness = createDomHarness();
 		harness.renderApp(createElement(SimilarHarness));
 
-		await waitFor(() => http.to("/search/semantic").length > 0);
+		await harness.waitFor(() => http.to("/search/semantic").length > 0);
 
 		assert.doesNotMatch(harness.text(), /Semantic search is off/);
 	});

package/src/lib/config-import.test.ts

@@ -151,6 +151,91 @@ test("a stopped import splits the write order into landed, failed and never reac
 	assert.equal(byId.get("settings")?.state, "not-attempted");
 });
 
+test("a rolled-back import lands nothing, however far the items say it got", () => {
+	// The shape a transactional backend answers with (#1093): `items` holds
+	// only the rejected entry, because the rollback emptied the rest.
+	const rolled = sectionResults(
+		reportOf({
+			applied: false,
+			items: [item("filters", "Receipts", "rejected", "the store refused")],
+			errors: [
+				{
+					code: "import_write_failed",
+					message:
+						"the store refused the write Nothing was written; the import stopped here.",
+					details: { section: "filters", key: "Receipts" },
+				},
+			],
+		}),
+	);
+
+	assert.equal(
+		rolled.some((result) => result.state === "landed"),
+		false,
+	);
+	const byId = new Map(rolled.map((result) => [result.section, result]));
+	assert.equal(byId.get("accounts")?.state, "rolled-back");
+	assert.match(byId.get("accounts")?.detail ?? "", /Nothing was written/);
+	assert.equal(byId.get("labels")?.state, "rolled-back");
+	assert.equal(byId.get("filters")?.state, "failed");
+	assert.match(byId.get("filters")?.detail ?? "", /Nothing was written/);
+	assert.equal(byId.get("addressFlags")?.state, "rolled-back");
+	assert.equal(byId.get("settings")?.state, "rolled-back");
+});
+
+test("item verdicts cannot turn a rolled-back import back into a landed one", () => {
+	// `applied` is the server's own answer, and it outranks the counts: a
+	// report that claims writes while saying nothing was applied still lands
+	// nothing, because "your accounts are in" is the one answer this screen
+	// must never give without the server saying so.
+	const rolled = sectionResults(
+		reportOf({
+			applied: false,
+			items: [
+				item("accounts", "a@example.test", "created"),
+				item("labels", "Receipts", "created"),
+			],
+			errors: [
+				{
+					code: "import_write_failed",
+					message: "the store refused the write",
+					details: { section: "filters", key: "Receipts" },
+				},
+			],
+		}),
+	);
+
+	assert.equal(
+		rolled.some((result) => result.state === "landed"),
+		false,
+	);
+	assert.deepEqual(
+		rolled
+			.filter((result) => result.section !== "filters")
+			.map((result) => result.state),
+		["rolled-back", "rolled-back", "rolled-back", "rolled-back"],
+	);
+});
+
+test("a rolled-back import that names no section still says what happened", () => {
+	const rolled = sectionResults(
+		reportOf({
+			applied: false,
+			errors: [{ code: "import_write_failed", message: "the store refused" }],
+		}),
+	);
+
+	assert.equal(
+		rolled.some((result) => result.state === "landed"),
+		false,
+	);
+	assert.equal(
+		rolled.some((result) => result.state === "unknown"),
+		false,
+	);
+	assert.match(rolled[0].detail, /Nothing was written/);
+});
+
 test("a pending folder names the setting waiting on it, and repeats are folded", () => {
 	const folders = pendingFolders(
 		reportOf({

package/src/lib/config-import.ts

@@ -285,7 +285,12 @@ export const writeFailure = (
 ): ApiError | undefined =>
 	report.errors.find((it) => it.code === WRITE_FAILURE_CODE);
 
-export type SectionOutcome = "landed" | "failed" | "not-attempted" | "unknown";
+export type SectionOutcome =
+	| "landed"
+	| "failed"
+	| "not-attempted"
+	| "rolled-back"
+	| "unknown";
 
 export interface SectionResult {
 	section: ImportSection;
@@ -305,6 +310,12 @@ export interface SectionResult {
  * section reads `unknown` rather than `landed`. Telling someone their accounts
  * are in when nothing said so is the one answer this screen must never give:
  * they would stop looking.
+ *
+ * `applied` says so when the import ran in a transaction: `false` means the
+ * write was undone whole, and the item counts — empty precisely because the
+ * rollback emptied them — must not turn sections before the failure back into
+ * `landed`. Every section then reads `rolled-back` except the one the failure
+ * named, which keeps its `failed` row and the server's own sentence.
  */
 export const sectionResults = (
 	report: RemitImapConfigImportReport,
@@ -320,6 +331,21 @@ export const sectionResults = (
 		counts.set(section, (counts.get(section) ?? 0) + 1);
 	}
 
+	if (failure && report.applied === false) {
+		return IMPORT_SECTION_ORDER.map((section) => ({
+			section,
+			title: SECTION_TITLES[section],
+			state:
+				section === failedSection
+					? ("failed" as const)
+					: ("rolled-back" as const),
+			detail:
+				section === failedSection
+					? (failure.message ?? "This section could not be written.")
+					: "Nothing was written — the import ran as one transaction and was undone.",
+		}));
+	}
+
 	if (!failedSection) {
 		const detail = named
 			? `The import stopped in "${named}", which this instance does not recognise, so it cannot say whether this section was written.`