@remit/imap-worker 0.0.90 → 0.0.91

package/src/scheduler/calendar-subscriptions.sqlite.test.ts

@@ -1,147 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import type { CalendarFeedFetcher } from "@remit/calendar-service";
-import type { CalendarCollectionItem } from "@remit/data-ports";
-import { CalendarSource } from "@remit/domain-enums";
-import type { Logger } from "@remit/logger";
-import { openStore } from "../test-helpers/test-world.js";
-import { refreshDueCalendarSubscriptions } from "./calendar-subscriptions.js";
-
-const INTERVAL_MS = 15 * 60 * 1000;
-const NOW = 1_800_000_000_000;
-
-const FEED = `${[
-	"BEGIN:VCALENDAR",
-	"VERSION:2.0",
-	"PRODID:-//Example//Published Calendar//EN",
-	"BEGIN:VEVENT",
-	"UID:ferry@calendar.example",
-	"DTSTAMP:20260901T000000Z",
-	"DTSTART:20260908T070000Z",
-	"DTEND:20260908T080000Z",
-	"SUMMARY:Ferry crossing",
-	"END:VEVENT",
-	"END:VCALENDAR",
-].join("\r\n")}\r\n`;
-
-const logged = (): { log: Logger; lines: string[] } => {
-	const lines: string[] = [];
-	const capture = (...args: unknown[]) => {
-		lines.push(JSON.stringify(args));
-	};
-	const log = {
-		info: capture,
-		warn: capture,
-		error: capture,
-		debug: capture,
-		fatal: capture,
-		trace: capture,
-		child: () => log,
-	} as unknown as Logger;
-	return { log, lines };
-};
-
-type Client = Awaited<ReturnType<typeof openStore>>["client"];
-
-const subscription = async (
-	client: Client,
-	urlSegment: string,
-	checkedAt: number,
-): Promise<CalendarCollectionItem> => {
-	const created = await client.calendarCollection.create({
-		accountConfigId: "account-config-1",
-		urlSegment,
-		displayName: urlSegment,
-		source: CalendarSource.Subscribed,
-		subscriptionUrl: `https://calendar.example/${urlSegment}/private-feedfacecafe.ics`,
-		subscriptionEnabled: true,
-	});
-	return client.calendarCollection.update(
-		created.accountConfigId,
-		created.calendarId,
-		{ subscriptionCheckedAt: checkedAt },
-	);
-};
-
-const recording =
-	(asked: string[], answer: (url: string) => Response): CalendarFeedFetcher =>
-	async (url) => {
-		asked.push(url);
-		return answer(url);
-	};
-
-describe("refreshDueCalendarSubscriptions", () => {
-	it("fetches the subscriptions that are due and skips the rest", async (t) => {
-		const { client, close } = await openStore();
-		t.after(close);
-		const due = await subscription(client, "due", NOW - INTERVAL_MS);
-		await subscription(client, "fresh", NOW - 60_000);
-		const paused = await subscription(client, "paused", 0);
-		await client.calendarCollection.update(
-			paused.accountConfigId,
-			paused.calendarId,
-			{ subscriptionEnabled: false },
-		);
-		const asked: string[] = [];
-
-		const tally = await refreshDueCalendarSubscriptions(
-			{
-				calendarCollection: client.calendarCollection,
-				calendarStore: client.calendarStore,
-				log: logged().log,
-				fetcher: recording(asked, () => new Response(FEED, { status: 200 })),
-			},
-			NOW,
-			INTERVAL_MS,
-		);
-
-		assert.deepEqual(asked, [due.subscriptionUrl]);
-		assert.deepEqual(tally, { refreshed: 1, failed: 0, notDue: 1 });
-		const objects = await client.calendarObject.listByCalendar(due.calendarId);
-		assert.deepEqual(
-			objects.map((object) => object.summary),
-			["Ferry crossing"],
-		);
-	});
-
-	it("counts a feed that fails, keeps refreshing the others, and never logs an address", async (t) => {
-		const { client, close } = await openStore();
-		t.after(close);
-		const broken = await subscription(client, "broken", 0);
-		const working = await subscription(client, "working", 0);
-		const { log, lines } = logged();
-
-		const tally = await refreshDueCalendarSubscriptions(
-			{
-				calendarCollection: client.calendarCollection,
-				calendarStore: client.calendarStore,
-				log,
-				fetcher: recording([], (url) =>
-					url === broken.subscriptionUrl
-						? new Response("gone", { status: 410 })
-						: new Response(FEED, { status: 200 }),
-				),
-			},
-			NOW,
-			INTERVAL_MS,
-		);
-
-		assert.deepEqual(tally, { refreshed: 1, failed: 1, notDue: 0 });
-		const stored = await client.calendarCollection.get(
-			broken.accountConfigId,
-			broken.calendarId,
-		);
-		assert.equal(stored.subscriptionError, "the feed answered HTTP 410");
-		assert.equal(stored.subscriptionCheckedAt, NOW);
-		const refreshed = await client.calendarCollection.get(
-			working.accountConfigId,
-			working.calendarId,
-		);
-		assert.equal(refreshed.subscriptionFetchedAt, NOW);
-		assert.ok(lines.some((line) => line.includes(broken.calendarId)));
-		assert.equal(
-			lines.some((line) => line.includes("private-feedfacecafe")),
-			false,
-		);
-	});
-});

package/src/scheduler/calendar-subscriptions.ts

@@ -1,103 +0,0 @@
-import type { RemitClient } from "@remit/backend/client";
-import {
-	type CalendarFeedFetcher,
-	isSubscriptionDue,
-	refreshCalendarSubscription,
-} from "@remit/calendar-service";
-import type {
-	ICalendarCollectionRepository,
-	ICalendarStore,
-} from "@remit/data-ports";
-import type { Logger } from "@remit/logger";
-import pMap from "p-map";
-
-const REFRESH_CONCURRENCY = 4;
-
-export interface CalendarSubscriptionTally {
-	refreshed: number;
-	failed: number;
-	notDue: number;
-}
-
-export interface CalendarSubscriptionRefreshDeps {
-	calendarCollection: Pick<
-		ICalendarCollectionRepository,
-		"listEnabledSubscriptions"
-	>;
-	calendarStore: ICalendarStore;
-	log: Logger;
-	fetcher?: CalendarFeedFetcher;
-}
-
-/**
- * Re-reads every enabled subscription whose last fetch is at least
- * `intervalMs` old. A disabled subscription is never listed, which is what
- * stops its refresh while leaving its events in place.
- *
- * One feed's failure is recorded on its own collection and counted here; it
- * never stops the others. The log names the calendar and the reason, never the
- * URL, which for a Google secret address is the whole credential.
- */
-export const refreshDueCalendarSubscriptions = async (
-	deps: CalendarSubscriptionRefreshDeps,
-	now: number,
-	intervalMs: number,
-): Promise<CalendarSubscriptionTally> => {
-	const enabled = await deps.calendarCollection.listEnabledSubscriptions();
-	const due = enabled.filter((collection) =>
-		isSubscriptionDue(collection, now, intervalMs),
-	);
-
-	const outcomes = await pMap(
-		due,
-		(collection) =>
-			refreshCalendarSubscription(
-				deps.calendarStore,
-				collection,
-				now,
-				deps.fetcher,
-			).then(
-				(refresh) => {
-					if (refresh.ok) return true;
-					deps.log.warn(
-						{ calendarId: collection.calendarId, reason: refresh.reason },
-						"Calendar subscription could not be refreshed",
-					);
-					return false;
-				},
-				(error: unknown) => {
-					deps.log.error(
-						{ calendarId: collection.calendarId, error },
-						"Calendar subscription refresh failed",
-					);
-					return false;
-				},
-			),
-		{ concurrency: REFRESH_CONCURRENCY },
-	);
-
-	return {
-		refreshed: outcomes.filter(Boolean).length,
-		failed: outcomes.filter((ok) => !ok).length,
-		notDue: enabled.length - due.length,
-	};
-};
-
-export const buildCalendarSubscriptionRefresh =
-	(
-		client: Pick<RemitClient, "calendarCollection" | "calendarStore">,
-		log: Logger,
-	): ((
-		now: number,
-		intervalMs: number,
-	) => Promise<CalendarSubscriptionTally>) =>
-	(now, intervalMs) =>
-		refreshDueCalendarSubscriptions(
-			{
-				calendarCollection: client.calendarCollection,
-				calendarStore: client.calendarStore,
-				log,
-			},
-			now,
-			intervalMs,
-		);

package/src/scheduler/config.test.ts

@@ -1,40 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import { getOfflineIntervalMs, getTickIntervalMs } from "./config.js";
-
-describe("getTickIntervalMs", () => {
-	it("defaults to 1 hour when unset", () => {
-		assert.equal(getTickIntervalMs({}), 60 * 60 * 1000);
-	});
-
-	it("reads MAILBOX_SYNC_TICK_INTERVAL_SECONDS", () => {
-		assert.equal(
-			getTickIntervalMs({ MAILBOX_SYNC_TICK_INTERVAL_SECONDS: "60" }),
-			60_000,
-		);
-	});
-
-	it("falls back to the default on a non-positive or non-numeric value", () => {
-		assert.equal(
-			getTickIntervalMs({ MAILBOX_SYNC_TICK_INTERVAL_SECONDS: "0" }),
-			60 * 60 * 1000,
-		);
-		assert.equal(
-			getTickIntervalMs({ MAILBOX_SYNC_TICK_INTERVAL_SECONDS: "nope" }),
-			60 * 60 * 1000,
-		);
-	});
-});
-
-describe("getOfflineIntervalMs", () => {
-	it("defaults to 12 hours when unset", () => {
-		assert.equal(getOfflineIntervalMs({}), 12 * 60 * 60 * 1000);
-	});
-
-	it("reads MAILBOX_SYNC_OFFLINE_INTERVAL_SECONDS", () => {
-		assert.equal(
-			getOfflineIntervalMs({ MAILBOX_SYNC_OFFLINE_INTERVAL_SECONDS: "3600" }),
-			3_600_000,
-		);
-	});
-});

package/src/scheduler/decide-due.test.ts

@@ -1,44 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import { isSyncDue } from "./decide-due.js";
-
-const OFFLINE_INTERVAL_MS = 12 * 60 * 60 * 1000;
-const NOW = 1_700_000_000_000;
-
-describe("isSyncDue", () => {
-	it("is always due when the account has never synced", () => {
-		assert.equal(isSyncDue({ accountId: "a" }, NOW, OFFLINE_INTERVAL_MS), true);
-	});
-
-	it("is due once the sync is older than the offline interval", () => {
-		const account = {
-			accountId: "a",
-			lastSyncAt: NOW - OFFLINE_INTERVAL_MS - 1,
-		};
-		assert.equal(isSyncDue(account, NOW, OFFLINE_INTERVAL_MS), true);
-	});
-
-	it("is not due within the offline interval", () => {
-		const account = {
-			accountId: "a",
-			lastSyncAt: NOW - 60_000,
-		};
-		assert.equal(isSyncDue(account, NOW, OFFLINE_INTERVAL_MS), false);
-	});
-
-	it("is due exactly at the threshold", () => {
-		const account = {
-			accountId: "a",
-			lastSyncAt: NOW - OFFLINE_INTERVAL_MS,
-		};
-		assert.equal(isSyncDue(account, NOW, OFFLINE_INTERVAL_MS), true);
-	});
-
-	it("is not due one millisecond before the threshold", () => {
-		const account = {
-			accountId: "a",
-			lastSyncAt: NOW - OFFLINE_INTERVAL_MS + 1,
-		};
-		assert.equal(isSyncDue(account, NOW, OFFLINE_INTERVAL_MS), false);
-	});
-});

package/src/scheduler/half-deleted-accounts.sqlite.test.ts

@@ -1,196 +0,0 @@
-import assert from "node:assert/strict";
-import { randomBytes } from "node:crypto";
-import { after, before, beforeEach, describe, it } from "node:test";
-import { finishHalfDeletedAccounts } from "@remit/backend/account-deletion";
-import type { RemitClient } from "@remit/backend/client";
-import { importConfig } from "@remit/config-transfer";
-import type { AccountItem } from "@remit/data-ports";
-import {
-	failingQueue,
-	type RecordingQueue,
-	recordingQueue,
-} from "@remit/data-ports/recording-queue";
-import { AccountAuthType, ConnectionState } from "@remit/domain-enums";
-import { noopLogger } from "@remit/logger";
-import { openStore } from "../test-helpers/test-world.js";
-
-let store: Awaited<ReturnType<typeof openStore>>;
-let client: RemitClient;
-
-before(async () => {
-	store = await openStore();
-	client = store.client;
-});
-
-after(() => store.close());
-
-const storedId = (): string => randomBytes(13).toString("hex").slice(0, 25);
-
-const configDocument = (accountId: string, email: string) => ({
-	kind: "reader.config",
-	schemaVersion: 1,
-	generator: {
-		app: "reader",
-		version: "v0.1.0",
-		exportedAt: "2026-08-27T09:15:00+02:00",
-	},
-	provenance: { accountConfigId: storedId(), instance: "reader.example.com" },
-	accountConfig: { name: "Imported" },
-	accounts: [
-		{
-			accountId,
-			email,
-			username: email,
-			authType: "password",
-			credentials: { required: "password" },
-			isActive: true,
-			imap: { host: "imap.example.com", port: 993, tls: true, startTls: false },
-			smtp: {
-				enabled: false,
-				host: "",
-				port: 587,
-				tls: false,
-				startTls: false,
-				username: "",
-			},
-			displayName: "",
-			muted: null,
-			composeLanguages: [],
-			signature: { plainText: "", html: "" },
-			folderRoles: [],
-			folderOverrides: [],
-			pinnedFolders: [],
-		},
-	],
-	labels: [],
-	filters: [],
-	addressFlags: [],
-});
-
-const seedAccount = (
-	accountConfigId: string,
-	name: string,
-	extra: { deletedAt?: number } = {},
-): Promise<AccountItem> =>
-	client.account.create({
-		accountConfigId,
-		username: `${name}@example.com`,
-		email: `${name}@example.com`,
-		authType: AccountAuthType.Password,
-		passwordHash: '{"ciphertext":"x"}',
-		imapHost: "imap.example.com",
-		imapPort: 993,
-		imapTls: true,
-		imapStartTls: false,
-		isActive: true,
-		connectionState: ConnectionState.Authenticated,
-		...extra,
-	});
-
-const importAccount = async (email: string): Promise<AccountItem> => {
-	const accountConfigId = storedId();
-	const accountId = storedId();
-	const outcome = await importConfig(
-		{
-			repositories: client,
-			appointFolderRole: async () => {},
-		},
-		{
-			accountConfigId,
-			userId: accountConfigId,
-			document: configDocument(accountId, email),
-			mode: "apply",
-			onExisting: "abort",
-		},
-	);
-	assert.equal(outcome.outcome, "report");
-	return client.account.get(accountId);
-};
-
-const heal = (queue: RecordingQueue) =>
-	finishHalfDeletedAccounts({
-		account: client.account,
-		configImport: client.configImport,
-		queue,
-		log: noopLogger,
-	});
-
-describe("finishing an account deleted before #1384 on scheduler start", () => {
-	let halfDeleted: AccountItem;
-	let live: AccountItem;
-	let deleted: AccountItem;
-	let imported: AccountItem;
-
-	beforeEach(async () => {
-		const accountConfigId = storedId();
-		live = await seedAccount(accountConfigId, `live-${storedId()}`);
-		halfDeleted = await seedAccount(accountConfigId, `gone-${storedId()}`);
-		await client.account.update(halfDeleted.accountId, { isActive: false });
-		deleted = await seedAccount(accountConfigId, `deleted-${storedId()}`, {
-			deletedAt: 1_700_000_000_000,
-		});
-		await client.account.update(deleted.accountId, { isActive: false });
-		imported = await importAccount(`imported-${storedId()}@example.com`);
-	});
-
-	const allAccounts = () =>
-		client.account.get([
-			halfDeleted.accountId,
-			live.accountId,
-			deleted.accountId,
-			imported.accountId,
-		]);
-
-	it("tombstones it and asks for the same purge a delete asks for", async () => {
-		const queue = recordingQueue();
-
-		await heal(queue);
-
-		const purges = queue.sent.map((message) => message.body);
-		assert.ok(
-			purges.some(
-				(body) =>
-					body.type === "AccountDataPurge" &&
-					body.accountId === halfDeleted.accountId &&
-					body.accountConfigId === halfDeleted.accountConfigId,
-			),
-		);
-		const byId = new Map(
-			(await allAccounts()).map((account) => [account.accountId, account]),
-		);
-		assert.ok(byId.get(halfDeleted.accountId)?.deletedAt);
-		assert.equal(byId.get(live.accountId)?.deletedAt, undefined);
-		assert.equal(byId.get(imported.accountId)?.deletedAt, undefined);
-		assert.equal(byId.get(deleted.accountId)?.deletedAt, 1_700_000_000_000);
-		assert.ok(
-			!purges.some((body) =>
-				[live.accountId, imported.accountId, deleted.accountId].includes(
-					String(body.accountId),
-				),
-			),
-		);
-	});
-
-	it("does nothing for it on the next start", async () => {
-		await heal(recordingQueue());
-		const queue = recordingQueue();
-
-		await heal(queue);
-
-		assert.ok(
-			!queue.sent.some(
-				(message) => message.body.accountId === halfDeleted.accountId,
-			),
-		);
-	});
-
-	it("fails the start and leaves it to be found again when the purge cannot be asked for", async () => {
-		await assert.rejects(
-			heal(failingQueue(new Error("queue unreachable"))),
-			/queue unreachable/,
-		);
-
-		const after = await client.account.get(halfDeleted.accountId);
-		assert.equal(after.deletedAt, undefined);
-	});
-});

package/src/scheduler/loop.test.ts

@@ -1,143 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import { runSchedulerLoop, type SchedulerLoopOptions } from "./loop.js";
-import type { RunSchedulerTickDeps, SchedulerTickResult } from "./run-tick.js";
-
-const RESULT: SchedulerTickResult = {
-	scanned: 0,
-	enqueued: 0,
-	skipped: 0,
-	swept: 0,
-	sweepFailed: 0,
-	subscriptionsRefreshed: 0,
-	subscriptionsFailed: 0,
-	redriven: 0,
-	redriveFailed: 0,
-};
-
-// Only the loop's own two calls matter here; the tick is a stub, so what it is
-// handed is never read.
-const TICK_DEPS = {} as RunSchedulerTickDeps;
-
-const buildLoop = (
-	overrides: Partial<SchedulerLoopOptions>,
-): SchedulerLoopOptions => ({
-	tick: () => Promise.resolve(RESULT),
-	tickDeps: TICK_DEPS,
-	heartbeat: () => Promise.resolve(),
-	onHeartbeatError: () => {},
-	tickIntervalMs: 1000,
-	wait: () => Promise.resolve(),
-	...overrides,
-});
-
-describe("runSchedulerLoop", () => {
-	it("writes no heartbeat for a tick that throws", async () => {
-		let beats = 0;
-		await assert.rejects(
-			runSchedulerLoop(
-				buildLoop({
-					tick: () => Promise.reject(new Error("tick failed")),
-					heartbeat: () => {
-						beats += 1;
-						return Promise.resolve();
-					},
-				}),
-			),
-			/tick failed/,
-		);
-		assert.equal(beats, 0);
-	});
-
-	it("beats once per completed round, and stops beating when a round stops completing", async () => {
-		let rounds = 0;
-		let beats = 0;
-		await assert.rejects(
-			runSchedulerLoop(
-				buildLoop({
-					tick: () => {
-						rounds += 1;
-						return rounds > 2
-							? Promise.reject(new Error("tick failed"))
-							: Promise.resolve(RESULT);
-					},
-					heartbeat: () => {
-						beats += 1;
-						return Promise.resolve();
-					},
-				}),
-			),
-			/tick failed/,
-		);
-		assert.equal(beats, 2);
-	});
-
-	it("keeps ticking when the heartbeat write fails", async () => {
-		const errors: unknown[] = [];
-		let rounds = 0;
-		await assert.rejects(
-			runSchedulerLoop(
-				buildLoop({
-					tick: () => {
-						rounds += 1;
-						return rounds > 3
-							? Promise.reject(new Error("done"))
-							: Promise.resolve(RESULT);
-					},
-					heartbeat: () => Promise.reject(new Error("ENOSPC")),
-					onHeartbeatError: (error) => errors.push(error),
-				}),
-			),
-			/done/,
-		);
-		assert.equal(rounds, 4);
-		assert.equal(errors.length, 3);
-	});
-
-	it("waits a tick interval between rounds", async () => {
-		const waited: number[] = [];
-		let rounds = 0;
-		await assert.rejects(
-			runSchedulerLoop(
-				buildLoop({
-					tickIntervalMs: 300_000,
-					tick: () => {
-						rounds += 1;
-						return rounds > 2
-							? Promise.reject(new Error("done"))
-							: Promise.resolve(RESULT);
-					},
-					wait: (ms) => {
-						waited.push(ms);
-						return Promise.resolve();
-					},
-				}),
-			),
-			/done/,
-		);
-		assert.deepEqual(waited, [300_000, 300_000]);
-	});
-
-	// The default is the only one production uses, so it is the one a wrong unit
-	// or a dropped argument would ship in.
-	it("sleeps the real timer when no wait is injected", async () => {
-		let rounds = 0;
-		const started = Date.now();
-		await assert.rejects(
-			runSchedulerLoop({
-				...buildLoop({
-					tickIntervalMs: 25,
-					tick: () => {
-						rounds += 1;
-						return rounds > 2
-							? Promise.reject(new Error("done"))
-							: Promise.resolve(RESULT);
-					},
-				}),
-				wait: undefined,
-			}),
-			/done/,
-		);
-		assert.ok(Date.now() - started >= 50);
-	});
-});