@remit/web-client 0.0.258 → 0.0.259

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/web-client",
-  "version": "0.0.258",
+  "version": "0.0.259",
   "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.flow.test.ts

@@ -19,9 +19,7 @@ import assert from "node:assert/strict";
 import { afterEach, describe, it } from "node:test";
 import { MutationCache, QueryCache, QueryClient } from "@tanstack/react-query";
 import { createElement } from "react";
-import { ApiError } from "../../lib/api";
 import "../../lib/client";
-import { shouldEscalate, softErrorStatuses } from "../../lib/error-classifier";
 import { __resetFatalError, getCurrentFatalError } from "../../lib/fatal-error";
 import {
 	handleMutationCacheError,
@@ -196,28 +194,18 @@ describe("ConfigImportWizard — an instance that is not empty", () => {
 
 	/**
 	 * The other half of reaching that screen: the refusal must not also take the
-	 * app to the fatal page over it. That decision is `shouldEscalate` reading
-	 * the mutation's meta, and it is pinned here rather than through the wizard
-	 * because under this loader `lib/client.ts` and the generated SDK resolve
-	 * `client.gen` through two specifiers (`…/client.gen.ts` and `./client.gen.js`)
-	 * and so hold two client instances — the error interceptor registers on one
-	 * and the request goes through the other, which never happens under Vite,
-	 * where both specifiers resolve to the same module.
+	 * app to the fatal page over it. Driven through the wizard, so it holds the
+	 * whole chain — the error interceptor stamping the status on the thrown
+	 * `ApiError`, and the mutation's meta telling `shouldEscalate` to leave 409
+	 * to the caller.
 	 */
-	it("keeps the 409 off the fatal page, and still escalates a 401", () => {
-		const meta = softErrorStatuses(409);
-		assert.equal(
-			shouldEscalate(new ApiError("not empty", 409, {}), meta, "user"),
-			false,
-		);
-		assert.equal(
-			shouldEscalate(new ApiError("signed out", 401, {}), meta, "user"),
-			true,
-		);
-		assert.equal(
-			shouldEscalate(new ApiError("broken", 500, {}), meta, "user"),
-			true,
-		);
+	it("keeps the 409 off the fatal page", async () => {
+		const dom = start({ onImport: conflicted });
+		await pickFile(dom, "config.json", CONFIG);
+		dom.click(checkButton(dom));
+		await dom.flush();
+
+		assert.equal(getCurrentFatalError(), null);
 	});
 
 	it("does not record an import when the reader aborts the 409", async () => {

package/src/lib/client.test.ts

@@ -1,6 +1,9 @@
 import assert from "node:assert/strict";
 import { afterEach, describe, it } from "node:test";
+import { trashOperationsEmptyTrashMutation } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
 import { trashOperationsEmptyTrash } from "@remit/api-http-client/sdk.gen.ts";
+import { QueryClient } from "@tanstack/react-query";
+import { getRuntimeConfig } from "../runtime-config";
 import { type HttpMock, mockFetch } from "../test-support/http";
 import { ApiError } from "./api";
 import "./client";
@@ -66,3 +69,46 @@ describe("the error interceptor", () => {
 		assert.equal(error.message, "Request failed with status 503");
 	});
 });
+
+/**
+ * `client.ts` reaches the generated client as `@remit/api-http-client/client.gen.ts`
+ * while the generated code reaches it as `./client.gen.js`. Both must land on
+ * one module: two would leave every generated call on the generated default
+ * base URL and outside the error interceptor, so a 409 would arrive with no
+ * status and the fatal-error classifier would escalate it. Vite dedupes; this
+ * pins the node test loader, where the flow tests run.
+ */
+describe("the client the generated code calls through", () => {
+	const emptyViaQueryLayer = (): Promise<unknown> => {
+		const { mutationFn } = trashOperationsEmptyTrashMutation();
+		assert.ok(mutationFn);
+		return mutationFn(
+			{ path: { accountId: "acc-1" } },
+			{ client: new QueryClient(), meta: undefined },
+		);
+	};
+
+	it("is the instance client.ts configured, for the SDK and the query layer", async () => {
+		answer(200, {});
+
+		await empty();
+		await emptyViaQueryLayer();
+
+		const sent = http?.calls.map((call) => call.url) ?? [];
+		assert.equal(sent.length, 2);
+		const base = `${getRuntimeConfig().apiUrl}/accounts/acc-1/trash/empty`;
+		assert.deepEqual(sent, [base, base]);
+	});
+
+	it("carries the status on a query-layer failure too", async () => {
+		answer(409, { code: "config_not_empty", message: "already configured" });
+
+		const error = await emptyViaQueryLayer().then(
+			() => undefined,
+			(reason: unknown) => reason,
+		);
+
+		assert.ok(error instanceof ApiError);
+		assert.equal(error.status, 409);
+	});
+});