@remit/config-transfer 0.0.5 → 0.0.7

package/package.json

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

package/src/binder.ts

@@ -18,7 +18,7 @@ import type { AppointFolderRole } from "./import-repositories.js";
 export interface ConfigBinderRepositories {
 	configImport: Pick<IConfigImportRepository, "listByAccountConfig" | "update">;
 	accountSetting: Pick<IAccountSettingRepository, "upsert">;
-	filter: Pick<IFilterRepository, "update">;
+	filter: Pick<IFilterRepository, "listByAccountConfig" | "update">;
 	mailbox: Pick<IMailboxRepository, "listAllByAccount">;
 }
 
@@ -34,9 +34,15 @@ export interface ConfigBinderDeps {
  */
 export interface BindResult {
 	bound: number;
+	dropped: number;
 	stillPending: number;
 }
 
+type RefState =
+	| { kind: "TargetGone" }
+	| { kind: "Waiting" }
+	| { kind: "Ready"; mailboxId: string };
+
 /**
  * Bind the folder references an import could not resolve, now that discovery
  * has produced this account's mailboxes.
@@ -62,7 +68,7 @@ export const bindImportedFolders = async (
 	const imports = (
 		await repositories.configImport.listByAccountConfig(accountConfigId)
 	).filter((row) => row.state === ConfigImportState.Pending);
-	if (imports.length === 0) return { bound: 0, stillPending: 0 };
+	if (imports.length === 0) return { bound: 0, dropped: 0, stillPending: 0 };
 
 	const byPath = new Map(
 		(await repositories.mailbox.listAllByAccount(accountId)).map(
@@ -70,7 +76,14 @@ export const bindImportedFolders = async (
 		),
 	);
 
+	const filterIds = new Set(
+		(await repositories.filter.listByAccountConfig(accountConfigId)).map(
+			(filter) => filter.filterId,
+		),
+	);
+
 	let bound = 0;
+	let dropped = 0;
 	let stillPending = 0;
 
 	for (const row of imports) {
@@ -78,13 +91,16 @@ export const bindImportedFolders = async (
 		const remaining: ConfigImportUnresolvedRefItem[] = [];
 
 		for (const ref of row.unresolvedRefs) {
-			const mailboxId =
-				ref.accountId === accountId ? byPath.get(ref.folderPath) : undefined;
-			if (mailboxId === undefined) {
+			const state = refStateOf(ref, accountId, byPath, filterIds);
+			if (state.kind === "TargetGone") {
+				dropped++;
+				continue;
+			}
+			if (state.kind === "Waiting") {
 				remaining.push(ref);
 				continue;
 			}
-			await bindRef(deps, accountConfigId, ref, mailboxId, document);
+			await bindRef(deps, accountConfigId, ref, state.mailboxId, document);
 			bound++;
 		}
 
@@ -99,11 +115,29 @@ export const bindImportedFolders = async (
 		});
 	}
 
-	return { bound, stillPending };
+	return { bound, dropped, stillPending };
 };
 
 type BoundDocument = ReturnType<typeof readConfigDocument>;
 
+const refStateOf = (
+	ref: ConfigImportUnresolvedRefItem,
+	accountId: string,
+	byPath: ReadonlyMap<string, string>,
+	filterIds: ReadonlySet<string>,
+): RefState => {
+	if (
+		ref.kind === ConfigImportRefKind.FilterAction &&
+		!filterIds.has(ref.target)
+	) {
+		return { kind: "TargetGone" };
+	}
+	const mailboxId =
+		ref.accountId === accountId ? byPath.get(ref.folderPath) : undefined;
+	if (mailboxId === undefined) return { kind: "Waiting" };
+	return { kind: "Ready", mailboxId };
+};
+
 const bindRef = async (
 	deps: ConfigBinderDeps,
 	accountConfigId: string,

package/src/export.ts

@@ -297,6 +297,7 @@ const userFlagsOf = (flags: AddressFlags | undefined): ConfigAddressFlags => {
 	const user: ConfigAddressFlags = {};
 	if (stored.trusted) user.trusted = carriedFlag(stored.trusted);
 	if (stored.blocked) user.blocked = carriedFlag(stored.blocked);
+	if (stored.neverSpam) user.neverSpam = carriedFlag(stored.neverSpam);
 	if (stored.muted) user.muted = carriedFlag(stored.muted);
 	if (stored.vip) user.vip = carriedFlag(stored.vip);
 	if (stored.category) user.category = carriedFlag(stored.category);

package/src/import.test.ts

@@ -229,6 +229,9 @@ const repositoriesOf = (store: Store, accountConfigId: string): any => {
 				const at = store.filters.findIndex(
 					(filter) => filter.filterId === filterId,
 				);
+				if (at === -1) {
+					throw new NotFoundError(`Filter not found: ${filterId}`);
+				}
 				const next = { ...store.filters[at], ...patch };
 				store.filters[at] = next;
 				return next;
@@ -1228,6 +1231,93 @@ test("a binder run on a configuration with no import does nothing", async () =>
 		TARGET_CONFIG_ID,
 		PASSWORD_ACCOUNT_ID,
 	);
-	assert.deepEqual(result, { bound: 0, stillPending: 0 });
+	assert.deepEqual(result, { bound: 0, dropped: 0, stillPending: 0 });
 	assert.equal(pendingImportOf([]), undefined);
 });
+
+test("a filter deleted before its folder is discovered drops its reference instead of failing the bind", async () => {
+	const document = await exportSource(sourceWithLegacyFlagsFixture());
+	const store = emptyStore();
+	await apply(store, document);
+
+	const invoices = store.filters.find(
+		(filter) => filter.name === "Invoices to Facturen",
+	);
+	assert.ok(invoices);
+	store.filters = store.filters.filter(
+		(filter) => filter.filterId !== invoices.filterId,
+	);
+
+	discover(store, PASSWORD_ACCOUNT_ID, [
+		"INBOX",
+		"INBOX.Sent",
+		"INBOX.Facturen",
+		"INBOX.Lists.dev-null",
+	]);
+	discover(store, OAUTH_ACCOUNT_ID, ["INBOX"]);
+	const binder = {
+		repositories: repositoriesOf(store, TARGET_CONFIG_ID),
+		appointFolderRole: appointFolderRoleInto(store),
+		now: () => NOW,
+	};
+
+	const first = await bindImportedFolders(
+		binder,
+		TARGET_CONFIG_ID,
+		PASSWORD_ACCOUNT_ID,
+	);
+	await bindImportedFolders(binder, TARGET_CONFIG_ID, OAUTH_ACCOUNT_ID);
+
+	assert.equal(first.dropped, 1);
+	assert.equal(
+		store.imports[0].unresolvedRefs.some(
+			(ref) => ref.target === invoices.filterId,
+		),
+		false,
+	);
+	assert.equal(store.imports[0].state, "Complete");
+
+	const again = await bindImportedFolders(
+		binder,
+		TARGET_CONFIG_ID,
+		PASSWORD_ACCOUNT_ID,
+	);
+	assert.deepEqual(again, { bound: 0, dropped: 0, stillPending: 0 });
+});
+
+test("a deleted filter's reference is dropped even when its folder never appears", async () => {
+	const document = await exportSource(sourceWithLegacyFlagsFixture());
+	const store = emptyStore();
+	await apply(store, document);
+
+	const invoices = store.filters.find(
+		(filter) => filter.name === "Invoices to Facturen",
+	);
+	assert.ok(invoices);
+	store.filters = store.filters.filter(
+		(filter) => filter.filterId !== invoices.filterId,
+	);
+
+	discover(store, PASSWORD_ACCOUNT_ID, ["INBOX"]);
+	const result = await bindImportedFolders(
+		{
+			repositories: repositoriesOf(store, TARGET_CONFIG_ID),
+			appointFolderRole: appointFolderRoleInto(store),
+			now: () => NOW,
+		},
+		TARGET_CONFIG_ID,
+		PASSWORD_ACCOUNT_ID,
+	);
+
+	assert.equal(result.dropped, 1);
+	assert.equal(
+		store.imports[0].unresolvedRefs.some(
+			(ref) => ref.target === invoices.filterId,
+		),
+		false,
+	);
+	assert.equal(
+		pendingImportOf(store.imports)?.folderPaths.includes("INBOX.Facturen"),
+		false,
+	);
+});