@remit/web-client 0.0.246 → 0.0.247

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/web-client",
-  "version": "0.0.246",
+  "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,7 +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"}`}
-					nothingLanded={!report.applied}
+					// `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

@@ -182,11 +182,11 @@ export const partialImportReport: RemitImapConfigImportReport = report({
 });
 
 /**
- * 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.
+ * 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 nothingLandedImportReport: RemitImapConfigImportReport = report({
+export const rolledBackImportReport: 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,7 +417,6 @@ export const PartiallyLandedImportUnnamed: Story = {
 				results={sectionResults(report)}
 				message={writeFailure(report)?.message ?? ""}
 				raw="import_write_failed: the store refused the write"
-				nothingLanded={!report.applied}
 			/>
 		);
 	},
@@ -430,23 +429,26 @@ export const PartiallyLandedImport: Story = {
 			results={sectionResults(partialImportReport)}
 			message={writeFailure(partialImportReport)?.message ?? ""}
 			raw={`import_write_failed: ${writeFailure(partialImportReport)?.message ?? ""}`}
-			nothingLanded={!partialImportReport.applied}
 		/>
 	),
 };
 
 /**
- * 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.
+ * The same stop on a transactional backend: nothing landed, and the screen
+ * says the import was undone rather than counting sections (#1093).
  */
-export const NothingLandedImport: Story = {
+export const RolledBackImport: Story = {
 	render: () => (
 		<StepPartialImport
-			results={sectionResults(nothingLandedImportReport)}
-			message={writeFailure(nothingLandedImportReport)?.message ?? ""}
-			raw={`import_write_failed: ${writeFailure(nothingLandedImportReport)?.message ?? ""}`}
-			nothingLanded={!nothingLandedImportReport.applied}
+			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}
 		/>
 	),
 };

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

@@ -704,15 +704,16 @@ export function StepFileRejected({
 }
 
 /**
- * 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.
+ * 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.
  */
 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;
 }
 
@@ -720,7 +721,7 @@ export function StepPartialImport({
 	results,
 	message,
 	raw,
-	nothingLanded,
+	undone,
 	onBack,
 	onNext,
 }: {
@@ -728,8 +729,8 @@ export function StepPartialImport({
 	/** The server's own account of what survived, which only it knows. */
 	message: string;
 	raw: string;
-	/** No section of the file was written — not that the instance is unchanged. */
-	nothingLanded: boolean;
+	/** `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");
@@ -737,14 +738,10 @@ export function StepPartialImport({
 		<WizardShell
 			steps={IMPORT_STEPS}
 			activeStep={1}
-			title={
-				nothingLanded
-					? "The import stopped, and nothing landed"
-					: "The import stopped part-way"
-			}
+			title="The import stopped part-way"
 			subtitle={
-				nothingLanded
-					? "No section of the file was written."
+				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.`
@@ -755,7 +752,7 @@ export function StepPartialImport({
 						Choose another file
 					</Button>
 					<Button variant="primary" onClick={onNext}>
-						{nothingLanded ? "Try the import again" : "Retry the rest"}
+						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("an import the server says wrote nothing marks no section landed, whatever ran before the stop", () => {
-	const results = sectionResults(
+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 the write"),
-			],
+			items: [item("filters", "Receipts", "rejected", "the store refused")],
 			errors: [
 				{
 					code: "import_write_failed",
@@ -169,55 +169,71 @@ test("an import the server says wrote nothing marks no section landed, whatever
 		}),
 	);
 
-	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/,
+	assert.equal(
+		rolled.some((result) => result.state === "landed"),
+		false,
 	);
-	assert.equal(byId.get("labels")?.state, "not-landed");
+	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.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);
+	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("a first write that fails on a store with no transaction lands nothing either", () => {
-	const results = sectionResults(
+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", "rejected", "the store refused"),
+				item("accounts", "a@example.test", "created"),
+				item("labels", "Receipts", "created"),
 			],
 			errors: [
 				{
 					code: "import_write_failed",
-					message:
-						"the store refused The items above it were written and remain; the import stopped here.",
-					details: { section: "accounts", key: "a@example.test" },
+					message: "the store refused the write",
+					details: { section: "filters", key: "Receipts" },
 				},
 			],
 		}),
 	);
 
-	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);
+	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("nothing written and no section named is a known outcome, not an unknown one", () => {
-	const results = sectionResults(
+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.deepEqual(
-		[...new Set(results.map((result) => result.state))],
-		["not-landed"],
+	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", () => {

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,24 +299,23 @@ export interface SectionResult {
 	detail: string;
 }
 
-const NOT_LANDED_DETAIL = "Nothing from this section was written.";
-
 /**
- * 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.
+ * 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.
  *
- * A failure that names no section leaves the split undecidable, and every
+ * A failure that names no section leaves that 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,
@@ -324,7 +323,6 @@ 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;
@@ -333,20 +331,31 @@ export const sectionResults = (
 		counts.set(section, (counts.get(section) ?? 0) + 1);
 	}
 
-	const everySection = (state: SectionOutcome, detail: string) =>
-		IMPORT_SECTION_ORDER.map((section) => ({
+	if (failure && report.applied === false) {
+		return IMPORT_SECTION_ORDER.map((section) => ({
 			section,
 			title: SECTION_TITLES[section],
-			state,
-			detail,
+			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) {
-		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 everySection("unknown", detail);
+		return IMPORT_SECTION_ORDER.map((section) => ({
+			section,
+			title: SECTION_TITLES[section],
+			state: "unknown" as const,
+			detail,
+		}));
 	}
 
 	const failedAt = IMPORT_SECTION_ORDER.indexOf(failedSection);
@@ -369,14 +378,6 @@ 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,