@remit/imap-worker 0.0.89 → 0.0.91

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);
-	});
-});

package/src/scheduler/run-tick.sqlite.test.ts

@@ -1,191 +0,0 @@
-import assert from "node:assert/strict";
-import { afterEach, beforeEach, describe, it } from "node:test";
-import type { AccountItem } from "@remit/data-ports";
-import { recordingQueue } from "@remit/data-ports/recording-queue";
-import {
-	AccountAuthType,
-	AccountService,
-	ConnectionState,
-} from "@remit/domain-enums";
-import {
-	type AccountRepo,
-	createSqliteRepositories,
-} from "@remit/drizzle-service";
-import { createShippedSqliteDb } from "@remit/drizzle-service/test-sqlite";
-import { capturingLogger, type LogLine } from "../test-helpers/test-world.js";
-import { runSchedulerTick } from "./run-tick.js";
-
-const TICK_INTERVAL_MS = 60 * 60 * 1000;
-const OFFLINE_INTERVAL_MS = 12 * 60 * 60 * 1000;
-const NOW = 1_700_000_000_000;
-
-let accounts: AccountRepo;
-let close: () => void;
-
-beforeEach(() => {
-	const store = createShippedSqliteDb();
-	close = store.close;
-	accounts = createSqliteRepositories({
-		app: store.db,
-		mail: store.db,
-		search: store.db,
-	}).account;
-});
-
-afterEach(() => close());
-
-const account = async (
-	name: string,
-	overrides: Partial<AccountItem> = {},
-	stored: { credential: boolean } = { credential: true },
-): Promise<AccountItem> => {
-	const created = await accounts.create({
-		accountConfigId: `cfg-${name}`,
-		username: `${name}@example.com`,
-		email: `${name}@example.com`,
-		authType: AccountAuthType.Password,
-		passwordHash: stored.credential ? '{"ciphertext":"x"}' : undefined,
-		imapHost: "imap.example.com",
-		imapPort: 993,
-		imapTls: true,
-		imapStartTls: false,
-		isActive: true,
-		connectionState: ConnectionState.Authenticated,
-	} as Parameters<AccountRepo["create"]>[0]);
-	if (Object.keys(overrides).length === 0) return created;
-	await accounts.update(created.accountId, overrides);
-	return accounts.get(created.accountId);
-};
-
-const tick = async (
-	options: Partial<Parameters<typeof runSchedulerTick>[0]> = {},
-) => {
-	const queue = recordingQueue();
-	const { sent } = queue;
-	const logs: LogLine[] = [];
-	const result = await runSchedulerTick({
-		accountService: accounts,
-		queue,
-		log: capturingLogger(logs),
-		tickIntervalMs: TICK_INTERVAL_MS,
-		offlineIntervalMs: OFFLINE_INTERVAL_MS,
-		now: NOW,
-		redriveStrandedPlacements: async () => 0,
-		...options,
-	});
-	const enqueued = sent.map((message) => String(message.body.accountId));
-	return { result, sent, enqueued, logs };
-};
-
-describe("a scheduler tick", () => {
-	it("enqueues the accounts that are due and only those", async () => {
-		const due = await account("due", {
-			lastSyncAt: NOW - OFFLINE_INTERVAL_MS - 1,
-		});
-		const never = await account("never");
-		await account("fresh", { lastSyncAt: NOW - 60_000 });
-
-		const { enqueued } = await tick();
-
-		assert.deepEqual(enqueued.sort(), [due.accountId, never.accountId].sort());
-	});
-
-	it("skips an account it cannot or should not sync, and says so once in aggregate", async () => {
-		const live = await account("live");
-		await account("unsyncable", { imapHost: "mail.invalid" });
-		await account("reauth", {
-			connectionState: ConnectionState.ReauthRequired,
-		});
-		await account("calendar", { syncedServices: [AccountService.Calendar] });
-
-		const { enqueued, result, logs } = await tick();
-
-		assert.deepEqual(enqueued, [live.accountId]);
-		assert.equal(result.skipped, 3);
-		assert.equal(logs.length, 1, "one aggregate line, no per-account noise");
-	});
-
-	// Issue #1120: a sync for an account with no stored credential fenced the
-	// account's FIFO group for its whole visibility timeout.
-	it("skips an account that stores no credential", async () => {
-		const live = await account("live");
-		await account("missing", {}, { credential: false });
-
-		const { enqueued } = await tick();
-
-		assert.deepEqual(enqueued, [live.accountId]);
-	});
-
-	it("gives each enqueued account a scheduler-namespaced, time-bucketed dedup id", async () => {
-		const live = await account("live");
-
-		const { sent } = await tick();
-
-		const dedupId = sent[0]?.deduplicationId;
-		assert.ok(
-			dedupId?.startsWith(`SYNC_MAILBOXES:scheduled:${live.accountId}:`),
-		);
-	});
-
-	it("sweeps every account's attachments, due a sync or not", async () => {
-		const due = await account("due");
-		const fresh = await account("fresh", { lastSyncAt: NOW - 60_000 });
-		const swept: string[] = [];
-
-		const { result } = await tick({
-			sweepAttachments: async (item) => {
-				swept.push(item.accountId);
-			},
-		});
-
-		assert.deepEqual(swept.sort(), [due.accountId, fresh.accountId].sort());
-		assert.equal(result.swept, 2);
-	});
-
-	// Uncontained, one storage error reaches the loop, which exits, and the
-	// container restarts without ever enqueuing an account again.
-	it("keeps enqueuing mail when the attachment sweep throws", async () => {
-		const live = await account("live");
-
-		const { enqueued, result } = await tick({
-			sweepAttachments: async () => {
-				throw new Error("AccessDenied on ListObjectsV2");
-			},
-		});
-
-		assert.deepEqual(enqueued, [live.accountId]);
-		assert.equal(result.sweepFailed, 1);
-	});
-
-	it("keeps the tick alive when the calendar subscription refresh throws", async () => {
-		const live = await account("live");
-
-		const { enqueued, logs } = await tick({
-			refreshCalendarSubscriptions: async () => {
-				throw new Error("database is locked");
-			},
-		});
-
-		assert.deepEqual(enqueued, [live.accountId]);
-		assert.ok(logs.some((line) => line.level === "error"));
-	});
-
-	it("counts what each account re-drove and keeps enqueuing past one that fails", async () => {
-		const live = await account("live");
-		const busy = await account("busy");
-
-		const { enqueued, result, logs } = await tick({
-			redriveStrandedPlacements: async (redriven) => {
-				if (redriven.accountId === busy.accountId) {
-					throw new Error("SQLITE_BUSY");
-				}
-				return 2;
-			},
-		});
-
-		assert.deepEqual(enqueued.sort(), [live.accountId, busy.accountId].sort());
-		assert.equal(result.redriven, 2);
-		assert.equal(result.redriveFailed, 1);
-		assert.ok(logs.some((line) => line.level === "error"));
-	});
-});

package/src/scheduler/run-tick.ts

@@ -1,281 +0,0 @@
-import {
-	buildScheduledSyncDedupId,
-	type SyncMailboxesEvent,
-	triggerAccountSync,
-} from "@remit/backend/trigger-sync";
-import type {
-	AccountItem,
-	FifoQueueProducer,
-	IAccountRepository,
-} from "@remit/data-ports";
-import type { Logger } from "@remit/logger";
-import { hasStoredCredential } from "@remit/mailbox-service/account-credentials";
-import pMap from "p-map";
-import {
-	isAccountDeleted,
-	isAccountReauthRequired,
-	isMailSyncDisabled,
-	isUnsyncableHost,
-} from "../account-check.js";
-import type { CalendarSubscriptionTally } from "./calendar-subscriptions.js";
-import {
-	SCHEDULER_ENQUEUE_CONCURRENCY,
-	SCHEDULER_PAGE_SIZE,
-} from "./config.js";
-import { isSyncDue } from "./decide-due.js";
-
-export interface RunSchedulerTickDeps {
-	accountService: Pick<IAccountRepository, "listAllAccountsPage">;
-	queue: FifoQueueProducer<SyncMailboxesEvent>;
-	log: Logger;
-	offlineIntervalMs: number;
-	/**
-	 * How often this tick itself runs — the dedup-id bucket width for
-	 * `buildScheduledSyncDedupId`, so consecutive ticks each get a fresh id.
-	 */
-	tickIntervalMs: number;
-	/** Injectable for tests; defaults to `Date.now()`. */
-	now?: number;
-	/**
-	 * Collect attachment bytes the database does not know about, for one account.
-	 *
-	 * The tick already walks every account on a cadence, which is the only thing
-	 * this needs. It exists because an upload URL minted for a draft stays valid
-	 * after that draft is discarded, and where the browser writes straight to
-	 * block storage nothing is in the path to refuse it — see
-	 * `sweepAbandonedOutboxAttachments`. Optional only so a test can leave it out;
-	 * both real entry points pass it.
-	 */
-	sweepAttachments?: (account: AccountItem) => Promise<void>;
-	/**
-	 * Re-read the calendar subscriptions whose last fetch is older than
-	 * `offlineIntervalMs` — the same knob that says how stale mail may get.
-	 * Optional only so a test can leave it out; both real entry points pass it.
-	 */
-	refreshCalendarSubscriptions?: (
-		now: number,
-		intervalMs: number,
-	) => Promise<CalendarSubscriptionTally>;
-	redriveStrandedPlacements: (
-		account: AccountItem,
-		now: number,
-	) => Promise<number>;
-}
-
-export interface SchedulerTickResult {
-	scanned: number;
-	enqueued: number;
-	skipped: number;
-	swept: number;
-	sweepFailed: number;
-	subscriptionsRefreshed: number;
-	subscriptionsFailed: number;
-	redriven: number;
-	redriveFailed: number;
-}
-
-/**
- * `isAccountDeleted` / `isUnsyncableHost` / `isAccountReauthRequired` each log
- * one line per ineligible account — the right volume for their real call site
- * (once per SYNC_MAILBOXES event). Run across the whole account base every
- * tick, that becomes one log line per deleted/reauth/placeholder account
- * every 5 minutes, forever (review #1250). The tick already reports the
- * aggregate `skipped` count, so eligibility checks here go through a silent
- * logger — the per-event path (sync-mailboxes.ts) is untouched and keeps
- * logging normally.
- */
-const silentLogger: Logger = (() => {
-	const noop = () => {};
-	const stub = {
-		info: noop,
-		warn: noop,
-		error: noop,
-		debug: noop,
-		fatal: noop,
-		trace: noop,
-		child: () => stub,
-	};
-	return stub as unknown as Logger;
-})();
-
-const isEligible = (account: AccountItem): boolean => {
-	if (isAccountDeleted(account, silentLogger)) return false;
-	if (isMailSyncDisabled(account, silentLogger)) return false;
-	if (isUnsyncableHost(account, silentLogger)) return false;
-	if (isAccountReauthRequired(account, silentLogger)) return false;
-	// An account storing no credential can only produce a sync that fails at
-	// credential resolution (issue #1120); the tick would enqueue one every
-	// tick, forever, for an account the user never finished setting up.
-	if (!hasStoredCredential(account)) return false;
-	return true;
-};
-
-/**
- * One tick of the periodic mailbox-sync scheduler (#1247, restructured
- * #1251). Pages through every account (never loading the whole account base
- * into memory), decides per account via `isSyncDue` against the single
- * offline threshold, and enqueues SYNC_MAILBOXES for the accounts that are
- * due — in bounded-concurrency batches, never an unbounded `Promise.all`.
- *
- * Every enqueue goes through the same `triggerAccountSync` the manual
- * POST /sync path uses, with a scheduler-specific, time-bucketed dedup id
- * (`buildScheduledSyncDedupId`, bucketed by `tickIntervalMs`) so this tick
- * can never collide with its own previous tick or with a concurrent manual
- * trigger (see trigger-sync.ts). Concurrent-sync safety for the mailbox
- * itself is MailboxLockService's job, inside the worker handler — this tick
- * only decides "is a sync due" and enqueues; it never talks to IMAP.
- */
-export const runSchedulerTick = async (
-	deps: RunSchedulerTickDeps,
-): Promise<SchedulerTickResult> => {
-	const { accountService, queue, log, offlineIntervalMs, tickIntervalMs } =
-		deps;
-	const now = deps.now ?? Date.now();
-
-	let cursor: string | undefined;
-	let scanned = 0;
-	let enqueued = 0;
-	let skipped = 0;
-	let swept = 0;
-	let sweepFailed = 0;
-	let redriven = 0;
-	let redriveFailed = 0;
-
-	do {
-		const page = await accountService.listAllAccountsPage({
-			limit: SCHEDULER_PAGE_SIZE,
-			cursor,
-		});
-		scanned += page.items.length;
-
-		const due = page.items.filter(
-			(account) =>
-				isEligible(account) && isSyncDue(account, now, offlineIntervalMs),
-		);
-		skipped += page.items.length - due.length;
-
-		await pMap(
-			due,
-			(account) =>
-				triggerAccountSync({
-					queue,
-					accountId: account.accountId,
-					dedupId: buildScheduledSyncDedupId(
-						account.accountId,
-						now,
-						tickIntervalMs,
-					),
-				}),
-			{ concurrency: SCHEDULER_ENQUEUE_CONCURRENCY },
-		);
-		enqueued += due.length;
-
-		if (deps.sweepAttachments) {
-			// After the enqueue, never before it. Enqueuing mail is the tick's job
-			// and collecting bytes is housekeeping; on a hosted Lambda a slow sweep
-			// ahead of the enqueue eats the invocation budget, and a timeout is not
-			// catchable, so the remaining pages would never be enqueued at all.
-			//
-			// Every account, not only the ones due a sync: abandoned bytes have
-			// nothing to do with how recently mail was fetched. Bounded to the same
-			// concurrency as the enqueues.
-			//
-			// Contained, because this is housekeeping and enqueuing mail is not. An
-			// unreadable input or a storage permission error thrown from here would
-			// otherwise reach the loop, which logs and exits, and compose would
-			// restart the process every five seconds — no account would ever be
-			// enqueued again. A failed sweep costs a tick's collection and nothing
-			// else; the count is what makes that visible.
-			const sweep = deps.sweepAttachments;
-			const outcomes = await pMap(
-				page.items,
-				(account) =>
-					sweep(account).then(
-						() => true,
-						(error: unknown) => {
-							log.error(
-								{ accountId: account.accountId, error },
-								"Outbox attachment sweep failed for account",
-							);
-							return false;
-						},
-					),
-				{ concurrency: SCHEDULER_ENQUEUE_CONCURRENCY },
-			);
-			swept += outcomes.filter(Boolean).length;
-			sweepFailed += outcomes.filter((ok) => !ok).length;
-		}
-
-		// Contained like the sweep, and for the same reason: a failed re-drive
-		// costs one account this tick, never the scheduler. Eligible accounts
-		// only, since a re-driven event needs a connection to settle anything.
-		const redrives = await pMap(
-			page.items.filter(isEligible),
-			(account) =>
-				deps.redriveStrandedPlacements(account, now).then(
-					(count) => count,
-					(error: unknown) => {
-						log.error(
-							{ accountId: account.accountId, error },
-							"Stranded placement re-drive failed for account",
-						);
-						return null;
-					},
-				),
-			{ concurrency: SCHEDULER_ENQUEUE_CONCURRENCY },
-		);
-		for (const count of redrives) {
-			if (count === null) {
-				redriveFailed += 1;
-				continue;
-			}
-			redriven += count;
-		}
-
-		cursor = page.cursor ?? undefined;
-	} while (cursor);
-
-	let subscriptionsRefreshed = 0;
-	let subscriptionsFailed = 0;
-	if (deps.refreshCalendarSubscriptions) {
-		// After every page is enqueued, for the same reason the sweep runs after
-		// the enqueue: a slow feed must never cost an account its mail. Contained
-		// like the sweep, so an unreadable store costs a tick's refresh and not
-		// the scheduler.
-		const tally = await deps
-			.refreshCalendarSubscriptions(now, offlineIntervalMs)
-			.catch((error: unknown) => {
-				log.error({ error }, "Calendar subscription refresh failed");
-				return { refreshed: 0, failed: 0, notDue: 0 };
-			});
-		subscriptionsRefreshed = tally.refreshed;
-		subscriptionsFailed = tally.failed;
-	}
-
-	log.info(
-		{
-			scanned,
-			enqueued,
-			skipped,
-			swept,
-			sweepFailed,
-			subscriptionsRefreshed,
-			subscriptionsFailed,
-			redriven,
-			redriveFailed,
-		},
-		"Scheduled-sync tick complete",
-	);
-
-	return {
-		scanned,
-		enqueued,
-		skipped,
-		swept,
-		sweepFailed,
-		subscriptionsRefreshed,
-		subscriptionsFailed,
-		redriven,
-		redriveFailed,
-	};
-};