@remit/drizzle-service 0.0.87 → 0.0.89

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/drizzle-service",
-  "version": "0.0.87",
+  "version": "0.0.89",
   "description": "Drizzle ORM service over SQLite",
   "type": "module",
   "main": "src/index.ts",

package/src/account-granted-scopes-migration.sqlite.test.ts

@@ -0,0 +1,66 @@
+import assert from "node:assert/strict";
+import { describe, test } from "node:test";
+import Database from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+import { AccountRepo } from "./repos/i4-account.js";
+import { accountTable } from "./schema.js";
+import {
+	applyMigration,
+	migrationJournal,
+} from "./test-shipped-sqlite-schema.js";
+
+const MIGRATION = "0032_account_granted_scopes";
+
+const atPredecessor = (): Database.Database => {
+	const sqlite = new Database(":memory:");
+	for (const entry of migrationJournal()) {
+		if (entry.tag === MIGRATION) return sqlite;
+		applyMigration(sqlite, entry.tag);
+	}
+	throw new Error(`${MIGRATION} is not in the journal`);
+};
+
+const migrateOnward = (sqlite: Database.Database): void => {
+	const tags = migrationJournal().map((entry) => entry.tag);
+	for (const tag of tags.slice(tags.indexOf(MIGRATION))) {
+		applyMigration(sqlite, tag);
+	}
+};
+
+const insertAccount = (
+	sqlite: Database.Database,
+	accountId: string,
+	authType: string,
+): void => {
+	sqlite
+		.prepare(
+			`INSERT INTO account (
+				account_id, account_config_id, username, email, auth_type,
+				imap_host, imap_port, imap_tls, imap_start_tls, smtp_port,
+				is_active, connection_state, created_at, updated_at
+			) VALUES (?, 'config', 'person', 'person@example.com', ?,
+				'outlook.office365.com', 993, 1, 0, 587, 1,
+				'not_authenticated', 0, 0)`,
+		)
+		.run(accountId, authType);
+};
+
+describe("an account written before granted scopes were recorded", () => {
+	test("a Microsoft account holds the mail grant its consent always asked for", async () => {
+		const sqlite = atPredecessor();
+		insertAccount(sqlite, "microsoft", "oauthMicrosoft");
+		insertAccount(sqlite, "password", "password");
+
+		migrateOnward(sqlite);
+
+		const repo = new AccountRepo(
+			drizzle(sqlite, { schema: { accounts: accountTable } }) as never,
+		);
+		assert.deepEqual((await repo.get("microsoft")).grantedScopes, [
+			"https://outlook.office.com/IMAP.AccessAsUser.All",
+			"https://outlook.office.com/SMTP.Send",
+		]);
+		assert.deepEqual((await repo.get("password")).grantedScopes, []);
+		sqlite.close();
+	});
+});

package/src/account-synced-services-migration.sqlite.test.ts

@@ -21,6 +21,13 @@ const atPredecessor = (): Database.Database => {
 	throw new Error(`${MIGRATION} is not in the journal`);
 };
 
+const migrateOnward = (sqlite: Database.Database): void => {
+	const tags = migrationJournal().map((entry) => entry.tag);
+	for (const tag of tags.slice(tags.indexOf(MIGRATION))) {
+		applyMigration(sqlite, tag);
+	}
+};
+
 describe("an account written before the service selection existed", () => {
 	test("comes out of the migration syncing mail only", async () => {
 		const sqlite = atPredecessor();
@@ -36,7 +43,7 @@ describe("an account written before the service selection existed", () => {
 			)
 			.run();
 
-		applyMigration(sqlite, MIGRATION);
+		migrateOnward(sqlite);
 
 		const repo = new AccountRepo(
 			drizzle(sqlite, { schema: { accounts: accountTable } }) as never,

package/src/mailbox-path-dedupe.sqlite.test.ts

@@ -0,0 +1,436 @@
+import assert from "node:assert/strict";
+import { describe, test } from "node:test";
+import * as entities from "@remit/drizzle-sqlite-schema";
+import Database from "better-sqlite3";
+import { asc, eq } from "drizzle-orm";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+import type { Db } from "./db.js";
+import {
+	PARKED_MAILBOX_ID,
+	sweepDuplicateMailboxMail,
+} from "./repair/duplicate-mailbox-mail.js";
+import { MESSAGE_REMOVED_EVENT } from "./repos/message.js";
+import { outboxTable } from "./schema/outbox.js";
+import {
+	applyMigration,
+	migrationJournal,
+} from "./test-shipped-sqlite-schema.js";
+
+const DEDUPE = "0030_mailbox_path_dedupe";
+const UNIQUE = "0031_mailbox_path_unique";
+const ACCOUNT = "acct";
+const CONFIG = "cfg";
+
+type Handle = { sqlite: Database.Database; db: Db<Record<string, unknown>> };
+
+const atPredecessor = (): Handle => {
+	const sqlite = new Database(":memory:");
+	for (const entry of migrationJournal()) {
+		if (entry.tag === DEDUPE) {
+			return {
+				sqlite,
+				db: drizzle(sqlite) as unknown as Db<Record<string, unknown>>,
+			};
+		}
+		applyMigration(sqlite, entry.tag);
+	}
+	throw new Error(`${DEDUPE} is not in the journal`);
+};
+
+const seedMailbox = async (
+	{ db }: Handle,
+	mailboxId: string,
+	fullPath: string,
+	createdAt: number,
+	over: Partial<typeof entities.mailboxes.$inferInsert> = {},
+): Promise<void> => {
+	await db.insert(entities.mailboxes).values({
+		mailboxId,
+		accountId: ACCOUNT,
+		namespacePrefix: "",
+		hierarchyDelimiter: "/",
+		fullPath,
+		uidValidity: 1,
+		uidNext: 1,
+		highestModseq: "0",
+		messageCount: 0,
+		unseenCount: 0,
+		deletedCount: 0,
+		totalSize: 0,
+		lastSyncUid: 0,
+		highWaterMarkUid: 0,
+		lastMessageSyncAt: 0,
+		createdAt,
+		updatedAt: createdAt,
+		...over,
+	});
+};
+
+const seedMessage = async (
+	{ db }: Handle,
+	messageId: string,
+	mailboxId: string,
+	uid = 1,
+): Promise<void> => {
+	await db.insert(entities.messages).values({
+		messageId,
+		mailboxId,
+		uid,
+		sequenceNumber: uid,
+		rfc822Size: 1,
+		internalDate: 0,
+		envelopeId: `env-${messageId}`,
+		rootBodyPartId: `bp-${messageId}`,
+		createdAt: 0,
+		updatedAt: 0,
+	});
+	await db.insert(entities.threadMessages).values({
+		threadMessageId: `tm-${messageId}`,
+		threadId: `thread-${messageId}`,
+		messageId,
+		accountConfigId: CONFIG,
+		mailboxId,
+		uid,
+		referenceOrder: 0,
+		internalDate: 0,
+		sentDate: 0,
+		isRead: false,
+		hasAttachment: false,
+		hasStars: false,
+		isDeleted: false,
+		createdAt: 0,
+		updatedAt: 0,
+	});
+};
+
+const seedSetting = async (
+	{ db }: Handle,
+	name: string,
+	value: typeof entities.accountSettings.$inferInsert.value,
+): Promise<void> => {
+	await db.insert(entities.accountSettings).values({
+		accountSettingId: name,
+		accountConfigId: CONFIG,
+		name,
+		value,
+		createdAt: 0,
+		updatedAt: 0,
+	});
+};
+
+const dedupe = (handle: Handle): void => {
+	applyMigration(handle.sqlite, DEDUPE);
+	applyMigration(handle.sqlite, UNIQUE);
+};
+
+const mailboxIds = async ({ db }: Handle): Promise<string[]> =>
+	(
+		await db
+			.select({ mailboxId: entities.mailboxes.mailboxId })
+			.from(entities.mailboxes)
+			.orderBy(asc(entities.mailboxes.mailboxId))
+	).map((row) => row.mailboxId);
+
+const messagesIn = async ({ db }: Handle, mailboxId: string): Promise<number> =>
+	(
+		await db
+			.select({ messageId: entities.messages.messageId })
+			.from(entities.messages)
+			.where(eq(entities.messages.mailboxId, mailboxId))
+	).length;
+
+const threadsIn = async ({ db }: Handle, mailboxId: string): Promise<number> =>
+	(
+		await db
+			.select({ messageId: entities.threadMessages.messageId })
+			.from(entities.threadMessages)
+			.where(eq(entities.threadMessages.mailboxId, mailboxId))
+	).length;
+
+const survivorCursor = async ({ db }: Handle, mailboxId: string) => {
+	const [row] = await db
+		.select({
+			lastSyncUid: entities.mailboxes.lastSyncUid,
+			highWaterMarkUid: entities.mailboxes.highWaterMarkUid,
+			highestModseq: entities.mailboxes.highestModseq,
+		})
+		.from(entities.mailboxes)
+		.where(eq(entities.mailboxes.mailboxId, mailboxId));
+	return row;
+};
+
+describe("(account_id, full_path) becomes unique", () => {
+	test("the loser's mail moves onto the survivor, so none of it is lost", async () => {
+		const handle = atPredecessor();
+		const cursor = {
+			lastSyncUid: 1,
+			highWaterMarkUid: 105,
+			highestModseq: "900",
+		};
+		await seedMailbox(handle, "a", "Archive", 1, cursor);
+		await seedMailbox(handle, "b", "Archive", 2, cursor);
+		for (let uid = 1; uid <= 100; uid++) {
+			await seedMessage(handle, `a-${uid}`, "a", uid);
+		}
+		for (let uid = 101; uid <= 105; uid++) {
+			await seedMessage(handle, `b-${uid}`, "b", uid);
+		}
+
+		dedupe(handle);
+
+		assert.deepEqual(await mailboxIds(handle), ["a"]);
+		assert.equal(await messagesIn(handle, "a"), 105);
+		assert.equal(await threadsIn(handle, "a"), 105);
+		assert.equal(await messagesIn(handle, PARKED_MAILBOX_ID), 0);
+		assert.deepEqual(await survivorCursor(handle, "a"), cursor);
+		handle.sqlite.close();
+	});
+
+	test("what named the loser follows the survivor", async () => {
+		const handle = atPredecessor();
+		await seedMailbox(handle, "older-empty", "INBOX/Notifications", 1);
+		await seedMailbox(handle, "with-mail", "INBOX/Notifications", 2);
+		await seedMailbox(handle, "child", "INBOX/Notifications/Old", 3);
+		await seedMailbox(handle, "elsewhere", "Receipts", 4);
+		await seedMessage(handle, "m1", "with-mail");
+		await seedMessage(handle, "copied", "elsewhere");
+		await handle.db
+			.update(entities.messages)
+			.set({ originalMailboxId: "older-empty" })
+			.where(eq(entities.messages.messageId, "copied"));
+		await handle.db
+			.update(entities.mailboxes)
+			.set({ parentMailboxId: "older-empty" })
+			.where(eq(entities.mailboxes.mailboxId, "child"));
+		await handle.db.insert(entities.filters).values({
+			filterId: "f1",
+			accountConfigId: CONFIG,
+			name: "Alerts",
+			scope: "Standing",
+			ruleChangedAt: 0,
+			actionChangedAt: 0,
+			actionMailboxId: "older-empty",
+			createdAt: 0,
+			updatedAt: 0,
+		});
+		await handle.db.insert(entities.organizeJobRequests).values({
+			organizeJobId: "job-1",
+			accountConfigId: CONFIG,
+			userId: "user",
+			actionMailboxId: "older-empty",
+			ttl: 0,
+			createdAt: 0,
+			updatedAt: 0,
+		});
+		await handle.db.insert(entities.messagePlacementMoves).values({
+			messageId: "copied",
+			accountId: ACCOUNT,
+			accountConfigId: CONFIG,
+			sourceMailboxId: "elsewhere",
+			destinationMailboxId: "older-empty",
+			createdAt: 0,
+			updatedAt: 0,
+		});
+		await seedSetting(handle, "FolderRoleAppointment#acct#Archive", {
+			kind: "String",
+			value: "older-empty",
+		});
+		await handle.db.insert(entities.mailboxFlags).values({
+			mailboxFlagId: "flag-1",
+			mailboxId: "older-empty",
+			flagName: "\\Seen",
+			isPermanent: true,
+		});
+
+		dedupe(handle);
+
+		assert.deepEqual(await mailboxIds(handle), [
+			"child",
+			"elsewhere",
+			"with-mail",
+		]);
+		const [child] = await handle.db
+			.select({ parent: entities.mailboxes.parentMailboxId })
+			.from(entities.mailboxes)
+			.where(eq(entities.mailboxes.mailboxId, "child"));
+		assert.equal(child?.parent, "with-mail");
+		const [filter] = await handle.db.select().from(entities.filters);
+		assert.equal(filter?.actionMailboxId, "with-mail");
+		const [job] = await handle.db.select().from(entities.organizeJobRequests);
+		assert.equal(job?.actionMailboxId, "with-mail");
+		const [copied] = await handle.db
+			.select({ original: entities.messages.originalMailboxId })
+			.from(entities.messages)
+			.where(eq(entities.messages.messageId, "copied"));
+		assert.equal(copied?.original, "with-mail");
+		const [move] = await handle.db
+			.select()
+			.from(entities.messagePlacementMoves);
+		assert.equal(move?.destinationMailboxId, "with-mail");
+		const [setting] = await handle.db.select().from(entities.accountSettings);
+		assert.deepEqual(setting?.value, { kind: "String", value: "with-mail" });
+		assert.deepEqual(await handle.db.select().from(entities.mailboxFlags), []);
+		const index = (
+			handle.sqlite.prepare("PRAGMA index_list(mailbox)").all() as Array<{
+				name: string;
+				unique: number;
+			}>
+		).find((entry) => entry.name === "mailbox_by_account_full_path");
+		assert.equal(index?.unique, 1);
+		handle.sqlite.close();
+	});
+
+	test("a muted losing folder stays muted, and the survivor's own name is kept", async () => {
+		const handle = atPredecessor();
+		await seedMailbox(handle, "survivor", "Newsletters", 1);
+		await seedMailbox(handle, "loser", "Newsletters", 2);
+		await seedSetting(handle, "MailboxMuted#loser", {
+			kind: "Muted",
+			value: true,
+		});
+		await seedSetting(handle, "MailboxDisplayName#loser", {
+			kind: "String",
+			value: "Loser name",
+		});
+		await seedSetting(handle, "MailboxDisplayName#survivor", {
+			kind: "String",
+			value: "Survivor name",
+		});
+
+		dedupe(handle);
+
+		const settings = await handle.db
+			.select({
+				name: entities.accountSettings.name,
+				value: entities.accountSettings.value,
+			})
+			.from(entities.accountSettings)
+			.orderBy(asc(entities.accountSettings.name));
+		assert.deepEqual(settings, [
+			{
+				name: "MailboxDisplayName#survivor",
+				value: { kind: "String", value: "Survivor name" },
+			},
+			{ name: "MailboxMuted#survivor", value: { kind: "Muted", value: true } },
+		]);
+		handle.sqlite.close();
+	});
+
+	test("the survivor is chosen by the mail it holds, not by message_count", async () => {
+		const handle = atPredecessor();
+		await seedMailbox(handle, "claims-mail", "Archive", 1, {
+			messageCount: 500,
+		});
+		await seedMailbox(handle, "holds-mail", "Archive", 2);
+		await seedMessage(handle, "m1", "holds-mail", 1);
+		await seedMessage(handle, "m2", "holds-mail", 2);
+
+		dedupe(handle);
+
+		assert.deepEqual(await mailboxIds(handle), ["holds-mail"]);
+		handle.sqlite.close();
+	});
+
+	test("with equal mail the oldest row survives", async () => {
+		const handle = atPredecessor();
+		await seedMailbox(handle, "a-newer", "Archive", 2);
+		await seedMailbox(handle, "b-older", "Archive", 1);
+
+		dedupe(handle);
+
+		assert.deepEqual(await mailboxIds(handle), ["b-older"]);
+		handle.sqlite.close();
+	});
+
+	test("with equal mail and age the lowest mailbox_id survives", async () => {
+		const handle = atPredecessor();
+		await seedMailbox(handle, "b", "Archive", 1);
+		await seedMailbox(handle, "a", "Archive", 1);
+
+		dedupe(handle);
+
+		assert.deepEqual(await mailboxIds(handle), ["a"]);
+		handle.sqlite.close();
+	});
+
+	test("mail the survivor already holds at that uid is parked, removed at boot, and re-fetched", async () => {
+		const handle = atPredecessor();
+		const cursor = {
+			lastSyncUid: 1,
+			highWaterMarkUid: 9,
+			highestModseq: "900",
+		};
+		await seedMailbox(handle, "older", "Archive", 1, cursor);
+		await seedMailbox(handle, "newer", "Archive", 2, cursor);
+		await seedMessage(handle, "kept", "older", 7);
+		await seedMessage(handle, "stale", "newer", 7);
+		await seedMessage(handle, "unrelated", "no-such-folder", 1);
+
+		dedupe(handle);
+
+		assert.deepEqual(await mailboxIds(handle), ["older"]);
+		assert.equal(await messagesIn(handle, PARKED_MAILBOX_ID), 1);
+		assert.equal(await threadsIn(handle, PARKED_MAILBOX_ID), 1);
+		assert.deepEqual(await survivorCursor(handle, "older"), {
+			lastSyncUid: 0,
+			highWaterMarkUid: 0,
+			highestModseq: "0",
+		});
+
+		const report = await sweepDuplicateMailboxMail(handle.db, "repair");
+
+		assert.deepEqual(report, {
+			mode: "repair",
+			duplicatePaths: 0,
+			parked: 1,
+			removed: 1,
+		});
+		const messages = await handle.db
+			.select({ messageId: entities.messages.messageId })
+			.from(entities.messages)
+			.orderBy(asc(entities.messages.messageId));
+		assert.deepEqual(messages, [
+			{ messageId: "kept" },
+			{ messageId: "unrelated" },
+		]);
+		const events = await handle.db
+			.select({ messageId: outboxTable.messageId, event: outboxTable.event })
+			.from(outboxTable);
+		assert.deepEqual(events, [
+			{ messageId: "stale", event: MESSAGE_REMOVED_EVENT },
+		]);
+		assert.deepEqual(await sweepDuplicateMailboxMail(handle.db, "repair"), {
+			mode: "repair",
+			duplicatePaths: 0,
+			parked: 0,
+			removed: 0,
+		});
+		handle.sqlite.close();
+	});
+
+	test("the check before migrating reports the paths the migration will merge", async () => {
+		const handle = atPredecessor();
+		await seedMailbox(handle, "a", "Archive", 1);
+		await seedMailbox(handle, "b", "Archive", 2);
+
+		assert.deepEqual(await sweepDuplicateMailboxMail(handle.db, "check"), {
+			mode: "check",
+			duplicatePaths: 1,
+			parked: 0,
+			removed: 0,
+		});
+		handle.sqlite.close();
+	});
+
+	test("the unique index is refused without the dedupe ahead of it", async () => {
+		const handle = atPredecessor();
+		await seedMailbox(handle, "a", "Archive", 1);
+		await seedMailbox(handle, "b", "Archive", 2);
+
+		assert.throws(
+			() => applyMigration(handle.sqlite, UNIQUE),
+			/UNIQUE constraint failed/,
+		);
+		handle.sqlite.close();
+	});
+});

package/src/repair/duplicate-mailbox-mail.ts

@@ -0,0 +1,98 @@
+import { count, eq, gt, inArray } from "drizzle-orm";
+import type { Db } from "../db.js";
+import { deleteMessageSubtree } from "../repos/message.js";
+import { mailboxTable } from "../schema/i4-mailbox.js";
+import { messageTable } from "../schema/message-data.js";
+import { threadMessageTable } from "../schema/thread-message.js";
+import { messageLabelTable } from "../schema.js";
+import { runInTransaction } from "../tx.js";
+
+export const PARKED_MAILBOX_ID = "DuplicateMailboxRemoved";
+
+type DuplicateMailDb = Db<Record<string, unknown>>;
+
+export type DuplicateMailRepairMode = "check" | "repair";
+
+export type DuplicateMailReport = {
+	readonly mode: DuplicateMailRepairMode;
+	readonly duplicatePaths: number;
+	readonly parked: number;
+	readonly removed: number;
+};
+
+const BATCH_SIZE = 100;
+
+const countDuplicatePaths = async (db: DuplicateMailDb): Promise<number> => {
+	const groups = await db
+		.select({ rows: count() })
+		.from(mailboxTable)
+		.groupBy(mailboxTable.accountId, mailboxTable.fullPath)
+		.having(gt(count(), 1));
+	return groups.length;
+};
+
+const countParked = async (db: DuplicateMailDb): Promise<number> => {
+	const [row] = await db
+		.select({ parked: count() })
+		.from(messageTable)
+		.where(eq(messageTable.mailboxId, PARKED_MAILBOX_ID));
+	return row?.parked ?? 0;
+};
+
+const nextParkedBatch = async (db: DuplicateMailDb): Promise<string[]> => {
+	const rows = await db
+		.select({ messageId: messageTable.messageId })
+		.from(messageTable)
+		.where(eq(messageTable.mailboxId, PARKED_MAILBOX_ID))
+		.limit(BATCH_SIZE);
+	return rows.map((row) => row.messageId);
+};
+
+export const sweepDuplicateMailboxMail = async (
+	db: DuplicateMailDb,
+	mode: DuplicateMailRepairMode,
+): Promise<DuplicateMailReport> => {
+	const duplicatePaths = await countDuplicatePaths(db);
+	const parked = await countParked(db);
+	if (mode === "check" || parked === 0) {
+		return { mode, duplicatePaths, parked, removed: 0 };
+	}
+
+	let removed = 0;
+	for (;;) {
+		const messageIds = await nextParkedBatch(db);
+		if (messageIds.length === 0) break;
+		await runInTransaction(db, async (tx) => {
+			await deleteMessageSubtree(tx, messageIds);
+			await tx
+				.delete(threadMessageTable)
+				.where(inArray(threadMessageTable.messageId, messageIds));
+			await tx
+				.delete(messageLabelTable)
+				.where(inArray(messageLabelTable.messageId, messageIds));
+		});
+		removed += messageIds.length;
+	}
+	return { mode, duplicatePaths, parked, removed };
+};
+
+export const formatDuplicateMailReport = (
+	report: DuplicateMailReport,
+): string[] => {
+	const lines: string[] = [];
+	if (report.duplicatePaths > 0) {
+		lines.push(
+			`${report.duplicatePaths} folder path(s) held by more than one row, merged by the pending migration`,
+		);
+	}
+	if (report.parked === 0) {
+		lines.push("No message is parked by the folder dedupe");
+		return lines;
+	}
+	lines.push(
+		report.mode === "check"
+			? `${report.parked} message(s) parked by the folder dedupe, would be removed`
+			: `${report.removed} of ${report.parked} message(s) parked by the folder dedupe removed`,
+	);
+	return lines;
+};

package/src/repos/i4-account.test.ts

@@ -3,6 +3,7 @@ import { after, before, describe, test } from "node:test";
 import { createTestDb, randomId, type TestDb } from "../test-db.js";
 import { AccountRepo } from "./i4-account.js";
 import { MailboxRepo } from "./i4-mailbox.js";
+import { mailboxCreated } from "./test-helpers.js";
 
 function makeAccountInput(accountConfigId: string) {
 	return {
@@ -160,23 +161,25 @@ describe("AccountRepo", () => {
 		const account = await repo.create(makeAccountInput(accountConfigId));
 
 		const mailboxRepo = new MailboxRepo(db as never);
-		await mailboxRepo.create({
-			accountId: account.accountId,
-			namespaceType: "personal",
-			namespacePrefix: "",
-			hierarchyDelimiter: "/",
-			fullPath: "INBOX",
-			uidValidity: 1,
-			uidNext: 1,
-			highestModseq: "0",
-			messageCount: 0,
-			unseenCount: 0,
-			deletedCount: 0,
-			totalSize: 0,
-			lastSyncUid: 0,
-			highWaterMarkUid: 0,
-			lastMessageSyncAt: Date.now(),
-		});
+		mailboxCreated(
+			await mailboxRepo.create({
+				accountId: account.accountId,
+				namespaceType: "personal",
+				namespacePrefix: "",
+				hierarchyDelimiter: "/",
+				fullPath: "INBOX",
+				uidValidity: 1,
+				uidNext: 1,
+				highestModseq: "0",
+				messageCount: 0,
+				unseenCount: 0,
+				deletedCount: 0,
+				totalSize: 0,
+				lastSyncUid: 0,
+				highWaterMarkUid: 0,
+				lastMessageSyncAt: Date.now(),
+			}),
+		);
 
 		const desc = await repo.describe(account.accountId);
 		assert.equal(desc.account.length, 1);