@remit/drizzle-service 0.0.84 → 0.0.86

package/package.json

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

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

@@ -0,0 +1,49 @@
+import assert from "node:assert/strict";
+import { describe, test } from "node:test";
+import { AccountService } from "@remit/domain-enums";
+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 = "0029_account_synced_services";
+
+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`);
+};
+
+describe("an account written before the service selection existed", () => {
+	test("comes out of the migration syncing mail only", async () => {
+		const sqlite = atPredecessor();
+		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 ('existing', 'config', 'person', 'person@example.com',
+					'password', 'imap.example.com', 993, 1, 0, 587, 1,
+					'not_authenticated', 0, 0)`,
+			)
+			.run();
+
+		applyMigration(sqlite, MIGRATION);
+
+		const repo = new AccountRepo(
+			drizzle(sqlite, { schema: { accounts: accountTable } }) as never,
+		);
+		assert.deepEqual((await repo.get("existing")).syncedServices, [
+			AccountService.Mail,
+		]);
+		sqlite.close();
+	});
+});

package/src/repos/account.conformance.sqlite.test.ts

@@ -0,0 +1,23 @@
+import { accountRepositoryConformance } from "@remit/data-ports/conformance";
+import { NotFoundError } from "../error.js";
+import { randomId } from "../id.js";
+import { accountTable } from "../schema.js";
+import { createSqliteTestDb } from "../test-db-sqlite.js";
+import { AccountRepo } from "./i4-account.js";
+
+let close: (() => Promise<void>) | undefined;
+
+accountRepositoryConformance({
+	async createRepository() {
+		const { db, close: closeDb } = await createSqliteTestDb({
+			accounts: accountTable,
+		});
+		close = closeDb;
+		return new AccountRepo(db as never);
+	},
+	teardown: async () => {
+		await close?.();
+	},
+	makeId: () => randomId(),
+	isNotFoundError: (error) => error instanceof NotFoundError,
+});

package/src/repos/cascade-delete.sqlite.test.ts

@@ -58,6 +58,7 @@ describe("createSqliteCascadeDeleter", () => {
 			username: "u",
 			email: "u@example.com",
 			authType: "password",
+			syncedServices: ["Mail"],
 			imapHost: "imap.example.com",
 			imapPort: 993,
 			imapTls: true,

package/src/repos/cascade-delete.test.ts

@@ -56,6 +56,7 @@ describe("runDrizzleCascadeDelete", () => {
 			username: "u",
 			email: "u@example.com",
 			authType: "password",
+			syncedServices: ["Mail"],
 			imapHost: "imap.example.com",
 			imapPort: 993,
 			imapTls: true,

package/src/repos/i4-account.ts

@@ -7,7 +7,7 @@ import type {
 	ResultList,
 	UpdateAccountInput,
 } from "@remit/data-ports";
-import { SyncPhase } from "@remit/domain-enums";
+import { AccountService, SyncPhase } from "@remit/domain-enums";
 import { and, asc, eq, gt, inArray, or, sql } from "drizzle-orm";
 import type { Db } from "../db.js";
 import { NotFoundError } from "../error.js";
@@ -39,6 +39,7 @@ export function rowToAccount(
 		username: row.username,
 		email: row.email,
 		authType: row.authType as AccountItem["authType"],
+		syncedServices: row.syncedServices as AccountItem["syncedServices"],
 		passwordHash: row.passwordHash ?? undefined,
 		oauthRefreshTokenHash: row.oauthRefreshTokenHash ?? undefined,
 		oauthTokenUpdatedAt: row.oauthTokenUpdatedAt ?? undefined,
@@ -81,6 +82,7 @@ export class AccountRepo implements IAccountRepository {
 				username: input.username,
 				email: input.email,
 				authType: input.authType ?? "password",
+				syncedServices: input.syncedServices ?? [AccountService.Mail],
 				passwordHash: input.passwordHash,
 				oauthRefreshTokenHash: input.oauthRefreshTokenHash,
 				oauthTokenUpdatedAt: input.oauthTokenUpdatedAt,
@@ -144,6 +146,8 @@ export class AccountRepo implements IAccountRepository {
 		if (input.username !== undefined) updates.username = input.username;
 		if (input.email !== undefined) updates.email = input.email;
 		if (input.authType !== undefined) updates.authType = input.authType;
+		if (input.syncedServices !== undefined)
+			updates.syncedServices = input.syncedServices;
 		if (input.passwordHash !== undefined)
 			updates.passwordHash = input.passwordHash;
 		if (input.oauthRefreshTokenHash !== undefined)

package/src/repos/i4-address-junk-move.sqlite.test.ts

@@ -20,9 +20,9 @@ describe("reconciling one message's addresses at the moment it moves", () => {
 				`INSERT OR IGNORE INTO account (
 					account_id, account_config_id, username, email, imap_host,
 					imap_port, imap_tls, imap_start_tls, smtp_port, is_active,
-					connection_state, created_at, updated_at
+					connection_state, synced_services, created_at, updated_at
 				) VALUES (?, ?, 'user', 'user@example.com', 'imap.example.com',
-					993, 1, 0, 465, 1, 'disconnected', 0, 0)`,
+					993, 1, 0, 465, 1, 'disconnected', '["Mail"]', 0, 0)`,
 			)
 			.run(accountId, CONFIG);
 	};

package/src/repos/i4-address-merge-flags.sqlite.test.ts

@@ -75,6 +75,137 @@ describe("concurrent flag merges on one address", () => {
 		await repo.deleteAddress(addr.accountConfigId, addr.addressId);
 	});
 
+	test("marking a blocked sender never-spam drops the block", async () => {
+		const addr = await address();
+		await repo.mergeFlags(addr.accountConfigId, addr.addressId, {
+			blocked: { value: true, setAt: 1 },
+			muted: { value: true, setAt: 1 },
+		});
+
+		await repo.mergeFlags(addr.accountConfigId, addr.addressId, {
+			neverSpam: { value: true, setAt: 2 },
+		});
+
+		const merged = await repo.getAddress(addr.accountConfigId, addr.addressId);
+		assert.equal(merged.flags?.neverSpam?.value, true);
+		assert.equal(merged.flags?.blocked, undefined);
+		assert.equal(
+			merged.flags?.muted?.value,
+			true,
+			"a flag on another axis is untouched",
+		);
+
+		await repo.deleteAddress(addr.accountConfigId, addr.addressId);
+	});
+
+	test("blocking a never-spam sender drops the grant", async () => {
+		const addr = await address();
+		await repo.mergeFlags(addr.accountConfigId, addr.addressId, {
+			neverSpam: { value: true, setAt: 1 },
+		});
+
+		await repo.mergeFlags(addr.accountConfigId, addr.addressId, {
+			blocked: { value: true, setAt: 2 },
+		});
+
+		const merged = await repo.getAddress(addr.accountConfigId, addr.addressId);
+		assert.equal(merged.flags?.blocked?.value, true);
+		assert.equal(merged.flags?.neverSpam, undefined);
+
+		await repo.deleteAddress(addr.accountConfigId, addr.addressId);
+	});
+
+	test("a never-spam grant turned off leaves a later block alone", async () => {
+		const addr = await address();
+		await repo.mergeFlags(addr.accountConfigId, addr.addressId, {
+			neverSpam: { value: false, setAt: 1 },
+		});
+
+		await repo.mergeFlags(addr.accountConfigId, addr.addressId, {
+			blocked: { value: true, setAt: 2 },
+		});
+
+		const merged = await repo.getAddress(addr.accountConfigId, addr.addressId);
+		assert.equal(merged.flags?.blocked?.value, true);
+		assert.equal(
+			merged.flags?.neverSpam?.value,
+			false,
+			"an explicit false is not a contradiction and keeps its audit trail",
+		);
+
+		await repo.deleteAddress(addr.accountConfigId, addr.addressId);
+	});
+
+	// A row written before the invariant existed still carries both. Healing it
+	// while patching an unrelated key would revoke a placement instruction the
+	// user never touched, so the write leaves it and the read arbitrates.
+	test("a patch about another flag leaves a legacy both-set row alone", async () => {
+		const accountConfigId = randomId();
+		const addr = await repo.createAddress({
+			addressId: randomId(),
+			accountConfigId,
+			localPart: "legacy",
+			domain: "example.com",
+			normalizedEmail: "legacy@example.com",
+			normalizedCompound: "legacy@example.com:legacy",
+			flags: {
+				blocked: { value: true, setAt: 1 },
+				neverSpam: { value: true, setAt: 2 },
+			},
+		});
+
+		await repo.mergeFlags(addr.accountConfigId, addr.addressId, {
+			muted: { value: true, setAt: 3 },
+		});
+
+		const merged = await repo.getAddress(addr.accountConfigId, addr.addressId);
+		assert.equal(merged.flags?.blocked?.value, true);
+		assert.equal(merged.flags?.neverSpam?.value, true);
+		assert.equal(merged.flags?.muted?.value, true);
+
+		await repo.deleteAddress(addr.accountConfigId, addr.addressId);
+	});
+
+	test("writing either placement flag heals a legacy both-set row", async () => {
+		const accountConfigId = randomId();
+		const addr = await repo.createAddress({
+			addressId: randomId(),
+			accountConfigId,
+			localPart: "legacy",
+			domain: "example.com",
+			normalizedEmail: "legacy2@example.com",
+			normalizedCompound: "legacy2@example.com:legacy",
+			flags: {
+				blocked: { value: true, setAt: 1 },
+				neverSpam: { value: true, setAt: 2 },
+			},
+		});
+
+		await repo.mergeFlags(addr.accountConfigId, addr.addressId, {
+			neverSpam: { value: true, setAt: 3 },
+		});
+
+		const merged = await repo.getAddress(addr.accountConfigId, addr.addressId);
+		assert.equal(merged.flags?.neverSpam?.value, true);
+		assert.equal(merged.flags?.blocked, undefined);
+
+		await repo.deleteAddress(addr.accountConfigId, addr.addressId);
+	});
+
+	test("one patch naming both contradictory flags settles on the block", async () => {
+		const addr = await address();
+		await repo.mergeFlags(addr.accountConfigId, addr.addressId, {
+			blocked: { value: true, setAt: 1 },
+			neverSpam: { value: true, setAt: 1 },
+		});
+
+		const merged = await repo.getAddress(addr.accountConfigId, addr.addressId);
+		assert.equal(merged.flags?.blocked?.value, true);
+		assert.equal(merged.flags?.neverSpam, undefined);
+
+		await repo.deleteAddress(addr.accountConfigId, addr.addressId);
+	});
+
 	test("a concurrent merge does not resurrect a deleted flag", async () => {
 		const addr = await address();
 		await repo.mergeFlags(addr.accountConfigId, addr.addressId, {

package/src/repos/i4-address.ts

@@ -70,6 +70,41 @@ type MergeAttempt =
 	| { outcome: "missing" }
 	| { outcome: "contended" };
 
+/**
+ * `blocked` and `neverSpam` are two directly contradictory statements about
+ * where a sender's mail belongs (issue #605), so a row asserting both is not a
+ * tie to break — it is a row that should not exist. This is the only place that
+ * sees both keys at once: `buildFlagsPatch` stays a pure per-key translation,
+ * and the merge fold is the read-modify-write of the whole map.
+ *
+ * The flag the patch just raised wins, so the instruction the user gave last is
+ * the one that stands. A patch raising both resolves to `blocked` — the same
+ * direction the `blocked`/`vip` same-second tie already breaks in.
+ *
+ * Only a patch that raises one of the two is allowed to drop the other. A row
+ * that somehow already carries both survives a patch about anything else
+ * untouched: dropping a placement instruction as a side effect of writing
+ * `muted` would be a silent revocation the user never asked for. Such a row is
+ * resolved on read — `resolveSenderPlacement` reads it as `Blocked` — and
+ * healed the next time either key is written.
+ */
+const dropContradictedPlacementFlag = (
+	next: AddressFlags,
+	patch: FlagsMergePatch,
+): AddressFlags => {
+	if (next.blocked?.value !== true || next.neverSpam?.value !== true)
+		return next;
+	if (patch.blocked?.value === true) {
+		const { neverSpam: _neverSpam, ...rest } = next;
+		return rest;
+	}
+	if (patch.neverSpam?.value === true) {
+		const { blocked: _blocked, ...rest } = next;
+		return rest;
+	}
+	return next;
+};
+
 /**
  * The stored `"<display name> <email>"` compound, folded in JavaScript exactly
  * as message sync folds it — SQL `lower()` stops at ASCII, and the search reads
@@ -496,7 +531,7 @@ export class AddressRepo implements IAddressRepository {
 				}
 				(next[key] as AddressFlags[keyof AddressFlags]) = value;
 			}
-			return next;
+			return dropContradictedPlacementFlag(next, patch);
 		});
 	}
 

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

@@ -82,6 +82,7 @@ describe("MailboxSpecialUseRepo role lookups (sqlite)", () => {
 			imapStartTls: false,
 			isActive: true,
 			connectionState: "authenticated",
+			syncedServices: ["Mail"],
 			createdAt: now,
 			updatedAt: now,
 		} as never);