@remit/web-client 0.0.251 → 0.0.252

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/web-client",
-  "version": "0.0.251",
+  "version": "0.0.252",
   "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,9 +565,7 @@ 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}
+					nothingLanded={!report.applied}
 					onBack={goToFile}
 					onNext={() => runImport("apply", "merge")}
 				/>

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

@@ -182,11 +182,11 @@ export const partialImportReport: RemitImapConfigImportReport = report({
 });
 
 /**
- * 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.
+ * The same stop with no section written: a store that holds the import in one
+ * transaction undoes the earlier writes, so the report carries no landed item
+ * and `applied` is false. Warnings go with them.
  */
-export const rolledBackImportReport: RemitImapConfigImportReport = report({
+export const nothingLandedImportReport: RemitImapConfigImportReport = report({
 	applied: false,
 	items: [
 		item(

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

@@ -19,9 +19,9 @@ import {
 	cleanRunReport,
 	dryRunReport,
 	importedAccounts,
+	nothingLandedImportReport,
 	partialImportReport,
 	rejectedReports,
-	rolledBackImportReport,
 } from "./config-import.fixtures";
 import {
 	AccountCredentialsList,
@@ -417,6 +417,7 @@ export const PartiallyLandedImportUnnamed: Story = {
 				results={sectionResults(report)}
 				message={writeFailure(report)?.message ?? ""}
 				raw="import_write_failed: the store refused the write"
+				nothingLanded={!report.applied}
 			/>
 		);
 	},
@@ -429,26 +430,23 @@ export const PartiallyLandedImport: Story = {
 			results={sectionResults(partialImportReport)}
 			message={writeFailure(partialImportReport)?.message ?? ""}
 			raw={`import_write_failed: ${writeFailure(partialImportReport)?.message ?? ""}`}
+			nothingLanded={!partialImportReport.applied}
 		/>
 	),
 };
 
 /**
- * The same stop on a transactional backend: nothing landed, and the screen
- * says the import was undone rather than counting sections (#1093).
+ * The same stop with no section written — a transaction undid the earlier
+ * writes, or the first write was the one that failed. No section may carry a
+ * tick, and the screen counts nothing as landed.
  */
-export const RolledBackImport: Story = {
+export const NothingLandedImport: 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}
+			results={sectionResults(nothingLandedImportReport)}
+			message={writeFailure(nothingLandedImportReport)?.message ?? ""}
+			raw={`import_write_failed: ${writeFailure(nothingLandedImportReport)?.message ?? ""}`}
+			nothingLanded={!nothingLandedImportReport.applied}
 		/>
 	),
 };

package/src/components/config-import/steps.import-failure.test.ts

@@ -0,0 +1,91 @@
+/**
+ * The stopped-import screen tells the reader one story (#1147).
+ *
+ * Title, subtitle and primary action were written three times over and merged
+ * out of order, leaving a screen that said the import stopped part-way, then
+ * that nothing was written, and offered to retry "the rest". Whichever half a
+ * reader believed, the other one was there to contradict it. What is pinned
+ * here is agreement: the three strings answer the same question the same way,
+ * and no section carries a tick the report cannot vouch for.
+ */
+
+import assert from "node:assert/strict";
+import { afterEach, describe, it } from "node:test";
+import type { RemitImapConfigImportReport } from "@remit/api-http-client/types.gen.ts";
+import { createElement } from "react";
+import { sectionResults, writeFailure } from "../../lib/config-import";
+import { createDomHarness, type DomHarness } from "../../test-support/dom";
+import {
+	nothingLandedImportReport,
+	partialImportReport,
+} from "./config-import.fixtures";
+import { StepPartialImport } from "./steps";
+
+let harness: DomHarness | undefined;
+
+afterEach(() => {
+	harness?.close();
+	harness = undefined;
+});
+
+const renderReport = (report: RemitImapConfigImportReport): DomHarness => {
+	const mounted = createDomHarness();
+	mounted.render(
+		createElement(StepPartialImport, {
+			results: sectionResults(report),
+			message: writeFailure(report)?.message ?? "",
+			raw: `import_write_failed: ${writeFailure(report)?.message ?? ""}`,
+			nothingLanded: !report.applied,
+		}),
+	);
+	return mounted;
+};
+
+const heading = (mounted: DomHarness): string =>
+	mounted.query("h1")?.textContent ?? "";
+
+const subtitle = (mounted: DomHarness): string =>
+	mounted.query("h1 + p")?.textContent ?? "";
+
+const primaryAction = (mounted: DomHarness): string => {
+	const footer = mounted.query("[data-testid=wizard-footer]");
+	assert.ok(footer, "the step renders a footer");
+	const buttons = [...footer.querySelectorAll("button")];
+	const last = buttons[buttons.length - 1];
+	assert.ok(last, "the footer offers an action");
+	return last.textContent ?? "";
+};
+
+const ticked = (mounted: DomHarness): number => {
+	const body = mounted.query("[data-testid=wizard-body]");
+	assert.ok(body, "the step renders a report body");
+	return body.querySelectorAll('[class*="bg-positive"]').length;
+};
+
+describe("the screen for an import that stopped", () => {
+	it("says nothing landed in all three places, and never part-way", () => {
+		harness = renderReport(nothingLandedImportReport);
+
+		assert.equal(heading(harness), "The import stopped, and nothing landed");
+		assert.equal(subtitle(harness), "No section of the file was written.");
+		assert.equal(primaryAction(harness), "Try the import again");
+		assert.ok(
+			!harness.text().includes("part-way"),
+			"a screen that says nothing landed cannot also say the import got part of the way",
+		);
+		assert.ok(
+			!harness.text().includes("Retry the rest"),
+			'"the rest" claims the file has a part already here',
+		);
+		assert.equal(ticked(harness), 0, "no section may carry a tick");
+	});
+
+	it("counts what landed when the server says some of it did", () => {
+		harness = renderReport(partialImportReport);
+
+		assert.equal(heading(harness), "The import stopped part-way");
+		assert.equal(subtitle(harness), "2 of 5 sections landed.");
+		assert.equal(primaryAction(harness), "Retry the rest");
+		assert.equal(ticked(harness), 2, "the landed sections keep their ticks");
+	});
+});

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

@@ -704,16 +704,15 @@ 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. 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.
+ * A section nobody can vouch for reads as failed, never as pending: it is
+ * finished, and an outcome the reader has to go and check for themselves is
+ * not a quiet empty row. Pending is the empty row — nothing from the file went
+ * into this section, whether the import never reached it or reached it and
+ * wrote none of it — and it is the state that carries no tick.
  */
 function resultState(state: SectionResult["state"]) {
 	if (state === "landed") return "ok" as const;
-	if (state === "failed" || state === "unknown" || state === "rolled-back")
-		return "failed" as const;
+	if (state === "failed" || state === "unknown") return "failed" as const;
 	return "pending" as const;
 }
 
@@ -721,7 +720,7 @@ export function StepPartialImport({
 	results,
 	message,
 	raw,
-	undone,
+	nothingLanded,
 	onBack,
 	onNext,
 }: {
@@ -729,8 +728,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;
+	/** No section of the file was written — not that the instance is unchanged. */
+	nothingLanded: boolean;
 } & StepNav) {
 	const landed = results.filter((result) => result.state === "landed").length;
 	const unknown = results.some((result) => result.state === "unknown");
@@ -738,10 +737,14 @@ export function StepPartialImport({
 		<WizardShell
 			steps={IMPORT_STEPS}
 			activeStep={1}
-			title="The import stopped part-way"
+			title={
+				nothingLanded
+					? "The import stopped, and nothing landed"
+					: "The import stopped part-way"
+			}
 			subtitle={
-				undone
-					? "Nothing was written — the whole import was undone."
+				nothingLanded
+					? "No section of the file was written."
 					: unknown
 						? "It did not say how far it got, so check Settings before importing again."
 						: `${landed} of ${results.length} sections landed.`
@@ -752,7 +755,7 @@ export function StepPartialImport({
 						Choose another file
 					</Button>
 					<Button variant="primary" onClick={onNext}>
-						Retry the rest
+						{nothingLanded ? "Try the import again" : "Retry the rest"}
 					</Button>
 				</>
 			}

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

@@ -151,13 +151,13 @@ 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(
+test("an import the server says wrote nothing marks no section landed, whatever ran before the stop", () => {
+	const results = sectionResults(
 		reportOf({
 			applied: false,
-			items: [item("filters", "Receipts", "rejected", "the store refused")],
+			items: [
+				item("filters", "Receipts", "rejected", "the store refused the write"),
+			],
 			errors: [
 				{
 					code: "import_write_failed",
@@ -169,71 +169,55 @@ test("a rolled-back import lands nothing, however far the items say it got", ()
 		}),
 	);
 
-	assert.equal(
-		rolled.some((result) => result.state === "landed"),
-		false,
+	const byId = new Map(results.map((result) => [result.section, result]));
+	assert.equal(byId.get("accounts")?.state, "not-landed");
+	assert.match(
+		byId.get("accounts")?.detail ?? "",
+		/Nothing from this section was written/,
 	);
-	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("labels")?.state, "not-landed");
 	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");
+	assert.equal(byId.get("addressFlags")?.state, "not-attempted");
+	assert.equal(byId.get("settings")?.state, "not-attempted");
+	assert.equal(results.filter((result) => result.state === "landed").length, 0);
 });
 
-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(
+test("a first write that fails on a store with no transaction lands nothing either", () => {
+	const results = sectionResults(
 		reportOf({
 			applied: false,
 			items: [
-				item("accounts", "a@example.test", "created"),
-				item("labels", "Receipts", "created"),
+				item("accounts", "a@example.test", "rejected", "the store refused"),
 			],
 			errors: [
 				{
 					code: "import_write_failed",
-					message: "the store refused the write",
-					details: { section: "filters", key: "Receipts" },
+					message:
+						"the store refused The items above it were written and remain; the import stopped here.",
+					details: { section: "accounts", key: "a@example.test" },
 				},
 			],
 		}),
 	);
 
-	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"],
-	);
+	const byId = new Map(results.map((result) => [result.section, result]));
+	assert.equal(byId.get("accounts")?.state, "failed");
+	assert.equal(byId.get("labels")?.state, "not-attempted");
+	assert.equal(results.filter((result) => result.state === "landed").length, 0);
 });
 
-test("a rolled-back import that names no section still says what happened", () => {
-	const rolled = sectionResults(
+test("nothing written and no section named is a known outcome, not an unknown one", () => {
+	const results = 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.deepEqual(
+		[...new Set(results.map((result) => result.state))],
+		["not-landed"],
 	);
-	assert.match(rolled[0].detail, /Nothing was written/);
 });
 
 test("a pending folder names the setting waiting on it, and repeats are folded", () => {

package/src/lib/config-import.ts

@@ -287,9 +287,9 @@ export const writeFailure = (
 
 export type SectionOutcome =
 	| "landed"
+	| "not-landed"
 	| "failed"
 	| "not-attempted"
-	| "rolled-back"
 	| "unknown";
 
 export interface SectionResult {
@@ -299,23 +299,24 @@ export interface SectionResult {
 	detail: string;
 }
 
+const NOT_LANDED_DETAIL = "Nothing from this section was written.";
+
 /**
- * What a stopped import left behind, section by section. The write order is
- * fixed, so the section the failure names splits the document in three: what is
- * before it ran, it did not, and what is after it was never reached. The
- * server's own sentence says whether the earlier writes survived, because only
- * the backend knows whether it had a transaction.
+ * What a stopped import wrote, section by section. The write order is fixed, so
+ * the section the failure names splits the document in three: what is before it
+ * ran, it did not, and what is after it was never reached.
+ *
+ * `applied` is the server's answer on whether any of it was written, because
+ * only the backend knows whether it had a transaction: false means no section
+ * of the file was written, however far the write order got. It does not say
+ * why — a transaction undid the earlier writes, or the first one failed — and
+ * the report carries no flag that does, so this says what the file put in and
+ * never what the instance now holds.
  *
- * A failure that names no section leaves that split undecidable, and every
+ * A failure that names no section leaves the split undecidable, and every
  * 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,
@@ -323,6 +324,7 @@ export const sectionResults = (
 	const failure = writeFailure(report);
 	const named = failure?.details?.section;
 	const failedSection = named ? asSection(named) : undefined;
+	const nothingLanded = !report.applied;
 	const counts = new Map<ImportSection, number>();
 	for (const item of report.items) {
 		if (asVerdict(item.verdict) === "rejected") continue;
@@ -331,31 +333,20 @@ export const sectionResults = (
 		counts.set(section, (counts.get(section) ?? 0) + 1);
 	}
 
-	if (failure && report.applied === false) {
-		return IMPORT_SECTION_ORDER.map((section) => ({
+	const everySection = (state: SectionOutcome, detail: string) =>
+		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.",
+			state,
+			detail,
 		}));
-	}
 
 	if (!failedSection) {
+		if (nothingLanded) return everySection("not-landed", NOT_LANDED_DETAIL);
 		const detail = named
 			? `The import stopped in "${named}", which this instance does not recognise, so it cannot say whether this section was written.`
 			: "The import stopped without naming where, so it cannot say whether this section was written. Open Settings to see what is here.";
-		return IMPORT_SECTION_ORDER.map((section) => ({
-			section,
-			title: SECTION_TITLES[section],
-			state: "unknown" as const,
-			detail,
-		}));
+		return everySection("unknown", detail);
 	}
 
 	const failedAt = IMPORT_SECTION_ORDER.indexOf(failedSection);
@@ -378,6 +369,14 @@ export const sectionResults = (
 				detail: "Not attempted — the import stopped before this section.",
 			};
 		}
+		if (nothingLanded) {
+			return {
+				section,
+				title,
+				state: "not-landed" as const,
+				detail: NOT_LANDED_DETAIL,
+			};
+		}
 		const written = counts.get(section) ?? 0;
 		return {
 			section,