@remit/drizzle-service 0.0.82 → 0.0.84

package/package.json

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

package/src/mailbox-sync-status-backfill.sqlite.test.ts

@@ -0,0 +1,118 @@
+import assert from "node:assert/strict";
+import { describe, test } from "node:test";
+import Database from "better-sqlite3";
+import {
+	applyMigration,
+	migrationJournal,
+} from "./test-shipped-sqlite-schema.js";
+
+/**
+ * `sync_status` becomes NOT NULL, and on a real install almost every row is
+ * NULL: the sweep's insert is the only create path that omitted it, and the
+ * sweep is what discovers a folder in the first place.
+ *
+ * drizzle-kit does not emit data migrations, and SQLite cannot alter
+ * nullability, so the schema change is a copy-and-swap whose `INSERT … SELECT`
+ * would violate the new constraint on every one of those rows. Because drizzle
+ * runs a folder's whole pending set inside one `BEGIN`/`COMMIT`, that failure
+ * rolls the entities set back and the migrate one-shot that gates all six
+ * services never completes.
+ *
+ * So the pair is proven here in the order the migrator runs it, against the
+ * data it will actually meet.
+ */
+const BACKFILL = "0026_mailbox_sync_status_backfill";
+const SCHEMA_CHANGE = "0027_mailbox_sync_status_total";
+
+const atPredecessor = (): Database.Database => {
+	const sqlite = new Database(":memory:");
+	for (const entry of migrationJournal()) {
+		if (entry.tag === BACKFILL) return sqlite;
+		applyMigration(sqlite, entry.tag);
+	}
+	throw new Error(`${BACKFILL} is not in the journal`);
+};
+
+const seed = (
+	sqlite: Database.Database,
+	rows: Array<{ mailboxId: string; syncStatus: string | null }>,
+): void => {
+	const insert = sqlite.prepare(
+		`INSERT INTO mailbox (
+			mailbox_id, account_id, namespace_type, namespace_prefix,
+			hierarchy_delimiter, full_path, uid_validity, uid_next, highest_modseq,
+			message_count, unseen_count, deleted_count, total_size, last_sync_uid,
+			high_water_mark_uid, last_message_sync_at, parent_mailbox_id,
+			sync_status, cursor_state, created_at, updated_at
+		) VALUES (?, 'acct', 'personal', '', '/', ?, 1, 1, '0', 0, 0, 0, 0, 0, 0, 0,
+			'None', ?, 'normal', 0, 0)`,
+	);
+	for (const row of rows) {
+		insert.run(row.mailboxId, `Folder/${row.mailboxId}`, row.syncStatus);
+	}
+};
+
+describe("mailbox sync_status becomes total", () => {
+	test("the backfill runs first, so the rebuild sees no NULLs", () => {
+		const sqlite = atPredecessor();
+		seed(sqlite, [
+			{ mailboxId: "swept-1", syncStatus: null },
+			{ mailboxId: "swept-2", syncStatus: null },
+			{ mailboxId: "created", syncStatus: "pending" },
+			{ mailboxId: "failed", syncStatus: "failed" },
+		]);
+
+		applyMigration(sqlite, BACKFILL);
+		applyMigration(sqlite, SCHEMA_CHANGE);
+
+		const rows = sqlite
+			.prepare(
+				"SELECT mailbox_id, sync_status FROM mailbox ORDER BY mailbox_id",
+			)
+			.all() as Array<{ mailbox_id: string; sync_status: string }>;
+
+		assert.deepEqual(rows, [
+			{ mailbox_id: "created", sync_status: "pending" },
+			{ mailbox_id: "failed", sync_status: "failed" },
+			{ mailbox_id: "swept-1", sync_status: "synced" },
+			{ mailbox_id: "swept-2", sync_status: "synced" },
+		]);
+		sqlite.close();
+	});
+
+	test("the rebuild is refused without the backfill ahead of it", () => {
+		// The failure this ordering exists to prevent, made visible: without the
+		// backfill the copy-and-swap cannot insert a NULL into the new column.
+		const sqlite = atPredecessor();
+		seed(sqlite, [{ mailboxId: "swept-1", syncStatus: null }]);
+
+		assert.throws(
+			() => applyMigration(sqlite, SCHEMA_CHANGE),
+			/NOT NULL constraint failed/,
+		);
+		sqlite.close();
+	});
+
+	test("the rebuild keeps the account index and the new column", () => {
+		const sqlite = atPredecessor();
+		applyMigration(sqlite, BACKFILL);
+		applyMigration(sqlite, SCHEMA_CHANGE);
+		applyMigration(sqlite, "0028_mailbox_pending_path");
+
+		const columns = (
+			sqlite.prepare("PRAGMA table_info(mailbox)").all() as Array<{
+				name: string;
+			}>
+		).map((column) => column.name);
+		assert.equal(columns.includes("pending_path"), true);
+		assert.equal(columns.includes("old_path"), false);
+
+		const indexes = (
+			sqlite.prepare("PRAGMA index_list(mailbox)").all() as Array<{
+				name: string;
+			}>
+		).map((index) => index.name);
+		assert.equal(indexes.includes("mailbox_by_account_id"), true);
+		sqlite.close();
+	});
+});

package/src/repair/junk-only-address.sqlite.test.ts

@@ -7,7 +7,10 @@ import Database from "better-sqlite3";
 import { drizzle } from "drizzle-orm/better-sqlite3";
 import { AccountSettingRepo } from "../repos/i4-account-setting.js";
 import { MailboxSpecialUseRepo } from "../repos/i4-mailbox-special-use.js";
-import { shippedTableDdl } from "../test-shipped-sqlite-schema.js";
+import {
+	applyMigration,
+	shippedTableDdl,
+} from "../test-shipped-sqlite-schema.js";
 import {
 	type JunkOnlyRepairClient,
 	type JunkOnlyRepairMode,
@@ -197,6 +200,9 @@ describe("addresses standing only on mail in Junk", () => {
 		]) {
 			sqlite.exec(shippedTableDdl(DDL_TAG, table));
 		}
+		// `mailbox` is read through the repo, which selects every column the
+		// entity declares — including the rename target added after this DDL.
+		applyMigration(sqlite, "0028_mailbox_pending_path");
 		sqlite.exec(
 			readFileSync(
 				new URL(

package/src/repos/i4-mailbox.sqlite.test.ts

@@ -68,31 +68,39 @@ describe("MailboxRepo (sqlite)", () => {
 		assert.equal(reread.highestModseq, "9007199254740993");
 	});
 
-	test("renameChildPaths marks each child pending along with its new path (#290)", async () => {
-		// A renamed parent is set pending by the caller; its children's new paths
-		// are equally absent from the server until MAILBOX_RENAME lands, so they
-		// must be pending too — otherwise a reconcile in that window reaps the
-		// child as server-deleted.
+	test("a row written without a state reads back synced (D1)", async () => {
 		const accountId = randomUUID();
-		const parent = await repo.create({
-			...makeMailboxInput(accountId, "Work"),
-			syncStatus: MailboxSyncStatus.pending,
-		});
-		const child = await repo.create({
-			...makeMailboxInput(accountId, "Work/sub"),
-			syncStatus: MailboxSyncStatus.synced,
-		});
+		const created = await repo.create(
+			makeMailboxInput(accountId, "Discovered"),
+		);
+		assert.equal(created.syncStatus, MailboxSyncStatus.synced);
+		const fetched = await repo.get(accountId, created.mailboxId);
+		assert.equal(fetched.syncStatus, MailboxSyncStatus.synced);
+	});
 
-		await repo.renameChildPaths(accountId, "Work", "Projects", "/");
+	test("pendingPath round-trips and clears", async () => {
+		const accountId = randomUUID();
+		const created = await repo.create(makeMailboxInput(accountId, "Archive"));
+		assert.equal(created.pendingPath, undefined);
 
-		const renamedChild = await repo.get(accountId, child.mailboxId);
-		assert.equal(renamedChild.fullPath, "Projects/sub");
-		assert.equal(renamedChild.syncStatus, MailboxSyncStatus.pending);
+		const claimed = await repo.transition(accountId, created.mailboxId, {
+			from: [MailboxSyncStatus.synced],
+			to: MailboxSyncStatus.pending,
+			set: { pendingPath: "Records" },
+		});
+		assert.equal(claimed?.pendingPath, "Records");
+		assert.equal(
+			(await repo.get(accountId, created.mailboxId)).pendingPath,
+			"Records",
+		);
 
-		// The parent row is untouched by this call (its own path/status is the
-		// caller's job).
-		const parentRow = await repo.get(accountId, parent.mailboxId);
-		assert.equal(parentRow.fullPath, "Work");
+		const settled = await repo.transition(accountId, created.mailboxId, {
+			from: [MailboxSyncStatus.pending],
+			to: MailboxSyncStatus.synced,
+			set: { fullPath: "Records", pendingPath: null },
+		});
+		assert.equal(settled?.pendingPath, undefined);
+		assert.equal(settled?.fullPath, "Records");
 	});
 });
 
@@ -115,6 +123,9 @@ describe("MailboxRepo (sqlite, shipped migrations)", () => {
 		const sqlite = new Database(":memory:");
 		sqlite.exec(shippedTableDdl("0000_happy_roland_deschain", "mailbox"));
 		applyMigration(sqlite, "0002_highest_modseq_text");
+		applyMigration(sqlite, "0026_mailbox_sync_status_backfill");
+		applyMigration(sqlite, "0027_mailbox_sync_status_total");
+		applyMigration(sqlite, "0028_mailbox_pending_path");
 		const db = drizzle(sqlite, { schema: { mailbox: mailboxTable } });
 		repo = new MailboxRepo(db as never);
 		close = async () => {
@@ -157,6 +168,31 @@ describe("MailboxRepo (sqlite, shipped migrations)", () => {
 		assert.strictEqual(fetched.highestModseq, "900:149");
 	});
 
+	test("a row inserted without a state reads back synced", async () => {
+		const accountId = randomUUID();
+		const created = await repo.create(makeMailboxInput(accountId, "Notes"));
+		assert.equal(created.syncStatus, MailboxSyncStatus.synced);
+	});
+
+	test("pendingPath round-trips and clears on the shipped shape", async () => {
+		const accountId = randomUUID();
+		const created = await repo.create(makeMailboxInput(accountId, "Receipts"));
+
+		const claimed = await repo.transition(accountId, created.mailboxId, {
+			from: [MailboxSyncStatus.synced],
+			to: MailboxSyncStatus.pending,
+			set: { pendingPath: "Invoices" },
+		});
+		assert.equal(claimed?.pendingPath, "Invoices");
+
+		const cleared = await repo.transition(accountId, created.mailboxId, {
+			from: [MailboxSyncStatus.pending],
+			to: MailboxSyncStatus.synced,
+			set: { pendingPath: null },
+		});
+		assert.equal(cleared?.pendingPath, undefined);
+	});
+
 	test("round-trips a cursor above 2^53 with its exact digits", async () => {
 		const accountId = randomUUID();
 		const modseq = "18446744073709551615";