@remit/drizzle-service 0.0.84 → 0.0.85

package/package.json

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

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