@remit/config-transfer 0.0.1 → 0.0.2

package/package.json

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

package/src/binder.ts

@@ -0,0 +1,184 @@
+import { readConfigDocument } from "@remit/config-format";
+import type {
+	ConfigImportItem,
+	ConfigImportUnresolvedRefItem,
+	IAccountSettingRepository,
+	IConfigImportRepository,
+	IFilterRepository,
+	IMailboxRepository,
+} from "@remit/data-ports";
+import { composeSettingName } from "@remit/data-ports/account-settings";
+import {
+	AccountSettingName,
+	ConfigImportRefKind,
+	ConfigImportState,
+} from "@remit/domain-enums";
+import type { AppointFolderRole } from "./import-repositories.js";
+
+export interface ConfigBinderRepositories {
+	configImport: Pick<IConfigImportRepository, "listByAccountConfig" | "update">;
+	accountSetting: Pick<IAccountSettingRepository, "upsert">;
+	filter: Pick<IFilterRepository, "update">;
+	mailbox: Pick<IMailboxRepository, "listAllByAccount">;
+}
+
+export interface ConfigBinderDeps {
+	repositories: ConfigBinderRepositories;
+	appointFolderRole: AppointFolderRole;
+	now?: () => number;
+}
+
+/**
+ * What one folder path an import was waiting for is still waiting for, told as
+ * a count so a caller can log it without walking the refs again.
+ */
+export interface BindResult {
+	bound: number;
+	stillPending: number;
+}
+
+/**
+ * Bind the folder references an import could not resolve, now that discovery
+ * has produced this account's mailboxes.
+ *
+ * Every reference names a folder by IMAP path, because the ids are new on every
+ * discovery. This runs where discovery ends, resolves what it can, writes the
+ * row each reference belongs to, and drops it. An import whose last reference
+ * is gone is Complete; the rest stay, and surface on `GET /config` until the
+ * folder they name shows up or the person removes the expectation.
+ *
+ * Idempotent and replayable: every write is an upsert or an update onto a row
+ * the import already created, so a second discovery finds nothing to do rather
+ * than doing it again differently.
+ */
+export const bindImportedFolders = async (
+	deps: ConfigBinderDeps,
+	accountConfigId: string,
+	accountId: string,
+): Promise<BindResult> => {
+	const { repositories } = deps;
+	const now = deps.now ?? Date.now;
+
+	const imports = (
+		await repositories.configImport.listByAccountConfig(accountConfigId)
+	).filter((row) => row.state === ConfigImportState.Pending);
+	if (imports.length === 0) return { bound: 0, stillPending: 0 };
+
+	const byPath = new Map(
+		(await repositories.mailbox.listAllByAccount(accountId)).map(
+			(mailbox) => [mailbox.fullPath, mailbox.mailboxId] as const,
+		),
+	);
+
+	let bound = 0;
+	let stillPending = 0;
+
+	for (const row of imports) {
+		const document = readConfigDocument(row.document);
+		const remaining: ConfigImportUnresolvedRefItem[] = [];
+
+		for (const ref of row.unresolvedRefs) {
+			const mailboxId =
+				ref.accountId === accountId ? byPath.get(ref.folderPath) : undefined;
+			if (mailboxId === undefined) {
+				remaining.push(ref);
+				continue;
+			}
+			await bindRef(deps, accountConfigId, ref, mailboxId, document);
+			bound++;
+		}
+
+		stillPending += remaining.length;
+		if (remaining.length === row.unresolvedRefs.length) continue;
+
+		await repositories.configImport.update(row.importId, {
+			unresolvedRefs: remaining,
+			...(remaining.length === 0
+				? { state: ConfigImportState.Complete, completedAt: now() }
+				: {}),
+		});
+	}
+
+	return { bound, stillPending };
+};
+
+type BoundDocument = ReturnType<typeof readConfigDocument>;
+
+const bindRef = async (
+	deps: ConfigBinderDeps,
+	accountConfigId: string,
+	ref: ConfigImportUnresolvedRefItem,
+	mailboxId: string,
+	document: BoundDocument,
+): Promise<void> => {
+	const { repositories } = deps;
+	if (ref.kind === ConfigImportRefKind.FilterAction) {
+		await repositories.filter.update(accountConfigId, ref.target, {
+			actionMailboxId: mailboxId,
+		});
+		return;
+	}
+
+	if (ref.kind === ConfigImportRefKind.FolderRole) {
+		await deps.appointFolderRole(
+			accountConfigId,
+			ref.accountId,
+			ref.target,
+			mailboxId,
+			ref.folderPath,
+		);
+		return;
+	}
+
+	// The account the file named, when this instance still holds it under that
+	// id — it does for every account the import created, because the id crosses
+	// verbatim. A merge onto an account already here can have renumbered it, and
+	// then the path is the only thing left to match on.
+	const named = document.accounts.find(
+		(account) => account.accountId === ref.accountId,
+	);
+	const override = (
+		named
+			? named.folderOverrides
+			: document.accounts.flatMap((a) => a.folderOverrides)
+	).find((candidate) => candidate.folderPath === ref.folderPath);
+	if (!override) return;
+
+	if (override.displayName !== "") {
+		await repositories.accountSetting.upsert({
+			accountConfigId,
+			name: composeSettingName(
+				AccountSettingName.MailboxDisplayName,
+				mailboxId,
+			),
+			value: { kind: "String", value: override.displayName },
+		});
+	}
+	if (override.muted !== null) {
+		await repositories.accountSetting.upsert({
+			accountConfigId,
+			name: composeSettingName(AccountSettingName.MailboxMuted, mailboxId),
+			value: { kind: "MutedFlag", value: override.muted },
+		});
+	}
+};
+
+/**
+ * The folder paths an import is still waiting on, for `GET /config`. The newest
+ * pending import only: an older one waiting for the same folder is waiting for
+ * the same thing, and naming it twice tells nobody anything.
+ */
+export const pendingImportOf = (
+	imports: readonly ConfigImportItem[],
+): { importId: string; folderPaths: string[] } | undefined => {
+	const pending = imports
+		.filter((row) => row.state === ConfigImportState.Pending)
+		.sort((a, b) => b.createdAt - a.createdAt)[0];
+	if (!pending || pending.unresolvedRefs.length === 0) return undefined;
+	return {
+		importId: pending.importId,
+		folderPaths: [
+			...new Set(pending.unresolvedRefs.map((ref) => ref.folderPath)),
+		],
+	};
+};

package/src/import-repositories.ts

@@ -0,0 +1,97 @@
+import type {
+	AccountConfigItem,
+	CreateAccountConfigInput,
+	IAccountRepository,
+	IAccountSettingRepository,
+	IAddressRepository,
+	IConfigImportRepository,
+	IFilterAnchorRepository,
+	IFilterRepository,
+	ILabelRepository,
+	IMailboxRepository,
+	UpdateAccountConfigInput,
+} from "@remit/data-ports";
+
+/**
+ * Everything the import reads and writes, and nothing else. Repositories rather
+ * than a client or an HTTP surface, for the same reason the export takes them:
+ * what a configuration contains is decided here, not by whichever process
+ * happens to be holding the file.
+ */
+export interface ConfigImportRepositories {
+	accountConfig: {
+		get: (accountConfigId: string) => Promise<AccountConfigItem>;
+		create: (input: CreateAccountConfigInput) => Promise<AccountConfigItem>;
+		update: (
+			accountConfigId: string,
+			input: UpdateAccountConfigInput,
+		) => Promise<AccountConfigItem>;
+	};
+	account: Pick<
+		IAccountRepository,
+		"listAllByAccountConfig" | "create" | "update"
+	>;
+	accountSetting: Pick<
+		IAccountSettingRepository,
+		"listByAccountConfig" | "upsert"
+	>;
+	mailbox: Pick<IMailboxRepository, "listAllByAccount">;
+	label: Pick<ILabelRepository, "listByAccountConfig" | "create" | "update">;
+	filter: Pick<IFilterRepository, "listByAccountConfig" | "create" | "update">;
+	filterAnchor: Pick<IFilterAnchorRepository, "put">;
+	address: Pick<
+		IAddressRepository,
+		"listByAccountConfig" | "upsertAddress" | "mergeFlags"
+	>;
+	configImport: Pick<
+		IConfigImportRepository,
+		"create" | "update" | "listByAccountConfig"
+	>;
+}
+
+/**
+ * A filter anchor, re-embedded from the source text the file carries. The
+ * stored vector is a function of the model that produced it, so it never
+ * travels; this is the one thing an import has to compute rather than copy.
+ *
+ * Optional, and free to answer `undefined`, because a configuration file has to
+ * import on a deployment that ships no embedding model at all. Either way the
+ * anchor lands stamped `ANCHOR_EMBEDDING_PENDING`, which the existing lazy
+ * repair (`refreshAnchorForEmbedder`) treats as needing a fresh vector the
+ * first time the filter is matched.
+ */
+export type EmbedAnchor = (
+	sourceText: string,
+) => Promise<{ embedding: number[]; embeddingId: string } | undefined>;
+
+/**
+ * Persist one role's folder appointment. Injected rather than composed here:
+ * an appointment row means a person decided, and it keeps that meaning only
+ * while one writer produces it — the same one every other appointment in the
+ * repo goes through.
+ */
+export type AppointFolderRole = (
+	accountConfigId: string,
+	accountId: string,
+	role: string,
+	mailboxId: string,
+	lastKnownPath: string,
+) => Promise<void>;
+
+export interface ConfigImportDeps {
+	repositories: ConfigImportRepositories;
+	appointFolderRole: AppointFolderRole;
+	/**
+	 * Runs the whole apply as one write set, rolling back on any throw.
+	 *
+	 * Optional, and its presence is the fact the report words itself from: a
+	 * backend that supplies this rolls a failed apply back to nothing, and one
+	 * that does not leaves behind whatever landed before the failure. Only the
+	 * caller knows which, so it says so by passing this or omitting it rather
+	 * than by handing over a pass-through that would claim atomicity it has not
+	 * got.
+	 */
+	transaction?: <T>(run: () => Promise<T>) => Promise<T>;
+	embedAnchor?: EmbedAnchor;
+	now?: () => number;
+}