@remit/config-transfer 0.0.3 → 0.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/config-transfer",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "type": "module",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/export.test.ts

@@ -10,6 +10,7 @@ import {
 import { ConfigExportRefusedError, readConfigForExport } from "./export.js";
 import {
 	ACCOUNT_CONFIG_ID,
+	asAddressRepository,
 	asRepositories,
 	type ConfigFixture,
 	makeAccount,
@@ -17,6 +18,7 @@ import {
 	makeAddress,
 	makeAnchor,
 	makeFilter,
+	makeJunkOnlyFlaggedAddress,
 	makeLabel,
 	makeLegacyFlaggedAddress,
 	makeMailbox,
@@ -463,13 +465,48 @@ test("an address exports only when the user decided something about it", async (
 			},
 		}),
 	];
-	fixture.addresses = [...derivedOnly, ...fixture.addresses];
+	fixture.addresses = [
+		...derivedOnly,
+		...fixture.addresses,
+		makeJunkOnlyFlaggedAddress(),
+	];
 
 	const document = await exportFixture(fixture);
 
 	assert.deepEqual(
 		document.addressFlags.map((entry) => entry.normalizedEmail),
-		["post@bank.example", "noreply@newsletter.example"],
+		["post@bank.example", "sale@junk.example", "noreply@newsletter.example"],
+	);
+});
+
+test("an address the machine marked junk-only still exports the decision on it", async () => {
+	const fixture = fullFixture();
+	fixture.addresses = [...fixture.addresses, makeJunkOnlyFlaggedAddress()];
+
+	const suggested = await asAddressRepository(fixture).listByAccountConfig({
+		accountConfigId: ACCOUNT_CONFIG_ID,
+	});
+	assert.equal(
+		suggested.items.some((item) => item.addressId === "adr-junk-news"),
+		false,
+		"the suggest listing is right to hide it, and is not the export's read",
+	);
+
+	const document = await exportFixture(fixture);
+
+	const exported = document.addressFlags.find(
+		(entry) => entry.normalizedEmail === "sale@junk.example",
+	);
+	assert.deepEqual(exported?.flags.unsubscribed, {
+		value: true,
+		setAt: 1755000000000,
+	});
+	assert.equal(exported?.flags.autoArchive?.value, true);
+	assert.equal(exported?.flags.category?.value, "newsletter");
+	assert.equal(
+		"junkOnly" in (exported?.flags ?? {}),
+		false,
+		"the machine's own flag is still not carried",
 	);
 });
 

package/src/export.ts

@@ -329,7 +329,7 @@ const readAddresses = async (
 	const addresses: AddressItem[] = [];
 	let cursor: string | undefined;
 	do {
-		const page = await repositories.address.listByAccountConfig({
+		const page = await repositories.address.listAllByAccountConfigPage({
 			accountConfigId,
 			cursor,
 		});

package/src/fixtures.ts

@@ -5,6 +5,7 @@ import type {
 	AddressItem,
 	FilterAnchorItem,
 	FilterItem,
+	IAddressRepository,
 	LabelItem,
 	MailboxItem,
 } from "@remit/data-ports";
@@ -89,6 +90,7 @@ export const makeMailbox = (
 	highWaterMarkUid: 0,
 	lastMessageSyncAt: NOW,
 	parentMailboxId: "",
+	syncStatus: "synced",
 	cursorState: "normal",
 	createdAt: NOW,
 	updatedAt: NOW,
@@ -185,6 +187,79 @@ export const makeLegacyFlaggedAddress = (): AddressItem =>
 		} as unknown as AddressItem["flags"],
 	});
 
+/**
+ * The shape #1029 was about: mail the reader unsubscribed from and never
+ * replied to, landing only in Junk, so sync marks the row `junkOnly`. The
+ * autocomplete listing is right to hide it; neither half of the transfer is.
+ */
+export const makeJunkOnlyFlaggedAddress = (): AddressItem =>
+	makeAddress({
+		addressId: "adr-junk-news",
+		normalizedEmail: "sale@junk.example",
+		flags: {
+			junkOnly: { value: true, setAt: 1750000000000 },
+			unsubscribed: { value: true, setAt: 1755000000000 },
+			autoArchive: { value: true, setAt: 1755000000000 },
+			category: { value: "newsletter", setAt: 1755000000000 },
+		},
+	});
+
+/**
+ * The suggest predicate the stored listing applies, spelled in JavaScript: an
+ * address is hidden exactly when the machine marked it `junkOnly` and the
+ * account has neither corresponded with the sender nor flagged it. Modelled
+ * rather than ignored, because a stub that filters nothing cannot tell a read
+ * that hides decisions apart from one that does (#1029).
+ */
+export const suggestable = (address: AddressItem): boolean => {
+	const flags = address.flags ?? {};
+	if (flags.junkOnly?.value !== true) return true;
+	const corresponded =
+		address.outboundCount + address.replyCount > 0 ||
+		flags.vip?.value === true ||
+		flags.trusted?.value === true;
+	return (
+		corresponded || flags.blocked?.value === true || flags.muted?.value === true
+	);
+};
+
+const byAddressId = (rows: AddressItem[]): AddressItem[] =>
+	[...rows].sort((left, right) =>
+		left.addressId < right.addressId
+			? -1
+			: left.addressId > right.addressId
+				? 1
+				: 0,
+	);
+
+/**
+ * Both address reads, so a test can hold them against each other: the suggest
+ * listing hides a junk-only row, the export's listing carries every row in
+ * `addressId` order.
+ */
+export const asAddressRepository = (
+	fixture: ConfigFixture,
+): Pick<
+	IAddressRepository,
+	"listByAccountConfig" | "listAllByAccountConfigPage"
+> => {
+	const pageOf = (rows: AddressItem[], cursor: string | undefined) => {
+		const size = fixture.addressPageSize ?? rows.length + 1;
+		const offset = cursor ? Number(cursor) : 0;
+		const next = offset + size;
+		return {
+			items: rows.slice(offset, next),
+			continuationToken: next < rows.length ? String(next) : undefined,
+		};
+	};
+	return {
+		listByAccountConfig: async ({ cursor }) =>
+			pageOf(fixture.addresses.filter(suggestable), cursor),
+		listAllByAccountConfigPage: async ({ cursor }) =>
+			pageOf(byAddressId(fixture.addresses), cursor),
+	};
+};
+
 /** The fixture, behind the repository interfaces the export takes. */
 export const asRepositories = (
 	fixture: ConfigFixture,
@@ -211,17 +286,5 @@ export const asRepositories = (
 	filterAnchor: {
 		listByAccountConfig: async () => fixture.anchors,
 	},
-	address: {
-		listByAccountConfig: async ({ cursor }) => {
-			const size = fixture.addressPageSize ?? fixture.addresses.length + 1;
-			const offset = cursor ? Number(cursor) : 0;
-			const items = fixture.addresses.slice(offset, offset + size);
-			const next = offset + size;
-			return {
-				items,
-				continuationToken:
-					next < fixture.addresses.length ? String(next) : undefined,
-			};
-		},
-	},
+	address: asAddressRepository(fixture),
 });

package/src/import-repositories.ts

@@ -39,9 +39,14 @@ export interface ConfigImportRepositories {
 	label: Pick<ILabelRepository, "listByAccountConfig" | "create" | "update">;
 	filter: Pick<IFilterRepository, "listByAccountConfig" | "create" | "update">;
 	filterAnchor: Pick<IFilterAnchorRepository, "put">;
+	/**
+	 * Not the suggest listing, for the reason the export refuses it too: what a
+	 * configuration already holds is decided over every stored row, junk-only
+	 * ones included (#1029).
+	 */
 	address: Pick<
 		IAddressRepository,
-		"listByAccountConfig" | "upsertAddress" | "mergeFlags"
+		"listAllByAccountConfigPage" | "upsertAddress" | "mergeFlags"
 	>;
 	configImport: Pick<
 		IConfigImportRepository,

package/src/import.test.ts

@@ -28,12 +28,14 @@ import {
 	makeAddress,
 	makeAnchor,
 	makeFilter,
+	makeJunkOnlyFlaggedAddress,
 	makeLabel,
 	makeLegacyFlaggedAddress,
 	makeMailbox,
 	makeSetting,
 	OAUTH_ACCOUNT_ID,
 	PASSWORD_ACCOUNT_ID,
+	suggestable,
 } from "./fixtures.js";
 import { ANCHOR_EMBEDDING_PENDING, importConfig } from "./import.js";
 import type { ConfigImportDeps } from "./import-repositories.js";
@@ -246,7 +248,13 @@ const repositoriesOf = (store: Store, accountConfigId: string): any => {
 			listByAccountConfig: async () => [...store.anchors],
 		},
 		address: {
+			// Both reads, so the stub can tell them apart: the suggest listing
+			// hides a junk-only row, and the import must not be reading it (#1029).
 			listByAccountConfig: async () => ({
+				items: store.addresses.filter(suggestable),
+				continuationToken: undefined,
+			}),
+			listAllByAccountConfigPage: async () => ({
 				items: [...store.addresses],
 				continuationToken: undefined,
 			}),
@@ -694,6 +702,31 @@ test("a configuration that already holds something refuses the default import",
 	assert.equal(outcome.conflict.details.addressFlags, "2");
 });
 
+test("a junk-only sender the user decided about still holds the configuration", async () => {
+	const document = await exportSource();
+	const store = emptyStore();
+	store.addresses.push(makeJunkOnlyFlaggedAddress());
+
+	assert.equal(
+		store.addresses.filter(suggestable).length,
+		0,
+		"the suggest listing hides it, and is not the read the import may use",
+	);
+
+	const outcome = await importConfig(depsOf(store, ACCOUNT_CONFIG_ID), {
+		accountConfigId: ACCOUNT_CONFIG_ID,
+		userId: TARGET_USER_ID,
+		document,
+		mode: "apply",
+		onExisting: "abort",
+	});
+
+	assert.equal(outcome.outcome, "conflict");
+	if (outcome.outcome !== "conflict") throw new Error("unreachable");
+	assert.equal(outcome.conflict.code, "config_not_empty");
+	assert.equal(outcome.conflict.details.addressFlags, "1");
+});
+
 test("merge folds the file in and deletes nothing the file left out", async () => {
 	const document = await exportSource();
 	const store = emptyStore();

package/src/import.ts

@@ -118,11 +118,14 @@ const readExisting = async (
 	]);
 	const live = accounts.filter((account) => account.deletedAt === undefined);
 
+	// Not the suggest listing: it hides an address the machine marked `junkOnly`,
+	// so a decision the user made about a junk-only sender would read as absent
+	// and be re-created or left out of the conflict count (#1029).
 	let flaggedAddresses = 0;
 	const addressEmails = new Set<string>();
 	let cursor: string | undefined;
 	do {
-		const page = await repositories.address.listByAccountConfig({
+		const page = await repositories.address.listAllByAccountConfigPage({
 			accountConfigId,
 			cursor,
 		});

package/src/repositories.ts

@@ -25,7 +25,13 @@ export interface ConfigExportRepositories {
 	label: Pick<ILabelRepository, "listByAccountConfig">;
 	filter: Pick<IFilterRepository, "listByAccountConfig">;
 	filterAnchor: Pick<IFilterAnchorRepository, "listByAccountConfig">;
-	address: Pick<IAddressRepository, "listByAccountConfig">;
+	/**
+	 * Not the suggest listing: that one hides an address the machine marked
+	 * `junkOnly` unless the account has corresponded with it, which is right for
+	 * autocomplete and wrong for a file whose whole job is to keep the reader's
+	 * decisions (#1029).
+	 */
+	address: Pick<IAddressRepository, "listAllByAccountConfigPage">;
 }
 
 /** Who wrote the file, and where from. Recorded; never authoritative on import. */